protocols/rtp_payload_parser/rfc_3984/src/h264_payload_parser_interleave_mode.h - platform/external/opencore - Git at Google

 /* ------------------------------------------------------------------
  * Copyright (C) 1998-2009 PacketVideo
  *
  * 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 H264_PAYLOAD_PARSER_INTERLEAVE_MODE_H
 #define H264_PAYLOAD_PARSER_INTERLEAVE_MODE_H


 #ifndef OSCL_PRIQUEUE_H_INCLUDED
 #include "oscl_priqueue.h"
 #endif

 #ifndef OSCL_MEM_H_INCLUDED
 #include "oscl_mem.h"
 #endif

 #ifndef PAYLOAD_PARSER_H_INCLUDED
 #include "payload_parser.h"
 #endif

 #ifndef H264_PAYLOAD_PARSER_MACROS_H_INCLUDED
 #include "h264_payload_parser_macros.h"
 #endif

 /////////////////////////////////////////////////////////////////////////////////
 ////////////// priority queue related data structures ///////////////////////////
 /////////////////////////////////////////////////////////////////////////////////
 class PVH264PayLoadOutputMediaData
 {
     public:
         PVH264PayLoadOutputMediaData() : don(0), fuType(0) {};

         PVH264PayLoadOutputMediaData(const PVH264PayLoadOutputMediaData& x)
         {
             data  = x.data;
             don  = x.don;
             fuType = x.fuType;
         }

         PVH264PayLoadOutputMediaData(IPayloadParser::Payload adata, uint32 aDon, uint32 aFuType)
         {
             data = adata;
             don = aDon;
             fuType = aFuType;
         }

         //required for compile of OsclPriorityQueue but not currently used & not implemented.
         //would be needed if code called "remove".
         bool operator==(const PVH264PayLoadOutputMediaData& x)const
         {
             OSCL_UNUSED_ARG(&x);
             OSCL_ASSERT(0);
             return false;
         }

     public:
         IPayloadParser::Payload data;
         uint32	don;
         uint32  fuType;	// First byte: current fuType
         // 0 complete NAL
         // 1 starting FU
         // 2 intermediate FU
         // 3 ending FU
         // Second byte: previous fuType
         // Third-Fourth bytes: counter for intermediate FUs for the following compare function

 };

 // priority comparison class
 class PVH264PayLoadOutputMediaDataCompareLess
 {
     public:
         /**
         * The algorithm used in OsclPriorityQueue needs a compare function
         * that returns true when a's priority is less than b's. In the
         * current context, when a's don is larger than b's don, return true
         * Basically when a's don is smaller than b's don, then a's priority
         * is higher than b's.
         * @return true if a's priority is less than b's, else false
         */
         int compare(PVH264PayLoadOutputMediaData& a, PVH264PayLoadOutputMediaData& b) const
         {
             int32 diffDon = PVH264PayLoadOutputMediaDataCompareLess::don_diff(a.don, b.don);
             if (diffDon == 0)
             {
                 // use fuType
                 diffDon = PVH264PayLoadOutputMediaDataCompareLess::fuType_diff(a.fuType, b.fuType);
             }
             return (diffDon < 0);
         }

     private:

         static int32 don_diff(uint32 m_don, uint32 n_don)
         {
             if (m_don == n_don) return 0;

             if (m_don < n_don && (n_don - m_don < 32768))
                 return ((int32)n_don - (int32)m_don);

             if (m_don < n_don && (n_don - m_don >= 32768))
                 return ((int32)n_don - (int32)m_don - 65536);

             if (m_don > n_don && (m_don - n_don < 32768))
                 return -((int32)m_don - (int32)n_don);

             if (m_don > n_don && (m_don - n_don >= 32768))
                 return (65536 - m_don + n_don);

             return 0;
         }

         static int32 fuType_diff(uint32 m_fuType, uint32 n_fuType)
         {
             int32 diff_fuType = (int32)(n_fuType & 0x03) - (int32)(m_fuType & 0x03);

             // for intermediate FUs
             if (diff_fuType == 0)
             {
                 diff_fuType = (int32)(n_fuType >> 16) - (int32)(m_fuType >> 16);
             }

             return diff_fuType;
         }
 };

 //memory allocator type for this node.
 typedef OsclMemAllocator PVH264PayloadParserAllocator;


 class InterleaveModeProcessing
 {

     public:

         // constructor
         InterleaveModeProcessing() : iNALUnitsCounter(0),
                 iDon(0),
                 iDonBase(0),
                 iTimestampOffset(0),
                 iPrevNALType(0),
                 iRtpPayloadPtr(NULL)
         {
             ;
         }

         // destructor
         ~InterleaveModeProcessing()
         {

             // for iOutputMediaDataQueue, remove all the elements from the output data priority queue
             while (!iOutputMediaDataQueue.empty())
             {
                 iOutputMediaDataQueue.pop();
             }

             iNALUnitsCounter = iDon = iDonBase =
                                           iTimestampOffset = iPrevNALType = 0;
             iRtpPayloadPtr = NULL;
         }

         // initialize the iOutputMediaDataQueue when in the interleaved mode
         bool initialize(uint32 aInterleaveDepth)
         {
             if (aInterleaveDepth > 0)
             {
                 int32 err = 0;
                 OSCL_TRY(err, iOutputMediaDataQueue.reserve((aInterleaveDepth + 1) << 2));
                 if (err) return false;
             }
             return true;
         }

         // push data to priority queue
         bool queue(const IPayloadParser::Payload& aMediaData, const uint8 nal_type, const uint32 fragmentedBitMask)
         {
             uint32 prev_fuType = iPrevNALType & 0x03;
             uint32 fuType = fragmentedBitMask & 0x03;
             uint32 fuCounter = 0;
             if (fuType == 2)  // for the above fuType_diff() in priority comparsion
             {
                 fuCounter = (fragmentedBitMask >> BIT_SHIFT_FOR_FU_COUNTER) << 16;
             }
             PVH264PayLoadOutputMediaData out_data(aMediaData, iDon, (fuCounter | (prev_fuType << 8) | fuType));

             // push into the prority queue
             int32 err;
             OSCL_TRY(err, iOutputMediaDataQueue.push(out_data));
             if (err || iOutputMediaDataQueue.empty()) return false;

             // update internal variables
             updateWhenQueuingData(fuType, nal_type, fragmentedBitMask);
             return true;
         }

         // pop data from priority queue
         void dequeue(IPayloadParser::Payload& accessUnit)
         {
             PVH264PayLoadOutputMediaData out_data(iOutputMediaDataQueue.top());
             iOutputMediaDataQueue.pop();
             accessUnit = out_data.data;

             // update internal variables
             updateWhenDequeuingData(out_data.fuType);
         }

         // priority queue is empty
         bool isQueueEmpty()
         {
             return iOutputMediaDataQueue.empty();
         }

     private:
         // update variables when the prority queue is queuing data
         void updateWhenQueuingData(const uint32 fuType, const uint8 nal_type, const uint32 fragmentedBitMask)
         {
             if (fuType == 0 || fuType == 3)  // complete NAL or ending FU
             {
                 iNALUnitsCounter++;
             }

             // update iPrevNALType, only for complete NALs and FU-B
             if (nal_type != H264_RTP_PAYLOAD_FU_A)
             {
                 iPrevNALType = fragmentedBitMask & 0x07;
             }
             else   // FU-A
             {
                 iPrevNALType >>= 2;
                 iPrevNALType <<= 2;		// clear bit 1 and bit 0
                 iPrevNALType |= fuType;	// keep bit 2 unchanged for FU-A, for isCurrRTPPacketIgnored()
             }
         }

         // update variables when the prority queue is de-queuing data
         void updateWhenDequeuingData(const uint32 fuType)
         {
             uint32 prev_fuType = (fuType >> 8) & 0x03;
             uint32 curr_fuType = fuType & 0x03;

             if (curr_fuType == 0)  // complete NAL
             {
                 iNALUnitsCounter--;
                 if (prev_fuType == 1 || prev_fuType == 2)  // current one is complete NAL, but the previous one is fragmented NAL in case that the ending fragmented NAL is lost
                 {
                     iNALUnitsCounter--;
                 }
             }
             else if (curr_fuType == 3)  // ending fragemented NAL
             {
                 iNALUnitsCounter--;
             }
         }


     public:
         // counter of complete NAL units, which could be smaller than the actual number of elements in iOutputMediaDataQueue
         uint32 iNALUnitsCounter;

         // hold the current DON, for FU-As following the first FU-B
         uint32 iDon;

         // hold the DONB, for MTAPs, or serves as the counter for FUs
         uint32 iDonBase;

         // for MTAPs only, save the timestamp offset
         uint32 iTimestampOffset;

         // for the NAL type of the previous media message sent out, should be equal to "iIsFragmentedBitMask&0x03" of class H264PayloadParser
         uint32 iPrevNALType;

         // save the rtp payload pointer to check if the current input rtp packet is the same as the previous one
         uint8 *iRtpPayloadPtr;

         // Priority Queue of output media data
         OsclPriorityQueue < PVH264PayLoadOutputMediaData,
         PVH264PayloadParserAllocator,
         Oscl_Vector<PVH264PayLoadOutputMediaData, PVH264PayloadParserAllocator>,
         PVH264PayLoadOutputMediaDataCompareLess > iOutputMediaDataQueue;

 };

 #endif // H264_PAYLOAD_PARSER_INTERLEAVE_MODE_H
	/* ------------------------------------------------------------------
	* Copyright (C) 1998-2009 PacketVideo
	*
	* 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 H264_PAYLOAD_PARSER_INTERLEAVE_MODE_H
	#define H264_PAYLOAD_PARSER_INTERLEAVE_MODE_H


	#ifndef OSCL_PRIQUEUE_H_INCLUDED
	#include "oscl_priqueue.h"
	#endif

	#ifndef OSCL_MEM_H_INCLUDED
	#include "oscl_mem.h"
	#endif

	#ifndef PAYLOAD_PARSER_H_INCLUDED
	#include "payload_parser.h"
	#endif

	#ifndef H264_PAYLOAD_PARSER_MACROS_H_INCLUDED
	#include "h264_payload_parser_macros.h"
	#endif

	/////////////////////////////////////////////////////////////////////////////////
	////////////// priority queue related data structures ///////////////////////////
	/////////////////////////////////////////////////////////////////////////////////
	class PVH264PayLoadOutputMediaData
	{
	public:
	PVH264PayLoadOutputMediaData() : don(0), fuType(0) {};

	PVH264PayLoadOutputMediaData(const PVH264PayLoadOutputMediaData& x)
	{
	data = x.data;
	don = x.don;
	fuType = x.fuType;
	}

	PVH264PayLoadOutputMediaData(IPayloadParser::Payload adata, uint32 aDon, uint32 aFuType)
	{
	data = adata;
	don = aDon;
	fuType = aFuType;
	}

	//required for compile of OsclPriorityQueue but not currently used & not implemented.
	//would be needed if code called "remove".
	bool operator==(const PVH264PayLoadOutputMediaData& x)const
	{
	OSCL_UNUSED_ARG(&x);
	OSCL_ASSERT(0);
	return false;
	}

	public:
	IPayloadParser::Payload data;
	uint32 don;
	uint32 fuType; // First byte: current fuType
	// 0 complete NAL
	// 1 starting FU
	// 2 intermediate FU
	// 3 ending FU
	// Second byte: previous fuType
	// Third-Fourth bytes: counter for intermediate FUs for the following compare function

	};

	// priority comparison class
	class PVH264PayLoadOutputMediaDataCompareLess
	{
	public:
	/**
	* The algorithm used in OsclPriorityQueue needs a compare function
	* that returns true when a's priority is less than b's. In the
	* current context, when a's don is larger than b's don, return true
	* Basically when a's don is smaller than b's don, then a's priority
	* is higher than b's.
	* @return true if a's priority is less than b's, else false
	*/
	int compare(PVH264PayLoadOutputMediaData& a, PVH264PayLoadOutputMediaData& b) const
	{
	int32 diffDon = PVH264PayLoadOutputMediaDataCompareLess::don_diff(a.don, b.don);
	if (diffDon == 0)
	{
	// use fuType
	diffDon = PVH264PayLoadOutputMediaDataCompareLess::fuType_diff(a.fuType, b.fuType);
	}
	return (diffDon < 0);
	}

	private:

	static int32 don_diff(uint32 m_don, uint32 n_don)
	{
	if (m_don == n_don) return 0;

	if (m_don < n_don && (n_don - m_don < 32768))
	return ((int32)n_don - (int32)m_don);

	if (m_don < n_don && (n_don - m_don >= 32768))
	return ((int32)n_don - (int32)m_don - 65536);

	if (m_don > n_don && (m_don - n_don < 32768))
	return -((int32)m_don - (int32)n_don);

	if (m_don > n_don && (m_don - n_don >= 32768))
	return (65536 - m_don + n_don);

	return 0;
	}

	static int32 fuType_diff(uint32 m_fuType, uint32 n_fuType)
	{
	int32 diff_fuType = (int32)(n_fuType & 0x03) - (int32)(m_fuType & 0x03);

	// for intermediate FUs
	if (diff_fuType == 0)
	{
	diff_fuType = (int32)(n_fuType >> 16) - (int32)(m_fuType >> 16);
	}

	return diff_fuType;
	}
	};

	//memory allocator type for this node.
	typedef OsclMemAllocator PVH264PayloadParserAllocator;


	class InterleaveModeProcessing
	{

	public:

	// constructor
	InterleaveModeProcessing() : iNALUnitsCounter(0),
	iDon(0),
	iDonBase(0),
	iTimestampOffset(0),
	iPrevNALType(0),
	iRtpPayloadPtr(NULL)
	{
	;
	}

	// destructor
	~InterleaveModeProcessing()
	{

	// for iOutputMediaDataQueue, remove all the elements from the output data priority queue
	while (!iOutputMediaDataQueue.empty())
	{
	iOutputMediaDataQueue.pop();
	}

	iNALUnitsCounter = iDon = iDonBase =
	iTimestampOffset = iPrevNALType = 0;
	iRtpPayloadPtr = NULL;
	}

	// initialize the iOutputMediaDataQueue when in the interleaved mode
	bool initialize(uint32 aInterleaveDepth)
	{
	if (aInterleaveDepth > 0)
	{
	int32 err = 0;
	OSCL_TRY(err, iOutputMediaDataQueue.reserve((aInterleaveDepth + 1) << 2));
	if (err) return false;
	}
	return true;
	}

	// push data to priority queue
	bool queue(const IPayloadParser::Payload& aMediaData, const uint8 nal_type, const uint32 fragmentedBitMask)
	{
	uint32 prev_fuType = iPrevNALType & 0x03;
	uint32 fuType = fragmentedBitMask & 0x03;
	uint32 fuCounter = 0;
	if (fuType == 2) // for the above fuType_diff() in priority comparsion
	{
	fuCounter = (fragmentedBitMask >> BIT_SHIFT_FOR_FU_COUNTER) << 16;
	}
	PVH264PayLoadOutputMediaData out_data(aMediaData, iDon, (fuCounter \| (prev_fuType << 8) \| fuType));

	// push into the prority queue
	int32 err;
	OSCL_TRY(err, iOutputMediaDataQueue.push(out_data));
	if (err \|\| iOutputMediaDataQueue.empty()) return false;

	// update internal variables
	updateWhenQueuingData(fuType, nal_type, fragmentedBitMask);
	return true;
	}

	// pop data from priority queue
	void dequeue(IPayloadParser::Payload& accessUnit)
	{
	PVH264PayLoadOutputMediaData out_data(iOutputMediaDataQueue.top());
	iOutputMediaDataQueue.pop();
	accessUnit = out_data.data;

	// update internal variables
	updateWhenDequeuingData(out_data.fuType);
	}

	// priority queue is empty
	bool isQueueEmpty()
	{
	return iOutputMediaDataQueue.empty();
	}

	private:
	// update variables when the prority queue is queuing data
	void updateWhenQueuingData(const uint32 fuType, const uint8 nal_type, const uint32 fragmentedBitMask)
	{
	if (fuType == 0 \|\| fuType == 3) // complete NAL or ending FU
	{
	iNALUnitsCounter++;
	}

	// update iPrevNALType, only for complete NALs and FU-B
	if (nal_type != H264_RTP_PAYLOAD_FU_A)
	{
	iPrevNALType = fragmentedBitMask & 0x07;
	}
	else // FU-A
	{
	iPrevNALType >>= 2;
	iPrevNALType <<= 2; // clear bit 1 and bit 0
	iPrevNALType \|= fuType; // keep bit 2 unchanged for FU-A, for isCurrRTPPacketIgnored()
	}
	}

	// update variables when the prority queue is de-queuing data
	void updateWhenDequeuingData(const uint32 fuType)
	{
	uint32 prev_fuType = (fuType >> 8) & 0x03;
	uint32 curr_fuType = fuType & 0x03;

	if (curr_fuType == 0) // complete NAL
	{
	iNALUnitsCounter--;
	if (prev_fuType == 1 \|\| prev_fuType == 2) // current one is complete NAL, but the previous one is fragmented NAL in case that the ending fragmented NAL is lost
	{
	iNALUnitsCounter--;
	}
	}
	else if (curr_fuType == 3) // ending fragemented NAL
	{
	iNALUnitsCounter--;
	}
	}


	public:
	// counter of complete NAL units, which could be smaller than the actual number of elements in iOutputMediaDataQueue
	uint32 iNALUnitsCounter;

	// hold the current DON, for FU-As following the first FU-B
	uint32 iDon;

	// hold the DONB, for MTAPs, or serves as the counter for FUs
	uint32 iDonBase;

	// for MTAPs only, save the timestamp offset
	uint32 iTimestampOffset;

	// for the NAL type of the previous media message sent out, should be equal to "iIsFragmentedBitMask&0x03" of class H264PayloadParser
	uint32 iPrevNALType;

	// save the rtp payload pointer to check if the current input rtp packet is the same as the previous one
	uint8 *iRtpPayloadPtr;

	// Priority Queue of output media data
	OsclPriorityQueue < PVH264PayLoadOutputMediaData,
	PVH264PayloadParserAllocator,
	Oscl_Vector<PVH264PayLoadOutputMediaData, PVH264PayloadParserAllocator>,
	PVH264PayLoadOutputMediaDataCompareLess > iOutputMediaDataQueue;

	};

	#endif // H264_PAYLOAD_PARSER_INTERLEAVE_MODE_H