VPLAY-11143: AAMP mp4Demux Integration

Reason for change: Integrate mp4Demux formally into AAMP
Test Procedure: Test with useMp4Demux=true and validate
all types of Linear, VOD content in all apps.
Risks: Low

Signed-off-by: Vinish100 <[email protected]>

Author: Vinish100

AampDemuxDataTypes.h

@@ -0,0 +1,110 @@
+/*
+ * If not stated otherwise in this file or this component's license file the
+ * following copyright and licenses apply:
+ *
+ * Copyright 2025 RDK Management
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef __AAMP_DEMUX_DATA_TYPES_H__
+#define __AAMP_DEMUX_DATA_TYPES_H__
+
+#include <string>
+#include <vector>
+#include "AampGrowableBuffer.h" // for AampGrowableBuffer
+#include "AampTime.h" // for AampTime
+#include "StreamOutputFormat.h" // for StreamOutputFormat
+#include "AampMediaType.h" // for AampMediaType
+
+struct AampPsshData
+{
+	std::string systemID; // 16 bytes UUID
+	std::vector<uint8_t> pssh; // variable length
+};
+
+struct AampCodecInfo
+{
+	StreamOutputFormat mCodecFormat; // FORMAT_VIDEO_ES_H264, etc
+	std::vector<uint8_t> mCodecData; // codec private data, e.g. avcC box
+	AampMediaType mType;
+	bool mIsEncrypted;
+	union
+	{
+		struct
+		{
+			uint16_t mChannelCount;
+			uint16_t mSampleSize;
+			uint16_t mSampleRate;
+			uint8_t mObjectTypeId;
+			uint8_t mStreamType;
+			uint8_t mUpStream;
+			uint16_t mBufferSize;
+			uint32_t mMaxBitrate;
+			uint32_t mAvgBitrate;
+		} audio;
+		
+		struct
+		{
+			uint16_t mWidth;
+			uint16_t mHeight;
+			uint16_t mFrameCount;
+			uint16_t mDepth;
+			uint32_t mHorizontalResolution;
+			uint32_t mVerticalResolution;
+		} video;
+	} mInfo;
+
+	AampCodecInfo() : mCodecFormat(FORMAT_INVALID), mIsEncrypted(false), mCodecData()
+	{
+		std::memset(&mInfo, 0, sizeof(mInfo));
+	}
+
+	AampCodecInfo(StreamOutputFormat format) : mCodecFormat(format), mIsEncrypted(false), mCodecData()
+	{
+		std::memset(&mInfo, 0, sizeof(mInfo));
+	}
+};
+
+struct AampDrmMetadata
+{
+	bool mIsEncrypted;
+	std::string mKeyId; // 16 bytes UUID
+	std::vector<uint8_t> mIV; // 8 or 16 bytes
+	std::string mCipher; // e.g. 'cenc', 'cbcs'
+	std::string mOriginalMediaType; // 'vide' or 'soun'
+	std::vector<uint8_t> mSubSamples; // optional subsample encryption data
+	uint8_t mCryptByteBlock;
+	uint8_t mSkipByteBlock;
+
+	AampDrmMetadata() : mIsEncrypted(false), mKeyId(), mIV(), mCipher(), mOriginalMediaType(),
+		mSubSamples(), mCryptByteBlock(0), mSkipByteBlock(0)
+	{
+	}
+};
+
+struct AampMediaSample
+{
+	AampGrowableBuffer mData;
+	AampTime mPts;
+	AampTime mDts;
+	AampTime mDuration;
+
+    AampDrmMetadata mDrmMetadata; // empty if not encrypted
+
+	AampMediaSample() : mData("AampMediaSample"), mPts(0), mDts(0), mDuration(0), mDrmMetadata()
+	{
+	}
+};
+
+#endif /* __AAMP_DEMUX_DATA_TYPES_H__ */

AampStreamSinkInactive.h

@@ -70,6 +70,15 @@ class AampStreamSinkInactive : public StreamSink
 		return false;
 	}
 	/**
+	 *   @fn SendSample
+	 *   @brief stub implementation for Inactive aamp instance
+	 */
+	virtual bool SendSample( AampMediaType mediaType, AampMediaSample& sample)
+	{
+		AAMPLOG_WARN("Called AAMPGstPlayer()::%s stub", __FUNCTION__);
+		return false;
+	}
+	/**
      *   @fn EndOfStreamReached
 	 *   @brief stub implementation for Inactive aamp instance
 	 */

CMakeLists.txt

@@ -148,7 +148,7 @@ include_directories(${CMAKE_CURRENT_SOURCE_DIR}/jsbindings)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/jsbindings/PersistentWatermark)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/subtec/subtecparser)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/subtitle)
-include_directories(${CMAKE_CURRENT_SOURCE_DIR}/test/gstTestHarness)
+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/mp4demux)
 include_directories(${CMAKE_CURRENT_SOURCE_DIR}/tsb/api)
 
 # Locally built/installed dependencies are here
