zhangzhaopeng
/
sdk-hwV1.3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
sdk-hwV1.3/external/eyesee-mpp/system/private/rtsp/liveMedia/MatroskaFile.cpp

887 lines
33 KiB
C++
Executable File
Raw Blame History

/**********
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 2.1 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-2016 Live Networks, Inc. All rights reserved.
// A class that encapsulates a Matroska file.
// Implementation
#include "MatroskaFileParser.hh"
#include "MatroskaDemuxedTrack.hh"
#include <ByteStreamFileSource.hh>
#include <H264VideoStreamDiscreteFramer.hh>
#include <H265VideoStreamDiscreteFramer.hh>
#include <MPEG1or2AudioRTPSink.hh>
#include <MPEG4GenericRTPSink.hh>
#include <AC3AudioRTPSink.hh>
#include <SimpleRTPSink.hh>
#include <VorbisAudioRTPSink.hh>
#include <H264VideoRTPSink.hh>
#include <H265VideoRTPSink.hh>
#include <VP8VideoRTPSink.hh>
#include <VP9VideoRTPSink.hh>
#include <TheoraVideoRTPSink.hh>
#include <T140TextRTPSink.hh>
////////// CuePoint definition //////////
class CuePoint {
public:
CuePoint(double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster/* 1-based */);
virtual ~CuePoint();
static void addCuePoint(CuePoint*& root, double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster/* 1-based */,
Boolean& needToReviseBalanceOfParent);
// If "cueTime" == "root.fCueTime", replace the existing data, otherwise add to the left or right subtree.
// (Note that this is a static member function because - as a result of tree rotation - "root" might change.)
Boolean lookup(double& cueTime, u_int64_t& resultClusterOffsetInFile, unsigned& resultBlockNumWithinCluster);
static void fprintf(FILE* fid, CuePoint* cuePoint); // used for debugging; it's static to allow for "cuePoint == NULL"
private:
// The "CuePoint" tree is implemented as an AVL Tree, to keep it balanced (for efficient lookup).
CuePoint* fSubTree[2]; // 0 => left; 1 => right
CuePoint* left() const { return fSubTree[0]; }
CuePoint* right() const { return fSubTree[1]; }
char fBalance; // height of right subtree - height of left subtree
static void rotate(unsigned direction/*0 => left; 1 => right*/, CuePoint*& root); // used to keep the tree in balance
double fCueTime;
u_int64_t fClusterOffsetInFile;
unsigned fBlockNumWithinCluster; // 0-based
};
UsageEnvironment& operator<<(UsageEnvironment& env, const CuePoint* cuePoint); // used for debugging
////////// MatroskaTrackTable definition /////////
// For looking up and iterating over the file's tracks:
class MatroskaTrackTable {
public:
MatroskaTrackTable();
virtual ~MatroskaTrackTable();
void add(MatroskaTrack* newTrack, unsigned trackNumber);
MatroskaTrack* lookup(unsigned trackNumber);
unsigned numTracks() const;
class Iterator {
public:
Iterator(MatroskaTrackTable& ourTable);
virtual ~Iterator();
MatroskaTrack* next();
private:
HashTable::Iterator* fIter;
};
private:
friend class Iterator;
HashTable* fTable;
};
////////// MatroskaFile implementation //////////
void MatroskaFile
::createNew(UsageEnvironment& env, char const* fileName, onCreationFunc* onCreation, void* onCreationClientData,
char const* preferredLanguage) {
new MatroskaFile(env, fileName, onCreation, onCreationClientData, preferredLanguage);
}
MatroskaFile::MatroskaFile(UsageEnvironment& env, char const* fileName, onCreationFunc* onCreation, void* onCreationClientData,
char const* preferredLanguage)
: Medium(env),
fFileName(strDup(fileName)), fOnCreation(onCreation), fOnCreationClientData(onCreationClientData),
fPreferredLanguage(strDup(preferredLanguage)),
fTimecodeScale(1000000), fSegmentDuration(0.0), fSegmentDataOffset(0), fClusterOffset(0), fCuesOffset(0), fCuePoints(NULL),
fChosenVideoTrackNumber(0), fChosenAudioTrackNumber(0), fChosenSubtitleTrackNumber(0) {
fTrackTable = new MatroskaTrackTable;
fDemuxesTable = HashTable::create(ONE_WORD_HASH_KEYS);
FramedSource* inputSource = ByteStreamFileSource::createNew(envir(), fileName);
if (inputSource == NULL) {
// The specified input file does not exist!
fParserForInitialization = NULL;
handleEndOfTrackHeaderParsing(); // we have no file, and thus no tracks, but we still need to signal this
} else {
// Initialize ourselves by parsing the file's 'Track' headers:
fParserForInitialization = new MatroskaFileParser(*this, inputSource, handleEndOfTrackHeaderParsing, this, NULL);
}
}
MatroskaFile::~MatroskaFile() {
delete fParserForInitialization;
delete fCuePoints;
// Delete any outstanding "MatroskaDemux"s, and the table for them:
MatroskaDemux* demux;
while ((demux = (MatroskaDemux*)fDemuxesTable->RemoveNext()) != NULL) {
delete demux;
}
delete fDemuxesTable;
delete fTrackTable;
delete[] (char*)fPreferredLanguage;
delete[] (char*)fFileName;
}
void MatroskaFile::handleEndOfTrackHeaderParsing(void* clientData) {
((MatroskaFile*)clientData)->handleEndOfTrackHeaderParsing();
}
class TrackChoiceRecord {
public:
unsigned trackNumber;
u_int8_t trackType;
unsigned choiceFlags;
};
void MatroskaFile::handleEndOfTrackHeaderParsing() {
// Having parsed all of our track headers, iterate through the tracks to figure out which ones should be played.
// The Matroska 'specification' is rather imprecise about this (as usual). However, we use the following algorithm:
// - Use one (but no more) enabled track of each type (video, audio, subtitle). (Ignore all tracks that are not 'enabled'.)
// - For each track type, choose the one that's 'forced'.
// - If more than one is 'forced', choose the first one that matches our preferred language, or the first if none matches.
// - If none is 'forced', choose the one that's 'default'.
// - If more than one is 'default', choose the first one that matches our preferred language, or the first if none matches.
// - If none is 'default', choose the first one that matches our preferred language, or the first if none matches.
unsigned numTracks = fTrackTable->numTracks();
if (numTracks > 0) {
TrackChoiceRecord* trackChoice = new TrackChoiceRecord[numTracks];
unsigned numEnabledTracks = 0;
MatroskaTrackTable::Iterator iter(*fTrackTable);
MatroskaTrack* track;
while ((track = iter.next()) != NULL) {
if (!track->isEnabled || track->trackType == 0 || track->mimeType[0] == '\0') continue; // track not enabled, or not fully-defined
trackChoice[numEnabledTracks].trackNumber = track->trackNumber;
trackChoice[numEnabledTracks].trackType = track->trackType;
// Assign flags for this track so that, when sorted, the largest value becomes our choice:
unsigned choiceFlags = 0;
if (fPreferredLanguage != NULL && track->language != NULL && strcmp(fPreferredLanguage, track->language) == 0) {
// This track matches our preferred language:
choiceFlags |= 1;
}
if (track->isForced) {
choiceFlags |= 4;
} else if (track->isDefault) {
choiceFlags |= 2;
}
trackChoice[numEnabledTracks].choiceFlags = choiceFlags;
++numEnabledTracks;
}
// Choose the desired track for each track type:
for (u_int8_t trackType = 0x01; trackType != MATROSKA_TRACK_TYPE_OTHER; trackType <<= 1) {
int bestNum = -1;
int bestChoiceFlags = -1;
for (unsigned i = 0; i < numEnabledTracks; ++i) {
if (trackChoice[i].trackType == trackType && (int)trackChoice[i].choiceFlags > bestChoiceFlags) {
bestNum = i;
bestChoiceFlags = (int)trackChoice[i].choiceFlags;
}
}
if (bestChoiceFlags >= 0) { // There is a track for this track type
if (trackType == MATROSKA_TRACK_TYPE_VIDEO) fChosenVideoTrackNumber = trackChoice[bestNum].trackNumber;
else if (trackType == MATROSKA_TRACK_TYPE_AUDIO) fChosenAudioTrackNumber = trackChoice[bestNum].trackNumber;
else fChosenSubtitleTrackNumber = trackChoice[bestNum].trackNumber;
}
}
delete[] trackChoice;
}
#ifdef DEBUG
if (fChosenVideoTrackNumber > 0) fprintf(stderr, "Chosen video track: #%d\n", fChosenVideoTrackNumber); else fprintf(stderr, "No chosen video track\n");
if (fChosenAudioTrackNumber > 0) fprintf(stderr, "Chosen audio track: #%d\n", fChosenAudioTrackNumber); else fprintf(stderr, "No chosen audio track\n");
if (fChosenSubtitleTrackNumber > 0) fprintf(stderr, "Chosen subtitle track: #%d\n", fChosenSubtitleTrackNumber); else fprintf(stderr, "No chosen subtitle track\n");
#endif
// Delete our parser, because it's done its job now:
delete fParserForInitialization; fParserForInitialization = NULL;
// Finally, signal our caller that we've been created and initialized:
if (fOnCreation != NULL) (*fOnCreation)(this, fOnCreationClientData);
}
MatroskaTrack* MatroskaFile::lookup(unsigned trackNumber) const {
return fTrackTable->lookup(trackNumber);
}
MatroskaDemux* MatroskaFile::newDemux() {
MatroskaDemux* demux = new MatroskaDemux(*this);
fDemuxesTable->Add((char const*)demux, demux);
return demux;
}
void MatroskaFile::removeDemux(MatroskaDemux* demux) {
fDemuxesTable->Remove((char const*)demux);
}
float MatroskaFile::fileDuration() {
if (fCuePoints == NULL) return 0.0; // Hack, because the RTSP server code assumes that duration > 0 => seekable. (fix this) #####
return segmentDuration()*(timecodeScale()/1000000000.0f);
}
FramedSource* MatroskaFile
::createSourceForStreaming(FramedSource* baseSource, unsigned trackNumber,
unsigned& estBitrate, unsigned& numFiltersInFrontOfTrack) {
if (baseSource == NULL) return NULL;
FramedSource* result = baseSource; // by default
estBitrate = 100; // by default
numFiltersInFrontOfTrack = 0; // by default
// Look at the track's MIME type to set its estimated bitrate (for use by RTCP).
// (Later, try to be smarter about figuring out the bitrate.) #####
// Some MIME types also require adding a special 'framer' in front of the source.
MatroskaTrack* track = lookup(trackNumber);
if (track != NULL) { // should always be true
if (strcmp(track->mimeType, "audio/MPEG") == 0) {
estBitrate = 128;
} else if (strcmp(track->mimeType, "audio/AAC") == 0) {
estBitrate = 96;
} else if (strcmp(track->mimeType, "audio/AC3") == 0) {
estBitrate = 48;
} else if (strcmp(track->mimeType, "audio/VORBIS") == 0) {
estBitrate = 96;
} else if (strcmp(track->mimeType, "video/H264") == 0) {
estBitrate = 500;
// Allow for the possibility of very large NAL units being fed to the sink object:
OutPacketBuffer::increaseMaxSizeTo(300000); // bytes
// Add a framer in front of the source:
result = H264VideoStreamDiscreteFramer::createNew(envir(), result);
++numFiltersInFrontOfTrack;
} else if (strcmp(track->mimeType, "video/H265") == 0) {
estBitrate = 500;
// Allow for the possibility of very large NAL units being fed to the sink object:
OutPacketBuffer::increaseMaxSizeTo(300000); // bytes
// Add a framer in front of the source:
result = H265VideoStreamDiscreteFramer::createNew(envir(), result);
++numFiltersInFrontOfTrack;
} else if (strcmp(track->mimeType, "video/VP8") == 0) {
estBitrate = 500;
} else if (strcmp(track->mimeType, "video/VP9") == 0) {
estBitrate = 500;
} else if (strcmp(track->mimeType, "video/THEORA") == 0) {
estBitrate = 500;
} else if (strcmp(track->mimeType, "text/T140") == 0) {
estBitrate = 48;
}
}
return result;
}
#define getPrivByte(b) if (n == 0) break; else do {b = *p++; --n;} while (0) /* Vorbis/Theora configuration header parsing */
#define CHECK_PTR if (ptr >= limit) break /* H.264/H.265 parsing */
#define NUM_BYTES_REMAINING (unsigned)(limit - ptr) /* H.264/H.265 parsing */
RTPSink* MatroskaFile
::createRTPSinkForTrackNumber(unsigned trackNumber, Groupsock* rtpGroupsock,
unsigned char rtpPayloadTypeIfDynamic) {
RTPSink* result = NULL; // default value, if an error occurs
do {
MatroskaTrack* track = lookup(trackNumber);
if (track == NULL) break;
if (strcmp(track->mimeType, "audio/L16") == 0) {
result = SimpleRTPSink::createNew(envir(), rtpGroupsock,rtpPayloadTypeIfDynamic, track->samplingFrequency, "audio", "L16", track->numChannels);
} else if (strcmp(track->mimeType, "audio/MPEG") == 0) {
result = MPEG1or2AudioRTPSink::createNew(envir(), rtpGroupsock);
} else if (strcmp(track->mimeType, "audio/AAC") == 0) {
// The Matroska file's 'Codec Private' data is assumed to be the AAC configuration
// information. Use this to generate a hexadecimal 'config' string for the new RTP sink:
char* configStr = new char[2*track->codecPrivateSize + 1]; if (configStr == NULL) break;
// 2 hex digits per byte, plus the trailing '\0'
for (unsigned i = 0; i < track->codecPrivateSize; ++i) {
sprintf(&configStr[2*i], "%02X", track->codecPrivate[i]);
}
result = MPEG4GenericRTPSink::createNew(envir(), rtpGroupsock,
rtpPayloadTypeIfDynamic,
track->samplingFrequency,
"audio", "AAC-hbr", configStr,
track->numChannels);
delete[] configStr;
} else if (strcmp(track->mimeType, "audio/AC3") == 0) {
result = AC3AudioRTPSink
::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic, track->samplingFrequency);
} else if (strcmp(track->mimeType, "audio/OPUS") == 0) {
result = SimpleRTPSink
::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic,
48000, "audio", "OPUS", 2, False/*only 1 Opus 'packet' in each RTP packet*/);
} else if (strcmp(track->mimeType, "audio/VORBIS") == 0 || strcmp(track->mimeType, "video/THEORA") == 0) {
// The Matroska file's 'Codec Private' data is assumed to be the codec configuration
// information, containing the "Identification", "Comment", and "Setup" headers.
// Extract these headers now:
u_int8_t* identificationHeader = NULL; unsigned identificationHeaderSize = 0;
u_int8_t* commentHeader = NULL; unsigned commentHeaderSize = 0;
u_int8_t* setupHeader = NULL; unsigned setupHeaderSize = 0;
Boolean isTheora = strcmp(track->mimeType, "video/THEORA") == 0; // otherwise, Vorbis
do {
u_int8_t* p = track->codecPrivate;
unsigned n = track->codecPrivateSize;
if (n == 0 || p == NULL) break; // we have no 'Codec Private' data
u_int8_t numHeaders;
getPrivByte(numHeaders);
unsigned headerSize[3]; // we don't handle any more than 2+1 headers
// Extract the sizes of each of these headers:
unsigned sizesSum = 0;
Boolean success = True;
unsigned i;
for (i = 0; i < numHeaders && i < 3; ++i) {
unsigned len = 0;
u_int8_t c;
do {
success = False;
getPrivByte(c);
success = True;
len += c;
} while (c == 255);
if (!success || len == 0) break;
headerSize[i] = len;
sizesSum += len;
}
if (!success) break;
// Compute the implicit size of the final header:
if (numHeaders < 3) {
int finalHeaderSize = n - sizesSum;
if (finalHeaderSize <= 0) break; // error in data; give up
headerSize[numHeaders] = (unsigned)finalHeaderSize;
++numHeaders; // include the final header now
} else {
numHeaders = 3; // The maximum number of headers that we handle
}
// Then, extract and classify each header:
for (i = 0; i < numHeaders; ++i) {
success = False;
unsigned newHeaderSize = headerSize[i];
u_int8_t* newHeader = new u_int8_t[newHeaderSize];
if (newHeader == NULL) break;
u_int8_t* hdr = newHeader;
while (newHeaderSize-- > 0) {
success = False;
getPrivByte(*hdr++);
success = True;
}
if (!success) {
delete[] newHeader;
break;
}
u_int8_t headerType = newHeader[0];
if (headerType == 1 || (isTheora && headerType == 0x80)) { // "identification" header
delete[] identificationHeader; identificationHeader = newHeader;
identificationHeaderSize = headerSize[i];
} else if (headerType == 3 || (isTheora && headerType == 0x81)) { // "comment" header
delete[] commentHeader; commentHeader = newHeader;
commentHeaderSize = headerSize[i];
} else if (headerType == 5 || (isTheora && headerType == 0x82)) { // "setup" header
delete[] setupHeader; setupHeader = newHeader;
setupHeaderSize = headerSize[i];
} else {
delete[] newHeader; // because it was a header type that we don't understand
}
}
if (!success) break;
if (isTheora) {
result = TheoraVideoRTPSink
::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic,
identificationHeader, identificationHeaderSize,
commentHeader, commentHeaderSize,
setupHeader, setupHeaderSize);
} else { // Vorbis
result = VorbisAudioRTPSink
::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic,
track->samplingFrequency, track->numChannels,
identificationHeader, identificationHeaderSize,
commentHeader, commentHeaderSize,
setupHeader, setupHeaderSize);
}
} while (0);
delete[] identificationHeader; delete[] commentHeader; delete[] setupHeader;
} else if (strcmp(track->mimeType, "video/H264") == 0) {
// Use our track's 'Codec Private' data: Bytes 5 and beyond contain SPS and PPSs:
u_int8_t* SPS = NULL; unsigned SPSSize = 0;
u_int8_t* PPS = NULL; unsigned PPSSize = 0;
u_int8_t* SPSandPPSBytes = NULL; unsigned numSPSandPPSBytes = 0;
do {
if (track->codecPrivateSize < 6) break;
numSPSandPPSBytes = track->codecPrivateSize - 5;
SPSandPPSBytes = &track->codecPrivate[5];
// Extract, from "SPSandPPSBytes", one SPS NAL unit, and one PPS NAL unit.
// (I hope one is all we need of each.)
unsigned i;
u_int8_t* ptr = SPSandPPSBytes;
u_int8_t* limit = &SPSandPPSBytes[numSPSandPPSBytes];
unsigned numSPSs = (*ptr++)&0x1F; CHECK_PTR;
for (i = 0; i < numSPSs; ++i) {
unsigned spsSize = (*ptr++)<<8; CHECK_PTR;
spsSize |= *ptr++; CHECK_PTR;
if (spsSize > NUM_BYTES_REMAINING) break;
u_int8_t nal_unit_type = ptr[0]&0x1F;
if (SPS == NULL && nal_unit_type == 7/*sanity check*/) { // save the first one
SPSSize = spsSize;
SPS = new u_int8_t[spsSize];
memmove(SPS, ptr, spsSize);
}
ptr += spsSize;
}
unsigned numPPSs = (*ptr++)&0x1F; CHECK_PTR;
for (i = 0; i < numPPSs; ++i) {
unsigned ppsSize = (*ptr++)<<8; CHECK_PTR;
ppsSize |= *ptr++; CHECK_PTR;
if (ppsSize > NUM_BYTES_REMAINING) break;
u_int8_t nal_unit_type = ptr[0]&0x1F;
if (PPS == NULL && nal_unit_type == 8/*sanity check*/) { // save the first one
PPSSize = ppsSize;
PPS = new u_int8_t[ppsSize];
memmove(PPS, ptr, ppsSize);
}
ptr += ppsSize;
}
} while (0);
result = H264VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic,
SPS, SPSSize, PPS, PPSSize);
delete[] SPS; delete[] PPS;
} else if (strcmp(track->mimeType, "video/H265") == 0) {
u_int8_t* VPS = NULL; unsigned VPSSize = 0;
u_int8_t* SPS = NULL; unsigned SPSSize = 0;
u_int8_t* PPS = NULL; unsigned PPSSize = 0;
u_int8_t* VPS_SPS_PPSBytes = NULL; unsigned numVPS_SPS_PPSBytes = 0;
unsigned i;
do {
if (track->codecPrivateUsesH264FormatForH265) {
// The data uses the H.264-style format (but including VPS NAL unit(s)).
// The VPS,SPS,PPS NAL unit information starts at byte #5:
if (track->codecPrivateSize >= 6) {
numVPS_SPS_PPSBytes = track->codecPrivateSize - 5;
VPS_SPS_PPSBytes = &track->codecPrivate[5];
}
} else {
// The data uses the proper H.265-style format.
// The VPS,SPS,PPS NAL unit information starts at byte #22:
if (track->codecPrivateSize >= 23) {
numVPS_SPS_PPSBytes = track->codecPrivateSize - 22;
VPS_SPS_PPSBytes = &track->codecPrivate[22];
}
}
// Extract, from "VPS_SPS_PPSBytes", one VPS NAL unit, one SPS NAL unit, and one PPS NAL unit.
// (I hope one is all we need of each.)
if (numVPS_SPS_PPSBytes == 0 || VPS_SPS_PPSBytes == NULL) break; // sanity check
u_int8_t* ptr = VPS_SPS_PPSBytes;
u_int8_t* limit = &VPS_SPS_PPSBytes[numVPS_SPS_PPSBytes];
if (track->codecPrivateUsesH264FormatForH265) {
// The data uses the H.264-style format (but including VPS NAL unit(s)).
while (NUM_BYTES_REMAINING > 0) {
unsigned numNALUnits = (*ptr++)&0x1F; CHECK_PTR;
for (i = 0; i < numNALUnits; ++i) {
unsigned nalUnitLength = (*ptr++)<<8; CHECK_PTR;
nalUnitLength |= *ptr++; CHECK_PTR;
if (nalUnitLength > NUM_BYTES_REMAINING) break;
u_int8_t nal_unit_type = (ptr[0]&0x7E)>>1;
if (nal_unit_type == 32) { // VPS
VPSSize = nalUnitLength;
delete[] VPS; VPS = new u_int8_t[nalUnitLength];
memmove(VPS, ptr, nalUnitLength);
} else if (nal_unit_type == 33) { // SPS
SPSSize = nalUnitLength;
delete[] SPS; SPS = new u_int8_t[nalUnitLength];
memmove(SPS, ptr, nalUnitLength);
} else if (nal_unit_type == 34) { // PPS
PPSSize = nalUnitLength;
delete[] PPS; PPS = new u_int8_t[nalUnitLength];
memmove(PPS, ptr, nalUnitLength);
}
ptr += nalUnitLength;
}
}
} else {
// The data uses the proper H.265-style format.
unsigned numOfArrays = *ptr++; CHECK_PTR;
for (unsigned j = 0; j < numOfArrays; ++j) {
++ptr; CHECK_PTR; // skip the 'array_completeness'|'reserved'|'NAL_unit_type' byte
unsigned numNalus = (*ptr++)<<8; CHECK_PTR;
numNalus |= *ptr++; CHECK_PTR;
for (i = 0; i < numNalus; ++i) {
unsigned nalUnitLength = (*ptr++)<<8; CHECK_PTR;
nalUnitLength |= *ptr++; CHECK_PTR;
if (nalUnitLength > NUM_BYTES_REMAINING) break;
u_int8_t nal_unit_type = (ptr[0]&0x7E)>>1;
if (nal_unit_type == 32) { // VPS
VPSSize = nalUnitLength;
delete[] VPS; VPS = new u_int8_t[nalUnitLength];
memmove(VPS, ptr, nalUnitLength);
} else if (nal_unit_type == 33) { // SPS
SPSSize = nalUnitLength;
delete[] SPS; SPS = new u_int8_t[nalUnitLength];
memmove(SPS, ptr, nalUnitLength);
} else if (nal_unit_type == 34) { // PPS
PPSSize = nalUnitLength;
delete[] PPS; PPS = new u_int8_t[nalUnitLength];
memmove(PPS, ptr, nalUnitLength);
}
ptr += nalUnitLength;
}
}
}
} while (0);
result = H265VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic,
VPS, VPSSize, SPS, SPSSize, PPS, PPSSize);
delete[] VPS; delete[] SPS; delete[] PPS;
} else if (strcmp(track->mimeType, "video/VP8") == 0) {
result = VP8VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
} else if (strcmp(track->mimeType, "video/VP9") == 0) {
result = VP9VideoRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
} else if (strcmp(track->mimeType, "text/T140") == 0) {
result = T140TextRTPSink::createNew(envir(), rtpGroupsock, rtpPayloadTypeIfDynamic);
}
} while (0);
return result;
}
void MatroskaFile::addTrack(MatroskaTrack* newTrack, unsigned trackNumber) {
fTrackTable->add(newTrack, trackNumber);
}
void MatroskaFile::addCuePoint(double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster) {
Boolean dummy = False; // not used
CuePoint::addCuePoint(fCuePoints, cueTime, clusterOffsetInFile, blockNumWithinCluster, dummy);
}
Boolean MatroskaFile::lookupCuePoint(double& cueTime, u_int64_t& resultClusterOffsetInFile, unsigned& resultBlockNumWithinCluster) {
if (fCuePoints == NULL) return False;
(void)fCuePoints->lookup(cueTime, resultClusterOffsetInFile, resultBlockNumWithinCluster);
return True;
}
void MatroskaFile::printCuePoints(FILE* fid) {
CuePoint::fprintf(fid, fCuePoints);
}
////////// MatroskaTrackTable implementation //////////
MatroskaTrackTable::MatroskaTrackTable()
: fTable(HashTable::create(ONE_WORD_HASH_KEYS)) {
}
MatroskaTrackTable::~MatroskaTrackTable() {
// Remove and delete all of our "MatroskaTrack" descriptors, and the hash table itself:
MatroskaTrack* track;
while ((track = (MatroskaTrack*)fTable->RemoveNext()) != NULL) {
delete track;
}
delete fTable;
}
void MatroskaTrackTable::add(MatroskaTrack* newTrack, unsigned trackNumber) {
if (newTrack != NULL && newTrack->trackNumber != 0) fTable->Remove((char const*)newTrack->trackNumber);
MatroskaTrack* existingTrack = (MatroskaTrack*)fTable->Add((char const*)trackNumber, newTrack);
delete existingTrack; // in case it wasn't NULL
}
MatroskaTrack* MatroskaTrackTable::lookup(unsigned trackNumber) {
return (MatroskaTrack*)fTable->Lookup((char const*)trackNumber);
}
unsigned MatroskaTrackTable::numTracks() const { return fTable->numEntries(); }
MatroskaTrackTable::Iterator::Iterator(MatroskaTrackTable& ourTable) {
fIter = HashTable::Iterator::create(*(ourTable.fTable));
}
MatroskaTrackTable::Iterator::~Iterator() {
delete fIter;
}
MatroskaTrack* MatroskaTrackTable::Iterator::next() {
char const* key;
return (MatroskaTrack*)fIter->next(key);
}
////////// MatroskaTrack implementation //////////
MatroskaTrack::MatroskaTrack()
: trackNumber(0/*not set*/), trackType(0/*unknown*/),
isEnabled(True), isDefault(True), isForced(False),
defaultDuration(0),
name(NULL), language(NULL), codecID(NULL),
samplingFrequency(0), numChannels(2), mimeType(""),
codecPrivateSize(0), codecPrivate(NULL),
codecPrivateUsesH264FormatForH265(False), codecIsOpus(False),
headerStrippedBytesSize(0), headerStrippedBytes(NULL),
subframeSizeSize(0) {
}
MatroskaTrack::~MatroskaTrack() {
delete[] name; delete[] language; delete[] codecID;
delete[] codecPrivate;
delete[] headerStrippedBytes;
}
////////// MatroskaDemux implementation //////////
MatroskaDemux::MatroskaDemux(MatroskaFile& ourFile)
: Medium(ourFile.envir()),
fOurFile(ourFile), fDemuxedTracksTable(HashTable::create(ONE_WORD_HASH_KEYS)),
fNextTrackTypeToCheck(0x1) {
fOurParser = new MatroskaFileParser(ourFile, ByteStreamFileSource::createNew(envir(), ourFile.fileName()),
handleEndOfFile, this, this);
}
MatroskaDemux::~MatroskaDemux() {
// Begin by acting as if we've reached the end of the source file. This should cause all of our demuxed tracks to get closed.
handleEndOfFile();
// Then delete our table of "MatroskaDemuxedTrack"s
// - but not the "MatroskaDemuxedTrack"s themselves; that should have already happened:
delete fDemuxedTracksTable;
delete fOurParser;
fOurFile.removeDemux(this);
}
FramedSource* MatroskaDemux::newDemuxedTrack() {
unsigned dummyResultTrackNumber;
return newDemuxedTrack(dummyResultTrackNumber);
}
FramedSource* MatroskaDemux::newDemuxedTrack(unsigned& resultTrackNumber) {
FramedSource* result;
resultTrackNumber = 0;
for (result = NULL; result == NULL && fNextTrackTypeToCheck != MATROSKA_TRACK_TYPE_OTHER;
fNextTrackTypeToCheck <<= 1) {
if (fNextTrackTypeToCheck == MATROSKA_TRACK_TYPE_VIDEO) resultTrackNumber = fOurFile.chosenVideoTrackNumber();
else if (fNextTrackTypeToCheck == MATROSKA_TRACK_TYPE_AUDIO) resultTrackNumber = fOurFile.chosenAudioTrackNumber();
else if (fNextTrackTypeToCheck == MATROSKA_TRACK_TYPE_SUBTITLE) resultTrackNumber = fOurFile.chosenSubtitleTrackNumber();
result = newDemuxedTrackByTrackNumber(resultTrackNumber);
}
return result;
}
FramedSource* MatroskaDemux::newDemuxedTrackByTrackNumber(unsigned trackNumber) {
if (trackNumber == 0) return NULL;
FramedSource* trackSource = new MatroskaDemuxedTrack(envir(), trackNumber, *this);
fDemuxedTracksTable->Add((char const*)trackNumber, trackSource);
return trackSource;
}
MatroskaDemuxedTrack* MatroskaDemux::lookupDemuxedTrack(unsigned trackNumber) {
return (MatroskaDemuxedTrack*)fDemuxedTracksTable->Lookup((char const*)trackNumber);
}
void MatroskaDemux::removeTrack(unsigned trackNumber) {
fDemuxedTracksTable->Remove((char const*)trackNumber);
if (fDemuxedTracksTable->numEntries() == 0) {
// We no longer have any demuxed tracks, so delete ourselves now:
Medium::close(this);
}
}
void MatroskaDemux::continueReading() {
fOurParser->continueParsing();
}
void MatroskaDemux::seekToTime(double& seekNPT) {
if (fOurParser != NULL) fOurParser->seekToTime(seekNPT);
}
void MatroskaDemux::handleEndOfFile(void* clientData) {
((MatroskaDemux*)clientData)->handleEndOfFile();
}
void MatroskaDemux::handleEndOfFile() {
// Iterate through all of our 'demuxed tracks', handling 'end of input' on each one.
// Hack: Because this can cause the hash table to get modified underneath us, we don't call the handlers until after we've
// first iterated through all of the tracks.
unsigned numTracks = fDemuxedTracksTable->numEntries();
if (numTracks == 0) return;
MatroskaDemuxedTrack** tracks = new MatroskaDemuxedTrack*[numTracks];
HashTable::Iterator* iter = HashTable::Iterator::create(*fDemuxedTracksTable);
unsigned i;
char const* trackNumber;
for (i = 0; i < numTracks; ++i) {
tracks[i] = (MatroskaDemuxedTrack*)iter->next(trackNumber);
}
delete iter;
for (i = 0; i < numTracks; ++i) {
if (tracks[i] == NULL) continue; // sanity check; shouldn't happen
tracks[i]->handleClosure();
}
delete[] tracks;
}
////////// CuePoint implementation //////////
CuePoint::CuePoint(double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster)
: fBalance(0),
fCueTime(cueTime), fClusterOffsetInFile(clusterOffsetInFile), fBlockNumWithinCluster(blockNumWithinCluster - 1) {
fSubTree[0] = fSubTree[1] = NULL;
}
CuePoint::~CuePoint() {
delete fSubTree[0]; delete fSubTree[1];
}
void CuePoint::addCuePoint(CuePoint*& root, double cueTime, u_int64_t clusterOffsetInFile, unsigned blockNumWithinCluster,
Boolean& needToReviseBalanceOfParent) {
needToReviseBalanceOfParent = False; // by default; may get changed below
if (root == NULL) {
root = new CuePoint(cueTime, clusterOffsetInFile, blockNumWithinCluster);
needToReviseBalanceOfParent = True;
} else if (cueTime == root->fCueTime) {
// Replace existing data:
root->fClusterOffsetInFile = clusterOffsetInFile;
root->fBlockNumWithinCluster = blockNumWithinCluster - 1;
} else {
// Add to our left or right subtree:
int direction = cueTime > root->fCueTime; // 0 (left) or 1 (right)
Boolean needToReviseOurBalance = False;
addCuePoint(root->fSubTree[direction], cueTime, clusterOffsetInFile, blockNumWithinCluster, needToReviseOurBalance);
if (needToReviseOurBalance) {
// We need to change our 'balance' number, perhaps while also performing a rotation to bring ourself back into balance:
if (root->fBalance == 0) {
// We were balanced before, but now we're unbalanced (by 1) on the "direction" side:
root->fBalance = -1 + 2*direction; // -1 for "direction" 0; 1 for "direction" 1
needToReviseBalanceOfParent = True;
} else if (root->fBalance == 1 - 2*direction) { // 1 for "direction" 0; -1 for "direction" 1
// We were unbalanced (by 1) on the side opposite to where we added an entry, so now we're balanced:
root->fBalance = 0;
} else {
// We were unbalanced (by 1) on the side where we added an entry, so now we're unbalanced by 2, and have to rebalance:
if (root->fSubTree[direction]->fBalance == -1 + 2*direction) { // -1 for "direction" 0; 1 for "direction" 1
// We're 'doubly-unbalanced' on this side, so perform a single rotation in the opposite direction:
root->fBalance = root->fSubTree[direction]->fBalance = 0;
rotate(1-direction, root);
} else {
// This is the Left-Right case (for "direction" 0) or the Right-Left case (for "direction" 1); perform two rotations:
char newParentCurBalance = root->fSubTree[direction]->fSubTree[1-direction]->fBalance;
if (newParentCurBalance == 1 - 2*direction) { // 1 for "direction" 0; -1 for "direction" 1
root->fBalance = 0;
root->fSubTree[direction]->fBalance = -1 + 2*direction; // -1 for "direction" 0; 1 for "direction" 1
} else if (newParentCurBalance == 0) {
root->fBalance = 0;
root->fSubTree[direction]->fBalance = 0;
} else {
root->fBalance = 1 - 2*direction; // 1 for "direction" 0; -1 for "direction" 1
root->fSubTree[direction]->fBalance = 0;
}
rotate(direction, root->fSubTree[direction]);
root->fSubTree[direction]->fBalance = 0; // the new root will be balanced
rotate(1-direction, root);
}
}
}
}
}
Boolean CuePoint::lookup(double& cueTime, u_int64_t& resultClusterOffsetInFile, unsigned& resultBlockNumWithinCluster) {
if (cueTime < fCueTime) {
if (left() == NULL) {
resultClusterOffsetInFile = 0;
resultBlockNumWithinCluster = 0;
return False;
} else {
return left()->lookup(cueTime, resultClusterOffsetInFile, resultBlockNumWithinCluster);
}
} else {
if (right() == NULL || !right()->lookup(cueTime, resultClusterOffsetInFile, resultBlockNumWithinCluster)) {
// Use this record:
cueTime = fCueTime;
resultClusterOffsetInFile = fClusterOffsetInFile;
resultBlockNumWithinCluster = fBlockNumWithinCluster;
}
return True;
}
}
void CuePoint::fprintf(FILE* fid, CuePoint* cuePoint) {
if (cuePoint != NULL) {
::fprintf(fid, "[");
fprintf(fid, cuePoint->left());
::fprintf(fid, ",%.1f{%d},", cuePoint->fCueTime, cuePoint->fBalance);
fprintf(fid, cuePoint->right());
::fprintf(fid, "]");
}
}
void CuePoint::rotate(unsigned direction/*0 => left; 1 => right*/, CuePoint*& root) {
CuePoint* pivot = root->fSubTree[1-direction]; // ASSERT: pivot != NULL
root->fSubTree[1-direction] = pivot->fSubTree[direction];
pivot->fSubTree[direction] = root;
root = pivot;
}
Reference in New Issue View Git Blame Copy Permalink