liveMedia/RawVideoRTPSink.cpp - meet/live555 - Git at Google

 /**********
 This library is free software; you can redistribute it and/or modify it under
 the terms of the GNU Lesser General Public License as published by the
 Free Software Foundation; either version 3 of the License, or (at your
 option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)

 This library is distributed in the hope that it will be useful, but WITHOUT
 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
 more details.

 You should have received a copy of the GNU Lesser General Public License
 along with this library; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 **********/
 // "liveMedia"
 // Copyright (c) 1996-2020 Live Networks, Inc.  All rights reserved.
 // RTP sink for Raw video
 // Implementation

 #include "RawVideoRTPSink.hh"

 RawVideoRTPSink* RawVideoRTPSink
 ::createNew(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat,
         unsigned height, unsigned width, unsigned depth,
         char const* sampling, char const* colorimetry) {
   return new RawVideoRTPSink(env, RTPgs,
                              rtpPayloadFormat,
                              height, width, depth,
                              sampling, colorimetry);
 }

 RawVideoRTPSink
 ::RawVideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat,
                   unsigned height, unsigned width, unsigned depth,
                   char const* sampling, char const* colorimetry)
   : VideoRTPSink(env, RTPgs, rtpPayloadFormat, 90000, "RAW"),
     fFmtpSDPLine(NULL), fSampling(NULL), fWidth(width), fHeight(height),
     fDepth(depth), fColorimetry(NULL), fLineindex(0) {

   // Then use this 'config' string to construct our "a=fmtp:" SDP line:
   unsigned fmtpSDPLineMaxSize = 200;// 200 => more than enough space
   fFmtpSDPLine = new char[fmtpSDPLineMaxSize];
   sprintf(fFmtpSDPLine, "a=fmtp:%d sampling=%s;width=%u;height=%u;depth=%u;colorimetry=%s\r\n",
 	  rtpPayloadType(), sampling, width, height, depth, colorimetry);

   // Set parameters
   fSampling = strDup(sampling);
   fColorimetry = strDup(colorimetry);
   setFrameParameters();
 }

 RawVideoRTPSink::~RawVideoRTPSink() {
   delete[] fFmtpSDPLine;
   delete[] fSampling;
   delete[] fColorimetry;}

 char const* RawVideoRTPSink::auxSDPLine() {
   return fFmtpSDPLine;
 }

 void RawVideoRTPSink
 ::doSpecialFrameHandling(unsigned fragmentationOffset,
              unsigned char* frameStart,
              unsigned numBytesInFrame,
              struct timeval framePresentationTime,
              unsigned numRemainingBytes) {

   unsigned * lengths = NULL;
   unsigned * offsets= NULL;
   unsigned nbLines = getNbLineInPacket(fragmentationOffset, lengths, offsets);
   unsigned specialHeaderSize = 2 + (6 * nbLines);
   u_int8_t* specialHeader = new u_int8_t[specialHeaderSize];

   // Extended Sequence Number (not used)
   specialHeader[0] = 0;
   specialHeader[1] = 0;

   for (unsigned i = 0; i < nbLines; i++) {
     // detection of new line incrementation
     if ((offsets[i] == 0) && fragmentationOffset != 0) {
       fLineindex = fLineindex + fFrameParameters.scanLineIterationStep;
     }

     // Set length
     specialHeader[2 + (i * 6) + 0] = lengths[i] >> 8;
     specialHeader[2 + (i * 6) + 1] = (u_int8_t)lengths[i];

     // Field Identification (false for us)
     bool fieldIdent = false;

     // Set line index
     specialHeader[2 + (i * 6) + 2] = ((fLineindex >> 8) & 0x7F) | (fieldIdent << 7);
     specialHeader[2 + (i * 6) + 3] = (u_int8_t)fLineindex;

     // Set Continuation bit
     bool continuationBit = (i < nbLines - 1) ? true : false;

     // Set offset
     specialHeader[2 + (i * 6) + 4] = ((offsets[i] >> 8) & 0x7F) | (continuationBit << 7);
     specialHeader[2 + (i * 6) + 5] = (u_int8_t)offsets[i];
   }

   setSpecialHeaderBytes(specialHeader, specialHeaderSize);

   if (numRemainingBytes == 0) {
     // This packet contains the last (or only) fragment of the frame.
     // Set the RTP 'M' ('marker') bit:
     setMarkerBit();
     // Reset line index
     fLineindex = 0;
   }

   // Also set the RTP timestamp:
   setTimestamp(framePresentationTime);

   delete[] specialHeader;
   delete[] lengths;
   delete[] offsets;
 }

 Boolean RawVideoRTPSink::frameCanAppearAfterPacketStart(unsigned char const* /*frameStart*/,
                                unsigned /*numBytesInFrame*/) const {
   // Only one frame per packet:
   return False;
 }

 unsigned RawVideoRTPSink::specialHeaderSize() const {
   unsigned * lengths = NULL;
   unsigned * offsets= NULL;
   unsigned nbLines = getNbLineInPacket(curFragmentationOffset(), lengths, offsets);
   delete[] lengths;
   delete[] offsets;
   return 2 + (6 * nbLines);
 }

 unsigned RawVideoRTPSink::getNbLineInPacket(unsigned fragOffset, unsigned * &lengths, unsigned * &offsets) const
 {
   unsigned rtpHeaderSize = 12;
   unsigned specialHeaderSize = 2; // Extended Sequence Nb
   unsigned packetMaxSize = ourMaxPacketSize();
   unsigned nbLines = 0;
   unsigned remainingSizeInPacket;

   if (fragOffset >= fFrameParameters.frameSize) {
     envir() << "RawVideoRTPSink::getNbLineInPacket(): bad fragOffset " << fragOffset << "\n";
     return 0;
   }
   unsigned lengthArray[100] = {0};
   unsigned offsetArray[100] = {0};
   unsigned curDataTotalLength = 0;
   unsigned lineOffset = (fragOffset % fFrameParameters.scanLineSize);

   unsigned remainingLineSize = fFrameParameters.scanLineSize - (fragOffset % fFrameParameters.scanLineSize);
   while(1) {
     if (packetMaxSize - specialHeaderSize - rtpHeaderSize - 6 <= curDataTotalLength) {
       break; // packet sanity check
     }

     // add one line
     nbLines ++;
     specialHeaderSize += 6;

     remainingSizeInPacket = packetMaxSize - specialHeaderSize - rtpHeaderSize - curDataTotalLength;
     remainingSizeInPacket -= remainingSizeInPacket % fFrameParameters.pGroupSize; // use only multiple of pgroup
     lengthArray[nbLines-1] = remainingLineSize < remainingSizeInPacket ? remainingLineSize : remainingSizeInPacket;
     offsetArray[nbLines-1] = lineOffset * fFrameParameters.scanLineIterationStep / fFrameParameters.pGroupSize;
     if (remainingLineSize >= remainingSizeInPacket) {
       break; //packet full
     }

     remainingLineSize = fFrameParameters.scanLineSize;
     curDataTotalLength += lengthArray[nbLines-1];
     lineOffset = 0;

     if (fragOffset + curDataTotalLength >= fFrameParameters.frameSize) {
       break; // end of the frame.
     }
   }

   lengths = new unsigned[nbLines];
   offsets = new unsigned[nbLines];
   for (unsigned i = 0; i < nbLines; i++) {
     lengths[i] = lengthArray[i];
     offsets[i] = offsetArray[i];
   }
   return nbLines;
 }

 unsigned RawVideoRTPSink::computeOverflowForNewFrame(unsigned newFrameSize) const {
   unsigned initialOverflow = MultiFramedRTPSink::computeOverflowForNewFrame(newFrameSize);

   // Adjust (increase) this overflow to be a multiple of the pgroup value
   unsigned numFrameBytesUsed = newFrameSize - initialOverflow;
   initialOverflow += numFrameBytesUsed % fFrameParameters.pGroupSize;

   return initialOverflow;
 }

 void RawVideoRTPSink::setFrameParameters() {
   fFrameParameters.scanLineIterationStep = 1;
   if ((strncmp("RGB", fSampling, strlen(fSampling)) == 0) || (strncmp("BGR", fSampling, strlen(fSampling)) == 0)) {
     switch (fDepth) {
       case 8:
         fFrameParameters.pGroupSize = 3;
         fFrameParameters.nbOfPixelInPGroup = 1;
         break;
       case 10:
         fFrameParameters.pGroupSize = 15;
         fFrameParameters.nbOfPixelInPGroup = 4;
         break;
       case 12:
         fFrameParameters.pGroupSize = 9;
         fFrameParameters.nbOfPixelInPGroup = 2;
         break;
       case 16:
         fFrameParameters.pGroupSize = 6;
         fFrameParameters.nbOfPixelInPGroup = 1;
         break;
       default:
         break;
     }
   }
   else if ((strncmp("RGBA", fSampling, strlen(fSampling)) == 0) || (strncmp("BGRA", fSampling, strlen(fSampling)) == 0)) {
     switch (fDepth) {
       case 8:
         fFrameParameters.pGroupSize = 4;
         break;
       case 10:
         fFrameParameters.pGroupSize = 5;
         break;
       case 12:
         fFrameParameters.pGroupSize = 6;
         break;
       case 16:
         fFrameParameters.pGroupSize = 8;
         break;
       default:
         break;
     }
     fFrameParameters.nbOfPixelInPGroup = 1;
   } else if (strncmp("YCbCr-4:4:4", fSampling, strlen(fSampling)) == 0) {
     switch (fDepth) {
       case 8:
         fFrameParameters.pGroupSize = 3;
         fFrameParameters.nbOfPixelInPGroup = 1;
         break;
       case 10:
         fFrameParameters.pGroupSize = 15;
         fFrameParameters.nbOfPixelInPGroup = 4;
         break;
       case 12:
         fFrameParameters.pGroupSize = 9;
         fFrameParameters.nbOfPixelInPGroup = 2;
         break;
       case 16:
         fFrameParameters.pGroupSize = 6;
         fFrameParameters.nbOfPixelInPGroup = 1;
         break;
       default:
         break;
     }
   } else if (strncmp("YCbCr-4:2:2", fSampling, strlen(fSampling)) == 0) {
     switch (fDepth) {
       case 8:
         fFrameParameters.pGroupSize = 4;
         break;
       case 10:
         fFrameParameters.pGroupSize = 5;
         break;
       case 12:
         fFrameParameters.pGroupSize = 6;
         break;
       case 16:
         fFrameParameters.pGroupSize = 8;
         break;
       default:
         break;
     }
     fFrameParameters.nbOfPixelInPGroup = 2;
   } else if (strncmp("YCbCr-4:1:1", fSampling, strlen(fSampling)) == 0) {
     switch (fDepth) {
       case 8:
         fFrameParameters.pGroupSize = 6;
         break;
       case 10:
         fFrameParameters.pGroupSize = 15;
         break;
       case 12:
         fFrameParameters.pGroupSize = 9;
         break;
       case 16:
         fFrameParameters.pGroupSize = 12;
         break;
       default:
         break;
     }
     fFrameParameters.nbOfPixelInPGroup = 4;
   } else if (strncmp("YCbCr-4:2:0", fSampling, strlen(fSampling)) == 0) {
     switch (fDepth) {
       case 8:
         fFrameParameters.pGroupSize = 6;
         break;
       case 10:
         fFrameParameters.pGroupSize = 15;
         break;
       case 12:
         fFrameParameters.pGroupSize = 9;
         break;
       case 16:
         fFrameParameters.pGroupSize = 12;
         break;
       default:
         break;
     }
     fFrameParameters.nbOfPixelInPGroup = 4;
     fFrameParameters.scanLineIterationStep = 2;
   }
   fFrameParameters.frameSize = fHeight * fWidth * fFrameParameters.pGroupSize / fFrameParameters.nbOfPixelInPGroup;
   fFrameParameters.scanLineSize  = fWidth * fFrameParameters.pGroupSize / fFrameParameters.nbOfPixelInPGroup * fFrameParameters.scanLineIterationStep;
 }
	/**********
	This library is free software; you can redistribute it and/or modify it under
	the terms of the GNU Lesser General Public License as published by the
	Free Software Foundation; either version 3 of the License, or (at your
	option) any later version. (See <http://www.gnu.org/copyleft/lesser.html>.)

	This library is distributed in the hope that it will be useful, but WITHOUT
	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
	FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for
	more details.

	You should have received a copy of the GNU Lesser General Public License
	along with this library; if not, write to the Free Software Foundation, Inc.,
	51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	**********/
	// "liveMedia"
	// Copyright (c) 1996-2020 Live Networks, Inc. All rights reserved.
	// RTP sink for Raw video
	// Implementation

	#include "RawVideoRTPSink.hh"

	RawVideoRTPSink* RawVideoRTPSink
	::createNew(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat,
	unsigned height, unsigned width, unsigned depth,
	char const* sampling, char const* colorimetry) {
	return new RawVideoRTPSink(env, RTPgs,
	rtpPayloadFormat,
	height, width, depth,
	sampling, colorimetry);
	}

	RawVideoRTPSink
	::RawVideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat,
	unsigned height, unsigned width, unsigned depth,
	char const* sampling, char const* colorimetry)
	: VideoRTPSink(env, RTPgs, rtpPayloadFormat, 90000, "RAW"),
	fFmtpSDPLine(NULL), fSampling(NULL), fWidth(width), fHeight(height),
	fDepth(depth), fColorimetry(NULL), fLineindex(0) {

	// Then use this 'config' string to construct our "a=fmtp:" SDP line:
	unsigned fmtpSDPLineMaxSize = 200;// 200 => more than enough space
	fFmtpSDPLine = new char[fmtpSDPLineMaxSize];
	sprintf(fFmtpSDPLine, "a=fmtp:%d sampling=%s;width=%u;height=%u;depth=%u;colorimetry=%s\r\n",
	rtpPayloadType(), sampling, width, height, depth, colorimetry);

	// Set parameters
	fSampling = strDup(sampling);
	fColorimetry = strDup(colorimetry);
	setFrameParameters();
	}

	RawVideoRTPSink::~RawVideoRTPSink() {
	delete[] fFmtpSDPLine;
	delete[] fSampling;
	delete[] fColorimetry;}

	char const* RawVideoRTPSink::auxSDPLine() {
	return fFmtpSDPLine;
	}

	void RawVideoRTPSink
	::doSpecialFrameHandling(unsigned fragmentationOffset,
	unsigned char* frameStart,
	unsigned numBytesInFrame,
	struct timeval framePresentationTime,
	unsigned numRemainingBytes) {

	unsigned * lengths = NULL;
	unsigned * offsets= NULL;
	unsigned nbLines = getNbLineInPacket(fragmentationOffset, lengths, offsets);
	unsigned specialHeaderSize = 2 + (6 * nbLines);
	u_int8_t* specialHeader = new u_int8_t[specialHeaderSize];

	// Extended Sequence Number (not used)
	specialHeader[0] = 0;
	specialHeader[1] = 0;

	for (unsigned i = 0; i < nbLines; i++) {
	// detection of new line incrementation
	if ((offsets[i] == 0) && fragmentationOffset != 0) {
	fLineindex = fLineindex + fFrameParameters.scanLineIterationStep;
	}

	// Set length
	specialHeader[2 + (i * 6) + 0] = lengths[i] >> 8;
	specialHeader[2 + (i * 6) + 1] = (u_int8_t)lengths[i];

	// Field Identification (false for us)
	bool fieldIdent = false;

	// Set line index
	specialHeader[2 + (i * 6) + 2] = ((fLineindex >> 8) & 0x7F) \| (fieldIdent << 7);
	specialHeader[2 + (i * 6) + 3] = (u_int8_t)fLineindex;

	// Set Continuation bit
	bool continuationBit = (i < nbLines - 1) ? true : false;

	// Set offset
	specialHeader[2 + (i * 6) + 4] = ((offsets[i] >> 8) & 0x7F) \| (continuationBit << 7);
	specialHeader[2 + (i * 6) + 5] = (u_int8_t)offsets[i];
	}

	setSpecialHeaderBytes(specialHeader, specialHeaderSize);

	if (numRemainingBytes == 0) {
	// This packet contains the last (or only) fragment of the frame.
	// Set the RTP 'M' ('marker') bit:
	setMarkerBit();
	// Reset line index
	fLineindex = 0;
	}

	// Also set the RTP timestamp:
	setTimestamp(framePresentationTime);

	delete[] specialHeader;
	delete[] lengths;
	delete[] offsets;
	}

	Boolean RawVideoRTPSink::frameCanAppearAfterPacketStart(unsigned char const* /frameStart/,
	unsigned /numBytesInFrame/) const {
	// Only one frame per packet:
	return False;
	}

	unsigned RawVideoRTPSink::specialHeaderSize() const {
	unsigned * lengths = NULL;
	unsigned * offsets= NULL;
	unsigned nbLines = getNbLineInPacket(curFragmentationOffset(), lengths, offsets);
	delete[] lengths;
	delete[] offsets;
	return 2 + (6 * nbLines);
	}

	unsigned RawVideoRTPSink::getNbLineInPacket(unsigned fragOffset, unsigned * &lengths, unsigned * &offsets) const
	{
	unsigned rtpHeaderSize = 12;
	unsigned specialHeaderSize = 2; // Extended Sequence Nb
	unsigned packetMaxSize = ourMaxPacketSize();
	unsigned nbLines = 0;
	unsigned remainingSizeInPacket;

	if (fragOffset >= fFrameParameters.frameSize) {
	envir() << "RawVideoRTPSink::getNbLineInPacket(): bad fragOffset " << fragOffset << "\n";
	return 0;
	}
	unsigned lengthArray[100] = {0};
	unsigned offsetArray[100] = {0};
	unsigned curDataTotalLength = 0;
	unsigned lineOffset = (fragOffset % fFrameParameters.scanLineSize);

	unsigned remainingLineSize = fFrameParameters.scanLineSize - (fragOffset % fFrameParameters.scanLineSize);
	while(1) {
	if (packetMaxSize - specialHeaderSize - rtpHeaderSize - 6 <= curDataTotalLength) {
	break; // packet sanity check
	}

	// add one line
	nbLines ++;
	specialHeaderSize += 6;

	remainingSizeInPacket = packetMaxSize - specialHeaderSize - rtpHeaderSize - curDataTotalLength;
	remainingSizeInPacket -= remainingSizeInPacket % fFrameParameters.pGroupSize; // use only multiple of pgroup
	lengthArray[nbLines-1] = remainingLineSize < remainingSizeInPacket ? remainingLineSize : remainingSizeInPacket;
	offsetArray[nbLines-1] = lineOffset * fFrameParameters.scanLineIterationStep / fFrameParameters.pGroupSize;
	if (remainingLineSize >= remainingSizeInPacket) {
	break; //packet full
	}

	remainingLineSize = fFrameParameters.scanLineSize;
	curDataTotalLength += lengthArray[nbLines-1];
	lineOffset = 0;

	if (fragOffset + curDataTotalLength >= fFrameParameters.frameSize) {
	break; // end of the frame.
	}
	}

	lengths = new unsigned[nbLines];
	offsets = new unsigned[nbLines];
	for (unsigned i = 0; i < nbLines; i++) {
	lengths[i] = lengthArray[i];
	offsets[i] = offsetArray[i];
	}
	return nbLines;
	}

	unsigned RawVideoRTPSink::computeOverflowForNewFrame(unsigned newFrameSize) const {
	unsigned initialOverflow = MultiFramedRTPSink::computeOverflowForNewFrame(newFrameSize);

	// Adjust (increase) this overflow to be a multiple of the pgroup value
	unsigned numFrameBytesUsed = newFrameSize - initialOverflow;
	initialOverflow += numFrameBytesUsed % fFrameParameters.pGroupSize;

	return initialOverflow;
	}

	void RawVideoRTPSink::setFrameParameters() {
	fFrameParameters.scanLineIterationStep = 1;
	if ((strncmp("RGB", fSampling, strlen(fSampling)) == 0) \|\| (strncmp("BGR", fSampling, strlen(fSampling)) == 0)) {
	switch (fDepth) {
	case 8:
	fFrameParameters.pGroupSize = 3;
	fFrameParameters.nbOfPixelInPGroup = 1;
	break;
	case 10:
	fFrameParameters.pGroupSize = 15;
	fFrameParameters.nbOfPixelInPGroup = 4;
	break;
	case 12:
	fFrameParameters.pGroupSize = 9;
	fFrameParameters.nbOfPixelInPGroup = 2;
	break;
	case 16:
	fFrameParameters.pGroupSize = 6;
	fFrameParameters.nbOfPixelInPGroup = 1;
	break;
	default:
	break;
	}
	}
	else if ((strncmp("RGBA", fSampling, strlen(fSampling)) == 0) \|\| (strncmp("BGRA", fSampling, strlen(fSampling)) == 0)) {
	switch (fDepth) {
	case 8:
	fFrameParameters.pGroupSize = 4;
	break;
	case 10:
	fFrameParameters.pGroupSize = 5;
	break;
	case 12:
	fFrameParameters.pGroupSize = 6;
	break;
	case 16:
	fFrameParameters.pGroupSize = 8;
	break;
	default:
	break;
	}
	fFrameParameters.nbOfPixelInPGroup = 1;
	} else if (strncmp("YCbCr-4:4:4", fSampling, strlen(fSampling)) == 0) {
	switch (fDepth) {
	case 8:
	fFrameParameters.pGroupSize = 3;
	fFrameParameters.nbOfPixelInPGroup = 1;
	break;
	case 10:
	fFrameParameters.pGroupSize = 15;
	fFrameParameters.nbOfPixelInPGroup = 4;
	break;
	case 12:
	fFrameParameters.pGroupSize = 9;
	fFrameParameters.nbOfPixelInPGroup = 2;
	break;
	case 16:
	fFrameParameters.pGroupSize = 6;
	fFrameParameters.nbOfPixelInPGroup = 1;
	break;
	default:
	break;
	}
	} else if (strncmp("YCbCr-4:2:2", fSampling, strlen(fSampling)) == 0) {
	switch (fDepth) {
	case 8:
	fFrameParameters.pGroupSize = 4;
	break;
	case 10:
	fFrameParameters.pGroupSize = 5;
	break;
	case 12:
	fFrameParameters.pGroupSize = 6;
	break;
	case 16:
	fFrameParameters.pGroupSize = 8;
	break;
	default:
	break;
	}
	fFrameParameters.nbOfPixelInPGroup = 2;
	} else if (strncmp("YCbCr-4:1:1", fSampling, strlen(fSampling)) == 0) {
	switch (fDepth) {
	case 8:
	fFrameParameters.pGroupSize = 6;
	break;
	case 10:
	fFrameParameters.pGroupSize = 15;
	break;
	case 12:
	fFrameParameters.pGroupSize = 9;
	break;
	case 16:
	fFrameParameters.pGroupSize = 12;
	break;
	default:
	break;
	}
	fFrameParameters.nbOfPixelInPGroup = 4;
	} else if (strncmp("YCbCr-4:2:0", fSampling, strlen(fSampling)) == 0) {
	switch (fDepth) {
	case 8:
	fFrameParameters.pGroupSize = 6;
	break;
	case 10:
	fFrameParameters.pGroupSize = 15;
	break;
	case 12:
	fFrameParameters.pGroupSize = 9;
	break;
	case 16:
	fFrameParameters.pGroupSize = 12;
	break;
	default:
	break;
	}
	fFrameParameters.nbOfPixelInPGroup = 4;
	fFrameParameters.scanLineIterationStep = 2;
	}
	fFrameParameters.frameSize = fHeight * fWidth * fFrameParameters.pGroupSize / fFrameParameters.nbOfPixelInPGroup;
	fFrameParameters.scanLineSize = fWidth * fFrameParameters.pGroupSize / fFrameParameters.nbOfPixelInPGroup * fFrameParameters.scanLineIterationStep;
	}