@@ -351,10 +351,12 @@ set(LIBAAMP_SOURCES
 	subtec/subtecparser/WebvttSubtecDevParser.cpp
 	AampTrackWorker.cpp AampTrackWorker.h
 	LangCodePreference.h
-	test/gstTestHarness/mp4demux.hpp
 	AampTrackWorkerManager.cpp
 	AampFragmentDescriptor.cpp
 	AampTimeBasedBufferManager.cpp
+	mp4demux/AampMp4Demuxer.cpp mp4demux/AampMp4Demuxer.h
+	mp4demux/Mp4Demux.hpp
+	AampDemuxDataTypes.h
 )
 
 if(CMAKE_SOC_PLATFORM_RPI)
@@ -514,6 +516,7 @@ install(FILES
 	MediaSegmentDownloadJob.hpp
 	tsb/api/TsbApi.h
 	LangCodePreference.h StreamOutputFormat.h VideoZoomMode.h StreamSink.h TimedMetadata.h
+	AampDemuxDataTypes.h AampTime.h
 	DESTINATION include
 )
 

StreamAbstractionAAMP.h

@@ -46,6 +46,7 @@
 #include "AampTime.h"
 #include "AampTimeBasedBufferManager.hpp"
 #include "CachedFragment.h"
+#include "AampDemuxDataTypes.h"
 
 /**
  * @brief Media Track Types
@@ -1992,6 +1993,8 @@ class StreamAbstractionAAMP : public AampLicenseFetcher
 	 */	
 	void ReinitializeInjection(double rate);
 
+	virtual void GetStreamCodecInfo (AampCodecInfo &videoCodec, AampCodecInfo &audioCodec, AampCodecInfo &textCodec) { (void)videoCodec; (void)audioCodec; (void)textCodec; }
+
 protected:
 	/**
 	 *   @brief Get stream information of a profile from subclass.

StreamSink.h

@@ -22,6 +22,7 @@
 
 #include "StreamOutputFormat.h"
 #include "AampMediaType.h"
+#include "AampDemuxDataTypes.h"
 
 /**
  * @struct PlaybackQualityData
@@ -81,6 +82,8 @@ class StreamSink
      */
     virtual bool SendTransfer( AampMediaType mediaType, void *ptr, size_t len, double fpts, double fdts, double fDuration, double fragmentPTSoffset, bool initFragment = false, bool discontinuity = false)= 0;
 
+    virtual bool SendSample( AampMediaType mediaType, AampMediaSample& sample ) = 0;
+
     /**
      *   @brief  Checks pipeline is configured for media type
      *
@@ -390,6 +393,8 @@ class StreamSink
      */
     virtual void NotifyInjectorToPause() {};
 
+    virtual void SetStreamCaps(AampMediaType type, const AampCodecInfo &codecInfo) {};
+
 };
 
 #endif // STREAM_SINK_H

aampgstplayer.cpp

@@ -102,7 +102,6 @@ static void InitializePlayerConfigs(AAMPGstPlayer *_this, void *playerInstance)
 	interfacePlayer->m_gstConfigParam->audioOnlyMode = _this->aamp->mAudioOnlyPb;
 	interfacePlayer->m_gstConfigParam->gstreamerSubsEnabled = _this->aamp->IsGstreamerSubsEnabled();
 	interfacePlayer->m_gstConfigParam->media = _this->aamp->GetMediaFormatTypeEnum();
-	interfacePlayer->m_gstConfigParam->useMp4Demux = config->IsConfigSet(eAAMPConfig_UseMp4Demux);
 }
 
 /*
@@ -679,7 +678,7 @@ void AAMPGstPlayer::NotifyInjectorToResume()
 /**
  *  @brief Inject stream buffer to gstreamer pipeline
  */
