| /********** |
| 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 Theora video |
| // Implementation |
| |
| #include "TheoraVideoRTPSink.hh" |
| #include "Base64.hh" |
| #include "VorbisAudioRTPSource.hh" // for parseVorbisOrTheoraConfigStr() |
| #include "VorbisAudioRTPSink.hh" // for generateVorbisOrTheoraConfigStr() |
| |
| TheoraVideoRTPSink* TheoraVideoRTPSink |
| ::createNew(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat, |
| u_int8_t* identificationHeader, unsigned identificationHeaderSize, |
| u_int8_t* commentHeader, unsigned commentHeaderSize, |
| u_int8_t* setupHeader, unsigned setupHeaderSize, |
| u_int32_t identField) { |
| return new TheoraVideoRTPSink(env, RTPgs, |
| rtpPayloadFormat, |
| identificationHeader, identificationHeaderSize, |
| commentHeader, commentHeaderSize, |
| setupHeader, setupHeaderSize, identField); |
| } |
| |
| TheoraVideoRTPSink* TheoraVideoRTPSink |
| ::createNew(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat, |
| char const* configStr) { |
| // Begin by decoding and unpacking the configuration string: |
| u_int8_t* identificationHeader; unsigned identificationHeaderSize; |
| u_int8_t* commentHeader; unsigned commentHeaderSize; |
| u_int8_t* setupHeader; unsigned setupHeaderSize; |
| u_int32_t identField; |
| |
| parseVorbisOrTheoraConfigStr(configStr, |
| identificationHeader, identificationHeaderSize, |
| commentHeader, commentHeaderSize, |
| setupHeader, setupHeaderSize, |
| identField); |
| |
| TheoraVideoRTPSink* resultSink |
| = new TheoraVideoRTPSink(env, RTPgs, rtpPayloadFormat, |
| identificationHeader, identificationHeaderSize, |
| commentHeader, commentHeaderSize, |
| setupHeader, setupHeaderSize, |
| identField); |
| delete[] identificationHeader; delete[] commentHeader; delete[] setupHeader; |
| |
| return resultSink; |
| } |
| |
| TheoraVideoRTPSink |
| ::TheoraVideoRTPSink(UsageEnvironment& env, Groupsock* RTPgs, u_int8_t rtpPayloadFormat, |
| u_int8_t* identificationHeader, unsigned identificationHeaderSize, |
| u_int8_t* commentHeader, unsigned commentHeaderSize, |
| u_int8_t* setupHeader, unsigned setupHeaderSize, |
| u_int32_t identField) |
| : VideoRTPSink(env, RTPgs, rtpPayloadFormat, 90000, "THEORA"), |
| fIdent(identField), fFmtpSDPLine(NULL) { |
| static const char *pf_to_str[] = { |
| "YCbCr-4:2:0", |
| "Reserved", |
| "YCbCr-4:2:2", |
| "YCbCr-4:4:4", |
| }; |
| |
| unsigned width = 1280; // default value |
| unsigned height = 720; // default value |
| unsigned pf = 0; // default value |
| if (identificationHeaderSize >= 42) { |
| // Parse this header to get the "width", "height", "pf" (pixel format), and |
| // 'nominal bitrate' parameters: |
| u_int8_t* p = identificationHeader; // alias |
| width = (p[14]<<16)|(p[15]<<8)|p[16]; |
| height = (p[17]<<16)|(p[18]<<8)|p[19]; |
| pf = (p[41]&0x18)>>3; |
| unsigned nominalBitrate = (p[37]<<16)|(p[38]<<8)|p[39]; |
| if (nominalBitrate > 0) estimatedBitrate() = nominalBitrate/1000; |
| } |
| |
| // Generate a 'config' string from the supplied configuration headers: |
| char* base64PackedHeaders |
| = generateVorbisOrTheoraConfigStr(identificationHeader, identificationHeaderSize, |
| commentHeader, commentHeaderSize, |
| setupHeader, setupHeaderSize, |
| identField); |
| if (base64PackedHeaders == NULL) return; |
| |
| // Then use this 'config' string to construct our "a=fmtp:" SDP line: |
| unsigned fmtpSDPLineMaxSize = 200 + strlen(base64PackedHeaders);// 200 => more than enough space |
| fFmtpSDPLine = new char[fmtpSDPLineMaxSize]; |
| sprintf(fFmtpSDPLine, "a=fmtp:%d sampling=%s;width=%u;height=%u;delivery-method=out_band/rtsp;configuration=%s\r\n", rtpPayloadType(), pf_to_str[pf], width, height, base64PackedHeaders); |
| delete[] base64PackedHeaders; |
| } |
| |
| TheoraVideoRTPSink::~TheoraVideoRTPSink() { |
| delete[] fFmtpSDPLine; |
| } |
| |
| char const* TheoraVideoRTPSink::auxSDPLine() { |
| return fFmtpSDPLine; |
| } |
| |
| void TheoraVideoRTPSink |
| ::doSpecialFrameHandling(unsigned fragmentationOffset, |
| unsigned char* frameStart, |
| unsigned numBytesInFrame, |
| struct timeval framePresentationTime, |
| unsigned numRemainingBytes) { |
| // Set the 4-byte "payload header", as defined in http://svn.xiph.org/trunk/theora/doc/draft-ietf-avt-rtp-theora-00.txt |
| u_int8_t header[6]; |
| |
| // The three bytes of the header are our "Ident": |
| header[0] = fIdent>>16; header[1] = fIdent>>8; header[2] = fIdent; |
| |
| // The final byte contains the "F", "TDT", and "numPkts" fields: |
| u_int8_t F; // Fragment type |
| if (numRemainingBytes > 0) { |
| if (fragmentationOffset > 0) { |
| F = 2<<6; // continuation fragment |
| } else { |
| F = 1<<6; // start fragment |
| } |
| } else { |
| if (fragmentationOffset > 0) { |
| F = 3<<6; // end fragment |
| } else { |
| F = 0<<6; // not fragmented |
| } |
| } |
| u_int8_t const TDT = 0<<4; // Theora Data Type (always a "Raw Theora payload") |
| u_int8_t numPkts = F == 0 ? (numFramesUsedSoFar() + 1): 0; // set to 0 when we're a fragment |
| header[3] = F|TDT|numPkts; |
| |
| // There's also a 2-byte 'frame-specific' header: The length of the |
| // Theora data: |
| header[4] = numBytesInFrame >>8; |
| header[5] = numBytesInFrame; |
| setSpecialHeaderBytes(header, sizeof(header)); |
| |
| if (numRemainingBytes == 0) { |
| // This packet contains the last (or only) fragment of the frame. |
| // Set the RTP 'M' ('marker') bit: |
| setMarkerBit(); |
| } |
| |
| // Important: Also call our base class's doSpecialFrameHandling(), |
| // to set the packet's timestamp: |
| MultiFramedRTPSink::doSpecialFrameHandling(fragmentationOffset, |
| frameStart, numBytesInFrame, |
| framePresentationTime, |
| numRemainingBytes); |
| } |
| |
| Boolean TheoraVideoRTPSink::frameCanAppearAfterPacketStart(unsigned char const* /*frameStart*/, |
| unsigned /*numBytesInFrame*/) const { |
| // Only one frame per packet: |
| return False; |
| } |
| |
| unsigned TheoraVideoRTPSink::specialHeaderSize() const { |
| return 6; |
| } |