-bool AAMPGstPlayer::SendHelper(AampMediaType mediaType, const void *ptr, size_t len, double fpts, double fdts, double fDuration, bool copy, double fragmentPTSoffset, bool initFragment, bool discontinuity)
+bool AAMPGstPlayer::SendHelper(AampMediaType mediaType, MediaSample sample, bool copy, bool initFragment, bool discontinuity)
 {
 	if(ISCONFIGSET(eAAMPConfig_SuppressDecode))
 	{
@@ -707,10 +706,10 @@ bool AAMPGstPlayer::SendHelper(AampMediaType mediaType, const void *ptr, size_t
 		namespace aih = aamp::id3_metadata::helpers;
 
 		if (aih::IsValidMediaType(mediaType) &&
-			aih::IsValidHeader(static_cast<const uint8_t*>(ptr), len))
+			aih::IsValidHeader(static_cast<const uint8_t*>(sample.data), sample.dataSize))
 		{
-			m_ID3MetadataHandler(mediaType, static_cast<const uint8_t*>(ptr), len,
-								 {fpts, fdts, fDuration}, nullptr);
+			m_ID3MetadataHandler(mediaType, static_cast<const uint8_t*>(sample.data), sample.dataSize,
+								 {sample.pts, sample.dts, sample.duration}, nullptr);
 		}
 	}
 
@@ -723,7 +722,7 @@ bool AAMPGstPlayer::SendHelper(AampMediaType mediaType, const void *ptr, size_t
 	{
 		sendNewSegmentEvent = true;
 	}
-	bool bPushBuffer = playerInstance->SendHelper(mediaType, ptr, len, fpts, fdts, fDuration, fragmentPTSoffset, copy, initFragment, discontinuity, notifyFirstBufferProcessed, sendNewSegmentEvent, resetTrickUTC, firstBufferPushed);
+	bool bPushBuffer = playerInstance->SendHelper(mediaType, std::move(sample), copy, initFragment, discontinuity, notifyFirstBufferProcessed, sendNewSegmentEvent, resetTrickUTC, firstBufferPushed);
 	if(sendNewSegmentEvent)
 	{
 		aamp->mbNewSegmentEvtSent[mediaType] = true;
@@ -734,7 +733,8 @@ bool AAMPGstPlayer::SendHelper(AampMediaType mediaType, const void *ptr, size_t
 	}
 	if(bPushBuffer)
 	{
-		privateContext->mBufferControl[mediaType].notifyFragmentInject(this, mediaType, fpts, fdts, fDuration, discontinuity);
+		// TODO: Accessing values from a moved object
+		privateContext->mBufferControl[mediaType].notifyFragmentInject(this, mediaType, sample.pts, sample.dts, sample.duration, discontinuity);
 	}
 	if (eMEDIATYPE_VIDEO == mediaType)
 	{
@@ -763,15 +763,29 @@ bool AAMPGstPlayer::SendHelper(AampMediaType mediaType, const void *ptr, size_t
  */
 bool AAMPGstPlayer::SendCopy(AampMediaType mediaType, const void *ptr, size_t len, double fpts, double fdts, double fDuration)
 {
-	return SendHelper( mediaType, ptr, len, fpts, fdts, fDuration, true /*copy*/, 0.0 );
+	MediaSample sample;
+	sample.data = ptr;
+	sample.dataSize = len;
+	sample.pts = fpts;
+	sample.dts = fdts;
+	sample.duration = fDuration;
+	sample.ptsOffset = 0.0;
+	return SendHelper( mediaType, std::move(sample), true /*copy*/ );
 }
 
 /**
  *  @brief inject mp4 segment to gstreamer pipeline
  */
 bool AAMPGstPlayer::SendTransfer(AampMediaType mediaType, void *ptr, size_t len, double fpts, double fdts, double fDuration, double fragmentPTSoffset, bool initFragment, bool discontinuity)
 {
-	return SendHelper( mediaType, ptr, len, fpts, fdts, fDuration, false /*transfer*/, fragmentPTSoffset,  initFragment, discontinuity );
+	MediaSample sample;
+	sample.data = ptr;
+	sample.dataSize = len;
+	sample.pts = fpts;
+	sample.dts = fdts;
+	sample.duration = fDuration;
+	sample.ptsOffset = fragmentPTSoffset;
+	return SendHelper( mediaType, std::move(sample), false /*transfer*/, initFragment, discontinuity );
 }
 
 /**
@@ -1312,3 +1326,63 @@ void AAMPGstPlayer::StopMonitorAvTimer()
 		AAMPLOG_MIL("MonitorAvTimer stopped");
 	}
 }
+
+void AAMPGstPlayer::SetStreamCaps(AampMediaType type, const AampCodecInfo &codecInfo)
+{
+	CodecInfo gstCodecInfo;
+	gstCodecInfo.codecFormat = (GstStreamOutputFormat)codecInfo.mCodecFormat;
+	gstCodecInfo.codecData = std::move(codecInfo.mCodecData);
+	gstCodecInfo.isEncrypted = codecInfo.mIsEncrypted;
+	if (codecInfo.mType == eMEDIATYPE_VIDEO)
+	{
+		gstCodecInfo.info.video.width = codecInfo.mInfo.video.mWidth;
+		gstCodecInfo.info.video.height = codecInfo.mInfo.video.mHeight;
+	}
+	else if (codecInfo.mType == eMEDIATYPE_AUDIO)
+	{
+		gstCodecInfo.info.audio.channelCount = codecInfo.mInfo.audio.mChannelCount;
+		gstCodecInfo.info.audio.sampleRate = codecInfo.mInfo.audio.mSampleRate;
+	}
+	playerInstance->SetStreamCaps((GstMediaType)type, gstCodecInfo);
+}
+
+bool AAMPGstPlayer::SendSample(AampMediaType mediaType, AampMediaSample& sample)
+{
+	bool ret = false;
+	MediaSample gstSample;
+
+	// Convert AampMediaSample to MediaSample
+	gstSample.data = sample.mData.GetPtr();
+	gstSample.dataSize = sample.mData.GetLen();
+	gstSample.pts = static_cast<double>(sample.mPts);
+	gstSample.dts = static_cast<double>(sample.mDts);
+	gstSample.duration = static_cast<double>(sample.mDuration);
+	// Sample is encrypted, set the DRM metadata
+	if (sample.mDrmMetadata.mIsEncrypted)
+	{
+		gstSample.drmMetadata.isEncrypted = true;
+		gstSample.drmMetadata.subSamples = std::move(sample.mDrmMetadata.mSubSamples);
+		gstSample.drmMetadata.keyId = std::move(sample.mDrmMetadata.mKeyId);
+		gstSample.drmMetadata.iv = std::move(sample.mDrmMetadata.mIV);
+		gstSample.drmMetadata.cipher = std::move(sample.mDrmMetadata.mCipher);
+		gstSample.drmMetadata.cryptByteBlock = sample.mDrmMetadata.mCryptByteBlock;
+		gstSample.drmMetadata.skipByteBlock = sample.mDrmMetadata.mSkipByteBlock;
+		gstSample.drmMetadata.originalMediaType = std::move(sample.mDrmMetadata.mOriginalMediaType);
+	}
+	else
+	{
+		gstSample.drmMetadata.isEncrypted = false;
+	}
+
+	ret = SendHelper( mediaType, std::move(gstSample), false /*transfer*/);
+
+	if (ret)
+	{
+		sample.mData.Transfer();
+	}
+	else
+	{
+		sample.mData.Free();
+	}
+	return ret;
+}

aampgstplayer.h

@@ -91,18 +91,18 @@ class AAMPGstPlayer : public StreamSink
 {
 private:
 	/**
-		 * @fn SendHelper
-		 * @param[in] mediaType stream type
-		 * @param[in] ptr buffer pointer
-		 * @param[in] len length of buffer
-		 * @param[in] fpts PTS of buffer (in sec)
-		 * @param[in] fdts DTS of buffer (in sec)
-		 * @param[in] duration duration of buffer (in sec)
-		 * @param[in] fragmentPTSoffset PTS offset
-		 * @param[in] copy to map or transfer the buffer
-		 * @param[in] initFragment flag for buffer type (init, data)
-		 */
-	bool SendHelper(AampMediaType mediaType, const void *ptr, size_t len, double fpts, double fdts, double duration, bool copy, double fragmentPTSoffset, bool initFragment = false, bool discontinuity = false);
+	 * @fn SendHelper
+	 * @param[in] mediaType stream type
+	 * @param[in] ptr buffer pointer
+	 * @param[in] len length of buffer
+	 * @param[in] fpts PTS of buffer (in sec)
+	 * @param[in] fdts DTS of buffer (in sec)
+	 * @param[in] duration duration of buffer (in sec)
+	 * @param[in] fragmentPTSoffset PTS offset
+	 * @param[in] copy to map or transfer the buffer
+	 * @param[in] initFragment flag for buffer type (init, data)
+	 */
+	bool SendHelper(AampMediaType mediaType, MediaSample sample, bool copy, bool initFragment = false, bool discontinuity = false);
 
 public:
 	class PrivateInstanceAAMP *aamp;
@@ -141,6 +141,8 @@ class AAMPGstPlayer : public StreamSink
 		 * @param[in] discontinuity flag for discontinuity
 		 */
 	bool SendTransfer(AampMediaType mediaType, void *ptr, size_t len, double fpts, double fdts, double fDuration, double fragmentPTSoffset, bool initFragment = false, bool discontinuity = false) override;
+
+ 	bool SendSample( AampMediaType mediaType, AampMediaSample& sample ) override;
 	/**
 		 * @fn PipelineConfiguredForMedia
 		 * @param[in] type stream type
@@ -425,6 +427,8 @@ class AAMPGstPlayer : public StreamSink
 	 */
 	int GetMonitorAVInterval() const { return mMonitorAVInterval; }
 
+	void SetStreamCaps(AampMediaType type, const AampCodecInfo &codecInfo) override;
+
 private:
 	std::mutex mBufferingLock;
 	id3_callback_t m_ID3MetadataHandler; /**< Function to call to generate the JS event for in ID3 packet */