From 4eaf011277fee98350c907bd93271ad90547897f Mon Sep 17 00:00:00 2001 From: dwsinger Date: Mon, 30 Sep 2019 15:13:15 -0700 Subject: [PATCH 01/55] Add compact samples to group --- IsoLib/favs_example/src/demux_main.c | 4 +- IsoLib/favs_example/src/hevc.c | 4 +- IsoLib/favs_example/src/mux_main.c | 10 +- IsoLib/libisomediafile/CMakeLists.txt | 1 + .../src/CompactSampleToGroupAtom.c | 741 ++++++++++++++++++ IsoLib/libisomediafile/src/MP4Atoms.c | 6 + IsoLib/libisomediafile/src/MP4Atoms.h | 50 +- IsoLib/libisomediafile/src/MP4Media.c | 25 +- IsoLib/libisomediafile/src/MP4Movies.h | 5 +- IsoLib/libisomediafile/src/MediaAtom.c | 2 +- .../src/MediaInformationAtom.c | 4 +- IsoLib/libisomediafile/src/SampleTableAtom.c | 100 ++- .../libisomediafile/src/TrackFragmentAtom.c | 95 ++- isofile.doc | Bin 269824 -> 258560 bytes 14 files changed, 989 insertions(+), 58 deletions(-) create mode 100644 IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c diff --git a/IsoLib/favs_example/src/demux_main.c b/IsoLib/favs_example/src/demux_main.c index b5c5a8b..11f0ff1 100644 --- a/IsoLib/favs_example/src/demux_main.c +++ b/IsoLib/favs_example/src/demux_main.c @@ -69,7 +69,7 @@ ISOErr playMyMovie(struct ParamStruct *parameters, char *filename) { err = ISONewHandle(1, &sampleEntryH); if (err) goto bail; err = ISONewHandle(1, &alst_desc); if (err) goto bail; - err = ISOOpenMovieFile(&moov, filename, MP4OpenMovieNormal); if (err) goto bail; + err = ISOOpenMovieFile(&moov, filename, MP4OpenMovieDebug); if (err) goto bail; err = MP4GetMovieTrackCount(moov, &trackCount); if (err) goto bail; printf("trackCount: %d\r\n", trackCount); @@ -340,4 +340,4 @@ int main(int argc, char* argv[]) cleanParameters(¶meters); return 1; -} \ No newline at end of file +} diff --git a/IsoLib/favs_example/src/hevc.c b/IsoLib/favs_example/src/hevc.c index 302648a..d4c9f08 100644 --- a/IsoLib/favs_example/src/hevc.c +++ b/IsoLib/favs_example/src/hevc.c @@ -654,7 +654,7 @@ struct hevc_sps* sps, struct hevc_pps* pps) { if ((pps->weighted_pred_flag && header->slice_type == SLICE_P) || (pps->weighted_bipred_flag && header->slice_type == SLICE_B)) { printf("pred_weight_table() not implemented!\r\n"); - assert(0); + //assert(0); exit(1); /* pred_weight_table()*/ } @@ -995,4 +995,4 @@ ISOErr analyze_hevc_stream(FILE* input, struct hevc_stream* stream) { bail: return err; -} \ No newline at end of file +} diff --git a/IsoLib/favs_example/src/mux_main.c b/IsoLib/favs_example/src/mux_main.c index fecc5c2..50acd3a 100644 --- a/IsoLib/favs_example/src/mux_main.c +++ b/IsoLib/favs_example/src/mux_main.c @@ -30,7 +30,7 @@ derivative works. Copyright (c) 1999. #include "tools.h" MP4_EXTERN(MP4Err) ISOAddGroupDescription(MP4Media media, u32 groupType, MP4Handle description, u32* index); -MP4_EXTERN(MP4Err) ISOMapSamplestoGroup(MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count); +MP4_EXTERN(MP4Err) ISOMapSamplestoGroup(MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples); MP4_EXTERN(MP4Err) ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, @@ -155,7 +155,7 @@ static ISOErr addNaluSamples(FILE* input, ISOTrack trak, ISOMedia media, u8 trac } else { printf("Unknown NAL: %d\r\n", naltype); - assert(0); + //assert(0); free(data); data = NULL; } } @@ -410,7 +410,7 @@ ISOErr createMyMovie(struct ParamStruct *parameters) { /* Mark RAP frames (CRA/BLA/IDR/IRAP) to the group */ if (stream.header[frameCounter]->first_slice_segment_in_pic_flag && stream.header[frameCounter]->nal_type >= 16 && stream.header[frameCounter]->nal_type <= 23) { - ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc_index, stream.header[frameCounter]->sample_number, 1); + ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc_index, stream.header[frameCounter]->sample_number, 1, 1); } } @@ -466,7 +466,7 @@ ISOErr createMyMovie(struct ParamStruct *parameters) { ((stream.header[frameCounter - 1]->nal_type >= 6 && stream.header[frameCounter - 1]->nal_type <= 9) && (stream.header[frameCounter]->nal_type < 6 || stream.header[frameCounter]->nal_type > 9)) ) { - ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('a', 'l', 's', 't'), alst_desc_index, stream.header[frameCounter]->sample_number, 1); + ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('a', 'l', 's', 't'), alst_desc_index, stream.header[frameCounter]->sample_number, 1, 1); } } MP4DisposeHandle(alst_temp); @@ -548,4 +548,4 @@ int main(int argc, char* argv[]) cleanParameters(¶meters); return 1; -} \ No newline at end of file +} diff --git a/IsoLib/libisomediafile/CMakeLists.txt b/IsoLib/libisomediafile/CMakeLists.txt index 0d96517..47a8236 100644 --- a/IsoLib/libisomediafile/CMakeLists.txt +++ b/IsoLib/libisomediafile/CMakeLists.txt @@ -41,6 +41,7 @@ add_library( src/ChunkOffsetAtom.c src/ClockReferenceMediaHeader.c src/CompatibleSchemeTypeAtom.c + src/CompactSampleToGroupAtom.c src/CompositionToDecodeAtom.c src/CopyrightAtom.c src/DataEntryURLAtom.c diff --git a/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c b/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c new file mode 100644 index 0000000..9a1963e --- /dev/null +++ b/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c @@ -0,0 +1,741 @@ +/* +This software module was originally developed by Apple Computer, Inc. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. +ISO/IEC gives users of MPEG-4 free license to this +software module or modifications thereof for use in hardware +or software products claiming conformance to MPEG-4. +Those intending to use this software module in hardware or software +products are advised that its use may infringe existing patents. +The original developer of this software module and his/her company, +the subsequent editors and their companies, and ISO/IEC have no +liability for use of this software module or modifications thereof +in an implementation. +Copyright is not released for non MPEG-4 conforming +products. Apple Computer, Inc. retains full right to use the code for its own +purpose, assign or donate the code to a third party and to +inhibit third parties from using the code for non +MPEG-4 conforming products. +This copyright notice must be included in all copies or +derivative works. Copyright (c) 1999. +*/ + +#include "MP4Atoms.h" +#include +#include + +#define allocation_size 8192 + +enum { + kMaxPatternLength = 32, + kUpperNibblePresent = 0x8000, +}; + +// PatternTracker is maintained as an array for each sample input. +typedef struct { + u32 patternStart; + u32 patternLength; + u32 sampleCount; + // patternStart at index k, represents the start index of the pattern which helped yield the most efficient way to encode samples from [0, k] inclusive with patternLength, repeated sampleCount times + s32 cumulativeMemoryCost; // cumulativeMemoryCost at index k, represents the memory cost associated with most efficient way to encode samples from [0, k] inclusive. Default considers each sample as a distinct non-pattern + s32 prevEfficientIndex; // prevEfficientIndex at index k, represents the end of the most efficient previous pattern/ non-pattern before k which helped yield the cumulativeMemoryCost at index k. + s32 nextEfficientIndex; // nextEfficientIndex is populated after back-tracking prevEfficientIndex to easily create compact sample groups +} PatternTracker; + + /* + Compacting Algorithm: + 1. Run through sample group set: i=[0,n] + a. Expand the input samples + b. Initialize memory costs in tracker assuming each sample is a distinct non-pattern C[i] = (i*indexFieldSize) + 2. Run through sample group set: i=[0,n] + a. Update memory cost considering sample i is a distinct non-pattern C[i] = min(C[i] , C[i-1]+ indexFieldSize) + b. For pattern lengths, p=[1, 32] + i. Consider patterns ending at i, from [start=i-p, i] in the Search buffer. + ii. Extend right end from [i+1, n] in the look ahead buffer + 1. As long as the pattern repeats, keep extending right end and update memory cost + C[end] = min(C[end] , C[start-1] + p*indexFieldSize + 2. If C[end] got modified, a more efficient pattern was found, maintain previousEfficientIndex = start-1 for backtracking. + 3. Tracker[n-1] represents most efficienct way to encode samples [0,n]. Run through tracker backwards from last sample: i[n-1, 0]. + a. Use previousEfficientIndex to populate nextEfficientIndex to easily create compact sample groups + b. Patterns with (pattern length == sample count == 1), are combined and considered as non-pattern + +Algorithm can further be optimized by making memory cost consider patternLength and sampleCount field sizes + */ + +typedef struct { + u32* groupIndex; + u32 sampleCount; + PatternTracker* patternTracker; + u8 groupIndexFieldSize; +} SampleGroupInfo; + +u8 GetFieldSize(u32 value, u8 localFragmentUsed) +{ + if (localFragmentUsed) { + if (value < 8) { + return 4; + } else if (value < 128) { + return 8; + } else if (value < 32768) { + return 16; + } else { + return 32; + } + } else { + if (value < 16) { + return 4; + } else if (value < 256) { + return 8; + } else if (value < 65536) { + return 16; + } else { + return 32; + } + } +} + +u8 SetFieldSize(u32 fieldSize) +{ + assert(fieldSize == 4 || fieldSize == 8 || fieldSize == 16 || fieldSize == 32); + switch(fieldSize) + { + case 4: + return 0; + break; + case 8: + return 1; + break; + case 16: + return 2; + break; + case 32: + return 3; + break; + }; + return 0; +} + +void AppendDescriptionIndexToCompactGroup(CompressedGroupInfo* compressedGroup, u32 descIndex, u32 groupIndex) +{ + assert(descIndex < compressedGroup->totalIndexDescriptionCount); + compressedGroup->indexDescriptionArray[descIndex] = groupIndex; +} + +void AppendNewPatternEntry(CompressedGroupInfo* compressedGroup, u32 index, u32 patternLength, u32 sampleCount) +{ + assert(patternLength != 0); + assert(sampleCount != 0); + assert(index < compressedGroup->patternCount); + //printf("\n New pattern: length %d sampleCount %d", patternLength, sampleCount); + + compressedGroup->patternEntries[index].patternLength = patternLength; + compressedGroup->patternEntries[index].sampleCount = sampleCount; + compressedGroup->totalSampleCount += sampleCount; +} + +void SetMemoryCostForPattern(SampleGroupInfo *sampleGroup, u32 patternLength, u32 startPatternSampleIndex, u32 endPatternSampleIndex) +{ + u32 sampleCount = endPatternSampleIndex - startPatternSampleIndex + 1; + + assert(startPatternSampleIndex + patternLength <= endPatternSampleIndex); + + s32 memoryCost = startPatternSampleIndex <= 0 ? sampleGroup->patternTracker[0].cumulativeMemoryCost : sampleGroup->patternTracker[startPatternSampleIndex - 1].cumulativeMemoryCost; + memoryCost += (patternLength * sampleGroup->groupIndexFieldSize); + + if(memoryCost < sampleGroup->patternTracker[endPatternSampleIndex].cumulativeMemoryCost) { + PatternTracker patTrack; + patTrack.patternStart = startPatternSampleIndex; + patTrack.patternLength = patternLength; + patTrack.sampleCount = sampleCount; + patTrack.cumulativeMemoryCost = memoryCost; + patTrack.prevEfficientIndex = startPatternSampleIndex - 1; + + sampleGroup->patternTracker[endPatternSampleIndex] = patTrack; + //printf("\n Pattern run of pattern length %d, sample count %d, starting @ %3d with memoryCost %d and prevMostEffIndex %d", patternLength, sampleCount, startPatternSampleIndex, patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex); + } +} + +void SetMemoryCostForNonPattern(SampleGroupInfo *sampleGroup, s32 sampleIndex) +{ + s32 memoryCost = (sampleIndex < 1 ? sampleGroup->patternTracker[0].cumulativeMemoryCost: sampleGroup->patternTracker[sampleIndex-1].cumulativeMemoryCost) + sampleGroup->groupIndexFieldSize; + + if(memoryCost < sampleGroup->patternTracker[sampleIndex].cumulativeMemoryCost) { + PatternTracker patTrack; + patTrack.patternStart = sampleIndex; + patTrack.patternLength = 1; + patTrack.sampleCount = 1; + patTrack.cumulativeMemoryCost = memoryCost; + patTrack.prevEfficientIndex = sampleIndex-1; + + sampleGroup->patternTracker[sampleIndex] = patTrack; + //printf("\n Writing non-pattern with memoryCost %d and prevMostEffIndex %d ", patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex); + } +} + +void CombineNonPatterns(SampleGroupInfo *sampleGroup, CompressedGroupInfo* compressedGroup) +{ + s32 prevIndex = sampleGroup->sampleCount -1; + s32 nextIndex = sampleGroup->sampleCount; + PatternTracker* patternTracker = sampleGroup->patternTracker; + + // Post-process output pattern tracker. Get Pattern Count, Populate the nextIndex to navigate easily + while(prevIndex >= 0 && prevIndex < sampleGroup->sampleCount) + { + u32 consecutiveNonPatterns = 0; + s32 i = prevIndex; + while(i >= 0 && i < sampleGroup->sampleCount && (patternTracker[i].patternLength == 1) && (patternTracker[i].sampleCount == 1)) + { + consecutiveNonPatterns++; + i = patternTracker[i].prevEfficientIndex; + } + if(consecutiveNonPatterns) { + patternTracker[prevIndex].patternLength = consecutiveNonPatterns; + patternTracker[prevIndex].sampleCount = consecutiveNonPatterns; + patternTracker[prevIndex].patternStart -= (consecutiveNonPatterns - 1); + compressedGroup->totalIndexDescriptionCount += consecutiveNonPatterns; + patternTracker[prevIndex].prevEfficientIndex = i; + } + else { + compressedGroup->totalIndexDescriptionCount += patternTracker[prevIndex].patternLength; + } + + patternTracker[prevIndex].nextEfficientIndex = nextIndex; + nextIndex = prevIndex; + prevIndex = patternTracker[prevIndex].prevEfficientIndex; + + compressedGroup->patternCount++; + } + compressedGroup->efficientStartIndex = nextIndex; +} + +void FindPatternsStartingAtIndex(SampleGroupInfo *sampleGroup, u32 sampleIndex) +{ + assert(sampleIndex < sampleGroup->sampleCount); + + // Update memoryCost in case current sample is considered as a non-pattern + SetMemoryCostForNonPattern(sampleGroup, sampleIndex); + + for (u32 p = 1; p <= kMaxPatternLength; p++) + { + if(sampleIndex < p) + break; + + if (sampleGroup->groupIndex[sampleIndex] == sampleGroup->groupIndex[sampleIndex - p]) { + u32 startPatternSampleIndex = sampleIndex - p; + u32 i = sampleIndex; + while (i < sampleGroup->sampleCount && sampleGroup->groupIndex[i] == sampleGroup->groupIndex[i - p]) { + SetMemoryCostForPattern(sampleGroup, p, startPatternSampleIndex, i); + i++; + } + + // Pattern ended at i - 1. + //printf("\n %3d: pattern run ended", i-1); + //break; // out of for loop + } + } +} + +void InitializeSampleGroupInput(MP4CompactSampletoGroupAtomPtr self, SampleGroupInfo* sampleGroup) +{ + sampleGroup->groupIndex = self->group_index; + sampleGroup->sampleCount = self->sampleCount; + sampleGroup->groupIndexFieldSize = self->compressedGroup.indexFieldSize; + sampleGroup->patternTracker = (PatternTracker*) malloc(sizeof(PatternTracker)*self->sampleCount); + + memset(sampleGroup->patternTracker, 0, sizeof(PatternTracker)*self->sampleCount); + + // Expand sample group indices, get maximum field size to represent each group index + u32 startValue = self->group_index[0]; + + for(u32 i = 1; i < self->sampleCount; i++) { + if(self->group_index[i-1] == self->group_index[i]) { + self->group_index[i-1] = startValue; + } + else { + startValue = self->group_index[i]; + } + } + self->group_index[self->sampleCount-1] = startValue; + + // Initialize efficiencies assuming each input sample is a distinct non-pattern + PatternTracker patternTrackerEntry; + patternTrackerEntry.patternLength = patternTrackerEntry.sampleCount = 1; + + for(u32 i = 0; i < self->sampleCount; i++) { + patternTrackerEntry.patternStart = i; + patternTrackerEntry.prevEfficientIndex = i-1; + patternTrackerEntry.cumulativeMemoryCost = (i+1) * sampleGroup->groupIndexFieldSize; + sampleGroup->patternTracker[i] = patternTrackerEntry; + } +} + +void CreateCompactSampleGroups(MP4CompactSampletoGroupAtomPtr self) +{ + if(self->compressedGroup.isSampleGroupCompressed) + return; + + SampleGroupInfo sampleGroup; + InitializeSampleGroupInput(self, &sampleGroup); + + CompressedGroupInfo* compressedGroup = &self->compressedGroup; + compressedGroup->patternLengthFieldSize = 4; + compressedGroup->sampleCountFieldSize = 4; + compressedGroup->indexFieldSize = sampleGroup.groupIndexFieldSize; + + // Repeatedly process, find and update efficiencies at each sample index + for (u32 j = 0; j < self->sampleCount; j++) { + FindPatternsStartingAtIndex(&sampleGroup, j); + } + + CombineNonPatterns(&sampleGroup, compressedGroup); + + if(compressedGroup->patternEntries == NULL) { + compressedGroup->patternEntries = (MP4CompactSampleToGroupPatternEntryPtr) malloc(sizeof(MP4CompactSampleToGroupPatternEntry)*compressedGroup->patternCount); + } + if(compressedGroup->indexDescriptionArray == NULL) { + compressedGroup->indexDescriptionArray = (u32*) malloc(sizeof(u32)*compressedGroup->totalIndexDescriptionCount); + } + + /*printf("\n The pattern tracker details are"); + for(int i = 0; i < self->sampleCount; i++) + { + printf("\n Index %d Start: %d PL: %d SC: %d Eff: %d PrevIndex: %d NextIndex: %d ", i, patternTracker[i].start, patternTracker[i].patternLength, patternTracker[i].sampleCount, patternTracker[i].cumulativeMemoryCost, patternTracker[i].prevEfficientIndex, patternTracker[i].nextEfficientIndex); + }*/ + + PatternTracker* patternTracker = sampleGroup.patternTracker; + u32 descIndex = 0; + u32 nextIndex = compressedGroup->efficientStartIndex; + for(u32 patternIndex = 0; patternIndex < compressedGroup->patternCount; patternIndex++) { + u32 patternLength = patternTracker[nextIndex].patternLength; + u8 fieldSize = GetFieldSize(patternLength, 0); + if(fieldSize > compressedGroup->patternLengthFieldSize) + compressedGroup->patternLengthFieldSize = fieldSize; + + u32 sampleCount = patternTracker[nextIndex].sampleCount; + fieldSize = GetFieldSize(sampleCount, 0); + if(fieldSize > compressedGroup->sampleCountFieldSize) + compressedGroup->sampleCountFieldSize = fieldSize; + + AppendNewPatternEntry(compressedGroup, patternIndex, patternLength, sampleCount); + + assert(patternTracker[nextIndex].patternStart >= 0 && patternTracker[nextIndex].patternStart < self->sampleCount); + assert(patternTracker[nextIndex].patternStart+patternLength-1 < self->sampleCount); + + for (u32 j = 0; j < patternLength; j++) { + u32 groupIndex = sampleGroup.groupIndex[patternTracker[nextIndex].patternStart + j]; + if(self->fragmentLocalIndexPresent) { + groupIndex = groupIndex | (1 << (self->compressedGroup.indexFieldSize - 1)); + } + AppendDescriptionIndexToCompactGroup(compressedGroup, descIndex, groupIndex); + descIndex++; + } + nextIndex = patternTracker[nextIndex].nextEfficientIndex; + } + + // In case only patternLength or sampleCount field size is 4, ensure pattern entry is always byte aligned + if((compressedGroup->patternLengthFieldSize+compressedGroup->sampleCountFieldSize) % 8) { + if(compressedGroup->patternLengthFieldSize == 4) + compressedGroup->patternLengthFieldSize = 8; + else + compressedGroup->sampleCountFieldSize = 8; + + } + + assert(descIndex == compressedGroup->totalIndexDescriptionCount); + self->compressedGroup.isSampleGroupCompressed = 1; + + free(sampleGroup.patternTracker); + sampleGroup.patternTracker = NULL; +} + +static void destroy( MP4AtomPtr s ) +{ + MP4Err err; + MP4CompactSampletoGroupAtomPtr self; + err = MP4NoErr; + self = (MP4CompactSampletoGroupAtomPtr) s; + if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) + if ( self->group_index != NULL ) { + free( self->group_index ); + self->group_index = NULL; + } + + if(self->compressedGroup.patternEntries != NULL) { + free(self->compressedGroup.patternEntries); + self->compressedGroup.patternEntries = NULL; + } + + if(self->compressedGroup.indexDescriptionArray != NULL) { + free(self->compressedGroup.indexDescriptionArray); + self->compressedGroup.indexDescriptionArray = NULL; + } + if ( self->super ) + self->super->destroy( s ); +bail: + TEST_RETURN( err ); + + return; +} + +static MP4Err ensureSize( struct MP4CompactSampletoGroupAtom *self, u32 newSize ) +{ + MP4Err err; + + err = MP4NoErr; + + if (newSize > self->allocatedSize) { + self->allocatedSize += allocation_size; + if (newSize > self->allocatedSize) self->allocatedSize = newSize; + + if (self->group_index != NULL) + self->group_index = (u32*) realloc( self->group_index, self->allocatedSize ); + else + self->group_index = (u32*) calloc( self->allocatedSize, 1 ); + + TESTMALLOC( self->group_index ); + } + +bail: + TEST_RETURN( err ); + + return err; +} + +static MP4Err addSamples( struct MP4CompactSampletoGroupAtom *self, u32 count ) +{ + MP4Err err; + u32 *p; + u32 j; + + err = MP4NoErr; + err = ensureSize( self, (self->sampleCount + count)*sizeof(u32) ); if (err) goto bail; + + p = &((self->group_index)[self->sampleCount]); + for (j=0; jsampleCount += count; + +bail: + TEST_RETURN( err ); + + return err; +} + +static MP4Err mapSamplestoGroup( struct MP4CompactSampletoGroupAtom *self, u32 group_index, s32 sample_index, u32 count ) +{ + MP4Err err; + u32 i; + u32* p; + + err = MP4NoErr; + + if (sample_index<0) { + p = &((self->group_index)[self->sampleCount + sample_index]); + if (count > ((u32) (- sample_index))) { err = MP4BadParamErr; goto bail; } + } + else { + p = &((self->group_index)[sample_index]); + if (count+sample_index > self->sampleCount) { err = MP4BadParamErr; goto bail; } + } + for (i=0; ifragmentLocalIndexPresent) > self->compressedGroup.indexFieldSize) + self->compressedGroup.indexFieldSize = GetFieldSize(group_index, self->fragmentLocalIndexPresent); + +bail: + TEST_RETURN( err ); + + return err; +} + +static MP4Err getSampleGroupMap( struct MP4CompactSampletoGroupAtom *self, u32 sampleNumber, u32* groupIndex ) +{ + MP4Err err; + + err = MP4NoErr; + + if (sampleNumber<1) BAILWITHERROR( MP4BadParamErr ); + if (sampleNumber > self->sampleCount) + *groupIndex = 0; + else *groupIndex = (self->group_index)[sampleNumber - 1]; + +bail: + TEST_RETURN( err ); + + return err; +} + +static MP4Err GetData(MP4AtomPtr s, MP4InputStreamPtr inputStream, u8 fieldSize, u32* upperNibble, u32* outValue) +{ + MP4Err err = MP4NoErr; + MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr) s; + + if(fieldSize != 4 && fieldSize != 8 && fieldSize != 16 && fieldSize != 32) BAILWITHERROR( MP4BadParamErr ) + + u32 readData = 0; + switch(fieldSize) { + case 4: + if(*upperNibble & kUpperNibblePresent) { + *outValue = *upperNibble & 0xF; + *upperNibble = 0; + } + else { + GET8_V_MSG( readData, NULL ); + *upperNibble = (readData & 0xF) | kUpperNibblePresent; + *outValue = readData >> 4; + } + break; + case 8: + GET8_V_MSG( readData, NULL ); + *outValue = readData; + break; + case 16: + GET16_V_MSG( readData, NULL ); + *outValue = readData; + break; + case 32: + GET32_V_MSG( readData, NULL ); + *outValue = readData; + break; + } +bail: + TEST_RETURN( err ); + + return err; +} + +static MP4Err inline PackData(MP4CompactSampletoGroupAtomPtr self, char** bufferPtr, u8 fieldSize, u8 nonByteBoundary, u32 value) +{ + MP4Err err = MP4NoErr; + u32 previousByte; + char* buffer = *bufferPtr; + if(fieldSize != 4 && fieldSize != 8 && fieldSize != 16 && fieldSize != 32) BAILWITHERROR( MP4BadParamErr ) + + switch(fieldSize) + { + case 4: + // Read the previous byte and append the new nibble to it + if(nonByteBoundary) { + buffer = buffer - 1; + self->bytesWritten -= 1; + previousByte = *(u8*) buffer; + value = previousByte | (value & 0xF); + } + else { + value = value << 4; + } + PUT8_V(value); + break; + case 8: + PUT8_V(value); + break; + case 16: + PUT16_V(value); + break; + case 32: + PUT32_V(value); + break; + } + *bufferPtr = buffer; +bail: + TEST_RETURN( err ); + + return err; +} + +static MP4Err serialize( struct MP4Atom* s, char* buffer ) +{ + MP4Err err = MP4NoErr; + + MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr) s; + + self->flags = SetFieldSize(self->compressedGroup.indexFieldSize) | (SetFieldSize(self->compressedGroup.sampleCountFieldSize) << 2) | (SetFieldSize(self->compressedGroup.patternLengthFieldSize) << 4) | (self->fragmentLocalIndexPresent ? 0x80 : 0); + + err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; + buffer += self->bytesWritten; + + PUT32( grouping_type ); + // Grouping type parameter is disabled. If enabled, will need to pack an additional byte to represent it + PUT32( entryCount ); + + printf (" \n Field sizes of pattern is %d , sampleCount is %d , indexDescription is %d ", self->compressedGroup.patternLengthFieldSize, self->compressedGroup.sampleCountFieldSize, self->compressedGroup.indexFieldSize); + + printf("\n Pattern count %d covering %d total samples ", self->compressedGroup.patternCount, self->compressedGroup.totalSampleCount); + + for(u32 i = 0; i < self->compressedGroup.patternCount; i++) { + printf("\n Pattern length %d for %d samples ", self->compressedGroup.patternEntries[i].patternLength, self->compressedGroup.patternEntries[i].sampleCount); + + // Pattern entry is ensured to start at a byte boundary + PackData(self, &buffer, self->compressedGroup.patternLengthFieldSize, 0, self->compressedGroup.patternEntries[i].patternLength); + + PackData(self, &buffer, self->compressedGroup.sampleCountFieldSize, (self->compressedGroup.patternLengthFieldSize == 4), self->compressedGroup.patternEntries[i].sampleCount); + + } + + // Index descriptor array is ensured to start at a byte boundary + printf("\n Index Descriptors array is: "); + for(u32 i = 0; i < self->compressedGroup.totalIndexDescriptionCount; i++) { + printf(" %d ", self->compressedGroup.indexDescriptionArray[i]); + PackData(self, &buffer, self->compressedGroup.indexFieldSize, (i&1) , self->compressedGroup.indexDescriptionArray[i]); + } + + assert( self->bytesWritten == self->size ); + +bail: + TEST_RETURN( err ); + + return err; +} + +static MP4Err calculateSize( struct MP4Atom* s ) +{ + MP4Err err = MP4NoErr; + MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr) s; + + err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; + + CreateCompactSampleGroups(self); + + // If grouping type parameter is enabled in flags, will need to add an additional byte + self->size += 8; + + u32 sizeInBits = (self->compressedGroup.patternCount*(self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); + sizeInBits += (self->compressedGroup.totalIndexDescriptionCount*self->compressedGroup.indexFieldSize); + self->size = self->size + (sizeInBits+4)/8; + + self->entryCount = self->compressedGroup.patternCount; + +bail: + TEST_RETURN( err ); + + return err; +} + +static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +{ + MP4Err err; + u32 i, j; + u32* p; + u32 flags; + MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr) s; + char typeString[ 8 ]; + char msgString[ 80 ]; + u8 indexFieldSize, countFieldSize, patternFieldSize; + char groupingTypeParamPresent; + + err = MP4NoErr; + if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) + err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; + flags = self->flags; + + indexFieldSize = 4 << ((flags & 0x3) >> 0); + if(indexFieldSize != 4 && indexFieldSize != 8 && indexFieldSize != 16 && indexFieldSize != 32) BAILWITHERROR( MP4BadParamErr ) + + countFieldSize = 4 << ((flags & 0xC) >> 2); + if(countFieldSize != 4 && countFieldSize != 8 && countFieldSize != 16 && countFieldSize != 32) BAILWITHERROR( MP4BadParamErr ) + + patternFieldSize = 4 << ((flags & 0x30) >> 4); + if(patternFieldSize != 4 && patternFieldSize != 8 && patternFieldSize != 16 && patternFieldSize != 32) BAILWITHERROR( MP4BadParamErr ) + + // Ensure each pattern entry is always byte-aligned + if((patternFieldSize + countFieldSize) % 8 ) BAILWITHERROR( MP4BadParamErr ) + + self->fragmentLocalIndexPresent = (flags & 0x80); + groupingTypeParamPresent = (flags & 0x40); + + sprintf( msgString, "field size for index %d , sample count %d pattern length %d ", indexFieldSize, countFieldSize, patternFieldSize ); + inputStream->msg( inputStream, msgString ); + + GET32( grouping_type ); + MP4TypeToString( self->grouping_type, typeString ); + sprintf( msgString, "grouping type is '%s'", typeString ); + inputStream->msg( inputStream, msgString ); + + if(groupingTypeParamPresent) { + GET32( groupingTypeParameter ); + } + + GET32( entryCount ); + + MP4CompactSampleToGroupPatternEntryPtr patternEntries = malloc(self->entryCount* sizeof(MP4CompactSampleToGroupPatternEntry)); + TESTMALLOC( patternEntries ); + u32 upperNibble = 0; + + for (i=0; ientryCount; i++) { + u32 sampleCount, patternLength; + + GetData(s, inputStream, patternFieldSize, &upperNibble, &patternLength); + patternEntries[i].patternLength = patternLength; + + GetData(s, inputStream, countFieldSize, &upperNibble, &sampleCount); + patternEntries[i].sampleCount = sampleCount; + self->sampleCount += sampleCount; + + sprintf( msgString, "pattern entry %d: pattern length->%d sample count->%d ", i+1, patternLength, sampleCount ); + inputStream->msg( inputStream, msgString ); + + } + + err = ensureSize( self, self->sampleCount*sizeof(u32) ); if (err) goto bail; + p = &((self->group_index)[0]); + + sprintf(msgString, "Index description values are:" ); + inputStream->msg( inputStream, msgString ); + for (i=0; ientryCount; i++) { + u32* patternStart = p; + u32 mask = self->fragmentLocalIndexPresent? 0xFFFFFFFF >> (32 - indexFieldSize + 1): 0xFFFFFFFF; + for (j=0; jmsg( inputStream, msgString ); + + free(patternEntries); + patternEntries = NULL; + +bail: + TEST_RETURN( err ); + + return err; +} + +MP4Err MP4CreateCompactSampletoGroupAtom( MP4CompactSampletoGroupAtomPtr *outAtom ) +{ + MP4Err err; + MP4CompactSampletoGroupAtomPtr self; + + self = (MP4CompactSampletoGroupAtomPtr) calloc( 1, sizeof(MP4CompactSampletoGroupAtom) ); + TESTMALLOC( self ) + + err = MP4CreateFullAtom( (MP4AtomPtr) self ); + if ( err ) goto bail; + self->type = MP4CompactSampletoGroupAtomType; + self->name = "compact sample to group"; + self->createFromInputStream = (cisfunc) createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->mapSamplestoGroup = mapSamplestoGroup; + self->addSamples = addSamples; + self->getSampleGroupMap = getSampleGroupMap; + self->group_index = NULL; + self->flags = 0; + self->sampleCount = 0; + self->fragmentLocalIndexPresent = 0; + memset(&self->compressedGroup, 0, sizeof(CompressedGroupInfo)); + + *outAtom = self; +bail: + TEST_RETURN( err ); + + return err; +} diff --git a/IsoLib/libisomediafile/src/MP4Atoms.c b/IsoLib/libisomediafile/src/MP4Atoms.c index 6567006..a521b7e 100755 --- a/IsoLib/libisomediafile/src/MP4Atoms.c +++ b/IsoLib/libisomediafile/src/MP4Atoms.c @@ -39,6 +39,8 @@ #include "MJ2Atoms.h" #endif +MP4Err MP4CreateHEVCConfigAtom(ISOHEVCConfigAtomPtr *outAtom); + static MP4AtomPtr MP4BaseAtomClassPtr = 0; static char* baseAtomGetName( MP4AtomPtr self ) @@ -552,6 +554,10 @@ MP4Err MP4CreateAtom( u32 atomType, MP4AtomPtr *outAtom ) case MP4SampletoGroupAtomType: err = MP4CreateSampletoGroupAtom( (MP4SampletoGroupAtomPtr*) &newAtom ); break; + + case MP4CompactSampletoGroupAtomType: + err = MP4CreateCompactSampletoGroupAtom( (MP4CompactSampletoGroupAtomPtr*) &newAtom ); + break; case ISOMetaAtomType: err = ISOCreateMetaAtom( (ISOMetaAtomPtr *) &newAtom ); diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index f612b47..89b73fe 100755 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -120,6 +120,7 @@ enum MP4ItemPropertyAssociationAtomType = MP4_FOUR_CHAR_CODE( 'i', 'p', 'm', 'a' ), MP4SampleGroupDescriptionAtomType = MP4_FOUR_CHAR_CODE( 's', 'g', 'p', 'd' ), MP4SampletoGroupAtomType = MP4_FOUR_CHAR_CODE( 's', 'b', 'g', 'p' ), + MP4CompactSampletoGroupAtomType = MP4_FOUR_CHAR_CODE( 'c', 's', 'g', 'p' ), MP4SampleDependencyAtomType = MP4_FOUR_CHAR_CODE( 's', 'd', 't', 'p' ), ISOMetaAtomType = MP4_FOUR_CHAR_CODE( 'm', 'e', 't', 'a' ), ISOPrimaryItemAtomType = MP4_FOUR_CHAR_CODE( 'p', 'i', 't', 'm' ), @@ -457,6 +458,7 @@ typedef struct MP4MediaAtom MP4AtomPtr extendedLanguageTag; MP4LinkedList atomList; MP4AtomPtr true_minf; + u32 enableCompactSamples; } MP4MediaAtom, *MP4MediaAtomPtr; typedef struct MP4MediaHeaderAtom @@ -500,7 +502,7 @@ typedef struct MP4ExtendedLanguageTag MP4Handle sampleEntryH, \ MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ); \ MP4Err (*mdatMoved)( struct MP4MediaInformationAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ); \ - MP4Err (*mapSamplestoGroup)(struct MP4MediaInformationAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count ); \ + MP4Err (*mapSamplestoGroup)(struct MP4MediaInformationAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ); \ MP4Err (*setSampleDependency)( struct MP4MediaInformationAtom *self, s32 sample_index, MP4Handle dependencies ); typedef struct MP4MediaInformationAtom @@ -679,7 +681,7 @@ typedef struct MP4SampleTableAtom u32 (*getCurrentSampleEntryIndex)( struct MP4SampleTableAtom *self ); MP4Err (*setDefaultSampleEntry)( struct MP4SampleTableAtom *self, u32 index ); MP4Err (*addGroupDescription)( struct MP4SampleTableAtom *self, u32 theType, MP4Handle theDescription, u32* index ); - MP4Err (*mapSamplestoGroup)( struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count ); + MP4Err (*mapSamplestoGroup)( struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ); MP4Err (*getSampleGroupMap)( struct MP4SampleTableAtom *self, u32 groupType, u32 sample_number, u32* group_index ); MP4Err (*getGroupDescription)( struct MP4SampleTableAtom *self, u32 theType, u32 index, MP4Handle theDescription ); @@ -708,7 +710,8 @@ typedef struct MP4SampleTableAtom MP4LinkedList groupDescriptionList; MP4LinkedList sampletoGroupList; - + MP4LinkedList compactSampletoGroupList; + MP4LinkedList atomList; MP4AtomPtr currentSampleEntry; @@ -1292,6 +1295,7 @@ typedef struct MP4TrackFragmentAtom MP4LinkedList atomList; /* track runs */ MP4LinkedList groupList; /* sample to group maps */ + MP4LinkedList compactSampleGroupList; /* compact sample to group maps */ u8 useSignedCompositionTimeOffsets; @@ -1649,6 +1653,45 @@ typedef struct MP4SampletoGroupAtom MP4Err (*getSampleGroupMap)( struct MP4SampletoGroupAtom *self, u32 sampleNumber, u32* groupIndex ); } MP4SampletoGroupAtom, *MP4SampletoGroupAtomPtr; +typedef struct MP4CompactSampleToGroupPatternEntry +{ + u32 patternLength; + u32 sampleCount; +} MP4CompactSampleToGroupPatternEntry, *MP4CompactSampleToGroupPatternEntryPtr; + +typedef struct { + u32 patternCount; + u32 totalSampleCount; + u32 totalIndexDescriptionCount; + u32 efficientStartIndex; + u8 patternLengthFieldSize; + u8 sampleCountFieldSize; + u8 indexFieldSize; + u8 isSampleGroupCompressed; + + MP4CompactSampleToGroupPatternEntryPtr patternEntries; + u32* indexDescriptionArray; + +} CompressedGroupInfo; + +typedef struct MP4CompactSampletoGroupAtom +{ + COMMON_GROUP_ATOM_FIELDS + + u32 groupingTypeParameter; + u32 entryCount; + u32* group_index; /* indexed by sample number; we compact on write and expand on read */ + u32 sampleCount; + u32 allocatedSize; + u8 fragmentLocalIndexPresent; + u32 mapSampleToGroupIndex; + CompressedGroupInfo compressedGroup; + + MP4Err (*addSamples)( struct MP4CompactSampletoGroupAtom *self, u32 count ); + MP4Err (*mapSamplestoGroup)( struct MP4CompactSampletoGroupAtom *self, u32 group_index, s32 sample_index, u32 count ); + MP4Err (*getSampleGroupMap)( struct MP4CompactSampletoGroupAtom *self, u32 sampleNumber, u32* groupIndex ); +} MP4CompactSampletoGroupAtom, *MP4CompactSampletoGroupAtomPtr; + typedef struct ISOMetaAtom { MP4_FULL_ATOM @@ -2003,6 +2046,7 @@ MP4Err MP4CreateEncBaseAtom( MP4EncBaseSampleEntryAtomPtr outAtom ); #endif MP4Err MP4CreateSampletoGroupAtom( MP4SampletoGroupAtomPtr *outAtom ); +MP4Err MP4CreateCompactSampletoGroupAtom( MP4CompactSampletoGroupAtomPtr *outAtom ); MP4Err MP4CreateSampleGroupDescriptionAtom( MP4SampleGroupDescriptionAtomPtr *outAtom ); MP4Err MP4CreateSampleDependencyAtom( MP4SampleDependencyAtomPtr *outAtom ); diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index b166a78..7ebd88e 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -197,7 +197,28 @@ ISOGetGroupDescription( MP4Media media, u32 groupType, u32 index, MP4Handle desc } MP4_EXTERN( MP4Err ) -ISOMapSamplestoGroup( MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count ) +ISOSetSamplestoGroupType( MP4Media media, u32 enableCompactSamples ) +{ + MP4Err err; + MP4MediaAtomPtr mdia; + + err = MP4NoErr; + if ( media == NULL ) + { + BAILWITHERROR( MP4BadParamErr ); + } + mdia = (MP4MediaAtomPtr) media; + mdia->enableCompactSamples = enableCompactSamples; + + bail: + TEST_RETURN( err ); + + return err; +} + + +MP4_EXTERN( MP4Err ) +ISOMapSamplestoGroup( MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ) { MP4Err err; MP4MediaAtomPtr mdia; @@ -2326,4 +2347,4 @@ MP4GetSampleAuxiliaryInformationForSample( MP4Media theMedia, u8 isUsingAuxInfoP bail: return err; -} \ No newline at end of file +} diff --git a/IsoLib/libisomediafile/src/MP4Movies.h b/IsoLib/libisomediafile/src/MP4Movies.h index a62054c..d00ec6c 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.h +++ b/IsoLib/libisomediafile/src/MP4Movies.h @@ -391,7 +391,10 @@ MP4_EXTERN( MP4Err ) ISOGetGroupDescription( MP4Media media, u32 groupType, u32 index, MP4Handle description ); MP4_EXTERN( MP4Err ) -ISOMapSamplestoGroup( MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count ); +ISOSetSamplestoGroupType( MP4Media media, u32 enableCompactSamples ); + +MP4_EXTERN( MP4Err ) +ISOMapSamplestoGroup( MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ); MP4_EXTERN( MP4Err ) ISOGetSampletoGroupMap( MP4Media media, u32 groupType, u32 sample_number, u32* group_index ); diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index e3768a8..15ff755 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -345,7 +345,7 @@ static MP4Err mapSamplestoGroup(struct MP4MediaAtom *self, u32 groupType, u32 gr minf = (MP4MediaInformationAtomPtr) self->information; assert( minf ); assert( minf->mapSamplestoGroup ); - err = minf->mapSamplestoGroup( minf, groupType, group_index, sample_index, count ); if (err) goto bail; + err = minf->mapSamplestoGroup( minf, groupType, group_index, sample_index, count, self->enableCompactSamples ); if (err) goto bail; bail: TEST_RETURN( err ); diff --git a/IsoLib/libisomediafile/src/MediaInformationAtom.c b/IsoLib/libisomediafile/src/MediaInformationAtom.c index fa81b4f..6c71a8c 100644 --- a/IsoLib/libisomediafile/src/MediaInformationAtom.c +++ b/IsoLib/libisomediafile/src/MediaInformationAtom.c @@ -532,7 +532,7 @@ static MP4Err getGroupDescription(struct MP4MediaInformationAtom *self, u32 grou return err; } -static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count ) +static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ) { MP4Err err; MP4SampleTableAtomPtr stbl; @@ -542,7 +542,7 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *self, u32 groupT stbl = (MP4SampleTableAtomPtr) self->sampleTable; assert( stbl ); assert( stbl->mapSamplestoGroup ); - err = stbl->mapSamplestoGroup( stbl, groupType, group_index, sample_index, count ); if (err) goto bail; + err = stbl->mapSamplestoGroup( stbl, groupType, group_index, sample_index, count, enableCompactSamples ); if (err) goto bail; bail: TEST_RETURN( err ); diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index bbde520..424ead5 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -40,7 +40,7 @@ static void destroy( MP4AtomPtr s ) err = MP4DeleteLinkedList( self->groupDescriptionList ); if (err) goto bail; err = MP4DeleteLinkedList( self->sampletoGroupList ); if (err) goto bail; - + err = MP4DeleteLinkedList( self->compactSampletoGroupList ); if (err) goto bail; err = MP4DeleteLinkedList( self->SampleAuxiliaryInformationSizes ); if (err) goto bail; err = MP4DeleteLinkedList( self->SampleAuxiliaryInformationOffsets ); if (err) goto bail; @@ -66,10 +66,19 @@ MP4Err MP4FindGroupAtom( MP4LinkedList theList, u32 type, MP4AtomPtr* theAtom ) err = MP4GetListEntry( theList, i, (char **) &desc ); if (err) goto bail; if ( desc ) { - MP4SampletoGroupAtomPtr grp; - grp = (MP4SampletoGroupAtomPtr) desc; - if (grp->grouping_type == type) { - *theAtom = desc; + if(desc->type == MP4CompactSampletoGroupAtomType) { + MP4CompactSampletoGroupAtomPtr grp = (MP4CompactSampletoGroupAtomPtr) desc; + if (grp->grouping_type == type) { + *theAtom = desc; + return err; + } + } + else { + MP4SampletoGroupAtomPtr grp = (MP4SampletoGroupAtomPtr) desc; + if (grp->grouping_type == type) { + *theAtom = desc; + return err; + } } } } @@ -129,6 +138,10 @@ static MP4Err addAtom( MP4SampleTableAtomPtr self, MP4AtomPtr atom ) case MP4SampletoGroupAtomType: err = MP4AddListEntry( (void*) atom, self->sampletoGroupList ); break; + + case MP4CompactSampletoGroupAtomType: + err = MP4AddListEntry( (void*) atom, self->compactSampletoGroupList); + break; } bail: TEST_RETURN( err ); @@ -393,6 +406,17 @@ static MP4Err addSamples( struct MP4SampleTableAtom *self, err = desc->addSamples( desc, sampleCount ); if (err) goto bail; } } + err = MP4GetListEntryCount( self->compactSampletoGroupList, &groupCount ); if (err) goto bail; + for ( i = 0; i < groupCount; i++ ) \ + { + MP4CompactSampletoGroupAtomPtr desc; + err = MP4GetListEntry( self->compactSampletoGroupList, i, (char **) &desc ); if (err) goto bail; + if ( desc ) + { + err = desc->addSamples( desc, sampleCount ); if (err) goto bail; + } + } + if (self->SampleDependency) { MP4SampleDependencyAtomPtr sdtp; sdtp = (MP4SampleDependencyAtomPtr) self->SampleDependency; @@ -518,7 +542,7 @@ static MP4Err getGroupDescription( struct MP4SampleTableAtom *self, u32 theType, return err; } -static MP4Err mapSamplestoGroup( struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count ) +static MP4Err mapSamplestoGroup( struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ) { MP4Err err; MP4SampletoGroupAtomPtr theGroup; @@ -528,21 +552,41 @@ static MP4Err mapSamplestoGroup( struct MP4SampleTableAtom *self, u32 groupType, if (!theDesc) BAILWITHERROR( MP4BadParamErr ); if (group_index > theDesc->groupCount) BAILWITHERROR( MP4BadParamErr ); - err = MP4FindGroupAtom( self->sampletoGroupList, groupType, (MP4AtomPtr*) &theGroup ); - if (!theGroup) { - MP4SampleSizeAtomPtr stsz; + if (enableCompactSamples) { + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + err = MP4FindGroupAtom( self->compactSampletoGroupList, groupType, (MP4AtomPtr*) &compactSampleGroup ); + if (!compactSampleGroup) { + MP4SampleSizeAtomPtr stsz; + stsz = (MP4SampleSizeAtomPtr) self->SampleSize; + if ( stsz == NULL ) + { + BAILWITHERROR( MP4InvalidMediaErr ); + } + err = MP4CreateCompactSampletoGroupAtom( &compactSampleGroup ); if (err) goto bail; + compactSampleGroup->grouping_type = groupType; + compactSampleGroup->fragmentLocalIndexPresent = 0; + err = addAtom( self, (MP4AtomPtr) compactSampleGroup ); if (err) goto bail; + err = compactSampleGroup->addSamples( compactSampleGroup, stsz->sampleCount ); if (err) goto bail; + } + err = compactSampleGroup->mapSamplestoGroup( compactSampleGroup, group_index, sample_index, count ); if (err) goto bail; + } + else { + err = MP4FindGroupAtom( self->sampletoGroupList, groupType, (MP4AtomPtr*) &theGroup ); + if (!theGroup) { + MP4SampleSizeAtomPtr stsz; - stsz = (MP4SampleSizeAtomPtr) self->SampleSize; - if ( stsz == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); + stsz = (MP4SampleSizeAtomPtr) self->SampleSize; + if ( stsz == NULL ) + { + BAILWITHERROR( MP4InvalidMediaErr ); + } + err = MP4CreateSampletoGroupAtom( &theGroup ); if (err) goto bail; + theGroup->grouping_type = groupType; + err = addAtom( self, (MP4AtomPtr) theGroup ); if (err) goto bail; + err = theGroup->addSamples( theGroup, stsz->sampleCount ); if (err) goto bail; } - err = MP4CreateSampletoGroupAtom( &theGroup ); if (err) goto bail; - theGroup->grouping_type = groupType; - err = addAtom( self, (MP4AtomPtr) theGroup ); if (err) goto bail; - err = theGroup->addSamples( theGroup, stsz->sampleCount ); if (err) goto bail; + err = theGroup->mapSamplestoGroup( theGroup, group_index, sample_index, count ); if (err) goto bail; } - err = theGroup->mapSamplestoGroup( theGroup, group_index, sample_index, count ); if (err) goto bail; bail: TEST_RETURN( err ); @@ -554,13 +598,22 @@ static MP4Err getSampleGroupMap( struct MP4SampleTableAtom *self, u32 groupType, { MP4Err err; MP4SampletoGroupAtomPtr theGroup; - + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + err = MP4FindGroupAtom( self->sampletoGroupList, groupType, (MP4AtomPtr*) &theGroup ); - if (!theGroup) { - err = MP4BadParamErr; + if (theGroup) { + err = theGroup->getSampleGroupMap( theGroup, sample_number, group_index ); if (err) goto bail; + return err; + } + + err = MP4FindGroupAtom( self->compactSampletoGroupList, groupType, (MP4AtomPtr*) &compactSampleGroup ); + if (compactSampleGroup) { + err = compactSampleGroup->getSampleGroupMap( compactSampleGroup, sample_number, group_index ); if (err) goto bail; + } + else { + err = MP4BadParamErr; goto bail; } - err = theGroup->getSampleGroupMap( theGroup, sample_number, group_index ); if (err) goto bail; bail: TEST_RETURN( err ); @@ -703,7 +756,8 @@ MP4Err MP4CreateSampleTableAtom( MP4SampleTableAtomPtr *outAtom ) err = MP4MakeLinkedList( &(self->groupDescriptionList) ); if (err) goto bail; err = MP4MakeLinkedList( &(self->sampletoGroupList) ); if (err) goto bail; - + err = MP4MakeLinkedList( &(self->compactSampletoGroupList) ); if (err) goto bail; + self->useSignedCompositionTimeOffsets = 0; self->getSampleAuxiliaryInformation = getSampleAuxiliaryInformation; diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index a147515..76ac2d6 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -37,6 +37,7 @@ static void destroy( MP4AtomPtr s ) if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) DESTROY_ATOM_LIST_F( atomList ); DESTROY_ATOM_LIST_F( groupList ); + DESTROY_ATOM_LIST_F( compactSampleGroupList ); (self->tfhd)->destroy( (MP4AtomPtr) (self->tfhd) ); (self->tfdt)->destroy( (MP4AtomPtr) (self->tfdt) ); @@ -63,6 +64,7 @@ static MP4Err addAtom( MP4TrackFragmentAtomPtr self, MP4AtomPtr atom ) case MP4SampleAuxiliaryInformationOffsetsAtomType: err = MP4AddListEntry( atom, self->saioList ); break; case MP4TrackRunAtomType: err = MP4AddListEntry( atom, self->atomList ); break; case MP4SampletoGroupAtomType: err = MP4AddListEntry( atom, self->groupList ); break; + case MP4CompactSampletoGroupAtomType: err = MP4AddListEntry( atom, self->compactSampleGroupList ); break; /* default: BAILWITHERROR( MP4BadDataErr ) */ } bail: @@ -109,6 +111,18 @@ static MP4Err addSampleGroups( struct MP4TrackFragmentAtom *self, u32 sampleCoun } } + err = MP4GetListEntryCount( self->compactSampleGroupList, &groupListSize ); if (err) goto bail; + for ( i = 0; i < groupListSize; i++ ) + { + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + err = MP4GetListEntry( self->compactSampleGroupList, i, (char **) &compactSampleGroup ); if (err) goto bail; + if ( compactSampleGroup ) { + err = compactSampleGroup->addSamples( compactSampleGroup, sampleCount ); + if (err) goto bail; + } + } + + bail: TEST_RETURN( err ); return err; @@ -509,6 +523,7 @@ static MP4Err mergeRuns( MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia ) if (self->groupList) { u32 groupListSize; + err = ISOSetSamplestoGroupType( (MP4Media) mdia, 0 ); if (err) goto bail; err = MP4GetListEntryCount( self->groupList, &groupListSize ); if (err) goto bail; for ( i = 0; i < groupListSize; i++ ) { @@ -525,6 +540,26 @@ static MP4Err mergeRuns( MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia ) } } } + + if (self->compactSampleGroupList) { + u32 groupListSize; + err = ISOSetSamplestoGroupType( (MP4Media) mdia, 1 ); if (err) goto bail; + err = MP4GetListEntryCount( self->compactSampleGroupList, &groupListSize ); if (err) goto bail; + for ( i = 0; i < groupListSize; i++ ) + { + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + err = MP4GetListEntry( self->compactSampleGroupList, i, (char **) &compactSampleGroup ); if (err) goto bail; + if ( compactSampleGroup ) { + u32 j; + for (j=0; jsampleCount; j++) { + s32 position; + position = j - total_samples; + err = mdia->mapSamplestoGroup( mdia, compactSampleGroup->grouping_type, (compactSampleGroup->group_index)[j], position, 1 ); + if (err) goto bail; + } + } + } + } bail: TEST_RETURN( err ); @@ -662,7 +697,7 @@ static MP4Err calculateDataEnd( MP4TrackFragmentAtomPtr self, u32* outEnd ) return err; } -static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType, u32 group_index, s32 sample_index, u32 count ) +static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 compactSamples ) { MP4Err err; MP4SampletoGroupAtomPtr theGroup; @@ -671,26 +706,52 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType self = (MP4TrackFragmentAtomPtr) s; - err = MP4FindGroupAtom( self->groupList, groupType, (MP4AtomPtr*) &theGroup ); - if (!theGroup) { - err = MP4CreateSampletoGroupAtom( &theGroup ); if (err) goto bail; - theGroup->grouping_type = groupType; - err = addAtom( self, (MP4AtomPtr) theGroup ); if (err) goto bail; - - fragment_sample_count = 0; - err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; - for ( i = 0; i < atomListSize; i++ ) - { - MP4TrackRunAtomPtr trun; - err = MP4GetListEntry( self->atomList, i, (char **) &trun ); if (err) goto bail; - if ( trun ) fragment_sample_count += trun->samplecount; + if (compactSamples) { + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + err = MP4FindGroupAtom( self->compactSampleGroupList, groupType, (MP4AtomPtr*) &compactSampleGroup ); + if (!compactSampleGroup) { + err = MP4CreateCompactSampletoGroupAtom( &compactSampleGroup ); if (err) goto bail; + compactSampleGroup->fragmentLocalIndexPresent = 1; + compactSampleGroup->grouping_type = groupType; + err = addAtom( self, (MP4AtomPtr) compactSampleGroup ); if (err) goto bail; + + fragment_sample_count = 0; + err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; + for ( i = 0; i < atomListSize; i++ ) + { + MP4TrackRunAtomPtr trun; + err = MP4GetListEntry( self->atomList, i, (char **) &trun ); if (err) goto bail; + if ( trun ) fragment_sample_count += trun->samplecount; + } + + if (fragment_sample_count > 0) { + err = compactSampleGroup->addSamples( compactSampleGroup, fragment_sample_count ); + } } + err = compactSampleGroup->mapSamplestoGroup( compactSampleGroup, group_index, sample_index, count ); if (err) goto bail; + } + else { + err = MP4FindGroupAtom( self->groupList, groupType, (MP4AtomPtr*) &theGroup ); + if (!theGroup) { + err = MP4CreateSampletoGroupAtom( &theGroup ); if (err) goto bail; + theGroup->grouping_type = groupType; + err = addAtom( self, (MP4AtomPtr) theGroup ); if (err) goto bail; + + fragment_sample_count = 0; + err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; + for ( i = 0; i < atomListSize; i++ ) + { + MP4TrackRunAtomPtr trun; + err = MP4GetListEntry( self->atomList, i, (char **) &trun ); if (err) goto bail; + if ( trun ) fragment_sample_count += trun->samplecount; + } - if (fragment_sample_count > 0) { - err = theGroup->addSamples( theGroup, fragment_sample_count ); + if (fragment_sample_count > 0) { + err = theGroup->addSamples( theGroup, fragment_sample_count ); + } } + err = theGroup->mapSamplestoGroup( theGroup, group_index, sample_index, count ); if (err) goto bail; } - err = theGroup->mapSamplestoGroup( theGroup, group_index, sample_index, count ); if (err) goto bail; bail: TEST_RETURN( err ); diff --git a/isofile.doc b/isofile.doc index 9e2c73014d5cc83d284cbea51cedf5acaa4be201..816a45d48bc60525e139549a94469376047505d2 100644 GIT binary patch literal 258560 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 z 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%0DfPZ2aK;@~vX` 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઼-V4}44xUc9h|&&(98nsvK+si_r~+Y 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 Date: Mon, 30 Sep 2019 15:22:24 -0700 Subject: [PATCH 02/55] call mapsamples correctly --- IsoLib/favs_example/src/mux_main.c | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/IsoLib/favs_example/src/mux_main.c b/IsoLib/favs_example/src/mux_main.c index 50acd3a..e466051 100644 --- a/IsoLib/favs_example/src/mux_main.c +++ b/IsoLib/favs_example/src/mux_main.c @@ -30,7 +30,7 @@ derivative works. Copyright (c) 1999. #include "tools.h" MP4_EXTERN(MP4Err) ISOAddGroupDescription(MP4Media media, u32 groupType, MP4Handle description, u32* index); -MP4_EXTERN(MP4Err) ISOMapSamplestoGroup(MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples); +MP4_EXTERN(MP4Err) ISOMapSamplestoGroup(MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count ); MP4_EXTERN(MP4Err) ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, @@ -406,11 +406,12 @@ ISOErr createMyMovie(struct ParamStruct *parameters) { /* Create "rap " sample description and group */ ISOAddGroupDescription(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc, &rap_desc_index); + ISOSetSamplestoGroupType( media, 1 ); for (frameCounter = 1; frameCounter < stream.used_count; frameCounter++) { /* Mark RAP frames (CRA/BLA/IDR/IRAP) to the group */ if (stream.header[frameCounter]->first_slice_segment_in_pic_flag && stream.header[frameCounter]->nal_type >= 16 && stream.header[frameCounter]->nal_type <= 23) { - ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc_index, stream.header[frameCounter]->sample_number, 1, 1); + ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc_index, stream.header[frameCounter]->sample_number, 1); } } @@ -454,7 +455,8 @@ ISOErr createMyMovie(struct ParamStruct *parameters) { PUT32(&(*alst_desc)[4], alst->sample_offset[0]); /* Push decoding time forward */ PUT32(&(*alst_desc)[8], alst->sample_offset[1]); ISOAddGroupDescription(media, MP4_FOUR_CHAR_CODE('a', 'l', 's', 't'), alst_desc, &alst_desc_index); - + ISOSetSamplestoGroupType( media, 1); + for (frameCounter = start_slice; frameCounter < stream.used_count-1; frameCounter++) { if (!stream.header[frameCounter]->first_slice_segment_in_pic_flag) continue; /* Mark RAP before RASL pics and one picture after them to this group */ @@ -466,7 +468,7 @@ ISOErr createMyMovie(struct ParamStruct *parameters) { ((stream.header[frameCounter - 1]->nal_type >= 6 && stream.header[frameCounter - 1]->nal_type <= 9) && (stream.header[frameCounter]->nal_type < 6 || stream.header[frameCounter]->nal_type > 9)) ) { - ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('a', 'l', 's', 't'), alst_desc_index, stream.header[frameCounter]->sample_number, 1, 1); + ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('a', 'l', 's', 't'), alst_desc_index, stream.header[frameCounter]->sample_number, 1 ); } } MP4DisposeHandle(alst_temp); From 283cd9c8c22a3d7ccb768bc77b651e35c8b1b205 Mon Sep 17 00:00:00 2001 From: dwsinger Date: Wed, 2 Oct 2019 14:24:07 -0700 Subject: [PATCH 03/55] minor changes to compact sample to group support --- IsoLib/libisomediafile/src/MP4Media.c | 2 +- IsoLib/libisomediafile/src/MP4Movies.h | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index 7ebd88e..7dddbab 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -218,7 +218,7 @@ ISOSetSamplestoGroupType( MP4Media media, u32 enableCompactSamples ) MP4_EXTERN( MP4Err ) -ISOMapSamplestoGroup( MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ) +ISOMapSamplestoGroup( MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count ) { MP4Err err; MP4MediaAtomPtr mdia; diff --git a/IsoLib/libisomediafile/src/MP4Movies.h b/IsoLib/libisomediafile/src/MP4Movies.h index d00ec6c..c017868 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.h +++ b/IsoLib/libisomediafile/src/MP4Movies.h @@ -394,7 +394,7 @@ MP4_EXTERN( MP4Err ) ISOSetSamplestoGroupType( MP4Media media, u32 enableCompactSamples ); MP4_EXTERN( MP4Err ) -ISOMapSamplestoGroup( MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ); +ISOMapSamplestoGroup( MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count ); MP4_EXTERN( MP4Err ) ISOGetSampletoGroupMap( MP4Media media, u32 groupType, u32 sample_number, u32* group_index ); From 367891141c968c488b235b0b823f07b0db361267 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski <40244254+podborski@users.noreply.github.com> Date: Thu, 9 Jul 2020 21:14:08 +0200 Subject: [PATCH 04/55] Create c-cpp.yml --- .github/workflows/c-cpp.yml | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) create mode 100644 .github/workflows/c-cpp.yml diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml new file mode 100644 index 0000000..6e46a9c --- /dev/null +++ b/.github/workflows/c-cpp.yml @@ -0,0 +1,19 @@ +name: C/C++ CI + +on: + push: + branches: [ master ] + pull_request: + branches: [ master ] + +jobs: + build: + + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v2 + - name: configure + run: mkdir build && cd build && cmake .. + - name: make + run: make From cadbad93c03dcc28b58418b7e0c4d851a68fbe7c Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Fri, 10 Jul 2020 19:04:53 +0200 Subject: [PATCH 05/55] fix c++ related errors --- .../src/CompactSampleToGroupAtom.c | 75 +++++++++++-------- 1 file changed, 42 insertions(+), 33 deletions(-) diff --git a/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c b/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c index 9a1963e..103d904 100644 --- a/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c +++ b/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c @@ -29,18 +29,22 @@ derivative works. Copyright (c) 1999. enum { kMaxPatternLength = 32, - kUpperNibblePresent = 0x8000, + kUpperNibblePresent = 0x8000 }; -// PatternTracker is maintained as an array for each sample input. +/* PatternTracker is maintained as an array for each sample input. +patternStart at index k, represents the start index of the pattern which helped yield the most efficient way to encode samples from [0, k] inclusive with patternLength, repeated sampleCount times +cumulativeMemoryCost at index k, represents the memory cost associated with most efficient way to encode samples from [0, k] inclusive. Default considers each sample as a distinct non-pattern +prevEfficientIndex at index k, represents the end of the most efficient previous pattern/ non-pattern before k which helped yield the cumulativeMemoryCost at index k. +nextEfficientIndex is populated after back-tracking prevEfficientIndex to easily create compact sample groups +*/ typedef struct { u32 patternStart; u32 patternLength; u32 sampleCount; - // patternStart at index k, represents the start index of the pattern which helped yield the most efficient way to encode samples from [0, k] inclusive with patternLength, repeated sampleCount times - s32 cumulativeMemoryCost; // cumulativeMemoryCost at index k, represents the memory cost associated with most efficient way to encode samples from [0, k] inclusive. Default considers each sample as a distinct non-pattern - s32 prevEfficientIndex; // prevEfficientIndex at index k, represents the end of the most efficient previous pattern/ non-pattern before k which helped yield the cumulativeMemoryCost at index k. - s32 nextEfficientIndex; // nextEfficientIndex is populated after back-tracking prevEfficientIndex to easily create compact sample groups + s32 cumulativeMemoryCost; + s32 prevEfficientIndex; + s32 nextEfficientIndex; } PatternTracker; /* @@ -127,7 +131,7 @@ void AppendNewPatternEntry(CompressedGroupInfo* compressedGroup, u32 index, u32 assert(patternLength != 0); assert(sampleCount != 0); assert(index < compressedGroup->patternCount); - //printf("\n New pattern: length %d sampleCount %d", patternLength, sampleCount); + /*printf("\n New pattern: length %d sampleCount %d", patternLength, sampleCount); */ compressedGroup->patternEntries[index].patternLength = patternLength; compressedGroup->patternEntries[index].sampleCount = sampleCount; @@ -152,7 +156,7 @@ void SetMemoryCostForPattern(SampleGroupInfo *sampleGroup, u32 patternLength, u3 patTrack.prevEfficientIndex = startPatternSampleIndex - 1; sampleGroup->patternTracker[endPatternSampleIndex] = patTrack; - //printf("\n Pattern run of pattern length %d, sample count %d, starting @ %3d with memoryCost %d and prevMostEffIndex %d", patternLength, sampleCount, startPatternSampleIndex, patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex); + /*printf("\n Pattern run of pattern length %d, sample count %d, starting @ %3d with memoryCost %d and prevMostEffIndex %d", patternLength, sampleCount, startPatternSampleIndex, patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex); */ } } @@ -169,7 +173,7 @@ void SetMemoryCostForNonPattern(SampleGroupInfo *sampleGroup, s32 sampleIndex) patTrack.prevEfficientIndex = sampleIndex-1; sampleGroup->patternTracker[sampleIndex] = patTrack; - //printf("\n Writing non-pattern with memoryCost %d and prevMostEffIndex %d ", patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex); + /*printf("\n Writing non-pattern with memoryCost %d and prevMostEffIndex %d ", patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex);*/ } } @@ -179,7 +183,7 @@ void CombineNonPatterns(SampleGroupInfo *sampleGroup, CompressedGroupInfo* compr s32 nextIndex = sampleGroup->sampleCount; PatternTracker* patternTracker = sampleGroup->patternTracker; - // Post-process output pattern tracker. Get Pattern Count, Populate the nextIndex to navigate easily + /* Post-process output pattern tracker. Get Pattern Count, Populate the nextIndex to navigate easily*/ while(prevIndex >= 0 && prevIndex < sampleGroup->sampleCount) { u32 consecutiveNonPatterns = 0; @@ -211,12 +215,13 @@ void CombineNonPatterns(SampleGroupInfo *sampleGroup, CompressedGroupInfo* compr void FindPatternsStartingAtIndex(SampleGroupInfo *sampleGroup, u32 sampleIndex) { + u32 p; assert(sampleIndex < sampleGroup->sampleCount); - // Update memoryCost in case current sample is considered as a non-pattern + /* Update memoryCost in case current sample is considered as a non-pattern*/ SetMemoryCostForNonPattern(sampleGroup, sampleIndex); - for (u32 p = 1; p <= kMaxPatternLength; p++) + for (p = 1; p <= kMaxPatternLength; p++) { if(sampleIndex < p) break; @@ -229,15 +234,16 @@ void FindPatternsStartingAtIndex(SampleGroupInfo *sampleGroup, u32 sampleIndex) i++; } - // Pattern ended at i - 1. - //printf("\n %3d: pattern run ended", i-1); - //break; // out of for loop + /* Pattern ended at i - 1. + printf("\n %3d: pattern run ended", i-1); + break; */ } } } void InitializeSampleGroupInput(MP4CompactSampletoGroupAtomPtr self, SampleGroupInfo* sampleGroup) { + u32 i; sampleGroup->groupIndex = self->group_index; sampleGroup->sampleCount = self->sampleCount; sampleGroup->groupIndexFieldSize = self->compressedGroup.indexFieldSize; @@ -245,10 +251,10 @@ void InitializeSampleGroupInput(MP4CompactSampletoGroupAtomPtr self, SampleGroup memset(sampleGroup->patternTracker, 0, sizeof(PatternTracker)*self->sampleCount); - // Expand sample group indices, get maximum field size to represent each group index + /* Expand sample group indices, get maximum field size to represent each group index*/ u32 startValue = self->group_index[0]; - for(u32 i = 1; i < self->sampleCount; i++) { + for(i = 1; i < self->sampleCount; i++) { if(self->group_index[i-1] == self->group_index[i]) { self->group_index[i-1] = startValue; } @@ -258,11 +264,11 @@ void InitializeSampleGroupInput(MP4CompactSampletoGroupAtomPtr self, SampleGroup } self->group_index[self->sampleCount-1] = startValue; - // Initialize efficiencies assuming each input sample is a distinct non-pattern + /* Initialize efficiencies assuming each input sample is a distinct non-pattern*/ PatternTracker patternTrackerEntry; patternTrackerEntry.patternLength = patternTrackerEntry.sampleCount = 1; - for(u32 i = 0; i < self->sampleCount; i++) { + for(i = 0; i < self->sampleCount; i++) { patternTrackerEntry.patternStart = i; patternTrackerEntry.prevEfficientIndex = i-1; patternTrackerEntry.cumulativeMemoryCost = (i+1) * sampleGroup->groupIndexFieldSize; @@ -272,6 +278,8 @@ void InitializeSampleGroupInput(MP4CompactSampletoGroupAtomPtr self, SampleGroup void CreateCompactSampleGroups(MP4CompactSampletoGroupAtomPtr self) { + u32 j; + u32 patternIndex; if(self->compressedGroup.isSampleGroupCompressed) return; @@ -283,8 +291,8 @@ void CreateCompactSampleGroups(MP4CompactSampletoGroupAtomPtr self) compressedGroup->sampleCountFieldSize = 4; compressedGroup->indexFieldSize = sampleGroup.groupIndexFieldSize; - // Repeatedly process, find and update efficiencies at each sample index - for (u32 j = 0; j < self->sampleCount; j++) { + /* Repeatedly process, find and update efficiencies at each sample index*/ + for (j = 0; j < self->sampleCount; j++) { FindPatternsStartingAtIndex(&sampleGroup, j); } @@ -306,7 +314,7 @@ void CreateCompactSampleGroups(MP4CompactSampletoGroupAtomPtr self) PatternTracker* patternTracker = sampleGroup.patternTracker; u32 descIndex = 0; u32 nextIndex = compressedGroup->efficientStartIndex; - for(u32 patternIndex = 0; patternIndex < compressedGroup->patternCount; patternIndex++) { + for(patternIndex = 0; patternIndex < compressedGroup->patternCount; patternIndex++) { u32 patternLength = patternTracker[nextIndex].patternLength; u8 fieldSize = GetFieldSize(patternLength, 0); if(fieldSize > compressedGroup->patternLengthFieldSize) @@ -322,7 +330,7 @@ void CreateCompactSampleGroups(MP4CompactSampletoGroupAtomPtr self) assert(patternTracker[nextIndex].patternStart >= 0 && patternTracker[nextIndex].patternStart < self->sampleCount); assert(patternTracker[nextIndex].patternStart+patternLength-1 < self->sampleCount); - for (u32 j = 0; j < patternLength; j++) { + for (j = 0; j < patternLength; j++) { u32 groupIndex = sampleGroup.groupIndex[patternTracker[nextIndex].patternStart + j]; if(self->fragmentLocalIndexPresent) { groupIndex = groupIndex | (1 << (self->compressedGroup.indexFieldSize - 1)); @@ -333,7 +341,7 @@ void CreateCompactSampleGroups(MP4CompactSampletoGroupAtomPtr self) nextIndex = patternTracker[nextIndex].nextEfficientIndex; } - // In case only patternLength or sampleCount field size is 4, ensure pattern entry is always byte aligned + /* In case only patternLength or sampleCount field size is 4, ensure pattern entry is always byte aligned*/ if((compressedGroup->patternLengthFieldSize+compressedGroup->sampleCountFieldSize) % 8) { if(compressedGroup->patternLengthFieldSize == 4) compressedGroup->patternLengthFieldSize = 8; @@ -504,7 +512,7 @@ static MP4Err GetData(MP4AtomPtr s, MP4InputStreamPtr inputStream, u8 fieldSize, return err; } -static MP4Err inline PackData(MP4CompactSampletoGroupAtomPtr self, char** bufferPtr, u8 fieldSize, u8 nonByteBoundary, u32 value) +static MP4Err PackData(MP4CompactSampletoGroupAtomPtr self, char** bufferPtr, u8 fieldSize, u8 nonByteBoundary, u32 value) { MP4Err err = MP4NoErr; u32 previousByte; @@ -514,7 +522,7 @@ static MP4Err inline PackData(MP4CompactSampletoGroupAtomPtr self, char** buffer switch(fieldSize) { case 4: - // Read the previous byte and append the new nibble to it + /* Read the previous byte and append the new nibble to it*/ if(nonByteBoundary) { buffer = buffer - 1; self->bytesWritten -= 1; @@ -546,6 +554,7 @@ static MP4Err inline PackData(MP4CompactSampletoGroupAtomPtr self, char** buffer static MP4Err serialize( struct MP4Atom* s, char* buffer ) { MP4Err err = MP4NoErr; + u32 i; MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr) s; @@ -555,26 +564,26 @@ static MP4Err serialize( struct MP4Atom* s, char* buffer ) buffer += self->bytesWritten; PUT32( grouping_type ); - // Grouping type parameter is disabled. If enabled, will need to pack an additional byte to represent it + /* Grouping type parameter is disabled. If enabled, will need to pack an additional byte to represent it*/ PUT32( entryCount ); printf (" \n Field sizes of pattern is %d , sampleCount is %d , indexDescription is %d ", self->compressedGroup.patternLengthFieldSize, self->compressedGroup.sampleCountFieldSize, self->compressedGroup.indexFieldSize); printf("\n Pattern count %d covering %d total samples ", self->compressedGroup.patternCount, self->compressedGroup.totalSampleCount); - for(u32 i = 0; i < self->compressedGroup.patternCount; i++) { + for(i = 0; i < self->compressedGroup.patternCount; i++) { printf("\n Pattern length %d for %d samples ", self->compressedGroup.patternEntries[i].patternLength, self->compressedGroup.patternEntries[i].sampleCount); - // Pattern entry is ensured to start at a byte boundary + /* Pattern entry is ensured to start at a byte boundary*/ PackData(self, &buffer, self->compressedGroup.patternLengthFieldSize, 0, self->compressedGroup.patternEntries[i].patternLength); PackData(self, &buffer, self->compressedGroup.sampleCountFieldSize, (self->compressedGroup.patternLengthFieldSize == 4), self->compressedGroup.patternEntries[i].sampleCount); } - // Index descriptor array is ensured to start at a byte boundary + /* Index descriptor array is ensured to start at a byte boundary*/ printf("\n Index Descriptors array is: "); - for(u32 i = 0; i < self->compressedGroup.totalIndexDescriptionCount; i++) { + for(i = 0; i < self->compressedGroup.totalIndexDescriptionCount; i++) { printf(" %d ", self->compressedGroup.indexDescriptionArray[i]); PackData(self, &buffer, self->compressedGroup.indexFieldSize, (i&1) , self->compressedGroup.indexDescriptionArray[i]); } @@ -596,7 +605,7 @@ static MP4Err calculateSize( struct MP4Atom* s ) CreateCompactSampleGroups(self); - // If grouping type parameter is enabled in flags, will need to add an additional byte + /* If grouping type parameter is enabled in flags, will need to add an additional byte*/ self->size += 8; u32 sizeInBits = (self->compressedGroup.patternCount*(self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); @@ -637,7 +646,7 @@ static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStr patternFieldSize = 4 << ((flags & 0x30) >> 4); if(patternFieldSize != 4 && patternFieldSize != 8 && patternFieldSize != 16 && patternFieldSize != 32) BAILWITHERROR( MP4BadParamErr ) - // Ensure each pattern entry is always byte-aligned + /* Ensure each pattern entry is always byte-aligned*/ if((patternFieldSize + countFieldSize) % 8 ) BAILWITHERROR( MP4BadParamErr ) self->fragmentLocalIndexPresent = (flags & 0x80); From 2e3b07cc24c0120caedac11219cabc7eabf7566e Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Fri, 10 Jul 2020 19:18:09 +0200 Subject: [PATCH 06/55] get rid of travis workflow script since the main repo already has one --- .github/workflows/c-cpp.yml | 19 ------------------- 1 file changed, 19 deletions(-) delete mode 100644 .github/workflows/c-cpp.yml diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml deleted file mode 100644 index 6e46a9c..0000000 --- a/.github/workflows/c-cpp.yml +++ /dev/null @@ -1,19 +0,0 @@ -name: C/C++ CI - -on: - push: - branches: [ master ] - pull_request: - branches: [ master ] - -jobs: - build: - - runs-on: ubuntu-latest - - steps: - - uses: actions/checkout@v2 - - name: configure - run: mkdir build && cd build && cmake .. - - name: make - run: make From b460be27951426208e14c3b38730a5515a552c8d Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Thu, 17 Sep 2020 19:20:21 +0200 Subject: [PATCH 07/55] Point to documetnation wiki in isofile.doc, cosmetics --- README.md | 34 +++++++++++++--------------------- isofile.doc | Bin 269824 -> 271360 bytes 2 files changed, 13 insertions(+), 21 deletions(-) diff --git a/README.md b/README.md index 6a7b512..7a48d68 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,7 @@ # ISOBMFF This repository is the official repository for the ISO Base Media File Format -Reference Software. +Reference Software. The ISO base media file format is published by ISO as part 12 of the MPEG-4 specifications, ISO/IEC 14496-12. As such, it implements and conforms to @@ -20,7 +20,7 @@ software features. ## Development -The repository contains the libisomediafile which is a library implementing +The repository contains the `libisomediafile` which is a library implementing the ISO base media file format. In addition, several tools to read and write files based on this specification are provided. @@ -33,45 +33,38 @@ write files based on this specification are provided. Example of commands to build the entire toolset on a Linux platform. -``` -git clone https://github.com/MPEGGroup/isobmff.git - -cd isobmff - -mkdir build - -cd build - -cmake .. - -make +``` sh +$ git clone https://github.com/MPEGGroup/isobmff.git +$ cd isobmff +$ mkdir build && cd build +$ cmake .. +$ make ``` #### Cross platform CMake allows to generate build scripts for different platforms. For instance: -``` +``` sh cmake -G "Visual Studio 16 2019" -A ARM64 ``` -For more generator, please see [CMake documentation](https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html). +For more generators, please see [CMake documentation](https://cmake.org/cmake/help/latest/manual/cmake-generators.7.html). Note also that certain IDE may be able to natively parse a `CMakeLists.txt` -in which case there is no need to generate specific build scripts. Please refer to your IDE's -documentation on how to best handle CMake-based projects. +in which case there is no need to generate specific build scripts. Please refer to your IDE's documentation on how to best handle CMake-based projects. #### Individual compilation If you are only interested in certain tools, you can build them individually. -For instance, the libisomediafile can be built using `make libisomediafile` +For instance, the `libisomediafile` can be built using `make libisomediafile` when using Unix Makefile. For a complete list, please refer to the generated build scripts, for instance with Unix Makefile: -``` +``` sh $ make help The following are some of the valid targets for this Makefile: ... all (the default if no target is provided) @@ -99,4 +92,3 @@ The following are some of the valid targets for this Makefile: ... WAV_to_MP4 ... MP4_to_WAV ``` - diff --git a/isofile.doc b/isofile.doc index 9e2c73014d5cc83d284cbea51cedf5acaa4be201..c56de5b80b2df532e0acdd0c2fd22d59e857302c 100644 GIT binary patch delta 55317 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 z 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 delta 51184 zcmcfK2Uyft*zo-%px8U0fC?5YsE7r7?;U$bQCtc(*dY~CYx>+rHZ^zj^Ht|-w)HcHr?yp;Pg%keKY*E3isBWnDjAe6 z0bK$-LOepuFDAdYvvp94oz#?if2oEk`xZ3Td`xY!nBOGRZMhXC4G;G-O~>>&Q~8&C zn$7%_anA}T$jo)i`;t$~@_Z&&Maf1A^5sz!Tc+06cdSqpCmTg6m`^b&zI^dyZ$&B3 z0^v;M->=hmWq1!?GNLsflv+{7bXJs!(rVO>wDyJDN4H+%Q^6* z!vgawzfR@zvt?FFCg#2MgMR&B$%5qn92P8iW9MDWx_*CuIqCcQupTd#C`wIL&-_rU zZ(6w2Tm~Q)?Nu zT0xPzYrLCD`Cs2*K#q7r5B1NLX<1I3!SCq`~KoJy0F?galYNHPP&;?!Lk8b!4UgNkMk7fAw z?%TWP@4nspcI(^Kh?5ba+e24u58XbI=|HA!nUY#P&ReUXS3jeM>NY3TqA4>w^e8hV zlYZ-jnzvUTY0C1TFZy8<)m>J<7prPreOWE}>Q%Uf0vT8(EWuxJ%cv+FF%3r%2Nwdh z4hCaAqBH4UJ+(r5Oq5zm@26|&^}t~68gwgHLh{ko?z+botNt+$%NrgPfi+sorcSyQxq82)# zGyKp6UE!ahmZA)2W&{=@2#cU&G2-rBzjyfhz3W>o(`AayNalU)@XyaXpat%a_xbhn1G3xgee(ID#}!5q|jq;M&3LWc{6e~(|MNZSf;=6 zxTQQ+T(wl=Yy$4}ElMhc0GTp>jcJ?o3-5Q*zpz&TA?4Ohq*x-S>j(qo2K?=Fv}| zRV(XH&XLe4Rr6Hc^v>s0SJNaubuxmn3ahae>mZe8FZSUgF5xn+;u@my1W#c@)Y~Ej z?2rnnkq`M%1yxZEHBb|^GAm`2R?M_Uf5bn%9{)5x{Av8t?Uv~Z%XF4yI?6JoJ

@ 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 Date: Fri, 18 Sep 2020 16:08:25 +0200 Subject: [PATCH 08/55] add a statement about old project files --- README.md | 2 ++ 1 file changed, 2 insertions(+) diff --git a/README.md b/README.md index 7a48d68..3cbd18a 100644 --- a/README.md +++ b/README.md @@ -31,6 +31,8 @@ write files based on this specification are provided. ### Compiling +It is recommended to use `cmake` to build the software in this repository. However, this repository also contains old project files for some IDE's which are no longer maintained and are kept in the repository just to maintain compatibility with other software from MPEG. + Example of commands to build the entire toolset on a Linux platform. ``` sh From 2099ff9e3a4ed252fb5f4ce1a8823c539afd3b33 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Mon, 5 Oct 2020 15:15:47 +0200 Subject: [PATCH 09/55] Implement sbgp, sgpd and csgp in movie fragments --- IsoLib/favs_example/src/mux_main.c | 20 +- IsoLib/favs_example/src/structures.h | 1 + IsoLib/favs_example/src/tools.c | 6 +- IsoLib/libisomediafile/src/MP4Atoms.h | 57 +-- IsoLib/libisomediafile/src/MediaAtom.c | 4 +- .../libisomediafile/src/TrackFragmentAtom.c | 378 +++++++++++------- 6 files changed, 272 insertions(+), 194 deletions(-) diff --git a/IsoLib/favs_example/src/mux_main.c b/IsoLib/favs_example/src/mux_main.c index a2fb83d..925af50 100644 --- a/IsoLib/favs_example/src/mux_main.c +++ b/IsoLib/favs_example/src/mux_main.c @@ -408,7 +408,7 @@ ISOErr createMyMovie(struct ParamStruct *parameters) { /* Create "rap " sample description and group */ ISOAddGroupDescription(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc, &rap_desc_index); - ISOSetSamplestoGroupType( media, 1 ); + ISOSetSamplestoGroupType( media, parameters->compactSampleToGroup ); for (frameCounter = 1; frameCounter < stream.used_count; frameCounter++) { /* Mark RAP frames (CRA/BLA/IDR/IRAP) to the group */ if (stream.header[frameCounter]->first_slice_segment_in_pic_flag && @@ -457,7 +457,7 @@ ISOErr createMyMovie(struct ParamStruct *parameters) { PUT32(&(*alst_desc)[4], alst->sample_offset[0]); /* Push decoding time forward */ PUT32(&(*alst_desc)[8], alst->sample_offset[1]); ISOAddGroupDescription(media, MP4_FOUR_CHAR_CODE('a', 'l', 's', 't'), alst_desc, &alst_desc_index); - ISOSetSamplestoGroupType( media, 1); + ISOSetSamplestoGroupType( media, parameters->compactSampleToGroup ); for (frameCounter = start_slice; frameCounter < stream.used_count-1; frameCounter++) { if (!stream.header[frameCounter]->first_slice_segment_in_pic_flag) continue; @@ -531,21 +531,25 @@ int main(int argc, char* argv[]) memset(¶meters, 0, sizeof(struct ParamStruct)); /* Set default parameters */ parameters.framerate = 30.0; + parameters.compactSampleToGroup = 0; parseInput(argc, argv, ¶meters); parameters.frameduration = (u32)((30000.0 / parameters.framerate)+0.5); /* We need inputs */ if (!parameters.inputCount) { - fprintf(stderr, "Usage: hevc_muxer -i -g : -o -f \r\n"); - fprintf(stderr, " --input, -i : Input file, can be multiple\r\n"); - fprintf(stderr, " -g : :Add track group, can be multiple\r\n"); - fprintf(stderr, " --output, -o Output file (MP4)\r\n"); - fprintf(stderr, " --framerate, -f set framerate, default 30\r\n"); - fprintf(stderr, " --subs enable subsample information, 4 = slice, 2 = tile\r\n"); + fprintf(stderr, "Usage:\r\n"); + fprintf(stderr, "hevc_muxer -i -g : -o -f \r\n"); + fprintf(stderr, " --input, -i : Input file, can be multiple\r\n"); + fprintf(stderr, " -g : :Add track group, can be multiple\r\n"); + fprintf(stderr, " --output, -o Output file (MP4)\r\n"); + fprintf(stderr, " --framerate, -f set framerate, default 30\r\n"); + fprintf(stderr, " --subs enable subsample information, 4 = slice, 2 = tile\r\n"); + fprintf(stderr, " -c use compact sample to group box\r\n"); exit(1); } printf("Using framerate: %.2f\r\n", parameters.framerate); + if(parameters.compactSampleToGroup) printf("Using compact sample to group\r\n"); createMyMovie(¶meters); diff --git a/IsoLib/favs_example/src/structures.h b/IsoLib/favs_example/src/structures.h index 96c17d8..f28329f 100644 --- a/IsoLib/favs_example/src/structures.h +++ b/IsoLib/favs_example/src/structures.h @@ -135,6 +135,7 @@ struct ParamStruct { struct TrackGroup **trackGroups; u32 subsample_information; + u32 compactSampleToGroup; }; diff --git a/IsoLib/favs_example/src/tools.c b/IsoLib/favs_example/src/tools.c index 15776f8..b81db3e 100644 --- a/IsoLib/favs_example/src/tools.c +++ b/IsoLib/favs_example/src/tools.c @@ -236,6 +236,11 @@ int parseInput(int argc, char* argv[], struct ParamStruct *parameters) { /* Free original list data */ if (tempGroups) free(tempGroups); + } + break; + /* Compact sample to group flag */ + case 'c': { + parameters->compactSampleToGroup = 1; } break; /* Long parameter name */ @@ -278,7 +283,6 @@ int parseInput(int argc, char* argv[], struct ParamStruct *parameters) { break; } } - } return 1; } \ No newline at end of file diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index 20c7638..1300251 100755 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -120,7 +120,7 @@ enum MP4ItemPropertyAssociationAtomType = MP4_FOUR_CHAR_CODE( 'i', 'p', 'm', 'a' ), MP4SampleGroupDescriptionAtomType = MP4_FOUR_CHAR_CODE( 's', 'g', 'p', 'd' ), MP4SampletoGroupAtomType = MP4_FOUR_CHAR_CODE( 's', 'b', 'g', 'p' ), - MP4CompactSampletoGroupAtomType = MP4_FOUR_CHAR_CODE( 'c', 's', 'g', 'p' ), + MP4CompactSampletoGroupAtomType = MP4_FOUR_CHAR_CODE( 'c', 's', 'g', 'p' ), MP4SampleDependencyAtomType = MP4_FOUR_CHAR_CODE( 's', 'd', 't', 'p' ), ISOMetaAtomType = MP4_FOUR_CHAR_CODE( 'm', 'e', 't', 'a' ), ISOPrimaryItemAtomType = MP4_FOUR_CHAR_CODE( 'p', 'i', 't', 'm' ), @@ -1272,35 +1272,36 @@ typedef struct MP4TrackFragmentHeaderAtom typedef struct MP4TrackFragmentAtom { - MP4_FULL_ATOM - COMMON_MINF_ATOM_FIELDS - MP4AtomPtr tfhd; - MP4AtomPtr tfdt; - MP4AtomPtr trex; - - MP4Err (*mergeRuns)( struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia ); - MP4Err (*calculateDataEnd)( struct MP4TrackFragmentAtom *self, u32* outSize); - MP4Err (*mergeSampleAuxiliaryInformation)( struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia ); - - MP4Err (*getSampleAuxiliaryInfoFromTrackFragment)(struct MP4TrackFragmentAtom *self, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, + MP4_FULL_ATOM + COMMON_MINF_ATOM_FIELDS + MP4AtomPtr tfhd; + MP4AtomPtr tfdt; + MP4AtomPtr trex; + + MP4Err (*mergeRuns)( struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia ); + MP4Err (*calculateDataEnd)( struct MP4TrackFragmentAtom *self, u32* outSize); + MP4Err (*mergeSampleAuxiliaryInformation)( struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia ); + MP4Err (*getSampleAuxiliaryInfoFromTrackFragment)(struct MP4TrackFragmentAtom *self, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut); - - u32 default_sample_description_index; /* all copied from the matching trex */ - u32 default_sample_duration; - u32 default_sample_size; - u32 default_sample_flags; - - MP4MediaDataAtomPtr mdat; - u32 samples_use_mdat; /* 0 -- not yet decided, 1=yes, 2=no */ - MP4LinkedList atomList; /* track runs */ - MP4LinkedList groupList; /* sample to group maps */ - MP4LinkedList compactSampleGroupList; /* compact sample to group maps */ - - u8 useSignedCompositionTimeOffsets; - - MP4LinkedList saizList; - MP4LinkedList saioList; + MP4Err (*addGroupDescription)(struct MP4TrackFragmentAtom *self, u32 groupType, MP4Handle description, u32 *index ); + MP4Err (*getSampleGroupMap)( struct MP4TrackFragmentAtom *self, u32 groupType, u32 sample_number, u32* group_index ); + MP4Err (*getGroupDescription)( struct MP4TrackFragmentAtom *self, u32 theType, u32 index, MP4Handle theDescription ); + u32 default_sample_description_index; /* all copied from the matching trex */ + u32 default_sample_duration; + u32 default_sample_size; + u32 default_sample_flags; + + MP4MediaDataAtomPtr mdat; + u32 samples_use_mdat; /* 0 -- not yet decided, 1=yes, 2=no */ + u8 useSignedCompositionTimeOffsets; + + MP4LinkedList atomList; /* track runs */ + MP4LinkedList groupDescriptionList; /* sample group description list */ + MP4LinkedList groupList; /* sample to group maps */ + MP4LinkedList compactSampleGroupList; /* compact sample to group maps */ + MP4LinkedList saizList; + MP4LinkedList saioList; } MP4TrackFragmentAtom, *MP4TrackFragmentAtomPtr; enum { diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index 15ff755..8a54ea4 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -310,7 +310,7 @@ static MP4Err addGroupDescription(struct MP4MediaAtom *self, u32 groupType, MP4H MP4MediaInformationAtomPtr minf; err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; + minf = (MP4MediaInformationAtomPtr) self->information; /* this can be 'traf' if fragmented */ assert( minf ); assert( minf->addGroupDescription ); err = minf->addGroupDescription( minf, groupType, description, index ); if (err) goto bail; @@ -342,7 +342,7 @@ static MP4Err mapSamplestoGroup(struct MP4MediaAtom *self, u32 groupType, u32 gr MP4MediaInformationAtomPtr minf; err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; + minf = (MP4MediaInformationAtomPtr) self->information; /* this can be 'traf' if fragmented */ assert( minf ); assert( minf->mapSamplestoGroup ); err = minf->mapSamplestoGroup( minf, groupType, group_index, sample_index, count, self->enableCompactSamples ); if (err) goto bail; diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index 76ac2d6..5dbc975 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -37,6 +37,7 @@ static void destroy( MP4AtomPtr s ) if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) DESTROY_ATOM_LIST_F( atomList ); DESTROY_ATOM_LIST_F( groupList ); + DESTROY_ATOM_LIST_F( groupDescriptionList ); DESTROY_ATOM_LIST_F( compactSampleGroupList ); (self->tfhd)->destroy( (MP4AtomPtr) (self->tfhd) ); (self->tfdt)->destroy( (MP4AtomPtr) (self->tfdt) ); @@ -52,25 +53,26 @@ static void destroy( MP4AtomPtr s ) static MP4Err addAtom( MP4TrackFragmentAtomPtr self, MP4AtomPtr atom ) { - MP4Err err; - err = MP4NoErr; - - if ( self == 0 ) - BAILWITHERROR( MP4BadParamErr ); - switch (atom->type) { - case MP4TrackFragmentHeaderAtomType: self->tfhd = atom; break; - case MP4TrackFragmentDecodeTimeAtomType: self->tfdt = atom; break; - case MP4SampleAuxiliaryInformationSizesAtomType: err = MP4AddListEntry( atom, self->saizList ); break; - case MP4SampleAuxiliaryInformationOffsetsAtomType: err = MP4AddListEntry( atom, self->saioList ); break; - case MP4TrackRunAtomType: err = MP4AddListEntry( atom, self->atomList ); break; - case MP4SampletoGroupAtomType: err = MP4AddListEntry( atom, self->groupList ); break; - case MP4CompactSampletoGroupAtomType: err = MP4AddListEntry( atom, self->compactSampleGroupList ); break; - /* default: BAILWITHERROR( MP4BadDataErr ) */ - } + MP4Err err; + err = MP4NoErr; + + if ( self == 0 ) + BAILWITHERROR( MP4BadParamErr ); + switch (atom->type) + { + case MP4TrackFragmentHeaderAtomType: self->tfhd = atom; break; + case MP4TrackFragmentDecodeTimeAtomType: self->tfdt = atom; break; + case MP4SampleAuxiliaryInformationSizesAtomType: err = MP4AddListEntry( atom, self->saizList ); break; + case MP4SampleAuxiliaryInformationOffsetsAtomType: err = MP4AddListEntry( atom, self->saioList ); break; + case MP4TrackRunAtomType: err = MP4AddListEntry( atom, self->atomList ); break; + case MP4SampletoGroupAtomType: err = MP4AddListEntry( atom, self->groupList ); break; /* sbgp */ + case MP4SampleGroupDescriptionAtomType: err = MP4AddListEntry( atom, self->groupDescriptionList ); break; /* sgpd */ + case MP4CompactSampletoGroupAtomType: err = MP4AddListEntry( atom, self->compactSampleGroupList ); break; + /* default: BAILWITHERROR( MP4BadDataErr ) */ + } bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN( err ); + return err; } static MP4Err mdatMoved( struct MP4MediaInformationAtom* s, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) @@ -299,117 +301,150 @@ static MP4Err addSampleReference( struct MP4MediaInformationAtom *s, u64 dataOff return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err addGroupDescription( struct MP4Atom* s, u32 theType, MP4Handle theDescription, u32* index ) { - MP4Err err; - MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr) s; - err = MP4NoErr; - - if ( self->size > 0 ) { - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM( tfhd ); - SERIALIZE_ATOM( tfdt ); - SERIALIZE_ATOM_LIST( saizList ); - SERIALIZE_ATOM_LIST( saioList ); - - SERIALIZE_ATOM_LIST( atomList ); - SERIALIZE_ATOM_LIST( groupList ); - assert( self->bytesWritten == self->size ); - } + MP4Err err; + MP4SampleGroupDescriptionAtomPtr theGroup; + MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr) s; + + err = MP4FindGroupAtom( self->groupDescriptionList, theType, (MP4AtomPtr*) &theGroup ); + if (!theGroup) + { + err = MP4CreateSampleGroupDescriptionAtom( &theGroup ); if (err) goto bail; + theGroup->grouping_type = theType; + err = addAtom( self, (MP4AtomPtr) theGroup ); if (err) goto bail; + } + err = theGroup->addGroupDescription( theGroup, theDescription, index ); if (err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN( err ); + return err; +} - return err; +static MP4Err getGroupDescription( struct MP4SampleTableAtom *self, u32 theType, u32 index, MP4Handle theDescription ) +{ + MP4Err err; + MP4SampleGroupDescriptionAtomPtr theGroup; + + err = MP4FindGroupAtom( self->groupDescriptionList, theType, (MP4AtomPtr*) &theGroup ); + if (!theGroup) BAILWITHERROR(MP4BadParamErr ); + err = theGroup->getGroupDescription( theGroup, index, theDescription ); if (err) goto bail; + +bail: + TEST_RETURN( err ); + return err; +} + +static MP4Err serialize( struct MP4Atom* s, char* buffer ) +{ + MP4Err err; + MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr) s; + err = MP4NoErr; + + if ( self->size > 0 ) + { + err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM( tfhd ); + SERIALIZE_ATOM( tfdt ); + SERIALIZE_ATOM_LIST( saizList ); + SERIALIZE_ATOM_LIST( saioList ); + + SERIALIZE_ATOM_LIST( atomList ); + SERIALIZE_ATOM_LIST( groupDescriptionList ); + SERIALIZE_ATOM_LIST( groupList ); + SERIALIZE_ATOM_LIST( compactSampleGroupList ); + assert( self->bytesWritten == self->size ); + } + +bail: + TEST_RETURN( err ); + return err; } static MP4Err calculateSize( struct MP4Atom* s ) { - MP4Err err; - MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr) s; - MP4TrackFragmentHeaderAtomPtr tfhd; - MP4TrackFragmentDecodeTimeAtomPtr tfdt; + MP4Err err; + MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr) s; + MP4TrackFragmentHeaderAtomPtr tfhd; + MP4TrackFragmentDecodeTimeAtomPtr tfdt; + + u32 tfhd_flags; + u32 i; + u32 atomListSize; + + err = MP4NoErr; + + tfhd = (MP4TrackFragmentHeaderAtomPtr) self->tfhd; + tfdt = (MP4TrackFragmentDecodeTimeAtomPtr) self->tfdt; + + tfhd->default_sample_duration = 0; + tfhd->default_sample_flags = 0; + tfhd->default_sample_size = 0; + tfhd_flags = tfhd_base_data_offset_present; + + if ( self->atomList ) + { + err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; + } + else atomListSize = 0; + + if (atomListSize > 0) + { + MP4TrackRunAtomPtr a; - u32 tfhd_flags; - u32 i; - u32 atomListSize; - - err = MP4NoErr; - - tfhd = (MP4TrackFragmentHeaderAtomPtr) self->tfhd; - tfdt = (MP4TrackFragmentDecodeTimeAtomPtr) self->tfdt; + /* first, calculate what defaults are suitable in this track fragment header */ + for ( i = 0; i < atomListSize; i++ ) + { + err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; + if ( a ) a->calculateDefaults( a, tfhd, 2 ); + /* first iteration gets the second flag value as the first can be special-cased */ + } + + /* then come back round and pick up the flags if not already set from second position */ + if (tfhd->default_sample_flags == 0) + { + for ( i = 0; i < atomListSize; i++ ) + { + err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; + if ( a ) a->calculateDefaults( a, tfhd, 1 ); + /* pick up flags from the first position */ + } + } + + /* then see how they compare with the trex defaults */ + if (self->default_sample_description_index != tfhd->sample_description_index) + tfhd_flags |= tfhd_sample_description_index_present; + if (self->default_sample_duration != tfhd->default_sample_duration) + tfhd_flags |= tfhd_default_sample_duration_present; + if (self->default_sample_size != tfhd->default_sample_size) + tfhd_flags |= tfhd_default_sample_size_present; + if (self->default_sample_flags != tfhd->default_sample_flags) + tfhd_flags |= tfhd_default_sample_flags_present; + + /* finally, tell each run to set its flags based on what we calculated */ + for ( i = 0; i < atomListSize; i++ ) + { + err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; + if ( a ) a->setFlags( a, tfhd ); + } + tfhd->flags = tfhd_flags; + + err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; + ADD_ATOM_SIZE( tfhd ); + ADD_ATOM_SIZE( tfdt ); + ADD_ATOM_LIST_SIZE( saizList ); + ADD_ATOM_LIST_SIZE( saioList ); + ADD_ATOM_LIST_SIZE( atomList ); + ADD_ATOM_LIST_SIZE( groupDescriptionList ); + ADD_ATOM_LIST_SIZE( groupList ); + ADD_ATOM_LIST_SIZE( compactSampleGroupList ); + } + else self->size = 0; - tfhd->default_sample_duration = 0; - tfhd->default_sample_flags = 0; - tfhd->default_sample_size = 0; - tfhd_flags = tfhd_base_data_offset_present; - - if ( self->atomList ) { - err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; - } - else atomListSize = 0; - - if (atomListSize > 0) - { - MP4TrackRunAtomPtr a; - - /* first, calculate what defaults are suitable in this track fragment header */ - - for ( i = 0; i < atomListSize; i++ ) - { - err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; - if ( a ) - a->calculateDefaults( a, tfhd, 2 ); - /* first iteration gets the second flag value as the first can be special-cased */ - } - - /* then come back round and pick up the flags if not already set from second position */ - if (tfhd->default_sample_flags == 0) - { - for ( i = 0; i < atomListSize; i++ ) - { - err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; - if ( a ) - a->calculateDefaults( a, tfhd, 1 ); - /* pick up flags from the first position */ - } - } - - /* then see how they compare with the trex defaults */ - - if (self->default_sample_description_index != tfhd->sample_description_index) - tfhd_flags |= tfhd_sample_description_index_present; - if (self->default_sample_duration != tfhd->default_sample_duration) - tfhd_flags |= tfhd_default_sample_duration_present; - if (self->default_sample_size != tfhd->default_sample_size) - tfhd_flags |= tfhd_default_sample_size_present; - if (self->default_sample_flags != tfhd->default_sample_flags) - tfhd_flags |= tfhd_default_sample_flags_present; - - /* finally, tell each run to set its flags based on what we calculated */ - for ( i = 0; i < atomListSize; i++ ) - { - err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; - if ( a ) - a->setFlags( a, tfhd ); - } - tfhd->flags = tfhd_flags; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_SIZE( tfhd ); - ADD_ATOM_SIZE( tfdt ); - ADD_ATOM_LIST_SIZE( saizList ); - ADD_ATOM_LIST_SIZE( saioList ); - ADD_ATOM_LIST_SIZE( atomList ); - ADD_ATOM_LIST_SIZE( groupList ); - } - else self->size = 0; - bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN( err ); + return err; } static MP4Err mergeRuns( MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia ) @@ -755,9 +790,37 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType bail: TEST_RETURN( err ); - return err; +} + +static MP4Err getSampleGroupMap( struct MP4Atom* s, u32 groupType, u32 sample_number, u32* group_index ) +{ + MP4Err err; + MP4SampletoGroupAtomPtr theGroup; + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr) s; + + err = MP4FindGroupAtom( self->groupList, groupType, (MP4AtomPtr*) &theGroup ); + if (theGroup) + { + err = theGroup->getSampleGroupMap( theGroup, sample_number, group_index ); if (err) goto bail; + return err; + } + + err = MP4FindGroupAtom( self->compactSampleGroupList, groupType, (MP4AtomPtr*) &compactSampleGroup ); + if (compactSampleGroup) + { + err = compactSampleGroup->getSampleGroupMap( compactSampleGroup, sample_number, group_index ); if (err) goto bail; + } + else + { + err = MP4BadParamErr; + goto bail; + } +bail: + TEST_RETURN( err ); + return err; } static MP4Err setSampleDependency( struct MP4MediaInformationAtom *s, s32 sample_index, MP4Handle dependencies ) @@ -822,41 +885,46 @@ static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStr MP4Err MP4CreateTrackFragmentAtom( MP4TrackFragmentAtomPtr *outAtom ) { - MP4Err err; - MP4TrackFragmentAtomPtr self; - - self = (MP4TrackFragmentAtomPtr) calloc( 1, sizeof(MP4TrackFragmentAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4TrackFragmentAtomType; - self->name = "track fragment"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->groupList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->mdatMoved = mdatMoved; - self->addSamples = addSamples; - self->addSampleReference = addSampleReference; - self->mergeRuns = mergeRuns; - self->calculateDataEnd = calculateDataEnd; - self->mapSamplestoGroup = mapSamplestoGroup; - - self->setSampleDependency = setSampleDependency; - - self->useSignedCompositionTimeOffsets = 0; - self->mergeSampleAuxiliaryInformation = mergeSampleAuxiliaryInformation; - self->getSampleAuxiliaryInfoFromTrackFragment = getSampleAuxiliaryInfoFromTrackFragment; - - err = MP4MakeLinkedList( &self->saizList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->saioList ); if (err) goto bail; - - *outAtom = self; + MP4Err err; + MP4TrackFragmentAtomPtr self; + + self = (MP4TrackFragmentAtomPtr) calloc( 1, sizeof(MP4TrackFragmentAtom) ); + TESTMALLOC( self ) + + err = MP4CreateBaseAtom( (MP4AtomPtr) self ); + if ( err ) goto bail; + self->type = MP4TrackFragmentAtomType; + self->name = "track fragment"; + self->createFromInputStream = (cisfunc) createFromInputStream; + self->destroy = destroy; + err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; + err = MP4MakeLinkedList( &self->groupList ); if (err) goto bail; + err = MP4MakeLinkedList( &self->groupDescriptionList ); if (err) goto bail; + err = MP4MakeLinkedList( &self->compactSampleGroupList ); if (err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->mdatMoved = mdatMoved; + self->addSamples = addSamples; + self->addSampleReference = addSampleReference; + self->mergeRuns = mergeRuns; + self->calculateDataEnd = calculateDataEnd; + + self->addGroupDescription = addGroupDescription; + self->mapSamplestoGroup = mapSamplestoGroup; + self->getSampleGroupMap = getSampleGroupMap; + self->getGroupDescription = getGroupDescription; + + self->setSampleDependency = setSampleDependency; + + self->useSignedCompositionTimeOffsets = 0; + self->mergeSampleAuxiliaryInformation = mergeSampleAuxiliaryInformation; + self->getSampleAuxiliaryInfoFromTrackFragment = getSampleAuxiliaryInfoFromTrackFragment; + + err = MP4MakeLinkedList( &self->saizList ); if (err) goto bail; + err = MP4MakeLinkedList( &self->saioList ); if (err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN( err ); + return err; } From ee47be394b7b8bf6edb9d7f9f46e5be20f986f29 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Thu, 15 Oct 2020 14:31:50 +0200 Subject: [PATCH 10/55] add missing tests & copyright headers --- .github/workflows/c-cpp.yml | 6 +- test/CMakeLists.txt | 1 + test/test_01_simple.cpp | 258 ++++++++++++++++++++++++++----- test/test_fragment_creation.cpp | 261 ++++++++++++++++++++++++++++++++ 4 files changed, 486 insertions(+), 40 deletions(-) create mode 100644 test/test_fragment_creation.cpp diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml index 65d84df..abfa20b 100644 --- a/.github/workflows/c-cpp.yml +++ b/.github/workflows/c-cpp.yml @@ -16,7 +16,7 @@ jobs: - name: build run: cmake --build build - name: test - run: ./bin/unit_tests + run: ./bin/unit_tests --wait-for-keypress never -d yes macos: runs-on: macOS-latest @@ -27,7 +27,7 @@ jobs: - name: build run: cmake --build build - name: test - run: ./bin/unit_tests + run: ./bin/unit_tests --wait-for-keypress never -d yes windows: runs-on: windows-latest @@ -38,4 +38,4 @@ jobs: - name: build run: cmake --build build --config Debug - name: test - run: ./bin/Debug/unit_tests + run: ./bin/Debug/unit_tests --wait-for-keypress never -d yes diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt index 0e9d2b2..6f25214 100644 --- a/test/CMakeLists.txt +++ b/test/CMakeLists.txt @@ -26,6 +26,7 @@ add_executable( test_main.cpp test_01_simple.cpp + test_fragment_creation.cpp ) target_link_libraries(unit_tests LINK_PUBLIC libisomediafile) \ No newline at end of file diff --git a/test/test_01_simple.cpp b/test/test_01_simple.cpp index 041d73b..8c832ce 100644 --- a/test/test_01_simple.cpp +++ b/test/test_01_simple.cpp @@ -1,3 +1,26 @@ +/* +This software module was originally developed by Apple Computer, Inc. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. +ISO/IEC gives users of MPEG-4 free license to this +software module or modifications thereof for use in hardware +or software products claiming conformance to MPEG-4. +Those intending to use this software module in hardware or software +products are advised that its use may infringe existing patents. +The original developer of this software module and his/her company, +the subsequent editors and their companies, and ISO/IEC have no +liability for use of this software module or modifications thereof +in an implementation. +Copyright is not released for non MPEG-4 conforming +products. Apple Computer, Inc. retains full right to use the code for its own +purpose, assign or donate the code to a third party and to +inhibit third parties from using the code for non +MPEG-4 conforming products. +This copyright notice must be included in all copies or +derivative works. Copyright (c) 1999. +*/ + #include #include #include "testdataPath.h" @@ -11,43 +34,45 @@ const std::string strTestFile = strDataPath + + "/isobmff/01_simple.mp4"; ISOMovie cMovieBox; -TEST_CASE( "1: Check isobmff/01_simple.mp4" ) { +TEST_CASE( "Check isobmff/01_simple.mp4" ) { ISOErr err; err = ISOOpenMovieFile(&cMovieBox, strTestFile.c_str(), MP4OpenMovieNormal); REQUIRE( err == MP4NoErr ); + ISOTrack audioTrack, videoTrack; + SECTION( "Check Movie" ) { u32 brand, minorversion; err = ISOGetMovieBrand( cMovieBox, &brand, &minorversion ); - REQUIRE( err == MP4NoErr ); - REQUIRE( brand == MP4_FOUR_CHAR_CODE('m', 'p', '4', '2') ); - REQUIRE( minorversion == 1 ); + CHECK( err == MP4NoErr ); + CHECK( brand == MP4_FOUR_CHAR_CODE('m', 'p', '4', '2') ); + CHECK( minorversion == 1 ); u32 outTimeScale; err = ISOGetMovieTimeScale( cMovieBox, &outTimeScale ); - REQUIRE( err == MP4NoErr ); - REQUIRE( outTimeScale == 600 ); + CHECK( err == MP4NoErr ); + CHECK( outTimeScale == 600 ); ISOTrack audioTrack; err = ISOGetMovieTrack( cMovieBox, 101, &audioTrack); - REQUIRE( err == MP4NoErr ); - REQUIRE( audioTrack != 0 ); + CHECK( err == MP4NoErr ); + CHECK( audioTrack != 0 ); err = ISOGetMovieTrack( cMovieBox, 301, &audioTrack); // non existing track - REQUIRE( err == MP4BadParamErr ); + CHECK( err == MP4BadParamErr ); ISOHandle h; err = ISONewHandle(0, &h); - REQUIRE( err == MP4NoErr ); // todo: move this to utility testing suite + CHECK( err == MP4NoErr ); // TODO: move this to utility testing suite err = MP4GetMovieInitialObjectDescriptor( cMovieBox, h ); - REQUIRE( err == MP4NoErr ); + CHECK( err == MP4NoErr ); ISODisposeHandle(h); - REQUIRE( err == MP4NoErr ); // todo: move this to utility testing suite + CHECK( err == MP4NoErr ); // TODO: move this to utility testing suite u8 outFlag; err = MP4GetMovieIODInlineProfileFlag ( cMovieBox, &outFlag ); - REQUIRE( err == MP4NoErr ); - // todo: outFlag ??? + CHECK( err == MP4NoErr ); + // TODO: check the value of outFlag u8 outOD; u8 outScene; @@ -60,8 +85,8 @@ TEST_CASE( "1: Check isobmff/01_simple.mp4" ) { &outAudio, &outVisual, &outGraphics ); - REQUIRE( err == MP4NoErr ); - // todo: profiles and levels of Object Descriptor + CHECK( err == MP4NoErr ); + // TODO: profiles and levels of Object Descriptor // WARN((u32)outOD); // WARN((u32)outScene); // WARN((u32)outAudio); @@ -70,38 +95,197 @@ TEST_CASE( "1: Check isobmff/01_simple.mp4" ) { u64 outDuration; err = ISOGetMovieDuration(cMovieBox, &outDuration); - REQUIRE( err == MP4NoErr ); - REQUIRE( outDuration == 6074 ); + CHECK( err == MP4NoErr ); + CHECK( outDuration == 6074 ); } SECTION( "Check Tracks" ) { - - ISOTrack tempTrack; - err = ISOGetMovieIndTrack( cMovieBox, 0, &tempTrack ); - REQUIRE( err != MP4NoErr ); - err = ISOGetMovieIndTrack( cMovieBox, 1, &tempTrack ); - REQUIRE( err == MP4NoErr ); - err = ISOGetMovieIndTrack( cMovieBox, 2, &tempTrack ); - REQUIRE( err == MP4NoErr ); - err = ISOGetMovieIndTrack( cMovieBox, 3, &tempTrack ); - REQUIRE( err == MP4NoErr ); - err = ISOGetMovieIndTrack( cMovieBox, 4, &tempTrack ); - REQUIRE( err == MP4NoErr ); - err = ISOGetMovieIndTrack( cMovieBox, 5, &tempTrack ); + // ISOGetMovieIndTrack + ISOTrack track1, track2, track3, track4; + err = ISOGetMovieIndTrack( cMovieBox, 0, &audioTrack ); REQUIRE( err != MP4NoErr ); + err = ISOGetMovieIndTrack( cMovieBox, 1, &track1 ); + CHECK( err == MP4NoErr ); + err = ISOGetMovieIndTrack( cMovieBox, 2, &track2 ); + CHECK( err == MP4NoErr ); + err = ISOGetMovieIndTrack( cMovieBox, 3, &track3 ); + CHECK( err == MP4NoErr ); + err = ISOGetMovieIndTrack( cMovieBox, 4, &track4 ); + CHECK( err == MP4NoErr ); + err = ISOGetMovieIndTrack( cMovieBox, 5, &track4 ); + CHECK( err != MP4NoErr ); + // ISOGetMovieTrackCount uint32_t uiTrackCnt = 0; err = ISOGetMovieTrackCount(cMovieBox, &uiTrackCnt); - REQUIRE( err == MP4NoErr ); - REQUIRE( uiTrackCnt == 4 ); + CHECK( err == MP4NoErr ); + CHECK( uiTrackCnt == 4 ); + // ISOGetTrackEnabled u32 outEnabled; - ISOGetMovieTrack( cMovieBox, 101, &tempTrack); - err = ISOGetTrackEnabled( tempTrack, &outEnabled ); + ISOGetMovieTrack( cMovieBox, 101, &audioTrack); + err = ISOGetTrackEnabled( audioTrack, &outEnabled ); + CHECK( err == MP4NoErr ); + CHECK( outEnabled == 1 ); + + // ISOGetTrackEditlistEntryCount no elst in 01_simple.mp4 + u32 outEditListCnt; + err = ISOGetTrackEditlistEntryCount( audioTrack, &outEditListCnt ); + CHECK( err == MP4NotFoundErr ); + + // ISOGetTrackEditlist n/a for 01_simple.mp4 + // ISOGetTrackID + u32 outTrackID; + err = ISOGetTrackID( audioTrack, &outTrackID ); + CHECK( err == MP4NoErr ); + CHECK( outTrackID == 101 ); + + // ISOGetTrackMedia + ISOMedia outMedia; + err = ISOGetTrackMedia( audioTrack, &outMedia ); + CHECK( err == MP4NoErr ); + + // ISOGetTrackMovie + ISOMovie outMovie; + err = ISOGetTrackMovie( audioTrack, &outMovie ); + CHECK( err == MP4NoErr ); + + // ISOGetTrackOffset + u32 outMovieOffsetTime; + err = ISOGetTrackOffset( audioTrack, &outMovieOffsetTime ); + CHECK( err == MP4NoErr ); + CHECK( outMovieOffsetTime == 0 ); + + // ISOGetTrackReference + ISOTrack outReferencedTrack; + err = ISOGetTrackReference( audioTrack, MP4_FOUR_CHAR_CODE('s','y','n','c'), 1, &outReferencedTrack ); + CHECK( err == MP4NoErr ); + ISOGetTrackID( outReferencedTrack, &outTrackID ); + CHECK( outTrackID == 201 ); + + // ISOGetTrackReferenceCount + u32 outReferenceIndex; + err = ISOGetTrackReferenceCount(audioTrack, MP4_FOUR_CHAR_CODE('s','y','n','c'), &outReferenceIndex ); + CHECK( err == MP4NoErr ); + CHECK( outReferenceIndex == 1 ); + + // MJ2GetTrackMatrix + u32 outMatrix[9]; + err = MJ2GetTrackMatrix( audioTrack, outMatrix ); + CHECK( err == MP4NoErr ); + // 65536,0,0,0,65536,0,0,0,1073741824 + CHECK( outMatrix[0] == 65536 ); + CHECK( outMatrix[1] == 0 ); + CHECK( outMatrix[2] == 0 ); + CHECK( outMatrix[3] == 0 ); + CHECK( outMatrix[4] == 65536 ); + CHECK( outMatrix[5] == 0 ); + CHECK( outMatrix[6] == 0 ); + CHECK( outMatrix[7] == 0 ); + CHECK( outMatrix[8] == 1073741824 ); + + // MJ2GetTrackLayer + s16 outLayer; + err = MJ2GetTrackLayer( audioTrack, &outLayer ); + CHECK( err == MP4NoErr ); + CHECK( outLayer == 0 ); + + // MJ2GetTrackDimensions + u32 outWidth, outHeight; + ISOGetMovieTrack( cMovieBox, 201, &videoTrack); + err = MJ2GetTrackDimensions( videoTrack, &outWidth, &outHeight ); + CHECK( err == MP4NoErr ); + CHECK( outWidth == 120 ); + CHECK( outHeight == 96 ); + + // MJ2GetTrackVolume + s16 outVolume; + err = MJ2GetTrackVolume( audioTrack, &outVolume ); + CHECK( err == MP4NoErr ); + CHECK( outVolume == 256 ); + + // ISOGetTrackDuration + u64 outDuration; + err = ISOGetTrackDuration( audioTrack, &outDuration ); + CHECK( err == MP4NoErr ); + CHECK( outDuration == 6074 ); + } + + SECTION( "Check Media" ) { + ISOMedia audioMedia, videoMedia; + + ISOGetMovieTrack( cMovieBox, 101, &audioTrack); + ISOGetMovieTrack( cMovieBox, 201, &videoTrack); + + err = ISOGetTrackMedia( audioTrack, &audioMedia ); + REQUIRE( err == MP4NoErr ); + err = ISOGetTrackMedia( videoTrack, &videoMedia ); REQUIRE( err == MP4NoErr ); - REQUIRE( outEnabled == 1 ); + + // MP4GetMediaDataRefCount + u32 outCount; + err = MP4GetMediaDataRefCount( audioMedia, &outCount ); + CHECK( err == MP4NoErr ); + CHECK( outCount == 1 ); + + // ISOGetIndMediaSample: read second sample of the audio track + ISOHandle outSample; + u32 outSize; + u64 outDecodingTime; + s32 outCTSOffset; + u64 outDuration; + u32 outSampleFlags; + u32 outSampleDescIndex; + ISONewHandle(0, &outSample); + err = ISOGetIndMediaSample(audioMedia, 2, outSample, &outSize, &outDecodingTime, &outCTSOffset, &outDuration, &outSampleFlags, &outSampleDescIndex ); + CHECK( err == MP4NoErr ); + CHECK( outSize == 141 ); + CHECK( outDecodingTime == 1024 ); + CHECK( outCTSOffset == 0 ); + CHECK( outDuration == 1024 ); + CHECK( outSampleFlags == 0 ); + CHECK( outSampleDescIndex == 1 ); + + // TODO: implement MP4GetIndMediaSampleReference + // TODO: implement ISOGetIndMediaSampleWithPad + // TODO: implement ISOGetMediaDataReference + // TODO: implement ISOGetMediaDuration + // TODO: implement ISOGetMediaHandlerDescription + // TODO: implement ISOGetMediaLanguage + // TODO: implement ISOGetMediaExtendedLanguageTag + + // ISOGetMediaSample + u64 outCompositionTime = 0; + ISOHandle outSampleDescription; + ISONewHandle(0, &outSampleDescription); + outDecodingTime = 0; + outDuration = 0; + outSampleDescIndex = 0; + err = ISOGetMediaSample(audioMedia, outSample, &outSize, 3000, &outDecodingTime, &outCompositionTime, &outDuration, outSampleDescription, &outSampleDescIndex, &outSampleFlags); + CHECK( err == MP4NoErr ); + CHECK( outDecodingTime == 2048 ); + CHECK( outCompositionTime == 2048 ); + CHECK( outDuration == 1024 ); + CHECK( outSampleDescIndex == 1 ); + CHECK( outSampleFlags == 0 ); + + // TODO: implement ISOGetMediaSampleWithPad - // todo others + // ISOGetMediaSampleCount + err = ISOGetMediaSampleCount(audioMedia, &outCount); + CHECK( err == MP4NoErr ); + CHECK( outCount == 218 ); + + // TODO: implement ISOGetMediaTimeScale + // TODO: implement ISOGetMediaTrack + // TODO: implement MP4GetMediaDecoderConfig + // TODO: implement MP4GetMediaDecoderType + // TODO: implement MP4GetMediaDecoderInformation + // TODO: implement MJ2GetMediaGraphicsMode + // TODO: implement MJ2GetMediaSoundBalance + // TODO: implement ISOGetSampletoGroupMap + // TODO: implement ISOGetGroupDescription + // TODO: implement ISOGetSampleDependency } } diff --git a/test/test_fragment_creation.cpp b/test/test_fragment_creation.cpp new file mode 100644 index 0000000..2a03e9b --- /dev/null +++ b/test/test_fragment_creation.cpp @@ -0,0 +1,261 @@ +/* +This software module was originally developed by Apple Computer, Inc. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. +ISO/IEC gives users of MPEG-4 free license to this +software module or modifications thereof for use in hardware +or software products claiming conformance to MPEG-4. +Those intending to use this software module in hardware or software +products are advised that its use may infringe existing patents. +The original developer of this software module and his/her company, +the subsequent editors and their companies, and ISO/IEC have no +liability for use of this software module or modifications thereof +in an implementation. +Copyright is not released for non MPEG-4 conforming +products. Apple Computer, Inc. retains full right to use the code for its own +purpose, assign or donate the code to a third party and to +inhibit third parties from using the code for non +MPEG-4 conforming products. +This copyright notice must be included in all copies or +derivative works. Copyright (c) 1999. +*/ + +#include +#include + +/* AAC encoding of a 234.375 Hz stereo tone */ +u8 aacDecoderSpecificInfo[] = { +0x11, 0x80, 0x08, 0xc4, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, +0x00, 0x00 +}; +u8 aacAccessUnit[] = { +0x21, 0x09, 0x49, 0x00, 0x00, 0x00, 0x00, 0x29, 0xc0, 0x56, +0x10, 0xf8, 0xc3, 0x8e, 0x9f, 0x84, 0x3b, 0xe0, 0x7c, 0xc3, +0x80, 0x00, 0x00, 0x00, 0x00 +}; +u32 frameCount = 1; +u32 samplesizefieldsize = 32; +u32 samplesperchunk = 24; + + +MP4Err addMySamples( MP4Track theTrack, MP4Media theMedia, u32 do_init ); +MP4Err getDecoderSpecificInfo( MP4Handle sampleH ); +MP4Err getNextAudioFrame( MP4Handle sampleH ); + +TEST_CASE( "Fragment creation" ) +{ + MP4Err err; + MP4Movie moov; + MP4Track trak; + MP4Media media; + u8 OD_profileAndLevel; + u8 scene_profileAndLevel; + u8 audio_profileAndLevel; + u8 visual_profileAndLevel; + u8 graphics_profileAndLevel; + u32 initialObjectDescriptorID; + u32 timeScale; + u64 mediaDuration; + MP4Handle rap_desc; + u32 rap_desc_index; + u32 frameCounter; + + MP4NewHandle(1, &rap_desc); /* Allocate one byte for rap */ + err = MP4NoErr; + initialObjectDescriptorID = 1; + OD_profileAndLevel = 0xff; /* none required */ + scene_profileAndLevel = 0xff; /* none required */ + audio_profileAndLevel = 0x01; /* main profile L1 */ + visual_profileAndLevel = 0xff; /* none required */ + graphics_profileAndLevel = 0xff; /* none required */ + timeScale = 48000; /* sampling frequency */ + err = MP4NewMovie( &moov, + initialObjectDescriptorID, + OD_profileAndLevel, + scene_profileAndLevel, + audio_profileAndLevel, + visual_profileAndLevel, + graphics_profileAndLevel ); + CHECK( err == MP4NoErr ); + + err = ISOSetMovieTimeScale( moov, 48000 ); + CHECK( err == MP4NoErr ); + + err = MP4NewMovieTrack( moov, MP4NewTrackIsAudio, &trak ); + CHECK( err == MP4NoErr ); + + if (initialObjectDescriptorID != 0) { + err = MP4AddTrackToMovieIOD( trak ); + CHECK( err == MP4NoErr ); + } + + err = MP4NewTrackMedia( trak, &media, MP4AudioHandlerType, timeScale, NULL ); + CHECK( err == MP4NoErr ); + err = ISOSetSampleSizeField ( media, samplesizefieldsize ); + CHECK( err == MP4NoErr ); + err = MP4BeginMediaEdits( media ); + CHECK( err == MP4NoErr ); + + err = ISOSetTrackFragmentDefaults( trak, 1024, sizeof(aacAccessUnit), 1, 0 ); + CHECK( err == MP4NoErr ); + + err = addMySamples( trak, media, 1 ); + + err = MP4EndMediaEdits( media ); + CHECK( err == MP4NoErr ); + + err = MP4GetMediaDuration( media, &mediaDuration ); + CHECK( err == MP4NoErr ); + + err = MP4InsertMediaIntoTrack( trak, 0, 0, mediaDuration, 1 ); + CHECK( err == MP4NoErr ); + + err = ISOStartMovieFragment( moov ); + CHECK( err == MP4NoErr ); + frameCount = 1; + err = addMySamples( trak, media, 0 ); + CHECK( err == MP4NoErr ); + + ISOAddGroupDescription(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc, &rap_desc_index); + for (frameCounter = 1; frameCounter < samplesperchunk; frameCounter++) { + /* Mark RAP frames (CRA/BLA/IDR/IRAP) to the group */ + if (frameCounter % 4 == 0) { + ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc_index, frameCounter-1, 1); + } + } + + err = MP4WriteMovieToFile( moov, "test_fragments.mp4" ); + CHECK( err == MP4NoErr ); +} + + +MP4Err addMySamples( MP4Track trak, MP4Media media, u32 do_init ) +{ + MP4Err err; + MP4Handle sampleEntryH; + MP4Handle sampleDataH; + MP4Handle sampleDurationH; + MP4Handle sampleSizeH; + MP4Handle decoderSpecificInfoH; + u32 objectTypeIndication; + u32 streamType; + u32 decoderBufferSize; + u32 maxBitrate; + u32 avgBitrate; + u32 done = 0; + u32 fileoffset = 0; + u32 i; + MP4Handle pad_bits, depsH; + + err = MP4NoErr; + if (do_init) + { + err = MP4SetMediaLanguage( media, "und" ); if (err) goto bail; + + objectTypeIndication = 0x40; /* mpeg-4 audio */ + streamType = 0x05; /* audio stream */ + decoderBufferSize = 2*6144; /* stereo */ + maxBitrate = 128000; + avgBitrate = 128000; + err = MP4NewHandle( 0, &decoderSpecificInfoH ); if (err) goto bail; + err = getDecoderSpecificInfo( decoderSpecificInfoH ); if (err) goto bail; + + err = MP4NewHandle( 0, &sampleEntryH ); if (err) goto bail; + err = MP4NewSampleDescription( trak, sampleEntryH, + 1, + objectTypeIndication, + streamType, + decoderBufferSize, + maxBitrate, + avgBitrate, + decoderSpecificInfoH ); if (err) goto bail; + } else sampleEntryH = NULL; + + err = MP4NewHandle( samplesperchunk * sizeof(u32), &sampleDurationH ); if (err) goto bail; + err = MP4NewHandle( 0, &sampleDataH ); if (err) goto bail; + err = MP4NewHandle( samplesperchunk * sizeof(u32), &sampleSizeH ); if (err) goto bail; + err = MP4NewHandle( 1, &pad_bits ); if (err) goto bail; + err = MP4NewHandle( samplesperchunk, &depsH ); if (err) goto bail; + *(( u8* )(*pad_bits)) = 0; + for (i=0; i 0) { + err = MP4SetHandleOffset(sampleDataH, 0); + err = MP4AddMediaSamples( media, sampleDataH, frames, sampleDurationH, + sampleSizeH, sampleEntryH, NULL, NULL ); if (err) goto bail; + + if ( sampleEntryH ) + { + err = MP4DisposeHandle( sampleEntryH ); if (err) goto bail; + sampleEntryH = NULL; + } + } + } +bail: + return err; +} + +MP4Err getDecoderSpecificInfo( MP4Handle decoderSpecificInfoH ) +{ + MP4Err err; + u8 *p; + u32 i, frameLength; + + err = MP4NoErr; + if ((frameLength = sizeof(aacDecoderSpecificInfo)) >= 128) { + err = MP4BadParamErr; goto bail; + } + err = MP4SetHandleSize( decoderSpecificInfoH, frameLength+2 ); if (err) goto bail; + p = (u8*) *decoderSpecificInfoH; + *p++ = 0x05; /* DecSpecificInfoTag, 14496-1, Sec 8.2.2.2, Table 1*/ + *p++ = frameLength; /* sizeOfInstance, 14496-1, Sec 12.3.3 */ + for (i=0; i 48 ) /* one second of sine wave signal */ + return MP4EOF; + frameLength = sizeof(aacAccessUnit); + err = MP4SetHandleSize( sampleH, frameLength ); if (err) goto bail; + p = (u8*) *sampleH; + for (i=0; i Date: Fri, 16 Oct 2020 10:50:43 +0200 Subject: [PATCH 11/55] add a pointer to our Wiki --- README.md | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/README.md b/README.md index 3cbd18a..613a0c0 100644 --- a/README.md +++ b/README.md @@ -18,6 +18,10 @@ When possible, it is preferred that separate Pull Requests for fixes/enhancements to the build system and for fixes/enhancements to the software features. +## Documentation + +The general documentation of the public exported API as well as several **How to use** examples are provided on the [Wiki](https://github.com/MPEGGroup/isobmff/wiki). + ## Development The repository contains the `libisomediafile` which is a library implementing From e9edd3a95e7d3b33504d379e11315dc861836371 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Tue, 3 Nov 2020 13:00:47 +0100 Subject: [PATCH 12/55] format all files in libisomedia using .clang-format file --- .clang-format | 136 + IsoLib/libisomediafile/linux/MP4OSMacros.h | 14 +- .../linux/SimpleFileMappingObject.c | 227 +- .../linux/SimpleFileMappingObject.h | 22 +- IsoLib/libisomediafile/macosx/MP4OSMacros.h | 14 +- .../macosx/SimpleFileMappingObject.c | 364 +- .../macosx/SimpleFileMappingObject.h | 28 +- .../libisomediafile/src/AMRSpecificInfoAtom.c | 154 +- .../src/AMRWPSpecificInfoAtom.c | 140 +- .../src/AdditionalMetaDataContainerAtom.c | 311 +- .../src/AudioSampleEntryAtom.c | 178 +- IsoLib/libisomediafile/src/BaseDescriptor.c | 56 +- IsoLib/libisomediafile/src/BitRateAtom.c | 174 +- .../libisomediafile/src/ChannelLayoutAtom.c | 496 +- IsoLib/libisomediafile/src/ChunkOffsetAtom.c | 357 +- .../src/ClockReferenceMediaHeader.c | 122 +- .../src/CompactSampleToGroupAtom.c | 1381 ++--- .../src/CompatibleSchemeTypeAtom.c | 236 +- .../src/CompositionToDecodeAtom.c | 297 +- IsoLib/libisomediafile/src/CopyrightAtom.c | 168 +- IsoLib/libisomediafile/src/DataEntryURLAtom.c | 302 +- IsoLib/libisomediafile/src/DataEntryURNAtom.c | 336 +- .../libisomediafile/src/DataInformationAtom.c | 242 +- .../libisomediafile/src/DataReferenceAtom.c | 316 +- .../libisomediafile/src/DecodingOffsetAtom.c | 458 +- .../src/DegradationPriorityAtom.c | 181 +- .../src/DownMixInstructionsAtom.c | 252 +- IsoLib/libisomediafile/src/ESDAtom.c | 173 +- IsoLib/libisomediafile/src/ESUpdateCommand.c | 234 +- IsoLib/libisomediafile/src/EditAtom.c | 175 +- IsoLib/libisomediafile/src/EditListAtom.c | 905 ++-- .../src/EncAudioSampleEntryAtom.c | 624 +-- .../src/EncVisualSampleEntryAtom.c | 283 +- .../libisomediafile/src/ExtendedLanguageTag.c | 161 +- .../src/FileMappingDataHandler.c | 330 +- .../src/FileMappingDataHandler.h | 34 +- .../libisomediafile/src/FileMappingObject.h | 39 +- IsoLib/libisomediafile/src/FreeSpaceAtom.c | 161 +- .../src/GenericSampleEntryAtom.c | 180 +- .../src/H263SpecificInfoAtom.c | 199 +- IsoLib/libisomediafile/src/HEVCConfigAtom.c | 579 ++- IsoLib/libisomediafile/src/HandlerAtom.c | 312 +- .../libisomediafile/src/HintMediaHeaderAtom.c | 147 +- .../src/IPMPToolUpdateCommand.c | 132 +- IsoLib/libisomediafile/src/ISMAKMSAtom.c | 185 +- IsoLib/libisomediafile/src/ISMASaltAtom.c | 135 +- .../src/ISMASampleFormatAtom.c | 143 +- IsoLib/libisomediafile/src/ISMASecurity.c | 374 +- IsoLib/libisomediafile/src/ISOMeta.c | 3288 ++++++------ IsoLib/libisomediafile/src/ISOMovies.h | 924 ++-- .../src/ISOSampleDescriptions.c | 2337 +++++---- IsoLib/libisomediafile/src/ItemDataAtom.c | 218 +- IsoLib/libisomediafile/src/ItemInfoAtom.c | 250 +- .../libisomediafile/src/ItemInfoEntryAtom.c | 564 ++- IsoLib/libisomediafile/src/ItemLocationAtom.c | 791 +-- .../libisomediafile/src/ItemPropertiesAtom.c | 378 +- .../src/ItemPropertyAssociationAtom.c | 455 +- .../src/ItemPropertyContainerAtom.c | 141 +- .../libisomediafile/src/ItemProtectionAtom.c | 190 +- .../libisomediafile/src/ItemReferenceAtom.c | 177 +- IsoLib/libisomediafile/src/LoudnessAtom.c | 279 +- IsoLib/libisomediafile/src/LoudnessBaseAtom.c | 338 +- IsoLib/libisomediafile/src/MJ2Atoms.h | 120 +- .../src/MJ2BitsPerComponentAtom.c | 234 +- .../src/MJ2ColorSpecificationAtom.c | 225 +- IsoLib/libisomediafile/src/MJ2FileTypeAtom.c | 363 +- IsoLib/libisomediafile/src/MJ2HeaderAtom.c | 184 +- .../libisomediafile/src/MJ2ImageHeaderAtom.c | 171 +- IsoLib/libisomediafile/src/MJ2Movies.c | 191 +- IsoLib/libisomediafile/src/MJ2SignatureAtom.c | 141 +- IsoLib/libisomediafile/src/MP4Atoms.c | 1590 +++--- IsoLib/libisomediafile/src/MP4Atoms.h | 2842 ++++++----- IsoLib/libisomediafile/src/MP4Commands.c | 119 +- IsoLib/libisomediafile/src/MP4DataHandler.c | 41 +- IsoLib/libisomediafile/src/MP4DataHandler.h | 34 +- .../src/MP4DecoderConfigDescriptor.c | 181 +- .../libisomediafile/src/MP4DefaultCommand.c | 119 +- .../src/MP4DefaultDescriptor.c | 118 +- IsoLib/libisomediafile/src/MP4Descriptors.c | 279 +- IsoLib/libisomediafile/src/MP4Descriptors.h | 451 +- IsoLib/libisomediafile/src/MP4ESDescriptor.c | 503 +- .../src/MP4ES_ID_IncDescriptor.c | 89 +- .../src/MP4ES_ID_RefDescriptor.c | 89 +- .../src/MP4FileMappingInputStream.c | 321 +- IsoLib/libisomediafile/src/MP4Handle.c | 370 +- .../src/MP4IPMPDescriptorPointer.c | 126 +- .../libisomediafile/src/MP4IPMPInitialize.c | 220 +- IsoLib/libisomediafile/src/MP4IPMPTool.c | 415 +- .../src/MP4IPMPToolDescriptor.c | 342 +- IsoLib/libisomediafile/src/MP4IPMPToolList.c | 164 +- IsoLib/libisomediafile/src/MP4IPMPX.c | 904 ++-- IsoLib/libisomediafile/src/MP4IPMPXData.c | 152 +- IsoLib/libisomediafile/src/MP4IPMPXData.h | 134 +- .../libisomediafile/src/MP4IPMPXDefaultData.c | 135 +- IsoLib/libisomediafile/src/MP4Impl.h | 1318 ++--- .../src/MP4InitialObjectDescriptor.c | 394 +- IsoLib/libisomediafile/src/MP4InputStream.c | 13 +- IsoLib/libisomediafile/src/MP4InputStream.h | 63 +- IsoLib/libisomediafile/src/MP4LinkedList.c | 323 +- IsoLib/libisomediafile/src/MP4LinkedList.h | 41 +- IsoLib/libisomediafile/src/MP4Media.c | 4445 +++++++++-------- .../src/MP4MemoryInputStream.c | 312 +- IsoLib/libisomediafile/src/MP4MovieFile.c | 803 +-- IsoLib/libisomediafile/src/MP4Movies.c | 2262 +++++---- IsoLib/libisomediafile/src/MP4Movies.h | 1543 +++--- IsoLib/libisomediafile/src/MP4ODTrackReader.c | 32 +- .../libisomediafile/src/MP4ObjectDescriptor.c | 374 +- .../src/MP4OrdinaryTrackReader.c | 591 +-- IsoLib/libisomediafile/src/MP4SLPacket.c | 514 +- IsoLib/libisomediafile/src/MP4TrackReader.c | 312 +- IsoLib/libisomediafile/src/MP4TrackReader.h | 75 +- IsoLib/libisomediafile/src/MP4UserData.c | 432 +- .../libisomediafile/src/MPEGMediaHeaderAtom.c | 125 +- .../libisomediafile/src/MPEGSampleEntryAtom.c | 148 +- IsoLib/libisomediafile/src/MdatDataHandler.c | 129 +- IsoLib/libisomediafile/src/MdatDataHandler.h | 18 +- IsoLib/libisomediafile/src/MediaAtom.c | 1334 ++--- IsoLib/libisomediafile/src/MediaDataAtom.c | 435 +- IsoLib/libisomediafile/src/MediaHeaderAtom.c | 203 +- .../src/MediaInformationAtom.c | 1261 ++--- .../src/MemoryFileMappingObject.c | 106 +- IsoLib/libisomediafile/src/MetaAtom.c | 527 +- .../libisomediafile/src/MetaboxRelationAtom.c | 153 +- IsoLib/libisomediafile/src/MovieAtom.c | 1104 ++-- IsoLib/libisomediafile/src/MovieExtendsAtom.c | 548 +- .../libisomediafile/src/MovieFragmentAtom.c | 436 +- .../src/MovieFragmentHeaderAtom.c | 133 +- IsoLib/libisomediafile/src/MovieHeaderAtom.c | 292 +- IsoLib/libisomediafile/src/MovieTracks.c | 1825 +++---- IsoLib/libisomediafile/src/MovieTracks.h | 15 +- IsoLib/libisomediafile/src/ODUpdateCommand.c | 173 +- .../src/ObjectDescriptorAtom.c | 178 +- .../src/ObjectDescriptorMediaHeader.c | 122 +- .../libisomediafile/src/OriginalFormatAtom.c | 136 +- IsoLib/libisomediafile/src/PCMConfigAtom.c | 161 +- IsoLib/libisomediafile/src/PaddingBitsAtom.c | 320 +- IsoLib/libisomediafile/src/PrimaryItemAtom.c | 135 +- .../src/ProducerReferenceTimeAtom.c | 176 +- IsoLib/libisomediafile/src/QTMovies.c | 247 +- .../src/RestrictedSchemeInfoAtom.c | 212 +- .../src/RestrictedVideoSampleEntry.c | 587 ++- .../libisomediafile/src/SLConfigDescriptor.c | 537 +- .../SampleAuxiliaryInformationOffsetsAtom.c | 408 +- .../src/SampleAuxiliaryInformationSizesAtom.c | 386 +- .../src/SampleDependencyAtom.c | 316 +- .../src/SampleDescriptionAtom.c | 233 +- .../src/SampleGroupDescriptionAtom.c | 392 +- IsoLib/libisomediafile/src/SampleSizeAtom.c | 622 +-- IsoLib/libisomediafile/src/SampleTableAtom.c | 1372 ++--- .../libisomediafile/src/SampleToChunkAtom.c | 582 +-- .../libisomediafile/src/SampleToGroupAtom.c | 417 +- .../src/SceneDescriptionMediaHeader.c | 124 +- IsoLib/libisomediafile/src/SchemeInfoAtom.c | 165 +- IsoLib/libisomediafile/src/SchemeTypeAtom.c | 211 +- IsoLib/libisomediafile/src/SecurityInfoAtom.c | 219 +- .../libisomediafile/src/SecuritySchemeAtom.c | 198 +- IsoLib/libisomediafile/src/SegmentIndexAtom.c | 361 +- IsoLib/libisomediafile/src/SegmentTypeAtom.c | 366 +- IsoLib/libisomediafile/src/ShadowSyncAtom.c | 192 +- .../src/SingleItemTypeReferenceAtom.c | 266 +- .../src/SoundMediaHeaderAtom.c | 135 +- IsoLib/libisomediafile/src/StereoVideoAtom.c | 257 +- .../src/StereoVideoGroupAtom.c | 185 +- .../src/SubSampleInformationAtom.c | 423 +- .../libisomediafile/src/SubsegmentIndexAtom.c | 374 +- IsoLib/libisomediafile/src/SyncSampleAtom.c | 374 +- .../libisomediafile/src/TextMetaSampleEntry.c | 298 +- IsoLib/libisomediafile/src/TimeToSampleAtom.c | 718 +-- IsoLib/libisomediafile/src/TrackAtom.c | 818 ++- IsoLib/libisomediafile/src/TrackExtendsAtom.c | 157 +- .../src/TrackExtensionPropertiesAtom.c | 213 +- .../libisomediafile/src/TrackFragmentAtom.c | 1567 +++--- .../src/TrackFragmentDecodeTimeAtom.c | 139 +- .../src/TrackFragmentHeaderAtom.c | 218 +- .../src/TrackFragmentRunAtom.c | 416 +- IsoLib/libisomediafile/src/TrackGroupAtom.c | 236 +- .../libisomediafile/src/TrackGroupTypeAtom.c | 133 +- IsoLib/libisomediafile/src/TrackHeaderAtom.c | 287 +- .../libisomediafile/src/TrackReferenceAtom.c | 237 +- .../src/TrackReferenceTypeAtom.c | 209 +- IsoLib/libisomediafile/src/TrackTypeAtom.c | 352 +- IsoLib/libisomediafile/src/UnknownAtom.c | 164 +- IsoLib/libisomediafile/src/UserDataAtom.c | 591 ++- IsoLib/libisomediafile/src/VCConfigAtom.c | 683 +-- .../src/VideoMediaHeaderAtom.c | 150 +- .../src/VisualSampleEntryAtom.c | 212 +- .../libisomediafile/src/XMLMetaSampleEntry.c | 334 +- IsoLib/libisomediafile/w32/MP4OSMacros.h | 8 +- .../w32/W32FileMappingObject.c | 259 +- .../w32/W32FileMappingObject.h | 20 +- 190 files changed, 39619 insertions(+), 37165 deletions(-) create mode 100644 .clang-format mode change 100755 => 100644 IsoLib/libisomediafile/src/MP4Atoms.c mode change 100755 => 100644 IsoLib/libisomediafile/src/MP4Atoms.h mode change 100755 => 100644 IsoLib/libisomediafile/src/PCMConfigAtom.c diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..6b81094 --- /dev/null +++ b/.clang-format @@ -0,0 +1,136 @@ +--- +Language: Cpp +# BasedOnStyle: LLVM +AccessModifierOffset: -2 +AlignAfterOpenBracket: Align +AlignConsecutiveMacros: false +AlignConsecutiveAssignments: true +AlignConsecutiveDeclarations: false +AlignEscapedNewlines: Left +AlignOperands: true +AlignTrailingComments: true +AllowAllArgumentsOnNextLine: true +AllowAllConstructorInitializersOnNextLine: true +AllowAllParametersOfDeclarationOnNextLine: true +AllowShortBlocksOnASingleLine: Never +AllowShortCaseLabelsOnASingleLine: false +AllowShortFunctionsOnASingleLine: All +AllowShortLambdasOnASingleLine: All +AllowShortIfStatementsOnASingleLine: Always +AllowShortLoopsOnASingleLine: false +AlwaysBreakAfterDefinitionReturnType: None +AlwaysBreakAfterReturnType: None +AlwaysBreakBeforeMultilineStrings: false +AlwaysBreakTemplateDeclarations: MultiLine +BinPackArguments: true +BinPackParameters: true +BraceWrapping: + AfterCaseLabel: false + AfterClass: false + AfterControlStatement: false + AfterEnum: false + AfterFunction: false + AfterNamespace: false + AfterObjCDeclaration: false + AfterStruct: false + AfterUnion: false + AfterExternBlock: false + BeforeCatch: false + BeforeElse: false + IndentBraces: false + SplitEmptyFunction: true + SplitEmptyRecord: true + SplitEmptyNamespace: true +BreakBeforeBinaryOperators: None +BreakBeforeBraces: Allman +BreakBeforeInheritanceComma: false +BreakInheritanceList: BeforeComma +BreakBeforeTernaryOperators: true +BreakConstructorInitializersBeforeComma: false +BreakConstructorInitializers: BeforeComma +BreakAfterJavaFieldAnnotations: false +BreakStringLiterals: true +ColumnLimit: 100 +CommentPragmas: '^ IWYU pragma:' +CompactNamespaces: false +ConstructorInitializerAllOnOneLineOrOnePerLine: false +ConstructorInitializerIndentWidth: 4 +ContinuationIndentWidth: 4 +Cpp11BracedListStyle: true +DeriveLineEnding: false +DerivePointerAlignment: false +DisableFormat: false +ExperimentalAutoDetectBinPacking: false +FixNamespaceComments: true +ForEachMacros: + - foreach + - Q_FOREACH + - BOOST_FOREACH +IncludeBlocks: Preserve +IncludeCategories: + - Regex: '^"(llvm|llvm-c|clang|clang-c)/' + Priority: 2 + SortPriority: 0 + - Regex: '^(<|"(gtest|gmock|isl|json)/)' + Priority: 3 + SortPriority: 0 + - Regex: '.*' + Priority: 1 + SortPriority: 0 +IncludeIsMainRegex: '(Test)?$' +IncludeIsMainSourceRegex: '' +IndentCaseLabels: false +IndentGotoLabels: true +IndentPPDirectives: None +IndentWidth: 2 +IndentWrappedFunctionNames: false +JavaScriptQuotes: Leave +JavaScriptWrapImports: true +KeepEmptyLinesAtTheStartOfBlocks: true +MacroBlockBegin: '' +MacroBlockEnd: '' +MaxEmptyLinesToKeep: 1 +NamespaceIndentation: None +ObjCBinPackProtocolList: Auto +ObjCBlockIndentWidth: 2 +ObjCSpaceAfterProperty: false +ObjCSpaceBeforeProtocolList: true +PenaltyBreakAssignment: 2 +PenaltyBreakBeforeFirstCallParameter: 19 +PenaltyBreakComment: 300 +PenaltyBreakFirstLessLess: 120 +PenaltyBreakString: 1000 +PenaltyBreakTemplateDeclaration: 10 +PenaltyExcessCharacter: 1000000 +PenaltyReturnTypeOnItsOwnLine: 60 +PointerAlignment: Right +ReflowComments: true +SortIncludes: false +SortUsingDeclarations: true +SpaceAfterCStyleCast: false +SpaceAfterLogicalNot: false +SpaceAfterTemplateKeyword: false +SpaceBeforeAssignmentOperators: true +SpaceBeforeCpp11BracedList: false +SpaceBeforeCtorInitializerColon: true +SpaceBeforeInheritanceColon: true +SpaceBeforeParens: Never +SpaceBeforeRangeBasedForLoopColon: true +SpaceInEmptyBlock: false +SpaceInEmptyParentheses: false +SpacesBeforeTrailingComments: 1 +SpacesInAngles: false +SpacesInConditionalStatement: false +SpacesInContainerLiterals: true +SpacesInCStyleCastParentheses: false +SpacesInParentheses: false +SpacesInSquareBrackets: false +SpaceBeforeSquareBrackets: false +Standard: Latest +StatementMacros: + - Q_UNUSED + - QT_REQUIRE_VERSION +TabWidth: 8 +UseCRLF: false +UseTab: Never +... diff --git a/IsoLib/libisomediafile/linux/MP4OSMacros.h b/IsoLib/libisomediafile/linux/MP4OSMacros.h index 787830d..102556a 100644 --- a/IsoLib/libisomediafile/linux/MP4OSMacros.h +++ b/IsoLib/libisomediafile/linux/MP4OSMacros.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - Linux OS Macros for the ISO file format library + Linux OS Macros for the ISO file format library */ #ifndef INCLUDED_MP4OSMACROS_H @@ -64,6 +64,6 @@ typedef int8_t s8; #endif -#define MP4_FOUR_CHAR_CODE( a, b, c, d ) (((a)<<24)|((b)<<16)|((c)<<8)|(d)) +#define MP4_FOUR_CHAR_CODE(a, b, c, d) (((a) << 24) | ((b) << 16) | ((c) << 8) | (d)) #endif diff --git a/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c b/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c index 90cfb23..1e75ed9 100644 --- a/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c +++ b/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SimpleFileMappingObject.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: SimpleFileMappingObject.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "SimpleFileMappingObject.h" #include @@ -31,145 +31,138 @@ derivative works. Copyright (c) 1999. #include #include -static MP4Err doClose( struct FileMappingObjectRecord *s ); -static MP4Err doOpen( struct FileMappingObjectRecord *s, const char *filename ); -static MP4Err isYourFile( struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile ); +static MP4Err doClose(struct FileMappingObjectRecord *s); +static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *filename); +static MP4Err isYourFile(struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile); -static MP4Err destroy( struct FileMappingObjectRecord *s ) +static MP4Err destroy(struct FileMappingObjectRecord *s) { - MP4Err err; - SimpleFileMappingObject self = (SimpleFileMappingObject) s; - - err = MP4NoErr; - if ( self->data ) - err = doClose( s ); if (err) goto bail; - free( s ); + MP4Err err; + SimpleFileMappingObject self = (SimpleFileMappingObject)s; + + err = MP4NoErr; + if(self->data) err = doClose(s); + if(err) goto bail; + free(s); bail: -TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err doOpen( struct FileMappingObjectRecord *s, const char *pathname ) +static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *pathname) { - MP4Err err; - struct stat info; - long count; - char *separator; - - SimpleFileMappingObject self = (SimpleFileMappingObject) s; - err = MP4NoErr; - - self->fd = open( pathname, O_RDONLY ); - if ( self->fd == -1 ) - BAILWITHERROR( MP4FileNotFoundErr ); - self->fileName = (char *) calloc( 1, strlen(pathname)+1 ); - if ( self->fileName == NULL ) - BAILWITHERROR( MP4NoMemoryErr ) - strcpy( self->fileName, pathname ); - - if ( fstat(self->fd, &info) == -1 ) - BAILWITHERROR( MP4IOErr ); - self->size64 = info.st_size; - self->size = info.st_size; - self->data = (char *) malloc( self->size ); - if ( self->data == NULL ) - BAILWITHERROR( MP4IOErr ); - count = self->size; - if ( read(self->fd, self->data, self->size) != ((s32) self->size) ) - { - BAILWITHERROR( MP4IOErr ); - } - /* make parent */ - if ( (separator = strrchr(pathname, '\\')) || (separator = strrchr(pathname, '/')) ) - { - int len = separator - pathname; - self->parent = (char *) calloc( 1, len + 2 ); - TESTMALLOC( self->parent ); - strncpy( self->parent, pathname, len ); - strcat( self->parent, "/" ); - } + MP4Err err; + struct stat info; + long count; + char *separator; + + SimpleFileMappingObject self = (SimpleFileMappingObject)s; + err = MP4NoErr; + + self->fd = open(pathname, O_RDONLY); + if(self->fd == -1) BAILWITHERROR(MP4FileNotFoundErr); + self->fileName = (char *)calloc(1, strlen(pathname) + 1); + if(self->fileName == NULL) BAILWITHERROR(MP4NoMemoryErr) + strcpy(self->fileName, pathname); + + if(fstat(self->fd, &info) == -1) BAILWITHERROR(MP4IOErr); + self->size64 = info.st_size; + self->size = info.st_size; + self->data = (char *)malloc(self->size); + if(self->data == NULL) BAILWITHERROR(MP4IOErr); + count = self->size; + if(read(self->fd, self->data, self->size) != ((s32)self->size)) + { + BAILWITHERROR(MP4IOErr); + } + /* make parent */ + if((separator = strrchr(pathname, '\\')) || (separator = strrchr(pathname, '/'))) + { + int len = separator - pathname; + self->parent = (char *)calloc(1, len + 2); + TESTMALLOC(self->parent); + strncpy(self->parent, pathname, len); + strcat(self->parent, "/"); + } bail: -TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err doClose( struct FileMappingObjectRecord *s ) +static MP4Err doClose(struct FileMappingObjectRecord *s) { - MP4Err err; - SimpleFileMappingObject self = (SimpleFileMappingObject) s; - - err = MP4NoErr; - if (self->data) - free (self->data); - self->data = NULL; - if ( self->fileName ) - free( self->fileName ); - self->fileName = NULL; - if ( self->parent ) - free( self->parent ); - self->parent = NULL; - close( self->fd ); - return err; + MP4Err err; + SimpleFileMappingObject self = (SimpleFileMappingObject)s; + + err = MP4NoErr; + if(self->data) free(self->data); + self->data = NULL; + if(self->fileName) free(self->fileName); + self->fileName = NULL; + if(self->parent) free(self->parent); + self->parent = NULL; + close(self->fd); + return err; } -static MP4Err isYourFile( struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile ) +static MP4Err isYourFile(struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile) { - MP4Err err; - SimpleFileMappingObject self = (SimpleFileMappingObject) s; - int result; - err = MP4NoErr; + MP4Err err; + SimpleFileMappingObject self = (SimpleFileMappingObject)s; + int result; + err = MP4NoErr; #if defined(_MSC_VER) - result = _stricmp( self->fileName, filename ); + result = _stricmp(self->fileName, filename); #else - result = strcmp( self->fileName, filename ); + result = strcmp(self->fileName, filename); #endif - *outSameFile = result ? 0 : 1; - return err; + *outSameFile = result ? 0 : 1; + return err; } - -MP4Err MP4CreateSimpleFileMappingObject( char *filename, FileMappingObject *outObject ) +MP4Err MP4CreateSimpleFileMappingObject(char *filename, FileMappingObject *outObject) { - MP4Err err; - SimpleFileMappingObject self; - - err = MP4NoErr; - self = (SimpleFileMappingObject) calloc( 1, sizeof(SimpleFileMappingObjectRecord) ); - TESTMALLOC( self ); - self->destroy = destroy; - self->open = doOpen; - self->close = doClose; - self->isYourFile = isYourFile; - err = doOpen( (FileMappingObject) self, filename ); if (err) goto bail; - *outObject = (FileMappingObject) self; + MP4Err err; + SimpleFileMappingObject self; + + err = MP4NoErr; + self = (SimpleFileMappingObject)calloc(1, sizeof(SimpleFileMappingObjectRecord)); + TESTMALLOC(self); + self->destroy = destroy; + self->open = doOpen; + self->close = doClose; + self->isYourFile = isYourFile; + err = doOpen((FileMappingObject)self, filename); + if(err) goto bail; + *outObject = (FileMappingObject)self; bail: -TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateFileMappingObject( char *urlString, FileMappingObject *outObject ) +MP4Err MP4CreateFileMappingObject(char *urlString, FileMappingObject *outObject) { - char *pathname = urlString; - if ( (strncmp(urlString, "file://", 7) == 0) || (strncmp(urlString, "file|//", 7) == 0) ) - { - pathname += 7; - } - return MP4CreateSimpleFileMappingObject( pathname, outObject ); + char *pathname = urlString; + if((strncmp(urlString, "file://", 7) == 0) || (strncmp(urlString, "file|//", 7) == 0)) + { + pathname += 7; + } + return MP4CreateSimpleFileMappingObject(pathname, outObject); } -MP4Err MP4AssertFileExists( char *pathName ) +MP4Err MP4AssertFileExists(char *pathName) { - MP4Err err; - struct stat buf; - - err = stat( pathName, &buf ); - if ( err ) - { - BAILWITHERROR( MP4FileNotFoundErr ); - } + MP4Err err; + struct stat buf; + + err = stat(pathName, &buf); + if(err) + { + BAILWITHERROR(MP4FileNotFoundErr); + } bail: - return err; + return err; } diff --git a/IsoLib/libisomediafile/linux/SimpleFileMappingObject.h b/IsoLib/libisomediafile/linux/SimpleFileMappingObject.h index b4e89f6..feaa353 100644 --- a/IsoLib/libisomediafile/linux/SimpleFileMappingObject.h +++ b/IsoLib/libisomediafile/linux/SimpleFileMappingObject.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SimpleFileMappingObject.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: SimpleFileMappingObject.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #ifndef INCLUDED_SIMPLEFILEMAPPING_OBJECT_H #define INCLUDED_SIMPLEFILEMAPPING_OBJECT_H @@ -30,12 +30,12 @@ derivative works. Copyright (c) 1999. typedef struct SimpleFileMappingObjectRecord { - COMMON_FILEMAPPING_OBJECT_FIELDS - char *fileName; - int fd; - u32 size; + COMMON_FILEMAPPING_OBJECT_FIELDS + char *fileName; + int fd; + u32 size; } SimpleFileMappingObjectRecord, *SimpleFileMappingObject; -MP4Err MP4CreateSimpleFileMappingObject( char *filename, FileMappingObject *outObject ); +MP4Err MP4CreateSimpleFileMappingObject(char *filename, FileMappingObject *outObject); #endif diff --git a/IsoLib/libisomediafile/macosx/MP4OSMacros.h b/IsoLib/libisomediafile/macosx/MP4OSMacros.h index 14bce65..99f2d6e 100644 --- a/IsoLib/libisomediafile/macosx/MP4OSMacros.h +++ b/IsoLib/libisomediafile/macosx/MP4OSMacros.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - Mac OS X Macros for the ISO file format library + Mac OS X Macros for the ISO file format library */ #ifndef INCLUDED_MP4OSMACROS_H @@ -48,6 +48,6 @@ typedef int s32; typedef short s16; typedef char s8; -#define MP4_FOUR_CHAR_CODE( a, b, c, d ) (((a)<<24)|((b)<<16)|((c)<<8)|(d)) +#define MP4_FOUR_CHAR_CODE(a, b, c, d) (((a) << 24) | ((b) << 16) | ((c) << 8) | (d)) #endif diff --git a/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c b/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c index 286a087..af6d9e3 100644 --- a/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c +++ b/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SimpleFileMappingObject.c,v 1.1 2002/10/08 10:27:59 fred Exp $ + $Id: SimpleFileMappingObject.c,v 1.1 2002/10/08 10:27:59 fred Exp $ */ #include "SimpleFileMappingObject.h" #include @@ -36,221 +36,233 @@ derivative works. Copyright (c) 1999. #define DO_MAP 1 #define WINDOW_RESIDUE 0x02000000 -#define WINDOW_BITS 0xFFFFFFFFFF000000ll +#define WINDOW_BITS 0xFFFFFFFFFF000000ll -static MP4Err doClose( struct FileMappingObjectRecord *s ); -static MP4Err doOpen( struct FileMappingObjectRecord *s, const char *filename ); -static MP4Err isYourFile( struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile ); -static MP4Err copyData( struct FileMappingObjectRecord *s, u64 offset, char *dst, u32 bytes ); +static MP4Err doClose(struct FileMappingObjectRecord *s); +static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *filename); +static MP4Err isYourFile(struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile); +static MP4Err copyData(struct FileMappingObjectRecord *s, u64 offset, char *dst, u32 bytes); -static MP4Err destroy( struct FileMappingObjectRecord *s ) +static MP4Err destroy(struct FileMappingObjectRecord *s) { - MP4Err err; - SimpleFileMappingObject self = (SimpleFileMappingObject) s; - - err = MP4NoErr; - if ( self->data ) - err = doClose( s ); if (err) goto bail; - free( s ); + MP4Err err; + SimpleFileMappingObject self = (SimpleFileMappingObject)s; + + err = MP4NoErr; + if(self->data) err = doClose(s); + if(err) goto bail; + free(s); bail: -TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err doOpen( struct FileMappingObjectRecord *s, const char *pathname ) +static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *pathname) { - MP4Err err; - struct stat info; - long count; - char *separator; - - SimpleFileMappingObject self = (SimpleFileMappingObject) s; - err = MP4NoErr; - - self->fd = open( pathname, O_RDONLY ); - if ( self->fd < 0 ) - BAILWITHERROR( MP4FileNotFoundErr ); - self->fileName = (char *) calloc( 1, strlen(pathname)+1 ); - if ( self->fileName == NULL ) - BAILWITHERROR( MP4NoMemoryErr ) - strcpy( self->fileName, pathname ); - - if ( fstat(self->fd, &info) < 0 ) - BAILWITHERROR( MP4IOErr ); - self->size64 = info.st_size; + MP4Err err; + struct stat info; + long count; + char *separator; + + SimpleFileMappingObject self = (SimpleFileMappingObject)s; + err = MP4NoErr; + + self->fd = open(pathname, O_RDONLY); + if(self->fd < 0) BAILWITHERROR(MP4FileNotFoundErr); + self->fileName = (char *)calloc(1, strlen(pathname) + 1); + if(self->fileName == NULL) BAILWITHERROR(MP4NoMemoryErr) + strcpy(self->fileName, pathname); + + if(fstat(self->fd, &info) < 0) BAILWITHERROR(MP4IOErr); + self->size64 = info.st_size; #ifdef DO_MAP - self->window = 0; - if (self->size64>WINDOW_RESIDUE) - self->window_size = WINDOW_RESIDUE; - else self->window_size = self->size64; - - self->data = mmap( 0, self->window_size, PROT_READ, MAP_FILE + MAP_PRIVATE, self->fd, self->window ); - - - if (!(self->data) || (self->data < 0)) - { /* printf("Error was %d %s\n",errno,strerror( errno )); */ - BAILWITHERROR( MP4IOErr ); } + self->window = 0; + if(self->size64 > WINDOW_RESIDUE) self->window_size = WINDOW_RESIDUE; + else + self->window_size = self->size64; + + self->data = + mmap(0, self->window_size, PROT_READ, MAP_FILE + MAP_PRIVATE, self->fd, self->window); + + if(!(self->data) || (self->data < 0)) + { /* printf("Error was %d %s\n",errno,strerror( errno )); */ + BAILWITHERROR(MP4IOErr); + } #else - if (info.st_size >> 32) - { BAILWITHERROR( MP4NotImplementedErr ); } - self->size64 = info.st_size; - self->data = (char *) malloc( self->size64 ); - if ( self->data == NULL ) - BAILWITHERROR( MP4IOErr ); - count = self->size64; - if ( read(self->fd, self->data, self->size64) != ((s32) self->size64) ) - { - BAILWITHERROR( MP4IOErr ); - } + if(info.st_size >> 32) + { + BAILWITHERROR(MP4NotImplementedErr); + } + self->size64 = info.st_size; + self->data = (char *)malloc(self->size64); + if(self->data == NULL) BAILWITHERROR(MP4IOErr); + count = self->size64; + if(read(self->fd, self->data, self->size64) != ((s32)self->size64)) + { + BAILWITHERROR(MP4IOErr); + } #endif - /* make parent */ - if ( (separator = strrchr(pathname, '\\')) || (separator = strrchr(pathname, '/')) ) - { - int len = separator - pathname; - self->parent = (char *) calloc( 1, len + 2 ); - TESTMALLOC( self->parent ); - strncpy( self->parent, pathname, len ); - strcat( self->parent, "/" ); - } + /* make parent */ + if((separator = strrchr(pathname, '\\')) || (separator = strrchr(pathname, '/'))) + { + int len = separator - pathname; + self->parent = (char *)calloc(1, len + 2); + TESTMALLOC(self->parent); + strncpy(self->parent, pathname, len); + strcat(self->parent, "/"); + } bail: -TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err doClose( struct FileMappingObjectRecord *s ) +static MP4Err doClose(struct FileMappingObjectRecord *s) { - MP4Err err; - SimpleFileMappingObject self = (SimpleFileMappingObject) s; - - err = MP4NoErr; - if (self->data) { + MP4Err err; + SimpleFileMappingObject self = (SimpleFileMappingObject)s; + + err = MP4NoErr; + if(self->data) + { #ifdef DO_MAP - err = munmap( self->data, self->window_size); - if (err) { err = MP4IOErr; } + err = munmap(self->data, self->window_size); + if(err) + { + err = MP4IOErr; + } #else - free( self->data ); + free(self->data); #endif - } - self->data = NULL; - if ( self->fileName ) - free( self->fileName ); - self->fileName = NULL; - if ( self->parent ) - free( self->parent ); - self->parent = NULL; - - close( self->fd ); - - return err; + } + self->data = NULL; + if(self->fileName) free(self->fileName); + self->fileName = NULL; + if(self->parent) free(self->parent); + self->parent = NULL; + + close(self->fd); + + return err; } -static MP4Err isYourFile( struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile ) +static MP4Err isYourFile(struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile) { - MP4Err err; - SimpleFileMappingObject self = (SimpleFileMappingObject) s; - int result; - err = MP4NoErr; + MP4Err err; + SimpleFileMappingObject self = (SimpleFileMappingObject)s; + int result; + err = MP4NoErr; #if defined(_MSC_VER) - result = _stricmp( self->fileName, filename ); + result = _stricmp(self->fileName, filename); #else - result = strcmp( self->fileName, filename ); + result = strcmp(self->fileName, filename); #endif - *outSameFile = result ? 0 : 1; - return err; + *outSameFile = result ? 0 : 1; + return err; } -static MP4Err copyData( struct FileMappingObjectRecord *s, u64 offset, char *dst, u32 bytes ) +static MP4Err copyData(struct FileMappingObjectRecord *s, u64 offset, char *dst, u32 bytes) { - MP4Err err; - SimpleFileMappingObject self = (SimpleFileMappingObject) s; - - err = MP4NoErr; - - if ((offset + bytes) > self->size64) - { BAILWITHERROR( MP4IOErr ); } - + MP4Err err; + SimpleFileMappingObject self = (SimpleFileMappingObject)s; + + err = MP4NoErr; + + if((offset + bytes) > self->size64) + { + BAILWITHERROR(MP4IOErr); + } + #ifdef DO_MAP - if (self->window != (offset & WINDOW_BITS)) { - err = munmap( self->data, self->window_size); - if (err) { BAILWITHERROR( MP4IOErr ); } - self->window = (offset & WINDOW_BITS); - - if ((self->size64 - self->window)>WINDOW_RESIDUE) - self->window_size = WINDOW_RESIDUE; - else self->window_size = (self->size64 - self->window); - - self->data = mmap( 0, self->window_size, PROT_READ, MAP_FILE + MAP_PRIVATE, self->fd, self->window ); - if (!(self->data) || (self->data < 0)) - { BAILWITHERROR( MP4IOErr ); } - } - - offset -= self->window; - if ((offset + bytes) > self->window_size) { - u32 len; - len = self->window_size - offset; - - memcpy( dst, self->data + offset, len ); - err = copyData( s, self->window + self->window_size, dst + len, bytes - len ); - } - else - { - memcpy( dst, self->data + offset, bytes ); - } + if(self->window != (offset & WINDOW_BITS)) + { + err = munmap(self->data, self->window_size); + if(err) + { + BAILWITHERROR(MP4IOErr); + } + self->window = (offset & WINDOW_BITS); + + if((self->size64 - self->window) > WINDOW_RESIDUE) self->window_size = WINDOW_RESIDUE; + else + self->window_size = (self->size64 - self->window); + + self->data = + mmap(0, self->window_size, PROT_READ, MAP_FILE + MAP_PRIVATE, self->fd, self->window); + if(!(self->data) || (self->data < 0)) + { + BAILWITHERROR(MP4IOErr); + } + } + + offset -= self->window; + if((offset + bytes) > self->window_size) + { + u32 len; + len = self->window_size - offset; + + memcpy(dst, self->data + offset, len); + err = copyData(s, self->window + self->window_size, dst + len, bytes - len); + } + else + { + memcpy(dst, self->data + offset, bytes); + } #else - memcpy( dst, self->data + offset, bytes ); + memcpy(dst, self->data + offset, bytes); #endif bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSimpleFileMappingObject( char *filename, FileMappingObject *outObject ) +MP4Err MP4CreateSimpleFileMappingObject(char *filename, FileMappingObject *outObject) { - MP4Err err; - SimpleFileMappingObject self; - - err = MP4NoErr; - self = (SimpleFileMappingObject) calloc( 1, sizeof(SimpleFileMappingObjectRecord) ); - TESTMALLOC( self ); - self->destroy = destroy; - self->open = doOpen; - self->close = doClose; - self->isYourFile = isYourFile; - self->copyData = copyData; - self->window = 0; - - err = doOpen( (FileMappingObject) self, filename ); if (err) goto bail; - *outObject = (FileMappingObject) self; + MP4Err err; + SimpleFileMappingObject self; + + err = MP4NoErr; + self = (SimpleFileMappingObject)calloc(1, sizeof(SimpleFileMappingObjectRecord)); + TESTMALLOC(self); + self->destroy = destroy; + self->open = doOpen; + self->close = doClose; + self->isYourFile = isYourFile; + self->copyData = copyData; + self->window = 0; + + err = doOpen((FileMappingObject)self, filename); + if(err) goto bail; + *outObject = (FileMappingObject)self; bail: -TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateFileMappingObject( char *urlString, FileMappingObject *outObject ) +MP4Err MP4CreateFileMappingObject(char *urlString, FileMappingObject *outObject) { - char *pathname = urlString; - if ( (strncmp(urlString, "file://", 7) == 0) || (strncmp(urlString, "file|//", 7) == 0) ) - { - pathname += 7; - } - return MP4CreateSimpleFileMappingObject( pathname, outObject ); + char *pathname = urlString; + if((strncmp(urlString, "file://", 7) == 0) || (strncmp(urlString, "file|//", 7) == 0)) + { + pathname += 7; + } + return MP4CreateSimpleFileMappingObject(pathname, outObject); } -MP4Err MP4AssertFileExists( char *pathName ) +MP4Err MP4AssertFileExists(char *pathName) { - MP4Err err; - struct stat buf; + MP4Err err; + struct stat buf; - err = stat( pathName, &buf ); - if ( err ) - { - BAILWITHERROR( MP4FileNotFoundErr ); - } + err = stat(pathName, &buf); + if(err) + { + BAILWITHERROR(MP4FileNotFoundErr); + } bail: - return err; + return err; } diff --git a/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.h b/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.h index 4936fdc..15b7afa 100644 --- a/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.h +++ b/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SimpleFileMappingObject.h,v 1.1 2002/10/08 10:27:59 fred Exp $ + $Id: SimpleFileMappingObject.h,v 1.1 2002/10/08 10:27:59 fred Exp $ */ #ifndef INCLUDED_SIMPLEFILEMAPPING_OBJECT_H #define INCLUDED_SIMPLEFILEMAPPING_OBJECT_H @@ -30,15 +30,15 @@ derivative works. Copyright (c) 1999. typedef struct SimpleFileMappingObjectRecord { - COMMON_FILEMAPPING_OBJECT_FIELDS - char *fileName; - int fd; - /* u64 size64; */ - u32 window_size; - - u64 window; + COMMON_FILEMAPPING_OBJECT_FIELDS + char *fileName; + int fd; + /* u64 size64; */ + u32 window_size; + + u64 window; } SimpleFileMappingObjectRecord, *SimpleFileMappingObject; -MP4Err MP4CreateSimpleFileMappingObject( char *filename, FileMappingObject *outObject ); +MP4Err MP4CreateSimpleFileMappingObject(char *filename, FileMappingObject *outObject); #endif diff --git a/IsoLib/libisomediafile/src/AMRSpecificInfoAtom.c b/IsoLib/libisomediafile/src/AMRSpecificInfoAtom.c index eb910d3..5f05167 100644 --- a/IsoLib/libisomediafile/src/AMRSpecificInfoAtom.c +++ b/IsoLib/libisomediafile/src/AMRSpecificInfoAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. and Ericsson Research -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,110 +15,110 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. The copyright owners retain full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) Apple Computer and Telefonaktiebolaget LM Ericsson 2001 */ /* - $Id: AMRSpecificInfoAtom.c,v 1.2 2001/10/25 15:53:24 erapefh Exp $ + $Id: AMRSpecificInfoAtom.c,v 1.2 2001/10/25 15:53:24 erapefh Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4AMRSpecificInfoAtomPtr self; - err = MP4NoErr; - self = (MP4AMRSpecificInfoAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4AMRSpecificInfoAtomPtr self; + err = MP4NoErr; + self = (MP4AMRSpecificInfoAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4AMRSpecificInfoAtomPtr self = (MP4AMRSpecificInfoAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32(vendor ); - PUT8( decoder_version ); - PUT16(mode_set ); - PUT8( mode_change_period ); - PUT8( frames_per_sample ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4AMRSpecificInfoAtomPtr self = (MP4AMRSpecificInfoAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(vendor); + PUT8(decoder_version); + PUT16(mode_set); + PUT8(mode_change_period); + PUT8(frames_per_sample); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4AMRSpecificInfoAtomPtr self = (MP4AMRSpecificInfoAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 4+2+(3*1); + MP4Err err; + MP4AMRSpecificInfoAtomPtr self = (MP4AMRSpecificInfoAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 4 + 2 + (3 * 1); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4AMRSpecificInfoAtomPtr self = (MP4AMRSpecificInfoAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32(vendor ); - GET8( decoder_version ); - GET16(mode_set ); - GET8( mode_change_period ); - GET8( frames_per_sample ); - + MP4Err err; + MP4AMRSpecificInfoAtomPtr self = (MP4AMRSpecificInfoAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(vendor); + GET8(decoder_version); + GET16(mode_set); + GET8(mode_change_period); + GET8(frames_per_sample); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateAMRSpecificInfoAtom( MP4AMRSpecificInfoAtomPtr *outAtom ) +MP4Err MP4CreateAMRSpecificInfoAtom(MP4AMRSpecificInfoAtomPtr *outAtom) { - MP4Err err; - MP4AMRSpecificInfoAtomPtr self; - - self = (MP4AMRSpecificInfoAtomPtr) calloc( 1, sizeof(MP4AMRSpecificInfoAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4AMRSpecificInfoAtomType; - self->name = "AMR specific info"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4AMRSpecificInfoAtomPtr self; + + self = (MP4AMRSpecificInfoAtomPtr)calloc(1, sizeof(MP4AMRSpecificInfoAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4AMRSpecificInfoAtomType; + self->name = "AMR specific info"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/AMRWPSpecificInfoAtom.c b/IsoLib/libisomediafile/src/AMRWPSpecificInfoAtom.c index 3b178c5..fbe52af 100644 --- a/IsoLib/libisomediafile/src/AMRWPSpecificInfoAtom.c +++ b/IsoLib/libisomediafile/src/AMRWPSpecificInfoAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. and Ericsson Research -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,103 +15,103 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. The copyright owners retain full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) Apple Computer and Telefonaktiebolaget LM Ericsson 2001 */ /* - $Id: AMRWPSpecificInfoAtom.c,v 1.1 2004/10/26 15:01:47 eanital Exp $ + $Id: AMRWPSpecificInfoAtom.c,v 1.1 2004/10/26 15:01:47 eanital Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4AMRWPSpecificInfoAtomPtr self; - err = MP4NoErr; - self = (MP4AMRWPSpecificInfoAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4AMRWPSpecificInfoAtomPtr self; + err = MP4NoErr; + self = (MP4AMRWPSpecificInfoAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4AMRWPSpecificInfoAtomPtr self = (MP4AMRWPSpecificInfoAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32(vendor ); - PUT8( decoder_version ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4AMRWPSpecificInfoAtomPtr self = (MP4AMRWPSpecificInfoAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(vendor); + PUT8(decoder_version); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4AMRWPSpecificInfoAtomPtr self = (MP4AMRWPSpecificInfoAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 4+1; + MP4Err err; + MP4AMRWPSpecificInfoAtomPtr self = (MP4AMRWPSpecificInfoAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 4 + 1; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4AMRWPSpecificInfoAtomPtr self = (MP4AMRWPSpecificInfoAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32(vendor ); - GET8( decoder_version ); - + MP4Err err; + MP4AMRWPSpecificInfoAtomPtr self = (MP4AMRWPSpecificInfoAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(vendor); + GET8(decoder_version); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateAMRWPSpecificInfoAtom( MP4AMRWPSpecificInfoAtomPtr *outAtom ) +MP4Err MP4CreateAMRWPSpecificInfoAtom(MP4AMRWPSpecificInfoAtomPtr *outAtom) { - MP4Err err; - MP4AMRWPSpecificInfoAtomPtr self; - - self = (MP4AMRWPSpecificInfoAtomPtr) calloc( 1, sizeof(MP4AMRWPSpecificInfoAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4AMRWPSpecificInfoAtomType; - self->name = "AMRWP specific info"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4AMRWPSpecificInfoAtomPtr self; + + self = (MP4AMRWPSpecificInfoAtomPtr)calloc(1, sizeof(MP4AMRWPSpecificInfoAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4AMRWPSpecificInfoAtomType; + self->name = "AMRWP specific info"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/AdditionalMetaDataContainerAtom.c b/IsoLib/libisomediafile/src/AdditionalMetaDataContainerAtom.c index 0b68536..2c4656c 100644 --- a/IsoLib/libisomediafile/src/AdditionalMetaDataContainerAtom.c +++ b/IsoLib/libisomediafile/src/AdditionalMetaDataContainerAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 2014. @@ -25,57 +25,60 @@ derivative works. Copyright (c) 2014. #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISOAdditionalMetaDataContainerAtomPtr self; - err = MP4NoErr; - self = (ISOAdditionalMetaDataContainerAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ); - - DESTROY_ATOM_LIST_F(metaList); - DESTROY_ATOM_LIST_F(relationList); - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + ISOAdditionalMetaDataContainerAtomPtr self; + err = MP4NoErr; + self = (ISOAdditionalMetaDataContainerAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + DESTROY_ATOM_LIST_F(metaList); + DESTROY_ATOM_LIST_F(relationList); + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err addAtom( ISOAdditionalMetaDataContainerAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(ISOAdditionalMetaDataContainerAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; + MP4Err err; + err = MP4NoErr; + + switch(atom->type) + { + case ISOMetaAtomType: + err = MP4AddListEntry(atom, self->metaList); + if(err) goto bail; + break; + + case ISOMetaboxRelationAtomType: + err = MP4AddListEntry(atom, self->relationList); + if(err) goto bail; + break; + default: + break; + } - switch( atom->type ) - { - case ISOMetaAtomType: - err = MP4AddListEntry(atom, self->metaList); if (err) goto bail; - break; - - case ISOMetaboxRelationAtomType: - err = MP4AddListEntry(atom, self->relationList); if (err) goto bail; - break; - default: break; - } - bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { MP4Err err; - ISOAdditionalMetaDataContainerAtomPtr self = (ISOAdditionalMetaDataContainerAtomPtr) s; - err = MP4NoErr; + ISOAdditionalMetaDataContainerAtomPtr self = (ISOAdditionalMetaDataContainerAtomPtr)s; + err = MP4NoErr; err = MP4SerializeCommonBaseAtomFields(s, buffer); - if (err) { + if(err) + { goto bail; } @@ -91,15 +94,16 @@ static MP4Err serialize( struct MP4Atom* s, char* buffer ) return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { MP4Err err; - ISOAdditionalMetaDataContainerAtomPtr self = (ISOAdditionalMetaDataContainerAtomPtr) s; - err = MP4NoErr; + ISOAdditionalMetaDataContainerAtomPtr self = (ISOAdditionalMetaDataContainerAtomPtr)s; + err = MP4NoErr; err = MP4CalculateBaseAtomFieldSize(s); - if (err) { + if(err) + { goto bail; } @@ -112,133 +116,144 @@ static MP4Err calculateSize( struct MP4Atom* s ) return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(ISOAdditionalMetaDataContainerAtom); + PARSE_ATOM_LIST(ISOAdditionalMetaDataContainerAtom); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addMeta( struct ISOAdditionalMetaDataContainerAtom* self, MP4AtomPtr meta ) +static MP4Err addMeta(struct ISOAdditionalMetaDataContainerAtom *self, MP4AtomPtr meta) { - u32 i; - MP4Err err; - ISOMetaAtomPtr metaPtr; - - err = MP4NoErr; - - metaPtr = (ISOMetaAtomPtr) meta; - - for (i = 0; i < self->metaList->entryCount; i++) - { - ISOMetaAtomPtr tempMetaPtr; - err = MP4GetListEntry(self->metaList, i, (char **) &tempMetaPtr); if (err) goto bail; - if (tempMetaPtr->type == metaPtr->type) - BAILWITHERROR(MP4BadParamErr); - } - - err = MP4AddListEntry(metaPtr, self->metaList); if (err) goto bail; - + u32 i; + MP4Err err; + ISOMetaAtomPtr metaPtr; + + err = MP4NoErr; + + metaPtr = (ISOMetaAtomPtr)meta; + + for(i = 0; i < self->metaList->entryCount; i++) + { + ISOMetaAtomPtr tempMetaPtr; + err = MP4GetListEntry(self->metaList, i, (char **)&tempMetaPtr); + if(err) goto bail; + if(tempMetaPtr->type == metaPtr->type) BAILWITHERROR(MP4BadParamErr); + } + + err = MP4AddListEntry(metaPtr, self->metaList); + if(err) goto bail; + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err getMeta( struct ISOAdditionalMetaDataContainerAtom* self, u32 type, ISOMetaAtomPtr *outMetaPtr ) +static MP4Err getMeta(struct ISOAdditionalMetaDataContainerAtom *self, u32 type, + ISOMetaAtomPtr *outMetaPtr) { - u32 i; - MP4Err err; - MP4HandlerAtomPtr hdlr; - - err = MP4NoErr; - *outMetaPtr = NULL; - - for (i = 0; i < self->metaList->entryCount; i++) + u32 i; + MP4Err err; + MP4HandlerAtomPtr hdlr; + + err = MP4NoErr; + *outMetaPtr = NULL; + + for(i = 0; i < self->metaList->entryCount; i++) + { + ISOMetaAtomPtr tempMetaPtr; + err = MP4GetListEntry(self->metaList, i, (char **)&tempMetaPtr); + if(err) goto bail; + hdlr = (MP4HandlerAtomPtr)tempMetaPtr->hdlr; + if(hdlr->handlerType == type) { - ISOMetaAtomPtr tempMetaPtr; - err = MP4GetListEntry(self->metaList, i, (char **) &tempMetaPtr); if (err) goto bail; - hdlr = (MP4HandlerAtomPtr) tempMetaPtr->hdlr; - if (hdlr->handlerType == type) - { - *outMetaPtr = tempMetaPtr; - break; - } + *outMetaPtr = tempMetaPtr; + break; } - + } + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err setMdat( struct ISOAdditionalMetaDataContainerAtom* self, MP4AtomPtr mdat ) +static MP4Err setMdat(struct ISOAdditionalMetaDataContainerAtom *self, MP4AtomPtr mdat) { - u32 i; - MP4Err err; - - err = MP4NoErr; - - for (i = 0; i < self->metaList->entryCount; i++) - { - ISOMetaAtomPtr meta; - err = MP4GetListEntry(self->metaList, i, (char **) &meta); if (err) goto bail; - err = meta->setMdat(meta, mdat); if (err) goto bail; - } + u32 i; + MP4Err err; + + err = MP4NoErr; + + for(i = 0; i < self->metaList->entryCount; i++) + { + ISOMetaAtomPtr meta; + err = MP4GetListEntry(self->metaList, i, (char **)&meta); + if(err) goto bail; + err = meta->setMdat(meta, mdat); + if(err) goto bail; + } bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err mdatMoved(struct ISOAdditionalMetaDataContainerAtom* self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) +static MP4Err mdatMoved(struct ISOAdditionalMetaDataContainerAtom *self, u64 mdatBase, u64 mdatEnd, + s32 mdatOffset) { - u32 i; - MP4Err err; - - err = MP4NoErr; - - for (i = 0; i < self->metaList->entryCount; i++) - { - ISOMetaAtomPtr meta; - err = MP4GetListEntry(self->metaList, i, (char **) &meta); if (err) goto bail; - err = meta->mdatMoved(meta, mdatBase, mdatEnd, mdatOffset); if (err) goto bail; - } + u32 i; + MP4Err err; + + err = MP4NoErr; + + for(i = 0; i < self->metaList->entryCount; i++) + { + ISOMetaAtomPtr meta; + err = MP4GetListEntry(self->metaList, i, (char **)&meta); + if(err) goto bail; + err = meta->mdatMoved(meta, mdatBase, mdatEnd, mdatOffset); + if(err) goto bail; + } bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err ISOCreateAdditionalMetaDataContainerAtom( ISOAdditionalMetaDataContainerAtomPtr *outAtom ) +MP4Err ISOCreateAdditionalMetaDataContainerAtom(ISOAdditionalMetaDataContainerAtomPtr *outAtom) { - MP4Err err; - ISOAdditionalMetaDataContainerAtomPtr self; - - self = (ISOAdditionalMetaDataContainerAtomPtr) calloc( 1, sizeof(ISOAdditionalMetaDataContainerAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOAdditionalMetaDataContainerAtomType; - self->name = "Additional Metadata Container"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addMeta = addMeta; - self->getMeta = getMeta; - self->mdatMoved = mdatMoved; - self->setMdat = setMdat; - - err = MP4MakeLinkedList( &self->metaList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->relationList ); if (err) goto bail; - - *outAtom = self; + MP4Err err; + ISOAdditionalMetaDataContainerAtomPtr self; + + self = + (ISOAdditionalMetaDataContainerAtomPtr)calloc(1, sizeof(ISOAdditionalMetaDataContainerAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOAdditionalMetaDataContainerAtomType; + self->name = "Additional Metadata Container"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addMeta = addMeta; + self->getMeta = getMeta; + self->mdatMoved = mdatMoved; + self->setMdat = setMdat; + + err = MP4MakeLinkedList(&self->metaList); + if(err) goto bail; + err = MP4MakeLinkedList(&self->relationList); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/AudioSampleEntryAtom.c b/IsoLib/libisomediafile/src/AudioSampleEntryAtom.c index 8f98a68..4667e1e 100644 --- a/IsoLib/libisomediafile/src/AudioSampleEntryAtom.c +++ b/IsoLib/libisomediafile/src/AudioSampleEntryAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,122 +15,124 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: AudioSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: AudioSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4AudioSampleEntryAtomPtr self; - err = MP4NoErr; - self = (MP4AudioSampleEntryAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST_F( ExtensionAtomList ) - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4AudioSampleEntryAtomPtr self; + err = MP4NoErr; + self = (MP4AudioSampleEntryAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST_F(ExtensionAtomList) + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4AudioSampleEntryAtomPtr self = (MP4AudioSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( self->reserved, 6 ); - PUT16( dataReferenceIndex ); - PUTBYTES( self->reserved2, 8 ); - PUT16( reserved3 ); - PUT16( reserved4 ); - PUT32( reserved5 ); - PUT16( timeScale ); - PUT16( reserved6 ); - SERIALIZE_ATOM_LIST( ExtensionAtomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4AudioSampleEntryAtomPtr self = (MP4AudioSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(self->reserved, 6); + PUT16(dataReferenceIndex); + PUTBYTES(self->reserved2, 8); + PUT16(reserved3); + PUT16(reserved4); + PUT32(reserved5); + PUT16(timeScale); + PUT16(reserved6); + SERIALIZE_ATOM_LIST(ExtensionAtomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4AudioSampleEntryAtomPtr self = (MP4AudioSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 14 + (1*4)+(5*2); - ADD_ATOM_LIST_SIZE( ExtensionAtomList ); + MP4Err err; + MP4AudioSampleEntryAtomPtr self = (MP4AudioSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 14 + (1 * 4) + (5 * 2); + ADD_ATOM_LIST_SIZE(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4AudioSampleEntryAtomPtr self = (MP4AudioSampleEntryAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GETBYTES( 6, reserved ); - GET16( dataReferenceIndex ); - GETBYTES( 8, reserved2 ); - GET16( reserved3 ); - GET16( reserved4 ); - GET32( reserved5 ); - GET16( timeScale ); - GET16( reserved6 ); - GETATOM_LIST( ExtensionAtomList ); + MP4Err err; + MP4AudioSampleEntryAtomPtr self = (MP4AudioSampleEntryAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GETBYTES(6, reserved); + GET16(dataReferenceIndex); + GETBYTES(8, reserved2); + GET16(reserved3); + GET16(reserved4); + GET32(reserved5); + GET16(timeScale); + GET16(reserved6); + GETATOM_LIST(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateAudioSampleEntryAtom( MP4AudioSampleEntryAtomPtr *outAtom ) +MP4Err MP4CreateAudioSampleEntryAtom(MP4AudioSampleEntryAtomPtr *outAtom) { - MP4Err err; - MP4AudioSampleEntryAtomPtr self; - - self = (MP4AudioSampleEntryAtomPtr) calloc( 1, sizeof(MP4AudioSampleEntryAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4AudioSampleEntryAtomType; - self->name = "audio sample entry"; - err = MP4MakeLinkedList( &self->ExtensionAtomList ); if (err) goto bail; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->reserved3 = 2; - self->reserved4 = 16; - self->timeScale = 44100; - *outAtom = self; + MP4Err err; + MP4AudioSampleEntryAtomPtr self; + + self = (MP4AudioSampleEntryAtomPtr)calloc(1, sizeof(MP4AudioSampleEntryAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4AudioSampleEntryAtomType; + self->name = "audio sample entry"; + err = MP4MakeLinkedList(&self->ExtensionAtomList); + if(err) goto bail; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->reserved3 = 2; + self->reserved4 = 16; + self->timeScale = 44100; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/BaseDescriptor.c b/IsoLib/libisomediafile/src/BaseDescriptor.c index e0bbb23..71b2b8a 100644 --- a/IsoLib/libisomediafile/src/BaseDescriptor.c +++ b/IsoLib/libisomediafile/src/BaseDescriptor.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,40 +15,42 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: BaseDescriptor.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: BaseDescriptor.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include "MP4Impl.h" - -MP4Err MP4EncodeBaseDescriptor( struct MP4DescriptorRecord* self, char* buffer ) +MP4Err MP4EncodeBaseDescriptor(struct MP4DescriptorRecord *self, char *buffer) { - MP4Err err; - u32 length; - u8 vals[ 4 ]; - err = MP4NoErr; - - self->bytesWritten = 0; - - length = self->size - DESCRIPTOR_TAG_LEN_SIZE; - vals[ 3 ] = (u8) (length & 0x7f); length >>= 7; - vals[ 2 ] = (u8) ((length & 0x7f) | 0x80); length >>= 7; - vals[ 1 ] = (u8) ((length & 0x7f) | 0x80); length >>= 7; - vals[ 0 ] = (u8) ((length & 0x7f) | 0x80); - PUT8( tag ); - PUT8_V( vals[0] ); - PUT8_V( vals[1] ); - PUT8_V( vals[2] ); - PUT8_V( vals[3] ); + MP4Err err; + u32 length; + u8 vals[4]; + err = MP4NoErr; + + self->bytesWritten = 0; + + length = self->size - DESCRIPTOR_TAG_LEN_SIZE; + vals[3] = (u8)(length & 0x7f); + length >>= 7; + vals[2] = (u8)((length & 0x7f) | 0x80); + length >>= 7; + vals[1] = (u8)((length & 0x7f) | 0x80); + length >>= 7; + vals[0] = (u8)((length & 0x7f) | 0x80); + PUT8(tag); + PUT8_V(vals[0]); + PUT8_V(vals[1]); + PUT8_V(vals[2]); + PUT8_V(vals[3]); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/BitRateAtom.c b/IsoLib/libisomediafile/src/BitRateAtom.c index 6590661..572e0bd 100644 --- a/IsoLib/libisomediafile/src/BitRateAtom.c +++ b/IsoLib/libisomediafile/src/BitRateAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. and Ericsson Research -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,118 +15,122 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. The copyright owners retain full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) Apple Computer and Telefonaktiebolaget LM Ericsson 2001 */ /* - $Id: BitRateAtom.c,v 1.1 2004/09/15 17:00:48 erapefh Exp $ + $Id: BitRateAtom.c,v 1.1 2004/09/15 17:00:48 erapefh Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4BitRateAtomPtr self; - err = MP4NoErr; - self = (MP4BitRateAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4BitRateAtomPtr self; + err = MP4NoErr; + self = (MP4BitRateAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4BitRateAtomPtr self = (MP4BitRateAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - if (self->type == MP4BitRateAtomType) { - PUT32( buffersizeDB ); - PUT32( max_bitrate ); - PUT32( avg_bitrate ); - } - else { - PUT32( avg_bitrate ); - PUT32( max_bitrate ); - } - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4BitRateAtomPtr self = (MP4BitRateAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + if(self->type == MP4BitRateAtomType) + { + PUT32(buffersizeDB); + PUT32(max_bitrate); + PUT32(avg_bitrate); + } + else + { + PUT32(avg_bitrate); + PUT32(max_bitrate); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4BitRateAtomPtr self = (MP4BitRateAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 4+4; - if (self->type == MP4BitRateAtomType) self->size += 4; + MP4Err err; + MP4BitRateAtomPtr self = (MP4BitRateAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 4 + 4; + if(self->type == MP4BitRateAtomType) self->size += 4; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4BitRateAtomPtr self = (MP4BitRateAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - if (self->type == MP4BitRateAtomType) { - GET32( buffersizeDB ); - GET32( max_bitrate ); - GET32( avg_bitrate ); - } - else { - GET32( avg_bitrate ); - GET32( max_bitrate ); - } - + MP4Err err; + MP4BitRateAtomPtr self = (MP4BitRateAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + if(self->type == MP4BitRateAtomType) + { + GET32(buffersizeDB); + GET32(max_bitrate); + GET32(avg_bitrate); + } + else + { + GET32(avg_bitrate); + GET32(max_bitrate); + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateBitRateAtom( MP4BitRateAtomPtr *outAtom ) +MP4Err MP4CreateBitRateAtom(MP4BitRateAtomPtr *outAtom) { - MP4Err err; - MP4BitRateAtomPtr self; - - self = (MP4BitRateAtomPtr) calloc( 1, sizeof(MP4BitRateAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4BitRateAtomType; - self->name = "Bitrate"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4BitRateAtomPtr self; + + self = (MP4BitRateAtomPtr)calloc(1, sizeof(MP4BitRateAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4BitRateAtomType; + self->name = "Bitrate"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ChannelLayoutAtom.c b/IsoLib/libisomediafile/src/ChannelLayoutAtom.c index 77d893a..8a93c6a 100644 --- a/IsoLib/libisomediafile/src/ChannelLayoutAtom.c +++ b/IsoLib/libisomediafile/src/ChannelLayoutAtom.c @@ -28,267 +28,317 @@ #include #include -#define SPEAKER_POSITION_EXPLICIT 126 -#define STREAM_STRUCTURE_CHANNELS 0x1 -#define STREAM_STRUCTURE_OBJECTS 0x2 +#define SPEAKER_POSITION_EXPLICIT 126 +#define STREAM_STRUCTURE_CHANNELS 0x1 +#define STREAM_STRUCTURE_OBJECTS 0x2 -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4ChannelLayoutAtomPtr self = (MP4ChannelLayoutAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ); + MP4Err err; + MP4ChannelLayoutAtomPtr self = (MP4ChannelLayoutAtomPtr)s; + err = MP4NoErr; - if (self->definedLayouts != NULL) { - while (self->definedLayouts->entryCount > 0) - { - MP4ChannelLayoutDefinedLayout *definedLayout; - MP4GetListEntry(self->definedLayouts, 0, (char**) &definedLayout); - free (definedLayout); - MP4DeleteListEntry(self->definedLayouts, 0); - } - MP4DeleteLinkedList(self->definedLayouts); + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + if(self->definedLayouts != NULL) + { + while(self->definedLayouts->entryCount > 0) + { + MP4ChannelLayoutDefinedLayout *definedLayout; + MP4GetListEntry(self->definedLayouts, 0, (char **)&definedLayout); + free(definedLayout); + MP4DeleteListEntry(self->definedLayouts, 0); } - if ( self->super ) - self->super->destroy( s ); + MP4DeleteLinkedList(self->definedLayouts); + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - u16 i; - MP4Err err; - u8 tmp8; - MP4ChannelLayoutDefinedLayout *definedLayoutStruct; - MP4ChannelLayoutAtomPtr self = (MP4ChannelLayoutAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - if (self->version == 0) { - PUT8(stream_structure); - if (self->stream_structure & STREAM_STRUCTURE_CHANNELS) { - PUT8(definedLayout); - if (self->definedLayout == 0) { - for (i = 0; i < self->channelCount; i++){ - err = MP4GetListEntry(self->definedLayouts, i, (char**) &definedLayoutStruct); if (err) goto bail; - PUT8_V(definedLayoutStruct->speaker_position); - if (definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT){ - PUT16_V(definedLayoutStruct->azimuth); - PUT8_V(definedLayoutStruct->elevation); - } - } - } - else { - PUT64(omittedChannelsMap); - } - } - if (self->stream_structure & STREAM_STRUCTURE_OBJECTS) { - PUT8(object_count); + u16 i; + MP4Err err; + u8 tmp8; + MP4ChannelLayoutDefinedLayout *definedLayoutStruct; + MP4ChannelLayoutAtomPtr self = (MP4ChannelLayoutAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + if(self->version == 0) + { + PUT8(stream_structure); + if(self->stream_structure & STREAM_STRUCTURE_CHANNELS) + { + PUT8(definedLayout); + if(self->definedLayout == 0) + { + for(i = 0; i < self->channelCount; i++) + { + err = MP4GetListEntry(self->definedLayouts, i, (char **)&definedLayoutStruct); + if(err) goto bail; + PUT8_V(definedLayoutStruct->speaker_position); + if(definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT) + { + PUT16_V(definedLayoutStruct->azimuth); + PUT8_V(definedLayoutStruct->elevation); + } } + } + else + { + PUT64(omittedChannelsMap); + } + } + if(self->stream_structure & STREAM_STRUCTURE_OBJECTS) + { + PUT8(object_count); } - else { /* version > 0 */ - tmp8 = (self->stream_structure << 4) + self->formatOrdering; + } + else + { /* version > 0 */ + tmp8 = (self->stream_structure << 4) + self->formatOrdering; + PUT8_V(tmp8); + PUT8(baseChannelCount); + if(self->stream_structure & STREAM_STRUCTURE_CHANNELS) + { + PUT8(definedLayout); + if(self->definedLayout == 0) + { + PUT8(layoutChannelCount); + for(i = 0; i < self->layoutChannelCount; i++) + { + err = MP4GetListEntry(self->definedLayouts, i, (char **)&definedLayoutStruct); + if(err) goto bail; + PUT8_V(definedLayoutStruct->speaker_position); + if(definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT) + { + PUT16_V(definedLayoutStruct->azimuth); + PUT8_V(definedLayoutStruct->elevation); + } + } + } + else + { + tmp8 = (self->channelOrderDefinition << 1) + self->omittedChannelsPresent; PUT8_V(tmp8); - PUT8(baseChannelCount); - if (self->stream_structure & STREAM_STRUCTURE_CHANNELS) { - PUT8(definedLayout); - if (self->definedLayout == 0) { - PUT8(layoutChannelCount); - for (i = 0; i < self->layoutChannelCount; i++){ - err = MP4GetListEntry(self->definedLayouts, i, (char**) &definedLayoutStruct); if (err) goto bail; - PUT8_V(definedLayoutStruct->speaker_position); - if (definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT){ - PUT16_V(definedLayoutStruct->azimuth); - PUT8_V(definedLayoutStruct->elevation); - } - } - } - else { - tmp8 = (self->channelOrderDefinition << 1) + self->omittedChannelsPresent; - PUT8_V(tmp8); - if (self->omittedChannelsPresent) { - PUT64(omittedChannelsMap); - } - } + if(self->omittedChannelsPresent) + { + PUT64(omittedChannelsMap); } + } } - assert( self->bytesWritten == self->size ); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - u16 i; - MP4ChannelLayoutDefinedLayout *definedLayoutStruct; - MP4ChannelLayoutAtomPtr self = (MP4ChannelLayoutAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; + MP4Err err; + u16 i; + MP4ChannelLayoutDefinedLayout *definedLayoutStruct; + MP4ChannelLayoutAtomPtr self = (MP4ChannelLayoutAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; - if (self->version == 0) { + if(self->version == 0) + { + self->size += 1; + if(self->stream_structure & STREAM_STRUCTURE_CHANNELS) + { + self->size += 1; + if(self->definedLayout == 0) + { + for(i = 0; i < self->channelCount; i++) + { + MP4GetListEntry(self->definedLayouts, i, (char **)&definedLayoutStruct); + self->size += 1; + if(definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT) + { + self->size += 3; + } + } + } + else + { + self->size += 8; + } + } + if(self->stream_structure & STREAM_STRUCTURE_OBJECTS) + { + self->size += 1; + } + } + else + { /* version > 0 */ + self->size += 2; + if(self->stream_structure & STREAM_STRUCTURE_CHANNELS) + { + self->size += 1; + if(self->definedLayout == 0) + { self->size += 1; - if (self->stream_structure & STREAM_STRUCTURE_CHANNELS){ - self->size += 1; - if (self->definedLayout == 0) { - for (i = 0; i < self->channelCount; i++) { - MP4GetListEntry(self->definedLayouts, i, (char**) &definedLayoutStruct); - self->size += 1; - if (definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT) { - self->size += 3; - } - } - } - else { - self->size += 8; - } + for(i = 0; i < self->layoutChannelCount; i++) + { + MP4GetListEntry(self->definedLayouts, i, (char **)&definedLayoutStruct); + self->size += 1; + if(definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT) + { + self->size += 3; + } } - if (self->stream_structure & STREAM_STRUCTURE_OBJECTS) { - self->size += 1; + } + else + { + self->size += 1; + if(self->omittedChannelsPresent) + { + self->size += 8; } + } } - else { /* version > 0 */ - self->size += 2; - if (self->stream_structure & STREAM_STRUCTURE_CHANNELS){ - self->size += 1; - if (self->definedLayout == 0) { - self->size += 1; - for (i = 0; i < self->layoutChannelCount; i++) { - MP4GetListEntry(self->definedLayouts, i, (char**) &definedLayoutStruct); - self->size += 1; - if (definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT) { - self->size += 3; - } - } - } - else { - self->size += 1; - if (self->omittedChannelsPresent) { - self->size += 8; - } - } - } - } - + } + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - u32 tmp8, i; - MP4Err err; - MP4ChannelLayoutAtomPtr self = (MP4ChannelLayoutAtomPtr) s; + u32 tmp8, i; + MP4Err err; + MP4ChannelLayoutAtomPtr self = (MP4ChannelLayoutAtomPtr)s; - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; - if (self->version == 0) { - GET8(stream_structure); - if (self->stream_structure & STREAM_STRUCTURE_CHANNELS) { - GET8(definedLayout); - if (self->definedLayout == 0) { - while ( self->bytesRead < self->size) { - MP4ChannelLayoutDefinedLayout *definedLayoutStruct; - definedLayoutStruct = calloc(1, sizeof(MP4ChannelLayoutDefinedLayout)); - GET8_V(definedLayoutStruct->speaker_position); - if (definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT) { - GET16_V(definedLayoutStruct->azimuth); - GET8_V(definedLayoutStruct->elevation); - } - else { - definedLayoutStruct->azimuth = 0; - definedLayoutStruct->elevation = 0; - } - err = MP4AddListEntry(definedLayoutStruct, self->definedLayouts); if ( err ) goto bail; - } - } - else { - GET64(omittedChannelsMap); - } - } - if (self->stream_structure & STREAM_STRUCTURE_OBJECTS) { - GET8(object_count); + if(self->version == 0) + { + GET8(stream_structure); + if(self->stream_structure & STREAM_STRUCTURE_CHANNELS) + { + GET8(definedLayout); + if(self->definedLayout == 0) + { + while(self->bytesRead < self->size) + { + MP4ChannelLayoutDefinedLayout *definedLayoutStruct; + definedLayoutStruct = calloc(1, sizeof(MP4ChannelLayoutDefinedLayout)); + GET8_V(definedLayoutStruct->speaker_position); + if(definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT) + { + GET16_V(definedLayoutStruct->azimuth); + GET8_V(definedLayoutStruct->elevation); + } + else + { + definedLayoutStruct->azimuth = 0; + definedLayoutStruct->elevation = 0; + } + err = MP4AddListEntry(definedLayoutStruct, self->definedLayouts); + if(err) goto bail; } + } + else + { + GET64(omittedChannelsMap); + } + } + if(self->stream_structure & STREAM_STRUCTURE_OBJECTS) + { + GET8(object_count); } - else { /* version > 0 */ + } + else + { /* version > 0 */ + GET8_V(tmp8); + self->stream_structure = tmp8 >> 4; + self->formatOrdering = tmp8 & 0xF; + GET8(baseChannelCount); + if(self->stream_structure & STREAM_STRUCTURE_CHANNELS) + { + GET8(definedLayout); + if(self->definedLayout == 0) + { + GET8(layoutChannelCount); + for(i = 0; i < self->layoutChannelCount; i++) + { + MP4ChannelLayoutDefinedLayout *definedLayoutStruct; + definedLayoutStruct = calloc(1, sizeof(MP4ChannelLayoutDefinedLayout)); + GET8_V(definedLayoutStruct->speaker_position); + if(definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT) + { + GET16_V(definedLayoutStruct->azimuth); + GET8_V(definedLayoutStruct->elevation); + } + else + { + definedLayoutStruct->azimuth = 0; + definedLayoutStruct->elevation = 0; + } + err = MP4AddListEntry(definedLayoutStruct, self->definedLayouts); + if(err) goto bail; + } + } + else + { GET8_V(tmp8); - self->stream_structure = tmp8 >> 4; - self->formatOrdering = tmp8 & 0xF; - GET8(baseChannelCount); - if (self->stream_structure & STREAM_STRUCTURE_CHANNELS) { - GET8(definedLayout); - if (self->definedLayout == 0) { - GET8(layoutChannelCount); - for (i=0; ilayoutChannelCount; i++) { - MP4ChannelLayoutDefinedLayout *definedLayoutStruct; - definedLayoutStruct = calloc(1, sizeof(MP4ChannelLayoutDefinedLayout)); - GET8_V(definedLayoutStruct->speaker_position); - if (definedLayoutStruct->speaker_position == SPEAKER_POSITION_EXPLICIT) - { - GET16_V(definedLayoutStruct->azimuth); - GET8_V(definedLayoutStruct->elevation); - } - else { - definedLayoutStruct->azimuth = 0; - definedLayoutStruct->elevation = 0; - } - err = MP4AddListEntry(definedLayoutStruct, self->definedLayouts); if ( err ) goto bail; - } - } - else { - GET8_V(tmp8); - self->channelOrderDefinition = (tmp8 >> 1) & 0x7; - self->omittedChannelsPresent = tmp8 & 0x1; - if (self->omittedChannelsPresent) { - GET64(omittedChannelsMap); - } - } + self->channelOrderDefinition = (tmp8 >> 1) & 0x7; + self->omittedChannelsPresent = tmp8 & 0x1; + if(self->omittedChannelsPresent) + { + GET64(omittedChannelsMap); } + } } - assert( self->bytesRead == self->size ); + } + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateChannelLayoutAtom( MP4ChannelLayoutAtomPtr *outAtom ) +MP4Err MP4CreateChannelLayoutAtom(MP4ChannelLayoutAtomPtr *outAtom) { - MP4Err err; - MP4ChannelLayoutAtomPtr self; - - self = (MP4ChannelLayoutAtomPtr) calloc( 1, sizeof(MP4ChannelLayoutAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4ChannelLayoutAtomType; - self->name = "channel layout"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - err = MP4MakeLinkedList(&self->definedLayouts); if ( err ) goto bail; - - *outAtom = self; + MP4Err err; + MP4ChannelLayoutAtomPtr self; + + self = (MP4ChannelLayoutAtomPtr)calloc(1, sizeof(MP4ChannelLayoutAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4ChannelLayoutAtomType; + self->name = "channel layout"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + err = MP4MakeLinkedList(&self->definedLayouts); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/ChunkOffsetAtom.c b/IsoLib/libisomediafile/src/ChunkOffsetAtom.c index a6ea9e9..645c928 100644 --- a/IsoLib/libisomediafile/src/ChunkOffsetAtom.c +++ b/IsoLib/libisomediafile/src/ChunkOffsetAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ChunkOffsetAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ChunkOffsetAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -29,214 +29,221 @@ derivative works. Copyright (c) 1999. #define allocation_size 8192 -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4ChunkOffsetAtomPtr self; - err = MP4NoErr; - self = (MP4ChunkOffsetAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->offsets ) - { - free( self->offsets ); - self->offsets = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4ChunkOffsetAtomPtr self; + err = MP4NoErr; + self = (MP4ChunkOffsetAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->offsets) + { + free(self->offsets); + self->offsets = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - MP4ChunkOffsetAtomPtr self = (MP4ChunkOffsetAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( entryCount ); - if (self->type == MP4ChunkOffsetAtomType) { - u32 theoffset; - for ( i = 0; i < self->entryCount; i++ ) - { - theoffset = (u32) self->offsets[i]; - PUT32_V( theoffset ); - } - } else if (self->type == MP4ChunkLargeOffsetAtomType) { - for ( i = 0; i < self->entryCount; i++ ) - { - PUT64_V( self->offsets[i] ); - } - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + MP4ChunkOffsetAtomPtr self = (MP4ChunkOffsetAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(entryCount); + if(self->type == MP4ChunkOffsetAtomType) + { + u32 theoffset; + for(i = 0; i < self->entryCount; i++) + { + theoffset = (u32)self->offsets[i]; + PUT32_V(theoffset); + } + } + else if(self->type == MP4ChunkLargeOffsetAtomType) + { + for(i = 0; i < self->entryCount; i++) + { + PUT64_V(self->offsets[i]); + } + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static u32 getChunkCount( MP4AtomPtr self) -{ - return ((MP4ChunkOffsetAtomPtr) self)->entryCount; -} +static u32 getChunkCount(MP4AtomPtr self) { return ((MP4ChunkOffsetAtomPtr)self)->entryCount; } -static MP4Err addOffset(struct MP4ChunkOffsetAtom *s, u64 offset ) +static MP4Err addOffset(struct MP4ChunkOffsetAtom *s, u64 offset) { - MP4Err err; - MP4ChunkOffsetAtomPtr self; - - self = (MP4ChunkOffsetAtomPtr) s; - - err = MP4NoErr; - self->entryCount++; - if ((self->entryCount * sizeof(u64)) > self->allocatedSize) { - self->allocatedSize += allocation_size; - - if (self->offsets != NULL) - self->offsets = (u64*) realloc( self->offsets, self->allocatedSize ); - else - self->offsets = (u64*) calloc( self->allocatedSize, 1 ); - TESTMALLOC( self->offsets ); - } - self->offsets[ self->entryCount - 1 ] = offset; + MP4Err err; + MP4ChunkOffsetAtomPtr self; + + self = (MP4ChunkOffsetAtomPtr)s; + + err = MP4NoErr; + self->entryCount++; + if((self->entryCount * sizeof(u64)) > self->allocatedSize) + { + self->allocatedSize += allocation_size; + + if(self->offsets != NULL) self->offsets = (u64 *)realloc(self->offsets, self->allocatedSize); + else + self->offsets = (u64 *)calloc(self->allocatedSize, 1); + TESTMALLOC(self->offsets); + } + self->offsets[self->entryCount - 1] = offset; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4ChunkOffsetAtomPtr self = (MP4ChunkOffsetAtomPtr) s; - u32 i; - err = MP4NoErr; - - self->type = MP4ChunkOffsetAtomType; - for ( i = 0; i < self->entryCount; i++ ) - { - if (( self->offsets[i] >> 32 ) != 0) { - self->type = MP4ChunkLargeOffsetAtomType; - break; - } - } - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - if (self->type == MP4ChunkOffsetAtomType) - self->size += 4 + (4 * self->entryCount); - else - self->size += 4 + (8 * self->entryCount); + MP4Err err; + MP4ChunkOffsetAtomPtr self = (MP4ChunkOffsetAtomPtr)s; + u32 i; + err = MP4NoErr; + + self->type = MP4ChunkOffsetAtomType; + for(i = 0; i < self->entryCount; i++) + { + if((self->offsets[i] >> 32) != 0) + { + self->type = MP4ChunkLargeOffsetAtomType; + break; + } + } + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + if(self->type == MP4ChunkOffsetAtomType) self->size += 4 + (4 * self->entryCount); + else + self->size += 4 + (8 * self->entryCount); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getChunkOffset( MP4AtomPtr s, u32 chunkIndex, u64 *outOffset ) +static MP4Err getChunkOffset(MP4AtomPtr s, u32 chunkIndex, u64 *outOffset) { - MP4Err err; - MP4ChunkOffsetAtomPtr self = (MP4ChunkOffsetAtomPtr) s; - - err = MP4NoErr; - if ( (self == NULL) || (outOffset == NULL) || (chunkIndex == 0) || (chunkIndex > self->entryCount) ) - BAILWITHERROR( MP4BadParamErr ) - *outOffset = self->offsets[ chunkIndex - 1 ]; + MP4Err err; + MP4ChunkOffsetAtomPtr self = (MP4ChunkOffsetAtomPtr)s; + + err = MP4NoErr; + if((self == NULL) || (outOffset == NULL) || (chunkIndex == 0) || (chunkIndex > self->entryCount)) + BAILWITHERROR(MP4BadParamErr) + *outOffset = self->offsets[chunkIndex - 1]; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err mdatMoved(MP4ChunkOffsetAtomPtr self, u32 firstchunk, u32 lastchunk, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) +static MP4Err mdatMoved(MP4ChunkOffsetAtomPtr self, u32 firstchunk, u32 lastchunk, u64 mdatBase, + u64 mdatEnd, s32 mdatOffset) { - MP4Err err; - u32 j; - - err = MP4NoErr; - if ( (self == NULL) || (firstchunk == 0) || (firstchunk > self->entryCount) || - (lastchunk == 0) || (lastchunk > self->entryCount) ) - BAILWITHERROR( MP4BadParamErr ) - for (j=firstchunk-1; j<=(lastchunk-1); j++) { - if ((self->offsets[j] >= mdatBase) && (self->offsets[j] < mdatEnd)) - self->offsets[j] += mdatOffset; - } + MP4Err err; + u32 j; + + err = MP4NoErr; + if((self == NULL) || (firstchunk == 0) || (firstchunk > self->entryCount) || (lastchunk == 0) || + (lastchunk > self->entryCount)) + BAILWITHERROR(MP4BadParamErr) + for(j = firstchunk - 1; j <= (lastchunk - 1); j++) + { + if((self->offsets[j] >= mdatBase) && (self->offsets[j] < mdatEnd)) + self->offsets[j] += mdatOffset; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 entries; - u64* p; - MP4ChunkOffsetAtomPtr self = (MP4ChunkOffsetAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( entryCount ); - if (self->entryCount > 0) { - self->offsets = (u64 *) calloc( self->entryCount, sizeof(u64) ); - TESTMALLOC( self->offsets ); - self->allocatedSize = (self->entryCount) * sizeof(u64); - if (self->type == MP4ChunkOffsetAtomType) { - for ( entries = 0, p = self->offsets; entries < self->entryCount; entries++, p++ ) - { - u32 offset; - GET32_V( offset ); - *p = offset; - } - } - else if (self->type == MP4ChunkLargeOffsetAtomType) { - for ( entries = 0, p = self->offsets; entries < self->entryCount; entries++, p++ ) - { - u64 offset; - GET64_V( offset ); - *p = offset; - } - } - else BAILWITHERROR( MP4InternalErr ); - } - + MP4Err err; + u32 entries; + u64 *p; + MP4ChunkOffsetAtomPtr self = (MP4ChunkOffsetAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(entryCount); + if(self->entryCount > 0) + { + self->offsets = (u64 *)calloc(self->entryCount, sizeof(u64)); + TESTMALLOC(self->offsets); + self->allocatedSize = (self->entryCount) * sizeof(u64); + if(self->type == MP4ChunkOffsetAtomType) + { + for(entries = 0, p = self->offsets; entries < self->entryCount; entries++, p++) + { + u32 offset; + GET32_V(offset); + *p = offset; + } + } + else if(self->type == MP4ChunkLargeOffsetAtomType) + { + for(entries = 0, p = self->offsets; entries < self->entryCount; entries++, p++) + { + u64 offset; + GET64_V(offset); + *p = offset; + } + } + else + BAILWITHERROR(MP4InternalErr); + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateChunkOffsetAtom( MP4ChunkOffsetAtomPtr *outAtom ) +MP4Err MP4CreateChunkOffsetAtom(MP4ChunkOffsetAtomPtr *outAtom) { - MP4Err err; - MP4ChunkOffsetAtomPtr self; - - self = (MP4ChunkOffsetAtomPtr) calloc( 1, sizeof(MP4ChunkOffsetAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4ChunkOffsetAtomType; - self->name = "chunk offset"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->getChunkOffset = getChunkOffset; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addOffset = addOffset; - self->getChunkCount = getChunkCount; - self->mdatMoved = mdatMoved; - *outAtom = self; + MP4Err err; + MP4ChunkOffsetAtomPtr self; + + self = (MP4ChunkOffsetAtomPtr)calloc(1, sizeof(MP4ChunkOffsetAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4ChunkOffsetAtomType; + self->name = "chunk offset"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->getChunkOffset = getChunkOffset; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addOffset = addOffset; + self->getChunkCount = getChunkCount; + self->mdatMoved = mdatMoved; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ClockReferenceMediaHeader.c b/IsoLib/libisomediafile/src/ClockReferenceMediaHeader.c index 7efad37..bb30776 100644 --- a/IsoLib/libisomediafile/src/ClockReferenceMediaHeader.c +++ b/IsoLib/libisomediafile/src/ClockReferenceMediaHeader.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,96 +15,96 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ClockReferenceMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ClockReferenceMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - - MP4ClockReferenceMediaHeaderAtomPtr self = (MP4ClockReferenceMediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - assert( self->bytesWritten == self->size ); + MP4Err err; + + MP4ClockReferenceMediaHeaderAtomPtr self = (MP4ClockReferenceMediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; + MP4Err err; - err = MP4NoErr; - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; + err = MP4NoErr; + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4ClockReferenceMediaHeaderAtomPtr self = (MP4ClockReferenceMediaHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; + MP4Err err; + MP4ClockReferenceMediaHeaderAtomPtr self = (MP4ClockReferenceMediaHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateClockReferenceMediaHeaderAtom( MP4ClockReferenceMediaHeaderAtomPtr *outAtom ) +MP4Err MP4CreateClockReferenceMediaHeaderAtom(MP4ClockReferenceMediaHeaderAtomPtr *outAtom) { - MP4Err err; - MP4ClockReferenceMediaHeaderAtomPtr self; - - self = (MP4ClockReferenceMediaHeaderAtomPtr) calloc( 1, sizeof(MP4ClockReferenceMediaHeaderAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4ClockReferenceMediaHeaderAtomType; - self->name = "clock reference media header"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4ClockReferenceMediaHeaderAtomPtr self; + + self = (MP4ClockReferenceMediaHeaderAtomPtr)calloc(1, sizeof(MP4ClockReferenceMediaHeaderAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4ClockReferenceMediaHeaderAtomType; + self->name = "clock reference media header"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c b/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c index 103d904..100422f 100644 --- a/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c +++ b/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -27,724 +27,849 @@ derivative works. Copyright (c) 1999. #define allocation_size 8192 -enum { - kMaxPatternLength = 32, - kUpperNibblePresent = 0x8000 +enum +{ + kMaxPatternLength = 32, + kUpperNibblePresent = 0x8000 }; -/* PatternTracker is maintained as an array for each sample input. -patternStart at index k, represents the start index of the pattern which helped yield the most efficient way to encode samples from [0, k] inclusive with patternLength, repeated sampleCount times -cumulativeMemoryCost at index k, represents the memory cost associated with most efficient way to encode samples from [0, k] inclusive. Default considers each sample as a distinct non-pattern -prevEfficientIndex at index k, represents the end of the most efficient previous pattern/ non-pattern before k which helped yield the cumulativeMemoryCost at index k. -nextEfficientIndex is populated after back-tracking prevEfficientIndex to easily create compact sample groups +/* PatternTracker is maintained as an array for each sample input. +patternStart at index k, represents the start index of the pattern which helped yield the most +efficient way to encode samples from [0, k] inclusive with patternLength, repeated sampleCount times +cumulativeMemoryCost at index k, represents the memory cost associated with most efficient way to +encode samples from [0, k] inclusive. Default considers each sample as a distinct non-pattern +prevEfficientIndex at index k, represents the end of the most efficient previous pattern/ +non-pattern before k which helped yield the cumulativeMemoryCost at index k. nextEfficientIndex is +populated after back-tracking prevEfficientIndex to easily create compact sample groups */ -typedef struct { - u32 patternStart; - u32 patternLength; - u32 sampleCount; - s32 cumulativeMemoryCost; - s32 prevEfficientIndex; - s32 nextEfficientIndex; +typedef struct +{ + u32 patternStart; + u32 patternLength; + u32 sampleCount; + s32 cumulativeMemoryCost; + s32 prevEfficientIndex; + s32 nextEfficientIndex; } PatternTracker; - /* - Compacting Algorithm: - 1. Run through sample group set: i=[0,n] - a. Expand the input samples - b. Initialize memory costs in tracker assuming each sample is a distinct non-pattern C[i] = (i*indexFieldSize) - 2. Run through sample group set: i=[0,n] - a. Update memory cost considering sample i is a distinct non-pattern C[i] = min(C[i] , C[i-1]+ indexFieldSize) - b. For pattern lengths, p=[1, 32] - i. Consider patterns ending at i, from [start=i-p, i] in the Search buffer. - ii. Extend right end from [i+1, n] in the look ahead buffer - 1. As long as the pattern repeats, keep extending right end and update memory cost - C[end] = min(C[end] , C[start-1] + p*indexFieldSize - 2. If C[end] got modified, a more efficient pattern was found, maintain previousEfficientIndex = start-1 for backtracking. - 3. Tracker[n-1] represents most efficienct way to encode samples [0,n]. Run through tracker backwards from last sample: i[n-1, 0]. - a. Use previousEfficientIndex to populate nextEfficientIndex to easily create compact sample groups - b. Patterns with (pattern length == sample count == 1), are combined and considered as non-pattern - -Algorithm can further be optimized by making memory cost consider patternLength and sampleCount field sizes - */ - -typedef struct { - u32* groupIndex; - u32 sampleCount; - PatternTracker* patternTracker; - u8 groupIndexFieldSize; +/* +Compacting Algorithm: +1. Run through sample group set: i=[0,n] + a. Expand the input samples + b. Initialize memory costs in tracker assuming each sample is a distinct non-pattern C[i] = +(i*indexFieldSize) +2. Run through sample group set: i=[0,n] + a. Update memory cost considering sample i is a distinct non-pattern C[i] = min(C[i] , +C[i-1]+ indexFieldSize) b. For pattern lengths, p=[1, 32] i. Consider patterns ending at i, from +[start=i-p, i] in the Search buffer. ii. Extend right end from [i+1, n] in the look ahead buffer + 1. As long as the pattern repeats, keep extending right end and +update memory cost C[end] = min(C[end] , C[start-1] + p*indexFieldSize + 2. If C[end] got modified, a more efficient pattern was found, +maintain previousEfficientIndex = start-1 for backtracking. +3. Tracker[n-1] represents most efficienct way to encode samples [0,n]. Run through tracker +backwards from last sample: i[n-1, 0]. a. Use previousEfficientIndex to populate nextEfficientIndex +to easily create compact sample groups b. Patterns with (pattern length == sample count == 1), are +combined and considered as non-pattern + +Algorithm can further be optimized by making memory cost consider patternLength and sampleCount +field sizes +*/ + +typedef struct +{ + u32 *groupIndex; + u32 sampleCount; + PatternTracker *patternTracker; + u8 groupIndexFieldSize; } SampleGroupInfo; u8 GetFieldSize(u32 value, u8 localFragmentUsed) { - if (localFragmentUsed) { - if (value < 8) { - return 4; - } else if (value < 128) { - return 8; - } else if (value < 32768) { - return 16; - } else { - return 32; - } - } else { - if (value < 16) { - return 4; - } else if (value < 256) { - return 8; - } else if (value < 65536) { - return 16; - } else { - return 32; - } - } + if(localFragmentUsed) + { + if(value < 8) + { + return 4; + } + else if(value < 128) + { + return 8; + } + else if(value < 32768) + { + return 16; + } + else + { + return 32; + } + } + else + { + if(value < 16) + { + return 4; + } + else if(value < 256) + { + return 8; + } + else if(value < 65536) + { + return 16; + } + else + { + return 32; + } + } } u8 SetFieldSize(u32 fieldSize) { - assert(fieldSize == 4 || fieldSize == 8 || fieldSize == 16 || fieldSize == 32); - switch(fieldSize) - { - case 4: - return 0; - break; - case 8: - return 1; - break; - case 16: - return 2; - break; - case 32: - return 3; - break; - }; - return 0; + assert(fieldSize == 4 || fieldSize == 8 || fieldSize == 16 || fieldSize == 32); + switch(fieldSize) + { + case 4: + return 0; + break; + case 8: + return 1; + break; + case 16: + return 2; + break; + case 32: + return 3; + break; + }; + return 0; } -void AppendDescriptionIndexToCompactGroup(CompressedGroupInfo* compressedGroup, u32 descIndex, u32 groupIndex) +void AppendDescriptionIndexToCompactGroup(CompressedGroupInfo *compressedGroup, u32 descIndex, + u32 groupIndex) { - assert(descIndex < compressedGroup->totalIndexDescriptionCount); - compressedGroup->indexDescriptionArray[descIndex] = groupIndex; + assert(descIndex < compressedGroup->totalIndexDescriptionCount); + compressedGroup->indexDescriptionArray[descIndex] = groupIndex; } -void AppendNewPatternEntry(CompressedGroupInfo* compressedGroup, u32 index, u32 patternLength, u32 sampleCount) +void AppendNewPatternEntry(CompressedGroupInfo *compressedGroup, u32 index, u32 patternLength, + u32 sampleCount) { - assert(patternLength != 0); - assert(sampleCount != 0); - assert(index < compressedGroup->patternCount); - /*printf("\n New pattern: length %d sampleCount %d", patternLength, sampleCount); */ - - compressedGroup->patternEntries[index].patternLength = patternLength; - compressedGroup->patternEntries[index].sampleCount = sampleCount; - compressedGroup->totalSampleCount += sampleCount; + assert(patternLength != 0); + assert(sampleCount != 0); + assert(index < compressedGroup->patternCount); + /*printf("\n New pattern: length %d sampleCount %d", patternLength, sampleCount); */ + + compressedGroup->patternEntries[index].patternLength = patternLength; + compressedGroup->patternEntries[index].sampleCount = sampleCount; + compressedGroup->totalSampleCount += sampleCount; } -void SetMemoryCostForPattern(SampleGroupInfo *sampleGroup, u32 patternLength, u32 startPatternSampleIndex, u32 endPatternSampleIndex) +void SetMemoryCostForPattern(SampleGroupInfo *sampleGroup, u32 patternLength, + u32 startPatternSampleIndex, u32 endPatternSampleIndex) { - u32 sampleCount = endPatternSampleIndex - startPatternSampleIndex + 1; - - assert(startPatternSampleIndex + patternLength <= endPatternSampleIndex); - - s32 memoryCost = startPatternSampleIndex <= 0 ? sampleGroup->patternTracker[0].cumulativeMemoryCost : sampleGroup->patternTracker[startPatternSampleIndex - 1].cumulativeMemoryCost; - memoryCost += (patternLength * sampleGroup->groupIndexFieldSize); - - if(memoryCost < sampleGroup->patternTracker[endPatternSampleIndex].cumulativeMemoryCost) { - PatternTracker patTrack; - patTrack.patternStart = startPatternSampleIndex; - patTrack.patternLength = patternLength; - patTrack.sampleCount = sampleCount; - patTrack.cumulativeMemoryCost = memoryCost; - patTrack.prevEfficientIndex = startPatternSampleIndex - 1; - - sampleGroup->patternTracker[endPatternSampleIndex] = patTrack; - /*printf("\n Pattern run of pattern length %d, sample count %d, starting @ %3d with memoryCost %d and prevMostEffIndex %d", patternLength, sampleCount, startPatternSampleIndex, patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex); */ - } + u32 sampleCount = endPatternSampleIndex - startPatternSampleIndex + 1; + + assert(startPatternSampleIndex + patternLength <= endPatternSampleIndex); + + s32 memoryCost = + startPatternSampleIndex <= 0 + ? sampleGroup->patternTracker[0].cumulativeMemoryCost + : sampleGroup->patternTracker[startPatternSampleIndex - 1].cumulativeMemoryCost; + memoryCost += (patternLength * sampleGroup->groupIndexFieldSize); + + if(memoryCost < sampleGroup->patternTracker[endPatternSampleIndex].cumulativeMemoryCost) + { + PatternTracker patTrack; + patTrack.patternStart = startPatternSampleIndex; + patTrack.patternLength = patternLength; + patTrack.sampleCount = sampleCount; + patTrack.cumulativeMemoryCost = memoryCost; + patTrack.prevEfficientIndex = startPatternSampleIndex - 1; + + sampleGroup->patternTracker[endPatternSampleIndex] = patTrack; + /*printf("\n Pattern run of pattern length %d, sample count %d, starting @ %3d with memoryCost + * %d and prevMostEffIndex %d", patternLength, sampleCount, startPatternSampleIndex, + * patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex); */ + } } void SetMemoryCostForNonPattern(SampleGroupInfo *sampleGroup, s32 sampleIndex) { - s32 memoryCost = (sampleIndex < 1 ? sampleGroup->patternTracker[0].cumulativeMemoryCost: sampleGroup->patternTracker[sampleIndex-1].cumulativeMemoryCost) + sampleGroup->groupIndexFieldSize; - - if(memoryCost < sampleGroup->patternTracker[sampleIndex].cumulativeMemoryCost) { - PatternTracker patTrack; - patTrack.patternStart = sampleIndex; - patTrack.patternLength = 1; - patTrack.sampleCount = 1; - patTrack.cumulativeMemoryCost = memoryCost; - patTrack.prevEfficientIndex = sampleIndex-1; - - sampleGroup->patternTracker[sampleIndex] = patTrack; - /*printf("\n Writing non-pattern with memoryCost %d and prevMostEffIndex %d ", patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex);*/ - } + s32 memoryCost = + (sampleIndex < 1 ? sampleGroup->patternTracker[0].cumulativeMemoryCost + : sampleGroup->patternTracker[sampleIndex - 1].cumulativeMemoryCost) + + sampleGroup->groupIndexFieldSize; + + if(memoryCost < sampleGroup->patternTracker[sampleIndex].cumulativeMemoryCost) + { + PatternTracker patTrack; + patTrack.patternStart = sampleIndex; + patTrack.patternLength = 1; + patTrack.sampleCount = 1; + patTrack.cumulativeMemoryCost = memoryCost; + patTrack.prevEfficientIndex = sampleIndex - 1; + + sampleGroup->patternTracker[sampleIndex] = patTrack; + /*printf("\n Writing non-pattern with memoryCost %d and prevMostEffIndex %d ", + * patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex);*/ + } } -void CombineNonPatterns(SampleGroupInfo *sampleGroup, CompressedGroupInfo* compressedGroup) +void CombineNonPatterns(SampleGroupInfo *sampleGroup, CompressedGroupInfo *compressedGroup) { - s32 prevIndex = sampleGroup->sampleCount -1; - s32 nextIndex = sampleGroup->sampleCount; - PatternTracker* patternTracker = sampleGroup->patternTracker; - - /* Post-process output pattern tracker. Get Pattern Count, Populate the nextIndex to navigate easily*/ - while(prevIndex >= 0 && prevIndex < sampleGroup->sampleCount) - { - u32 consecutiveNonPatterns = 0; - s32 i = prevIndex; - while(i >= 0 && i < sampleGroup->sampleCount && (patternTracker[i].patternLength == 1) && (patternTracker[i].sampleCount == 1)) - { - consecutiveNonPatterns++; - i = patternTracker[i].prevEfficientIndex; - } - if(consecutiveNonPatterns) { - patternTracker[prevIndex].patternLength = consecutiveNonPatterns; - patternTracker[prevIndex].sampleCount = consecutiveNonPatterns; - patternTracker[prevIndex].patternStart -= (consecutiveNonPatterns - 1); - compressedGroup->totalIndexDescriptionCount += consecutiveNonPatterns; - patternTracker[prevIndex].prevEfficientIndex = i; - } - else { - compressedGroup->totalIndexDescriptionCount += patternTracker[prevIndex].patternLength; - } - - patternTracker[prevIndex].nextEfficientIndex = nextIndex; - nextIndex = prevIndex; - prevIndex = patternTracker[prevIndex].prevEfficientIndex; - - compressedGroup->patternCount++; - } - compressedGroup->efficientStartIndex = nextIndex; + s32 prevIndex = sampleGroup->sampleCount - 1; + s32 nextIndex = sampleGroup->sampleCount; + PatternTracker *patternTracker = sampleGroup->patternTracker; + + /* Post-process output pattern tracker. Get Pattern Count, Populate the nextIndex to navigate + * easily*/ + while(prevIndex >= 0 && prevIndex < sampleGroup->sampleCount) + { + u32 consecutiveNonPatterns = 0; + s32 i = prevIndex; + while(i >= 0 && i < sampleGroup->sampleCount && (patternTracker[i].patternLength == 1) && + (patternTracker[i].sampleCount == 1)) + { + consecutiveNonPatterns++; + i = patternTracker[i].prevEfficientIndex; + } + if(consecutiveNonPatterns) + { + patternTracker[prevIndex].patternLength = consecutiveNonPatterns; + patternTracker[prevIndex].sampleCount = consecutiveNonPatterns; + patternTracker[prevIndex].patternStart -= (consecutiveNonPatterns - 1); + compressedGroup->totalIndexDescriptionCount += consecutiveNonPatterns; + patternTracker[prevIndex].prevEfficientIndex = i; + } + else + { + compressedGroup->totalIndexDescriptionCount += patternTracker[prevIndex].patternLength; + } + + patternTracker[prevIndex].nextEfficientIndex = nextIndex; + nextIndex = prevIndex; + prevIndex = patternTracker[prevIndex].prevEfficientIndex; + + compressedGroup->patternCount++; + } + compressedGroup->efficientStartIndex = nextIndex; } void FindPatternsStartingAtIndex(SampleGroupInfo *sampleGroup, u32 sampleIndex) { - u32 p; - assert(sampleIndex < sampleGroup->sampleCount); - - /* Update memoryCost in case current sample is considered as a non-pattern*/ - SetMemoryCostForNonPattern(sampleGroup, sampleIndex); - - for (p = 1; p <= kMaxPatternLength; p++) - { - if(sampleIndex < p) - break; - - if (sampleGroup->groupIndex[sampleIndex] == sampleGroup->groupIndex[sampleIndex - p]) { - u32 startPatternSampleIndex = sampleIndex - p; - u32 i = sampleIndex; - while (i < sampleGroup->sampleCount && sampleGroup->groupIndex[i] == sampleGroup->groupIndex[i - p]) { - SetMemoryCostForPattern(sampleGroup, p, startPatternSampleIndex, i); - i++; - } - - /* Pattern ended at i - 1. - printf("\n %3d: pattern run ended", i-1); - break; */ - } - } + u32 p; + assert(sampleIndex < sampleGroup->sampleCount); + + /* Update memoryCost in case current sample is considered as a non-pattern*/ + SetMemoryCostForNonPattern(sampleGroup, sampleIndex); + + for(p = 1; p <= kMaxPatternLength; p++) + { + if(sampleIndex < p) break; + + if(sampleGroup->groupIndex[sampleIndex] == sampleGroup->groupIndex[sampleIndex - p]) + { + u32 startPatternSampleIndex = sampleIndex - p; + u32 i = sampleIndex; + while(i < sampleGroup->sampleCount && + sampleGroup->groupIndex[i] == sampleGroup->groupIndex[i - p]) + { + SetMemoryCostForPattern(sampleGroup, p, startPatternSampleIndex, i); + i++; + } + + /* Pattern ended at i - 1. + printf("\n %3d: pattern run ended", i-1); + break; */ + } + } } -void InitializeSampleGroupInput(MP4CompactSampletoGroupAtomPtr self, SampleGroupInfo* sampleGroup) +void InitializeSampleGroupInput(MP4CompactSampletoGroupAtomPtr self, SampleGroupInfo *sampleGroup) { - u32 i; - sampleGroup->groupIndex = self->group_index; - sampleGroup->sampleCount = self->sampleCount; - sampleGroup->groupIndexFieldSize = self->compressedGroup.indexFieldSize; - sampleGroup->patternTracker = (PatternTracker*) malloc(sizeof(PatternTracker)*self->sampleCount); - - memset(sampleGroup->patternTracker, 0, sizeof(PatternTracker)*self->sampleCount); - - /* Expand sample group indices, get maximum field size to represent each group index*/ - u32 startValue = self->group_index[0]; - - for(i = 1; i < self->sampleCount; i++) { - if(self->group_index[i-1] == self->group_index[i]) { - self->group_index[i-1] = startValue; - } - else { - startValue = self->group_index[i]; - } - } - self->group_index[self->sampleCount-1] = startValue; - - /* Initialize efficiencies assuming each input sample is a distinct non-pattern*/ - PatternTracker patternTrackerEntry; - patternTrackerEntry.patternLength = patternTrackerEntry.sampleCount = 1; - - for(i = 0; i < self->sampleCount; i++) { - patternTrackerEntry.patternStart = i; - patternTrackerEntry.prevEfficientIndex = i-1; - patternTrackerEntry.cumulativeMemoryCost = (i+1) * sampleGroup->groupIndexFieldSize; - sampleGroup->patternTracker[i] = patternTrackerEntry; - } + u32 i; + sampleGroup->groupIndex = self->group_index; + sampleGroup->sampleCount = self->sampleCount; + sampleGroup->groupIndexFieldSize = self->compressedGroup.indexFieldSize; + sampleGroup->patternTracker = + (PatternTracker *)malloc(sizeof(PatternTracker) * self->sampleCount); + + memset(sampleGroup->patternTracker, 0, sizeof(PatternTracker) * self->sampleCount); + + /* Expand sample group indices, get maximum field size to represent each group index*/ + u32 startValue = self->group_index[0]; + + for(i = 1; i < self->sampleCount; i++) + { + if(self->group_index[i - 1] == self->group_index[i]) + { + self->group_index[i - 1] = startValue; + } + else + { + startValue = self->group_index[i]; + } + } + self->group_index[self->sampleCount - 1] = startValue; + + /* Initialize efficiencies assuming each input sample is a distinct non-pattern*/ + PatternTracker patternTrackerEntry; + patternTrackerEntry.patternLength = patternTrackerEntry.sampleCount = 1; + + for(i = 0; i < self->sampleCount; i++) + { + patternTrackerEntry.patternStart = i; + patternTrackerEntry.prevEfficientIndex = i - 1; + patternTrackerEntry.cumulativeMemoryCost = (i + 1) * sampleGroup->groupIndexFieldSize; + sampleGroup->patternTracker[i] = patternTrackerEntry; + } } void CreateCompactSampleGroups(MP4CompactSampletoGroupAtomPtr self) { - u32 j; - u32 patternIndex; - if(self->compressedGroup.isSampleGroupCompressed) - return; - - SampleGroupInfo sampleGroup; - InitializeSampleGroupInput(self, &sampleGroup); - - CompressedGroupInfo* compressedGroup = &self->compressedGroup; - compressedGroup->patternLengthFieldSize = 4; - compressedGroup->sampleCountFieldSize = 4; - compressedGroup->indexFieldSize = sampleGroup.groupIndexFieldSize; - - /* Repeatedly process, find and update efficiencies at each sample index*/ - for (j = 0; j < self->sampleCount; j++) { - FindPatternsStartingAtIndex(&sampleGroup, j); - } - - CombineNonPatterns(&sampleGroup, compressedGroup); - - if(compressedGroup->patternEntries == NULL) { - compressedGroup->patternEntries = (MP4CompactSampleToGroupPatternEntryPtr) malloc(sizeof(MP4CompactSampleToGroupPatternEntry)*compressedGroup->patternCount); - } - if(compressedGroup->indexDescriptionArray == NULL) { - compressedGroup->indexDescriptionArray = (u32*) malloc(sizeof(u32)*compressedGroup->totalIndexDescriptionCount); - } - - /*printf("\n The pattern tracker details are"); - for(int i = 0; i < self->sampleCount; i++) - { - printf("\n Index %d Start: %d PL: %d SC: %d Eff: %d PrevIndex: %d NextIndex: %d ", i, patternTracker[i].start, patternTracker[i].patternLength, patternTracker[i].sampleCount, patternTracker[i].cumulativeMemoryCost, patternTracker[i].prevEfficientIndex, patternTracker[i].nextEfficientIndex); - }*/ - - PatternTracker* patternTracker = sampleGroup.patternTracker; - u32 descIndex = 0; - u32 nextIndex = compressedGroup->efficientStartIndex; - for(patternIndex = 0; patternIndex < compressedGroup->patternCount; patternIndex++) { - u32 patternLength = patternTracker[nextIndex].patternLength; - u8 fieldSize = GetFieldSize(patternLength, 0); - if(fieldSize > compressedGroup->patternLengthFieldSize) - compressedGroup->patternLengthFieldSize = fieldSize; - - u32 sampleCount = patternTracker[nextIndex].sampleCount; - fieldSize = GetFieldSize(sampleCount, 0); - if(fieldSize > compressedGroup->sampleCountFieldSize) - compressedGroup->sampleCountFieldSize = fieldSize; - - AppendNewPatternEntry(compressedGroup, patternIndex, patternLength, sampleCount); - - assert(patternTracker[nextIndex].patternStart >= 0 && patternTracker[nextIndex].patternStart < self->sampleCount); - assert(patternTracker[nextIndex].patternStart+patternLength-1 < self->sampleCount); - - for (j = 0; j < patternLength; j++) { - u32 groupIndex = sampleGroup.groupIndex[patternTracker[nextIndex].patternStart + j]; - if(self->fragmentLocalIndexPresent) { - groupIndex = groupIndex | (1 << (self->compressedGroup.indexFieldSize - 1)); - } - AppendDescriptionIndexToCompactGroup(compressedGroup, descIndex, groupIndex); - descIndex++; - } - nextIndex = patternTracker[nextIndex].nextEfficientIndex; - } - - /* In case only patternLength or sampleCount field size is 4, ensure pattern entry is always byte aligned*/ - if((compressedGroup->patternLengthFieldSize+compressedGroup->sampleCountFieldSize) % 8) { - if(compressedGroup->patternLengthFieldSize == 4) - compressedGroup->patternLengthFieldSize = 8; - else - compressedGroup->sampleCountFieldSize = 8; - - } - - assert(descIndex == compressedGroup->totalIndexDescriptionCount); - self->compressedGroup.isSampleGroupCompressed = 1; - - free(sampleGroup.patternTracker); - sampleGroup.patternTracker = NULL; + u32 j; + u32 patternIndex; + if(self->compressedGroup.isSampleGroupCompressed) return; + + SampleGroupInfo sampleGroup; + InitializeSampleGroupInput(self, &sampleGroup); + + CompressedGroupInfo *compressedGroup = &self->compressedGroup; + compressedGroup->patternLengthFieldSize = 4; + compressedGroup->sampleCountFieldSize = 4; + compressedGroup->indexFieldSize = sampleGroup.groupIndexFieldSize; + + /* Repeatedly process, find and update efficiencies at each sample index*/ + for(j = 0; j < self->sampleCount; j++) + { + FindPatternsStartingAtIndex(&sampleGroup, j); + } + + CombineNonPatterns(&sampleGroup, compressedGroup); + + if(compressedGroup->patternEntries == NULL) + { + compressedGroup->patternEntries = (MP4CompactSampleToGroupPatternEntryPtr)malloc( + sizeof(MP4CompactSampleToGroupPatternEntry) * compressedGroup->patternCount); + } + if(compressedGroup->indexDescriptionArray == NULL) + { + compressedGroup->indexDescriptionArray = + (u32 *)malloc(sizeof(u32) * compressedGroup->totalIndexDescriptionCount); + } + + /*printf("\n The pattern tracker details are"); + for(int i = 0; i < self->sampleCount; i++) + { + printf("\n Index %d Start: %d PL: %d SC: %d Eff: %d PrevIndex: %d NextIndex: %d ", i, + patternTracker[i].start, patternTracker[i].patternLength, patternTracker[i].sampleCount, + patternTracker[i].cumulativeMemoryCost, patternTracker[i].prevEfficientIndex, + patternTracker[i].nextEfficientIndex); + }*/ + + PatternTracker *patternTracker = sampleGroup.patternTracker; + u32 descIndex = 0; + u32 nextIndex = compressedGroup->efficientStartIndex; + for(patternIndex = 0; patternIndex < compressedGroup->patternCount; patternIndex++) + { + u32 patternLength = patternTracker[nextIndex].patternLength; + u8 fieldSize = GetFieldSize(patternLength, 0); + if(fieldSize > compressedGroup->patternLengthFieldSize) + compressedGroup->patternLengthFieldSize = fieldSize; + + u32 sampleCount = patternTracker[nextIndex].sampleCount; + fieldSize = GetFieldSize(sampleCount, 0); + if(fieldSize > compressedGroup->sampleCountFieldSize) + compressedGroup->sampleCountFieldSize = fieldSize; + + AppendNewPatternEntry(compressedGroup, patternIndex, patternLength, sampleCount); + + assert(patternTracker[nextIndex].patternStart >= 0 && + patternTracker[nextIndex].patternStart < self->sampleCount); + assert(patternTracker[nextIndex].patternStart + patternLength - 1 < self->sampleCount); + + for(j = 0; j < patternLength; j++) + { + u32 groupIndex = sampleGroup.groupIndex[patternTracker[nextIndex].patternStart + j]; + if(self->fragmentLocalIndexPresent) + { + groupIndex = groupIndex | (1 << (self->compressedGroup.indexFieldSize - 1)); + } + AppendDescriptionIndexToCompactGroup(compressedGroup, descIndex, groupIndex); + descIndex++; + } + nextIndex = patternTracker[nextIndex].nextEfficientIndex; + } + + /* In case only patternLength or sampleCount field size is 4, ensure pattern entry is always byte + * aligned*/ + if((compressedGroup->patternLengthFieldSize + compressedGroup->sampleCountFieldSize) % 8) + { + if(compressedGroup->patternLengthFieldSize == 4) compressedGroup->patternLengthFieldSize = 8; + else + compressedGroup->sampleCountFieldSize = 8; + } + + assert(descIndex == compressedGroup->totalIndexDescriptionCount); + self->compressedGroup.isSampleGroupCompressed = 1; + + free(sampleGroup.patternTracker); + sampleGroup.patternTracker = NULL; } -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4CompactSampletoGroupAtomPtr self; - err = MP4NoErr; - self = (MP4CompactSampletoGroupAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->group_index != NULL ) { - free( self->group_index ); - self->group_index = NULL; - } - - if(self->compressedGroup.patternEntries != NULL) { - free(self->compressedGroup.patternEntries); - self->compressedGroup.patternEntries = NULL; - } - - if(self->compressedGroup.indexDescriptionArray != NULL) { - free(self->compressedGroup.indexDescriptionArray); - self->compressedGroup.indexDescriptionArray = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4CompactSampletoGroupAtomPtr self; + err = MP4NoErr; + self = (MP4CompactSampletoGroupAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->group_index != NULL) + { + free(self->group_index); + self->group_index = NULL; + } + + if(self->compressedGroup.patternEntries != NULL) + { + free(self->compressedGroup.patternEntries); + self->compressedGroup.patternEntries = NULL; + } + + if(self->compressedGroup.indexDescriptionArray != NULL) + { + free(self->compressedGroup.indexDescriptionArray); + self->compressedGroup.indexDescriptionArray = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err ensureSize( struct MP4CompactSampletoGroupAtom *self, u32 newSize ) +static MP4Err ensureSize(struct MP4CompactSampletoGroupAtom *self, u32 newSize) { - MP4Err err; - - err = MP4NoErr; - - if (newSize > self->allocatedSize) { - self->allocatedSize += allocation_size; - if (newSize > self->allocatedSize) self->allocatedSize = newSize; - - if (self->group_index != NULL) - self->group_index = (u32*) realloc( self->group_index, self->allocatedSize ); - else - self->group_index = (u32*) calloc( self->allocatedSize, 1 ); - - TESTMALLOC( self->group_index ); - } + MP4Err err; + + err = MP4NoErr; + + if(newSize > self->allocatedSize) + { + self->allocatedSize += allocation_size; + if(newSize > self->allocatedSize) self->allocatedSize = newSize; + + if(self->group_index != NULL) + self->group_index = (u32 *)realloc(self->group_index, self->allocatedSize); + else + self->group_index = (u32 *)calloc(self->allocatedSize, 1); + + TESTMALLOC(self->group_index); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSamples( struct MP4CompactSampletoGroupAtom *self, u32 count ) +static MP4Err addSamples(struct MP4CompactSampletoGroupAtom *self, u32 count) { - MP4Err err; - u32 *p; - u32 j; - - err = MP4NoErr; - err = ensureSize( self, (self->sampleCount + count)*sizeof(u32) ); if (err) goto bail; - - p = &((self->group_index)[self->sampleCount]); - for (j=0; jsampleCount += count; + MP4Err err; + u32 *p; + u32 j; + + err = MP4NoErr; + err = ensureSize(self, (self->sampleCount + count) * sizeof(u32)); + if(err) goto bail; + + p = &((self->group_index)[self->sampleCount]); + for(j = 0; j < count; j++) + *p++ = 0; + self->sampleCount += count; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err mapSamplestoGroup( struct MP4CompactSampletoGroupAtom *self, u32 group_index, s32 sample_index, u32 count ) +static MP4Err mapSamplestoGroup(struct MP4CompactSampletoGroupAtom *self, u32 group_index, + s32 sample_index, u32 count) { - MP4Err err; - u32 i; - u32* p; - - err = MP4NoErr; - - if (sample_index<0) { - p = &((self->group_index)[self->sampleCount + sample_index]); - if (count > ((u32) (- sample_index))) { err = MP4BadParamErr; goto bail; } - } - else { - p = &((self->group_index)[sample_index]); - if (count+sample_index > self->sampleCount) { err = MP4BadParamErr; goto bail; } - } - for (i=0; ifragmentLocalIndexPresent) > self->compressedGroup.indexFieldSize) - self->compressedGroup.indexFieldSize = GetFieldSize(group_index, self->fragmentLocalIndexPresent); + MP4Err err; + u32 i; + u32 *p; + + err = MP4NoErr; + + if(sample_index < 0) + { + p = &((self->group_index)[self->sampleCount + sample_index]); + if(count > ((u32)(-sample_index))) + { + err = MP4BadParamErr; + goto bail; + } + } + else + { + p = &((self->group_index)[sample_index]); + if(count + sample_index > self->sampleCount) + { + err = MP4BadParamErr; + goto bail; + } + } + for(i = 0; i < count; i++) + *p++ = group_index; + + if(GetFieldSize(group_index, self->fragmentLocalIndexPresent) > + self->compressedGroup.indexFieldSize) + self->compressedGroup.indexFieldSize = + GetFieldSize(group_index, self->fragmentLocalIndexPresent); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getSampleGroupMap( struct MP4CompactSampletoGroupAtom *self, u32 sampleNumber, u32* groupIndex ) +static MP4Err getSampleGroupMap(struct MP4CompactSampletoGroupAtom *self, u32 sampleNumber, + u32 *groupIndex) { - MP4Err err; - - err = MP4NoErr; - - if (sampleNumber<1) BAILWITHERROR( MP4BadParamErr ); - if (sampleNumber > self->sampleCount) - *groupIndex = 0; - else *groupIndex = (self->group_index)[sampleNumber - 1]; + MP4Err err; + + err = MP4NoErr; + + if(sampleNumber < 1) BAILWITHERROR(MP4BadParamErr); + if(sampleNumber > self->sampleCount) *groupIndex = 0; + else + *groupIndex = (self->group_index)[sampleNumber - 1]; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err GetData(MP4AtomPtr s, MP4InputStreamPtr inputStream, u8 fieldSize, u32* upperNibble, u32* outValue) +static MP4Err GetData(MP4AtomPtr s, MP4InputStreamPtr inputStream, u8 fieldSize, u32 *upperNibble, + u32 *outValue) { - MP4Err err = MP4NoErr; - MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr) s; - - if(fieldSize != 4 && fieldSize != 8 && fieldSize != 16 && fieldSize != 32) BAILWITHERROR( MP4BadParamErr ) - - u32 readData = 0; - switch(fieldSize) { - case 4: - if(*upperNibble & kUpperNibblePresent) { - *outValue = *upperNibble & 0xF; - *upperNibble = 0; - } - else { - GET8_V_MSG( readData, NULL ); - *upperNibble = (readData & 0xF) | kUpperNibblePresent; - *outValue = readData >> 4; - } - break; - case 8: - GET8_V_MSG( readData, NULL ); - *outValue = readData; - break; - case 16: - GET16_V_MSG( readData, NULL ); - *outValue = readData; - break; - case 32: - GET32_V_MSG( readData, NULL ); - *outValue = readData; - break; - } + MP4Err err = MP4NoErr; + MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr)s; + + if(fieldSize != 4 && fieldSize != 8 && fieldSize != 16 && fieldSize != 32) + BAILWITHERROR(MP4BadParamErr) + + u32 readData = 0; + switch(fieldSize) + { + case 4: + if(*upperNibble & kUpperNibblePresent) + { + *outValue = *upperNibble & 0xF; + *upperNibble = 0; + } + else + { + GET8_V_MSG(readData, NULL); + *upperNibble = (readData & 0xF) | kUpperNibblePresent; + *outValue = readData >> 4; + } + break; + case 8: + GET8_V_MSG(readData, NULL); + *outValue = readData; + break; + case 16: + GET16_V_MSG(readData, NULL); + *outValue = readData; + break; + case 32: + GET32_V_MSG(readData, NULL); + *outValue = readData; + break; + } bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err PackData(MP4CompactSampletoGroupAtomPtr self, char** bufferPtr, u8 fieldSize, u8 nonByteBoundary, u32 value) +static MP4Err PackData(MP4CompactSampletoGroupAtomPtr self, char **bufferPtr, u8 fieldSize, + u8 nonByteBoundary, u32 value) { - MP4Err err = MP4NoErr; - u32 previousByte; - char* buffer = *bufferPtr; - if(fieldSize != 4 && fieldSize != 8 && fieldSize != 16 && fieldSize != 32) BAILWITHERROR( MP4BadParamErr ) - - switch(fieldSize) - { - case 4: - /* Read the previous byte and append the new nibble to it*/ - if(nonByteBoundary) { - buffer = buffer - 1; - self->bytesWritten -= 1; - previousByte = *(u8*) buffer; - value = previousByte | (value & 0xF); - } - else { - value = value << 4; - } - PUT8_V(value); - break; - case 8: - PUT8_V(value); - break; - case 16: - PUT16_V(value); - break; - case 32: - PUT32_V(value); - break; - } - *bufferPtr = buffer; + MP4Err err = MP4NoErr; + u32 previousByte; + char *buffer = *bufferPtr; + if(fieldSize != 4 && fieldSize != 8 && fieldSize != 16 && fieldSize != 32) + BAILWITHERROR(MP4BadParamErr) + + switch(fieldSize) + { + case 4: + /* Read the previous byte and append the new nibble to it*/ + if(nonByteBoundary) + { + buffer = buffer - 1; + self->bytesWritten -= 1; + previousByte = *(u8 *)buffer; + value = previousByte | (value & 0xF); + } + else + { + value = value << 4; + } + PUT8_V(value); + break; + case 8: + PUT8_V(value); + break; + case 16: + PUT16_V(value); + break; + case 32: + PUT32_V(value); + break; + } + *bufferPtr = buffer; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err = MP4NoErr; - u32 i; - - MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr) s; - - self->flags = SetFieldSize(self->compressedGroup.indexFieldSize) | (SetFieldSize(self->compressedGroup.sampleCountFieldSize) << 2) | (SetFieldSize(self->compressedGroup.patternLengthFieldSize) << 4) | (self->fragmentLocalIndexPresent ? 0x80 : 0); - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - PUT32( grouping_type ); - /* Grouping type parameter is disabled. If enabled, will need to pack an additional byte to represent it*/ - PUT32( entryCount ); - - printf (" \n Field sizes of pattern is %d , sampleCount is %d , indexDescription is %d ", self->compressedGroup.patternLengthFieldSize, self->compressedGroup.sampleCountFieldSize, self->compressedGroup.indexFieldSize); - - printf("\n Pattern count %d covering %d total samples ", self->compressedGroup.patternCount, self->compressedGroup.totalSampleCount); - - for(i = 0; i < self->compressedGroup.patternCount; i++) { - printf("\n Pattern length %d for %d samples ", self->compressedGroup.patternEntries[i].patternLength, self->compressedGroup.patternEntries[i].sampleCount); - - /* Pattern entry is ensured to start at a byte boundary*/ - PackData(self, &buffer, self->compressedGroup.patternLengthFieldSize, 0, self->compressedGroup.patternEntries[i].patternLength); - - PackData(self, &buffer, self->compressedGroup.sampleCountFieldSize, (self->compressedGroup.patternLengthFieldSize == 4), self->compressedGroup.patternEntries[i].sampleCount); - - } - - /* Index descriptor array is ensured to start at a byte boundary*/ - printf("\n Index Descriptors array is: "); - for(i = 0; i < self->compressedGroup.totalIndexDescriptionCount; i++) { - printf(" %d ", self->compressedGroup.indexDescriptionArray[i]); - PackData(self, &buffer, self->compressedGroup.indexFieldSize, (i&1) , self->compressedGroup.indexDescriptionArray[i]); - } - - assert( self->bytesWritten == self->size ); - + MP4Err err = MP4NoErr; + u32 i; + + MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr)s; + + self->flags = SetFieldSize(self->compressedGroup.indexFieldSize) | + (SetFieldSize(self->compressedGroup.sampleCountFieldSize) << 2) | + (SetFieldSize(self->compressedGroup.patternLengthFieldSize) << 4) | + (self->fragmentLocalIndexPresent ? 0x80 : 0); + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + PUT32(grouping_type); + /* Grouping type parameter is disabled. If enabled, will need to pack an additional byte to + * represent it*/ + PUT32(entryCount); + + printf(" \n Field sizes of pattern is %d , sampleCount is %d , indexDescription is %d ", + self->compressedGroup.patternLengthFieldSize, self->compressedGroup.sampleCountFieldSize, + self->compressedGroup.indexFieldSize); + + printf("\n Pattern count %d covering %d total samples ", self->compressedGroup.patternCount, + self->compressedGroup.totalSampleCount); + + for(i = 0; i < self->compressedGroup.patternCount; i++) + { + printf("\n Pattern length %d for %d samples ", + self->compressedGroup.patternEntries[i].patternLength, + self->compressedGroup.patternEntries[i].sampleCount); + + /* Pattern entry is ensured to start at a byte boundary*/ + PackData(self, &buffer, self->compressedGroup.patternLengthFieldSize, 0, + self->compressedGroup.patternEntries[i].patternLength); + + PackData(self, &buffer, self->compressedGroup.sampleCountFieldSize, + (self->compressedGroup.patternLengthFieldSize == 4), + self->compressedGroup.patternEntries[i].sampleCount); + } + + /* Index descriptor array is ensured to start at a byte boundary*/ + printf("\n Index Descriptors array is: "); + for(i = 0; i < self->compressedGroup.totalIndexDescriptionCount; i++) + { + printf(" %d ", self->compressedGroup.indexDescriptionArray[i]); + PackData(self, &buffer, self->compressedGroup.indexFieldSize, (i & 1), + self->compressedGroup.indexDescriptionArray[i]); + } + + assert(self->bytesWritten == self->size); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err = MP4NoErr; - MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr) s; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - - CreateCompactSampleGroups(self); - - /* If grouping type parameter is enabled in flags, will need to add an additional byte*/ - self->size += 8; - - u32 sizeInBits = (self->compressedGroup.patternCount*(self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); - sizeInBits += (self->compressedGroup.totalIndexDescriptionCount*self->compressedGroup.indexFieldSize); - self->size = self->size + (sizeInBits+4)/8; - - self->entryCount = self->compressedGroup.patternCount; - + MP4Err err = MP4NoErr; + MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr)s; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + CreateCompactSampleGroups(self); + + /* If grouping type parameter is enabled in flags, will need to add an additional byte*/ + self->size += 8; + + u32 sizeInBits = + (self->compressedGroup.patternCount * + (self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); + sizeInBits += + (self->compressedGroup.totalIndexDescriptionCount * self->compressedGroup.indexFieldSize); + self->size = self->size + (sizeInBits + 4) / 8; + + self->entryCount = self->compressedGroup.patternCount; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i, j; - u32* p; - u32 flags; - MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr) s; - char typeString[ 8 ]; - char msgString[ 80 ]; - u8 indexFieldSize, countFieldSize, patternFieldSize; - char groupingTypeParamPresent; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - flags = self->flags; - - indexFieldSize = 4 << ((flags & 0x3) >> 0); - if(indexFieldSize != 4 && indexFieldSize != 8 && indexFieldSize != 16 && indexFieldSize != 32) BAILWITHERROR( MP4BadParamErr ) - - countFieldSize = 4 << ((flags & 0xC) >> 2); - if(countFieldSize != 4 && countFieldSize != 8 && countFieldSize != 16 && countFieldSize != 32) BAILWITHERROR( MP4BadParamErr ) - - patternFieldSize = 4 << ((flags & 0x30) >> 4); - if(patternFieldSize != 4 && patternFieldSize != 8 && patternFieldSize != 16 && patternFieldSize != 32) BAILWITHERROR( MP4BadParamErr ) - - /* Ensure each pattern entry is always byte-aligned*/ - if((patternFieldSize + countFieldSize) % 8 ) BAILWITHERROR( MP4BadParamErr ) - - self->fragmentLocalIndexPresent = (flags & 0x80); - groupingTypeParamPresent = (flags & 0x40); - - sprintf( msgString, "field size for index %d , sample count %d pattern length %d ", indexFieldSize, countFieldSize, patternFieldSize ); - inputStream->msg( inputStream, msgString ); - - GET32( grouping_type ); - MP4TypeToString( self->grouping_type, typeString ); - sprintf( msgString, "grouping type is '%s'", typeString ); - inputStream->msg( inputStream, msgString ); - - if(groupingTypeParamPresent) { - GET32( groupingTypeParameter ); - } - - GET32( entryCount ); - - MP4CompactSampleToGroupPatternEntryPtr patternEntries = malloc(self->entryCount* sizeof(MP4CompactSampleToGroupPatternEntry)); - TESTMALLOC( patternEntries ); - u32 upperNibble = 0; - - for (i=0; ientryCount; i++) { - u32 sampleCount, patternLength; - - GetData(s, inputStream, patternFieldSize, &upperNibble, &patternLength); - patternEntries[i].patternLength = patternLength; - - GetData(s, inputStream, countFieldSize, &upperNibble, &sampleCount); - patternEntries[i].sampleCount = sampleCount; - self->sampleCount += sampleCount; - - sprintf( msgString, "pattern entry %d: pattern length->%d sample count->%d ", i+1, patternLength, sampleCount ); - inputStream->msg( inputStream, msgString ); - - } - - err = ensureSize( self, self->sampleCount*sizeof(u32) ); if (err) goto bail; - p = &((self->group_index)[0]); - - sprintf(msgString, "Index description values are:" ); - inputStream->msg( inputStream, msgString ); - for (i=0; ientryCount; i++) { - u32* patternStart = p; - u32 mask = self->fragmentLocalIndexPresent? 0xFFFFFFFF >> (32 - indexFieldSize + 1): 0xFFFFFFFF; - for (j=0; jmsg( inputStream, msgString ); - - free(patternEntries); - patternEntries = NULL; - + MP4Err err; + u32 i, j; + u32 *p; + u32 flags; + MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr)s; + char typeString[8]; + char msgString[80]; + u8 indexFieldSize, countFieldSize, patternFieldSize; + char groupingTypeParamPresent; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + flags = self->flags; + + indexFieldSize = 4 << ((flags & 0x3) >> 0); + if(indexFieldSize != 4 && indexFieldSize != 8 && indexFieldSize != 16 && indexFieldSize != 32) + BAILWITHERROR(MP4BadParamErr) + + countFieldSize = 4 << ((flags & 0xC) >> 2); + if(countFieldSize != 4 && countFieldSize != 8 && countFieldSize != 16 && countFieldSize != 32) + BAILWITHERROR(MP4BadParamErr) + + patternFieldSize = 4 << ((flags & 0x30) >> 4); + if(patternFieldSize != 4 && patternFieldSize != 8 && patternFieldSize != 16 && + patternFieldSize != 32) + BAILWITHERROR(MP4BadParamErr) + + /* Ensure each pattern entry is always byte-aligned*/ + if((patternFieldSize + countFieldSize) % 8) BAILWITHERROR(MP4BadParamErr) + + self->fragmentLocalIndexPresent = (flags & 0x80); + groupingTypeParamPresent = (flags & 0x40); + + sprintf(msgString, "field size for index %d , sample count %d pattern length %d ", indexFieldSize, + countFieldSize, patternFieldSize); + inputStream->msg(inputStream, msgString); + + GET32(grouping_type); + MP4TypeToString(self->grouping_type, typeString); + sprintf(msgString, "grouping type is '%s'", typeString); + inputStream->msg(inputStream, msgString); + + if(groupingTypeParamPresent) + { + GET32(groupingTypeParameter); + } + + GET32(entryCount); + + MP4CompactSampleToGroupPatternEntryPtr patternEntries = + malloc(self->entryCount * sizeof(MP4CompactSampleToGroupPatternEntry)); + TESTMALLOC(patternEntries); + u32 upperNibble = 0; + + for(i = 0; i < self->entryCount; i++) + { + u32 sampleCount, patternLength; + + GetData(s, inputStream, patternFieldSize, &upperNibble, &patternLength); + patternEntries[i].patternLength = patternLength; + + GetData(s, inputStream, countFieldSize, &upperNibble, &sampleCount); + patternEntries[i].sampleCount = sampleCount; + self->sampleCount += sampleCount; + + sprintf(msgString, "pattern entry %d: pattern length->%d sample count->%d ", i + 1, + patternLength, sampleCount); + inputStream->msg(inputStream, msgString); + } + + err = ensureSize(self, self->sampleCount * sizeof(u32)); + if(err) goto bail; + p = &((self->group_index)[0]); + + sprintf(msgString, "Index description values are:"); + inputStream->msg(inputStream, msgString); + for(i = 0; i < self->entryCount; i++) + { + u32 *patternStart = p; + u32 mask = + self->fragmentLocalIndexPresent ? 0xFFFFFFFF >> (32 - indexFieldSize + 1) : 0xFFFFFFFF; + for(j = 0; j < patternEntries[i].sampleCount; j++) + { + if(j < patternEntries[i].patternLength) + { + u32 indexValue; + GetData(s, inputStream, indexFieldSize, &upperNibble, &indexValue); + indexValue = indexValue & mask; + *p++ = indexValue; + sprintf(msgString + (i * 2), "%d ", indexValue); + } + else + { + *p++ = *(patternStart + (j % patternEntries[i].patternLength)); + } + } + } + inputStream->msg(inputStream, msgString); + + free(patternEntries); + patternEntries = NULL; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateCompactSampletoGroupAtom( MP4CompactSampletoGroupAtomPtr *outAtom ) +MP4Err MP4CreateCompactSampletoGroupAtom(MP4CompactSampletoGroupAtomPtr *outAtom) { - MP4Err err; - MP4CompactSampletoGroupAtomPtr self; - - self = (MP4CompactSampletoGroupAtomPtr) calloc( 1, sizeof(MP4CompactSampletoGroupAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4CompactSampletoGroupAtomType; - self->name = "compact sample to group"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->mapSamplestoGroup = mapSamplestoGroup; - self->addSamples = addSamples; - self->getSampleGroupMap = getSampleGroupMap; - self->group_index = NULL; - self->flags = 0; - self->sampleCount = 0; - self->fragmentLocalIndexPresent = 0; - memset(&self->compressedGroup, 0, sizeof(CompressedGroupInfo)); - - *outAtom = self; + MP4Err err; + MP4CompactSampletoGroupAtomPtr self; + + self = (MP4CompactSampletoGroupAtomPtr)calloc(1, sizeof(MP4CompactSampletoGroupAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4CompactSampletoGroupAtomType; + self->name = "compact sample to group"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->mapSamplestoGroup = mapSamplestoGroup; + self->addSamples = addSamples; + self->getSampleGroupMap = getSampleGroupMap; + self->group_index = NULL; + self->flags = 0; + self->sampleCount = 0; + self->fragmentLocalIndexPresent = 0; + memset(&self->compressedGroup, 0, sizeof(CompressedGroupInfo)); + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c b/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c index d10fb05..da32037 100644 --- a/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c +++ b/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c @@ -23,162 +23,164 @@ * derivative works. */ - /** -* @file CompatibleSchemeTypeAtom.c -* @author Ahmed Hamza -* @date -* @brief Implements functions for reading and writing CompatibleSchemeTypeAtom instances. -*/ - + * @file CompatibleSchemeTypeAtom.c + * @author Ahmed Hamza + * @date + * @brief Implements functions for reading and writing CompatibleSchemeTypeAtom instances. + */ #include "MP4Atoms.h" #include #include - - static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4CompatibleSchemeTypeAtomPtr self = (MP4CompatibleSchemeTypeAtomPtr)s; - err = MP4NoErr; + MP4Err err; + MP4CompatibleSchemeTypeAtomPtr self = (MP4CompatibleSchemeTypeAtomPtr)s; + err = MP4NoErr; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - /* if there is a scheme_url field, free it */ - if (self->scheme_url) { - free(self->scheme_url); - self->scheme_url = NULL; - } + /* if there is a scheme_url field, free it */ + if(self->scheme_url) + { + free(self->scheme_url); + self->scheme_url = NULL; + } - if (self->super) - self->super->destroy(s); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return; + return; } - -static MP4Err serialize(struct MP4Atom* s, char* buffer) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4CompatibleSchemeTypeAtomPtr self = (MP4CompatibleSchemeTypeAtomPtr)s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); if (err) goto bail; - buffer += self->bytesWritten; - - PUT32(scheme_type); - PUT32(scheme_version); - if ((self->flags & 1) == 1) - { - u32 len = strlen(self->scheme_url) + 1; - PUTBYTES(self->scheme_url, len); - } - - assert(self->bytesWritten == self->size); + MP4Err err; + MP4CompatibleSchemeTypeAtomPtr self = (MP4CompatibleSchemeTypeAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + PUT32(scheme_type); + PUT32(scheme_version); + if((self->flags & 1) == 1) + { + u32 len = strlen(self->scheme_url) + 1; + PUTBYTES(self->scheme_url, len); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize(struct MP4Atom* s) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4CompatibleSchemeTypeAtomPtr self = (MP4CompatibleSchemeTypeAtomPtr)s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if (err) goto bail; - self->size += 8; /* 4 bytes (scheme_type) + 4 bytes (scheme_version) */ - if ((self->scheme_url) && (strlen(self->scheme_url) > 0)) - { - self->flags = 1; - self->size += 1 + strlen(self->scheme_url); /* strlen ignores \0 */ - } - else self->flags = 0; + MP4Err err; + MP4CompatibleSchemeTypeAtomPtr self = (MP4CompatibleSchemeTypeAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 8; /* 4 bytes (scheme_type) + 4 bytes (scheme_version) */ + if((self->scheme_url) && (strlen(self->scheme_url) > 0)) + { + self->flags = 1; + self->size += 1 + strlen(self->scheme_url); /* strlen ignores \0 */ + } + else + self->flags = 0; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - char debugstr[256]; - MP4CompatibleSchemeTypeAtomPtr self = (MP4CompatibleSchemeTypeAtomPtr)s; - - err = MP4NoErr; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); - - err = self->super->createFromInputStream(s, proto, (char*)inputStream); if (err) goto bail; - - GET32(scheme_type); - GET32(scheme_version); - - bytesToRead = self->size - self->bytesRead; - if (bytesToRead < 0) - BAILWITHERROR(MP4BadDataErr); - - if (bytesToRead > 0) - { - if ((self->flags & 1) != 1) { err = MP4BadDataErr; goto bail; } - self->scheme_url = (char*)calloc(1, bytesToRead); - if (self->scheme_url == NULL) - BAILWITHERROR(MP4NoMemoryErr); - - GETBYTES(bytesToRead, scheme_url); - - if (bytesToRead < 200) - { - sprintf(debugstr, "Scheme URL location is \"%s\"", self->scheme_url); - DEBUG_MSG(debugstr); - } - } - else - { - if ((self->flags & 1) != 0) { err = MP4BadDataErr; goto bail; } - } - - assert(self->bytesRead == self->size); + MP4Err err; + long bytesToRead; + char debugstr[256]; + MP4CompatibleSchemeTypeAtomPtr self = (MP4CompatibleSchemeTypeAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(scheme_type); + GET32(scheme_version); + + bytesToRead = self->size - self->bytesRead; + if(bytesToRead < 0) BAILWITHERROR(MP4BadDataErr); + + if(bytesToRead > 0) + { + if((self->flags & 1) != 1) + { + err = MP4BadDataErr; + goto bail; + } + self->scheme_url = (char *)calloc(1, bytesToRead); + if(self->scheme_url == NULL) BAILWITHERROR(MP4NoMemoryErr); + + GETBYTES(bytesToRead, scheme_url); + + if(bytesToRead < 200) + { + sprintf(debugstr, "Scheme URL location is \"%s\"", self->scheme_url); + DEBUG_MSG(debugstr); + } + } + else + { + if((self->flags & 1) != 0) + { + err = MP4BadDataErr; + goto bail; + } + } + + assert(self->bytesRead == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } +MP4Err MP4CreateCompatibleSchemeTypeAtom(MP4CompatibleSchemeTypeAtomPtr *outAtom) +{ -MP4Err MP4CreateCompatibleSchemeTypeAtom(MP4CompatibleSchemeTypeAtomPtr *outAtom) { - - MP4Err err; - MP4CompatibleSchemeTypeAtomPtr self; + MP4Err err; + MP4CompatibleSchemeTypeAtomPtr self; - self = (MP4CompatibleSchemeTypeAtomPtr)calloc(1, sizeof(MP4CompatibleSchemeTypeAtom)); - TESTMALLOC(self); + self = (MP4CompatibleSchemeTypeAtomPtr)calloc(1, sizeof(MP4CompatibleSchemeTypeAtom)); + TESTMALLOC(self); - err = MP4CreateFullAtom((MP4AtomPtr)self); if (err) goto bail; + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; - self->type = MP4SchemeTypeAtomType; - self->name = "CompatibleSchemeTypeBox"; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; + self->type = MP4SchemeTypeAtomType; + self->name = "CompatibleSchemeTypeBox"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; - *outAtom = self; + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - diff --git a/IsoLib/libisomediafile/src/CompositionToDecodeAtom.c b/IsoLib/libisomediafile/src/CompositionToDecodeAtom.c index a9cd12b..456f994 100644 --- a/IsoLib/libisomediafile/src/CompositionToDecodeAtom.c +++ b/IsoLib/libisomediafile/src/CompositionToDecodeAtom.c @@ -29,177 +29,174 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( compositionToDTSShift ); - PUT32( leastDecodeToDisplayDelta ); - PUT32( greatestDecodeToDisplayDelta ); - PUT32( compositionStartTime ); - PUT32( compositionEndTime ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(compositionToDTSShift); + PUT32(leastDecodeToDisplayDelta); + PUT32(greatestDecodeToDisplayDelta); + PUT32(compositionStartTime); + PUT32(compositionEndTime); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err updateFields( struct MP4Atom* s, u32 sampleCount, MP4Handle durationsH, MP4Handle compositionOffsetsH ) +static MP4Err updateFields(struct MP4Atom *s, u32 sampleCount, MP4Handle durationsH, + MP4Handle compositionOffsetsH) { - MP4Err err; - u32 durationsCount; - u32 onlyDuration; - u32 offsetCount; - s32 onlyOffset; - s32 offset; - s32 duration; - s32 *offsets; - s32 *durations; - u32 i; - - MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr) s; - err = MP4NoErr; - - offsets = (s32*) *compositionOffsetsH; - durations = (s32*) *durationsH; - - err = MP4GetHandleSize( compositionOffsetsH, &offsetCount ); if (err) goto bail; - offsetCount /= sizeof(u32); - if ( offsetCount == 1 ) - onlyOffset = *(s32*) *compositionOffsetsH; - else if ( offsetCount != sampleCount ) - BAILWITHERROR( MP4BadParamErr ); - - err = MP4GetHandleSize( durationsH, &durationsCount ); if (err) goto bail; - durationsCount /= sizeof(u32); - if ( durationsCount == 1 ) - onlyDuration = *(u32*) *durationsH; - else if ( durationsCount != sampleCount ) - BAILWITHERROR( MP4BadParamErr ); - - for ( i = 0; i < sampleCount; i++ ) - { - if ( durationsCount == 1 ) - duration = onlyDuration; - else - duration = durations[i]; - - if ( offsetCount == 1 ) - offset = onlyOffset; - else - offset = offsets[i]; - - - if (offset < self->leastDecodeToDisplayDelta) - self->leastDecodeToDisplayDelta = offset; - - if (offset > self->greatestDecodeToDisplayDelta) - self->greatestDecodeToDisplayDelta = offset; - - if (self->leastDecodeToDisplayDelta < 0) - self->compositionToDTSShift = -1 * self->leastDecodeToDisplayDelta; - - if ((self->totalDuration + offset) < self->compositionStartTime) - self->compositionStartTime = (s32)(self->totalDuration + (s64)offset); - - if ((self->totalDuration + offset) > self->compositionEndTime) - self->compositionEndTime = (s32)(self->totalDuration + (s64)offset); - - self->totalDuration += duration; - } - + MP4Err err; + u32 durationsCount; + u32 onlyDuration; + u32 offsetCount; + s32 onlyOffset; + s32 offset; + s32 duration; + s32 *offsets; + s32 *durations; + u32 i; + + MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr)s; + err = MP4NoErr; + + offsets = (s32 *)*compositionOffsetsH; + durations = (s32 *)*durationsH; + + err = MP4GetHandleSize(compositionOffsetsH, &offsetCount); + if(err) goto bail; + offsetCount /= sizeof(u32); + if(offsetCount == 1) onlyOffset = *(s32 *)*compositionOffsetsH; + else if(offsetCount != sampleCount) + BAILWITHERROR(MP4BadParamErr); + + err = MP4GetHandleSize(durationsH, &durationsCount); + if(err) goto bail; + durationsCount /= sizeof(u32); + if(durationsCount == 1) onlyDuration = *(u32 *)*durationsH; + else if(durationsCount != sampleCount) + BAILWITHERROR(MP4BadParamErr); + + for(i = 0; i < sampleCount; i++) + { + if(durationsCount == 1) duration = onlyDuration; + else + duration = durations[i]; + + if(offsetCount == 1) offset = onlyOffset; + else + offset = offsets[i]; + + if(offset < self->leastDecodeToDisplayDelta) self->leastDecodeToDisplayDelta = offset; + + if(offset > self->greatestDecodeToDisplayDelta) self->greatestDecodeToDisplayDelta = offset; + + if(self->leastDecodeToDisplayDelta < 0) + self->compositionToDTSShift = -1 * self->leastDecodeToDisplayDelta; + + if((self->totalDuration + offset) < self->compositionStartTime) + self->compositionStartTime = (s32)(self->totalDuration + (s64)offset); + + if((self->totalDuration + offset) > self->compositionEndTime) + self->compositionEndTime = (s32)(self->totalDuration + (s64)offset); + + self->totalDuration += duration; + } + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4 * 5; + MP4Err err; + MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4 * 5; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - GET32( compositionToDTSShift ); - GET32( leastDecodeToDisplayDelta ); - GET32( greatestDecodeToDisplayDelta ); - GET32( compositionStartTime ); - GET32( compositionEndTime ); - assert( self->bytesRead == self->size ); - + MP4Err err; + MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + GET32(compositionToDTSShift); + GET32(leastDecodeToDisplayDelta); + GET32(greatestDecodeToDisplayDelta); + GET32(compositionStartTime); + GET32(compositionEndTime); + assert(self->bytesRead == self->size); + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err MP4CreateCompositionToDecodeAtom( MP4CompositionToDecodeAtomPtr *outAtom ) +MP4Err MP4CreateCompositionToDecodeAtom(MP4CompositionToDecodeAtomPtr *outAtom) { - MP4Err err; - MP4CompositionToDecodeAtomPtr self; - - self = (MP4CompositionToDecodeAtomPtr) calloc( 1, sizeof(MP4CompositionToDecodeAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4CompositionToDecodeAtomType; - self->name = "composition to decode"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->updateFields = updateFields; - - self->compositionToDTSShift = 0; - self->leastDecodeToDisplayDelta = INT_MAX; /* 2147483647; */ - self->greatestDecodeToDisplayDelta = INT_MIN; /* -2147483648; */ - self->compositionStartTime = INT_MAX; /* 2147483647; */ - self->compositionEndTime = INT_MIN; /* -2147483648; */ - self->totalDuration = 0; - - *outAtom = self; + MP4Err err; + MP4CompositionToDecodeAtomPtr self; + + self = (MP4CompositionToDecodeAtomPtr)calloc(1, sizeof(MP4CompositionToDecodeAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4CompositionToDecodeAtomType; + self->name = "composition to decode"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->updateFields = updateFields; + + self->compositionToDTSShift = 0; + self->leastDecodeToDisplayDelta = INT_MAX; /* 2147483647; */ + self->greatestDecodeToDisplayDelta = INT_MIN; /* -2147483648; */ + self->compositionStartTime = INT_MAX; /* 2147483647; */ + self->compositionEndTime = INT_MIN; /* -2147483648; */ + self->totalDuration = 0; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/CopyrightAtom.c b/IsoLib/libisomediafile/src/CopyrightAtom.c index 747ad3f..3a7986c 100644 --- a/IsoLib/libisomediafile/src/CopyrightAtom.c +++ b/IsoLib/libisomediafile/src/CopyrightAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,118 +15,118 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: CopyrightAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: CopyrightAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4CopyrightAtomPtr self = (MP4CopyrightAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->notice ) - { - free( self->notice ); - self->notice = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4CopyrightAtomPtr self = (MP4CopyrightAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->notice) + { + free(self->notice); + self->notice = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 len; - MP4CopyrightAtomPtr self = (MP4CopyrightAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT16( packedLanguageCode ); - len = strlen( self->notice ) + 1; - PUTBYTES( self->notice, len ); - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 len; + MP4CopyrightAtomPtr self = (MP4CopyrightAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT16(packedLanguageCode); + len = strlen(self->notice) + 1; + PUTBYTES(self->notice, len); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4CopyrightAtomPtr self = (MP4CopyrightAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 3 + strlen( self->notice ); + MP4Err err; + MP4CopyrightAtomPtr self = (MP4CopyrightAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 3 + strlen(self->notice); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - MP4CopyrightAtomPtr self = (MP4CopyrightAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - GET16( packedLanguageCode ); - bytesToRead = self->size - self->bytesRead; - if ( bytesToRead < 0 ) - BAILWITHERROR( MP4BadDataErr ) - if ( bytesToRead > 0 ) - { - self->notice = (char*) calloc( 1, bytesToRead ); - TESTMALLOC( self->notice ); - GETBYTES( bytesToRead, notice ); - } + MP4Err err; + long bytesToRead; + MP4CopyrightAtomPtr self = (MP4CopyrightAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + GET16(packedLanguageCode); + bytesToRead = self->size - self->bytesRead; + if(bytesToRead < 0) BAILWITHERROR(MP4BadDataErr) + if(bytesToRead > 0) + { + self->notice = (char *)calloc(1, bytesToRead); + TESTMALLOC(self->notice); + GETBYTES(bytesToRead, notice); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateCopyrightAtom( MP4CopyrightAtomPtr *outAtom ) +MP4Err MP4CreateCopyrightAtom(MP4CopyrightAtomPtr *outAtom) { - MP4Err err; - MP4CopyrightAtomPtr self; - - self = (MP4CopyrightAtomPtr) calloc( 1, sizeof(MP4CopyrightAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4CopyrightAtomType; - self->name = "copyright"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4CopyrightAtomPtr self; + + self = (MP4CopyrightAtomPtr)calloc(1, sizeof(MP4CopyrightAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4CopyrightAtomType; + self->name = "copyright"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/DataEntryURLAtom.c b/IsoLib/libisomediafile/src/DataEntryURLAtom.c index a44fb70..e842b34 100644 --- a/IsoLib/libisomediafile/src/DataEntryURLAtom.c +++ b/IsoLib/libisomediafile/src/DataEntryURLAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: DataEntryURLAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: DataEntryURLAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -29,188 +29,186 @@ derivative works. Copyright (c) 1999. #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4DataEntryURLAtomPtr self = (MP4DataEntryURLAtomPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->location ) { - free( self->location ); - self->location = NULL; - } - - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + MP4DataEntryURLAtomPtr self = (MP4DataEntryURLAtomPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->location) + { + free(self->location); + self->location = NULL; + } + + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err getOffset( struct MP4DataEntryAtom *self, u64 *outOffset ) +static MP4Err getOffset(struct MP4DataEntryAtom *self, u64 *outOffset) { - MP4Err err; - - err = MP4NoErr; - if ( outOffset == NULL ) - BAILWITHERROR( MP4BadParamErr ); - if ( self->mdat ) - { - MP4MediaDataAtomPtr mdat; - mdat = (MP4MediaDataAtomPtr) self->mdat; - self->offset = mdat->dataSize; - } - *outOffset = self->offset; + MP4Err err; + + err = MP4NoErr; + if(outOffset == NULL) BAILWITHERROR(MP4BadParamErr); + if(self->mdat) + { + MP4MediaDataAtomPtr mdat; + mdat = (MP4MediaDataAtomPtr)self->mdat; + self->offset = mdat->dataSize; + } + *outOffset = self->offset; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSampleReference( struct MP4DataEntryAtom *self, u64 dataOffset, MP4Handle sizesH ) +static MP4Err addSampleReference(struct MP4DataEntryAtom *self, u64 dataOffset, MP4Handle sizesH) { - MP4Err err; - - err = MP4NoErr; - dataOffset = dataOffset; - sizesH = sizesH; - if ( self->mdat ) - BAILWITHERROR( MP4BadParamErr ) + MP4Err err; + + err = MP4NoErr; + dataOffset = dataOffset; + sizesH = sizesH; + if(self->mdat) BAILWITHERROR(MP4BadParamErr) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSamples( struct MP4DataEntryAtom *self, MP4Handle sampleH ) +static MP4Err addSamples(struct MP4DataEntryAtom *self, MP4Handle sampleH) { - u32 size; - MP4Err err; - - err = MP4NoErr; - err = MP4GetHandleSize( sampleH, &size ); if (err) goto bail; - if ( self->mdat ) - { - MP4MediaDataAtomPtr mdat; - mdat = (MP4MediaDataAtomPtr) self->mdat; - err = mdat->addData( mdat, sampleH ); if (err) goto bail; - self->offset = mdat->dataSize; - } - else - self->offset += size; - + u32 size; + MP4Err err; + + err = MP4NoErr; + err = MP4GetHandleSize(sampleH, &size); + if(err) goto bail; + if(self->mdat) + { + MP4MediaDataAtomPtr mdat; + mdat = (MP4MediaDataAtomPtr)self->mdat; + err = mdat->addData(mdat, sampleH); + if(err) goto bail; + self->offset = mdat->dataSize; + } + else + self->offset += size; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4DataEntryURLAtomPtr self = (MP4DataEntryURLAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - if ( (self->flags & 1) == 0 ) - { - if ( self->location ) - { - u32 len = strlen( self->location ) + 1; - PUTBYTES( self->location, len ); - } - } - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4DataEntryURLAtomPtr self = (MP4DataEntryURLAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + if((self->flags & 1) == 0) + { + if(self->location) + { + u32 len = strlen(self->location) + 1; + PUTBYTES(self->location, len); + } + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4DataEntryURLAtomPtr self = (MP4DataEntryURLAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - if ( (self->flags & 1) == 0 ) - { - if ( self->location ) - self->size += 1 + strlen( self->location ); - } + MP4Err err; + MP4DataEntryURLAtomPtr self = (MP4DataEntryURLAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + if((self->flags & 1) == 0) + { + if(self->location) self->size += 1 + strlen(self->location); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - char debugstr[ 256 ]; - - MP4DataEntryURLAtomPtr self = (MP4DataEntryURLAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - bytesToRead = self->size - self->bytesRead; - if ( bytesToRead < 0 ) - BAILWITHERROR( MP4BadDataErr ) - if ( bytesToRead > 0 ) - { - if (self->type == MP4DataEntryURLAtomType) { - self->location = (char*) calloc( 1, bytesToRead ); - if ( self->location == NULL ) - BAILWITHERROR( MP4NoMemoryErr ) - GETBYTES( bytesToRead, location ); - self->locationLength = bytesToRead; - if ( self->locationLength < 200 ) - { - sprintf( debugstr, "URL location is \"%s\"", self->location ); - DEBUG_MSG( debugstr ); - } - } - else - { - GETBYTES_V( bytesToRead, debugstr ); - } - - } + MP4Err err; + long bytesToRead; + char debugstr[256]; + + MP4DataEntryURLAtomPtr self = (MP4DataEntryURLAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + bytesToRead = self->size - self->bytesRead; + if(bytesToRead < 0) BAILWITHERROR(MP4BadDataErr) + if(bytesToRead > 0) + { + if(self->type == MP4DataEntryURLAtomType) + { + self->location = (char *)calloc(1, bytesToRead); + if(self->location == NULL) BAILWITHERROR(MP4NoMemoryErr) + GETBYTES(bytesToRead, location); + self->locationLength = bytesToRead; + if(self->locationLength < 200) + { + sprintf(debugstr, "URL location is \"%s\"", self->location); + DEBUG_MSG(debugstr); + } + } + else + { + GETBYTES_V(bytesToRead, debugstr); + } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateDataEntryURLAtom( MP4DataEntryURLAtomPtr *outAtom ) +MP4Err MP4CreateDataEntryURLAtom(MP4DataEntryURLAtomPtr *outAtom) { - MP4Err err; - MP4DataEntryURLAtomPtr self; - - self = (MP4DataEntryURLAtomPtr) calloc( 1, sizeof(MP4DataEntryURLAtom) ); - if ( self == NULL ) BAILWITHERROR( MP4NoMemoryErr ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4DataEntryURLAtomType; - self->name = "data entry URL"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->getOffset = getOffset; - self->addSamples = addSamples; - self->addSampleReference = addSampleReference; - *outAtom = self; + MP4Err err; + MP4DataEntryURLAtomPtr self; + + self = (MP4DataEntryURLAtomPtr)calloc(1, sizeof(MP4DataEntryURLAtom)); + if(self == NULL) BAILWITHERROR(MP4NoMemoryErr) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4DataEntryURLAtomType; + self->name = "data entry URL"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->getOffset = getOffset; + self->addSamples = addSamples; + self->addSampleReference = addSampleReference; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/DataEntryURNAtom.c b/IsoLib/libisomediafile/src/DataEntryURNAtom.c index a13e989..b0f2ee7 100644 --- a/IsoLib/libisomediafile/src/DataEntryURNAtom.c +++ b/IsoLib/libisomediafile/src/DataEntryURNAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,219 +15,213 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: DataEntryURNAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: DataEntryURNAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4DataEntryURNAtomPtr self = (MP4DataEntryURNAtomPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->nameURN ) { - free( self->nameURN ); - self->nameURN = NULL; - } - - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + MP4DataEntryURNAtomPtr self = (MP4DataEntryURNAtomPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->nameURN) + { + free(self->nameURN); + self->nameURN = NULL; + } + + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err getOffset( struct MP4DataEntryAtom *self, u64 *outOffset ) +static MP4Err getOffset(struct MP4DataEntryAtom *self, u64 *outOffset) { - MP4Err err; - - err = MP4NoErr; - if ( outOffset == NULL ) - BAILWITHERROR( MP4BadParamErr ); - if ( self->mdat ) - { - MP4MediaDataAtomPtr mdat; - mdat = (MP4MediaDataAtomPtr) self->mdat; - self->offset = mdat->dataSize; - } - *outOffset = self->offset; + MP4Err err; + + err = MP4NoErr; + if(outOffset == NULL) BAILWITHERROR(MP4BadParamErr); + if(self->mdat) + { + MP4MediaDataAtomPtr mdat; + mdat = (MP4MediaDataAtomPtr)self->mdat; + self->offset = mdat->dataSize; + } + *outOffset = self->offset; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSampleReference( struct MP4DataEntryAtom *self, u64 dataOffset, MP4Handle sizesH ) +static MP4Err addSampleReference(struct MP4DataEntryAtom *self, u64 dataOffset, MP4Handle sizesH) { - MP4Err err; - - err = MP4NoErr; - dataOffset = dataOffset; - sizesH = sizesH; - if ( self->mdat ) - BAILWITHERROR( MP4BadParamErr ); + MP4Err err; + + err = MP4NoErr; + dataOffset = dataOffset; + sizesH = sizesH; + if(self->mdat) BAILWITHERROR(MP4BadParamErr); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSamples( struct MP4DataEntryAtom *self, MP4Handle sampleH ) +static MP4Err addSamples(struct MP4DataEntryAtom *self, MP4Handle sampleH) { - u32 size; - MP4Err err; - - err = MP4NoErr; - err = MP4GetHandleSize( sampleH, &size ); if (err) goto bail; - if ( self->mdat ) - { - MP4MediaDataAtomPtr mdat; - mdat = (MP4MediaDataAtomPtr) self->mdat; - err = mdat->addData( mdat, sampleH ); if (err) goto bail; - self->offset = mdat->dataSize; - } - else - self->offset += size; - + u32 size; + MP4Err err; + + err = MP4NoErr; + err = MP4GetHandleSize(sampleH, &size); + if(err) goto bail; + if(self->mdat) + { + MP4MediaDataAtomPtr mdat; + mdat = (MP4MediaDataAtomPtr)self->mdat; + err = mdat->addData(mdat, sampleH); + if(err) goto bail; + self->offset = mdat->dataSize; + } + else + self->offset += size; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4DataEntryURNAtomPtr self = (MP4DataEntryURNAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - if ( (self->flags & 1) == 0 ) - { - if ( self->location ) - { - u32 len = strlen( self->location ) + 1; - PUTBYTES( self->location, len ); - if ( self->name ) - { - len = strlen( self->name ) + 1; - PUTBYTES( self->name, len ); - } - } - } - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4DataEntryURNAtomPtr self = (MP4DataEntryURNAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + if((self->flags & 1) == 0) + { + if(self->location) + { + u32 len = strlen(self->location) + 1; + PUTBYTES(self->location, len); + if(self->name) + { + len = strlen(self->name) + 1; + PUTBYTES(self->name, len); + } + } + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4DataEntryURNAtomPtr self = (MP4DataEntryURNAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - if ( (self->flags & 1) == 0 ) - { - if ( self->location ) - self->size += 1 + strlen( self->location ); - if ( self->name ) - self->size += 1 + strlen( self->name ); - } + MP4Err err; + MP4DataEntryURNAtomPtr self = (MP4DataEntryURNAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + if((self->flags & 1) == 0) + { + if(self->location) self->size += 1 + strlen(self->location); + if(self->name) self->size += 1 + strlen(self->name); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - MP4DataEntryURNAtomPtr self = (MP4DataEntryURNAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - bytesToRead = self->size - self->bytesRead; - if ( bytesToRead < 0 ) - BAILWITHERROR( MP4BadDataErr ) - - self->nameURN = (char*) calloc( 1, bytesToRead ); - if ( self->nameURN == NULL ) - BAILWITHERROR( MP4NoMemoryErr ) - if ( bytesToRead ) - { - char *cp = self->nameURN; - self->location = NULL; - GETBYTES( bytesToRead, nameURN ); - self->locationLength = bytesToRead; - while ( bytesToRead-- > 0 ) - { - self->nameLength++; - if ( *cp++ == 0 ) - { - self->location = cp; - break; - } - } - /* !!! HERE !!! */ - self->locationLength -= self->nameLength; - if ( self->location == NULL ) - BAILWITHERROR( MP4BadDataErr ) - } - else - self->location = self->nameURN; + MP4Err err; + long bytesToRead; + MP4DataEntryURNAtomPtr self = (MP4DataEntryURNAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + bytesToRead = self->size - self->bytesRead; + if(bytesToRead < 0) BAILWITHERROR(MP4BadDataErr) + + self->nameURN = (char *)calloc(1, bytesToRead); + if(self->nameURN == NULL) BAILWITHERROR(MP4NoMemoryErr) + if(bytesToRead) + { + char *cp = self->nameURN; + self->location = NULL; + GETBYTES(bytesToRead, nameURN); + self->locationLength = bytesToRead; + while(bytesToRead-- > 0) + { + self->nameLength++; + if(*cp++ == 0) + { + self->location = cp; + break; + } + } + /* !!! HERE !!! */ + self->locationLength -= self->nameLength; + if(self->location == NULL) BAILWITHERROR(MP4BadDataErr) + } + else + self->location = self->nameURN; bail: - TEST_RETURN( err ); - - if ( err ) - { - if ( self->nameURN ) - free( self->nameURN ); - } - return err; + TEST_RETURN(err); + + if(err) + { + if(self->nameURN) free(self->nameURN); + } + return err; } -MP4Err MP4CreateDataEntryURNAtom( MP4DataEntryURNAtomPtr *outAtom ) +MP4Err MP4CreateDataEntryURNAtom(MP4DataEntryURNAtomPtr *outAtom) { - MP4Err err; - MP4DataEntryURNAtomPtr self; - - self = (MP4DataEntryURNAtomPtr) calloc( 1, sizeof(MP4DataEntryURNAtom) ); - if ( self == NULL ) - BAILWITHERROR( MP4NoMemoryErr ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4DataEntryURNAtomType; - self->name = "data entry URN"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->getOffset = getOffset; - self->addSamples = addSamples; - self->addSampleReference = addSampleReference; - *outAtom = self; + MP4Err err; + MP4DataEntryURNAtomPtr self; + + self = (MP4DataEntryURNAtomPtr)calloc(1, sizeof(MP4DataEntryURNAtom)); + if(self == NULL) BAILWITHERROR(MP4NoMemoryErr) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4DataEntryURNAtomType; + self->name = "data entry URN"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->getOffset = getOffset; + self->addSamples = addSamples; + self->addSampleReference = addSampleReference; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/DataInformationAtom.c b/IsoLib/libisomediafile/src/DataInformationAtom.c index e1c987b..bf0f376 100644 --- a/IsoLib/libisomediafile/src/DataInformationAtom.c +++ b/IsoLib/libisomediafile/src/DataInformationAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,175 +15,173 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: DataInformationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: DataInformationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4DataInformationAtomPtr self; - u32 i; - err = MP4NoErr; - self = (MP4DataInformationAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4DataInformationAtomPtr self; + u32 i; + err = MP4NoErr; + self = (MP4DataInformationAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err getOffset( struct MP4DataInformationAtom *self, u32 dataReferenceIndex, u64 *outOffset ) +static MP4Err getOffset(struct MP4DataInformationAtom *self, u32 dataReferenceIndex, u64 *outOffset) { - MP4DataReferenceAtomPtr dref; - MP4Err err; - - err = MP4NoErr; - if ( self->dataReference == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - if ( dataReferenceIndex == 0 ) - BAILWITHERROR( MP4BadParamErr ); - dref = (MP4DataReferenceAtomPtr) self->dataReference; - err = dref->getOffset( dref, dataReferenceIndex, outOffset ); if (err) goto bail; + MP4DataReferenceAtomPtr dref; + MP4Err err; + + err = MP4NoErr; + if(self->dataReference == NULL) BAILWITHERROR(MP4InvalidMediaErr); + if(dataReferenceIndex == 0) BAILWITHERROR(MP4BadParamErr); + dref = (MP4DataReferenceAtomPtr)self->dataReference; + err = dref->getOffset(dref, dataReferenceIndex, outOffset); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSampleReference( struct MP4DataInformationAtom *self, u32 sampleCount, u32 dataReferenceIndex, u64 dataOffset, MP4Handle sizesH ) +static MP4Err addSampleReference(struct MP4DataInformationAtom *self, u32 sampleCount, + u32 dataReferenceIndex, u64 dataOffset, MP4Handle sizesH) { - MP4DataReferenceAtomPtr dref; - MP4Err err; - - err = MP4NoErr; - if ( self->dataReference == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - if ( dataReferenceIndex == 0 ) - BAILWITHERROR( MP4BadParamErr ); - dref = (MP4DataReferenceAtomPtr) self->dataReference; - err = dref->addSampleReference( dref, sampleCount, dataReferenceIndex, dataOffset, sizesH ); if (err) goto bail; + MP4DataReferenceAtomPtr dref; + MP4Err err; + + err = MP4NoErr; + if(self->dataReference == NULL) BAILWITHERROR(MP4InvalidMediaErr); + if(dataReferenceIndex == 0) BAILWITHERROR(MP4BadParamErr); + dref = (MP4DataReferenceAtomPtr)self->dataReference; + err = dref->addSampleReference(dref, sampleCount, dataReferenceIndex, dataOffset, sizesH); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + return err; } -static MP4Err addSamples( struct MP4DataInformationAtom *self, u32 sampleCount, u32 dataReferenceIndex, MP4Handle sampleH ) +static MP4Err addSamples(struct MP4DataInformationAtom *self, u32 sampleCount, + u32 dataReferenceIndex, MP4Handle sampleH) { - MP4DataReferenceAtomPtr dref; - MP4Err err; - - err = MP4NoErr; - if ( self->dataReference == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - if ( dataReferenceIndex == 0 ) - BAILWITHERROR( MP4BadParamErr ); - dref = (MP4DataReferenceAtomPtr) self->dataReference; - err = dref->addSamples( dref, sampleCount, dataReferenceIndex, sampleH ); if (err) goto bail; + MP4DataReferenceAtomPtr dref; + MP4Err err; + + err = MP4NoErr; + if(self->dataReference == NULL) BAILWITHERROR(MP4InvalidMediaErr); + if(dataReferenceIndex == 0) BAILWITHERROR(MP4BadParamErr); + dref = (MP4DataReferenceAtomPtr)self->dataReference; + err = dref->addSamples(dref, sampleCount, dataReferenceIndex, sampleH); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err addAtom( MP4DataInformationAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4DataInformationAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; - switch( atom->type ) - { - case MP4DataReferenceAtomType: - if ( self->dataReference ) - BAILWITHERROR( MP4BadDataErr ) - self->dataReference = atom; - break; - } + MP4Err err; + err = MP4NoErr; + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; + switch(atom->type) + { + case MP4DataReferenceAtomType: + if(self->dataReference) BAILWITHERROR(MP4BadDataErr) + self->dataReference = atom; + break; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4DataInformationAtomPtr self = (MP4DataInformationAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4DataInformationAtomPtr self = (MP4DataInformationAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4DataInformationAtomPtr self = (MP4DataInformationAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE( atomList ); + MP4Err err; + MP4DataInformationAtomPtr self = (MP4DataInformationAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MP4DataInformationAtom) + PARSE_ATOM_LIST(MP4DataInformationAtom) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateDataInformationAtom( MP4DataInformationAtomPtr *outAtom ) +MP4Err MP4CreateDataInformationAtom(MP4DataInformationAtomPtr *outAtom) { - MP4Err err; - MP4DataInformationAtomPtr self; - - self = (MP4DataInformationAtomPtr) calloc( 1, sizeof(MP4DataInformationAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4DataInformationAtomType; - self->name = "data information"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->getOffset = getOffset; - self->addSamples = addSamples; - self->addAtom = addAtom; - self->addSampleReference = addSampleReference; - *outAtom = self; + MP4Err err; + MP4DataInformationAtomPtr self; + + self = (MP4DataInformationAtomPtr)calloc(1, sizeof(MP4DataInformationAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4DataInformationAtomType; + self->name = "data information"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->getOffset = getOffset; + self->addSamples = addSamples; + self->addAtom = addAtom; + self->addSampleReference = addSampleReference; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/DataReferenceAtom.c b/IsoLib/libisomediafile/src/DataReferenceAtom.c index 7eb8138..22a625d 100644 --- a/IsoLib/libisomediafile/src/DataReferenceAtom.c +++ b/IsoLib/libisomediafile/src/DataReferenceAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,215 +15,227 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: DataReferenceAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: DataReferenceAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4DataReferenceAtomPtr self; - u32 i; - err = MP4NoErr; - self = (MP4DataReferenceAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4DataReferenceAtomPtr self; + u32 i; + err = MP4NoErr; + self = (MP4DataReferenceAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static u32 getEntryCount( struct MP4DataReferenceAtom *self ) +static u32 getEntryCount(struct MP4DataReferenceAtom *self) { - u32 entryCount = 0; - MP4GetListEntryCount( self->atomList, &entryCount ); - return entryCount; + u32 entryCount = 0; + MP4GetListEntryCount(self->atomList, &entryCount); + return entryCount; } -static MP4Err getEntry( struct MP4DataReferenceAtom *self, u32 dataReferenceIndex, struct MP4DataEntryAtom **outEntry ) +static MP4Err getEntry(struct MP4DataReferenceAtom *self, u32 dataReferenceIndex, + struct MP4DataEntryAtom **outEntry) { - MP4DataEntryAtomPtr entry; - MP4Err err; - - err = MP4NoErr; - if ( (dataReferenceIndex < 1) || (outEntry == NULL) || (dataReferenceIndex > getEntryCount(self)) ) - BAILWITHERROR( MP4BadParamErr ) - err = MP4GetListEntry( self->atomList, dataReferenceIndex - 1, (char**) &entry ); if (err) goto bail; - *outEntry = entry; + MP4DataEntryAtomPtr entry; + MP4Err err; + + err = MP4NoErr; + if((dataReferenceIndex < 1) || (outEntry == NULL) || (dataReferenceIndex > getEntryCount(self))) + BAILWITHERROR(MP4BadParamErr) + err = MP4GetListEntry(self->atomList, dataReferenceIndex - 1, (char **)&entry); + if(err) goto bail; + *outEntry = entry; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getOffset( struct MP4DataReferenceAtom *self, u32 dataReferenceIndex, u64 *outOffset ) +static MP4Err getOffset(struct MP4DataReferenceAtom *self, u32 dataReferenceIndex, u64 *outOffset) { - MP4DataEntryAtomPtr entry; - MP4Err err; - - err = MP4NoErr; - if ( (dataReferenceIndex < 1) || (outOffset == NULL) || (dataReferenceIndex > getEntryCount(self)) ) - BAILWITHERROR( MP4BadParamErr ) - err = MP4GetListEntry( self->atomList, dataReferenceIndex - 1, (char**) &entry ); if (err) goto bail; - err = entry->getOffset( entry, outOffset ); if (err) goto bail; + MP4DataEntryAtomPtr entry; + MP4Err err; + + err = MP4NoErr; + if((dataReferenceIndex < 1) || (outOffset == NULL) || (dataReferenceIndex > getEntryCount(self))) + BAILWITHERROR(MP4BadParamErr) + err = MP4GetListEntry(self->atomList, dataReferenceIndex - 1, (char **)&entry); + if(err) goto bail; + err = entry->getOffset(entry, outOffset); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSampleReference( struct MP4DataReferenceAtom *self, u32 sampleCount, u32 dataReferenceIndex, u64 dataOffset, MP4Handle sizesH ) +static MP4Err addSampleReference(struct MP4DataReferenceAtom *self, u32 sampleCount, + u32 dataReferenceIndex, u64 dataOffset, MP4Handle sizesH) { - MP4DataEntryAtomPtr entry; - MP4Err err; - - err = MP4NoErr; - if ( (dataReferenceIndex < 1) || (sampleCount == 0) || (dataReferenceIndex > getEntryCount(self)) ) - BAILWITHERROR( MP4BadParamErr ) - err = MP4GetListEntry( self->atomList, dataReferenceIndex - 1, (char**) &entry ); if (err) goto bail; - err = entry->addSampleReference( entry, dataOffset, sizesH ); if (err) goto bail; + MP4DataEntryAtomPtr entry; + MP4Err err; + + err = MP4NoErr; + if((dataReferenceIndex < 1) || (sampleCount == 0) || (dataReferenceIndex > getEntryCount(self))) + BAILWITHERROR(MP4BadParamErr) + err = MP4GetListEntry(self->atomList, dataReferenceIndex - 1, (char **)&entry); + if(err) goto bail; + err = entry->addSampleReference(entry, dataOffset, sizesH); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSamples( struct MP4DataReferenceAtom *self, u32 sampleCount, u32 dataReferenceIndex, MP4Handle sampleH ) +static MP4Err addSamples(struct MP4DataReferenceAtom *self, u32 sampleCount, u32 dataReferenceIndex, + MP4Handle sampleH) { - MP4DataEntryAtomPtr entry; - MP4Err err; - - err = MP4NoErr; - if ( (dataReferenceIndex < 1) || (sampleCount == 0) || (dataReferenceIndex > getEntryCount(self)) ) - BAILWITHERROR( MP4BadParamErr ) - err = MP4GetListEntry( self->atomList, dataReferenceIndex - 1, (char**) &entry ); if (err) goto bail; - err = entry->addSamples( entry, sampleH ); if (err) goto bail; + MP4DataEntryAtomPtr entry; + MP4Err err; + + err = MP4NoErr; + if((dataReferenceIndex < 1) || (sampleCount == 0) || (dataReferenceIndex > getEntryCount(self))) + BAILWITHERROR(MP4BadParamErr) + err = MP4GetListEntry(self->atomList, dataReferenceIndex - 1, (char **)&entry); + if(err) goto bail; + err = entry->addSamples(entry, sampleH); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 entryCount; - MP4DataReferenceAtomPtr self = (MP4DataReferenceAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - entryCount = getEntryCount( self ); - PUT32_V( entryCount ); - { - SERIALIZE_ATOM_LIST( atomList ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 entryCount; + MP4DataReferenceAtomPtr self = (MP4DataReferenceAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + entryCount = getEntryCount(self); + PUT32_V(entryCount); + { + SERIALIZE_ATOM_LIST(atomList); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4DataReferenceAtomPtr self = (MP4DataReferenceAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4; - { - ADD_ATOM_LIST_SIZE( atomList ); - } + MP4Err err; + MP4DataReferenceAtomPtr self = (MP4DataReferenceAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4; + { + ADD_ATOM_LIST_SIZE(atomList); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -IMPLEMENT_NEW_ADDATOM( MP4DataReferenceAtom ) +IMPLEMENT_NEW_ADDATOM(MP4DataReferenceAtom) -static MP4Err addDataEntry( struct MP4DataReferenceAtom *self, MP4AtomPtr entry ) +static MP4Err addDataEntry(struct MP4DataReferenceAtom *self, MP4AtomPtr entry) { - MP4Err err; - err = addAtom( self, entry ); if (err) goto bail; + MP4Err err; + err = addAtom(self, entry); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 entryCount; - u32 i; - MP4DataReferenceAtomPtr self = (MP4DataReferenceAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32_V( entryCount ); - for ( i = 0; i < entryCount; i++ ) - { - MP4AtomPtr atom; - err = MP4ParseAtom( inputStream, &atom ); if (err) goto bail; - self->bytesRead += atom->size; - err = addAtom( self, atom ); if (err) goto bail; - } - if ( self->bytesRead != self->size ) - BAILWITHERROR( MP4BadDataErr ) + MP4Err err; + u32 entryCount; + u32 i; + MP4DataReferenceAtomPtr self = (MP4DataReferenceAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32_V(entryCount); + for(i = 0; i < entryCount; i++) + { + MP4AtomPtr atom; + err = MP4ParseAtom(inputStream, &atom); + if(err) goto bail; + self->bytesRead += atom->size; + err = addAtom(self, atom); + if(err) goto bail; + } + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateDataReferenceAtom( MP4DataReferenceAtomPtr *outAtom ) +MP4Err MP4CreateDataReferenceAtom(MP4DataReferenceAtomPtr *outAtom) { - MP4Err err; - MP4DataReferenceAtomPtr self; - - self = (MP4DataReferenceAtomPtr) calloc( 1, sizeof(MP4DataReferenceAtom) ); - if ( self == NULL ) - BAILWITHERROR( MP4NoMemoryErr ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->type = MP4DataReferenceAtomType; - self->name = "data reference"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->addDataEntry = addDataEntry; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->getOffset = getOffset; - self->addSamples = addSamples; - self->getEntryCount = getEntryCount; - self->getEntry = getEntry; - self->addSampleReference = addSampleReference; - *outAtom = self; + MP4Err err; + MP4DataReferenceAtomPtr self; + + self = (MP4DataReferenceAtomPtr)calloc(1, sizeof(MP4DataReferenceAtom)); + if(self == NULL) BAILWITHERROR(MP4NoMemoryErr) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->type = MP4DataReferenceAtomType; + self->name = "data reference"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->addDataEntry = addDataEntry; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->getOffset = getOffset; + self->addSamples = addSamples; + self->getEntryCount = getEntryCount; + self->getEntry = getEntry; + self->addSampleReference = addSampleReference; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/DecodingOffsetAtom.c b/IsoLib/libisomediafile/src/DecodingOffsetAtom.c index b31cf35..db57dda 100644 --- a/IsoLib/libisomediafile/src/DecodingOffsetAtom.c +++ b/IsoLib/libisomediafile/src/DecodingOffsetAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: DecodingOffsetAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: DecodingOffsetAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -29,260 +29,272 @@ derivative works. Copyright (c) 1999. typedef struct { - u32 sampleCount; - u32 decodingOffset; + u32 sampleCount; + u32 decodingOffset; } cttsEntry, *cttsEntryPtr; - -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4CompositionOffsetAtomPtr self; - err = MP4NoErr; - self = (MP4CompositionOffsetAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->entryList ) - { - u32 entryCount; - u32 i; - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - for ( i = 0; i < entryCount; i++ ) - { - cttsEntryPtr pe; - err = MP4GetListEntry( self->entryList, i, (char**) &pe ); if (err) goto bail; - free( pe ); - } - err = MP4DeleteLinkedList( self->entryList ); if (err) goto bail; - self->entryList = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4CompositionOffsetAtomPtr self; + err = MP4NoErr; + self = (MP4CompositionOffsetAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->entryList) + { + u32 entryCount; + u32 i; + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + for(i = 0; i < entryCount; i++) + { + cttsEntryPtr pe; + err = MP4GetListEntry(self->entryList, i, (char **)&pe); + if(err) goto bail; + free(pe); + } + err = MP4DeleteLinkedList(self->entryList); + if(err) goto bail; + self->entryList = NULL; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err getOffsetForSampleNumber( MP4AtomPtr s, u32 sampleNumber, s32 *outOffset ) +static MP4Err getOffsetForSampleNumber(MP4AtomPtr s, u32 sampleNumber, s32 *outOffset) { - MP4Err err; - u32 i; - u32 entryCount; - u32 currentSampleNumberOffset; - - MP4CompositionOffsetAtomPtr self = (MP4CompositionOffsetAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - err = MP4BadParamErr; - currentSampleNumberOffset = 0; - - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - for ( i = 0; i < entryCount; i++ ) - { - cttsEntryPtr p; - err = MP4GetListEntry( self->entryList, i, (char**) &p ); if (err) goto bail; - if ( currentSampleNumberOffset + p->sampleCount >= sampleNumber ) - { - *outOffset = p->decodingOffset; - err = MP4NoErr; - break; - } - else - currentSampleNumberOffset += p->sampleCount; - } + MP4Err err; + u32 i; + u32 entryCount; + u32 currentSampleNumberOffset; + + MP4CompositionOffsetAtomPtr self = (MP4CompositionOffsetAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + err = MP4BadParamErr; + currentSampleNumberOffset = 0; + + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + for(i = 0; i < entryCount; i++) + { + cttsEntryPtr p; + err = MP4GetListEntry(self->entryList, i, (char **)&p); + if(err) goto bail; + if(currentSampleNumberOffset + p->sampleCount >= sampleNumber) + { + *outOffset = p->decodingOffset; + err = MP4NoErr; + break; + } + else + currentSampleNumberOffset += p->sampleCount; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSample( struct MP4CompositionOffsetAtom *self, u32 offset ) +static MP4Err addSample(struct MP4CompositionOffsetAtom *self, u32 offset) { - MP4Err err; - cttsEntryPtr current; - - err = MP4NoErr; - current = (cttsEntryPtr) self->currentEntry; - if ( (current == NULL) || (current->decodingOffset != offset) ) - { - current = (cttsEntryPtr) calloc( 1, sizeof(cttsEntry) ); - TESTMALLOC( current ); - current->sampleCount = 1; - current->decodingOffset = offset; - err = MP4AddListEntry( current, self->entryList ); if (err) goto bail; - self->currentEntry = current; - } - else - { - current->sampleCount++; - } - self->finalSampleNumber++; + MP4Err err; + cttsEntryPtr current; + + err = MP4NoErr; + current = (cttsEntryPtr)self->currentEntry; + if((current == NULL) || (current->decodingOffset != offset)) + { + current = (cttsEntryPtr)calloc(1, sizeof(cttsEntry)); + TESTMALLOC(current); + current->sampleCount = 1; + current->decodingOffset = offset; + err = MP4AddListEntry(current, self->entryList); + if(err) goto bail; + self->currentEntry = current; + } + else + { + current->sampleCount++; + } + self->finalSampleNumber++; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSamples(struct MP4CompositionOffsetAtom *self, u32 sampleNumber, u32 sampleCount, MP4Handle offsetsH ) +static MP4Err addSamples(struct MP4CompositionOffsetAtom *self, u32 sampleNumber, u32 sampleCount, + MP4Handle offsetsH) { - MP4Err err; - u32 i; - u32 entryCount; - u32 offsetCount; - u32 onlyOffset; - - - err = MP4NoErr; - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - if ( self->finalSampleNumber ) - { - s32 skipSamples; - if ( self->finalSampleNumber >= sampleNumber ) - BAILWITHERROR( MP4BadParamErr ); - skipSamples = sampleNumber - self->finalSampleNumber - 1; - - if ( skipSamples > 0 ) - { - for ( i = 0; i < (u32) skipSamples; i++ ) - { - err = addSample( self, 0 ); if (err) goto bail; - } - } - } - offsetCount = 0; - onlyOffset = 0; - if ( offsetsH ) - { - err = MP4GetHandleSize( offsetsH, &offsetCount ); if (err) goto bail; - offsetCount /= sizeof(u32); - if ( offsetCount == 1 ) - onlyOffset = *(u32*) *offsetsH; - else if ( offsetCount != sampleCount ) - BAILWITHERROR( MP4BadParamErr ); - } - if ( sampleCount != offsetCount ) - { - for ( i = 0; i < sampleCount; i++ ) - { - err = addSample( self, onlyOffset ); if (err) goto bail; - } - } - else - { - u32 *offset; - offset = (u32*) *offsetsH; - for ( i = 0; i < sampleCount; i++ ) - { - err = addSample( self, *offset++ ); if (err) goto bail; - } - } + MP4Err err; + u32 i; + u32 entryCount; + u32 offsetCount; + u32 onlyOffset; + + err = MP4NoErr; + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + if(self->finalSampleNumber) + { + s32 skipSamples; + if(self->finalSampleNumber >= sampleNumber) BAILWITHERROR(MP4BadParamErr); + skipSamples = sampleNumber - self->finalSampleNumber - 1; + + if(skipSamples > 0) + { + for(i = 0; i < (u32)skipSamples; i++) + { + err = addSample(self, 0); + if(err) goto bail; + } + } + } + offsetCount = 0; + onlyOffset = 0; + if(offsetsH) + { + err = MP4GetHandleSize(offsetsH, &offsetCount); + if(err) goto bail; + offsetCount /= sizeof(u32); + if(offsetCount == 1) onlyOffset = *(u32 *)*offsetsH; + else if(offsetCount != sampleCount) + BAILWITHERROR(MP4BadParamErr); + } + if(sampleCount != offsetCount) + { + for(i = 0; i < sampleCount; i++) + { + err = addSample(self, onlyOffset); + if(err) goto bail; + } + } + else + { + u32 *offset; + offset = (u32 *)*offsetsH; + for(i = 0; i < sampleCount; i++) + { + err = addSample(self, *offset++); + if(err) goto bail; + } + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - - u32 entryCount; - MP4CompositionOffsetAtomPtr self = (MP4CompositionOffsetAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - PUT32_V( entryCount ); - - for ( i = 0; i < entryCount; i++ ) - { - cttsEntryPtr p; - err = MP4GetListEntry( self->entryList, i, (char**) &p ); if (err) goto bail; - PUT32_V( p->sampleCount ); - PUT32_V( p->decodingOffset ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + + u32 entryCount; + MP4CompositionOffsetAtomPtr self = (MP4CompositionOffsetAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + PUT32_V(entryCount); + + for(i = 0; i < entryCount; i++) + { + cttsEntryPtr p; + err = MP4GetListEntry(self->entryList, i, (char **)&p); + if(err) goto bail; + PUT32_V(p->sampleCount); + PUT32_V(p->decodingOffset); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - u32 entryCount; - MP4CompositionOffsetAtomPtr self = (MP4CompositionOffsetAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - self->size += 4 + (8 * entryCount); + MP4Err err; + u32 entryCount; + MP4CompositionOffsetAtomPtr self = (MP4CompositionOffsetAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + self->size += 4 + (8 * entryCount); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 entries; - u32 entryCount; - MP4CompositionOffsetAtomPtr self = (MP4CompositionOffsetAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32_V( entryCount ); - for ( entries = 0; entries < entryCount; entries++ ) - { - u32 count; - s32 decodingOffset; - cttsEntryPtr p; - - p = (cttsEntryPtr) calloc( 1, sizeof(cttsEntry) ); - TESTMALLOC( p ); - GET32_V( count ); - GET32_V( decodingOffset ); - p->sampleCount = count; - p->decodingOffset = decodingOffset; - err = MP4AddListEntry( p, self->entryList ); if (err) goto bail; - } + MP4Err err; + u32 entries; + u32 entryCount; + MP4CompositionOffsetAtomPtr self = (MP4CompositionOffsetAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32_V(entryCount); + for(entries = 0; entries < entryCount; entries++) + { + u32 count; + s32 decodingOffset; + cttsEntryPtr p; + + p = (cttsEntryPtr)calloc(1, sizeof(cttsEntry)); + TESTMALLOC(p); + GET32_V(count); + GET32_V(decodingOffset); + p->sampleCount = count; + p->decodingOffset = decodingOffset; + err = MP4AddListEntry(p, self->entryList); + if(err) goto bail; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateCompositionOffsetAtom( MP4CompositionOffsetAtomPtr *outAtom ) +MP4Err MP4CreateCompositionOffsetAtom(MP4CompositionOffsetAtomPtr *outAtom) { - MP4Err err; - MP4CompositionOffsetAtomPtr self; - - self = (MP4CompositionOffsetAtomPtr) calloc( 1, sizeof(MP4CompositionOffsetAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); if ( err ) goto bail; - err = MP4MakeLinkedList( &self->entryList ); if (err) goto bail; - self->type = MP4CompositionOffsetAtomType; - self->name = "decoding offset"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->getOffsetForSampleNumber = getOffsetForSampleNumber; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addSamples = addSamples; - *outAtom = self; + MP4Err err; + MP4CompositionOffsetAtomPtr self; + + self = (MP4CompositionOffsetAtomPtr)calloc(1, sizeof(MP4CompositionOffsetAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + err = MP4MakeLinkedList(&self->entryList); + if(err) goto bail; + self->type = MP4CompositionOffsetAtomType; + self->name = "decoding offset"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->getOffsetForSampleNumber = getOffsetForSampleNumber; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addSamples = addSamples; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/DegradationPriorityAtom.c b/IsoLib/libisomediafile/src/DegradationPriorityAtom.c index d019530..d4caba3 100644 --- a/IsoLib/libisomediafile/src/DegradationPriorityAtom.c +++ b/IsoLib/libisomediafile/src/DegradationPriorityAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,124 +15,123 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: DegradationPriorityAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: DegradationPriorityAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4DegradationPriorityAtomPtr self; - err = MP4NoErr; - self = (MP4DegradationPriorityAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->priorities ) - { - free( self->priorities ); - self->priorities = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4DegradationPriorityAtomPtr self; + err = MP4NoErr; + self = (MP4DegradationPriorityAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->priorities) + { + free(self->priorities); + self->priorities = NULL; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - MP4DegradationPriorityAtomPtr self = (MP4DegradationPriorityAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - for ( i = 0; i < self->entryCount; i++ ) - { - PUT16_V( self->priorities[i] ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + MP4DegradationPriorityAtomPtr self = (MP4DegradationPriorityAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + for(i = 0; i < self->entryCount; i++) + { + PUT16_V(self->priorities[i]); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4DegradationPriorityAtomPtr self = (MP4DegradationPriorityAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += (2 * self->entryCount); + MP4Err err; + MP4DegradationPriorityAtomPtr self = (MP4DegradationPriorityAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += (2 * self->entryCount); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 entries; - u16* p; - MP4DegradationPriorityAtomPtr self = (MP4DegradationPriorityAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - /* GET32( entryCount ); -- no, it's in the sample size atom, which is unreachable */ - self->entryCount = ((self->size) - (self->bytesRead))/2; - - self->priorities = (u16 *) calloc( self->entryCount, sizeof(u16) ); - TESTMALLOC( self->priorities ); - for ( entries = 0, p = self->priorities; entries < self->entryCount; entries++, p++ ) - { - u32 priority; - GET16_V( priority ); - *p = priority; - } + MP4Err err; + u32 entries; + u16 *p; + MP4DegradationPriorityAtomPtr self = (MP4DegradationPriorityAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + /* GET32( entryCount ); -- no, it's in the sample size atom, which is unreachable */ + self->entryCount = ((self->size) - (self->bytesRead)) / 2; + + self->priorities = (u16 *)calloc(self->entryCount, sizeof(u16)); + TESTMALLOC(self->priorities); + for(entries = 0, p = self->priorities; entries < self->entryCount; entries++, p++) + { + u32 priority; + GET16_V(priority); + *p = priority; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateDegradationPriorityAtom( MP4DegradationPriorityAtomPtr *outAtom ) +MP4Err MP4CreateDegradationPriorityAtom(MP4DegradationPriorityAtomPtr *outAtom) { - MP4Err err; - MP4DegradationPriorityAtomPtr self; - - self = (MP4DegradationPriorityAtomPtr) calloc( 1, sizeof(MP4DegradationPriorityAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4DegradationPriorityAtomType; - self->name = "degradation priority"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4DegradationPriorityAtomPtr self; + + self = (MP4DegradationPriorityAtomPtr)calloc(1, sizeof(MP4DegradationPriorityAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4DegradationPriorityAtomType; + self->name = "degradation priority"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c b/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c index 9bcc351..d2e0caf 100644 --- a/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c +++ b/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c @@ -28,156 +28,156 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4DownMixInstructionsAtomPtr self = (MP4DownMixInstructionsAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - if (self->bs_downmix_coefficients) - free(self->bs_downmix_coefficients); - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4DownMixInstructionsAtomPtr self = (MP4DownMixInstructionsAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + if(self->bs_downmix_coefficients) free(self->bs_downmix_coefficients); + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - u8 tmp8; - MP4Err err; - u16 i; - u16 j; - u32 index; - MP4DownMixInstructionsAtomPtr self = (MP4DownMixInstructionsAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - PUT8(targetLayout); - tmp8 = (self->reserved << 7) + self->targetChannelCount; - PUT8_V(tmp8); - tmp8 = (self->in_stream << 7) + self->downmix_ID; - PUT8_V(tmp8); - - if (self->in_stream == 0) + u8 tmp8; + MP4Err err; + u16 i; + u16 j; + u32 index; + MP4DownMixInstructionsAtomPtr self = (MP4DownMixInstructionsAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + PUT8(targetLayout); + tmp8 = (self->reserved << 7) + self->targetChannelCount; + PUT8_V(tmp8); + tmp8 = (self->in_stream << 7) + self->downmix_ID; + PUT8_V(tmp8); + + if(self->in_stream == 0) + { + for(i = 0; i < self->targetChannelCount; i++) { - for (i = 0; i < self->targetChannelCount; i++) + for(j = 0; j < self->baseChannelCount; j++) + { + index = (i * self->baseChannelCount) + j; + if((index % 2) == 0) { - for (j = 0; j < self->baseChannelCount; j++) - { - index = (i * self->baseChannelCount) + j; - if ((index % 2) == 0) - { - tmp8 = self->bs_downmix_coefficients[index] << 4; - } - else - { - tmp8 += self->bs_downmix_coefficients[index]; - PUT8_V(tmp8); - } - } + tmp8 = self->bs_downmix_coefficients[index] << 4; } - if (((self->baseChannelCount * self->targetChannelCount) % 2) == 1) + else { - tmp8 += 0x0F; - PUT8_V(tmp8); + tmp8 += self->bs_downmix_coefficients[index]; + PUT8_V(tmp8); } + } } - assert( self->bytesWritten == self->size ); + if(((self->baseChannelCount * self->targetChannelCount) % 2) == 1) + { + tmp8 += 0x0F; + PUT8_V(tmp8); + } + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4DownMixInstructionsAtomPtr self = (MP4DownMixInstructionsAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - - self->size += 3; - - if (self->in_stream == 0) - { - self->size += (self->baseChannelCount * self->targetChannelCount) / 2; - self->size += (self->baseChannelCount * self->targetChannelCount) % 2; - } - + MP4Err err; + MP4DownMixInstructionsAtomPtr self = (MP4DownMixInstructionsAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + self->size += 3; + + if(self->in_stream == 0) + { + self->size += (self->baseChannelCount * self->targetChannelCount) / 2; + self->size += (self->baseChannelCount * self->targetChannelCount) % 2; + } + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - u32 tmp8; - u16 count; - MP4Err err; - MP4DownMixInstructionsAtomPtr self = (MP4DownMixInstructionsAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - count = 0; - GET8(targetLayout); - GET8_V(tmp8); - self->reserved = tmp8 >> 7; - self->targetChannelCount = tmp8 & 0x7F; + u32 tmp8; + u16 count; + MP4Err err; + MP4DownMixInstructionsAtomPtr self = (MP4DownMixInstructionsAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + count = 0; + GET8(targetLayout); + GET8_V(tmp8); + self->reserved = tmp8 >> 7; + self->targetChannelCount = tmp8 & 0x7F; + GET8_V(tmp8); + self->in_stream = tmp8 >> 7; + self->downmix_ID = tmp8 & 0x7F; + + while(self->bytesRead < self->size) + { + self->bs_downmix_coefficients = realloc(self->bs_downmix_coefficients, count + 2); GET8_V(tmp8); - self->in_stream = tmp8 >> 7; - self->downmix_ID = tmp8 & 0x7F; - - while ( self->bytesRead < self->size) - { - self->bs_downmix_coefficients = realloc(self->bs_downmix_coefficients, count + 2); - GET8_V(tmp8); - self->bs_downmix_coefficients[count] = tmp8 >> 4; - self->bs_downmix_coefficients[count+1] = tmp8 & 0x0F; - count += 2; - } + self->bs_downmix_coefficients[count] = tmp8 >> 4; + self->bs_downmix_coefficients[count + 1] = tmp8 & 0x0F; + count += 2; + } - assert( self->bytesRead == self->size ); + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err MP4CreateDownMixInstructionsAtom( MP4DownMixInstructionsAtomPtr *outAtom ) +MP4Err MP4CreateDownMixInstructionsAtom(MP4DownMixInstructionsAtomPtr *outAtom) { - MP4Err err; - MP4DownMixInstructionsAtomPtr self; - - self = (MP4DownMixInstructionsAtomPtr) calloc( 1, sizeof(MP4DownMixInstructionsAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4DownMixInstructionsAtomType; - self->name = "down mix instructions"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->bs_downmix_coefficients = NULL; - self->reserved = 0; - - *outAtom = self; + MP4Err err; + MP4DownMixInstructionsAtomPtr self; + + self = (MP4DownMixInstructionsAtomPtr)calloc(1, sizeof(MP4DownMixInstructionsAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4DownMixInstructionsAtomType; + self->name = "down mix instructions"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->bs_downmix_coefficients = NULL; + self->reserved = 0; + + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/ESDAtom.c b/IsoLib/libisomediafile/src/ESDAtom.c index 1fc70fa..b7b8c51 100644 --- a/IsoLib/libisomediafile/src/ESDAtom.c +++ b/IsoLib/libisomediafile/src/ESDAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,120 +15,121 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ESDAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ESDAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include "MP4Descriptors.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4ESDAtomPtr self; - err = MP4NoErr; - self = (MP4ESDAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->descriptor ) - { - self->descriptor->destroy( self->descriptor ); - self->descriptor = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4ESDAtomPtr self; + err = MP4NoErr; + self = (MP4ESDAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->descriptor) + { + self->descriptor->destroy(self->descriptor); + self->descriptor = NULL; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4ESDAtomPtr self = (MP4ESDAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - { - SERIALIZE_DESCRIPTOR( descriptor ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4ESDAtomPtr self = (MP4ESDAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + { + SERIALIZE_DESCRIPTOR(descriptor); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4ESDAtomPtr self = (MP4ESDAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - { - ADD_DESCRIPTOR_SIZE( descriptor ); - } + MP4Err err; + MP4ESDAtomPtr self = (MP4ESDAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + { + ADD_DESCRIPTOR_SIZE(descriptor); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4ESDAtomPtr self = (MP4ESDAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - self->descriptorLength = self->size - self->bytesRead; - if ( self->descriptorLength == 0) - { - DEBUG_MSG( "Warning: ESD size is zero" ); - } - else - { - err = MP4ParseDescriptor( inputStream, &self->descriptor ); if (err) goto bail; - self->bytesRead += self->descriptor->size; - } - + MP4Err err; + MP4ESDAtomPtr self = (MP4ESDAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + self->descriptorLength = self->size - self->bytesRead; + if(self->descriptorLength == 0) + { + DEBUG_MSG("Warning: ESD size is zero"); + } + else + { + err = MP4ParseDescriptor(inputStream, &self->descriptor); + if(err) goto bail; + self->bytesRead += self->descriptor->size; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateESDAtom( MP4ESDAtomPtr *outAtom ) +MP4Err MP4CreateESDAtom(MP4ESDAtomPtr *outAtom) { - MP4Err err; - MP4ESDAtomPtr self; - - self = (MP4ESDAtomPtr) calloc( 1, sizeof(MP4ESDAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4ESDAtomType; - self->name = "ESD"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4ESDAtomPtr self; + + self = (MP4ESDAtomPtr)calloc(1, sizeof(MP4ESDAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4ESDAtomType; + self->name = "ESD"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ESUpdateCommand.c b/IsoLib/libisomediafile/src/ESUpdateCommand.c index 19ffd31..8bb5b4f 100644 --- a/IsoLib/libisomediafile/src/ESUpdateCommand.c +++ b/IsoLib/libisomediafile/src/ESUpdateCommand.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,152 +15,164 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ESUpdateCommand.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ESUpdateCommand.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include -static MP4Err addDescriptor( struct MP4DescriptorRecord* s, MP4DescriptorPtr desc ) +static MP4Err addDescriptor(struct MP4DescriptorRecord *s, MP4DescriptorPtr desc) { - MP4Err err; - MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr) s; - err = MP4NoErr; - switch( desc->tag ) - { - case MP4ES_DescriptorTag: - err = MP4AddListEntry( desc, self->ESDescriptors ); if (err) goto bail; - break; - - case MP4ES_ID_RefDescriptorTag: - err = MP4AddListEntry( desc, self->ES_ID_RefDescriptors ); if (err) goto bail; - break; - - default: - err = MP4AddListEntry( desc, self->extensionDescriptors ); if (err) goto bail; - break; - } + MP4Err err; + MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr)s; + err = MP4NoErr; + switch(desc->tag) + { + case MP4ES_DescriptorTag: + err = MP4AddListEntry(desc, self->ESDescriptors); + if(err) goto bail; + break; + + case MP4ES_ID_RefDescriptorTag: + err = MP4AddListEntry(desc, self->ES_ID_RefDescriptors); + if(err) goto bail; + break; + + default: + err = MP4AddListEntry(desc, self->extensionDescriptors); + if(err) goto bail; + break; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - u32 count; - u32 i; - MP4DescriptorPtr desc; - MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr) s; - err = MP4NoErr; - self->size = DESCRIPTOR_TAG_LEN_SIZE; - self->size += 2; - ADD_DESCRIPTOR_LIST_SIZE( ESDescriptors ); - ADD_DESCRIPTOR_LIST_SIZE( ES_ID_RefDescriptors ); - ADD_DESCRIPTOR_LIST_SIZE( extensionDescriptors ); + MP4Err err; + u32 count; + u32 i; + MP4DescriptorPtr desc; + MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr)s; + err = MP4NoErr; + self->size = DESCRIPTOR_TAG_LEN_SIZE; + self->size += 2; + ADD_DESCRIPTOR_LIST_SIZE(ESDescriptors); + ADD_DESCRIPTOR_LIST_SIZE(ES_ID_RefDescriptors); + ADD_DESCRIPTOR_LIST_SIZE(extensionDescriptors); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - u32 val; - MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr) s; - err = MP4NoErr; - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - val = self->objectDescriptorID << 6; - PUT16_V( val ); - SERIALIZE_DESCRIPTOR_LIST( ESDescriptors ); - SERIALIZE_DESCRIPTOR_LIST( ES_ID_RefDescriptors ); - SERIALIZE_DESCRIPTOR_LIST( extensionDescriptors ); + MP4Err err; + u32 val; + MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr)s; + err = MP4NoErr; + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + val = self->objectDescriptorID << 6; + PUT16_V(val); + SERIALIZE_DESCRIPTOR_LIST(ESDescriptors); + SERIALIZE_DESCRIPTOR_LIST(ES_ID_RefDescriptors); + SERIALIZE_DESCRIPTOR_LIST(extensionDescriptors); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 val; - MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr) s; - err = MP4NoErr; - - GET16_V( val ); - self->objectDescriptorID = val >> 6; - while ( self->bytesRead < self->size ) - { - MP4DescriptorPtr desc; - err = MP4ParseDescriptor( inputStream, &desc ); if (err) goto bail; - switch( desc->tag ) - { - case MP4ES_DescriptorTag: - err = MP4AddListEntry( desc, self->ESDescriptors ); if (err) goto bail; - break; - - case MP4ES_ID_RefDescriptorTag: - err = MP4AddListEntry( desc, self->ES_ID_RefDescriptors ); if (err) goto bail; - break; - - default: - err = MP4AddListEntry( desc, self->extensionDescriptors ); if (err) goto bail; - break; - } - self->bytesRead += desc->size; - } - + MP4Err err; + u32 val; + MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr)s; + err = MP4NoErr; + + GET16_V(val); + self->objectDescriptorID = val >> 6; + while(self->bytesRead < self->size) + { + MP4DescriptorPtr desc; + err = MP4ParseDescriptor(inputStream, &desc); + if(err) goto bail; + switch(desc->tag) + { + case MP4ES_DescriptorTag: + err = MP4AddListEntry(desc, self->ESDescriptors); + if(err) goto bail; + break; + + case MP4ES_ID_RefDescriptorTag: + err = MP4AddListEntry(desc, self->ES_ID_RefDescriptors); + if(err) goto bail; + break; + + default: + err = MP4AddListEntry(desc, self->extensionDescriptors); + if(err) goto bail; + break; + } + self->bytesRead += desc->size; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static void destroy( struct MP4DescriptorRecord* s ) + +static void destroy(struct MP4DescriptorRecord *s) { - MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr) s; - DESTROY_DESCRIPTOR_LIST( ESDescriptors ) - DESTROY_DESCRIPTOR_LIST( ES_ID_RefDescriptors ) - DESTROY_DESCRIPTOR_LIST( extensionDescriptors ) + MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr)s; + DESTROY_DESCRIPTOR_LIST(ESDescriptors) + DESTROY_DESCRIPTOR_LIST(ES_ID_RefDescriptors) + DESTROY_DESCRIPTOR_LIST(extensionDescriptors) - free( s ); + free(s); bail: - return; + return; } -static MP4Err removeESDS( struct MP4DescriptorRecord* s ) +static MP4Err removeESDS(struct MP4DescriptorRecord *s) { - MP4Err err; - MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr) s; - err = MP4NoErr; - DESTROY_DESCRIPTOR_LIST( ESDescriptors ); - err = MP4MakeLinkedList( &self->ESDescriptors ); if (err) goto bail; - bail: - return err; + MP4Err err; + MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr)s; + err = MP4NoErr; + DESTROY_DESCRIPTOR_LIST(ESDescriptors); + err = MP4MakeLinkedList(&self->ESDescriptors); + if(err) goto bail; +bail: + return err; } -MP4Err MP4CreateESDescriptorUpdate( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateESDescriptorUpdate(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4ESDescriptorUpdate ) - self->addDescriptor = addDescriptor; - self->removeESDS = removeESDS; - err = MP4MakeLinkedList( &self->ESDescriptors ); if (err) goto bail; - err = MP4MakeLinkedList( &self->ES_ID_RefDescriptors ); if (err) goto bail; - err = MP4MakeLinkedList( &self->extensionDescriptors ); if (err) goto bail; - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4ESDescriptorUpdate) + self->addDescriptor = addDescriptor; + self->removeESDS = removeESDS; + err = MP4MakeLinkedList(&self->ESDescriptors); + if(err) goto bail; + err = MP4MakeLinkedList(&self->ES_ID_RefDescriptors); + if(err) goto bail; + err = MP4MakeLinkedList(&self->extensionDescriptors); + if(err) goto bail; + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/EditAtom.c b/IsoLib/libisomediafile/src/EditAtom.c index d78d608..b006d59 100644 --- a/IsoLib/libisomediafile/src/EditAtom.c +++ b/IsoLib/libisomediafile/src/EditAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,130 +15,129 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: EditAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: EditAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4EditAtomPtr self; - u32 i; - err = MP4NoErr; - self = (MP4EditAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4EditAtomPtr self; + u32 i; + err = MP4NoErr; + self = (MP4EditAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err getEffectiveDuration( struct MP4EditAtom *self, u32 *outDuration ) +static MP4Err getEffectiveDuration(struct MP4EditAtom *self, u32 *outDuration) { - MP4EditListAtomPtr elst; - MP4Err err; - - err = MP4NoErr; - if ( outDuration == NULL ) - BAILWITHERROR( MP4BadParamErr ) - elst = (MP4EditListAtomPtr) self->editListAtom; - err = elst->getEffectiveDuration( elst, outDuration ); if (err) goto bail; + MP4EditListAtomPtr elst; + MP4Err err; + + err = MP4NoErr; + if(outDuration == NULL) BAILWITHERROR(MP4BadParamErr) + elst = (MP4EditListAtomPtr)self->editListAtom; + err = elst->getEffectiveDuration(elst, outDuration); + if(err) goto bail; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err addAtom( MP4EditAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4EditAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4AddListEntry( atom, self->atomList ); - if ( atom->type == MP4EditListAtomType ) - { - if ( self->editListAtom ) - BAILWITHERROR( MP4InvalidMediaErr ) - self->editListAtom = atom; - } + MP4Err err; + err = MP4AddListEntry(atom, self->atomList); + if(atom->type == MP4EditListAtomType) + { + if(self->editListAtom) BAILWITHERROR(MP4InvalidMediaErr) + self->editListAtom = atom; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4EditAtomPtr self = (MP4EditAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( (MP4AtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4EditAtomPtr self = (MP4EditAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields((MP4AtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4EditAtomPtr self = (MP4EditAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( (MP4AtomPtr) s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE( atomList ); + MP4Err err; + MP4EditAtomPtr self = (MP4EditAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MP4EditAtom) + PARSE_ATOM_LIST(MP4EditAtom) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateEditAtom( MP4EditAtomPtr *outAtom ) +MP4Err MP4CreateEditAtom(MP4EditAtomPtr *outAtom) { - MP4Err err; - MP4EditAtomPtr self; - - self = (MP4EditAtomPtr) calloc( 1, sizeof(MP4EditAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4EditAtomType; - self->name = "edit"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->addAtom = addAtom; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->getEffectiveDuration = getEffectiveDuration; - *outAtom = self; + MP4Err err; + MP4EditAtomPtr self; + + self = (MP4EditAtomPtr)calloc(1, sizeof(MP4EditAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4EditAtomType; + self->name = "edit"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->addAtom = addAtom; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->getEffectiveDuration = getEffectiveDuration; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/EditListAtom.c b/IsoLib/libisomediafile/src/EditListAtom.c index f252154..3410059 100644 --- a/IsoLib/libisomediafile/src/EditListAtom.c +++ b/IsoLib/libisomediafile/src/EditListAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: EditListAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: EditListAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -31,508 +31,513 @@ derivative works. Copyright (c) 1999. typedef struct { - u64 segmentDuration; - s64 mediaTime; - u32 mediaRate; - u32 emptyEdit; + u64 segmentDuration; + s64 mediaTime; + u32 mediaRate; + u32 emptyEdit; } edtsEntry, *edtsEntryPtr; -static u32 getEntryCount( struct MP4EditListAtom *self ) +static u32 getEntryCount(struct MP4EditListAtom *self) { - u32 count = 0; - MP4GetListEntryCount( self->entryList, &count ); - return count; + u32 count = 0; + MP4GetListEntryCount(self->entryList, &count); + return count; } -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4EditListAtomPtr self; - u32 entryCount; - u32 i; - - err = MP4NoErr; - self = (MP4EditListAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - entryCount = getEntryCount( self ); - for ( i = 0; i < entryCount; i++ ) - { - char *p; - err = MP4GetListEntry( self->entryList, i, &p ); if (err) goto bail; - if ( p ) - free( p ); - } - MP4DeleteLinkedList( self->entryList ); - self->entryList = NULL; - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4EditListAtomPtr self; + u32 entryCount; + u32 i; + + err = MP4NoErr; + self = (MP4EditListAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + entryCount = getEntryCount(self); + for(i = 0; i < entryCount; i++) + { + char *p; + err = MP4GetListEntry(self->entryList, i, &p); + if(err) goto bail; + if(p) free(p); + } + MP4DeleteLinkedList(self->entryList); + self->entryList = NULL; + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err getTrackOffset( struct MP4EditListAtom *self, u32 *outTrackStartTime ) +static MP4Err getTrackOffset(struct MP4EditListAtom *self, u32 *outTrackStartTime) { - MP4Err err; - u32 entryCount; - edtsEntryPtr p; - - err = MP4NoErr; - p = NULL; - - err = MP4GetListEntryCount( self->entryList, &entryCount ); - if ( entryCount == 0 ) - { - *outTrackStartTime = 0; - } - else - { - edtsEntryPtr firstSegment; - - err = MP4GetListEntry( self->entryList, 0, (char**) &firstSegment ); if (err) goto bail; - if ( firstSegment->emptyEdit ) - { - /* existing track offset */ - *outTrackStartTime = (u32)firstSegment->segmentDuration; - } - else - { - *outTrackStartTime = 0; - } - } + MP4Err err; + u32 entryCount; + edtsEntryPtr p; + + err = MP4NoErr; + p = NULL; + + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(entryCount == 0) + { + *outTrackStartTime = 0; + } + else + { + edtsEntryPtr firstSegment; + + err = MP4GetListEntry(self->entryList, 0, (char **)&firstSegment); + if(err) goto bail; + if(firstSegment->emptyEdit) + { + /* existing track offset */ + *outTrackStartTime = (u32)firstSegment->segmentDuration; + } + else + { + *outTrackStartTime = 0; + } + } bail: - return err; + return err; } -static MP4Err setTrackOffset( struct MP4EditListAtom *self, u32 trackStartTime, u64 trackDuration ) +static MP4Err setTrackOffset(struct MP4EditListAtom *self, u32 trackStartTime, u64 trackDuration) { - MP4Err err; - u32 entryCount; - edtsEntryPtr p; - - err = MP4NoErr; - p = NULL; - - err = MP4GetListEntryCount( self->entryList, &entryCount ); - if ( entryCount == 0 ) - { - p = (edtsEntryPtr) calloc( 1, sizeof(edtsEntry) ); - TESTMALLOC( p ); - p->segmentDuration = trackStartTime; - p->mediaTime = -1; - p->mediaRate = 1; - p->emptyEdit = 1; - err = MP4AddListEntry( p, self->entryList ); if (err) goto bail; - - p = (edtsEntryPtr) calloc( 1, sizeof(edtsEntry) ); - TESTMALLOC( p ); - p->segmentDuration = trackDuration; - p->mediaTime = 0; - p->mediaRate = 1; - p->emptyEdit = 0; - err = MP4AddListEntry( p, self->entryList ); if (err) goto bail; - } - else - { - edtsEntryPtr firstSegment; - - err = MP4GetListEntry( self->entryList, 0, (char**) &firstSegment ); if (err) goto bail; - if ( firstSegment->emptyEdit ) - { - /* existing track offset -- resize */ - firstSegment->segmentDuration = trackStartTime; - } - else - { - /* prepend an empty edit */ - p = (edtsEntryPtr) calloc( 1, sizeof(edtsEntry) ); - TESTMALLOC( p ); - p->segmentDuration = trackStartTime; - p->mediaTime = -1; - p->mediaRate = 1; - p->emptyEdit = 1; - err = MP4PrependListEntry( self->entryList, p ); if (err) goto bail; - } - } + MP4Err err; + u32 entryCount; + edtsEntryPtr p; + + err = MP4NoErr; + p = NULL; + + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(entryCount == 0) + { + p = (edtsEntryPtr)calloc(1, sizeof(edtsEntry)); + TESTMALLOC(p); + p->segmentDuration = trackStartTime; + p->mediaTime = -1; + p->mediaRate = 1; + p->emptyEdit = 1; + err = MP4AddListEntry(p, self->entryList); + if(err) goto bail; + + p = (edtsEntryPtr)calloc(1, sizeof(edtsEntry)); + TESTMALLOC(p); + p->segmentDuration = trackDuration; + p->mediaTime = 0; + p->mediaRate = 1; + p->emptyEdit = 0; + err = MP4AddListEntry(p, self->entryList); + if(err) goto bail; + } + else + { + edtsEntryPtr firstSegment; + + err = MP4GetListEntry(self->entryList, 0, (char **)&firstSegment); + if(err) goto bail; + if(firstSegment->emptyEdit) + { + /* existing track offset -- resize */ + firstSegment->segmentDuration = trackStartTime; + } + else + { + /* prepend an empty edit */ + p = (edtsEntryPtr)calloc(1, sizeof(edtsEntry)); + TESTMALLOC(p); + p->segmentDuration = trackStartTime; + p->mediaTime = -1; + p->mediaRate = 1; + p->emptyEdit = 1; + err = MP4PrependListEntry(self->entryList, p); + if(err) goto bail; + } + } bail: - return err; + return err; } -static MP4Err insertSegment( struct MP4EditListAtom *self, s32 trackStartTime, s32 mediaStartTime, u64 segmentDuration, u32 mediaRate ) +static MP4Err insertSegment(struct MP4EditListAtom *self, s32 trackStartTime, s32 mediaStartTime, + u64 segmentDuration, u32 mediaRate) { - MP4Err err; - u32 entryCount; - edtsEntryPtr p; - - err = MP4NoErr; - p = NULL; - - err = MP4GetListEntryCount( self->entryList, &entryCount ); - if ( entryCount == 0 ) - { - if ( trackStartTime > 0 ) - { - /* err = setTrackOffset( self, trackStartTime, segmentDuration ); if (err) goto bail; */ - /* No, that makes two segments and we only want one */ - p = (edtsEntryPtr) calloc( 1, sizeof(edtsEntry) ); - TESTMALLOC( p ); - p->segmentDuration = trackStartTime; - p->mediaTime = -1; - p->mediaRate = 1; - p->emptyEdit = 1; - err = MP4AddListEntry( p, self->entryList ); if (err) goto bail; - } - /* this used to be commented out, but without explanation. we need it now. dws */ - p = (edtsEntryPtr) calloc( 1, sizeof(edtsEntry) ); - TESTMALLOC( p ); - p->segmentDuration = segmentDuration; - p->mediaTime = mediaStartTime; - p->mediaRate = mediaRate; - err = MP4AddListEntry( p, self->entryList ); if (err) goto bail; - /* to here */ - } - else - { - if ( trackStartTime == -1 ) - { - /* append this segment */ - p = (edtsEntryPtr) calloc( 1, sizeof(edtsEntry) ); - TESTMALLOC( p ); - p->segmentDuration = segmentDuration; - p->mediaTime = mediaStartTime; - p->mediaRate = mediaRate; - err = MP4AddListEntry( p, self->entryList ); if (err) goto bail; - } - else - { - /* insert this segment */ - /* !!! complete this -- insert an edit into an existing list... !!! */ - BAILWITHERROR( MP4NotImplementedErr ); - } - } + MP4Err err; + u32 entryCount; + edtsEntryPtr p; + + err = MP4NoErr; + p = NULL; + + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(entryCount == 0) + { + if(trackStartTime > 0) + { + /* err = setTrackOffset( self, trackStartTime, segmentDuration ); if (err) goto bail; */ + /* No, that makes two segments and we only want one */ + p = (edtsEntryPtr)calloc(1, sizeof(edtsEntry)); + TESTMALLOC(p); + p->segmentDuration = trackStartTime; + p->mediaTime = -1; + p->mediaRate = 1; + p->emptyEdit = 1; + err = MP4AddListEntry(p, self->entryList); + if(err) goto bail; + } + /* this used to be commented out, but without explanation. we need it now. dws */ + p = (edtsEntryPtr)calloc(1, sizeof(edtsEntry)); + TESTMALLOC(p); + p->segmentDuration = segmentDuration; + p->mediaTime = mediaStartTime; + p->mediaRate = mediaRate; + err = MP4AddListEntry(p, self->entryList); + if(err) goto bail; + /* to here */ + } + else + { + if(trackStartTime == -1) + { + /* append this segment */ + p = (edtsEntryPtr)calloc(1, sizeof(edtsEntry)); + TESTMALLOC(p); + p->segmentDuration = segmentDuration; + p->mediaTime = mediaStartTime; + p->mediaRate = mediaRate; + err = MP4AddListEntry(p, self->entryList); + if(err) goto bail; + } + else + { + /* insert this segment */ + /* !!! complete this -- insert an edit into an existing list... !!! */ + BAILWITHERROR(MP4NotImplementedErr); + } + } bail: - return err; + return err; } -static MP4Err getEffectiveDuration( struct MP4EditListAtom *self, u32 *outDuration ) +static MP4Err getEffectiveDuration(struct MP4EditListAtom *self, u32 *outDuration) { - u32 duration; - u32 entryCount; - u32 i; - MP4Err err; - - /* This function returns 0 if there are no edits at all, which means you MUST get the media duration */ - - err = MP4NoErr; - entryCount = getEntryCount( self ); - duration = 0; - for ( i = 0; i < entryCount; i++ ) - { - edtsEntryPtr p; - err = MP4GetListEntry( self->entryList, i, (char**) &p ); if (err) goto bail; - duration += (u32) p->segmentDuration; - } - *outDuration = duration; + u32 duration; + u32 entryCount; + u32 i; + MP4Err err; + + /* This function returns 0 if there are no edits at all, which means you MUST get the media + * duration */ + + err = MP4NoErr; + entryCount = getEntryCount(self); + duration = 0; + for(i = 0; i < entryCount; i++) + { + edtsEntryPtr p; + err = MP4GetListEntry(self->entryList, i, (char **)&p); + if(err) goto bail; + duration += (u32)p->segmentDuration; + } + *outDuration = duration; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err isEmptyEdit( struct MP4EditListAtom *self, u32 segmentNumber, u32 *outIsEmpty ) +static MP4Err isEmptyEdit(struct MP4EditListAtom *self, u32 segmentNumber, u32 *outIsEmpty) { - MP4Err err; - u32 entryCount; - edtsEntryPtr p; - - err = MP4NoErr; - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - - if (outIsEmpty == NULL) BAILWITHERROR( MP4BadParamErr ); - - if ((segmentNumber == 1) && (entryCount == 0)) - *outIsEmpty = 0; - else { - if ( (segmentNumber == 0) || (segmentNumber > entryCount) ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4GetListEntry( self->entryList, segmentNumber - 1, (char**) &p ); if (err) goto bail; - *outIsEmpty = p->emptyEdit; - } + MP4Err err; + u32 entryCount; + edtsEntryPtr p; + + err = MP4NoErr; + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + + if(outIsEmpty == NULL) BAILWITHERROR(MP4BadParamErr); + + if((segmentNumber == 1) && (entryCount == 0)) *outIsEmpty = 0; + else + { + if((segmentNumber == 0) || (segmentNumber > entryCount)) BAILWITHERROR(MP4BadParamErr); + err = MP4GetListEntry(self->entryList, segmentNumber - 1, (char **)&p); + if(err) goto bail; + *outIsEmpty = p->emptyEdit; + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getIndSegmentTime( MP4AtomPtr s, - u32 segmentIndex, /* one based */ - u64 *outSegmentMovieTime, - s64 *outSegmentMediaTime, - u64 *outSegmentDuration /* in movie's time scale */ - ) +static MP4Err getIndSegmentTime(MP4AtomPtr s, u32 segmentIndex, /* one based */ + u64 *outSegmentMovieTime, s64 *outSegmentMediaTime, + u64 *outSegmentDuration /* in movie's time scale */ +) { - MP4Err err; - u32 i; - u32 entryCount; - u64 currentMovieTime; - MP4EditListAtomPtr self = (MP4EditListAtomPtr) s; - - /* This function cannot be used if there are no segments at all */ - - err = MP4NoErr; - entryCount = getEntryCount( self ); - if ( (self == NULL) || (segmentIndex == 0) || (segmentIndex > entryCount) ) - BAILWITHERROR( MP4BadParamErr ) - - currentMovieTime = 0; - for ( i = 0; i < entryCount; i++ ) - { - edtsEntryPtr p; - err = MP4GetListEntry( self->entryList, i, (char**) &p ); if (err) goto bail; - if ( i == (segmentIndex - 1) ) - { - if ( outSegmentMovieTime ) - *outSegmentMovieTime = currentMovieTime; - if ( outSegmentMediaTime ) - { - if ( p->emptyEdit ) - *outSegmentMediaTime = -1; - else - *outSegmentMediaTime = p->mediaTime; - } - if ( outSegmentDuration ) - *outSegmentDuration = p->segmentDuration; - } - else - { - currentMovieTime += p->segmentDuration; - } - } + MP4Err err; + u32 i; + u32 entryCount; + u64 currentMovieTime; + MP4EditListAtomPtr self = (MP4EditListAtomPtr)s; + + /* This function cannot be used if there are no segments at all */ + + err = MP4NoErr; + entryCount = getEntryCount(self); + if((self == NULL) || (segmentIndex == 0) || (segmentIndex > entryCount)) + BAILWITHERROR(MP4BadParamErr) + + currentMovieTime = 0; + for(i = 0; i < entryCount; i++) + { + edtsEntryPtr p; + err = MP4GetListEntry(self->entryList, i, (char **)&p); + if(err) goto bail; + if(i == (segmentIndex - 1)) + { + if(outSegmentMovieTime) *outSegmentMovieTime = currentMovieTime; + if(outSegmentMediaTime) + { + if(p->emptyEdit) *outSegmentMediaTime = -1; + else + *outSegmentMediaTime = p->mediaTime; + } + if(outSegmentDuration) *outSegmentDuration = p->segmentDuration; + } + else + { + currentMovieTime += p->segmentDuration; + } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err getTimeAndRate( MP4AtomPtr s, u64 movieTime, u32 movieTimeScale, - u32 mediaTimeScale, s64 *outMediaTime, u32 *outMediaRate, - u64 *outPriorSegmentEndTime, u64 *outNextSegmentBeginTime ) +static MP4Err getTimeAndRate(MP4AtomPtr s, u64 movieTime, u32 movieTimeScale, u32 mediaTimeScale, + s64 *outMediaTime, u32 *outMediaRate, u64 *outPriorSegmentEndTime, + u64 *outNextSegmentBeginTime) { - MP4Err err; - - u32 i; - u32 entryCount; - u64 currentMovieTime; - u64 priorSegmentEndTime; - u64 nextSegmentBeginTime; - MP4EditListAtomPtr self = (MP4EditListAtomPtr) s; - - /* This function cannot be used if there are no segments at all */ - - err = MP4NoErr; - if ( (self == NULL) || (movieTimeScale == 0) || (mediaTimeScale == 0) ) - BAILWITHERROR( MP4BadParamErr ) - currentMovieTime = 0; - *outMediaTime = -1; - *outMediaRate = 1 << 16; - priorSegmentEndTime = 0; - nextSegmentBeginTime = 0; - - /* - We rely on there being no consecutive empty edits, and - this is not tested !!! - */ - entryCount = getEntryCount( self ); - for ( i = 0; i < entryCount; i++ ) - { - edtsEntryPtr p; - u64 secondsOffset; - err = MP4GetListEntry( self->entryList, i, (char**) &p ); if (err) goto bail; - if ( (currentMovieTime + p->segmentDuration) >= movieTime ) - { - /* found the correct segment */ - if ( p->emptyEdit ) - { - /* an empty edit */ - *outMediaTime = -1; - *outMediaRate = p->mediaRate; - if ( i < entryCount ) - nextSegmentBeginTime = (p+1)->mediaTime; - break; - } - else - { - /* normal edit */ - secondsOffset = (movieTime - currentMovieTime) / movieTimeScale; - *outMediaTime = p->mediaTime + (secondsOffset * mediaTimeScale); - *outMediaRate = p->mediaRate; - } - } - else - { - /* advance to next segment */ - secondsOffset = p->segmentDuration / movieTimeScale; - priorSegmentEndTime = secondsOffset * mediaTimeScale; - currentMovieTime += p->segmentDuration; - } - } - if ( outPriorSegmentEndTime ) - *outPriorSegmentEndTime = priorSegmentEndTime; - if ( outNextSegmentBeginTime ) - *outNextSegmentBeginTime = nextSegmentBeginTime; + MP4Err err; + + u32 i; + u32 entryCount; + u64 currentMovieTime; + u64 priorSegmentEndTime; + u64 nextSegmentBeginTime; + MP4EditListAtomPtr self = (MP4EditListAtomPtr)s; + + /* This function cannot be used if there are no segments at all */ + + err = MP4NoErr; + if((self == NULL) || (movieTimeScale == 0) || (mediaTimeScale == 0)) BAILWITHERROR(MP4BadParamErr) + currentMovieTime = 0; + *outMediaTime = -1; + *outMediaRate = 1 << 16; + priorSegmentEndTime = 0; + nextSegmentBeginTime = 0; + + /* + We rely on there being no consecutive empty edits, and + this is not tested !!! + */ + entryCount = getEntryCount(self); + for(i = 0; i < entryCount; i++) + { + edtsEntryPtr p; + u64 secondsOffset; + err = MP4GetListEntry(self->entryList, i, (char **)&p); + if(err) goto bail; + if((currentMovieTime + p->segmentDuration) >= movieTime) + { + /* found the correct segment */ + if(p->emptyEdit) + { + /* an empty edit */ + *outMediaTime = -1; + *outMediaRate = p->mediaRate; + if(i < entryCount) nextSegmentBeginTime = (p + 1)->mediaTime; + break; + } + else + { + /* normal edit */ + secondsOffset = (movieTime - currentMovieTime) / movieTimeScale; + *outMediaTime = p->mediaTime + (secondsOffset * mediaTimeScale); + *outMediaRate = p->mediaRate; + } + } + else + { + /* advance to next segment */ + secondsOffset = p->segmentDuration / movieTimeScale; + priorSegmentEndTime = secondsOffset * mediaTimeScale; + currentMovieTime += p->segmentDuration; + } + } + if(outPriorSegmentEndTime) *outPriorSegmentEndTime = priorSegmentEndTime; + if(outNextSegmentBeginTime) *outNextSegmentBeginTime = nextSegmentBeginTime; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - u32 entryCount; - MP4EditListAtomPtr self = (MP4EditListAtomPtr) s; - err = MP4NoErr; - entryCount = getEntryCount( self ); - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32_V( entryCount ); - - for ( i = 0; i < entryCount; i++ ) - { - edtsEntryPtr p; - u32 rate; - err = MP4GetListEntry( self->entryList, i, (char**) &p ); if (err) goto bail; - if ( self->version == 1 ) - { - PUT64_V( p->segmentDuration ); - PUT64_V( p->mediaTime ); - } - else - { - s32 mediaTime = (s32) p->mediaTime; - PUT32_V( p->segmentDuration ); - PUT32_V( mediaTime ); - } - rate = p->mediaRate << 16; - PUT32_V( rate ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + u32 entryCount; + MP4EditListAtomPtr self = (MP4EditListAtomPtr)s; + err = MP4NoErr; + entryCount = getEntryCount(self); + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32_V(entryCount); + + for(i = 0; i < entryCount; i++) + { + edtsEntryPtr p; + u32 rate; + err = MP4GetListEntry(self->entryList, i, (char **)&p); + if(err) goto bail; + if(self->version == 1) + { + PUT64_V(p->segmentDuration); + PUT64_V(p->mediaTime); + } + else + { + s32 mediaTime = (s32)p->mediaTime; + PUT32_V(p->segmentDuration); + PUT32_V(mediaTime); + } + rate = p->mediaRate << 16; + PUT32_V(rate); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - u32 durtimebytes; - u32 entryCount; - MP4EditListAtomPtr self = (MP4EditListAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4; - durtimebytes = self->version == 1 ? 16 : 8; - entryCount = getEntryCount( self ); - self->size += (entryCount * (durtimebytes + 4)); + MP4Err err; + u32 durtimebytes; + u32 entryCount; + MP4EditListAtomPtr self = (MP4EditListAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4; + durtimebytes = self->version == 1 ? 16 : 8; + entryCount = getEntryCount(self); + self->size += (entryCount * (durtimebytes + 4)); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 entries; - u32 entryCount; - MP4EditListAtomPtr self = (MP4EditListAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32_V( entryCount ); - for ( entries = 0; entries < entryCount; entries++ ) - { - u64 segmentDuration; - s64 mediaTime; - u32 mediaRate; - edtsEntryPtr p; - p = (edtsEntryPtr) calloc( 1, sizeof(edtsEntry) ); - TESTMALLOC( p ); - if ( self->version == 1 ) - { - GET64_V( segmentDuration ); - GET64_V( mediaTime ); - if ( mediaTime < 0 ) - p->emptyEdit = 1; - } - else - { - u32 val; - s32 sval; - GET32_V_MSG( val, "segment-duration" ); - segmentDuration = val; - GET32_V_MSG( sval, "media-time" ); - mediaTime = sval; - if ( sval < 0 ) - p->emptyEdit = 1; - } - GET32_V( mediaRate ); - /* - Earlier versions of this code - forgot that mediaRate was fixed32! - */ + MP4Err err; + u32 entries; + u32 entryCount; + MP4EditListAtomPtr self = (MP4EditListAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32_V(entryCount); + for(entries = 0; entries < entryCount; entries++) + { + u64 segmentDuration; + s64 mediaTime; + u32 mediaRate; + edtsEntryPtr p; + p = (edtsEntryPtr)calloc(1, sizeof(edtsEntry)); + TESTMALLOC(p); + if(self->version == 1) + { + GET64_V(segmentDuration); + GET64_V(mediaTime); + if(mediaTime < 0) p->emptyEdit = 1; + } + else + { + u32 val; + s32 sval; + GET32_V_MSG(val, "segment-duration"); + segmentDuration = val; + GET32_V_MSG(sval, "media-time"); + mediaTime = sval; + if(sval < 0) p->emptyEdit = 1; + } + GET32_V(mediaRate); + /* + Earlier versions of this code + forgot that mediaRate was fixed32! + */ #ifdef USE_OLD_FILES_WORKAROUND - if ( mediaRate != 1 ) + if(mediaRate != 1) #endif - { - mediaRate >>= 16; - } - p->segmentDuration = segmentDuration; - p->mediaTime = mediaTime; - p->mediaRate = mediaRate; - err = MP4AddListEntry( p, self->entryList ); if (err) goto bail; - } + { + mediaRate >>= 16; + } + p->segmentDuration = segmentDuration; + p->mediaTime = mediaTime; + p->mediaRate = mediaRate; + err = MP4AddListEntry(p, self->entryList); + if(err) goto bail; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateEditListAtom( MP4EditListAtomPtr *outAtom ) +MP4Err MP4CreateEditListAtom(MP4EditListAtomPtr *outAtom) { - MP4Err err; - MP4EditListAtomPtr self; - - self = (MP4EditListAtomPtr) calloc( 1, sizeof(MP4EditListAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); if (err) goto bail; - err = MP4MakeLinkedList( &self->entryList ); if (err) goto bail; - self->type = MP4EditListAtomType; - self->name = "edit list"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->insertSegment = insertSegment; - self->getTimeAndRate = getTimeAndRate; - self->getIndSegmentTime = getIndSegmentTime; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->getEffectiveDuration = getEffectiveDuration; - self->getEntryCount = getEntryCount; - self->setTrackOffset = setTrackOffset; - self->getTrackOffset = getTrackOffset; - self->isEmptyEdit = isEmptyEdit; - *outAtom = self; + MP4Err err; + MP4EditListAtomPtr self; + + self = (MP4EditListAtomPtr)calloc(1, sizeof(MP4EditListAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + err = MP4MakeLinkedList(&self->entryList); + if(err) goto bail; + self->type = MP4EditListAtomType; + self->name = "edit list"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->insertSegment = insertSegment; + self->getTimeAndRate = getTimeAndRate; + self->getIndSegmentTime = getIndSegmentTime; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->getEffectiveDuration = getEffectiveDuration; + self->getEntryCount = getEntryCount; + self->setTrackOffset = setTrackOffset; + self->getTrackOffset = getTrackOffset; + self->isEmptyEdit = isEmptyEdit; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c b/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c index 3b61012..a49b85b 100644 --- a/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c +++ b/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,354 +15,402 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: EncAudioSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: EncAudioSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4EncAudioSampleEntryAtomPtr self; - err = MP4NoErr; - self = (MP4EncAudioSampleEntryAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->SecurityInfo ) - { - self->SecurityInfo->destroy( self->SecurityInfo ); - self->SecurityInfo = NULL; - } - DESTROY_ATOM_LIST_F( ExtensionAtomList ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4EncAudioSampleEntryAtomPtr self; + err = MP4NoErr; + self = (MP4EncAudioSampleEntryAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->SecurityInfo) + { + self->SecurityInfo->destroy(self->SecurityInfo); + self->SecurityInfo = NULL; + } + DESTROY_ATOM_LIST_F(ExtensionAtomList) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4EncAudioSampleEntryAtomPtr self = (MP4EncAudioSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( self->reserved1, 6 ); - PUT16( dataReferenceIndex ); - PUTBYTES( self->reserved2, 8 ); - PUT16( reserved3 ); - PUT16( reserved4 ); - PUT32( reserved5 ); - PUT16( timeScale ); - PUT16( reserved6 ); - SERIALIZE_ATOM_LIST( ExtensionAtomList ); - SERIALIZE_ATOM( SecurityInfo ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4EncAudioSampleEntryAtomPtr self = (MP4EncAudioSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(self->reserved1, 6); + PUT16(dataReferenceIndex); + PUTBYTES(self->reserved2, 8); + PUT16(reserved3); + PUT16(reserved4); + PUT32(reserved5); + PUT16(timeScale); + PUT16(reserved6); + SERIALIZE_ATOM_LIST(ExtensionAtomList); + SERIALIZE_ATOM(SecurityInfo); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4EncAudioSampleEntryAtomPtr self = (MP4EncAudioSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 14 + (1*4)+(5*2); - ADD_ATOM_SIZE( SecurityInfo ); - ADD_ATOM_LIST_SIZE( ExtensionAtomList ); + MP4Err err; + MP4EncAudioSampleEntryAtomPtr self = (MP4EncAudioSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 14 + (1 * 4) + (5 * 2); + ADD_ATOM_SIZE(SecurityInfo); + ADD_ATOM_LIST_SIZE(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addAtom( MP4EncAudioSampleEntryAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4EncAudioSampleEntryAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - if ( atom == NULL ) - BAILWITHERROR( MP4BadParamErr ); - if (atom->type == MP4SecurityInfoAtomType) - self->SecurityInfo = atom; - else { err = MP4AddListEntry( atom, self->ExtensionAtomList ); if (err) goto bail; } - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + err = MP4NoErr; + if(atom == NULL) BAILWITHERROR(MP4BadParamErr); + if(atom->type == MP4SecurityInfoAtomType) self->SecurityInfo = atom; + else + { + err = MP4AddListEntry(atom, self->ExtensionAtomList); + if(err) goto bail; + } +bail: + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4EncAudioSampleEntryAtomPtr self = (MP4EncAudioSampleEntryAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GETBYTES( 6, reserved1 ); - GET16( dataReferenceIndex ); - GETBYTES( 8, reserved2 ); - GET16( reserved3 ); - GET16( reserved4 ); - GET32( reserved5 ); - GET16( timeScale ); - GET16( reserved6 ); - while ( self->bytesRead < self->size ) - { - MP4AtomPtr atom; - err = MP4ParseAtom( (MP4InputStreamPtr) inputStream, &atom ); - if (err) goto bail; - self->bytesRead += atom->size; - if ( ((atom->type)== MP4FreeSpaceAtomType) || ((atom->type)== MP4SkipAtomType)) - atom->destroy( atom ); - else { - err = addAtom( self, atom ); - if (err) goto bail; - } - } - if ( self->bytesRead != self->size ) - BAILWITHERROR( MP4BadDataErr ) + MP4Err err; + MP4EncAudioSampleEntryAtomPtr self = (MP4EncAudioSampleEntryAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GETBYTES(6, reserved1); + GET16(dataReferenceIndex); + GETBYTES(8, reserved2); + GET16(reserved3); + GET16(reserved4); + GET32(reserved5); + GET16(timeScale); + GET16(reserved6); + while(self->bytesRead < self->size) + { + MP4AtomPtr atom; + err = MP4ParseAtom((MP4InputStreamPtr)inputStream, &atom); + if(err) goto bail; + self->bytesRead += atom->size; + if(((atom->type) == MP4FreeSpaceAtomType) || ((atom->type) == MP4SkipAtomType)) + atom->destroy(atom); + else + { + err = addAtom(self, atom); + if(err) goto bail; + } + } + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err transform(struct MP4Atom *s, u32 sch_type, u32 sch_version, char* sch_url ) +static MP4Err transform(struct MP4Atom *s, u32 sch_type, u32 sch_version, char *sch_url) { - MP4Err err; - - MP4EncBaseSampleEntryAtomPtr self = (MP4EncBaseSampleEntryAtomPtr) s; - MP4OriginalFormatAtomPtr fmt; - MP4SecurityInfoAtomPtr sinf; - MP4SchemeTypeAtomPtr schm; - MP4SchemeInfoAtomPtr schi; - char* sch_url_copy = NULL; - - err = MP4CreateOriginalFormatAtom( &fmt ); if (err) goto bail; - fmt->original_format = self->type; - - err = MP4CreateSchemeInfoAtom( &schi ); if (err) goto bail; - - err = MP4CreateSchemeTypeAtom( &schm ); if (err) goto bail; - schm->scheme_type = sch_type; - schm->scheme_version = sch_version; - - if (sch_url) { - sch_url_copy = (char*) calloc( 1, strlen(sch_url)+1 ); - TESTMALLOC( sch_url_copy ); - memcpy( sch_url_copy, sch_url, strlen(sch_url)+1 ); - schm->scheme_url = sch_url_copy; sch_url_copy = NULL; - } - else schm->scheme_url = NULL; - - err = MP4CreateSecurityInfoAtom( &sinf ); if (err) goto bail; - sinf->MP4OriginalFormat = (MP4AtomPtr) fmt; fmt = NULL; - sinf->MP4SchemeType = (MP4AtomPtr) schm; schm = NULL; - sinf->MP4SchemeInfo = (MP4AtomPtr) schi; schi = NULL; - - self->type = self->enc_type; - self->SecurityInfo = (MP4AtomPtr) sinf; - + MP4Err err; + + MP4EncBaseSampleEntryAtomPtr self = (MP4EncBaseSampleEntryAtomPtr)s; + MP4OriginalFormatAtomPtr fmt; + MP4SecurityInfoAtomPtr sinf; + MP4SchemeTypeAtomPtr schm; + MP4SchemeInfoAtomPtr schi; + char *sch_url_copy = NULL; + + err = MP4CreateOriginalFormatAtom(&fmt); + if(err) goto bail; + fmt->original_format = self->type; + + err = MP4CreateSchemeInfoAtom(&schi); + if(err) goto bail; + + err = MP4CreateSchemeTypeAtom(&schm); + if(err) goto bail; + schm->scheme_type = sch_type; + schm->scheme_version = sch_version; + + if(sch_url) + { + sch_url_copy = (char *)calloc(1, strlen(sch_url) + 1); + TESTMALLOC(sch_url_copy); + memcpy(sch_url_copy, sch_url, strlen(sch_url) + 1); + schm->scheme_url = sch_url_copy; + sch_url_copy = NULL; + } + else + schm->scheme_url = NULL; + + err = MP4CreateSecurityInfoAtom(&sinf); + if(err) goto bail; + sinf->MP4OriginalFormat = (MP4AtomPtr)fmt; + fmt = NULL; + sinf->MP4SchemeType = (MP4AtomPtr)schm; + schm = NULL; + sinf->MP4SchemeInfo = (MP4AtomPtr)schi; + schi = NULL; + + self->type = self->enc_type; + self->SecurityInfo = (MP4AtomPtr)sinf; + bail: - if (fmt) fmt->destroy( (MP4AtomPtr) fmt ); - if (schm) schm->destroy( (MP4AtomPtr) schm ); - if (schi) schi->destroy( (MP4AtomPtr) schi ); - if (sch_url_copy) free( sch_url_copy ); - - TEST_RETURN( err ); - - return err; + if(fmt) fmt->destroy((MP4AtomPtr)fmt); + if(schm) schm->destroy((MP4AtomPtr)schm); + if(schi) schi->destroy((MP4AtomPtr)schi); + if(sch_url_copy) free(sch_url_copy); + + TEST_RETURN(err); + + return err; } -static MP4Err untransform(struct MP4Atom *s ) +static MP4Err untransform(struct MP4Atom *s) { - MP4Err err; - - MP4EncBaseSampleEntryAtomPtr self = (MP4EncBaseSampleEntryAtomPtr) s; - MP4OriginalFormatAtomPtr fmt; - MP4SecurityInfoAtomPtr sinf; - - err = MP4NoErr; - - sinf = (MP4SecurityInfoAtomPtr) self->SecurityInfo; - if (!sinf) { err = MP4BadParamErr; goto bail; } - - fmt = (MP4OriginalFormatAtomPtr) sinf->MP4OriginalFormat; - if (!fmt) { err = MP4BadDataErr; goto bail; } - - self->type = fmt->original_format; - self->SecurityInfo = NULL; - - sinf->destroy( (MP4AtomPtr) sinf ); - + MP4Err err; + + MP4EncBaseSampleEntryAtomPtr self = (MP4EncBaseSampleEntryAtomPtr)s; + MP4OriginalFormatAtomPtr fmt; + MP4SecurityInfoAtomPtr sinf; + + err = MP4NoErr; + + sinf = (MP4SecurityInfoAtomPtr)self->SecurityInfo; + if(!sinf) + { + err = MP4BadParamErr; + goto bail; + } + + fmt = (MP4OriginalFormatAtomPtr)sinf->MP4OriginalFormat; + if(!fmt) + { + err = MP4BadDataErr; + goto bail; + } + + self->type = fmt->original_format; + self->SecurityInfo = NULL; + + sinf->destroy((MP4AtomPtr)sinf); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSchemeInfoAtom(struct MP4Atom *s, struct MP4Atom *theAtom ) +static MP4Err addSchemeInfoAtom(struct MP4Atom *s, struct MP4Atom *theAtom) { - MP4Err err; - - MP4EncBaseSampleEntryAtomPtr self = (MP4EncBaseSampleEntryAtomPtr) s; - MP4SchemeInfoAtomPtr schi; - MP4SecurityInfoAtomPtr sinf; - - sinf = (MP4SecurityInfoAtomPtr) self->SecurityInfo; - if (!sinf) { err = MP4BadParamErr; goto bail; } - - schi = (MP4SchemeInfoAtomPtr) sinf->MP4SchemeInfo; - if (!schi) { err = MP4BadDataErr; goto bail; } - - err = schi->addAtom( schi, theAtom ); if (err) goto bail; - + MP4Err err; + + MP4EncBaseSampleEntryAtomPtr self = (MP4EncBaseSampleEntryAtomPtr)s; + MP4SchemeInfoAtomPtr schi; + MP4SecurityInfoAtomPtr sinf; + + sinf = (MP4SecurityInfoAtomPtr)self->SecurityInfo; + if(!sinf) + { + err = MP4BadParamErr; + goto bail; + } + + schi = (MP4SchemeInfoAtomPtr)sinf->MP4SchemeInfo; + if(!schi) + { + err = MP4BadDataErr; + goto bail; + } + + err = schi->addAtom(schi, theAtom); + if(err) goto bail; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getSchemeInfoAtom(struct MP4Atom *s, u32 theType, struct MP4Atom **theAtom ) +static MP4Err getSchemeInfoAtom(struct MP4Atom *s, u32 theType, struct MP4Atom **theAtom) { - MP4Err err; - - MP4EncBaseSampleEntryAtomPtr self = (MP4EncBaseSampleEntryAtomPtr) s; - MP4SchemeInfoAtomPtr schi; - MP4SecurityInfoAtomPtr sinf; - - err = MP4NoErr; - - sinf = (MP4SecurityInfoAtomPtr) self->SecurityInfo; - if (!sinf) { err = MP4BadParamErr; goto bail; } - - schi = (MP4SchemeInfoAtomPtr) sinf->MP4SchemeInfo; - if (!schi) { err = MP4BadDataErr; goto bail; } - - err = MP4BadParamErr; - *theAtom = NULL; - - if ( schi->atomList ) - { - u32 count; - u32 i; - struct MP4Atom* desc; - err = MP4GetListEntryCount( schi->atomList, &count ); if (err) goto bail; - for ( i = 0; i < count; i++ ) - { - err = MP4GetListEntry( schi->atomList, i, (char **) &desc ); if (err) goto bail; - if ( desc && (desc->type == theType)) - { - *theAtom = desc; - break; - err = MP4NoErr; - } - } - } - + MP4Err err; + + MP4EncBaseSampleEntryAtomPtr self = (MP4EncBaseSampleEntryAtomPtr)s; + MP4SchemeInfoAtomPtr schi; + MP4SecurityInfoAtomPtr sinf; + + err = MP4NoErr; + + sinf = (MP4SecurityInfoAtomPtr)self->SecurityInfo; + if(!sinf) + { + err = MP4BadParamErr; + goto bail; + } + + schi = (MP4SchemeInfoAtomPtr)sinf->MP4SchemeInfo; + if(!schi) + { + err = MP4BadDataErr; + goto bail; + } + + err = MP4BadParamErr; + *theAtom = NULL; + + if(schi->atomList) + { + u32 count; + u32 i; + struct MP4Atom *desc; + err = MP4GetListEntryCount(schi->atomList, &count); + if(err) goto bail; + for(i = 0; i < count; i++) + { + err = MP4GetListEntry(schi->atomList, i, (char **)&desc); + if(err) goto bail; + if(desc && (desc->type == theType)) + { + *theAtom = desc; + break; + err = MP4NoErr; + } + } + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getScheme(struct MP4Atom *s, u32* sch_type, u32* sch_version, char** sch_url ) +static MP4Err getScheme(struct MP4Atom *s, u32 *sch_type, u32 *sch_version, char **sch_url) { - MP4Err err; - - MP4EncBaseSampleEntryAtomPtr self = (MP4EncBaseSampleEntryAtomPtr) s; - MP4SchemeTypeAtomPtr schm; - MP4SecurityInfoAtomPtr sinf; - char* sch_url_copy; - - err = MP4NoErr; - - sinf = (MP4SecurityInfoAtomPtr) self->SecurityInfo; - if (!sinf) { err = MP4BadParamErr; goto bail; } - - schm = (MP4SchemeTypeAtomPtr)sinf->MP4SchemeType; - if (!schm) { err = MP4BadDataErr; goto bail; } - - *sch_type = schm->scheme_type; - *sch_version = schm->scheme_version; - - if (sch_url) { - sch_url_copy = (char*) calloc( 1, strlen(schm->scheme_url)+1 ); - TESTMALLOC( sch_url_copy ); - memcpy( sch_url_copy, schm->scheme_url, strlen(schm->scheme_url)+1 ); - *sch_url = sch_url_copy; - } - + MP4Err err; + + MP4EncBaseSampleEntryAtomPtr self = (MP4EncBaseSampleEntryAtomPtr)s; + MP4SchemeTypeAtomPtr schm; + MP4SecurityInfoAtomPtr sinf; + char *sch_url_copy; + + err = MP4NoErr; + + sinf = (MP4SecurityInfoAtomPtr)self->SecurityInfo; + if(!sinf) + { + err = MP4BadParamErr; + goto bail; + } + + schm = (MP4SchemeTypeAtomPtr)sinf->MP4SchemeType; + if(!schm) + { + err = MP4BadDataErr; + goto bail; + } + + *sch_type = schm->scheme_type; + *sch_version = schm->scheme_version; + + if(sch_url) + { + sch_url_copy = (char *)calloc(1, strlen(schm->scheme_url) + 1); + TESTMALLOC(sch_url_copy); + memcpy(sch_url_copy, schm->scheme_url, strlen(schm->scheme_url) + 1); + *sch_url = sch_url_copy; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -MP4Err MP4CreateEncBaseAtom( MP4EncBaseSampleEntryAtomPtr self ) +MP4Err MP4CreateEncBaseAtom(MP4EncBaseSampleEntryAtomPtr self) { - MP4Err err; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - - self->untransform = untransform; - self->addSchemeInfoAtom = addSchemeInfoAtom; - self->getSchemeInfoAtom = getSchemeInfoAtom; - self->getScheme = getScheme; - self->transform = transform; - err = MP4MakeLinkedList( &self->ExtensionAtomList ); if (err) goto bail; + MP4Err err; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = MP4CreateBaseAtom((MP4AtomPtr)self); + + self->untransform = untransform; + self->addSchemeInfoAtom = addSchemeInfoAtom; + self->getSchemeInfoAtom = getSchemeInfoAtom; + self->getScheme = getScheme; + self->transform = transform; + err = MP4MakeLinkedList(&self->ExtensionAtomList); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateEncAudioSampleEntryAtom( MP4EncAudioSampleEntryAtomPtr *outAtom ) +MP4Err MP4CreateEncAudioSampleEntryAtom(MP4EncAudioSampleEntryAtomPtr *outAtom) { - MP4Err err; - MP4EncAudioSampleEntryAtomPtr self; - - self = (MP4EncAudioSampleEntryAtomPtr) calloc( 1, sizeof(MP4EncAudioSampleEntryAtom) ); - TESTMALLOC( self ); - - err = MP4CreateEncBaseAtom( (MP4EncBaseSampleEntryAtomPtr) self ); - if ( err ) goto bail; - self->type = MP4EncAudioSampleEntryAtomType; - self->name = "protected audio sample entry"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->enc_type = MP4EncAudioSampleEntryAtomType; - self->reserved3 = 2; - self->reserved4 = 16; - self->timeScale = 44100; - *outAtom = self; + MP4Err err; + MP4EncAudioSampleEntryAtomPtr self; + + self = (MP4EncAudioSampleEntryAtomPtr)calloc(1, sizeof(MP4EncAudioSampleEntryAtom)); + TESTMALLOC(self); + + err = MP4CreateEncBaseAtom((MP4EncBaseSampleEntryAtomPtr)self); + if(err) goto bail; + self->type = MP4EncAudioSampleEntryAtomType; + self->name = "protected audio sample entry"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->enc_type = MP4EncAudioSampleEntryAtomType; + self->reserved3 = 2; + self->reserved4 = 16; + self->timeScale = 44100; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/EncVisualSampleEntryAtom.c b/IsoLib/libisomediafile/src/EncVisualSampleEntryAtom.c index a855682..61d9717 100644 --- a/IsoLib/libisomediafile/src/EncVisualSampleEntryAtom.c +++ b/IsoLib/libisomediafile/src/EncVisualSampleEntryAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,177 +15,182 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: EncVisualSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: EncVisualSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4EncVisualSampleEntryAtomPtr self; - err = MP4NoErr; - self = (MP4EncVisualSampleEntryAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->SecurityInfo ) - { - self->SecurityInfo->destroy( self->SecurityInfo ); - self->SecurityInfo = NULL; - } - DESTROY_ATOM_LIST_F( ExtensionAtomList ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4EncVisualSampleEntryAtomPtr self; + err = MP4NoErr; + self = (MP4EncVisualSampleEntryAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->SecurityInfo) + { + self->SecurityInfo->destroy(self->SecurityInfo); + self->SecurityInfo = NULL; + } + DESTROY_ATOM_LIST_F(ExtensionAtomList) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4EncVisualSampleEntryAtomPtr self = (MP4EncVisualSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( self->reserved1, 6 ); - PUT16( dataReferenceIndex ); - PUTBYTES( self->reserved2, 16 ); - PUT16( width ); - PUT16( height ); - /* PUT32( reserved3 ); */ - PUT32( reserved4 ); - PUT32( reserved5 ); - PUT32( reserved6 ); - PUT16( reserved7 ); - PUT8( nameLength ); - PUTBYTES(self->name31, 31 ); - PUT16( reserved8 ); - PUT16( reserved9 ); - SERIALIZE_ATOM_LIST( ExtensionAtomList ); - SERIALIZE_ATOM( SecurityInfo ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4EncVisualSampleEntryAtomPtr self = (MP4EncVisualSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(self->reserved1, 6); + PUT16(dataReferenceIndex); + PUTBYTES(self->reserved2, 16); + PUT16(width); + PUT16(height); + /* PUT32( reserved3 ); */ + PUT32(reserved4); + PUT32(reserved5); + PUT32(reserved6); + PUT16(reserved7); + PUT8(nameLength); + PUTBYTES(self->name31, 31); + PUT16(reserved8); + PUT16(reserved9); + SERIALIZE_ATOM_LIST(ExtensionAtomList); + SERIALIZE_ATOM(SecurityInfo); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4EncVisualSampleEntryAtomPtr self = (MP4EncVisualSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += (6 + 16 + 31 + (4*2)+(1*1)+(4*4)); - ADD_ATOM_SIZE( SecurityInfo ); - ADD_ATOM_LIST_SIZE( ExtensionAtomList ); + MP4Err err; + MP4EncVisualSampleEntryAtomPtr self = (MP4EncVisualSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += (6 + 16 + 31 + (4 * 2) + (1 * 1) + (4 * 4)); + ADD_ATOM_SIZE(SecurityInfo); + ADD_ATOM_LIST_SIZE(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addAtom( MP4EncVisualSampleEntryAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4EncVisualSampleEntryAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - if ( atom == NULL ) - BAILWITHERROR( MP4BadParamErr ); - if (atom->type == MP4SecurityInfoAtomType) - self->SecurityInfo = atom; - else { err = MP4AddListEntry( atom, self->ExtensionAtomList ); if (err) goto bail; } - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + err = MP4NoErr; + if(atom == NULL) BAILWITHERROR(MP4BadParamErr); + if(atom->type == MP4SecurityInfoAtomType) self->SecurityInfo = atom; + else + { + err = MP4AddListEntry(atom, self->ExtensionAtomList); + if(err) goto bail; + } +bail: + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4EncVisualSampleEntryAtomPtr self = (MP4EncVisualSampleEntryAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GETBYTES( 6, reserved1 ); - GET16( dataReferenceIndex ); - GETBYTES( 16, reserved2 ); - GET16( width ); - GET16( height ); - /* GET32( reserved3 ); */ - GET32( reserved4 ); - GET32( reserved5 ); - GET32( reserved6 ); - GET16( reserved7 ); - GET8( nameLength ); - GETBYTES( 31, name31 ); - GET16( reserved8 ); - GET16( reserved9 ); - while ( self->bytesRead < self->size ) - { - MP4AtomPtr atom; - err = MP4ParseAtom( (MP4InputStreamPtr) inputStream, &atom ); - if (err) goto bail; - self->bytesRead += atom->size; - if ( ((atom->type)== MP4FreeSpaceAtomType) || ((atom->type)== MP4SkipAtomType)) - atom->destroy( atom ); - else { - err = addAtom( self, atom ); - if (err) goto bail; - } - } - - if ( self->bytesRead != self->size ) - BAILWITHERROR( MP4BadDataErr ) + MP4Err err; + MP4EncVisualSampleEntryAtomPtr self = (MP4EncVisualSampleEntryAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GETBYTES(6, reserved1); + GET16(dataReferenceIndex); + GETBYTES(16, reserved2); + GET16(width); + GET16(height); + /* GET32( reserved3 ); */ + GET32(reserved4); + GET32(reserved5); + GET32(reserved6); + GET16(reserved7); + GET8(nameLength); + GETBYTES(31, name31); + GET16(reserved8); + GET16(reserved9); + while(self->bytesRead < self->size) + { + MP4AtomPtr atom; + err = MP4ParseAtom((MP4InputStreamPtr)inputStream, &atom); + if(err) goto bail; + self->bytesRead += atom->size; + if(((atom->type) == MP4FreeSpaceAtomType) || ((atom->type) == MP4SkipAtomType)) + atom->destroy(atom); + else + { + err = addAtom(self, atom); + if(err) goto bail; + } + } + + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateEncVisualSampleEntryAtom( MP4EncVisualSampleEntryAtomPtr *outAtom ) +MP4Err MP4CreateEncVisualSampleEntryAtom(MP4EncVisualSampleEntryAtomPtr *outAtom) { - MP4Err err; - MP4EncVisualSampleEntryAtomPtr self; - - self = (MP4EncVisualSampleEntryAtomPtr) calloc( 1, sizeof(MP4EncVisualSampleEntryAtom) ); - TESTMALLOC( self ) - - err = MP4CreateEncBaseAtom( (MP4EncBaseSampleEntryAtomPtr) self ); - if ( err ) goto bail; - self->type = MP4EncVisualSampleEntryAtomType; - self->name = "protected visual sample entry"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->enc_type = MP4EncVisualSampleEntryAtomType; - - self->width = 0x140; - self->height = 0xf0; - self->reserved4 = 0x00480000; self->reserved5 = 0x00480000; - self->reserved7 = 1; - self->reserved8 = 0x18; - self->reserved9 = -1; - - *outAtom = self; + MP4Err err; + MP4EncVisualSampleEntryAtomPtr self; + + self = (MP4EncVisualSampleEntryAtomPtr)calloc(1, sizeof(MP4EncVisualSampleEntryAtom)); + TESTMALLOC(self) + + err = MP4CreateEncBaseAtom((MP4EncBaseSampleEntryAtomPtr)self); + if(err) goto bail; + self->type = MP4EncVisualSampleEntryAtomType; + self->name = "protected visual sample entry"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->enc_type = MP4EncVisualSampleEntryAtomType; + + self->width = 0x140; + self->height = 0xf0; + self->reserved4 = 0x00480000; + self->reserved5 = 0x00480000; + self->reserved7 = 1; + self->reserved8 = 0x18; + self->reserved9 = -1; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ExtendedLanguageTag.c b/IsoLib/libisomediafile/src/ExtendedLanguageTag.c index b9881c5..7ee0423 100644 --- a/IsoLib/libisomediafile/src/ExtendedLanguageTag.c +++ b/IsoLib/libisomediafile/src/ExtendedLanguageTag.c @@ -25,103 +25,102 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4ExtendedLanguageTagAtomPtr self; - err = MP4NoErr; - self = (MP4ExtendedLanguageTagAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->extended_language ) - { - free( self->extended_language ); - self->extended_language = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4ExtendedLanguageTagAtomPtr self; + err = MP4NoErr; + self = (MP4ExtendedLanguageTagAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->extended_language) + { + free(self->extended_language); + self->extended_language = NULL; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4ExtendedLanguageTagAtomPtr self = (MP4ExtendedLanguageTagAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( self->extended_language, strlen(self->extended_language) * sizeof(char) + 1 ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4ExtendedLanguageTagAtomPtr self = (MP4ExtendedLanguageTagAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(self->extended_language, strlen(self->extended_language) * sizeof(char) + 1); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4ExtendedLanguageTagAtomPtr self = (MP4ExtendedLanguageTagAtomPtr) s; - - err = MP4NoErr; - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - - self->size += strlen(self->extended_language) * sizeof(char) + 1; - + MP4Err err; + MP4ExtendedLanguageTagAtomPtr self = (MP4ExtendedLanguageTagAtomPtr)s; + + err = MP4NoErr; + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + self->size += strlen(self->extended_language) * sizeof(char) + 1; + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 dataSize = 0; - MP4ExtendedLanguageTagAtomPtr self = (MP4ExtendedLanguageTagAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - dataSize = self->size - self->bytesRead; - self->extended_language = (char*) malloc( dataSize ); - TESTMALLOC( self->extended_language ); - GETBYTES( dataSize, extended_language ); + MP4Err err; + u32 dataSize = 0; + MP4ExtendedLanguageTagAtomPtr self = (MP4ExtendedLanguageTagAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + dataSize = self->size - self->bytesRead; + self->extended_language = (char *)malloc(dataSize); + TESTMALLOC(self->extended_language); + GETBYTES(dataSize, extended_language); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err MP4CreateExtendedLanguageTagAtom( MP4ExtendedLanguageTagAtomPtr *outAtom ) +MP4Err MP4CreateExtendedLanguageTagAtom(MP4ExtendedLanguageTagAtomPtr *outAtom) { - MP4Err err; - MP4ExtendedLanguageTagAtomPtr self; - - self = (MP4ExtendedLanguageTagAtomPtr) calloc( 1, sizeof(MP4ExtendedLanguageTagAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4ExtendedLanguageTagAtomType; - self->name = "extended language tag"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->extended_language = NULL; - *outAtom = self; + MP4Err err; + MP4ExtendedLanguageTagAtomPtr self; + + self = (MP4ExtendedLanguageTagAtomPtr)calloc(1, sizeof(MP4ExtendedLanguageTagAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4ExtendedLanguageTagAtomType; + self->name = "extended language tag"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->extended_language = NULL; + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; -} + TEST_RETURN(err); + return err; +} diff --git a/IsoLib/libisomediafile/src/FileMappingDataHandler.c b/IsoLib/libisomediafile/src/FileMappingDataHandler.c index bef87dd..461a285 100644 --- a/IsoLib/libisomediafile/src/FileMappingDataHandler.c +++ b/IsoLib/libisomediafile/src/FileMappingDataHandler.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: FileMappingDataHandler.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: FileMappingDataHandler.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Movies.h" #include "MP4Impl.h" @@ -30,192 +30,202 @@ derivative works. Copyright (c) 1999. #include #include -static MP4Err createCanonicalPathName( struct MP4InputStreamRecord* inputStream, MP4DataEntryAtomPtr dataEntry, MP4Handle outPathNameH ); +static MP4Err createCanonicalPathName(struct MP4InputStreamRecord *inputStream, + MP4DataEntryAtomPtr dataEntry, MP4Handle outPathNameH); -static MP4Err createCanonicalPathName( struct MP4InputStreamRecord* inputStream, MP4DataEntryAtomPtr dataEntry, MP4Handle outPathNameH ) +static MP4Err createCanonicalPathName(struct MP4InputStreamRecord *inputStream, + MP4DataEntryAtomPtr dataEntry, MP4Handle outPathNameH) { - MP4Err err; - char *fname; - if ( (dataEntry == NULL) || (dataEntry->flags == 1) || (outPathNameH == NULL) ) + MP4Err err; + char *fname; + if((dataEntry == NULL) || (dataEntry->flags == 1) || (outPathNameH == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + err = MP4NoErr; + fname = dataEntry->location; + if((strncmp(fname, "file://", 7) == 0) || (strncmp(fname, "file|//", 7) == 0)) + { + /* absolute URL */ + err = MP4SetHandleSize(outPathNameH, strlen(fname + 6)); + if(err) goto bail; + strcpy(*outPathNameH, fname + 7); + } + else + { + /* a relative file name */ + char *parent = NULL; + if(inputStream) { - BAILWITHERROR( MP4BadParamErr ); + parent = inputStream->getFileMappingObject(inputStream)->parent; } - err = MP4NoErr; - fname = dataEntry->location; - if ( (strncmp(fname, "file://", 7) == 0) || (strncmp(fname, "file|//", 7) == 0 ) ) - { - /* absolute URL */ - err = MP4SetHandleSize( outPathNameH, strlen(fname+6) ); if (err) goto bail; - strcpy(*outPathNameH, fname + 7 ); - } - else - { - /* a relative file name */ - char *parent = NULL; - if ( inputStream ) - { - parent = inputStream->getFileMappingObject(inputStream)->parent; - } - if ( parent ) - { - /* prepend parent path */ - err = MP4SetHandleSize( outPathNameH, (strlen(parent) + strlen(fname) + 1) ); if (err) goto bail; - strcpy( *outPathNameH, parent ); /* parent includes platform-specific path separator */ - strcat( *outPathNameH, fname ); - } - else - { - /* bare: open relative to cwd */ - err = MP4SetHandleSize( outPathNameH, (strlen(fname) + 1) ); if (err) goto bail; - strcat( *outPathNameH, fname ); - } - } - + if(parent) + { + /* prepend parent path */ + err = MP4SetHandleSize(outPathNameH, (strlen(parent) + strlen(fname) + 1)); + if(err) goto bail; + strcpy(*outPathNameH, parent); /* parent includes platform-specific path separator */ + strcat(*outPathNameH, fname); + } + else + { + /* bare: open relative to cwd */ + err = MP4SetHandleSize(outPathNameH, (strlen(fname) + 1)); + if(err) goto bail; + strcat(*outPathNameH, fname); + } + } + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err doOpen( struct MP4DataHandler *s, - struct MP4InputStreamRecord* inputStream, - MP4DataEntryAtomPtr dataEntry ) +static MP4Err doOpen(struct MP4DataHandler *s, struct MP4InputStreamRecord *inputStream, + MP4DataEntryAtomPtr dataEntry) { - MP4Err err; - MP4FileMappingDataHandlerPtr self = (MP4FileMappingDataHandlerPtr) s; - MP4Handle pathH = NULL; - - err = MP4NoErr; - if ( dataEntry->flags == 1 ) - { - /* self-contained: get from movie */ - if ( inputStream == NULL ) - BAILWITHERROR( MP4BadParamErr ) - self->mappingObject = inputStream->getFileMappingObject( inputStream ); - if ( self->mappingObject == NULL ) - BAILWITHERROR( MP4IOErr ) - - } - else - { - err = MP4NewHandle( 1024, &pathH ); if (err) goto bail; - err = createCanonicalPathName( inputStream, dataEntry, pathH ); if (err) goto bail; - err = MP4CreateFileMappingObject( *pathH, &self->mappingObject ); if (err) goto bail; - err = MP4DisposeHandle( pathH ); if (err) goto bail; - pathH = NULL; - } + MP4Err err; + MP4FileMappingDataHandlerPtr self = (MP4FileMappingDataHandlerPtr)s; + MP4Handle pathH = NULL; + + err = MP4NoErr; + if(dataEntry->flags == 1) + { + /* self-contained: get from movie */ + if(inputStream == NULL) BAILWITHERROR(MP4BadParamErr) + self->mappingObject = inputStream->getFileMappingObject(inputStream); + if(self->mappingObject == NULL) BAILWITHERROR(MP4IOErr) + } + else + { + err = MP4NewHandle(1024, &pathH); + if(err) goto bail; + err = createCanonicalPathName(inputStream, dataEntry, pathH); + if(err) goto bail; + err = MP4CreateFileMappingObject(*pathH, &self->mappingObject); + if(err) goto bail; + err = MP4DisposeHandle(pathH); + if(err) goto bail; + pathH = NULL; + } bail: - if ( pathH ) - { - MP4DisposeHandle( pathH ); - } - TEST_RETURN( err ); + if(pathH) + { + MP4DisposeHandle(pathH); + } + TEST_RETURN(err); - return err; + return err; } -static MP4Err doClose( struct MP4DataHandler *s ) +static MP4Err doClose(struct MP4DataHandler *s) { - MP4Err err; - MP4FileMappingDataHandlerPtr self = (MP4FileMappingDataHandlerPtr) s; + MP4Err err; + MP4FileMappingDataHandlerPtr self = (MP4FileMappingDataHandlerPtr)s; - err = self->mappingObject->close( self->mappingObject ); - return err; + err = self->mappingObject->close(self->mappingObject); + return err; } -static MP4Err copyData( struct MP4DataHandler *s, u64 offset, char *dst, u32 bytes ) +static MP4Err copyData(struct MP4DataHandler *s, u64 offset, char *dst, u32 bytes) { - MP4Err err; - MP4FileMappingDataHandlerPtr self = (MP4FileMappingDataHandlerPtr) s; - FileMappingObject themap; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - themap = self->mappingObject; - if ( themap ) - { - if ( themap->copyData ) { - err = themap->copyData( themap, offset, dst, bytes ); - } - else { - char *src; - if (offset >> 32) - { BAILWITHERROR( MP4NotImplementedErr ); } - src = themap->data + offset; - memcpy( dst, src, bytes ); - } - } + MP4Err err; + MP4FileMappingDataHandlerPtr self = (MP4FileMappingDataHandlerPtr)s; + FileMappingObject themap; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + themap = self->mappingObject; + if(themap) + { + if(themap->copyData) + { + err = themap->copyData(themap, offset, dst, bytes); + } + else + { + char *src; + if(offset >> 32) + { + BAILWITHERROR(MP4NotImplementedErr); + } + src = themap->data + offset; + memcpy(dst, src, bytes); + } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getDataSize( struct MP4DataHandler *s, u64* bytes ) +static MP4Err getDataSize(struct MP4DataHandler *s, u64 *bytes) { - MP4FileMappingDataHandlerPtr self = (MP4FileMappingDataHandlerPtr) s; - if ( self == NULL ) - return MP4BadParamErr; - *bytes = (self->mappingObject)->size64; - return MP4NoErr; + MP4FileMappingDataHandlerPtr self = (MP4FileMappingDataHandlerPtr)s; + if(self == NULL) return MP4BadParamErr; + *bytes = (self->mappingObject)->size64; + return MP4NoErr; } -MP4Err MP4CreateFileMappingDataHandler( MP4InputStreamPtr inputStream, - MP4DataEntryAtomPtr dataEntry, - MP4DataHandlerPtr *outDataHandler ) +MP4Err MP4CreateFileMappingDataHandler(MP4InputStreamPtr inputStream, MP4DataEntryAtomPtr dataEntry, + MP4DataHandlerPtr *outDataHandler) { - MP4Err err; - MP4FileMappingDataHandlerPtr self; - - err = MP4NoErr; - self = (MP4FileMappingDataHandlerPtr) calloc( 1, sizeof(MP4FileMappingDataHandler) ); - TESTMALLOC( self ); - self->inputStream = inputStream; - self->copyData = copyData; - self->entryAtom = dataEntry; - self->open = doOpen; - self->close = doClose; - self->getDataSize = getDataSize; - - err = doOpen( (MP4DataHandlerPtr) self, inputStream, dataEntry ); - *outDataHandler = (MP4DataHandlerPtr) self; + MP4Err err; + MP4FileMappingDataHandlerPtr self; + + err = MP4NoErr; + self = (MP4FileMappingDataHandlerPtr)calloc(1, sizeof(MP4FileMappingDataHandler)); + TESTMALLOC(self); + self->inputStream = inputStream; + self->copyData = copyData; + self->entryAtom = dataEntry; + self->open = doOpen; + self->close = doClose; + self->getDataSize = getDataSize; + + err = doOpen((MP4DataHandlerPtr)self, inputStream, dataEntry); + *outDataHandler = (MP4DataHandlerPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4DisposeFileMappingDataHandler( MP4DataHandlerPtr dataHandler, MP4DataEntryAtomPtr dataEntry ) +MP4Err MP4DisposeFileMappingDataHandler(MP4DataHandlerPtr dataHandler, + MP4DataEntryAtomPtr dataEntry) { - MP4Err err; - - err = MP4NoErr; - if ( dataEntry->flags == 1 ) - { - /* contained in the same file as the moov atom: - do not close the file */ - return err; - } - err = doClose( dataHandler ); - free(dataHandler); - - TEST_RETURN( err ); - return err; + MP4Err err; + + err = MP4NoErr; + if(dataEntry->flags == 1) + { + /* contained in the same file as the moov atom: + do not close the file */ + return err; + } + err = doClose(dataHandler); + free(dataHandler); + + TEST_RETURN(err); + return err; } -MP4Err MP4PreflightFileMappingDataHandler( MP4InputStreamPtr inputStream, MP4DataEntryAtomPtr dataEntry ) +MP4Err MP4PreflightFileMappingDataHandler(MP4InputStreamPtr inputStream, + MP4DataEntryAtomPtr dataEntry) { - MP4Err err; - MP4Handle pathH = NULL; - err = MP4NewHandle( 1024, &pathH ); if (err) goto bail; - err = createCanonicalPathName( inputStream, dataEntry, pathH ); if (err) goto bail; - err = MP4AssertFileExists( *pathH ); if (err) goto bail; + MP4Err err; + MP4Handle pathH = NULL; + err = MP4NewHandle(1024, &pathH); + if(err) goto bail; + err = createCanonicalPathName(inputStream, dataEntry, pathH); + if(err) goto bail; + err = MP4AssertFileExists(*pathH); + if(err) goto bail; bail: - if ( pathH ) - { - MP4DisposeHandle( pathH ); - } - TEST_RETURN( err ); - return err; + if(pathH) + { + MP4DisposeHandle(pathH); + } + TEST_RETURN(err); + return err; } - diff --git a/IsoLib/libisomediafile/src/FileMappingDataHandler.h b/IsoLib/libisomediafile/src/FileMappingDataHandler.h index b826b2f..89d18f5 100644 --- a/IsoLib/libisomediafile/src/FileMappingDataHandler.h +++ b/IsoLib/libisomediafile/src/FileMappingDataHandler.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: FileMappingDataHandler.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: FileMappingDataHandler.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #ifndef INCLUDED_FILEMAPPING_DATAHANDLER_H #define INCLUDED_FILEMAPPING_DATAHANDLER_H @@ -31,21 +31,21 @@ derivative works. Copyright (c) 1999. typedef struct MP4FileMappingDataHandler { - COMMON_DATAHANDLER_FIELDS - struct MP4InputStreamRecord* inputStream; - MP4DataEntryAtomPtr entryAtom; - FileMappingObject mappingObject; + COMMON_DATAHANDLER_FIELDS + struct MP4InputStreamRecord *inputStream; + MP4DataEntryAtomPtr entryAtom; + FileMappingObject mappingObject; } MP4FileMappingDataHandler, *MP4FileMappingDataHandlerPtr; -MP4Err MP4CreateFileMappingDataHandler( struct MP4InputStreamRecord* inputStream, - MP4DataEntryAtomPtr dataEntry, - MP4DataHandlerPtr *outDataHandler ); +MP4Err MP4CreateFileMappingDataHandler(struct MP4InputStreamRecord *inputStream, + MP4DataEntryAtomPtr dataEntry, + MP4DataHandlerPtr *outDataHandler); -MP4Err MP4DisposeFileMappingDataHandler( MP4DataHandlerPtr dataHandler, - MP4DataEntryAtomPtr dataEntry ); +MP4Err MP4DisposeFileMappingDataHandler(MP4DataHandlerPtr dataHandler, + MP4DataEntryAtomPtr dataEntry); -MP4Err MP4PreflightFileMappingDataHandler( struct MP4InputStreamRecord* inputStream, - MP4DataEntryAtomPtr dataEntry ); +MP4Err MP4PreflightFileMappingDataHandler(struct MP4InputStreamRecord *inputStream, + MP4DataEntryAtomPtr dataEntry); #endif diff --git a/IsoLib/libisomediafile/src/FileMappingObject.h b/IsoLib/libisomediafile/src/FileMappingObject.h index 46a2e95..a612276 100644 --- a/IsoLib/libisomediafile/src/FileMappingObject.h +++ b/IsoLib/libisomediafile/src/FileMappingObject.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: FileMappingObject.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: FileMappingObject.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #ifndef INCLUDED_FILEMAPPING_OBJECT_H #define INCLUDED_FILEMAPPING_OBJECT_H @@ -29,22 +29,23 @@ derivative works. Copyright (c) 1999. #include "MP4Movies.h" #include "MP4Atoms.h" -#define COMMON_FILEMAPPING_OBJECT_FIELDS \ - char *data; \ - u64 size64; \ - char *parent; \ - MP4Err (*open) ( struct FileMappingObjectRecord *self, const char *filename ); \ - MP4Err (*close) ( struct FileMappingObjectRecord *self ); \ - MP4Err (*destroy) ( struct FileMappingObjectRecord *self ); \ - MP4Err (*isYourFile)( struct FileMappingObjectRecord *self, const char *filename, u32 *outSameFile ); \ - MP4Err (*copyData) ( struct FileMappingObjectRecord *self, u64 offset, char *dst, u32 bytes ); +#define COMMON_FILEMAPPING_OBJECT_FIELDS \ + char *data; \ + u64 size64; \ + char *parent; \ + MP4Err (*open)(struct FileMappingObjectRecord * self, const char *filename); \ + MP4Err (*close)(struct FileMappingObjectRecord * self); \ + MP4Err (*destroy)(struct FileMappingObjectRecord * self); \ + MP4Err (*isYourFile)(struct FileMappingObjectRecord * self, const char *filename, \ + u32 *outSameFile); \ + MP4Err (*copyData)(struct FileMappingObjectRecord * self, u64 offset, char *dst, u32 bytes); typedef struct FileMappingObjectRecord { - COMMON_FILEMAPPING_OBJECT_FIELDS + COMMON_FILEMAPPING_OBJECT_FIELDS } FileMappingObjectRecord, *FileMappingObject; -MP4Err MP4CreateFileMappingObject( char *urlString, FileMappingObject *outObject ); -MP4Err MP4CreateMemoryFileMappingObject( char *src, u32 size, FileMappingObject *outObject ); -MP4Err MP4AssertFileExists( char *pathname ); +MP4Err MP4CreateFileMappingObject(char *urlString, FileMappingObject *outObject); +MP4Err MP4CreateMemoryFileMappingObject(char *src, u32 size, FileMappingObject *outObject); +MP4Err MP4AssertFileExists(char *pathname); #endif diff --git a/IsoLib/libisomediafile/src/FreeSpaceAtom.c b/IsoLib/libisomediafile/src/FreeSpaceAtom.c index f87cd40..3b40cab 100644 --- a/IsoLib/libisomediafile/src/FreeSpaceAtom.c +++ b/IsoLib/libisomediafile/src/FreeSpaceAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,113 +15,114 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: FreeSpaceAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: FreeSpaceAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4FreeSpaceAtomPtr self; - self = (MP4FreeSpaceAtomPtr) s; - if ( self->data ) - { - free( self->data ); - self->data = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4FreeSpaceAtomPtr self; + self = (MP4FreeSpaceAtomPtr)s; + if(self->data) + { + free(self->data); + self->data = NULL; + } + if(self->super) self->super->destroy(s); } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4FreeSpaceAtomPtr self = (MP4FreeSpaceAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( self->data, self->dataSize ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4FreeSpaceAtomPtr self = (MP4FreeSpaceAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(self->data, self->dataSize); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4FreeSpaceAtomPtr self = (MP4FreeSpaceAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += self->dataSize; + MP4Err err; + MP4FreeSpaceAtomPtr self = (MP4FreeSpaceAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += self->dataSize; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - MP4FreeSpaceAtomPtr self = (MP4FreeSpaceAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); - - bytesToRead = s->size - s->bytesRead; - if (bytesToRead > 0) { - self->data = (char*) calloc( 1, bytesToRead ); - TESTMALLOC( self->data ); - GETBYTES( bytesToRead, data ); - } - else self->data = 0; - self->dataSize = bytesToRead; + MP4Err err; + long bytesToRead; + MP4FreeSpaceAtomPtr self = (MP4FreeSpaceAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + + bytesToRead = s->size - s->bytesRead; + if(bytesToRead > 0) + { + self->data = (char *)calloc(1, bytesToRead); + TESTMALLOC(self->data); + GETBYTES(bytesToRead, data); + } + else + self->data = 0; + self->dataSize = bytesToRead; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - if ( err && self->data ) - { - free( self->data ); - } - return err; + if(err && self->data) + { + free(self->data); + } + return err; } -MP4Err MP4CreateFreeSpaceAtom( MP4FreeSpaceAtomPtr *outAtom ) +MP4Err MP4CreateFreeSpaceAtom(MP4FreeSpaceAtomPtr *outAtom) { - MP4Err err; - MP4FreeSpaceAtomPtr self; - - self = (MP4FreeSpaceAtomPtr) calloc( 1, sizeof(MP4FreeSpaceAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4FreeSpaceAtomType; - self->name = "free space"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->data = NULL; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4FreeSpaceAtomPtr self; + + self = (MP4FreeSpaceAtomPtr)calloc(1, sizeof(MP4FreeSpaceAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4FreeSpaceAtomType; + self->name = "free space"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->data = NULL; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/GenericSampleEntryAtom.c b/IsoLib/libisomediafile/src/GenericSampleEntryAtom.c index 1850b93..b65592e 100644 --- a/IsoLib/libisomediafile/src/GenericSampleEntryAtom.c +++ b/IsoLib/libisomediafile/src/GenericSampleEntryAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,124 +15,126 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: GenericSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: GenericSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4GenericSampleEntryAtomPtr self; - err = MP4NoErr; - self = (MP4GenericSampleEntryAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->data ) - { - free( self->data ); - self->data = NULL; - } - DESTROY_ATOM_LIST_F( ExtensionAtomList ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4GenericSampleEntryAtomPtr self; + err = MP4NoErr; + self = (MP4GenericSampleEntryAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->data) + { + free(self->data); + self->data = NULL; + } + DESTROY_ATOM_LIST_F(ExtensionAtomList) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4GenericSampleEntryAtomPtr self = (MP4GenericSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( self->reserved, 6 ); - PUT16( dataReferenceIndex ); - PUTBYTES( self->data, self->dataSize ); - SERIALIZE_ATOM_LIST( ExtensionAtomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4GenericSampleEntryAtomPtr self = (MP4GenericSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(self->reserved, 6); + PUT16(dataReferenceIndex); + PUTBYTES(self->data, self->dataSize); + SERIALIZE_ATOM_LIST(ExtensionAtomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4GenericSampleEntryAtomPtr self = (MP4GenericSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 8 + self->dataSize; - ADD_ATOM_LIST_SIZE( ExtensionAtomList ); + MP4Err err; + MP4GenericSampleEntryAtomPtr self = (MP4GenericSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 8 + self->dataSize; + ADD_ATOM_LIST_SIZE(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4GenericSampleEntryAtomPtr self = (MP4GenericSampleEntryAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GETBYTES( 6, reserved ); - GET16( dataReferenceIndex ); - self->dataSize = self->size - self->bytesRead; /* NOTE: this will prevent the extention atoms list from being read */ - self->data = (char*) malloc( self->dataSize ); - TESTMALLOC( self->data ); - GETBYTES( self->dataSize, data ); - GETATOM_LIST(ExtensionAtomList); - - if (self->bytesRead != self->size) - BAILWITHERROR(MP4BadDataErr); + MP4Err err; + MP4GenericSampleEntryAtomPtr self = (MP4GenericSampleEntryAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GETBYTES(6, reserved); + GET16(dataReferenceIndex); + self->dataSize = + self->size - + self->bytesRead; /* NOTE: this will prevent the extention atoms list from being read */ + self->data = (char *)malloc(self->dataSize); + TESTMALLOC(self->data); + GETBYTES(self->dataSize, data); + GETATOM_LIST(ExtensionAtomList); + + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateGenericSampleEntryAtom( MP4GenericSampleEntryAtomPtr *outAtom ) +MP4Err MP4CreateGenericSampleEntryAtom(MP4GenericSampleEntryAtomPtr *outAtom) { - MP4Err err; - MP4GenericSampleEntryAtomPtr self; - - self = (MP4GenericSampleEntryAtomPtr) calloc( 1, sizeof(MP4GenericSampleEntryAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4GenericSampleEntryAtomType; - self->name = "generic sample entry"; - err = MP4MakeLinkedList( &self->ExtensionAtomList ); if (err) goto bail; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4GenericSampleEntryAtomPtr self; + + self = (MP4GenericSampleEntryAtomPtr)calloc(1, sizeof(MP4GenericSampleEntryAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4GenericSampleEntryAtomType; + self->name = "generic sample entry"; + err = MP4MakeLinkedList(&self->ExtensionAtomList); + if(err) goto bail; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/H263SpecificInfoAtom.c b/IsoLib/libisomediafile/src/H263SpecificInfoAtom.c index c324dfb..a820620 100644 --- a/IsoLib/libisomediafile/src/H263SpecificInfoAtom.c +++ b/IsoLib/libisomediafile/src/H263SpecificInfoAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. and Ericsson Research -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,136 +15,139 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. The copyright owners retain full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) Apple Computer and Telefonaktiebolaget LM Ericsson 2001 */ /* - $Id: H263SpecificInfoAtom.c,v 1.2 2004/09/15 17:03:35 erapefh Exp $ + $Id: H263SpecificInfoAtom.c,v 1.2 2004/09/15 17:03:35 erapefh Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4H263SpecificInfoAtomPtr self; - u32 i; - - err = MP4NoErr; - self = (MP4H263SpecificInfoAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - DESTROY_ATOM_LIST - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4H263SpecificInfoAtomPtr self; + u32 i; + + err = MP4NoErr; + self = (MP4H263SpecificInfoAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + DESTROY_ATOM_LIST + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err addAtom( MP4H263SpecificInfoAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4H263SpecificInfoAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; + MP4Err err; + err = MP4NoErr; + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4H263SpecificInfoAtomPtr self = (MP4H263SpecificInfoAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32(vendor ); - PUT8( decoder_version ); - PUT8( H263_level ); - PUT8( H263_profile ); - SERIALIZE_ATOM_LIST (atomList); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4H263SpecificInfoAtomPtr self = (MP4H263SpecificInfoAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(vendor); + PUT8(decoder_version); + PUT8(H263_level); + PUT8(H263_profile); + SERIALIZE_ATOM_LIST(atomList); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4H263SpecificInfoAtomPtr self = (MP4H263SpecificInfoAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 4+(3*1); - ADD_ATOM_LIST_SIZE( atomList ); + MP4Err err; + MP4H263SpecificInfoAtomPtr self = (MP4H263SpecificInfoAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 4 + (3 * 1); + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4H263SpecificInfoAtomPtr self = (MP4H263SpecificInfoAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32(vendor ); - GET8( decoder_version ); - GET8( H263_level ); - GET8( H263_profile ); - while (self->bytesRead < self->size ) - { - MP4AtomPtr atom; - err = MP4ParseAtom( inputStream, &atom ); if (err) goto bail; - self->bytesRead += atom->size; - err = addAtom( self, atom ); if (err) goto bail; - } - - if ( self->bytesRead != self->size ) - BAILWITHERROR( MP4BadDataErr ) + MP4Err err; + MP4H263SpecificInfoAtomPtr self = (MP4H263SpecificInfoAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(vendor); + GET8(decoder_version); + GET8(H263_level); + GET8(H263_profile); + while(self->bytesRead < self->size) + { + MP4AtomPtr atom; + err = MP4ParseAtom(inputStream, &atom); + if(err) goto bail; + self->bytesRead += atom->size; + err = addAtom(self, atom); + if(err) goto bail; + } + + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateH263SpecificInfoAtom( MP4H263SpecificInfoAtomPtr *outAtom ) +MP4Err MP4CreateH263SpecificInfoAtom(MP4H263SpecificInfoAtomPtr *outAtom) { - MP4Err err; - MP4H263SpecificInfoAtomPtr self; - - self = (MP4H263SpecificInfoAtomPtr) calloc( 1, sizeof(MP4H263SpecificInfoAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->type = MP4H263SpecificInfoAtomType; - self->name = "H263 specific info"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addAtom = addAtom; - *outAtom = self; + MP4Err err; + MP4H263SpecificInfoAtomPtr self; + + self = (MP4H263SpecificInfoAtomPtr)calloc(1, sizeof(MP4H263SpecificInfoAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->type = MP4H263SpecificInfoAtomType; + self->name = "H263 specific info"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addAtom = addAtom; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/HEVCConfigAtom.c b/IsoLib/libisomediafile/src/HEVCConfigAtom.c index bc52836..b0d5024 100644 --- a/IsoLib/libisomediafile/src/HEVCConfigAtom.c +++ b/IsoLib/libisomediafile/src/HEVCConfigAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -28,306 +28,341 @@ derivative works. Copyright (c) 1999. #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 i; - ISOHEVCConfigAtomPtr self; - err = MP4NoErr; - self = (ISOHEVCConfigAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->numOfArrays ) - { - for (i = 0; i < self->numOfArrays; i++) { - err = MP4DeleteLinkedList(self->arrays[i].nalList); if (err) goto bail; - self->arrays[i].nalList = NULL; - } - } - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + u32 i; + ISOHEVCConfigAtomPtr self; + err = MP4NoErr; + self = (ISOHEVCConfigAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->numOfArrays) + { + for(i = 0; i < self->numOfArrays; i++) + { + err = MP4DeleteLinkedList(self->arrays[i].nalList); + if(err) goto bail; + self->arrays[i].nalList = NULL; + } + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 x, i, array_index; - ISOHEVCConfigAtomPtr self = (ISOHEVCConfigAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( (MP4AtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - /* config_version */ - x = 1; - PUT8_V(x); - - /* general_profile_space(2) + general_tier_flag(1) + general_profile_idc(5) */ - x = self->general_profile_idc; - PUT8_V(x); - PUT32(general_profile_compatibility_flags); - /* general_constraint_indicator_flags (48) */ - x = 0; - PUT32_V(x); PUT16_V(x); - - PUT8(general_level_idc); - - /* reserved '1111'b + min_spatial_segmentation_idc (12) */ - x = (0xf << 12); - PUT16_V(x); - - /* reserved '111111'b + parallelismType (2) */ - x = (0x3f << 2); - PUT8_V(x); - - /* reserved '111111'b + chromaFormat (2) */ - x = (0x3f << 2) | self->chromaFormat; - PUT8_V(x); - - /* reserved '11111'b + bitDepthLumaMinus8 (3) */ - x = (0x1f << 3) | self->bitDepthLumaMinus8; - PUT8_V(x); - - /* reserved '11111'b + bitDepthChromaMinus8 (3) */ - x = (0x1f << 3) | self->bitDepthChromaMinus8; - PUT8_V(x); - - /* avgFrameRate */ - PUT16(avgFrameRate); - - /* constantFrameRate (2) + numTemporalLayers (3) + temporalIdNested (1) + lengthSizeMinusOne (2) */ - x = /*(1<<6) |*/ (1<<3) | (self->sps_temporal_id_nesting_flag << 2) | self->lengthSizeMinusOne+3; - PUT8_V(x); - - PUT8(numOfArrays); - - for (array_index = 0; array_index < self->numOfArrays; array_index++) { - u32 count; - err = MP4GetListEntryCount(self->arrays[array_index].nalList, &count); if (err) goto bail; - x = (self->arrays[array_index].array_completeness << 7) | self->arrays[array_index].NALtype; - PUT8_V( x ); - - PUT16_V(count); - - for (i=0; iarrays[array_index].nalList, i, (char **)&b); if (err) goto bail; - err = MP4GetHandleSize( b, &the_size ); if (err) goto bail; - PUT16_V( the_size ); - PUTBYTES( *b, the_size ); - } - } - - - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 x, i, array_index; + ISOHEVCConfigAtomPtr self = (ISOHEVCConfigAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields((MP4AtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + /* config_version */ + x = 1; + PUT8_V(x); + + /* general_profile_space(2) + general_tier_flag(1) + general_profile_idc(5) */ + x = self->general_profile_idc; + PUT8_V(x); + PUT32(general_profile_compatibility_flags); + /* general_constraint_indicator_flags (48) */ + x = 0; + PUT32_V(x); + PUT16_V(x); + + PUT8(general_level_idc); + + /* reserved '1111'b + min_spatial_segmentation_idc (12) */ + x = (0xf << 12); + PUT16_V(x); + + /* reserved '111111'b + parallelismType (2) */ + x = (0x3f << 2); + PUT8_V(x); + + /* reserved '111111'b + chromaFormat (2) */ + x = (0x3f << 2) | self->chromaFormat; + PUT8_V(x); + + /* reserved '11111'b + bitDepthLumaMinus8 (3) */ + x = (0x1f << 3) | self->bitDepthLumaMinus8; + PUT8_V(x); + + /* reserved '11111'b + bitDepthChromaMinus8 (3) */ + x = (0x1f << 3) | self->bitDepthChromaMinus8; + PUT8_V(x); + + /* avgFrameRate */ + PUT16(avgFrameRate); + + /* constantFrameRate (2) + numTemporalLayers (3) + temporalIdNested (1) + lengthSizeMinusOne (2) + */ + x = /*(1<<6) |*/ (1 << 3) | (self->sps_temporal_id_nesting_flag << 2) | + self->lengthSizeMinusOne + 3; + PUT8_V(x); + + PUT8(numOfArrays); + + for(array_index = 0; array_index < self->numOfArrays; array_index++) + { + u32 count; + err = MP4GetListEntryCount(self->arrays[array_index].nalList, &count); + if(err) goto bail; + x = (self->arrays[array_index].array_completeness << 7) | self->arrays[array_index].NALtype; + PUT8_V(x); + + PUT16_V(count); + + for(i = 0; i < count; i++) + { + MP4Handle b; + u32 the_size; + err = MP4GetListEntry(self->arrays[array_index].nalList, i, (char **)&b); + if(err) goto bail; + err = MP4GetHandleSize(b, &the_size); + if(err) goto bail; + PUT16_V(the_size); + PUTBYTES(*b, the_size); + } + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISOHEVCConfigAtomPtr self = (ISOHEVCConfigAtomPtr) s; - u32 i, ii; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( (MP4AtomPtr) s ); if (err) goto bail; - self->size += 23; - - if (self->numOfArrays) { - self->size += 3 * self->numOfArrays; - for (i = 0; i < self->numOfArrays; i++) { - u32 count; - err = MP4GetListEntryCount(self->arrays[i].nalList, &count); if (err) goto bail; - if (count >> 5) BAILWITHERROR(MP4BadParamErr); - - for (ii = 0; ii < count; ii++) { - MP4Handle b; - u32 the_size; - err = MP4GetListEntry(self->arrays[i].nalList, ii, (char **)&b); if (err) goto bail; - err = MP4GetHandleSize(b, &the_size); if (err) goto bail; - self->size += 2 + the_size; - } - } - } - + MP4Err err; + ISOHEVCConfigAtomPtr self = (ISOHEVCConfigAtomPtr)s; + u32 i, ii; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)s); + if(err) goto bail; + self->size += 23; + + if(self->numOfArrays) + { + self->size += 3 * self->numOfArrays; + for(i = 0; i < self->numOfArrays; i++) + { + u32 count; + err = MP4GetListEntryCount(self->arrays[i].nalList, &count); + if(err) goto bail; + if(count >> 5) BAILWITHERROR(MP4BadParamErr); + + for(ii = 0; ii < count; ii++) + { + MP4Handle b; + u32 the_size; + err = MP4GetListEntry(self->arrays[i].nalList, ii, (char **)&b); + if(err) goto bail; + err = MP4GetHandleSize(b, &the_size); + if(err) goto bail; + self->size += 2 + the_size; + } + } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - ISOHEVCConfigAtomPtr self = (ISOHEVCConfigAtomPtr) s; - u32 x, count, i, array_index; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET8_V( x ); /* config_version */ - if (x!=1) BAILWITHERROR( MP4BadDataErr ); - - /* general_profile_space(2) + general_tier_flag(1) + general_profile_idc(5) */ - GET8_V(x); - self->general_profile_idc = x & 0x1f; - - GET32(general_profile_compatibility_flags); - /* general_constraint_indicator_flags (48) */ - GET32_V(x); GET16_V(x); - - GET8(general_level_idc); - - /* reserved '1111'b + min_spatial_segmentation_idc (12) */ - GET16_V(x); - - /* reserved '111111'b + parallelismType (2) */ - GET8_V(x); - - /* reserved '111111'b + chromaFormat (2) */ - GET8_V(x); - self->chromaFormat = x & 0x3; - - /* reserved '11111'b + bitDepthLumaMinus8 (3) */ - GET8_V(x); - self->bitDepthLumaMinus8 = x & 0x7; - - /* reserved '11111'b + bitDepthChromaMinus8 (3) */ - GET8_V(x); - self->bitDepthChromaMinus8 = x & 0x7; - - /* avgFrameRate */ - GET16(avgFrameRate); - - /* constantFrameRate (2) + numTemporalLayers (3) + temporalIdNested (1) + lengthSizeMinusOne (2) */ - GET8_V(x); - self->lengthSizeMinusOne = x & 0x3; - self->sps_temporal_id_nesting_flag = (x >> 2) & 1; - - GET8(numOfArrays); - for (array_index = 0; array_index < self->numOfArrays; array_index++) { - GET8_V(x); - self->arrays[array_index].array_completeness = (x & 0x80) ? 1 : 0; - self->arrays[array_index].NALtype = x & 0x3f; - err = MP4MakeLinkedList(&self->arrays[array_index].nalList); if (err) goto bail; - - GET16_V(count); - for (i = 0; i < count; i++) { - MP4Handle b; - u32 the_size; - - GET16_V(the_size); - err = MP4NewHandle(the_size, &b); if (err) goto bail; - - GETBYTES_V_MSG(the_size, *b, "NAL"); - err = MP4AddListEntry((void*)b, self->arrays[array_index].nalList); if (err) goto bail; - } - } - + MP4Err err; + ISOHEVCConfigAtomPtr self = (ISOHEVCConfigAtomPtr)s; + u32 x, count, i, array_index; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET8_V(x); /* config_version */ + if(x != 1) BAILWITHERROR(MP4BadDataErr); + + /* general_profile_space(2) + general_tier_flag(1) + general_profile_idc(5) */ + GET8_V(x); + self->general_profile_idc = x & 0x1f; + + GET32(general_profile_compatibility_flags); + /* general_constraint_indicator_flags (48) */ + GET32_V(x); + GET16_V(x); + + GET8(general_level_idc); + + /* reserved '1111'b + min_spatial_segmentation_idc (12) */ + GET16_V(x); + + /* reserved '111111'b + parallelismType (2) */ + GET8_V(x); + + /* reserved '111111'b + chromaFormat (2) */ + GET8_V(x); + self->chromaFormat = x & 0x3; + + /* reserved '11111'b + bitDepthLumaMinus8 (3) */ + GET8_V(x); + self->bitDepthLumaMinus8 = x & 0x7; + + /* reserved '11111'b + bitDepthChromaMinus8 (3) */ + GET8_V(x); + self->bitDepthChromaMinus8 = x & 0x7; + + /* avgFrameRate */ + GET16(avgFrameRate); + + /* constantFrameRate (2) + numTemporalLayers (3) + temporalIdNested (1) + lengthSizeMinusOne (2) + */ + GET8_V(x); + self->lengthSizeMinusOne = x & 0x3; + self->sps_temporal_id_nesting_flag = (x >> 2) & 1; + + GET8(numOfArrays); + for(array_index = 0; array_index < self->numOfArrays; array_index++) + { + GET8_V(x); + self->arrays[array_index].array_completeness = (x & 0x80) ? 1 : 0; + self->arrays[array_index].NALtype = x & 0x3f; + err = MP4MakeLinkedList(&self->arrays[array_index].nalList); + if(err) goto bail; + + GET16_V(count); + for(i = 0; i < count; i++) + { + MP4Handle b; + u32 the_size; + + GET16_V(the_size); + err = MP4NewHandle(the_size, &b); + if(err) goto bail; + + GETBYTES_V_MSG(the_size, *b, "NAL"); + err = MP4AddListEntry((void *)b, self->arrays[array_index].nalList); + if(err) goto bail; + } + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addParameterSet( struct ISOHEVCConfigAtom *self, MP4Handle ps, u32 nalu ) +static MP4Err addParameterSet(struct ISOHEVCConfigAtom *self, MP4Handle ps, u32 nalu) { - MP4Err err; - MP4Handle b; - u32 the_size; - u32 i; - - err = MP4NoErr; - err = MP4GetHandleSize( ps, &the_size ); if (err) goto bail; - err = MP4NewHandle( the_size, &b ); if (err) goto bail; - memcpy( *b, *ps, the_size ); - - for (i = 0; i < 8; i++) { - if (self->arrays[i].NALtype == nalu) { - u32 nalCount = 0; - err = MP4GetListEntryCount(self->arrays[i].nalList, &nalCount); if (err) goto bail; - if (!nalCount) { - self->numOfArrays++; - } - err = MP4AddListEntry((void*)b, self->arrays[i].nalList); if (err) goto bail; - break; - } - } + MP4Err err; + MP4Handle b; + u32 the_size; + u32 i; + + err = MP4NoErr; + err = MP4GetHandleSize(ps, &the_size); + if(err) goto bail; + err = MP4NewHandle(the_size, &b); + if(err) goto bail; + memcpy(*b, *ps, the_size); + + for(i = 0; i < 8; i++) + { + if(self->arrays[i].NALtype == nalu) + { + u32 nalCount = 0; + err = MP4GetListEntryCount(self->arrays[i].nalList, &nalCount); + if(err) goto bail; + if(!nalCount) + { + self->numOfArrays++; + } + err = MP4AddListEntry((void *)b, self->arrays[i].nalList); + if(err) goto bail; + break; + } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getParameterSet( struct ISOHEVCConfigAtom *self, MP4Handle ps, u32 nalu, u32 index ) +static MP4Err getParameterSet(struct ISOHEVCConfigAtom *self, MP4Handle ps, u32 nalu, u32 index) { - MP4Err err; - MP4Handle b = NULL; - u32 the_size; - u32 i; - - err = MP4NoErr; - - for (i = 0; i < self->numOfArrays; i++) { - if (self->arrays[i].NALtype == nalu) { - err = MP4GetListEntry(self->arrays[i].nalList, index - 1, (char**)&b); if (err) goto bail; - break; - } - } - - err = MP4GetHandleSize( b, &the_size ); if (err) goto bail; - err = MP4SetHandleSize( ps, the_size ); if (err) goto bail; - memcpy( *ps, *b, the_size ); - + MP4Err err; + MP4Handle b = NULL; + u32 the_size; + u32 i; + + err = MP4NoErr; + + for(i = 0; i < self->numOfArrays; i++) + { + if(self->arrays[i].NALtype == nalu) + { + err = MP4GetListEntry(self->arrays[i].nalList, index - 1, (char **)&b); + if(err) goto bail; + break; + } + } + + err = MP4GetHandleSize(b, &the_size); + if(err) goto bail; + err = MP4SetHandleSize(ps, the_size); + if(err) goto bail; + memcpy(*ps, *b, the_size); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateHEVCConfigAtom( ISOHEVCConfigAtomPtr *outAtom ) +MP4Err MP4CreateHEVCConfigAtom(ISOHEVCConfigAtomPtr *outAtom) { - MP4Err err; - ISOHEVCConfigAtomPtr self; - u32 i; - - self = (ISOHEVCConfigAtomPtr) calloc( 1, sizeof(ISOHEVCConfigAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOHEVCConfigAtomType; - self->name = "HEVCConfig"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->complete_rep = 1; - self->addParameterSet = addParameterSet; - self->getParameterSet = getParameterSet; - - for (i = 0; i < 8; i++) { - err = MP4MakeLinkedList(&self->arrays[i].nalList); if (err) goto bail; - self->arrays[i].NALtype = 32 + i; - self->arrays[i].array_completeness = 1; - } - - *outAtom = self; + MP4Err err; + ISOHEVCConfigAtomPtr self; + u32 i; + + self = (ISOHEVCConfigAtomPtr)calloc(1, sizeof(ISOHEVCConfigAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOHEVCConfigAtomType; + self->name = "HEVCConfig"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->complete_rep = 1; + self->addParameterSet = addParameterSet; + self->getParameterSet = getParameterSet; + + for(i = 0; i < 8; i++) + { + err = MP4MakeLinkedList(&self->arrays[i].nalList); + if(err) goto bail; + self->arrays[i].NALtype = 32 + i; + self->arrays[i].array_completeness = 1; + } + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/HandlerAtom.c b/IsoLib/libisomediafile/src/HandlerAtom.c index 7e35726..01fa990 100644 --- a/IsoLib/libisomediafile/src/HandlerAtom.c +++ b/IsoLib/libisomediafile/src/HandlerAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: HandlerAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: HandlerAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -29,181 +29,185 @@ derivative works. Copyright (c) 1999. #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4HandlerAtomPtr self = (MP4HandlerAtomPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->nameUTF8 ) - { - free( self->nameUTF8 ); - self->nameUTF8 = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4HandlerAtomPtr self = (MP4HandlerAtomPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->nameUTF8) + { + free(self->nameUTF8); + self->nameUTF8 = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4HandlerAtomPtr self = (MP4HandlerAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - if (self->is_qt) { - self->qt_componentType = MP4_FOUR_CHAR_CODE( 'm', 'h', 'l', 'r' ); - self->qt_componentManufacturer = MP4_FOUR_CHAR_CODE( 'a', 'p', 'p', 'l' ); - } - - PUT32( qt_componentType ); - PUT32( handlerType ); - PUT32( qt_componentManufacturer ); - PUT32( qt_componentFlags ); - PUT32( qt_componentFlagsMask ); - if (self->is_qt) { - PUT8( nameLength ); - PUTBYTES( self->nameUTF8, self->nameLength ); - } - else - { - PUTBYTES( self->nameUTF8, self->nameLength ); - PUT8_V( 0 ); - } - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4HandlerAtomPtr self = (MP4HandlerAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + if(self->is_qt) + { + self->qt_componentType = MP4_FOUR_CHAR_CODE('m', 'h', 'l', 'r'); + self->qt_componentManufacturer = MP4_FOUR_CHAR_CODE('a', 'p', 'p', 'l'); + } + + PUT32(qt_componentType); + PUT32(handlerType); + PUT32(qt_componentManufacturer); + PUT32(qt_componentFlags); + PUT32(qt_componentFlagsMask); + if(self->is_qt) + { + PUT8(nameLength); + PUTBYTES(self->nameUTF8, self->nameLength); + } + else + { + PUTBYTES(self->nameUTF8, self->nameLength); + PUT8_V(0); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4HandlerAtomPtr self = (MP4HandlerAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 20 + self->nameLength + 1; + MP4Err err; + MP4HandlerAtomPtr self = (MP4HandlerAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 20 + self->nameLength + 1; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err setName( struct MP4Atom* s, char* name, u32 is_qt ) +static MP4Err setName(struct MP4Atom *s, char *name, u32 is_qt) { - MP4Err err; - MP4HandlerAtomPtr self = (MP4HandlerAtomPtr) s; - char* oldname; - err = MP4NoErr; - - if ( name == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - oldname = self->nameUTF8; - - self->nameLength = strlen( name ); - self->nameUTF8 = (char*) calloc( 1, self->nameLength + 1 ); - TESTMALLOC( self->nameUTF8 ) - memcpy( self->nameUTF8, name, self->nameLength + 1); - - if ( oldname ) free( oldname ); - - self->is_qt = is_qt; - - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4HandlerAtomPtr self = (MP4HandlerAtomPtr)s; + char *oldname; + err = MP4NoErr; + + if(name == NULL) BAILWITHERROR(MP4BadParamErr) + + oldname = self->nameUTF8; + + self->nameLength = strlen(name); + self->nameUTF8 = (char *)calloc(1, self->nameLength + 1); + TESTMALLOC(self->nameUTF8) + memcpy(self->nameUTF8, name, self->nameLength + 1); + + if(oldname) free(oldname); + + self->is_qt = is_qt; + +bail: + TEST_RETURN(err); + + return err; } -static void pascaltocstr( char * s ) +static void pascaltocstr(char *s) { - u8 size; - u8 i; - size = (u8) s[0]; - for (i=0; isuper->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( qt_componentType ); - GET32( handlerType ); - MP4TypeToString( self->handlerType, htype ); - sprintf( debugmsg, "handler type is '%s'", htype ); - DEBUG_MSG( debugmsg ); - GET32( qt_componentManufacturer ); - GET32( qt_componentFlags ); - GET32( qt_componentFlagsMask ); - - bytesLeft = self->size - self->bytesRead; - if ( bytesLeft < 0 ) - BAILWITHERROR( MP4BadDataErr ) - self->nameUTF8 = (char*) calloc( 1, bytesLeft ); - TESTMALLOC( self->nameUTF8 ); - GETBYTES_MSG( bytesLeft, nameUTF8, "handler name" ); - if ((self->nameUTF8)[0] == (bytesLeft-1)) { - /* It's a pascal string */ - pascaltocstr( self->nameUTF8 ); - self->nameLength = bytesLeft - 1; - } - else if ((self->nameUTF8)[ bytesLeft-1 ] == 0) { - self->nameLength = bytesLeft - 1; - } - else self->nameLength = bytesLeft; - - if ( self->nameLength > 0 ) - { - sprintf( debugmsg, "handler name is '%s'", self->nameUTF8 ); - DEBUG_MSG( debugmsg ); - } + MP4Err err; + long bytesLeft; + char debugmsg[256]; + char htype[8]; + MP4HandlerAtomPtr self = (MP4HandlerAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(qt_componentType); + GET32(handlerType); + MP4TypeToString(self->handlerType, htype); + sprintf(debugmsg, "handler type is '%s'", htype); + DEBUG_MSG(debugmsg); + GET32(qt_componentManufacturer); + GET32(qt_componentFlags); + GET32(qt_componentFlagsMask); + + bytesLeft = self->size - self->bytesRead; + if(bytesLeft < 0) BAILWITHERROR(MP4BadDataErr) + self->nameUTF8 = (char *)calloc(1, bytesLeft); + TESTMALLOC(self->nameUTF8); + GETBYTES_MSG(bytesLeft, nameUTF8, "handler name"); + if((self->nameUTF8)[0] == (bytesLeft - 1)) + { + /* It's a pascal string */ + pascaltocstr(self->nameUTF8); + self->nameLength = bytesLeft - 1; + } + else if((self->nameUTF8)[bytesLeft - 1] == 0) + { + self->nameLength = bytesLeft - 1; + } + else + self->nameLength = bytesLeft; + + if(self->nameLength > 0) + { + sprintf(debugmsg, "handler name is '%s'", self->nameUTF8); + DEBUG_MSG(debugmsg); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateHandlerAtom( MP4HandlerAtomPtr *outAtom ) +MP4Err MP4CreateHandlerAtom(MP4HandlerAtomPtr *outAtom) { - MP4Err err; - MP4HandlerAtomPtr self; - - self = (MP4HandlerAtomPtr) calloc( 1, sizeof(MP4HandlerAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4HandlerAtomType; - self->name = "handler reference"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->setName = setName; - - *outAtom = self; + MP4Err err; + MP4HandlerAtomPtr self; + + self = (MP4HandlerAtomPtr)calloc(1, sizeof(MP4HandlerAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4HandlerAtomType; + self->name = "handler reference"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->setName = setName; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/HintMediaHeaderAtom.c b/IsoLib/libisomediafile/src/HintMediaHeaderAtom.c index 177f257..a8aaf88 100644 --- a/IsoLib/libisomediafile/src/HintMediaHeaderAtom.c +++ b/IsoLib/libisomediafile/src/HintMediaHeaderAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,107 +15,106 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: HintMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: HintMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4HintMediaHeaderAtomPtr self = (MP4HintMediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT16( maxPDUSize ); - PUT16( avgPDUSize ); - PUT32( maxBitrate ); - PUT32( avgBitrate ); - PUT32( slidingAverageBitrate ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4HintMediaHeaderAtomPtr self = (MP4HintMediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT16(maxPDUSize); + PUT16(avgPDUSize); + PUT32(maxBitrate); + PUT32(avgBitrate); + PUT32(slidingAverageBitrate); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4HintMediaHeaderAtomPtr self = (MP4HintMediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 16; + MP4Err err; + MP4HintMediaHeaderAtomPtr self = (MP4HintMediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 16; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4HintMediaHeaderAtomPtr self = (MP4HintMediaHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET16( maxPDUSize ); - GET16( avgPDUSize ); - GET32( maxBitrate ); - GET32( avgBitrate ); - GET32( slidingAverageBitrate ); + MP4Err err; + MP4HintMediaHeaderAtomPtr self = (MP4HintMediaHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET16(maxPDUSize); + GET16(avgPDUSize); + GET32(maxBitrate); + GET32(avgBitrate); + GET32(slidingAverageBitrate); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateHintMediaHeaderAtom( MP4HintMediaHeaderAtomPtr *outAtom ) +MP4Err MP4CreateHintMediaHeaderAtom(MP4HintMediaHeaderAtomPtr *outAtom) { - MP4Err err; - MP4HintMediaHeaderAtomPtr self; - - self = (MP4HintMediaHeaderAtomPtr) calloc( 1, sizeof(MP4HintMediaHeaderAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4HintMediaHeaderAtomType; - self->name = "hint media header"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4HintMediaHeaderAtomPtr self; + + self = (MP4HintMediaHeaderAtomPtr)calloc(1, sizeof(MP4HintMediaHeaderAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4HintMediaHeaderAtomType; + self->name = "hint media header"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/IPMPToolUpdateCommand.c b/IsoLib/libisomediafile/src/IPMPToolUpdateCommand.c index 59c7821..431b788 100644 --- a/IsoLib/libisomediafile/src/IPMPToolUpdateCommand.c +++ b/IsoLib/libisomediafile/src/IPMPToolUpdateCommand.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -24,93 +24,99 @@ derivative works. Copyright (c) 1999. #include "MP4Movies.h" #include -static MP4Err addDescriptor( struct MP4DescriptorRecord* s, MP4DescriptorPtr desc ) +static MP4Err addDescriptor(struct MP4DescriptorRecord *s, MP4DescriptorPtr desc) { - MP4Err err; - MP4IPMPToolDescriptorUpdatePtr self = (MP4IPMPToolDescriptorUpdatePtr) s; - err = MP4NoErr; - if ( desc->tag == MP4IPMP_ToolDescriptorTag ) - { - err = MP4AddListEntry( desc, self->ipmpToolDescriptors ); if (err) goto bail; - } - else - BAILWITHERROR( MP4BadDataErr ); + MP4Err err; + MP4IPMPToolDescriptorUpdatePtr self = (MP4IPMPToolDescriptorUpdatePtr)s; + err = MP4NoErr; + if(desc->tag == MP4IPMP_ToolDescriptorTag) + { + err = MP4AddListEntry(desc, self->ipmpToolDescriptors); + if(err) goto bail; + } + else + BAILWITHERROR(MP4BadDataErr); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - u32 count; - u32 i; - MP4DescriptorPtr desc; - MP4IPMPToolDescriptorUpdatePtr self = (MP4IPMPToolDescriptorUpdatePtr) s; - err = MP4NoErr; - self->size = DESCRIPTOR_TAG_LEN_SIZE; - ADD_DESCRIPTOR_LIST_SIZE( ipmpToolDescriptors ); + MP4Err err; + u32 count; + u32 i; + MP4DescriptorPtr desc; + MP4IPMPToolDescriptorUpdatePtr self = (MP4IPMPToolDescriptorUpdatePtr)s; + err = MP4NoErr; + self->size = DESCRIPTOR_TAG_LEN_SIZE; + ADD_DESCRIPTOR_LIST_SIZE(ipmpToolDescriptors); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - MP4IPMPToolDescriptorUpdatePtr self = (MP4IPMPToolDescriptorUpdatePtr) s; - err = MP4NoErr; - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; + MP4Err err; + MP4IPMPToolDescriptorUpdatePtr self = (MP4IPMPToolDescriptorUpdatePtr)s; + err = MP4NoErr; + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; - SERIALIZE_DESCRIPTOR_LIST( ipmpToolDescriptors ); + SERIALIZE_DESCRIPTOR_LIST(ipmpToolDescriptors); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4IPMPToolDescriptorUpdatePtr self = (MP4IPMPToolDescriptorUpdatePtr) s; - err = MP4NoErr; - while ( self->bytesRead < self->size ) - { - MP4DescriptorPtr desc; - err = MP4ParseDescriptor( inputStream, &desc ); if (err) goto bail; - err = addDescriptor( s, desc ); if (err) goto bail; - self->bytesRead += desc->size; - } + MP4Err err; + MP4IPMPToolDescriptorUpdatePtr self = (MP4IPMPToolDescriptorUpdatePtr)s; + err = MP4NoErr; + while(self->bytesRead < self->size) + { + MP4DescriptorPtr desc; + err = MP4ParseDescriptor(inputStream, &desc); + if(err) goto bail; + err = addDescriptor(s, desc); + if(err) goto bail; + self->bytesRead += desc->size; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static void destroy( struct MP4DescriptorRecord* s ) +static void destroy(struct MP4DescriptorRecord *s) { - MP4IPMPToolDescriptorUpdatePtr self = (MP4IPMPToolDescriptorUpdatePtr) s; - DESTROY_DESCRIPTOR_LIST( ipmpToolDescriptors ) - - free( s ); + MP4IPMPToolDescriptorUpdatePtr self = (MP4IPMPToolDescriptorUpdatePtr)s; + DESTROY_DESCRIPTOR_LIST(ipmpToolDescriptors) + + free(s); bail: - return; + return; } -MP4Err MP4CreateIPMPToolDescriptorUpdate( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateIPMPToolDescriptorUpdate(u32 tag, u32 size, u32 bytesRead, + MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4IPMPToolDescriptorUpdate ) - self->addDescriptor = addDescriptor; - err = MP4MakeLinkedList( &self->ipmpToolDescriptors ); if (err) goto bail; - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4IPMPToolDescriptorUpdate) + self->addDescriptor = addDescriptor; + err = MP4MakeLinkedList(&self->ipmpToolDescriptors); + if(err) goto bail; + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ISMAKMSAtom.c b/IsoLib/libisomediafile/src/ISMAKMSAtom.c index 04eda2e..6af41bf 100644 --- a/IsoLib/libisomediafile/src/ISMAKMSAtom.c +++ b/IsoLib/libisomediafile/src/ISMAKMSAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ISMAKMSAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ISMAKMSAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -30,115 +30,116 @@ derivative works. Copyright (c) 1999. #ifdef ISMACrypt -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISMAKMSAtomPtr self = (ISMAKMSAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->kms_url ) - { - free( self->kms_url ); - self->kms_url = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + ISMAKMSAtomPtr self = (ISMAKMSAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->kms_url) + { + free(self->kms_url); + self->kms_url = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 len; - ISMAKMSAtomPtr self = (ISMAKMSAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - if (self->kms_url) { - len = strlen( self->kms_url ) + 1; - PUTBYTES( self->kms_url, len ); - } - else - { - PUT8_V( 0 ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 len; + ISMAKMSAtomPtr self = (ISMAKMSAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + if(self->kms_url) + { + len = strlen(self->kms_url) + 1; + PUTBYTES(self->kms_url, len); + } + else + { + PUT8_V(0); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISMAKMSAtomPtr self = (ISMAKMSAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 1 + (self->kms_url ? strlen( self->kms_url ) : 0); + MP4Err err; + ISMAKMSAtomPtr self = (ISMAKMSAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 1 + (self->kms_url ? strlen(self->kms_url) : 0); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - ISMAKMSAtomPtr self = (ISMAKMSAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - bytesToRead = self->size - self->bytesRead; - if ( bytesToRead < 0 ) - BAILWITHERROR( MP4BadDataErr ) - if ( bytesToRead > 0 ) - { - self->kms_url = (char*) calloc( 1, bytesToRead ); - TESTMALLOC( self->kms_url ); - GETBYTES( bytesToRead, kms_url ); - } - else - self->kms_url = NULL; + MP4Err err; + long bytesToRead; + ISMAKMSAtomPtr self = (ISMAKMSAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + bytesToRead = self->size - self->bytesRead; + if(bytesToRead < 0) BAILWITHERROR(MP4BadDataErr) + if(bytesToRead > 0) + { + self->kms_url = (char *)calloc(1, bytesToRead); + TESTMALLOC(self->kms_url); + GETBYTES(bytesToRead, kms_url); + } + else + self->kms_url = NULL; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err CreateISMAKMSAtom( ISMAKMSAtomPtr *outAtom ) +MP4Err CreateISMAKMSAtom(ISMAKMSAtomPtr *outAtom) { - MP4Err err; - ISMAKMSAtomPtr self; - - self = (ISMAKMSAtomPtr) calloc( 1, sizeof(ISMAKMSAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISMAKMSAtomType; - self->name = "ISMAKMS"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + ISMAKMSAtomPtr self; + + self = (ISMAKMSAtomPtr)calloc(1, sizeof(ISMAKMSAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISMAKMSAtomType; + self->name = "ISMAKMS"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } #endif diff --git a/IsoLib/libisomediafile/src/ISMASaltAtom.c b/IsoLib/libisomediafile/src/ISMASaltAtom.c index 19e9d0b..b3f0eb3 100644 --- a/IsoLib/libisomediafile/src/ISMASaltAtom.c +++ b/IsoLib/libisomediafile/src/ISMASaltAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ISMASaltAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ISMASaltAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -30,93 +30,94 @@ derivative works. Copyright (c) 1999. #ifdef ISMACrypt -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISMASaltAtomPtr self = (ISMASaltAtomPtr) s; - err = MP4NoErr; + MP4Err err; + ISMASaltAtomPtr self = (ISMASaltAtomPtr)s; + err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) + if(self == NULL) BAILWITHERROR(MP4BadParamErr) - if ( self->super ) - self->super->destroy( s ); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - ISMASaltAtomPtr self = (ISMASaltAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( (MP4AtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT64( salt ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + ISMASaltAtomPtr self = (ISMASaltAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields((MP4AtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT64(salt); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISMASaltAtomPtr self = (ISMASaltAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( (MP4AtomPtr) s ); if (err) goto bail; - self->size += 8; + MP4Err err; + ISMASaltAtomPtr self = (ISMASaltAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)s); + if(err) goto bail; + self->size += 8; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - ISMASaltAtomPtr self = (ISMASaltAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - GET64( salt ); - assert( self->bytesRead == self->size ); + MP4Err err; + ISMASaltAtomPtr self = (ISMASaltAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + GET64(salt); + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err CreateISMASaltAtom( ISMASaltAtomPtr *outAtom ) +MP4Err CreateISMASaltAtom(ISMASaltAtomPtr *outAtom) { - MP4Err err; - ISMASaltAtomPtr self; - - self = (ISMASaltAtomPtr) calloc( 1, sizeof(ISMASaltAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISMASaltAtomType; - self->name = "ISMASalt"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + ISMASaltAtomPtr self; + + self = (ISMASaltAtomPtr)calloc(1, sizeof(ISMASaltAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISMASaltAtomType; + self->name = "ISMASalt"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } #endif diff --git a/IsoLib/libisomediafile/src/ISMASampleFormatAtom.c b/IsoLib/libisomediafile/src/ISMASampleFormatAtom.c index 456ed52..a791354 100644 --- a/IsoLib/libisomediafile/src/ISMASampleFormatAtom.c +++ b/IsoLib/libisomediafile/src/ISMASampleFormatAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ISMASampleFormatAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ISMASampleFormatAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -30,97 +30,98 @@ derivative works. Copyright (c) 1999. #ifdef ISMACrypt -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISMASampleFormatAtomPtr self = (ISMASampleFormatAtomPtr) s; - err = MP4NoErr; + MP4Err err; + ISMASampleFormatAtomPtr self = (ISMASampleFormatAtomPtr)s; + err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) + if(self == NULL) BAILWITHERROR(MP4BadParamErr) - if ( self->super ) - self->super->destroy( s ); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - ISMASampleFormatAtomPtr self = (ISMASampleFormatAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT8( selective_encryption ); - PUT8( key_indicator_len ); - PUT8( IV_len ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + ISMASampleFormatAtomPtr self = (ISMASampleFormatAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT8(selective_encryption); + PUT8(key_indicator_len); + PUT8(IV_len); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISMASampleFormatAtomPtr self = (ISMASampleFormatAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 3; + MP4Err err; + ISMASampleFormatAtomPtr self = (ISMASampleFormatAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 3; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - ISMASampleFormatAtomPtr self = (ISMASampleFormatAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - GET8( selective_encryption ); - GET8( key_indicator_len ); - GET8( IV_len ); - assert( self->bytesRead == self->size ); + MP4Err err; + ISMASampleFormatAtomPtr self = (ISMASampleFormatAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + GET8(selective_encryption); + GET8(key_indicator_len); + GET8(IV_len); + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err CreateISMASampleFormatAtom( ISMASampleFormatAtomPtr *outAtom ) +MP4Err CreateISMASampleFormatAtom(ISMASampleFormatAtomPtr *outAtom) { - MP4Err err; - ISMASampleFormatAtomPtr self; - - self = (ISMASampleFormatAtomPtr) calloc( 1, sizeof(ISMASampleFormatAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISMASampleFormatAtomType; - self->name = "ISMASampleFormat"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + ISMASampleFormatAtomPtr self; + + self = (ISMASampleFormatAtomPtr)calloc(1, sizeof(ISMASampleFormatAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISMASampleFormatAtomType; + self->name = "ISMASampleFormat"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } #endif diff --git a/IsoLib/libisomediafile/src/ISMASecurity.c b/IsoLib/libisomediafile/src/ISMASecurity.c index 6455d9d..e7f2da9 100644 --- a/IsoLib/libisomediafile/src/ISMASecurity.c +++ b/IsoLib/libisomediafile/src/ISMASecurity.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: ISMASecurity.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: ISMASecurity.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" @@ -30,185 +30,221 @@ derivative works. Copyright (c) 1999, 2000. #ifdef ISMACrypt -u32 NoProtos[] = { 0 }; +u32 NoProtos[] = {0}; -MP4_EXTERN ( MP4Err ) ISMATransformSampleEntry( u32 newTrackFlags, MP4Handle insampleEntryH, - u8 selective_encryption, u8 key_indicator_length, u8 IV_length, - char* kms_URL, - MP4Handle outsampleEntryH ) +MP4_EXTERN(MP4Err) +ISMATransformSampleEntry(u32 newTrackFlags, MP4Handle insampleEntryH, u8 selective_encryption, + u8 key_indicator_length, u8 IV_length, char *kms_URL, + MP4Handle outsampleEntryH) { - return ISMATransformSampleEntrySalt( newTrackFlags, insampleEntryH, - selective_encryption, key_indicator_length, IV_length, - kms_URL, 0, - outsampleEntryH ); + return ISMATransformSampleEntrySalt(newTrackFlags, insampleEntryH, selective_encryption, + key_indicator_length, IV_length, kms_URL, 0, outsampleEntryH); } -MP4_EXTERN ( MP4Err ) ISMATransformSampleEntrySalt( u32 newTrackFlags, MP4Handle insampleEntryH, - u8 selective_encryption, u8 key_indicator_length, u8 IV_length, - char* kms_URL, u64 salt, - MP4Handle outsampleEntryH ) +MP4_EXTERN(MP4Err) +ISMATransformSampleEntrySalt(u32 newTrackFlags, MP4Handle insampleEntryH, u8 selective_encryption, + u8 key_indicator_length, u8 IV_length, char *kms_URL, u64 salt, + MP4Handle outsampleEntryH) { - MP4Err MP4CreateMemoryInputStream( char *base, u32 size, MP4InputStreamPtr *outStream ); - MP4Err MP4ParseAtomUsingProtoList( MP4InputStreamPtr inputStream, u32* protoList, u32 defaultAtom, MP4AtomPtr *outAtom ); - - u32 atomType; - MP4Err err; - MP4InputStreamPtr is; - u32 size; - MP4EncBaseSampleEntryAtomPtr entry; - ISMAKMSAtomPtr kms; - ISMASampleFormatAtomPtr fmt; - ISMASaltAtomPtr slt; - char* kms_url_copy = NULL; - - err = MP4NoErr; entry = NULL; kms = NULL; fmt = NULL; slt = NULL; - - if (newTrackFlags & ISONewTrackIsVisual) - atomType = MP4EncVisualSampleEntryAtomType; - else if (newTrackFlags & ISONewTrackIsAudio) - atomType = MP4EncAudioSampleEntryAtomType; - else { err = MP4NotImplementedErr; goto bail; } - - err = MP4GetHandleSize( insampleEntryH, &size ); if (err) goto bail; - err = MP4CreateMemoryInputStream(*insampleEntryH, size, &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseAtomUsingProtoList( is, NoProtos, atomType, (MP4AtomPtr*) &entry ); if (err) goto bail; - - err = CreateISMAKMSAtom( &kms ); if (err) goto bail; - - if (kms_URL) { - kms_url_copy = (char*) calloc( 1, strlen(kms_URL)+1 ); - TESTMALLOC( kms_url_copy ); - memcpy( kms_url_copy, kms_URL, strlen(kms_URL)+1 ); - kms->kms_url = kms_url_copy; - } - else kms->kms_url = NULL; - - err = CreateISMASampleFormatAtom( &fmt ); if (err) goto bail; - - fmt->selective_encryption = selective_encryption; - fmt->key_indicator_len = key_indicator_length; - fmt->IV_len = IV_length; - - err = entry->transform( (MP4AtomPtr) entry, ISMACryptAESCounterType, 1, "http://www.isma.tv" ); - if (err) goto bail; - err = entry->addSchemeInfoAtom( (MP4AtomPtr) entry, (MP4AtomPtr) kms ); if (err) goto bail; - kms = NULL; - - err = entry->addSchemeInfoAtom( (MP4AtomPtr) entry, (MP4AtomPtr) fmt ); if (err) goto bail; - fmt = NULL; - - if (salt != 0) { - err = CreateISMASaltAtom( &slt ); if (err) goto bail; - slt->salt = salt; - err = entry->addSchemeInfoAtom( (MP4AtomPtr) entry, (MP4AtomPtr) slt ); if (err) goto bail; - slt = NULL; - } - - err = entry->calculateSize( (MP4AtomPtr) entry ); if (err) goto bail; - err = MP4SetHandleSize( outsampleEntryH, entry->size ); if (err) goto bail; - err = entry->serialize( (MP4AtomPtr) entry, *outsampleEntryH ); if (err) goto bail; - + MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); + MP4Err MP4ParseAtomUsingProtoList(MP4InputStreamPtr inputStream, u32 * protoList, u32 defaultAtom, + MP4AtomPtr * outAtom); + + u32 atomType; + MP4Err err; + MP4InputStreamPtr is; + u32 size; + MP4EncBaseSampleEntryAtomPtr entry; + ISMAKMSAtomPtr kms; + ISMASampleFormatAtomPtr fmt; + ISMASaltAtomPtr slt; + char *kms_url_copy = NULL; + + err = MP4NoErr; + entry = NULL; + kms = NULL; + fmt = NULL; + slt = NULL; + + if(newTrackFlags & ISONewTrackIsVisual) atomType = MP4EncVisualSampleEntryAtomType; + else if(newTrackFlags & ISONewTrackIsAudio) + atomType = MP4EncAudioSampleEntryAtomType; + else + { + err = MP4NotImplementedErr; + goto bail; + } + + err = MP4GetHandleSize(insampleEntryH, &size); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*insampleEntryH, size, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseAtomUsingProtoList(is, NoProtos, atomType, (MP4AtomPtr *)&entry); + if(err) goto bail; + + err = CreateISMAKMSAtom(&kms); + if(err) goto bail; + + if(kms_URL) + { + kms_url_copy = (char *)calloc(1, strlen(kms_URL) + 1); + TESTMALLOC(kms_url_copy); + memcpy(kms_url_copy, kms_URL, strlen(kms_URL) + 1); + kms->kms_url = kms_url_copy; + } + else + kms->kms_url = NULL; + + err = CreateISMASampleFormatAtom(&fmt); + if(err) goto bail; + + fmt->selective_encryption = selective_encryption; + fmt->key_indicator_len = key_indicator_length; + fmt->IV_len = IV_length; + + err = entry->transform((MP4AtomPtr)entry, ISMACryptAESCounterType, 1, "http://www.isma.tv"); + if(err) goto bail; + err = entry->addSchemeInfoAtom((MP4AtomPtr)entry, (MP4AtomPtr)kms); + if(err) goto bail; + kms = NULL; + + err = entry->addSchemeInfoAtom((MP4AtomPtr)entry, (MP4AtomPtr)fmt); + if(err) goto bail; + fmt = NULL; + + if(salt != 0) + { + err = CreateISMASaltAtom(&slt); + if(err) goto bail; + slt->salt = salt; + err = entry->addSchemeInfoAtom((MP4AtomPtr)entry, (MP4AtomPtr)slt); + if(err) goto bail; + slt = NULL; + } + + err = entry->calculateSize((MP4AtomPtr)entry); + if(err) goto bail; + err = MP4SetHandleSize(outsampleEntryH, entry->size); + if(err) goto bail; + err = entry->serialize((MP4AtomPtr)entry, *outsampleEntryH); + if(err) goto bail; + bail: - if (is) { - is->destroy( is ); - is = NULL; - } - - if (entry) entry->destroy( (MP4AtomPtr) entry ); - if (kms) kms->destroy( (MP4AtomPtr) kms ); - if (fmt) fmt->destroy( (MP4AtomPtr) fmt ); - if (slt) slt->destroy( (MP4AtomPtr) slt ); - - TEST_RETURN( err ); - - return err; -} + if(is) + { + is->destroy(is); + is = NULL; + } + + if(entry) entry->destroy((MP4AtomPtr)entry); + if(kms) kms->destroy((MP4AtomPtr)kms); + if(fmt) fmt->destroy((MP4AtomPtr)fmt); + if(slt) slt->destroy((MP4AtomPtr)slt); + TEST_RETURN(err); -MP4_EXTERN ( MP4Err ) ISMAUnTransformSampleEntry( MP4Handle insampleEntryH, - u8* selective_encryption, u8* key_indicator_length, u8* IV_length, - char** kms_URL, - MP4Handle outsampleEntryH ) + return err; +} + +MP4_EXTERN(MP4Err) +ISMAUnTransformSampleEntry(MP4Handle insampleEntryH, u8 *selective_encryption, + u8 *key_indicator_length, u8 *IV_length, char **kms_URL, + MP4Handle outsampleEntryH) { - return ISMAUnTransformSampleEntrySalt( insampleEntryH, - selective_encryption, key_indicator_length, IV_length, - kms_URL, NULL, - outsampleEntryH ); + return ISMAUnTransformSampleEntrySalt(insampleEntryH, selective_encryption, key_indicator_length, + IV_length, kms_URL, NULL, outsampleEntryH); } -MP4_EXTERN ( MP4Err ) ISMAUnTransformSampleEntrySalt( MP4Handle insampleEntryH, - u8* selective_encryption, u8* key_indicator_length, u8* IV_length, - char** kms_URL, u64* salt, - MP4Handle outsampleEntryH ) +MP4_EXTERN(MP4Err) +ISMAUnTransformSampleEntrySalt(MP4Handle insampleEntryH, u8 *selective_encryption, + u8 *key_indicator_length, u8 *IV_length, char **kms_URL, u64 *salt, + MP4Handle outsampleEntryH) { - MP4Err err; - MP4InputStreamPtr is; - u32 size; - MP4EncBaseSampleEntryAtomPtr entry; - ISMAKMSAtomPtr kms; - ISMASaltAtomPtr slt; - ISMASampleFormatAtomPtr fmt; - char* kms_url_copy; - u32 sch_type, sch_version; - - err = MP4NoErr; - - err = MP4GetHandleSize( insampleEntryH, &size ); if (err) goto bail; - err = MP4CreateMemoryInputStream(*insampleEntryH, size, &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseAtom( is, (MP4AtomPtr*) &entry ); if (err) goto bail; - - if ((entry->type != MP4EncAudioSampleEntryAtomType) && - (entry->type != MP4EncVisualSampleEntryAtomType)) - { - err = MP4NotImplementedErr; - goto bail; - } - - err = entry->getScheme( (MP4AtomPtr) entry, &sch_type, &sch_version, NULL ); if (err) goto bail; - if ((sch_type != ISMACryptAESCounterType) || (sch_version != 1)) - { - err = MP4NotImplementedErr; - goto bail; - } - - err = entry->getSchemeInfoAtom( (MP4AtomPtr) entry, ISMAKMSAtomType, (MP4AtomPtr*) &kms); if (err) goto bail; - if (kms_URL) { - kms_url_copy = (char*) calloc( 1, strlen(kms->kms_url)+1 ); - TESTMALLOC( kms_url_copy ); - memcpy( kms_url_copy, kms->kms_url, strlen(kms->kms_url)+1 ); - *kms_URL = kms_url_copy; - } - - err = entry->getSchemeInfoAtom( (MP4AtomPtr) entry, ISMASaltAtomType, (MP4AtomPtr*) &slt); if (err) goto bail; - if (salt) { - err = entry->getSchemeInfoAtom( (MP4AtomPtr) entry, ISMASaltAtomType, (MP4AtomPtr*) &slt); if (err) goto bail; - if (slt) *salt = slt->salt; else *salt = 0; - } - - err = entry->getSchemeInfoAtom( (MP4AtomPtr) entry, ISMASampleFormatAtomType, (MP4AtomPtr*) &fmt); if (err) goto bail; - *selective_encryption = fmt->selective_encryption; - *key_indicator_length = fmt->key_indicator_len; - *IV_length = fmt->IV_len; - - err = entry->untransform( (MP4AtomPtr) entry ); if (err) goto bail; - - err = entry->calculateSize( (MP4AtomPtr) entry ); if (err) goto bail; - err = MP4SetHandleSize( outsampleEntryH, entry->size ); if (err) goto bail; - err = entry->serialize( (MP4AtomPtr) entry, *outsampleEntryH ); if (err) goto bail; + MP4Err err; + MP4InputStreamPtr is; + u32 size; + MP4EncBaseSampleEntryAtomPtr entry; + ISMAKMSAtomPtr kms; + ISMASaltAtomPtr slt; + ISMASampleFormatAtomPtr fmt; + char *kms_url_copy; + u32 sch_type, sch_version; + + err = MP4NoErr; + + err = MP4GetHandleSize(insampleEntryH, &size); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*insampleEntryH, size, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseAtom(is, (MP4AtomPtr *)&entry); + if(err) goto bail; + + if((entry->type != MP4EncAudioSampleEntryAtomType) && + (entry->type != MP4EncVisualSampleEntryAtomType)) + { + err = MP4NotImplementedErr; + goto bail; + } + + err = entry->getScheme((MP4AtomPtr)entry, &sch_type, &sch_version, NULL); + if(err) goto bail; + if((sch_type != ISMACryptAESCounterType) || (sch_version != 1)) + { + err = MP4NotImplementedErr; + goto bail; + } + + err = entry->getSchemeInfoAtom((MP4AtomPtr)entry, ISMAKMSAtomType, (MP4AtomPtr *)&kms); + if(err) goto bail; + if(kms_URL) + { + kms_url_copy = (char *)calloc(1, strlen(kms->kms_url) + 1); + TESTMALLOC(kms_url_copy); + memcpy(kms_url_copy, kms->kms_url, strlen(kms->kms_url) + 1); + *kms_URL = kms_url_copy; + } + + err = entry->getSchemeInfoAtom((MP4AtomPtr)entry, ISMASaltAtomType, (MP4AtomPtr *)&slt); + if(err) goto bail; + if(salt) + { + err = entry->getSchemeInfoAtom((MP4AtomPtr)entry, ISMASaltAtomType, (MP4AtomPtr *)&slt); + if(err) goto bail; + if(slt) *salt = slt->salt; + else + *salt = 0; + } + + err = entry->getSchemeInfoAtom((MP4AtomPtr)entry, ISMASampleFormatAtomType, (MP4AtomPtr *)&fmt); + if(err) goto bail; + *selective_encryption = fmt->selective_encryption; + *key_indicator_length = fmt->key_indicator_len; + *IV_length = fmt->IV_len; + + err = entry->untransform((MP4AtomPtr)entry); + if(err) goto bail; + + err = entry->calculateSize((MP4AtomPtr)entry); + if(err) goto bail; + err = MP4SetHandleSize(outsampleEntryH, entry->size); + if(err) goto bail; + err = entry->serialize((MP4AtomPtr)entry, *outsampleEntryH); + if(err) goto bail; bail: - if (is) { - is->destroy( is ); - is = NULL; - } + if(is) + { + is->destroy(is); + is = NULL; + } + + if(entry) entry->destroy((MP4AtomPtr)entry); - if (entry) entry->destroy( (MP4AtomPtr) entry ); - - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } #endif diff --git a/IsoLib/libisomediafile/src/ISOMeta.c b/IsoLib/libisomediafile/src/ISOMeta.c index 86d05c0..e94e91c 100644 --- a/IsoLib/libisomediafile/src/ISOMeta.c +++ b/IsoLib/libisomediafile/src/ISOMeta.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: MP4Movies.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4Movies.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" @@ -36,1763 +36,1967 @@ derivative works. Copyright (c) 1999, 2000. #include #endif -static ISOErr newMeta( ISOMetaAtomPtr* outMeta, u32 metaType ) +static ISOErr newMeta(ISOMetaAtomPtr *outMeta, u32 metaType) { - ISOMetaAtomPtr meta; - MP4HandlerAtomPtr hdlr; - char name[8]; - - MP4Err ISOCreateMetaAtom( ISOMetaAtomPtr *outAtom ); - MP4Err MP4CreateHandlerAtom( MP4HandlerAtomPtr *outAtom ); - - MP4Err err; - err = MP4NoErr; - - err = ISOCreateMetaAtom( &meta ); if (err) goto bail; - err = MP4CreateHandlerAtom( &hdlr ); if (err) goto bail; - - hdlr->handlerType = metaType; - MP4TypeToString( metaType, name ); - hdlr->setName( (MP4AtomPtr) hdlr, name, 0 ); - - err = meta->addAtom( meta, (MP4AtomPtr) hdlr ); if (err) goto bail; - - *outMeta = meta; - + ISOMetaAtomPtr meta; + MP4HandlerAtomPtr hdlr; + char name[8]; + + MP4Err ISOCreateMetaAtom(ISOMetaAtomPtr * outAtom); + MP4Err MP4CreateHandlerAtom(MP4HandlerAtomPtr * outAtom); + + MP4Err err; + err = MP4NoErr; + + err = ISOCreateMetaAtom(&meta); + if(err) goto bail; + err = MP4CreateHandlerAtom(&hdlr); + if(err) goto bail; + + hdlr->handlerType = metaType; + MP4TypeToString(metaType, name); + hdlr->setName((MP4AtomPtr)hdlr, name, 0); + + err = meta->addAtom(meta, (MP4AtomPtr)hdlr); + if(err) goto bail; + + *outMeta = meta; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISONewFileMeta( ISOMovie theMovie, u32 metaType, ISOMeta* outMeta) +ISO_EXTERN(ISOErr) ISONewFileMeta(ISOMovie theMovie, u32 metaType, ISOMeta *outMeta) { - ISOMetaAtomPtr myMeta; - ISOAdditionalMetaDataContainerAtomPtr mecoPtr; - GETMOOV( theMovie ); - err = newMeta( &myMeta, metaType); if (err) goto bail; - - if (moov->meta != NULL) - { - if (moov->meta->type == metaType) - BAILWITHERROR(MP4BadParamErr); - - if (moov->meco == NULL) - { - err = ISOCreateAdditionalMetaDataContainerAtom((ISOAdditionalMetaDataContainerAtomPtr*) &moov->meco); if (err) goto bail; - } - - mecoPtr = (ISOAdditionalMetaDataContainerAtomPtr) moov->meco; - err = mecoPtr->addMeta(mecoPtr, (MP4AtomPtr) myMeta); if (err) goto bail; - myMeta->relatedMeco = (MP4AtomPtr) mecoPtr; - } - else + ISOMetaAtomPtr myMeta; + ISOAdditionalMetaDataContainerAtomPtr mecoPtr; + GETMOOV(theMovie); + err = newMeta(&myMeta, metaType); + if(err) goto bail; + + if(moov->meta != NULL) + { + if(moov->meta->type == metaType) BAILWITHERROR(MP4BadParamErr); + + if(moov->meco == NULL) { - moov->meta = (MP4AtomPtr) myMeta; + err = ISOCreateAdditionalMetaDataContainerAtom( + (ISOAdditionalMetaDataContainerAtomPtr *)&moov->meco); + if(err) goto bail; } - - err = myMeta->setMdat( myMeta, moov->mdat ); if (err) goto bail; - *outMeta = (ISOMeta) myMeta; - + + mecoPtr = (ISOAdditionalMetaDataContainerAtomPtr)moov->meco; + err = mecoPtr->addMeta(mecoPtr, (MP4AtomPtr)myMeta); + if(err) goto bail; + myMeta->relatedMeco = (MP4AtomPtr)mecoPtr; + } + else + { + moov->meta = (MP4AtomPtr)myMeta; + } + + err = myMeta->setMdat(myMeta, moov->mdat); + if(err) goto bail; + *outMeta = (ISOMeta)myMeta; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISONewMovieMeta( ISOMovie theMovie, u32 metaType, ISOMeta* outMeta ) +ISO_EXTERN(ISOErr) ISONewMovieMeta(ISOMovie theMovie, u32 metaType, ISOMeta *outMeta) { - ISOMetaAtomPtr myMeta; - ISOAdditionalMetaDataContainerAtomPtr mecoPtr; - GETMOVIEATOM(theMovie); - err = newMeta( &myMeta, metaType); if (err) goto bail; + ISOMetaAtomPtr myMeta; + ISOAdditionalMetaDataContainerAtomPtr mecoPtr; + GETMOVIEATOM(theMovie); + err = newMeta(&myMeta, metaType); + if(err) goto bail; - if (moov->meta != NULL) - { - if (moov->meta->type == metaType) - BAILWITHERROR(MP4BadParamErr); - - if (moov->meco == NULL) - { - MP4AtomPtr tempMeco; - err = ISOCreateAdditionalMetaDataContainerAtom((ISOAdditionalMetaDataContainerAtomPtr*) &tempMeco); if (err) goto bail; - err = movieAtom->addAtom( movieAtom, tempMeco ); if (err) goto bail; - myMeta->relatedMeco = (MP4AtomPtr) mecoPtr; - } - - mecoPtr = (ISOAdditionalMetaDataContainerAtomPtr) moov->meco; - err = mecoPtr->addMeta(mecoPtr, (MP4AtomPtr) myMeta); if (err) goto bail; - } - else + if(moov->meta != NULL) + { + if(moov->meta->type == metaType) BAILWITHERROR(MP4BadParamErr); + + if(moov->meco == NULL) { - err = movieAtom->addAtom( movieAtom, (MP4AtomPtr) myMeta ); if (err) goto bail; + MP4AtomPtr tempMeco; + err = ISOCreateAdditionalMetaDataContainerAtom( + (ISOAdditionalMetaDataContainerAtomPtr *)&tempMeco); + if(err) goto bail; + err = movieAtom->addAtom(movieAtom, tempMeco); + if(err) goto bail; + myMeta->relatedMeco = (MP4AtomPtr)mecoPtr; } - - err = myMeta->setMdat( myMeta, moov->mdat ); if (err) goto bail; - *outMeta = (ISOMeta) myMeta; + mecoPtr = (ISOAdditionalMetaDataContainerAtomPtr)moov->meco; + err = mecoPtr->addMeta(mecoPtr, (MP4AtomPtr)myMeta); + if(err) goto bail; + } + else + { + err = movieAtom->addAtom(movieAtom, (MP4AtomPtr)myMeta); + if(err) goto bail; + } + + err = myMeta->setMdat(myMeta, moov->mdat); + if(err) goto bail; + + *outMeta = (ISOMeta)myMeta; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISONewTrackMeta( ISOTrack theTrack, u32 metaType, ISOMeta* outMeta ) +ISO_EXTERN(ISOErr) ISONewTrackMeta(ISOTrack theTrack, u32 metaType, ISOMeta *outMeta) { - ISOMetaAtomPtr myMeta; - MP4TrackAtomPtr trak; - ISOAdditionalMetaDataContainerAtomPtr mecoPtr; - MP4Err err; + ISOMetaAtomPtr myMeta; + MP4TrackAtomPtr trak; + ISOAdditionalMetaDataContainerAtomPtr mecoPtr; + MP4Err err; - err = newMeta( &myMeta, metaType); if (err) goto bail; - trak = (MP4TrackAtomPtr) theTrack; + err = newMeta(&myMeta, metaType); + if(err) goto bail; + trak = (MP4TrackAtomPtr)theTrack; - if (trak->meta != NULL) - { - if (trak->meta->type == metaType) - BAILWITHERROR(MP4BadParamErr); - - if (trak->meco == NULL) - { - MP4AtomPtr tempMeco; - err = ISOCreateAdditionalMetaDataContainerAtom((ISOAdditionalMetaDataContainerAtomPtr*) &tempMeco); if (err) goto bail; - err = trak->addAtom( trak, tempMeco ); if (err) goto bail; - myMeta->relatedMeco = (MP4AtomPtr) mecoPtr; - } - - mecoPtr = (ISOAdditionalMetaDataContainerAtomPtr) trak->meco; - err = mecoPtr->addMeta(mecoPtr, (MP4AtomPtr) myMeta); if (err) goto bail; - } - else + if(trak->meta != NULL) + { + if(trak->meta->type == metaType) BAILWITHERROR(MP4BadParamErr); + + if(trak->meco == NULL) { - err = trak->addAtom( trak, (MP4AtomPtr) myMeta ); if (err) goto bail; + MP4AtomPtr tempMeco; + err = ISOCreateAdditionalMetaDataContainerAtom( + (ISOAdditionalMetaDataContainerAtomPtr *)&tempMeco); + if(err) goto bail; + err = trak->addAtom(trak, tempMeco); + if(err) goto bail; + myMeta->relatedMeco = (MP4AtomPtr)mecoPtr; } - err = myMeta->setMdat( myMeta, trak->mdat ); if (err) goto bail; + mecoPtr = (ISOAdditionalMetaDataContainerAtomPtr)trak->meco; + err = mecoPtr->addMeta(mecoPtr, (MP4AtomPtr)myMeta); + if(err) goto bail; + } + else + { + err = trak->addAtom(trak, (MP4AtomPtr)myMeta); + if(err) goto bail; + } - *outMeta = (ISOMeta) myMeta; + err = myMeta->setMdat(myMeta, trak->mdat); + if(err) goto bail; + + *outMeta = (ISOMeta)myMeta; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOAddMetaBoxRelation( ISOMeta first_meta, ISOMeta second_meta, u8 relation_type ) +ISO_EXTERN(ISOErr) ISOAddMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 relation_type) { - MP4Err err; - ISOMetaAtomPtr firstMeta; - ISOMetaAtomPtr secondMeta; - ISOAdditionalMetaDataContainerAtomPtr meco; - ISOMetaboxRelationAtomPtr mere; - MP4HandlerAtomPtr hdlr; - - err = MP4NoErr; - firstMeta = (ISOMetaAtomPtr) first_meta; - secondMeta = (ISOMetaAtomPtr) second_meta; - meco = NULL; - - if (firstMeta->relatedMeco != NULL) - meco = (ISOAdditionalMetaDataContainerAtomPtr) firstMeta->relatedMeco; - - if (secondMeta->relatedMeco != NULL) - meco = (ISOAdditionalMetaDataContainerAtomPtr) secondMeta->relatedMeco; - - if (meco == NULL) - BAILWITHERROR(MP4BadParamErr); - - err = ISOCreateMetaboxRelationAtom(&mere); if (err) goto bail; - - hdlr = (MP4HandlerAtomPtr) firstMeta->hdlr; - mere->first_metabox_handler_type = hdlr->handlerType; - hdlr = (MP4HandlerAtomPtr) secondMeta->hdlr; - mere->second_metabox_handler_type = hdlr->handlerType; - mere->metabox_relation = relation_type; - - err = MP4AddListEntry(mere, meco->relationList); if (err) goto bail; - + MP4Err err; + ISOMetaAtomPtr firstMeta; + ISOMetaAtomPtr secondMeta; + ISOAdditionalMetaDataContainerAtomPtr meco; + ISOMetaboxRelationAtomPtr mere; + MP4HandlerAtomPtr hdlr; + + err = MP4NoErr; + firstMeta = (ISOMetaAtomPtr)first_meta; + secondMeta = (ISOMetaAtomPtr)second_meta; + meco = NULL; + + if(firstMeta->relatedMeco != NULL) + meco = (ISOAdditionalMetaDataContainerAtomPtr)firstMeta->relatedMeco; + + if(secondMeta->relatedMeco != NULL) + meco = (ISOAdditionalMetaDataContainerAtomPtr)secondMeta->relatedMeco; + + if(meco == NULL) BAILWITHERROR(MP4BadParamErr); + + err = ISOCreateMetaboxRelationAtom(&mere); + if(err) goto bail; + + hdlr = (MP4HandlerAtomPtr)firstMeta->hdlr; + mere->first_metabox_handler_type = hdlr->handlerType; + hdlr = (MP4HandlerAtomPtr)secondMeta->hdlr; + mere->second_metabox_handler_type = hdlr->handlerType; + mere->metabox_relation = relation_type; + + err = MP4AddListEntry(mere, meco->relationList); + if(err) goto bail; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOGetMetaBoxRelation( ISOMeta first_meta, ISOMeta second_meta, u8 *relation_type ) +ISO_EXTERN(ISOErr) ISOGetMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 *relation_type) { - MP4Err err; - ISOMetaAtomPtr firstMeta; - ISOMetaAtomPtr secondMeta; - ISOAdditionalMetaDataContainerAtomPtr meco; - ISOMetaboxRelationAtomPtr mere; - u32 i; - - err = MP4NoErr; - firstMeta = (ISOMetaAtomPtr) first_meta; - secondMeta = (ISOMetaAtomPtr) second_meta; - meco = NULL; - *relation_type = 0; - - if (firstMeta->relatedMeco != NULL) - meco = (ISOAdditionalMetaDataContainerAtomPtr) firstMeta->relatedMeco; - - if (secondMeta->relatedMeco != NULL) - meco = (ISOAdditionalMetaDataContainerAtomPtr) secondMeta->relatedMeco; - - if (meco == NULL) - BAILWITHERROR(MP4BadParamErr); - - for (i = 0; i < meco->relationList->entryCount; i++) + MP4Err err; + ISOMetaAtomPtr firstMeta; + ISOMetaAtomPtr secondMeta; + ISOAdditionalMetaDataContainerAtomPtr meco; + ISOMetaboxRelationAtomPtr mere; + u32 i; + + err = MP4NoErr; + firstMeta = (ISOMetaAtomPtr)first_meta; + secondMeta = (ISOMetaAtomPtr)second_meta; + meco = NULL; + *relation_type = 0; + + if(firstMeta->relatedMeco != NULL) + meco = (ISOAdditionalMetaDataContainerAtomPtr)firstMeta->relatedMeco; + + if(secondMeta->relatedMeco != NULL) + meco = (ISOAdditionalMetaDataContainerAtomPtr)secondMeta->relatedMeco; + + if(meco == NULL) BAILWITHERROR(MP4BadParamErr); + + for(i = 0; i < meco->relationList->entryCount; i++) + { + err = MP4GetListEntry(meco->relationList, i, (char **)&mere); + if(err) goto bail; + if((mere->first_metabox_handler_type == firstMeta->type) && + (mere->second_metabox_handler_type == secondMeta->type)) { - err = MP4GetListEntry(meco->relationList, i, (char**) &mere); if (err) goto bail; - if ((mere->first_metabox_handler_type == firstMeta->type) && - (mere->second_metabox_handler_type == secondMeta->type)) - { - *relation_type = mere->metabox_relation; - } + *relation_type = mere->metabox_relation; } - + } + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } - -ISO_EXTERN ( ISOErr ) ISOAddMetaDataReference( ISOMeta meta, u16* out_ref, ISOHandle urlHandle, ISOHandle urnHandle ) +ISO_EXTERN(ISOErr) +ISOAddMetaDataReference(ISOMeta meta, u16 *out_ref, ISOHandle urlHandle, ISOHandle urnHandle) { - MP4Err MP4CreateDataInformationAtom( MP4DataInformationAtomPtr *outAtom ); - MP4Err MP4CreateDataReferenceAtom( MP4DataReferenceAtomPtr *outAtom ); - MP4Err MP4CreateDataEntryURLAtom( MP4DataEntryURLAtomPtr *outAtom ); - ISOMetaAtomPtr myMeta; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - - MP4Err err; - - myMeta = (ISOMetaAtomPtr) meta; - - dinf = (MP4DataInformationAtomPtr) myMeta->dinf; - if (dinf) { - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - } - else - { - err = MP4CreateDataInformationAtom( &dinf ); if (err) goto bail; - err = myMeta->addAtom( myMeta, (MP4AtomPtr) dinf ); if (err) goto bail; - - err = MP4CreateDataReferenceAtom( &dref ); if (err) goto bail; - err = dinf->addAtom( dinf, (MP4AtomPtr) dref ); if (err) goto bail; - } - if ( urnHandle == NULL ) - { - u32 sz; - MP4DataEntryURLAtomPtr url; - err = MP4CreateDataEntryURLAtom( &url ); if (err) goto bail; - err = MP4GetHandleSize( urlHandle, &sz ); if (err) goto bail; - url->locationLength = (u32) sz; - url->location = (char*) calloc( 1, sz ); - memcpy( url->location, *urlHandle, sz ); - err = dref->addDataEntry( dref, (MP4AtomPtr) url ); if (err) goto bail; - } - else + MP4Err MP4CreateDataInformationAtom(MP4DataInformationAtomPtr * outAtom); + MP4Err MP4CreateDataReferenceAtom(MP4DataReferenceAtomPtr * outAtom); + MP4Err MP4CreateDataEntryURLAtom(MP4DataEntryURLAtomPtr * outAtom); + ISOMetaAtomPtr myMeta; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + + MP4Err err; + + myMeta = (ISOMetaAtomPtr)meta; + + dinf = (MP4DataInformationAtomPtr)myMeta->dinf; + if(dinf) + { + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) { - u32 sz; - MP4DataEntryURNAtomPtr urn; - err = MP4CreateDataEntryURNAtom( &urn ); if (err) goto bail; - err = MP4GetHandleSize( urlHandle, &sz ); if (err) goto bail; - urn->locationLength = (u32) sz; - urn->location = (char*) calloc( 1, sz ); - memcpy( urn->location, *urlHandle, sz ); - - err = MP4GetHandleSize( urnHandle, &sz ); if (err) goto bail; - urn->nameLength = (u32) sz; - urn->name = (char*) calloc( 1, sz ); - memcpy( urn->name, *urnHandle, sz ); - err = dref->addDataEntry( dref, (MP4AtomPtr) urn ); if (err) goto bail; + BAILWITHERROR(MP4InvalidMediaErr); } - *out_ref = dref->getEntryCount( dref ); + } + else + { + err = MP4CreateDataInformationAtom(&dinf); + if(err) goto bail; + err = myMeta->addAtom(myMeta, (MP4AtomPtr)dinf); + if(err) goto bail; + + err = MP4CreateDataReferenceAtom(&dref); + if(err) goto bail; + err = dinf->addAtom(dinf, (MP4AtomPtr)dref); + if(err) goto bail; + } + if(urnHandle == NULL) + { + u32 sz; + MP4DataEntryURLAtomPtr url; + err = MP4CreateDataEntryURLAtom(&url); + if(err) goto bail; + err = MP4GetHandleSize(urlHandle, &sz); + if(err) goto bail; + url->locationLength = (u32)sz; + url->location = (char *)calloc(1, sz); + memcpy(url->location, *urlHandle, sz); + err = dref->addDataEntry(dref, (MP4AtomPtr)url); + if(err) goto bail; + } + else + { + u32 sz; + MP4DataEntryURNAtomPtr urn; + err = MP4CreateDataEntryURNAtom(&urn); + if(err) goto bail; + err = MP4GetHandleSize(urlHandle, &sz); + if(err) goto bail; + urn->locationLength = (u32)sz; + urn->location = (char *)calloc(1, sz); + memcpy(urn->location, *urlHandle, sz); + + err = MP4GetHandleSize(urnHandle, &sz); + if(err) goto bail; + urn->nameLength = (u32)sz; + urn->name = (char *)calloc(1, sz); + memcpy(urn->name, *urnHandle, sz); + err = dref->addDataEntry(dref, (MP4AtomPtr)urn); + if(err) goto bail; + } + *out_ref = dref->getEntryCount(dref); bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err requestItemID( ISOMetaAtomPtr myMeta, u16 itemID ) +static MP4Err requestItemID(ISOMetaAtomPtr myMeta, u16 itemID) { - MP4Err err; - - err = MP4NoErr; - if (itemID == 0) - BAILWITHERROR( MP4BadParamErr ); - - if ( myMeta == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - if ( itemID >= myMeta->next_item_ID ) - { - myMeta->next_item_ID = itemID + 1; - } - else - { - u32 i; - u32 itemCount = 0; - ISOItemLocationAtomPtr iloc; - iloc = (ISOItemLocationAtomPtr) myMeta->iloc; - - err = MP4BadParamErr; - - if ((iloc == NULL) || (!( iloc->itemList ))) - BAILWITHERROR( MP4NotFoundErr ) - - err = MP4GetListEntryCount( iloc->itemList, &itemCount ); if (err) goto bail; - for ( i = 0; i < itemCount; i++ ) - { - MetaItemLocationPtr a; - err = MP4GetListEntry( iloc->itemList, i, (char **) &a ); if (err) goto bail; - if ( a == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - if (a->item_ID == itemID) - goto bail; - } - err = MP4NoErr; - } + MP4Err err; + + err = MP4NoErr; + if(itemID == 0) BAILWITHERROR(MP4BadParamErr); + + if(myMeta == NULL) BAILWITHERROR(MP4InvalidMediaErr) + if(itemID >= myMeta->next_item_ID) + { + myMeta->next_item_ID = itemID + 1; + } + else + { + u32 i; + u32 itemCount = 0; + ISOItemLocationAtomPtr iloc; + iloc = (ISOItemLocationAtomPtr)myMeta->iloc; + + err = MP4BadParamErr; + + if((iloc == NULL) || (!(iloc->itemList))) BAILWITHERROR(MP4NotFoundErr) + + err = MP4GetListEntryCount(iloc->itemList, &itemCount); + if(err) goto bail; + for(i = 0; i < itemCount; i++) + { + MetaItemLocationPtr a; + err = MP4GetListEntry(iloc->itemList, i, (char **)&a); + if(err) goto bail; + if(a == NULL) BAILWITHERROR(MP4InvalidMediaErr); + if(a->item_ID == itemID) goto bail; + } + err = MP4NoErr; + } bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) ISOAddMetaItem( ISOMeta meta, ISOMetaItem* outItem, u64 base_offset, u16 data_ref_index ) +ISO_EXTERN(ISOErr) +ISOAddMetaItem(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, u16 data_ref_index) { - ISOMetaAtomPtr myMeta; - - myMeta = (ISOMetaAtomPtr) meta; - return ISOAddMetaItemWithID( meta, outItem, base_offset, data_ref_index, myMeta->next_item_ID ); + ISOMetaAtomPtr myMeta; + + myMeta = (ISOMetaAtomPtr)meta; + return ISOAddMetaItemWithID(meta, outItem, base_offset, data_ref_index, myMeta->next_item_ID); } -ISO_EXTERN ( ISOErr ) ISOAddMetaItemWithID( ISOMeta meta, ISOMetaItem* outItem, u64 base_offset, u16 data_ref_index, u16 item_ID ) +ISO_EXTERN(ISOErr) +ISOAddMetaItemWithID(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, u16 data_ref_index, + u16 item_ID) { - MP4Err ISOCreateItemLocationAtom( ISOItemLocationAtomPtr *outAtom ); - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr item; - ISOItemLocationAtomPtr iloc; - - MP4Err err; - - myMeta = (ISOMetaAtomPtr) meta; - - err = requestItemID( myMeta, item_ID ); if (err) goto bail; - - item = (MetaItemLocationPtr)calloc( 1, sizeof(MetaItemLocation) ); - TESTMALLOC( item ); - - item->item_ID = item_ID; - item->base_offset = base_offset; - item->dref_index = data_ref_index; - item->construction_method = 0; - item->meta = (MP4AtomPtr) myMeta; - - err = MP4MakeLinkedList( &(item->extentList) ); if (err) goto bail; - - iloc = (ISOItemLocationAtomPtr) myMeta->iloc; - if (!iloc) { - err = ISOCreateItemLocationAtom( &iloc ); if (err) goto bail; - err = myMeta->addAtom( myMeta, (MP4AtomPtr) iloc ); - } - err = MP4AddListEntry( (void*) item, iloc->itemList ); - - *outItem = (ISOMetaItem) item; - + MP4Err ISOCreateItemLocationAtom(ISOItemLocationAtomPtr * outAtom); + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr item; + ISOItemLocationAtomPtr iloc; + + MP4Err err; + + myMeta = (ISOMetaAtomPtr)meta; + + err = requestItemID(myMeta, item_ID); + if(err) goto bail; + + item = (MetaItemLocationPtr)calloc(1, sizeof(MetaItemLocation)); + TESTMALLOC(item); + + item->item_ID = item_ID; + item->base_offset = base_offset; + item->dref_index = data_ref_index; + item->construction_method = 0; + item->meta = (MP4AtomPtr)myMeta; + + err = MP4MakeLinkedList(&(item->extentList)); + if(err) goto bail; + + iloc = (ISOItemLocationAtomPtr)myMeta->iloc; + if(!iloc) + { + err = ISOCreateItemLocationAtom(&iloc); + if(err) goto bail; + err = myMeta->addAtom(myMeta, (MP4AtomPtr)iloc); + } + err = MP4AddListEntry((void *)item, iloc->itemList); + + *outItem = (ISOMetaItem)item; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOAddItemExtent( ISOMetaItem item, MP4Handle data ) +ISO_EXTERN(ISOErr) ISOAddItemExtent(ISOMetaItem item, MP4Handle data) { - MetaExtentLocationPtr extent; - ISOMetaAtomPtr myMeta; - MP4DataInformationAtomPtr dinf; - MetaItemLocationPtr myItem; - u32 size, extents; - MP4Err err; - - extent = (MetaExtentLocationPtr)calloc( 1, sizeof(MetaExtentLocation) ); - TESTMALLOC( extent ); - - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - - err = MP4GetHandleSize( data, &size ); if (err) goto bail; - extent->extent_length = size; - extent->extent_index = 0; - - if (myItem->dref_index) { - dinf = (MP4DataInformationAtomPtr) myMeta->dinf; - if (!dinf) { BAILWITHERROR( ISOBadParamErr ); } - - err = dinf->getOffset( dinf, myItem->dref_index, &(extent->extent_offset) ); if (err) goto bail; - err = dinf->addSamples( dinf, 1, myItem->dref_index, data ); if (err) goto bail; - } - else - { - MP4MediaDataAtomPtr mdat; - mdat = (MP4MediaDataAtomPtr) myMeta->mdat; - extent->extent_offset = mdat->dataSize; - err = mdat->addData( mdat, data ); if (err) goto bail; - } - err = MP4GetListEntryCount( myItem->extentList, &extents ); if (err) goto bail; - if (extents==0) - myItem->base_offset += extent->extent_offset; - - err = MP4AddListEntry( (void*) extent, myItem->extentList ); - + MetaExtentLocationPtr extent; + ISOMetaAtomPtr myMeta; + MP4DataInformationAtomPtr dinf; + MetaItemLocationPtr myItem; + u32 size, extents; + MP4Err err; + + extent = (MetaExtentLocationPtr)calloc(1, sizeof(MetaExtentLocation)); + TESTMALLOC(extent); + + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + + err = MP4GetHandleSize(data, &size); + if(err) goto bail; + extent->extent_length = size; + extent->extent_index = 0; + + if(myItem->dref_index) + { + dinf = (MP4DataInformationAtomPtr)myMeta->dinf; + if(!dinf) + { + BAILWITHERROR(ISOBadParamErr); + } + + err = dinf->getOffset(dinf, myItem->dref_index, &(extent->extent_offset)); + if(err) goto bail; + err = dinf->addSamples(dinf, 1, myItem->dref_index, data); + if(err) goto bail; + } + else + { + MP4MediaDataAtomPtr mdat; + mdat = (MP4MediaDataAtomPtr)myMeta->mdat; + extent->extent_offset = mdat->dataSize; + err = mdat->addData(mdat, data); + if(err) goto bail; + } + err = MP4GetListEntryCount(myItem->extentList, &extents); + if(err) goto bail; + if(extents == 0) myItem->base_offset += extent->extent_offset; + + err = MP4AddListEntry((void *)extent, myItem->extentList); + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOAddItemExtentReference( ISOMetaItem item, u64 offset, u64 length ) +ISO_EXTERN(ISOErr) ISOAddItemExtentReference(ISOMetaItem item, u64 offset, u64 length) { - MetaExtentLocationPtr extent; - ISOMetaAtomPtr myMeta; - MP4DataInformationAtomPtr dinf; - MetaItemLocationPtr myItem; - MP4Err err; - u32 extents; - - extent = (MetaExtentLocationPtr)calloc( 1, sizeof(MetaExtentLocation) ); - TESTMALLOC( extent ); - - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - - extent->extent_length = length; - extent->extent_offset = offset; - extent->extent_index = 0; - - if (myItem->dref_index) { - dinf = (MP4DataInformationAtomPtr) myMeta->dinf; - if (!dinf) { BAILWITHERROR( ISOBadParamErr ); } - } - else { BAILWITHERROR( ISOBadParamErr ); } - - err = MP4GetListEntryCount( myItem->extentList, &extents ); if (err) goto bail; - if (extents==0) - myItem->base_offset += extent->extent_offset; - - err = MP4AddListEntry( (void*) extent, myItem->extentList ); - + MetaExtentLocationPtr extent; + ISOMetaAtomPtr myMeta; + MP4DataInformationAtomPtr dinf; + MetaItemLocationPtr myItem; + MP4Err err; + u32 extents; + + extent = (MetaExtentLocationPtr)calloc(1, sizeof(MetaExtentLocation)); + TESTMALLOC(extent); + + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + + extent->extent_length = length; + extent->extent_offset = offset; + extent->extent_index = 0; + + if(myItem->dref_index) + { + dinf = (MP4DataInformationAtomPtr)myMeta->dinf; + if(!dinf) + { + BAILWITHERROR(ISOBadParamErr); + } + } + else + { + BAILWITHERROR(ISOBadParamErr); + } + + err = MP4GetListEntryCount(myItem->extentList, &extents); + if(err) goto bail; + if(extents == 0) myItem->base_offset += extent->extent_offset; + + err = MP4AddListEntry((void *)extent, myItem->extentList); + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOAddItemExtentUsingItemData( ISOMetaItem item, MP4Handle data ) +ISO_EXTERN(ISOErr) ISOAddItemExtentUsingItemData(ISOMetaItem item, MP4Handle data) { - MetaExtentLocationPtr extent; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - ISOItemLocationAtomPtr iloc; - ISOItemDataAtomPtr idat; - u32 size; - u32 offset; - u32 extents; - MP4Err err; - - extent = (MetaExtentLocationPtr)calloc( 1, sizeof(MetaExtentLocation) ); - TESTMALLOC( extent ); - - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - iloc = (ISOItemLocationAtomPtr) myMeta->iloc; - idat = (ISOItemDataAtomPtr) myMeta->idat; - - if (idat == NULL) - { - err = ISOCreateItemDataAtom(&idat); - err = myMeta->addAtom( myMeta, (MP4AtomPtr) idat ); if (err) goto bail; - } - - err = MP4GetHandleSize( data, &size ); if (err) goto bail; - extent->extent_length = size; - - err = MP4GetHandleSize( idat->data, &offset ); if (err) goto bail; - extent->extent_offset = offset; - - extent->extent_index = 0; - - err = MP4GetListEntryCount( myItem->extentList, &extents ); if (err) goto bail; - if (extents == 0) - { - iloc->version = 1; - myItem->construction_method = 1; - - } - else - { - if (myItem->construction_method != 1) - BAILWITHERROR(MP4BadParamErr); - } - - err = MP4HandleCat(idat->data, data); if (err) goto bail; - - if (extents==0) - myItem->base_offset += extent->extent_offset; - - err = MP4AddListEntry( (void*) extent, myItem->extentList ); - + MetaExtentLocationPtr extent; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + ISOItemLocationAtomPtr iloc; + ISOItemDataAtomPtr idat; + u32 size; + u32 offset; + u32 extents; + MP4Err err; + + extent = (MetaExtentLocationPtr)calloc(1, sizeof(MetaExtentLocation)); + TESTMALLOC(extent); + + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + iloc = (ISOItemLocationAtomPtr)myMeta->iloc; + idat = (ISOItemDataAtomPtr)myMeta->idat; + + if(idat == NULL) + { + err = ISOCreateItemDataAtom(&idat); + err = myMeta->addAtom(myMeta, (MP4AtomPtr)idat); + if(err) goto bail; + } + + err = MP4GetHandleSize(data, &size); + if(err) goto bail; + extent->extent_length = size; + + err = MP4GetHandleSize(idat->data, &offset); + if(err) goto bail; + extent->extent_offset = offset; + + extent->extent_index = 0; + + err = MP4GetListEntryCount(myItem->extentList, &extents); + if(err) goto bail; + if(extents == 0) + { + iloc->version = 1; + myItem->construction_method = 1; + } + else + { + if(myItem->construction_method != 1) BAILWITHERROR(MP4BadParamErr); + } + + err = MP4HandleCat(idat->data, data); + if(err) goto bail; + + if(extents == 0) myItem->base_offset += extent->extent_offset; + + err = MP4AddListEntry((void *)extent, myItem->extentList); + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOAddItemExtentItem( ISOMetaItem item, ISOMetaItem extent_item, u32 offset, u32 length ) +ISO_EXTERN(ISOErr) +ISOAddItemExtentItem(ISOMetaItem item, ISOMetaItem extent_item, u32 offset, u32 length) { - MetaExtentLocationPtr extent; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - MetaItemLocationPtr extentItem; - ISOItemLocationAtomPtr iloc; - u32 extents; - MP4Err err; - u32 index; - - extent = (MetaExtentLocationPtr)calloc( 1, sizeof(MetaExtentLocation) ); - TESTMALLOC( extent ); - - myItem = (MetaItemLocationPtr) item; - extentItem = (MetaItemLocationPtr) extent_item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - iloc = (ISOItemLocationAtomPtr) myMeta->iloc; - - err = MP4GetListEntryCount( myItem->extentList, &extents ); if (err) goto bail; - if (extents == 0) - { - iloc->version = 1; - myItem->construction_method = 2; - } - else - { - if (myItem->construction_method != 2) - BAILWITHERROR(MP4BadParamErr); - } - - extent->extent_length = length; - extent->extent_offset = offset; - - err = ISOAddItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), extentItem->item_ID, &index); if (err) goto bail; - - extent->extent_index = index; - - if (extents==0) - myItem->base_offset += extent->extent_offset; - err = MP4AddListEntry( (void*) extent, myItem->extentList ); - + MetaExtentLocationPtr extent; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + MetaItemLocationPtr extentItem; + ISOItemLocationAtomPtr iloc; + u32 extents; + MP4Err err; + u32 index; + + extent = (MetaExtentLocationPtr)calloc(1, sizeof(MetaExtentLocation)); + TESTMALLOC(extent); + + myItem = (MetaItemLocationPtr)item; + extentItem = (MetaItemLocationPtr)extent_item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + iloc = (ISOItemLocationAtomPtr)myMeta->iloc; + + err = MP4GetListEntryCount(myItem->extentList, &extents); + if(err) goto bail; + if(extents == 0) + { + iloc->version = 1; + myItem->construction_method = 2; + } + else + { + if(myItem->construction_method != 2) BAILWITHERROR(MP4BadParamErr); + } + + extent->extent_length = length; + extent->extent_offset = offset; + + err = ISOAddItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), extentItem->item_ID, + &index); + if(err) goto bail; + + extent->extent_index = index; + + if(extents == 0) myItem->base_offset += extent->extent_offset; + err = MP4AddListEntry((void *)extent, myItem->extentList); + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOAddPrimaryData( ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom ) +ISO_EXTERN(ISOErr) ISOAddPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom) { - ISOMetaAtomPtr myMeta; - MP4UnknownAtomPtr myAtom; - char * dataPtr; - u32 len; - - MP4Err err; - err = MP4NoErr; - - myMeta = (ISOMetaAtomPtr) meta; - - err = MP4CreateUnknownAtom( &myAtom ); if (err) goto bail; - - err = MP4GetHandleSize( data, &len ); if (err) goto bail; - if (is_full_atom) len += 4; - - dataPtr = (char*)calloc( 1, len ); TESTMALLOC( dataPtr ); - myAtom->data = dataPtr; - myAtom->dataSize = len; - myAtom->type = box_type; - - if (is_full_atom) { dataPtr[0] = dataPtr[1] = dataPtr[2] = dataPtr[3] = 0; dataPtr += 4; len -= 4; } - memcpy( dataPtr, *data, len ); - - err = myMeta->addAtom( myMeta, (MP4AtomPtr) myAtom ); if (err) goto bail; - + ISOMetaAtomPtr myMeta; + MP4UnknownAtomPtr myAtom; + char *dataPtr; + u32 len; + + MP4Err err; + err = MP4NoErr; + + myMeta = (ISOMetaAtomPtr)meta; + + err = MP4CreateUnknownAtom(&myAtom); + if(err) goto bail; + + err = MP4GetHandleSize(data, &len); + if(err) goto bail; + if(is_full_atom) len += 4; + + dataPtr = (char *)calloc(1, len); + TESTMALLOC(dataPtr); + myAtom->data = dataPtr; + myAtom->dataSize = len; + myAtom->type = box_type; + + if(is_full_atom) + { + dataPtr[0] = dataPtr[1] = dataPtr[2] = dataPtr[3] = 0; + dataPtr += 4; + len -= 4; + } + memcpy(dataPtr, *data, len); + + err = myMeta->addAtom(myMeta, (MP4AtomPtr)myAtom); + if(err) goto bail; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOGetItemReferences( ISOMetaItem item, u32 reference_type, u16 *reference_count, MP4Handle to_item_IDs) +ISO_EXTERN(ISOErr) +ISOGetItemReferences(ISOMetaItem item, u32 reference_type, u16 *reference_count, + MP4Handle to_item_IDs) { - MP4Err err; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - ISOItemReferenceAtomPtr irefPtr; - ISOSingleItemTypeReferenceAtomPtr singleIrefPtr; - u32 i; - - err = MP4NoErr; - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - *reference_count = 0; - - if (myMeta->iref == NULL) - BAILWITHERROR(MP4BadParamErr); - - irefPtr = (ISOItemReferenceAtomPtr) myMeta->iref; - - for (i = 0; i < irefPtr->atomList->entryCount; i++) + MP4Err err; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + ISOItemReferenceAtomPtr irefPtr; + ISOSingleItemTypeReferenceAtomPtr singleIrefPtr; + u32 i; + + err = MP4NoErr; + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + *reference_count = 0; + + if(myMeta->iref == NULL) BAILWITHERROR(MP4BadParamErr); + + irefPtr = (ISOItemReferenceAtomPtr)myMeta->iref; + + for(i = 0; i < irefPtr->atomList->entryCount; i++) + { + err = MP4GetListEntry(irefPtr->atomList, i, (char **)&singleIrefPtr); + if(err) goto bail; + if((singleIrefPtr->from_item_ID == myItem->item_ID) && (singleIrefPtr->type == reference_type)) { - err = MP4GetListEntry(irefPtr->atomList, i, (char**) &singleIrefPtr); if (err) goto bail; - if ((singleIrefPtr->from_item_ID == myItem->item_ID) && - (singleIrefPtr->type == reference_type)) - { - *reference_count = singleIrefPtr->reference_count; - err = MP4SetHandleSize(to_item_IDs, singleIrefPtr->reference_count * sizeof(u32)); - memcpy((char *) *to_item_IDs, singleIrefPtr->to_item_IDs, singleIrefPtr->reference_count * sizeof(u32)); - break; - } + *reference_count = singleIrefPtr->reference_count; + err = MP4SetHandleSize(to_item_IDs, singleIrefPtr->reference_count * sizeof(u32)); + memcpy((char *)*to_item_IDs, singleIrefPtr->to_item_IDs, + singleIrefPtr->reference_count * sizeof(u32)); + break; } - + } + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOGetItemReference( ISOMetaItem item, u32 reference_type, u16 reference_index, ISOMetaItem *outItem) +ISO_EXTERN(ISOErr) +ISOGetItemReference(ISOMetaItem item, u32 reference_type, u16 reference_index, ISOMetaItem *outItem) { - MP4Err err; - MetaItemLocationPtr myItem; - MP4Handle toItemIDS; - u16 existingCount; - u32 *toItemIDsArray; - u32 referencedItemID; - ISOMetaAtomPtr myMeta; - - err = MP4NoErr; - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - - err = MP4NewHandle(0, &toItemIDS); if (err) goto bail; - err = ISOGetItemReferences(item, reference_type, &existingCount, toItemIDS); if (err) goto bail; - - if (existingCount < reference_index) - BAILWITHERROR(MP4BadParamErr); - - toItemIDsArray = (u32*) *toItemIDS; - - referencedItemID = toItemIDsArray[reference_index - 1]; - - err = ISOFindItemByID( (ISOMeta) myMeta, outItem, referencedItemID ); if (err) goto bail; - + MP4Err err; + MetaItemLocationPtr myItem; + MP4Handle toItemIDS; + u16 existingCount; + u32 *toItemIDsArray; + u32 referencedItemID; + ISOMetaAtomPtr myMeta; + + err = MP4NoErr; + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + + err = MP4NewHandle(0, &toItemIDS); + if(err) goto bail; + err = ISOGetItemReferences(item, reference_type, &existingCount, toItemIDS); + if(err) goto bail; + + if(existingCount < reference_index) BAILWITHERROR(MP4BadParamErr); + + toItemIDsArray = (u32 *)*toItemIDS; + + referencedItemID = toItemIDsArray[reference_index - 1]; + + err = ISOFindItemByID((ISOMeta)myMeta, outItem, referencedItemID); + if(err) goto bail; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOAddItemReference( ISOMetaItem item, u32 reference_type, u32 to_item_ID, u32 *outIndex ) +ISO_EXTERN(ISOErr) +ISOAddItemReference(ISOMetaItem item, u32 reference_type, u32 to_item_ID, u32 *outIndex) { - MP4Err err; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - ISOItemReferenceAtomPtr irefPtr; - ISOSingleItemTypeReferenceAtomPtr singleIrefPtr; - u16 existingCount; - MP4Handle toItemIDS; - u32 i; - - err = MP4NoErr; - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - *outIndex = 1; - - if (myMeta->iref == NULL) - { - err = ISOCreateItemReferenceAtom(&irefPtr); if (err) goto bail; - err = myMeta->addAtom(myMeta, (MP4AtomPtr) irefPtr); if (err) goto bail; - } - - irefPtr = (ISOItemReferenceAtomPtr) myMeta->iref; - - err = MP4NewHandle(0, &toItemIDS); if (err) goto bail; - err = ISOGetItemReferences(item, reference_type, &existingCount, toItemIDS); if (err) goto bail; - - if (existingCount == 0) - { - err = MP4SetHandleSize(toItemIDS, sizeof(u32)); if (err) goto bail; - *((u32*) *toItemIDS) = to_item_ID; - err = ISOAddItemReferences(item, reference_type, 1, toItemIDS); if (err) goto bail; - } - else + MP4Err err; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + ISOItemReferenceAtomPtr irefPtr; + ISOSingleItemTypeReferenceAtomPtr singleIrefPtr; + u16 existingCount; + MP4Handle toItemIDS; + u32 i; + + err = MP4NoErr; + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + *outIndex = 1; + + if(myMeta->iref == NULL) + { + err = ISOCreateItemReferenceAtom(&irefPtr); + if(err) goto bail; + err = myMeta->addAtom(myMeta, (MP4AtomPtr)irefPtr); + if(err) goto bail; + } + + irefPtr = (ISOItemReferenceAtomPtr)myMeta->iref; + + err = MP4NewHandle(0, &toItemIDS); + if(err) goto bail; + err = ISOGetItemReferences(item, reference_type, &existingCount, toItemIDS); + if(err) goto bail; + + if(existingCount == 0) + { + err = MP4SetHandleSize(toItemIDS, sizeof(u32)); + if(err) goto bail; + *((u32 *)*toItemIDS) = to_item_ID; + err = ISOAddItemReferences(item, reference_type, 1, toItemIDS); + if(err) goto bail; + } + else + { + for(i = 0; i < irefPtr->atomList->entryCount; i++) { - for (i = 0; i < irefPtr->atomList->entryCount; i++) - { - err = MP4GetListEntry(irefPtr->atomList, i, (char**) &singleIrefPtr); if (err) goto bail; - if ((singleIrefPtr->from_item_ID == myItem->item_ID) && - (singleIrefPtr->type == reference_type)) - { - singleIrefPtr->reference_count++; - singleIrefPtr->to_item_IDs = (u32*)realloc(singleIrefPtr->to_item_IDs, singleIrefPtr->reference_count * sizeof(u32)); - singleIrefPtr->to_item_IDs[singleIrefPtr->reference_count - 1] = to_item_ID; - *outIndex = singleIrefPtr->reference_count; - break; - } - } + err = MP4GetListEntry(irefPtr->atomList, i, (char **)&singleIrefPtr); + if(err) goto bail; + if((singleIrefPtr->from_item_ID == myItem->item_ID) && + (singleIrefPtr->type == reference_type)) + { + singleIrefPtr->reference_count++; + singleIrefPtr->to_item_IDs = (u32 *)realloc(singleIrefPtr->to_item_IDs, + singleIrefPtr->reference_count * sizeof(u32)); + singleIrefPtr->to_item_IDs[singleIrefPtr->reference_count - 1] = to_item_ID; + *outIndex = singleIrefPtr->reference_count; + break; + } } - - err = MP4DisposeHandle(toItemIDS); if (err) goto bail; + } + + err = MP4DisposeHandle(toItemIDS); + if(err) goto bail; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOAddItemReferences( ISOMetaItem item, u32 reference_type, u16 reference_count, MP4Handle to_item_IDs ) +ISO_EXTERN(ISOErr) +ISOAddItemReferences(ISOMetaItem item, u32 reference_type, u16 reference_count, + MP4Handle to_item_IDs) { - MP4Err err; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - ISOItemReferenceAtomPtr irefPtr; - ISOSingleItemTypeReferenceAtomPtr singleIrefPtr; - u32 *toItemIdsArray; - - err = MP4NoErr; - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - - if (myMeta->iref == NULL) - { - err = ISOCreateItemReferenceAtom(&irefPtr); if (err) goto bail; - err = myMeta->addAtom(myMeta, (MP4AtomPtr) irefPtr); if (err) goto bail; - } - - irefPtr = (ISOItemReferenceAtomPtr) myMeta->iref; - - err = ISOCreateSingleItemTypeReferenceAtom(&singleIrefPtr, reference_type, irefPtr->version); if (err) goto bail; - - singleIrefPtr->from_item_ID = myItem->item_ID; - singleIrefPtr->reference_count = reference_count; - toItemIdsArray = (u32*) *to_item_IDs; - - singleIrefPtr->to_item_IDs = (u32*)calloc(reference_count, sizeof(u32)); - memcpy(singleIrefPtr->to_item_IDs, toItemIdsArray, reference_count * sizeof(u32)); - - err = MP4AddListEntry(singleIrefPtr, irefPtr->atomList); if (err) goto bail; - + MP4Err err; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + ISOItemReferenceAtomPtr irefPtr; + ISOSingleItemTypeReferenceAtomPtr singleIrefPtr; + u32 *toItemIdsArray; + + err = MP4NoErr; + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + + if(myMeta->iref == NULL) + { + err = ISOCreateItemReferenceAtom(&irefPtr); + if(err) goto bail; + err = myMeta->addAtom(myMeta, (MP4AtomPtr)irefPtr); + if(err) goto bail; + } + + irefPtr = (ISOItemReferenceAtomPtr)myMeta->iref; + + err = ISOCreateSingleItemTypeReferenceAtom(&singleIrefPtr, reference_type, irefPtr->version); + if(err) goto bail; + + singleIrefPtr->from_item_ID = myItem->item_ID; + singleIrefPtr->reference_count = reference_count; + toItemIdsArray = (u32 *)*to_item_IDs; + + singleIrefPtr->to_item_IDs = (u32 *)calloc(reference_count, sizeof(u32)); + memcpy(singleIrefPtr->to_item_IDs, toItemIdsArray, reference_count * sizeof(u32)); + + err = MP4AddListEntry(singleIrefPtr, irefPtr->atomList); + if(err) goto bail; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOGetPrimaryData( ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom ) +ISO_EXTERN(ISOErr) ISOGetPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom) { - ISOMetaAtomPtr myMeta; - - MP4Err err; - err = MP4NoErr; - - myMeta = (ISOMetaAtomPtr) meta; - - err = myMeta->getData( myMeta, box_type, data, is_full_atom ); if (err) goto bail; - + ISOMetaAtomPtr myMeta; + + MP4Err err; + err = MP4NoErr; + + myMeta = (ISOMetaAtomPtr)meta; + + err = myMeta->getData(myMeta, box_type, data, is_full_atom); + if(err) goto bail; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOGetPrimaryItemData( ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom ) +ISO_EXTERN(ISOErr) +ISOGetPrimaryItemData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom) { - MP4Err err; - - err = ISOGetPrimaryData( meta, box_type, data, is_full_atom ); - if (err == MP4NotFoundErr) - { - u64 boff; - u16 ID; - ISOMetaItem item; - err = ISOGetPrimaryItemID( meta, &ID ); if (err) goto bail; - err = ISOFindItemByID( meta, &item, ID ); if (err) goto bail; - err = ISOGetItemData( item, data, &boff ); if (err) goto bail; - } - + MP4Err err; + + err = ISOGetPrimaryData(meta, box_type, data, is_full_atom); + if(err == MP4NotFoundErr) + { + u64 boff; + u16 ID; + ISOMetaItem item; + err = ISOGetPrimaryItemID(meta, &ID); + if(err) goto bail; + err = ISOFindItemByID(meta, &item, ID); + if(err) goto bail; + err = ISOGetItemData(item, data, &boff); + if(err) goto bail; + } + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOSetPrimaryItem( ISOMeta meta, ISOMetaItem item ) +ISO_EXTERN(ISOErr) ISOSetPrimaryItem(ISOMeta meta, ISOMetaItem item) { - MP4Err err; - ISOMetaAtomPtr myMeta; - ISOPrimaryItemAtomPtr pitm; - MetaItemLocationPtr myItem; - - err = MP4NoErr; - - myMeta = (ISOMetaAtomPtr) meta; - myItem = (MetaItemLocationPtr) item; - - if (myMeta->pitm == NULL) - { - err = ISOCreatePrimaryItemAtom( &pitm ); if (err) goto bail; - err = myMeta->addAtom( myMeta, (MP4AtomPtr) pitm ); if (err) goto bail; - } - - pitm = (ISOPrimaryItemAtomPtr) myMeta->pitm; - pitm->item_ID = myItem->item_ID; + MP4Err err; + ISOMetaAtomPtr myMeta; + ISOPrimaryItemAtomPtr pitm; + MetaItemLocationPtr myItem; + + err = MP4NoErr; + + myMeta = (ISOMetaAtomPtr)meta; + myItem = (MetaItemLocationPtr)item; + + if(myMeta->pitm == NULL) + { + err = ISOCreatePrimaryItemAtom(&pitm); + if(err) goto bail; + err = myMeta->addAtom(myMeta, (MP4AtomPtr)pitm); + if(err) goto bail; + } + + pitm = (ISOPrimaryItemAtomPtr)myMeta->pitm; + pitm->item_ID = myItem->item_ID; +bail: + TEST_RETURN(err); + return err; +} + +ISO_EXTERN(ISOErr) ISOGetPrimaryItemID(ISOMeta meta, u16 *ID) +{ + MP4Err err; + ISOMetaAtomPtr myMeta; + ISOPrimaryItemAtomPtr pitm; + + err = MP4NoErr; + + myMeta = (ISOMetaAtomPtr)meta; + pitm = (ISOPrimaryItemAtomPtr)myMeta->pitm; + if(pitm) + { + *ID = pitm->item_ID; + } + else + BAILWITHERROR(MP4NotFoundErr); + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOGetPrimaryItemID( ISOMeta meta, u16 *ID ) +ISO_EXTERN(ISOErr) ISOGetItemID(ISOMetaItem item, u16 *ID) { - MP4Err err; - ISOMetaAtomPtr myMeta; - ISOPrimaryItemAtomPtr pitm; - - err = MP4NoErr; - - myMeta = (ISOMetaAtomPtr) meta; - pitm = (ISOPrimaryItemAtomPtr) myMeta->pitm; - if (pitm) { - *ID = pitm->item_ID; - } else BAILWITHERROR( MP4NotFoundErr ); - + MP4Err err; + MetaItemLocationPtr myItem; + + err = MP4NoErr; + + myItem = (MetaItemLocationPtr)item; + if(item) *ID = myItem->item_ID; + else + { + BAILWITHERROR(MP4BadParamErr); + } + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOGetItemID( ISOMetaItem item, u16* ID ) +ISO_EXTERN(ISOErr) +ISOSetItemInfo(ISOMetaItem item, u16 protection_index, char *name, char *content_type, + char *content_encoding) { - MP4Err err; - MetaItemLocationPtr myItem; - - err = MP4NoErr; - - myItem = (MetaItemLocationPtr) item; - if (item) *ID = myItem->item_ID; - else { BAILWITHERROR(MP4BadParamErr); } - + MP4Err ISOCreateItemInfoAtom(ISOItemInfoAtomPtr * outAtom); + MP4Err ISOCreateItemInfoEntryAtom(ISOItemInfoEntryAtomPtr * outAtom); + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + ISOItemInfoAtomPtr iinf; + ISOItemInfoEntryAtomPtr infe; + u32 sz; + + MP4Err err; + err = MP4NoErr; + + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + + iinf = (ISOItemInfoAtomPtr)myMeta->iinf; + if(!iinf) + { + err = ISOCreateItemInfoAtom(&iinf); + if(err) goto bail; + err = myMeta->addAtom(myMeta, (MP4AtomPtr)iinf); + if(err) goto bail; + } + err = ISOCreateItemInfoEntryAtom(&infe); + if(err) goto bail; + err = iinf->addAtom(iinf, (MP4AtomPtr)infe); + if(err) goto bail; + + if(name) + { + sz = strlen(name); + infe->item_name = (char *)calloc(1, sz + 1); + memcpy(infe->item_name, name, sz); + (infe->item_name)[sz] = '\0'; + } + else + { + infe->item_name = (char *)calloc(1, 1); + (infe->item_name)[0] = '\0'; + } + + if(content_encoding) + { + sz = strlen(content_encoding); + infe->content_encoding = (char *)calloc(1, sz); + memcpy(infe->content_encoding, content_encoding, sz); + } + else + { + infe->content_encoding = (char *)calloc(1, 1); + (infe->content_encoding)[0] = '\0'; + } + + if(content_type) + { + sz = strlen(content_type); + infe->content_type = (char *)calloc(1, sz); + memcpy(infe->content_type, content_type, sz); + } + else + { + infe->content_type = (char *)calloc(1, 1); + (infe->content_type)[0] = '\0'; + } + + infe->item_ID = myItem->item_ID; + infe->protection_index = protection_index; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } +ISO_EXTERN(ISOErr) +ISOSetItemInfoExtension(ISOMetaItem item, MP4Handle extension, u32 extension_type) +{ + MP4Err err; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + ISOItemInfoAtomPtr iinf; + ISOItemInfoEntryAtomPtr infe; + + err = MP4NoErr; + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + iinf = (ISOItemInfoAtomPtr)myMeta->iinf; + + if(!iinf) BAILWITHERROR(MP4BadParamErr); + + infe = NULL; + err = iinf->getEntry(iinf, myItem->item_ID, &infe); + if(err) goto bail; + + if(infe == NULL) BAILWITHERROR(MP4BadParamErr); + + err = MP4NewHandle(0, &infe->item_info_extension); + if(err) goto bail; + err = MP4HandleCat(infe->item_info_extension, extension); + if(err) goto bail; + + infe->extension_type = extension_type; + infe->version = 1; + +bail: + TEST_RETURN(err); + return err; +} -ISO_EXTERN ( ISOErr ) ISOSetItemInfo( ISOMetaItem item, u16 protection_index, char* name, char* content_type, char* content_encoding ) +ISO_EXTERN(ISOErr) +ISOGetItemInfoExtension(ISOMetaItem item, MP4Handle extension, u32 *extension_type) { - MP4Err ISOCreateItemInfoAtom( ISOItemInfoAtomPtr *outAtom ); - MP4Err ISOCreateItemInfoEntryAtom( ISOItemInfoEntryAtomPtr *outAtom ); - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - ISOItemInfoAtomPtr iinf; - ISOItemInfoEntryAtomPtr infe; - u32 sz; - - MP4Err err; - err = MP4NoErr; - - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - - iinf = (ISOItemInfoAtomPtr) myMeta->iinf; - if (!iinf) { - err = ISOCreateItemInfoAtom( &iinf ); if (err) goto bail; - err = myMeta->addAtom( myMeta, (MP4AtomPtr) iinf); if (err) goto bail; - } - err = ISOCreateItemInfoEntryAtom( &infe ); if (err) goto bail; - err = iinf->addAtom( iinf, (MP4AtomPtr) infe); if (err) goto bail; - - if (name) { - sz = strlen( name ); - infe->item_name = (char*) calloc( 1, sz + 1); - memcpy( infe->item_name, name, sz ); - (infe->item_name)[sz] = '\0'; - } else { - infe->item_name = (char*) calloc( 1, 1 ); - (infe->item_name)[0] = '\0'; - } - - if (content_encoding) { - sz = strlen( content_encoding ); - infe->content_encoding = (char*) calloc( 1, sz ); - memcpy( infe->content_encoding, content_encoding, sz ); - } else { - infe->content_encoding = (char*) calloc( 1, 1 ); - (infe->content_encoding)[0] = '\0'; - } - - if (content_type) { - sz = strlen( content_type ); - infe->content_type = (char*) calloc( 1, sz ); - memcpy( infe->content_type, content_type, sz ); - } else { - infe->content_type = (char*) calloc( 1, 1 ); - (infe->content_type)[0] = '\0'; - } - - infe->item_ID = myItem->item_ID; - infe->protection_index = protection_index; - + MP4Err err; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + ISOItemInfoAtomPtr iinf; + ISOItemInfoEntryAtomPtr infe; + + err = MP4NoErr; + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + iinf = (ISOItemInfoAtomPtr)myMeta->iinf; + + if(!iinf) BAILWITHERROR(MP4BadParamErr); + + infe = NULL; + err = iinf->getEntry(iinf, myItem->item_ID, &infe); + if(err) goto bail; + + if(infe == NULL) BAILWITHERROR(MP4BadParamErr); + + if(infe->version != 1) BAILWITHERROR(MP4InvalidMediaErr); + + err = MP4HandleCat(extension, infe->item_info_extension); + if(err) goto bail; + *extension_type = infe->extension_type; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOSetItemInfoExtension( ISOMetaItem item, MP4Handle extension, u32 extension_type ) +ISO_EXTERN(ISOErr) ISOSetItemInfoItemType(ISOMetaItem item, u32 item_type, char *item_uri_type) { - MP4Err err; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - ISOItemInfoAtomPtr iinf; - ISOItemInfoEntryAtomPtr infe; - - err = MP4NoErr; - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - iinf = (ISOItemInfoAtomPtr) myMeta->iinf; - - if (!iinf) - BAILWITHERROR(MP4BadParamErr); - - infe = NULL; - err = iinf->getEntry(iinf, myItem->item_ID, &infe); if (err) goto bail; - - if (infe == NULL) - BAILWITHERROR(MP4BadParamErr); - - err = MP4NewHandle(0, &infe->item_info_extension); if (err) goto bail; - err = MP4HandleCat(infe->item_info_extension, extension); if (err) goto bail; - - infe->extension_type = extension_type; - infe->version = 1; - + MP4Err err; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + ISOItemInfoAtomPtr iinf; + ISOItemInfoEntryAtomPtr infe; + + err = MP4NoErr; + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + iinf = (ISOItemInfoAtomPtr)myMeta->iinf; + + if(!iinf) BAILWITHERROR(MP4BadParamErr); + + infe = NULL; + err = iinf->getEntry(iinf, myItem->item_ID, &infe); + if(err) goto bail; + + if(infe == NULL) BAILWITHERROR(MP4BadParamErr); + + infe->version = 2; + infe->item_type = item_type; + + if(item_uri_type) + { + u32 sz = strlen(item_uri_type); + infe->item_uri_type = (char *)calloc(1, sz); + memcpy(infe->item_uri_type, item_uri_type, sz); + } + else + { + infe->item_uri_type = (char *)calloc(1, 1); + (infe->item_uri_type)[0] = '\0'; + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOGetItemInfoExtension( ISOMetaItem item, MP4Handle extension, u32 *extension_type ) +ISO_EXTERN(ISOErr) ISOGetItemInfoItemType(ISOMetaItem item, u32 *item_type, char **item_uri_type) { - MP4Err err; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - ISOItemInfoAtomPtr iinf; - ISOItemInfoEntryAtomPtr infe; - - err = MP4NoErr; - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - iinf = (ISOItemInfoAtomPtr) myMeta->iinf; - - if (!iinf) - BAILWITHERROR(MP4BadParamErr); - - infe = NULL; - err = iinf->getEntry(iinf, myItem->item_ID, &infe); if (err) goto bail; - - if (infe == NULL) - BAILWITHERROR(MP4BadParamErr); - - if (infe->version != 1) - BAILWITHERROR(MP4InvalidMediaErr); - - err = MP4HandleCat(extension, infe->item_info_extension); if (err) goto bail; - *extension_type = infe->extension_type; + MP4Err err; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + ISOItemInfoAtomPtr iinf; + ISOItemInfoEntryAtomPtr infe; + + err = MP4NoErr; + myItem = (MetaItemLocationPtr)item; + myMeta = (ISOMetaAtomPtr)myItem->meta; + iinf = (ISOItemInfoAtomPtr)myMeta->iinf; + + if(!iinf) BAILWITHERROR(MP4BadParamErr); + + infe = NULL; + err = iinf->getEntry(iinf, myItem->item_ID, &infe); + if(err) goto bail; + + if(infe == NULL) BAILWITHERROR(MP4BadParamErr); + + if(infe->version != 2) BAILWITHERROR(MP4InvalidMediaErr); + + *item_type = infe->item_type; + + if(infe->item_uri_type) + { + u32 sz = strlen(infe->item_uri_type); + *item_uri_type = (char *)calloc(1, sz); + memcpy(*item_uri_type, infe->item_uri_type, sz); + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOSetItemInfoItemType( ISOMetaItem item, u32 item_type, char* item_uri_type) +ISO_EXTERN(ISOErr) +ISOGetFileMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, u32 *outMetaType) { - MP4Err err; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - ISOItemInfoAtomPtr iinf; - ISOItemInfoEntryAtomPtr infe; - - err = MP4NoErr; - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - iinf = (ISOItemInfoAtomPtr) myMeta->iinf; - - if (!iinf) - BAILWITHERROR(MP4BadParamErr); - - infe = NULL; - err = iinf->getEntry(iinf, myItem->item_ID, &infe); if (err) goto bail; - - if (infe == NULL) - BAILWITHERROR(MP4BadParamErr); - - infe->version = 2; - infe->item_type = item_type; - - if (item_uri_type) - { - u32 sz = strlen( item_uri_type ); - infe->item_uri_type = (char*) calloc( 1, sz ); - memcpy( infe->item_uri_type, item_uri_type, sz ); - } else + ISOMetaAtomPtr myMeta; + MP4HandlerAtomPtr hdlr; + ISOAdditionalMetaDataContainerAtomPtr meco; + + GETMOOV(theMovie); + myMeta = (ISOMetaAtomPtr)moov->meta; + + if(!myMeta) + { + BAILWITHERROR(MP4BadParamErr); + } + hdlr = (MP4HandlerAtomPtr)myMeta->hdlr; + if(!hdlr) + { + BAILWITHERROR(MP4BadDataErr); + } + + if((inMetaType != 0) && (hdlr->handlerType != inMetaType)) + { + meco = (ISOAdditionalMetaDataContainerAtomPtr)moov->meco; + if(!meco) BAILWITHERROR(MP4BadParamErr); + + err = meco->getMeta(meco, inMetaType, &myMeta); + if(err) goto bail; + hdlr = (MP4HandlerAtomPtr)myMeta->hdlr; + if(!hdlr) { - infe->item_uri_type = (char*) calloc( 1, 1 ); - (infe->item_uri_type)[0] = '\0'; + BAILWITHERROR(MP4BadDataErr); } + } + if(outMetaType) *outMetaType = hdlr->handlerType; + if(meta) *meta = (ISOMeta)myMeta; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOGetItemInfoItemType( ISOMetaItem item, u32 *item_type, char** item_uri_type) +ISO_EXTERN(ISOErr) +ISOGetMovieMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, u32 *outMetaType) { - MP4Err err; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - ISOItemInfoAtomPtr iinf; - ISOItemInfoEntryAtomPtr infe; - - err = MP4NoErr; - myItem = (MetaItemLocationPtr) item; - myMeta = (ISOMetaAtomPtr) myItem->meta; - iinf = (ISOItemInfoAtomPtr) myMeta->iinf; - - if (!iinf) - BAILWITHERROR(MP4BadParamErr); - - infe = NULL; - err = iinf->getEntry(iinf, myItem->item_ID, &infe); if (err) goto bail; - - if (infe == NULL) - BAILWITHERROR(MP4BadParamErr); - - if (infe->version != 2) - BAILWITHERROR(MP4InvalidMediaErr); - - *item_type = infe->item_type; - - if (infe->item_uri_type) + ISOMetaAtomPtr myMeta; + MP4HandlerAtomPtr hdlr; + ISOAdditionalMetaDataContainerAtomPtr meco; + + GETMOVIEATOM(theMovie); + myMeta = (ISOMetaAtomPtr)movieAtom->meta; + + if(!myMeta) + { + BAILWITHERROR(MP4BadParamErr); + } + hdlr = (MP4HandlerAtomPtr)myMeta->hdlr; + if(!hdlr) + { + BAILWITHERROR(MP4BadDataErr); + } + + if((inMetaType != 0) && (hdlr->handlerType != inMetaType)) + { + meco = (ISOAdditionalMetaDataContainerAtomPtr)movieAtom->meco; + if(!meco) BAILWITHERROR(MP4BadParamErr); + + err = meco->getMeta(meco, inMetaType, &myMeta); + if(err) goto bail; + hdlr = (MP4HandlerAtomPtr)myMeta->hdlr; + if(!hdlr) { - u32 sz = strlen( infe->item_uri_type ); - *item_uri_type = (char*) calloc( 1, sz ); - memcpy( *item_uri_type, infe->item_uri_type, sz ); + BAILWITHERROR(MP4BadDataErr); } + } + if(outMetaType) *outMetaType = hdlr->handlerType; + if(meta) *meta = (ISOMeta)myMeta; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOGetFileMeta( ISOMovie theMovie, ISOMeta* meta, u32 inMetaType, u32* outMetaType) +ISO_EXTERN(ISOErr) +ISOGetTrackMeta(ISOTrack theTrack, ISOMeta *meta, u32 inMetaType, u32 *outMetaType) { - ISOMetaAtomPtr myMeta; - MP4HandlerAtomPtr hdlr; - ISOAdditionalMetaDataContainerAtomPtr meco; - - GETMOOV( theMovie ); - myMeta = (ISOMetaAtomPtr) moov->meta; - - if (!myMeta) { BAILWITHERROR( MP4BadParamErr ); } - hdlr = (MP4HandlerAtomPtr) myMeta->hdlr; - if (!hdlr) { BAILWITHERROR( MP4BadDataErr ); } - - if ((inMetaType != 0) && (hdlr->handlerType != inMetaType)) + MP4Err err; + ISOMetaAtomPtr myMeta; + MP4HandlerAtomPtr hdlr; + MP4TrackAtomPtr trak; + ISOAdditionalMetaDataContainerAtomPtr meco; + + err = MP4NoErr; + + trak = (MP4TrackAtomPtr)theTrack; + myMeta = (ISOMetaAtomPtr)trak->meta; + + if(!myMeta) + { + BAILWITHERROR(MP4BadParamErr); + } + hdlr = (MP4HandlerAtomPtr)myMeta->hdlr; + if(!hdlr) + { + BAILWITHERROR(MP4BadDataErr); + } + + if((inMetaType != 0) && (hdlr->handlerType != inMetaType)) + { + meco = (ISOAdditionalMetaDataContainerAtomPtr)trak->meco; + if(!meco) BAILWITHERROR(MP4BadParamErr); + + err = meco->getMeta(meco, inMetaType, &myMeta); + if(err) goto bail; + hdlr = (MP4HandlerAtomPtr)myMeta->hdlr; + if(!hdlr) { - meco = (ISOAdditionalMetaDataContainerAtomPtr) moov->meco; - if (!meco) - BAILWITHERROR( MP4BadParamErr ); - - err = meco->getMeta(meco, inMetaType, &myMeta); if (err) goto bail; - hdlr = (MP4HandlerAtomPtr) myMeta->hdlr; - if (!hdlr) { BAILWITHERROR( MP4BadDataErr ); } + BAILWITHERROR(MP4BadDataErr); } - if (outMetaType) *outMetaType = hdlr->handlerType; - if (meta) *meta = (ISOMeta) myMeta; - + } + if(outMetaType) *outMetaType = hdlr->handlerType; + if(meta) *meta = (ISOMeta)myMeta; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) ISOGetMovieMeta( ISOMovie theMovie, ISOMeta* meta, u32 inMetaType, u32* outMetaType ) +ISO_EXTERN(ISOErr) ISOFindItemByID(ISOMeta meta, ISOMetaItem *item, u16 ID) { - ISOMetaAtomPtr myMeta; - MP4HandlerAtomPtr hdlr; - ISOAdditionalMetaDataContainerAtomPtr meco; - - GETMOVIEATOM(theMovie); - myMeta = (ISOMetaAtomPtr) movieAtom->meta; - - if (!myMeta) { BAILWITHERROR( MP4BadParamErr ); } - hdlr = (MP4HandlerAtomPtr) myMeta->hdlr; - if (!hdlr) { BAILWITHERROR( MP4BadDataErr ); } - - if ((inMetaType != 0) && (hdlr->handlerType != inMetaType)) + MP4Err err; + ISOMetaAtomPtr myMeta; + ISOItemLocationAtomPtr iloc; + u32 i, item_total; + + err = MP4NoErr; + myMeta = (ISOMetaAtomPtr)meta; + + if(myMeta == NULL) BAILWITHERROR(MP4BadParamErr) + iloc = (ISOItemLocationAtomPtr)myMeta->iloc; + *item = NULL; + + if(iloc == NULL) BAILWITHERROR(MP4NotFoundErr) + + *item = NULL; + + if(iloc->itemList) + { + err = MP4GetListEntryCount(iloc->itemList, &item_total); + if(err) goto bail; + + for(i = 0; i < item_total; i++) { - meco = (ISOAdditionalMetaDataContainerAtomPtr) movieAtom->meco; - if (!meco) - BAILWITHERROR( MP4BadParamErr ); - - err = meco->getMeta(meco, inMetaType, &myMeta); if (err) goto bail; - hdlr = (MP4HandlerAtomPtr) myMeta->hdlr; - if (!hdlr) { BAILWITHERROR( MP4BadDataErr ); } + MetaItemLocationPtr a; + err = MP4GetListEntry(iloc->itemList, i, (char **)&a); + if(err) goto bail; + + if(a->item_ID == ID) + { + a->meta = (MP4AtomPtr)myMeta; + *item = (ISOMetaItem)a; + err = MP4NoErr; + goto bail; + } } - if (outMetaType) *outMetaType = hdlr->handlerType; - if (meta) *meta = (ISOMeta) myMeta; - + } + else + BAILWITHERROR(MP4BadDataErr); + err = MP4NotFoundErr; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + + return err; } -ISO_EXTERN ( ISOErr ) ISOGetTrackMeta( ISOTrack theTrack, ISOMeta* meta, u32 inMetaType, u32* outMetaType ) +ISO_EXTERN(ISOErr) +ISOGetAllItemsWithType(ISOMeta meta, u32 type, ISOMetaItem **items, u32 *numberOfItemsFound) { - MP4Err err; - ISOMetaAtomPtr myMeta; - MP4HandlerAtomPtr hdlr; - MP4TrackAtomPtr trak; - ISOAdditionalMetaDataContainerAtomPtr meco; - - err = MP4NoErr; - - trak = (MP4TrackAtomPtr) theTrack; - myMeta = (ISOMetaAtomPtr) trak->meta; - - if (!myMeta) { BAILWITHERROR( MP4BadParamErr ); } - hdlr = (MP4HandlerAtomPtr) myMeta->hdlr; - if (!hdlr) { BAILWITHERROR( MP4BadDataErr ); } - - if ((inMetaType != 0) && (hdlr->handlerType != inMetaType)) + MP4Err err; + ISOMetaAtomPtr myMeta; + ISOItemLocationAtomPtr iloc; + u32 i, item_total; + + err = MP4NoErr; + myMeta = (ISOMetaAtomPtr)meta; + + if(myMeta == NULL) BAILWITHERROR(MP4BadParamErr); + + iloc = (ISOItemLocationAtomPtr)myMeta->iloc; + + if(iloc == NULL) BAILWITHERROR(MP4NotFoundErr); + + *numberOfItemsFound = 0; + *items = NULL; + if(iloc->itemList) + { + err = MP4GetListEntryCount(iloc->itemList, &item_total); + if(err) goto bail; + + for(i = 0; i < item_total; i++) { - meco = (ISOAdditionalMetaDataContainerAtomPtr) trak->meco; - if (!meco) - BAILWITHERROR( MP4BadParamErr ); - - err = meco->getMeta(meco, inMetaType, &myMeta); if (err) goto bail; - hdlr = (MP4HandlerAtomPtr) myMeta->hdlr; - if (!hdlr) { BAILWITHERROR( MP4BadDataErr ); } + char *tmp; + u32 outType; + MetaItemLocationPtr a; + + err = MP4GetListEntry(iloc->itemList, i, (char **)&a); + if(err) goto bail; + err = ISOGetItemInfoItemType((ISOMetaItem)a, &outType, &tmp); + if(err) goto bail; + + if(type == outType) + { + *numberOfItemsFound = *numberOfItemsFound + 1; + *items = (ISOMetaItem *)realloc(*items, *numberOfItemsFound * sizeof(ISOMetaItem)); + (*items)[*numberOfItemsFound - 1] = (ISOMetaItem)a; + } } - if (outMetaType) *outMetaType = hdlr->handlerType; - if (meta) *meta = (ISOMeta) myMeta; - + } + else + BAILWITHERROR(MP4BadDataErr); + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + + return err; } -ISO_EXTERN ( ISOErr ) ISOFindItemByID( ISOMeta meta, ISOMetaItem* item, u16 ID ) +ISO_EXTERN(ISOErr) ISOFindItemByName(ISOMeta meta, ISOMetaItem *item, char *name, u8 exact_case) { - MP4Err err; - ISOMetaAtomPtr myMeta; - ISOItemLocationAtomPtr iloc; - u32 i, item_total; - - err = MP4NoErr; - myMeta = (ISOMetaAtomPtr) meta; - - if (myMeta == NULL) - BAILWITHERROR( MP4BadParamErr ) - iloc = (ISOItemLocationAtomPtr) myMeta->iloc; - *item = NULL; - - if (iloc == NULL) - BAILWITHERROR( MP4NotFoundErr ) - - *item = NULL; - - if ( iloc->itemList ) - { - err = MP4GetListEntryCount( iloc->itemList, &item_total ); if (err) goto bail; - - for ( i = 0; i < item_total; i++ ) - { - MetaItemLocationPtr a; - err = MP4GetListEntry( iloc->itemList, i, (char **) &a ); if (err) goto bail; - - if (a->item_ID == ID) { - a->meta = (MP4AtomPtr) myMeta; - *item = (ISOMetaItem) a; - err = MP4NoErr; - goto bail; - } - } - } else BAILWITHERROR( MP4BadDataErr ); - err = MP4NotFoundErr; - + MP4Err err; + ISOMetaAtomPtr myMeta; + ISOItemInfoAtomPtr iinf; + u32 i, item_total; + + err = MP4NoErr; + myMeta = (ISOMetaAtomPtr)meta; + + if(myMeta == NULL) BAILWITHERROR(MP4BadParamErr) + iinf = (ISOItemInfoAtomPtr)myMeta->iinf; + *item = NULL; + + if(iinf == NULL) BAILWITHERROR(MP4NotFoundErr) + + if(iinf->atomList) + { + err = MP4GetListEntryCount(iinf->atomList, &item_total); + if(err) goto bail; + + for(i = 0; i < item_total; i++) + { + ISOItemInfoEntryAtomPtr infe; + err = MP4GetListEntry(iinf->atomList, i, (char **)&infe); + if(err) goto bail; + + if((exact_case && (strcmp(name, infe->item_name) == 0)) || + (!exact_case && (strcasecmp(name, infe->item_name) == 0))) + return ISOFindItemByID(meta, item, (u16)infe->item_ID); + } + } + else + BAILWITHERROR(MP4BadDataErr) + err = MP4NotFoundErr; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -ISO_EXTERN ( ISOErr ) ISOGetAllItemsWithType( ISOMeta meta, u32 type, ISOMetaItem **items, u32 *numberOfItemsFound ) +ISO_EXTERN(ISOErr) ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_offset) { - MP4Err err; - ISOMetaAtomPtr myMeta; - ISOItemLocationAtomPtr iloc; - u32 i, item_total; - - err = MP4NoErr; - myMeta = (ISOMetaAtomPtr) meta; - - if (myMeta == NULL) - BAILWITHERROR( MP4BadParamErr ); - - iloc = (ISOItemLocationAtomPtr) myMeta->iloc; - - if (iloc == NULL) - BAILWITHERROR( MP4NotFoundErr ); - - *numberOfItemsFound = 0; - *items = NULL; - if ( iloc->itemList ) + MP4Err err; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + MP4DataHandlerPtr dhlr; + ISOItemDataAtomPtr idat; + + err = MP4NoErr; + myItem = (MetaItemLocationPtr)item; + if(myItem == NULL) BAILWITHERROR(MP4BadParamErr) + + myMeta = (ISOMetaAtomPtr)myItem->meta; + if(myMeta == NULL) BAILWITHERROR(MP4BadDataErr) + + if(myItem->construction_method == 0) + { + if(myMeta->dataEntryIndex != myItem->dref_index) { - err = MP4GetListEntryCount( iloc->itemList, &item_total ); if (err) goto bail; - - for ( i = 0; i < item_total; i++ ) + if(myMeta->dataHandler) + { + err = myMeta->closeDataHandler(myMeta); + if(err) goto bail; + } + + err = myMeta->openDataHandler(myMeta, myItem->dref_index); + if(err) goto bail; + } + + dhlr = (MP4DataHandlerPtr)myMeta->dataHandler; + if(dhlr == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + } + else if(myItem->construction_method == 1) + { + idat = (ISOItemDataAtomPtr)myMeta->idat; + if(idat == NULL) BAILWITHERROR(MP4BadDataErr); + } + + err = MP4SetHandleSize(data, 0); + if(err) goto bail; + + *base_offset = myItem->base_offset; + + if(myItem->extentList) + { + u32 list2Size; + u32 datasize, j; + + err = MP4GetListEntryCount(myItem->extentList, &list2Size); + if(err) goto bail; + + datasize = 0; + + for(j = 0; j < list2Size; j++) + { + MetaExtentLocationPtr b; + ISOMetaItem referenceItem; + MP4Handle referenceItemData; + u32 length; + u64 fileSize; + + err = MP4GetListEntry(myItem->extentList, j, (char **)&b); + if(err) goto bail; + + if(b->extent_length == 0) + { + if(myItem->construction_method == 0) + { + err = dhlr->getDataSize(dhlr, &fileSize); + if(err) goto bail; + if(fileSize >> 32) BAILWITHERROR(MP4NoLargeAtomSupportErr); + length = (u32)fileSize; + } + else if(myItem->construction_method == 1) { - char *tmp; - u32 outType; - MetaItemLocationPtr a; - - err = MP4GetListEntry( iloc->itemList, i, (char **) &a ); if (err) goto bail; - err = ISOGetItemInfoItemType((ISOMetaItem) a, &outType, &tmp); if (err) goto bail; - - if (type == outType) - { - *numberOfItemsFound = *numberOfItemsFound + 1; - *items = (ISOMetaItem*)realloc(*items, *numberOfItemsFound * sizeof(ISOMetaItem)); - (*items)[*numberOfItemsFound - 1] = (ISOMetaItem) a; - } + err = MP4GetHandleSize(idat->data, &length); + if(err) goto bail; } + else if(myItem->construction_method == 2) + { + u64 k; + err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), b->extent_index, + &referenceItem); + if(err) goto bail; + err = MP4NewHandle(0, &referenceItemData); + if(err) goto bail; + err = ISOGetItemData(referenceItem, referenceItemData, &k); + if(err) goto bail; + err = MP4GetHandleSize(referenceItemData, &length); + if(err) goto bail; + } + + if(b->extent_offset) BAILWITHERROR(MP4BadDataErr); + } + else + { + if(b->extent_length >> 32) BAILWITHERROR(MP4NoLargeAtomSupportErr); + length = (u32)b->extent_length; + } + + err = MP4SetHandleSize(data, datasize + length); + if(err) goto bail; + + if(myItem->construction_method == 0) + { + err = dhlr->copyData(dhlr, b->extent_offset + *base_offset, (*data) + datasize, length); + if(err) goto bail; + } + else if(myItem->construction_method == 1) + { + err = idat->getData((MP4AtomPtr)idat, (*data) + datasize, b->extent_offset, length); + if(err) goto bail; + } + else if(myItem->construction_method == 2) + { + u64 k; + u32 referenceDataLength; + + err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), b->extent_index, + &referenceItem); + if(err) goto bail; + err = MP4NewHandle(0, &referenceItemData); + if(err) goto bail; + err = ISOGetItemData(referenceItem, referenceItemData, &k); + if(err) goto bail; + err = MP4GetHandleSize(referenceItemData, &referenceDataLength); + if(err) goto bail; + + if((referenceDataLength - b->extent_offset) < length) BAILWITHERROR(MP4BadDataErr); + + memcpy((*data) + datasize, (*referenceItemData) + b->extent_offset, length); + } + if(j == 0) *base_offset -= b->extent_offset; + + datasize += length; } - else - BAILWITHERROR( MP4BadDataErr ); - + } + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -ISO_EXTERN ( ISOErr ) ISOFindItemByName( ISOMeta meta, ISOMetaItem* item, char* name, u8 exact_case ) +ISO_EXTERN(ISOErr) +ISOGetItemInfo(ISOMetaItem item, u16 *protection_index, char *name, char *content_type, + char *content_encoding) { - MP4Err err; - ISOMetaAtomPtr myMeta; - ISOItemInfoAtomPtr iinf; - u32 i, item_total; - - err = MP4NoErr; - myMeta = (ISOMetaAtomPtr) meta; - - if (myMeta == NULL) - BAILWITHERROR( MP4BadParamErr ) - iinf = (ISOItemInfoAtomPtr) myMeta->iinf; - *item = NULL; - - if (iinf == NULL) - BAILWITHERROR( MP4NotFoundErr ) - - if ( iinf->atomList ) - { - err = MP4GetListEntryCount( iinf->atomList, &item_total ); if (err) goto bail; - - for ( i = 0; i < item_total; i++ ) - { - ISOItemInfoEntryAtomPtr infe; - err = MP4GetListEntry( iinf->atomList, i, (char **) &infe ); if (err) goto bail; - - if (( exact_case && (strcmp(name,infe->item_name)==0)) || - (!exact_case && (strcasecmp(name,infe->item_name)==0)) ) - return ISOFindItemByID(meta, item, (u16) infe->item_ID); - } - } else BAILWITHERROR( MP4BadDataErr ) - err = MP4NotFoundErr; + MP4Err err; + ISOMetaAtomPtr myMeta; + ISOItemInfoAtomPtr iinf; + u32 i, item_total; + MetaItemLocationPtr myItem; -bail: - TEST_RETURN( err ); + err = MP4NoErr; + myItem = (MetaItemLocationPtr)item; + if(myItem == NULL) BAILWITHERROR(MP4BadParamErr) - return err; -} + myMeta = (ISOMetaAtomPtr)myItem->meta; + if(myMeta == NULL) BAILWITHERROR(MP4BadDataErr) -ISO_EXTERN ( ISOErr ) ISOGetItemData( ISOMetaItem item, MP4Handle data, u64* base_offset ) -{ - MP4Err err; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - MP4DataHandlerPtr dhlr; - ISOItemDataAtomPtr idat; - - err = MP4NoErr; - myItem = (MetaItemLocationPtr) item; - if (myItem == NULL) - BAILWITHERROR( MP4BadParamErr ) - - myMeta = (ISOMetaAtomPtr) myItem->meta; - if (myMeta == NULL) - BAILWITHERROR( MP4BadDataErr ) - - - if (myItem->construction_method == 0) + iinf = (ISOItemInfoAtomPtr)myMeta->iinf; + + if(iinf == NULL) BAILWITHERROR(MP4NotFoundErr) + + if(iinf->atomList) + { + err = MP4GetListEntryCount(iinf->atomList, &item_total); + if(err) goto bail; + + for(i = 0; i < item_total; i++) { - if (myMeta->dataEntryIndex != myItem->dref_index) + ISOItemInfoEntryAtomPtr infe; + err = MP4GetListEntry(iinf->atomList, i, (char **)&infe); + if(err) goto bail; + if(infe->item_ID == myItem->item_ID) + { + u32 sz; + if(name && infe->item_name) { - if ( myMeta->dataHandler ) - { - err = myMeta->closeDataHandler( myMeta ); if (err) goto bail; - } - - err = myMeta->openDataHandler( myMeta, myItem->dref_index ); if (err) goto bail; + sz = strlen(infe->item_name); + memcpy(name, infe->item_name, sz + 1); } - - dhlr = (MP4DataHandlerPtr) myMeta->dataHandler; - if ( dhlr == NULL ) + else if(name) + name[0] = 0; + + if(content_encoding && infe->content_encoding) { - BAILWITHERROR( MP4InvalidMediaErr ); + sz = strlen(infe->content_encoding); + memcpy(content_encoding, infe->content_encoding, sz + 1); } + else if(content_encoding) + content_encoding[0] = 0; + + if(content_type && infe->content_type) + { + sz = strlen(infe->content_type); + memcpy(content_type, infe->content_type, sz + 1); + } + else if(content_type) + name[0] = 0; + + if(protection_index) *protection_index = infe->protection_index; + err = MP4NoErr; + goto bail; + } } - else if (myItem->construction_method == 1) - { - idat = (ISOItemDataAtomPtr) myMeta->idat; - if (idat == NULL) - BAILWITHERROR(MP4BadDataErr); - } - - - err = MP4SetHandleSize( data, 0 ); if (err) goto bail; - - *base_offset = myItem->base_offset; - - if ( myItem->extentList ) - { - u32 list2Size; - u32 datasize, j; - - err = MP4GetListEntryCount( myItem->extentList, &list2Size ); if (err) goto bail; - - datasize = 0; - - for ( j = 0; j < list2Size; j++ ) - { - MetaExtentLocationPtr b; - ISOMetaItem referenceItem; - MP4Handle referenceItemData; - u32 length; - u64 fileSize; - - err = MP4GetListEntry( myItem->extentList, j, (char **) &b ); if (err) goto bail; - - - if (b->extent_length == 0) - { - if (myItem->construction_method == 0) - { - err = dhlr->getDataSize( dhlr, &fileSize ); if (err) goto bail; - if (fileSize >> 32) BAILWITHERROR( MP4NoLargeAtomSupportErr ); - length = (u32) fileSize; - } - else if (myItem->construction_method == 1) - { - err = MP4GetHandleSize(idat->data, &length); if (err) goto bail; - } - else if (myItem->construction_method == 2) - { - u64 k; - err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), b->extent_index, &referenceItem); if (err) goto bail; - err = MP4NewHandle(0, &referenceItemData); if (err) goto bail; - err = ISOGetItemData( referenceItem, referenceItemData, &k ); if (err) goto bail; - err = MP4GetHandleSize(referenceItemData, &length); if (err) goto bail; - } - - if (b->extent_offset) - BAILWITHERROR( MP4BadDataErr ); - } - else - { - if (b->extent_length >> 32) BAILWITHERROR( MP4NoLargeAtomSupportErr ); - length = (u32) b->extent_length; - } - - err = MP4SetHandleSize( data, datasize+length ); if (err) goto bail; - - if (myItem->construction_method == 0) - { - err = dhlr->copyData( dhlr, b->extent_offset + *base_offset, (*data)+datasize, length ); if (err) goto bail; - } - else if (myItem->construction_method == 1) - { - err = idat->getData((MP4AtomPtr) idat, (*data)+datasize, b->extent_offset, length); if (err) goto bail; - } - else if (myItem->construction_method == 2) - { - u64 k; - u32 referenceDataLength; - - err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), b->extent_index, &referenceItem); if (err) goto bail; - err = MP4NewHandle(0, &referenceItemData); if (err) goto bail; - err = ISOGetItemData( referenceItem, referenceItemData, &k ); if (err) goto bail; - err = MP4GetHandleSize(referenceItemData, &referenceDataLength); if (err) goto bail; - - if ((referenceDataLength - b->extent_offset) < length) - BAILWITHERROR(MP4BadDataErr); - - memcpy((*data)+datasize, (*referenceItemData) + b->extent_offset, length); - } - if (j == 0) - *base_offset -= b->extent_offset; - - datasize += length; - } - } - + } + else + BAILWITHERROR(MP4BadDataErr) + err = MP4NotFoundErr; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISO_EXTERN ( ISOErr ) ISOGetItemInfo( ISOMetaItem item, u16* protection_index, char* name, char* content_type, char* content_encoding ) +ISO_EXTERN(MP4Err) +ISOCheckMetaDataReferences(ISOMeta meta) { - MP4Err err; - ISOMetaAtomPtr myMeta; - ISOItemInfoAtomPtr iinf; - u32 i, item_total; - MetaItemLocationPtr myItem; - - err = MP4NoErr; - myItem = (MetaItemLocationPtr) item; - if (myItem == NULL) - BAILWITHERROR( MP4BadParamErr ) - - myMeta = (ISOMetaAtomPtr) myItem->meta; - if (myMeta == NULL) - BAILWITHERROR( MP4BadDataErr ) - - iinf = (ISOItemInfoAtomPtr) myMeta->iinf; - - if (iinf == NULL) - BAILWITHERROR( MP4NotFoundErr ) - - if ( iinf->atomList ) - { - err = MP4GetListEntryCount( iinf->atomList, &item_total ); if (err) goto bail; - - for ( i = 0; i < item_total; i++ ) - { - ISOItemInfoEntryAtomPtr infe; - err = MP4GetListEntry( iinf->atomList, i, (char **) &infe ); if (err) goto bail; - if (infe->item_ID == myItem->item_ID) { - u32 sz; - if (name && infe->item_name) { - sz = strlen( infe->item_name ); - memcpy( name, infe->item_name, sz+1 ); - } else if (name) name[0] = 0; - - if (content_encoding && infe->content_encoding) { - sz = strlen( infe->content_encoding ); - memcpy( content_encoding, infe->content_encoding, sz+1 ); - } else if (content_encoding) content_encoding[0] = 0; - - if (content_type && infe->content_type) { - sz = strlen( infe->content_type ); - memcpy( content_type, infe->content_type, sz+1 ); - } else if (content_type) name[0] = 0; - - if (protection_index) *protection_index = infe->protection_index; - err = MP4NoErr; - goto bail; - } - } - } else BAILWITHERROR( MP4BadDataErr ) - err = MP4NotFoundErr; - + MP4Err err; + ISOMetaAtomPtr myMeta; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + MP4DataEntryAtomPtr dataEntryAtom; + u32 count, dataEntryIndex; + + err = MP4NoErr; + myMeta = (ISOMetaAtomPtr)meta; + + dinf = (MP4DataInformationAtomPtr)myMeta->dinf; + if(!dinf) goto bail; + + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + + count = dref->getEntryCount(dref); + for(dataEntryIndex = 1; dataEntryIndex <= count; dataEntryIndex++) + { + err = dref->getEntry(dref, dataEntryIndex, &dataEntryAtom); + if(err) goto bail; + if(dataEntryAtom == NULL) BAILWITHERROR(MP4InvalidMediaErr) + err = MP4PreflightDataHandler(myMeta->inputStream, dataEntryAtom); + if(err) goto bail; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISO_EXTERN ( MP4Err ) -ISOCheckMetaDataReferences( ISOMeta meta ) +ISO_EXTERN(MP4Err) +ISONewMetaProtection(ISOMeta meta, u32 sch_type, u32 sch_version, char *sch_url, + u16 *protection_index) { - MP4Err err; - ISOMetaAtomPtr myMeta; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - MP4DataEntryAtomPtr dataEntryAtom; - u32 count, dataEntryIndex; - - err = MP4NoErr; - myMeta = (ISOMetaAtomPtr) meta; - - dinf = (MP4DataInformationAtomPtr) myMeta->dinf; - if (!dinf) goto bail; - - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - - count = dref->getEntryCount( dref ); - for ( dataEntryIndex = 1; dataEntryIndex <= count; dataEntryIndex++ ) - { - err = dref->getEntry( dref, dataEntryIndex, &dataEntryAtom ); if (err) goto bail; - if ( dataEntryAtom == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - err = MP4PreflightDataHandler( myMeta->inputStream, dataEntryAtom ); if (err) goto bail; - } - + MP4Err err; + + ISOMetaAtomPtr myMeta; + MP4SecurityInfoAtomPtr sinf; + MP4SchemeTypeAtomPtr schm; + MP4SchemeInfoAtomPtr schi; + ISOItemProtectionAtomPtr ipro; + u32 j; + + char *sch_url_copy = NULL; + + err = MP4NoErr; + myMeta = (ISOMetaAtomPtr)meta; + + err = MP4CreateSchemeInfoAtom(&schi); + if(err) goto bail; + + err = MP4CreateSchemeTypeAtom(&schm); + if(err) goto bail; + schm->scheme_type = sch_type; + schm->scheme_version = sch_version; + + if(sch_url) + { + sch_url_copy = (char *)calloc(1, strlen(sch_url) + 1); + TESTMALLOC(sch_url_copy); + memcpy(sch_url_copy, sch_url, strlen(sch_url) + 1); + schm->scheme_url = sch_url_copy; + sch_url_copy = NULL; + } + else + schm->scheme_url = NULL; + + err = MP4CreateSecurityInfoAtom(&sinf); + if(err) goto bail; + sinf->MP4SchemeType = (MP4AtomPtr)schm; + schm = NULL; + sinf->MP4SchemeInfo = (MP4AtomPtr)schi; + schi = NULL; + + ipro = (ISOItemProtectionAtomPtr)myMeta->ipro; + if(!ipro) + { + err = ISOCreateItemProtectionAtom(&ipro); + if(err) goto bail; + err = myMeta->addAtom(myMeta, (MP4AtomPtr)ipro); + if(err) goto bail; + } + err = MP4GetListEntryCount(ipro->atomList, &j); + if(err) goto bail; + *protection_index = j + 1; + + err = ipro->addAtom(ipro, (MP4AtomPtr)sinf); + if(err) goto bail; + bail: - TEST_RETURN( err ); + if(schm) schm->destroy((MP4AtomPtr)schm); + if(schi) schi->destroy((MP4AtomPtr)schi); + if(sch_url_copy) free(sch_url_copy); - return err; + TEST_RETURN(err); + + return err; } -ISO_EXTERN ( MP4Err ) -ISONewMetaProtection( ISOMeta meta, u32 sch_type, u32 sch_version, char* sch_url, u16* protection_index ) +ISO_EXTERN(MP4Err) +ISOAddMetaProtectionInfo(ISOMeta meta, u16 protection_index, MP4GenericAtom schi_atom) { - MP4Err err; - - ISOMetaAtomPtr myMeta; - MP4SecurityInfoAtomPtr sinf; - MP4SchemeTypeAtomPtr schm; - MP4SchemeInfoAtomPtr schi; - ISOItemProtectionAtomPtr ipro; - u32 j; - - char* sch_url_copy = NULL; - - err = MP4NoErr; - myMeta = (ISOMetaAtomPtr) meta; - - err = MP4CreateSchemeInfoAtom( &schi ); if (err) goto bail; - - err = MP4CreateSchemeTypeAtom( &schm ); if (err) goto bail; - schm->scheme_type = sch_type; - schm->scheme_version = sch_version; - - if (sch_url) { - sch_url_copy = (char*) calloc( 1, strlen(sch_url)+1 ); - TESTMALLOC( sch_url_copy ); - memcpy( sch_url_copy, sch_url, strlen(sch_url)+1 ); - schm->scheme_url = sch_url_copy; sch_url_copy = NULL; - } - else schm->scheme_url = NULL; - - err = MP4CreateSecurityInfoAtom( &sinf ); if (err) goto bail; - sinf->MP4SchemeType = (MP4AtomPtr) schm; schm = NULL; - sinf->MP4SchemeInfo = (MP4AtomPtr) schi; schi = NULL; - - ipro = (ISOItemProtectionAtomPtr) myMeta->ipro; - if (!ipro) { - err = ISOCreateItemProtectionAtom( &ipro ); if (err) goto bail; - err = myMeta->addAtom( myMeta, (MP4AtomPtr) ipro ); if (err) goto bail; - } - err = MP4GetListEntryCount( ipro->atomList, &j ); if (err) goto bail; - *protection_index = j+1; - - err = ipro->addAtom( ipro, (MP4AtomPtr) sinf ); if (err) goto bail; - + MP4Err err; + + ISOMetaAtomPtr myMeta; + MP4SecurityInfoAtomPtr sinf; + MP4SchemeInfoAtomPtr schi; + ISOItemProtectionAtomPtr ipro; + + err = MP4NoErr; + myMeta = (ISOMetaAtomPtr)meta; + ipro = (ISOItemProtectionAtomPtr)myMeta->ipro; + if(!ipro) BAILWITHERROR(MP4BadParamErr); + + err = MP4GetListEntry(ipro->atomList, protection_index - 1, (char **)&sinf); + if(err) goto bail; + schi = (MP4SchemeInfoAtomPtr)sinf->MP4SchemeInfo; + if(!schi) BAILWITHERROR(MP4BadParamErr); + err = schi->addAtom(schi, (MP4AtomPtr)schi_atom); + if(err) goto bail; + bail: - if (schm) schm->destroy( (MP4AtomPtr) schm ); - if (schi) schi->destroy( (MP4AtomPtr) schi ); - if (sch_url_copy) free( sch_url_copy ); - - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISO_EXTERN ( MP4Err ) -ISOAddMetaProtectionInfo( ISOMeta meta, u16 protection_index, MP4GenericAtom schi_atom ) +ISO_EXTERN(MP4Err) +ISOGetMetaProtection(ISOMeta meta, u16 protection_index, u32 *sch_type, u32 *sch_version, + char *sch_url) { - MP4Err err; - - ISOMetaAtomPtr myMeta; - MP4SecurityInfoAtomPtr sinf; - MP4SchemeInfoAtomPtr schi; - ISOItemProtectionAtomPtr ipro; - - err = MP4NoErr; - myMeta = (ISOMetaAtomPtr) meta; - ipro = (ISOItemProtectionAtomPtr) myMeta->ipro; - if (!ipro) BAILWITHERROR( MP4BadParamErr ); - - err = MP4GetListEntry( ipro->atomList, protection_index-1, (char **) &sinf ); if (err) goto bail; - schi = (MP4SchemeInfoAtomPtr) sinf->MP4SchemeInfo; - if (!schi) BAILWITHERROR( MP4BadParamErr ); - err = schi->addAtom( schi, (MP4AtomPtr) schi_atom ); if (err) goto bail; - + MP4Err err; + + ISOMetaAtomPtr myMeta; + MP4SecurityInfoAtomPtr sinf; + MP4SchemeTypeAtomPtr schm; + ISOItemProtectionAtomPtr ipro; + + err = MP4NoErr; + myMeta = (ISOMetaAtomPtr)meta; + + ipro = (ISOItemProtectionAtomPtr)myMeta->ipro; + if(!ipro) BAILWITHERROR(MP4BadParamErr); + err = MP4GetListEntry(ipro->atomList, protection_index - 1, (char **)&sinf); + if(err) goto bail; + + schm = (MP4SchemeTypeAtomPtr)sinf->MP4SchemeType; + + *sch_type = schm->scheme_type; + *sch_version = schm->scheme_version; + + if(sch_url && schm->scheme_url) + { + memcpy(sch_url, schm->scheme_url, strlen(schm->scheme_url) + 1); + } + bail: - TEST_RETURN( err ); - - return err; -} + TEST_RETURN(err); -ISO_EXTERN ( MP4Err ) -ISOGetMetaProtection( ISOMeta meta, u16 protection_index, u32* sch_type, u32* sch_version, char* sch_url ) -{ - MP4Err err; - - ISOMetaAtomPtr myMeta; - MP4SecurityInfoAtomPtr sinf; - MP4SchemeTypeAtomPtr schm; - ISOItemProtectionAtomPtr ipro; - - err = MP4NoErr; - myMeta = (ISOMetaAtomPtr) meta; - - ipro = (ISOItemProtectionAtomPtr) myMeta->ipro; - if (!ipro) BAILWITHERROR( MP4BadParamErr); - err = MP4GetListEntry( ipro->atomList, protection_index-1, (char **) &sinf ); if (err) goto bail; - - schm = (MP4SchemeTypeAtomPtr) sinf->MP4SchemeType; - - *sch_type = schm->scheme_type; - *sch_version = schm->scheme_version; - - if (sch_url && schm->scheme_url) { - memcpy( sch_url, schm->scheme_url, strlen(schm->scheme_url)+1 ); - } - -bail: - TEST_RETURN( err ); - - return err; + return err; } -ISO_EXTERN ( MP4Err ) -ISOGetMetaProtectionInfo( ISOMeta meta, u16 protection_index, u32 atom_type, MP4GenericAtom* schi_atom ) +ISO_EXTERN(MP4Err) +ISOGetMetaProtectionInfo(ISOMeta meta, u16 protection_index, u32 atom_type, + MP4GenericAtom *schi_atom) { - MP4Err err; - - ISOMetaAtomPtr myMeta; - MP4SecurityInfoAtomPtr sinf; - MP4SchemeInfoAtomPtr schi; - ISOItemProtectionAtomPtr ipro; - u32 item_total, i; - - err = MP4NoErr; - *schi_atom = NULL; - myMeta = (ISOMetaAtomPtr) meta; - ipro = (ISOItemProtectionAtomPtr) myMeta->ipro; - if (!ipro) BAILWITHERROR( MP4BadParamErr ); - - err = MP4GetListEntry( ipro->atomList, protection_index-1, (char **) &sinf ); if (err) goto bail; - schi = (MP4SchemeInfoAtomPtr) sinf->MP4SchemeInfo; - if (!schi) BAILWITHERROR( MP4BadParamErr ); - - if ( schi->atomList ) - { - err = MP4GetListEntryCount( schi->atomList, &item_total ); if (err) goto bail; - - for ( i = 0; i < item_total; i++ ) - { - MP4AtomPtr a; - err = MP4GetListEntry( schi->atomList, i, (char **) &a ); if (err) goto bail; - - if (a->type == atom_type) { - *schi_atom = (MP4GenericAtom) a; - err = MP4NoErr; - goto bail; - } - } - } else BAILWITHERROR( MP4BadDataErr ) - err = MP4NotFoundErr; - + MP4Err err; + + ISOMetaAtomPtr myMeta; + MP4SecurityInfoAtomPtr sinf; + MP4SchemeInfoAtomPtr schi; + ISOItemProtectionAtomPtr ipro; + u32 item_total, i; + + err = MP4NoErr; + *schi_atom = NULL; + myMeta = (ISOMetaAtomPtr)meta; + ipro = (ISOItemProtectionAtomPtr)myMeta->ipro; + if(!ipro) BAILWITHERROR(MP4BadParamErr); + + err = MP4GetListEntry(ipro->atomList, protection_index - 1, (char **)&sinf); + if(err) goto bail; + schi = (MP4SchemeInfoAtomPtr)sinf->MP4SchemeInfo; + if(!schi) BAILWITHERROR(MP4BadParamErr); + + if(schi->atomList) + { + err = MP4GetListEntryCount(schi->atomList, &item_total); + if(err) goto bail; + + for(i = 0; i < item_total; i++) + { + MP4AtomPtr a; + err = MP4GetListEntry(schi->atomList, i, (char **)&a); + if(err) goto bail; + + if(a->type == atom_type) + { + *schi_atom = (MP4GenericAtom)a; + err = MP4NoErr; + goto bail; + } + } + } + else + BAILWITHERROR(MP4BadDataErr) + err = MP4NotFoundErr; + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } ISO_EXTERN(MP4Err) -ISOAddMetaItemProperty(ISOMetaItem item, MP4GenericAtom* itemProperty, u8 essential) +ISOAddMetaItemProperty(ISOMetaItem item, MP4GenericAtom *itemProperty, u8 essential) { - MP4Err err; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - MP4ItemPropertiesAtomPtr iprp; - u16 itemId; - err = MP4NoErr; - - myItem = (MetaItemLocationPtr) item; - if (myItem == NULL) - BAILWITHERROR(MP4BadParamErr) - - myMeta = (ISOMetaAtomPtr) myItem->meta; - if (myMeta == NULL) - BAILWITHERROR(MP4BadDataErr) - - if (myMeta->iprp == NULL) - { - err = MP4CreateItemPropertiesAtom(&myMeta->iprp); if (err) goto bail; - err = MP4AddListEntry(myMeta->iprp, myMeta->atomList); if (err) goto bail; - } - - iprp = (MP4ItemPropertiesAtomPtr) myMeta->iprp; - - err = ISOGetItemID(item, &itemId); - err = iprp->addItemProperty(iprp, (MP4AtomPtr) itemProperty, itemId, essential); if (err) goto bail; - + MP4Err err; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + MP4ItemPropertiesAtomPtr iprp; + u16 itemId; + err = MP4NoErr; + + myItem = (MetaItemLocationPtr)item; + if(myItem == NULL) BAILWITHERROR(MP4BadParamErr) + + myMeta = (ISOMetaAtomPtr)myItem->meta; + if(myMeta == NULL) BAILWITHERROR(MP4BadDataErr) + + if(myMeta->iprp == NULL) + { + err = MP4CreateItemPropertiesAtom(&myMeta->iprp); + if(err) goto bail; + err = MP4AddListEntry(myMeta->iprp, myMeta->atomList); + if(err) goto bail; + } + + iprp = (MP4ItemPropertiesAtomPtr)myMeta->iprp; + + err = ISOGetItemID(item, &itemId); + err = iprp->addItemProperty(iprp, (MP4AtomPtr)itemProperty, itemId, essential); + if(err) goto bail; + bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } ISO_EXTERN(MP4Err) -ISOGetProperitesOfMetaItem(ISOMetaItem item, MP4GenericAtom** properties, u32 *propertiesFound) +ISOGetProperitesOfMetaItem(ISOMetaItem item, MP4GenericAtom **properties, u32 *propertiesFound) { - MP4Err err; - ISOMetaAtomPtr myMeta; - MetaItemLocationPtr myItem; - MP4ItemPropertiesAtomPtr iprp; - u16 itemId; - MP4LinkedList properitiesList; - u32 listSize; - u32 i; - MP4GenericAtom property; - MP4GenericAtom *outProperties; - err = MP4NoErr; - - myItem = (MetaItemLocationPtr)item; - if (myItem == NULL) - BAILWITHERROR(MP4BadParamErr) - - myMeta = (ISOMetaAtomPtr)myItem->meta; - if (myMeta == NULL) - BAILWITHERROR(MP4BadDataErr) - - if (myMeta->iprp == NULL) - { - err = MP4CreateItemPropertiesAtom(&myMeta->iprp); if (err) goto bail; - err = MP4AddListEntry(myMeta->iprp, myMeta->atomList); if (err) goto bail; - } - - iprp = (MP4ItemPropertiesAtomPtr)myMeta->iprp; - - err = ISOGetItemID(item, &itemId); if (err) goto bail; - err = iprp->getPropertiesOfItem(iprp, itemId, &properitiesList); if (err) goto bail; - - err = MP4GetListEntryCount(properitiesList, &listSize); if (err) goto bail; - - *propertiesFound = listSize; - outProperties = (MP4GenericAtom*)malloc(listSize * sizeof(MP4GenericAtom)); - - - for (i = 0; i < listSize; i++) - { - err = MP4GetListEntry(properitiesList, i, (char **)&property); if (err) goto bail; - outProperties[i] = (MP4GenericAtom) property; - } - - *properties = outProperties; + MP4Err err; + ISOMetaAtomPtr myMeta; + MetaItemLocationPtr myItem; + MP4ItemPropertiesAtomPtr iprp; + u16 itemId; + MP4LinkedList properitiesList; + u32 listSize; + u32 i; + MP4GenericAtom property; + MP4GenericAtom *outProperties; + err = MP4NoErr; + + myItem = (MetaItemLocationPtr)item; + if(myItem == NULL) BAILWITHERROR(MP4BadParamErr) + + myMeta = (ISOMetaAtomPtr)myItem->meta; + if(myMeta == NULL) BAILWITHERROR(MP4BadDataErr) + + if(myMeta->iprp == NULL) + { + err = MP4CreateItemPropertiesAtom(&myMeta->iprp); + if(err) goto bail; + err = MP4AddListEntry(myMeta->iprp, myMeta->atomList); + if(err) goto bail; + } + + iprp = (MP4ItemPropertiesAtomPtr)myMeta->iprp; + + err = ISOGetItemID(item, &itemId); + if(err) goto bail; + err = iprp->getPropertiesOfItem(iprp, itemId, &properitiesList); + if(err) goto bail; + + err = MP4GetListEntryCount(properitiesList, &listSize); + if(err) goto bail; + + *propertiesFound = listSize; + outProperties = (MP4GenericAtom *)malloc(listSize * sizeof(MP4GenericAtom)); + + for(i = 0; i < listSize; i++) + { + err = MP4GetListEntry(properitiesList, i, (char **)&property); + if(err) goto bail; + outProperties[i] = (MP4GenericAtom)property; + } + + *properties = outProperties; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ISOMovies.h b/IsoLib/libisomediafile/src/ISOMovies.h index 2770d74..63baa5f 100644 --- a/IsoLib/libisomediafile/src/ISOMovies.h +++ b/IsoLib/libisomediafile/src/ISOMovies.h @@ -1,7 +1,7 @@ /* - ISOMovies.h: A wrapper for the code defined in the MPEG-4 library. - - This header file may be freely copied and distributed. + ISOMovies.h: A wrapper for the code defined in the MPEG-4 library. + + This header file may be freely copied and distributed. */ #ifndef INCLUDED_ISOMOVIE_H @@ -12,482 +12,478 @@ #endif #ifdef __cplusplus -extern "C" { +extern "C" +{ #endif /* These data types are common to both MPEG-4 and JPEG-2; ideally the "ISO" names should be used. */ -#define ISOHandle MP4Handle -#define ISOErr MP4Err -#define ISOMovie MP4Movie -#define ISOTrack MP4Track -#define ISOMedia MP4Media -#define ISOTrackReader MP4TrackReader -#define ISOUserData MP4UserData -#define ISOAtomPtr MP4AtomPtr -#define ISOLinkedList MP4LinkedList - -#define ISO_EXTERN MP4_EXTERN +#define ISOHandle MP4Handle +#define ISOErr MP4Err +#define ISOMovie MP4Movie +#define ISOTrack MP4Track +#define ISOMedia MP4Media +#define ISOTrackReader MP4TrackReader +#define ISOUserData MP4UserData +#define ISOAtomPtr MP4AtomPtr +#define ISOLinkedList MP4LinkedList + +#define ISO_EXTERN MP4_EXTERN /* These constants are common to both MPEG-4 and JPEG-2; ideally the "ISO" names should be used. */ -#define ISOEOF MP4EOF -#define ISONoErr MP4NoErr -#define ISOFileNotFoundErr MP4FileNotFoundErr -#define ISOBadParamErr MP4BadParamErr -#define ISONoMemoryErr MP4NoMemoryErr -#define ISOIOErr MP4IOErr -#define ISONoLargeAtomSupportErr MP4NoLargeAtomSupportErr -#define ISOBadDataErr MP4BadDataErr -#define ISOVersionNotSupportedErr MP4VersionNotSupportedErr -#define ISOInvalidMediaErr MP4InvalidMediaErr -#define ISODataEntryTypeNotSupportedErr MP4DataEntryTypeNotSupportedErr -#define ISONoQTAtomErr MP4NoQTAtomErr -#define ISONotImplementedErr MP4NotImplementedErr - -#define ISONewTrackIsVisual MP4NewTrackIsVisual -#define ISONewTrackIsAudio MP4NewTrackIsAudio -#define ISONewTrackIsPrivate MP4NewTrackIsPrivate -#define ISONewTrackIsMetadata MP4NewTrackIsMetadata - -#define ISOVisualHandlerType MP4VisualHandlerType -#define ISOAudioHandlerType MP4AudioHandlerType -#define ISOHintHandlerType MP4HintHandlerType - -#define ISOOpenMovieNormal MP4OpenMovieNormal -#define ISOOpenMovieDebug MP4OpenMovieDebug -#define ISOOpenMovieInPlace MP4OpenMovieInPlace - - -/* constants for the graphics modes (e.g. for MJ2SetMediaGraphicsMode) */ -enum -{ - ISOGraphicsModeSrcCopy = 0x00000000, - ISOGraphicsModeTransparent = 0x00000024, - ISOGraphicsModeAlpha = 0x00000100, - ISOGraphicsModeWhiteAlpha = 0x00000101, - ISOGraphicsModeBlackAlpha = 0x00000102 -}; - -/* These data types are specific to JPEG-2; however, they have "ISO" names. */ -struct ISOMatrixRecord -{ - u32 data[9]; -}; -typedef struct ISOMatrixRecord ISOMatrixRecord; -typedef ISOMatrixRecord* ISOMatrix; - -struct ISORGBColor -{ - u16 red; - u16 green; - u16 blue; -}; -typedef struct ISORGBColor ISORGBColor; -typedef ISORGBColor* ISORGBColorPtr; +#define ISOEOF MP4EOF +#define ISONoErr MP4NoErr +#define ISOFileNotFoundErr MP4FileNotFoundErr +#define ISOBadParamErr MP4BadParamErr +#define ISONoMemoryErr MP4NoMemoryErr +#define ISOIOErr MP4IOErr +#define ISONoLargeAtomSupportErr MP4NoLargeAtomSupportErr +#define ISOBadDataErr MP4BadDataErr +#define ISOVersionNotSupportedErr MP4VersionNotSupportedErr +#define ISOInvalidMediaErr MP4InvalidMediaErr +#define ISODataEntryTypeNotSupportedErr MP4DataEntryTypeNotSupportedErr +#define ISONoQTAtomErr MP4NoQTAtomErr +#define ISONotImplementedErr MP4NotImplementedErr + +#define ISONewTrackIsVisual MP4NewTrackIsVisual +#define ISONewTrackIsAudio MP4NewTrackIsAudio +#define ISONewTrackIsPrivate MP4NewTrackIsPrivate +#define ISONewTrackIsMetadata MP4NewTrackIsMetadata + +#define ISOVisualHandlerType MP4VisualHandlerType +#define ISOAudioHandlerType MP4AudioHandlerType +#define ISOHintHandlerType MP4HintHandlerType + +#define ISOOpenMovieNormal MP4OpenMovieNormal +#define ISOOpenMovieDebug MP4OpenMovieDebug +#define ISOOpenMovieInPlace MP4OpenMovieInPlace + + /* constants for the graphics modes (e.g. for MJ2SetMediaGraphicsMode) */ + enum + { + ISOGraphicsModeSrcCopy = 0x00000000, + ISOGraphicsModeTransparent = 0x00000024, + ISOGraphicsModeAlpha = 0x00000100, + ISOGraphicsModeWhiteAlpha = 0x00000101, + ISOGraphicsModeBlackAlpha = 0x00000102 + }; + + /* These data types are specific to JPEG-2; however, they have "ISO" names. */ + struct ISOMatrixRecord + { + u32 data[9]; + }; + typedef struct ISOMatrixRecord ISOMatrixRecord; + typedef ISOMatrixRecord *ISOMatrix; + + struct ISORGBColor + { + u16 red; + u16 green; + u16 blue; + }; + typedef struct ISORGBColor ISORGBColor; + typedef ISORGBColor *ISORGBColorPtr; + + /* constants for the fileType field of the MP4PrivateMovieRecord structure */ + enum + { + ISOUnknownFileType = (u32)0, + ISOMPEG4FileType = (u32)1, + ISOStillJPEG2000FileType = (u32)2, + ISOMotionJPEG2000FileType = (u32)3, + ISOQuickTimeFileType = (u32)4, + ISO3GPPFileType = (u32)5, + ISOMPEG21FileType = (u32)6 + }; + + /* constants for the qt_componentType field of the MP4HandlerAtom structure */ + enum + { + ISOMediaHandlerType = MP4_FOUR_CHAR_CODE('m', 'h', 'l', 'r'), + ISODataHandlerType = MP4_FOUR_CHAR_CODE('d', 'h', 'l', 'r') + }; + + /* Brands */ + + enum + { + JP2JPEG2000Brand = MP4_FOUR_CHAR_CODE('j', 'p', '2', ' '), /* brand for JPEG-2000 */ + MJ2JPEG2000Brand = MP4_FOUR_CHAR_CODE('m', 'j', 'p', '2'), /* brand for Motion JPEG-2000 */ + ISOQuickTimeBrand = MP4_FOUR_CHAR_CODE('q', 't', ' ', ' '), /* brand for QuickTime */ + ISOMpeg4V1Brand = MP4_FOUR_CHAR_CODE('m', 'p', '4', '1'), /* brand for MPEG-4 version 1 */ + ISOMpeg4V2Brand = MP4_FOUR_CHAR_CODE('m', 'p', '4', '2'), /* brand for MPEG-4 version 2 */ + ISOISOBrand = MP4_FOUR_CHAR_CODE('i', 's', 'o', 'm'), /* conforming brand for all files */ + ISOISO2Brand = MP4_FOUR_CHAR_CODE('i', 's', 'o', '2'), /* conforming brand for all files */ + ISO3GP4Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '4'), /* 3GPP Release 4 */ + ISO3GP5Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '5'), /* 3GPP Release 5 */ + ISO3GP6Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '6'), /* 3GPP Release 6 */ + ISOMPEG21Brand = MP4_FOUR_CHAR_CODE('m', 'p', '2', '1'), /* MPEG-21 */ + ISOUnknownBrand = MP4_FOUR_CHAR_CODE(' ', ' ', ' ', ' '), /* default 'brand' */ + /* DASH-related brands (ISO/IEC 23009-1) */ + ISO_DASH_Brand = MP4_FOUR_CHAR_CODE('d', 'a', 's', 'h'), + ISO_DASH_DSMS_Brand = + MP4_FOUR_CHAR_CODE('d', 's', 'm', 's'), /* self-initializing media segment */ + ISO_DASH_MSDH_Brand = MP4_FOUR_CHAR_CODE('m', 's', 'd', 'h'), /* general format media segment */ + ISO_DASH_MSIX_Brand = MP4_FOUR_CHAR_CODE('m', 's', 'd', 'h'), /* indexed media segment */ + ISO_DASH_RISX_Brand = MP4_FOUR_CHAR_CODE( + 'r', 'i', 's', 'x'), /* representation index segment for MPEG-2 TS media segments */ + ISO_DASH_LMSG_Brand = + MP4_FOUR_CHAR_CODE('l', 'm', 's', 'g'), /* last media segment indicator (ISO BMFF) */ + ISO_DASH_SISX_Brand = + MP4_FOUR_CHAR_CODE('s', 'i', 's', 'x'), /* single index segment (MPEG-2 TS) */ + ISO_DASH_SSSS_Brand = + MP4_FOUR_CHAR_CODE('s', 's', 's', 's') /* subsegment index segment (MPEG-2 TS) */ + }; + + /* AVC/SVC PS places */ + + enum + { + AVCsps = 1, + AVCpps = 2, + AVCspsext = 3, + + SVCsps = 0x11, + SVCpps = 0x12, + SVCspsext = 0x13 + }; + + /* Meta-data records */ + + struct ISOMetaRecord + { + void *data; + }; + typedef struct ISOMetaRecord ISOMetaRecord; + typedef ISOMetaRecord *ISOMeta; + + struct ISOMetaItemRecord + { + void *data; + }; + typedef struct ISOMetaItemRecord ISOMetaItemRecord; + typedef ISOMetaItemRecord *ISOMetaItem; -/* constants for the fileType field of the MP4PrivateMovieRecord structure */ -enum -{ - ISOUnknownFileType = (u32)0, - ISOMPEG4FileType = (u32)1, - ISOStillJPEG2000FileType = (u32)2, - ISOMotionJPEG2000FileType = (u32)3, - ISOQuickTimeFileType = (u32)4, - ISO3GPPFileType = (u32)5, - ISOMPEG21FileType = (u32)6 -}; - -/* constants for the qt_componentType field of the MP4HandlerAtom structure */ -enum -{ - ISOMediaHandlerType = MP4_FOUR_CHAR_CODE( 'm', 'h', 'l', 'r' ), - ISODataHandlerType = MP4_FOUR_CHAR_CODE( 'd', 'h', 'l', 'r' ) -}; +/* These functions are general movie-handling functions and are common to both MPEG-4 and JPEG-2; + ideally the "ISO" names should be used. */ +#define ISODisposeMovie MP4DisposeMovie +#define ISOGetMovieTimeScale MP4GetMovieTimeScale +#define ISOGetMovieTrack MP4GetMovieTrack +#define ISOOpenMovieFile MP4OpenMovieFile +#define ISOPutMovieIntoHandle MP4PutMovieIntoHandle +#define ISOSetMovieTimeScale MP4SetMovieTimeScale +#define ISOAddTrackReference MP4AddTrackReference +#define ISOAddTrackReferenceWithID MP4AddTrackReferenceWithID +#define ISOGetMovieIndTrack MP4GetMovieIndTrack +#define ISOGetMovieTrackCount MP4GetMovieTrackCount +#define ISOGetTrackEnabled MP4GetTrackEnabled +#define ISOGetTrackID MP4GetTrackID +#define ISOGetTrackMedia MP4GetTrackMedia +#define ISOGetTrackMovie MP4GetTrackMovie +#define ISOGetTrackOffset MP4GetTrackOffset +#define ISOGetTrackReference MP4GetTrackReference +#define ISOGetTrackReferenceCount MP4GetTrackReferenceCount +#define ISOInsertMediaIntoTrack MP4InsertMediaIntoTrack +#define ISONewMovieTrack MP4NewMovieTrack +#define ISONewMovieTrackWithID MP4NewMovieTrackWithID +#define ISONewTrackMedia MP4NewTrackMedia +#define ISOSetTrackEnabled MP4SetTrackEnabled +#define ISOSetTrackOffset MP4SetTrackOffset +#define ISOTrackTimeToMediaTime MP4TrackTimeToMediaTime +#define ISOAddMediaDataReference MP4AddMediaDataReference +#define ISOAddMediaSampleReference MP4AddMediaSampleReference +#define ISOAddMediaSamples MP4AddMediaSamples +#define ISOAddMediaSamplesPad MP4AddMediaSamplesPad +#define ISOBeginMediaEdits MP4BeginMediaEdits +#define ISOCheckMediaDataReferences MP4CheckMediaDataReferences +#define ISOEndMediaEdits MP4EndMediaEdits +#define ISOGetIndMediaSample MP4GetIndMediaSample +#define ISOGetIndMediaSampleWithPad MP4GetIndMediaSampleWithPad +#define ISOGetMediaDataReference MP4GetMediaDataReference +#define ISOGetMovieDuration MP4GetMovieDuration +#define ISOGetTrackDuration MP4GetTrackDuration +#define ISOGetMediaDuration MP4GetMediaDuration +#define ISOGetMediaHandlerDescription MP4GetMediaHandlerDescription +#define ISOGetMediaLanguage MP4GetMediaLanguage +#define ISOGetMediaSample MP4GetMediaSample +#define ISOGetMediaSampleWithPad MP4GetMediaSampleWithPad +#define ISOGetMediaSampleCount MP4GetMediaSampleCount +#define ISOGetMediaTimeScale MP4GetMediaTimeScale +#define ISOGetMediaTrack MP4GetMediaTrack +#define ISOMediaTimeToSampleNum MP4MediaTimeToSampleNum +#define ISOSampleNumToMediaTime MP4SampleNumToMediaTime +#define ISOSetMediaLanguage MP4SetMediaLanguage +#define ISOSetMediaExtendedLanguageTag MP4SetMediaExtendedLanguageTag +#define ISOAddUserData MP4AddUserData +#define ISOGetIndUserDataType MP4GetIndUserDataType +#define ISOGetMovieUserData MP4GetMovieUserData +#define ISOGetTrackUserData MP4GetTrackUserData +#define ISOGetUserDataEntryCount MP4GetUserDataEntryCount +#define ISOGetUserDataItem MP4GetUserDataItem +#define ISOGetAtomFromUserData MP4GetAtomFromUserData +#define ISODeleteUserDataItem MP4DeleteUserDataItem +#define ISOGetUserDataTypeCount MP4GetUserDataTypeCount +#define ISONewUserData MP4NewUserData +#define ISOCreateTrackReader MP4CreateTrackReader +#define ISODisposeTrackReader MP4DisposeTrackReader +#define ISONewHandle MP4NewHandle +#define ISOSetHandleSize MP4SetHandleSize +#define ISODisposeHandle MP4DisposeHandle +#define ISOGetHandleSize MP4GetHandleSize +#define ISOSetHandleOffset MP4SetHandleOffset +#define ISOUseSignedCompositionTimeOffsets MP4UseSignedCompositionTimeOffsets + +#define QTPutMovieIntoHandle MP4PutMovieIntoHandle +#define MJ2PutMovieIntoHandle MP4PutMovieIntoHandle +#define ISOPutMovieIntoHandle MP4PutMovieIntoHandle + +#define QTWriteMovieToFile MP4WriteMovieToFile +#define MJ2WriteMovieToFile MP4WriteMovieToFile +#define ISOWriteMovieToFile MP4WriteMovieToFile + +#define ISOAddAtomToMovie MP4AddAtomToMovie +#define ISONewForeignAtom MP4NewForeignAtom +#define ISOGetForeignAtom MP4GetForeignAtom +#define ISONewUUIDAtom MP4NewUUIDAtom +#define ISOAddAtomToTrack MP4AddAtomToTrack + +#define ISOGetTrackEditlistEntryCount MP4GetTrackEditlistEntryCount +#define ISOGetTrackEditlist MP4GetTrackEditlist + +#define ISOGenericAtom MP4GenericAtom + +#define MJ2TrackReaderGetNextSample MP4TrackReaderGetNextAccessUnit + + /* These functions are specific to Motion JPEG-2; they have only the "MJ2" names. */ + ISO_EXTERN(ISOErr) + MJ2SetMovieMatrix(ISOMovie theMovie, u32 matrix[9]); + + ISO_EXTERN(ISOErr) + MJ2GetMovieMatrix(ISOMovie theMovie, u32 outMatrix[9]); + + ISO_EXTERN(ISOErr) + MJ2SetMoviePreferredRate(ISOMovie theMovie, u32 rate); + + ISO_EXTERN(ISOErr) + MJ2GetMoviePreferredRate(ISOMovie theMovie, u32 *outRate); + + ISO_EXTERN(ISOErr) + MJ2SetMoviePreferredVolume(ISOMovie theMovie, s16 volume); + + ISO_EXTERN(ISOErr) + MJ2GetMoviePreferredVolume(ISOMovie theMovie, s16 *outVolume); + + ISO_EXTERN(ISOErr) + MJ2SetTrackMatrix(ISOTrack theTrack, u32 matrix[9]); + + ISO_EXTERN(ISOErr) + MJ2GetTrackMatrix(ISOTrack theTrack, u32 outMatrix[9]); + + ISO_EXTERN(ISOErr) + MJ2SetTrackLayer(ISOTrack theTrack, s16 layer); + + ISO_EXTERN(ISOErr) + MJ2GetTrackLayer(ISOTrack theTrack, s16 *outLayer); + + ISO_EXTERN(ISOErr) + MJ2SetTrackDimensions(ISOTrack theTrack, u32 width, u32 height); + + ISO_EXTERN(ISOErr) + MJ2GetTrackDimensions(ISOTrack theTrack, u32 *outWidth, u32 *outHeight); + + ISO_EXTERN(ISOErr) + MJ2SetTrackVolume(ISOTrack theTrack, s16 volume); + + ISO_EXTERN(ISOErr) + MJ2GetTrackVolume(ISOTrack theTrack, s16 *outVolume); + + ISO_EXTERN(ISOErr) + MJ2SetMediaGraphicsMode(ISOMedia theMedia, u32 mode, const ISORGBColor *opColor); + + ISO_EXTERN(ISOErr) + MJ2GetMediaGraphicsMode(ISOMedia theMedia, u32 *outMode, ISORGBColor *outOpColor); + + ISO_EXTERN(ISOErr) + MJ2SetMediaSoundBalance(ISOMedia theMedia, s16 balance); + + ISO_EXTERN(ISOErr) + MJ2GetMediaSoundBalance(ISOMedia theMedia, s16 *outBalance); + + ISO_EXTERN(ISOErr) + MJ2NewMovie(ISOMovie *outMovie); + + /* These functions are specific to 3GPP; they have only the "3GPP" names. */ + ISO_EXTERN(ISOErr) + New3GPPMovie(ISOMovie *outMovie, u16 release); + + /* These functions are specific to QuickTime; they have only the "QT" names. */ + ISO_EXTERN(ISOErr) + QTNewMovie(ISOMovie *outMovie); + + /* These functions are general. */ + ISO_EXTERN(ISOErr) + ISOWriteMovieToFile(ISOMovie theMovie, const char *filename); + + ISO_EXTERN(ISOErr) + ISOSetMovieBrand(ISOMovie theMovie, u32 brand, u32 minorversion); -/* Brands */ + ISO_EXTERN(ISOErr) + ISOSetMovieCompatibleBrand(ISOMovie theMovie, u32 brand); -enum -{ - JP2JPEG2000Brand = MP4_FOUR_CHAR_CODE( 'j', 'p', '2', ' ' ), /* brand for JPEG-2000 */ - MJ2JPEG2000Brand = MP4_FOUR_CHAR_CODE( 'm', 'j', 'p', '2' ), /* brand for Motion JPEG-2000 */ - ISOQuickTimeBrand = MP4_FOUR_CHAR_CODE( 'q', 't', ' ', ' ' ), /* brand for QuickTime */ - ISOMpeg4V1Brand = MP4_FOUR_CHAR_CODE( 'm', 'p', '4', '1' ), /* brand for MPEG-4 version 1 */ - ISOMpeg4V2Brand = MP4_FOUR_CHAR_CODE( 'm', 'p', '4', '2' ), /* brand for MPEG-4 version 2 */ - ISOISOBrand = MP4_FOUR_CHAR_CODE( 'i', 's', 'o', 'm' ), /* conforming brand for all files */ - ISOISO2Brand = MP4_FOUR_CHAR_CODE( 'i', 's', 'o', '2' ), /* conforming brand for all files */ - ISO3GP4Brand = MP4_FOUR_CHAR_CODE( '3', 'g', 'p', '4' ), /* 3GPP Release 4 */ - ISO3GP5Brand = MP4_FOUR_CHAR_CODE( '3', 'g', 'p', '5' ), /* 3GPP Release 5 */ - ISO3GP6Brand = MP4_FOUR_CHAR_CODE( '3', 'g', 'p', '6' ), /* 3GPP Release 6 */ - ISOMPEG21Brand = MP4_FOUR_CHAR_CODE( 'm', 'p', '2', '1' ), /* MPEG-21 */ - ISOUnknownBrand = MP4_FOUR_CHAR_CODE( ' ', ' ', ' ', ' ' ), /* default 'brand' */ + ISO_EXTERN(ISOErr) + ISOGetMovieBrand(ISOMovie theMovie, u32 *brand, u32 *minorversion); - /* DASH-related brands (ISO/IEC 23009-1) */ - ISO_DASH_Brand = MP4_FOUR_CHAR_CODE( 'd', 'a', 's', 'h' ), - ISO_DASH_DSMS_Brand = MP4_FOUR_CHAR_CODE( 'd', 's', 'm', 's' ), /* self-initializing media segment */ - ISO_DASH_MSDH_Brand = MP4_FOUR_CHAR_CODE( 'm', 's', 'd', 'h' ), /* general format media segment */ - ISO_DASH_MSIX_Brand = MP4_FOUR_CHAR_CODE( 'm', 's', 'd', 'h' ), /* indexed media segment */ - ISO_DASH_RISX_Brand = MP4_FOUR_CHAR_CODE( 'r', 'i', 's', 'x' ), /* representation index segment for MPEG-2 TS media segments */ - ISO_DASH_LMSG_Brand = MP4_FOUR_CHAR_CODE( 'l', 'm', 's', 'g' ), /* last media segment indicator (ISO BMFF) */ - ISO_DASH_SISX_Brand = MP4_FOUR_CHAR_CODE( 's', 'i', 's', 'x' ), /* single index segment (MPEG-2 TS) */ - ISO_DASH_SSSS_Brand = MP4_FOUR_CHAR_CODE( 's', 's', 's', 's' ) /* subsegment index segment (MPEG-2 TS) */ -}; - -/* AVC/SVC PS places */ - -enum -{ - AVCsps = 1, - AVCpps = 2, - AVCspsext = 3, - - SVCsps = 0x11, - SVCpps = 0x12, - SVCspsext = 0x13 -}; + ISO_EXTERN(u32) + ISOIsMovieCompatibleBrand(ISOMovie theMovie, u32 brand); + /* AVC Sample descriptions */ -/* Meta-data records */ + ISO_EXTERN(ISOErr) + ISONewAVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps, + MP4Handle first_pps, MP4Handle first_spsext); -struct ISOMetaRecord -{ - void* data; -}; -typedef struct ISOMetaRecord ISOMetaRecord; -typedef ISOMetaRecord* ISOMeta; + ISO_EXTERN(ISOErr) ISOAddVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where); -struct ISOMetaItemRecord -{ - void* data; -}; -typedef struct ISOMetaItemRecord ISOMetaItemRecord; -typedef ISOMetaItemRecord* ISOMetaItem; + ISO_EXTERN(ISOErr) + ISOGetAVCSampleDescription(MP4Handle sampleEntryH, u32 *dataReferenceIndex, u32 *length_size, + u32 *sps_count, u32 *pss_count, u32 *spsext_count); -/* These functions are general movie-handling functions and are common to both MPEG-4 and JPEG-2; - ideally the "ISO" names should be used. */ -#define ISODisposeMovie MP4DisposeMovie -#define ISOGetMovieTimeScale MP4GetMovieTimeScale -#define ISOGetMovieTrack MP4GetMovieTrack -#define ISOOpenMovieFile MP4OpenMovieFile -#define ISOPutMovieIntoHandle MP4PutMovieIntoHandle -#define ISOSetMovieTimeScale MP4SetMovieTimeScale -#define ISOAddTrackReference MP4AddTrackReference -#define ISOAddTrackReferenceWithID MP4AddTrackReferenceWithID -#define ISOGetMovieIndTrack MP4GetMovieIndTrack -#define ISOGetMovieTrackCount MP4GetMovieTrackCount -#define ISOGetTrackEnabled MP4GetTrackEnabled -#define ISOGetTrackID MP4GetTrackID -#define ISOGetTrackMedia MP4GetTrackMedia -#define ISOGetTrackMovie MP4GetTrackMovie -#define ISOGetTrackOffset MP4GetTrackOffset -#define ISOGetTrackReference MP4GetTrackReference -#define ISOGetTrackReferenceCount MP4GetTrackReferenceCount -#define ISOInsertMediaIntoTrack MP4InsertMediaIntoTrack -#define ISONewMovieTrack MP4NewMovieTrack -#define ISONewMovieTrackWithID MP4NewMovieTrackWithID -#define ISONewTrackMedia MP4NewTrackMedia -#define ISOSetTrackEnabled MP4SetTrackEnabled -#define ISOSetTrackOffset MP4SetTrackOffset -#define ISOTrackTimeToMediaTime MP4TrackTimeToMediaTime -#define ISOAddMediaDataReference MP4AddMediaDataReference -#define ISOAddMediaSampleReference MP4AddMediaSampleReference -#define ISOAddMediaSamples MP4AddMediaSamples -#define ISOAddMediaSamplesPad MP4AddMediaSamplesPad -#define ISOBeginMediaEdits MP4BeginMediaEdits -#define ISOCheckMediaDataReferences MP4CheckMediaDataReferences -#define ISOEndMediaEdits MP4EndMediaEdits -#define ISOGetIndMediaSample MP4GetIndMediaSample -#define ISOGetIndMediaSampleWithPad MP4GetIndMediaSampleWithPad -#define ISOGetMediaDataReference MP4GetMediaDataReference -#define ISOGetMovieDuration MP4GetMovieDuration -#define ISOGetTrackDuration MP4GetTrackDuration -#define ISOGetMediaDuration MP4GetMediaDuration -#define ISOGetMediaHandlerDescription MP4GetMediaHandlerDescription -#define ISOGetMediaLanguage MP4GetMediaLanguage -#define ISOGetMediaSample MP4GetMediaSample -#define ISOGetMediaSampleWithPad MP4GetMediaSampleWithPad -#define ISOGetMediaSampleCount MP4GetMediaSampleCount -#define ISOGetMediaTimeScale MP4GetMediaTimeScale -#define ISOGetMediaTrack MP4GetMediaTrack -#define ISOMediaTimeToSampleNum MP4MediaTimeToSampleNum -#define ISOSampleNumToMediaTime MP4SampleNumToMediaTime -#define ISOSetMediaLanguage MP4SetMediaLanguage -#define ISOSetMediaExtendedLanguageTag MP4SetMediaExtendedLanguageTag -#define ISOAddUserData MP4AddUserData -#define ISOGetIndUserDataType MP4GetIndUserDataType -#define ISOGetMovieUserData MP4GetMovieUserData -#define ISOGetTrackUserData MP4GetTrackUserData -#define ISOGetUserDataEntryCount MP4GetUserDataEntryCount -#define ISOGetUserDataItem MP4GetUserDataItem -#define ISOGetAtomFromUserData MP4GetAtomFromUserData -#define ISODeleteUserDataItem MP4DeleteUserDataItem -#define ISOGetUserDataTypeCount MP4GetUserDataTypeCount -#define ISONewUserData MP4NewUserData -#define ISOCreateTrackReader MP4CreateTrackReader -#define ISODisposeTrackReader MP4DisposeTrackReader -#define ISONewHandle MP4NewHandle -#define ISOSetHandleSize MP4SetHandleSize -#define ISODisposeHandle MP4DisposeHandle -#define ISOGetHandleSize MP4GetHandleSize -#define ISOSetHandleOffset MP4SetHandleOffset -#define ISOUseSignedCompositionTimeOffsets MP4UseSignedCompositionTimeOffsets - -#define QTPutMovieIntoHandle MP4PutMovieIntoHandle -#define MJ2PutMovieIntoHandle MP4PutMovieIntoHandle -#define ISOPutMovieIntoHandle MP4PutMovieIntoHandle - - -#define QTWriteMovieToFile MP4WriteMovieToFile -#define MJ2WriteMovieToFile MP4WriteMovieToFile -#define ISOWriteMovieToFile MP4WriteMovieToFile - -#define ISOAddAtomToMovie MP4AddAtomToMovie -#define ISONewForeignAtom MP4NewForeignAtom -#define ISOGetForeignAtom MP4GetForeignAtom -#define ISONewUUIDAtom MP4NewUUIDAtom -#define ISOAddAtomToTrack MP4AddAtomToTrack - -#define ISOGetTrackEditlistEntryCount MP4GetTrackEditlistEntryCount -#define ISOGetTrackEditlist MP4GetTrackEditlist - -#define ISOGenericAtom MP4GenericAtom - -#define MJ2TrackReaderGetNextSample MP4TrackReaderGetNextAccessUnit - -/* These functions are specific to Motion JPEG-2; they have only the "MJ2" names. */ -ISO_EXTERN ( ISOErr ) -MJ2SetMovieMatrix( ISOMovie theMovie, u32 matrix[9] ); - -ISO_EXTERN ( ISOErr ) -MJ2GetMovieMatrix( ISOMovie theMovie, u32 outMatrix[9] ); - -ISO_EXTERN ( ISOErr ) -MJ2SetMoviePreferredRate( ISOMovie theMovie, u32 rate ); - -ISO_EXTERN ( ISOErr ) -MJ2GetMoviePreferredRate( ISOMovie theMovie, u32 *outRate ); - -ISO_EXTERN ( ISOErr ) -MJ2SetMoviePreferredVolume( ISOMovie theMovie, s16 volume ); - -ISO_EXTERN ( ISOErr ) -MJ2GetMoviePreferredVolume( ISOMovie theMovie, s16 *outVolume ); - -ISO_EXTERN ( ISOErr ) -MJ2SetTrackMatrix( ISOTrack theTrack, u32 matrix[9] ); - -ISO_EXTERN ( ISOErr ) -MJ2GetTrackMatrix( ISOTrack theTrack, u32 outMatrix[9] ); - -ISO_EXTERN ( ISOErr ) -MJ2SetTrackLayer( ISOTrack theTrack, s16 layer ); - -ISO_EXTERN ( ISOErr ) -MJ2GetTrackLayer( ISOTrack theTrack, s16 *outLayer ); - -ISO_EXTERN ( ISOErr ) -MJ2SetTrackDimensions( ISOTrack theTrack, u32 width, u32 height ); - -ISO_EXTERN ( ISOErr ) -MJ2GetTrackDimensions( ISOTrack theTrack, u32 *outWidth, u32 *outHeight ); - -ISO_EXTERN ( ISOErr ) -MJ2SetTrackVolume( ISOTrack theTrack, s16 volume ); - -ISO_EXTERN ( ISOErr ) -MJ2GetTrackVolume( ISOTrack theTrack, s16 *outVolume ); - -ISO_EXTERN ( ISOErr ) -MJ2SetMediaGraphicsMode( ISOMedia theMedia, u32 mode, const ISORGBColor *opColor ); - -ISO_EXTERN ( ISOErr ) -MJ2GetMediaGraphicsMode( ISOMedia theMedia, u32 *outMode, ISORGBColor *outOpColor ); - -ISO_EXTERN( ISOErr ) -MJ2SetMediaSoundBalance( ISOMedia theMedia, s16 balance ); - -ISO_EXTERN( ISOErr ) -MJ2GetMediaSoundBalance( ISOMedia theMedia, s16 *outBalance ); - -ISO_EXTERN ( ISOErr ) -MJ2NewMovie( ISOMovie *outMovie ); - -/* These functions are specific to 3GPP; they have only the "3GPP" names. */ -ISO_EXTERN ( ISOErr ) -New3GPPMovie( ISOMovie *outMovie, u16 release ); - -/* These functions are specific to QuickTime; they have only the "QT" names. */ -ISO_EXTERN ( ISOErr ) -QTNewMovie( ISOMovie *outMovie ); - -/* These functions are general. */ -ISO_EXTERN ( ISOErr ) -ISOWriteMovieToFile( ISOMovie theMovie, const char *filename ); - -ISO_EXTERN ( ISOErr ) -ISOSetMovieBrand( ISOMovie theMovie, u32 brand, u32 minorversion ); - -ISO_EXTERN ( ISOErr ) -ISOSetMovieCompatibleBrand( ISOMovie theMovie, u32 brand ); - -ISO_EXTERN ( ISOErr ) -ISOGetMovieBrand( ISOMovie theMovie, u32* brand, u32* minorversion ); - -ISO_EXTERN ( u32 ) -ISOIsMovieCompatibleBrand( ISOMovie theMovie, u32 brand ); - -/* AVC Sample descriptions */ - -ISO_EXTERN ( ISOErr ) ISONewAVCSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 length_size, MP4Handle first_sps, MP4Handle first_pps, MP4Handle first_spsext ); - -ISO_EXTERN ( ISOErr ) ISOAddVCSampleDescriptionPS( MP4Handle sampleEntryH, - MP4Handle ps, u32 where ); - -ISO_EXTERN ( ISOErr ) ISOGetAVCSampleDescription( MP4Handle sampleEntryH, - u32 *dataReferenceIndex, - u32 *length_size, - u32* sps_count, u32* pss_count, u32* spsext_count ); - -ISO_EXTERN ( ISOErr ) ISOGetVCSampleDescriptionPS( MP4Handle sampleEntryH, - MP4Handle ps, u32 where, u32 index ); -/* 3GPP media */ -MP4_EXTERN ( MP4Err ) ISOAddBitrateToSampleDescription(MP4Handle sampleEntryH, - u8 is_3GPP, u32 buffersizeDB, u32 maxBitrate, u32 avgBitrate); - - -MP4_EXTERN ( MP4Err ) ISONewH263SampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 vendor, - u8 decoder_version, - u8 H263_level, - u8 H263_profile); - -MP4_EXTERN ( MP4Err ) ISONewAMRSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u8 is_WB, - u32 vendor, - u8 decoder_version, - u16 mode_set, - u8 mode_change_period, - u8 frames_per_sample); - -MP4_EXTERN ( MP4Err ) ISONewAMRWPSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 vendor, - u8 decoder_version); -/* Meta Data */ - -ISO_EXTERN ( ISOErr ) -ISONewFileMeta( ISOMovie theMovie, u32 metaType, ISOMeta* meta); -ISO_EXTERN ( ISOErr ) -ISONewMovieMeta( ISOMovie theMovie, u32 metaType, ISOMeta* meta ); -ISO_EXTERN ( ISOErr ) -ISONewTrackMeta( ISOTrack theTrack, u32 metaType, ISOMeta* meta ); - -ISO_EXTERN ( ISOErr ) -ISOAddMetaBoxRelation( ISOMeta first_meta, ISOMeta second_meta, u8 relation_type ); -ISO_EXTERN ( ISOErr ) -ISOGetMetaBoxRelation( ISOMeta first_meta, ISOMeta second_meta, u8 *relation_type ); - -ISO_EXTERN ( ISOErr ) -ISOAddMetaDataReference( ISOMeta meta, u16* out_ref, ISOHandle urlHandle, ISOHandle urnHandle ); - -ISO_EXTERN ( ISOErr ) -ISOAddMetaItem( ISOMeta meta, ISOMetaItem* outItem, u64 base_offset, u16 data_ref_index ); -ISO_EXTERN ( ISOErr ) -ISOAddMetaItemWithID( ISOMeta meta, ISOMetaItem* outItem, u64 base_offset, u16 data_ref_index, u16 item_ID ); - -ISO_EXTERN ( ISOErr ) -ISOAddItemExtent( ISOMetaItem item, MP4Handle data ); -ISO_EXTERN ( ISOErr ) -ISOAddItemExtentReference( ISOMetaItem item, u64 offset, u64 length ); -ISO_EXTERN ( ISOErr ) -ISOAddItemExtentUsingItemData( ISOMetaItem item, MP4Handle data ); -ISO_EXTERN ( ISOErr ) -ISOAddItemExtentItem( ISOMetaItem item, ISOMetaItem extent_item, u32 offset, u32 length ); - - -ISO_EXTERN ( ISOErr ) -ISOAddItemReference( ISOMetaItem item, u32 reference_type, u32 to_item_ID, u32 *outIndex); -ISO_EXTERN ( ISOErr ) -ISOAddItemReferences( ISOMetaItem item, u32 reference_type, u16 reference_count, MP4Handle to_item_IDs); -ISO_EXTERN ( ISOErr ) -ISOGetItemReferences( ISOMetaItem item, u32 reference_type, u16 *reference_count, MP4Handle to_item_IDs ); - -ISO_EXTERN ( ISOErr ) -ISOAddPrimaryData( ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom ); -ISO_EXTERN ( ISOErr ) -ISOGetPrimaryData( ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom ); -ISO_EXTERN ( ISOErr ) -ISOGetPrimaryItemData( ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom ); - -ISO_EXTERN ( ISOErr ) -ISOSetPrimaryItem( ISOMeta meta, ISOMetaItem item ); -ISO_EXTERN ( ISOErr ) -ISOGetPrimaryItemID( ISOMeta meta, u16 *ID ); - -ISO_EXTERN ( ISOErr ) -ISOGetItemID( ISOMetaItem item, u16* ID ); - -ISO_EXTERN ( ISOErr ) -ISOSetItemInfo( ISOMetaItem item, u16 protection_index, char* name, char* content_type, char* content_encoding ); - -ISO_EXTERN ( ISOErr ) -ISOSetItemInfoExtension( ISOMetaItem item, MP4Handle extension, u32 extension_type ); -ISO_EXTERN ( ISOErr ) -ISOGetItemInfoExtension( ISOMetaItem item, MP4Handle extension, u32 *extension_type ); - -ISO_EXTERN ( ISOErr ) -ISOSetItemInfoItemType( ISOMetaItem item, u32 item_type, char* item_uri_type); -ISO_EXTERN ( ISOErr ) -ISOGetItemInfoItemType( ISOMetaItem item, u32 *item_type, char** item_uri_type); - -ISO_EXTERN ( ISOErr ) -ISOGetFileMeta( ISOMovie theMovie, ISOMeta* meta, u32 inMetaType, u32* outMetaType); -ISO_EXTERN ( ISOErr ) -ISOGetMovieMeta( ISOMovie theMovie, ISOMeta* meta, u32 inMetaType, u32* outMetaType ); -ISO_EXTERN ( ISOErr ) -ISOGetTrackMeta( ISOTrack theTrack, ISOMeta* meta, u32 inMetaType, u32* outMetaType ); - - -ISO_EXTERN ( ISOErr ) -ISOGetAllItemsWithType( ISOMeta meta, u32 type, ISOMetaItem **items, u32 *numberOfItemsFound ); -ISO_EXTERN ( ISOErr ) -ISOFindItemByName( ISOMeta meta, ISOMetaItem* item, char* name, u8 exact_case ); -ISO_EXTERN ( ISOErr ) -ISOFindItemByID( ISOMeta meta, ISOMetaItem* item, u16 ID ); - -ISO_EXTERN ( ISOErr ) -ISOGetItemData( ISOMetaItem item, MP4Handle data, u64* base_offset ); - -ISO_EXTERN ( ISOErr ) -ISOGetItemInfo( ISOMetaItem item, u16* protection_index, char* name, char* content_type, char* content_encoding ); - -ISO_EXTERN ( MP4Err ) -ISOCheckMetaDataReferences( ISOMeta meta ); - -ISO_EXTERN ( MP4Err ) -ISONewMetaProtection( ISOMeta meta, u32 sch_type, u32 sch_version, char* sch_url, u16* protection_index ); - -ISO_EXTERN ( MP4Err ) -ISOAddMetaProtectionInfo( ISOMeta meta, u16 protection_index, MP4GenericAtom schi_atom ); - -ISO_EXTERN ( MP4Err ) -ISOGetMetaProtection( ISOMeta meta, u16 protection_index, u32* sch_type, u32* sch_version, char* sch_url ); - -ISO_EXTERN ( MP4Err ) -ISOGetMetaProtectionInfo( ISOMeta meta, u16 protection_index, u32 atom_type, MP4GenericAtom* schi_atom ); - -ISO_EXTERN ( MP4Err ) -ISOAddMetaItemProperty( ISOMetaItem item, MP4GenericAtom* itemProperty, u8 essential ); - -ISO_EXTERN ( MP4Err ) -ISOGetProperitesOfMetaItem( ISOMetaItem item, MP4GenericAtom** properties, u32 *propertiesFound); + ISO_EXTERN(ISOErr) + ISOGetVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index); + /* 3GPP media */ + MP4_EXTERN(MP4Err) + ISOAddBitrateToSampleDescription(MP4Handle sampleEntryH, u8 is_3GPP, u32 buffersizeDB, + u32 maxBitrate, u32 avgBitrate); + + MP4_EXTERN(MP4Err) + ISONewH263SampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 vendor, u8 decoder_version, u8 H263_level, + u8 H263_profile); + + MP4_EXTERN(MP4Err) + ISONewAMRSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u8 is_WB, u32 vendor, u8 decoder_version, + u16 mode_set, u8 mode_change_period, u8 frames_per_sample); + + MP4_EXTERN(MP4Err) + ISONewAMRWPSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 vendor, u8 decoder_version); + /* Meta Data */ + + ISO_EXTERN(ISOErr) + ISONewFileMeta(ISOMovie theMovie, u32 metaType, ISOMeta *meta); + ISO_EXTERN(ISOErr) + ISONewMovieMeta(ISOMovie theMovie, u32 metaType, ISOMeta *meta); + ISO_EXTERN(ISOErr) + ISONewTrackMeta(ISOTrack theTrack, u32 metaType, ISOMeta *meta); + + ISO_EXTERN(ISOErr) + ISOAddMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 relation_type); + ISO_EXTERN(ISOErr) + ISOGetMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 *relation_type); + + ISO_EXTERN(ISOErr) + ISOAddMetaDataReference(ISOMeta meta, u16 *out_ref, ISOHandle urlHandle, ISOHandle urnHandle); + + ISO_EXTERN(ISOErr) + ISOAddMetaItem(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, u16 data_ref_index); + ISO_EXTERN(ISOErr) + ISOAddMetaItemWithID(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, u16 data_ref_index, + u16 item_ID); + + ISO_EXTERN(ISOErr) + ISOAddItemExtent(ISOMetaItem item, MP4Handle data); + ISO_EXTERN(ISOErr) + ISOAddItemExtentReference(ISOMetaItem item, u64 offset, u64 length); + ISO_EXTERN(ISOErr) + ISOAddItemExtentUsingItemData(ISOMetaItem item, MP4Handle data); + ISO_EXTERN(ISOErr) + ISOAddItemExtentItem(ISOMetaItem item, ISOMetaItem extent_item, u32 offset, u32 length); + + ISO_EXTERN(ISOErr) + ISOAddItemReference(ISOMetaItem item, u32 reference_type, u32 to_item_ID, u32 *outIndex); + ISO_EXTERN(ISOErr) + ISOAddItemReferences(ISOMetaItem item, u32 reference_type, u16 reference_count, + MP4Handle to_item_IDs); + ISO_EXTERN(ISOErr) + ISOGetItemReferences(ISOMetaItem item, u32 reference_type, u16 *reference_count, + MP4Handle to_item_IDs); + + ISO_EXTERN(ISOErr) + ISOAddPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom); + ISO_EXTERN(ISOErr) + ISOGetPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom); + ISO_EXTERN(ISOErr) + ISOGetPrimaryItemData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom); + + ISO_EXTERN(ISOErr) + ISOSetPrimaryItem(ISOMeta meta, ISOMetaItem item); + ISO_EXTERN(ISOErr) + ISOGetPrimaryItemID(ISOMeta meta, u16 *ID); + + ISO_EXTERN(ISOErr) + ISOGetItemID(ISOMetaItem item, u16 *ID); + + ISO_EXTERN(ISOErr) + ISOSetItemInfo(ISOMetaItem item, u16 protection_index, char *name, char *content_type, + char *content_encoding); + + ISO_EXTERN(ISOErr) + ISOSetItemInfoExtension(ISOMetaItem item, MP4Handle extension, u32 extension_type); + ISO_EXTERN(ISOErr) + ISOGetItemInfoExtension(ISOMetaItem item, MP4Handle extension, u32 *extension_type); + + ISO_EXTERN(ISOErr) + ISOSetItemInfoItemType(ISOMetaItem item, u32 item_type, char *item_uri_type); + ISO_EXTERN(ISOErr) + ISOGetItemInfoItemType(ISOMetaItem item, u32 *item_type, char **item_uri_type); + + ISO_EXTERN(ISOErr) + ISOGetFileMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, u32 *outMetaType); + ISO_EXTERN(ISOErr) + ISOGetMovieMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, u32 *outMetaType); + ISO_EXTERN(ISOErr) + ISOGetTrackMeta(ISOTrack theTrack, ISOMeta *meta, u32 inMetaType, u32 *outMetaType); + + ISO_EXTERN(ISOErr) + ISOGetAllItemsWithType(ISOMeta meta, u32 type, ISOMetaItem **items, u32 *numberOfItemsFound); + ISO_EXTERN(ISOErr) + ISOFindItemByName(ISOMeta meta, ISOMetaItem *item, char *name, u8 exact_case); + ISO_EXTERN(ISOErr) + ISOFindItemByID(ISOMeta meta, ISOMetaItem *item, u16 ID); + + ISO_EXTERN(ISOErr) + ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_offset); + + ISO_EXTERN(ISOErr) + ISOGetItemInfo(ISOMetaItem item, u16 *protection_index, char *name, char *content_type, + char *content_encoding); + + ISO_EXTERN(MP4Err) + ISOCheckMetaDataReferences(ISOMeta meta); + + ISO_EXTERN(MP4Err) + ISONewMetaProtection(ISOMeta meta, u32 sch_type, u32 sch_version, char *sch_url, + u16 *protection_index); + + ISO_EXTERN(MP4Err) + ISOAddMetaProtectionInfo(ISOMeta meta, u16 protection_index, MP4GenericAtom schi_atom); + + ISO_EXTERN(MP4Err) + ISOGetMetaProtection(ISOMeta meta, u16 protection_index, u32 *sch_type, u32 *sch_version, + char *sch_url); + + ISO_EXTERN(MP4Err) + ISOGetMetaProtectionInfo(ISOMeta meta, u16 protection_index, u32 atom_type, + MP4GenericAtom *schi_atom); + + ISO_EXTERN(MP4Err) + ISOAddMetaItemProperty(ISOMetaItem item, MP4GenericAtom *itemProperty, u8 essential); + + ISO_EXTERN(MP4Err) + ISOGetProperitesOfMetaItem(ISOMetaItem item, MP4GenericAtom **properties, u32 *propertiesFound); #ifdef PRAGMA_EXPORT #pragma export on diff --git a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c index 793d8ee..2f3c1af 100644 --- a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c +++ b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c @@ -24,10 +24,10 @@ * acting on behalf of its Fraunhofer Institute for Telecommunications, * Heinrich Hertz Institute, HHI * All rights reserved. -*/ + */ /* - $Id: MP4Media.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4Media.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" @@ -36,1264 +36,1439 @@ #include #include -MP4Err MP4GetMediaESD( MP4Media theMedia, u32 index, MP4ES_DescriptorPtr *outESD, u32 *outDataReferenceIndex ); -MP4Err MP4GetMediaSampleDescIndex( MP4Media theMedia, u64 desiredTime, u32 *outSampleDescriptionIndex ); - -MP4Err MP4CreateMemoryInputStream( char *base, u32 size, MP4InputStreamPtr *outStream ); -MP4Err MP4ParseAtomUsingProtoList( MP4InputStreamPtr inputStream, u32* protoList, u32 defaultAtom, MP4AtomPtr *outAtom ); +MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr *outESD, + u32 *outDataReferenceIndex); +MP4Err MP4GetMediaSampleDescIndex(MP4Media theMedia, u64 desiredTime, + u32 *outSampleDescriptionIndex); +MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); +MP4Err MP4ParseAtomUsingProtoList(MP4InputStreamPtr inputStream, u32 *protoList, u32 defaultAtom, + MP4AtomPtr *outAtom); #ifdef ISMACrypt - u32 MP4SampleEntryProtos[] = { MP4MPEGSampleEntryAtomType, MP4VisualSampleEntryAtomType, MP4AudioSampleEntryAtomType, - MP4EncAudioSampleEntryAtomType, MP4EncVisualSampleEntryAtomType, - MP4XMLMetaSampleEntryAtomType, MP4TextMetaSampleEntryAtomType, - MP4AMRSampleEntryAtomType, MP4AWBSampleEntryAtomType, MP4AMRWPSampleEntryAtomType, MP4H263SampleEntryAtomType, MP4RestrictedVideoSampleEntryAtomType, - 0 }; +u32 MP4SampleEntryProtos[] = {MP4MPEGSampleEntryAtomType, + MP4VisualSampleEntryAtomType, + MP4AudioSampleEntryAtomType, + MP4EncAudioSampleEntryAtomType, + MP4EncVisualSampleEntryAtomType, + MP4XMLMetaSampleEntryAtomType, + MP4TextMetaSampleEntryAtomType, + MP4AMRSampleEntryAtomType, + MP4AWBSampleEntryAtomType, + MP4AMRWPSampleEntryAtomType, + MP4H263SampleEntryAtomType, + MP4RestrictedVideoSampleEntryAtomType, + 0}; #else - u32 MP4SampleEntryProtos[] = { MP4MPEGSampleEntryAtomType, MP4VisualSampleEntryAtomType, MP4AudioSampleEntryAtomType, - MP4XMLMetaSampleEntryAtomType, MP4TextMetaSampleEntryAtomType, - MP4AMRSampleEntryAtomType, MP4AWBSampleEntryAtomType, MP4AMRWPSampleEntryAtomType, MP4H263SampleEntryAtomType, MP4RestrictedVideoSampleEntryAtomType, - 0 }; +u32 MP4SampleEntryProtos[] = {MP4MPEGSampleEntryAtomType, + MP4VisualSampleEntryAtomType, + MP4AudioSampleEntryAtomType, + MP4XMLMetaSampleEntryAtomType, + MP4TextMetaSampleEntryAtomType, + MP4AMRSampleEntryAtomType, + MP4AWBSampleEntryAtomType, + MP4AMRWPSampleEntryAtomType, + MP4H263SampleEntryAtomType, + MP4RestrictedVideoSampleEntryAtomType, + 0}; #endif -MP4Err sampleEntryHToAtomPtr( MP4Handle sampleEntryH, MP4AtomPtr* entryPtr, u32 defaultType ) +MP4Err sampleEntryHToAtomPtr(MP4Handle sampleEntryH, MP4AtomPtr *entryPtr, u32 defaultType) { - MP4Err err = MP4NoErr; - MP4InputStreamPtr is; - u32 size; - - is = NULL; - - if ( sampleEntryH == NULL ) return MP4BadParamErr; - - err = MP4GetHandleSize( sampleEntryH, &size ); if (err) goto bail; - err = MP4CreateMemoryInputStream(*sampleEntryH, size, &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseAtomUsingProtoList( is, MP4SampleEntryProtos, defaultType, entryPtr ); if (err) goto bail; - + MP4Err err = MP4NoErr; + MP4InputStreamPtr is; + u32 size; + + is = NULL; + + if(sampleEntryH == NULL) return MP4BadParamErr; + + err = MP4GetHandleSize(sampleEntryH, &size); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*sampleEntryH, size, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseAtomUsingProtoList(is, MP4SampleEntryProtos, defaultType, entryPtr); + if(err) goto bail; + bail: - if (is) - is->destroy(is); - TEST_RETURN( err ); - - return err; + if(is) is->destroy(is); + TEST_RETURN(err); + + return err; } -MP4Err atomPtrToSampleEntryH( MP4Handle sampleEntryH, MP4AtomPtr entry ) +MP4Err atomPtrToSampleEntryH(MP4Handle sampleEntryH, MP4AtomPtr entry) { - MP4Err err = MP4NoErr; + MP4Err err = MP4NoErr; - err = entry->calculateSize( (MP4AtomPtr) entry ); if (err) goto bail; - err = MP4SetHandleSize( sampleEntryH, entry->size ); if (err) goto bail; - err = entry->serialize( (MP4AtomPtr) entry, *sampleEntryH ); if (err) goto bail; + err = entry->calculateSize((MP4AtomPtr)entry); + if(err) goto bail; + err = MP4SetHandleSize(sampleEntryH, entry->size); + if(err) goto bail; + err = entry->serialize((MP4AtomPtr)entry, *sampleEntryH); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4NewSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 objectTypeIndication, - u32 streamType, - u32 decoderBufferSize, - u32 maxBitrate, - u32 avgBitrate, - MP4Handle decoderSpecificInfoH ) +MP4_EXTERN(MP4Err) +MP4NewSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, + u32 objectTypeIndication, u32 streamType, u32 decoderBufferSize, + u32 maxBitrate, u32 avgBitrate, MP4Handle decoderSpecificInfoH) { - return MP4NewSampleDescriptionWithOCRAssociation( theTrack, sampleDescriptionH, - dataReferenceIndex, - objectTypeIndication, - streamType, - decoderBufferSize, - maxBitrate, - avgBitrate, - decoderSpecificInfoH, - 0 ); + return MP4NewSampleDescriptionWithOCRAssociation( + theTrack, sampleDescriptionH, dataReferenceIndex, objectTypeIndication, streamType, + decoderBufferSize, maxBitrate, avgBitrate, decoderSpecificInfoH, 0); } -MP4_EXTERN ( MP4Err ) MP4NewSampleDescriptionWithOCRAssociation( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 objectTypeIndication, - u32 streamType, - u32 decoderBufferSize, - u32 maxBitrate, - u32 avgBitrate, - MP4Handle decoderSpecificInfoH, - u32 theOCRESID ) +MP4_EXTERN(MP4Err) +MP4NewSampleDescriptionWithOCRAssociation(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 objectTypeIndication, + u32 streamType, u32 decoderBufferSize, u32 maxBitrate, + u32 avgBitrate, MP4Handle decoderSpecificInfoH, + u32 theOCRESID) { - MP4Err MP4CreateMPEGSampleEntryAtom( MP4MPEGSampleEntryAtomPtr *outAtom ); - MP4Err MP4CreateVisualSampleEntryAtom( MP4VisualSampleEntryAtomPtr *outAtom ); - MP4Err MP4CreateAudioSampleEntryAtom( MP4AudioSampleEntryAtomPtr *outAtom ); - MP4Err MP4CreateESDAtom( MP4ESDAtomPtr *outAtom ); - MP4Err MP4CreateES_Descriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - MP4Err MP4CreateDecoderConfigDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - MP4Err MP4CreateSLConfigDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - - MP4Err err; - GenericSampleEntryAtomPtr entry; - MP4ESDAtomPtr esdAtom; - MP4ES_DescriptorPtr esd; - MP4DecoderConfigDescriptorPtr config; - MP4SLConfigDescriptorPtr slconfig; - MP4TrackAtomPtr trak; - u32 outReferenceIndex; - - if ( (theTrack == NULL) || (sampleDescriptionH == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - if ( trak->newTrackFlags & MP4NewTrackIsVisual ) - { - err = MP4CreateVisualSampleEntryAtom( (MP4VisualSampleEntryAtomPtr*) &entry ); if (err) goto bail; - } - else if ( trak->newTrackFlags & MP4NewTrackIsAudio ) - { - MP4AudioSampleEntryAtomPtr audioSampleEntry; - MP4Media media; - u32 timeScale; - - err = MP4CreateAudioSampleEntryAtom( (MP4AudioSampleEntryAtomPtr*) &entry ); if (err) goto bail; - audioSampleEntry = (MP4AudioSampleEntryAtomPtr) entry; - err = MP4GetTrackMedia( theTrack, &media ); if (err) goto bail; - err = MP4GetMediaTimeScale( media, &timeScale ); if (err) goto bail; - audioSampleEntry->timeScale = (timeScale <= 0xFFFF ? timeScale : 0); - } - else - { - err = MP4CreateMPEGSampleEntryAtom( (MP4MPEGSampleEntryAtomPtr*) &entry ); if (err) goto bail; - } - entry->dataReferenceIndex = dataReferenceIndex; - err = MP4CreateESDAtom( &esdAtom ); if (err) goto bail; - err = MP4CreateES_Descriptor( MP4ES_DescriptorTag, 0, 0, (MP4DescriptorPtr*) &esd ); if (err) goto bail; - err = MP4CreateDecoderConfigDescriptor( MP4DecoderConfigDescriptorTag, 0, 0, - (MP4DescriptorPtr*) &config ); if (err) goto bail; - config->objectTypeIndication = objectTypeIndication; - config->streamType = streamType; - config->upstream = 0; - config->bufferSizeDB = decoderBufferSize; - config->maxBitrate = maxBitrate; - config->avgBitrate = avgBitrate; - if ( decoderSpecificInfoH ) - { - MP4Err MP4CreateMemoryInputStream( char *base, u32 size, MP4InputStreamPtr *outStream ); - MP4DescriptorPtr specificInfoDesc; - MP4InputStreamPtr is; - u32 infoSize; - - err = MP4GetHandleSize( decoderSpecificInfoH, &infoSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *decoderSpecificInfoH, infoSize, &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseDescriptor( is, &specificInfoDesc ); if (err) goto bail; - config->decoderSpecificInfo = specificInfoDesc; - if (is) { - is->destroy( is ); - is = NULL; - } - } - esd->decoderConfig = (MP4DescriptorPtr) config; - err = MP4CreateSLConfigDescriptor( MP4SLConfigDescriptorTag, 0, 0, - (MP4DescriptorPtr*) &slconfig ); if (err) goto bail; - slconfig->predefined = SLConfigPredefinedMP4; - slconfig->useTimestampsFlag = 1; - - /* JLF 11/00: OCR is always 0, if OCR wanted, create a sync dependancy */ - esd->OCRESID = 0; - if (theOCRESID) { - /* MP4Err MP4AddTrackReferenceWithID( MP4Track theTrack, u32 dependsOnID, u32 dependencyType, u32 *outReferenceIndex); */ - /* already declared in MP4Movies.h */ - err = MP4AddTrackReferenceWithID((MP4Track) trak, theOCRESID, MP4SyncTrackReferenceAtomType, &outReferenceIndex); - if (err) goto bail; - } - esd->slConfig = (MP4DescriptorPtr) slconfig; - esdAtom->descriptor = (MP4DescriptorPtr) esd; - err = MP4AddListEntry( (void*) esdAtom, entry->ExtensionAtomList ); if (err) goto bail; - err = atomPtrToSampleEntryH( sampleDescriptionH, (MP4AtomPtr) entry ); if (err) goto bail; - + MP4Err MP4CreateMPEGSampleEntryAtom(MP4MPEGSampleEntryAtomPtr * outAtom); + MP4Err MP4CreateVisualSampleEntryAtom(MP4VisualSampleEntryAtomPtr * outAtom); + MP4Err MP4CreateAudioSampleEntryAtom(MP4AudioSampleEntryAtomPtr * outAtom); + MP4Err MP4CreateESDAtom(MP4ESDAtomPtr * outAtom); + MP4Err MP4CreateES_Descriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); + MP4Err MP4CreateDecoderConfigDescriptor(u32 tag, u32 size, u32 bytesRead, + MP4DescriptorPtr * outDesc); + MP4Err MP4CreateSLConfigDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); + + MP4Err err; + GenericSampleEntryAtomPtr entry; + MP4ESDAtomPtr esdAtom; + MP4ES_DescriptorPtr esd; + MP4DecoderConfigDescriptorPtr config; + MP4SLConfigDescriptorPtr slconfig; + MP4TrackAtomPtr trak; + u32 outReferenceIndex; + + if((theTrack == NULL) || (sampleDescriptionH == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + if(trak->newTrackFlags & MP4NewTrackIsVisual) + { + err = MP4CreateVisualSampleEntryAtom((MP4VisualSampleEntryAtomPtr *)&entry); + if(err) goto bail; + } + else if(trak->newTrackFlags & MP4NewTrackIsAudio) + { + MP4AudioSampleEntryAtomPtr audioSampleEntry; + MP4Media media; + u32 timeScale; + + err = MP4CreateAudioSampleEntryAtom((MP4AudioSampleEntryAtomPtr *)&entry); + if(err) goto bail; + audioSampleEntry = (MP4AudioSampleEntryAtomPtr)entry; + err = MP4GetTrackMedia(theTrack, &media); + if(err) goto bail; + err = MP4GetMediaTimeScale(media, &timeScale); + if(err) goto bail; + audioSampleEntry->timeScale = (timeScale <= 0xFFFF ? timeScale : 0); + } + else + { + err = MP4CreateMPEGSampleEntryAtom((MP4MPEGSampleEntryAtomPtr *)&entry); + if(err) goto bail; + } + entry->dataReferenceIndex = dataReferenceIndex; + err = MP4CreateESDAtom(&esdAtom); + if(err) goto bail; + err = MP4CreateES_Descriptor(MP4ES_DescriptorTag, 0, 0, (MP4DescriptorPtr *)&esd); + if(err) goto bail; + err = MP4CreateDecoderConfigDescriptor(MP4DecoderConfigDescriptorTag, 0, 0, + (MP4DescriptorPtr *)&config); + if(err) goto bail; + config->objectTypeIndication = objectTypeIndication; + config->streamType = streamType; + config->upstream = 0; + config->bufferSizeDB = decoderBufferSize; + config->maxBitrate = maxBitrate; + config->avgBitrate = avgBitrate; + if(decoderSpecificInfoH) + { + MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); + MP4DescriptorPtr specificInfoDesc; + MP4InputStreamPtr is; + u32 infoSize; + + err = MP4GetHandleSize(decoderSpecificInfoH, &infoSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*decoderSpecificInfoH, infoSize, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseDescriptor(is, &specificInfoDesc); + if(err) goto bail; + config->decoderSpecificInfo = specificInfoDesc; + if(is) + { + is->destroy(is); + is = NULL; + } + } + esd->decoderConfig = (MP4DescriptorPtr)config; + err = MP4CreateSLConfigDescriptor(MP4SLConfigDescriptorTag, 0, 0, (MP4DescriptorPtr *)&slconfig); + if(err) goto bail; + slconfig->predefined = SLConfigPredefinedMP4; + slconfig->useTimestampsFlag = 1; + + /* JLF 11/00: OCR is always 0, if OCR wanted, create a sync dependancy */ + esd->OCRESID = 0; + if(theOCRESID) + { + /* MP4Err MP4AddTrackReferenceWithID( MP4Track theTrack, u32 dependsOnID, u32 dependencyType, + * u32 *outReferenceIndex); */ + /* already declared in MP4Movies.h */ + err = MP4AddTrackReferenceWithID((MP4Track)trak, theOCRESID, MP4SyncTrackReferenceAtomType, + &outReferenceIndex); + if(err) goto bail; + } + esd->slConfig = (MP4DescriptorPtr)slconfig; + esdAtom->descriptor = (MP4DescriptorPtr)esd; + err = MP4AddListEntry((void *)esdAtom, entry->ExtensionAtomList); + if(err) goto bail; + err = atomPtrToSampleEntryH(sampleDescriptionH, (MP4AtomPtr)entry); + if(err) goto bail; + bail: - if ( esdAtom ) { - /* JLF 07/01: need to set the esd atom to NULL as the SampleDescEntry destructors - attempts to delete it */ - if (entry) err = MP4DeleteListEntryAtom( entry->ExtensionAtomList, MP4ESDAtomType ); - esdAtom->destroy( (MP4AtomPtr) esdAtom ); - } - - if ( entry ) - entry->destroy( (MP4AtomPtr) entry ); - - TEST_RETURN( err ); - - return err; + if(esdAtom) + { + /* JLF 07/01: need to set the esd atom to NULL as the SampleDescEntry destructors + attempts to delete it */ + if(entry) err = MP4DeleteListEntryAtom(entry->ExtensionAtomList, MP4ESDAtomType); + esdAtom->destroy((MP4AtomPtr)esdAtom); + } + + if(entry) entry->destroy((MP4AtomPtr)entry); + + TEST_RETURN(err); + + return err; } /* JLF: set the stream priority in the sample desc */ -MP4_EXTERN ( MP4Err ) MP4SetSampleDescriptionPriority(MP4Handle sampleEntryH, u32 priority) +MP4_EXTERN(MP4Err) MP4SetSampleDescriptionPriority(MP4Handle sampleEntryH, u32 priority) { - MP4Err err = MP4NoErr; - MP4ESDAtomPtr esda; - MP4ES_Descriptor *esd; - GenericSampleEntryAtomPtr entry = NULL; - - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4GenericSampleEntryAtomType ); if (err) goto bail; - - err = MP4GetListEntryAtom( entry->ExtensionAtomList, MP4ESDAtomType, (MP4AtomPtr*) &esda ); - if ( err == MP4NotFoundErr ) - { - BAILWITHERROR( MP4BadParamErr ); - } - esd = (MP4ES_DescriptorPtr) esda->descriptor; - if (esd == NULL) { - err = MP4InvalidMediaErr; - goto bail; - } - esd->streamPriority = priority; - - /* rewrite it... */ - err = atomPtrToSampleEntryH( sampleEntryH, (MP4AtomPtr) entry ); if (err) goto bail; + MP4Err err = MP4NoErr; + MP4ESDAtomPtr esda; + MP4ES_Descriptor *esd; + GenericSampleEntryAtomPtr entry = NULL; + + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4GenericSampleEntryAtomType); + if(err) goto bail; + + err = MP4GetListEntryAtom(entry->ExtensionAtomList, MP4ESDAtomType, (MP4AtomPtr *)&esda); + if(err == MP4NotFoundErr) + { + BAILWITHERROR(MP4BadParamErr); + } + esd = (MP4ES_DescriptorPtr)esda->descriptor; + if(esd == NULL) + { + err = MP4InvalidMediaErr; + goto bail; + } + esd->streamPriority = priority; + + /* rewrite it... */ + err = atomPtrToSampleEntryH(sampleEntryH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if (entry) - entry->destroy((MP4AtomPtr) entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } - /* JLF: add a Descriptor to the esd in the sample desc */ -MP4_EXTERN ( MP4Err ) MP4AddDescToSampleDescription(MP4Handle sampleEntryH, MP4Handle descriptorH) +MP4_EXTERN(MP4Err) MP4AddDescToSampleDescription(MP4Handle sampleEntryH, MP4Handle descriptorH) { - MP4Err err = MP4NoErr; - MP4ESDAtomPtr esda; - MP4ES_Descriptor *esd; - MP4DescriptorPtr desc; - GenericSampleEntryAtomPtr entry = NULL; - MP4InputStreamPtr is; - u32 size; - - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4GenericSampleEntryAtomType ); if (err) goto bail; - - err = MP4GetListEntryAtom( entry->ExtensionAtomList, MP4ESDAtomType, (MP4AtomPtr*) &esda ); - if ( err == MP4NotFoundErr ) - { - BAILWITHERROR( MP4BadParamErr ); - } - esd = (MP4ES_DescriptorPtr) esda->descriptor; - if (esd == NULL) { - err = MP4InvalidMediaErr; - goto bail; - } - /* then parse our descriptor... */ - err = MP4GetHandleSize( descriptorH, &size ); if (err) goto bail; - err = MP4CreateMemoryInputStream(*descriptorH, size, &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseDescriptor( is, (MP4DescriptorPtr *)&desc); if (err) goto bail; - is->destroy(is); - - if (!desc) { - err = MP4BadParamErr; - goto bail; - } - err = esd->addDescriptor((MP4DescriptorPtr) esd, desc); - if (err) goto bail; - - /* rewrite it... */ - err = atomPtrToSampleEntryH( sampleEntryH, (MP4AtomPtr) entry ); if (err) goto bail; + MP4Err err = MP4NoErr; + MP4ESDAtomPtr esda; + MP4ES_Descriptor *esd; + MP4DescriptorPtr desc; + GenericSampleEntryAtomPtr entry = NULL; + MP4InputStreamPtr is; + u32 size; + + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4GenericSampleEntryAtomType); + if(err) goto bail; + + err = MP4GetListEntryAtom(entry->ExtensionAtomList, MP4ESDAtomType, (MP4AtomPtr *)&esda); + if(err == MP4NotFoundErr) + { + BAILWITHERROR(MP4BadParamErr); + } + esd = (MP4ES_DescriptorPtr)esda->descriptor; + if(esd == NULL) + { + err = MP4InvalidMediaErr; + goto bail; + } + /* then parse our descriptor... */ + err = MP4GetHandleSize(descriptorH, &size); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*descriptorH, size, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseDescriptor(is, (MP4DescriptorPtr *)&desc); + if(err) goto bail; + is->destroy(is); + + if(!desc) + { + err = MP4BadParamErr; + goto bail; + } + err = esd->addDescriptor((MP4DescriptorPtr)esd, desc); + if(err) goto bail; + + /* rewrite it... */ + err = atomPtrToSampleEntryH(sampleEntryH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if (entry) entry->destroy((MP4AtomPtr) entry); - return err; - + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN ( MP4Err ) ISOSetSampleDescriptionDimensions(MP4Handle sampleEntryH, u16 width, u16 height) +MP4_EXTERN(MP4Err) ISOSetSampleDescriptionDimensions(MP4Handle sampleEntryH, u16 width, u16 height) { - MP4Err err = MP4NoErr; - MP4VisualSampleEntryAtomPtr entry = NULL; + MP4Err err = MP4NoErr; + MP4VisualSampleEntryAtomPtr entry = NULL; - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4VisualSampleEntryAtomType ); if (err) goto bail; - - entry->width = width; - entry->height = height; + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); + if(err) goto bail; - /* rewrite it... */ - err = atomPtrToSampleEntryH( sampleEntryH, (MP4AtomPtr) entry ); if (err) goto bail; + entry->width = width; + entry->height = height; + + /* rewrite it... */ + err = atomPtrToSampleEntryH(sampleEntryH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if (entry) - entry->destroy((MP4AtomPtr) entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN ( MP4Err ) ISOSetSampleDescriptionType(MP4Handle sampleEntryH, u32 type) +MP4_EXTERN(MP4Err) ISOSetSampleDescriptionType(MP4Handle sampleEntryH, u32 type) { - MP4Err err = MP4NoErr; - MP4AtomPtr esds; - MP4VisualSampleEntryAtomPtr entry = NULL; - - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4GenericSampleEntryAtomType ); if (err) goto bail; - - entry->type = type; - - type = (type & 0xFFFFFF00) | ' '; - - if (type!=MP4_FOUR_CHAR_CODE( 'm', 'p', '4', ' ' )) { - err = MP4GetListEntryAtom(entry->ExtensionAtomList, MP4ESDAtomType, &esds); if (err) goto bail; - if (esds) esds->destroy( esds ); - err = MP4DeleteListEntryAtom(entry->ExtensionAtomList, MP4ESDAtomType); if (err) goto bail; - } - /* DO NOT set the type of a sample description away from and back to MP4, as you'll lose the esds */ - - /* rewrite it... */ - err = atomPtrToSampleEntryH( sampleEntryH, (MP4AtomPtr) entry ); if (err) goto bail; + MP4Err err = MP4NoErr; + MP4AtomPtr esds; + MP4VisualSampleEntryAtomPtr entry = NULL; + + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4GenericSampleEntryAtomType); + if(err) goto bail; + + entry->type = type; + + type = (type & 0xFFFFFF00) | ' '; + + if(type != MP4_FOUR_CHAR_CODE('m', 'p', '4', ' ')) + { + err = MP4GetListEntryAtom(entry->ExtensionAtomList, MP4ESDAtomType, &esds); + if(err) goto bail; + if(esds) esds->destroy(esds); + err = MP4DeleteListEntryAtom(entry->ExtensionAtomList, MP4ESDAtomType); + if(err) goto bail; + } + /* DO NOT set the type of a sample description away from and back to MP4, as you'll lose the esds + */ + + /* rewrite it... */ + err = atomPtrToSampleEntryH(sampleEntryH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if (entry) - entry->destroy((MP4AtomPtr) entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN ( MP4Err ) ISOGetSampleDescriptionDimensions(MP4Handle sampleEntryH, u16 *width, u16 *height) +MP4_EXTERN(MP4Err) +ISOGetSampleDescriptionDimensions(MP4Handle sampleEntryH, u16 *width, u16 *height) { - MP4Err err = MP4NoErr; - MP4VisualSampleEntryAtomPtr entry = NULL; - - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4VisualSampleEntryAtomType ); if (err) goto bail; + MP4Err err = MP4NoErr; + MP4VisualSampleEntryAtomPtr entry = NULL; - *width = entry->width; - *height = entry->height; + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); + if(err) goto bail; + + *width = entry->width; + *height = entry->height; bail: - if (entry) - entry->destroy((MP4AtomPtr) entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN ( MP4Err ) ISOGetSampleDescriptionType(MP4Handle sampleEntryH, u32 *type) +MP4_EXTERN(MP4Err) ISOGetSampleDescriptionType(MP4Handle sampleEntryH, u32 *type) { - MP4Err err = MP4NoErr; - MP4VisualSampleEntryAtomPtr entry = NULL; - - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4GenericSampleEntryAtomType ); if (err) goto bail; + MP4Err err = MP4NoErr; + MP4VisualSampleEntryAtomPtr entry = NULL; + + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4GenericSampleEntryAtomType); + if(err) goto bail; + + *type = entry->type; - *type = entry->type; - bail: - if (entry) - entry->destroy((MP4AtomPtr) entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN ( MP4Err ) ISONewGeneralSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 sampleEntryType, - MP4GenericAtom extensionAtom ) +MP4_EXTERN(MP4Err) +ISONewGeneralSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 sampleEntryType, + MP4GenericAtom extensionAtom) { - MP4Err MP4CreateMPEGSampleEntryAtom( MP4MPEGSampleEntryAtomPtr *outAtom ); - MP4Err MP4CreateVisualSampleEntryAtom( MP4VisualSampleEntryAtomPtr *outAtom ); - MP4Err MP4CreateAudioSampleEntryAtom( MP4AudioSampleEntryAtomPtr *outAtom ); - - MP4Err err; - GenericSampleEntryAtomPtr entry; - MP4TrackAtomPtr trak; - - if ( (theTrack == NULL) || (sampleDescriptionH == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - if ( trak->newTrackFlags & MP4NewTrackIsVisual ) - { - err = MP4CreateVisualSampleEntryAtom( (MP4VisualSampleEntryAtomPtr*) &entry ); if (err) goto bail; - } - else if ( trak->newTrackFlags & MP4NewTrackIsAudio ) - { - MP4AudioSampleEntryAtomPtr audioSampleEntry; - MP4Media media; - u32 timeScale; - - err = MP4CreateAudioSampleEntryAtom( (MP4AudioSampleEntryAtomPtr*) &entry ); if (err) goto bail; - audioSampleEntry = (MP4AudioSampleEntryAtomPtr) entry; - err = MP4GetTrackMedia( theTrack, &media ); if (err) goto bail; - err = MP4GetMediaTimeScale( media, &timeScale ); if (err) goto bail; - audioSampleEntry->timeScale = (timeScale <= 0xFFFF ? timeScale : 0); - } - else - { - /* this case covers MP4NewTrackIsMetadata */ - err = MP4CreateMPEGSampleEntryAtom( (MP4MPEGSampleEntryAtomPtr*) &entry ); if (err) goto bail; - } - entry->dataReferenceIndex = dataReferenceIndex; - entry->type = sampleEntryType; - - if ( extensionAtom ) { - err = MP4AddListEntry( (void*) extensionAtom, entry->ExtensionAtomList); if (err) goto bail; - } - - err = atomPtrToSampleEntryH( sampleDescriptionH, (MP4AtomPtr) entry ); if (err) goto bail; + MP4Err MP4CreateMPEGSampleEntryAtom(MP4MPEGSampleEntryAtomPtr * outAtom); + MP4Err MP4CreateVisualSampleEntryAtom(MP4VisualSampleEntryAtomPtr * outAtom); + MP4Err MP4CreateAudioSampleEntryAtom(MP4AudioSampleEntryAtomPtr * outAtom); + + MP4Err err; + GenericSampleEntryAtomPtr entry; + MP4TrackAtomPtr trak; + + if((theTrack == NULL) || (sampleDescriptionH == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + if(trak->newTrackFlags & MP4NewTrackIsVisual) + { + err = MP4CreateVisualSampleEntryAtom((MP4VisualSampleEntryAtomPtr *)&entry); + if(err) goto bail; + } + else if(trak->newTrackFlags & MP4NewTrackIsAudio) + { + MP4AudioSampleEntryAtomPtr audioSampleEntry; + MP4Media media; + u32 timeScale; + + err = MP4CreateAudioSampleEntryAtom((MP4AudioSampleEntryAtomPtr *)&entry); + if(err) goto bail; + audioSampleEntry = (MP4AudioSampleEntryAtomPtr)entry; + err = MP4GetTrackMedia(theTrack, &media); + if(err) goto bail; + err = MP4GetMediaTimeScale(media, &timeScale); + if(err) goto bail; + audioSampleEntry->timeScale = (timeScale <= 0xFFFF ? timeScale : 0); + } + else + { + /* this case covers MP4NewTrackIsMetadata */ + err = MP4CreateMPEGSampleEntryAtom((MP4MPEGSampleEntryAtomPtr *)&entry); + if(err) goto bail; + } + entry->dataReferenceIndex = dataReferenceIndex; + entry->type = sampleEntryType; + + if(extensionAtom) + { + err = MP4AddListEntry((void *)extensionAtom, entry->ExtensionAtomList); + if(err) goto bail; + } + + err = atomPtrToSampleEntryH(sampleDescriptionH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if ( entry ) - entry->destroy( (MP4AtomPtr) entry ); - - TEST_RETURN( err ); - - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) ISOAddAtomToSampleDescription(MP4Handle sampleEntryH, MP4GenericAtom extensionAtom) +MP4_EXTERN(MP4Err) +ISOAddAtomToSampleDescription(MP4Handle sampleEntryH, MP4GenericAtom extensionAtom) { - MP4Err err = MP4NoErr; - MP4GenericSampleEntryAtomPtr entry = NULL; - - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4GenericSampleEntryAtomType ); if (err) goto bail; + MP4Err err = MP4NoErr; + MP4GenericSampleEntryAtomPtr entry = NULL; + + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4GenericSampleEntryAtomType); + if(err) goto bail; - if ( extensionAtom ) { - err = MP4AddListEntry( (void*) extensionAtom, entry->ExtensionAtomList); if (err) goto bail; - } - /* rewrite it... */ - err = atomPtrToSampleEntryH( sampleEntryH, (MP4AtomPtr) entry ); if (err) goto bail; + if(extensionAtom) + { + err = MP4AddListEntry((void *)extensionAtom, entry->ExtensionAtomList); + if(err) goto bail; + } + /* rewrite it... */ + err = atomPtrToSampleEntryH(sampleEntryH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if (entry) - entry->destroy((MP4AtomPtr) entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN ( MP4Err ) ISOGetAtomFromSampleDescription(MP4Handle sampleEntryH, u32 atomType, MP4GenericAtom* outAtom) +MP4_EXTERN(MP4Err) +ISOGetAtomFromSampleDescription(MP4Handle sampleEntryH, u32 atomType, MP4GenericAtom *outAtom) { - MP4Err err = MP4NoErr; - MP4GenericSampleEntryAtomPtr entry = NULL; - - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4GenericSampleEntryAtomType ); if (err) goto bail; - err = MP4GetListEntryAtom(entry->ExtensionAtomList, atomType, (MP4AtomPtr*) outAtom ); if (err) goto bail; + MP4Err err = MP4NoErr; + MP4GenericSampleEntryAtomPtr entry = NULL; + + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4GenericSampleEntryAtomType); + if(err) goto bail; + err = MP4GetListEntryAtom(entry->ExtensionAtomList, atomType, (MP4AtomPtr *)outAtom); + if(err) goto bail; bail: - if (entry) - entry->destroy((MP4AtomPtr) entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN ( MP4Err ) ISOAddBitrateToSampleDescription(MP4Handle sampleEntryH, u8 is_3GPP, u32 buffersizeDB, u32 maxBitrate, u32 avgBitrate) +MP4_EXTERN(MP4Err) +ISOAddBitrateToSampleDescription(MP4Handle sampleEntryH, u8 is_3GPP, u32 buffersizeDB, + u32 maxBitrate, u32 avgBitrate) { - MP4Err err = MP4NoErr; - MP4GenericSampleEntryAtomPtr entry = NULL; - MP4BitRateAtomPtr rate; - - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4GenericSampleEntryAtomType ); if (err) goto bail; - - err = MP4CreateBitRateAtom( &rate ); if (err) goto bail; - rate->type = (is_3GPP ? TGPPBitRateAtomType : MP4BitRateAtomType ); - rate->buffersizeDB = buffersizeDB; - rate->max_bitrate = maxBitrate; - rate->avg_bitrate = avgBitrate; - - err = MP4AddListEntry( (void*) rate, entry->ExtensionAtomList); if (err) goto bail; - - /* rewrite it... */ - err = atomPtrToSampleEntryH( sampleEntryH, (MP4AtomPtr) entry ); if (err) goto bail; + MP4Err err = MP4NoErr; + MP4GenericSampleEntryAtomPtr entry = NULL; + MP4BitRateAtomPtr rate; -bail: - if (entry) - entry->destroy((MP4AtomPtr) entry); - return err; -} + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4GenericSampleEntryAtomType); + if(err) goto bail; -MP4_EXTERN ( MP4Err ) ISONewXMLMetaDataSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - char* content_encoding, - char* xml_namespace, - char* schema_location ) -{ - MP4Err err; - MP4XMLMetaSampleEntryAtomPtr entry; - MP4TrackAtomPtr trak; - - if ( (theTrack == NULL) || (sampleDescriptionH == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - err = MP4CreateXMLMetaSampleEntryAtom( (MP4XMLMetaSampleEntryAtomPtr*) &entry ); if (err) goto bail; - - entry->dataReferenceIndex = dataReferenceIndex; - - if (content_encoding) { - entry->content_encoding = (char*)calloc( strlen(content_encoding)+1, 1 ); - TESTMALLOC( entry->content_encoding ); - strcpy( entry->content_encoding, content_encoding ); - } else entry->content_encoding = NULL; - if (xml_namespace) { - entry->xml_namespace = (char*)calloc( strlen(xml_namespace)+1, 1 ); - TESTMALLOC( entry->xml_namespace ); - strcpy( entry->xml_namespace, xml_namespace ); - } else entry->xml_namespace = NULL; - if (schema_location) { - entry->schema_location = (char*)calloc( strlen(schema_location)+1, 1 ); - TESTMALLOC( entry->schema_location ); - strcpy( entry->schema_location, schema_location ); - } else entry->schema_location = NULL; - - err = atomPtrToSampleEntryH( sampleDescriptionH, (MP4AtomPtr) entry ); if (err) goto bail; + err = MP4CreateBitRateAtom(&rate); + if(err) goto bail; + rate->type = (is_3GPP ? TGPPBitRateAtomType : MP4BitRateAtomType); + rate->buffersizeDB = buffersizeDB; + rate->max_bitrate = maxBitrate; + rate->avg_bitrate = avgBitrate; + + err = MP4AddListEntry((void *)rate, entry->ExtensionAtomList); + if(err) goto bail; + + /* rewrite it... */ + err = atomPtrToSampleEntryH(sampleEntryH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if ( entry ) - entry->destroy( (MP4AtomPtr) entry ); - - TEST_RETURN( err ); - - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN ( MP4Err ) ISONewTextMetaDataSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - char* content_encoding, - char* mime_format ) +MP4_EXTERN(MP4Err) +ISONewXMLMetaDataSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, char *content_encoding, + char *xml_namespace, char *schema_location) { - MP4Err err; - MP4TextMetaSampleEntryAtomPtr entry; - MP4TrackAtomPtr trak; + MP4Err err; + MP4XMLMetaSampleEntryAtomPtr entry; + MP4TrackAtomPtr trak; + + if((theTrack == NULL) || (sampleDescriptionH == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + err = MP4CreateXMLMetaSampleEntryAtom((MP4XMLMetaSampleEntryAtomPtr *)&entry); + if(err) goto bail; + + entry->dataReferenceIndex = dataReferenceIndex; + + if(content_encoding) + { + entry->content_encoding = (char *)calloc(strlen(content_encoding) + 1, 1); + TESTMALLOC(entry->content_encoding); + strcpy(entry->content_encoding, content_encoding); + } + else + entry->content_encoding = NULL; + if(xml_namespace) + { + entry->xml_namespace = (char *)calloc(strlen(xml_namespace) + 1, 1); + TESTMALLOC(entry->xml_namespace); + strcpy(entry->xml_namespace, xml_namespace); + } + else + entry->xml_namespace = NULL; + if(schema_location) + { + entry->schema_location = (char *)calloc(strlen(schema_location) + 1, 1); + TESTMALLOC(entry->schema_location); + strcpy(entry->schema_location, schema_location); + } + else + entry->schema_location = NULL; + + err = atomPtrToSampleEntryH(sampleDescriptionH, (MP4AtomPtr)entry); + if(err) goto bail; - if ( (theTrack == NULL) || (sampleDescriptionH == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - err = MP4CreateTextMetaSampleEntryAtom( (MP4TextMetaSampleEntryAtomPtr*) &entry ); if (err) goto bail; +bail: + if(entry) entry->destroy((MP4AtomPtr)entry); - entry->dataReferenceIndex = dataReferenceIndex; + TEST_RETURN(err); - if (content_encoding) { - entry->content_encoding = (char*)calloc( strlen(content_encoding)+1, 1 ); - TESTMALLOC( entry->content_encoding ); - strcpy( entry->content_encoding, content_encoding ); - } else entry->content_encoding = NULL; - if (mime_format) { - entry->mime_format = (char*)calloc( strlen(mime_format)+1, 1 ); - TESTMALLOC( entry->mime_format ); - strcpy( entry->mime_format, mime_format ); - } else entry->mime_format = NULL; + return err; +} - err = atomPtrToSampleEntryH( sampleDescriptionH, (MP4AtomPtr) entry ); if (err) goto bail; +MP4_EXTERN(MP4Err) +ISONewTextMetaDataSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, char *content_encoding, + char *mime_format) +{ + MP4Err err; + MP4TextMetaSampleEntryAtomPtr entry; + MP4TrackAtomPtr trak; + + if((theTrack == NULL) || (sampleDescriptionH == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + err = MP4CreateTextMetaSampleEntryAtom((MP4TextMetaSampleEntryAtomPtr *)&entry); + if(err) goto bail; + + entry->dataReferenceIndex = dataReferenceIndex; + + if(content_encoding) + { + entry->content_encoding = (char *)calloc(strlen(content_encoding) + 1, 1); + TESTMALLOC(entry->content_encoding); + strcpy(entry->content_encoding, content_encoding); + } + else + entry->content_encoding = NULL; + if(mime_format) + { + entry->mime_format = (char *)calloc(strlen(mime_format) + 1, 1); + TESTMALLOC(entry->mime_format); + strcpy(entry->mime_format, mime_format); + } + else + entry->mime_format = NULL; + + err = atomPtrToSampleEntryH(sampleDescriptionH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if ( entry ) - entry->destroy( (MP4AtomPtr) entry ); - - TEST_RETURN( err ); - - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) ISONewH263SampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 vendor, - u8 decoder_version, - u8 H263_level, - u8 H263_profile) +MP4_EXTERN(MP4Err) +ISONewH263SampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, + u32 vendor, u8 decoder_version, u8 H263_level, u8 H263_profile) { - MP4Err err; - GenericSampleEntryAtomPtr entry; - MP4H263SpecificInfoAtomPtr H263SpecificInfoAtom; - MP4TrackAtomPtr trak; + MP4Err err; + GenericSampleEntryAtomPtr entry; + MP4H263SpecificInfoAtomPtr H263SpecificInfoAtom; + MP4TrackAtomPtr trak; - if ( (theTrack == NULL) || (sampleDescriptionH == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } + if((theTrack == NULL) || (sampleDescriptionH == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } - trak = (MP4TrackAtomPtr) theTrack; - if (!( trak->newTrackFlags & MP4NewTrackIsVisual )) BAILWITHERROR (MP4BadParamErr ); - err = MP4CreateVisualSampleEntryAtom( (MP4VisualSampleEntryAtomPtr*) &entry ); if (err) goto bail; + trak = (MP4TrackAtomPtr)theTrack; + if(!(trak->newTrackFlags & MP4NewTrackIsVisual)) BAILWITHERROR(MP4BadParamErr); + err = MP4CreateVisualSampleEntryAtom((MP4VisualSampleEntryAtomPtr *)&entry); + if(err) goto bail; - entry->dataReferenceIndex = dataReferenceIndex; - entry->type = MP4H263SampleEntryAtomType; + entry->dataReferenceIndex = dataReferenceIndex; + entry->type = MP4H263SampleEntryAtomType; - err = MP4CreateH263SpecificInfoAtom( &H263SpecificInfoAtom ); if (err) goto bail; - H263SpecificInfoAtom->vendor = vendor; - H263SpecificInfoAtom->decoder_version = decoder_version; - H263SpecificInfoAtom->H263_level = H263_level; - H263SpecificInfoAtom->H263_profile = H263_profile; - - err = MP4AddListEntry( (void*) H263SpecificInfoAtom, entry->ExtensionAtomList); if (err) goto bail; + err = MP4CreateH263SpecificInfoAtom(&H263SpecificInfoAtom); + if(err) goto bail; + H263SpecificInfoAtom->vendor = vendor; + H263SpecificInfoAtom->decoder_version = decoder_version; + H263SpecificInfoAtom->H263_level = H263_level; + H263SpecificInfoAtom->H263_profile = H263_profile; - err = atomPtrToSampleEntryH( sampleDescriptionH, (MP4AtomPtr) entry ); if (err) goto bail; + err = MP4AddListEntry((void *)H263SpecificInfoAtom, entry->ExtensionAtomList); + if(err) goto bail; + + err = atomPtrToSampleEntryH(sampleDescriptionH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if ( entry ) - entry->destroy( (MP4AtomPtr) entry ); - - TEST_RETURN( err ); - - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) ISONewAMRSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u8 is_WB, - u32 vendor, - u8 decoder_version, - u16 mode_set, - u8 mode_change_period, - u8 frames_per_sample) +MP4_EXTERN(MP4Err) +ISONewAMRSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, + u8 is_WB, u32 vendor, u8 decoder_version, u16 mode_set, + u8 mode_change_period, u8 frames_per_sample) { - MP4Err err; - MP4AudioSampleEntryAtomPtr entry; - MP4AMRSpecificInfoAtomPtr AMRSpecificInfoAtom; - MP4TrackAtomPtr trak; - MP4Media media; - u32 timeScale; - - if ( (theTrack == NULL) || (sampleDescriptionH == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - if (!( trak->newTrackFlags & MP4NewTrackIsAudio )) BAILWITHERROR (MP4BadParamErr ); - err = MP4CreateAudioSampleEntryAtom( (MP4AudioSampleEntryAtomPtr*) &entry ); if (err) goto bail; - - err = MP4GetTrackMedia( theTrack, &media ); if (err) goto bail; - err = MP4GetMediaTimeScale( media, &timeScale ); if (err) goto bail; - entry->timeScale = timeScale; - - entry->dataReferenceIndex = dataReferenceIndex; - entry->type = (is_WB ? MP4AWBSampleEntryAtomType : MP4AMRSampleEntryAtomType); - - err = MP4CreateAMRSpecificInfoAtom( &AMRSpecificInfoAtom ); if (err) goto bail; - AMRSpecificInfoAtom->vendor = vendor; - AMRSpecificInfoAtom->decoder_version = decoder_version; - AMRSpecificInfoAtom->mode_set = mode_set; - AMRSpecificInfoAtom->mode_change_period = mode_change_period; - AMRSpecificInfoAtom->frames_per_sample = frames_per_sample; - - err = MP4AddListEntry( (void*) AMRSpecificInfoAtom, entry->ExtensionAtomList); if (err) goto bail; - - err = atomPtrToSampleEntryH( sampleDescriptionH, (MP4AtomPtr) entry ); if (err) goto bail; + MP4Err err; + MP4AudioSampleEntryAtomPtr entry; + MP4AMRSpecificInfoAtomPtr AMRSpecificInfoAtom; + MP4TrackAtomPtr trak; + MP4Media media; + u32 timeScale; + + if((theTrack == NULL) || (sampleDescriptionH == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + if(!(trak->newTrackFlags & MP4NewTrackIsAudio)) BAILWITHERROR(MP4BadParamErr); + err = MP4CreateAudioSampleEntryAtom((MP4AudioSampleEntryAtomPtr *)&entry); + if(err) goto bail; + + err = MP4GetTrackMedia(theTrack, &media); + if(err) goto bail; + err = MP4GetMediaTimeScale(media, &timeScale); + if(err) goto bail; + entry->timeScale = timeScale; + + entry->dataReferenceIndex = dataReferenceIndex; + entry->type = (is_WB ? MP4AWBSampleEntryAtomType : MP4AMRSampleEntryAtomType); + + err = MP4CreateAMRSpecificInfoAtom(&AMRSpecificInfoAtom); + if(err) goto bail; + AMRSpecificInfoAtom->vendor = vendor; + AMRSpecificInfoAtom->decoder_version = decoder_version; + AMRSpecificInfoAtom->mode_set = mode_set; + AMRSpecificInfoAtom->mode_change_period = mode_change_period; + AMRSpecificInfoAtom->frames_per_sample = frames_per_sample; + + err = MP4AddListEntry((void *)AMRSpecificInfoAtom, entry->ExtensionAtomList); + if(err) goto bail; + + err = atomPtrToSampleEntryH(sampleDescriptionH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if ( entry ) - entry->destroy( (MP4AtomPtr) entry ); - - TEST_RETURN( err ); - - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) ISONewAMRWPSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 vendor, - u8 decoder_version) +MP4_EXTERN(MP4Err) +ISONewAMRWPSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 vendor, u8 decoder_version) { - MP4Err err; - MP4AudioSampleEntryAtomPtr entry; - MP4AMRWPSpecificInfoAtomPtr AMRSpecificInfoAtom; - MP4TrackAtomPtr trak; - MP4Media media; - u32 timeScale; - - if ( (theTrack == NULL) || (sampleDescriptionH == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - if (!( trak->newTrackFlags & MP4NewTrackIsAudio )) BAILWITHERROR (MP4BadParamErr ); - err = MP4CreateAudioSampleEntryAtom( (MP4AudioSampleEntryAtomPtr*) &entry ); if (err) goto bail; - - err = MP4GetTrackMedia( theTrack, &media ); if (err) goto bail; - err = MP4GetMediaTimeScale( media, &timeScale ); if (err) goto bail; - entry->timeScale = timeScale; - - entry->dataReferenceIndex = dataReferenceIndex; - entry->type = MP4AMRWPSampleEntryAtomType; - - err = MP4CreateAMRWPSpecificInfoAtom( &AMRSpecificInfoAtom ); if (err) goto bail; - AMRSpecificInfoAtom->vendor = vendor; - AMRSpecificInfoAtom->decoder_version = decoder_version; - - err = MP4AddListEntry( (void*) AMRSpecificInfoAtom, entry->ExtensionAtomList); if (err) goto bail; - - err = atomPtrToSampleEntryH( sampleDescriptionH, (MP4AtomPtr) entry ); if (err) goto bail; + MP4Err err; + MP4AudioSampleEntryAtomPtr entry; + MP4AMRWPSpecificInfoAtomPtr AMRSpecificInfoAtom; + MP4TrackAtomPtr trak; + MP4Media media; + u32 timeScale; + + if((theTrack == NULL) || (sampleDescriptionH == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + if(!(trak->newTrackFlags & MP4NewTrackIsAudio)) BAILWITHERROR(MP4BadParamErr); + err = MP4CreateAudioSampleEntryAtom((MP4AudioSampleEntryAtomPtr *)&entry); + if(err) goto bail; + + err = MP4GetTrackMedia(theTrack, &media); + if(err) goto bail; + err = MP4GetMediaTimeScale(media, &timeScale); + if(err) goto bail; + entry->timeScale = timeScale; + + entry->dataReferenceIndex = dataReferenceIndex; + entry->type = MP4AMRWPSampleEntryAtomType; + + err = MP4CreateAMRWPSpecificInfoAtom(&AMRSpecificInfoAtom); + if(err) goto bail; + AMRSpecificInfoAtom->vendor = vendor; + AMRSpecificInfoAtom->decoder_version = decoder_version; + + err = MP4AddListEntry((void *)AMRSpecificInfoAtom, entry->ExtensionAtomList); + if(err) goto bail; + + err = atomPtrToSampleEntryH(sampleDescriptionH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if ( entry ) - entry->destroy( (MP4AtomPtr) entry ); - - TEST_RETURN( err ); - - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + + TEST_RETURN(err); + + return err; } /* whole loads of bitBuffer stuff for parsing parameter sets */ -typedef struct { - u8 *ptr; - u32 length; - u8 *cptr; - u8 cbyte; - u32 curbits; - u32 bits_left; - - u8 prevent_emulation; /* true or false */ - u8 emulation_position; /* 0 usually, 1 after 1 zero byte, 2 after 2 zero bytes, - 3 after 00 00 03, and the 3 gets stripped */ +typedef struct +{ + u8 *ptr; + u32 length; + u8 *cptr; + u8 cbyte; + u32 curbits; + u32 bits_left; + + u8 prevent_emulation; /* true or false */ + u8 emulation_position; /* 0 usually, 1 after 1 zero byte, 2 after 2 zero bytes, + 3 after 00 00 03, and the 3 gets stripped + */ } BitBuffer; static MP4Err BitBuffer_Init(BitBuffer *bb, u8 *p, u32 length) { - int err = MP4NoErr; - - if (length > 0x0fffffff) { - err = MP4BadParamErr; - goto bail; - } - - bb->ptr = (void*)p; - bb->length = length; - - bb->cptr = (void*)p; - bb->cbyte = *bb->cptr; - bb->curbits = 8; - - bb->bits_left = length * 8; - - bb->prevent_emulation = 0; - bb->emulation_position = (bb->cbyte == 0 ? 1 : 0); - + int err = MP4NoErr; + + if(length > 0x0fffffff) + { + err = MP4BadParamErr; + goto bail; + } + + bb->ptr = (void *)p; + bb->length = length; + + bb->cptr = (void *)p; + bb->cbyte = *bb->cptr; + bb->curbits = 8; + + bb->bits_left = length * 8; + + bb->prevent_emulation = 0; + bb->emulation_position = (bb->cbyte == 0 ? 1 : 0); + bail: - return err; + return err; } - static u32 GetBits(BitBuffer *bb, u32 nBits, MP4Err *errout) { - MP4Err err = MP4NoErr; - int myBits; - int myValue; - int myResidualBits; - int leftToRead; - - myValue = 0; - if (nBits>bb->bits_left) { - err = MP4EOF; - goto bail; - } - - if (bb->curbits <= 0) { - bb->cbyte = *++bb->cptr; - bb->curbits = 8; - - if (bb->prevent_emulation != 0) { - if ((bb->emulation_position >= 2) && (bb->cbyte == 3)) { - bb->cbyte = *++bb->cptr; - bb->bits_left -= 8; - bb->emulation_position = bb->cbyte ? 0 : 1; - if (nBits>bb->bits_left) { - err = MP4EOF; - goto bail; - } - } - else if (bb->cbyte == 0) bb->emulation_position += 1; - else bb->emulation_position = 0; - } - } - - if (nBits > bb->curbits) - myBits = bb->curbits; - else - myBits = nBits; - - myValue = (bb->cbyte>>(8-myBits)); - myResidualBits = bb->curbits - myBits; - leftToRead = nBits - myBits; - bb->bits_left -= myBits; - - bb->curbits = myResidualBits; - bb->cbyte = ((bb->cbyte) << myBits) & 0xff; - - if (leftToRead > 0) { - u32 newBits; - newBits = GetBits(bb, leftToRead, &err); - myValue = (myValue< bb->bits_left) + { + err = MP4EOF; + goto bail; + } + + if(bb->curbits <= 0) + { + bb->cbyte = *++bb->cptr; + bb->curbits = 8; + + if(bb->prevent_emulation != 0) + { + if((bb->emulation_position >= 2) && (bb->cbyte == 3)) + { + bb->cbyte = *++bb->cptr; + bb->bits_left -= 8; + bb->emulation_position = bb->cbyte ? 0 : 1; + if(nBits > bb->bits_left) + { + err = MP4EOF; + goto bail; + } + } + else if(bb->cbyte == 0) + bb->emulation_position += 1; + else + bb->emulation_position = 0; + } + } + + if(nBits > bb->curbits) myBits = bb->curbits; + else + myBits = nBits; + + myValue = (bb->cbyte >> (8 - myBits)); + myResidualBits = bb->curbits - myBits; + leftToRead = nBits - myBits; + bb->bits_left -= myBits; + + bb->curbits = myResidualBits; + bb->cbyte = ((bb->cbyte) << myBits) & 0xff; + + if(leftToRead > 0) + { + u32 newBits; + newBits = GetBits(bb, leftToRead, &err); + myValue = (myValue << leftToRead) | newBits; + } + +bail: + if(errout) *errout = err; + return myValue; } static MP4Err GetBytes(BitBuffer *bb, u32 nBytes, u8 *p) { - MP4Err err = MP4NoErr; - unsigned int i; - - for (i = 0; i < nBytes; i++) { - *p++ = (u8)GetBits(bb, 8, &err); - if (err) break; - } - - return err; + MP4Err err = MP4NoErr; + unsigned int i; + + for(i = 0; i < nBytes; i++) + { + *p++ = (u8)GetBits(bb, 8, &err); + if(err) break; + } + + return err; } static u32 read_golomb_uev(BitBuffer *bb, MP4Err *errout) { - MP4Err err = MP4NoErr; - - u32 power = 1; - u32 value = 0; - u32 leading = 0; - u32 nbits = 0; - - leading = GetBits(bb, 1, &err); if (err) goto bail; - - while (leading == 0) { - power = power << 1; - nbits++; - leading = GetBits(bb, 1, &err); if (err) goto bail; - } - - if (nbits > 0) { - value = GetBits( bb, nbits, &err); if (err) goto bail; - } - + MP4Err err = MP4NoErr; + + u32 power = 1; + u32 value = 0; + u32 leading = 0; + u32 nbits = 0; + + leading = GetBits(bb, 1, &err); + if(err) goto bail; + + while(leading == 0) + { + power = power << 1; + nbits++; + leading = GetBits(bb, 1, &err); + if(err) goto bail; + } + + if(nbits > 0) + { + value = GetBits(bb, nbits, &err); + if(err) goto bail; + } + bail: - if (errout) *errout = err; - return (power - 1 + value); + if(errout) *errout = err; + return (power - 1 + value); } -MP4_EXTERN ( MP4Err ) ISONewAVCSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 length_size, MP4Handle first_sps, MP4Handle first_pps, MP4Handle first_spsext ) +MP4_EXTERN(MP4Err) +ISONewAVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, + u32 length_size, MP4Handle first_sps, MP4Handle first_pps, + MP4Handle first_spsext) { - MP4Err MP4CreateVisualSampleEntryAtom( MP4VisualSampleEntryAtomPtr *outAtom ); - MP4Err MP4CreateVCConfigAtom( ISOVCConfigAtomPtr *outAtom ); - - MP4Err err; - GenericSampleEntryAtomPtr entry; - ISOVCConfigAtomPtr config; - MP4TrackAtomPtr trak; - BitBuffer mybb; - BitBuffer *bb; - - u32 the_size, y; - u8 x; - - if ( (theTrack == NULL) || (sampleDescriptionH == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - if (!( trak->newTrackFlags & MP4NewTrackIsVisual )) BAILWITHERROR (MP4BadParamErr ); - err = MP4CreateVisualSampleEntryAtom( (MP4VisualSampleEntryAtomPtr*) &entry ); if (err) goto bail; - - entry->dataReferenceIndex = dataReferenceIndex; - entry->type = ISOAVCSampleEntryAtomType; - - err = MP4CreateVCConfigAtom( &config ); - config->length_size = length_size; - - err = MP4AddListEntry( (void*) config, entry->ExtensionAtomList); if (err) goto bail; - - if (!first_sps) BAILWITHERROR( MP4BadParamErr ); - err = MP4GetHandleSize( first_sps, &the_size ); if (err) goto bail; - - bb = &mybb; - err = BitBuffer_Init( bb, (u8*) *first_sps, 8*the_size ); if (err) goto bail; - err = GetBytes( bb, 1, &x ); if (err) goto bail; - if ((x & 0x1F) != 7) BAILWITHERROR( MP4BadParamErr ); - /* 7 == SPS */ - err = GetBytes( bb, 1, &x ); if (err) goto bail; - config->profile = x; - err = GetBytes( bb, 1, &x ); if (err) goto bail; - config->profile_compatibility = x; - err = GetBytes( bb, 1, &x ); if (err) goto bail; - config->level = x; - y = read_golomb_uev( bb, &err ); if (err) goto bail; /* PPS ID */ - if( (config->profile == 100) || (config->profile == 110) || - (config->profile == 122) || (config->profile == 144) ) - { - y = read_golomb_uev( bb, &err ); if (err) goto bail; - config->chroma_format = y; - y = read_golomb_uev( bb, &err ); if (err) goto bail; - config->bit_depth_luma_minus8 = y; - y = read_golomb_uev( bb, &err ); if (err) goto bail; - config->bit_depth_chroma_minus8 = y; - } - - if (first_sps && first_pps) - { err = config->addParameterSet( config, first_sps, AVCsps ); if (err) goto bail; } - if (first_pps) { err = config->addParameterSet( config, first_pps, AVCpps ); if (err) goto bail; } - if (first_spsext) { err = config->addParameterSet( config, first_spsext, AVCspsext ); if (err) goto bail; } - - err = atomPtrToSampleEntryH( sampleDescriptionH, (MP4AtomPtr) entry ); if (err) goto bail; + MP4Err MP4CreateVisualSampleEntryAtom(MP4VisualSampleEntryAtomPtr * outAtom); + MP4Err MP4CreateVCConfigAtom(ISOVCConfigAtomPtr * outAtom); + + MP4Err err; + GenericSampleEntryAtomPtr entry; + ISOVCConfigAtomPtr config; + MP4TrackAtomPtr trak; + BitBuffer mybb; + BitBuffer *bb; + + u32 the_size, y; + u8 x; + + if((theTrack == NULL) || (sampleDescriptionH == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + if(!(trak->newTrackFlags & MP4NewTrackIsVisual)) BAILWITHERROR(MP4BadParamErr); + err = MP4CreateVisualSampleEntryAtom((MP4VisualSampleEntryAtomPtr *)&entry); + if(err) goto bail; + + entry->dataReferenceIndex = dataReferenceIndex; + entry->type = ISOAVCSampleEntryAtomType; + + err = MP4CreateVCConfigAtom(&config); + config->length_size = length_size; + + err = MP4AddListEntry((void *)config, entry->ExtensionAtomList); + if(err) goto bail; + + if(!first_sps) BAILWITHERROR(MP4BadParamErr); + err = MP4GetHandleSize(first_sps, &the_size); + if(err) goto bail; + + bb = &mybb; + err = BitBuffer_Init(bb, (u8 *)*first_sps, 8 * the_size); + if(err) goto bail; + err = GetBytes(bb, 1, &x); + if(err) goto bail; + if((x & 0x1F) != 7) BAILWITHERROR(MP4BadParamErr); + /* 7 == SPS */ + err = GetBytes(bb, 1, &x); + if(err) goto bail; + config->profile = x; + err = GetBytes(bb, 1, &x); + if(err) goto bail; + config->profile_compatibility = x; + err = GetBytes(bb, 1, &x); + if(err) goto bail; + config->level = x; + y = read_golomb_uev(bb, &err); + if(err) goto bail; /* PPS ID */ + if((config->profile == 100) || (config->profile == 110) || (config->profile == 122) || + (config->profile == 144)) + { + y = read_golomb_uev(bb, &err); + if(err) goto bail; + config->chroma_format = y; + y = read_golomb_uev(bb, &err); + if(err) goto bail; + config->bit_depth_luma_minus8 = y; + y = read_golomb_uev(bb, &err); + if(err) goto bail; + config->bit_depth_chroma_minus8 = y; + } + + if(first_sps && first_pps) + { + err = config->addParameterSet(config, first_sps, AVCsps); + if(err) goto bail; + } + if(first_pps) + { + err = config->addParameterSet(config, first_pps, AVCpps); + if(err) goto bail; + } + if(first_spsext) + { + err = config->addParameterSet(config, first_spsext, AVCspsext); + if(err) goto bail; + } + + err = atomPtrToSampleEntryH(sampleDescriptionH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - if ( entry ) - entry->destroy( (MP4AtomPtr) entry ); - - TEST_RETURN( err ); - - return err; -} + if(entry) entry->destroy((MP4AtomPtr)entry); -MP4_EXTERN ( MP4Err ) ISOAddVCSampleDescriptionPS( MP4Handle sampleEntryH, - MP4Handle ps, u32 where ) -{ - MP4Err err = MP4NoErr; - ISOVCConfigAtomPtr config; - MP4VisualSampleEntryAtomPtr entry = NULL; - - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4GenericSampleEntryAtomType ); if (err) goto bail; - - if (entry->type != ISOAVCSampleEntryAtomType) BAILWITHERROR( MP4BadParamErr ); - - err = MP4GetListEntryAtom( entry->ExtensionAtomList, ISOVCConfigAtomType, (MP4AtomPtr*) &config ); - if ( err == MP4NotFoundErr ) - { - BAILWITHERROR( MP4BadDataErr ); - } - - err = config->addParameterSet( config, ps, where ); if (err) goto bail; - - /* rewrite it... */ - err = atomPtrToSampleEntryH( sampleEntryH, (MP4AtomPtr) entry ); if (err) goto bail; + TEST_RETURN(err); -bail: - if (entry) - entry->destroy((MP4AtomPtr) entry); - return err; + return err; } -MP4_EXTERN ( MP4Err ) ISOGetAVCSampleDescription( MP4Handle sampleEntryH, - u32 *dataReferenceIndex, - u32 *length_size, u32* sps_count, u32* pps_count, u32* spsext_count ) +MP4_EXTERN(MP4Err) ISOAddVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where) { - MP4Err err = MP4NoErr; - MP4VisualSampleEntryAtomPtr entry = NULL; - ISOVCConfigAtomPtr config; - - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4VisualSampleEntryAtomType ); if (err) goto bail; - - if (entry->type != ISOAVCSampleEntryAtomType) BAILWITHERROR( MP4BadParamErr ); - err = MP4GetListEntryAtom( entry->ExtensionAtomList, ISOVCConfigAtomType, (MP4AtomPtr*) &config ); - if ( err == MP4NotFoundErr ) - { - BAILWITHERROR( MP4BadDataErr ); - } - - *dataReferenceIndex = entry->dataReferenceIndex; - *length_size = config->length_size; - err = MP4GetListEntryCount( config->spsList, sps_count ); if (err) goto bail; - err = MP4GetListEntryCount( config->ppsList, pps_count ); if (err) goto bail; - err = MP4GetListEntryCount( config->spsextList, spsext_count ); if (err) goto bail; - + MP4Err err = MP4NoErr; + ISOVCConfigAtomPtr config; + MP4VisualSampleEntryAtomPtr entry = NULL; + + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4GenericSampleEntryAtomType); + if(err) goto bail; + + if(entry->type != ISOAVCSampleEntryAtomType) BAILWITHERROR(MP4BadParamErr); + + err = MP4GetListEntryAtom(entry->ExtensionAtomList, ISOVCConfigAtomType, (MP4AtomPtr *)&config); + if(err == MP4NotFoundErr) + { + BAILWITHERROR(MP4BadDataErr); + } + + err = config->addParameterSet(config, ps, where); + if(err) goto bail; + + /* rewrite it... */ + err = atomPtrToSampleEntryH(sampleEntryH, (MP4AtomPtr)entry); + if(err) goto bail; + bail: - if (entry) - entry->destroy((MP4AtomPtr) entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN ( MP4Err ) ISOGetVCSampleDescriptionPS( MP4Handle sampleEntryH, - MP4Handle ps, u32 where, u32 index ) +MP4_EXTERN(MP4Err) +ISOGetAVCSampleDescription(MP4Handle sampleEntryH, u32 *dataReferenceIndex, u32 *length_size, + u32 *sps_count, u32 *pps_count, u32 *spsext_count) { - MP4Err err = MP4NoErr; - MP4VisualSampleEntryAtomPtr entry = NULL; - ISOVCConfigAtomPtr config; - - err = sampleEntryHToAtomPtr( sampleEntryH, (MP4AtomPtr *) &entry, MP4VisualSampleEntryAtomType ); if (err) goto bail; - - if (entry->type != ISOAVCSampleEntryAtomType) BAILWITHERROR( MP4BadParamErr ); - err = MP4GetListEntryAtom( entry->ExtensionAtomList, ISOVCConfigAtomType, (MP4AtomPtr*) &config ); - if ( err == MP4NotFoundErr ) - { - BAILWITHERROR( MP4BadDataErr ); - } - - err = config->getParameterSet( config, ps, where, index ); if (err) goto bail; - + MP4Err err = MP4NoErr; + MP4VisualSampleEntryAtomPtr entry = NULL; + ISOVCConfigAtomPtr config; + + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); + if(err) goto bail; + + if(entry->type != ISOAVCSampleEntryAtomType) BAILWITHERROR(MP4BadParamErr); + err = MP4GetListEntryAtom(entry->ExtensionAtomList, ISOVCConfigAtomType, (MP4AtomPtr *)&config); + if(err == MP4NotFoundErr) + { + BAILWITHERROR(MP4BadDataErr); + } + + *dataReferenceIndex = entry->dataReferenceIndex; + *length_size = config->length_size; + err = MP4GetListEntryCount(config->spsList, sps_count); + if(err) goto bail; + err = MP4GetListEntryCount(config->ppsList, pps_count); + if(err) goto bail; + err = MP4GetListEntryCount(config->spsextList, spsext_count); + if(err) goto bail; + bail: - if (entry) - entry->destroy((MP4AtomPtr) entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN(MP4Err) ISOGetHEVCSampleDescriptionPS(MP4Handle sampleEntryH, - MP4Handle ps, - u32 where, - u32 index) { - MP4Err err = MP4NoErr; - MP4VisualSampleEntryAtomPtr entry = NULL; - ISOHEVCConfigAtomPtr config; +MP4_EXTERN(MP4Err) +ISOGetVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index) +{ + MP4Err err = MP4NoErr; + MP4VisualSampleEntryAtomPtr entry = NULL; + ISOVCConfigAtomPtr config; - err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); if (err) goto bail; + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); + if(err) goto bail; - if (entry->type != ISOHEVCSampleEntryAtomType) BAILWITHERROR(MP4BadParamErr); - err = MP4GetListEntryAtom(entry->ExtensionAtomList, ISOHEVCConfigAtomType, (MP4AtomPtr*)&config); - if (err == MP4NotFoundErr) { - BAILWITHERROR(MP4BadDataErr); - } + if(entry->type != ISOAVCSampleEntryAtomType) BAILWITHERROR(MP4BadParamErr); + err = MP4GetListEntryAtom(entry->ExtensionAtomList, ISOVCConfigAtomType, (MP4AtomPtr *)&config); + if(err == MP4NotFoundErr) + { + BAILWITHERROR(MP4BadDataErr); + } - err = config->getParameterSet(config, ps, where, index); if (err) goto bail; + err = config->getParameterSet(config, ps, where, index); + if(err) goto bail; bail: - if (entry) - entry->destroy((MP4AtomPtr)entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN(MP4Err) ISOGetRESVSampleDescriptionPS(MP4Handle sampleEntryH, - MP4Handle ps, - u32 where, - u32 index) { - MP4Err err = MP4NoErr; - MP4VisualSampleEntryAtomPtr entry = NULL; - ISOHEVCConfigAtomPtr config; - - err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); if (err) goto bail; +MP4_EXTERN(MP4Err) +ISOGetHEVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index) +{ + MP4Err err = MP4NoErr; + MP4VisualSampleEntryAtomPtr entry = NULL; + ISOHEVCConfigAtomPtr config; - if (entry->type != MP4RestrictedVideoSampleEntryAtomType) BAILWITHERROR(MP4BadParamErr); + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); + if(err) goto bail; - err = MP4GetListEntryAtom(entry->ExtensionAtomList, ISOHEVCConfigAtomType, (MP4AtomPtr*)&config); - if (err == MP4NotFoundErr) { - BAILWITHERROR(MP4BadDataErr); - } + if(entry->type != ISOHEVCSampleEntryAtomType) BAILWITHERROR(MP4BadParamErr); + err = MP4GetListEntryAtom(entry->ExtensionAtomList, ISOHEVCConfigAtomType, (MP4AtomPtr *)&config); + if(err == MP4NotFoundErr) + { + BAILWITHERROR(MP4BadDataErr); + } - err = config->getParameterSet(config, ps, where, index); if (err) goto bail; + err = config->getParameterSet(config, ps, where, index); + if(err) goto bail; bail: - if (entry) - entry->destroy((MP4AtomPtr)entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN(MP4Err) ISOGetRESVLengthSizeMinusOne(MP4Handle sampleEntryH, u32* out) +MP4_EXTERN(MP4Err) +ISOGetRESVSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index) { - MP4Err err = MP4NoErr; - MP4VisualSampleEntryAtomPtr entry = NULL; - ISOHEVCConfigAtomPtr config; - - if (!out) { - goto bail; - } + MP4Err err = MP4NoErr; + MP4VisualSampleEntryAtomPtr entry = NULL; + ISOHEVCConfigAtomPtr config; - err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); - if (err) { - goto bail; - } + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); + if(err) goto bail; - if (entry->type != MP4RestrictedVideoSampleEntryAtomType) { - BAILWITHERROR(MP4BadParamErr); - } + if(entry->type != MP4RestrictedVideoSampleEntryAtomType) BAILWITHERROR(MP4BadParamErr); - err = MP4GetListEntryAtom(entry->ExtensionAtomList, ISOHEVCConfigAtomType, (MP4AtomPtr*)&config); - if (err == MP4NotFoundErr) { - BAILWITHERROR(MP4BadDataErr); - } + err = MP4GetListEntryAtom(entry->ExtensionAtomList, ISOHEVCConfigAtomType, (MP4AtomPtr *)&config); + if(err == MP4NotFoundErr) + { + BAILWITHERROR(MP4BadDataErr); + } - *out = config->lengthSizeMinusOne; + err = config->getParameterSet(config, ps, where, index); + if(err) goto bail; bail: - if (entry) { - entry->destroy((MP4AtomPtr)entry); - } - - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN(MP4Err) ISOGetRESVOriginalFormat(MP4Handle sampleEntryH, - u32* outOrigFmt) +MP4_EXTERN(MP4Err) ISOGetRESVLengthSizeMinusOne(MP4Handle sampleEntryH, u32 *out) { - MP4Err err = MP4NoErr; - MP4RestrictedVideoSampleEntryAtomPtr entry = NULL; /* MP4RestrictedVideoSampleEntryAtomPtr | MP4VisualSampleEntryAtomPtr */ - MP4RestrictedSchemeInfoAtomPtr rinf; - MP4OriginalFormatAtomPtr fmt; - - err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); if (err) goto bail; + MP4Err err = MP4NoErr; + MP4VisualSampleEntryAtomPtr entry = NULL; + ISOHEVCConfigAtomPtr config; + + if(!out) + { + goto bail; + } + + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); + if(err) + { + goto bail; + } + + if(entry->type != MP4RestrictedVideoSampleEntryAtomType) + { + BAILWITHERROR(MP4BadParamErr); + } + + err = MP4GetListEntryAtom(entry->ExtensionAtomList, ISOHEVCConfigAtomType, (MP4AtomPtr *)&config); + if(err == MP4NotFoundErr) + { + BAILWITHERROR(MP4BadDataErr); + } + + *out = config->lengthSizeMinusOne; - if (entry->type != MP4RestrictedVideoSampleEntryAtomType) BAILWITHERROR(MP4BadParamErr); - - rinf = (MP4RestrictedSchemeInfoAtomPtr)entry->MP4RestrictedSchemeInfo; - if (!rinf) { BAILWITHERROR(MP4BadParamErr); } +bail: + if(entry) + { + entry->destroy((MP4AtomPtr)entry); + } - fmt = (MP4OriginalFormatAtomPtr)rinf->MP4OriginalFormat; - if (!fmt) { BAILWITHERROR(MP4BadParamErr); } + return err; +} - *outOrigFmt = fmt->original_format; +MP4_EXTERN(MP4Err) ISOGetRESVOriginalFormat(MP4Handle sampleEntryH, u32 *outOrigFmt) +{ + MP4Err err = MP4NoErr; + MP4RestrictedVideoSampleEntryAtomPtr entry = + NULL; /* MP4RestrictedVideoSampleEntryAtomPtr | MP4VisualSampleEntryAtomPtr */ + MP4RestrictedSchemeInfoAtomPtr rinf; + MP4OriginalFormatAtomPtr fmt; + + err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); + if(err) goto bail; + + if(entry->type != MP4RestrictedVideoSampleEntryAtomType) BAILWITHERROR(MP4BadParamErr); + + rinf = (MP4RestrictedSchemeInfoAtomPtr)entry->MP4RestrictedSchemeInfo; + if(!rinf) + { + BAILWITHERROR(MP4BadParamErr); + } + + fmt = (MP4OriginalFormatAtomPtr)rinf->MP4OriginalFormat; + if(!fmt) + { + BAILWITHERROR(MP4BadParamErr); + } + + *outOrigFmt = fmt->original_format; bail: - if (entry) - entry->destroy((MP4AtomPtr)entry); - return err; + if(entry) entry->destroy((MP4AtomPtr)entry); + return err; } -MP4_EXTERN(MP4Err) ISONewHEVCSampleDescription(MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 length_size, - MP4Handle first_sps, - MP4Handle first_pps, - MP4Handle first_vps) { - MP4Err MP4CreateVisualSampleEntryAtom(MP4VisualSampleEntryAtomPtr *outAtom); - MP4Err MP4CreateHEVCConfigAtom(ISOHEVCConfigAtomPtr *outAtom); - - MP4Err err; - GenericSampleEntryAtomPtr entry; - ISOHEVCConfigAtomPtr config; - MP4TrackAtomPtr trak; - BitBuffer mybb; - BitBuffer *bb; - - u32 the_size, y, width, height; - u8 x; - u32 ii; - u8 i; - u8 sps_max_sub_layers; - u8 sub_layer_profile_present_flag[8]; - u8 sub_layer_level_present_flag[8]; - - if ((theTrack == NULL) || (sampleDescriptionH == NULL)) { - BAILWITHERROR(MP4BadParamErr); - } - - trak = (MP4TrackAtomPtr)theTrack; - if (!(trak->newTrackFlags & MP4NewTrackIsVisual)) BAILWITHERROR(MP4BadParamErr); - err = MP4CreateVisualSampleEntryAtom((MP4VisualSampleEntryAtomPtr*)&entry); if (err) goto bail; - entry->super = NULL; - - entry->dataReferenceIndex = dataReferenceIndex; - entry->type = ISOHEVCSampleEntryAtomType; - - err = MP4CreateHEVCConfigAtom(&config); - config->lengthSizeMinusOne = length_size-1; - - err = MP4AddListEntry((void*)config, entry->ExtensionAtomList); if (err) goto bail; - - if (!first_sps) BAILWITHERROR(MP4BadParamErr); - err = MP4GetHandleSize(first_sps, &the_size); if (err) goto bail; - - bb = &mybb; - err = BitBuffer_Init(bb, (u8*)*first_sps, 8 * the_size); if (err) goto bail; - bb->prevent_emulation = 1; - - /* Get first header byte for nal_unit_type */ - err = GetBytes(bb, 1, &x); if (err) goto bail; - - /* 33 == SPS */ - if ((x>>1) != 33) BAILWITHERROR(MP4BadParamErr); - - /* Skip second header byte */ - err = GetBytes(bb, 1, &x); if (err) goto bail; - - /* sps_video_parameter_set_id (4) + sps_max_sub_layers_minus1 (3) + sps_temporal_id_nesting_flag (1) */ - err = GetBytes(bb, 1, &x); if (err) goto bail; - sps_max_sub_layers = ((x & 0xf) >> 1)+1; - config->sps_temporal_id_nesting_flag = x & 1; - - /* profile_tier_level */ - /* general_profile_space (2) + general_tier_flag (1) + general_profile_idc (5) */ - err = GetBytes(bb, 1, &x); if (err) goto bail; - config->general_profile_idc = x & 0x1f; - - /* general_profile_compatibility_flag[32] */ - config->general_profile_compatibility_flags = 0; - for (i = 0; i < 4; i++) { - err = GetBytes(bb, 1, &x); if (err) goto bail; - config->general_profile_compatibility_flags |= x << ((3 - i) * 8); - } - - /* progressive_source + interlaced_source + non_packed_constraint + - frame_only_constraint + general_reserved_zero_44bits[44] */ - for (i = 0; i < 6; i++) { - err = GetBytes(bb, 1, &x); if (err) goto bail; - } - - /* general_level_idc */ - err = GetBytes(bb, 1, &x); if (err) goto bail; - config->general_level_idc = x; - - /* sub_layer_profile_present_flag[i] + sub_layer_level_present_flag[i] */ - for (i = 0; i < sps_max_sub_layers - 1; i++) { - sub_layer_profile_present_flag[i] = GetBits(bb, 1, &err); if (err) goto bail; - sub_layer_level_present_flag[i] = GetBits(bb, 1, &err); if (err) goto bail; - } - /* reserved_zero_2bits[ i ] */ - if (sps_max_sub_layers > 1) { - x = GetBits(bb, 16 - (sps_max_sub_layers - 1)*2, &err); if (err) goto bail; - } - - /* We are byte-aligned at this point */ - for (i = 0; i < sps_max_sub_layers - 1; i++) { - if (sub_layer_profile_present_flag[i]) { - for (ii = 0; ii < 11; ii++) { - err = GetBytes(bb, 1, &x); if (err) goto bail; - } - } - if (sub_layer_level_present_flag[i]) { - err = GetBytes(bb, 1, &x); if (err) goto bail; - } - } - /* end profile_tier_level */ - - /* sps_seq_parameter_set_id */ - y = read_golomb_uev(bb, &err); if (err) goto bail; - /* chroma_format_idc */ - y = read_golomb_uev(bb, &err); if (err) goto bail; - config->chromaFormat = y; - if (y == 3) { - /* separate_colour_plane_flag */ - x = GetBits(bb, 1, &err); if (err) goto bail; - } - /* pic_width_in_luma_samples */ - width = read_golomb_uev(bb, &err); if (err) goto bail; - ((MP4VisualSampleEntryAtomPtr)entry)->width = width; - - - /* pic_height_in_luma_samples */ - height = read_golomb_uev(bb, &err); if (err) goto bail; - ((MP4VisualSampleEntryAtomPtr)entry)->height = height; - ((MP4TrackAtomPtr)theTrack)->setDimensions(theTrack, width, height); - - /* conformance_window_flag */ - x = GetBits(bb, 1, &err); if (err) goto bail; - if (x) { - /* conf_win_[left|right|top|bottom]_offset */ - for (i = 0; i < 4; i++) { - x = read_golomb_uev(bb, &err); if (err) goto bail; - } - } - - /* bit_depth_luma_minus8 */ - y = read_golomb_uev(bb, &err); if (err) goto bail; - config->bitDepthLumaMinus8 = y; - - /* bit_depth_chroma_minus8 */ - y = read_golomb_uev(bb, &err); if (err) goto bail; - config->bitDepthChromaMinus8 = y; - - - if (first_vps) { err = config->addParameterSet(config, first_vps, 32); if (err) goto bail; } - if (first_sps) { err = config->addParameterSet(config, first_sps, 33); if (err) goto bail; } - if (first_pps) { err = config->addParameterSet(config, first_pps, 34); if (err) goto bail; } - - err = atomPtrToSampleEntryH(sampleDescriptionH, (MP4AtomPtr)entry); if (err) goto bail; +MP4_EXTERN(MP4Err) +ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, + u32 length_size, MP4Handle first_sps, MP4Handle first_pps, + MP4Handle first_vps) +{ + MP4Err MP4CreateVisualSampleEntryAtom(MP4VisualSampleEntryAtomPtr * outAtom); + MP4Err MP4CreateHEVCConfigAtom(ISOHEVCConfigAtomPtr * outAtom); + + MP4Err err; + GenericSampleEntryAtomPtr entry; + ISOHEVCConfigAtomPtr config; + MP4TrackAtomPtr trak; + BitBuffer mybb; + BitBuffer *bb; + + u32 the_size, y, width, height; + u8 x; + u32 ii; + u8 i; + u8 sps_max_sub_layers; + u8 sub_layer_profile_present_flag[8]; + u8 sub_layer_level_present_flag[8]; + + if((theTrack == NULL) || (sampleDescriptionH == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + if(!(trak->newTrackFlags & MP4NewTrackIsVisual)) BAILWITHERROR(MP4BadParamErr); + err = MP4CreateVisualSampleEntryAtom((MP4VisualSampleEntryAtomPtr *)&entry); + if(err) goto bail; + entry->super = NULL; + + entry->dataReferenceIndex = dataReferenceIndex; + entry->type = ISOHEVCSampleEntryAtomType; + + err = MP4CreateHEVCConfigAtom(&config); + config->lengthSizeMinusOne = length_size - 1; + + err = MP4AddListEntry((void *)config, entry->ExtensionAtomList); + if(err) goto bail; + + if(!first_sps) BAILWITHERROR(MP4BadParamErr); + err = MP4GetHandleSize(first_sps, &the_size); + if(err) goto bail; + + bb = &mybb; + err = BitBuffer_Init(bb, (u8 *)*first_sps, 8 * the_size); + if(err) goto bail; + bb->prevent_emulation = 1; + + /* Get first header byte for nal_unit_type */ + err = GetBytes(bb, 1, &x); + if(err) goto bail; + + /* 33 == SPS */ + if((x >> 1) != 33) BAILWITHERROR(MP4BadParamErr); + + /* Skip second header byte */ + err = GetBytes(bb, 1, &x); + if(err) goto bail; + + /* sps_video_parameter_set_id (4) + sps_max_sub_layers_minus1 (3) + sps_temporal_id_nesting_flag + * (1) */ + err = GetBytes(bb, 1, &x); + if(err) goto bail; + sps_max_sub_layers = ((x & 0xf) >> 1) + 1; + config->sps_temporal_id_nesting_flag = x & 1; + + /* profile_tier_level */ + /* general_profile_space (2) + general_tier_flag (1) + general_profile_idc (5) */ + err = GetBytes(bb, 1, &x); + if(err) goto bail; + config->general_profile_idc = x & 0x1f; + + /* general_profile_compatibility_flag[32] */ + config->general_profile_compatibility_flags = 0; + for(i = 0; i < 4; i++) + { + err = GetBytes(bb, 1, &x); + if(err) goto bail; + config->general_profile_compatibility_flags |= x << ((3 - i) * 8); + } + + /* progressive_source + interlaced_source + non_packed_constraint + + frame_only_constraint + general_reserved_zero_44bits[44] */ + for(i = 0; i < 6; i++) + { + err = GetBytes(bb, 1, &x); + if(err) goto bail; + } + + /* general_level_idc */ + err = GetBytes(bb, 1, &x); + if(err) goto bail; + config->general_level_idc = x; + + /* sub_layer_profile_present_flag[i] + sub_layer_level_present_flag[i] */ + for(i = 0; i < sps_max_sub_layers - 1; i++) + { + sub_layer_profile_present_flag[i] = GetBits(bb, 1, &err); + if(err) goto bail; + sub_layer_level_present_flag[i] = GetBits(bb, 1, &err); + if(err) goto bail; + } + /* reserved_zero_2bits[ i ] */ + if(sps_max_sub_layers > 1) + { + x = GetBits(bb, 16 - (sps_max_sub_layers - 1) * 2, &err); + if(err) goto bail; + } + + /* We are byte-aligned at this point */ + for(i = 0; i < sps_max_sub_layers - 1; i++) + { + if(sub_layer_profile_present_flag[i]) + { + for(ii = 0; ii < 11; ii++) + { + err = GetBytes(bb, 1, &x); + if(err) goto bail; + } + } + if(sub_layer_level_present_flag[i]) + { + err = GetBytes(bb, 1, &x); + if(err) goto bail; + } + } + /* end profile_tier_level */ + + /* sps_seq_parameter_set_id */ + y = read_golomb_uev(bb, &err); + if(err) goto bail; + /* chroma_format_idc */ + y = read_golomb_uev(bb, &err); + if(err) goto bail; + config->chromaFormat = y; + if(y == 3) + { + /* separate_colour_plane_flag */ + x = GetBits(bb, 1, &err); + if(err) goto bail; + } + /* pic_width_in_luma_samples */ + width = read_golomb_uev(bb, &err); + if(err) goto bail; + ((MP4VisualSampleEntryAtomPtr)entry)->width = width; + + /* pic_height_in_luma_samples */ + height = read_golomb_uev(bb, &err); + if(err) goto bail; + ((MP4VisualSampleEntryAtomPtr)entry)->height = height; + ((MP4TrackAtomPtr)theTrack)->setDimensions(theTrack, width, height); + + /* conformance_window_flag */ + x = GetBits(bb, 1, &err); + if(err) goto bail; + if(x) + { + /* conf_win_[left|right|top|bottom]_offset */ + for(i = 0; i < 4; i++) + { + x = read_golomb_uev(bb, &err); + if(err) goto bail; + } + } + + /* bit_depth_luma_minus8 */ + y = read_golomb_uev(bb, &err); + if(err) goto bail; + config->bitDepthLumaMinus8 = y; + + /* bit_depth_chroma_minus8 */ + y = read_golomb_uev(bb, &err); + if(err) goto bail; + config->bitDepthChromaMinus8 = y; + + if(first_vps) + { + err = config->addParameterSet(config, first_vps, 32); + if(err) goto bail; + } + if(first_sps) + { + err = config->addParameterSet(config, first_sps, 33); + if(err) goto bail; + } + if(first_pps) + { + err = config->addParameterSet(config, first_pps, 34); + if(err) goto bail; + } + + err = atomPtrToSampleEntryH(sampleDescriptionH, (MP4AtomPtr)entry); + if(err) goto bail; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ItemDataAtom.c b/IsoLib/libisomediafile/src/ItemDataAtom.c index 99ff5c0..55451a0 100644 --- a/IsoLib/libisomediafile/src/ItemDataAtom.c +++ b/IsoLib/libisomediafile/src/ItemDataAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 2014. @@ -25,136 +25,142 @@ derivative works. Copyright (c) 2014. #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISOItemDataAtomPtr self; - - err = MP4NoErr; - self = (ISOItemDataAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - err = MP4DisposeHandle(self->data); if (err) goto bail; - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + ISOItemDataAtomPtr self; + + err = MP4NoErr; + self = (ISOItemDataAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + err = MP4DisposeHandle(self->data); + if(err) goto bail; + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - ISOItemDataAtomPtr self = (ISOItemDataAtomPtr) s; - u32 dataSize; - err = MP4NoErr; + MP4Err err; + ISOItemDataAtomPtr self = (ISOItemDataAtomPtr)s; + u32 dataSize; + err = MP4NoErr; - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; - err = MP4GetHandleSize(self->data, &dataSize); if (err) goto bail; - PUTBYTES((char *) *self->data, dataSize); + err = MP4GetHandleSize(self->data, &dataSize); + if(err) goto bail; + PUTBYTES((char *)*self->data, dataSize); - assert( self->bytesWritten == self->size ); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - u32 size; - ISOItemDataAtomPtr self = (ISOItemDataAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - - err = MP4GetHandleSize(self->data, &size); if (err) goto bail; - - self->size += size; - + MP4Err err; + u32 size; + ISOItemDataAtomPtr self = (ISOItemDataAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + + err = MP4GetHandleSize(self->data, &size); + if(err) goto bail; + + self->size += size; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - ISOItemDataAtomPtr self = (ISOItemDataAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - bytesToRead = self->size - self->bytesRead; - - err = MP4SetHandleSize(self->data, bytesToRead); if ( err ) goto bail; - if (bytesToRead > 0) - { - GETBYTES_V( bytesToRead, (char *) *self->data ); - } - - assert( self->bytesRead == self->size ); + MP4Err err; + long bytesToRead; + ISOItemDataAtomPtr self = (ISOItemDataAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + bytesToRead = self->size - self->bytesRead; + + err = MP4SetHandleSize(self->data, bytesToRead); + if(err) goto bail; + if(bytesToRead > 0) + { + GETBYTES_V(bytesToRead, (char *)*self->data); + } + + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getData( MP4AtomPtr s, char *target, u32 offset, u32 length ) +static MP4Err getData(MP4AtomPtr s, char *target, u32 offset, u32 length) { - MP4Err err; - ISOItemDataAtomPtr self = (ISOItemDataAtomPtr) s; - char *dataBuffer; - u32 dataSize; - - err = MP4NoErr; - dataBuffer = (char*) *self->data; - - err = MP4GetHandleSize(self->data, &dataSize); if (err) goto bail; - - if ((dataSize - offset) < length) - BAILWITHERROR(MP4BadParamErr); - - memcpy(target, dataBuffer + offset, length); + MP4Err err; + ISOItemDataAtomPtr self = (ISOItemDataAtomPtr)s; + char *dataBuffer; + u32 dataSize; + + err = MP4NoErr; + dataBuffer = (char *)*self->data; + + err = MP4GetHandleSize(self->data, &dataSize); + if(err) goto bail; + + if((dataSize - offset) < length) BAILWITHERROR(MP4BadParamErr); + + memcpy(target, dataBuffer + offset, length); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err ISOCreateItemDataAtom( ISOItemDataAtomPtr *outAtom ) +MP4Err ISOCreateItemDataAtom(ISOItemDataAtomPtr *outAtom) { - MP4Err err; - ISOItemDataAtomPtr self; - - self = (ISOItemDataAtomPtr) calloc( 1, sizeof(ISOItemDataAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOItemDataAtomType; - self->name = "item data"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->getData = getData; - - err = MP4NewHandle(0, &self->data); if (err) goto bail; - - *outAtom = self; + MP4Err err; + ISOItemDataAtomPtr self; + + self = (ISOItemDataAtomPtr)calloc(1, sizeof(ISOItemDataAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOItemDataAtomType; + self->name = "item data"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->getData = getData; + + err = MP4NewHandle(0, &self->data); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ItemInfoAtom.c b/IsoLib/libisomediafile/src/ItemInfoAtom.c index 90f7ad2..7a06664 100644 --- a/IsoLib/libisomediafile/src/ItemInfoAtom.c +++ b/IsoLib/libisomediafile/src/ItemInfoAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,82 +15,83 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ItemInfoAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ItemInfoAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISOItemInfoAtomPtr self; - u32 i; - err = MP4NoErr; - self = (ISOItemInfoAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + ISOItemInfoAtomPtr self; + u32 i; + err = MP4NoErr; + self = (ISOItemInfoAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err addAtom( ISOItemInfoAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(ISOItemInfoAtomPtr self, MP4AtomPtr atom) { - MP4Err err; + MP4Err err; - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getEntry( ISOItemInfoAtomPtr self, u32 itemID, ISOItemInfoEntryAtomPtr *outEntry ) +static MP4Err getEntry(ISOItemInfoAtomPtr self, u32 itemID, ISOItemInfoEntryAtomPtr *outEntry) { - MP4Err err; - u32 i; - - for (i = 0; i < self->atomList->entryCount; i++) + MP4Err err; + u32 i; + + for(i = 0; i < self->atomList->entryCount; i++) + { + ISOItemInfoEntryAtomPtr entry; + err = MP4GetListEntry(self->atomList, i, (char **)&entry); + if(err) goto bail; + if(entry->type == ISOItemInfoEntryAtomType) { - ISOItemInfoEntryAtomPtr entry; - err = MP4GetListEntry(self->atomList, i, (char **) &entry); if (err) goto bail; - if (entry->type == ISOItemInfoEntryAtomType) - { - if (entry->item_ID == itemID) - *outEntry = entry; - } + if(entry->item_ID == itemID) *outEntry = entry; } + } bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { MP4Err err; - ISOItemInfoAtomPtr self = (ISOItemInfoAtomPtr) s; + ISOItemInfoAtomPtr self = (ISOItemInfoAtomPtr)s; u32 count; err = MP4NoErr; - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; buffer += self->bytesWritten; - err = MP4GetListEntryCount( self->atomList, &count ); if (err) goto bail; + err = MP4GetListEntryCount(self->atomList, &count); + if(err) goto bail; - if (self->version == 0) + if(self->version == 0) { PUT16_V(count); } @@ -99,103 +100,110 @@ static MP4Err serialize( struct MP4Atom* s, char* buffer ) PUT32_V(count); } - SERIALIZE_ATOM_LIST( atomList ); /* should be sorted by item_id! */ - assert( self->bytesWritten == self->size ); + SERIALIZE_ATOM_LIST(atomList); /* should be sorted by item_id! */ + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISOItemInfoAtomPtr self = (ISOItemInfoAtomPtr) s; - err = MP4NoErr; + MP4Err err; + ISOItemInfoAtomPtr self = (ISOItemInfoAtomPtr)s; + err = MP4NoErr; - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 2; + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 2; - if (self->version != 0) - { - self->size += 2; - } + if(self->version != 0) + { + self->size += 2; + } - ADD_ATOM_LIST_SIZE( atomList ); + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - u32 in_count; - u32 list_count; - MP4Err err; - ISOItemInfoAtomPtr self = (ISOItemInfoAtomPtr) s; - - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ); - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - if (self->version == 0) - { - GET16_V(in_count); - } - else - { - GET32_V(in_count); - } - - while (self->bytesRead < self->size) - { - MP4AtomPtr atom; - err = MP4ParseAtom((MP4InputStreamPtr)inputStream, &atom); - if (err) goto bail; - self->bytesRead += atom->size; - if (((atom->type) == MP4FreeSpaceAtomType) || ((atom->type) == MP4SkipAtomType)) - atom->destroy(atom); - else { - - err = addAtom(self, atom); - if (err) goto bail; - } - } - if (self->bytesRead != self->size) - BAILWITHERROR(MP4BadDataErr) - - err = MP4GetListEntryCount( self->atomList, &list_count ); if (err) goto bail; - if (list_count != in_count) { BAILWITHERROR( MP4BadDataErr ); } + u32 in_count; + u32 list_count; + MP4Err err; + ISOItemInfoAtomPtr self = (ISOItemInfoAtomPtr)s; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + if(self->version == 0) + { + GET16_V(in_count); + } + else + { + GET32_V(in_count); + } + + while(self->bytesRead < self->size) + { + MP4AtomPtr atom; + err = MP4ParseAtom((MP4InputStreamPtr)inputStream, &atom); + if(err) goto bail; + self->bytesRead += atom->size; + if(((atom->type) == MP4FreeSpaceAtomType) || ((atom->type) == MP4SkipAtomType)) + atom->destroy(atom); + else + { + + err = addAtom(self, atom); + if(err) goto bail; + } + } + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr) + + err = MP4GetListEntryCount(self->atomList, &list_count); + if(err) goto bail; + if(list_count != in_count) + { + BAILWITHERROR(MP4BadDataErr); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err ISOCreateItemInfoAtom( ISOItemInfoAtomPtr *outAtom ) +MP4Err ISOCreateItemInfoAtom(ISOItemInfoAtomPtr *outAtom) { - MP4Err err; - ISOItemInfoAtomPtr self; - - self = (ISOItemInfoAtomPtr) calloc( 1, sizeof(ISOItemInfoAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOItemInfoAtomType; - self->name = "item info"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addAtom = addAtom; - self->getEntry = getEntry; - *outAtom = self; + MP4Err err; + ISOItemInfoAtomPtr self; + + self = (ISOItemInfoAtomPtr)calloc(1, sizeof(ISOItemInfoAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOItemInfoAtomType; + self->name = "item info"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addAtom = addAtom; + self->getEntry = getEntry; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c b/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c index 0fc0e17..391e4d6 100644 --- a/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c +++ b/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,330 +15,364 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ItemInfoEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ItemInfoEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISOItemInfoEntryAtomPtr self = (ISOItemInfoEntryAtomPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->item_name ) { - free( self->item_name ); - self->item_name = NULL; - } - if ( self->content_type ) { - free( self->content_type ); - self->content_type = NULL; - } - if ( self->content_encoding ) { - free( self->content_encoding ); - self->content_encoding = NULL; - } - - if ( self->item_info_extension != NULL ) { - err = MP4DisposeHandle(self->item_info_extension); if (err) goto bail; - } - - if ( self->item_uri_type ) { - free( self->item_uri_type ); - self->item_uri_type = NULL; - } - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + ISOItemInfoEntryAtomPtr self = (ISOItemInfoEntryAtomPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->item_name) + { + free(self->item_name); + self->item_name = NULL; + } + if(self->content_type) + { + free(self->content_type); + self->content_type = NULL; + } + if(self->content_encoding) + { + free(self->content_encoding); + self->content_encoding = NULL; + } + + if(self->item_info_extension != NULL) + { + err = MP4DisposeHandle(self->item_info_extension); + if(err) goto bail; + } + + if(self->item_uri_type) + { + free(self->item_uri_type); + self->item_uri_type = NULL; + } + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - ISOItemInfoEntryAtomPtr self = (ISOItemInfoEntryAtomPtr) s; - u8 x; - - err = MP4NoErr; - x = 0; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - if (self->version == 3) + MP4Err err; + ISOItemInfoEntryAtomPtr self = (ISOItemInfoEntryAtomPtr)s; + u8 x; + + err = MP4NoErr; + x = 0; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + if(self->version == 3) + { + PUT32(item_ID); + } + else + { + PUT16(item_ID); + } + + PUT16(protection_index); + + if(self->version >= 2) + { + PUT32(item_type); + } + + if(self->item_name) + { + u32 len = strlen(self->item_name) + 1; + PUTBYTES(self->item_name, len); + } + else + { + PUT8_V(x); + } + + if((self->version < 2) || (self->item_type == MP4_FOUR_CHAR_CODE('m', 'i', 'm', 'e'))) + { + if(self->content_type) { - PUT32( item_ID ); + u32 len = strlen(self->content_type) + 1; + PUTBYTES(self->content_type, len); } else { - PUT16( item_ID ); + PUT8_V(x); } - PUT16( protection_index ); - - if (self->version >= 2) + if(self->content_encoding) { - PUT32( item_type ); + u32 len = strlen(self->content_encoding) + 1; + PUTBYTES(self->content_encoding, len); } - - if ( self->item_name ) - { - u32 len = strlen( self->item_name ) + 1; - PUTBYTES( self->item_name, len ); - } else { PUT8_V( x ); } - - if ((self->version < 2) || (self->item_type == MP4_FOUR_CHAR_CODE('m', 'i', 'm', 'e'))) + else { - if ( self->content_type ) - { - u32 len = strlen( self->content_type ) + 1; - PUTBYTES( self->content_type, len ); - } else { PUT8_V( x ); } - - if ( self->content_encoding ) - { - u32 len = strlen( self->content_encoding ) + 1; - PUTBYTES( self->content_encoding, len ); - } else { PUT8_V( x ); } + PUT8_V(x); } - else if (self->item_type == MP4_FOUR_CHAR_CODE('u', 'r', 'i', ' ')) + } + else if(self->item_type == MP4_FOUR_CHAR_CODE('u', 'r', 'i', ' ')) + { + if(self->item_uri_type) { - if ( self->item_uri_type ) - { - u32 len = strlen( self->item_uri_type ) + 1; - PUTBYTES( self->item_uri_type, len ); - } else { PUT8_V( x ); } + u32 len = strlen(self->item_uri_type) + 1; + PUTBYTES(self->item_uri_type, len); } - - if (self->version == 1) + else + { + PUT8_V(x); + } + } + + if(self->version == 1) + { + if(self->extension_type != 0) PUT32(extension_type); + + if(self->item_info_extension != NULL) { - if (self->extension_type != 0) - PUT32( extension_type ); - - if (self->item_info_extension != NULL) - { - u32 extensionSize; - char *handleBuffer; - err = MP4GetHandleSize(self->item_info_extension, &extensionSize); if (err) goto bail; - handleBuffer = (char *) *self->item_info_extension; - PUTBYTES( handleBuffer, extensionSize ); - } + u32 extensionSize; + char *handleBuffer; + err = MP4GetHandleSize(self->item_info_extension, &extensionSize); + if(err) goto bail; + handleBuffer = (char *)*self->item_info_extension; + PUTBYTES(handleBuffer, extensionSize); } + } - assert( self->bytesWritten == self->size ); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISOItemInfoEntryAtomPtr self = (ISOItemInfoEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - - if ((self->version == 0) || (self->version == 1)) + MP4Err err; + ISOItemInfoEntryAtomPtr self = (ISOItemInfoEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + if((self->version == 0) || (self->version == 1)) + { + self->size += 7; /* includes the null terminators of the three strings */ + if(self->item_name) self->size += strlen(self->item_name); + if(self->content_type) self->size += strlen(self->content_type); + if(self->content_encoding) self->size += strlen(self->content_encoding); + } + + if(self->version == 1) + { + if(self->extension_type != 0) self->size += 4; + + if(self->item_info_extension != NULL) { - self->size += 7; /* includes the null terminators of the three strings */ - if ( self->item_name ) - self->size += strlen( self->item_name ); - if ( self->content_type ) - self->size += strlen( self->content_type ); - if ( self->content_encoding ) - self->size += strlen( self->content_encoding ); + u32 extensionSize; + err = MP4GetHandleSize(self->item_info_extension, &extensionSize); + if(err) goto bail; + self->size += extensionSize; } - - if (self->version == 1) + } + + if(self->version >= 2) + { + if(self->version == 2) self->size += 2; + else if(self->version == 3) + self->size += 4; + + self->size += 7; + if(self->item_name) self->size += strlen(self->item_name); + + if(self->item_type == MP4_FOUR_CHAR_CODE('m', 'i', 'm', 'e')) { - if (self->extension_type != 0) - self->size += 4; - - if (self->item_info_extension != NULL) - { - u32 extensionSize; - err = MP4GetHandleSize(self->item_info_extension, &extensionSize); if (err) goto bail; - self->size += extensionSize; - } + self->size += 2; + if(self->content_type) self->size += strlen(self->content_type); + if(self->content_encoding) self->size += strlen(self->content_encoding); } - - if (self->version >= 2) + else if(self->item_type == MP4_FOUR_CHAR_CODE('u', 'r', 'i', ' ')) { - if (self->version == 2) - self->size += 2; - else if (self->version == 3) - self->size += 4; - - self->size += 7; - if ( self->item_name ) - self->size += strlen( self->item_name ); - - if (self->item_type == MP4_FOUR_CHAR_CODE('m', 'i', 'm', 'e')) - { - self->size += 2; - if ( self->content_type ) - self->size += strlen( self->content_type ); - if ( self->content_encoding ) - self->size += strlen( self->content_encoding ); - } - else if (self->item_type == MP4_FOUR_CHAR_CODE('u', 'r', 'i', ' ')) - { - self->size += 1; - if ( self->item_uri_type ) - self->size += strlen( self->item_uri_type ); - } + self->size += 1; + if(self->item_uri_type) self->size += strlen(self->item_uri_type); } - - + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - char inputstr[4096]; - char* str; - u32 i; - char msgString[200]; - char typeString[8]; - - ISOItemInfoEntryAtomPtr self = (ISOItemInfoEntryAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - if (self->version == 3) + MP4Err err; + long bytesToRead; + char inputstr[4096]; + char *str; + u32 i; + char msgString[200]; + char typeString[8]; + + ISOItemInfoEntryAtomPtr self = (ISOItemInfoEntryAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + if(self->version == 3) + { + GET32(item_ID); + } + else + { + GET16(item_ID); + } + + GET16(protection_index); + + if(self->version >= 2) + { + GET32(item_type); + MP4TypeToString(self->item_type, typeString); + sprintf(msgString, "item type is '%s'", typeString); + inputStream->msg(inputStream, msgString); + } + + bytesToRead = self->size - self->bytesRead; + if(bytesToRead < 0) BAILWITHERROR(MP4BadDataErr) + + if(bytesToRead > 0) + { + GETBYTES_V(bytesToRead, inputstr); + } + else + inputstr[0] = inputstr[1] = inputstr[2] = 0; + + str = inputstr; + + if(bytesToRead > 0) + { + i = strlen(str); + bytesToRead -= i + 1; + self->item_name = calloc(i + 1, 1); + strcpy(self->item_name, str); + str = str + i + 1; + sprintf(msgString, "itemName = '%s'", self->item_name); + inputStream->msg(inputStream, msgString); + } + else + self->item_name = NULL; + + if((self->version < 2) || (self->item_type == MP4_FOUR_CHAR_CODE('m', 'i', 'm', 'e'))) + { + if(bytesToRead > 0) { - GET32( item_ID ); + i = strlen(str); + bytesToRead -= i + 1; + self->content_type = calloc(i + 1, 1); + strcpy(self->content_type, str); + str = str + i + 1; + sprintf(msgString, "contentType = '%s'", self->content_type); + inputStream->msg(inputStream, msgString); } else + self->content_type = NULL; + + if(bytesToRead > 0) { - GET16( item_ID ); - } - - GET16( protection_index ); - - if (self->version >= 2) - { - GET32( item_type ); - MP4TypeToString( self->item_type, typeString ); - sprintf( msgString, "item type is '%s'", typeString ); - inputStream->msg( inputStream, msgString ); - } - - bytesToRead = self->size - self->bytesRead; - if ( bytesToRead < 0 ) - BAILWITHERROR( MP4BadDataErr ) - - if (bytesToRead > 0) { - GETBYTES_V( bytesToRead, inputstr ); - } else inputstr[0] = inputstr[1] = inputstr[2] = 0; - - str = inputstr; - - if (bytesToRead > 0) { - i = strlen( str ); bytesToRead -= i+1; - self->item_name = calloc( i+1, 1 ); - strcpy( self->item_name, str ); str = str + i + 1; - sprintf( msgString, "itemName = '%s'", self->item_name ); - inputStream->msg( inputStream, msgString ); - } - else self->item_name = NULL; - - if ((self->version < 2) || (self->item_type == MP4_FOUR_CHAR_CODE('m', 'i', 'm', 'e'))) - { - if (bytesToRead > 0) { - i = strlen( str ); bytesToRead -= i+1; - self->content_type = calloc( i+1, 1 ); - strcpy( self->content_type, str ); str = str + i + 1; - sprintf( msgString, "contentType = '%s'", self->content_type ); - inputStream->msg( inputStream, msgString ); - } - else self->content_type = NULL; - - if (bytesToRead > 0) { - i = strlen( str ); bytesToRead -= i+1; - self->content_encoding = calloc( i+1, 1 ); - strcpy( self->content_encoding, str ); str = str + i + 1; - sprintf( msgString, "contentEncoding = '%s'", self->content_encoding ); - inputStream->msg( inputStream, msgString ); - } - else self->content_encoding = NULL; + i = strlen(str); + bytesToRead -= i + 1; + self->content_encoding = calloc(i + 1, 1); + strcpy(self->content_encoding, str); + str = str + i + 1; + sprintf(msgString, "contentEncoding = '%s'", self->content_encoding); + inputStream->msg(inputStream, msgString); } - else if (self->item_type == MP4_FOUR_CHAR_CODE('u', 'r', 'i', ' ')) + else + self->content_encoding = NULL; + } + else if(self->item_type == MP4_FOUR_CHAR_CODE('u', 'r', 'i', ' ')) + { + if(bytesToRead > 0) { - if (bytesToRead > 0) { - i = strlen( str ); bytesToRead -= i+1; - self->item_uri_type = calloc( i+1, 1 ); - strcpy( self->item_uri_type, str ); str = str + i + 1; - sprintf( msgString, "item_uri_type = '%s'", self->item_uri_type ); - inputStream->msg( inputStream, msgString ); - } - else self->item_uri_type = NULL; + i = strlen(str); + bytesToRead -= i + 1; + self->item_uri_type = calloc(i + 1, 1); + strcpy(self->item_uri_type, str); + str = str + i + 1; + sprintf(msgString, "item_uri_type = '%s'", self->item_uri_type); + inputStream->msg(inputStream, msgString); } - - if (self->version == 1) + else + self->item_uri_type = NULL; + } + + if(self->version == 1) + { + if(bytesToRead >= 2) { - if (bytesToRead >= 2) - { - char *handleBuffer; - memcpy(&self->extension_type, str, 4); - bytesToRead -= 4; - str = str + 4; - err = MP4NewHandle(bytesToRead, &self->item_info_extension); if (err) goto bail; - handleBuffer = (char *) *self->item_info_extension; - memcpy(handleBuffer, str, bytesToRead); - bytesToRead -= bytesToRead; - } + char *handleBuffer; + memcpy(&self->extension_type, str, 4); + bytesToRead -= 4; + str = str + 4; + err = MP4NewHandle(bytesToRead, &self->item_info_extension); + if(err) goto bail; + handleBuffer = (char *)*self->item_info_extension; + memcpy(handleBuffer, str, bytesToRead); + bytesToRead -= bytesToRead; } + } - - if (bytesToRead != 0) - { BAILWITHERROR( MP4BadDataErr ); } + if(bytesToRead != 0) + { + BAILWITHERROR(MP4BadDataErr); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err ISOCreateItemInfoEntryAtom( ISOItemInfoEntryAtomPtr *outAtom ) +MP4Err ISOCreateItemInfoEntryAtom(ISOItemInfoEntryAtomPtr *outAtom) { - MP4Err err; - ISOItemInfoEntryAtomPtr self; - - self = (ISOItemInfoEntryAtomPtr) calloc( 1, sizeof(ISOItemInfoEntryAtom) ); - if ( self == NULL ) BAILWITHERROR( MP4NoMemoryErr ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOItemInfoEntryAtomType; - self->name = "item info entry"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + ISOItemInfoEntryAtomPtr self; + + self = (ISOItemInfoEntryAtomPtr)calloc(1, sizeof(ISOItemInfoEntryAtom)); + if(self == NULL) BAILWITHERROR(MP4NoMemoryErr) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOItemInfoEntryAtomType; + self->name = "item info entry"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ItemLocationAtom.c b/IsoLib/libisomediafile/src/ItemLocationAtom.c index 07823ef..30e0422 100644 --- a/IsoLib/libisomediafile/src/ItemLocationAtom.c +++ b/IsoLib/libisomediafile/src/ItemLocationAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,390 +15,497 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ItemLocationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ItemLocationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISOItemLocationAtomPtr self; - u32 i, j; - - err = MP4NoErr; - self = (ISOItemLocationAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->itemList ) - { - u32 listSize; - err = MP4GetListEntryCount( self->itemList, &listSize ); if (err) goto bail; - for ( i = 0; i < listSize; i++ ) - { - MetaItemLocationPtr a; - err = MP4GetListEntry( self->itemList, i, (char **) &a ); if (err) goto bail; - if ( a->extentList ) - { - u32 list2Size; - err = MP4GetListEntryCount( a->extentList, &list2Size ); if (err) goto bail; - for ( j = 0; j < list2Size; j++ ) - { - MetaExtentLocationPtr b; - err = MP4GetListEntry( a->extentList, j, (char **) &b ); if (err) goto bail; - if ( b ) free (b); - } - err = MP4DeleteLinkedList( a->extentList ); if (err) goto bail; - } - if ( a ) free (a); - } - err = MP4DeleteLinkedList( self->itemList ); if (err) goto bail; - } - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + ISOItemLocationAtomPtr self; + u32 i, j; + + err = MP4NoErr; + self = (ISOItemLocationAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->itemList) + { + u32 listSize; + err = MP4GetListEntryCount(self->itemList, &listSize); + if(err) goto bail; + for(i = 0; i < listSize; i++) + { + MetaItemLocationPtr a; + err = MP4GetListEntry(self->itemList, i, (char **)&a); + if(err) goto bail; + if(a->extentList) + { + u32 list2Size; + err = MP4GetListEntryCount(a->extentList, &list2Size); + if(err) goto bail; + for(j = 0; j < list2Size; j++) + { + MetaExtentLocationPtr b; + err = MP4GetListEntry(a->extentList, j, (char **)&b); + if(err) goto bail; + if(b) free(b); + } + err = MP4DeleteLinkedList(a->extentList); + if(err) goto bail; + } + if(a) free(a); + } + err = MP4DeleteLinkedList(self->itemList); + if(err) goto bail; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i, j; - u32 item_total; - u8 x; - - ISOItemLocationAtomPtr self = (ISOItemLocationAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - item_total = 0; - - x = (self->offset_size <<4) | self->length_size; PUT8_V( x ); - x = (self->base_offset_size <<4) | self->index_size; PUT8_V( x ); - - if ( self->itemList ) - { - err = MP4GetListEntryCount( self->itemList, &item_total ); if (err) goto bail; - PUT16_V( item_total ); - - for ( i = 0; i < item_total; i++ ) - { - u32 list2Size; - MetaItemLocationPtr a; - err = MP4GetListEntry( self->itemList, i, (char **) &a ); if (err) goto bail; - - PUT16_V( (a->item_ID) ); - - if (self->version == 1) + MP4Err err; + u32 i, j; + u32 item_total; + u8 x; + + ISOItemLocationAtomPtr self = (ISOItemLocationAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + item_total = 0; + + x = (self->offset_size << 4) | self->length_size; + PUT8_V(x); + x = (self->base_offset_size << 4) | self->index_size; + PUT8_V(x); + + if(self->itemList) + { + err = MP4GetListEntryCount(self->itemList, &item_total); + if(err) goto bail; + PUT16_V(item_total); + + for(i = 0; i < item_total; i++) + { + u32 list2Size; + MetaItemLocationPtr a; + err = MP4GetListEntry(self->itemList, i, (char **)&a); + if(err) goto bail; + + PUT16_V((a->item_ID)); + + if(self->version == 1) + { + x = 0; + PUT8_V(x); + x = a->construction_method; + PUT8_V(x); + } + + PUT16_V((a->dref_index)); + if(self->base_offset_size == 8) + { + PUT64_V((a->base_offset)); + } + else if(self->base_offset_size == 4) + { + u32 x; + x = (u32)a->base_offset; + PUT32_V(x); + } + + list2Size = 0; + + if(a->extentList) + { + err = MP4GetListEntryCount(a->extentList, &list2Size); + if(err) goto bail; + PUT16_V(list2Size); + + for(j = 0; j < list2Size; j++) + { + MetaExtentLocationPtr b; + err = MP4GetListEntry(a->extentList, j, (char **)&b); + if(err) goto bail; + + if(self->version == 1) + { + if(self->index_size == 8) { - x = 0; PUT8_V( x ); - x = a->construction_method; PUT8_V( x ); + PUT64_V((b->extent_index)); } - - PUT16_V( (a->dref_index) ); - if (self->base_offset_size == 8) { PUT64_V( (a->base_offset) ); } - else if (self->base_offset_size == 4) { u32 x; x = (u32) a->base_offset; PUT32_V( x ); } - - list2Size = 0; - - if ( a->extentList ) - { - err = MP4GetListEntryCount( a->extentList, &list2Size ); if (err) goto bail; - PUT16_V( list2Size ); - - for ( j = 0; j < list2Size; j++ ) - { - MetaExtentLocationPtr b; - err = MP4GetListEntry( a->extentList, j, (char **) &b ); if (err) goto bail; - - if (self->version == 1) - { - if (self->index_size == 8) { PUT64_V( (b->extent_index) ); } - else if (self->index_size == 4) { u32 x; x = (u32) b->extent_index; PUT32_V( x ); } - } - - if (self->offset_size == 8) { PUT64_V( (b->extent_offset) ); } - else if (self->offset_size == 4) { u32 x; x = (u32) b->extent_offset; PUT32_V( x ); } - - if (self->length_size == 8) { PUT64_V( (b->extent_length) ); } - else if (self->length_size == 4) { u32 x; x = (u32) b->extent_length; PUT32_V( x ); } - } - } - else { PUT16_V( list2Size ); } - } - } - else { PUT16_V( item_total ); }; - - assert( self->bytesWritten == self->size ); + else if(self->index_size == 4) + { + u32 x; + x = (u32)b->extent_index; + PUT32_V(x); + } + } + + if(self->offset_size == 8) + { + PUT64_V((b->extent_offset)); + } + else if(self->offset_size == 4) + { + u32 x; + x = (u32)b->extent_offset; + PUT32_V(x); + } + + if(self->length_size == 8) + { + PUT64_V((b->extent_length)); + } + else if(self->length_size == 4) + { + u32 x; + x = (u32)b->extent_length; + PUT32_V(x); + } + } + } + else + { + PUT16_V(list2Size); + } + } + } + else + { + PUT16_V(item_total); + }; + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISOItemLocationAtomPtr self = (ISOItemLocationAtomPtr) s; - u32 i, j; - u32 item_total, extent_total; - err = MP4NoErr; - - self->offset_size = 0; - self->length_size = 0; - self->base_offset_size = 0; - self->index_size = 0; - - item_total = 0; - extent_total = 0; - - if ( self->itemList ) - { - err = MP4GetListEntryCount( self->itemList, &item_total ); if (err) goto bail; - - for ( i = 0; i < item_total; i++ ) - { - MetaItemLocationPtr a; - err = MP4GetListEntry( self->itemList, i, (char **) &a ); if (err) goto bail; - if (((a->base_offset)>>32) > 0) self->base_offset_size = 8; - else if ((self->base_offset_size < 4) && ((a->base_offset) > 0)) self->base_offset_size = 4; - - if ((a->dref_index == 0) && ( a->extentList )) - { - if (self->offset_size < 4) self->offset_size = 4; - if (self->base_offset_size < 4) self->base_offset_size = 4; - } - /* we have to allow space for the mdat to move up; if this item has one extent, and it's at - offset 0 in the mdat, we might conclude we need only have 0 bytes for offsets, but by the - time we serialize, the offset (in the file now) is not zero */ - if ( a->extentList ) - { - u32 list2Size; - err = MP4GetListEntryCount( a->extentList, &list2Size ); if (err) goto bail; - extent_total += list2Size; - - for ( j = 0; j < list2Size; j++ ) - { - MetaExtentLocationPtr b; - err = MP4GetListEntry( a->extentList, j, (char **) &b ); if (err) goto bail; - - if (((b->extent_offset)>>32) > 0) self->offset_size = 8; - else if ((self->offset_size < 4) && ((b->extent_offset) > 0)) self->offset_size = 4; - - if (((b->extent_length)>>32) > 0) self->length_size = 8; - else if ((self->length_size < 4) && ((b->extent_length) > 0)) self->length_size = 4; - - if (((b->extent_index)>>32) > 0) self->index_size = 8; - else if ((self->index_size < 4) && ((b->extent_index) > 0)) self->index_size = 4; - } - } - } - } - - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - - - self->size += 4 + item_total * (self->base_offset_size + 6) + extent_total * (self->offset_size + self->length_size); - - if (self->version == 1) - self->size += item_total * 2 + extent_total * self->index_size; + MP4Err err; + ISOItemLocationAtomPtr self = (ISOItemLocationAtomPtr)s; + u32 i, j; + u32 item_total, extent_total; + err = MP4NoErr; + + self->offset_size = 0; + self->length_size = 0; + self->base_offset_size = 0; + self->index_size = 0; + + item_total = 0; + extent_total = 0; + + if(self->itemList) + { + err = MP4GetListEntryCount(self->itemList, &item_total); + if(err) goto bail; + + for(i = 0; i < item_total; i++) + { + MetaItemLocationPtr a; + err = MP4GetListEntry(self->itemList, i, (char **)&a); + if(err) goto bail; + if(((a->base_offset) >> 32) > 0) self->base_offset_size = 8; + else if((self->base_offset_size < 4) && ((a->base_offset) > 0)) + self->base_offset_size = 4; + + if((a->dref_index == 0) && (a->extentList)) + { + if(self->offset_size < 4) self->offset_size = 4; + if(self->base_offset_size < 4) self->base_offset_size = 4; + } + /* we have to allow space for the mdat to move up; if this item has one extent, and it's at + offset 0 in the mdat, we might conclude we need only have 0 bytes for offsets, but by the + time we serialize, the offset (in the file now) is not zero */ + if(a->extentList) + { + u32 list2Size; + err = MP4GetListEntryCount(a->extentList, &list2Size); + if(err) goto bail; + extent_total += list2Size; + + for(j = 0; j < list2Size; j++) + { + MetaExtentLocationPtr b; + err = MP4GetListEntry(a->extentList, j, (char **)&b); + if(err) goto bail; + + if(((b->extent_offset) >> 32) > 0) self->offset_size = 8; + else if((self->offset_size < 4) && ((b->extent_offset) > 0)) + self->offset_size = 4; + + if(((b->extent_length) >> 32) > 0) self->length_size = 8; + else if((self->length_size < 4) && ((b->extent_length) > 0)) + self->length_size = 4; + + if(((b->extent_index) >> 32) > 0) self->index_size = 8; + else if((self->index_size < 4) && ((b->extent_index) > 0)) + self->index_size = 4; + } + } + } + } + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + self->size += 4 + item_total * (self->base_offset_size + 6) + + extent_total * (self->offset_size + self->length_size); + + if(self->version == 1) self->size += item_total * 2 + extent_total * self->index_size; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err mdatMoved(ISOItemLocationAtomPtr self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) +static MP4Err mdatMoved(ISOItemLocationAtomPtr self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset) { - MP4Err err; - u32 i,j, item_total; - - err = MP4NoErr; - if (self == NULL) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->itemList ) - { - err = MP4GetListEntryCount( self->itemList, &item_total ); if (err) goto bail; - - for ( i = 0; i < item_total; i++ ) - { - MetaItemLocationPtr a; - err = MP4GetListEntry( self->itemList, i, (char **) &a ); if (err) goto bail; - - if ((a->construction_method == 0) && (a->dref_index == 0) && (a->base_offset >= mdatBase) && (a->base_offset < mdatEnd)) - a->base_offset += mdatOffset; - - if ((a->construction_method == 0) && (a->dref_index == 0) && ( a->extentList )) - { - u32 list2Size; - err = MP4GetListEntryCount( a->extentList, &list2Size ); if (err) goto bail; - - for ( j = 0; j < list2Size; j++ ) - { - MetaExtentLocationPtr b; - err = MP4GetListEntry( a->extentList, j, (char **) &b ); if (err) goto bail; - - if ((b->extent_offset >= mdatBase) && (b->extent_offset < mdatEnd)) - b->extent_offset += mdatOffset; - } - } - } - } - + MP4Err err; + u32 i, j, item_total; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->itemList) + { + err = MP4GetListEntryCount(self->itemList, &item_total); + if(err) goto bail; + + for(i = 0; i < item_total; i++) + { + MetaItemLocationPtr a; + err = MP4GetListEntry(self->itemList, i, (char **)&a); + if(err) goto bail; + + if((a->construction_method == 0) && (a->dref_index == 0) && (a->base_offset >= mdatBase) && + (a->base_offset < mdatEnd)) + a->base_offset += mdatOffset; + + if((a->construction_method == 0) && (a->dref_index == 0) && (a->extentList)) + { + u32 list2Size; + err = MP4GetListEntryCount(a->extentList, &list2Size); + if(err) goto bail; + + for(j = 0; j < list2Size; j++) + { + MetaExtentLocationPtr b; + err = MP4GetListEntry(a->extentList, j, (char **)&b); + if(err) goto bail; + + if((b->extent_offset >= mdatBase) && (b->extent_offset < mdatEnd)) + b->extent_offset += mdatOffset; + } + } + } + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err setItemsMeta( ISOItemLocationAtomPtr self, MP4AtomPtr meta ) +static MP4Err setItemsMeta(ISOItemLocationAtomPtr self, MP4AtomPtr meta) { - MP4Err err; - u32 i; - - err = MP4NoErr; - if (self == NULL) - BAILWITHERROR( MP4BadParamErr ); - - if (self->itemList) + MP4Err err; + u32 i; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + if(self->itemList) + { + for(i = 0; i < self->itemList->entryCount; i++) { - for ( i = 0; i < self->itemList->entryCount; i++ ) - { - MetaItemLocationPtr a; - err = MP4GetListEntry( self->itemList, i, (char **) &a ); if (err) goto bail; - a->meta = meta; - } + MetaItemLocationPtr a; + err = MP4GetListEntry(self->itemList, i, (char **)&a); + if(err) goto bail; + a->meta = meta; } + } bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 x; - u32 item_count; - u32 i; - - ISOItemLocationAtomPtr self = (ISOItemLocationAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET8_V( x ); - self->offset_size = (x>>4); - self->length_size = (x & 0xF); - GET8_V_MSG( x, "base offset size" ); - self->base_offset_size = (x>>4); - self->index_size = (x & 0xF); - - GET16_V( item_count ); - err = MP4MakeLinkedList( &(self->itemList) ); if (err) goto bail; - - for (i=0; iitemList ); if (err) goto bail; - - GET16_V_MSG( tmp, "item_ID" ); a->item_ID = tmp; - - if (self->version == 1) + MP4Err err; + u32 x; + u32 item_count; + u32 i; + + ISOItemLocationAtomPtr self = (ISOItemLocationAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET8_V(x); + self->offset_size = (x >> 4); + self->length_size = (x & 0xF); + GET8_V_MSG(x, "base offset size"); + self->base_offset_size = (x >> 4); + self->index_size = (x & 0xF); + + GET16_V(item_count); + err = MP4MakeLinkedList(&(self->itemList)); + if(err) goto bail; + + for(i = 0; i < item_count; i++) + { + MetaItemLocationPtr a; + u32 j, tmp; + u32 extent_count; + + a = calloc(1, sizeof(MetaItemLocation)); + err = MP4AddListEntry((void *)a, self->itemList); + if(err) goto bail; + + GET16_V_MSG(tmp, "item_ID"); + a->item_ID = tmp; + + if(self->version == 1) + { + GET16_V_MSG(tmp, "construction_method"); + a->construction_method = tmp; + } + + GET16_V_MSG(tmp, "dref_index"); + a->dref_index = tmp; + switch(self->base_offset_size) + { + case 8: + GET64_V_MSG((a->base_offset), "base_offset"); + break; + case 4: + GET32_V_MSG(tmp, "base_offset"); + a->base_offset = tmp; + break; + case 0: + a->base_offset = 0; + break; + default: + BAILWITHERROR(MP4BadDataErr); + } + GET16_V(extent_count); + err = MP4MakeLinkedList(&(a->extentList)); + if(err) goto bail; + + for(j = 0; j < extent_count; j++) + { + MetaExtentLocationPtr b; + b = calloc(1, sizeof(MetaExtentLocation)); + err = MP4AddListEntry((void *)b, a->extentList); + if(err) goto bail; + + if(self->version == 1) + { + switch(self->index_size) { - GET16_V_MSG( tmp, "construction_method" ); - a->construction_method = tmp; + case 8: + GET64_V_MSG((b->extent_index), "extent_index"); + break; + case 4: + GET32_V_MSG(tmp, "extent_index"); + b->extent_index = tmp; + break; + case 0: + b->extent_index = 0; + break; + default: + BAILWITHERROR(MP4BadDataErr); } - - GET16_V_MSG( tmp, "dref_index" ); a->dref_index = tmp; - switch( self->base_offset_size ) { - case 8: GET64_V_MSG( (a->base_offset), "base_offset" ); break; - case 4: GET32_V_MSG( tmp, "base_offset" ); a->base_offset = tmp; break; - case 0: a->base_offset =0; break; - default: BAILWITHERROR( MP4BadDataErr ); - } - GET16_V( extent_count ); - err = MP4MakeLinkedList( &(a->extentList) ); if (err) goto bail; - - for (j=0; jextentList ); if (err) goto bail; - - if (self->version == 1) - { - switch( self->index_size ) { - case 8: GET64_V_MSG( (b->extent_index), "extent_index" ); break; - case 4: GET32_V_MSG( tmp, "extent_index" ); b->extent_index = tmp; break; - case 0: b->extent_index = 0; break; - default: BAILWITHERROR( MP4BadDataErr ); - } - } - - switch( self->offset_size ) { - case 8: GET64_V_MSG( (b->extent_offset), "extent_offset" ); break; - case 4: GET32_V_MSG( tmp, "extent_offset" ); b->extent_offset = tmp; break; - case 0: b->extent_offset = 0; break; - default: BAILWITHERROR( MP4BadDataErr ); - } - switch( self->length_size ) { - case 8: GET64_V_MSG( (b->extent_length), "extent_length" ); break; - case 4: GET32_V_MSG( tmp, "extent_length" ); b->extent_length = tmp; break; - case 0: b->extent_length = 0; break; - default: BAILWITHERROR( MP4BadDataErr ); - } - } - } - + } + + switch(self->offset_size) + { + case 8: + GET64_V_MSG((b->extent_offset), "extent_offset"); + break; + case 4: + GET32_V_MSG(tmp, "extent_offset"); + b->extent_offset = tmp; + break; + case 0: + b->extent_offset = 0; + break; + default: + BAILWITHERROR(MP4BadDataErr); + } + switch(self->length_size) + { + case 8: + GET64_V_MSG((b->extent_length), "extent_length"); + break; + case 4: + GET32_V_MSG(tmp, "extent_length"); + b->extent_length = tmp; + break; + case 0: + b->extent_length = 0; + break; + default: + BAILWITHERROR(MP4BadDataErr); + } + } + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err ISOCreateItemLocationAtom( ISOItemLocationAtomPtr *outAtom ) +MP4Err ISOCreateItemLocationAtom(ISOItemLocationAtomPtr *outAtom) { - MP4Err err; - ISOItemLocationAtomPtr self; - - self = (ISOItemLocationAtomPtr) calloc( 1, sizeof(ISOItemLocationAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOItemLocationAtomType; - self->name = "item location"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->mdatMoved = mdatMoved; - self->setItemsMeta = setItemsMeta; - - - err = MP4MakeLinkedList( &(self->itemList) ); if (err) goto bail; - - *outAtom = self; + MP4Err err; + ISOItemLocationAtomPtr self; + + self = (ISOItemLocationAtomPtr)calloc(1, sizeof(ISOItemLocationAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOItemLocationAtomType; + self->name = "item location"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->mdatMoved = mdatMoved; + self->setItemsMeta = setItemsMeta; + + err = MP4MakeLinkedList(&(self->itemList)); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ItemPropertiesAtom.c b/IsoLib/libisomediafile/src/ItemPropertiesAtom.c index 10e95f3..3e8055b 100644 --- a/IsoLib/libisomediafile/src/ItemPropertiesAtom.c +++ b/IsoLib/libisomediafile/src/ItemPropertiesAtom.c @@ -28,224 +28,244 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4ItemPropertiesAtomPtr self = (MP4ItemPropertiesAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4ItemPropertiesAtomPtr self = (MP4ItemPropertiesAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } static MP4Err addAtom(MP4ItemPropertiesAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; + MP4Err err; + err = MP4NoErr; - if (self == 0) - BAILWITHERROR(MP4BadParamErr); + if(self == 0) BAILWITHERROR(MP4BadParamErr); - switch (atom->type) - { - case MP4ItemPropertyContainerAtomType: - self->ipco = atom; - break; + switch(atom->type) + { + case MP4ItemPropertyContainerAtomType: + self->ipco = atom; + break; - case MP4ItemPropertyAssociationAtomType: - self->ipma = atom; - break; - } + case MP4ItemPropertyAssociationAtomType: + self->ipma = atom; + break; + } - err = MP4AddListEntry(atom, self->atomList); + err = MP4AddListEntry(atom, self->atomList); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addItemProperty(struct MP4ItemPropertiesAtom* self, MP4AtomPtr itemProperty, u32 itemID, u8 essential) +static MP4Err addItemProperty(struct MP4ItemPropertiesAtom *self, MP4AtomPtr itemProperty, + u32 itemID, u8 essential) { - MP4Err err; - u32 i; - u32 property_index; - u32 entry_count; - MP4ItemPropertyAssociationEntryPtr entry; - MP4ItemPropertyAssociationEntryPtr targetEntry; - MP4ItemPropertyAssociationEntryPropertyIndexPtr propertyIndex; - - err = MP4NoErr; - - if (self == 0) - BAILWITHERROR(MP4BadParamErr); - - if (self->ipma == NULL) - { - err = MP4CreateItemPropertyAssociationAtom(&self->ipma); if (err) goto bail; - err = MP4AddListEntry(self->ipma, self->atomList); if (err) goto bail; - } - - err = MP4GetListEntryCount(self->ipco->atomList, &property_index); if (err) goto bail; - err = self->ipco->addAtom(self->ipco, itemProperty); if (err) goto bail; - - err = MP4GetListEntryCount(self->ipma->entries, &entry_count); if (err) goto bail; - - targetEntry = NULL; - for (i = 0; i < entry_count; i++) - { - err = MP4GetListEntry(self->ipma->entries, i, (char **)&entry); if (err) goto bail; - if (itemID == entry->item_ID) - { - targetEntry = entry; - } - } - - if (targetEntry == NULL) - { - targetEntry = (MP4ItemPropertyAssociationEntryPtr)calloc(1, sizeof(MP4ItemPropertyAssociationEntry)); - TESTMALLOC(targetEntry); - targetEntry->item_ID = itemID; - err = MP4AddListEntry(targetEntry, self->ipma->entries); if (err) goto bail; - err = MP4MakeLinkedList(&targetEntry->propertyIndexes); if (err) goto bail; - } - - propertyIndex = (MP4ItemPropertyAssociationEntryPropertyIndexPtr)calloc(1, sizeof(MP4ItemPropertyAssociationEntryPropertyIndex)); - TESTMALLOC(propertyIndex); - propertyIndex->essential = essential; - propertyIndex->property_index = property_index + 1; - err = MP4AddListEntry(propertyIndex, targetEntry->propertyIndexes); if (err) goto bail; + MP4Err err; + u32 i; + u32 property_index; + u32 entry_count; + MP4ItemPropertyAssociationEntryPtr entry; + MP4ItemPropertyAssociationEntryPtr targetEntry; + MP4ItemPropertyAssociationEntryPropertyIndexPtr propertyIndex; + + err = MP4NoErr; + + if(self == 0) BAILWITHERROR(MP4BadParamErr); + + if(self->ipma == NULL) + { + err = MP4CreateItemPropertyAssociationAtom(&self->ipma); + if(err) goto bail; + err = MP4AddListEntry(self->ipma, self->atomList); + if(err) goto bail; + } + + err = MP4GetListEntryCount(self->ipco->atomList, &property_index); + if(err) goto bail; + err = self->ipco->addAtom(self->ipco, itemProperty); + if(err) goto bail; + + err = MP4GetListEntryCount(self->ipma->entries, &entry_count); + if(err) goto bail; + + targetEntry = NULL; + for(i = 0; i < entry_count; i++) + { + err = MP4GetListEntry(self->ipma->entries, i, (char **)&entry); + if(err) goto bail; + if(itemID == entry->item_ID) + { + targetEntry = entry; + } + } + + if(targetEntry == NULL) + { + targetEntry = + (MP4ItemPropertyAssociationEntryPtr)calloc(1, sizeof(MP4ItemPropertyAssociationEntry)); + TESTMALLOC(targetEntry); + targetEntry->item_ID = itemID; + err = MP4AddListEntry(targetEntry, self->ipma->entries); + if(err) goto bail; + err = MP4MakeLinkedList(&targetEntry->propertyIndexes); + if(err) goto bail; + } + + propertyIndex = (MP4ItemPropertyAssociationEntryPropertyIndexPtr)calloc( + 1, sizeof(MP4ItemPropertyAssociationEntryPropertyIndex)); + TESTMALLOC(propertyIndex); + propertyIndex->essential = essential; + propertyIndex->property_index = property_index + 1; + err = MP4AddListEntry(propertyIndex, targetEntry->propertyIndexes); + if(err) goto bail; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getPropertiesOfItem(struct MP4ItemPropertiesAtom* self, u32 itemID, MP4LinkedList *properties) +static MP4Err getPropertiesOfItem(struct MP4ItemPropertiesAtom *self, u32 itemID, + MP4LinkedList *properties) { - MP4Err err; - u32 i; - u32 entry_count; - u32 association_count; - MP4LinkedList outProperties; - MP4ItemPropertyAssociationEntryPtr entry; - MP4ItemPropertyAssociationEntryPtr targetEntry; - MP4ItemPropertyAssociationEntryPropertyIndexPtr propertyIndex; - MP4AtomPtr property; - - err = MP4NoErr; - - err = MP4MakeLinkedList(&outProperties); if (err) goto bail; - err = MP4GetListEntryCount(self->ipma->entries, &entry_count); if (err) goto bail; - - targetEntry = NULL; - for (i = 0; i < entry_count; i++) - { - err = MP4GetListEntry(self->ipma->entries, i, (char **)&entry); if (err) goto bail; - if (itemID == entry->item_ID) - { - targetEntry = entry; - } - } - - if (targetEntry != NULL) - { - err = MP4GetListEntryCount(targetEntry->propertyIndexes, &association_count); if (err) goto bail; - for (i = 0; i < association_count; i++) - { - err = MP4GetListEntry(targetEntry->propertyIndexes, i, (char **)&propertyIndex); if (err) goto bail; - err = MP4GetListEntry(self->ipco->atomList, propertyIndex->property_index - 1, (char **)&property); if (err) goto bail; - err = MP4AddListEntry(property, outProperties); - } - } - - *properties = outProperties; + MP4Err err; + u32 i; + u32 entry_count; + u32 association_count; + MP4LinkedList outProperties; + MP4ItemPropertyAssociationEntryPtr entry; + MP4ItemPropertyAssociationEntryPtr targetEntry; + MP4ItemPropertyAssociationEntryPropertyIndexPtr propertyIndex; + MP4AtomPtr property; + + err = MP4NoErr; + + err = MP4MakeLinkedList(&outProperties); + if(err) goto bail; + err = MP4GetListEntryCount(self->ipma->entries, &entry_count); + if(err) goto bail; + + targetEntry = NULL; + for(i = 0; i < entry_count; i++) + { + err = MP4GetListEntry(self->ipma->entries, i, (char **)&entry); + if(err) goto bail; + if(itemID == entry->item_ID) + { + targetEntry = entry; + } + } + + if(targetEntry != NULL) + { + err = MP4GetListEntryCount(targetEntry->propertyIndexes, &association_count); + if(err) goto bail; + for(i = 0; i < association_count; i++) + { + err = MP4GetListEntry(targetEntry->propertyIndexes, i, (char **)&propertyIndex); + if(err) goto bail; + err = MP4GetListEntry(self->ipco->atomList, propertyIndex->property_index - 1, + (char **)&property); + if(err) goto bail; + err = MP4AddListEntry(property, outProperties); + } + } + + *properties = outProperties; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4ItemPropertiesAtomPtr self = (MP4ItemPropertiesAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( (MP4AtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - SERIALIZE_ATOM_LIST(atomList); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4ItemPropertiesAtomPtr self = (MP4ItemPropertiesAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields((MP4AtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + SERIALIZE_ATOM_LIST(atomList); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4ItemPropertiesAtomPtr self = (MP4ItemPropertiesAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( (MP4AtomPtr) s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE(atomList); + MP4Err err; + MP4ItemPropertiesAtomPtr self = (MP4ItemPropertiesAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MP4ItemPropertiesAtom) - bail: - TEST_RETURN(err); + PARSE_ATOM_LIST(MP4ItemPropertiesAtom) +bail: + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateItemPropertiesAtom( MP4ItemPropertiesAtomPtr *outAtom ) +MP4Err MP4CreateItemPropertiesAtom(MP4ItemPropertiesAtomPtr *outAtom) { - MP4Err err; - MP4ItemPropertiesAtomPtr self; - - self = (MP4ItemPropertiesAtomPtr) calloc( 1, sizeof(MP4ItemPropertiesAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4ItemPropertiesAtomType; - self->name = "item properties"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addItemProperty = addItemProperty; - self->getPropertiesOfItem = getPropertiesOfItem; - self->addAtom = addAtom; - self->ipma = NULL; - - err = MP4MakeLinkedList(&self->atomList); if (err) goto bail; - - - err = MP4CreateItemPropertyContainerAtom(&self->ipco); if (err) goto bail; - err = MP4AddListEntry(self->ipco, self->atomList); if (err) goto bail; - - *outAtom = self; + MP4Err err; + MP4ItemPropertiesAtomPtr self; + + self = (MP4ItemPropertiesAtomPtr)calloc(1, sizeof(MP4ItemPropertiesAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4ItemPropertiesAtomType; + self->name = "item properties"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addItemProperty = addItemProperty; + self->getPropertiesOfItem = getPropertiesOfItem; + self->addAtom = addAtom; + self->ipma = NULL; + + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + + err = MP4CreateItemPropertyContainerAtom(&self->ipco); + if(err) goto bail; + err = MP4AddListEntry(self->ipco, self->atomList); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/ItemPropertyAssociationAtom.c b/IsoLib/libisomediafile/src/ItemPropertyAssociationAtom.c index 688f0df..64430cc 100644 --- a/IsoLib/libisomediafile/src/ItemPropertyAssociationAtom.c +++ b/IsoLib/libisomediafile/src/ItemPropertyAssociationAtom.c @@ -30,259 +30,272 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 i, j; - u32 entry_count; - u32 association_count; - MP4ItemPropertyAssociationEntryPtr entry; - MP4ItemPropertyAssociationEntryPropertyIndexPtr propertyIndex; - MP4ItemPropertyAssociationAtomPtr self = (MP4ItemPropertyAssociationAtomPtr)s; - err = MP4NoErr; - - if (self == NULL) - BAILWITHERROR(MP4BadParamErr) - - err = MP4GetListEntryCount(self->entries, &entry_count); if (err) goto bail; - - for (i = 0; i < entry_count; i++) - { - err = MP4GetListEntry(self->entries, i, (char **)&entry); if (err) goto bail; - - if (entry->propertyIndexes == NULL) - BAILWITHERROR(MP4InternalErr) - - err = MP4GetListEntryCount(entry->propertyIndexes, &association_count); if (err) goto bail; - for (j = 0; j < association_count; j++) - { - err = MP4GetListEntry(entry->propertyIndexes, j, (char **)&propertyIndex); if (err) goto bail; - free(propertyIndex); - } - - err = MP4DeleteLinkedList(entry->propertyIndexes); if (err) goto bail; - free(entry); - } - - err = MP4DeleteLinkedList(self->entries); if (err) goto bail; - - if (self->super) - self->super->destroy(s); + MP4Err err; + u32 i, j; + u32 entry_count; + u32 association_count; + MP4ItemPropertyAssociationEntryPtr entry; + MP4ItemPropertyAssociationEntryPropertyIndexPtr propertyIndex; + MP4ItemPropertyAssociationAtomPtr self = (MP4ItemPropertyAssociationAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + err = MP4GetListEntryCount(self->entries, &entry_count); + if(err) goto bail; + + for(i = 0; i < entry_count; i++) + { + err = MP4GetListEntry(self->entries, i, (char **)&entry); + if(err) goto bail; + + if(entry->propertyIndexes == NULL) BAILWITHERROR(MP4InternalErr) + + err = MP4GetListEntryCount(entry->propertyIndexes, &association_count); + if(err) goto bail; + for(j = 0; j < association_count; j++) + { + err = MP4GetListEntry(entry->propertyIndexes, j, (char **)&propertyIndex); + if(err) goto bail; + free(propertyIndex); + } + + err = MP4DeleteLinkedList(entry->propertyIndexes); + if(err) goto bail; + free(entry); + } + + err = MP4DeleteLinkedList(self->entries); + if(err) goto bail; + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize(struct MP4Atom* s, char* buffer) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i, j; - u32 entry_count; - u32 association_count; - u16 property_index; - MP4ItemPropertyAssociationEntryPtr entry; - MP4ItemPropertyAssociationEntryPropertyIndexPtr propertyIndex; - MP4ItemPropertyAssociationAtomPtr self = (MP4ItemPropertyAssociationAtomPtr)s; - - err = MP4NoErr; - err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); if (err) goto bail; - buffer += self->bytesWritten; - - err = MP4GetListEntryCount(self->entries, &entry_count); if (err) goto bail; - - PUT32_V(entry_count); - for (i = 0; i < entry_count; i++) - { - err = MP4GetListEntry(self->entries, i, (char **)&entry); if (err) goto bail; - if (self->version < 1) - { - PUT16_V(entry->item_ID); - } - else - { - PUT32_V(entry->item_ID); - } - - if (entry->propertyIndexes == NULL) - BAILWITHERROR(MP4InternalErr) - - err = MP4GetListEntryCount(entry->propertyIndexes, &association_count); if (err) goto bail; - PUT8_V(association_count); - for (j = 0; j < association_count; j++) - { - err = MP4GetListEntry(entry->propertyIndexes, j, (char **)&propertyIndex); if (err) goto bail; - property_index = propertyIndex->property_index; - - if (self->flags & 1) - { - property_index = property_index | (propertyIndex->essential << 15); - PUT16_V(property_index); - } - else - { - property_index = property_index | (propertyIndex->essential << 7); - PUT8_V(property_index); - } - } - } - assert(self->bytesWritten == self->size); + MP4Err err; + u32 i, j; + u32 entry_count; + u32 association_count; + u16 property_index; + MP4ItemPropertyAssociationEntryPtr entry; + MP4ItemPropertyAssociationEntryPropertyIndexPtr propertyIndex; + MP4ItemPropertyAssociationAtomPtr self = (MP4ItemPropertyAssociationAtomPtr)s; + + err = MP4NoErr; + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + err = MP4GetListEntryCount(self->entries, &entry_count); + if(err) goto bail; + + PUT32_V(entry_count); + for(i = 0; i < entry_count; i++) + { + err = MP4GetListEntry(self->entries, i, (char **)&entry); + if(err) goto bail; + if(self->version < 1) + { + PUT16_V(entry->item_ID); + } + else + { + PUT32_V(entry->item_ID); + } + + if(entry->propertyIndexes == NULL) BAILWITHERROR(MP4InternalErr) + + err = MP4GetListEntryCount(entry->propertyIndexes, &association_count); + if(err) goto bail; + PUT8_V(association_count); + for(j = 0; j < association_count; j++) + { + err = MP4GetListEntry(entry->propertyIndexes, j, (char **)&propertyIndex); + if(err) goto bail; + property_index = propertyIndex->property_index; + + if(self->flags & 1) + { + property_index = property_index | (propertyIndex->essential << 15); + PUT16_V(property_index); + } + else + { + property_index = property_index | (propertyIndex->essential << 7); + PUT8_V(property_index); + } + } + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize(struct MP4Atom* s) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - u32 i; - u32 entry_count; - u32 association_count; - MP4ItemPropertyAssociationEntryPtr entry; - MP4ItemPropertyAssociationAtomPtr self = (MP4ItemPropertyAssociationAtomPtr)s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if (err) goto bail; - - err = MP4GetListEntryCount(self->entries, &entry_count); if (err) goto bail; - self->size += 4; - for (i = 0; i < entry_count; i++) - { - err = MP4GetListEntry(self->entries, i, (char **)&entry); if (err) goto bail; - if (self->version < 1) - self->size += 2; - else - self->size += 4; - - if (entry->propertyIndexes == NULL) - BAILWITHERROR(MP4InternalErr) - - err = MP4GetListEntryCount(entry->propertyIndexes, &association_count); if (err) goto bail; - self->size += 1; - - if (self->flags & 1) - self->size += 2 * association_count; - else - self->size += association_count; - } + MP4Err err; + u32 i; + u32 entry_count; + u32 association_count; + MP4ItemPropertyAssociationEntryPtr entry; + MP4ItemPropertyAssociationAtomPtr self = (MP4ItemPropertyAssociationAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + err = MP4GetListEntryCount(self->entries, &entry_count); + if(err) goto bail; + self->size += 4; + for(i = 0; i < entry_count; i++) + { + err = MP4GetListEntry(self->entries, i, (char **)&entry); + if(err) goto bail; + if(self->version < 1) self->size += 2; + else + self->size += 4; + + if(entry->propertyIndexes == NULL) BAILWITHERROR(MP4InternalErr) + + err = MP4GetListEntryCount(entry->propertyIndexes, &association_count); + if(err) goto bail; + self->size += 1; + + if(self->flags & 1) self->size += 2 * association_count; + else + self->size += association_count; + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i, j; - u32 entry_count; - u32 tmp32; - u8 association_count; - MP4ItemPropertyAssociationEntryPtr entry; - MP4ItemPropertyAssociationEntryPropertyIndexPtr propertyIndex; - MP4ItemPropertyAssociationAtomPtr self = (MP4ItemPropertyAssociationAtomPtr)s; - - err = MP4NoErr; - if (self == NULL) BAILWITHERROR(MP4BadParamErr) - err = self->super->createFromInputStream(s, proto, (char*)inputStream); if (err) goto bail; - - GET32_V(entry_count); - tmp32 = entry_count; - - for (i = 0; i < tmp32; i++) - { - entry = (MP4ItemPropertyAssociationEntryPtr)calloc(1, sizeof(MP4ItemPropertyAssociationEntry)); - TESTMALLOC(entry); - err = MP4AddListEntry(entry, self->entries); if (err) goto bail; - err = MP4MakeLinkedList(&entry->propertyIndexes); if (err) goto bail; - - if (self->version < 1) - { - GET16_V(entry->item_ID); - } - else - { - GET32_V(entry->item_ID); - } - - GET8_V(association_count); - for (j = 0; j < association_count; j++) - { - propertyIndex = (MP4ItemPropertyAssociationEntryPropertyIndexPtr)calloc(1, sizeof(MP4ItemPropertyAssociationEntryPropertyIndex)); - TESTMALLOC(propertyIndex); - err = MP4AddListEntry(propertyIndex, entry->propertyIndexes); if (err) goto bail; - - if (self->flags & 1) - { - GET16_V(propertyIndex->property_index); - propertyIndex->essential = propertyIndex->property_index & (1 << 15); - if (propertyIndex->essential == 1) - { - propertyIndex->property_index &= ~(1 << 15); - } - } - else - { - GET8_V(propertyIndex->property_index); - propertyIndex->essential = 0; - if (propertyIndex->property_index & (1 << 7)) - propertyIndex->essential = 1; - - if (propertyIndex->essential == 1) - { - propertyIndex->property_index &= ~(1 << 7); - } - } - } - } - - assert(self->bytesRead == self->size); + MP4Err err; + u32 i, j; + u32 entry_count; + u32 tmp32; + u8 association_count; + MP4ItemPropertyAssociationEntryPtr entry; + MP4ItemPropertyAssociationEntryPropertyIndexPtr propertyIndex; + MP4ItemPropertyAssociationAtomPtr self = (MP4ItemPropertyAssociationAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32_V(entry_count); + tmp32 = entry_count; + + for(i = 0; i < tmp32; i++) + { + entry = (MP4ItemPropertyAssociationEntryPtr)calloc(1, sizeof(MP4ItemPropertyAssociationEntry)); + TESTMALLOC(entry); + err = MP4AddListEntry(entry, self->entries); + if(err) goto bail; + err = MP4MakeLinkedList(&entry->propertyIndexes); + if(err) goto bail; + + if(self->version < 1) + { + GET16_V(entry->item_ID); + } + else + { + GET32_V(entry->item_ID); + } + + GET8_V(association_count); + for(j = 0; j < association_count; j++) + { + propertyIndex = (MP4ItemPropertyAssociationEntryPropertyIndexPtr)calloc( + 1, sizeof(MP4ItemPropertyAssociationEntryPropertyIndex)); + TESTMALLOC(propertyIndex); + err = MP4AddListEntry(propertyIndex, entry->propertyIndexes); + if(err) goto bail; + + if(self->flags & 1) + { + GET16_V(propertyIndex->property_index); + propertyIndex->essential = propertyIndex->property_index & (1 << 15); + if(propertyIndex->essential == 1) + { + propertyIndex->property_index &= ~(1 << 15); + } + } + else + { + GET8_V(propertyIndex->property_index); + propertyIndex->essential = 0; + if(propertyIndex->property_index & (1 << 7)) propertyIndex->essential = 1; + + if(propertyIndex->essential == 1) + { + propertyIndex->property_index &= ~(1 << 7); + } + } + } + } + + assert(self->bytesRead == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addEntry(MP4ItemPropertyAssociationAtomPtr self, MP4ItemPropertyAssociationEntryPtr entry) +static MP4Err addEntry(MP4ItemPropertyAssociationAtomPtr self, + MP4ItemPropertyAssociationEntryPtr entry) { - MP4Err err; - err = MP4NoErr; + MP4Err err; + err = MP4NoErr; - if (self == 0) - BAILWITHERROR(MP4BadParamErr); + if(self == 0) BAILWITHERROR(MP4BadParamErr); - err = MP4AddListEntry(entry, self->entries); + err = MP4AddListEntry(entry, self->entries); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } MP4Err MP4CreateItemPropertyAssociationAtom(MP4ItemPropertyAssociationAtomPtr *outAtom) { - MP4Err err; - MP4ItemPropertyAssociationAtomPtr self; - - self = (MP4ItemPropertyAssociationAtomPtr)calloc(1, sizeof(MP4ItemPropertyAssociationAtom)); - TESTMALLOC(self); - - err = MP4CreateFullAtom((MP4AtomPtr)self); - if (err) goto bail; - self->type = MP4ItemPropertyAssociationAtomType; - self->name = "Item Property Association"; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addEntry = addEntry; - - err = MP4MakeLinkedList(&self->entries); if (err) goto bail; - - *outAtom = self; + MP4Err err; + MP4ItemPropertyAssociationAtomPtr self; + + self = (MP4ItemPropertyAssociationAtomPtr)calloc(1, sizeof(MP4ItemPropertyAssociationAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4ItemPropertyAssociationAtomType; + self->name = "Item Property Association"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addEntry = addEntry; + + err = MP4MakeLinkedList(&self->entries); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ItemPropertyContainerAtom.c b/IsoLib/libisomediafile/src/ItemPropertyContainerAtom.c index 2aa873b..1e3f19f 100644 --- a/IsoLib/libisomediafile/src/ItemPropertyContainerAtom.c +++ b/IsoLib/libisomediafile/src/ItemPropertyContainerAtom.c @@ -28,103 +28,102 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4ItemPropertyContainerAtomPtr self = (MP4ItemPropertyContainerAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4ItemPropertyContainerAtomPtr self = (MP4ItemPropertyContainerAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } static MP4Err addAtom(MP4ItemPropertyContainerAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; + MP4Err err; + err = MP4NoErr; - if (self == 0) - BAILWITHERROR(MP4BadParamErr); + if(self == 0) BAILWITHERROR(MP4BadParamErr); - err = MP4AddListEntry(atom, self->atomList); + err = MP4AddListEntry(atom, self->atomList); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4ItemPropertyContainerAtomPtr self = (MP4ItemPropertyContainerAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( (MP4AtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - SERIALIZE_ATOM_LIST(atomList); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4ItemPropertyContainerAtomPtr self = (MP4ItemPropertyContainerAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields((MP4AtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + SERIALIZE_ATOM_LIST(atomList); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4ItemPropertyContainerAtomPtr self = (MP4ItemPropertyContainerAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( (MP4AtomPtr) s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE(atomList); + MP4Err err; + MP4ItemPropertyContainerAtomPtr self = (MP4ItemPropertyContainerAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MP4ItemPropertyContainerAtom) + PARSE_ATOM_LIST(MP4ItemPropertyContainerAtom) bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateItemPropertyContainerAtom( MP4ItemPropertyContainerAtomPtr *outAtom ) +MP4Err MP4CreateItemPropertyContainerAtom(MP4ItemPropertyContainerAtomPtr *outAtom) { - MP4Err err; - MP4ItemPropertyContainerAtomPtr self; - - self = (MP4ItemPropertyContainerAtomPtr) calloc( 1, sizeof(MP4ItemPropertyContainerAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4ItemPropertyContainerAtomType; - self->name = "Item Property Container"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addAtom = addAtom; - err = MP4MakeLinkedList(&self->atomList); if (err) goto bail; - - - *outAtom = self; + MP4Err err; + MP4ItemPropertyContainerAtomPtr self; + + self = (MP4ItemPropertyContainerAtomPtr)calloc(1, sizeof(MP4ItemPropertyContainerAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4ItemPropertyContainerAtomType; + self->name = "Item Property Container"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addAtom = addAtom; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/ItemProtectionAtom.c b/IsoLib/libisomediafile/src/ItemProtectionAtom.c index 0f1291d..0d920a5 100644 --- a/IsoLib/libisomediafile/src/ItemProtectionAtom.c +++ b/IsoLib/libisomediafile/src/ItemProtectionAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,130 +15,138 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ItemProtectionAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ItemProtectionAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISOItemProtectionAtomPtr self; - u32 i; - err = MP4NoErr; - self = (ISOItemProtectionAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + ISOItemProtectionAtomPtr self; + u32 i; + err = MP4NoErr; + self = (ISOItemProtectionAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err addAtom( ISOItemProtectionAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(ISOItemProtectionAtomPtr self, MP4AtomPtr atom) { - MP4Err err; + MP4Err err; - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - ISOItemProtectionAtomPtr self = (ISOItemProtectionAtomPtr) s; - u32 count; - - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - err = MP4GetListEntryCount( self->atomList, &count ); if (err) goto bail; - PUT16_V( count ); - - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + ISOItemProtectionAtomPtr self = (ISOItemProtectionAtomPtr)s; + u32 count; + + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + err = MP4GetListEntryCount(self->atomList, &count); + if(err) goto bail; + PUT16_V(count); + + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISOItemProtectionAtomPtr self = (ISOItemProtectionAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 2; - ADD_ATOM_LIST_SIZE( atomList ); - + MP4Err err; + ISOItemProtectionAtomPtr self = (ISOItemProtectionAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 2; + ADD_ATOM_LIST_SIZE(atomList); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - u32 in_count; - u32 list_count; - MP4Err err; - ISOItemProtectionAtomPtr self = (ISOItemProtectionAtomPtr) s; - - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ); - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET16_V( in_count ); - - PARSE_ATOM_INCLUDES(ISOItemInfoAtom); - - err = MP4GetListEntryCount( self->atomList, &list_count ); if (err) goto bail; - if (list_count != in_count) { BAILWITHERROR( MP4BadDataErr ); } - + u32 in_count; + u32 list_count; + MP4Err err; + ISOItemProtectionAtomPtr self = (ISOItemProtectionAtomPtr)s; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET16_V(in_count); + + PARSE_ATOM_INCLUDES(ISOItemInfoAtom); + + err = MP4GetListEntryCount(self->atomList, &list_count); + if(err) goto bail; + if(list_count != in_count) + { + BAILWITHERROR(MP4BadDataErr); + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err ISOCreateItemProtectionAtom( ISOItemProtectionAtomPtr *outAtom ) +MP4Err ISOCreateItemProtectionAtom(ISOItemProtectionAtomPtr *outAtom) { - MP4Err err; - ISOItemProtectionAtomPtr self; - - self = (ISOItemProtectionAtomPtr) calloc( 1, sizeof(ISOItemProtectionAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOItemProtectionAtomType; - self->name = "item protection"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addAtom = addAtom; - *outAtom = self; + MP4Err err; + ISOItemProtectionAtomPtr self; + + self = (ISOItemProtectionAtomPtr)calloc(1, sizeof(ISOItemProtectionAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOItemProtectionAtomType; + self->name = "item protection"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addAtom = addAtom; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ItemReferenceAtom.c b/IsoLib/libisomediafile/src/ItemReferenceAtom.c index a643d14..00d0e01 100644 --- a/IsoLib/libisomediafile/src/ItemReferenceAtom.c +++ b/IsoLib/libisomediafile/src/ItemReferenceAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 2014. @@ -25,111 +25,116 @@ derivative works. Copyright (c) 2014. #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISOItemReferenceAtomPtr self; - u32 i; - err = MP4NoErr; - self = (ISOItemReferenceAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ); - - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + ISOItemReferenceAtomPtr self; + u32 i; + err = MP4NoErr; + self = (ISOItemReferenceAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - ISOItemReferenceAtomPtr self = (ISOItemReferenceAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + ISOItemReferenceAtomPtr self = (ISOItemReferenceAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISOItemReferenceAtomPtr self = (ISOItemReferenceAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; + MP4Err err; + ISOItemReferenceAtomPtr self = (ISOItemReferenceAtomPtr)s; + err = MP4NoErr; - ADD_ATOM_LIST_SIZE( atomList ); + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - ISOItemReferenceAtomPtr self = (ISOItemReferenceAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - while (self->bytesRead < self->size) + MP4Err err; + ISOItemReferenceAtomPtr self = (ISOItemReferenceAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + while(self->bytesRead < self->size) + { + ISOSingleItemTypeReferenceAtomPtr atm; + err = ISOCreateSingleItemTypeReferenceAtom(&atm, 0, self->version); + if(err) goto bail; + + err = atm->createFromInputStream((MP4AtomPtr)atm, NULL, (char *)inputStream); + + self->bytesRead += atm->size; + if(((atm->type) == MP4FreeSpaceAtomType) || ((atm->type) == MP4SkipAtomType)) + { + atm->destroy((MP4AtomPtr)atm); + } + else { - ISOSingleItemTypeReferenceAtomPtr atm; - err = ISOCreateSingleItemTypeReferenceAtom(&atm, 0, self->version); if (err) goto bail; - - err = atm->createFromInputStream((MP4AtomPtr) atm, NULL, (char *) inputStream); - - self->bytesRead += atm->size; - if ( ((atm->type)== MP4FreeSpaceAtomType) || ((atm->type)== MP4SkipAtomType)) - { - atm->destroy( (MP4AtomPtr) atm ); - } - else - { - err = MP4AddListEntry( (void*) atm, self->atomList ); if (err) goto bail; - } + err = MP4AddListEntry((void *)atm, self->atomList); + if(err) goto bail; } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err ISOCreateItemReferenceAtom( ISOItemReferenceAtomPtr *outAtom ) +MP4Err ISOCreateItemReferenceAtom(ISOItemReferenceAtomPtr *outAtom) { - MP4Err err; - ISOItemReferenceAtomPtr self; - - self = (ISOItemReferenceAtomPtr) calloc( 1, sizeof(ISOItemReferenceAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOItemReferenceAtomType; - self->name = "item references"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - - *outAtom = self; + MP4Err err; + ISOItemReferenceAtomPtr self; + + self = (ISOItemReferenceAtomPtr)calloc(1, sizeof(ISOItemReferenceAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOItemReferenceAtomType; + self->name = "item references"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/LoudnessAtom.c b/IsoLib/libisomediafile/src/LoudnessAtom.c index e1cfe0f..553281f 100644 --- a/IsoLib/libisomediafile/src/LoudnessAtom.c +++ b/IsoLib/libisomediafile/src/LoudnessAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 2014. @@ -30,176 +30,181 @@ derivative works. Copyright (c) 2014. #ifdef ISMACrypt -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 i; - MP4LoudnessAtomPtr self = (MP4LoudnessAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - DESTROY_ATOM_LIST_V(self->albumLoudnessInfoList); - DESTROY_ATOM_LIST_V(self->trackLoudnessInfoList); - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + u32 i; + MP4LoudnessAtomPtr self = (MP4LoudnessAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + DESTROY_ATOM_LIST_V(self->albumLoudnessInfoList); + DESTROY_ATOM_LIST_V(self->trackLoudnessInfoList); + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err addAtom( MP4LoudnessAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4LoudnessAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - if (atom->type == MP4TrackLoudnessInfoAtomType) - err = MP4AddListEntry( atom, self->trackLoudnessInfoList ); if (err) goto bail; - if (atom->type == MP4AlbumLoudnessInfoAtomType) - err = MP4AddListEntry( atom, self->albumLoudnessInfoList ); if (err) goto bail; + MP4Err err; + err = MP4NoErr; + if(atom->type == MP4TrackLoudnessInfoAtomType) + err = MP4AddListEntry(atom, self->trackLoudnessInfoList); + if(err) goto bail; + if(atom->type == MP4AlbumLoudnessInfoAtomType) + err = MP4AddListEntry(atom, self->albumLoudnessInfoList); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4LoudnessAtomPtr self = (MP4LoudnessAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( (MP4AtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; + MP4Err err; + MP4LoudnessAtomPtr self = (MP4LoudnessAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields((MP4AtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST ( trackLoudnessInfoList ); - SERIALIZE_ATOM_LIST ( albumLoudnessInfoList ); + SERIALIZE_ATOM_LIST(trackLoudnessInfoList); + SERIALIZE_ATOM_LIST(albumLoudnessInfoList); - assert( self->bytesWritten == self->size ); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serializeData( struct MP4Atom* s, char* buffer ) +static MP4Err serializeData(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4LoudnessAtomPtr self = (MP4LoudnessAtomPtr) s; - err = MP4NoErr; - - SERIALIZE_ATOM_LIST ( trackLoudnessInfoList ); - SERIALIZE_ATOM_LIST ( albumLoudnessInfoList ); - + MP4Err err; + MP4LoudnessAtomPtr self = (MP4LoudnessAtomPtr)s; + err = MP4NoErr; + + SERIALIZE_ATOM_LIST(trackLoudnessInfoList); + SERIALIZE_ATOM_LIST(albumLoudnessInfoList); + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err getDataSize( struct MP4Atom* s, u32 *dataSizeOut ) +static MP4Err getDataSize(struct MP4Atom *s, u32 *dataSizeOut) { - MP4Err err; - u32 baseAtomFieldSize; - MP4LoudnessAtomPtr self; - - - self = (MP4LoudnessAtomPtr) s; - self->size = 0; - err = MP4NoErr; - err = MP4CalculateBaseAtomFieldSize( (MP4AtomPtr) s ); if (err) goto bail; - - baseAtomFieldSize = self->size; - - ADD_ATOM_LIST_SIZE( trackLoudnessInfoList ); - ADD_ATOM_LIST_SIZE( albumLoudnessInfoList ); - - *dataSizeOut = self->size - baseAtomFieldSize; + MP4Err err; + u32 baseAtomFieldSize; + MP4LoudnessAtomPtr self; + + self = (MP4LoudnessAtomPtr)s; + self->size = 0; + err = MP4NoErr; + err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)s); + if(err) goto bail; + + baseAtomFieldSize = self->size; + + ADD_ATOM_LIST_SIZE(trackLoudnessInfoList); + ADD_ATOM_LIST_SIZE(albumLoudnessInfoList); + + *dataSizeOut = self->size - baseAtomFieldSize; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - u32 baseAtomFieldSize; - MP4LoudnessAtomPtr self; - - self = (MP4LoudnessAtomPtr) s; - err = MP4NoErr; - err = MP4CalculateBaseAtomFieldSize( (MP4AtomPtr) s ); if (err) goto bail; - - baseAtomFieldSize = self->size; - - ADD_ATOM_LIST_SIZE( trackLoudnessInfoList ); - ADD_ATOM_LIST_SIZE( albumLoudnessInfoList ); - - + MP4Err err; + u32 baseAtomFieldSize; + MP4LoudnessAtomPtr self; + + self = (MP4LoudnessAtomPtr)s; + err = MP4NoErr; + err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)s); + if(err) goto bail; + + baseAtomFieldSize = self->size; + + ADD_ATOM_LIST_SIZE(trackLoudnessInfoList); + ADD_ATOM_LIST_SIZE(albumLoudnessInfoList); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4LoudnessAtomPtr self = (MP4LoudnessAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - while (self->bytesRead < self->size ) - { - MP4AtomPtr atom; - err = MP4ParseAtom( inputStream, &atom ); if (err) goto bail; - self->bytesRead += atom->size; - err = addAtom( self, atom ); if (err) goto bail; - } - - assert( self->bytesRead == self->size ); + MP4Err err; + MP4LoudnessAtomPtr self = (MP4LoudnessAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + while(self->bytesRead < self->size) + { + MP4AtomPtr atom; + err = MP4ParseAtom(inputStream, &atom); + if(err) goto bail; + self->bytesRead += atom->size; + err = addAtom(self, atom); + if(err) goto bail; + } + + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateLoudnessAtom( MP4LoudnessAtomPtr *outAtom ) +MP4Err MP4CreateLoudnessAtom(MP4LoudnessAtomPtr *outAtom) { - MP4Err err; - MP4LoudnessAtomPtr self; - - self = (MP4LoudnessAtomPtr) calloc( 1, sizeof(MP4LoudnessAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - - err = MP4MakeLinkedList( &self->trackLoudnessInfoList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->albumLoudnessInfoList ); if (err) goto bail; - - self->type = MP4LoudnessAtomType; - self->name = "Loudness"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addAtom = addAtom; - self->serializeData = serializeData; - self->getDataSize = getDataSize; - - *outAtom = self; + MP4Err err; + MP4LoudnessAtomPtr self; + + self = (MP4LoudnessAtomPtr)calloc(1, sizeof(MP4LoudnessAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + + err = MP4MakeLinkedList(&self->trackLoudnessInfoList); + if(err) goto bail; + err = MP4MakeLinkedList(&self->albumLoudnessInfoList); + if(err) goto bail; + + self->type = MP4LoudnessAtomType; + self->name = "Loudness"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addAtom = addAtom; + self->serializeData = serializeData; + self->getDataSize = getDataSize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } #endif - diff --git a/IsoLib/libisomediafile/src/LoudnessBaseAtom.c b/IsoLib/libisomediafile/src/LoudnessBaseAtom.c index e3bd83d..e6b15a6 100644 --- a/IsoLib/libisomediafile/src/LoudnessBaseAtom.c +++ b/IsoLib/libisomediafile/src/LoudnessBaseAtom.c @@ -28,192 +28,196 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 i; - MP4LoudnessBaseAtomPtr self = (MP4LoudnessBaseAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - for (i = 0; i < self->measurement_count; i++) - { - MP4LoudnessBaseMeasurement *measurement; - MP4GetListEntry(self->measurements, i, (char**) &measurement); - free(measurement); - } - - err = MP4DeleteLinkedList(self->measurements); if (err) goto bail; - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + u32 i; + MP4LoudnessBaseAtomPtr self = (MP4LoudnessBaseAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + for(i = 0; i < self->measurement_count; i++) + { + MP4LoudnessBaseMeasurement *measurement; + MP4GetListEntry(self->measurements, i, (char **)&measurement); + free(measurement); + } + + err = MP4DeleteLinkedList(self->measurements); + if(err) goto bail; + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - u8 tmp8; - MP4Err err; - u8 i; - MP4LoudnessBaseAtomPtr self = (MP4LoudnessBaseAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - tmp8 = (self->reserved << 5) + (self->downmix_ID >> 2); - PUT8_V(tmp8); - tmp8 = (self->downmix_ID << 6) + self->DRC_set_ID; - PUT8_V(tmp8); - tmp8 = (self->bs_sample_peak_level >> 4) & 0x00FF; - PUT8_V(tmp8); - tmp8 = (self->bs_sample_peak_level & 0x000F) << 4; - tmp8 += (self->bs_true_peak_level >> 8) & 0x000F; - PUT8_V(tmp8); - tmp8 = self->bs_true_peak_level & 0x00FF; - PUT8_V(tmp8); - tmp8 = (self->measurement_system_for_TP << 4) + self->reliability_for_TP; + u8 tmp8; + MP4Err err; + u8 i; + MP4LoudnessBaseAtomPtr self = (MP4LoudnessBaseAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + tmp8 = (self->reserved << 5) + (self->downmix_ID >> 2); + PUT8_V(tmp8); + tmp8 = (self->downmix_ID << 6) + self->DRC_set_ID; + PUT8_V(tmp8); + tmp8 = (self->bs_sample_peak_level >> 4) & 0x00FF; + PUT8_V(tmp8); + tmp8 = (self->bs_sample_peak_level & 0x000F) << 4; + tmp8 += (self->bs_true_peak_level >> 8) & 0x000F; + PUT8_V(tmp8); + tmp8 = self->bs_true_peak_level & 0x00FF; + PUT8_V(tmp8); + tmp8 = (self->measurement_system_for_TP << 4) + self->reliability_for_TP; + PUT8_V(tmp8); + PUT8(measurement_count); + + for(i = 0; i < self->measurement_count; i++) + { + MP4LoudnessBaseMeasurement *measurement; + MP4GetListEntry(self->measurements, i, (char **)&measurement); + PUT8_V(measurement->method_definition); + PUT8_V(measurement->method_value); + tmp8 = (measurement->measurement_system << 4) + measurement->reliability; PUT8_V(tmp8); - PUT8(measurement_count); - - for (i = 0; i < self->measurement_count; i++) - { - MP4LoudnessBaseMeasurement *measurement; - MP4GetListEntry(self->measurements, i, (char**) &measurement); - PUT8_V(measurement->method_definition); - PUT8_V(measurement->method_value); - tmp8 = (measurement->measurement_system << 4) + measurement->reliability; - PUT8_V(tmp8); - } - - assert( self->bytesWritten == self->size ); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4LoudnessBaseAtomPtr self = (MP4LoudnessBaseAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - - self->size += 7; - self->size += 3 * self->measurement_count; - + MP4Err err; + MP4LoudnessBaseAtomPtr self = (MP4LoudnessBaseAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + self->size += 7; + self->size += 3 * self->measurement_count; + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 tmp8; - u8 tmpVar; - u8 i; - MP4LoudnessBaseAtomPtr self = (MP4LoudnessBaseAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET8_V(tmp8); - self->reserved = tmp8 >> 5; - tmpVar = (tmp8 & 0x1F) << 2; - - GET8_V(tmp8); - tmpVar += tmp8 >> 6; - self->downmix_ID = tmpVar; - self->DRC_set_ID = tmp8 & 0x3F; - - GET8_V(tmp8); - self->bs_sample_peak_level = tmp8; - - GET8_V(tmp8); - self->bs_sample_peak_level = (self->bs_sample_peak_level << 4) + (tmp8 >> 4); - self->bs_sample_peak_level = self->bs_sample_peak_level << 4; - self->bs_sample_peak_level = self->bs_sample_peak_level >> 4; /* get sign right */ - self->bs_true_peak_level = tmp8 & 0x0F; - - GET8_V(tmp8); - self->bs_true_peak_level = (self->bs_true_peak_level << 8) + tmp8; - self->bs_true_peak_level = self->bs_true_peak_level << 4; - self->bs_true_peak_level = self->bs_true_peak_level >> 4; /* get sign right */ + MP4Err err; + u32 tmp8; + u8 tmpVar; + u8 i; + MP4LoudnessBaseAtomPtr self = (MP4LoudnessBaseAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET8_V(tmp8); + self->reserved = tmp8 >> 5; + tmpVar = (tmp8 & 0x1F) << 2; + + GET8_V(tmp8); + tmpVar += tmp8 >> 6; + self->downmix_ID = tmpVar; + self->DRC_set_ID = tmp8 & 0x3F; + + GET8_V(tmp8); + self->bs_sample_peak_level = tmp8; + + GET8_V(tmp8); + self->bs_sample_peak_level = (self->bs_sample_peak_level << 4) + (tmp8 >> 4); + self->bs_sample_peak_level = self->bs_sample_peak_level << 4; + self->bs_sample_peak_level = self->bs_sample_peak_level >> 4; /* get sign right */ + self->bs_true_peak_level = tmp8 & 0x0F; + + GET8_V(tmp8); + self->bs_true_peak_level = (self->bs_true_peak_level << 8) + tmp8; + self->bs_true_peak_level = self->bs_true_peak_level << 4; + self->bs_true_peak_level = self->bs_true_peak_level >> 4; /* get sign right */ + + GET8_V(tmp8); + self->measurement_system_for_TP = tmp8 >> 4; + self->reliability_for_TP = tmp8 & 0x0F; + GET8(measurement_count); + + err = MP4MakeLinkedList(&self->measurements); + if(err) goto bail; + for(i = 0; i < self->measurement_count; i++) + { + MP4LoudnessBaseMeasurement *measurement; + measurement = calloc(1, sizeof(MP4LoudnessBaseMeasurement)); + GET8_V(measurement->method_definition); + GET8_V(measurement->method_value); GET8_V(tmp8); - self->measurement_system_for_TP = tmp8 >> 4; - self->reliability_for_TP = tmp8 & 0x0F; - - GET8(measurement_count); - - err = MP4MakeLinkedList(&self->measurements); if (err) goto bail; - for (i = 0; i < self->measurement_count; i++) - { - MP4LoudnessBaseMeasurement *measurement; - measurement = calloc(1, sizeof(MP4LoudnessBaseMeasurement)); - GET8_V(measurement->method_definition); - GET8_V(measurement->method_value); - GET8_V(tmp8); - measurement->measurement_system = tmp8 >> 4; - measurement->reliability = tmp8 & 0x0F; - MP4AddListEntry(measurement, self->measurements); - } - - assert( self->bytesRead == self->size ); + measurement->measurement_system = tmp8 >> 4; + measurement->reliability = tmp8 & 0x0F; + MP4AddListEntry(measurement, self->measurements); + } + + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err MP4CreateLoudnessBaseAtom( MP4LoudnessBaseAtomPtr *outAtom, u32 type ) +MP4Err MP4CreateLoudnessBaseAtom(MP4LoudnessBaseAtomPtr *outAtom, u32 type) { - MP4Err err; - MP4LoudnessBaseAtomPtr self; - - err = MP4NoErr; - self = (MP4LoudnessBaseAtomPtr) calloc( 1, sizeof(MP4LoudnessBaseAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - - - if (type == MP4TrackLoudnessInfoAtomType) - { - self->name = "track loudness info"; - } - else if (type == MP4AlbumLoudnessInfoAtomType) - { - self->name = "album loudness info"; - } - else - { - err = MP4BadParamErr; goto bail; - } - - self->type = type; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->reserved = 0; - - err = MP4MakeLinkedList(&self->measurements); if (err) goto bail; - - *outAtom = self; + MP4Err err; + MP4LoudnessBaseAtomPtr self; + + err = MP4NoErr; + self = (MP4LoudnessBaseAtomPtr)calloc(1, sizeof(MP4LoudnessBaseAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + + if(type == MP4TrackLoudnessInfoAtomType) + { + self->name = "track loudness info"; + } + else if(type == MP4AlbumLoudnessInfoAtomType) + { + self->name = "album loudness info"; + } + else + { + err = MP4BadParamErr; + goto bail; + } + + self->type = type; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->reserved = 0; + + err = MP4MakeLinkedList(&self->measurements); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/MJ2Atoms.h b/IsoLib/libisomediafile/src/MJ2Atoms.h index 535a879..62246a0 100644 --- a/IsoLib/libisomediafile/src/MJ2Atoms.h +++ b/IsoLib/libisomediafile/src/MJ2Atoms.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2Atoms.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2Atoms.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #ifndef INCLUDED_MJ2ATOMS_H @@ -31,98 +31,96 @@ derivative works. Copyright (c) 1999. #include "MP4Atoms.h" #endif - enum { - MJ2JPEG2000SignatureAtomType = MP4_FOUR_CHAR_CODE( 'j', 'P', ' ', ' ' ), - ISOFileTypeAtomType = MP4_FOUR_CHAR_CODE( 'f', 't', 'y', 'p' ), - MJ2JP2HeaderAtomType = MP4_FOUR_CHAR_CODE( 'j', 'p', '2', 'h' ), - MJ2ImageHeaderAtomType = MP4_FOUR_CHAR_CODE( 'i', 'h', 'd', 'r' ), - MJ2BitsPerComponentAtomType = MP4_FOUR_CHAR_CODE( 'b', 'p', 'c', 'c' ), - MJ2ColorSpecificationAtomType = MP4_FOUR_CHAR_CODE( 'c', 'o', 'l', 'r' ), - MJ2PaletteAtomType = MP4_FOUR_CHAR_CODE( 'p', 'c', 'l', 'r' ), - MJ2ChannelDefinitionAtomType = MP4_FOUR_CHAR_CODE( 'c', 'd', 'e', 'f' ), - MJ2ResolutionAtomType = MP4_FOUR_CHAR_CODE( 'r', 'e', 's', ' ' ) + MJ2JPEG2000SignatureAtomType = MP4_FOUR_CHAR_CODE('j', 'P', ' ', ' '), + ISOFileTypeAtomType = MP4_FOUR_CHAR_CODE('f', 't', 'y', 'p'), + MJ2JP2HeaderAtomType = MP4_FOUR_CHAR_CODE('j', 'p', '2', 'h'), + MJ2ImageHeaderAtomType = MP4_FOUR_CHAR_CODE('i', 'h', 'd', 'r'), + MJ2BitsPerComponentAtomType = MP4_FOUR_CHAR_CODE('b', 'p', 'c', 'c'), + MJ2ColorSpecificationAtomType = MP4_FOUR_CHAR_CODE('c', 'o', 'l', 'r'), + MJ2PaletteAtomType = MP4_FOUR_CHAR_CODE('p', 'c', 'l', 'r'), + MJ2ChannelDefinitionAtomType = MP4_FOUR_CHAR_CODE('c', 'd', 'e', 'f'), + MJ2ResolutionAtomType = MP4_FOUR_CHAR_CODE('r', 'e', 's', ' ') }; enum { - MJ2JPEG2000Signature = 0x0D0A870A, /* signature data for signature box */ - MJ2JPEG2000SignatureSize = 4 + MJ2JPEG2000Signature = 0x0D0A870A, /* signature data for signature box */ + MJ2JPEG2000SignatureSize = 4 }; typedef struct MJ2JPEG2000SignatureAtom { - MP4_BASE_ATOM - u32 signature; /* must be MJ2JPEG2000Signature */ + MP4_BASE_ATOM + u32 signature; /* must be MJ2JPEG2000Signature */ } MJ2JPEG2000SignatureAtom, *MJ2JPEG2000SignatureAtomPtr; typedef struct MJ2ImageHeaderAtom { - MP4_BASE_ATOM - - u32 height; /* height of the image */ - u32 width; /* width of the image */ - u32 compCount; /* number of components */ - u32 compBits; /* bits per component */ - u32 compressionType; /* compression type */ - u32 colorspaceKnown; /* is the colorspace of the image data known? */ - u32 ip; /* does this file contain intellectual property rights info? */ + MP4_BASE_ATOM + + u32 height; /* height of the image */ + u32 width; /* width of the image */ + u32 compCount; /* number of components */ + u32 compBits; /* bits per component */ + u32 compressionType; /* compression type */ + u32 colorspaceKnown; /* is the colorspace of the image data known? */ + u32 ip; /* does this file contain intellectual property rights info? */ } MJ2ImageHeaderAtom, *MJ2ImageHeaderAtomPtr; typedef struct MJ2BitsPerComponentAtom { - MP4_BASE_ATOM - - ISOErr (*addbpcItem)(struct MJ2BitsPerComponentAtom *self, u8 bpc ); - u32 bpcCount; /* the number of items in the bits per component list */ - u8 *bitsPerComponent; /* bit depths of the corresponding components */ + MP4_BASE_ATOM + + ISOErr (*addbpcItem)(struct MJ2BitsPerComponentAtom *self, u8 bpc); + u32 bpcCount; /* the number of items in the bits per component list */ + u8 *bitsPerComponent; /* bit depths of the corresponding components */ } MJ2BitsPerComponentAtom, *MJ2BitsPerComponentAtomPtr; enum { - MJ2EnumeratedColorSpace = 1, /* enumerated colorspace in enumCS field*/ - MJ2RestrictedICCProfile = 2 /* ICC profile in the profile field */ + MJ2EnumeratedColorSpace = 1, /* enumerated colorspace in enumCS field*/ + MJ2RestrictedICCProfile = 2 /* ICC profile in the profile field */ }; typedef struct MJ2ColorSpecificationAtom { - MP4_BASE_ATOM - - u32 method; /* the specification method; use constants defined above */ - u32 precedence; /* the precedence; currently must be 0 */ - u32 approx; /* the colorspace approximation; currently must be 0 */ - u32 enumCS; /* enumerated colorspace; used only if method == MJ2EnumeratedColorSpace */ - char *profile; /* ICC profile; used only if method == MJ2RestrictedICCProfile */ - u32 profileSize; /* size of data pointed to by profile */ + MP4_BASE_ATOM + + u32 method; /* the specification method; use constants defined above */ + u32 precedence; /* the precedence; currently must be 0 */ + u32 approx; /* the colorspace approximation; currently must be 0 */ + u32 enumCS; /* enumerated colorspace; used only if method == MJ2EnumeratedColorSpace */ + char *profile; /* ICC profile; used only if method == MJ2RestrictedICCProfile */ + u32 profileSize; /* size of data pointed to by profile */ } MJ2ColorSpecificationAtom, *MJ2ColorSpecificationAtomPtr; typedef struct MJ2HeaderAtom { - MP4_BASE_ATOM - - ISOErr (*addAtom)( struct MJ2HeaderAtom* self, MP4AtomPtr atom ); - ISOAtomPtr imageHeaderAtom; - ISOAtomPtr bitsPerComponentAtom; - ISOAtomPtr colorSpecificationAtom; - ISOAtomPtr paletteAtom; - ISOAtomPtr channelDefinitionAtom; - ISOAtomPtr resolutionAtom; - ISOLinkedList atomList; -} MJ2HeaderAtom, *MJ2HeaderAtomPtr; + MP4_BASE_ATOM + ISOErr (*addAtom)(struct MJ2HeaderAtom *self, MP4AtomPtr atom); + ISOAtomPtr imageHeaderAtom; + ISOAtomPtr bitsPerComponentAtom; + ISOAtomPtr colorSpecificationAtom; + ISOAtomPtr paletteAtom; + ISOAtomPtr channelDefinitionAtom; + ISOAtomPtr resolutionAtom; + ISOLinkedList atomList; +} MJ2HeaderAtom, *MJ2HeaderAtomPtr; /* public functions */ -ISOErr MJ2CreateSignatureAtom( MJ2JPEG2000SignatureAtomPtr *outAtom ); -ISOErr MJ2CreateFileTypeAtom( ISOFileTypeAtomPtr *outAtom ); -ISOErr MJ2CreateImageHeaderAtom( MJ2ImageHeaderAtomPtr *outAtom ); -ISOErr MJ2CreateBitsPerComponentAtom( MJ2BitsPerComponentAtomPtr *outAtom ); -ISOErr MJ2CreateColorSpecificationAtom( MJ2ColorSpecificationAtomPtr *outAtom ); +ISOErr MJ2CreateSignatureAtom(MJ2JPEG2000SignatureAtomPtr *outAtom); +ISOErr MJ2CreateFileTypeAtom(ISOFileTypeAtomPtr *outAtom); +ISOErr MJ2CreateImageHeaderAtom(MJ2ImageHeaderAtomPtr *outAtom); +ISOErr MJ2CreateBitsPerComponentAtom(MJ2BitsPerComponentAtomPtr *outAtom); +ISOErr MJ2CreateColorSpecificationAtom(MJ2ColorSpecificationAtomPtr *outAtom); /* To be supplied ISOErr MJ2CreatePaletteAtom( MJ2PaletteAtomPtr *outAtom ); ISOErr MJ2CreateChannelDefinitionAtom( MJ2ChannelDefinitionAtomPtr *outAtom ); ISOErr MJ2CreateResolutionAtom( MJ2ResolutionAtomPtr *outAtom ); */ -ISOErr MJ2CreateHeaderAtom( MJ2HeaderAtomPtr *outAtom ); +ISOErr MJ2CreateHeaderAtom(MJ2HeaderAtomPtr *outAtom); #endif diff --git a/IsoLib/libisomediafile/src/MJ2BitsPerComponentAtom.c b/IsoLib/libisomediafile/src/MJ2BitsPerComponentAtom.c index eff0c13..e8972ff 100644 --- a/IsoLib/libisomediafile/src/MJ2BitsPerComponentAtom.c +++ b/IsoLib/libisomediafile/src/MJ2BitsPerComponentAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,158 +15,156 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2BitsPerComponentAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2BitsPerComponentAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MJ2Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - ISOErr err = ISONoErr; - MJ2BitsPerComponentAtomPtr self = (MJ2BitsPerComponentAtomPtr) s; - - if ( self == NULL ) - BAILWITHERROR( ISOBadParamErr ) - - if ( self->bitsPerComponent ) - { - free( self->bitsPerComponent ); - self->bitsPerComponent = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + ISOErr err = ISONoErr; + MJ2BitsPerComponentAtomPtr self = (MJ2BitsPerComponentAtomPtr)s; + + if(self == NULL) BAILWITHERROR(ISOBadParamErr) + + if(self->bitsPerComponent) + { + free(self->bitsPerComponent); + self->bitsPerComponent = NULL; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static ISOErr serialize( struct MP4Atom* s, char* buffer ) +static ISOErr serialize(struct MP4Atom *s, char *buffer) { - ISOErr err; - u32 i; - MJ2BitsPerComponentAtomPtr self = (MJ2BitsPerComponentAtomPtr) s; - - err = ISONoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - for ( i = 0; i < self->bpcCount; i++ ) - { - PUTBYTES( &self->bitsPerComponent[i], sizeof(u8) ); - } - - assert( self->bytesWritten == self->size ); + ISOErr err; + u32 i; + MJ2BitsPerComponentAtomPtr self = (MJ2BitsPerComponentAtomPtr)s; + + err = ISONoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + for(i = 0; i < self->bpcCount; i++) + { + PUTBYTES(&self->bitsPerComponent[i], sizeof(u8)); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr calculateSize( struct MP4Atom* s ) +static ISOErr calculateSize(struct MP4Atom *s) { - ISOErr err; - MJ2BitsPerComponentAtomPtr self = (MJ2BitsPerComponentAtomPtr) s; - err = ISONoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += self->bpcCount * sizeof(u8); + ISOErr err; + MJ2BitsPerComponentAtomPtr self = (MJ2BitsPerComponentAtomPtr)s; + err = ISONoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += self->bpcCount * sizeof(u8); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } /* add a bits-per-component item to the list */ -static ISOErr addbpcItem(struct MJ2BitsPerComponentAtom *self, u8 bpc ) +static ISOErr addbpcItem(struct MJ2BitsPerComponentAtom *self, u8 bpc) { - ISOErr err; - err = ISONoErr; - self->bpcCount++; - self->bitsPerComponent = (u8 *) realloc( self->bitsPerComponent, self->bpcCount * sizeof(u8) ); - TESTMALLOC( self->bitsPerComponent ); - self->bitsPerComponent[ self->bpcCount - 1 ] = (u8) bpc; + ISOErr err; + err = ISONoErr; + self->bpcCount++; + self->bitsPerComponent = (u8 *)realloc(self->bitsPerComponent, self->bpcCount * sizeof(u8)); + TESTMALLOC(self->bitsPerComponent); + self->bitsPerComponent[self->bpcCount - 1] = (u8)bpc; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static ISOErr createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - ISOErr err; - u32 items = 0; - long bytesToRead; - MJ2BitsPerComponentAtomPtr self = (MJ2BitsPerComponentAtomPtr) s; - - err = ISONoErr; - if ( self == NULL ) - BAILWITHERROR( ISOBadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - bytesToRead = self->size - self->bytesRead; - if ( bytesToRead <= 0 ) /* there must be at least one item in the list */ - BAILWITHERROR( ISOBadDataErr ) - - if ( self->bitsPerComponent ) - free( self->bitsPerComponent ); - - self->bitsPerComponent = (u8 *) calloc( 1, bytesToRead ); - TESTMALLOC( self->bitsPerComponent ); - - while ( bytesToRead > 0 ) - { - GET8( bitsPerComponent[items] ); - items++; - bytesToRead = self->size - self->bytesRead; - } - - self->bpcCount = items; + ISOErr err; + u32 items = 0; + long bytesToRead; + MJ2BitsPerComponentAtomPtr self = (MJ2BitsPerComponentAtomPtr)s; + + err = ISONoErr; + if(self == NULL) BAILWITHERROR(ISOBadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + bytesToRead = self->size - self->bytesRead; + if(bytesToRead <= 0) /* there must be at least one item in the list */ + BAILWITHERROR(ISOBadDataErr) + + if(self->bitsPerComponent) free(self->bitsPerComponent); + + self->bitsPerComponent = (u8 *)calloc(1, bytesToRead); + TESTMALLOC(self->bitsPerComponent); + + while(bytesToRead > 0) + { + GET8(bitsPerComponent[items]); + items++; + bytesToRead = self->size - self->bytesRead; + } + + self->bpcCount = items; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISOErr MJ2CreateBitsPerComponentAtom( MJ2BitsPerComponentAtomPtr *outAtom ) +ISOErr MJ2CreateBitsPerComponentAtom(MJ2BitsPerComponentAtomPtr *outAtom) { - ISOErr err; - MJ2BitsPerComponentAtomPtr self; - - self = (MJ2BitsPerComponentAtomPtr) calloc( 1, sizeof( MJ2BitsPerComponentAtom ) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - - self->type = MJ2BitsPerComponentAtomType; - self->name = "JPEG 2000 bits-per-component atom"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addbpcItem = addbpcItem; - - self->bitsPerComponent = (u8 *) calloc( 1, sizeof( u8 ) ); - TESTMALLOC( self->bitsPerComponent ); - - self->bitsPerComponent[0] = 0; - self->bpcCount = (u32) 1; - - *outAtom = self; + ISOErr err; + MJ2BitsPerComponentAtomPtr self; + + self = (MJ2BitsPerComponentAtomPtr)calloc(1, sizeof(MJ2BitsPerComponentAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + + self->type = MJ2BitsPerComponentAtomType; + self->name = "JPEG 2000 bits-per-component atom"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addbpcItem = addbpcItem; + + self->bitsPerComponent = (u8 *)calloc(1, sizeof(u8)); + TESTMALLOC(self->bitsPerComponent); + + self->bitsPerComponent[0] = 0; + self->bpcCount = (u32)1; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - diff --git a/IsoLib/libisomediafile/src/MJ2ColorSpecificationAtom.c b/IsoLib/libisomediafile/src/MJ2ColorSpecificationAtom.c index 2bf3965..df932bc 100644 --- a/IsoLib/libisomediafile/src/MJ2ColorSpecificationAtom.c +++ b/IsoLib/libisomediafile/src/MJ2ColorSpecificationAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,149 +15,148 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2ColorSpecificationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2ColorSpecificationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MJ2Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - ISOErr err = ISONoErr; - MJ2ColorSpecificationAtomPtr self = (MJ2ColorSpecificationAtomPtr) s; - - if ( self == NULL ) - BAILWITHERROR( ISOBadParamErr ) - - if ( self->profile ) - { - free( self->profile ); - self->profile = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + ISOErr err = ISONoErr; + MJ2ColorSpecificationAtomPtr self = (MJ2ColorSpecificationAtomPtr)s; + + if(self == NULL) BAILWITHERROR(ISOBadParamErr) + + if(self->profile) + { + free(self->profile); + self->profile = NULL; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static ISOErr serialize( struct MP4Atom* s, char* buffer ) +static ISOErr serialize(struct MP4Atom *s, char *buffer) { - ISOErr err; - MJ2ColorSpecificationAtomPtr self = (MJ2ColorSpecificationAtomPtr) s; - - err = ISONoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - PUT8( method ); - PUT8( precedence ); - PUT8( approx ); - - if ( self->method == MJ2EnumeratedColorSpace ) - { - PUT32( enumCS ); - } - else if ( self->method == MJ2RestrictedICCProfile ) - { - PUTBYTES( self->profile, self->profileSize ); - } - - assert( self->bytesWritten == self->size ); + ISOErr err; + MJ2ColorSpecificationAtomPtr self = (MJ2ColorSpecificationAtomPtr)s; + + err = ISONoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + PUT8(method); + PUT8(precedence); + PUT8(approx); + + if(self->method == MJ2EnumeratedColorSpace) + { + PUT32(enumCS); + } + else if(self->method == MJ2RestrictedICCProfile) + { + PUTBYTES(self->profile, self->profileSize); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr calculateSize( struct MP4Atom* s ) +static ISOErr calculateSize(struct MP4Atom *s) { - ISOErr err; - MJ2ColorSpecificationAtomPtr self = (MJ2ColorSpecificationAtomPtr) s; - err = ISONoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 3 * sizeof(u8); - - if ( self->method == MJ2EnumeratedColorSpace ) - { - self->size += sizeof(u32); - } - else if ( self->method == MJ2RestrictedICCProfile ) - { - self->size += self->profileSize; - } + ISOErr err; + MJ2ColorSpecificationAtomPtr self = (MJ2ColorSpecificationAtomPtr)s; + err = ISONoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 3 * sizeof(u8); + + if(self->method == MJ2EnumeratedColorSpace) + { + self->size += sizeof(u32); + } + else if(self->method == MJ2RestrictedICCProfile) + { + self->size += self->profileSize; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static ISOErr createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - ISOErr err; - MJ2ColorSpecificationAtomPtr self = (MJ2ColorSpecificationAtomPtr) s; - - err = ISONoErr; - if ( self == NULL ) - BAILWITHERROR( ISOBadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET8( method ); - GET8( precedence ); - GET8( approx ); - - if ( self->method == MJ2EnumeratedColorSpace ) - { - GET32( enumCS ); - } - else if ( self->method == MJ2RestrictedICCProfile ) - { - self->profileSize = self->size - self->bytesRead; - self->profile = (char*) malloc( self->profileSize ); - TESTMALLOC( self->profile ); - GETBYTES( self->profileSize, profile ); - } + ISOErr err; + MJ2ColorSpecificationAtomPtr self = (MJ2ColorSpecificationAtomPtr)s; + + err = ISONoErr; + if(self == NULL) BAILWITHERROR(ISOBadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET8(method); + GET8(precedence); + GET8(approx); + + if(self->method == MJ2EnumeratedColorSpace) + { + GET32(enumCS); + } + else if(self->method == MJ2RestrictedICCProfile) + { + self->profileSize = self->size - self->bytesRead; + self->profile = (char *)malloc(self->profileSize); + TESTMALLOC(self->profile); + GETBYTES(self->profileSize, profile); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISOErr MJ2CreateColorSpecificationAtom( MJ2ColorSpecificationAtomPtr *outAtom ) +ISOErr MJ2CreateColorSpecificationAtom(MJ2ColorSpecificationAtomPtr *outAtom) { - ISOErr err; - MJ2ColorSpecificationAtomPtr self; - - self = (MJ2ColorSpecificationAtomPtr) calloc( 1, sizeof( MJ2ColorSpecificationAtom ) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - - self->type = MJ2ColorSpecificationAtomType; - self->name = "JPEG 2000 color specification atom"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->method = MJ2EnumeratedColorSpace; - *outAtom = self; + ISOErr err; + MJ2ColorSpecificationAtomPtr self; + + self = (MJ2ColorSpecificationAtomPtr)calloc(1, sizeof(MJ2ColorSpecificationAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + + self->type = MJ2ColorSpecificationAtomType; + self->name = "JPEG 2000 color specification atom"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->method = MJ2EnumeratedColorSpace; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - diff --git a/IsoLib/libisomediafile/src/MJ2FileTypeAtom.c b/IsoLib/libisomediafile/src/MJ2FileTypeAtom.c index b18bca2..7cd7bfe 100644 --- a/IsoLib/libisomediafile/src/MJ2FileTypeAtom.c +++ b/IsoLib/libisomediafile/src/MJ2FileTypeAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,226 +15,235 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2FileTypeAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2FileTypeAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MJ2Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - ISOErr err = ISONoErr; - ISOFileTypeAtomPtr self = (ISOFileTypeAtomPtr) s; - - if ( self == NULL ) - BAILWITHERROR( ISOBadParamErr ) - - if ( self->compatibilityList ) - { - free( self->compatibilityList ); - self->compatibilityList = NULL; - } - if ( self->super ) - self->super->destroy( s ); - + ISOErr err = ISONoErr; + ISOFileTypeAtomPtr self = (ISOFileTypeAtomPtr)s; + + if(self == NULL) BAILWITHERROR(ISOBadParamErr) + + if(self->compatibilityList) + { + free(self->compatibilityList); + self->compatibilityList = NULL; + } + if(self->super) self->super->destroy(s); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static ISOErr serialize( struct MP4Atom* s, char* buffer ) +static ISOErr serialize(struct MP4Atom *s, char *buffer) { - ISOErr err; - u32 i; - ISOFileTypeAtomPtr self = (ISOFileTypeAtomPtr) s; - - err = ISONoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - PUT32( brand ); - PUT32( minorVersion ); - - for ( i = 0; i < self->itemCount; i++ ) - { - PUT32_V( (self->compatibilityList[i]) ); - } - - assert( self->bytesWritten == self->size ); + ISOErr err; + u32 i; + ISOFileTypeAtomPtr self = (ISOFileTypeAtomPtr)s; + + err = ISONoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + PUT32(brand); + PUT32(minorVersion); + + for(i = 0; i < self->itemCount; i++) + { + PUT32_V((self->compatibilityList[i])); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr calculateSize( struct MP4Atom* s ) +static ISOErr calculateSize(struct MP4Atom *s) { - ISOErr err; - ISOFileTypeAtomPtr self = (ISOFileTypeAtomPtr) s; - err = ISONoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 2 * sizeof(u32); /* brand and minorVersion */ - self->size += self->itemCount * sizeof(u32); /* compatibilityList */ + ISOErr err; + ISOFileTypeAtomPtr self = (ISOFileTypeAtomPtr)s; + err = ISONoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 2 * sizeof(u32); /* brand and minorVersion */ + self->size += self->itemCount * sizeof(u32); /* compatibilityList */ bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr getBrand(struct ISOFileTypeAtom *self, u32* standard, u32* minorversion ) +static ISOErr getBrand(struct ISOFileTypeAtom *self, u32 *standard, u32 *minorversion) { - *standard = self->brand; - *minorversion = self->minorVersion; - - return MP4NoErr; + *standard = self->brand; + *minorversion = self->minorVersion; + + return MP4NoErr; } -static u32 getStandard(struct ISOFileTypeAtom *self, u32 standard ) +static u32 getStandard(struct ISOFileTypeAtom *self, u32 standard) { - u32 i; - u32 outval; - - outval = 0; - - for (i=0; iitemCount; i++) { - if (self->compatibilityList[ i ] == standard) { - outval = standard; - break; - } - } - return outval; + u32 i; + u32 outval; + + outval = 0; + + for(i = 0; i < self->itemCount; i++) + { + if(self->compatibilityList[i] == standard) + { + outval = standard; + break; + } + } + return outval; } /* add a file type to the compatibility list */ -static ISOErr addStandard(struct ISOFileTypeAtom *self, u32 standard ) +static ISOErr addStandard(struct ISOFileTypeAtom *self, u32 standard) { - ISOErr err; - err = ISONoErr; - - if (!getStandard(self, standard)) { - self->itemCount++; - self->compatibilityList = (u32*) realloc( self->compatibilityList, self->itemCount * sizeof(u32) ); - TESTMALLOC( self->compatibilityList ); - self->compatibilityList[ self->itemCount - 1 ] = (u32) standard; - } + ISOErr err; + err = ISONoErr; + + if(!getStandard(self, standard)) + { + self->itemCount++; + self->compatibilityList = + (u32 *)realloc(self->compatibilityList, self->itemCount * sizeof(u32)); + TESTMALLOC(self->compatibilityList); + self->compatibilityList[self->itemCount - 1] = (u32)standard; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr setBrand(struct ISOFileTypeAtom *self, u32 standard, u32 minorversion ) +static ISOErr setBrand(struct ISOFileTypeAtom *self, u32 standard, u32 minorversion) { - u32 oldstandard; - MP4Err err; - oldstandard = self->brand; - - self->brand = standard; - self->minorVersion = minorversion; - - /* in the compatibility list are also the new major brand, and the old one, if any */ - if (oldstandard) { err = addStandard( self, oldstandard); if (err) return err; } - err = addStandard( self, standard); if (err) return err; - - return err; + u32 oldstandard; + MP4Err err; + oldstandard = self->brand; + + self->brand = standard; + self->minorVersion = minorversion; + + /* in the compatibility list are also the new major brand, and the old one, if any */ + if(oldstandard) + { + err = addStandard(self, oldstandard); + if(err) return err; + } + err = addStandard(self, standard); + if(err) return err; + + return err; } -static ISOErr createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static ISOErr createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - ISOErr err; - u32 items = 0; - long bytesToRead; - char typeString[8]; - char msgString[80]; - ISOFileTypeAtomPtr self = (ISOFileTypeAtomPtr) s; - - err = ISONoErr; - if ( self == NULL ) - BAILWITHERROR( ISOBadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( brand ); - MP4TypeToString( self->brand, typeString ); - sprintf( msgString, " major brand is '%s'", typeString ); - inputStream->msg( inputStream, msgString ); - - GET32( minorVersion ); - - bytesToRead = self->size - self->bytesRead; - if ( bytesToRead < ((long) sizeof( u32 )) ) /* there must be at least one item in the compatibility list */ - BAILWITHERROR( ISOBadDataErr ) - - if ( self->compatibilityList ) - free( self->compatibilityList ); - - self->compatibilityList = (u32 *) calloc( 1, bytesToRead ); - TESTMALLOC( self->compatibilityList ); - - while ( bytesToRead > 0 ) - { - if ( bytesToRead < ((long) sizeof( u32 )) ) /* we need to read a full u32 */ - BAILWITHERROR( ISOBadDataErr ) - - GET32( compatibilityList[items] ); - MP4TypeToString( self->compatibilityList[items], typeString ); - sprintf( msgString, " minor brand is '%s'", typeString ); - inputStream->msg( inputStream, msgString ); - items++; - bytesToRead = self->size - self->bytesRead; - } - - self->itemCount = items; + ISOErr err; + u32 items = 0; + long bytesToRead; + char typeString[8]; + char msgString[80]; + ISOFileTypeAtomPtr self = (ISOFileTypeAtomPtr)s; + + err = ISONoErr; + if(self == NULL) BAILWITHERROR(ISOBadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(brand); + MP4TypeToString(self->brand, typeString); + sprintf(msgString, " major brand is '%s'", typeString); + inputStream->msg(inputStream, msgString); + + GET32(minorVersion); + + bytesToRead = self->size - self->bytesRead; + if(bytesToRead < + ((long)sizeof(u32))) /* there must be at least one item in the compatibility list */ + BAILWITHERROR(ISOBadDataErr) + + if(self->compatibilityList) free(self->compatibilityList); + + self->compatibilityList = (u32 *)calloc(1, bytesToRead); + TESTMALLOC(self->compatibilityList); + + while(bytesToRead > 0) + { + if(bytesToRead < ((long)sizeof(u32))) /* we need to read a full u32 */ + BAILWITHERROR(ISOBadDataErr) + + GET32(compatibilityList[items]); + MP4TypeToString(self->compatibilityList[items], typeString); + sprintf(msgString, " minor brand is '%s'", typeString); + inputStream->msg(inputStream, msgString); + items++; + bytesToRead = self->size - self->bytesRead; + } + + self->itemCount = items; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISOErr MJ2CreateFileTypeAtom( ISOFileTypeAtomPtr *outAtom ) +ISOErr MJ2CreateFileTypeAtom(ISOFileTypeAtomPtr *outAtom) { - ISOErr err; - ISOFileTypeAtomPtr self; - - self = (ISOFileTypeAtomPtr) calloc( 1, sizeof(ISOFileTypeAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - - self->type = ISOFileTypeAtomType; - self->name = "file type atom"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addStandard = addStandard; - self->setBrand = setBrand; - self->getBrand = getBrand; - self->getStandard = getStandard; - - self->brand = 0; /* was ISOISOBrand */ - self->minorVersion = (u32) 0; - self->compatibilityList = (u32 *) calloc( 1, sizeof( u32 ) ); - TESTMALLOC( self->compatibilityList ); - - /* self->compatibilityList[0] = ISOISOBrand; */ - /* self->compatibilityList[1] = ISOISOBrand; */ - /* No, MPEG-21 and meta movies are not ISOM branded */ - self->itemCount = (u32) 0; - - *outAtom = self; + ISOErr err; + ISOFileTypeAtomPtr self; + + self = (ISOFileTypeAtomPtr)calloc(1, sizeof(ISOFileTypeAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + + self->type = ISOFileTypeAtomType; + self->name = "file type atom"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addStandard = addStandard; + self->setBrand = setBrand; + self->getBrand = getBrand; + self->getStandard = getStandard; + + self->brand = 0; /* was ISOISOBrand */ + self->minorVersion = (u32)0; + self->compatibilityList = (u32 *)calloc(1, sizeof(u32)); + TESTMALLOC(self->compatibilityList); + + /* self->compatibilityList[0] = ISOISOBrand; */ + /* self->compatibilityList[1] = ISOISOBrand; */ + /* No, MPEG-21 and meta movies are not ISOM branded */ + self->itemCount = (u32)0; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MJ2HeaderAtom.c b/IsoLib/libisomediafile/src/MJ2HeaderAtom.c index a354e2a..357abe3 100644 --- a/IsoLib/libisomediafile/src/MJ2HeaderAtom.c +++ b/IsoLib/libisomediafile/src/MJ2HeaderAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,92 +15,90 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2HeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2HeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MJ2Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - ISOErr err = ISONoErr; - u32 i; - MJ2HeaderAtomPtr self = (MJ2HeaderAtomPtr) s; - - if ( self == NULL ) - BAILWITHERROR( ISOBadParamErr ) - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); - + ISOErr err = ISONoErr; + u32 i; + MJ2HeaderAtomPtr self = (MJ2HeaderAtomPtr)s; + + if(self == NULL) BAILWITHERROR(ISOBadParamErr) + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static ISOErr serialize( struct MP4Atom* s, char* buffer ) +static ISOErr serialize(struct MP4Atom *s, char *buffer) { - ISOErr err; - MJ2HeaderAtomPtr self = (MJ2HeaderAtomPtr) s; - - err = ISONoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + ISOErr err; + MJ2HeaderAtomPtr self = (MJ2HeaderAtomPtr)s; + + err = ISONoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr calculateSize( struct MP4Atom* s ) +static ISOErr calculateSize(struct MP4Atom *s) { - ISOErr err; - MJ2HeaderAtomPtr self = (MJ2HeaderAtomPtr) s; - err = ISONoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE( atomList ); + ISOErr err; + MJ2HeaderAtomPtr self = (MJ2HeaderAtomPtr)s; + err = ISONoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr addAtom( MJ2HeaderAtomPtr self, ISOAtomPtr atom ) +static ISOErr addAtom(MJ2HeaderAtomPtr self, ISOAtomPtr atom) { - ISOErr err; - err = ISONoErr; - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; - switch( atom->type ) - { - case MJ2ImageHeaderAtomType: - if ( self->imageHeaderAtom ) - BAILWITHERROR( ISOBadDataErr ); - self->imageHeaderAtom = atom; - break; - - case MJ2BitsPerComponentAtomType: - if ( self->bitsPerComponentAtom ) - BAILWITHERROR( ISOBadDataErr ); - self->bitsPerComponentAtom = atom; - break; - - case MJ2ColorSpecificationAtomType: - if ( self->colorSpecificationAtom ) - BAILWITHERROR( ISOBadDataErr ); - self->colorSpecificationAtom = atom; - break; + ISOErr err; + err = ISONoErr; + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; + switch(atom->type) + { + case MJ2ImageHeaderAtomType: + if(self->imageHeaderAtom) BAILWITHERROR(ISOBadDataErr); + self->imageHeaderAtom = atom; + break; + + case MJ2BitsPerComponentAtomType: + if(self->bitsPerComponentAtom) BAILWITHERROR(ISOBadDataErr); + self->bitsPerComponentAtom = atom; + break; + + case MJ2ColorSpecificationAtomType: + if(self->colorSpecificationAtom) BAILWITHERROR(ISOBadDataErr); + self->colorSpecificationAtom = atom; + break; #if 0 /* the following optional atoms are not yet implemented */ case MJ2PaletteAtomType: @@ -121,45 +119,45 @@ static ISOErr addAtom( MJ2HeaderAtomPtr self, ISOAtomPtr atom ) self->resolutionAtom = atom; break; #endif - } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static ISOErr createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MJ2HeaderAtom) + PARSE_ATOM_LIST(MJ2HeaderAtom) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISOErr MJ2CreateHeaderAtom( MJ2HeaderAtomPtr *outAtom ) +ISOErr MJ2CreateHeaderAtom(MJ2HeaderAtomPtr *outAtom) { - ISOErr err; - MJ2HeaderAtomPtr self; - - self = (MJ2HeaderAtomPtr) calloc( 1, sizeof(MJ2HeaderAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - - self->type = MJ2JP2HeaderAtomType; - self->name = "JPEG 2000 header atom"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc) createFromInputStream; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addAtom = addAtom; - *outAtom = self; + ISOErr err; + MJ2HeaderAtomPtr self; + + self = (MJ2HeaderAtomPtr)calloc(1, sizeof(MJ2HeaderAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + + self->type = MJ2JP2HeaderAtomType; + self->name = "JPEG 2000 header atom"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addAtom = addAtom; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - diff --git a/IsoLib/libisomediafile/src/MJ2ImageHeaderAtom.c b/IsoLib/libisomediafile/src/MJ2ImageHeaderAtom.c index 260be88..e0d0ff8 100644 --- a/IsoLib/libisomediafile/src/MJ2ImageHeaderAtom.c +++ b/IsoLib/libisomediafile/src/MJ2ImageHeaderAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,121 +15,120 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2ImageHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2ImageHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MJ2Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - ISOErr err = ISONoErr; - MJ2ImageHeaderAtomPtr self = (MJ2ImageHeaderAtomPtr) s; - - if ( self == NULL ) - BAILWITHERROR( ISOBadParamErr ) - - if ( self->super ) - self->super->destroy( s ); + ISOErr err = ISONoErr; + MJ2ImageHeaderAtomPtr self = (MJ2ImageHeaderAtomPtr)s; + + if(self == NULL) BAILWITHERROR(ISOBadParamErr) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static ISOErr serialize( struct MP4Atom* s, char* buffer ) +static ISOErr serialize(struct MP4Atom *s, char *buffer) { - ISOErr err; - MJ2ImageHeaderAtomPtr self = (MJ2ImageHeaderAtomPtr) s; - - err = ISONoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - PUTBYTES( &self->height, sizeof(u32) ); - PUTBYTES( &self->width, sizeof(u32) ); - PUTBYTES( &self->compCount, sizeof(u16) ); - PUTBYTES( &self->compBits, sizeof(u8) ); - PUTBYTES( &self->compressionType, sizeof(u8) ); - PUTBYTES( &self->colorspaceKnown, sizeof(u8) ); - PUTBYTES( &self->ip, sizeof(u8) ); - - assert( self->bytesWritten == self->size ); + ISOErr err; + MJ2ImageHeaderAtomPtr self = (MJ2ImageHeaderAtomPtr)s; + + err = ISONoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + PUTBYTES(&self->height, sizeof(u32)); + PUTBYTES(&self->width, sizeof(u32)); + PUTBYTES(&self->compCount, sizeof(u16)); + PUTBYTES(&self->compBits, sizeof(u8)); + PUTBYTES(&self->compressionType, sizeof(u8)); + PUTBYTES(&self->colorspaceKnown, sizeof(u8)); + PUTBYTES(&self->ip, sizeof(u8)); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr calculateSize( struct MP4Atom* s ) +static ISOErr calculateSize(struct MP4Atom *s) { - ISOErr err; - MJ2ImageHeaderAtomPtr self = (MJ2ImageHeaderAtomPtr) s; - err = ISONoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 2 * sizeof(u32); - self->size += 1 * sizeof(u16); - self->size += 4 * sizeof(u8); + ISOErr err; + MJ2ImageHeaderAtomPtr self = (MJ2ImageHeaderAtomPtr)s; + err = ISONoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 2 * sizeof(u32); + self->size += 1 * sizeof(u16); + self->size += 4 * sizeof(u8); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static ISOErr createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - ISOErr err; - MJ2ImageHeaderAtomPtr self = (MJ2ImageHeaderAtomPtr) s; - - err = ISONoErr; - if ( self == NULL ) - BAILWITHERROR( ISOBadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( height ); - GET32( width ); - GET16( compCount ); - GET8( compBits ); - GET8( compressionType ); - GET8( colorspaceKnown ); - GET8( ip ); + ISOErr err; + MJ2ImageHeaderAtomPtr self = (MJ2ImageHeaderAtomPtr)s; + + err = ISONoErr; + if(self == NULL) BAILWITHERROR(ISOBadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(height); + GET32(width); + GET16(compCount); + GET8(compBits); + GET8(compressionType); + GET8(colorspaceKnown); + GET8(ip); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISOErr MJ2CreateImageHeaderAtom( MJ2ImageHeaderAtomPtr *outAtom ) +ISOErr MJ2CreateImageHeaderAtom(MJ2ImageHeaderAtomPtr *outAtom) { - ISOErr err; - MJ2ImageHeaderAtomPtr self; - - self = (MJ2ImageHeaderAtomPtr) calloc( 1, sizeof(MJ2ImageHeaderAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - - self->type = MJ2ImageHeaderAtomType; - self->name = "JPEG 2000 image header atom"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + ISOErr err; + MJ2ImageHeaderAtomPtr self; + + self = (MJ2ImageHeaderAtomPtr)calloc(1, sizeof(MJ2ImageHeaderAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + + self->type = MJ2ImageHeaderAtomType; + self->name = "JPEG 2000 image header atom"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - diff --git a/IsoLib/libisomediafile/src/MJ2Movies.c b/IsoLib/libisomediafile/src/MJ2Movies.c index 0da6c58..1d85d2a 100644 --- a/IsoLib/libisomediafile/src/MJ2Movies.c +++ b/IsoLib/libisomediafile/src/MJ2Movies.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -43,94 +43,111 @@ derivative works. Copyright (c) 1999. #include #include -ISO_EXTERN ( ISOErr ) -MJ2NewMovie( ISOMovie *outMovie ) +ISO_EXTERN(ISOErr) +MJ2NewMovie(ISOMovie *outMovie) { - ISOErr MP4CreateMediaDataAtom( MP4MediaDataAtomPtr *outAtom ); - ISOErr MP4CreateMovieAtom( MP4MovieAtomPtr *outAtom ); - ISOErr MP4CreateMovieHeaderAtom( MP4MovieHeaderAtomPtr *outAtom ); - - - u64 now; - ISOErr err; - MP4PrivateMovieRecordPtr movie; - MP4MovieAtomPtr moov; - MP4MovieHeaderAtomPtr mvhd; - MP4MediaDataAtomPtr mdat; - ISOFileTypeAtomPtr ftyp; + ISOErr MP4CreateMediaDataAtom(MP4MediaDataAtomPtr * outAtom); + ISOErr MP4CreateMovieAtom(MP4MovieAtomPtr * outAtom); + ISOErr MP4CreateMovieHeaderAtom(MP4MovieHeaderAtomPtr * outAtom); + + u64 now; + ISOErr err; + MP4PrivateMovieRecordPtr movie; + MP4MovieAtomPtr moov; + MP4MovieHeaderAtomPtr mvhd; + MP4MediaDataAtomPtr mdat; + ISOFileTypeAtomPtr ftyp; #ifdef JP2KSTILLIMAGE - MJ2HeaderAtomPtr jp2h; + MJ2HeaderAtomPtr jp2h; #endif - MJ2JPEG2000SignatureAtomPtr sgnt; - - movie = (MP4PrivateMovieRecordPtr) calloc( 1, sizeof(MP4PrivateMovieRecord) ); - if ( movie == NULL ) - { - err = MP4NoMemoryErr; - goto bail; - } - movie->referenceCount = 1; - movie->prepend_handle = NULL; - err = MP4GetCurrentTime( &now ); if (err) goto bail; - err = MP4CreateMovieAtom( (MP4MovieAtomPtr *) &movie->moovAtomPtr ); if (err) goto bail; - moov = (MP4MovieAtomPtr) movie->moovAtomPtr; - err = MP4CreateMovieHeaderAtom( &mvhd ); if (err) goto bail; - mvhd->nextTrackID = 1; - mvhd->creationTime = now; - mvhd->modificationTime = now; - err = moov->addAtom( moov, (MP4AtomPtr) mvhd ); if (err) goto bail; - moov->setTimeScale( moov, 600 ); - err = MP4CreateMediaDataAtom( &mdat ); - movie->mdat = (MP4AtomPtr) mdat; - { - MP4DataHandlerPtr dh; - - err = MP4CreateMdatDataHandler( mdat, &dh ); if (err) goto bail; - movie->inMemoryDataHandler = dh; - } - movie->fileType = ISOMotionJPEG2000FileType; - - err = MJ2CreateFileTypeAtom( &ftyp ); if (err) goto bail; - err = ftyp->setBrand( ftyp, MJ2JPEG2000Brand, 0 ); if (err) goto bail; - err = ftyp->addStandard( ftyp, ISOISOBrand ); if (err) goto bail; - err = ftyp->calculateSize( (MP4AtomPtr) ftyp ); if (err) goto bail; - movie->ftyp = (MP4AtomPtr) ftyp; - - err = MJ2CreateSignatureAtom( &sgnt ); if (err) goto bail; - err = sgnt->calculateSize( (MP4AtomPtr) sgnt ); if (err) goto bail; - movie->sgnt = (MP4AtomPtr) sgnt; - - /* create JPEG-2000 specific atoms */ - /* a header atom only occurs if a still image occurs */ + MJ2JPEG2000SignatureAtomPtr sgnt; + + movie = (MP4PrivateMovieRecordPtr)calloc(1, sizeof(MP4PrivateMovieRecord)); + if(movie == NULL) + { + err = MP4NoMemoryErr; + goto bail; + } + movie->referenceCount = 1; + movie->prepend_handle = NULL; + err = MP4GetCurrentTime(&now); + if(err) goto bail; + err = MP4CreateMovieAtom((MP4MovieAtomPtr *)&movie->moovAtomPtr); + if(err) goto bail; + moov = (MP4MovieAtomPtr)movie->moovAtomPtr; + err = MP4CreateMovieHeaderAtom(&mvhd); + if(err) goto bail; + mvhd->nextTrackID = 1; + mvhd->creationTime = now; + mvhd->modificationTime = now; + err = moov->addAtom(moov, (MP4AtomPtr)mvhd); + if(err) goto bail; + moov->setTimeScale(moov, 600); + err = MP4CreateMediaDataAtom(&mdat); + movie->mdat = (MP4AtomPtr)mdat; + { + MP4DataHandlerPtr dh; + + err = MP4CreateMdatDataHandler(mdat, &dh); + if(err) goto bail; + movie->inMemoryDataHandler = dh; + } + movie->fileType = ISOMotionJPEG2000FileType; + + err = MJ2CreateFileTypeAtom(&ftyp); + if(err) goto bail; + err = ftyp->setBrand(ftyp, MJ2JPEG2000Brand, 0); + if(err) goto bail; + err = ftyp->addStandard(ftyp, ISOISOBrand); + if(err) goto bail; + err = ftyp->calculateSize((MP4AtomPtr)ftyp); + if(err) goto bail; + movie->ftyp = (MP4AtomPtr)ftyp; + + err = MJ2CreateSignatureAtom(&sgnt); + if(err) goto bail; + err = sgnt->calculateSize((MP4AtomPtr)sgnt); + if(err) goto bail; + movie->sgnt = (MP4AtomPtr)sgnt; + + /* create JPEG-2000 specific atoms */ + /* a header atom only occurs if a still image occurs */ #ifdef JP2KSTILLIMAGE - err = MJ2CreateHeaderAtom( &jp2h ); if (err) goto bail; - err = jp2h->calculateSize( (MP4AtomPtr) jp2h ); if (err) goto bail; - movie->jp2h = (MP4AtomPtr) jp2h; - - { - /* add in the required subatoms */ - MJ2ImageHeaderAtomPtr imag; - MJ2BitsPerComponentAtomPtr bpco; - MJ2ColorSpecificationAtomPtr colr; - - err = MJ2CreateImageHeaderAtom( &imag ); if (err) goto bail; - err = MJ2CreateBitsPerComponentAtom( &bpco ); if (err) goto bail; - err = MJ2CreateColorSpecificationAtom( &colr ); if (err) goto bail; - - err = imag->calculateSize( (MP4AtomPtr) imag ); if (err) goto bail; - err = bpco->calculateSize( (MP4AtomPtr) bpco ); if (err) goto bail; - err = colr->calculateSize( (MP4AtomPtr) colr ); if (err) goto bail; - - jp2h->addAtom(jp2h, (ISOAtomPtr) imag); - jp2h->addAtom(jp2h, (ISOAtomPtr) bpco); - jp2h->addAtom(jp2h, (ISOAtomPtr) colr); - } -#endif + err = MJ2CreateHeaderAtom(&jp2h); + if(err) goto bail; + err = jp2h->calculateSize((MP4AtomPtr)jp2h); + if(err) goto bail; + movie->jp2h = (MP4AtomPtr)jp2h; + + { + /* add in the required subatoms */ + MJ2ImageHeaderAtomPtr imag; + MJ2BitsPerComponentAtomPtr bpco; + MJ2ColorSpecificationAtomPtr colr; + + err = MJ2CreateImageHeaderAtom(&imag); + if(err) goto bail; + err = MJ2CreateBitsPerComponentAtom(&bpco); + if(err) goto bail; + err = MJ2CreateColorSpecificationAtom(&colr); + if(err) goto bail; + err = imag->calculateSize((MP4AtomPtr)imag); + if(err) goto bail; + err = bpco->calculateSize((MP4AtomPtr)bpco); + if(err) goto bail; + err = colr->calculateSize((MP4AtomPtr)colr); + if(err) goto bail; + + jp2h->addAtom(jp2h, (ISOAtomPtr)imag); + jp2h->addAtom(jp2h, (ISOAtomPtr)bpco); + jp2h->addAtom(jp2h, (ISOAtomPtr)colr); + } +#endif - *outMovie = (ISOMovie) movie; + *outMovie = (ISOMovie)movie; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MJ2SignatureAtom.c b/IsoLib/libisomediafile/src/MJ2SignatureAtom.c index 8918171..5fd57f3 100644 --- a/IsoLib/libisomediafile/src/MJ2SignatureAtom.c +++ b/IsoLib/libisomediafile/src/MJ2SignatureAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,106 +15,103 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2SignatureAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2SignatureAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MJ2Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - ISOErr err = ISONoErr; - MJ2JPEG2000SignatureAtomPtr self = (MJ2JPEG2000SignatureAtomPtr) s; - - if ( self == NULL ) - BAILWITHERROR( ISOBadParamErr ) - - if ( self->super ) - self->super->destroy( s ); - + ISOErr err = ISONoErr; + MJ2JPEG2000SignatureAtomPtr self = (MJ2JPEG2000SignatureAtomPtr)s; + + if(self == NULL) BAILWITHERROR(ISOBadParamErr) + + if(self->super) self->super->destroy(s); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static ISOErr serialize( struct MP4Atom* s, char* buffer ) +static ISOErr serialize(struct MP4Atom *s, char *buffer) { - ISOErr err; - MJ2JPEG2000SignatureAtomPtr self = (MJ2JPEG2000SignatureAtomPtr) s; - err = ISONoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( &self->signature, MJ2JPEG2000SignatureSize ); - assert( self->bytesWritten == self->size ); + ISOErr err; + MJ2JPEG2000SignatureAtomPtr self = (MJ2JPEG2000SignatureAtomPtr)s; + err = ISONoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(&self->signature, MJ2JPEG2000SignatureSize); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static ISOErr calculateSize( struct MP4Atom* s ) +static ISOErr calculateSize(struct MP4Atom *s) { - ISOErr err; - MJ2JPEG2000SignatureAtomPtr self = (MJ2JPEG2000SignatureAtomPtr) s; - err = ISONoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += MJ2JPEG2000SignatureSize; + ISOErr err; + MJ2JPEG2000SignatureAtomPtr self = (MJ2JPEG2000SignatureAtomPtr)s; + err = ISONoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += MJ2JPEG2000SignatureSize; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static ISOErr createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static ISOErr createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - ISOErr err; - MJ2JPEG2000SignatureAtomPtr self = (MJ2JPEG2000SignatureAtomPtr) s; - - err = ISONoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); - - GET32( signature ); + ISOErr err; + MJ2JPEG2000SignatureAtomPtr self = (MJ2JPEG2000SignatureAtomPtr)s; + + err = ISONoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + + GET32(signature); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISOErr MJ2CreateSignatureAtom( MJ2JPEG2000SignatureAtomPtr *outAtom ) +ISOErr MJ2CreateSignatureAtom(MJ2JPEG2000SignatureAtomPtr *outAtom) { - ISOErr err; - MJ2JPEG2000SignatureAtomPtr self; - - self = (MJ2JPEG2000SignatureAtomPtr) calloc( 1, sizeof(MJ2JPEG2000SignatureAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - - self->type = MJ2JPEG2000SignatureAtomType; - self->name = "JPEG 2000 signature atom"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->signature = MJ2JPEG2000Signature; - *outAtom = self; + ISOErr err; + MJ2JPEG2000SignatureAtomPtr self; + + self = (MJ2JPEG2000SignatureAtomPtr)calloc(1, sizeof(MJ2JPEG2000SignatureAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + + self->type = MJ2JPEG2000SignatureAtomType; + self->name = "JPEG 2000 signature atom"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->signature = MJ2JPEG2000Signature; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - diff --git a/IsoLib/libisomediafile/src/MP4Atoms.c b/IsoLib/libisomediafile/src/MP4Atoms.c old mode 100755 new mode 100644 index 132a109..c16bf9a --- a/IsoLib/libisomediafile/src/MP4Atoms.c +++ b/IsoLib/libisomediafile/src/MP4Atoms.c @@ -24,9 +24,9 @@ * acting on behalf of its Fraunhofer Institute for Telecommunications, * Heinrich Hertz Institute, HHI * All rights reserved. -*/ + */ /* - $Id: MP4Atoms.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MP4Atoms.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -43,851 +43,877 @@ MP4Err MP4CreateHEVCConfigAtom(ISOHEVCConfigAtomPtr *outAtom); static MP4AtomPtr MP4BaseAtomClassPtr = 0; -static char* baseAtomGetName( MP4AtomPtr self ) -{ - return self->name; -} +static char *baseAtomGetName(MP4AtomPtr self) { return self->name; } -static void baseAtomDestroy( MP4AtomPtr self ) +static void baseAtomDestroy(MP4AtomPtr self) { - free( self ); - /* if ( MP4BaseAtomClassPtr != NULL ) { - free (MP4BaseAtomClassPtr); - MP4BaseAtomClassPtr = NULL; - } */ - /* There is no good time to free these static optimizations; the old code freed them and - didn't zero them out, which meant they kept getting used. If you zero them out, they get - remade, but there still exist pointers to the now-freed protos. See below for the same for - fullatom. */ + free(self); + /* if ( MP4BaseAtomClassPtr != NULL ) { + free (MP4BaseAtomClassPtr); + MP4BaseAtomClassPtr = NULL; + } */ + /* There is no good time to free these static optimizations; the old code freed them and + didn't zero them out, which meant they kept getting used. If you zero them out, they get + remade, but there still exist pointers to the now-freed protos. See below for the same for + fullatom. */ } -static MP4Err baseAtomCreateFromInputStream( MP4AtomPtr self, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err baseAtomCreateFromInputStream(MP4AtomPtr self, MP4AtomPtr proto, + MP4InputStreamPtr inputStream) { - inputStream = inputStream; - self->type = proto->type; - memcpy( self->uuid, proto->uuid, 16 ); - self->size = proto->size; - self->size64 = proto->size64; - self->bytesRead = proto->bytesRead; - self->streamOffset = proto->streamOffset; - return MP4NoErr; + inputStream = inputStream; + self->type = proto->type; + memcpy(self->uuid, proto->uuid, 16); + self->size = proto->size; + self->size64 = proto->size64; + self->bytesRead = proto->bytesRead; + self->streamOffset = proto->streamOffset; + return MP4NoErr; } -MP4Err MP4CreateBaseAtom( MP4AtomPtr self ) +MP4Err MP4CreateBaseAtom(MP4AtomPtr self) { - MP4Err err; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( MP4BaseAtomClassPtr == NULL ) - { - MP4BaseAtomClassPtr = (MP4AtomPtr) calloc( 1, sizeof(MP4Atom) ); - TESTMALLOC( MP4BaseAtomClassPtr ); - - MP4BaseAtomClassPtr->name = "base"; - MP4BaseAtomClassPtr->createFromInputStream = (cisfunc) baseAtomCreateFromInputStream; - MP4BaseAtomClassPtr->getName = baseAtomGetName; - MP4BaseAtomClassPtr->destroy = baseAtomDestroy; - MP4BaseAtomClassPtr->super = MP4BaseAtomClassPtr; - } - *self = *MP4BaseAtomClassPtr; + MP4Err err; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(MP4BaseAtomClassPtr == NULL) + { + MP4BaseAtomClassPtr = (MP4AtomPtr)calloc(1, sizeof(MP4Atom)); + TESTMALLOC(MP4BaseAtomClassPtr); + + MP4BaseAtomClassPtr->name = "base"; + MP4BaseAtomClassPtr->createFromInputStream = (cisfunc)baseAtomCreateFromInputStream; + MP4BaseAtomClassPtr->getName = baseAtomGetName; + MP4BaseAtomClassPtr->destroy = baseAtomDestroy; + MP4BaseAtomClassPtr->super = MP4BaseAtomClassPtr; + } + *self = *MP4BaseAtomClassPtr; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } static MP4FullAtomPtr MP4FullAtomClassPtr = 0; -static void fullAtomDestroy( MP4AtomPtr self ) +static void fullAtomDestroy(MP4AtomPtr self) { - baseAtomDestroy( self ); - /* if ( MP4FullAtomClassPtr != NULL) { - free (MP4FullAtomClassPtr); - MP4FullAtomClassPtr = NULL; - } */ - /* see above for discussion of these protos and when, if ever, they can be freed */ + baseAtomDestroy(self); + /* if ( MP4FullAtomClassPtr != NULL) { + free (MP4FullAtomClassPtr); + MP4FullAtomClassPtr = NULL; + } */ + /* see above for discussion of these protos and when, if ever, they can be freed */ } -static MP4Err fullAtomCreateFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err fullAtomCreateFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, + MP4InputStreamPtr inputStream) { - MP4FullAtomPtr self; - MP4Err err; - u32 val; - self = (MP4FullAtomPtr) s; - - err = baseAtomCreateFromInputStream( s, proto, inputStream ); if (err) goto bail; - err = inputStream->read32( inputStream, &val, NULL ); if (err) goto bail; - DEBUG_SPRINTF( "atom version = %d", (val >> 24) ); - DEBUG_SPRINTF( "atom flags = 0x%06x", (val & 0xFFFFFF) ); - self->bytesRead += 4; - self->version = val >> 24; - self->flags = val & 0xffffff; + MP4FullAtomPtr self; + MP4Err err; + u32 val; + self = (MP4FullAtomPtr)s; + + err = baseAtomCreateFromInputStream(s, proto, inputStream); + if(err) goto bail; + err = inputStream->read32(inputStream, &val, NULL); + if(err) goto bail; + DEBUG_SPRINTF("atom version = %d", (val >> 24)); + DEBUG_SPRINTF("atom flags = 0x%06x", (val & 0xFFFFFF)); + self->bytesRead += 4; + self->version = val >> 24; + self->flags = val & 0xffffff; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateFullAtom( MP4AtomPtr s ) +MP4Err MP4CreateFullAtom(MP4AtomPtr s) { - MP4FullAtomPtr self; - MP4Err err; - self = (MP4FullAtomPtr) s; - - err = MP4NoErr; - - if ( MP4FullAtomClassPtr == NULL ) - { - MP4FullAtomClassPtr = (MP4FullAtomPtr) calloc( 1, sizeof(MP4FullAtom) ); - TESTMALLOC( MP4FullAtomClassPtr ); - err = MP4CreateBaseAtom( (MP4AtomPtr) MP4FullAtomClassPtr ); if (err) goto bail; - MP4FullAtomClassPtr->createFromInputStream = (cisfunc) fullAtomCreateFromInputStream; - MP4FullAtomClassPtr->destroy = fullAtomDestroy; - MP4FullAtomClassPtr->super = (MP4AtomPtr) MP4FullAtomClassPtr; - MP4FullAtomClassPtr->name = "full"; - MP4FullAtomClassPtr->version = 0; - MP4FullAtomClassPtr->flags = 0; - } - *self = *MP4FullAtomClassPtr; + MP4FullAtomPtr self; + MP4Err err; + self = (MP4FullAtomPtr)s; + + err = MP4NoErr; + + if(MP4FullAtomClassPtr == NULL) + { + MP4FullAtomClassPtr = (MP4FullAtomPtr)calloc(1, sizeof(MP4FullAtom)); + TESTMALLOC(MP4FullAtomClassPtr); + err = MP4CreateBaseAtom((MP4AtomPtr)MP4FullAtomClassPtr); + if(err) goto bail; + MP4FullAtomClassPtr->createFromInputStream = (cisfunc)fullAtomCreateFromInputStream; + MP4FullAtomClassPtr->destroy = fullAtomDestroy; + MP4FullAtomClassPtr->super = (MP4AtomPtr)MP4FullAtomClassPtr; + MP4FullAtomClassPtr->name = "full"; + MP4FullAtomClassPtr->version = 0; + MP4FullAtomClassPtr->flags = 0; + } + *self = *MP4FullAtomClassPtr; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateAtom( u32 atomType, MP4AtomPtr *outAtom ) +MP4Err MP4CreateAtom(u32 atomType, MP4AtomPtr *outAtom) { - MP4Err err; - MP4AtomPtr newAtom; - - err = MP4NoErr; - - switch ( atomType ) - { - case MP4HintTrackReferenceAtomType: - case MP4StreamDependenceAtomType: - case MP4ODTrackReferenceAtomType: - case MP4SyncTrackReferenceAtomType: - err = MP4CreateTrackReferenceTypeAtom( atomType, (MP4TrackReferenceTypeAtomPtr*) &newAtom ); - break; - - case MP4FreeSpaceAtomType: - case MP4SkipAtomType: - err = MP4CreateFreeSpaceAtom( (MP4FreeSpaceAtomPtr*) &newAtom ); - break; - - case MP4MediaDataAtomType: - err = MP4CreateMediaDataAtom( (MP4MediaDataAtomPtr*) &newAtom ); - break; - - case MP4MovieAtomType: - err = MP4CreateMovieAtom( (MP4MovieAtomPtr*) &newAtom ); - break; - - case MP4MovieHeaderAtomType: - err = MP4CreateMovieHeaderAtom( (MP4MovieHeaderAtomPtr*) &newAtom ); - break; - - case MP4MediaHeaderAtomType: - err = MP4CreateMediaHeaderAtom( (MP4MediaHeaderAtomPtr*) &newAtom ); - break; - - case MP4VideoMediaHeaderAtomType: - err = MP4CreateVideoMediaHeaderAtom( (MP4VideoMediaHeaderAtomPtr*) &newAtom ); - break; - - case MP4SoundMediaHeaderAtomType: - err = MP4CreateSoundMediaHeaderAtom( (MP4SoundMediaHeaderAtomPtr*) &newAtom ); - break; - - case MP4MPEGMediaHeaderAtomType: - err = MP4CreateMPEGMediaHeaderAtom( (MP4MPEGMediaHeaderAtomPtr*) &newAtom ); - break; - - case MP4ObjectDescriptorMediaHeaderAtomType: - err = MP4CreateObjectDescriptorMediaHeaderAtom( (MP4ObjectDescriptorMediaHeaderAtomPtr*) &newAtom ); - break; - - case MP4ClockReferenceMediaHeaderAtomType: - err = MP4CreateClockReferenceMediaHeaderAtom( (MP4ClockReferenceMediaHeaderAtomPtr*) &newAtom ); - break; - - case MP4SceneDescriptionMediaHeaderAtomType: - err = MP4CreateSceneDescriptionMediaHeaderAtom( (MP4SceneDescriptionMediaHeaderAtomPtr*) &newAtom ); - break; - - case MP4HintMediaHeaderAtomType: - err = MP4CreateHintMediaHeaderAtom( (MP4HintMediaHeaderAtomPtr*) &newAtom ); - break; - - case MP4SampleTableAtomType: - err = MP4CreateSampleTableAtom( (MP4SampleTableAtomPtr*) &newAtom ); - break; - - case MP4DataInformationAtomType: - err = MP4CreateDataInformationAtom( (MP4DataInformationAtomPtr*) &newAtom ); - break; - - case MP4_FOUR_CHAR_CODE( 'a', 'l', 'i', 's' ): - case MP4DataEntryURLAtomType: - err = MP4CreateDataEntryURLAtom( (MP4DataEntryURLAtomPtr*) &newAtom ); - break; - - case MP4CopyrightAtomType: - err = MP4CreateCopyrightAtom( (MP4CopyrightAtomPtr*) &newAtom ); - break; - - case MP4DataEntryURNAtomType: - err = MP4CreateDataEntryURNAtom( (MP4DataEntryURNAtomPtr*) &newAtom ); - break; - - case MP4HandlerAtomType: - err = MP4CreateHandlerAtom( (MP4HandlerAtomPtr*) &newAtom ); - break; - - case MP4ObjectDescriptorAtomType: - err = MP4CreateObjectDescriptorAtom( (MP4ObjectDescriptorAtomPtr*) &newAtom ); - break; - - case MP4TrackAtomType: - err = MP4CreateTrackAtom( (MP4TrackAtomPtr*) &newAtom ); - break; - - case MP4MPEGSampleEntryAtomType: - err = MP4CreateMPEGSampleEntryAtom( (MP4MPEGSampleEntryAtomPtr*) &newAtom ); - break; - - case MP4VisualSampleEntryAtomType: - case ISOAVCSampleEntryAtomType: - case MP4H263SampleEntryAtomType: - err = MP4CreateVisualSampleEntryAtom( (MP4VisualSampleEntryAtomPtr*) &newAtom ); - break; - - case MP4AudioSampleEntryAtomType: - case MP4AMRSampleEntryAtomType: - case MP4AWBSampleEntryAtomType: - case MP4AMRWPSampleEntryAtomType: - err = MP4CreateAudioSampleEntryAtom( (MP4AudioSampleEntryAtomPtr*) &newAtom ); - break; - - case MP4ChannelLayoutAtomType: - err = MP4CreateChannelLayoutAtom( (MP4ChannelLayoutAtomPtr*) &newAtom ); - break; - - case MP4PCMConfigAtomType: - err = MP4CreatePCMConfigAtom( (MP4PCMConfigAtomPtr*) &newAtom ); - break; - - case MP4DownMixInstructionsAtomType: - err = MP4CreateDownMixInstructionsAtom( (MP4DownMixInstructionsAtomPtr*) &newAtom ); - break; - - case MP4TrackLoudnessInfoAtomType: - case MP4AlbumLoudnessInfoAtomType: - err = MP4CreateLoudnessBaseAtom( (MP4LoudnessBaseAtomPtr*) &newAtom, atomType ); - break; - - case MP4LoudnessAtomType: - err = MP4CreateLoudnessAtom( (MP4LoudnessAtomPtr*) &newAtom ); - break; - - case MP4EncVisualSampleEntryAtomType: - err = MP4CreateEncVisualSampleEntryAtom( (MP4EncVisualSampleEntryAtomPtr*) &newAtom ); - break; - - case MP4EncAudioSampleEntryAtomType: - err = MP4CreateEncAudioSampleEntryAtom( (MP4EncAudioSampleEntryAtomPtr*) &newAtom ); - break; - - case MP4RestrictedVideoSampleEntryAtomType: - err = MP4CreateRestrictedVideoSampleEntryAtom( (MP4RestrictedVideoSampleEntryAtomPtr*) &newAtom ); - break; - - case MP4XMLMetaSampleEntryAtomType: - err = MP4CreateXMLMetaSampleEntryAtom( (MP4XMLMetaSampleEntryAtomPtr*) &newAtom ); - break; - - case MP4TextMetaSampleEntryAtomType: - err = MP4CreateTextMetaSampleEntryAtom( (MP4TextMetaSampleEntryAtomPtr*) &newAtom ); - break; - - case MP4GenericSampleEntryAtomType: - err = MP4CreateGenericSampleEntryAtom( (MP4GenericSampleEntryAtomPtr*) &newAtom ); - break; - - case MP4EditAtomType: - err = MP4CreateEditAtom( (MP4EditAtomPtr*) &newAtom ); - break; - - case MP4UserDataAtomType: - err = MP4CreateUserDataAtom( (MP4UserDataAtomPtr*) &newAtom ); - break; - - case MP4DataReferenceAtomType: - err = MP4CreateDataReferenceAtom( (MP4DataReferenceAtomPtr*) &newAtom ); - break; - - case MP4SampleDescriptionAtomType: - err = MP4CreateSampleDescriptionAtom( (MP4SampleDescriptionAtomPtr*) &newAtom ); - break; - - case MP4TimeToSampleAtomType: - err = MP4CreateTimeToSampleAtom( (MP4TimeToSampleAtomPtr*) &newAtom ); - break; - - case MP4CompositionOffsetAtomType: - err = MP4CreateCompositionOffsetAtom( (MP4CompositionOffsetAtomPtr*) &newAtom ); - break; - - case MP4CompositionToDecodeAtomType: - err = MP4CreateCompositionToDecodeAtom( (MP4CompositionToDecodeAtomPtr*) &newAtom ); - break; - - case MP4SampleAuxiliaryInformationSizesAtomType: - err = MP4CreateSampleAuxiliaryInformationSizesAtom( (MP4SampleAuxiliaryInformationSizesAtomPtr*) &newAtom ); - break; - - case MP4SampleAuxiliaryInformationOffsetsAtomType: - err = MP4CreateSampleAuxiliaryInformationOffsetsAtom( (MP4SampleAuxiliaryInformationOffsetsAtomPtr*) &newAtom ); - break; - - case MP4ShadowSyncAtomType: - err = MP4CreateShadowSyncAtom( (MP4ShadowSyncAtomPtr*) &newAtom ); - break; - - case MP4EditListAtomType: - err = MP4CreateEditListAtom( (MP4EditListAtomPtr*) &newAtom ); - break; - - case MP4SampleToChunkAtomType: - err = MP4CreateSampleToChunkAtom( (MP4SampleToChunkAtomPtr*) &newAtom ); - break; - - case MP4SampleSizeAtomType: - case MP4CompactSampleSizeAtomType: - err = MP4CreateSampleSizeAtom( (MP4SampleSizeAtomPtr*) &newAtom ); - break; - - case MP4ChunkLargeOffsetAtomType: - case MP4ChunkOffsetAtomType: - err = MP4CreateChunkOffsetAtom( (MP4ChunkOffsetAtomPtr*) &newAtom ); - break; - - case MP4SyncSampleAtomType: - err = MP4CreateSyncSampleAtom( (MP4SyncSampleAtomPtr*) &newAtom ); - break; - - case MP4DegradationPriorityAtomType: - err = MP4CreateDegradationPriorityAtom( (MP4DegradationPriorityAtomPtr*) &newAtom ); - break; - - case MP4SampleDependencyAtomType: - err = MP4CreateSampleDependencyAtom( (MP4SampleDependencyAtomPtr*) &newAtom ); - break; - -/* case MP4ChunkLargeOffsetAtomType: - err = MP4CreateChunkLargeOffsetAtom( (MP4ChunkLargeOffsetAtomPtr*) &newAtom ); - break; -*/ - case MP4ESDAtomType: - err = MP4CreateESDAtom( (MP4ESDAtomPtr*) &newAtom ); - break; - - case ISOVCConfigAtomType: - err = MP4CreateVCConfigAtom( (ISOVCConfigAtomPtr*) &newAtom ); - break; - - case MP4MediaInformationAtomType: - err = MP4CreateMediaInformationAtom( (MP4MediaInformationAtomPtr*) &newAtom ); - break; - - case MP4TrackHeaderAtomType: - err = MP4CreateTrackHeaderAtom( (MP4TrackHeaderAtomPtr*) &newAtom ); - break; - - case MP4TrackReferenceAtomType: - err = MP4CreateTrackReferenceAtom( (MP4TrackReferenceAtomPtr*) &newAtom ); - break; - - case MP4MediaAtomType: - err = MP4CreateMediaAtom( (MP4MediaAtomPtr*) &newAtom ); - break; - - case MP4ExtendedLanguageTagAtomType: - err = MP4CreateExtendedLanguageTagAtom( (MP4ExtendedLanguageTagAtomPtr*) &newAtom ); - break; - - case MP4PaddingBitsAtomType: - err = MP4CreatePaddingBitsAtom( (MP4PaddingBitsAtomPtr*) &newAtom ); - break; - - /* JPEG-2000 atom ("box") types */ - case MJ2JPEG2000SignatureAtomType: - err = MJ2CreateSignatureAtom( (MJ2JPEG2000SignatureAtomPtr*) &newAtom ); - break; - - case ISOFileTypeAtomType: - err = MJ2CreateFileTypeAtom( (ISOFileTypeAtomPtr*) &newAtom ); - break; - - case MJ2ImageHeaderAtomType: - err = MJ2CreateImageHeaderAtom( (MJ2ImageHeaderAtomPtr*) &newAtom ); - break; - - case MJ2BitsPerComponentAtomType: - err = MJ2CreateBitsPerComponentAtom( (MJ2BitsPerComponentAtomPtr*) &newAtom ); - break; - - case MJ2ColorSpecificationAtomType: - err = MJ2CreateColorSpecificationAtom( (MJ2ColorSpecificationAtomPtr*) &newAtom ); - break; - - case MJ2JP2HeaderAtomType: - err = MJ2CreateHeaderAtom( (MJ2HeaderAtomPtr*) &newAtom ); - break; - - /* Movie Fragment stuff */ - case MP4MovieExtendsAtomType: - err = MP4CreateMovieExtendsAtom( (MP4MovieExtendsAtomPtr*) &newAtom ); - break; - - case MP4TrackExtensionPropertiesAtomType: - err = MP4CreateTrackExtensionPropertiesAtom( (MP4TrackExtensionPropertiesAtomPtr*) &newAtom ); - break; - - case MP4TrackExtendsAtomType: - err = MP4CreateTrackExtendsAtom( (MP4TrackExtendsAtomPtr*) &newAtom ); - break; - - case MP4MovieFragmentAtomType: - err = MP4CreateMovieFragmentAtom( (MP4MovieFragmentAtomPtr*) &newAtom ); - break; - - case MP4MovieFragmentHeaderAtomType: - err = MP4CreateMovieFragmentHeaderAtom( (MP4MovieFragmentHeaderAtomPtr*) &newAtom ); - break; - - case MP4TrackFragmentAtomType: - err = MP4CreateTrackFragmentAtom( (MP4TrackFragmentAtomPtr*) &newAtom ); - break; - - case MP4TrackFragmentHeaderAtomType: - err = MP4CreateTrackFragmentHeaderAtom( (MP4TrackFragmentHeaderAtomPtr*) &newAtom ); - break; - - case MP4TrackFragmentDecodeTimeAtomType: - err = MP4CreateTrackFragmentDecodeTimeAtom( (MP4TrackFragmentDecodeTimeAtomPtr*) &newAtom ); - break; - - case MP4TrackRunAtomType: - err = MP4CreateTrackRunAtom( (MP4TrackRunAtomPtr*) &newAtom ); - break; - - case MP4SchemeTypeAtomType: - err = MP4CreateSchemeTypeAtom( (MP4SchemeTypeAtomPtr *) &newAtom ); - break; - - case MP4OriginalFormatAtomType: - err = MP4CreateOriginalFormatAtom((MP4OriginalFormatAtomPtr *)&newAtom); - break; - - case MP4SchemeInfoAtomType: - err = MP4CreateSchemeInfoAtom((MP4SchemeInfoAtomPtr *)&newAtom); - break; - - case MP4CompatibleSchemeTypeAtomType: - err = MP4CreateCompatibleSchemeTypeAtom((MP4CompatibleSchemeTypeAtomPtr *)&newAtom); - break; - - case MP4RestrictedSchemeInfoAtomType: - err = MP4CreateRestrictedSchemeInfoAtom((MP4RestrictedSchemeInfoAtomPtr *)&newAtom); - break; - - case MP4TrackTypeAtomType: - err = MP4CreateTrackTypeAtom((MP4TrackTypeAtomPtr *) &newAtom); - break; - - case MP4StereoVideoAtomType: - err = MP4CreateStereoVideoAtom((MP4StereoVideoAtomPtr *)&newAtom); - break; - - case MP4StereoVideoGroupAtomType: - err = MP4CreateStereoVideoGroupAtom((MP4StereoVideoGroupAtomPtr *)&newAtom); - break; - - case MP4SegmentTypeAtomType: - err = MP4CreateSegmentTypeAtom((MP4SegmentTypeAtomPtr *)&newAtom); - break; - case MP4SegmentIndexAtomType: - err = MP4CreateSegmentIndexAtom((MP4SegmentIndexAtomPtr *)&newAtom); - break; - case MP4SubsegmentIndexAtomType: - err = MP4CreateSubsegmentIndexAtom((MP4SubsegmentIndexAtomPtr *)&newAtom); - break; - case MP4ProducerReferenceTimeAtomType: - err = MP4CreateProducerReferenceTimeAtom((MP4ProducerReferenceTimeAtomPtr *)&newAtom); - break; + MP4Err err; + MP4AtomPtr newAtom; + + err = MP4NoErr; + + switch(atomType) + { + case MP4HintTrackReferenceAtomType: + case MP4StreamDependenceAtomType: + case MP4ODTrackReferenceAtomType: + case MP4SyncTrackReferenceAtomType: + err = MP4CreateTrackReferenceTypeAtom(atomType, (MP4TrackReferenceTypeAtomPtr *)&newAtom); + break; + + case MP4FreeSpaceAtomType: + case MP4SkipAtomType: + err = MP4CreateFreeSpaceAtom((MP4FreeSpaceAtomPtr *)&newAtom); + break; + + case MP4MediaDataAtomType: + err = MP4CreateMediaDataAtom((MP4MediaDataAtomPtr *)&newAtom); + break; + + case MP4MovieAtomType: + err = MP4CreateMovieAtom((MP4MovieAtomPtr *)&newAtom); + break; + + case MP4MovieHeaderAtomType: + err = MP4CreateMovieHeaderAtom((MP4MovieHeaderAtomPtr *)&newAtom); + break; + + case MP4MediaHeaderAtomType: + err = MP4CreateMediaHeaderAtom((MP4MediaHeaderAtomPtr *)&newAtom); + break; + + case MP4VideoMediaHeaderAtomType: + err = MP4CreateVideoMediaHeaderAtom((MP4VideoMediaHeaderAtomPtr *)&newAtom); + break; + + case MP4SoundMediaHeaderAtomType: + err = MP4CreateSoundMediaHeaderAtom((MP4SoundMediaHeaderAtomPtr *)&newAtom); + break; + + case MP4MPEGMediaHeaderAtomType: + err = MP4CreateMPEGMediaHeaderAtom((MP4MPEGMediaHeaderAtomPtr *)&newAtom); + break; + + case MP4ObjectDescriptorMediaHeaderAtomType: + err = + MP4CreateObjectDescriptorMediaHeaderAtom((MP4ObjectDescriptorMediaHeaderAtomPtr *)&newAtom); + break; + + case MP4ClockReferenceMediaHeaderAtomType: + err = MP4CreateClockReferenceMediaHeaderAtom((MP4ClockReferenceMediaHeaderAtomPtr *)&newAtom); + break; + + case MP4SceneDescriptionMediaHeaderAtomType: + err = + MP4CreateSceneDescriptionMediaHeaderAtom((MP4SceneDescriptionMediaHeaderAtomPtr *)&newAtom); + break; + + case MP4HintMediaHeaderAtomType: + err = MP4CreateHintMediaHeaderAtom((MP4HintMediaHeaderAtomPtr *)&newAtom); + break; + + case MP4SampleTableAtomType: + err = MP4CreateSampleTableAtom((MP4SampleTableAtomPtr *)&newAtom); + break; + + case MP4DataInformationAtomType: + err = MP4CreateDataInformationAtom((MP4DataInformationAtomPtr *)&newAtom); + break; + + case MP4_FOUR_CHAR_CODE('a', 'l', 'i', 's'): + case MP4DataEntryURLAtomType: + err = MP4CreateDataEntryURLAtom((MP4DataEntryURLAtomPtr *)&newAtom); + break; + + case MP4CopyrightAtomType: + err = MP4CreateCopyrightAtom((MP4CopyrightAtomPtr *)&newAtom); + break; + + case MP4DataEntryURNAtomType: + err = MP4CreateDataEntryURNAtom((MP4DataEntryURNAtomPtr *)&newAtom); + break; + + case MP4HandlerAtomType: + err = MP4CreateHandlerAtom((MP4HandlerAtomPtr *)&newAtom); + break; + + case MP4ObjectDescriptorAtomType: + err = MP4CreateObjectDescriptorAtom((MP4ObjectDescriptorAtomPtr *)&newAtom); + break; + + case MP4TrackAtomType: + err = MP4CreateTrackAtom((MP4TrackAtomPtr *)&newAtom); + break; + + case MP4MPEGSampleEntryAtomType: + err = MP4CreateMPEGSampleEntryAtom((MP4MPEGSampleEntryAtomPtr *)&newAtom); + break; + + case MP4VisualSampleEntryAtomType: + case ISOAVCSampleEntryAtomType: + case MP4H263SampleEntryAtomType: + err = MP4CreateVisualSampleEntryAtom((MP4VisualSampleEntryAtomPtr *)&newAtom); + break; + + case MP4AudioSampleEntryAtomType: + case MP4AMRSampleEntryAtomType: + case MP4AWBSampleEntryAtomType: + case MP4AMRWPSampleEntryAtomType: + err = MP4CreateAudioSampleEntryAtom((MP4AudioSampleEntryAtomPtr *)&newAtom); + break; + + case MP4ChannelLayoutAtomType: + err = MP4CreateChannelLayoutAtom((MP4ChannelLayoutAtomPtr *)&newAtom); + break; + + case MP4PCMConfigAtomType: + err = MP4CreatePCMConfigAtom((MP4PCMConfigAtomPtr *)&newAtom); + break; + + case MP4DownMixInstructionsAtomType: + err = MP4CreateDownMixInstructionsAtom((MP4DownMixInstructionsAtomPtr *)&newAtom); + break; + + case MP4TrackLoudnessInfoAtomType: + case MP4AlbumLoudnessInfoAtomType: + err = MP4CreateLoudnessBaseAtom((MP4LoudnessBaseAtomPtr *)&newAtom, atomType); + break; + + case MP4LoudnessAtomType: + err = MP4CreateLoudnessAtom((MP4LoudnessAtomPtr *)&newAtom); + break; + + case MP4EncVisualSampleEntryAtomType: + err = MP4CreateEncVisualSampleEntryAtom((MP4EncVisualSampleEntryAtomPtr *)&newAtom); + break; + + case MP4EncAudioSampleEntryAtomType: + err = MP4CreateEncAudioSampleEntryAtom((MP4EncAudioSampleEntryAtomPtr *)&newAtom); + break; + + case MP4RestrictedVideoSampleEntryAtomType: + err = MP4CreateRestrictedVideoSampleEntryAtom((MP4RestrictedVideoSampleEntryAtomPtr *)&newAtom); + break; + + case MP4XMLMetaSampleEntryAtomType: + err = MP4CreateXMLMetaSampleEntryAtom((MP4XMLMetaSampleEntryAtomPtr *)&newAtom); + break; + + case MP4TextMetaSampleEntryAtomType: + err = MP4CreateTextMetaSampleEntryAtom((MP4TextMetaSampleEntryAtomPtr *)&newAtom); + break; + + case MP4GenericSampleEntryAtomType: + err = MP4CreateGenericSampleEntryAtom((MP4GenericSampleEntryAtomPtr *)&newAtom); + break; + + case MP4EditAtomType: + err = MP4CreateEditAtom((MP4EditAtomPtr *)&newAtom); + break; + + case MP4UserDataAtomType: + err = MP4CreateUserDataAtom((MP4UserDataAtomPtr *)&newAtom); + break; + + case MP4DataReferenceAtomType: + err = MP4CreateDataReferenceAtom((MP4DataReferenceAtomPtr *)&newAtom); + break; + + case MP4SampleDescriptionAtomType: + err = MP4CreateSampleDescriptionAtom((MP4SampleDescriptionAtomPtr *)&newAtom); + break; + + case MP4TimeToSampleAtomType: + err = MP4CreateTimeToSampleAtom((MP4TimeToSampleAtomPtr *)&newAtom); + break; + + case MP4CompositionOffsetAtomType: + err = MP4CreateCompositionOffsetAtom((MP4CompositionOffsetAtomPtr *)&newAtom); + break; + + case MP4CompositionToDecodeAtomType: + err = MP4CreateCompositionToDecodeAtom((MP4CompositionToDecodeAtomPtr *)&newAtom); + break; + + case MP4SampleAuxiliaryInformationSizesAtomType: + err = MP4CreateSampleAuxiliaryInformationSizesAtom( + (MP4SampleAuxiliaryInformationSizesAtomPtr *)&newAtom); + break; + + case MP4SampleAuxiliaryInformationOffsetsAtomType: + err = MP4CreateSampleAuxiliaryInformationOffsetsAtom( + (MP4SampleAuxiliaryInformationOffsetsAtomPtr *)&newAtom); + break; + + case MP4ShadowSyncAtomType: + err = MP4CreateShadowSyncAtom((MP4ShadowSyncAtomPtr *)&newAtom); + break; + + case MP4EditListAtomType: + err = MP4CreateEditListAtom((MP4EditListAtomPtr *)&newAtom); + break; + + case MP4SampleToChunkAtomType: + err = MP4CreateSampleToChunkAtom((MP4SampleToChunkAtomPtr *)&newAtom); + break; + + case MP4SampleSizeAtomType: + case MP4CompactSampleSizeAtomType: + err = MP4CreateSampleSizeAtom((MP4SampleSizeAtomPtr *)&newAtom); + break; + + case MP4ChunkLargeOffsetAtomType: + case MP4ChunkOffsetAtomType: + err = MP4CreateChunkOffsetAtom((MP4ChunkOffsetAtomPtr *)&newAtom); + break; + + case MP4SyncSampleAtomType: + err = MP4CreateSyncSampleAtom((MP4SyncSampleAtomPtr *)&newAtom); + break; + + case MP4DegradationPriorityAtomType: + err = MP4CreateDegradationPriorityAtom((MP4DegradationPriorityAtomPtr *)&newAtom); + break; + + case MP4SampleDependencyAtomType: + err = MP4CreateSampleDependencyAtom((MP4SampleDependencyAtomPtr *)&newAtom); + break; + + /* case MP4ChunkLargeOffsetAtomType: + err = MP4CreateChunkLargeOffsetAtom( (MP4ChunkLargeOffsetAtomPtr*) + &newAtom ); break; + */ + case MP4ESDAtomType: + err = MP4CreateESDAtom((MP4ESDAtomPtr *)&newAtom); + break; + + case ISOVCConfigAtomType: + err = MP4CreateVCConfigAtom((ISOVCConfigAtomPtr *)&newAtom); + break; + + case MP4MediaInformationAtomType: + err = MP4CreateMediaInformationAtom((MP4MediaInformationAtomPtr *)&newAtom); + break; + + case MP4TrackHeaderAtomType: + err = MP4CreateTrackHeaderAtom((MP4TrackHeaderAtomPtr *)&newAtom); + break; + + case MP4TrackReferenceAtomType: + err = MP4CreateTrackReferenceAtom((MP4TrackReferenceAtomPtr *)&newAtom); + break; + + case MP4MediaAtomType: + err = MP4CreateMediaAtom((MP4MediaAtomPtr *)&newAtom); + break; + + case MP4ExtendedLanguageTagAtomType: + err = MP4CreateExtendedLanguageTagAtom((MP4ExtendedLanguageTagAtomPtr *)&newAtom); + break; + + case MP4PaddingBitsAtomType: + err = MP4CreatePaddingBitsAtom((MP4PaddingBitsAtomPtr *)&newAtom); + break; + + /* JPEG-2000 atom ("box") types */ + case MJ2JPEG2000SignatureAtomType: + err = MJ2CreateSignatureAtom((MJ2JPEG2000SignatureAtomPtr *)&newAtom); + break; + + case ISOFileTypeAtomType: + err = MJ2CreateFileTypeAtom((ISOFileTypeAtomPtr *)&newAtom); + break; + + case MJ2ImageHeaderAtomType: + err = MJ2CreateImageHeaderAtom((MJ2ImageHeaderAtomPtr *)&newAtom); + break; + + case MJ2BitsPerComponentAtomType: + err = MJ2CreateBitsPerComponentAtom((MJ2BitsPerComponentAtomPtr *)&newAtom); + break; + + case MJ2ColorSpecificationAtomType: + err = MJ2CreateColorSpecificationAtom((MJ2ColorSpecificationAtomPtr *)&newAtom); + break; + + case MJ2JP2HeaderAtomType: + err = MJ2CreateHeaderAtom((MJ2HeaderAtomPtr *)&newAtom); + break; + + /* Movie Fragment stuff */ + case MP4MovieExtendsAtomType: + err = MP4CreateMovieExtendsAtom((MP4MovieExtendsAtomPtr *)&newAtom); + break; + + case MP4TrackExtensionPropertiesAtomType: + err = MP4CreateTrackExtensionPropertiesAtom((MP4TrackExtensionPropertiesAtomPtr *)&newAtom); + break; + + case MP4TrackExtendsAtomType: + err = MP4CreateTrackExtendsAtom((MP4TrackExtendsAtomPtr *)&newAtom); + break; + + case MP4MovieFragmentAtomType: + err = MP4CreateMovieFragmentAtom((MP4MovieFragmentAtomPtr *)&newAtom); + break; + + case MP4MovieFragmentHeaderAtomType: + err = MP4CreateMovieFragmentHeaderAtom((MP4MovieFragmentHeaderAtomPtr *)&newAtom); + break; + + case MP4TrackFragmentAtomType: + err = MP4CreateTrackFragmentAtom((MP4TrackFragmentAtomPtr *)&newAtom); + break; + + case MP4TrackFragmentHeaderAtomType: + err = MP4CreateTrackFragmentHeaderAtom((MP4TrackFragmentHeaderAtomPtr *)&newAtom); + break; + + case MP4TrackFragmentDecodeTimeAtomType: + err = MP4CreateTrackFragmentDecodeTimeAtom((MP4TrackFragmentDecodeTimeAtomPtr *)&newAtom); + break; + + case MP4TrackRunAtomType: + err = MP4CreateTrackRunAtom((MP4TrackRunAtomPtr *)&newAtom); + break; + + case MP4SchemeTypeAtomType: + err = MP4CreateSchemeTypeAtom((MP4SchemeTypeAtomPtr *)&newAtom); + break; + + case MP4OriginalFormatAtomType: + err = MP4CreateOriginalFormatAtom((MP4OriginalFormatAtomPtr *)&newAtom); + break; + + case MP4SchemeInfoAtomType: + err = MP4CreateSchemeInfoAtom((MP4SchemeInfoAtomPtr *)&newAtom); + break; + + case MP4CompatibleSchemeTypeAtomType: + err = MP4CreateCompatibleSchemeTypeAtom((MP4CompatibleSchemeTypeAtomPtr *)&newAtom); + break; + + case MP4RestrictedSchemeInfoAtomType: + err = MP4CreateRestrictedSchemeInfoAtom((MP4RestrictedSchemeInfoAtomPtr *)&newAtom); + break; + + case MP4TrackTypeAtomType: + err = MP4CreateTrackTypeAtom((MP4TrackTypeAtomPtr *)&newAtom); + break; + + case MP4StereoVideoAtomType: + err = MP4CreateStereoVideoAtom((MP4StereoVideoAtomPtr *)&newAtom); + break; + + case MP4StereoVideoGroupAtomType: + err = MP4CreateStereoVideoGroupAtom((MP4StereoVideoGroupAtomPtr *)&newAtom); + break; + + case MP4SegmentTypeAtomType: + err = MP4CreateSegmentTypeAtom((MP4SegmentTypeAtomPtr *)&newAtom); + break; + case MP4SegmentIndexAtomType: + err = MP4CreateSegmentIndexAtom((MP4SegmentIndexAtomPtr *)&newAtom); + break; + case MP4SubsegmentIndexAtomType: + err = MP4CreateSubsegmentIndexAtom((MP4SubsegmentIndexAtomPtr *)&newAtom); + break; + case MP4ProducerReferenceTimeAtomType: + err = MP4CreateProducerReferenceTimeAtom((MP4ProducerReferenceTimeAtomPtr *)&newAtom); + break; #ifdef ISMACrypt - case MP4SecurityInfoAtomType: - err = MP4CreateSecurityInfoAtom( (MP4SecurityInfoAtomPtr *) &newAtom ); - break; - - case ISMAKMSAtomType: - err = CreateISMAKMSAtom( (ISMAKMSAtomPtr *) &newAtom ); - break; - - case ISMASampleFormatAtomType: - err = CreateISMASampleFormatAtom( (ISMASampleFormatAtomPtr *) &newAtom ); - break; - - case ISMASaltAtomType: - err = CreateISMASaltAtom( (ISMASaltAtomPtr *) &newAtom ); - break; -#endif - case MP4SampleGroupDescriptionAtomType: - err = MP4CreateSampleGroupDescriptionAtom( (MP4SampleGroupDescriptionAtomPtr*) &newAtom ); - break; - - case MP4SampletoGroupAtomType: - err = MP4CreateSampletoGroupAtom( (MP4SampletoGroupAtomPtr*) &newAtom ); - break; - - case MP4CompactSampletoGroupAtomType: - err = MP4CreateCompactSampletoGroupAtom( (MP4CompactSampletoGroupAtomPtr*) &newAtom ); - break; - - case ISOMetaAtomType: - err = ISOCreateMetaAtom( (ISOMetaAtomPtr *) &newAtom ); - break; - - case ISOPrimaryItemAtomType: - err = ISOCreatePrimaryItemAtom( (ISOPrimaryItemAtomPtr *) &newAtom ); - break; - - case ISOItemLocationAtomType: - err = ISOCreateItemLocationAtom( (ISOItemLocationAtomPtr *) &newAtom ); - break; - - case ISOItemProtectionAtomType: - err = ISOCreateItemProtectionAtom( (ISOItemProtectionAtomPtr *) &newAtom ); - break; - - case ISOItemInfoAtomType: - err = ISOCreateItemInfoAtom( (ISOItemInfoAtomPtr *) &newAtom ); - break; - - case ISOItemInfoEntryAtomType: - err = ISOCreateItemInfoEntryAtom( (ISOItemInfoEntryAtomPtr *) &newAtom ); - break; - - case ISOAdditionalMetaDataContainerAtomType: - err = ISOCreateAdditionalMetaDataContainerAtom( (ISOAdditionalMetaDataContainerAtomPtr *) &newAtom ); - break; - - case ISOMetaboxRelationAtomType: - err = ISOCreateMetaboxRelationAtom( (ISOMetaboxRelationAtomPtr *) &newAtom ); - break; - - case ISOItemDataAtomType: - err = ISOCreateItemDataAtom( (ISOItemDataAtomPtr *) &newAtom ); - break; - - case ISOItemReferenceAtomType: - err = ISOCreateItemReferenceAtom( (ISOItemReferenceAtomPtr *) &newAtom ); - break; - - case MP4AMRSpecificInfoAtomType: - err = MP4CreateAMRSpecificInfoAtom( (MP4AMRSpecificInfoAtomPtr *) &newAtom ); - break; - - case MP4AMRWPSpecificInfoAtomType: - err = MP4CreateAMRWPSpecificInfoAtom( (MP4AMRWPSpecificInfoAtomPtr *) &newAtom ); - break; - - case MP4H263SpecificInfoAtomType: - err = MP4CreateH263SpecificInfoAtom( (MP4H263SpecificInfoAtomPtr *) &newAtom ); - break; - - case MP4BitRateAtomType: - case TGPPBitRateAtomType: - err = MP4CreateBitRateAtom( (MP4BitRateAtomPtr *) &newAtom ); - break; - - case MP4ItemPropertiesAtomType: - err = MP4CreateItemPropertiesAtom((MP4ItemPropertiesAtomPtr *)&newAtom); - break; - - case MP4ItemPropertyContainerAtomType: - err = MP4CreateItemPropertyContainerAtom((MP4ItemPropertyContainerAtomPtr *)&newAtom); - break; - - case MP4ItemPropertyAssociationAtomType: - err = MP4CreateItemPropertyAssociationAtom((MP4ItemPropertyAssociationAtomPtr *)&newAtom); - break; - - case ISOHEVCConfigAtomType: - err = MP4CreateHEVCConfigAtom((ISOHEVCConfigAtomPtr *)&newAtom); - break; - - default: - err = MP4CreateUnknownAtom( (MP4UnknownAtomPtr*) &newAtom ); - newAtom->type = atomType; - break; - } - if ( err == MP4NoErr ) - *outAtom = newAtom; - return err; + case MP4SecurityInfoAtomType: + err = MP4CreateSecurityInfoAtom((MP4SecurityInfoAtomPtr *)&newAtom); + break; + + case ISMAKMSAtomType: + err = CreateISMAKMSAtom((ISMAKMSAtomPtr *)&newAtom); + break; + + case ISMASampleFormatAtomType: + err = CreateISMASampleFormatAtom((ISMASampleFormatAtomPtr *)&newAtom); + break; + + case ISMASaltAtomType: + err = CreateISMASaltAtom((ISMASaltAtomPtr *)&newAtom); + break; +#endif + case MP4SampleGroupDescriptionAtomType: + err = MP4CreateSampleGroupDescriptionAtom((MP4SampleGroupDescriptionAtomPtr *)&newAtom); + break; + + case MP4SampletoGroupAtomType: + err = MP4CreateSampletoGroupAtom((MP4SampletoGroupAtomPtr *)&newAtom); + break; + + case MP4CompactSampletoGroupAtomType: + err = MP4CreateCompactSampletoGroupAtom((MP4CompactSampletoGroupAtomPtr *)&newAtom); + break; + + case ISOMetaAtomType: + err = ISOCreateMetaAtom((ISOMetaAtomPtr *)&newAtom); + break; + + case ISOPrimaryItemAtomType: + err = ISOCreatePrimaryItemAtom((ISOPrimaryItemAtomPtr *)&newAtom); + break; + + case ISOItemLocationAtomType: + err = ISOCreateItemLocationAtom((ISOItemLocationAtomPtr *)&newAtom); + break; + + case ISOItemProtectionAtomType: + err = ISOCreateItemProtectionAtom((ISOItemProtectionAtomPtr *)&newAtom); + break; + + case ISOItemInfoAtomType: + err = ISOCreateItemInfoAtom((ISOItemInfoAtomPtr *)&newAtom); + break; + + case ISOItemInfoEntryAtomType: + err = ISOCreateItemInfoEntryAtom((ISOItemInfoEntryAtomPtr *)&newAtom); + break; + + case ISOAdditionalMetaDataContainerAtomType: + err = + ISOCreateAdditionalMetaDataContainerAtom((ISOAdditionalMetaDataContainerAtomPtr *)&newAtom); + break; + + case ISOMetaboxRelationAtomType: + err = ISOCreateMetaboxRelationAtom((ISOMetaboxRelationAtomPtr *)&newAtom); + break; + + case ISOItemDataAtomType: + err = ISOCreateItemDataAtom((ISOItemDataAtomPtr *)&newAtom); + break; + + case ISOItemReferenceAtomType: + err = ISOCreateItemReferenceAtom((ISOItemReferenceAtomPtr *)&newAtom); + break; + + case MP4AMRSpecificInfoAtomType: + err = MP4CreateAMRSpecificInfoAtom((MP4AMRSpecificInfoAtomPtr *)&newAtom); + break; + + case MP4AMRWPSpecificInfoAtomType: + err = MP4CreateAMRWPSpecificInfoAtom((MP4AMRWPSpecificInfoAtomPtr *)&newAtom); + break; + + case MP4H263SpecificInfoAtomType: + err = MP4CreateH263SpecificInfoAtom((MP4H263SpecificInfoAtomPtr *)&newAtom); + break; + + case MP4BitRateAtomType: + case TGPPBitRateAtomType: + err = MP4CreateBitRateAtom((MP4BitRateAtomPtr *)&newAtom); + break; + + case MP4ItemPropertiesAtomType: + err = MP4CreateItemPropertiesAtom((MP4ItemPropertiesAtomPtr *)&newAtom); + break; + + case MP4ItemPropertyContainerAtomType: + err = MP4CreateItemPropertyContainerAtom((MP4ItemPropertyContainerAtomPtr *)&newAtom); + break; + + case MP4ItemPropertyAssociationAtomType: + err = MP4CreateItemPropertyAssociationAtom((MP4ItemPropertyAssociationAtomPtr *)&newAtom); + break; + + case ISOHEVCConfigAtomType: + err = MP4CreateHEVCConfigAtom((ISOHEVCConfigAtomPtr *)&newAtom); + break; + + default: + err = MP4CreateUnknownAtom((MP4UnknownAtomPtr *)&newAtom); + newAtom->type = atomType; + break; + } + if(err == MP4NoErr) *outAtom = newAtom; + return err; } -void MP4TypeToString( u32 inType, char* ioStr ) +void MP4TypeToString(u32 inType, char *ioStr) { - u32 i; - int ch; - - for ( i = 0; i < 4; i++, ioStr++ ) - { - ch = inType >> (8*(3-i)) & 0xff; - if ( isprint(ch) ) - *ioStr = ch; - else - *ioStr = '.'; - } - *ioStr = 0; + u32 i; + int ch; + + for(i = 0; i < 4; i++, ioStr++) + { + ch = inType >> (8 * (3 - i)) & 0xff; + if(isprint(ch)) *ioStr = ch; + else + *ioStr = '.'; + } + *ioStr = 0; } -MP4Err MP4GetListEntryAtom( MP4LinkedList list, u32 atomType, MP4AtomPtr* outItem ) +MP4Err MP4GetListEntryAtom(MP4LinkedList list, u32 atomType, MP4AtomPtr *outItem) { - MP4Err err; - u32 count, i; - - err = MP4NoErr; - *outItem = NULL; - err = MP4GetListEntryCount( list, &count ); if (err) goto bail; - for ( i = 0; i < count; i++ ) - { - MP4AtomPtr p; - err = MP4GetListEntry( list, i, (char **) &p ); if (err) goto bail; - if ( (p != 0) && (p->type == atomType) ) - { - *outItem = p; err = MP4NoErr; - goto bail; - } - } - - err = MP4NotFoundErr; - + MP4Err err; + u32 count, i; + + err = MP4NoErr; + *outItem = NULL; + err = MP4GetListEntryCount(list, &count); + if(err) goto bail; + for(i = 0; i < count; i++) + { + MP4AtomPtr p; + err = MP4GetListEntry(list, i, (char **)&p); + if(err) goto bail; + if((p != 0) && (p->type == atomType)) + { + *outItem = p; + err = MP4NoErr; + goto bail; + } + } + + err = MP4NotFoundErr; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4DeleteListEntryAtom( MP4LinkedList list, u32 atomType ) +MP4Err MP4DeleteListEntryAtom(MP4LinkedList list, u32 atomType) { - MP4Err err; - u32 count, i; - - err = MP4NoErr; - err = MP4GetListEntryCount( list, &count ); if (err) goto bail; - for ( i = 0; i < count; i++ ) - { - MP4AtomPtr p; - err = MP4GetListEntry( list, i, (char **) &p ); if (err) goto bail; - if ( (p != 0) && (p->type == atomType) ) - { - err = MP4DeleteListEntry( list, i ); - goto bail; - } - } - - err = MP4NotFoundErr; - + MP4Err err; + u32 count, i; + + err = MP4NoErr; + err = MP4GetListEntryCount(list, &count); + if(err) goto bail; + for(i = 0; i < count; i++) + { + MP4AtomPtr p; + err = MP4GetListEntry(list, i, (char **)&p); + if(err) goto bail; + if((p != 0) && (p->type == atomType)) + { + err = MP4DeleteListEntry(list, i); + goto bail; + } + } + + err = MP4NotFoundErr; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4ParseAtomUsingProtoList( MP4InputStreamPtr inputStream, u32* protoList, u32 defaultAtom, MP4AtomPtr *outAtom ) +MP4Err MP4ParseAtomUsingProtoList(MP4InputStreamPtr inputStream, u32 *protoList, u32 defaultAtom, + MP4AtomPtr *outAtom) { - MP4AtomPtr atomProto; - MP4Err err; - long bytesParsed; - MP4Atom protoAtom; - MP4AtomPtr newAtom; - char typeString[ 8 ]; - char msgString[ 80 ]; - u64 beginAvail; - u64 consumedBytes; - u32 useDefaultAtom; - - atomProto = &protoAtom; - err = MP4NoErr; - bytesParsed = 0L; - - if ((inputStream == NULL) || (outAtom == NULL) ) - BAILWITHERROR( MP4BadParamErr ) - *outAtom = NULL; - beginAvail = inputStream->available; - useDefaultAtom = 0; - inputStream->msg( inputStream, "{" ); - inputStream->indent++; - err = MP4CreateBaseAtom( atomProto ); if ( err ) goto bail; - - atomProto->streamOffset = inputStream->getStreamOffset( inputStream ); - - /* atom size */ - err = inputStream->read32( inputStream, &atomProto->size, NULL ); if ( err ) goto bail; - if ( atomProto->size == 0 ) { - /* BAILWITHERROR( MP4NoQTAtomErr ) */ - u64 the_size; - the_size = inputStream->available + 4; - if (the_size >> 32) { - atomProto->size = 1; - atomProto->size64 = the_size + 8; - } - else atomProto->size = (u32) the_size; - } - if ((atomProto->size != 1) && ((atomProto->size - 4) > inputStream->available)) - BAILWITHERROR( MP4BadDataErr ) - bytesParsed += 4L; - - sprintf( msgString, "atom size is %d", atomProto->size ); - inputStream->msg( inputStream, msgString ); - - /* atom type */ - err = inputStream->read32( inputStream, &atomProto->type, NULL ); if ( err ) goto bail; - bytesParsed += 4L; - MP4TypeToString( atomProto->type, typeString ); - sprintf( msgString, "atom type is '%s'", typeString ); - inputStream->msg( inputStream, msgString ); - if ( atomProto->type == MP4ExtendedAtomType ) - { - err = inputStream->readData( inputStream, 16, (char*) atomProto->uuid, NULL ); if ( err ) goto bail; - bytesParsed += 16L; - } - - /* large atom */ - if ( atomProto->size == 1 ) - { - u32 size; - err = inputStream->read32( inputStream, &size, NULL ); if ( err ) goto bail; - /* if ( size ) - BAILWITHERROR( MP4NoLargeAtomSupportErr ) */ - atomProto->size64 = size; - atomProto->size64 <<= 32; - err = inputStream->read32( inputStream, &size, NULL ); if ( err ) goto bail; - atomProto->size64 |= size; - atomProto->size = 1; - bytesParsed += 8L; - } - - atomProto->bytesRead = bytesParsed; - if ((atomProto->size != 1) && ( ((long) atomProto->size) < bytesParsed )) - BAILWITHERROR( MP4BadDataErr ) - if ( protoList ) - { - while ( *protoList ) - { - if ( *protoList == atomProto->type ) - break; - protoList++; - } - if ( *protoList == 0 ) - { - useDefaultAtom = 1; - } - } - err = MP4CreateAtom( useDefaultAtom ? defaultAtom : atomProto->type, &newAtom ); if ( err ) goto bail; - sprintf( msgString, "atom name is '%s'", newAtom->name ); - inputStream->msg( inputStream, msgString ); - err = newAtom->createFromInputStream( newAtom, atomProto, (char*) inputStream ); if ( err ) goto bail; - consumedBytes = beginAvail - inputStream->available; - if ((atomProto->size != 1 ) && ( consumedBytes != atomProto->size )) - { - sprintf( msgString, "##### atom size is %d but parse used %lld bytes ####", atomProto->size, consumedBytes ); - inputStream->msg( inputStream, msgString ); - if (consumedBytes < atomProto->size) { - u32 x; - u32 i; - for (i=0; i<(atomProto->size)-consumedBytes; i++) inputStream->read8(inputStream, &x, NULL ); - } - } - else if ((atomProto->size == 1 ) && ( consumedBytes != atomProto->size64 )) - { - sprintf( msgString, "##### atom size is %lld but parse used %lld bytes ####", atomProto->size64, consumedBytes ); - inputStream->msg( inputStream, msgString ); - if (consumedBytes < atomProto->size64) { - u32 x; - u64 i; - for (i=0; i<(atomProto->size64)-consumedBytes; i++) inputStream->read8(inputStream, &x, NULL ); - } - } - *outAtom = newAtom; - inputStream->indent--; - inputStream->msg( inputStream, "}" ); + MP4AtomPtr atomProto; + MP4Err err; + long bytesParsed; + MP4Atom protoAtom; + MP4AtomPtr newAtom; + char typeString[8]; + char msgString[80]; + u64 beginAvail; + u64 consumedBytes; + u32 useDefaultAtom; + + atomProto = &protoAtom; + err = MP4NoErr; + bytesParsed = 0L; + + if((inputStream == NULL) || (outAtom == NULL)) BAILWITHERROR(MP4BadParamErr) + *outAtom = NULL; + beginAvail = inputStream->available; + useDefaultAtom = 0; + inputStream->msg(inputStream, "{"); + inputStream->indent++; + err = MP4CreateBaseAtom(atomProto); + if(err) goto bail; + + atomProto->streamOffset = inputStream->getStreamOffset(inputStream); + + /* atom size */ + err = inputStream->read32(inputStream, &atomProto->size, NULL); + if(err) goto bail; + if(atomProto->size == 0) + { + /* BAILWITHERROR( MP4NoQTAtomErr ) */ + u64 the_size; + the_size = inputStream->available + 4; + if(the_size >> 32) + { + atomProto->size = 1; + atomProto->size64 = the_size + 8; + } + else + atomProto->size = (u32)the_size; + } + if((atomProto->size != 1) && ((atomProto->size - 4) > inputStream->available)) + BAILWITHERROR(MP4BadDataErr) + bytesParsed += 4L; + + sprintf(msgString, "atom size is %d", atomProto->size); + inputStream->msg(inputStream, msgString); + + /* atom type */ + err = inputStream->read32(inputStream, &atomProto->type, NULL); + if(err) goto bail; + bytesParsed += 4L; + MP4TypeToString(atomProto->type, typeString); + sprintf(msgString, "atom type is '%s'", typeString); + inputStream->msg(inputStream, msgString); + if(atomProto->type == MP4ExtendedAtomType) + { + err = inputStream->readData(inputStream, 16, (char *)atomProto->uuid, NULL); + if(err) goto bail; + bytesParsed += 16L; + } + + /* large atom */ + if(atomProto->size == 1) + { + u32 size; + err = inputStream->read32(inputStream, &size, NULL); + if(err) goto bail; + /* if ( size ) + BAILWITHERROR( MP4NoLargeAtomSupportErr ) */ + atomProto->size64 = size; + atomProto->size64 <<= 32; + err = inputStream->read32(inputStream, &size, NULL); + if(err) goto bail; + atomProto->size64 |= size; + atomProto->size = 1; + bytesParsed += 8L; + } + + atomProto->bytesRead = bytesParsed; + if((atomProto->size != 1) && (((long)atomProto->size) < bytesParsed)) BAILWITHERROR(MP4BadDataErr) + if(protoList) + { + while(*protoList) + { + if(*protoList == atomProto->type) break; + protoList++; + } + if(*protoList == 0) + { + useDefaultAtom = 1; + } + } + err = MP4CreateAtom(useDefaultAtom ? defaultAtom : atomProto->type, &newAtom); + if(err) goto bail; + sprintf(msgString, "atom name is '%s'", newAtom->name); + inputStream->msg(inputStream, msgString); + err = newAtom->createFromInputStream(newAtom, atomProto, (char *)inputStream); + if(err) goto bail; + consumedBytes = beginAvail - inputStream->available; + if((atomProto->size != 1) && (consumedBytes != atomProto->size)) + { + sprintf(msgString, "##### atom size is %d but parse used %lld bytes ####", atomProto->size, + consumedBytes); + inputStream->msg(inputStream, msgString); + if(consumedBytes < atomProto->size) + { + u32 x; + u32 i; + for(i = 0; i < (atomProto->size) - consumedBytes; i++) + inputStream->read8(inputStream, &x, NULL); + } + } + else if((atomProto->size == 1) && (consumedBytes != atomProto->size64)) + { + sprintf(msgString, "##### atom size is %lld but parse used %lld bytes ####", atomProto->size64, + consumedBytes); + inputStream->msg(inputStream, msgString); + if(consumedBytes < atomProto->size64) + { + u32 x; + u64 i; + for(i = 0; i < (atomProto->size64) - consumedBytes; i++) + inputStream->read8(inputStream, &x, NULL); + } + } + *outAtom = newAtom; + inputStream->indent--; + inputStream->msg(inputStream, "}"); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4ParseAtom( MP4InputStreamPtr inputStream, MP4AtomPtr *outAtom ) +MP4Err MP4ParseAtom(MP4InputStreamPtr inputStream, MP4AtomPtr *outAtom) { - return MP4ParseAtomUsingProtoList( inputStream, NULL, 0, outAtom ); + return MP4ParseAtomUsingProtoList(inputStream, NULL, 0, outAtom); } -MP4Err MP4CalculateBaseAtomFieldSize( struct MP4Atom* self ) +MP4Err MP4CalculateBaseAtomFieldSize(struct MP4Atom *self) { - self->size = 8; - return MP4NoErr; + self->size = 8; + return MP4NoErr; } -MP4Err MP4CalculateFullAtomFieldSize( struct MP4FullAtom* self ) +MP4Err MP4CalculateFullAtomFieldSize(struct MP4FullAtom *self) { - MP4Err err = MP4CalculateBaseAtomFieldSize( (MP4AtomPtr) self ); - self->size += 4; - return err; + MP4Err err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)self); + self->size += 4; + return err; } -MP4Err MP4SerializeCommonBaseAtomFields( struct MP4Atom* self, char* buffer ) +MP4Err MP4SerializeCommonBaseAtomFields(struct MP4Atom *self, char *buffer) { - MP4Err err; - u32 kept_size; - err = MP4NoErr; - - kept_size = self->size; - if (self->size == 1) self->size = 16; - - self->bytesWritten = 0; - assert( self->size ); - assert( self->type ); - PUT32_V( kept_size ); - - PUT32( type ); - - if (kept_size == 1) { - PUT64( size64 ); - self->size = 1; - } + MP4Err err; + u32 kept_size; + err = MP4NoErr; + + kept_size = self->size; + if(self->size == 1) self->size = 16; + + self->bytesWritten = 0; + assert(self->size); + assert(self->type); + PUT32_V(kept_size); + + PUT32(type); + + if(kept_size == 1) + { + PUT64(size64); + self->size = 1; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4SerializeCommonFullAtomFields( struct MP4FullAtom* self, char* buffer ) +MP4Err MP4SerializeCommonFullAtomFields(struct MP4FullAtom *self, char *buffer) { - MP4Err err; - err = MP4SerializeCommonBaseAtomFields( (MP4AtomPtr) self, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT8( version ); - PUT24( flags ); + MP4Err err; + err = MP4SerializeCommonBaseAtomFields((MP4AtomPtr)self, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT8(version); + PUT24(flags); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h old mode 100755 new mode 100644 index 1300251..765f556 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -24,9 +24,9 @@ * acting on behalf of its Fraunhofer Institute for Telecommunications, * Heinrich Hertz Institute, HHI * All rights reserved. -*/ + */ /* - $Id: MP4Atoms.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4Atoms.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #ifndef INCLUDED_MP4ATOMS_H @@ -37,991 +37,1026 @@ #include "MP4InputStream.h" #include "MP4LinkedList.h" -ISOErr MP4GetCurrentTime( u64 *outTime ); +ISOErr MP4GetCurrentTime(u64 *outTime); enum { - MP4AudioSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 'm', 'p', '4', 'a' ), - AudioIntegerPCMSampleEntryType = MP4_FOUR_CHAR_CODE( 'i', 'p', 'c', 'm' ), - AudioFloatPCMSampleEntryType = MP4_FOUR_CHAR_CODE( 'f', 'p', 'c', 'm' ), - MP4PCMConfigAtomType = MP4_FOUR_CHAR_CODE( 'p', 'c', 'm', 'C' ), - MP4ChannelLayoutAtomType = MP4_FOUR_CHAR_CODE( 'c', 'h', 'n', 'l' ), - MP4DownMixInstructionsAtomType = MP4_FOUR_CHAR_CODE( 'd', 'm', 'i', 'x' ), - MP4TrackLoudnessInfoAtomType = MP4_FOUR_CHAR_CODE( 't', 'l', 'o', 'u' ), - MP4AlbumLoudnessInfoAtomType = MP4_FOUR_CHAR_CODE( 'a', 'l', 'o', 'u' ), - MP4LoudnessAtomType = MP4_FOUR_CHAR_CODE( 'l', 'u', 'd', 't' ), - MP4ChunkLargeOffsetAtomType = MP4_FOUR_CHAR_CODE( 'c', 'o', '6', '4' ), - MP4ChunkOffsetAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 'c', 'o' ), - MP4ClockReferenceMediaHeaderAtomType = MP4_FOUR_CHAR_CODE( 'c', 'r', 'h', 'd' ), - MP4CompositionOffsetAtomType = MP4_FOUR_CHAR_CODE( 'c', 't', 't', 's' ), - MP4CompositionToDecodeAtomType = MP4_FOUR_CHAR_CODE( 'c', 's', 'l', 'g' ), - MP4CopyrightAtomType = MP4_FOUR_CHAR_CODE( 'c', 'p', 'r', 't' ), - MP4DataEntryURLAtomType = MP4_FOUR_CHAR_CODE( 'u', 'r', 'l', ' ' ), - MP4DataEntryURNAtomType = MP4_FOUR_CHAR_CODE( 'u', 'r', 'n', ' ' ), - MP4DataInformationAtomType = MP4_FOUR_CHAR_CODE( 'd', 'i', 'n', 'f' ), - MP4DataReferenceAtomType = MP4_FOUR_CHAR_CODE( 'd', 'r', 'e', 'f' ), - MP4DegradationPriorityAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 'd', 'p' ), - MP4ESDAtomType = MP4_FOUR_CHAR_CODE( 'e', 's', 'd', 's' ), - MP4EditAtomType = MP4_FOUR_CHAR_CODE( 'e', 'd', 't', 's' ), - MP4EditListAtomType = MP4_FOUR_CHAR_CODE( 'e', 'l', 's', 't' ), - MP4ExtendedAtomType = MP4_FOUR_CHAR_CODE( 'u', 'u', 'i', 'd' ), - MP4FreeSpaceAtomType = MP4_FOUR_CHAR_CODE( 'f', 'r', 'e', 'e' ), - MP4GenericSampleEntryAtomType = MP4_FOUR_CHAR_CODE( '!', 'g', 'n', 'r' ), - MP4HandlerAtomType = MP4_FOUR_CHAR_CODE( 'h', 'd', 'l', 'r' ), - MP4HintMediaHeaderAtomType = MP4_FOUR_CHAR_CODE( 'h', 'm', 'h', 'd' ), - MP4HintTrackReferenceAtomType = MP4_FOUR_CHAR_CODE( 'h', 'i', 'n', 't' ), - MP4MPEGMediaHeaderAtomType = MP4_FOUR_CHAR_CODE( 'n', 'm', 'h', 'd' ), - MP4MPEGSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 'm', 'p', '4', 's' ), - MP4MediaAtomType = MP4_FOUR_CHAR_CODE( 'm', 'd', 'i', 'a' ), - MP4MediaDataAtomType = MP4_FOUR_CHAR_CODE( 'm', 'd', 'a', 't' ), - MP4MediaHeaderAtomType = MP4_FOUR_CHAR_CODE( 'm', 'd', 'h', 'd' ), - MP4MediaInformationAtomType = MP4_FOUR_CHAR_CODE( 'm', 'i', 'n', 'f' ), - MP4ExtendedLanguageTagAtomType = MP4_FOUR_CHAR_CODE( 'e', 'l', 'n', 'g' ), - MP4MovieAtomType = MP4_FOUR_CHAR_CODE( 'm', 'o', 'o', 'v' ), - MP4MovieHeaderAtomType = MP4_FOUR_CHAR_CODE( 'm', 'v', 'h', 'd' ), - MP4ObjectDescriptorAtomType = MP4_FOUR_CHAR_CODE( 'i', 'o', 'd', 's' ), - MP4ObjectDescriptorMediaHeaderAtomType = MP4_FOUR_CHAR_CODE( 'o', 'd', 'h', 'd' ), - MP4ODTrackReferenceAtomType = MP4_FOUR_CHAR_CODE( 'm', 'p', 'o', 'd' ), - MP4SampleDescriptionAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 's', 'd' ), - MP4SampleSizeAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 's', 'z' ), - MP4CompactSampleSizeAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 'z', '2' ), - MP4SampleTableAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 'b', 'l' ), - MP4SampleToChunkAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 's', 'c' ), - MP4SampleAuxiliaryInformationSizesAtomType = MP4_FOUR_CHAR_CODE( 's', 'a', 'i', 'z' ), - MP4SampleAuxiliaryInformationOffsetsAtomType = MP4_FOUR_CHAR_CODE( 's', 'a', 'i', 'o' ), - MP4SceneDescriptionMediaHeaderAtomType = MP4_FOUR_CHAR_CODE( 's', 'd', 'h', 'd' ), - MP4ShadowSyncAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 's', 'h' ), - MP4SkipAtomType = MP4_FOUR_CHAR_CODE( 's', 'k', 'i', 'p' ), - MP4SoundMediaHeaderAtomType = MP4_FOUR_CHAR_CODE( 's', 'm', 'h', 'd' ), - MP4StreamDependenceAtomType = MP4_FOUR_CHAR_CODE( 'd', 'p', 'n', 'd' ), - MP4SubSampleInformationAtomType = MP4_FOUR_CHAR_CODE( 's', 'u', 'b', 's' ), - MP4SyncSampleAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 's', 's' ), - MP4SyncTrackReferenceAtomType = MP4_FOUR_CHAR_CODE( 's', 'y', 'n', 'c' ), - MP4TimeToSampleAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 't', 's' ), - MP4TrackAtomType = MP4_FOUR_CHAR_CODE( 't', 'r', 'a', 'k' ), - MP4TrackHeaderAtomType = MP4_FOUR_CHAR_CODE( 't', 'k', 'h', 'd' ), - MP4TrackReferenceAtomType = MP4_FOUR_CHAR_CODE( 't', 'r', 'e', 'f' ), - MP4TrackGroupAtomType = MP4_FOUR_CHAR_CODE( 't', 'r', 'g', 'r' ), - MP4UserDataAtomType = MP4_FOUR_CHAR_CODE( 'u', 'd', 't', 'a' ), - MP4VideoMediaHeaderAtomType = MP4_FOUR_CHAR_CODE( 'v', 'm', 'h', 'd' ), - MP4VisualSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 'm', 'p', '4', 'v' ), - MP4PaddingBitsAtomType = MP4_FOUR_CHAR_CODE( 'p', 'a', 'd', 'b' ), - MP4MovieExtendsAtomType = MP4_FOUR_CHAR_CODE( 'm', 'v', 'e', 'x' ), - MP4TrackExtensionPropertiesAtomType = MP4_FOUR_CHAR_CODE( 't', 'r', 'e', 'p' ), - MP4TrackExtendsAtomType = MP4_FOUR_CHAR_CODE( 't', 'r', 'e', 'x' ), - MP4MovieFragmentAtomType = MP4_FOUR_CHAR_CODE( 'm', 'o', 'o', 'f' ), - MP4MovieFragmentHeaderAtomType = MP4_FOUR_CHAR_CODE( 'm', 'f', 'h', 'd' ), - MP4TrackFragmentAtomType = MP4_FOUR_CHAR_CODE( 't', 'r', 'a', 'f' ), - MP4TrackFragmentHeaderAtomType = MP4_FOUR_CHAR_CODE( 't', 'f', 'h', 'd' ), - MP4TrackFragmentDecodeTimeAtomType = MP4_FOUR_CHAR_CODE( 't', 'f', 'd', 't' ), - MP4TrackRunAtomType = MP4_FOUR_CHAR_CODE( 't', 'r', 'u', 'n' ), - MP4ItemPropertiesAtomType = MP4_FOUR_CHAR_CODE( 'i', 'p', 'r', 'p' ), - MP4ItemPropertyContainerAtomType = MP4_FOUR_CHAR_CODE( 'i', 'p', 'c', 'o' ), - MP4ItemPropertyAssociationAtomType = MP4_FOUR_CHAR_CODE( 'i', 'p', 'm', 'a' ), - MP4SampleGroupDescriptionAtomType = MP4_FOUR_CHAR_CODE( 's', 'g', 'p', 'd' ), - MP4SampletoGroupAtomType = MP4_FOUR_CHAR_CODE( 's', 'b', 'g', 'p' ), - MP4CompactSampletoGroupAtomType = MP4_FOUR_CHAR_CODE( 'c', 's', 'g', 'p' ), - MP4SampleDependencyAtomType = MP4_FOUR_CHAR_CODE( 's', 'd', 't', 'p' ), - ISOMetaAtomType = MP4_FOUR_CHAR_CODE( 'm', 'e', 't', 'a' ), - ISOPrimaryItemAtomType = MP4_FOUR_CHAR_CODE( 'p', 'i', 't', 'm' ), - ISOItemLocationAtomType = MP4_FOUR_CHAR_CODE( 'i', 'l', 'o', 'c' ), - ISOItemProtectionAtomType = MP4_FOUR_CHAR_CODE( 'i', 'p', 'r', 'o' ), - ISOItemInfoAtomType = MP4_FOUR_CHAR_CODE( 'i', 'i', 'n', 'f' ), - ISOItemInfoEntryAtomType = MP4_FOUR_CHAR_CODE( 'i', 'n', 'f', 'e' ), - ISOAdditionalMetaDataContainerAtomType = MP4_FOUR_CHAR_CODE( 'm', 'e', 'c', 'o' ), - ISOMetaboxRelationAtomType = MP4_FOUR_CHAR_CODE( 'm', 'e', 'r', 'e' ), - ISOItemDataAtomType = MP4_FOUR_CHAR_CODE( 'i', 'd', 'a', 't' ), - ISOItemReferenceAtomType = MP4_FOUR_CHAR_CODE( 'i', 'r', 'e', 'f' ), - ISOVCConfigAtomType = MP4_FOUR_CHAR_CODE( 'a', 'v', 'c', 'C' ), - ISOHEVCConfigAtomType = MP4_FOUR_CHAR_CODE( 'h', 'v', 'c', 'C' ), - ISOAVCSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 'a', 'v', 'c', '1' ), - ISOHEVCSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 'h', 'v', 'c', '1' ), - ISOLHEVCSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 'h', 'v', 'c', '2' ), - MP4XMLMetaSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 'm', 'e', 't', 'x' ), - MP4TextMetaSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 'm', 'e', 't', 't' ), - MP4AMRSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 's', 'a', 'm', 'r' ), - MP4AMRSpecificInfoAtomType = MP4_FOUR_CHAR_CODE( 'd', 'a', 'm', 'r' ), - MP4AWBSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 's', 'a', 'w', 'b' ), - MP4AMRWPSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 's', 'a', 'w', 'p' ), - MP4AMRWPSpecificInfoAtomType = MP4_FOUR_CHAR_CODE( 'd', 'a', 'w', 'p' ), - MP4H263SampleEntryAtomType = MP4_FOUR_CHAR_CODE( 's', '2', '6', '3' ), - MP4H263SpecificInfoAtomType = MP4_FOUR_CHAR_CODE( 'd', '2', '6', '3' ), - MP4BitRateAtomType = MP4_FOUR_CHAR_CODE( 'b', 't', 'r', 't' ), - TGPPBitRateAtomType = MP4_FOUR_CHAR_CODE( 'b', 'i', 't', 'r' ), - MP4OriginalFormatAtomType = MP4_FOUR_CHAR_CODE( 'f', 'r', 'm', 'a' ), - MP4SchemeTypeAtomType = MP4_FOUR_CHAR_CODE( 's', 'c', 'h', 'm' ), - MP4SchemeInfoAtomType = MP4_FOUR_CHAR_CODE( 's', 'c', 'h', 'i' ), - MP4StereoVideoAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 'v', 'i' ), - MP4CompatibleSchemeTypeAtomType = MP4_FOUR_CHAR_CODE( 'c', 's', 'c', 'h' ), - MP4RestrictedSchemeInfoAtomType = MP4_FOUR_CHAR_CODE( 'r', 'i', 'n', 'f' ), - MP4StereoVideoGroupAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 'e', 'r' ), - MP4TrackTypeAtomType = MP4_FOUR_CHAR_CODE( 't', 't', 'y', 'p' ), - MP4RestrictedVideoSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 'r', 'e', 's', 'v' ), - MP4SegmentTypeAtomType = MP4_FOUR_CHAR_CODE( 's', 't', 'y', 'p' ), - MP4SegmentIndexAtomType = MP4_FOUR_CHAR_CODE( 's', 'i', 'd', 'x' ), - MP4SubsegmentIndexAtomType = MP4_FOUR_CHAR_CODE( 's', 's', 'i', 'x' ), - MP4ProducerReferenceTimeAtomType = MP4_FOUR_CHAR_CODE( 'p', 'r', 'f', 't' ) - -}; + MP4AudioSampleEntryAtomType = MP4_FOUR_CHAR_CODE('m', 'p', '4', 'a'), + AudioIntegerPCMSampleEntryType = MP4_FOUR_CHAR_CODE('i', 'p', 'c', 'm'), + AudioFloatPCMSampleEntryType = MP4_FOUR_CHAR_CODE('f', 'p', 'c', 'm'), + MP4PCMConfigAtomType = MP4_FOUR_CHAR_CODE('p', 'c', 'm', 'C'), + MP4ChannelLayoutAtomType = MP4_FOUR_CHAR_CODE('c', 'h', 'n', 'l'), + MP4DownMixInstructionsAtomType = MP4_FOUR_CHAR_CODE('d', 'm', 'i', 'x'), + MP4TrackLoudnessInfoAtomType = MP4_FOUR_CHAR_CODE('t', 'l', 'o', 'u'), + MP4AlbumLoudnessInfoAtomType = MP4_FOUR_CHAR_CODE('a', 'l', 'o', 'u'), + MP4LoudnessAtomType = MP4_FOUR_CHAR_CODE('l', 'u', 'd', 't'), + MP4ChunkLargeOffsetAtomType = MP4_FOUR_CHAR_CODE('c', 'o', '6', '4'), + MP4ChunkOffsetAtomType = MP4_FOUR_CHAR_CODE('s', 't', 'c', 'o'), + MP4ClockReferenceMediaHeaderAtomType = MP4_FOUR_CHAR_CODE('c', 'r', 'h', 'd'), + MP4CompositionOffsetAtomType = MP4_FOUR_CHAR_CODE('c', 't', 't', 's'), + MP4CompositionToDecodeAtomType = MP4_FOUR_CHAR_CODE('c', 's', 'l', 'g'), + MP4CopyrightAtomType = MP4_FOUR_CHAR_CODE('c', 'p', 'r', 't'), + MP4DataEntryURLAtomType = MP4_FOUR_CHAR_CODE('u', 'r', 'l', ' '), + MP4DataEntryURNAtomType = MP4_FOUR_CHAR_CODE('u', 'r', 'n', ' '), + MP4DataInformationAtomType = MP4_FOUR_CHAR_CODE('d', 'i', 'n', 'f'), + MP4DataReferenceAtomType = MP4_FOUR_CHAR_CODE('d', 'r', 'e', 'f'), + MP4DegradationPriorityAtomType = MP4_FOUR_CHAR_CODE('s', 't', 'd', 'p'), + MP4ESDAtomType = MP4_FOUR_CHAR_CODE('e', 's', 'd', 's'), + MP4EditAtomType = MP4_FOUR_CHAR_CODE('e', 'd', 't', 's'), + MP4EditListAtomType = MP4_FOUR_CHAR_CODE('e', 'l', 's', 't'), + MP4ExtendedAtomType = MP4_FOUR_CHAR_CODE('u', 'u', 'i', 'd'), + MP4FreeSpaceAtomType = MP4_FOUR_CHAR_CODE('f', 'r', 'e', 'e'), + MP4GenericSampleEntryAtomType = MP4_FOUR_CHAR_CODE('!', 'g', 'n', 'r'), + MP4HandlerAtomType = MP4_FOUR_CHAR_CODE('h', 'd', 'l', 'r'), + MP4HintMediaHeaderAtomType = MP4_FOUR_CHAR_CODE('h', 'm', 'h', 'd'), + MP4HintTrackReferenceAtomType = MP4_FOUR_CHAR_CODE('h', 'i', 'n', 't'), + MP4MPEGMediaHeaderAtomType = MP4_FOUR_CHAR_CODE('n', 'm', 'h', 'd'), + MP4MPEGSampleEntryAtomType = MP4_FOUR_CHAR_CODE('m', 'p', '4', 's'), + MP4MediaAtomType = MP4_FOUR_CHAR_CODE('m', 'd', 'i', 'a'), + MP4MediaDataAtomType = MP4_FOUR_CHAR_CODE('m', 'd', 'a', 't'), + MP4MediaHeaderAtomType = MP4_FOUR_CHAR_CODE('m', 'd', 'h', 'd'), + MP4MediaInformationAtomType = MP4_FOUR_CHAR_CODE('m', 'i', 'n', 'f'), + MP4ExtendedLanguageTagAtomType = MP4_FOUR_CHAR_CODE('e', 'l', 'n', 'g'), + MP4MovieAtomType = MP4_FOUR_CHAR_CODE('m', 'o', 'o', 'v'), + MP4MovieHeaderAtomType = MP4_FOUR_CHAR_CODE('m', 'v', 'h', 'd'), + MP4ObjectDescriptorAtomType = MP4_FOUR_CHAR_CODE('i', 'o', 'd', 's'), + MP4ObjectDescriptorMediaHeaderAtomType = MP4_FOUR_CHAR_CODE('o', 'd', 'h', 'd'), + MP4ODTrackReferenceAtomType = MP4_FOUR_CHAR_CODE('m', 'p', 'o', 'd'), + MP4SampleDescriptionAtomType = MP4_FOUR_CHAR_CODE('s', 't', 's', 'd'), + MP4SampleSizeAtomType = MP4_FOUR_CHAR_CODE('s', 't', 's', 'z'), + MP4CompactSampleSizeAtomType = MP4_FOUR_CHAR_CODE('s', 't', 'z', '2'), + MP4SampleTableAtomType = MP4_FOUR_CHAR_CODE('s', 't', 'b', 'l'), + MP4SampleToChunkAtomType = MP4_FOUR_CHAR_CODE('s', 't', 's', 'c'), + MP4SampleAuxiliaryInformationSizesAtomType = MP4_FOUR_CHAR_CODE('s', 'a', 'i', 'z'), + MP4SampleAuxiliaryInformationOffsetsAtomType = MP4_FOUR_CHAR_CODE('s', 'a', 'i', 'o'), + MP4SceneDescriptionMediaHeaderAtomType = MP4_FOUR_CHAR_CODE('s', 'd', 'h', 'd'), + MP4ShadowSyncAtomType = MP4_FOUR_CHAR_CODE('s', 't', 's', 'h'), + MP4SkipAtomType = MP4_FOUR_CHAR_CODE('s', 'k', 'i', 'p'), + MP4SoundMediaHeaderAtomType = MP4_FOUR_CHAR_CODE('s', 'm', 'h', 'd'), + MP4StreamDependenceAtomType = MP4_FOUR_CHAR_CODE('d', 'p', 'n', 'd'), + MP4SubSampleInformationAtomType = MP4_FOUR_CHAR_CODE('s', 'u', 'b', 's'), + MP4SyncSampleAtomType = MP4_FOUR_CHAR_CODE('s', 't', 's', 's'), + MP4SyncTrackReferenceAtomType = MP4_FOUR_CHAR_CODE('s', 'y', 'n', 'c'), + MP4TimeToSampleAtomType = MP4_FOUR_CHAR_CODE('s', 't', 't', 's'), + MP4TrackAtomType = MP4_FOUR_CHAR_CODE('t', 'r', 'a', 'k'), + MP4TrackHeaderAtomType = MP4_FOUR_CHAR_CODE('t', 'k', 'h', 'd'), + MP4TrackReferenceAtomType = MP4_FOUR_CHAR_CODE('t', 'r', 'e', 'f'), + MP4TrackGroupAtomType = MP4_FOUR_CHAR_CODE('t', 'r', 'g', 'r'), + MP4UserDataAtomType = MP4_FOUR_CHAR_CODE('u', 'd', 't', 'a'), + MP4VideoMediaHeaderAtomType = MP4_FOUR_CHAR_CODE('v', 'm', 'h', 'd'), + MP4VisualSampleEntryAtomType = MP4_FOUR_CHAR_CODE('m', 'p', '4', 'v'), + MP4PaddingBitsAtomType = MP4_FOUR_CHAR_CODE('p', 'a', 'd', 'b'), + MP4MovieExtendsAtomType = MP4_FOUR_CHAR_CODE('m', 'v', 'e', 'x'), + MP4TrackExtensionPropertiesAtomType = MP4_FOUR_CHAR_CODE('t', 'r', 'e', 'p'), + MP4TrackExtendsAtomType = MP4_FOUR_CHAR_CODE('t', 'r', 'e', 'x'), + MP4MovieFragmentAtomType = MP4_FOUR_CHAR_CODE('m', 'o', 'o', 'f'), + MP4MovieFragmentHeaderAtomType = MP4_FOUR_CHAR_CODE('m', 'f', 'h', 'd'), + MP4TrackFragmentAtomType = MP4_FOUR_CHAR_CODE('t', 'r', 'a', 'f'), + MP4TrackFragmentHeaderAtomType = MP4_FOUR_CHAR_CODE('t', 'f', 'h', 'd'), + MP4TrackFragmentDecodeTimeAtomType = MP4_FOUR_CHAR_CODE('t', 'f', 'd', 't'), + MP4TrackRunAtomType = MP4_FOUR_CHAR_CODE('t', 'r', 'u', 'n'), + MP4ItemPropertiesAtomType = MP4_FOUR_CHAR_CODE('i', 'p', 'r', 'p'), + MP4ItemPropertyContainerAtomType = MP4_FOUR_CHAR_CODE('i', 'p', 'c', 'o'), + MP4ItemPropertyAssociationAtomType = MP4_FOUR_CHAR_CODE('i', 'p', 'm', 'a'), + MP4SampleGroupDescriptionAtomType = MP4_FOUR_CHAR_CODE('s', 'g', 'p', 'd'), + MP4SampletoGroupAtomType = MP4_FOUR_CHAR_CODE('s', 'b', 'g', 'p'), + MP4CompactSampletoGroupAtomType = MP4_FOUR_CHAR_CODE('c', 's', 'g', 'p'), + MP4SampleDependencyAtomType = MP4_FOUR_CHAR_CODE('s', 'd', 't', 'p'), + ISOMetaAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 't', 'a'), + ISOPrimaryItemAtomType = MP4_FOUR_CHAR_CODE('p', 'i', 't', 'm'), + ISOItemLocationAtomType = MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), + ISOItemProtectionAtomType = MP4_FOUR_CHAR_CODE('i', 'p', 'r', 'o'), + ISOItemInfoAtomType = MP4_FOUR_CHAR_CODE('i', 'i', 'n', 'f'), + ISOItemInfoEntryAtomType = MP4_FOUR_CHAR_CODE('i', 'n', 'f', 'e'), + ISOAdditionalMetaDataContainerAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 'c', 'o'), + ISOMetaboxRelationAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 'r', 'e'), + ISOItemDataAtomType = MP4_FOUR_CHAR_CODE('i', 'd', 'a', 't'), + ISOItemReferenceAtomType = MP4_FOUR_CHAR_CODE('i', 'r', 'e', 'f'), + ISOVCConfigAtomType = MP4_FOUR_CHAR_CODE('a', 'v', 'c', 'C'), + ISOHEVCConfigAtomType = MP4_FOUR_CHAR_CODE('h', 'v', 'c', 'C'), + ISOAVCSampleEntryAtomType = MP4_FOUR_CHAR_CODE('a', 'v', 'c', '1'), + ISOHEVCSampleEntryAtomType = MP4_FOUR_CHAR_CODE('h', 'v', 'c', '1'), + ISOLHEVCSampleEntryAtomType = MP4_FOUR_CHAR_CODE('h', 'v', 'c', '2'), + MP4XMLMetaSampleEntryAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 't', 'x'), + MP4TextMetaSampleEntryAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 't', 't'), + MP4AMRSampleEntryAtomType = MP4_FOUR_CHAR_CODE('s', 'a', 'm', 'r'), + MP4AMRSpecificInfoAtomType = MP4_FOUR_CHAR_CODE('d', 'a', 'm', 'r'), + MP4AWBSampleEntryAtomType = MP4_FOUR_CHAR_CODE('s', 'a', 'w', 'b'), + MP4AMRWPSampleEntryAtomType = MP4_FOUR_CHAR_CODE('s', 'a', 'w', 'p'), + MP4AMRWPSpecificInfoAtomType = MP4_FOUR_CHAR_CODE('d', 'a', 'w', 'p'), + MP4H263SampleEntryAtomType = MP4_FOUR_CHAR_CODE('s', '2', '6', '3'), + MP4H263SpecificInfoAtomType = MP4_FOUR_CHAR_CODE('d', '2', '6', '3'), + MP4BitRateAtomType = MP4_FOUR_CHAR_CODE('b', 't', 'r', 't'), + TGPPBitRateAtomType = MP4_FOUR_CHAR_CODE('b', 'i', 't', 'r'), + MP4OriginalFormatAtomType = MP4_FOUR_CHAR_CODE('f', 'r', 'm', 'a'), + MP4SchemeTypeAtomType = MP4_FOUR_CHAR_CODE('s', 'c', 'h', 'm'), + MP4SchemeInfoAtomType = MP4_FOUR_CHAR_CODE('s', 'c', 'h', 'i'), + MP4StereoVideoAtomType = MP4_FOUR_CHAR_CODE('s', 't', 'v', 'i'), + MP4CompatibleSchemeTypeAtomType = MP4_FOUR_CHAR_CODE('c', 's', 'c', 'h'), + MP4RestrictedSchemeInfoAtomType = MP4_FOUR_CHAR_CODE('r', 'i', 'n', 'f'), + MP4StereoVideoGroupAtomType = MP4_FOUR_CHAR_CODE('s', 't', 'e', 'r'), + MP4TrackTypeAtomType = MP4_FOUR_CHAR_CODE('t', 't', 'y', 'p'), + MP4RestrictedVideoSampleEntryAtomType = MP4_FOUR_CHAR_CODE('r', 'e', 's', 'v'), + MP4SegmentTypeAtomType = MP4_FOUR_CHAR_CODE('s', 't', 'y', 'p'), + MP4SegmentIndexAtomType = MP4_FOUR_CHAR_CODE('s', 'i', 'd', 'x'), + MP4SubsegmentIndexAtomType = MP4_FOUR_CHAR_CODE('s', 's', 'i', 'x'), + MP4ProducerReferenceTimeAtomType = MP4_FOUR_CHAR_CODE('p', 'r', 'f', 't') + +}; #ifdef ISMACrypt -enum { - MP4SecurityInfoAtomType = MP4_FOUR_CHAR_CODE( 's', 'i', 'n', 'f' ), - ISMAKMSAtomType = MP4_FOUR_CHAR_CODE( 'i', 'K', 'M', 'S' ), - ISMASampleFormatAtomType = MP4_FOUR_CHAR_CODE( 'i', 'S', 'F', 'M' ), - ISMASaltAtomType = MP4_FOUR_CHAR_CODE( 'i', 'S', 'L', 'T' ), - MP4EncAudioSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 'e', 'n', 'c', 'a' ), - MP4EncVisualSampleEntryAtomType = MP4_FOUR_CHAR_CODE( 'e', 'n', 'c', 'v' ), - ISMACryptAESCounterType = MP4_FOUR_CHAR_CODE( 'i', 'A', 'E', 'C' ) +enum +{ + MP4SecurityInfoAtomType = MP4_FOUR_CHAR_CODE('s', 'i', 'n', 'f'), + ISMAKMSAtomType = MP4_FOUR_CHAR_CODE('i', 'K', 'M', 'S'), + ISMASampleFormatAtomType = MP4_FOUR_CHAR_CODE('i', 'S', 'F', 'M'), + ISMASaltAtomType = MP4_FOUR_CHAR_CODE('i', 'S', 'L', 'T'), + MP4EncAudioSampleEntryAtomType = MP4_FOUR_CHAR_CODE('e', 'n', 'c', 'a'), + MP4EncVisualSampleEntryAtomType = MP4_FOUR_CHAR_CODE('e', 'n', 'c', 'v'), + ISMACryptAESCounterType = MP4_FOUR_CHAR_CODE('i', 'A', 'E', 'C') }; #endif -#define MP4_BASE_ATOM \ - u32 type; \ - u8 uuid[16]; \ - u32 size; \ - u64 size64; \ - u32 bytesRead; \ - u32 bytesWritten; \ - u64 streamOffset; \ - char *name; \ - struct MP4Atom* super; \ - MP4Err (*createFromInputStream)( struct MP4Atom* self, struct MP4Atom* proto, /*struct MP4InputStreamRecord* */ char *inputStream ); \ - char* (*getName)( struct MP4Atom* self ); \ - MP4Err (*serialize)( struct MP4Atom* self, char* buffer ); \ - MP4Err (*calculateSize)( struct MP4Atom* self ); \ - void (*destroy)( struct MP4Atom* self ); +#define MP4_BASE_ATOM \ + u32 type; \ + u8 uuid[16]; \ + u32 size; \ + u64 size64; \ + u32 bytesRead; \ + u32 bytesWritten; \ + u64 streamOffset; \ + char *name; \ + struct MP4Atom *super; \ + MP4Err (*createFromInputStream)(struct MP4Atom * self, struct MP4Atom * proto, \ + /*struct MP4InputStreamRecord* */ char *inputStream); \ + char *(*getName)(struct MP4Atom * self); \ + MP4Err (*serialize)(struct MP4Atom * self, char *buffer); \ + MP4Err (*calculateSize)(struct MP4Atom * self); \ + void (*destroy)(struct MP4Atom * self); #define MP4_FULL_ATOM \ - MP4_BASE_ATOM \ - u32 version; \ - u32 flags; - + MP4_BASE_ATOM \ + u32 version; \ + u32 flags; typedef struct MP4Atom { - MP4_BASE_ATOM + MP4_BASE_ATOM } MP4Atom, *MP4AtomPtr; typedef struct MP4FullAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM } MP4FullAtom, *MP4FullAtomPtr; -typedef MP4Err (*cisfunc)( struct MP4Atom* self, struct MP4Atom* proto, char *inputStream ); +typedef MP4Err (*cisfunc)(struct MP4Atom *self, struct MP4Atom *proto, char *inputStream); typedef struct MP4PrivateMovieRecord { - u32 referenceCount; - struct FileMappingObjectRecord *fileMappingObject; - struct MP4InputStreamRecord *inputStream; - MP4AtomPtr moovAtomPtr; /* might be a moof or a moov */ - MP4AtomPtr true_moov; - - MP4AtomPtr mdat; /* first, primary, mdat */ - MP4LinkedList mdatList; /* all the others we find */ - /*MP4Track initialBIFS;*/ - /*MP4Track initialOD; */ - u32 fileType; /* the file type: MPEG-4, Motion JPEG-2000, or QuickTime */ - MP4AtomPtr ftyp; /* the file type atom */ - MP4AtomPtr jp2h; /* for JPEG-2000, the JP2 header atom */ - MP4AtomPtr sgnt; /* for JPEG-2000, the signature atom */ - MP4AtomPtr meta; /* file-level meta-data */ - MP4AtomPtr meco; /* file-level additional meta-data container */ - - void *inMemoryDataHandler; - MP4Handle prepend_handle; - MP4LinkedList movieFragments; + u32 referenceCount; + struct FileMappingObjectRecord *fileMappingObject; + struct MP4InputStreamRecord *inputStream; + MP4AtomPtr moovAtomPtr; /* might be a moof or a moov */ + MP4AtomPtr true_moov; + + MP4AtomPtr mdat; /* first, primary, mdat */ + MP4LinkedList mdatList; /* all the others we find */ + /*MP4Track initialBIFS;*/ + /*MP4Track initialOD; */ + u32 fileType; /* the file type: MPEG-4, Motion JPEG-2000, or QuickTime */ + MP4AtomPtr ftyp; /* the file type atom */ + MP4AtomPtr jp2h; /* for JPEG-2000, the JP2 header atom */ + MP4AtomPtr sgnt; /* for JPEG-2000, the signature atom */ + MP4AtomPtr meta; /* file-level meta-data */ + MP4AtomPtr meco; /* file-level additional meta-data container */ + + void *inMemoryDataHandler; + MP4Handle prepend_handle; + MP4LinkedList movieFragments; } MP4PrivateMovieRecord, *MP4PrivateMovieRecordPtr; -MP4Err MP4CreateAtom( u32 atomType, MP4AtomPtr *outAtom ); -MP4Err MP4CreateBaseAtom( MP4AtomPtr self ); -MP4Err MP4CreateFullAtom( MP4AtomPtr s ); -MP4Err MP4ParseAtom( struct MP4InputStreamRecord* inputStream, MP4AtomPtr *outAtom ); -MP4Err MP4ParseAtomUsingProtoList( struct MP4InputStreamRecord* inputStream, u32* protoList, u32 defaultAtom, MP4AtomPtr *outAtom ); -MP4Err MP4SerializeCommonBaseAtomFields( struct MP4Atom* self, char* buffer ); -MP4Err MP4SerializeCommonFullAtomFields( struct MP4FullAtom* self, char* buffer ); -MP4Err MP4CalculateBaseAtomFieldSize( struct MP4Atom* self ); -MP4Err MP4CalculateFullAtomFieldSize( struct MP4FullAtom* self ); -MP4Err MP4FindGroupAtom( MP4LinkedList theList, u32 type, MP4AtomPtr* theAtom ); +MP4Err MP4CreateAtom(u32 atomType, MP4AtomPtr *outAtom); +MP4Err MP4CreateBaseAtom(MP4AtomPtr self); +MP4Err MP4CreateFullAtom(MP4AtomPtr s); +MP4Err MP4ParseAtom(struct MP4InputStreamRecord *inputStream, MP4AtomPtr *outAtom); +MP4Err MP4ParseAtomUsingProtoList(struct MP4InputStreamRecord *inputStream, u32 *protoList, + u32 defaultAtom, MP4AtomPtr *outAtom); +MP4Err MP4SerializeCommonBaseAtomFields(struct MP4Atom *self, char *buffer); +MP4Err MP4SerializeCommonFullAtomFields(struct MP4FullAtom *self, char *buffer); +MP4Err MP4CalculateBaseAtomFieldSize(struct MP4Atom *self); +MP4Err MP4CalculateFullAtomFieldSize(struct MP4FullAtom *self); +MP4Err MP4FindGroupAtom(MP4LinkedList theList, u32 type, MP4AtomPtr *theAtom); -void MP4TypeToString( u32 inType, char* ioStr ); +void MP4TypeToString(u32 inType, char *ioStr); typedef struct MP4MediaDataAtom { - MP4_BASE_ATOM - MP4Err (*addData)( struct MP4MediaDataAtom *self, MP4Handle dataH ); - MP4Err (*writeToFile)( struct MP4MediaDataAtom *self, FILE *fd ); - MP4Err (*addMdat)( struct MP4MediaDataAtom *self, struct MP4MediaDataAtom *other_mdat ); + MP4_BASE_ATOM + MP4Err (*addData)(struct MP4MediaDataAtom *self, MP4Handle dataH); + MP4Err (*writeToFile)(struct MP4MediaDataAtom *self, FILE *fd); + MP4Err (*addMdat)(struct MP4MediaDataAtom *self, struct MP4MediaDataAtom *other_mdat); - char *data; - u64 dataSize; - u64 dataOffset; - u32 allocatedSize; + char *data; + u64 dataSize; + u64 dataOffset; + u32 allocatedSize; } MP4MediaDataAtom, *MP4MediaDataAtomPtr; typedef struct MP4UnknownAtom { - MP4_BASE_ATOM - char *data; - u32 dataSize; + MP4_BASE_ATOM + char *data; + u32 dataSize; } MP4UnknownAtom, *MP4UnknownAtomPtr; -#define COMMON_MOVIE_ATOM_FIELDS \ - MP4Err (*mdatMoved)( struct MP4MovieAtom* self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ); \ - MP4Err (*calculateDuration)( struct MP4MovieAtom* self ); \ - \ - MP4AtomPtr iods; - /* the initial object descriptor */ +#define COMMON_MOVIE_ATOM_FIELDS \ + MP4Err (*mdatMoved)(struct MP4MovieAtom * self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset); \ + MP4Err (*calculateDuration)(struct MP4MovieAtom * self); \ + \ + MP4AtomPtr iods; +/* the initial object descriptor */ typedef struct MP4MovieAtom { - MP4_BASE_ATOM - COMMON_MOVIE_ATOM_FIELDS - MP4Err (*setupTracks)( struct MP4MovieAtom* self, MP4PrivateMovieRecordPtr moov ); - u32 (*getTrackCount)( struct MP4MovieAtom* self ); - MP4Err (*getIndTrack)( struct MP4MovieAtom* self, u32 trackNumber, MP4AtomPtr *outTrack ); - MP4Err (*addAtom)( struct MP4MovieAtom* self, MP4AtomPtr atom ); - MP4Err (*getNextTrackID)( struct MP4MovieAtom* self, u32 *outID ); - MP4Err (*addTrack)( struct MP4MovieAtom* self, MP4AtomPtr track ); - MP4Err (*newTrack)( struct MP4MovieAtom* self, u32 newTrackFlags, MP4AtomPtr *outTrack ); - MP4Err (*newTrackWithID)( struct MP4MovieAtom* self, u32 newTrackFlags, u32 newTrackID, MP4AtomPtr *outTrack ); - MP4Err (*setTimeScale)( struct MP4MovieAtom* self, u32 timeScale ); - MP4Err (*getTimeScale)( struct MP4MovieAtom* self, u32 *outTimeScale ); - MP4Err (*setMatrix)( struct MP4MovieAtom* self, u32 matrix[9] ); - MP4Err (*getMatrix)( struct MP4MovieAtom* self, u32 outMatrix[9] ); - MP4Err (*setPreferredRate)( struct MP4MovieAtom* self, u32 rate ); - MP4Err (*getPreferredRate)( struct MP4MovieAtom* self, u32 *outRate ); - MP4Err (*setPreferredVolume)( struct MP4MovieAtom* self, s16 volume ); - MP4Err (*getPreferredVolume)( struct MP4MovieAtom* self, s16 *outVolume ); - MP4Err (*settrackfragment) (struct MP4MovieAtom *self, u32 trackID, MP4AtomPtr fragment ); - MP4Err (*getTrackExtendsAtom)( struct MP4MovieAtom* self, u32 trackID, MP4AtomPtr *outTrack ); - MP4Err (*getTrackMedia)( struct MP4MovieAtom* self, u32 trackID, MP4AtomPtr *outMedia ); - MP4Err (*mdatArrived)( struct MP4MovieAtom *self, MP4AtomPtr mdat ); - MP4Err (*getSampleDescriptionIndex)(struct MP4MovieAtom *self, u32 trackID, u32* sd_index ); - - - MP4AtomPtr mvhd; /* the movie header */ - MP4AtomPtr udta; /* user data */ - MP4AtomPtr mvex; /* movie extends atom */ - MP4AtomPtr meta; - MP4AtomPtr meco; /* additional meta-data container */ - MP4PrivateMovieRecordPtr moov; - MP4LinkedList atomList; - MP4LinkedList trackList; + MP4_BASE_ATOM + COMMON_MOVIE_ATOM_FIELDS + MP4Err (*setupTracks)(struct MP4MovieAtom *self, MP4PrivateMovieRecordPtr moov); + u32 (*getTrackCount)(struct MP4MovieAtom *self); + MP4Err (*getIndTrack)(struct MP4MovieAtom *self, u32 trackNumber, MP4AtomPtr *outTrack); + MP4Err (*addAtom)(struct MP4MovieAtom *self, MP4AtomPtr atom); + MP4Err (*getNextTrackID)(struct MP4MovieAtom *self, u32 *outID); + MP4Err (*addTrack)(struct MP4MovieAtom *self, MP4AtomPtr track); + MP4Err (*newTrack)(struct MP4MovieAtom *self, u32 newTrackFlags, MP4AtomPtr *outTrack); + MP4Err (*newTrackWithID)(struct MP4MovieAtom *self, u32 newTrackFlags, u32 newTrackID, + MP4AtomPtr *outTrack); + MP4Err (*setTimeScale)(struct MP4MovieAtom *self, u32 timeScale); + MP4Err (*getTimeScale)(struct MP4MovieAtom *self, u32 *outTimeScale); + MP4Err (*setMatrix)(struct MP4MovieAtom *self, u32 matrix[9]); + MP4Err (*getMatrix)(struct MP4MovieAtom *self, u32 outMatrix[9]); + MP4Err (*setPreferredRate)(struct MP4MovieAtom *self, u32 rate); + MP4Err (*getPreferredRate)(struct MP4MovieAtom *self, u32 *outRate); + MP4Err (*setPreferredVolume)(struct MP4MovieAtom *self, s16 volume); + MP4Err (*getPreferredVolume)(struct MP4MovieAtom *self, s16 *outVolume); + MP4Err (*settrackfragment)(struct MP4MovieAtom *self, u32 trackID, MP4AtomPtr fragment); + MP4Err (*getTrackExtendsAtom)(struct MP4MovieAtom *self, u32 trackID, MP4AtomPtr *outTrack); + MP4Err (*getTrackMedia)(struct MP4MovieAtom *self, u32 trackID, MP4AtomPtr *outMedia); + MP4Err (*mdatArrived)(struct MP4MovieAtom *self, MP4AtomPtr mdat); + MP4Err (*getSampleDescriptionIndex)(struct MP4MovieAtom *self, u32 trackID, u32 *sd_index); + + MP4AtomPtr mvhd; /* the movie header */ + MP4AtomPtr udta; /* user data */ + MP4AtomPtr mvex; /* movie extends atom */ + MP4AtomPtr meta; + MP4AtomPtr meco; /* additional meta-data container */ + MP4PrivateMovieRecordPtr moov; + MP4LinkedList atomList; + MP4LinkedList trackList; } MP4MovieAtom, *MP4MovieAtomPtr; typedef struct MP4MovieHeaderAtom { - MP4_FULL_ATOM - u64 creationTime; - u64 modificationTime; - u32 timeScale; - u64 duration; - u32 qt_preferredRate; - u32 qt_preferredVolume; - char qt_reserved[10]; - u32 qt_matrixA; - u32 qt_matrixB; - u32 qt_matrixU; - u32 qt_matrixC; - u32 qt_matrixD; - u32 qt_matrixV; - u32 qt_matrixX; - u32 qt_matrixY; - u32 qt_matrixW; - u32 qt_previewTime; - u32 qt_previewDuration; - u32 qt_posterTime; - u32 qt_selectionTime; - u32 qt_selectionDuration; - u32 qt_currentTime; - u32 nextTrackID; + MP4_FULL_ATOM + u64 creationTime; + u64 modificationTime; + u32 timeScale; + u64 duration; + u32 qt_preferredRate; + u32 qt_preferredVolume; + char qt_reserved[10]; + u32 qt_matrixA; + u32 qt_matrixB; + u32 qt_matrixU; + u32 qt_matrixC; + u32 qt_matrixD; + u32 qt_matrixV; + u32 qt_matrixX; + u32 qt_matrixY; + u32 qt_matrixW; + u32 qt_previewTime; + u32 qt_previewDuration; + u32 qt_posterTime; + u32 qt_selectionTime; + u32 qt_selectionDuration; + u32 qt_currentTime; + u32 nextTrackID; } MP4MovieHeaderAtom, *MP4MovieHeaderAtomPtr; typedef struct MP4ObjectDescriptorAtom { - MP4_FULL_ATOM - MP4Err (*setDescriptor)( struct MP4Atom* self, /*struct MP4DescriptorRecord */ char * desc ); - u32 ODSize; - struct MP4DescriptorRecord* descriptor; + MP4_FULL_ATOM + MP4Err (*setDescriptor)(struct MP4Atom *self, /*struct MP4DescriptorRecord */ char *desc); + u32 ODSize; + struct MP4DescriptorRecord *descriptor; } MP4ObjectDescriptorAtom, *MP4ObjectDescriptorAtomPtr; typedef struct MP4TrackAtom { - MP4_BASE_ATOM - MP4PrivateMovieRecordPtr moov; - MP4Err (*addAtom)( struct MP4TrackAtom* self, MP4AtomPtr atom ); - MP4Err (*setMoov)( struct MP4TrackAtom *self, MP4PrivateMovieRecordPtr moov ); - MP4Err (*setMdat)( struct MP4TrackAtom *self, MP4AtomPtr mdat ); - MP4Err (*newMedia)( struct MP4TrackAtom *self, MP4Media *outMedia, u32 mediaType, u32 timeScale, MP4Handle dataURL ); - MP4Err (*setEnabled)( struct MP4TrackAtom *self, u32 enabled ); - MP4Err (*getEnabled)( struct MP4TrackAtom *self, u32 *outEnabled ); - MP4Err (*calculateDuration)( struct MP4TrackAtom *self, u32 movieTimeScale ); - MP4Err (*getDuration)( struct MP4TrackAtom *self, u32 *outDuration ); - MP4Err (*setMatrix)( struct MP4TrackAtom* self, u32 matrix[9] ); - MP4Err (*getMatrix)( struct MP4TrackAtom* self, u32 outMatrix[9] ); - MP4Err (*setLayer)( struct MP4TrackAtom* self, s16 layer ); - MP4Err (*getLayer)( struct MP4TrackAtom* self, s16 *outLayer ); - MP4Err (*setDimensions)( struct MP4TrackAtom* self, u32 width, u32 height ); - MP4Err (*getDimensions)( struct MP4TrackAtom* self, u32 *outWidth, u32 *outHeight ); - MP4Err (*setVolume)( struct MP4TrackAtom* self, s16 volume ); - MP4Err (*getVolume)( struct MP4TrackAtom* self, s16 *outVolume ); - MP4Err (*mdatMoved)( struct MP4TrackAtom* self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ); - MP4Err (*mdatArrived)( struct MP4TrackAtom *self, MP4AtomPtr mdat ); - MP4Err (*settrackfragment) (struct MP4TrackAtom *self, u32 trackID, MP4AtomPtr fragment ); - - u32 newTrackFlags; - MP4AtomPtr mdat; - MP4AtomPtr udta; - MP4AtomPtr trackHeader; - MP4AtomPtr trackMedia; - MP4AtomPtr trackEditAtom; - MP4AtomPtr trackReferences; - MP4AtomPtr trackGroups; - MP4AtomPtr meta; - MP4AtomPtr meco; /* additional meta-data container */ - MP4LinkedList atomList; + MP4_BASE_ATOM + MP4PrivateMovieRecordPtr moov; + MP4Err (*addAtom)(struct MP4TrackAtom *self, MP4AtomPtr atom); + MP4Err (*setMoov)(struct MP4TrackAtom *self, MP4PrivateMovieRecordPtr moov); + MP4Err (*setMdat)(struct MP4TrackAtom *self, MP4AtomPtr mdat); + MP4Err (*newMedia)(struct MP4TrackAtom *self, MP4Media *outMedia, u32 mediaType, u32 timeScale, + MP4Handle dataURL); + MP4Err (*setEnabled)(struct MP4TrackAtom *self, u32 enabled); + MP4Err (*getEnabled)(struct MP4TrackAtom *self, u32 *outEnabled); + MP4Err (*calculateDuration)(struct MP4TrackAtom *self, u32 movieTimeScale); + MP4Err (*getDuration)(struct MP4TrackAtom *self, u32 *outDuration); + MP4Err (*setMatrix)(struct MP4TrackAtom *self, u32 matrix[9]); + MP4Err (*getMatrix)(struct MP4TrackAtom *self, u32 outMatrix[9]); + MP4Err (*setLayer)(struct MP4TrackAtom *self, s16 layer); + MP4Err (*getLayer)(struct MP4TrackAtom *self, s16 *outLayer); + MP4Err (*setDimensions)(struct MP4TrackAtom *self, u32 width, u32 height); + MP4Err (*getDimensions)(struct MP4TrackAtom *self, u32 *outWidth, u32 *outHeight); + MP4Err (*setVolume)(struct MP4TrackAtom *self, s16 volume); + MP4Err (*getVolume)(struct MP4TrackAtom *self, s16 *outVolume); + MP4Err (*mdatMoved)(struct MP4TrackAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset); + MP4Err (*mdatArrived)(struct MP4TrackAtom *self, MP4AtomPtr mdat); + MP4Err (*settrackfragment)(struct MP4TrackAtom *self, u32 trackID, MP4AtomPtr fragment); + + u32 newTrackFlags; + MP4AtomPtr mdat; + MP4AtomPtr udta; + MP4AtomPtr trackHeader; + MP4AtomPtr trackMedia; + MP4AtomPtr trackEditAtom; + MP4AtomPtr trackReferences; + MP4AtomPtr trackGroups; + MP4AtomPtr meta; + MP4AtomPtr meco; /* additional meta-data container */ + MP4LinkedList atomList; } MP4TrackAtom, *MP4TrackAtomPtr; typedef struct MP4TrackHeaderAtom { - MP4_FULL_ATOM - u64 creationTime; - u64 modificationTime; - u32 trackID; - u32 qt_reserved1; - u64 duration; - char qt_reserved2[8]; - u32 qt_layer; - u32 qt_alternateGroup; - u32 qt_volume; - u32 qt_reserved3; - u32 qt_matrixA; - u32 qt_matrixB; - u32 qt_matrixU; - u32 qt_matrixC; - u32 qt_matrixD; - u32 qt_matrixV; - u32 qt_matrixX; - u32 qt_matrixY; - u32 qt_matrixW; - u32 qt_trackWidth; - u32 qt_trackHeight; + MP4_FULL_ATOM + u64 creationTime; + u64 modificationTime; + u32 trackID; + u32 qt_reserved1; + u64 duration; + char qt_reserved2[8]; + u32 qt_layer; + u32 qt_alternateGroup; + u32 qt_volume; + u32 qt_reserved3; + u32 qt_matrixA; + u32 qt_matrixB; + u32 qt_matrixU; + u32 qt_matrixC; + u32 qt_matrixD; + u32 qt_matrixV; + u32 qt_matrixX; + u32 qt_matrixY; + u32 qt_matrixW; + u32 qt_trackWidth; + u32 qt_trackHeight; } MP4TrackHeaderAtom, *MP4TrackHeaderAtomPtr; typedef struct MP4TrackReferenceAtom { - MP4_BASE_ATOM - MP4Err (*addAtom)( struct MP4TrackReferenceAtom *self, MP4AtomPtr atom ); - MP4Err (*findAtomOfType)( struct MP4TrackReferenceAtom *self, u32 atomType, MP4AtomPtr *outAtom ); - MP4LinkedList atomList; + MP4_BASE_ATOM + MP4Err (*addAtom)(struct MP4TrackReferenceAtom *self, MP4AtomPtr atom); + MP4Err (*findAtomOfType)(struct MP4TrackReferenceAtom *self, u32 atomType, MP4AtomPtr *outAtom); + MP4LinkedList atomList; } MP4TrackReferenceAtom, *MP4TrackReferenceAtomPtr; -typedef struct MP4TrackGroupAtom { - MP4_BASE_ATOM - MP4Err(*addAtom)(struct MP4TrackGroupAtom *self, MP4AtomPtr atom); - MP4Err(*findAtomOfType)(struct MP4TrackGroupAtom *self, u32 atomType, MP4AtomPtr *outAtom); - MP4LinkedList atomList; +typedef struct MP4TrackGroupAtom +{ + MP4_BASE_ATOM + MP4Err (*addAtom)(struct MP4TrackGroupAtom *self, MP4AtomPtr atom); + MP4Err (*findAtomOfType)(struct MP4TrackGroupAtom *self, u32 atomType, MP4AtomPtr *outAtom); + MP4LinkedList atomList; } MP4TrackGroupAtom, *MP4TrackGroupAtomPtr; typedef struct MP4MediaAtom { - MP4_BASE_ATOM - MP4Err (*setupNew)( struct MP4MediaAtom *self, MP4AtomPtr track, u32 mediaType, u32 timeScale, MP4Handle dataHandlerH ); - MP4Err (*addSampleReference)( struct MP4MediaAtom *self, u64 dataOffset, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ); - MP4Err (*addSamples)( struct MP4MediaAtom *self, MP4Handle sampleH, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ); - MP4Err (*calculateDuration)( struct MP4MediaAtom *self ); - MP4Err (*mdatMoved)( struct MP4MediaAtom* self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ); - MP4Err (*setfieldsize)( struct MP4MediaAtom* self, u32 fieldsize ); - MP4Err (*settrackfragment) (struct MP4MediaAtom *self, MP4AtomPtr fragment ); - MP4Err (*addGroupDescription)(struct MP4MediaAtom *self, u32 groupType, MP4Handle description, u32 *index ); - MP4Err (*mapSamplestoGroup)(struct MP4MediaAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count ); - MP4Err (*getSampleGroupMap)(struct MP4MediaAtom *self, u32 groupType, u32 sample_number, u32* group_index ); - MP4Err (*getGroupDescription)(struct MP4MediaAtom *self, u32 groupType, u32 index, MP4Handle description ); - - MP4Err (*setSampleDependency)( struct MP4MediaAtom *self, s32 sample_index, MP4Handle dependencies ); - MP4Err (*getSampleDependency)( struct MP4MediaAtom *self, u32 sampleNumber, u8* dependency ); - - MP4Err (*extendLastSampleDuration)( struct MP4MediaAtom *self, u32 duration ); - MP4Err (*setSampleEntry)( struct MP4MediaAtom *self, MP4AtomPtr entry ); - MP4Err (*setExtendedLanguageTag)( struct MP4MediaAtom *self, MP4AtomPtr tag ); - - MP4AtomPtr mediaTrack; - MP4AtomPtr mediaHeader; - MP4AtomPtr handler; - MP4AtomPtr information; /* might be a minf or traf */ - MP4AtomPtr extendedLanguageTag; - MP4LinkedList atomList; - MP4AtomPtr true_minf; - u32 enableCompactSamples; + MP4_BASE_ATOM + MP4Err (*setupNew)(struct MP4MediaAtom *self, MP4AtomPtr track, u32 mediaType, u32 timeScale, + MP4Handle dataHandlerH); + MP4Err (*addSampleReference)(struct MP4MediaAtom *self, u64 dataOffset, u32 sampleCount, + MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, + MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH); + MP4Err (*addSamples)(struct MP4MediaAtom *self, MP4Handle sampleH, u32 sampleCount, + MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, + MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH); + MP4Err (*calculateDuration)(struct MP4MediaAtom *self); + MP4Err (*mdatMoved)(struct MP4MediaAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset); + MP4Err (*setfieldsize)(struct MP4MediaAtom *self, u32 fieldsize); + MP4Err (*settrackfragment)(struct MP4MediaAtom *self, MP4AtomPtr fragment); + MP4Err (*addGroupDescription)(struct MP4MediaAtom *self, u32 groupType, MP4Handle description, + u32 *index); + MP4Err (*mapSamplestoGroup)(struct MP4MediaAtom *self, u32 groupType, u32 group_index, + s32 sample_index, u32 count); + MP4Err (*getSampleGroupMap)(struct MP4MediaAtom *self, u32 groupType, u32 sample_number, + u32 *group_index); + MP4Err (*getGroupDescription)(struct MP4MediaAtom *self, u32 groupType, u32 index, + MP4Handle description); + + MP4Err (*setSampleDependency)(struct MP4MediaAtom *self, s32 sample_index, + MP4Handle dependencies); + MP4Err (*getSampleDependency)(struct MP4MediaAtom *self, u32 sampleNumber, u8 *dependency); + + MP4Err (*extendLastSampleDuration)(struct MP4MediaAtom *self, u32 duration); + MP4Err (*setSampleEntry)(struct MP4MediaAtom *self, MP4AtomPtr entry); + MP4Err (*setExtendedLanguageTag)(struct MP4MediaAtom *self, MP4AtomPtr tag); + + MP4AtomPtr mediaTrack; + MP4AtomPtr mediaHeader; + MP4AtomPtr handler; + MP4AtomPtr information; /* might be a minf or traf */ + MP4AtomPtr extendedLanguageTag; + MP4LinkedList atomList; + MP4AtomPtr true_minf; + u32 enableCompactSamples; } MP4MediaAtom, *MP4MediaAtomPtr; typedef struct MP4MediaHeaderAtom { - MP4_FULL_ATOM - u64 creationTime; - u64 modificationTime; - u32 timeScale; - u64 duration; - u32 packedLanguage; - u32 qt_quality; + MP4_FULL_ATOM + u64 creationTime; + u64 modificationTime; + u32 timeScale; + u64 duration; + u32 packedLanguage; + u32 qt_quality; } MP4MediaHeaderAtom, *MP4MediaHeaderAtomPtr; typedef struct MP4HandlerAtom { - MP4_FULL_ATOM - MP4Err (*setName)( struct MP4Atom* s, char* name, u32 is_qt ); - u32 nameLength; - u32 qt_componentType; - u32 handlerType; - u32 qt_componentManufacturer; - u32 qt_componentFlags; - u32 qt_componentFlagsMask; - char *nameUTF8; - u32 is_qt; + MP4_FULL_ATOM + MP4Err (*setName)(struct MP4Atom *s, char *name, u32 is_qt); + u32 nameLength; + u32 qt_componentType; + u32 handlerType; + u32 qt_componentManufacturer; + u32 qt_componentFlags; + u32 qt_componentFlagsMask; + char *nameUTF8; + u32 is_qt; } MP4HandlerAtom, *MP4HandlerAtomPtr; typedef struct MP4ExtendedLanguageTag { - MP4_FULL_ATOM - char *extended_language; + MP4_FULL_ATOM + char *extended_language; } MP4ExtendedLanguageTagAtom, *MP4ExtendedLanguageTagAtomPtr; - -#define COMMON_MINF_ATOM_FIELDS \ - MP4Err (*addSampleReference)( struct MP4MediaInformationAtom *self, u64 dataOffset, u32 sampleCount, \ - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, \ - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ); \ - MP4Err (*addSamples)( struct MP4MediaInformationAtom *self, MP4Handle sampleH, \ - u32 sampleCount, MP4Handle durationsH, MP4Handle sizesH, \ - MP4Handle sampleEntryH, \ - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ); \ - MP4Err (*mdatMoved)( struct MP4MediaInformationAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ); \ - MP4Err (*mapSamplestoGroup)(struct MP4MediaInformationAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ); \ - MP4Err (*setSampleDependency)( struct MP4MediaInformationAtom *self, s32 sample_index, MP4Handle dependencies ); +#define COMMON_MINF_ATOM_FIELDS \ + MP4Err (*addSampleReference)(struct MP4MediaInformationAtom * self, u64 dataOffset, \ + u32 sampleCount, MP4Handle durationsH, MP4Handle sizesH, \ + MP4Handle sampleEntryH, MP4Handle decodingOffsetsH, \ + MP4Handle syncSamplesH, MP4Handle padsH); \ + MP4Err (*addSamples)(struct MP4MediaInformationAtom * self, MP4Handle sampleH, u32 sampleCount, \ + MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, \ + MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH); \ + MP4Err (*mdatMoved)(struct MP4MediaInformationAtom * self, u64 mdatBase, u64 mdatEnd, \ + s32 mdatOffset); \ + MP4Err (*mapSamplestoGroup)(struct MP4MediaInformationAtom * self, u32 groupType, \ + u32 group_index, s32 sample_index, u32 count, \ + u32 enableCompactSamples); \ + MP4Err (*setSampleDependency)(struct MP4MediaInformationAtom * self, s32 sample_index, \ + MP4Handle dependencies); typedef struct MP4MediaInformationAtom { - MP4_FULL_ATOM - COMMON_MINF_ATOM_FIELDS - MP4Err (*closeDataHandler)( MP4AtomPtr self ); - MP4Err (*openDataHandler)( MP4AtomPtr self, u32 dataEntryIndex ); - MP4Err (*setupNewMedia)( struct MP4MediaInformationAtom *self, u32 mediaType, MP4Handle dataH, MP4AtomPtr mdat ); - MP4Err (*getMediaDuration)( struct MP4MediaInformationAtom *self, u32 *outDuration ); - MP4Err (*setfieldsize)( struct MP4MediaInformationAtom* self, u32 fieldsize); - MP4Err (*testDataEntry)( struct MP4MediaInformationAtom *self, u32 dataEntryIndex ); - MP4Err (*mdatArrived)( struct MP4MediaInformationAtom *self, MP4AtomPtr mdat ); - MP4Err (*addGroupDescription)(struct MP4MediaInformationAtom *self, u32 groupType, MP4Handle description, u32 *index ); - MP4Err (*getSampleGroupMap)(struct MP4MediaInformationAtom *self, u32 groupType, u32 sample_number, u32* group_index ); - MP4Err (*getGroupDescription)(struct MP4MediaInformationAtom *self, u32 groupType, u32 index, MP4Handle description ); - MP4Err (*getSampleDependency)( struct MP4MediaInformationAtom *self, u32 sampleNumber, u8* dependency ); - MP4Err (*extendLastSampleDuration)( struct MP4MediaInformationAtom *self, u32 duration ); - MP4Err (*setSampleEntry)( struct MP4MediaInformationAtom *self, MP4AtomPtr entry ); - - MP4AtomPtr dataInformation; - MP4AtomPtr sampleTable; - MP4AtomPtr mediaHeader; - struct MP4InputStreamRecord* inputStream; - void *dataHandler; - u32 dataEntryIndex; - MP4LinkedList atomList; + MP4_FULL_ATOM + COMMON_MINF_ATOM_FIELDS + MP4Err (*closeDataHandler)(MP4AtomPtr self); + MP4Err (*openDataHandler)(MP4AtomPtr self, u32 dataEntryIndex); + MP4Err (*setupNewMedia)(struct MP4MediaInformationAtom *self, u32 mediaType, MP4Handle dataH, + MP4AtomPtr mdat); + MP4Err (*getMediaDuration)(struct MP4MediaInformationAtom *self, u32 *outDuration); + MP4Err (*setfieldsize)(struct MP4MediaInformationAtom *self, u32 fieldsize); + MP4Err (*testDataEntry)(struct MP4MediaInformationAtom *self, u32 dataEntryIndex); + MP4Err (*mdatArrived)(struct MP4MediaInformationAtom *self, MP4AtomPtr mdat); + MP4Err (*addGroupDescription)(struct MP4MediaInformationAtom *self, u32 groupType, + MP4Handle description, u32 *index); + MP4Err (*getSampleGroupMap)(struct MP4MediaInformationAtom *self, u32 groupType, + u32 sample_number, u32 *group_index); + MP4Err (*getGroupDescription)(struct MP4MediaInformationAtom *self, u32 groupType, u32 index, + MP4Handle description); + MP4Err (*getSampleDependency)(struct MP4MediaInformationAtom *self, u32 sampleNumber, + u8 *dependency); + MP4Err (*extendLastSampleDuration)(struct MP4MediaInformationAtom *self, u32 duration); + MP4Err (*setSampleEntry)(struct MP4MediaInformationAtom *self, MP4AtomPtr entry); + + MP4AtomPtr dataInformation; + MP4AtomPtr sampleTable; + MP4AtomPtr mediaHeader; + struct MP4InputStreamRecord *inputStream; + void *dataHandler; + u32 dataEntryIndex; + MP4LinkedList atomList; } MP4MediaInformationAtom, *MP4MediaInformationAtomPtr; typedef struct MP4VideoMediaHeaderAtom { - MP4_FULL_ATOM - u32 graphicsMode; - u32 opColorRed; - u32 opColorGreen; - u32 opColorBlue; + MP4_FULL_ATOM + u32 graphicsMode; + u32 opColorRed; + u32 opColorGreen; + u32 opColorBlue; } MP4VideoMediaHeaderAtom, *MP4VideoMediaHeaderAtomPtr; typedef struct MP4SoundMediaHeaderAtom { - MP4_FULL_ATOM - u32 balance; - u32 reserved; + MP4_FULL_ATOM + u32 balance; + u32 reserved; } MP4SoundMediaHeaderAtom, *MP4SoundMediaHeaderAtomPtr; typedef struct MP4HintMediaHeaderAtom { - MP4_FULL_ATOM - u32 maxPDUSize; - u32 avgPDUSize; - u32 maxBitrate; - u32 avgBitrate; - u32 slidingAverageBitrate; + MP4_FULL_ATOM + u32 maxPDUSize; + u32 avgPDUSize; + u32 maxBitrate; + u32 avgBitrate; + u32 slidingAverageBitrate; } MP4HintMediaHeaderAtom, *MP4HintMediaHeaderAtomPtr; typedef struct MP4MPEGMediaHeaderAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM } MP4MPEGMediaHeaderAtom, *MP4MPEGMediaHeaderAtomPtr; typedef struct MP4ObjectDescriptorMediaHeaderAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM } MP4ObjectDescriptorMediaHeaderAtom, *MP4ObjectDescriptorMediaHeaderAtomPtr; typedef struct MP4ClockReferenceMediaHeaderAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM } MP4ClockReferenceMediaHeaderAtom, *MP4ClockReferenceMediaHeaderAtomPtr; typedef struct MP4SceneDescriptionMediaHeaderAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM } MP4SceneDescriptionMediaHeaderAtom, *MP4SceneDescriptionMediaHeaderAtomPtr; typedef struct MP4DataInformationAtom { - MP4_BASE_ATOM - MP4Err (*getOffset)( struct MP4DataInformationAtom *self, u32 dataReferenceIndex, u64 *outOffset ); - MP4Err (*addSampleReference)( struct MP4DataInformationAtom *self, u32 sampleCount, u32 dataReferenceIndex, u64 dataOffset, MP4Handle sizesH ); - MP4Err (*addSamples)( struct MP4DataInformationAtom *self, u32 sampleCount, u32 dataReferenceIndex, MP4Handle sampleH ); - MP4Err (*addAtom)( struct MP4DataInformationAtom *self, MP4AtomPtr atom ); + MP4_BASE_ATOM + MP4Err (*getOffset)(struct MP4DataInformationAtom *self, u32 dataReferenceIndex, u64 *outOffset); + MP4Err (*addSampleReference)(struct MP4DataInformationAtom *self, u32 sampleCount, + u32 dataReferenceIndex, u64 dataOffset, MP4Handle sizesH); + MP4Err (*addSamples)(struct MP4DataInformationAtom *self, u32 sampleCount, u32 dataReferenceIndex, + MP4Handle sampleH); + MP4Err (*addAtom)(struct MP4DataInformationAtom *self, MP4AtomPtr atom); - MP4AtomPtr dataReference; - MP4LinkedList atomList; + MP4AtomPtr dataReference; + MP4LinkedList atomList; } MP4DataInformationAtom, *MP4DataInformationAtomPtr; -#define COMMON_DATAENTRY_ATOM_FIELDS \ - MP4Err (*getOffset)( struct MP4DataEntryAtom *self, u64 *outOffset ); \ - MP4Err (*addSampleReference)( struct MP4DataEntryAtom *self, u64 dataOffset, MP4Handle sizesH ); \ - MP4Err (*addSamples)( struct MP4DataEntryAtom *self, MP4Handle sampleH ); \ - \ - MP4AtomPtr mdat; \ - u64 offset; \ - u32 locationLength; \ - char* location; +#define COMMON_DATAENTRY_ATOM_FIELDS \ + MP4Err (*getOffset)(struct MP4DataEntryAtom * self, u64 * outOffset); \ + MP4Err (*addSampleReference)(struct MP4DataEntryAtom * self, u64 dataOffset, MP4Handle sizesH); \ + MP4Err (*addSamples)(struct MP4DataEntryAtom * self, MP4Handle sampleH); \ + \ + MP4AtomPtr mdat; \ + u64 offset; \ + u32 locationLength; \ + char *location; typedef struct MP4DataEntryAtom { - MP4_FULL_ATOM - COMMON_DATAENTRY_ATOM_FIELDS + MP4_FULL_ATOM + COMMON_DATAENTRY_ATOM_FIELDS } MP4DataEntryAtom, *MP4DataEntryAtomPtr; typedef struct MP4DataEntryURLAtom { - MP4_FULL_ATOM - COMMON_DATAENTRY_ATOM_FIELDS + MP4_FULL_ATOM + COMMON_DATAENTRY_ATOM_FIELDS } MP4DataEntryURLAtom, *MP4DataEntryURLAtomPtr; typedef struct MP4DataEntryURNAtom { - MP4_FULL_ATOM - COMMON_DATAENTRY_ATOM_FIELDS - u32 nameLength; - char* nameURN; + MP4_FULL_ATOM + COMMON_DATAENTRY_ATOM_FIELDS + u32 nameLength; + char *nameURN; } MP4DataEntryURNAtom, *MP4DataEntryURNAtomPtr; typedef struct MP4DataReferenceAtom { - MP4_FULL_ATOM - MP4Err (*addDataEntry)( struct MP4DataReferenceAtom *self, MP4AtomPtr entry ); - MP4Err (*getOffset)( struct MP4DataReferenceAtom *self, u32 dataReferenceIndex, u64 *outOffset ); - MP4Err (*addSampleReference)( struct MP4DataReferenceAtom *self, u32 sampleCount, u32 dataReferenceIndex, u64 dataOffset, MP4Handle sizesH ); - MP4Err (*addSamples)( struct MP4DataReferenceAtom *self, u32 sampleCount, u32 dataReferenceIndex, MP4Handle sampleH ); - u32 (*getEntryCount)( struct MP4DataReferenceAtom *self ); - MP4Err (*getEntry)( struct MP4DataReferenceAtom *self, u32 dataReferenceIndex, struct MP4DataEntryAtom **outEntry ); - MP4LinkedList atomList; + MP4_FULL_ATOM + MP4Err (*addDataEntry)(struct MP4DataReferenceAtom *self, MP4AtomPtr entry); + MP4Err (*getOffset)(struct MP4DataReferenceAtom *self, u32 dataReferenceIndex, u64 *outOffset); + MP4Err (*addSampleReference)(struct MP4DataReferenceAtom *self, u32 sampleCount, + u32 dataReferenceIndex, u64 dataOffset, MP4Handle sizesH); + MP4Err (*addSamples)(struct MP4DataReferenceAtom *self, u32 sampleCount, u32 dataReferenceIndex, + MP4Handle sampleH); + u32 (*getEntryCount)(struct MP4DataReferenceAtom *self); + MP4Err (*getEntry)(struct MP4DataReferenceAtom *self, u32 dataReferenceIndex, + struct MP4DataEntryAtom **outEntry); + MP4LinkedList atomList; } MP4DataReferenceAtom, *MP4DataReferenceAtomPtr; typedef struct MP4SampleAuxiliaryInformationSizesAtom { - MP4_FULL_ATOM - u32 aux_info_type; - u32 aux_info_type_parameter; - - u8 default_sample_info_size; - u32 sample_count; - u8 *sample_info_sizes; - - u32 totalSize; - - MP4Err (*addSizes) ( MP4AtomPtr s, u32 sampleCount, MP4Handle sizesH ); - MP4Err (*mergeSizes) ( MP4AtomPtr s, MP4AtomPtr otherSaiz ); + MP4_FULL_ATOM + u32 aux_info_type; + u32 aux_info_type_parameter; + + u8 default_sample_info_size; + u32 sample_count; + u8 *sample_info_sizes; + + u32 totalSize; + + MP4Err (*addSizes)(MP4AtomPtr s, u32 sampleCount, MP4Handle sizesH); + MP4Err (*mergeSizes)(MP4AtomPtr s, MP4AtomPtr otherSaiz); } MP4SampleAuxiliaryInformationSizesAtom, *MP4SampleAuxiliaryInformationSizesAtomPtr; typedef struct MP4SampleAuxiliaryInformationOffsetsAtom { - MP4_FULL_ATOM - u32 aux_info_type; - u32 aux_info_type_parameter; - - u32 entry_count; - u64 *offsets; - - u64 additionalOffset; - u64 totalOffset; - MP4Err (*addOffsets) ( MP4AtomPtr s, u32 entryCount, MP4Handle sizesH ); - MP4Err (*mdatMoved) ( MP4AtomPtr s, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ); - MP4Err (*mergeOffsets) ( MP4AtomPtr s, MP4AtomPtr otherSaio, u64 baseOffset ); + MP4_FULL_ATOM + u32 aux_info_type; + u32 aux_info_type_parameter; + + u32 entry_count; + u64 *offsets; + + u64 additionalOffset; + u64 totalOffset; + MP4Err (*addOffsets)(MP4AtomPtr s, u32 entryCount, MP4Handle sizesH); + MP4Err (*mdatMoved)(MP4AtomPtr s, u64 mdatBase, u64 mdatEnd, s32 mdatOffset); + MP4Err (*mergeOffsets)(MP4AtomPtr s, MP4AtomPtr otherSaio, u64 baseOffset); } MP4SampleAuxiliaryInformationOffsetsAtom, *MP4SampleAuxiliaryInformationOffsetsAtomPtr; typedef struct MP4SampleTableAtom { - MP4_BASE_ATOM - MP4Err (*setupNew)( struct MP4SampleTableAtom *self ); - MP4Err (*calculateDuration)( struct MP4SampleTableAtom *self, u32 *outDuration ); - MP4Err (*setSampleEntry)( struct MP4SampleTableAtom *self, MP4AtomPtr entry ); - MP4Err (*getCurrentDataReferenceIndex)( struct MP4SampleTableAtom *self, u32 *outDataReferenceIndex ); - MP4Err (*extendLastSampleDuration)( struct MP4SampleTableAtom *self, u32 duration ); - MP4Err (*addSamples)( struct MP4SampleTableAtom *self, - u32 sampleCount, u64 sampleOffset, MP4Handle durationsH, - MP4Handle sizesH, MP4Handle compositionOffsetsH, - MP4Handle syncSamplesH, MP4Handle padsH ); - MP4Err (*setfieldsize)( struct MP4SampleTableAtom* self, u32 fieldsize); - u32 (*getCurrentSampleEntryIndex)( struct MP4SampleTableAtom *self ); - MP4Err (*setDefaultSampleEntry)( struct MP4SampleTableAtom *self, u32 index ); - MP4Err (*addGroupDescription)( struct MP4SampleTableAtom *self, u32 theType, MP4Handle theDescription, u32* index ); - MP4Err (*mapSamplestoGroup)( struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ); - MP4Err (*getSampleGroupMap)( struct MP4SampleTableAtom *self, u32 groupType, u32 sample_number, u32* group_index ); - MP4Err (*getGroupDescription)( struct MP4SampleTableAtom *self, u32 theType, u32 index, MP4Handle theDescription ); - - MP4Err (*setSampleDependency)( struct MP4SampleTableAtom *self, s32 sample_index, MP4Handle dependencies ); - MP4Err (*getSampleDependency)( struct MP4SampleTableAtom *self, u32 sampleNumber, u8* dependency ); - - MP4Err (*getSampleAuxiliaryInformation)( struct MP4SampleTableAtom *self, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, - MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut); - - MP4AtomPtr TimeToSample; - MP4AtomPtr CompositionOffset; - MP4AtomPtr CompositionToDecode; - MP4AtomPtr SyncSample; - MP4AtomPtr SampleDescription; - MP4AtomPtr SampleSize; - MP4AtomPtr SampleToChunk; - MP4AtomPtr ChunkOffset; - MP4AtomPtr ShadowSync; - MP4AtomPtr DegradationPriority; - MP4AtomPtr PaddingBits; - MP4AtomPtr SampleDependency; - - - MP4LinkedList SampleAuxiliaryInformationSizes; - MP4LinkedList SampleAuxiliaryInformationOffsets; - - MP4LinkedList groupDescriptionList; - MP4LinkedList sampletoGroupList; - MP4LinkedList compactSampletoGroupList; - - MP4LinkedList atomList; - - MP4AtomPtr currentSampleEntry; - u32 currentSampleEntryIndex; - u8 useSignedCompositionTimeOffsets; + MP4_BASE_ATOM + MP4Err (*setupNew)(struct MP4SampleTableAtom *self); + MP4Err (*calculateDuration)(struct MP4SampleTableAtom *self, u32 *outDuration); + MP4Err (*setSampleEntry)(struct MP4SampleTableAtom *self, MP4AtomPtr entry); + MP4Err (*getCurrentDataReferenceIndex)(struct MP4SampleTableAtom *self, + u32 *outDataReferenceIndex); + MP4Err (*extendLastSampleDuration)(struct MP4SampleTableAtom *self, u32 duration); + MP4Err (*addSamples)(struct MP4SampleTableAtom *self, u32 sampleCount, u64 sampleOffset, + MP4Handle durationsH, MP4Handle sizesH, MP4Handle compositionOffsetsH, + MP4Handle syncSamplesH, MP4Handle padsH); + MP4Err (*setfieldsize)(struct MP4SampleTableAtom *self, u32 fieldsize); + u32 (*getCurrentSampleEntryIndex)(struct MP4SampleTableAtom *self); + MP4Err (*setDefaultSampleEntry)(struct MP4SampleTableAtom *self, u32 index); + MP4Err (*addGroupDescription)(struct MP4SampleTableAtom *self, u32 theType, + MP4Handle theDescription, u32 *index); + MP4Err (*mapSamplestoGroup)(struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, + s32 sample_index, u32 count, u32 enableCompactSamples); + MP4Err (*getSampleGroupMap)(struct MP4SampleTableAtom *self, u32 groupType, u32 sample_number, + u32 *group_index); + MP4Err (*getGroupDescription)(struct MP4SampleTableAtom *self, u32 theType, u32 index, + MP4Handle theDescription); + + MP4Err (*setSampleDependency)(struct MP4SampleTableAtom *self, s32 sample_index, + MP4Handle dependencies); + MP4Err (*getSampleDependency)(struct MP4SampleTableAtom *self, u32 sampleNumber, u8 *dependency); + + MP4Err (*getSampleAuxiliaryInformation)(struct MP4SampleTableAtom *self, + u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, + u32 aux_info_type_parameter, + MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, + MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut); + + MP4AtomPtr TimeToSample; + MP4AtomPtr CompositionOffset; + MP4AtomPtr CompositionToDecode; + MP4AtomPtr SyncSample; + MP4AtomPtr SampleDescription; + MP4AtomPtr SampleSize; + MP4AtomPtr SampleToChunk; + MP4AtomPtr ChunkOffset; + MP4AtomPtr ShadowSync; + MP4AtomPtr DegradationPriority; + MP4AtomPtr PaddingBits; + MP4AtomPtr SampleDependency; + + MP4LinkedList SampleAuxiliaryInformationSizes; + MP4LinkedList SampleAuxiliaryInformationOffsets; + + MP4LinkedList groupDescriptionList; + MP4LinkedList sampletoGroupList; + MP4LinkedList compactSampletoGroupList; + + MP4LinkedList atomList; + + MP4AtomPtr currentSampleEntry; + u32 currentSampleEntryIndex; + u8 useSignedCompositionTimeOffsets; } MP4SampleTableAtom, *MP4SampleTableAtomPtr; typedef struct MP4TimeToSampleAtom { - MP4_FULL_ATOM - MP4Err (*getTimeForSampleNumber)( MP4AtomPtr self, u32 sampleNumber, u64 *outSampleCTS, s32 *outSampleDuration ); - MP4Err (*findSamples)( MP4AtomPtr self, u64 desiredTime, - s64 *outPriorSample, s64 *outExactSample, s64 *outNextSample, - u32 *outSampleNumber, s32 *outSampleDuration ); - MP4Err (*getTotalDuration)( struct MP4TimeToSampleAtom *self, u32 *outDuration ); - MP4Err (*addSamples)( struct MP4TimeToSampleAtom *self, u32 sampleCount, MP4Handle durationsH ); - MP4Err (*extendLastSampleDuration)( struct MP4TimeToSampleAtom *self, u32 duration ); - - MP4LinkedList entryList; - void *currentEntry; - void *foundEntry; - u32 foundEntryNumber; - u32 foundEntrySampleNumber; - u64 foundEntryTime; + MP4_FULL_ATOM + MP4Err (*getTimeForSampleNumber)(MP4AtomPtr self, u32 sampleNumber, u64 *outSampleCTS, + s32 *outSampleDuration); + MP4Err (*findSamples)(MP4AtomPtr self, u64 desiredTime, s64 *outPriorSample, s64 *outExactSample, + s64 *outNextSample, u32 *outSampleNumber, s32 *outSampleDuration); + MP4Err (*getTotalDuration)(struct MP4TimeToSampleAtom *self, u32 *outDuration); + MP4Err (*addSamples)(struct MP4TimeToSampleAtom *self, u32 sampleCount, MP4Handle durationsH); + MP4Err (*extendLastSampleDuration)(struct MP4TimeToSampleAtom *self, u32 duration); + + MP4LinkedList entryList; + void *currentEntry; + void *foundEntry; + u32 foundEntryNumber; + u32 foundEntrySampleNumber; + u64 foundEntryTime; } MP4TimeToSampleAtom, *MP4TimeToSampleAtomPtr; typedef struct MP4CompositionOffsetAtom { - MP4_FULL_ATOM - MP4Err (*addSamples)(struct MP4CompositionOffsetAtom *self, u32 sampleNumber, u32 sampleCount, MP4Handle offsetsH ); - MP4Err (*getOffsetForSampleNumber)( MP4AtomPtr self, u32 sampleNumber, s32 *outOffset ); - MP4LinkedList entryList; - void *currentEntry; - u32 finalSampleNumber; + MP4_FULL_ATOM + MP4Err (*addSamples)(struct MP4CompositionOffsetAtom *self, u32 sampleNumber, u32 sampleCount, + MP4Handle offsetsH); + MP4Err (*getOffsetForSampleNumber)(MP4AtomPtr self, u32 sampleNumber, s32 *outOffset); + MP4LinkedList entryList; + void *currentEntry; + u32 finalSampleNumber; } MP4CompositionOffsetAtom, *MP4CompositionOffsetAtomPtr; typedef struct MP4CompositionToDecodeAtom { - MP4_FULL_ATOM - s32 compositionToDTSShift; - s32 leastDecodeToDisplayDelta; - s32 greatestDecodeToDisplayDelta; - s32 compositionStartTime; - s32 compositionEndTime; - MP4Err (*updateFields)( struct MP4Atom* s, u32 sampleCount, MP4Handle durationsH, MP4Handle compositionOffsetsH ); - s64 totalDuration; + MP4_FULL_ATOM + s32 compositionToDTSShift; + s32 leastDecodeToDisplayDelta; + s32 greatestDecodeToDisplayDelta; + s32 compositionStartTime; + s32 compositionEndTime; + MP4Err (*updateFields)(struct MP4Atom *s, u32 sampleCount, MP4Handle durationsH, + MP4Handle compositionOffsetsH); + s64 totalDuration; } MP4CompositionToDecodeAtom, *MP4CompositionToDecodeAtomPtr; #define COMMON_SAMPLE_ENTRY_FIELDS \ - u32 dataReferenceIndex; \ - char reserved[ 6 ]; \ - MP4LinkedList ExtensionAtomList; + u32 dataReferenceIndex; \ + char reserved[6]; \ + MP4LinkedList ExtensionAtomList; typedef struct GenericSampleEntryAtom { - MP4_BASE_ATOM - COMMON_SAMPLE_ENTRY_FIELDS + MP4_BASE_ATOM + COMMON_SAMPLE_ENTRY_FIELDS } GenericSampleEntryAtom, *GenericSampleEntryAtomPtr; typedef struct MP4GenericSampleEntryAtom { - MP4_BASE_ATOM - COMMON_SAMPLE_ENTRY_FIELDS - char *data; - u32 dataSize; + MP4_BASE_ATOM + COMMON_SAMPLE_ENTRY_FIELDS + char *data; + u32 dataSize; } MP4GenericSampleEntryAtom, *MP4GenericSampleEntryAtomPtr; typedef struct MP4MPEGSampleEntryAtom { - MP4_BASE_ATOM - COMMON_SAMPLE_ENTRY_FIELDS + MP4_BASE_ATOM + COMMON_SAMPLE_ENTRY_FIELDS } MP4MPEGSampleEntryAtom, *MP4MPEGSampleEntryAtomPtr; typedef struct MP4VisualSampleEntryAtom { - MP4_BASE_ATOM - COMMON_SAMPLE_ENTRY_FIELDS - char reserved2[ 16 ]; /* uint(32)[4] */ - /* u32 reserved3; uint(32) = 0x01400f0 */ - u32 width; - u32 height; - u32 reserved4; /* uint(32) = 0x0048000 */ - u32 reserved5; /* uint(32) = 0x0048000 */ - u32 reserved6; /* uint(32) = 0 */ - u32 reserved7; /* uint(16) = 1 */ - u32 nameLength; - char name31[31]; - u32 reserved8; /* uint(16) = 24 */ - s32 reserved9; /* int(16) = -1 */ - + MP4_BASE_ATOM + COMMON_SAMPLE_ENTRY_FIELDS + char reserved2[16]; /* uint(32)[4] */ + /* u32 reserved3; uint(32) = 0x01400f0 */ + u32 width; + u32 height; + u32 reserved4; /* uint(32) = 0x0048000 */ + u32 reserved5; /* uint(32) = 0x0048000 */ + u32 reserved6; /* uint(32) = 0 */ + u32 reserved7; /* uint(16) = 1 */ + u32 nameLength; + char name31[31]; + u32 reserved8; /* uint(16) = 24 */ + s32 reserved9; /* int(16) = -1 */ + } MP4VisualSampleEntryAtom, *MP4VisualSampleEntryAtomPtr; typedef struct MP4AudioSampleEntryAtom { - MP4_BASE_ATOM - COMMON_SAMPLE_ENTRY_FIELDS - char reserved2[ 8 ]; /* uint(32)[2] */ - u32 reserved3; /* uint(16) = 2 */ - u32 reserved4; /* uint(16) = 16 */ - u32 reserved5; /* uint(32) = 0 */ - u32 timeScale; /* uint(16) copied from track! */ - u32 reserved6; /* uint(16) = 0 */ - + MP4_BASE_ATOM + COMMON_SAMPLE_ENTRY_FIELDS + char reserved2[8]; /* uint(32)[2] */ + u32 reserved3; /* uint(16) = 2 */ + u32 reserved4; /* uint(16) = 16 */ + u32 reserved5; /* uint(32) = 0 */ + u32 timeScale; /* uint(16) copied from track! */ + u32 reserved6; /* uint(16) = 0 */ + } MP4AudioSampleEntryAtom, *MP4AudioSampleEntryAtomPtr; typedef struct MP4PCMConfigAtom { - MP4_FULL_ATOM - u8 format_flags; /* uint(8) */ - u8 PCM_sample_size; /* uint(8) */ + MP4_FULL_ATOM + u8 format_flags; /* uint(8) */ + u8 PCM_sample_size; /* uint(8) */ } MP4PCMConfigAtom, *MP4PCMConfigAtomPtr; typedef struct MP4ChannelLayoutDefinedLayout { - u8 speaker_position; /* uint(8) */ - s16 azimuth; /* sint(16) */ - s8 elevation; /* sint(8) */ + u8 speaker_position; /* uint(8) */ + s16 azimuth; /* sint(16) */ + s8 elevation; /* sint(8) */ } MP4ChannelLayoutDefinedLayout; typedef struct MP4ChannelLayoutAtom { - MP4_FULL_ATOM - /* format in Version 0, version 1 */ - u16 channelCount; /* (0) comes from the sample entry */ - u8 stream_structure; /* uint(8), uint(4) */ - u8 definedLayout; /* int(8), int(8) */ - MP4LinkedList definedLayouts; - u64 omittedChannelsMap; /* uint(64), uint(64) */ - u8 object_count; /* uint(8), uint(8) */ - /* for version > 0 */ - u8 formatOrdering; /* , int(4) */ - u16 baseChannelCount; /* , uint(8) */ - u16 layoutChannelCount; /* , uint(8) */ - u8 channelOrderDefinition; /* , uint(3) */ - u8 omittedChannelsPresent; /* , unit(1) */ + MP4_FULL_ATOM + /* format in Version 0, version 1 */ + u16 channelCount; /* (0) comes from the sample entry */ + u8 stream_structure; /* uint(8), uint(4) */ + u8 definedLayout; /* int(8), int(8) */ + MP4LinkedList definedLayouts; + u64 omittedChannelsMap; /* uint(64), uint(64) */ + u8 object_count; /* uint(8), uint(8) */ + /* for version > 0 */ + u8 formatOrdering; /* , int(4) */ + u16 baseChannelCount; /* , uint(8) */ + u16 layoutChannelCount; /* , uint(8) */ + u8 channelOrderDefinition; /* , uint(3) */ + u8 omittedChannelsPresent; /* , unit(1) */ } MP4ChannelLayoutAtom, *MP4ChannelLayoutAtomPtr; typedef struct MP4DownMixInstructionsAtom { - MP4_FULL_ATOM - u16 baseChannelCount; /* comes from the sample entry */ - u8 targetLayout; /* uint(8) */ - u8 reserved; /* uint(1) */ - u8 targetChannelCount; /* uint(7) */ - u8 in_stream; /* bit(1) */ - u8 downmix_ID; /* uint(7) */ - u8 *bs_downmix_coefficients; /* bit(4)[targetChannelCount][baseChannelCount] */ + MP4_FULL_ATOM + u16 baseChannelCount; /* comes from the sample entry */ + u8 targetLayout; /* uint(8) */ + u8 reserved; /* uint(1) */ + u8 targetChannelCount; /* uint(7) */ + u8 in_stream; /* bit(1) */ + u8 downmix_ID; /* uint(7) */ + u8 *bs_downmix_coefficients; /* bit(4)[targetChannelCount][baseChannelCount] */ } MP4DownMixInstructionsAtom, *MP4DownMixInstructionsAtomPtr; typedef struct MP4LoudnessBaseMeasurement { - u8 method_definition; /* uint(8) */ - u8 method_value; /* uint(8) */ - u8 measurement_system; /* uint(4) */ - u8 reliability; /* uint(4) */ + u8 method_definition; /* uint(8) */ + u8 method_value; /* uint(8) */ + u8 measurement_system; /* uint(4) */ + u8 reliability; /* uint(4) */ } MP4LoudnessBaseMeasurement; typedef struct MP4LoudnessBaseAtom { - MP4_FULL_ATOM - u8 reserved; /* unit(3) = 0 */ - u8 downmix_ID; /* uint(7) */ - u8 DRC_set_ID; /* uint(6) */ - s16 bs_sample_peak_level; /* int(12) */ - s16 bs_true_peak_level; /* int(12) */ - u8 measurement_system_for_TP; /* uint(4) */ - u8 reliability_for_TP; /* uint(4) */ - u8 measurement_count; /* uint(8) */ - MP4LinkedList measurements; + MP4_FULL_ATOM + u8 reserved; /* unit(3) = 0 */ + u8 downmix_ID; /* uint(7) */ + u8 DRC_set_ID; /* uint(6) */ + s16 bs_sample_peak_level; /* int(12) */ + s16 bs_true_peak_level; /* int(12) */ + u8 measurement_system_for_TP; /* uint(4) */ + u8 reliability_for_TP; /* uint(4) */ + u8 measurement_count; /* uint(8) */ + MP4LinkedList measurements; } MP4LoudnessBaseAtom, *MP4LoudnessBaseAtomPtr; typedef struct MP4LoudnessAtom { - MP4_BASE_ATOM - MP4LinkedList trackLoudnessInfoList; - MP4LinkedList albumLoudnessInfoList; - MP4Err (*addAtom)( struct MP4LoudnessAtom *self, MP4AtomPtr atom ); - MP4Err (*serializeData)( struct MP4Atom *s, char *buffer ); - MP4Err (*getDataSize)( struct MP4Atom *s, u32 *dataSizeOut ); + MP4_BASE_ATOM + MP4LinkedList trackLoudnessInfoList; + MP4LinkedList albumLoudnessInfoList; + MP4Err (*addAtom)(struct MP4LoudnessAtom *self, MP4AtomPtr atom); + MP4Err (*serializeData)(struct MP4Atom *s, char *buffer); + MP4Err (*getDataSize)(struct MP4Atom *s, u32 *dataSizeOut); } MP4LoudnessAtom, *MP4LoudnessAtomPtr; typedef struct MP4XMLMetaSampleEntryAtom { - MP4_BASE_ATOM - COMMON_SAMPLE_ENTRY_FIELDS - char* content_encoding; - char* xml_namespace; - char* schema_location; + MP4_BASE_ATOM + COMMON_SAMPLE_ENTRY_FIELDS + char *content_encoding; + char *xml_namespace; + char *schema_location; } MP4XMLMetaSampleEntryAtom, *MP4XMLMetaSampleEntryAtomPtr; typedef struct MP4TextMetaSampleEntryAtom { - MP4_BASE_ATOM - COMMON_SAMPLE_ENTRY_FIELDS - char* content_encoding; - char* mime_format; + MP4_BASE_ATOM + COMMON_SAMPLE_ENTRY_FIELDS + char *content_encoding; + char *mime_format; } MP4TextMetaSampleEntryAtom, *MP4TextMetaSampleEntryAtomPtr; typedef struct MP4AMRSpecificInfoAtom { - MP4_BASE_ATOM - u32 vendor; /* uint(32) */ - u32 decoder_version; /* uint(8) */ - u32 mode_set; /* uint(16) */ - u32 mode_change_period; /* uint(8) */ - u32 frames_per_sample; /* uint(8) */ - + MP4_BASE_ATOM + u32 vendor; /* uint(32) */ + u32 decoder_version; /* uint(8) */ + u32 mode_set; /* uint(16) */ + u32 mode_change_period; /* uint(8) */ + u32 frames_per_sample; /* uint(8) */ + } MP4AMRSpecificInfoAtom, *MP4AMRSpecificInfoAtomPtr; typedef struct MP4AMRWPSpecificInfoAtom { - MP4_BASE_ATOM - u32 vendor; /* uint(32) */ - u32 decoder_version; /* uint(8) */ - + MP4_BASE_ATOM + u32 vendor; /* uint(32) */ + u32 decoder_version; /* uint(8) */ + } MP4AMRWPSpecificInfoAtom, *MP4AMRWPSpecificInfoAtomPtr; typedef struct MP4H263SpecificInfoAtom { - MP4_BASE_ATOM - u32 vendor; /* uint(32) */ - u32 decoder_version; /* uint(8) */ - u32 H263_level; /* uint(8) */ - u32 H263_profile; /* uint(8) */ - MP4LinkedList atomList; - MP4Err (*addAtom)( struct MP4H263SpecificInfoAtom *self, MP4AtomPtr atom ); - + MP4_BASE_ATOM + u32 vendor; /* uint(32) */ + u32 decoder_version; /* uint(8) */ + u32 H263_level; /* uint(8) */ + u32 H263_profile; /* uint(8) */ + MP4LinkedList atomList; + MP4Err (*addAtom)(struct MP4H263SpecificInfoAtom *self, MP4AtomPtr atom); + } MP4H263SpecificInfoAtom, *MP4H263SpecificInfoAtomPtr; typedef struct MP4BitRateAtom { - MP4_BASE_ATOM - u32 buffersizeDB; - u32 avg_bitrate; /* uint(32) */ - u32 max_bitrate; /* uint(32) */ - + MP4_BASE_ATOM + u32 buffersizeDB; + u32 avg_bitrate; /* uint(32) */ + u32 max_bitrate; /* uint(32) */ + } MP4BitRateAtom, *MP4BitRateAtomPtr; typedef struct MP4SampleDescriptionAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM - MP4Err (*addEntry)( struct MP4SampleDescriptionAtom *self, MP4AtomPtr entry ); - u32 (*getEntryCount)( struct MP4SampleDescriptionAtom *self ); - MP4Err (*getEntry)( struct MP4SampleDescriptionAtom *self, u32 entryNumber, struct GenericSampleEntryAtom **outEntry ); + MP4Err (*addEntry)(struct MP4SampleDescriptionAtom *self, MP4AtomPtr entry); + u32 (*getEntryCount)(struct MP4SampleDescriptionAtom *self); + MP4Err (*getEntry)(struct MP4SampleDescriptionAtom *self, u32 entryNumber, + struct GenericSampleEntryAtom **outEntry); - MP4LinkedList atomList; + MP4LinkedList atomList; } MP4SampleDescriptionAtom, *MP4SampleDescriptionAtomPtr; - typedef struct MP4ESDAtom { - MP4_FULL_ATOM - u32 descriptorLength; - struct MP4DescriptorRecord* descriptor; + MP4_FULL_ATOM + u32 descriptorLength; + struct MP4DescriptorRecord *descriptor; } MP4ESDAtom, *MP4ESDAtomPtr; typedef struct ISOVCConfigAtom { - MP4_BASE_ATOM - MP4Err (*addParameterSet)( struct ISOVCConfigAtom *self, MP4Handle ps, u32 where ); - MP4Err (*getParameterSet)( struct ISOVCConfigAtom *self, MP4Handle ps, u32 where, u32 index ); - u32 profile; - u32 profile_compatibility; - u32 level; - u32 length_size; - u32 complete_rep; - MP4LinkedList spsList; - MP4LinkedList ppsList; - u32 chroma_format; - u32 bit_depth_luma_minus8; - u32 bit_depth_chroma_minus8; - MP4LinkedList spsextList; + MP4_BASE_ATOM + MP4Err (*addParameterSet)(struct ISOVCConfigAtom *self, MP4Handle ps, u32 where); + MP4Err (*getParameterSet)(struct ISOVCConfigAtom *self, MP4Handle ps, u32 where, u32 index); + u32 profile; + u32 profile_compatibility; + u32 level; + u32 length_size; + u32 complete_rep; + MP4LinkedList spsList; + MP4LinkedList ppsList; + u32 chroma_format; + u32 bit_depth_luma_minus8; + u32 bit_depth_chroma_minus8; + MP4LinkedList spsextList; } ISOVCConfigAtom, *ISOVCConfigAtomPtr; -typedef struct ISOHEVCConfigAtom { - MP4_BASE_ATOM - MP4Err(*addParameterSet)(struct ISOHEVCConfigAtom *self, MP4Handle ps, u32 where); - MP4Err(*getParameterSet)(struct ISOHEVCConfigAtom *self, MP4Handle ps, u32 where, u32 index); - u32 general_profile_idc; - u32 general_profile_compatibility_flags; - u32 general_level_idc; - u32 lengthSizeMinusOne; - u32 complete_rep; - u32 numOfArrays; - struct { - u32 array_completeness; - u32 NALtype; - MP4LinkedList nalList; - } arrays[8]; - u32 chromaFormat; - u32 avgFrameRate; - u32 sps_temporal_id_nesting_flag; - u32 bitDepthLumaMinus8; - u32 bitDepthChromaMinus8; +typedef struct ISOHEVCConfigAtom +{ + MP4_BASE_ATOM + MP4Err (*addParameterSet)(struct ISOHEVCConfigAtom *self, MP4Handle ps, u32 where); + MP4Err (*getParameterSet)(struct ISOHEVCConfigAtom *self, MP4Handle ps, u32 where, u32 index); + u32 general_profile_idc; + u32 general_profile_compatibility_flags; + u32 general_level_idc; + u32 lengthSizeMinusOne; + u32 complete_rep; + u32 numOfArrays; + struct + { + u32 array_completeness; + u32 NALtype; + MP4LinkedList nalList; + } arrays[8]; + u32 chromaFormat; + u32 avgFrameRate; + u32 sps_temporal_id_nesting_flag; + u32 bitDepthLumaMinus8; + u32 bitDepthChromaMinus8; } ISOHEVCConfigAtom, *ISOHEVCConfigAtomPtr; typedef struct MP4SampleSizeAtom { - MP4_FULL_ATOM - MP4Err (*getSampleSize)( MP4AtomPtr self, u32 sampleNumber, u32 *outSize ); - MP4Err (*getSampleSizeAndOffset)( MP4AtomPtr self, u32 sampleNumber, u32 *outSize, u32 startingSampleNumber, u32 *outOffsetSize ); - MP4Err (*addSamples)( struct MP4SampleSizeAtom *self, u32 sampleCount, MP4Handle sizesH ); - MP4Err (*setfieldsize)( struct MP4SampleSizeAtom* self, u32 fieldsize); - - u32 sampleSize; - u32 sampleCount; - u32 fieldsize; - u32 allocatedSize; - u32 *sizes; + MP4_FULL_ATOM + MP4Err (*getSampleSize)(MP4AtomPtr self, u32 sampleNumber, u32 *outSize); + MP4Err (*getSampleSizeAndOffset)(MP4AtomPtr self, u32 sampleNumber, u32 *outSize, + u32 startingSampleNumber, u32 *outOffsetSize); + MP4Err (*addSamples)(struct MP4SampleSizeAtom *self, u32 sampleCount, MP4Handle sizesH); + MP4Err (*setfieldsize)(struct MP4SampleSizeAtom *self, u32 fieldsize); + + u32 sampleSize; + u32 sampleCount; + u32 fieldsize; + u32 allocatedSize; + u32 *sizes; } MP4SampleSizeAtom, *MP4SampleSizeAtomPtr; typedef MP4SampleSizeAtom MP4CompactSampleSizeAtom; @@ -1029,992 +1064,1026 @@ typedef MP4SampleSizeAtomPtr MP4CompactSampleSizeAtomPtr; typedef struct MP4PaddingBitsAtom { - MP4_FULL_ATOM - MP4Err (*getSamplePad)( MP4AtomPtr self, u32 sampleNumber, u8 *outPad ); - MP4Err (*addSamplePads)( struct MP4PaddingBitsAtom *self, u32 sampleCount, MP4Handle padsH ); + MP4_FULL_ATOM + MP4Err (*getSamplePad)(MP4AtomPtr self, u32 sampleNumber, u8 *outPad); + MP4Err (*addSamplePads)(struct MP4PaddingBitsAtom *self, u32 sampleCount, MP4Handle padsH); - u32 sampleCount; - u8 *pads; + u32 sampleCount; + u8 *pads; } MP4PaddingBitsAtom, *MP4PaddingBitsAtomPtr; -#define COMMON_CHUNK_OFFSET_FIELDS \ - u32 (*getChunkCount)( MP4AtomPtr self); \ - MP4Err (*getChunkOffset)( MP4AtomPtr self, u32 chunkIndex, u64 *outOffset ); \ - MP4Err (*addOffset)(struct MP4ChunkOffsetAtom *self, u64 offset ); \ - MP4Err (*mdatMoved)(struct MP4ChunkOffsetAtom *self, u32 firstchunk, u32 lastchunk, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ); \ - u32 entryCount; +#define COMMON_CHUNK_OFFSET_FIELDS \ + u32 (*getChunkCount)(MP4AtomPtr self); \ + MP4Err (*getChunkOffset)(MP4AtomPtr self, u32 chunkIndex, u64 * outOffset); \ + MP4Err (*addOffset)(struct MP4ChunkOffsetAtom * self, u64 offset); \ + MP4Err (*mdatMoved)(struct MP4ChunkOffsetAtom * self, u32 firstchunk, u32 lastchunk, \ + u64 mdatBase, u64 mdatEnd, s32 mdatOffset); \ + u32 entryCount; typedef struct MP4ChunkOffsetAtom { - MP4_FULL_ATOM - COMMON_CHUNK_OFFSET_FIELDS - - u32 allocatedSize; - u64 *offsets; + MP4_FULL_ATOM + COMMON_CHUNK_OFFSET_FIELDS + + u32 allocatedSize; + u64 *offsets; } MP4ChunkOffsetAtom, *MP4ChunkOffsetAtomPtr; /* typedef struct MP4ChunkLargeOffsetAtom { - MP4_FULL_ATOM - COMMON_CHUNK_OFFSET_FIELDS + MP4_FULL_ATOM + COMMON_CHUNK_OFFSET_FIELDS - u64 *offsets; + u64 *offsets; } MP4ChunkLargeOffsetAtom, *MP4ChunkLargeOffsetAtomPtr; */ typedef struct MP4SampleToChunkAtom { - MP4_FULL_ATOM - MP4Err (*lookupSample)( MP4AtomPtr self, u32 sampleNumber, u32 *outChunkNumber, u32 *outSampleDescriptionIndex, u32 *outFirstSampleNumberInChunk ); - MP4Err (*setEntry)( struct MP4SampleToChunkAtom *self, u32 firstChunkNumber, u32 sampleCount, u32 sampleDescriptionIndex ); - u32 (*getEntryCount)( struct MP4SampleToChunkAtom *self ); - MP4Err (*mdatMoved)( struct MP4SampleToChunkAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset, - struct MP4SampleDescriptionAtom *stsd, - struct MP4DataReferenceAtom *dref, struct MP4ChunkOffsetAtom *stco ); - MP4LinkedList entryList; - - u32 foundEntryNumber; - u32 foundEntryFirstSampleNumber; + MP4_FULL_ATOM + MP4Err (*lookupSample)(MP4AtomPtr self, u32 sampleNumber, u32 *outChunkNumber, + u32 *outSampleDescriptionIndex, u32 *outFirstSampleNumberInChunk); + MP4Err (*setEntry)(struct MP4SampleToChunkAtom *self, u32 firstChunkNumber, u32 sampleCount, + u32 sampleDescriptionIndex); + u32 (*getEntryCount)(struct MP4SampleToChunkAtom *self); + MP4Err (*mdatMoved)(struct MP4SampleToChunkAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset, + struct MP4SampleDescriptionAtom *stsd, struct MP4DataReferenceAtom *dref, + struct MP4ChunkOffsetAtom *stco); + MP4LinkedList entryList; + + u32 foundEntryNumber; + u32 foundEntryFirstSampleNumber; } MP4SampleToChunkAtom, *MP4SampleToChunkAtomPtr; -typedef struct MP4SubSampleInformationAtom { - MP4_FULL_ATOM - MP4Err(*addEntry)(struct MP4SubSampleInformationAtom *self, u32 sample_delta, - u32 subsample_count, MP4Handle subsample_size_array, MP4Handle subsample_priority_array, - MP4Handle subsample_discardable_array); - u32 entry_count; - u32 *sample_delta; - u32 *subsample_count; - u32 **subsample_size; - u32 **subsample_priority; - u32 **discardable; - u32 **reserved; +typedef struct MP4SubSampleInformationAtom +{ + MP4_FULL_ATOM + MP4Err (*addEntry)(struct MP4SubSampleInformationAtom *self, u32 sample_delta, + u32 subsample_count, MP4Handle subsample_size_array, + MP4Handle subsample_priority_array, MP4Handle subsample_discardable_array); + u32 entry_count; + u32 *sample_delta; + u32 *subsample_count; + u32 **subsample_size; + u32 **subsample_priority; + u32 **discardable; + u32 **reserved; } MP4SubSampleInformationAtom, *MP4SubSampleInformationAtomPtr; typedef struct MP4SyncSampleAtom { - MP4_FULL_ATOM - MP4Err (*addSamples)(struct MP4SyncSampleAtom *self, u32 beginningSampleNumber, u32 sampleCount, MP4Handle syncSamplesH ); - MP4Err (*isSyncSample)( MP4AtomPtr self, u32 sampleNumber, u32 *outSync ); - u32 entryCount; - u32 *sampleNumbers; - u32 nonSyncFlag; - u32 allocatedSize; + MP4_FULL_ATOM + MP4Err (*addSamples)(struct MP4SyncSampleAtom *self, u32 beginningSampleNumber, u32 sampleCount, + MP4Handle syncSamplesH); + MP4Err (*isSyncSample)(MP4AtomPtr self, u32 sampleNumber, u32 *outSync); + u32 entryCount; + u32 *sampleNumbers; + u32 nonSyncFlag; + u32 allocatedSize; } MP4SyncSampleAtom, *MP4SyncSampleAtomPtr; typedef struct MP4ShadowSyncAtom { - MP4_FULL_ATOM - u32 entryCount; - void *entries; + MP4_FULL_ATOM + u32 entryCount; + void *entries; } MP4ShadowSyncAtom, *MP4ShadowSyncAtomPtr; typedef struct MP4DegradationPriorityAtom { - MP4_FULL_ATOM - u32 entryCount; - u16 *priorities; + MP4_FULL_ATOM + u32 entryCount; + u16 *priorities; } MP4DegradationPriorityAtom, *MP4DegradationPriorityAtomPtr; typedef struct MP4FreeSpaceAtom { - MP4_BASE_ATOM - char *data; - u32 dataSize; + MP4_BASE_ATOM + char *data; + u32 dataSize; } MP4FreeSpaceAtom, *MP4FreeSpaceAtomPtr; typedef struct MP4EditAtom { - MP4_BASE_ATOM - MP4Err (*addAtom)( struct MP4EditAtom *self, MP4AtomPtr atom ); - MP4Err (*getEffectiveDuration)( struct MP4EditAtom *self, u32 *outDuration ); + MP4_BASE_ATOM + MP4Err (*addAtom)(struct MP4EditAtom *self, MP4AtomPtr atom); + MP4Err (*getEffectiveDuration)(struct MP4EditAtom *self, u32 *outDuration); - MP4LinkedList atomList; - MP4AtomPtr editListAtom; + MP4LinkedList atomList; + MP4AtomPtr editListAtom; } MP4EditAtom, *MP4EditAtomPtr; typedef struct MP4EditListAtom { - MP4_FULL_ATOM - - MP4Err (*setTrackOffset)( struct MP4EditListAtom *self, u32 trackStartTime, u64 trackDuration ); - MP4Err (*getTrackOffset)( struct MP4EditListAtom *self, u32 *outTrackStartTime ); - - MP4Err (*isEmptyEdit)( struct MP4EditListAtom *self, u32 segmentNumber, u32 *outIsEmpty ); - - MP4Err (*insertSegment)( struct MP4EditListAtom *self, - s32 trackStartTime, - s32 mediaStartTime, - u64 segmentDuration, - u32 mediaRate ); - - MP4Err (*getEffectiveDuration)( struct MP4EditListAtom *self, u32 *outDuration ); - MP4Err (*getIndSegmentTime)( MP4AtomPtr self, - u32 segmentIndex, /* one based */ - u64 *outSegmentMovieTime, - s64 *outSegmentMediaTime, - u64 *outSegmentDuration /* in movie's time scale */ - ); - MP4Err (*getTimeAndRate)( MP4AtomPtr self, u64 movieTime, u32 movieTimeScale, - u32 mediaTimeScale, s64 *outMediaTime, u32 *outMediaRate, - u64 *outPriorSegmentEndTime, u64 *outNextSegmentBeginTime ); - u32 (*getEntryCount)( struct MP4EditListAtom *self ); - MP4LinkedList entryList; + MP4_FULL_ATOM + + MP4Err (*setTrackOffset)(struct MP4EditListAtom *self, u32 trackStartTime, u64 trackDuration); + MP4Err (*getTrackOffset)(struct MP4EditListAtom *self, u32 *outTrackStartTime); + + MP4Err (*isEmptyEdit)(struct MP4EditListAtom *self, u32 segmentNumber, u32 *outIsEmpty); + + MP4Err (*insertSegment)(struct MP4EditListAtom *self, s32 trackStartTime, s32 mediaStartTime, + u64 segmentDuration, u32 mediaRate); + + MP4Err (*getEffectiveDuration)(struct MP4EditListAtom *self, u32 *outDuration); + MP4Err (*getIndSegmentTime)(MP4AtomPtr self, u32 segmentIndex, /* one based */ + u64 *outSegmentMovieTime, s64 *outSegmentMediaTime, + u64 *outSegmentDuration /* in movie's time scale */ + ); + MP4Err (*getTimeAndRate)(MP4AtomPtr self, u64 movieTime, u32 movieTimeScale, u32 mediaTimeScale, + s64 *outMediaTime, u32 *outMediaRate, u64 *outPriorSegmentEndTime, + u64 *outNextSegmentBeginTime); + u32 (*getEntryCount)(struct MP4EditListAtom *self); + MP4LinkedList entryList; } MP4EditListAtom, *MP4EditListAtomPtr; typedef struct MP4UserDataAtom { - MP4_BASE_ATOM - MP4Err (*addUserData) (struct MP4UserDataAtom *self, MP4Handle userDataH, u32 userDataType, u32 *outIndex ); - MP4Err (*getEntryCount) (struct MP4UserDataAtom *self, u32 userDataType, u32 *outCount ); - MP4Err (*getIndType) (struct MP4UserDataAtom *self, u32 typeIndex, u32 *outType ); - MP4Err (*getItem) (struct MP4UserDataAtom *self, MP4Handle userDataH, u32 userDataType, u32 itemIndex ); - MP4Err (*getAtom) (struct MP4UserDataAtom *self, MP4AtomPtr *outatom, u32 userDataType, u32 itemIndex ); - MP4Err (*deleteItem) (struct MP4UserDataAtom *self, u32 userDataType, u32 itemIndex ); - MP4Err (*getTypeCount) (struct MP4UserDataAtom *self, u32 *outCount ); - MP4LinkedList recordList; + MP4_BASE_ATOM + MP4Err (*addUserData)(struct MP4UserDataAtom *self, MP4Handle userDataH, u32 userDataType, + u32 *outIndex); + MP4Err (*getEntryCount)(struct MP4UserDataAtom *self, u32 userDataType, u32 *outCount); + MP4Err (*getIndType)(struct MP4UserDataAtom *self, u32 typeIndex, u32 *outType); + MP4Err (*getItem)(struct MP4UserDataAtom *self, MP4Handle userDataH, u32 userDataType, + u32 itemIndex); + MP4Err (*getAtom)(struct MP4UserDataAtom *self, MP4AtomPtr *outatom, u32 userDataType, + u32 itemIndex); + MP4Err (*deleteItem)(struct MP4UserDataAtom *self, u32 userDataType, u32 itemIndex); + MP4Err (*getTypeCount)(struct MP4UserDataAtom *self, u32 *outCount); + MP4LinkedList recordList; } MP4UserDataAtom, *MP4UserDataAtomPtr; typedef struct MP4CopyrightAtom { - MP4_FULL_ATOM - u32 packedLanguageCode; - char* notice; + MP4_FULL_ATOM + u32 packedLanguageCode; + char *notice; } MP4CopyrightAtom, *MP4CopyrightAtomPtr; typedef struct MP4TrackReferenceTypeAtom { - MP4_BASE_ATOM - MP4Err (*addTrackID)( struct MP4TrackReferenceTypeAtom *self, u32 trackID ); - u32 trackIDCount; - u32 *trackIDs; + MP4_BASE_ATOM + MP4Err (*addTrackID)(struct MP4TrackReferenceTypeAtom *self, u32 trackID); + u32 trackIDCount; + u32 *trackIDs; } MP4TrackReferenceTypeAtom, *MP4TrackReferenceTypeAtomPtr; -typedef struct MP4TrackGroupTypeAtom { - MP4_FULL_ATOM - MP4Err(*setGroupID)(struct MP4TrackGroupTypeAtom *self, u32 track_group_id); - u32 track_group_id; +typedef struct MP4TrackGroupTypeAtom +{ + MP4_FULL_ATOM + MP4Err (*setGroupID)(struct MP4TrackGroupTypeAtom *self, u32 track_group_id); + u32 track_group_id; } MP4TrackGroupTypeAtom, *MP4TrackGroupTypeAtomPtr; - - - /* track fragment stuff */ -enum { - fragment_difference_sample_flag = 0x10000 +enum +{ + fragment_difference_sample_flag = 0x10000 }; typedef struct MP4MovieFragmentAtom { - MP4_BASE_ATOM - COMMON_MOVIE_ATOM_FIELDS + MP4_BASE_ATOM + COMMON_MOVIE_ATOM_FIELDS - MP4Err (*addAtom)( struct MP4MovieFragmentAtom *self, MP4AtomPtr atom ); - MP4Err (*mergeFragments)( struct MP4MovieFragmentAtom* self, MP4MovieAtomPtr moov ); - MP4AtomPtr mfhd; /* the movie fragment header */ - MP4PrivateMovieRecordPtr moov; - MP4LinkedList atomList; /* the track fragments */ + MP4Err (*addAtom)(struct MP4MovieFragmentAtom *self, MP4AtomPtr atom); + MP4Err (*mergeFragments)(struct MP4MovieFragmentAtom *self, MP4MovieAtomPtr moov); + MP4AtomPtr mfhd; /* the movie fragment header */ + MP4PrivateMovieRecordPtr moov; + MP4LinkedList atomList; /* the track fragments */ } MP4MovieFragmentAtom, *MP4MovieFragmentAtomPtr; typedef struct MP4MovieFragmentHeaderAtom { - MP4_FULL_ATOM - u32 sequence_number; + MP4_FULL_ATOM + u32 sequence_number; } MP4MovieFragmentHeaderAtom, *MP4MovieFragmentHeaderAtomPtr; typedef struct MP4MovieExtendsAtom { - MP4_FULL_ATOM - MP4LinkedList trackExtendsList; - MP4LinkedList trackExtensionPropertiesList; - MP4Err (*addAtom)( struct MP4MovieExtendsAtom *self, MP4AtomPtr atom ); - MP4Err (*maketrackfragments) (struct MP4MovieExtendsAtom *self, MP4MovieFragmentAtomPtr moof, MP4MovieAtomPtr moov, MP4MediaDataAtomPtr mdat ); - MP4Err (*getTrackExtendsAtom)( struct MP4MovieExtendsAtom* self, u32 trackID, MP4AtomPtr *outTrack ); - MP4Err (*getTrackExtensionPropertiesAtom)( struct MP4MovieExtendsAtom* self, u32 trackID, MP4AtomPtr *outProb); - MP4Err (*setSampleDescriptionIndexes)( struct MP4MovieExtendsAtom* self, MP4AtomPtr moov ); - MP4Err (*setCompositionToDecodeProperties) (struct MP4MovieExtendsAtom *self, u32 trackID, s32 compositionToDTSShift, s32 leastDecodeToDisplayDelta, - s32 greatestDecodeToDisplayDelta, s32 compositionStartTime, s32 compositionEndTime); + MP4_FULL_ATOM + MP4LinkedList trackExtendsList; + MP4LinkedList trackExtensionPropertiesList; + MP4Err (*addAtom)(struct MP4MovieExtendsAtom *self, MP4AtomPtr atom); + MP4Err (*maketrackfragments)(struct MP4MovieExtendsAtom *self, MP4MovieFragmentAtomPtr moof, + MP4MovieAtomPtr moov, MP4MediaDataAtomPtr mdat); + MP4Err (*getTrackExtendsAtom)(struct MP4MovieExtendsAtom *self, u32 trackID, + MP4AtomPtr *outTrack); + MP4Err (*getTrackExtensionPropertiesAtom)(struct MP4MovieExtendsAtom *self, u32 trackID, + MP4AtomPtr *outProb); + MP4Err (*setSampleDescriptionIndexes)(struct MP4MovieExtendsAtom *self, MP4AtomPtr moov); + MP4Err (*setCompositionToDecodeProperties)(struct MP4MovieExtendsAtom *self, u32 trackID, + s32 compositionToDTSShift, + s32 leastDecodeToDisplayDelta, + s32 greatestDecodeToDisplayDelta, + s32 compositionStartTime, s32 compositionEndTime); } MP4MovieExtendsAtom, *MP4MovieExtendsAtomPtr; typedef struct MP4TrackExtensionPropertiesAtom { - MP4_FULL_ATOM - u32 track_id; - MP4LinkedList atomList; - MP4Err (*addAtom)( struct MP4TrackExtensionPropertiesAtom *self, MP4AtomPtr atom ); - MP4Err (*getAtom)( struct MP4TrackExtensionPropertiesAtom *self, u32 atomType, MP4AtomPtr *outAtom ); + MP4_FULL_ATOM + u32 track_id; + MP4LinkedList atomList; + MP4Err (*addAtom)(struct MP4TrackExtensionPropertiesAtom *self, MP4AtomPtr atom); + MP4Err (*getAtom)(struct MP4TrackExtensionPropertiesAtom *self, u32 atomType, + MP4AtomPtr *outAtom); } MP4TrackExtensionPropertiesAtom, *MP4TrackExtensionPropertiesAtomPtr; typedef struct MP4TrackExtendsAtom { - MP4_FULL_ATOM - u32 trackID; - u8 isInitialMediaDecodeTimeAdded; - u32 baseMediaDecodeTime; - u32 default_sample_description_index; - u32 default_sample_duration; - u32 default_sample_size; - u32 default_sample_flags; + MP4_FULL_ATOM + u32 trackID; + u8 isInitialMediaDecodeTimeAdded; + u32 baseMediaDecodeTime; + u32 default_sample_description_index; + u32 default_sample_duration; + u32 default_sample_size; + u32 default_sample_flags; } MP4TrackExtendsAtom, *MP4TrackExtendsAtomPtr; typedef struct MP4TrackFragmentHeaderAtom { - MP4_FULL_ATOM - u32 trackID; - u64 base_data_offset; - u32 sample_description_index; - u32 default_sample_duration; - u32 default_sample_size; - u32 default_sample_flags; + MP4_FULL_ATOM + u32 trackID; + u64 base_data_offset; + u32 sample_description_index; + u32 default_sample_duration; + u32 default_sample_size; + u32 default_sample_flags; } MP4TrackFragmentHeaderAtom, *MP4TrackFragmentHeaderAtomPtr; typedef struct MP4TrackFragmentAtom { MP4_FULL_ATOM COMMON_MINF_ATOM_FIELDS - MP4AtomPtr tfhd; - MP4AtomPtr tfdt; - MP4AtomPtr trex; - - MP4Err (*mergeRuns)( struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia ); - MP4Err (*calculateDataEnd)( struct MP4TrackFragmentAtom *self, u32* outSize); - MP4Err (*mergeSampleAuxiliaryInformation)( struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia ); - MP4Err (*getSampleAuxiliaryInfoFromTrackFragment)(struct MP4TrackFragmentAtom *self, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, - MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut); - - MP4Err (*addGroupDescription)(struct MP4TrackFragmentAtom *self, u32 groupType, MP4Handle description, u32 *index ); - MP4Err (*getSampleGroupMap)( struct MP4TrackFragmentAtom *self, u32 groupType, u32 sample_number, u32* group_index ); - MP4Err (*getGroupDescription)( struct MP4TrackFragmentAtom *self, u32 theType, u32 index, MP4Handle theDescription ); + MP4AtomPtr tfhd; + MP4AtomPtr tfdt; + MP4AtomPtr trex; + + MP4Err (*mergeRuns)(struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia); + MP4Err (*calculateDataEnd)(struct MP4TrackFragmentAtom *self, u32 *outSize); + MP4Err (*mergeSampleAuxiliaryInformation)(struct MP4TrackFragmentAtom *self, + MP4MediaAtomPtr mdia); + MP4Err (*getSampleAuxiliaryInfoFromTrackFragment)( + struct MP4TrackFragmentAtom *self, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, + u32 aux_info_type_parameter, MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, + MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut); + + MP4Err (*addGroupDescription)(struct MP4TrackFragmentAtom *self, u32 groupType, + MP4Handle description, u32 *index); + MP4Err (*getSampleGroupMap)(struct MP4TrackFragmentAtom *self, u32 groupType, u32 sample_number, + u32 *group_index); + MP4Err (*getGroupDescription)(struct MP4TrackFragmentAtom *self, u32 theType, u32 index, + MP4Handle theDescription); u32 default_sample_description_index; /* all copied from the matching trex */ u32 default_sample_duration; u32 default_sample_size; u32 default_sample_flags; MP4MediaDataAtomPtr mdat; - u32 samples_use_mdat; /* 0 -- not yet decided, 1=yes, 2=no */ + u32 samples_use_mdat; /* 0 -- not yet decided, 1=yes, 2=no */ u8 useSignedCompositionTimeOffsets; - MP4LinkedList atomList; /* track runs */ - MP4LinkedList groupDescriptionList; /* sample group description list */ - MP4LinkedList groupList; /* sample to group maps */ - MP4LinkedList compactSampleGroupList; /* compact sample to group maps */ + MP4LinkedList atomList; /* track runs */ + MP4LinkedList groupDescriptionList; /* sample group description list */ + MP4LinkedList groupList; /* sample to group maps */ + MP4LinkedList compactSampleGroupList; /* compact sample to group maps */ MP4LinkedList saizList; MP4LinkedList saioList; } MP4TrackFragmentAtom, *MP4TrackFragmentAtomPtr; -enum { - tfhd_base_data_offset_present = 0x01, - tfhd_sample_description_index_present = 0x02, - tfhd_default_sample_duration_present = 0x08, - tfhd_default_sample_size_present = 0x10, - tfhd_default_sample_flags_present = 0x20, - tfhd_duration_is_empty = 0x10000, - tfhd_default_base_is_moof = 0x20000 +enum +{ + tfhd_base_data_offset_present = 0x01, + tfhd_sample_description_index_present = 0x02, + tfhd_default_sample_duration_present = 0x08, + tfhd_default_sample_size_present = 0x10, + tfhd_default_sample_flags_present = 0x20, + tfhd_duration_is_empty = 0x10000, + tfhd_default_base_is_moof = 0x20000 }; typedef struct MP4TrackRunEntry { - u32 sample_duration; - u32 sample_size; - u32 sample_flags; - u32 sample_composition_time_offset; + u32 sample_duration; + u32 sample_size; + u32 sample_flags; + u32 sample_composition_time_offset; } MP4TrackRunEntry, *MP4TrackRunEntryPtr; -enum { - trun_data_offset_present = 0x01, - trun_first_sample_flags_present = 0x04, - trun_sample_duration_present = 0x100, - trun_sample_size_present = 0x200, - trun_sample_flags_present = 0x400, - trun_sample_composition_times_present = 0x800 +enum +{ + trun_data_offset_present = 0x01, + trun_first_sample_flags_present = 0x04, + trun_sample_duration_present = 0x100, + trun_sample_size_present = 0x200, + trun_sample_flags_present = 0x400, + trun_sample_composition_times_present = 0x800 }; -#define trun_all_sample_flags (trun_sample_duration_present + trun_sample_size_present +trun_sample_flags_present + trun_sample_composition_times_present) +#define trun_all_sample_flags \ + (trun_sample_duration_present + trun_sample_size_present + trun_sample_flags_present + \ + trun_sample_composition_times_present) typedef struct MP4TrackFragmentDecodeTimeAtom { - MP4_FULL_ATOM - u32 baseMediaDecodeTime; + MP4_FULL_ATOM + u32 baseMediaDecodeTime; } MP4TrackFragmentDecodeTimeAtom, *MP4TrackFragmentDecodeTimeAtomPtr; typedef struct MP4ItemPropertyContainerAtom { - MP4_BASE_ATOM - MP4LinkedList atomList; + MP4_BASE_ATOM + MP4LinkedList atomList; - ISOErr(*addAtom)(struct MP4ItemPropertyContainerAtom* self, MP4AtomPtr atom); + ISOErr (*addAtom)(struct MP4ItemPropertyContainerAtom *self, MP4AtomPtr atom); } MP4ItemPropertyContainerAtom, *MP4ItemPropertyContainerAtomPtr; - typedef struct MP4ItemPropertyAssociationEntryPropertyIndex { - u8 essential; - u16 property_index; + u8 essential; + u16 property_index; } MP4ItemPropertyAssociationEntryPropertyIndex, *MP4ItemPropertyAssociationEntryPropertyIndexPtr; typedef struct MP4ItemPropertyAssociationEntry { - u32 item_ID; - MP4LinkedList propertyIndexes; + u32 item_ID; + MP4LinkedList propertyIndexes; } MP4ItemPropertyAssociationEntry, *MP4ItemPropertyAssociationEntryPtr; typedef struct MP4ItemPropertyAssociationAtom { - MP4_FULL_ATOM - MP4LinkedList entries; + MP4_FULL_ATOM + MP4LinkedList entries; - ISOErr(*addEntry)(struct MP4ItemPropertyAssociationAtom* self, MP4ItemPropertyAssociationEntryPtr entry); + ISOErr (*addEntry)(struct MP4ItemPropertyAssociationAtom *self, + MP4ItemPropertyAssociationEntryPtr entry); } MP4ItemPropertyAssociationAtom, *MP4ItemPropertyAssociationAtomPtr; typedef struct MP4ItemPropertiesAtom { - MP4_BASE_ATOM - MP4ItemPropertyContainerAtomPtr ipco; - MP4ItemPropertyAssociationAtomPtr ipma; - MP4LinkedList atomList; + MP4_BASE_ATOM + MP4ItemPropertyContainerAtomPtr ipco; + MP4ItemPropertyAssociationAtomPtr ipma; + MP4LinkedList atomList; - ISOErr(*addAtom)(struct MP4ItemPropertiesAtom* self, MP4AtomPtr atom); - ISOErr(*addItemProperty)(struct MP4ItemPropertiesAtom* self, MP4AtomPtr itemProperty, u32 itemID, u8 essential); - ISOErr(*getPropertiesOfItem)(struct MP4ItemPropertiesAtom* self, u32 itemID, MP4LinkedList *properties); + ISOErr (*addAtom)(struct MP4ItemPropertiesAtom *self, MP4AtomPtr atom); + ISOErr (*addItemProperty)(struct MP4ItemPropertiesAtom *self, MP4AtomPtr itemProperty, u32 itemID, + u8 essential); + ISOErr (*getPropertiesOfItem)(struct MP4ItemPropertiesAtom *self, u32 itemID, + MP4LinkedList *properties); } MP4ItemPropertiesAtom, *MP4ItemPropertiesAtomPtr; typedef struct MP4TrackRunAtom { - MP4_FULL_ATOM - u32 samplecount; - s32 data_offset; - u32 first_sample_flags; - MP4TrackRunEntryPtr entries; - - void (*calculateDefaults) (struct MP4TrackRunAtom *self, MP4TrackFragmentHeaderAtomPtr tfhd, u32 flags_index ); - void (*setFlags) (struct MP4TrackRunAtom *self, MP4TrackFragmentHeaderAtomPtr tfhd ); + MP4_FULL_ATOM + u32 samplecount; + s32 data_offset; + u32 first_sample_flags; + MP4TrackRunEntryPtr entries; + + void (*calculateDefaults)(struct MP4TrackRunAtom *self, MP4TrackFragmentHeaderAtomPtr tfhd, + u32 flags_index); + void (*setFlags)(struct MP4TrackRunAtom *self, MP4TrackFragmentHeaderAtomPtr tfhd); } MP4TrackRunAtom, *MP4TrackRunAtomPtr; typedef struct ISOFileTypeAtom { - MP4_BASE_ATOM - - ISOErr (*addStandard)(struct ISOFileTypeAtom *self, u32 standard ); - ISOErr (*setBrand)(struct ISOFileTypeAtom *self, u32 standard, u32 minorversion ); - ISOErr (*getBrand)(struct ISOFileTypeAtom *self, u32* standard, u32* minorversion ); - u32 (*getStandard)(struct ISOFileTypeAtom *self, u32 standard ); - u32 brand; /* the brand of this file */ - u32 minorVersion; /* the minor version of this file */ - u32 itemCount; /* the number of items in the compatibility list */ - u32 *compatibilityList; /* standards this file conforms to */ + MP4_BASE_ATOM + + ISOErr (*addStandard)(struct ISOFileTypeAtom *self, u32 standard); + ISOErr (*setBrand)(struct ISOFileTypeAtom *self, u32 standard, u32 minorversion); + ISOErr (*getBrand)(struct ISOFileTypeAtom *self, u32 *standard, u32 *minorversion); + u32 (*getStandard)(struct ISOFileTypeAtom *self, u32 standard); + u32 brand; /* the brand of this file */ + u32 minorVersion; /* the minor version of this file */ + u32 itemCount; /* the number of items in the compatibility list */ + u32 *compatibilityList; /* standards this file conforms to */ } ISOFileTypeAtom, *ISOFileTypeAtomPtr; typedef struct MP4TrackTypeAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM - ISOErr(*addStandard)(struct MP4TrackTypeAtom *self, u32 standard); - ISOErr(*setBrand)(struct MP4TrackTypeAtom *self, u32 standard, u32 minorversion); - ISOErr(*getBrand)(struct MP4TrackTypeAtom *self, u32* standard, u32* minorversion); - u32(*getStandard)(struct MP4TrackTypeAtom *self, u32 standard); + ISOErr (*addStandard)(struct MP4TrackTypeAtom *self, u32 standard); + ISOErr (*setBrand)(struct MP4TrackTypeAtom *self, u32 standard, u32 minorversion); + ISOErr (*getBrand)(struct MP4TrackTypeAtom *self, u32 *standard, u32 *minorversion); + u32 (*getStandard)(struct MP4TrackTypeAtom *self, u32 standard); - u32 majorBrand; /* the brand of this track */ - u32 minorVersion; /* the minor version of this track */ - u32 itemCount; /* the number of items in the compatibility list */ - u32 *compatibilityList; + u32 majorBrand; /* the brand of this track */ + u32 minorVersion; /* the minor version of this track */ + u32 itemCount; /* the number of items in the compatibility list */ + u32 *compatibilityList; } MP4TrackTypeAtom, *MP4TrackTypeAtomPtr; typedef struct MP4SchemeTypeAtom { - MP4_FULL_ATOM - u32 scheme_type; - u32 scheme_version; + MP4_FULL_ATOM + u32 scheme_type; + u32 scheme_version; - char* scheme_url; /* if (flags & 0x000001), a scheme URL is present */ + char *scheme_url; /* if (flags & 0x000001), a scheme URL is present */ } MP4SchemeTypeAtom, *MP4SchemeTypeAtomPtr; typedef struct MP4CompatibleSchemeTypeAtom { - MP4_FULL_ATOM - u32 scheme_type; - u32 scheme_version; + MP4_FULL_ATOM + u32 scheme_type; + u32 scheme_version; - char* scheme_url; + char *scheme_url; } MP4CompatibleSchemeTypeAtom, *MP4CompatibleSchemeTypeAtomPtr; typedef struct MP4RestrictedSchemeInfoAtom { - MP4_BASE_ATOM - MP4AtomPtr MP4OriginalFormat; /* ('frma') */ - MP4AtomPtr MP4SchemeType; /* ('schm') */ - MP4AtomPtr MP4SchemeInfo; /* optional ('schi') */ + MP4_BASE_ATOM + MP4AtomPtr MP4OriginalFormat; /* ('frma') */ + MP4AtomPtr MP4SchemeType; /* ('schm') */ + MP4AtomPtr MP4SchemeInfo; /* optional ('schi') */ - MP4LinkedList atomList; /* may contain one or more instances of CompatibleSchemeTypeBox */ - - MP4Err(*addAtom)(struct MP4RestrictedSchemeInfoAtom* self, MP4AtomPtr atom); + MP4LinkedList atomList; /* may contain one or more instances of CompatibleSchemeTypeBox */ + + MP4Err (*addAtom)(struct MP4RestrictedSchemeInfoAtom *self, MP4AtomPtr atom); } MP4RestrictedSchemeInfoAtom, *MP4RestrictedSchemeInfoAtomPtr; -typedef struct MP4StereoVideoAtom { - - MP4_FULL_ATOM +typedef struct MP4StereoVideoAtom +{ + + MP4_FULL_ATOM + + u32 reserved; /* unsigned int(30) = 0 */ + u8 single_view_allowed; /* unsigned int(2) */ + u32 stereo_scheme; /* unsigned int(32) */ + u32 length; /* unsigned int(32) */ + u8 *stereo_indication_type; /* unsigned int(8)[length] */ - u32 reserved; /* unsigned int(30) = 0 */ - u8 single_view_allowed; /* unsigned int(2) */ - u32 stereo_scheme; /* unsigned int(32) */ - u32 length; /* unsigned int(32) */ - u8 *stereo_indication_type; /* unsigned int(8)[length] */ - - MP4LinkedList atomList; /* optional */ - - MP4Err(*addAtom)(struct MP4StereoVideoAtom* self, MP4AtomPtr atom); + MP4LinkedList atomList; /* optional */ + + MP4Err (*addAtom)(struct MP4StereoVideoAtom *self, MP4AtomPtr atom); } MP4StereoVideoAtom, *MP4StereoVideoAtomPtr; -typedef struct MP4StereoVideoGroupAtom { +typedef struct MP4StereoVideoGroupAtom +{ - MP4_FULL_ATOM + MP4_FULL_ATOM - u32 trackGroupID; /* unsigned int(32), inherited from TrackGroupTypeAtom */ + u32 trackGroupID; /* unsigned int(32), inherited from TrackGroupTypeAtom */ - u8 leftViewFlag; /* unsigned int(1) */ - char reserved[4]; /* bit(31) = 0 */ + u8 leftViewFlag; /* unsigned int(1) */ + char reserved[4]; /* bit(31) = 0 */ } MP4StereoVideoGroupAtom, *MP4StereoVideoGroupAtomPtr; -typedef struct MP4RestrictedVideoSampleEntryAtom { - MP4_BASE_ATOM - COMMON_SAMPLE_ENTRY_FIELDS +typedef struct MP4RestrictedVideoSampleEntryAtom +{ + MP4_BASE_ATOM + COMMON_SAMPLE_ENTRY_FIELDS - MP4AtomPtr MP4RestrictedSchemeInfo; - u32 restriction_type; + MP4AtomPtr MP4RestrictedSchemeInfo; + u32 restriction_type; - MP4Err(*addSchemeInfoAtom) (struct MP4Atom *self, struct MP4Atom *theAtom); - MP4Err(*getSchemeInfoAtom) (struct MP4Atom *self, u32 theType, struct MP4Atom **theAtom); - MP4Err(*getScheme) (struct MP4Atom *self, u32* sch_type, u32* sch_version, char** sch_url); + MP4Err (*addSchemeInfoAtom)(struct MP4Atom *self, struct MP4Atom *theAtom); + MP4Err (*getSchemeInfoAtom)(struct MP4Atom *self, u32 theType, struct MP4Atom **theAtom); + MP4Err (*getScheme)(struct MP4Atom *self, u32 *sch_type, u32 *sch_version, char **sch_url); - MP4Err(*transform) (struct MP4Atom *self, u32 sch_type, u32 sch_version, char* sch_url); - MP4Err(*untransform) (struct MP4Atom *self); + MP4Err (*transform)(struct MP4Atom *self, u32 sch_type, u32 sch_version, char *sch_url); + MP4Err (*untransform)(struct MP4Atom *self); - MP4Err(*addAtom)(struct MP4RestrictedVideoSampleEntryAtom* self, MP4AtomPtr atom); + MP4Err (*addAtom)(struct MP4RestrictedVideoSampleEntryAtom *self, MP4AtomPtr atom); - char reserved1[6]; - char reserved2[16]; /* uint(32)[4] */ - /* u32 reserved3; uint(32) = 0x01400f0 */ - u32 width; - u32 height; - u32 reserved4; /* uint(32) = 0x0048000 */ - u32 reserved5; /* uint(32) = 0x0048000 */ - u32 reserved6; /* uint(32) = 0 */ - u32 reserved7; /* uint(16) = 1 */ - u32 nameLength; - char name31[31]; - u32 reserved8; /* uint(16) = 24 */ - s32 reserved9; /* int(16) = -1 */ + char reserved1[6]; + char reserved2[16]; /* uint(32)[4] */ + /* u32 reserved3; uint(32) = 0x01400f0 */ + u32 width; + u32 height; + u32 reserved4; /* uint(32) = 0x0048000 */ + u32 reserved5; /* uint(32) = 0x0048000 */ + u32 reserved6; /* uint(32) = 0 */ + u32 reserved7; /* uint(16) = 1 */ + u32 nameLength; + char name31[31]; + u32 reserved8; /* uint(16) = 24 */ + s32 reserved9; /* int(16) = -1 */ } MP4RestrictedVideoSampleEntryAtom, *MP4RestrictedVideoSampleEntryAtomPtr; typedef struct MP4OriginalFormatAtom { - MP4_BASE_ATOM - u32 original_format; + MP4_BASE_ATOM + u32 original_format; } MP4OriginalFormatAtom, *MP4OriginalFormatAtomPtr; typedef struct MP4SchemeInfoAtom { - MP4_BASE_ATOM + MP4_BASE_ATOM - MP4LinkedList atomList; /* this atom may include a variable number of atoms */ - ISOErr(*addAtom)(struct MP4SchemeInfoAtom* self, MP4AtomPtr atom); + MP4LinkedList atomList; /* this atom may include a variable number of atoms */ + ISOErr (*addAtom)(struct MP4SchemeInfoAtom *self, MP4AtomPtr atom); } MP4SchemeInfoAtom, *MP4SchemeInfoAtomPtr; - - - #ifdef ISMACrypt typedef struct MP4SecurityInfoAtom { - MP4_BASE_ATOM - MP4AtomPtr MP4OriginalFormat; - MP4AtomPtr MP4SchemeType; - MP4AtomPtr MP4SchemeInfo; + MP4_BASE_ATOM + MP4AtomPtr MP4OriginalFormat; + MP4AtomPtr MP4SchemeType; + MP4AtomPtr MP4SchemeInfo; } MP4SecurityInfoAtom, *MP4SecurityInfoAtomPtr; typedef struct ISMAKMSAtom { - MP4_FULL_ATOM - char* kms_url; - + MP4_FULL_ATOM + char *kms_url; + } ISMAKMSAtom, *ISMAKMSAtomPtr; typedef struct ISMASampleFormatAtom { - MP4_FULL_ATOM - u32 selective_encryption; - u32 key_indicator_len; - u32 IV_len; - + MP4_FULL_ATOM + u32 selective_encryption; + u32 key_indicator_len; + u32 IV_len; + } ISMASampleFormatAtom, *ISMASampleFormatAtomPtr; typedef struct ISMASaltAtom { - MP4_BASE_ATOM - u64 salt; + MP4_BASE_ATOM + u64 salt; } ISMASaltAtom, *ISMASaltAtomPtr; -#define COMMON_ENC_SAMPLE_ENTRY_FIELDS \ - COMMON_SAMPLE_ENTRY_FIELDS \ - MP4AtomPtr SecurityInfo; \ - u32 enc_type; \ - MP4Err (*transform) (struct MP4Atom *self, u32 sch_type, u32 sch_version, char* sch_url ); \ - MP4Err (*untransform) (struct MP4Atom *self ); \ - MP4Err (*addSchemeInfoAtom) (struct MP4Atom *self, struct MP4Atom *theAtom ); \ - MP4Err (*getSchemeInfoAtom) (struct MP4Atom *self, u32 theType, struct MP4Atom **theAtom ); \ - MP4Err (*getScheme) (struct MP4Atom *self, u32* sch_type, u32* sch_version, char** sch_url ); +#define COMMON_ENC_SAMPLE_ENTRY_FIELDS \ + COMMON_SAMPLE_ENTRY_FIELDS \ + MP4AtomPtr SecurityInfo; \ + u32 enc_type; \ + MP4Err (*transform)(struct MP4Atom * self, u32 sch_type, u32 sch_version, char *sch_url); \ + MP4Err (*untransform)(struct MP4Atom * self); \ + MP4Err (*addSchemeInfoAtom)(struct MP4Atom * self, struct MP4Atom * theAtom); \ + MP4Err (*getSchemeInfoAtom)(struct MP4Atom * self, u32 theType, struct MP4Atom * *theAtom); \ + MP4Err (*getScheme)(struct MP4Atom * self, u32 * sch_type, u32 * sch_version, char **sch_url); typedef struct MP4EncBaseSampleEntryAtom { - MP4_BASE_ATOM - COMMON_ENC_SAMPLE_ENTRY_FIELDS + MP4_BASE_ATOM + COMMON_ENC_SAMPLE_ENTRY_FIELDS } MP4EncBaseSampleEntryAtom, *MP4EncBaseSampleEntryAtomPtr; typedef struct MP4EncVisualSampleEntryAtom { - MP4_BASE_ATOM - COMMON_ENC_SAMPLE_ENTRY_FIELDS - - char reserved1[ 6 ]; - char reserved2[ 16 ]; /* uint(32)[4] */ - /* u32 reserved3; uint(32) = 0x01400f0 */ - u32 width; - u32 height; - u32 reserved4; /* uint(32) = 0x0048000 */ - u32 reserved5; /* uint(32) = 0x0048000 */ - u32 reserved6; /* uint(32) = 0 */ - u32 reserved7; /* uint(16) = 1 */ - u32 nameLength; - char name31[31]; - u32 reserved8; /* uint(16) = 24 */ - s32 reserved9; /* int(16) = -1 */ + MP4_BASE_ATOM + COMMON_ENC_SAMPLE_ENTRY_FIELDS + + char reserved1[6]; + char reserved2[16]; /* uint(32)[4] */ + /* u32 reserved3; uint(32) = 0x01400f0 */ + u32 width; + u32 height; + u32 reserved4; /* uint(32) = 0x0048000 */ + u32 reserved5; /* uint(32) = 0x0048000 */ + u32 reserved6; /* uint(32) = 0 */ + u32 reserved7; /* uint(16) = 1 */ + u32 nameLength; + char name31[31]; + u32 reserved8; /* uint(16) = 24 */ + s32 reserved9; /* int(16) = -1 */ } MP4EncVisualSampleEntryAtom, *MP4EncVisualSampleEntryAtomPtr; typedef struct MP4EncAudioSampleEntryAtom { - MP4_BASE_ATOM - COMMON_ENC_SAMPLE_ENTRY_FIELDS - - char reserved1[ 6 ]; - char reserved2[ 8 ]; /* uint(32)[2] */ - u32 reserved3; /* uint(16) = 2 */ - u32 reserved4; /* uint(16) = 16 */ - u32 reserved5; /* uint(32) = 0 */ - u32 timeScale; /* uint(16) copied from track! */ - u32 reserved6; /* uint(16) = 0 */ + MP4_BASE_ATOM + COMMON_ENC_SAMPLE_ENTRY_FIELDS + + char reserved1[6]; + char reserved2[8]; /* uint(32)[2] */ + u32 reserved3; /* uint(16) = 2 */ + u32 reserved4; /* uint(16) = 16 */ + u32 reserved5; /* uint(32) = 0 */ + u32 timeScale; /* uint(16) copied from track! */ + u32 reserved6; /* uint(16) = 0 */ } MP4EncAudioSampleEntryAtom, *MP4EncAudioSampleEntryAtomPtr; #endif -typedef struct sampleGroupEntry { - u32 groupSize; - char* groupDescription; +typedef struct sampleGroupEntry +{ + u32 groupSize; + char *groupDescription; } sampleGroupEntry; #define COMMON_GROUP_ATOM_FIELDS \ - MP4_FULL_ATOM \ - u32 grouping_type; + MP4_FULL_ATOM \ + u32 grouping_type; typedef struct MP4SampleGroupDescriptionAtom { - COMMON_GROUP_ATOM_FIELDS - - u32 default_length; /* we only handle version 1 */ - - u32 groupCount; - - sampleGroupEntry* groups; - - MP4Err (*addGroupDescription)( struct MP4SampleGroupDescriptionAtom *self, MP4Handle theDescription, u32* index ); - MP4Err (*getGroupDescription)( struct MP4SampleGroupDescriptionAtom *self, u32 index, MP4Handle theDescription ); + COMMON_GROUP_ATOM_FIELDS + + u32 default_length; /* we only handle version 1 */ + + u32 groupCount; + + sampleGroupEntry *groups; + + MP4Err (*addGroupDescription)(struct MP4SampleGroupDescriptionAtom *self, + MP4Handle theDescription, u32 *index); + MP4Err (*getGroupDescription)(struct MP4SampleGroupDescriptionAtom *self, u32 index, + MP4Handle theDescription); } MP4SampleGroupDescriptionAtom, *MP4SampleGroupDescriptionAtomPtr; typedef struct MP4SampletoGroupAtom { - COMMON_GROUP_ATOM_FIELDS + COMMON_GROUP_ATOM_FIELDS + + u32 *group_index; /* indexed by sample number; we compact on write and expand on read */ + u32 sampleCount; + u32 entryCount; + u32 allocatedSize; - u32* group_index; /* indexed by sample number; we compact on write and expand on read */ - u32 sampleCount; - u32 entryCount; - u32 allocatedSize; - - MP4Err (*addSamples)( struct MP4SampletoGroupAtom *self, u32 count ); - MP4Err (*mapSamplestoGroup)( struct MP4SampletoGroupAtom *self, u32 group_index, s32 sample_index, u32 count ); - MP4Err (*getSampleGroupMap)( struct MP4SampletoGroupAtom *self, u32 sampleNumber, u32* groupIndex ); + MP4Err (*addSamples)(struct MP4SampletoGroupAtom *self, u32 count); + MP4Err (*mapSamplestoGroup)(struct MP4SampletoGroupAtom *self, u32 group_index, s32 sample_index, + u32 count); + MP4Err (*getSampleGroupMap)(struct MP4SampletoGroupAtom *self, u32 sampleNumber, u32 *groupIndex); } MP4SampletoGroupAtom, *MP4SampletoGroupAtomPtr; typedef struct MP4CompactSampleToGroupPatternEntry { - u32 patternLength; - u32 sampleCount; + u32 patternLength; + u32 sampleCount; } MP4CompactSampleToGroupPatternEntry, *MP4CompactSampleToGroupPatternEntryPtr; -typedef struct { - u32 patternCount; - u32 totalSampleCount; - u32 totalIndexDescriptionCount; - u32 efficientStartIndex; - u8 patternLengthFieldSize; - u8 sampleCountFieldSize; - u8 indexFieldSize; - u8 isSampleGroupCompressed; - - MP4CompactSampleToGroupPatternEntryPtr patternEntries; - u32* indexDescriptionArray; - +typedef struct +{ + u32 patternCount; + u32 totalSampleCount; + u32 totalIndexDescriptionCount; + u32 efficientStartIndex; + u8 patternLengthFieldSize; + u8 sampleCountFieldSize; + u8 indexFieldSize; + u8 isSampleGroupCompressed; + + MP4CompactSampleToGroupPatternEntryPtr patternEntries; + u32 *indexDescriptionArray; + } CompressedGroupInfo; typedef struct MP4CompactSampletoGroupAtom { - COMMON_GROUP_ATOM_FIELDS - - u32 groupingTypeParameter; - u32 entryCount; - u32* group_index; /* indexed by sample number; we compact on write and expand on read */ - u32 sampleCount; - u32 allocatedSize; - u8 fragmentLocalIndexPresent; - u32 mapSampleToGroupIndex; - CompressedGroupInfo compressedGroup; - - MP4Err (*addSamples)( struct MP4CompactSampletoGroupAtom *self, u32 count ); - MP4Err (*mapSamplestoGroup)( struct MP4CompactSampletoGroupAtom *self, u32 group_index, s32 sample_index, u32 count ); - MP4Err (*getSampleGroupMap)( struct MP4CompactSampletoGroupAtom *self, u32 sampleNumber, u32* groupIndex ); + COMMON_GROUP_ATOM_FIELDS + + u32 groupingTypeParameter; + u32 entryCount; + u32 *group_index; /* indexed by sample number; we compact on write and expand on read */ + u32 sampleCount; + u32 allocatedSize; + u8 fragmentLocalIndexPresent; + u32 mapSampleToGroupIndex; + CompressedGroupInfo compressedGroup; + + MP4Err (*addSamples)(struct MP4CompactSampletoGroupAtom *self, u32 count); + MP4Err (*mapSamplestoGroup)(struct MP4CompactSampletoGroupAtom *self, u32 group_index, + s32 sample_index, u32 count); + MP4Err (*getSampleGroupMap)(struct MP4CompactSampletoGroupAtom *self, u32 sampleNumber, + u32 *groupIndex); } MP4CompactSampletoGroupAtom, *MP4CompactSampletoGroupAtomPtr; typedef struct ISOMetaAtom { - MP4_FULL_ATOM - MP4Err (*addMetaItemExtentReference)( struct ISOMetaAtom *self, u32 item_ID, u64 dataOffset, MP4Handle sizesH ); - MP4Err (*addMetaItemExtent)( struct MP4MediaAtom *self, u32 item_ID, MP4Handle sampleH ); - MP4Err (*addAtom)( struct ISOMetaAtom* self, MP4AtomPtr atom ); - MP4Err (*setMdat)( struct ISOMetaAtom *self, MP4AtomPtr mdat ); - MP4Err (*mdatMoved)( struct ISOMetaAtom* self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ); - MP4Err (*closeDataHandler)( struct ISOMetaAtom* self ); - MP4Err (*openDataHandler)( struct ISOMetaAtom* self, u32 dataEntryIndex ); - MP4Err (*getData)( struct ISOMetaAtom* self, u32 box_type, MP4Handle data, u8 is_full_atom ); - - MP4AtomPtr hdlr; - MP4AtomPtr dinf; - MP4AtomPtr iloc; - MP4AtomPtr iinf; - MP4AtomPtr iref; - MP4AtomPtr idat; - MP4AtomPtr pitm; - MP4AtomPtr ipro; - MP4AtomPtr iprp; - - MP4AtomPtr mdat; - MP4LinkedList atomList; - - u16 next_item_ID; - - MP4AtomPtr relatedMeco; - - struct MP4InputStreamRecord* inputStream; - void *dataHandler; - s32 dataEntryIndex; + MP4_FULL_ATOM + MP4Err (*addMetaItemExtentReference)(struct ISOMetaAtom *self, u32 item_ID, u64 dataOffset, + MP4Handle sizesH); + MP4Err (*addMetaItemExtent)(struct MP4MediaAtom *self, u32 item_ID, MP4Handle sampleH); + MP4Err (*addAtom)(struct ISOMetaAtom *self, MP4AtomPtr atom); + MP4Err (*setMdat)(struct ISOMetaAtom *self, MP4AtomPtr mdat); + MP4Err (*mdatMoved)(struct ISOMetaAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset); + MP4Err (*closeDataHandler)(struct ISOMetaAtom *self); + MP4Err (*openDataHandler)(struct ISOMetaAtom *self, u32 dataEntryIndex); + MP4Err (*getData)(struct ISOMetaAtom *self, u32 box_type, MP4Handle data, u8 is_full_atom); + + MP4AtomPtr hdlr; + MP4AtomPtr dinf; + MP4AtomPtr iloc; + MP4AtomPtr iinf; + MP4AtomPtr iref; + MP4AtomPtr idat; + MP4AtomPtr pitm; + MP4AtomPtr ipro; + MP4AtomPtr iprp; + + MP4AtomPtr mdat; + MP4LinkedList atomList; + + u16 next_item_ID; + + MP4AtomPtr relatedMeco; + + struct MP4InputStreamRecord *inputStream; + void *dataHandler; + s32 dataEntryIndex; } ISOMetaAtom, *ISOMetaAtomPtr; typedef struct ISOAdditionalMetaDataContainerAtom { - MP4_BASE_ATOM - MP4LinkedList metaList; - MP4LinkedList relationList; - MP4Err (*addMeta)( struct ISOAdditionalMetaDataContainerAtom* self, MP4AtomPtr meta ); - MP4Err (*getMeta) ( struct ISOAdditionalMetaDataContainerAtom* self, u32 type, ISOMetaAtomPtr *outMetaPtr ); - MP4Err (*mdatMoved) (struct ISOAdditionalMetaDataContainerAtom* self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ); - MP4Err (*setMdat) ( struct ISOAdditionalMetaDataContainerAtom* self, MP4AtomPtr mdat ); + MP4_BASE_ATOM + MP4LinkedList metaList; + MP4LinkedList relationList; + MP4Err (*addMeta)(struct ISOAdditionalMetaDataContainerAtom *self, MP4AtomPtr meta); + MP4Err (*getMeta)(struct ISOAdditionalMetaDataContainerAtom *self, u32 type, + ISOMetaAtomPtr *outMetaPtr); + MP4Err (*mdatMoved)(struct ISOAdditionalMetaDataContainerAtom *self, u64 mdatBase, u64 mdatEnd, + s32 mdatOffset); + MP4Err (*setMdat)(struct ISOAdditionalMetaDataContainerAtom *self, MP4AtomPtr mdat); } ISOAdditionalMetaDataContainerAtom, *ISOAdditionalMetaDataContainerAtomPtr; - typedef struct ISOMetaboxRelationAtom { - MP4_FULL_ATOM - u32 first_metabox_handler_type; - u32 second_metabox_handler_type; - u8 metabox_relation; + MP4_FULL_ATOM + u32 first_metabox_handler_type; + u32 second_metabox_handler_type; + u8 metabox_relation; } ISOMetaboxRelationAtom, *ISOMetaboxRelationAtomPtr; typedef struct ISOItemDataAtom { - MP4_BASE_ATOM - MP4Handle data; - MP4Err (*getData) ( MP4AtomPtr s, char *target, u32 offset, u32 length ); + MP4_BASE_ATOM + MP4Handle data; + MP4Err (*getData)(MP4AtomPtr s, char *target, u32 offset, u32 length); } ISOItemDataAtom, *ISOItemDataAtomPtr; typedef struct ISOItemReferenceAtom { - MP4_FULL_ATOM - MP4LinkedList atomList; + MP4_FULL_ATOM + MP4LinkedList atomList; } ISOItemReferenceAtom, *ISOItemReferenceAtomPtr; typedef struct ISOSingleItemTypeReferenceAtom { - MP4_BASE_ATOM - u32 from_item_ID; - u16 reference_count; - u32 *to_item_IDs; - u8 isLarge; + MP4_BASE_ATOM + u32 from_item_ID; + u16 reference_count; + u32 *to_item_IDs; + u8 isLarge; } ISOSingleItemTypeReferenceAtom, *ISOSingleItemTypeReferenceAtomPtr; typedef struct ISOPrimaryItemAtom { - MP4_FULL_ATOM - u32 item_ID; + MP4_FULL_ATOM + u32 item_ID; } ISOPrimaryItemAtom, *ISOPrimaryItemAtomPtr; -typedef struct MetaExtentLocation { - u64 extent_index; - u64 extent_offset; - u64 extent_length; +typedef struct MetaExtentLocation +{ + u64 extent_index; + u64 extent_offset; + u64 extent_length; } MetaExtentLocation, *MetaExtentLocationPtr; -typedef struct MetaItemLocation { - MP4AtomPtr meta; - u16 item_ID; - u8 construction_method; - u16 dref_index; - u64 base_offset; - MP4LinkedList extentList; +typedef struct MetaItemLocation +{ + MP4AtomPtr meta; + u16 item_ID; + u8 construction_method; + u16 dref_index; + u64 base_offset; + MP4LinkedList extentList; } MetaItemLocation, *MetaItemLocationPtr; typedef struct ISOItemLocationAtom { - MP4_FULL_ATOM - MP4Err (*mdatMoved)( struct ISOItemLocationAtom* self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ); - MP4Err (*setItemsMeta)( struct ISOItemLocationAtom* self, MP4AtomPtr meta ); - - u8 offset_size; - u8 length_size; - u8 base_offset_size; - u8 index_size; - MP4LinkedList itemList; + MP4_FULL_ATOM + MP4Err (*mdatMoved)(struct ISOItemLocationAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset); + MP4Err (*setItemsMeta)(struct ISOItemLocationAtom *self, MP4AtomPtr meta); + + u8 offset_size; + u8 length_size; + u8 base_offset_size; + u8 index_size; + MP4LinkedList itemList; } ISOItemLocationAtom, *ISOItemLocationAtomPtr; typedef struct ISOItemProtectionAtom { - MP4_FULL_ATOM - MP4LinkedList atomList; - MP4Err (*addAtom)( struct ISOItemProtectionAtom* self, MP4AtomPtr atom ); + MP4_FULL_ATOM + MP4LinkedList atomList; + MP4Err (*addAtom)(struct ISOItemProtectionAtom *self, MP4AtomPtr atom); } ISOItemProtectionAtom, *ISOItemProtectionAtomPtr; typedef struct ISOItemInfoEntryAtom { - MP4_FULL_ATOM - u32 item_ID; - u32 protection_index; - char* item_name; - char* content_type; - char* content_encoding; - u32 extension_type; - MP4Handle item_info_extension; - u16 item_protection_index; - u32 item_type; - char* item_uri_type; + MP4_FULL_ATOM + u32 item_ID; + u32 protection_index; + char *item_name; + char *content_type; + char *content_encoding; + u32 extension_type; + MP4Handle item_info_extension; + u16 item_protection_index; + u32 item_type; + char *item_uri_type; } ISOItemInfoEntryAtom, *ISOItemInfoEntryAtomPtr; typedef struct ISOItemInfoAtom { - MP4_FULL_ATOM - MP4LinkedList atomList; - MP4Err (*addAtom)( struct ISOItemInfoAtom* self, MP4AtomPtr atom ); - MP4Err (*getEntry) ( struct ISOItemInfoAtom* self, u32 itemID, ISOItemInfoEntryAtomPtr *outEntry ); + MP4_FULL_ATOM + MP4LinkedList atomList; + MP4Err (*addAtom)(struct ISOItemInfoAtom *self, MP4AtomPtr atom); + MP4Err (*getEntry)(struct ISOItemInfoAtom *self, u32 itemID, ISOItemInfoEntryAtomPtr *outEntry); } ISOItemInfoAtom, *ISOItemInfoAtomPtr; typedef struct MP4SampleDependencyAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM + + u8 *dependency; /* indexed by sample number; we compact on write and expand on read */ + u32 sampleCount; + u32 allocatedSize; - u8* dependency; /* indexed by sample number; we compact on write and expand on read */ - u32 sampleCount; - u32 allocatedSize; - - MP4Err (*addSamples)( struct MP4SampleDependencyAtom *self, u32 count ); - MP4Err (*setSampleDependency)( struct MP4SampleDependencyAtom *self, s32 sample_index, MP4Handle dependencies ); - MP4Err (*getSampleDependency)( struct MP4SampleDependencyAtom *self, u32 sampleNumber, u8* dependency ); + MP4Err (*addSamples)(struct MP4SampleDependencyAtom *self, u32 count); + MP4Err (*setSampleDependency)(struct MP4SampleDependencyAtom *self, s32 sample_index, + MP4Handle dependencies); + MP4Err (*getSampleDependency)(struct MP4SampleDependencyAtom *self, u32 sampleNumber, + u8 *dependency); } MP4SampleDependencyAtom, *MP4SampleDependencyAtomPtr; typedef struct SIDXReference { - u8 referenceType; - u32 referencedSize; - u32 subsegmentDuration; - u8 startsWithSAP; - u8 SAPType; - u32 SAPDeltaTime; + u8 referenceType; + u32 referencedSize; + u32 subsegmentDuration; + u8 startsWithSAP; + u8 SAPType; + u32 SAPDeltaTime; } SIDXReference, *SIDXReferencePtr; typedef struct SubsegmentRange { - u8 level; - u32 rangeSize; + u8 level; + u32 rangeSize; } SubsegmentRange, *SubsegmentRangePtr; typedef struct Subsegment { - u32 rangeCount; - MP4LinkedList rangesList; + u32 rangeCount; + MP4LinkedList rangesList; - u32(*getRangeCount)(struct Subsegment *self); - MP4Err(*addRange)(struct Subsegment *self); + u32 (*getRangeCount)(struct Subsegment *self); + MP4Err (*addRange)(struct Subsegment *self); } Subsegment, *SubsegmentPtr; typedef struct MP4SegmentTypeAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM - ISOErr(*addStandard)(struct MP4SegmentTypeAtom *self, u32 standard); - ISOErr(*setBrand)(struct MP4SegmentTypeAtom *self, u32 standard, u32 minorversion); - ISOErr(*getBrand)(struct MP4SegmentTypeAtom *self, u32* standard, u32* minorversion); - u32(*getStandard)(struct MP4SegmentTypeAtom *self, u32 standard); + ISOErr (*addStandard)(struct MP4SegmentTypeAtom *self, u32 standard); + ISOErr (*setBrand)(struct MP4SegmentTypeAtom *self, u32 standard, u32 minorversion); + ISOErr (*getBrand)(struct MP4SegmentTypeAtom *self, u32 *standard, u32 *minorversion); + u32 (*getStandard)(struct MP4SegmentTypeAtom *self, u32 standard); - u32 majorBrand; /* the brand of this track */ - u32 minorVersion; /* the minor version of this track */ - u32 itemCount; /* the number of items in the compatibility list */ - u32 *compatibilityList; + u32 majorBrand; /* the brand of this track */ + u32 minorVersion; /* the minor version of this track */ + u32 itemCount; /* the number of items in the compatibility list */ + u32 *compatibilityList; } MP4SegmentTypeAtom, *MP4SegmentTypeAtomPtr; typedef struct MP4SegmentIndexAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM - u32 referenceId; - u32 timescale; + u32 referenceId; + u32 timescale; - u32 earliestPresentationTime; - u32 firstOffset; + u32 earliestPresentationTime; + u32 firstOffset; - u16 reserved1; - u16 referenceCount; + u16 reserved1; + u16 referenceCount; - MP4LinkedList referencesList; + MP4LinkedList referencesList; - u32(*getReferenceCount)(struct MP4SegmentIndexAtom *self); - MP4Err(*addReference)(struct MP4SegmentIndexAtom *self, - u8 referenceType, u32 referencedSize, - u32 subsegmentDuration, - u8 startsWithSAP, u8 SAPType, u32 SAPDeltaTime); + u32 (*getReferenceCount)(struct MP4SegmentIndexAtom *self); + MP4Err (*addReference)(struct MP4SegmentIndexAtom *self, u8 referenceType, u32 referencedSize, + u32 subsegmentDuration, u8 startsWithSAP, u8 SAPType, u32 SAPDeltaTime); } MP4SegmentIndexAtom, *MP4SegmentIndexAtomPtr; typedef struct MP4SubsegmentIndexAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM - u32 subsegmentCount; + u32 subsegmentCount; - MP4LinkedList subsegmentsList; + MP4LinkedList subsegmentsList; - u32(*getSubsegmentCount)(struct MP4SubsegmentIndexAtom *self); - MP4Err(*addSubsegment)(struct MP4SubsegmentIndexAtom *self, struct Subsegment *ss); - MP4Err(*addSubsegmentRange)(struct Subsegment *self, u8 level, u32 rangeSize); - + u32 (*getSubsegmentCount)(struct MP4SubsegmentIndexAtom *self); + MP4Err (*addSubsegment)(struct MP4SubsegmentIndexAtom *self, struct Subsegment *ss); + MP4Err (*addSubsegmentRange)(struct Subsegment *self, u8 level, u32 rangeSize); } MP4SubsegmentIndexAtom, *MP4SubsegmentIndexAtomPtr; typedef struct MP4ProducerReferenceTimeAtom { - MP4_FULL_ATOM + MP4_FULL_ATOM - u32 referenceTrackId; - u64 ntpTimestamp; - u32 mediaTime; + u32 referenceTrackId; + u64 ntpTimestamp; + u32 mediaTime; } MP4ProducerReferenceTimeAtom, *MP4ProducerReferenceTimeAtomPtr; -MP4Err MP4GetListEntryAtom( MP4LinkedList list, u32 atomType, MP4AtomPtr* outItem ); -MP4Err MP4DeleteListEntryAtom( MP4LinkedList list, u32 atomType ); +MP4Err MP4GetListEntryAtom(MP4LinkedList list, u32 atomType, MP4AtomPtr *outItem); +MP4Err MP4DeleteListEntryAtom(MP4LinkedList list, u32 atomType); -MP4Err sampleEntryHToAtomPtr( MP4Handle sampleEntryH, MP4AtomPtr* entryPtr, u32 defaultType ); -MP4Err atomPtrToSampleEntryH( MP4Handle sampleEntryH, MP4AtomPtr entry ); +MP4Err sampleEntryHToAtomPtr(MP4Handle sampleEntryH, MP4AtomPtr *entryPtr, u32 defaultType); +MP4Err atomPtrToSampleEntryH(MP4Handle sampleEntryH, MP4AtomPtr entry); -MP4Err MP4CreateAudioSampleEntryAtom( MP4AudioSampleEntryAtomPtr *outAtom ); -MP4Err MP4CreatePCMConfigAtom ( MP4PCMConfigAtomPtr *outAtom ); -MP4Err MP4CreateChannelLayoutAtom( MP4ChannelLayoutAtomPtr *outAtom ); -MP4Err MP4CreateDownMixInstructionsAtom( MP4DownMixInstructionsAtomPtr *outAtom ); -MP4Err MP4CreateLoudnessBaseAtom( MP4LoudnessBaseAtomPtr *outAtom, u32 type ); -MP4Err MP4CreateLoudnessAtom( MP4LoudnessAtomPtr *outAtom ); +MP4Err MP4CreateAudioSampleEntryAtom(MP4AudioSampleEntryAtomPtr *outAtom); +MP4Err MP4CreatePCMConfigAtom(MP4PCMConfigAtomPtr *outAtom); +MP4Err MP4CreateChannelLayoutAtom(MP4ChannelLayoutAtomPtr *outAtom); +MP4Err MP4CreateDownMixInstructionsAtom(MP4DownMixInstructionsAtomPtr *outAtom); +MP4Err MP4CreateLoudnessBaseAtom(MP4LoudnessBaseAtomPtr *outAtom, u32 type); +MP4Err MP4CreateLoudnessAtom(MP4LoudnessAtomPtr *outAtom); /* MP4Err MP4CreateChunkLargeOffsetAtom( MP4ChunkLargeOffsetAtomPtr *outAtom ); */ -MP4Err MP4CreateChunkOffsetAtom( MP4ChunkOffsetAtomPtr *outAtom ); -MP4Err MP4CreateClockReferenceMediaHeaderAtom( MP4ClockReferenceMediaHeaderAtomPtr *outAtom ); -MP4Err MP4CreateCompositionOffsetAtom( MP4CompositionOffsetAtomPtr *outAtom ); -MP4Err MP4CreateCompositionToDecodeAtom( MP4CompositionToDecodeAtomPtr *outAtom ); -MP4Err MP4CreateCopyrightAtom( MP4CopyrightAtomPtr *outAtom ); -MP4Err MP4CreateDataEntryURLAtom( MP4DataEntryURLAtomPtr *outAtom ); -MP4Err MP4CreateDataEntryURNAtom( MP4DataEntryURNAtomPtr *outAtom ); -MP4Err MP4CreateDataInformationAtom( MP4DataInformationAtomPtr *outAtom ); -MP4Err MP4CreateDataReferenceAtom( MP4DataReferenceAtomPtr *outAtom ); -MP4Err MP4CreateDegradationPriorityAtom( MP4DegradationPriorityAtomPtr *outAtom ); -MP4Err MP4CreateESDAtom( MP4ESDAtomPtr *outAtom ); -MP4Err MP4CreateEditAtom( MP4EditAtomPtr *outAtom ); -MP4Err MP4CreateEditListAtom( MP4EditListAtomPtr *outAtom ); -MP4Err MP4CreateFreeSpaceAtom( MP4FreeSpaceAtomPtr *outAtom ); -MP4Err MP4CreateGenericSampleEntryAtom( MP4GenericSampleEntryAtomPtr *outAtom ); -MP4Err MP4CreateHandlerAtom( MP4HandlerAtomPtr *outAtom ); -MP4Err MP4CreateHintMediaHeaderAtom( MP4HintMediaHeaderAtomPtr *outAtom ); -MP4Err MP4CreateMPEGMediaHeaderAtom( MP4MPEGMediaHeaderAtomPtr *outAtom ); -MP4Err MP4CreateMPEGSampleEntryAtom( MP4MPEGSampleEntryAtomPtr *outAtom ); -MP4Err MP4CreateMediaAtom( MP4MediaAtomPtr *outAtom ); -MP4Err MP4CreateMediaDataAtom( MP4MediaDataAtomPtr *outAtom ); -MP4Err MP4CreateMediaHeaderAtom( MP4MediaHeaderAtomPtr *outAtom ); -MP4Err MP4CreateMediaInformationAtom( MP4MediaInformationAtomPtr *outAtom ); -MP4Err MP4CreateExtendedLanguageTagAtom( MP4ExtendedLanguageTagAtomPtr *outAtom ); -MP4Err MP4CreateMovieAtom( MP4MovieAtomPtr *outAtom ); -MP4Err MP4CreateMovieHeaderAtom( MP4MovieHeaderAtomPtr *outAtom ); -MP4Err MP4CreateObjectDescriptorAtom( MP4ObjectDescriptorAtomPtr *outAtom ); -MP4Err MP4CreateObjectDescriptorMediaHeaderAtom( MP4ObjectDescriptorMediaHeaderAtomPtr *outAtom ); -MP4Err MP4CreateSampleDescriptionAtom( MP4SampleDescriptionAtomPtr *outAtom ); -MP4Err MP4CreateSampleSizeAtom( MP4SampleSizeAtomPtr *outAtom ); -MP4Err MP4CreateSampleTableAtom( MP4SampleTableAtomPtr *outAtom ); -MP4Err MP4CreateSampleToChunkAtom( MP4SampleToChunkAtomPtr *outAtom ); -MP4Err MP4CreateSampleAuxiliaryInformationSizesAtom( MP4SampleAuxiliaryInformationSizesAtomPtr *outAtom ); -MP4Err MP4CreateSampleAuxiliaryInformationOffsetsAtom( MP4SampleAuxiliaryInformationOffsetsAtomPtr *outAtom ); -MP4Err MP4CreateSceneDescriptionMediaHeaderAtom( MP4SceneDescriptionMediaHeaderAtomPtr *outAtom ); -MP4Err MP4CreateShadowSyncAtom( MP4ShadowSyncAtomPtr *outAtom ); -MP4Err MP4CreateSoundMediaHeaderAtom( MP4SoundMediaHeaderAtomPtr *outAtom ); +MP4Err MP4CreateChunkOffsetAtom(MP4ChunkOffsetAtomPtr *outAtom); +MP4Err MP4CreateClockReferenceMediaHeaderAtom(MP4ClockReferenceMediaHeaderAtomPtr *outAtom); +MP4Err MP4CreateCompositionOffsetAtom(MP4CompositionOffsetAtomPtr *outAtom); +MP4Err MP4CreateCompositionToDecodeAtom(MP4CompositionToDecodeAtomPtr *outAtom); +MP4Err MP4CreateCopyrightAtom(MP4CopyrightAtomPtr *outAtom); +MP4Err MP4CreateDataEntryURLAtom(MP4DataEntryURLAtomPtr *outAtom); +MP4Err MP4CreateDataEntryURNAtom(MP4DataEntryURNAtomPtr *outAtom); +MP4Err MP4CreateDataInformationAtom(MP4DataInformationAtomPtr *outAtom); +MP4Err MP4CreateDataReferenceAtom(MP4DataReferenceAtomPtr *outAtom); +MP4Err MP4CreateDegradationPriorityAtom(MP4DegradationPriorityAtomPtr *outAtom); +MP4Err MP4CreateESDAtom(MP4ESDAtomPtr *outAtom); +MP4Err MP4CreateEditAtom(MP4EditAtomPtr *outAtom); +MP4Err MP4CreateEditListAtom(MP4EditListAtomPtr *outAtom); +MP4Err MP4CreateFreeSpaceAtom(MP4FreeSpaceAtomPtr *outAtom); +MP4Err MP4CreateGenericSampleEntryAtom(MP4GenericSampleEntryAtomPtr *outAtom); +MP4Err MP4CreateHandlerAtom(MP4HandlerAtomPtr *outAtom); +MP4Err MP4CreateHintMediaHeaderAtom(MP4HintMediaHeaderAtomPtr *outAtom); +MP4Err MP4CreateMPEGMediaHeaderAtom(MP4MPEGMediaHeaderAtomPtr *outAtom); +MP4Err MP4CreateMPEGSampleEntryAtom(MP4MPEGSampleEntryAtomPtr *outAtom); +MP4Err MP4CreateMediaAtom(MP4MediaAtomPtr *outAtom); +MP4Err MP4CreateMediaDataAtom(MP4MediaDataAtomPtr *outAtom); +MP4Err MP4CreateMediaHeaderAtom(MP4MediaHeaderAtomPtr *outAtom); +MP4Err MP4CreateMediaInformationAtom(MP4MediaInformationAtomPtr *outAtom); +MP4Err MP4CreateExtendedLanguageTagAtom(MP4ExtendedLanguageTagAtomPtr *outAtom); +MP4Err MP4CreateMovieAtom(MP4MovieAtomPtr *outAtom); +MP4Err MP4CreateMovieHeaderAtom(MP4MovieHeaderAtomPtr *outAtom); +MP4Err MP4CreateObjectDescriptorAtom(MP4ObjectDescriptorAtomPtr *outAtom); +MP4Err MP4CreateObjectDescriptorMediaHeaderAtom(MP4ObjectDescriptorMediaHeaderAtomPtr *outAtom); +MP4Err MP4CreateSampleDescriptionAtom(MP4SampleDescriptionAtomPtr *outAtom); +MP4Err MP4CreateSampleSizeAtom(MP4SampleSizeAtomPtr *outAtom); +MP4Err MP4CreateSampleTableAtom(MP4SampleTableAtomPtr *outAtom); +MP4Err MP4CreateSampleToChunkAtom(MP4SampleToChunkAtomPtr *outAtom); +MP4Err +MP4CreateSampleAuxiliaryInformationSizesAtom(MP4SampleAuxiliaryInformationSizesAtomPtr *outAtom); +MP4Err MP4CreateSampleAuxiliaryInformationOffsetsAtom( + MP4SampleAuxiliaryInformationOffsetsAtomPtr *outAtom); +MP4Err MP4CreateSceneDescriptionMediaHeaderAtom(MP4SceneDescriptionMediaHeaderAtomPtr *outAtom); +MP4Err MP4CreateShadowSyncAtom(MP4ShadowSyncAtomPtr *outAtom); +MP4Err MP4CreateSoundMediaHeaderAtom(MP4SoundMediaHeaderAtomPtr *outAtom); MP4Err MP4CreateSubSampleInformationAtom(MP4SubSampleInformationAtomPtr *outAtom); -MP4Err MP4CreateSyncSampleAtom( MP4SyncSampleAtomPtr *outAtom ); -MP4Err MP4CreateTimeToSampleAtom( MP4TimeToSampleAtomPtr *outAtom ); -MP4Err MP4CreateTrackAtom( MP4TrackAtomPtr *outAtom ); -MP4Err MP4CreateTrackHeaderAtom( MP4TrackHeaderAtomPtr *outAtom ); -MP4Err MP4CreateTrackReferenceAtom( MP4TrackReferenceAtomPtr *outAtom ); -MP4Err MP4CreateTrackReferenceTypeAtom( u32 atomType, MP4TrackReferenceTypeAtomPtr *outAtom ); +MP4Err MP4CreateSyncSampleAtom(MP4SyncSampleAtomPtr *outAtom); +MP4Err MP4CreateTimeToSampleAtom(MP4TimeToSampleAtomPtr *outAtom); +MP4Err MP4CreateTrackAtom(MP4TrackAtomPtr *outAtom); +MP4Err MP4CreateTrackHeaderAtom(MP4TrackHeaderAtomPtr *outAtom); +MP4Err MP4CreateTrackReferenceAtom(MP4TrackReferenceAtomPtr *outAtom); +MP4Err MP4CreateTrackReferenceTypeAtom(u32 atomType, MP4TrackReferenceTypeAtomPtr *outAtom); MP4Err MP4CreateTrackGroupAtom(MP4TrackGroupAtomPtr *outAtom); MP4Err MP4CreateTrackGroupTypeAtom(u32 atomType, MP4TrackGroupTypeAtomPtr *outAtom); -MP4Err MP4CreateUnknownAtom( MP4UnknownAtomPtr *outAtom ); -MP4Err MP4CreateUserDataAtom( MP4UserDataAtomPtr *outAtom ); -MP4Err MP4CreateVideoMediaHeaderAtom( MP4VideoMediaHeaderAtomPtr *outAtom ); -MP4Err MP4CreateVisualSampleEntryAtom( MP4VisualSampleEntryAtomPtr *outAtom ); - -MP4Err MP4CreateXMLMetaSampleEntryAtom( MP4XMLMetaSampleEntryAtomPtr *outAtom ); -MP4Err MP4CreateTextMetaSampleEntryAtom( MP4TextMetaSampleEntryAtomPtr *outAtom ); - -MP4Err MP4CreateMovieExtendsAtom( MP4MovieExtendsAtomPtr *outAtom ); -MP4Err MP4CreateTrackExtensionPropertiesAtom( MP4TrackExtensionPropertiesAtomPtr *outAtom ); -MP4Err MP4CreateTrackExtendsAtom( MP4TrackExtendsAtomPtr *outAtom ); -MP4Err MP4CreateMovieFragmentAtom( MP4MovieFragmentAtomPtr *outAtom ); -MP4Err MP4CreateMovieFragmentHeaderAtom( MP4MovieFragmentHeaderAtomPtr *outAtom ); -MP4Err MP4CreateTrackFragmentAtom( MP4TrackFragmentAtomPtr *outAtom ); -MP4Err MP4CreateTrackFragmentHeaderAtom( MP4TrackFragmentHeaderAtomPtr *outAtom ); -MP4Err MP4CreateTrackFragmentDecodeTimeAtom( MP4TrackFragmentDecodeTimeAtomPtr *outAtom ); -MP4Err MP4CreateTrackRunAtom( MP4TrackRunAtomPtr *outAtom ); -MP4Err MP4CreatePaddingBitsAtom( MP4PaddingBitsAtomPtr *outAtom ); +MP4Err MP4CreateUnknownAtom(MP4UnknownAtomPtr *outAtom); +MP4Err MP4CreateUserDataAtom(MP4UserDataAtomPtr *outAtom); +MP4Err MP4CreateVideoMediaHeaderAtom(MP4VideoMediaHeaderAtomPtr *outAtom); +MP4Err MP4CreateVisualSampleEntryAtom(MP4VisualSampleEntryAtomPtr *outAtom); + +MP4Err MP4CreateXMLMetaSampleEntryAtom(MP4XMLMetaSampleEntryAtomPtr *outAtom); +MP4Err MP4CreateTextMetaSampleEntryAtom(MP4TextMetaSampleEntryAtomPtr *outAtom); + +MP4Err MP4CreateMovieExtendsAtom(MP4MovieExtendsAtomPtr *outAtom); +MP4Err MP4CreateTrackExtensionPropertiesAtom(MP4TrackExtensionPropertiesAtomPtr *outAtom); +MP4Err MP4CreateTrackExtendsAtom(MP4TrackExtendsAtomPtr *outAtom); +MP4Err MP4CreateMovieFragmentAtom(MP4MovieFragmentAtomPtr *outAtom); +MP4Err MP4CreateMovieFragmentHeaderAtom(MP4MovieFragmentHeaderAtomPtr *outAtom); +MP4Err MP4CreateTrackFragmentAtom(MP4TrackFragmentAtomPtr *outAtom); +MP4Err MP4CreateTrackFragmentHeaderAtom(MP4TrackFragmentHeaderAtomPtr *outAtom); +MP4Err MP4CreateTrackFragmentDecodeTimeAtom(MP4TrackFragmentDecodeTimeAtomPtr *outAtom); +MP4Err MP4CreateTrackRunAtom(MP4TrackRunAtomPtr *outAtom); +MP4Err MP4CreatePaddingBitsAtom(MP4PaddingBitsAtomPtr *outAtom); MP4Err MP4CreateItemPropertiesAtom(MP4ItemPropertiesAtomPtr *outAtom); MP4Err MP4CreateItemPropertyContainerAtom(MP4ItemPropertyContainerAtomPtr *outAtom); @@ -2038,40 +2107,41 @@ MP4Err MP4CreateSubsegmentIndexAtom(MP4SubsegmentIndexAtomPtr *outAtom); MP4Err MP4CreateProducerReferenceTimeAtom(MP4ProducerReferenceTimeAtomPtr *outAtom); #ifdef ISMACrypt -MP4Err MP4CreateSecurityInfoAtom( MP4SecurityInfoAtomPtr *outAtom ); -MP4Err CreateISMAKMSAtom( ISMAKMSAtomPtr *outAtom ); -MP4Err CreateISMASampleFormatAtom( ISMASampleFormatAtomPtr *outAtom ); -MP4Err CreateISMASaltAtom( ISMASaltAtomPtr *outAtom ); -MP4Err MP4CreateEncAudioSampleEntryAtom( MP4EncAudioSampleEntryAtomPtr *outAtom ); -MP4Err MP4CreateEncVisualSampleEntryAtom( MP4EncVisualSampleEntryAtomPtr *outAtom ); - -MP4Err MP4CreateEncBaseAtom( MP4EncBaseSampleEntryAtomPtr outAtom ); +MP4Err MP4CreateSecurityInfoAtom(MP4SecurityInfoAtomPtr *outAtom); +MP4Err CreateISMAKMSAtom(ISMAKMSAtomPtr *outAtom); +MP4Err CreateISMASampleFormatAtom(ISMASampleFormatAtomPtr *outAtom); +MP4Err CreateISMASaltAtom(ISMASaltAtomPtr *outAtom); +MP4Err MP4CreateEncAudioSampleEntryAtom(MP4EncAudioSampleEntryAtomPtr *outAtom); +MP4Err MP4CreateEncVisualSampleEntryAtom(MP4EncVisualSampleEntryAtomPtr *outAtom); + +MP4Err MP4CreateEncBaseAtom(MP4EncBaseSampleEntryAtomPtr outAtom); #endif -MP4Err MP4CreateSampletoGroupAtom( MP4SampletoGroupAtomPtr *outAtom ); -MP4Err MP4CreateCompactSampletoGroupAtom( MP4CompactSampletoGroupAtomPtr *outAtom ); -MP4Err MP4CreateSampleGroupDescriptionAtom( MP4SampleGroupDescriptionAtomPtr *outAtom ); +MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom); +MP4Err MP4CreateCompactSampletoGroupAtom(MP4CompactSampletoGroupAtomPtr *outAtom); +MP4Err MP4CreateSampleGroupDescriptionAtom(MP4SampleGroupDescriptionAtomPtr *outAtom); -MP4Err MP4CreateSampleDependencyAtom( MP4SampleDependencyAtomPtr *outAtom ); +MP4Err MP4CreateSampleDependencyAtom(MP4SampleDependencyAtomPtr *outAtom); -MP4Err ISOCreateMetaAtom( ISOMetaAtomPtr *outAtom ); -MP4Err ISOCreatePrimaryItemAtom( ISOPrimaryItemAtomPtr *outAtom ); -MP4Err ISOCreateItemLocationAtom( ISOItemLocationAtomPtr *outAtom ); -MP4Err ISOCreateItemProtectionAtom( ISOItemProtectionAtomPtr *outAtom ); -MP4Err ISOCreateItemInfoAtom( ISOItemInfoAtomPtr *outAtom ); -MP4Err ISOCreateItemInfoEntryAtom( ISOItemInfoEntryAtomPtr *outAtom ); +MP4Err ISOCreateMetaAtom(ISOMetaAtomPtr *outAtom); +MP4Err ISOCreatePrimaryItemAtom(ISOPrimaryItemAtomPtr *outAtom); +MP4Err ISOCreateItemLocationAtom(ISOItemLocationAtomPtr *outAtom); +MP4Err ISOCreateItemProtectionAtom(ISOItemProtectionAtomPtr *outAtom); +MP4Err ISOCreateItemInfoAtom(ISOItemInfoAtomPtr *outAtom); +MP4Err ISOCreateItemInfoEntryAtom(ISOItemInfoEntryAtomPtr *outAtom); -MP4Err ISOCreateAdditionalMetaDataContainerAtom( ISOAdditionalMetaDataContainerAtomPtr *outAtom ); -MP4Err ISOCreateMetaboxRelationAtom( ISOMetaboxRelationAtomPtr *outAtom ); -MP4Err ISOCreateItemDataAtom( ISOItemDataAtomPtr *outAtom ); -MP4Err ISOCreateItemReferenceAtom( ISOItemReferenceAtomPtr *outAtom ); -MP4Err ISOCreateSingleItemTypeReferenceAtom( ISOSingleItemTypeReferenceAtomPtr *outAtom, u32 type, u8 isLarge ); +MP4Err ISOCreateAdditionalMetaDataContainerAtom(ISOAdditionalMetaDataContainerAtomPtr *outAtom); +MP4Err ISOCreateMetaboxRelationAtom(ISOMetaboxRelationAtomPtr *outAtom); +MP4Err ISOCreateItemDataAtom(ISOItemDataAtomPtr *outAtom); +MP4Err ISOCreateItemReferenceAtom(ISOItemReferenceAtomPtr *outAtom); +MP4Err ISOCreateSingleItemTypeReferenceAtom(ISOSingleItemTypeReferenceAtomPtr *outAtom, u32 type, + u8 isLarge); -MP4Err MP4CreateVCConfigAtom( ISOVCConfigAtomPtr *outAtom ); +MP4Err MP4CreateVCConfigAtom(ISOVCConfigAtomPtr *outAtom); -MP4Err MP4CreateAMRSpecificInfoAtom( MP4AMRSpecificInfoAtomPtr *outAtom ); -MP4Err MP4CreateAMRWPSpecificInfoAtom( MP4AMRWPSpecificInfoAtomPtr *outAtom ); -MP4Err MP4CreateH263SpecificInfoAtom( MP4H263SpecificInfoAtomPtr *outAtom ); -MP4Err MP4CreateBitRateAtom( MP4BitRateAtomPtr *outAtom ); +MP4Err MP4CreateAMRSpecificInfoAtom(MP4AMRSpecificInfoAtomPtr *outAtom); +MP4Err MP4CreateAMRWPSpecificInfoAtom(MP4AMRWPSpecificInfoAtomPtr *outAtom); +MP4Err MP4CreateH263SpecificInfoAtom(MP4H263SpecificInfoAtomPtr *outAtom); +MP4Err MP4CreateBitRateAtom(MP4BitRateAtomPtr *outAtom); #endif diff --git a/IsoLib/libisomediafile/src/MP4Commands.c b/IsoLib/libisomediafile/src/MP4Commands.c index 155cb42..361dab6 100644 --- a/IsoLib/libisomediafile/src/MP4Commands.c +++ b/IsoLib/libisomediafile/src/MP4Commands.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,74 +15,79 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4Commands.c,v 1.2 2002/09/25 18:31:08 julien Exp $ + $Id: MP4Commands.c,v 1.2 2002/09/25 18:31:08 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include "MP4Impl.h" -#define GET_DESCRIPTOR_BYTE( varName, what ) \ - err = inputStream->read8( inputStream, &varName, what ); if (err) goto bail; \ - bytesRead ++ +#define GET_DESCRIPTOR_BYTE(varName, what) \ + err = inputStream->read8(inputStream, &varName, what); \ + if(err) goto bail; \ + bytesRead++ -MP4Err MP4ParseCommand( MP4InputStreamPtr inputStream, MP4DescriptorPtr *outDesc ) +MP4Err MP4ParseCommand(MP4InputStreamPtr inputStream, MP4DescriptorPtr *outDesc) { - MP4Err err; - u32 tag; - u32 size; - u32 val; - u32 sizeBytes; - MP4DescriptorPtr desc; - u32 bytesRead; - char msgbuf[ 80 ]; - - if ( (inputStream == NULL) || (outDesc == NULL) ) - BAILWITHERROR( MP4BadParamErr ) - bytesRead = 0; - GET_DESCRIPTOR_BYTE( tag, "class tag" ); - - /* get size */ - size = 0; - sizeBytes = 1; - do - { - GET_DESCRIPTOR_BYTE( val, "size byte" ); - sizeBytes++; - size <<= 7; - size |= val & 0x7F; - } while ( val & 0x80 ); - size += sizeBytes; + MP4Err err; + u32 tag; + u32 size; + u32 val; + u32 sizeBytes; + MP4DescriptorPtr desc; + u32 bytesRead; + char msgbuf[80]; - switch ( tag ) - { + if((inputStream == NULL) || (outDesc == NULL)) BAILWITHERROR(MP4BadParamErr) + bytesRead = 0; + GET_DESCRIPTOR_BYTE(tag, "class tag"); - case MP4ObjectDescriptorUpdateTag: - err = MP4CreateObjectDescriptorUpdate( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4ESDescriptorUpdateTag: - err = MP4CreateESDescriptorUpdate( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4IPMP_ToolDescriptorUpdateTag: - err = MP4CreateIPMPToolDescriptorUpdate( tag, size, bytesRead, &desc ); if (err) goto bail; - break; + /* get size */ + size = 0; + sizeBytes = 1; + do + { + GET_DESCRIPTOR_BYTE(val, "size byte"); + sizeBytes++; + size <<= 7; + size |= val & 0x7F; + } while(val & 0x80); + size += sizeBytes; - default: - err = MP4CreateDefaultCommand( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - } - sprintf( msgbuf, "command is %s", desc->name ); - err = desc->createFromInputStream( desc, inputStream ); if (err) goto bail; - *outDesc = desc; + switch(tag) + { + + case MP4ObjectDescriptorUpdateTag: + err = MP4CreateObjectDescriptorUpdate(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4ESDescriptorUpdateTag: + err = MP4CreateESDescriptorUpdate(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4IPMP_ToolDescriptorUpdateTag: + err = MP4CreateIPMPToolDescriptorUpdate(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + default: + err = MP4CreateDefaultCommand(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + } + sprintf(msgbuf, "command is %s", desc->name); + err = desc->createFromInputStream(desc, inputStream); + if(err) goto bail; + *outDesc = desc; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4DataHandler.c b/IsoLib/libisomediafile/src/MP4DataHandler.c index eb7274d..32bb60b 100644 --- a/IsoLib/libisomediafile/src/MP4DataHandler.c +++ b/IsoLib/libisomediafile/src/MP4DataHandler.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,39 +15,38 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4DataHandler.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4DataHandler.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4Impl.h" #include "MP4DataHandler.h" #include "FileMappingDataHandler.h" -MP4Err MP4CreateMdatDataHandler( MP4MediaDataAtomPtr mdat, MP4DataHandlerPtr *outDataHandler ); +MP4Err MP4CreateMdatDataHandler(MP4MediaDataAtomPtr mdat, MP4DataHandlerPtr *outDataHandler); -MP4Err MP4CreateDataHandler( MP4InputStreamPtr inputStream, MP4DataEntryAtomPtr dataEntry, MP4DataHandlerPtr *outDataHandler ) +MP4Err MP4CreateDataHandler(MP4InputStreamPtr inputStream, MP4DataEntryAtomPtr dataEntry, + MP4DataHandlerPtr *outDataHandler) { - if ((dataEntry->flags==1) && (dataEntry->mdat != NULL)) - return MP4CreateMdatDataHandler( (MP4MediaDataAtomPtr) dataEntry->mdat, outDataHandler ); - else - return MP4CreateFileMappingDataHandler( inputStream, dataEntry, outDataHandler ); + if((dataEntry->flags == 1) && (dataEntry->mdat != NULL)) + return MP4CreateMdatDataHandler((MP4MediaDataAtomPtr)dataEntry->mdat, outDataHandler); + else + return MP4CreateFileMappingDataHandler(inputStream, dataEntry, outDataHandler); } -MP4Err MP4DisposeDataHandler( MP4DataHandlerPtr dataHandler, MP4DataEntryAtomPtr dataEntry ) +MP4Err MP4DisposeDataHandler(MP4DataHandlerPtr dataHandler, MP4DataEntryAtomPtr dataEntry) { - if ((dataEntry->flags==1) && (dataEntry->mdat != NULL)) - return dataHandler->close( dataHandler ); - else - return MP4DisposeFileMappingDataHandler( dataHandler, dataEntry ); + if((dataEntry->flags == 1) && (dataEntry->mdat != NULL)) return dataHandler->close(dataHandler); + else + return MP4DisposeFileMappingDataHandler(dataHandler, dataEntry); } -MP4Err MP4PreflightDataHandler( MP4InputStreamPtr inputStream, MP4DataEntryAtomPtr dataEntry ) +MP4Err MP4PreflightDataHandler(MP4InputStreamPtr inputStream, MP4DataEntryAtomPtr dataEntry) { - if ( dataEntry->flags == 1 ) - return MP4NoErr; - return MP4PreflightFileMappingDataHandler( inputStream, dataEntry ); + if(dataEntry->flags == 1) return MP4NoErr; + return MP4PreflightFileMappingDataHandler(inputStream, dataEntry); } diff --git a/IsoLib/libisomediafile/src/MP4DataHandler.h b/IsoLib/libisomediafile/src/MP4DataHandler.h index 1c080c0..430f714 100644 --- a/IsoLib/libisomediafile/src/MP4DataHandler.h +++ b/IsoLib/libisomediafile/src/MP4DataHandler.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4DataHandler.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4DataHandler.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #ifndef INCLUDED_MP4_DATAHANDLER_H #define INCLUDED_MP4_DATAHANDLER_H @@ -30,21 +30,21 @@ derivative works. Copyright (c) 1999. #include "MP4Atoms.h" #include "MP4Impl.h" -#define COMMON_DATAHANDLER_FIELDS \ - MP4Err (*open)( struct MP4DataHandler *self, struct MP4InputStreamRecord* inputStream, MP4DataEntryAtomPtr dataEntry ); \ - MP4Err (*close)( struct MP4DataHandler *self ); \ - MP4Err (*copyData)( struct MP4DataHandler *self, u64 offset, char *dst, u32 bytes ); \ - MP4Err (*getDataSize)( struct MP4DataHandler *self, u64* bytes ); +#define COMMON_DATAHANDLER_FIELDS \ + MP4Err (*open)(struct MP4DataHandler * self, struct MP4InputStreamRecord * inputStream, \ + MP4DataEntryAtomPtr dataEntry); \ + MP4Err (*close)(struct MP4DataHandler * self); \ + MP4Err (*copyData)(struct MP4DataHandler * self, u64 offset, char *dst, u32 bytes); \ + MP4Err (*getDataSize)(struct MP4DataHandler * self, u64 * bytes); typedef struct MP4DataHandler { - COMMON_DATAHANDLER_FIELDS + COMMON_DATAHANDLER_FIELDS } MP4DataHandler, *MP4DataHandlerPtr; - -MP4Err MP4CreateDataHandler( struct MP4InputStreamRecord* inputStream, MP4DataEntryAtomPtr dataEntry, MP4DataHandlerPtr *outDataHandler ); -MP4Err MP4DisposeDataHandler( MP4DataHandlerPtr dataHandler, MP4DataEntryAtomPtr dataEntry ); -MP4Err MP4PreflightDataHandler( MP4InputStreamPtr inputStream, MP4DataEntryAtomPtr dataEntry ); - +MP4Err MP4CreateDataHandler(struct MP4InputStreamRecord *inputStream, MP4DataEntryAtomPtr dataEntry, + MP4DataHandlerPtr *outDataHandler); +MP4Err MP4DisposeDataHandler(MP4DataHandlerPtr dataHandler, MP4DataEntryAtomPtr dataEntry); +MP4Err MP4PreflightDataHandler(MP4InputStreamPtr inputStream, MP4DataEntryAtomPtr dataEntry); #endif diff --git a/IsoLib/libisomediafile/src/MP4DecoderConfigDescriptor.c b/IsoLib/libisomediafile/src/MP4DecoderConfigDescriptor.c index 06dbec0..0457543 100644 --- a/IsoLib/libisomediafile/src/MP4DecoderConfigDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4DecoderConfigDescriptor.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,122 +15,123 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: + $Id: */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - MP4DecoderConfigDescriptorPtr self = (MP4DecoderConfigDescriptorPtr) s; - err = MP4NoErr; - self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ - self->size += 13; - ADD_DESCRIPTOR_SIZE( decoderSpecificInfo ); + MP4Err err; + MP4DecoderConfigDescriptorPtr self = (MP4DecoderConfigDescriptorPtr)s; + err = MP4NoErr; + self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ + self->size += 13; + ADD_DESCRIPTOR_SIZE(decoderSpecificInfo); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - u8 val; - MP4DecoderConfigDescriptorPtr self = (MP4DecoderConfigDescriptorPtr) s; - err = MP4NoErr; - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - - PUT8( objectTypeIndication ); - val = self->streamType << 2; - if ( self->upstream ) - val |= (1<<1); - val |= 1; - PUT8_V( val ); - PUT24( bufferSizeDB ); - PUT32( maxBitrate ); - PUT32( avgBitrate ); - SERIALIZE_DESCRIPTOR( decoderSpecificInfo ); + MP4Err err; + u8 val; + MP4DecoderConfigDescriptorPtr self = (MP4DecoderConfigDescriptorPtr)s; + err = MP4NoErr; + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + + PUT8(objectTypeIndication); + val = self->streamType << 2; + if(self->upstream) val |= (1 << 1); + val |= 1; + PUT8_V(val); + PUT24(bufferSizeDB); + PUT32(maxBitrate); + PUT32(avgBitrate); + SERIALIZE_DESCRIPTOR(decoderSpecificInfo); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 val; - MP4DescriptorPtr desc; - MP4DecoderConfigDescriptorPtr self = (MP4DecoderConfigDescriptorPtr) s; - err = MP4NoErr; + MP4Err err; + u32 val; + MP4DescriptorPtr desc; + MP4DecoderConfigDescriptorPtr self = (MP4DecoderConfigDescriptorPtr)s; + err = MP4NoErr; + + GET8(objectTypeIndication); + GET8_V_MSG(val, NULL); + self->upstream = val & (1 << 1); + self->streamType = val >> 2; + DEBUG_SPRINTF("upstream = %d", self->upstream); + DEBUG_SPRINTF("streamType = %d", self->streamType); + DEBUG_SPRINTF("reserved = %d", (val & 1)); + + GET16_V_MSG(val, NULL); - GET8( objectTypeIndication ); - GET8_V_MSG( val, NULL ); - self->upstream = val & (1 << 1); - self->streamType = val >> 2; - DEBUG_SPRINTF( "upstream = %d", self->upstream ); - DEBUG_SPRINTF( "streamType = %d", self->streamType ); - DEBUG_SPRINTF( "reserved = %d", (val & 1) ); - - GET16_V_MSG( val, NULL ); - - self->bufferSizeDB = val << 8; - GET8_V_MSG( val, NULL ); - self->bufferSizeDB |= val; - DEBUG_SPRINTF( "bufferSizeDB = %d", self->bufferSizeDB ); - - GET32( maxBitrate ); - GET32( avgBitrate ); - if ( self->bytesRead < self->size ) - { - err = MP4ParseDescriptor( inputStream, &desc ); if (err) goto bail; - self->bytesRead += desc->size; - if ( desc->tag != MP4DecSpecificInfoDescriptorTag ) - { - DEBUG_MSG( "note: got bogus decoderspecific info" ); - } - else - { - self->decoderSpecificInfo = desc; - self->bytesRead += desc->size; - } - } - else - DEBUG_MSG( "(no decoder specific info)" ); + self->bufferSizeDB = val << 8; + GET8_V_MSG(val, NULL); + self->bufferSizeDB |= val; + DEBUG_SPRINTF("bufferSizeDB = %d", self->bufferSizeDB); + + GET32(maxBitrate); + GET32(avgBitrate); + if(self->bytesRead < self->size) + { + err = MP4ParseDescriptor(inputStream, &desc); + if(err) goto bail; + self->bytesRead += desc->size; + if(desc->tag != MP4DecSpecificInfoDescriptorTag) + { + DEBUG_MSG("note: got bogus decoderspecific info"); + } + else + { + self->decoderSpecificInfo = desc; + self->bytesRead += desc->size; + } + } + else + DEBUG_MSG("(no decoder specific info)"); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static void destroy( struct MP4DescriptorRecord* s ) + +static void destroy(struct MP4DescriptorRecord *s) { - MP4DecoderConfigDescriptorPtr self = (MP4DecoderConfigDescriptorPtr) s; - if ( self->decoderSpecificInfo ) - { - self->decoderSpecificInfo->destroy( self->decoderSpecificInfo ); - self->decoderSpecificInfo = NULL; - } + MP4DecoderConfigDescriptorPtr self = (MP4DecoderConfigDescriptorPtr)s; + if(self->decoderSpecificInfo) + { + self->decoderSpecificInfo->destroy(self->decoderSpecificInfo); + self->decoderSpecificInfo = NULL; + } - free( s ); + free(s); } -MP4Err MP4CreateDecoderConfigDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateDecoderConfigDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4DecoderConfigDescriptor ) - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4DecoderConfigDescriptor) + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4DefaultCommand.c b/IsoLib/libisomediafile/src/MP4DefaultCommand.c index b7b150d..0b2d698 100644 --- a/IsoLib/libisomediafile/src/MP4DefaultCommand.c +++ b/IsoLib/libisomediafile/src/MP4DefaultCommand.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4DefaultCommand.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4DefaultCommand.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" @@ -29,80 +29,77 @@ derivative works. Copyright (c) 1999. #include #include -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; + MP4Err err; - - MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - self->size = 5; /* tag + length word */ - self->size += self->dataLength; + MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + self->size = 5; /* tag + length word */ + self->size += self->dataLength; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - - PUTBYTES( self->data, self->dataLength ); + MP4Err err; + MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + + PUTBYTES(self->data, self->dataLength); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - self->dataLength = self->size - self->bytesRead; - self->data = (char*) calloc( 1, self->dataLength ); - TESTMALLOC( self->data ); - GETBYTES( self->dataLength, data ); + MP4Err err; + MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + self->dataLength = self->size - self->bytesRead; + self->data = (char *)calloc(1, self->dataLength); + TESTMALLOC(self->data); + GETBYTES(self->dataLength, data); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static void destroy( struct MP4DescriptorRecord* s ) + +static void destroy(struct MP4DescriptorRecord *s) { - MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr) s; - if ( self->data ) - { - free( self->data ); - self->data = NULL; - } - if (self->name) free( self->name ); - free( s ); + MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr)s; + if(self->data) + { + free(self->data); + self->data = NULL; + } + if(self->name) free(self->name); + free(s); } -MP4Err MP4CreateDefaultCommand( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateDefaultCommand(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - char msgBuf[ 80 ]; - SETUP_BASE_DESCRIPTOR( MP4DefaultDescriptor ) - sprintf( msgBuf, "(some command with tag 0x%02x and size %d)", tag, size ); - self->name = (char*) calloc( 1, strlen(msgBuf) + 1 ); - TESTMALLOC( self->name ) - strcpy( self->name, msgBuf ); - *outDesc = (MP4DescriptorPtr) self; + char msgBuf[80]; + SETUP_BASE_DESCRIPTOR(MP4DefaultDescriptor) + sprintf(msgBuf, "(some command with tag 0x%02x and size %d)", tag, size); + self->name = (char *)calloc(1, strlen(msgBuf) + 1); + TESTMALLOC(self->name) + strcpy(self->name, msgBuf); + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4DefaultDescriptor.c b/IsoLib/libisomediafile/src/MP4DefaultDescriptor.c index 4fef1cb..1e7ac0f 100644 --- a/IsoLib/libisomediafile/src/MP4DefaultDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4DefaultDescriptor.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: + $Id: */ #include "MP4Descriptors.h" #include "MP4Movies.h" @@ -29,78 +29,76 @@ derivative works. Copyright (c) 1999. #include #include -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - self->size = 5; /* tag + length word */ - self->size += self->dataLength; + MP4Err err; + MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + self->size = 5; /* tag + length word */ + self->size += self->dataLength; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - - PUTBYTES( self->data, self->dataLength ); + MP4Err err; + MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + + PUTBYTES(self->data, self->dataLength); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - self->dataLength = self->size - self->bytesRead; - self->data = (char*) calloc( 1, self->dataLength ); - TESTMALLOC( self->data ); - GETBYTES( self->dataLength, data ); + MP4Err err; + MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + self->dataLength = self->size - self->bytesRead; + self->data = (char *)calloc(1, self->dataLength); + TESTMALLOC(self->data); + GETBYTES(self->dataLength, data); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static void destroy( struct MP4DescriptorRecord* s ) + +static void destroy(struct MP4DescriptorRecord *s) { - MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr) s; - if ( self->data ) - { - free( self->data ); - self->data = NULL; - } - if (self->name) free( self->name ); - free( s ); + MP4DefaultDescriptorPtr self = (MP4DefaultDescriptorPtr)s; + if(self->data) + { + free(self->data); + self->data = NULL; + } + if(self->name) free(self->name); + free(s); } -MP4Err MP4CreateDefaultDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateDefaultDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - char msgBuf[ 80 ]; - SETUP_BASE_DESCRIPTOR( MP4DefaultDescriptor ) - sprintf( msgBuf, "(some descriptor with tag 0x%02x and size %d)", tag, size ); - self->name = (char*) calloc( 1, strlen(msgBuf) + 1 ); - TESTMALLOC( self->name ) - strcpy( self->name, msgBuf ); - *outDesc = (MP4DescriptorPtr) self; + char msgBuf[80]; + SETUP_BASE_DESCRIPTOR(MP4DefaultDescriptor) + sprintf(msgBuf, "(some descriptor with tag 0x%02x and size %d)", tag, size); + self->name = (char *)calloc(1, strlen(msgBuf) + 1); + TESTMALLOC(self->name) + strcpy(self->name, msgBuf); + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4Descriptors.c b/IsoLib/libisomediafile/src/MP4Descriptors.c index cea8d42..802b338 100644 --- a/IsoLib/libisomediafile/src/MP4Descriptors.c +++ b/IsoLib/libisomediafile/src/MP4Descriptors.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,150 +15,167 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4Descriptors.c,v 1.3 2002/09/25 18:31:08 julien Exp $ + $Id: MP4Descriptors.c,v 1.3 2002/09/25 18:31:08 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include "MP4Impl.h" -#define GET_DESCRIPTOR_BYTE( varName, what ) \ - err = inputStream->read8( inputStream, &varName, what ); if (err) goto bail; \ - bytesRead ++ +#define GET_DESCRIPTOR_BYTE(varName, what) \ + err = inputStream->read8(inputStream, &varName, what); \ + if(err) goto bail; \ + bytesRead++ -MP4Err MP4ParseDescriptor( MP4InputStreamPtr inputStream, MP4DescriptorPtr *outDesc ) +MP4Err MP4ParseDescriptor(MP4InputStreamPtr inputStream, MP4DescriptorPtr *outDesc) { - MP4Err err; - u32 tag; - u32 size; - u32 val; - MP4DescriptorPtr desc; - u32 bytesRead; - u32 sizeBytes; - char msgbuf[ 80 ]; - - if ( (inputStream == NULL) || (outDesc == NULL) ) - BAILWITHERROR( MP4BadParamErr ) - inputStream->msg( inputStream, "{" ); - inputStream->indent++; - bytesRead = 0; - GET_DESCRIPTOR_BYTE( tag, "class tag" ); - - /* get size */ - size = 0; - sizeBytes = 1; - do - { - GET_DESCRIPTOR_BYTE( val, "size byte" ); - sizeBytes++; - size <<= 7; - size |= val & 0x7F; - } while ( val & 0x80 ); - size += sizeBytes; - - switch ( tag ) - { - case MP4InitialObjectDescriptorTag: - case MP4_IOD_Tag: - err = MP4CreateInitialObjectDescriptor( MP4_IOD_Tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4ES_DescriptorTag: - err = MP4CreateES_Descriptor( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4DecoderConfigDescriptorTag: - err = MP4CreateDecoderConfigDescriptor( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4ES_ID_IncDescriptorTag: - err = MP4CreateES_ID_IncDescriptor( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4ES_ID_RefDescriptorTag: - err = MP4CreateES_ID_RefDescriptor( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4SLConfigDescriptorTag: - err = MP4CreateSLConfigDescriptor( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4ObjectDescriptorTag: - case MP4_OD_Tag: - err = MP4CreateObjectDescriptor( MP4ObjectDescriptorTag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4IPMP_ToolTag: - err = MP4CreateIPMPTool( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4IPMP_ToolListDescriptorTag: - err = MP4CreateIPMPToolListDescriptor( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4IPMP_ToolDescriptorTag: - err = MP4CreateIPMPToolDescriptor( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - case MP4IPMP_DescriptorPointerTag: - case MP4_IPMP_ToolDescriptorPointerTag: - err = MP4CreateIPMPDescriptorPointer( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - - default: - err = MP4CreateDefaultDescriptor( tag, size, bytesRead, &desc ); if (err) goto bail; - break; - } - sprintf( msgbuf, "descriptor is %s", desc->name ); - inputStream->msg( inputStream, msgbuf ); - err = desc->createFromInputStream( desc, inputStream ); if (err) goto bail; - *outDesc = desc; - inputStream->indent--; - inputStream->msg( inputStream, "}" ); + MP4Err err; + u32 tag; + u32 size; + u32 val; + MP4DescriptorPtr desc; + u32 bytesRead; + u32 sizeBytes; + char msgbuf[80]; + + if((inputStream == NULL) || (outDesc == NULL)) BAILWITHERROR(MP4BadParamErr) + inputStream->msg(inputStream, "{"); + inputStream->indent++; + bytesRead = 0; + GET_DESCRIPTOR_BYTE(tag, "class tag"); + + /* get size */ + size = 0; + sizeBytes = 1; + do + { + GET_DESCRIPTOR_BYTE(val, "size byte"); + sizeBytes++; + size <<= 7; + size |= val & 0x7F; + } while(val & 0x80); + size += sizeBytes; + + switch(tag) + { + case MP4InitialObjectDescriptorTag: + case MP4_IOD_Tag: + err = MP4CreateInitialObjectDescriptor(MP4_IOD_Tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4ES_DescriptorTag: + err = MP4CreateES_Descriptor(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4DecoderConfigDescriptorTag: + err = MP4CreateDecoderConfigDescriptor(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4ES_ID_IncDescriptorTag: + err = MP4CreateES_ID_IncDescriptor(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4ES_ID_RefDescriptorTag: + err = MP4CreateES_ID_RefDescriptor(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4SLConfigDescriptorTag: + err = MP4CreateSLConfigDescriptor(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4ObjectDescriptorTag: + case MP4_OD_Tag: + err = MP4CreateObjectDescriptor(MP4ObjectDescriptorTag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4IPMP_ToolTag: + err = MP4CreateIPMPTool(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4IPMP_ToolListDescriptorTag: + err = MP4CreateIPMPToolListDescriptor(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4IPMP_ToolDescriptorTag: + err = MP4CreateIPMPToolDescriptor(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + case MP4IPMP_DescriptorPointerTag: + case MP4_IPMP_ToolDescriptorPointerTag: + err = MP4CreateIPMPDescriptorPointer(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + + default: + err = MP4CreateDefaultDescriptor(tag, size, bytesRead, &desc); + if(err) goto bail; + break; + } + sprintf(msgbuf, "descriptor is %s", desc->name); + inputStream->msg(inputStream, msgbuf); + err = desc->createFromInputStream(desc, inputStream); + if(err) goto bail; + *outDesc = desc; + inputStream->indent--; + inputStream->msg(inputStream, "}"); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CopyDescriptor( MP4DescriptorPtr inDesc, MP4DescriptorPtr *outDesc ) +MP4Err MP4CopyDescriptor(MP4DescriptorPtr inDesc, MP4DescriptorPtr *outDesc) { - MP4Err err; - MP4Handle myHandle; - MP4InputStreamPtr is; - - is = NULL; myHandle = NULL; - - err = inDesc->calculateSize( inDesc ); if (err) goto bail; - err = MP4NewHandle(inDesc->size, &myHandle); if (err) goto bail; - err = inDesc->serialize( inDesc, *myHandle ); if (err) goto bail; - - err = MP4CreateMemoryInputStream(*myHandle, inDesc->size, &is ); if (err) goto bail; - is->debugging = 0; - - - err = MP4ParseDescriptor( is, outDesc ); if (err) goto bail; + MP4Err err; + MP4Handle myHandle; + MP4InputStreamPtr is; + + is = NULL; + myHandle = NULL; + + err = inDesc->calculateSize(inDesc); + if(err) goto bail; + err = MP4NewHandle(inDesc->size, &myHandle); + if(err) goto bail; + err = inDesc->serialize(inDesc, *myHandle); + if(err) goto bail; + + err = MP4CreateMemoryInputStream(*myHandle, inDesc->size, &is); + if(err) goto bail; + is->debugging = 0; + + err = MP4ParseDescriptor(is, outDesc); + if(err) goto bail; bail: - if (is) { - is->destroy( is ); - is = NULL; - } - - if (myHandle) - { - err = MP4DisposeHandle( myHandle ); - myHandle = NULL; - } - - - TEST_RETURN( err ); - - return err; -} + if(is) + { + is->destroy(is); + is = NULL; + } + + if(myHandle) + { + err = MP4DisposeHandle(myHandle); + myHandle = NULL; + } + TEST_RETURN(err); + + return err; +} diff --git a/IsoLib/libisomediafile/src/MP4Descriptors.h b/IsoLib/libisomediafile/src/MP4Descriptors.h index 1f49e6a..1f73e69 100644 --- a/IsoLib/libisomediafile/src/MP4Descriptors.h +++ b/IsoLib/libisomediafile/src/MP4Descriptors.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: MP4Descriptors.h,v 1.5 2002/10/01 12:49:19 julien Exp $ + $Id: MP4Descriptors.h,v 1.5 2002/10/01 12:49:19 julien Exp $ */ #ifndef INCLUDED_MP4_DESCRIPTORS_H #define INCLUDED_MP4_DESCRIPTORS_H @@ -33,301 +33,302 @@ derivative works. Copyright (c) 1999, 2000. enum { - MP4ForbiddenZeroDescriptorTag = 0x0, - MP4ObjectDescriptorTag = 0x01, - MP4InitialObjectDescriptorTag = 0x02, - MP4ES_DescriptorTag = 0x03, - MP4DecoderConfigDescriptorTag = 0x04, - MP4DecSpecificInfoDescriptorTag = 0x05, - MP4SLConfigDescriptorTag = 0x06, - MP4ContentIdentDescriptorTag = 0x07, - MP4SupplContentIdentDescriptorTag = 0x08, - MP4IPI_DescriptorPointerTag = 0x09, - MP4IPMP_DescriptorPointerTag = 0x0A, - MP4IPMP_DescriptorTag = 0x0B, - MPM4QoS_DescriptorTag = 0x0C, - MP4RegistrationDescriptorTag = 0x0D, - - MP4ES_ID_IncDescriptorTag = 0x0E, - MP4ES_ID_RefDescriptorTag = 0x0F, - MP4_IOD_Tag = 0x10, - MP4_OD_Tag = 0x11, - MP4IPI_DescrPointerRefTag = 0x12, - MP4ExtendedProfileLevelDescrTag = 0x13, - MP4profileLevelIndicationIndexDescrTag = 0x14, - MP4_IPMP_ToolDescriptorPointerTag = 0x15, - - MP4ISO_DESC_RANGE_BEGIN = 0x16, - MP4ISO_DESC_RANGE_END = 0x3F, - - - MP4ContentClassificationDescriptorTag = 0x40, - MP4KeyWordDescriptorTag = 0x41, - MP4RatingDescriptorTag = 0x42, - MP4LanguageDescriptorTag = 0x43, - MP4ShortTextualDescriptorTag = 0x44, - MP4ExpandedTextualDescriptorTag = 0x45, - MP4ContentCreatorNameDescriptorTag = 0x46, - MP4ContentCreationDateDescriptorTag = 0x47, - MP4OCICreatorNameDescriptorTag = 0x48, - MP4OCICreationDateDescriptorTag = 0x49, - - MP4ISO_OCI_EXT_RANGE_BEGIN = 0x4A, - MP4ISO_OCI_EXT_RANGE_END = 0x5F, - - MP4IPMP_ToolListDescriptorTag = 0x60, - MP4IPMP_ToolParamDescriptorTag = 0x61, - MP4IPMP_ToolDescriptorTag = 0x62, - MP4IPMP_ToolTag = 0x63, - - MP4ISO_RESERVED_RANGE_BEGIN = 0x64, - MP4ISO_RESERVED_RANGE_END = 0xBF, - - MP4_USER_DESC_RANGE_BEGIN = 0xC0, - MP4_USER_DESC_RANGE_END = 0xFE, - - MP4ForbiddenFFTag = 0xFF + MP4ForbiddenZeroDescriptorTag = 0x0, + MP4ObjectDescriptorTag = 0x01, + MP4InitialObjectDescriptorTag = 0x02, + MP4ES_DescriptorTag = 0x03, + MP4DecoderConfigDescriptorTag = 0x04, + MP4DecSpecificInfoDescriptorTag = 0x05, + MP4SLConfigDescriptorTag = 0x06, + MP4ContentIdentDescriptorTag = 0x07, + MP4SupplContentIdentDescriptorTag = 0x08, + MP4IPI_DescriptorPointerTag = 0x09, + MP4IPMP_DescriptorPointerTag = 0x0A, + MP4IPMP_DescriptorTag = 0x0B, + MPM4QoS_DescriptorTag = 0x0C, + MP4RegistrationDescriptorTag = 0x0D, + + MP4ES_ID_IncDescriptorTag = 0x0E, + MP4ES_ID_RefDescriptorTag = 0x0F, + MP4_IOD_Tag = 0x10, + MP4_OD_Tag = 0x11, + MP4IPI_DescrPointerRefTag = 0x12, + MP4ExtendedProfileLevelDescrTag = 0x13, + MP4profileLevelIndicationIndexDescrTag = 0x14, + MP4_IPMP_ToolDescriptorPointerTag = 0x15, + + MP4ISO_DESC_RANGE_BEGIN = 0x16, + MP4ISO_DESC_RANGE_END = 0x3F, + + MP4ContentClassificationDescriptorTag = 0x40, + MP4KeyWordDescriptorTag = 0x41, + MP4RatingDescriptorTag = 0x42, + MP4LanguageDescriptorTag = 0x43, + MP4ShortTextualDescriptorTag = 0x44, + MP4ExpandedTextualDescriptorTag = 0x45, + MP4ContentCreatorNameDescriptorTag = 0x46, + MP4ContentCreationDateDescriptorTag = 0x47, + MP4OCICreatorNameDescriptorTag = 0x48, + MP4OCICreationDateDescriptorTag = 0x49, + + MP4ISO_OCI_EXT_RANGE_BEGIN = 0x4A, + MP4ISO_OCI_EXT_RANGE_END = 0x5F, + + MP4IPMP_ToolListDescriptorTag = 0x60, + MP4IPMP_ToolParamDescriptorTag = 0x61, + MP4IPMP_ToolDescriptorTag = 0x62, + MP4IPMP_ToolTag = 0x63, + + MP4ISO_RESERVED_RANGE_BEGIN = 0x64, + MP4ISO_RESERVED_RANGE_END = 0xBF, + + MP4_USER_DESC_RANGE_BEGIN = 0xC0, + MP4_USER_DESC_RANGE_END = 0xFE, + + MP4ForbiddenFFTag = 0xFF }; enum { - MP4ObjectDescriptorUpdateTag = 0x01, - MP4ObjectDescriptorRemoveTag = 0x02, - MP4ESDescriptorUpdateTag = 0x03, - MP4ESDescriptorRemoveTag = 0x04, - MP4IPMP_DescriptorUpdateTag = 0x05, - MP4IPMP_DescriptorRemoveTag = 0x06, - MP4ESDRemove_Tag = 0x07, - MP4ObjectDescrExecuteTag = 0x08, - MP4IPMP_ToolDescriptorUpdateTag = 0x09, - MP4IPMP_ToolDescriptorRemoveTag = 0x0A, - - MP4ISO_RESERVED_COMMANDS_BEGIN = 0x0B, - MP4ISO_RESERVED_COMMANDS_END = 0xBF, - - MP4USER_RESERVED_COMMANDS_BEGIN = 0xC0, - MP4USER_RESERVED_COMMANDS_END = 0xFE - + MP4ObjectDescriptorUpdateTag = 0x01, + MP4ObjectDescriptorRemoveTag = 0x02, + MP4ESDescriptorUpdateTag = 0x03, + MP4ESDescriptorRemoveTag = 0x04, + MP4IPMP_DescriptorUpdateTag = 0x05, + MP4IPMP_DescriptorRemoveTag = 0x06, + MP4ESDRemove_Tag = 0x07, + MP4ObjectDescrExecuteTag = 0x08, + MP4IPMP_ToolDescriptorUpdateTag = 0x09, + MP4IPMP_ToolDescriptorRemoveTag = 0x0A, + + MP4ISO_RESERVED_COMMANDS_BEGIN = 0x0B, + MP4ISO_RESERVED_COMMANDS_END = 0xBF, + + MP4USER_RESERVED_COMMANDS_BEGIN = 0xC0, + MP4USER_RESERVED_COMMANDS_END = 0xFE + }; enum { - SLConfigPredefinedNull = 1, - SLConfigPredefinedMP4 = 2 + SLConfigPredefinedNull = 1, + SLConfigPredefinedMP4 = 2 }; -#define MP4_BASE_DESCRIPTOR \ - u32 tag; \ - u32 size; \ - char *name; \ - u32 bytesRead; \ - u32 bytesWritten; \ - MP4Err (*createFromInputStream)( struct MP4DescriptorRecord* self, struct MP4InputStreamRecord* inputStream ); \ - MP4Err (*serialize)( struct MP4DescriptorRecord* self, char* buffer ); \ - MP4Err (*calculateSize)( struct MP4DescriptorRecord* self ); \ - void (*destroy)( struct MP4DescriptorRecord* self ); - +#define MP4_BASE_DESCRIPTOR \ + u32 tag; \ + u32 size; \ + char *name; \ + u32 bytesRead; \ + u32 bytesWritten; \ + MP4Err (*createFromInputStream)(struct MP4DescriptorRecord * self, \ + struct MP4InputStreamRecord * inputStream); \ + MP4Err (*serialize)(struct MP4DescriptorRecord * self, char *buffer); \ + MP4Err (*calculateSize)(struct MP4DescriptorRecord * self); \ + void (*destroy)(struct MP4DescriptorRecord * self); #define DESCRIPTOR_TAG_LEN_SIZE 5 typedef struct MP4DescriptorRecord { - MP4_BASE_DESCRIPTOR + MP4_BASE_DESCRIPTOR } MP4Descriptor, *MP4DescriptorPtr; typedef struct MP4DefaultDescriptorRecord { - MP4_BASE_DESCRIPTOR - u32 dataLength; - char *data; + MP4_BASE_DESCRIPTOR + u32 dataLength; + char *data; } MP4DefaultDescriptor, *MP4DefaultDescriptorPtr; typedef struct MP4ES_ID_IncDescriptorRecord { - MP4_BASE_DESCRIPTOR - u32 trackID; + MP4_BASE_DESCRIPTOR + u32 trackID; } MP4ES_ID_IncDescriptor, *MP4ES_ID_IncDescriptorPtr; typedef struct MP4ES_ID_RefDescriptorRecord { - MP4_BASE_DESCRIPTOR - u32 refIndex; + MP4_BASE_DESCRIPTOR + u32 refIndex; } MP4ES_ID_RefDescriptor, *MP4ES_ID_RefDescriptorPtr; -#define MP4_OBJECT_DESCRIPTOR \ - MP4_BASE_DESCRIPTOR \ - MP4Err (*addDescriptor)( struct MP4DescriptorRecord* self, MP4DescriptorPtr desc ); \ - MP4Err (*removeESDS)( struct MP4DescriptorRecord* self ); \ - u32 objectDescriptorID; \ - u32 URLStringLength; \ - char *URLString; \ - MP4LinkedList ES_ID_IncDescriptors; \ - MP4LinkedList ESDescriptors; \ - MP4LinkedList OCIDescriptors; \ - MP4LinkedList IPMPDescriptorPointers; \ - MP4LinkedList extensionDescriptors; - +#define MP4_OBJECT_DESCRIPTOR \ + MP4_BASE_DESCRIPTOR \ + MP4Err (*addDescriptor)(struct MP4DescriptorRecord * self, MP4DescriptorPtr desc); \ + MP4Err (*removeESDS)(struct MP4DescriptorRecord * self); \ + u32 objectDescriptorID; \ + u32 URLStringLength; \ + char *URLString; \ + MP4LinkedList ES_ID_IncDescriptors; \ + MP4LinkedList ESDescriptors; \ + MP4LinkedList OCIDescriptors; \ + MP4LinkedList IPMPDescriptorPointers; \ + MP4LinkedList extensionDescriptors; + typedef struct MP4InitialObjectDescriptorRecord { - MP4_OBJECT_DESCRIPTOR - u32 inlineProfileFlag; - u32 OD_profileAndLevel; - u32 scene_profileAndLevel; - u32 audio_profileAndLevel; - u32 visual_profileAndLevel; - u32 graphics_profileAndLevel; - MP4DescriptorPtr IPMPToolListDescriptor; - MP4LinkedList IPMPToolDescriptors; + MP4_OBJECT_DESCRIPTOR + u32 inlineProfileFlag; + u32 OD_profileAndLevel; + u32 scene_profileAndLevel; + u32 audio_profileAndLevel; + u32 visual_profileAndLevel; + u32 graphics_profileAndLevel; + MP4DescriptorPtr IPMPToolListDescriptor; + MP4LinkedList IPMPToolDescriptors; } MP4InitialObjectDescriptor, *MP4InitialObjectDescriptorPtr; typedef struct MP4ObjectDescriptorRecord { - MP4_OBJECT_DESCRIPTOR - MP4LinkedList ES_ID_RefDescriptors; + MP4_OBJECT_DESCRIPTOR + MP4LinkedList ES_ID_RefDescriptors; } MP4ObjectDescriptor, *MP4ObjectDescriptorPtr; typedef struct MP4ES_DescriptorRecord { - MP4_BASE_DESCRIPTOR - MP4Err (*addDescriptor)( struct MP4DescriptorRecord* self, MP4DescriptorPtr desc ); - u32 ESID; - u32 dependsOnES; - u32 streamPriority; - u32 OCRESID; - u32 URLStringLength; - char *URLString; - MP4DescriptorPtr decoderConfig; - MP4DescriptorPtr slConfig; - MP4DescriptorPtr ipiPtr; - MP4DescriptorPtr qos; - MP4LinkedList IPIDataSet; - MP4LinkedList langDesc; - MP4LinkedList IPMPDescriptorPointers; - MP4LinkedList extensionDescriptors; + MP4_BASE_DESCRIPTOR + MP4Err (*addDescriptor)(struct MP4DescriptorRecord *self, MP4DescriptorPtr desc); + u32 ESID; + u32 dependsOnES; + u32 streamPriority; + u32 OCRESID; + u32 URLStringLength; + char *URLString; + MP4DescriptorPtr decoderConfig; + MP4DescriptorPtr slConfig; + MP4DescriptorPtr ipiPtr; + MP4DescriptorPtr qos; + MP4LinkedList IPIDataSet; + MP4LinkedList langDesc; + MP4LinkedList IPMPDescriptorPointers; + MP4LinkedList extensionDescriptors; } MP4ES_Descriptor, *MP4ES_DescriptorPtr; typedef struct MP4DecoderConfigDescriptorRecord { - MP4_BASE_DESCRIPTOR - u32 objectTypeIndication; - u32 streamType; - u32 upstream; - u32 bufferSizeDB; - u32 maxBitrate; - u32 avgBitrate; - MP4DescriptorPtr decoderSpecificInfo; + MP4_BASE_DESCRIPTOR + u32 objectTypeIndication; + u32 streamType; + u32 upstream; + u32 bufferSizeDB; + u32 maxBitrate; + u32 avgBitrate; + MP4DescriptorPtr decoderSpecificInfo; } MP4DecoderConfigDescriptor, *MP4DecoderConfigDescriptorPtr; typedef struct MP4SLConfigDescriptorRecord { - MP4_BASE_DESCRIPTOR - u32 predefined; - u32 useAccessUnitStartFlag; - u32 useAccessUnitEndFlag; - u32 useRandomAccessPointFlag; - u32 useRandomAccessUnitsOnlyFlag; - u32 usePaddingFlag; - u32 useTimestampsFlag; - u32 useIdleFlag; - u32 durationFlag; - - u32 timestampResolution; - u32 OCRResolution; - u32 timestampLength; - u32 OCRLength; - u32 AULength; - u32 instantBitrateLength; - u32 degradationPriorityLength; - u32 AUSeqNumLength; - u32 packetSeqNumLength; - u32 timeScale; - u32 AUDuration; - u32 CUDuration; - u64 startDTS; - u64 startCTS; - MP4LinkedList extensionDescriptors; + MP4_BASE_DESCRIPTOR + u32 predefined; + u32 useAccessUnitStartFlag; + u32 useAccessUnitEndFlag; + u32 useRandomAccessPointFlag; + u32 useRandomAccessUnitsOnlyFlag; + u32 usePaddingFlag; + u32 useTimestampsFlag; + u32 useIdleFlag; + u32 durationFlag; + + u32 timestampResolution; + u32 OCRResolution; + u32 timestampLength; + u32 OCRLength; + u32 AULength; + u32 instantBitrateLength; + u32 degradationPriorityLength; + u32 AUSeqNumLength; + u32 packetSeqNumLength; + u32 timeScale; + u32 AUDuration; + u32 CUDuration; + u64 startDTS; + u64 startCTS; + MP4LinkedList extensionDescriptors; } MP4SLConfigDescriptor, *MP4SLConfigDescriptorPtr; typedef struct MP4ObjectDescriptorUpdateRecord { - MP4_BASE_DESCRIPTOR - MP4Err (*addDescriptor)( struct MP4DescriptorRecord* self, MP4DescriptorPtr desc ); - MP4LinkedList objectDescriptors; - MP4LinkedList extensionDescriptors; + MP4_BASE_DESCRIPTOR + MP4Err (*addDescriptor)(struct MP4DescriptorRecord *self, MP4DescriptorPtr desc); + MP4LinkedList objectDescriptors; + MP4LinkedList extensionDescriptors; } MP4ObjectDescriptorUpdate, *MP4ObjectDescriptorUpdatePtr; typedef struct MP4ESDescriptorUpdateRecord { - MP4_OBJECT_DESCRIPTOR - MP4LinkedList ES_ID_RefDescriptors; + MP4_OBJECT_DESCRIPTOR + MP4LinkedList ES_ID_RefDescriptors; } MP4ESDescriptorUpdate, *MP4ESDescriptorUpdatePtr; typedef struct MP4IPMPToolRecord { - MP4_BASE_DESCRIPTOR - MP4IPMPToolIdPtr toolId; - MP4LinkedList alternateToolIds; - MP4IPMPByteArrayPtr toolParamDesc; - MP4LinkedList toolUrls; + MP4_BASE_DESCRIPTOR + MP4IPMPToolIdPtr toolId; + MP4LinkedList alternateToolIds; + MP4IPMPByteArrayPtr toolParamDesc; + MP4LinkedList toolUrls; } MP4IPMPTool, *MP4IPMPToolPtr; typedef struct MP4IPMPToolListDescriptorRecord { - MP4_BASE_DESCRIPTOR - MP4Err (*addDescriptor) ( struct MP4DescriptorRecord* self, MP4DescriptorPtr desc ); - MP4LinkedList ipmpTools; + MP4_BASE_DESCRIPTOR + MP4Err (*addDescriptor)(struct MP4DescriptorRecord *self, MP4DescriptorPtr desc); + MP4LinkedList ipmpTools; } MP4IPMPToolListDescriptor, *MP4IPMPToolListDescriptorPtr; typedef struct MP4IPMPDescriptorPointerRecord { - MP4_BASE_DESCRIPTOR - u32 ipmpDescriptorId; /* fb_reso u8 */ - u32 ipmpToolDescriptorId; /* fb_reso u16 */ - u16 ipmpEsId; /* fb_reso u16 */ + MP4_BASE_DESCRIPTOR + u32 ipmpDescriptorId; /* fb_reso u8 */ + u32 ipmpToolDescriptorId; /* fb_reso u16 */ + u16 ipmpEsId; /* fb_reso u16 */ } MP4IPMPDescriptorPointer, *MP4IPMPDescriptorPointerPtr; typedef struct MP4IPMPToolDescriptorRecord { - MP4_BASE_DESCRIPTOR - u16 ipmpToolDescriptorId; /* fb_reso u16 */ - MP4IPMPToolIdPtr ipmpToolId; - MP4IPMPByteArrayPtr url; - MP4IPMPInitializePtr initData; - MP4LinkedList ipmpxData; - MP4Err (*addIPMPXData)( struct MP4DescriptorRecord* self, MP4IPMPXDataPtr data ); + MP4_BASE_DESCRIPTOR + u16 ipmpToolDescriptorId; /* fb_reso u16 */ + MP4IPMPToolIdPtr ipmpToolId; + MP4IPMPByteArrayPtr url; + MP4IPMPInitializePtr initData; + MP4LinkedList ipmpxData; + MP4Err (*addIPMPXData)(struct MP4DescriptorRecord *self, MP4IPMPXDataPtr data); } MP4IPMPToolDescriptor, *MP4IPMPToolDescriptorPtr; typedef struct MP4IPMPToolDescriptorUpdateRecord { - MP4_BASE_DESCRIPTOR - MP4Err (*addDescriptor)( struct MP4DescriptorRecord* self, MP4DescriptorPtr desc ); - MP4LinkedList ipmpToolDescriptors; + MP4_BASE_DESCRIPTOR + MP4Err (*addDescriptor)(struct MP4DescriptorRecord *self, MP4DescriptorPtr desc); + MP4LinkedList ipmpToolDescriptors; } MP4IPMPToolDescriptorUpdate, *MP4IPMPToolDescriptorUpdatePtr; - -MP4Err MP4ParseDescriptor( struct MP4InputStreamRecord* inputStream, MP4DescriptorPtr *outDesc ); -MP4Err MP4ParseCommand( struct MP4InputStreamRecord* inputStream, MP4DescriptorPtr *outDesc ); - -MP4Err MP4CopyDescriptor( MP4DescriptorPtr inDesc, MP4DescriptorPtr *outDesc ); -MP4Err MP4EncodeBaseDescriptor( struct MP4DescriptorRecord* self, char* buffer ); - -MP4Err MP4CreateDefaultCommand( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateObjectDescriptorUpdate( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateESDescriptorUpdate( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - -MP4Err MP4CreateInitialObjectDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateES_Descriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateDefaultDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateDecoderConfigDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateES_ID_IncDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateES_ID_RefDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateSLConfigDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateObjectDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - -MP4Err MP4CreateIPMPTool( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateIPMPToolListDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateIPMPDescriptorPointer( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateIPMPToolDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); -MP4Err MP4CreateIPMPToolDescriptorUpdate( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); +MP4Err MP4ParseDescriptor(struct MP4InputStreamRecord *inputStream, MP4DescriptorPtr *outDesc); +MP4Err MP4ParseCommand(struct MP4InputStreamRecord *inputStream, MP4DescriptorPtr *outDesc); + +MP4Err MP4CopyDescriptor(MP4DescriptorPtr inDesc, MP4DescriptorPtr *outDesc); +MP4Err MP4EncodeBaseDescriptor(struct MP4DescriptorRecord *self, char *buffer); + +MP4Err MP4CreateDefaultCommand(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); +MP4Err MP4CreateObjectDescriptorUpdate(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); +MP4Err MP4CreateESDescriptorUpdate(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); + +MP4Err MP4CreateInitialObjectDescriptor(u32 tag, u32 size, u32 bytesRead, + MP4DescriptorPtr *outDesc); +MP4Err MP4CreateES_Descriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); +MP4Err MP4CreateDefaultDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); +MP4Err MP4CreateDecoderConfigDescriptor(u32 tag, u32 size, u32 bytesRead, + MP4DescriptorPtr *outDesc); +MP4Err MP4CreateES_ID_IncDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); +MP4Err MP4CreateES_ID_RefDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); +MP4Err MP4CreateSLConfigDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); +MP4Err MP4CreateObjectDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); + +MP4Err MP4CreateIPMPTool(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); +MP4Err MP4CreateIPMPToolListDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); +MP4Err MP4CreateIPMPDescriptorPointer(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); +MP4Err MP4CreateIPMPToolDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc); +MP4Err MP4CreateIPMPToolDescriptorUpdate(u32 tag, u32 size, u32 bytesRead, + MP4DescriptorPtr *outDesc); #endif diff --git a/IsoLib/libisomediafile/src/MP4ESDescriptor.c b/IsoLib/libisomediafile/src/MP4ESDescriptor.c index b4faa76..cdf8b0e 100644 --- a/IsoLib/libisomediafile/src/MP4ESDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4ESDescriptor.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,291 +15,290 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: MP4ESDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4ESDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include #include - /* JLF 11/00 : added AddDescriptor for needed. */ -static MP4Err addDescriptor( struct MP4DescriptorRecord* s, MP4DescriptorPtr desc ) +static MP4Err addDescriptor(struct MP4DescriptorRecord *s, MP4DescriptorPtr desc) { - MP4Err err; - MP4ES_DescriptorPtr self = (MP4ES_DescriptorPtr) s; - err = MP4NoErr; - - /* try to handle OCI */ - if ( (desc->tag >= MP4ISO_OCI_EXT_RANGE_BEGIN) - && (desc->tag <= MP4ISO_OCI_EXT_RANGE_END) ) { - return MP4AddListEntry( desc, self->IPIDataSet ); - } - - switch( desc->tag ) { - case MP4DecoderConfigDescriptorTag: - if ( self->decoderConfig ) - BAILWITHERROR( MP4InvalidMediaErr ) - self->decoderConfig = desc; - break; - - case MP4SLConfigDescriptorTag: - if ( self->slConfig ) - BAILWITHERROR( MP4InvalidMediaErr ) - self->slConfig = desc; - break; - - case MP4IPI_DescriptorPointerTag: - if ( self->ipiPtr ) - BAILWITHERROR( MP4InvalidMediaErr ) - self->ipiPtr = desc; - break; - - case MPM4QoS_DescriptorTag: - if ( self->qos ) - BAILWITHERROR( MP4InvalidMediaErr ) - self->qos = desc; - break; - - case MP4LanguageDescriptorTag: - err = MP4AddListEntry( desc, self->langDesc ); if (err) goto bail; - break; - - case MP4IPMP_DescriptorPointerTag: - err = MP4AddListEntry( desc, self->IPMPDescriptorPointers ); if (err) goto bail; - break; - - case MP4ContentIdentDescriptorTag: - case MP4SupplContentIdentDescriptorTag: - err = MP4AddListEntry( desc, self->IPIDataSet ); if (err) goto bail; - break; - - default: - err = MP4AddListEntry( desc, self->extensionDescriptors ); if (err) goto bail; - break; - - } + MP4Err err; + MP4ES_DescriptorPtr self = (MP4ES_DescriptorPtr)s; + err = MP4NoErr; + + /* try to handle OCI */ + if((desc->tag >= MP4ISO_OCI_EXT_RANGE_BEGIN) && (desc->tag <= MP4ISO_OCI_EXT_RANGE_END)) + { + return MP4AddListEntry(desc, self->IPIDataSet); + } + + switch(desc->tag) + { + case MP4DecoderConfigDescriptorTag: + if(self->decoderConfig) BAILWITHERROR(MP4InvalidMediaErr) + self->decoderConfig = desc; + break; + + case MP4SLConfigDescriptorTag: + if(self->slConfig) BAILWITHERROR(MP4InvalidMediaErr) + self->slConfig = desc; + break; + + case MP4IPI_DescriptorPointerTag: + if(self->ipiPtr) BAILWITHERROR(MP4InvalidMediaErr) + self->ipiPtr = desc; + break; + + case MPM4QoS_DescriptorTag: + if(self->qos) BAILWITHERROR(MP4InvalidMediaErr) + self->qos = desc; + break; + + case MP4LanguageDescriptorTag: + err = MP4AddListEntry(desc, self->langDesc); + if(err) goto bail; + break; + + case MP4IPMP_DescriptorPointerTag: + err = MP4AddListEntry(desc, self->IPMPDescriptorPointers); + if(err) goto bail; + break; + + case MP4ContentIdentDescriptorTag: + case MP4SupplContentIdentDescriptorTag: + err = MP4AddListEntry(desc, self->IPIDataSet); + if(err) goto bail; + break; + + default: + err = MP4AddListEntry(desc, self->extensionDescriptors); + if(err) goto bail; + break; + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - u32 count; - u32 i; - MP4DescriptorPtr desc; - MP4ES_DescriptorPtr self = (MP4ES_DescriptorPtr) s; - err = MP4NoErr; - self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ - self->size += 3; - if ( self->dependsOnES ) - self->size += 2; - if ( self->OCRESID ) - self->size += 2; - if ( self->URLStringLength ) - self->size += self->URLStringLength + 1; - ADD_DESCRIPTOR_SIZE( decoderConfig ); - ADD_DESCRIPTOR_SIZE( slConfig ); - ADD_DESCRIPTOR_SIZE( ipiPtr ); - ADD_DESCRIPTOR_SIZE( qos ); - - ADD_DESCRIPTOR_LIST_SIZE( IPIDataSet ); - ADD_DESCRIPTOR_LIST_SIZE( langDesc ); - ADD_DESCRIPTOR_LIST_SIZE( IPMPDescriptorPointers ); - ADD_DESCRIPTOR_LIST_SIZE( extensionDescriptors ); + MP4Err err; + u32 count; + u32 i; + MP4DescriptorPtr desc; + MP4ES_DescriptorPtr self = (MP4ES_DescriptorPtr)s; + err = MP4NoErr; + self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ + self->size += 3; + if(self->dependsOnES) self->size += 2; + if(self->OCRESID) self->size += 2; + if(self->URLStringLength) self->size += self->URLStringLength + 1; + ADD_DESCRIPTOR_SIZE(decoderConfig); + ADD_DESCRIPTOR_SIZE(slConfig); + ADD_DESCRIPTOR_SIZE(ipiPtr); + ADD_DESCRIPTOR_SIZE(qos); + + ADD_DESCRIPTOR_LIST_SIZE(IPIDataSet); + ADD_DESCRIPTOR_LIST_SIZE(langDesc); + ADD_DESCRIPTOR_LIST_SIZE(IPMPDescriptorPointers); + ADD_DESCRIPTOR_LIST_SIZE(extensionDescriptors); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - u8 val; - MP4ES_DescriptorPtr self = (MP4ES_DescriptorPtr) s; - err = MP4NoErr; - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - - PUT16( ESID ); - val = self->streamPriority; - if ( self->OCRESID ) - val |= (1<<5); - if ( self->URLStringLength ) - val |= (1<<6); - if ( self->dependsOnES ) - val |= (1<<7); - PUT8_V( val ); - - if ( self->dependsOnES ) - { - PUT16( dependsOnES ); - } - if ( self->URLStringLength ) - { - PUT8( URLStringLength ); - PUTBYTES( self->URLString, self->URLStringLength ); - } - if ( self->OCRESID ) - { - PUT16( OCRESID ); - } - SERIALIZE_DESCRIPTOR( decoderConfig ); - SERIALIZE_DESCRIPTOR( slConfig ); - SERIALIZE_DESCRIPTOR( ipiPtr ); - SERIALIZE_DESCRIPTOR_LIST( IPIDataSet ); - SERIALIZE_DESCRIPTOR_LIST( IPMPDescriptorPointers ); - SERIALIZE_DESCRIPTOR_LIST( langDesc ); - SERIALIZE_DESCRIPTOR( qos ); - SERIALIZE_DESCRIPTOR_LIST( extensionDescriptors ); + MP4Err err; + u8 val; + MP4ES_DescriptorPtr self = (MP4ES_DescriptorPtr)s; + err = MP4NoErr; + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + + PUT16(ESID); + val = self->streamPriority; + if(self->OCRESID) val |= (1 << 5); + if(self->URLStringLength) val |= (1 << 6); + if(self->dependsOnES) val |= (1 << 7); + PUT8_V(val); + + if(self->dependsOnES) + { + PUT16(dependsOnES); + } + if(self->URLStringLength) + { + PUT8(URLStringLength); + PUTBYTES(self->URLString, self->URLStringLength); + } + if(self->OCRESID) + { + PUT16(OCRESID); + } + SERIALIZE_DESCRIPTOR(decoderConfig); + SERIALIZE_DESCRIPTOR(slConfig); + SERIALIZE_DESCRIPTOR(ipiPtr); + SERIALIZE_DESCRIPTOR_LIST(IPIDataSet); + SERIALIZE_DESCRIPTOR_LIST(IPMPDescriptorPointers); + SERIALIZE_DESCRIPTOR_LIST(langDesc); + SERIALIZE_DESCRIPTOR(qos); + SERIALIZE_DESCRIPTOR_LIST(extensionDescriptors); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 val; - u32 urlflag; - u32 streamDependenceFlag; - u32 ocrflag; - MP4ES_DescriptorPtr self = (MP4ES_DescriptorPtr) s; - err = MP4NoErr; - - GET16( ESID ); - GET8_V_MSG( val, NULL ); - streamDependenceFlag = val & (1 << 7) ? 1 : 0; - urlflag = val & (1 << 6) ? 1 : 0; - ocrflag = val & (1 << 5) ? 1 : 0; - /* ocrflag = 0; uncomment this line to ignore OCRFlag in systems V1 files */ - self->streamPriority = val & 0x1f; - - DEBUG_SPRINTF( "streamDependenceFlag = %d", streamDependenceFlag ); - DEBUG_SPRINTF( "urlflag = %d", urlflag ); - DEBUG_SPRINTF( "streamPriority = %d", self->streamPriority ); - DEBUG_SPRINTF( "OCRStreamFlag = %d", ocrflag ); - - /* jlf 12/00: get the streamDepend */ - if ( streamDependenceFlag ) - { - GET16( dependsOnES ); - } - - if ( urlflag ) - { - GET8( URLStringLength ); - self->URLString = (char*) calloc( 1, self->URLStringLength ); - TESTMALLOC( self->URLString ) - GETBYTES( self->URLStringLength, URLString ); - } - - if ( ocrflag ) - { - GET16( OCRESID ); - } - - while ( self->bytesRead < self->size ) - { - MP4DescriptorPtr desc; - err = MP4ParseDescriptor( inputStream, &desc ); if (err) goto bail; - switch( desc->tag ) - { - case MP4DecoderConfigDescriptorTag: - if ( self->decoderConfig ) - BAILWITHERROR( MP4InvalidMediaErr ) - self->decoderConfig = desc; - break; - - case MP4SLConfigDescriptorTag: - if ( self->slConfig ) - BAILWITHERROR( MP4InvalidMediaErr ) - self->slConfig = desc; - break; - - case MP4IPI_DescriptorPointerTag: - if ( self->ipiPtr ) - BAILWITHERROR( MP4InvalidMediaErr ) - self->ipiPtr = desc; - break; - - case MPM4QoS_DescriptorTag: - if ( self->qos ) - BAILWITHERROR( MP4InvalidMediaErr ) - self->qos = desc; - break; - - case MP4LanguageDescriptorTag: - err = MP4AddListEntry( desc, self->langDesc ); if (err) goto bail; - break; - - case MP4ContentIdentDescriptorTag: - case MP4SupplContentIdentDescriptorTag: - err = MP4AddListEntry( desc, self->IPIDataSet ); if (err) goto bail; - break; - - case MP4IPMP_DescriptorPointerTag: - err = MP4AddListEntry( desc, self->IPMPDescriptorPointers ); if (err) goto bail; - break; - - default: - err = MP4AddListEntry( desc, self->extensionDescriptors ); if (err) goto bail; - break; - } - self->bytesRead += desc->size; - } - + MP4Err err; + u32 val; + u32 urlflag; + u32 streamDependenceFlag; + u32 ocrflag; + MP4ES_DescriptorPtr self = (MP4ES_DescriptorPtr)s; + err = MP4NoErr; + + GET16(ESID); + GET8_V_MSG(val, NULL); + streamDependenceFlag = val & (1 << 7) ? 1 : 0; + urlflag = val & (1 << 6) ? 1 : 0; + ocrflag = val & (1 << 5) ? 1 : 0; + /* ocrflag = 0; uncomment this line to ignore OCRFlag in systems V1 files */ + self->streamPriority = val & 0x1f; + + DEBUG_SPRINTF("streamDependenceFlag = %d", streamDependenceFlag); + DEBUG_SPRINTF("urlflag = %d", urlflag); + DEBUG_SPRINTF("streamPriority = %d", self->streamPriority); + DEBUG_SPRINTF("OCRStreamFlag = %d", ocrflag); + + /* jlf 12/00: get the streamDepend */ + if(streamDependenceFlag) + { + GET16(dependsOnES); + } + + if(urlflag) + { + GET8(URLStringLength); + self->URLString = (char *)calloc(1, self->URLStringLength); + TESTMALLOC(self->URLString) + GETBYTES(self->URLStringLength, URLString); + } + + if(ocrflag) + { + GET16(OCRESID); + } + + while(self->bytesRead < self->size) + { + MP4DescriptorPtr desc; + err = MP4ParseDescriptor(inputStream, &desc); + if(err) goto bail; + switch(desc->tag) + { + case MP4DecoderConfigDescriptorTag: + if(self->decoderConfig) BAILWITHERROR(MP4InvalidMediaErr) + self->decoderConfig = desc; + break; + + case MP4SLConfigDescriptorTag: + if(self->slConfig) BAILWITHERROR(MP4InvalidMediaErr) + self->slConfig = desc; + break; + + case MP4IPI_DescriptorPointerTag: + if(self->ipiPtr) BAILWITHERROR(MP4InvalidMediaErr) + self->ipiPtr = desc; + break; + + case MPM4QoS_DescriptorTag: + if(self->qos) BAILWITHERROR(MP4InvalidMediaErr) + self->qos = desc; + break; + + case MP4LanguageDescriptorTag: + err = MP4AddListEntry(desc, self->langDesc); + if(err) goto bail; + break; + + case MP4ContentIdentDescriptorTag: + case MP4SupplContentIdentDescriptorTag: + err = MP4AddListEntry(desc, self->IPIDataSet); + if(err) goto bail; + break; + + case MP4IPMP_DescriptorPointerTag: + err = MP4AddListEntry(desc, self->IPMPDescriptorPointers); + if(err) goto bail; + break; + + default: + err = MP4AddListEntry(desc, self->extensionDescriptors); + if(err) goto bail; + break; + } + self->bytesRead += desc->size; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static void destroy( struct MP4DescriptorRecord* s ) +static void destroy(struct MP4DescriptorRecord *s) { - MP4ES_DescriptorPtr self = (MP4ES_DescriptorPtr) s; - if ( self->URLString ) { - free( self->URLString ); - self->URLString = NULL; - } - - DESTROY_DESCRIPTOR( decoderConfig ); - DESTROY_DESCRIPTOR( slConfig ); - DESTROY_DESCRIPTOR( ipiPtr ); - DESTROY_DESCRIPTOR( qos ); - DESTROY_DESCRIPTOR_LIST( IPIDataSet ) - DESTROY_DESCRIPTOR_LIST( langDesc ) - DESTROY_DESCRIPTOR_LIST( IPMPDescriptorPointers ) - DESTROY_DESCRIPTOR_LIST( extensionDescriptors ) - - free( s ); + MP4ES_DescriptorPtr self = (MP4ES_DescriptorPtr)s; + if(self->URLString) + { + free(self->URLString); + self->URLString = NULL; + } + + DESTROY_DESCRIPTOR(decoderConfig); + DESTROY_DESCRIPTOR(slConfig); + DESTROY_DESCRIPTOR(ipiPtr); + DESTROY_DESCRIPTOR(qos); + DESTROY_DESCRIPTOR_LIST(IPIDataSet) + DESTROY_DESCRIPTOR_LIST(langDesc) + DESTROY_DESCRIPTOR_LIST(IPMPDescriptorPointers) + DESTROY_DESCRIPTOR_LIST(extensionDescriptors) + + free(s); bail: - return; + return; } -MP4Err MP4CreateES_Descriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateES_Descriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4ES_Descriptor ) - self->addDescriptor = addDescriptor; - err = MP4MakeLinkedList( &self->IPIDataSet ); if (err) goto bail; - err = MP4MakeLinkedList( &self->langDesc ); if (err) goto bail; - err = MP4MakeLinkedList( &self->IPMPDescriptorPointers ); if (err) goto bail; - err = MP4MakeLinkedList( &self->extensionDescriptors ); if (err) goto bail; - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4ES_Descriptor) + self->addDescriptor = addDescriptor; + err = MP4MakeLinkedList(&self->IPIDataSet); + if(err) goto bail; + err = MP4MakeLinkedList(&self->langDesc); + if(err) goto bail; + err = MP4MakeLinkedList(&self->IPMPDescriptorPointers); + if(err) goto bail; + err = MP4MakeLinkedList(&self->extensionDescriptors); + if(err) goto bail; + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4ES_ID_IncDescriptor.c b/IsoLib/libisomediafile/src/MP4ES_ID_IncDescriptor.c index 2dc451c..a1b0d74 100644 --- a/IsoLib/libisomediafile/src/MP4ES_ID_IncDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4ES_ID_IncDescriptor.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,75 +15,70 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4ES_ID_IncDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4ES_ID_IncDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - MP4ES_ID_IncDescriptorPtr self = (MP4ES_ID_IncDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ - self->size += 4; + MP4Err err; + MP4ES_ID_IncDescriptorPtr self = (MP4ES_ID_IncDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ + self->size += 4; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - MP4ES_ID_IncDescriptorPtr self = (MP4ES_ID_IncDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - - PUT32( trackID ); + MP4Err err; + MP4ES_ID_IncDescriptorPtr self = (MP4ES_ID_IncDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + + PUT32(trackID); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4ES_ID_IncDescriptorPtr self = (MP4ES_ID_IncDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - GET32( trackID ); + MP4Err err; + MP4ES_ID_IncDescriptorPtr self = (MP4ES_ID_IncDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + GET32(trackID); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; -} - -static void destroy( struct MP4DescriptorRecord* self ) -{ - free( self ); + return err; } -MP4Err MP4CreateES_ID_IncDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +static void destroy(struct MP4DescriptorRecord *self) { free(self); } + +MP4Err MP4CreateES_ID_IncDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4ES_ID_IncDescriptor ) - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4ES_ID_IncDescriptor) + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4ES_ID_RefDescriptor.c b/IsoLib/libisomediafile/src/MP4ES_ID_RefDescriptor.c index ddfcdfd..ccfed2b 100644 --- a/IsoLib/libisomediafile/src/MP4ES_ID_RefDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4ES_ID_RefDescriptor.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,75 +15,70 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: + $Id: */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - MP4ES_ID_RefDescriptorPtr self = (MP4ES_ID_RefDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ - self->size += 2; + MP4Err err; + MP4ES_ID_RefDescriptorPtr self = (MP4ES_ID_RefDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ + self->size += 2; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - MP4ES_ID_RefDescriptorPtr self = (MP4ES_ID_RefDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - - PUT16( refIndex ); + MP4Err err; + MP4ES_ID_RefDescriptorPtr self = (MP4ES_ID_RefDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + + PUT16(refIndex); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4ES_ID_RefDescriptorPtr self = (MP4ES_ID_RefDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - GET16( refIndex ); + MP4Err err; + MP4ES_ID_RefDescriptorPtr self = (MP4ES_ID_RefDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + GET16(refIndex); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; -} - -static void destroy( struct MP4DescriptorRecord* self ) -{ - free( self ); + return err; } -MP4Err MP4CreateES_ID_RefDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +static void destroy(struct MP4DescriptorRecord *self) { free(self); } + +MP4Err MP4CreateES_ID_RefDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4ES_ID_RefDescriptor ) - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4ES_ID_RefDescriptor) + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4FileMappingInputStream.c b/IsoLib/libisomediafile/src/MP4FileMappingInputStream.c index 189fccf..14f6ea9 100644 --- a/IsoLib/libisomediafile/src/MP4FileMappingInputStream.c +++ b/IsoLib/libisomediafile/src/MP4FileMappingInputStream.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,214 +15,221 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4FileMappingInputStream.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4FileMappingInputStream.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4InputStream.h" #include "MP4Impl.h" #include #include -#define CHECK_AVAIL( bytes ) \ - if ( self->available < bytes ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } -static MP4Err readData( struct MP4InputStreamRecord *s, u64 bytes, char *outData, char *msg ); +#define CHECK_AVAIL(bytes) \ + if(self->available < bytes) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } +static MP4Err readData(struct MP4InputStreamRecord *s, u64 bytes, char *outData, char *msg); -static void doIndent( struct MP4InputStreamRecord *self ) +static void doIndent(struct MP4InputStreamRecord *self) { - u32 i; - for ( i = 0; i < self->indent; i++ ) - fprintf( stdout, " " ); + u32 i; + for(i = 0; i < self->indent; i++) + fprintf(stdout, " "); } -static void msg( struct MP4InputStreamRecord *self, char *msg ) +static void msg(struct MP4InputStreamRecord *self, char *msg) { - if ( self->debugging ) - { - doIndent( self ); - fprintf( stdout, "%s\n", msg ); - } + if(self->debugging) + { + doIndent(self); + fprintf(stdout, "%s\n", msg); + } } -static void destroy( struct MP4InputStreamRecord *s ) -{ - free(s); -} +static void destroy(struct MP4InputStreamRecord *s) { free(s); } -static FileMappingObject getFileMappingObject( struct MP4InputStreamRecord *s ) +static FileMappingObject getFileMappingObject(struct MP4InputStreamRecord *s) { - MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr) s; - return self->mapping; + MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr)s; + return self->mapping; } -static MP4Err read8( struct MP4InputStreamRecord *s, u32 *outVal, char *msg ) +static MP4Err read8(struct MP4InputStreamRecord *s, u32 *outVal, char *msg) { - MP4Err err; - u8 val; - MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr) s; - err = MP4NoErr; - - err = readData( s, 1, (char*) &val, NULL ); if (err) goto bail; - *outVal = val; - if ( msg && self->debugging ) - { - doIndent( s ); - fprintf( stdout, "%s = %d\n", msg, val ); - } + MP4Err err; + u8 val; + MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr)s; + err = MP4NoErr; + + err = readData(s, 1, (char *)&val, NULL); + if(err) goto bail; + *outVal = val; + if(msg && self->debugging) + { + doIndent(s); + fprintf(stdout, "%s = %d\n", msg, val); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err read16( struct MP4InputStreamRecord *s, u32 *outVal, char *msg ) +static MP4Err read16(struct MP4InputStreamRecord *s, u32 *outVal, char *msg) { - u8 a; - int val; - MP4Err err; - MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr) s; - err = MP4NoErr; - - CHECK_AVAIL( 2 ) - err = readData( s, 1, (char *) &a, NULL ); if (err) goto bail; - val = a << 8; - err = readData( s, 1, (char *) &a, NULL ); if (err) goto bail; - val |= a; - *outVal = val; - if ( msg && self->debugging ) - { - doIndent( s ); - fprintf( stdout, "%s = %d\n", msg, val ); - } + u8 a; + int val; + MP4Err err; + MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr)s; + err = MP4NoErr; + + CHECK_AVAIL(2) + err = readData(s, 1, (char *)&a, NULL); + if(err) goto bail; + val = a << 8; + err = readData(s, 1, (char *)&a, NULL); + if(err) goto bail; + val |= a; + *outVal = val; + if(msg && self->debugging) + { + doIndent(s); + fprintf(stdout, "%s = %d\n", msg, val); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err read32( struct MP4InputStreamRecord *s, u32 *outVal, char *msg ) +static MP4Err read32(struct MP4InputStreamRecord *s, u32 *outVal, char *msg) { - unsigned int hw; - unsigned int lw; - MP4Err err; - MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr) s; - err = MP4NoErr; - - CHECK_AVAIL( 4 ) - err = read16( s, (u32 *) &hw, NULL ); if (err) goto bail; - err = read16( s, (u32 *) &lw, NULL ); if (err) goto bail; - *outVal = (hw << 16) | lw; - if ( msg && self->debugging ) - { - doIndent( s ); - fprintf( stdout, "%s = %d\n", msg, *outVal ); - } + unsigned int hw; + unsigned int lw; + MP4Err err; + MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr)s; + err = MP4NoErr; + + CHECK_AVAIL(4) + err = read16(s, (u32 *)&hw, NULL); + if(err) goto bail; + err = read16(s, (u32 *)&lw, NULL); + if(err) goto bail; + *outVal = (hw << 16) | lw; + if(msg && self->debugging) + { + doIndent(s); + fprintf(stdout, "%s = %d\n", msg, *outVal); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err skipData( struct MP4InputStreamRecord *s, u64 bytes, char *msg ) +static MP4Err skipData(struct MP4InputStreamRecord *s, u64 bytes, char *msg) { - MP4Err err; - MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr) s; - - err = MP4NoErr; - - CHECK_AVAIL( bytes ) - self->available -= bytes; - self->current_offset += bytes; - - if ( msg && self->debugging ) - { - doIndent( s ); - fprintf( stdout, "%s = [%lld bytes of data skipped]\n", msg, bytes ); - } + MP4Err err; + MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr)s; + + err = MP4NoErr; + + CHECK_AVAIL(bytes) + self->available -= bytes; + self->current_offset += bytes; + + if(msg && self->debugging) + { + doIndent(s); + fprintf(stdout, "%s = [%lld bytes of data skipped]\n", msg, bytes); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err readData( struct MP4InputStreamRecord *s, u64 bytes, char *outData, char *msg ) +static MP4Err readData(struct MP4InputStreamRecord *s, u64 bytes, char *outData, char *msg) { - MP4Err err; - MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr) s; - u32 to_read; - FileMappingObject themap; - - err = MP4NoErr; - themap = self->mapping; - - if (bytes >> 32) { BAILWITHERROR( MP4NotImplementedErr ); } - - to_read = (u32) bytes; - CHECK_AVAIL( to_read ); - - if (( themap->copyData )) { - err = themap->copyData( themap, self->current_offset, outData, to_read ); - } - else - { - memcpy( outData, (self->base) + (self->current_offset), to_read ); - } - - self->available -= to_read; - self->current_offset += to_read; - if ( msg && self->debugging ) - { - doIndent( s ); - fprintf( stdout, "%s = [%d bytes of data]\n", msg, to_read ); - } + MP4Err err; + MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr)s; + u32 to_read; + FileMappingObject themap; + + err = MP4NoErr; + themap = self->mapping; + + if(bytes >> 32) + { + BAILWITHERROR(MP4NotImplementedErr); + } + + to_read = (u32)bytes; + CHECK_AVAIL(to_read); + + if((themap->copyData)) + { + err = themap->copyData(themap, self->current_offset, outData, to_read); + } + else + { + memcpy(outData, (self->base) + (self->current_offset), to_read); + } + + self->available -= to_read; + self->current_offset += to_read; + if(msg && self->debugging) + { + doIndent(s); + fprintf(stdout, "%s = [%d bytes of data]\n", msg, to_read); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static u64 getStreamOffset( struct MP4InputStreamRecord *s ) +static u64 getStreamOffset(struct MP4InputStreamRecord *s) { - MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr) s; - return (self->current_offset); + MP4FileMappingInputStreamPtr self = (MP4FileMappingInputStreamPtr)s; + return (self->current_offset); } -MP4Err MP4CreateFileMappingInputStream( struct FileMappingObjectRecord* mapping, MP4InputStreamPtr *outStream ) +MP4Err MP4CreateFileMappingInputStream(struct FileMappingObjectRecord *mapping, + MP4InputStreamPtr *outStream) { - MP4Err err; - MP4FileMappingInputStreamPtr is; - - err = MP4NoErr; - is = (MP4FileMappingInputStreamPtr) calloc( 1, sizeof(MP4FileMappingInputStream) ); - TESTMALLOC( is ) - is->available = mapping->size64; - is->base = mapping->data; - is->current_offset = 0; - is->destroy = destroy; - is->read8 = read8; - is->read16 = read16; - is->read32 = read32; - is->readData = readData; - is->skipData = skipData; - is->getStreamOffset = getStreamOffset; - is->getFileMappingObject = getFileMappingObject; - is->mapping = mapping; - is->msg = msg; - *outStream = (MP4InputStreamPtr) is; + MP4Err err; + MP4FileMappingInputStreamPtr is; + + err = MP4NoErr; + is = (MP4FileMappingInputStreamPtr)calloc(1, sizeof(MP4FileMappingInputStream)); + TESTMALLOC(is) + is->available = mapping->size64; + is->base = mapping->data; + is->current_offset = 0; + is->destroy = destroy; + is->read8 = read8; + is->read16 = read16; + is->read32 = read32; + is->readData = readData; + is->skipData = skipData; + is->getStreamOffset = getStreamOffset; + is->getFileMappingObject = getFileMappingObject; + is->mapping = mapping; + is->msg = msg; + *outStream = (MP4InputStreamPtr)is; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4Handle.c b/IsoLib/libisomediafile/src/MP4Handle.c index ea1645f..3f7149a 100644 --- a/IsoLib/libisomediafile/src/MP4Handle.c +++ b/IsoLib/libisomediafile/src/MP4Handle.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4Handle.c,v 1.4 2002/10/08 10:11:54 fred Exp $ + $Id: MP4Handle.c,v 1.4 2002/10/08 10:11:54 fred Exp $ */ #include "MP4Movies.h" #include @@ -29,15 +29,15 @@ derivative works. Copyright (c) 1999. typedef struct { - char *data; - char *truedata; - u32 signature; - u32 size; - u32 allocatedSize; - u32 offset; + char *data; + char *truedata; + u32 signature; + u32 size; + u32 allocatedSize; + u32 offset; } handleStruct, *actualHandle; -/* The handle offset makes the handle point to an offset into the datablock. +/* The handle offset makes the handle point to an offset into the datablock. Setting the offset thus 'reserves space' at the front of the block, and reduces its effective size. The handle size is thus set and reported without the offset. @@ -45,199 +45,189 @@ typedef struct #define HANDLE_SIGNATURE 0x1234 -MP4_EXTERN ( MP4Err ) -MP4NewHandle( u32 handleSize, MP4Handle *outHandle ) +MP4_EXTERN(MP4Err) +MP4NewHandle(u32 handleSize, MP4Handle *outHandle) { - MP4Err err; - MP4Handle ret; - actualHandle h; - ret = NULL; - err = MP4NoErr; - if ( outHandle == NULL ) - { - err = MP4BadParamErr; - goto bail; - } - h = (actualHandle) calloc( 1, sizeof(handleStruct) ); - if ( h != NULL ) - { - if ( handleSize ) - h->data = (char*) calloc( 1, handleSize ); - if ( handleSize && h->data == NULL ) - { - free( h ); - err = MP4NoMemoryErr; - goto bail; - } - else - { - h->signature = HANDLE_SIGNATURE; - h->size = handleSize; - h->allocatedSize = handleSize; - h->offset = 0; - h->truedata = h->data; - ret = (MP4Handle) h; - } - } - *outHandle = ret; + MP4Err err; + MP4Handle ret; + actualHandle h; + ret = NULL; + err = MP4NoErr; + if(outHandle == NULL) + { + err = MP4BadParamErr; + goto bail; + } + h = (actualHandle)calloc(1, sizeof(handleStruct)); + if(h != NULL) + { + if(handleSize) h->data = (char *)calloc(1, handleSize); + if(handleSize && h->data == NULL) + { + free(h); + err = MP4NoMemoryErr; + goto bail; + } + else + { + h->signature = HANDLE_SIGNATURE; + h->size = handleSize; + h->allocatedSize = handleSize; + h->offset = 0; + h->truedata = h->data; + ret = (MP4Handle)h; + } + } + *outHandle = ret; bail: - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetHandleSize( MP4Handle theHandle, u32 *outSize ) +MP4_EXTERN(MP4Err) +MP4GetHandleSize(MP4Handle theHandle, u32 *outSize) { - MP4Err err; - actualHandle h = (actualHandle) theHandle; - - err = MP4NoErr; - - if ( (h == NULL) || (h->signature != HANDLE_SIGNATURE) || (outSize == NULL) ) - { - err = MP4BadParamErr; - goto bail; - } - *outSize = h->size; + MP4Err err; + actualHandle h = (actualHandle)theHandle; + + err = MP4NoErr; + + if((h == NULL) || (h->signature != HANDLE_SIGNATURE) || (outSize == NULL)) + { + err = MP4BadParamErr; + goto bail; + } + *outSize = h->size; bail: - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4SetHandleSize( MP4Handle theHandle, u32 requestedSize ) +MP4_EXTERN(MP4Err) +MP4SetHandleSize(MP4Handle theHandle, u32 requestedSize) { - MP4Err err; - actualHandle h = (actualHandle) theHandle; - err = MP4NoErr; - if ( h == NULL || (h->signature != HANDLE_SIGNATURE) ) - err = MP4BadParamErr; - else - { - if ( h->allocatedSize >= requestedSize ) - { - h->size = requestedSize; - } - else - { - char *p = NULL; - - if ( h->data == NULL) - p = (char*) malloc( requestedSize + h->offset ); - else - p = (char*) realloc( h->truedata, requestedSize + h->offset ); - if ( p ) - { - h->truedata = p; - h->data = &( p[ h->offset ]); - h->size = requestedSize; - h->allocatedSize = requestedSize; - } - else - err = MP4NoMemoryErr; - } - } - return err; + MP4Err err; + actualHandle h = (actualHandle)theHandle; + err = MP4NoErr; + if(h == NULL || (h->signature != HANDLE_SIGNATURE)) err = MP4BadParamErr; + else + { + if(h->allocatedSize >= requestedSize) + { + h->size = requestedSize; + } + else + { + char *p = NULL; + + if(h->data == NULL) p = (char *)malloc(requestedSize + h->offset); + else + p = (char *)realloc(h->truedata, requestedSize + h->offset); + if(p) + { + h->truedata = p; + h->data = &(p[h->offset]); + h->size = requestedSize; + h->allocatedSize = requestedSize; + } + else + err = MP4NoMemoryErr; + } + } + return err; } -MP4_EXTERN ( MP4Err ) -MP4SetHandleOffset( MP4Handle theHandle, u32 offset ) +MP4_EXTERN(MP4Err) +MP4SetHandleOffset(MP4Handle theHandle, u32 offset) { - MP4Err err; - actualHandle h = (actualHandle) theHandle; - - - err = MP4NoErr; - if ( h == NULL || (h->signature != HANDLE_SIGNATURE) ) - err = MP4BadParamErr; - else - { - s32 adjust; - char *p; - - adjust = offset - h->offset; - - if (adjust == 0) - return MP4NoErr; - else if ((offset > (h->size + h->offset)) && (h->size != 0)) - return MP4BadParamErr; - - if ((h->size == 0) && (adjust > 0)) { - err = MP4SetHandleSize( theHandle, adjust ); - if (err) return err; - } - - h->offset = offset; - h->size -= adjust; - h->allocatedSize -= adjust; - p = h->truedata; - h->data = &( p[ offset ] ); - } - return err; + MP4Err err; + actualHandle h = (actualHandle)theHandle; + + err = MP4NoErr; + if(h == NULL || (h->signature != HANDLE_SIGNATURE)) err = MP4BadParamErr; + else + { + s32 adjust; + char *p; + + adjust = offset - h->offset; + + if(adjust == 0) return MP4NoErr; + else if((offset > (h->size + h->offset)) && (h->size != 0)) + return MP4BadParamErr; + + if((h->size == 0) && (adjust > 0)) + { + err = MP4SetHandleSize(theHandle, adjust); + if(err) return err; + } + + h->offset = offset; + h->size -= adjust; + h->allocatedSize -= adjust; + p = h->truedata; + h->data = &(p[offset]); + } + return err; } -MP4_EXTERN ( MP4Err ) -MP4DisposeHandle( MP4Handle theHandle ) +MP4_EXTERN(MP4Err) +MP4DisposeHandle(MP4Handle theHandle) { - MP4Err err; - actualHandle h = (actualHandle) theHandle; - err = MP4NoErr; - if ( h == NULL || (h->signature != HANDLE_SIGNATURE) ) - err = MP4BadParamErr; - else - { - if ( h->data ) - free( h->truedata ); - free( h ); - } - return err; + MP4Err err; + actualHandle h = (actualHandle)theHandle; + err = MP4NoErr; + if(h == NULL || (h->signature != HANDLE_SIGNATURE)) err = MP4BadParamErr; + else + { + if(h->data) free(h->truedata); + free(h); + } + return err; } -MP4_EXTERN ( MP4Err ) -MP4HandleCat(MP4Handle theDstHandle, MP4Handle theSrcHandle) +MP4_EXTERN(MP4Err) +MP4HandleCat(MP4Handle theDstHandle, MP4Handle theSrcHandle) { - MP4Err err; - u32 requestedSize, offset; - actualHandle dsth = (actualHandle) theDstHandle; - actualHandle srch = (actualHandle) theSrcHandle; - err = MP4NoErr; - - if ( ( dsth == NULL || (dsth->signature != HANDLE_SIGNATURE) ) || - ( srch == NULL || (srch->signature != HANDLE_SIGNATURE) ) ) - { - err = MP4BadParamErr; - goto bail; - } - - requestedSize = dsth->size + srch->size; - offset = dsth->size; - - if ( dsth->allocatedSize >= requestedSize ) - { - dsth->size = requestedSize; - } - else - { - char *p = NULL; - - if ( dsth->data == NULL) - p = (char*) malloc( srch->size + dsth->offset ); - else - p = (char*) realloc( dsth->truedata, requestedSize + dsth->offset ); - /* that used to be srch->size, not requestedsize; surely wrong? dws */ - - if ( p ) - { - dsth->data = &( p[ dsth->offset ] ); - dsth->truedata = p; - dsth->size = requestedSize; - dsth->allocatedSize = requestedSize; - } - else - err = MP4NoMemoryErr; - } - memcpy(dsth->data + offset, srch->data, srch->size); - -bail : - return err; -} - + MP4Err err; + u32 requestedSize, offset; + actualHandle dsth = (actualHandle)theDstHandle; + actualHandle srch = (actualHandle)theSrcHandle; + err = MP4NoErr; + + if((dsth == NULL || (dsth->signature != HANDLE_SIGNATURE)) || + (srch == NULL || (srch->signature != HANDLE_SIGNATURE))) + { + err = MP4BadParamErr; + goto bail; + } + + requestedSize = dsth->size + srch->size; + offset = dsth->size; + + if(dsth->allocatedSize >= requestedSize) + { + dsth->size = requestedSize; + } + else + { + char *p = NULL; + + if(dsth->data == NULL) p = (char *)malloc(srch->size + dsth->offset); + else + p = (char *)realloc(dsth->truedata, requestedSize + dsth->offset); + /* that used to be srch->size, not requestedsize; surely wrong? dws */ + + if(p) + { + dsth->data = &(p[dsth->offset]); + dsth->truedata = p; + dsth->size = requestedSize; + dsth->allocatedSize = requestedSize; + } + else + err = MP4NoMemoryErr; + } + memcpy(dsth->data + offset, srch->data, srch->size); +bail: + return err; +} diff --git a/IsoLib/libisomediafile/src/MP4IPMPDescriptorPointer.c b/IsoLib/libisomediafile/src/MP4IPMPDescriptorPointer.c index 8c4d3be..0a081e1 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPDescriptorPointer.c +++ b/IsoLib/libisomediafile/src/MP4IPMPDescriptorPointer.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -24,88 +24,82 @@ derivative works. Copyright (c) 1999. #include "MP4Movies.h" #include -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - MP4IPMPDescriptorPointerPtr self = (MP4IPMPDescriptorPointerPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - self->size = DESCRIPTOR_TAG_LEN_SIZE; - self->size += 1; /* IPMPDescriptorId */ - if ( self->ipmpDescriptorId == 0xFF ) - { - self->size += 4; /* IPMPToolDescriptorId + IPMPEsId */ - } + MP4Err err; + MP4IPMPDescriptorPointerPtr self = (MP4IPMPDescriptorPointerPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + self->size = DESCRIPTOR_TAG_LEN_SIZE; + self->size += 1; /* IPMPDescriptorId */ + if(self->ipmpDescriptorId == 0xFF) + { + self->size += 4; /* IPMPToolDescriptorId + IPMPEsId */ + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - MP4IPMPDescriptorPointerPtr self = (MP4IPMPDescriptorPointerPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - PUT8(ipmpDescriptorId); - if ( self->ipmpDescriptorId == 0xFF ) - { - PUT16(ipmpToolDescriptorId); - PUT16(ipmpEsId); - } - if ( self->bytesWritten != self->size ) - BAILWITHERROR( MP4BadDataErr ); + MP4Err err; + MP4IPMPDescriptorPointerPtr self = (MP4IPMPDescriptorPointerPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + PUT8(ipmpDescriptorId); + if(self->ipmpDescriptorId == 0xFF) + { + PUT16(ipmpToolDescriptorId); + PUT16(ipmpEsId); + } + if(self->bytesWritten != self->size) BAILWITHERROR(MP4BadDataErr); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4IPMPDescriptorPointerPtr self = (MP4IPMPDescriptorPointerPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - GET8(ipmpDescriptorId); - if ( self->ipmpDescriptorId == 0xFF ) - { - GET16(ipmpToolDescriptorId); - GET16(ipmpEsId); - } - if ( self->bytesRead != self->size ) - BAILWITHERROR( MP4BadDataErr ); + MP4Err err; + MP4IPMPDescriptorPointerPtr self = (MP4IPMPDescriptorPointerPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + GET8(ipmpDescriptorId); + if(self->ipmpDescriptorId == 0xFF) + { + GET16(ipmpToolDescriptorId); + GET16(ipmpEsId); + } + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static void destroy( struct MP4DescriptorRecord* s ) +static void destroy(struct MP4DescriptorRecord *s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - free( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + free(s); bail: - return; + return; } -MP4Err MP4CreateIPMPDescriptorPointer( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateIPMPDescriptorPointer(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4IPMPDescriptorPointer ); - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4IPMPDescriptorPointer); + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - diff --git a/IsoLib/libisomediafile/src/MP4IPMPInitialize.c b/IsoLib/libisomediafile/src/MP4IPMPInitialize.c index bb11952..b75ac97 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPInitialize.c +++ b/IsoLib/libisomediafile/src/MP4IPMPInitialize.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. @@ -24,140 +24,138 @@ derivative works. Copyright (c) 1999, 2000. #include "MP4IPMPXData.h" #include "MP4Movies.h" -static MP4Err addIPMPXData( MP4IPMPInitializePtr self, MP4IPMPXDataPtr data ) +static MP4Err addIPMPXData(MP4IPMPInitializePtr self, MP4IPMPXDataPtr data) { - MP4Err err; + MP4Err err; - err = MP4NoErr; - err = MP4AddListEntry( data, self->ipmpxData ); if (err) goto bail; + err = MP4NoErr; + err = MP4AddListEntry(data, self->ipmpxData); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( MP4IPMPInitializePtr self ) +static MP4Err calculateSize(MP4IPMPInitializePtr self) { - MP4Err err; - u32 i; - u32 ipmpxDataCount; - err = MP4NoErr; - - self->size = 3; /* controlPointCode + sequence code + numData */ - - /* calculate the size of the IPMPXData */ - err = MP4GetListEntryCount( self->ipmpxData, &ipmpxDataCount ); if (err) goto bail; - for ( i = 0; i < ipmpxDataCount; i++ ) - { - MP4IPMPXDataPtr entry; - err = MP4GetListEntry( self->ipmpxData, - i, - (char **) &entry ); if (err) goto bail; - entry->calculateSize( entry ); - self->size += entry->size; - } + MP4Err err; + u32 i; + u32 ipmpxDataCount; + err = MP4NoErr; + + self->size = 3; /* controlPointCode + sequence code + numData */ + + /* calculate the size of the IPMPXData */ + err = MP4GetListEntryCount(self->ipmpxData, &ipmpxDataCount); + if(err) goto bail; + for(i = 0; i < ipmpxDataCount; i++) + { + MP4IPMPXDataPtr entry; + err = MP4GetListEntry(self->ipmpxData, i, (char **)&entry); + if(err) goto bail; + entry->calculateSize(entry); + self->size += entry->size; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( MP4IPMPInitializePtr self, char* buffer ) +static MP4Err serialize(MP4IPMPInitializePtr self, char *buffer) { - MP4Err err; - u32 ipmpxDataCount; - u32 i; - - err = MP4NoErr; - PUT8(controlPointCode); - PUT8(sequenceCode); - err = MP4GetListEntryCount( self->ipmpxData, &ipmpxDataCount ); if (err) goto bail; - PUT8_V(ipmpxDataCount); - for ( i = 0; i < ipmpxDataCount; i++ ) - { - MP4IPMPXDataPtr entry; - err = MP4GetListEntry( self->ipmpxData, - i, - (char **) &entry ); if (err) goto bail; - entry->serialize( entry, buffer ); - self->bytesWritten += entry->bytesWritten; - buffer += entry->bytesWritten; - } + MP4Err err; + u32 ipmpxDataCount; + u32 i; + + err = MP4NoErr; + PUT8(controlPointCode); + PUT8(sequenceCode); + err = MP4GetListEntryCount(self->ipmpxData, &ipmpxDataCount); + if(err) goto bail; + PUT8_V(ipmpxDataCount); + for(i = 0; i < ipmpxDataCount; i++) + { + MP4IPMPXDataPtr entry; + err = MP4GetListEntry(self->ipmpxData, i, (char **)&entry); + if(err) goto bail; + entry->serialize(entry, buffer); + self->bytesWritten += entry->bytesWritten; + buffer += entry->bytesWritten; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4IPMPInitializePtr self, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4IPMPInitializePtr self, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 ipmpxDataCount; - u32 i; - - err = MP4NoErr; - GET8(controlPointCode); - GET8(sequenceCode); - GET8_V(ipmpxDataCount); - for ( i = 0; i < ipmpxDataCount; i++ ) - { - MP4IPMPXDataPtr data; - err = MP4ParseIPMPXData( inputStream, &data ); if (err) goto bail; - self->bytesRead += data->size; - err = addIPMPXData( self, data ); if (err) goto bail; - } - + MP4Err err; + u32 ipmpxDataCount; + u32 i; + + err = MP4NoErr; + GET8(controlPointCode); + GET8(sequenceCode); + GET8_V(ipmpxDataCount); + for(i = 0; i < ipmpxDataCount; i++) + { + MP4IPMPXDataPtr data; + err = MP4ParseIPMPXData(inputStream, &data); + if(err) goto bail; + self->bytesRead += data->size; + err = addIPMPXData(self, data); + if(err) goto bail; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static void destroy( MP4IPMPInitializePtr self ) +static void destroy(MP4IPMPInitializePtr self) { - MP4Err err; - u32 i; - u32 ipmpxDataCount; - - err = MP4NoErr; - err = MP4GetListEntryCount( self->ipmpxData, &ipmpxDataCount ); if (err) goto bail; - for ( i = 0; i < ipmpxDataCount; i++ ) - { - MP4IPMPXDataPtr data; - err = MP4GetListEntry( self->ipmpxData, - i, - (char **) &data ); if (err) goto bail; - if ( data ) - data->destroy( data ); - } - free( self ); + MP4Err err; + u32 i; + u32 ipmpxDataCount; + + err = MP4NoErr; + err = MP4GetListEntryCount(self->ipmpxData, &ipmpxDataCount); + if(err) goto bail; + for(i = 0; i < ipmpxDataCount; i++) + { + MP4IPMPXDataPtr data; + err = MP4GetListEntry(self->ipmpxData, i, (char **)&data); + if(err) goto bail; + if(data) data->destroy(data); + } + free(self); bail: - return; + return; } -MP4Err MP4CreateIPMPInitialize( MP4IPMPInitializePtr *outIpmpInit ) +MP4Err MP4CreateIPMPInitialize(MP4IPMPInitializePtr *outIpmpInit) { - MP4Err err; - MP4IPMPInitializePtr self; - err = MP4NoErr; - self = (MP4IPMPInitializePtr) calloc( 1, sizeof(MP4IPMPInitialize) ); - TESTMALLOC(self); - self->name = "MP4IPMPInitialize"; - err = MP4MakeLinkedList( &self->ipmpxData ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->createFromInputStream = createFromInputStream; - self->destroy = destroy; - self->addIPMPXData = addIPMPXData; - *outIpmpInit = self; + MP4Err err; + MP4IPMPInitializePtr self; + err = MP4NoErr; + self = (MP4IPMPInitializePtr)calloc(1, sizeof(MP4IPMPInitialize)); + TESTMALLOC(self); + self->name = "MP4IPMPInitialize"; + err = MP4MakeLinkedList(&self->ipmpxData); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->createFromInputStream = createFromInputStream; + self->destroy = destroy; + self->addIPMPXData = addIPMPXData; + *outIpmpInit = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - - - - diff --git a/IsoLib/libisomediafile/src/MP4IPMPTool.c b/IsoLib/libisomediafile/src/MP4IPMPTool.c index 6199cb4..153de17 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPTool.c +++ b/IsoLib/libisomediafile/src/MP4IPMPTool.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -25,255 +25,246 @@ derivative works. Copyright (c) 1999. #include #include -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - u32 numAlternates; - u32 numUrls; - u32 i; - MP4IPMPToolPtr self = (MP4IPMPToolPtr) s; - - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ - self->size += 17; /* IPMPToolId + Flags */ - err = MP4GetListEntryCount( self->alternateToolIds, - &numAlternates ); if (err) goto bail; - if ( numAlternates != 0 ) - { - self->size += 1; /* numAlternates */ - self->size += 16 * numAlternates; /* alternateToolIds */ - } + MP4Err err; + u32 numAlternates; + u32 numUrls; + u32 i; + MP4IPMPToolPtr self = (MP4IPMPToolPtr)s; - if ( self->toolParamDesc != NULL) - { - self->size += 4; /* size of the size */ - self->size += self->toolParamDesc->size; /* size of the data */ - } + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ + self->size += 17; /* IPMPToolId + Flags */ + err = MP4GetListEntryCount(self->alternateToolIds, &numAlternates); + if(err) goto bail; + if(numAlternates != 0) + { + self->size += 1; /* numAlternates */ + self->size += 16 * numAlternates; /* alternateToolIds */ + } + + if(self->toolParamDesc != NULL) + { + self->size += 4; /* size of the size */ + self->size += self->toolParamDesc->size; /* size of the data */ + } + + err = MP4GetListEntryCount(self->toolUrls, &numUrls); + if(err) goto bail; + self->size += 1; /* numUrls */ + for(i = 0; i < numUrls; i++) + { + MP4IPMPByteArrayPtr entry; + + err = MP4GetListEntry(self->toolUrls, i, (char **)&entry); + if(err) goto bail; + self->size += entry->size + 4; /* data + dataSize */ + } - err = MP4GetListEntryCount( self->toolUrls, - &numUrls ); if (err) goto bail; - self->size += 1; /* numUrls */ - for ( i = 0; i < numUrls; i++ ) - { - MP4IPMPByteArrayPtr entry; - - err = MP4GetListEntry( self->toolUrls, - i, - (char **) &entry ); if (err) goto bail; - self->size += entry->size + 4; /* data + dataSize */ - } - bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - u32 numUrls; - u32 numAlternates; - u8 flags; - u32 i; + MP4Err err; + u32 numUrls; + u32 numAlternates; + u8 flags; + u32 i; - MP4IPMPToolPtr self = (MP4IPMPToolPtr) s; + MP4IPMPToolPtr self = (MP4IPMPToolPtr)s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; - PUT64_V(self->toolId->upperPart); - PUT64_V(self->toolId->lowerPart); + PUT64_V(self->toolId->upperPart); + PUT64_V(self->toolId->lowerPart); - err = MP4GetListEntryCount( self->alternateToolIds, - &numAlternates ); if (err) goto bail; - flags = ((numAlternates > 0)?1:0) * 0x80 - + ((self->toolParamDesc != NULL)?1:0) * 0x40; - PUT8_V(flags); + err = MP4GetListEntryCount(self->alternateToolIds, &numAlternates); + if(err) goto bail; + flags = ((numAlternates > 0) ? 1 : 0) * 0x80 + ((self->toolParamDesc != NULL) ? 1 : 0) * 0x40; + PUT8_V(flags); - if ( numAlternates > 0 ) + if(numAlternates > 0) + { + PUT8_V(numAlternates); + for(i = 0; i < numAlternates; i++) { - PUT8_V(numAlternates); - for ( i = 0; i < numAlternates; i++ ) - { - MP4IPMPToolIdPtr entry; - err = MP4GetListEntry( self->alternateToolIds, - i, - (char **) &entry ); if (err) goto bail; - PUT64_V(entry->upperPart); - PUT64_V(entry->lowerPart); - } + MP4IPMPToolIdPtr entry; + err = MP4GetListEntry(self->alternateToolIds, i, (char **)&entry); + if(err) goto bail; + PUT64_V(entry->upperPart); + PUT64_V(entry->lowerPart); } + } - if ( self->toolParamDesc != NULL ) - { - PUT32_V(self->toolParamDesc->size); - PUTBYTES(self->toolParamDesc->data, self->toolParamDesc->size); - } + if(self->toolParamDesc != NULL) + { + PUT32_V(self->toolParamDesc->size); + PUTBYTES(self->toolParamDesc->data, self->toolParamDesc->size); + } - err = MP4GetListEntryCount( self->toolUrls, - &numUrls ); if (err) goto bail; - - PUT8_V(numUrls); - for ( i = 0; i < numUrls; i++ ) - { - MP4IPMPByteArrayPtr entry; - err = MP4GetListEntry( self->toolUrls, - i, - (char **) &entry ); if (err) goto bail; - PUT32_V(entry->size); - PUTBYTES(entry->data, entry->size); - } - - if ( self->bytesWritten != self->size ) - BAILWITHERROR( MP4BadDataErr ); + err = MP4GetListEntryCount(self->toolUrls, &numUrls); + if(err) goto bail; + + PUT8_V(numUrls); + for(i = 0; i < numUrls; i++) + { + MP4IPMPByteArrayPtr entry; + err = MP4GetListEntry(self->toolUrls, i, (char **)&entry); + if(err) goto bail; + PUT32_V(entry->size); + PUTBYTES(entry->data, entry->size); + } + + if(self->bytesWritten != self->size) BAILWITHERROR(MP4BadDataErr); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - u8 flags; - u32 i; - u32 numUrls; - - MP4IPMPToolPtr self = (MP4IPMPToolPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - GET64_V(self->toolId->upperPart); - GET64_V(self->toolId->lowerPart); - GET8_V(flags); - - if (flags & 0x80) /* isAltGroup */ - { - u32 numAlternates; - GET8_V(numAlternates); - - for ( i = 0; i < numAlternates; i++ ) - { - MP4IPMPToolIdPtr id; - - id = (MP4IPMPToolIdPtr) calloc( 1, sizeof(MP4IPMPToolId) ); - TESTMALLOC(id); - GET64_V(id->upperPart); - GET64_V(id->lowerPart); - err = MP4AddListEntry( id, - self->alternateToolIds ); if (err) goto bail; - } - } + MP4Err err; + u8 flags; + u32 i; + u32 numUrls; - if ( flags & 0x40 ) /* isParametric */ - { - self->toolParamDesc = (MP4IPMPByteArrayPtr) calloc( 1, sizeof(MP4IPMPByteArray)); - TESTMALLOC( self->toolParamDesc ); + MP4IPMPToolPtr self = (MP4IPMPToolPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + GET64_V(self->toolId->upperPart); + GET64_V(self->toolId->lowerPart); + GET8_V(flags); - GET32(toolParamDesc->size); - self->toolParamDesc->data = (char *)calloc( 1, self->toolParamDesc->size ); - TESTMALLOC(self->toolParamDesc->data); - GETBYTES(self->toolParamDesc->size, toolParamDesc->data); - } + if(flags & 0x80) /* isAltGroup */ + { + u32 numAlternates; + GET8_V(numAlternates); - GET8_V(numUrls); - for ( i = 0; i < numUrls; i++ ) + for(i = 0; i < numAlternates; i++) { - MP4IPMPByteArrayPtr entry; - entry = (MP4IPMPByteArrayPtr) calloc( 1, sizeof(MP4IPMPByteArray)); - TESTMALLOC(entry); - GET32_V(entry->size); - entry->data = (char *) calloc( 1, entry->size ); - TESTMALLOC(entry->data); - GETBYTES_V(entry->size, entry->data); - err = MP4AddListEntry( entry, self->toolUrls ); if (err) goto bail; + MP4IPMPToolIdPtr id; + + id = (MP4IPMPToolIdPtr)calloc(1, sizeof(MP4IPMPToolId)); + TESTMALLOC(id); + GET64_V(id->upperPart); + GET64_V(id->lowerPart); + err = MP4AddListEntry(id, self->alternateToolIds); + if(err) goto bail; } - - if ( self->bytesRead != self->size ) - BAILWITHERROR( MP4BadDataErr ); + } + + if(flags & 0x40) /* isParametric */ + { + self->toolParamDesc = (MP4IPMPByteArrayPtr)calloc(1, sizeof(MP4IPMPByteArray)); + TESTMALLOC(self->toolParamDesc); + + GET32(toolParamDesc->size); + self->toolParamDesc->data = (char *)calloc(1, self->toolParamDesc->size); + TESTMALLOC(self->toolParamDesc->data); + GETBYTES(self->toolParamDesc->size, toolParamDesc->data); + } + + GET8_V(numUrls); + for(i = 0; i < numUrls; i++) + { + MP4IPMPByteArrayPtr entry; + entry = (MP4IPMPByteArrayPtr)calloc(1, sizeof(MP4IPMPByteArray)); + TESTMALLOC(entry); + GET32_V(entry->size); + entry->data = (char *)calloc(1, entry->size); + TESTMALLOC(entry->data); + GETBYTES_V(entry->size, entry->data); + err = MP4AddListEntry(entry, self->toolUrls); + if(err) goto bail; + } + + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static void destroy( struct MP4DescriptorRecord* s ) + +static void destroy(struct MP4DescriptorRecord *s) { - MP4Err err; - u32 numUrls; - u32 numAlternates; - u32 i; - - MP4IPMPToolPtr self = (MP4IPMPToolPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - if ( self->toolId ) - free( self->toolId ); - - err = MP4GetListEntryCount( self->alternateToolIds, - &numAlternates ); if (err) goto bail; - for ( i = 0; i < numAlternates; i++ ) - { - MP4IPMPToolIdPtr entry; - err = MP4GetListEntry( self->alternateToolIds, - i, - (char **) &entry ); if (err) goto bail; - if ( entry ) - free( entry ); - } - err = MP4DeleteLinkedList( self->alternateToolIds ); if (err) goto bail; + MP4Err err; + u32 numUrls; + u32 numAlternates; + u32 i; - if ( self->toolParamDesc ) - { - if ( self->toolParamDesc->data ) - free( self->toolParamDesc->data ); - free ( self->toolParamDesc ); - } + MP4IPMPToolPtr self = (MP4IPMPToolPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + if(self->toolId) free(self->toolId); + + err = MP4GetListEntryCount(self->alternateToolIds, &numAlternates); + if(err) goto bail; + for(i = 0; i < numAlternates; i++) + { + MP4IPMPToolIdPtr entry; + err = MP4GetListEntry(self->alternateToolIds, i, (char **)&entry); + if(err) goto bail; + if(entry) free(entry); + } + err = MP4DeleteLinkedList(self->alternateToolIds); + if(err) goto bail; + + if(self->toolParamDesc) + { + if(self->toolParamDesc->data) free(self->toolParamDesc->data); + free(self->toolParamDesc); + } - err = MP4GetListEntryCount( self->toolUrls, &numUrls ); if (err) goto bail; - for ( i = 0; i < numUrls; i++ ) + err = MP4GetListEntryCount(self->toolUrls, &numUrls); + if(err) goto bail; + for(i = 0; i < numUrls; i++) + { + MP4IPMPByteArrayPtr entry; + err = MP4GetListEntry(self->toolUrls, i, (char **)&entry); + if(err) goto bail; + if(entry) { - MP4IPMPByteArrayPtr entry; - err = MP4GetListEntry( self->toolUrls, - i, - (char **) &entry ); if (err) goto bail; - if ( entry ) - { - if ( entry->data ) - free( entry->data ); - free( entry ); - } + if(entry->data) free(entry->data); + free(entry); } - err = MP4DeleteLinkedList( self->toolUrls ); if (err) goto bail; - - free( s ); + } + err = MP4DeleteLinkedList(self->toolUrls); + if(err) goto bail; + + free(s); bail: - return; + return; } -MP4Err MP4CreateIPMPTool( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateIPMPTool(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4IPMPTool ) - - self->toolId = (MP4IPMPToolIdPtr) calloc( 1, sizeof(MP4IPMPToolId) ); - TESTMALLOC(self->toolId); - - err = MP4MakeLinkedList( &self->alternateToolIds ); if (err) goto bail; - err = MP4MakeLinkedList( &self->toolUrls ); if (err) goto bail; - - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4IPMPTool) + + self->toolId = (MP4IPMPToolIdPtr)calloc(1, sizeof(MP4IPMPToolId)); + TESTMALLOC(self->toolId); + + err = MP4MakeLinkedList(&self->alternateToolIds); + if(err) goto bail; + err = MP4MakeLinkedList(&self->toolUrls); + if(err) goto bail; + + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4IPMPToolDescriptor.c b/IsoLib/libisomediafile/src/MP4IPMPToolDescriptor.c index 761038b..26f6d85 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPToolDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4IPMPToolDescriptor.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -25,217 +25,211 @@ derivative works. Copyright (c) 1999. #include #include -static MP4Err addIPMPXData( struct MP4DescriptorRecord* s, MP4IPMPXDataPtr data ) +static MP4Err addIPMPXData(struct MP4DescriptorRecord *s, MP4IPMPXDataPtr data) { - MP4Err err; - MP4IPMPToolDescriptorPtr self = (MP4IPMPToolDescriptorPtr) s; - err = MP4NoErr; - err = MP4AddListEntry( data, self->ipmpxData ); if (err) goto bail; + MP4Err err; + MP4IPMPToolDescriptorPtr self = (MP4IPMPToolDescriptorPtr)s; + err = MP4NoErr; + err = MP4AddListEntry(data, self->ipmpxData); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - u32 i; - u32 ipmpxDataCount; - MP4IPMPToolDescriptorPtr self = (MP4IPMPToolDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ - self->size += 18; /* ipmpToolDescId + ipmpToolId */ - if ( self->ipmpToolId->upperPart == 0 - && self->ipmpToolId->lowerPart == 0 ) + MP4Err err; + u32 i; + u32 ipmpxDataCount; + MP4IPMPToolDescriptorPtr self = (MP4IPMPToolDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ + self->size += 18; /* ipmpToolDescId + ipmpToolId */ + if(self->ipmpToolId->upperPart == 0 && self->ipmpToolId->lowerPart == 0) + { + self->size += 4; /* size of ByteArray */ + self->size += self->url->size; + } + else + { + self->size += 1; /* initialize tag */ + if(self->initData != NULL) { - self->size += 4; /* size of ByteArray */ - self->size += self->url->size; + self->initData->calculateSize(self->initData); + self->size += self->initData->size; } - else + self->size += 1; /* ipmpxDataCount */ + err = MP4GetListEntryCount(self->ipmpxData, &ipmpxDataCount); + if(err) goto bail; + for(i = 0; i < ipmpxDataCount; i++) { - self->size += 1; /* initialize tag */ - if ( self->initData != NULL ) - { - self->initData->calculateSize( self->initData ); - self->size += self->initData->size; - } - self->size += 1; /* ipmpxDataCount */ - err = MP4GetListEntryCount( self->ipmpxData, &ipmpxDataCount ); if (err) goto bail; - for ( i = 0; i < ipmpxDataCount; i++ ) - { - MP4IPMPXDataPtr entry; - err = MP4GetListEntry( self->ipmpxData, - i, - (char **) &entry ); if (err) goto bail; - entry->calculateSize( entry ); - self->size += entry->size; - } + MP4IPMPXDataPtr entry; + err = MP4GetListEntry(self->ipmpxData, i, (char **)&entry); + if(err) goto bail; + entry->calculateSize(entry); + self->size += entry->size; } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - u32 ipmpxDataCount; - u32 i; - MP4IPMPToolDescriptorPtr self = (MP4IPMPToolDescriptorPtr) s; - - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - PUT16(ipmpToolDescriptorId); - PUT64(ipmpToolId->upperPart); - PUT64(ipmpToolId->lowerPart); - if ( self->ipmpToolId->upperPart == 0 - && self->ipmpToolId->lowerPart == 0 ) + MP4Err err; + u32 ipmpxDataCount; + u32 i; + MP4IPMPToolDescriptorPtr self = (MP4IPMPToolDescriptorPtr)s; + + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + PUT16(ipmpToolDescriptorId); + PUT64(ipmpToolId->upperPart); + PUT64(ipmpToolId->lowerPart); + if(self->ipmpToolId->upperPart == 0 && self->ipmpToolId->lowerPart == 0) + { + if(self->url == NULL) BAILWITHERROR(MP4BadDataErr); + PUT32_V(self->url->size); + PUTBYTES(self->url->data, self->url->size); + } + else + { + PUT8_V((self->initData != NULL) ? 0x80 : 0X00); /* isInitialize flag */ + if(self->initData != NULL) { - if ( self->url == NULL ) - BAILWITHERROR( MP4BadDataErr ); - PUT32_V(self->url->size); - PUTBYTES(self->url->data, self->url->size); + err = self->initData->serialize(self->initData, buffer); + if(err) goto bail; + buffer += self->initData->bytesWritten; + self->bytesWritten += self->initData->bytesWritten; } - else + err = MP4GetListEntryCount(self->ipmpxData, &ipmpxDataCount); + if(err) goto bail; + PUT8_V(ipmpxDataCount); + for(i = 0; i < ipmpxDataCount; i++) { - PUT8_V((self->initData != NULL)?0x80:0X00); /* isInitialize flag */ - if ( self->initData != NULL ) - { - err = self->initData->serialize( self->initData, buffer ); if (err) goto bail; - buffer += self->initData->bytesWritten; - self->bytesWritten += self->initData->bytesWritten; - } - err = MP4GetListEntryCount( self->ipmpxData, &ipmpxDataCount ); if (err) goto bail; - PUT8_V(ipmpxDataCount); - for ( i = 0; i < ipmpxDataCount; i++ ) - { - MP4IPMPXDataPtr entry; - err = MP4GetListEntry( self->ipmpxData, - i, - (char **) &entry ); if (err) goto bail; - entry->serialize( entry, buffer ); - self->bytesWritten += entry->bytesWritten; - buffer += entry->bytesWritten; - } + MP4IPMPXDataPtr entry; + err = MP4GetListEntry(self->ipmpxData, i, (char **)&entry); + if(err) goto bail; + entry->serialize(entry, buffer); + self->bytesWritten += entry->bytesWritten; + buffer += entry->bytesWritten; } - if ( self->bytesWritten != self->size ) - BAILWITHERROR( MP4BadDataErr ); + } + if(self->bytesWritten != self->size) BAILWITHERROR(MP4BadDataErr); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i; - u32 ipmpxDataCount; - u8 initFlag; - MP4IPMPToolDescriptorPtr self = (MP4IPMPToolDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - GET16(ipmpToolDescriptorId); - GET64(ipmpToolId->upperPart); - GET64(ipmpToolId->lowerPart); - if ( self->ipmpToolId->upperPart == 0 - && self->ipmpToolId->lowerPart == 0 ) + MP4Err err; + u32 i; + u32 ipmpxDataCount; + u8 initFlag; + MP4IPMPToolDescriptorPtr self = (MP4IPMPToolDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + GET16(ipmpToolDescriptorId); + GET64(ipmpToolId->upperPart); + GET64(ipmpToolId->lowerPart); + if(self->ipmpToolId->upperPart == 0 && self->ipmpToolId->lowerPart == 0) + { + self->url = (MP4IPMPByteArrayPtr)calloc(1, sizeof(MP4IPMPByteArray)); + TESTMALLOC(self->url); + GET32(url->size); + self->url->data = (char *)calloc(1, self->url->size); + TESTMALLOC(self->url->data); + GETBYTES(self->url->size, url->data); + } + else + { + GET8_V(initFlag); + if(initFlag & 0x80) { - self->url = (MP4IPMPByteArrayPtr) calloc( 1, sizeof(MP4IPMPByteArray) ); - TESTMALLOC( self->url ); - GET32(url->size); - self->url->data = (char *) calloc ( 1, self->url->size ); - TESTMALLOC( self->url->data ); - GETBYTES(self->url->size, url->data); + err = MP4CreateIPMPInitialize(&self->initData); + if(err) goto bail; + err = self->initData->createFromInputStream(self->initData, inputStream); + if(err) goto bail; + self->bytesRead += self->initData->bytesRead; } - else + GET8_V(ipmpxDataCount); + for(i = 0; i < ipmpxDataCount; i++) { - GET8_V(initFlag); - if ( initFlag & 0x80 ) - { - err = MP4CreateIPMPInitialize( &self->initData ); if (err) goto bail; - err = self->initData->createFromInputStream( self->initData, - inputStream ); if (err) goto bail; - self->bytesRead += self->initData->bytesRead; - } - GET8_V(ipmpxDataCount); - for ( i = 0; i < ipmpxDataCount; i++ ) - { - MP4IPMPXDataPtr data; - err = MP4ParseIPMPXData( inputStream, &data ); if (err) goto bail; - self->bytesRead += data->size; - err = addIPMPXData( s, data ); if (err) goto bail; - } + MP4IPMPXDataPtr data; + err = MP4ParseIPMPXData(inputStream, &data); + if(err) goto bail; + self->bytesRead += data->size; + err = addIPMPXData(s, data); + if(err) goto bail; } + } - if ( self->bytesRead != self->size ) - BAILWITHERROR( MP4BadDataErr ); + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static void destroy( struct MP4DescriptorRecord* s ) +static void destroy(struct MP4DescriptorRecord *s) { - MP4Err err; - u32 i; - u32 ipmpxDataCount; - MP4IPMPToolDescriptorPtr self = (MP4IPMPToolDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - if ( self->ipmpToolId ) - free( self->ipmpToolId ); - if ( self->url ) - { - if ( self->url->data ) - free( self->url->data ); - free( self->url ); - } - if ( self->initData ) - { - self->initData->destroy( self->initData ); - free( self->initData ); - } - err = MP4GetListEntryCount( self->ipmpxData, &ipmpxDataCount ); if (err) goto bail; - for ( i = 0; i < ipmpxDataCount; i++ ) - { - MP4IPMPXDataPtr entry; - err = MP4GetListEntry( self->ipmpxData, - i, - (char **) &entry ); if (err) goto bail; - if ( entry ) - entry->destroy( entry ); - } - err = MP4DeleteLinkedList( self->ipmpxData ); - free( s ); + MP4Err err; + u32 i; + u32 ipmpxDataCount; + MP4IPMPToolDescriptorPtr self = (MP4IPMPToolDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + if(self->ipmpToolId) free(self->ipmpToolId); + if(self->url) + { + if(self->url->data) free(self->url->data); + free(self->url); + } + if(self->initData) + { + self->initData->destroy(self->initData); + free(self->initData); + } + err = MP4GetListEntryCount(self->ipmpxData, &ipmpxDataCount); + if(err) goto bail; + for(i = 0; i < ipmpxDataCount; i++) + { + MP4IPMPXDataPtr entry; + err = MP4GetListEntry(self->ipmpxData, i, (char **)&entry); + if(err) goto bail; + if(entry) entry->destroy(entry); + } + err = MP4DeleteLinkedList(self->ipmpxData); + free(s); bail: - return; + return; } -MP4Err MP4CreateIPMPToolDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateIPMPToolDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4IPMPToolDescriptor ); - err = MP4MakeLinkedList( &self->ipmpxData ); if (err) goto bail; - self->ipmpToolId = (MP4IPMPToolIdPtr) calloc( 1, sizeof(MP4IPMPToolId) ); - TESTMALLOC(self->ipmpToolId); - self->addIPMPXData = addIPMPXData; - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4IPMPToolDescriptor); + err = MP4MakeLinkedList(&self->ipmpxData); + if(err) goto bail; + self->ipmpToolId = (MP4IPMPToolIdPtr)calloc(1, sizeof(MP4IPMPToolId)); + TESTMALLOC(self->ipmpToolId); + self->addIPMPXData = addIPMPXData; + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4IPMPToolList.c b/IsoLib/libisomediafile/src/MP4IPMPToolList.c index dbbcb02..92c5979 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPToolList.c +++ b/IsoLib/libisomediafile/src/MP4IPMPToolList.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -24,115 +24,113 @@ derivative works. Copyright (c) 1999. #include "MP4Movies.h" #include -static MP4Err addDescriptor( struct MP4DescriptorRecord *s, MP4DescriptorPtr desc ) +static MP4Err addDescriptor(struct MP4DescriptorRecord *s, MP4DescriptorPtr desc) { - MP4Err err; - MP4IPMPToolListDescriptorPtr self = (MP4IPMPToolListDescriptorPtr) s; - err = MP4NoErr; - - if ( desc->tag == MP4IPMP_ToolTag ) - { - err = MP4AddListEntry( desc, - self->ipmpTools ); if (err) goto bail; - } - else - BAILWITHERROR( MP4BadParamErr ) + MP4Err err; + MP4IPMPToolListDescriptorPtr self = (MP4IPMPToolListDescriptorPtr)s; + err = MP4NoErr; + + if(desc->tag == MP4IPMP_ToolTag) + { + err = MP4AddListEntry(desc, self->ipmpTools); + if(err) goto bail; + } + else + BAILWITHERROR(MP4BadParamErr) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - u32 count; - u32 i; - MP4DescriptorPtr desc; - MP4IPMPToolListDescriptorPtr self = (MP4IPMPToolListDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ - ADD_DESCRIPTOR_LIST_SIZE( ipmpTools ); + MP4Err err; + u32 count; + u32 i; + MP4DescriptorPtr desc; + MP4IPMPToolListDescriptorPtr self = (MP4IPMPToolListDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + + self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ + ADD_DESCRIPTOR_LIST_SIZE(ipmpTools); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - MP4IPMPToolListDescriptorPtr self = (MP4IPMPToolListDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - SERIALIZE_DESCRIPTOR_LIST( ipmpTools ); + MP4Err err; + MP4IPMPToolListDescriptorPtr self = (MP4IPMPToolListDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + SERIALIZE_DESCRIPTOR_LIST(ipmpTools); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4IPMPToolListDescriptorPtr self = (MP4IPMPToolListDescriptorPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - while ( self->bytesRead < self->size ) + MP4Err err; + MP4IPMPToolListDescriptorPtr self = (MP4IPMPToolListDescriptorPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + + while(self->bytesRead < self->size) + { + MP4DescriptorPtr desc; + err = MP4ParseDescriptor(inputStream, &desc); + if(err) goto bail; + if(desc->tag == MP4IPMP_ToolTag) { - MP4DescriptorPtr desc; - err = MP4ParseDescriptor( inputStream, &desc ); if (err) goto bail; - if ( desc->tag == MP4IPMP_ToolTag ) - { - err = MP4AddListEntry( desc, self->ipmpTools ); if (err) goto bail; - } - else - BAILWITHERROR( MP4InvalidMediaErr ) - - self->bytesRead += desc->size; + err = MP4AddListEntry(desc, self->ipmpTools); + if(err) goto bail; } + else + BAILWITHERROR(MP4InvalidMediaErr) + + self->bytesRead += desc->size; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static void destroy( struct MP4DescriptorRecord* s ) +static void destroy(struct MP4DescriptorRecord *s) { - MP4Err err; - MP4IPMPToolListDescriptorPtr self = (MP4IPMPToolListDescriptorPtr) s; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - DESTROY_DESCRIPTOR_LIST( ipmpTools ) + MP4Err err; + MP4IPMPToolListDescriptorPtr self = (MP4IPMPToolListDescriptorPtr)s; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); - free( s ); + DESTROY_DESCRIPTOR_LIST(ipmpTools) + + free(s); bail: - return; + return; } - -MP4Err MP4CreateIPMPToolListDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateIPMPToolListDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4IPMPToolListDescriptor ); - self->addDescriptor = addDescriptor; - err = MP4MakeLinkedList( &self->ipmpTools ); if (err) goto bail; - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4IPMPToolListDescriptor); + self->addDescriptor = addDescriptor; + err = MP4MakeLinkedList(&self->ipmpTools); + if(err) goto bail; + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - diff --git a/IsoLib/libisomediafile/src/MP4IPMPX.c b/IsoLib/libisomediafile/src/MP4IPMPX.c index b7f3947..aa5475f 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPX.c +++ b/IsoLib/libisomediafile/src/MP4IPMPX.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -27,515 +27,495 @@ derivative works. Copyright (c) 1999. #include "MP4Impl.h" #include -MP4Err MP4NewIPMPTool( MP4Handle ipmpToolH, - u64 ipmpToolIdLowerPart, - u64 ipmpToolIdUpperPart, - MP4Handle altGroupInfoH, - MP4Handle parametricInfoH ) +MP4Err MP4NewIPMPTool(MP4Handle ipmpToolH, u64 ipmpToolIdLowerPart, u64 ipmpToolIdUpperPart, + MP4Handle altGroupInfoH, MP4Handle parametricInfoH) { - MP4Err err; - MP4IPMPToolPtr tool; - err = MP4NoErr; - tool = NULL; - - if ( ipmpToolH == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - /* create the IPMP Tool */ - err = MP4CreateIPMPTool( MP4IPMP_ToolTag, - 0, - 0, - (MP4DescriptorPtr *) &tool ); - if (err) goto bail; - - /* set the id */ - tool->toolId->upperPart = ipmpToolIdUpperPart; - tool->toolId->lowerPart = ipmpToolIdLowerPart; - - /* set the alternates */ - if ( altGroupInfoH != NULL ) + MP4Err err; + MP4IPMPToolPtr tool; + err = MP4NoErr; + tool = NULL; + + if(ipmpToolH == NULL) BAILWITHERROR(MP4BadParamErr); + + /* create the IPMP Tool */ + err = MP4CreateIPMPTool(MP4IPMP_ToolTag, 0, 0, (MP4DescriptorPtr *)&tool); + if(err) goto bail; + + /* set the id */ + tool->toolId->upperPart = ipmpToolIdUpperPart; + tool->toolId->lowerPart = ipmpToolIdLowerPart; + + /* set the alternates */ + if(altGroupInfoH != NULL) + { + u32 handleSize; + + err = MP4GetHandleSize(altGroupInfoH, &handleSize); + if(err) goto bail; + /* check that the handler is 128 bits aligned */ + if(((handleSize % 16) != 0) || (handleSize == 0)) { - u32 handleSize; - - err = MP4GetHandleSize( altGroupInfoH, - &handleSize ); if (err) goto bail; - /* check that the handler is 128 bits aligned */ - if ( ((handleSize % 16) != 0) || (handleSize == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - else - { - u32 i; - u64* altIds = (u64 *)*altGroupInfoH; - for ( i = 0; i < handleSize/16; i++ ) - { - MP4IPMPToolIdPtr id = (MP4IPMPToolIdPtr) calloc( 1, sizeof(MP4IPMPToolId) ); - TESTMALLOC(id); - id->lowerPart = altIds[i*2]; - id->upperPart = altIds[i*2 + 1]; - err = MP4AddListEntry( id, - tool->alternateToolIds ); if (err) goto bail; - } - } + BAILWITHERROR(MP4BadParamErr); } - /* set the parametric description */ - if ( parametricInfoH != NULL ) + else { - u32 paramInfoSize; - MP4IPMPByteArrayPtr paramInfo = (MP4IPMPByteArrayPtr) calloc( 1, sizeof(MP4IPMPByteArray) ); - TESTMALLOC( paramInfo ); - err = MP4GetHandleSize( parametricInfoH, - ¶mInfoSize ); if (err) goto bail; - paramInfo->size = paramInfoSize; - paramInfo->data = (char*) calloc( 1, paramInfoSize ); - TESTMALLOC( paramInfo->data ); - memcpy( paramInfo->data, *parametricInfoH, paramInfoSize ); - tool->toolParamDesc = paramInfo; + u32 i; + u64 *altIds = (u64 *)*altGroupInfoH; + for(i = 0; i < handleSize / 16; i++) + { + MP4IPMPToolIdPtr id = (MP4IPMPToolIdPtr)calloc(1, sizeof(MP4IPMPToolId)); + TESTMALLOC(id); + id->lowerPart = altIds[i * 2]; + id->upperPart = altIds[i * 2 + 1]; + err = MP4AddListEntry(id, tool->alternateToolIds); + if(err) goto bail; + } } + } + /* set the parametric description */ + if(parametricInfoH != NULL) + { + u32 paramInfoSize; + MP4IPMPByteArrayPtr paramInfo = (MP4IPMPByteArrayPtr)calloc(1, sizeof(MP4IPMPByteArray)); + TESTMALLOC(paramInfo); + err = MP4GetHandleSize(parametricInfoH, ¶mInfoSize); + if(err) goto bail; + paramInfo->size = paramInfoSize; + paramInfo->data = (char *)calloc(1, paramInfoSize); + TESTMALLOC(paramInfo->data); + memcpy(paramInfo->data, *parametricInfoH, paramInfoSize); + tool->toolParamDesc = paramInfo; + } + + /* save the tool as a handle */ + err = tool->calculateSize((MP4DescriptorPtr)tool); + if(err) goto bail; + err = MP4SetHandleSize(ipmpToolH, tool->size); + if(err) goto bail; + err = tool->serialize((MP4DescriptorPtr)tool, *ipmpToolH); + if(err) goto bail; - /* save the tool as a handle */ - err = tool->calculateSize( (MP4DescriptorPtr)tool ); if (err) goto bail; - err = MP4SetHandleSize( ipmpToolH, tool->size ); if (err) goto bail; - err = tool->serialize( (MP4DescriptorPtr)tool, *ipmpToolH ); if (err) goto bail; - bail: - if ( tool ) tool->destroy( (MP4DescriptorPtr) tool ); - return err; + if(tool) tool->destroy((MP4DescriptorPtr)tool); + return err; } -MP4Err MP4AddUrlToIPMPTool( MP4Handle ipmpToolH, - MP4Handle urlH ) +MP4Err MP4AddUrlToIPMPTool(MP4Handle ipmpToolH, MP4Handle urlH) { - MP4Err MP4CreateMemoryInputStream( char* base, u32 size, MP4InputStreamPtr *outStream ); - - MP4Err err; - MP4IPMPToolPtr desc; - u32 toolSize; - MP4InputStreamPtr is; - MP4IPMPByteArrayPtr url; - - err = MP4NoErr; - desc = NULL; - if ( (ipmpToolH == NULL) || (urlH == NULL) ) - BAILWITHERROR( MP4BadParamErr ); - - /* parse the descriptor */ - err = MP4GetHandleSize( ipmpToolH, - &toolSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *ipmpToolH, - toolSize, - &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseDescriptor( is, (MP4DescriptorPtr *) &desc ); if (err) goto bail; - is->destroy( is ); - - /* build the url */ - url = (MP4IPMPByteArrayPtr) calloc( 1, sizeof(MP4IPMPByteArray) ); - TESTMALLOC( url ); - err = MP4GetHandleSize( urlH, - &url->size ); if (err) goto bail; - url->data = (char *) calloc( 1, url->size ); - TESTMALLOC( url->data ); - - /* add the url to the descriptor */ - err = MP4AddListEntry( url, desc->toolUrls ); if (err) goto bail; - - /* save the descriptor as a handle */ - err = desc->calculateSize( (MP4DescriptorPtr) desc ); if (err) goto bail; - err = MP4SetHandleSize( ipmpToolH, - desc->size ); if (err) goto bail; - err = desc->serialize( (MP4DescriptorPtr) desc, - *ipmpToolH ); if (err) goto bail; + MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); + + MP4Err err; + MP4IPMPToolPtr desc; + u32 toolSize; + MP4InputStreamPtr is; + MP4IPMPByteArrayPtr url; + + err = MP4NoErr; + desc = NULL; + if((ipmpToolH == NULL) || (urlH == NULL)) BAILWITHERROR(MP4BadParamErr); + + /* parse the descriptor */ + err = MP4GetHandleSize(ipmpToolH, &toolSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*ipmpToolH, toolSize, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseDescriptor(is, (MP4DescriptorPtr *)&desc); + if(err) goto bail; + is->destroy(is); + + /* build the url */ + url = (MP4IPMPByteArrayPtr)calloc(1, sizeof(MP4IPMPByteArray)); + TESTMALLOC(url); + err = MP4GetHandleSize(urlH, &url->size); + if(err) goto bail; + url->data = (char *)calloc(1, url->size); + TESTMALLOC(url->data); + + /* add the url to the descriptor */ + err = MP4AddListEntry(url, desc->toolUrls); + if(err) goto bail; + + /* save the descriptor as a handle */ + err = desc->calculateSize((MP4DescriptorPtr)desc); + if(err) goto bail; + err = MP4SetHandleSize(ipmpToolH, desc->size); + if(err) goto bail; + err = desc->serialize((MP4DescriptorPtr)desc, *ipmpToolH); + if(err) goto bail; bail: - if ( desc ) desc->destroy( (MP4DescriptorPtr) desc ); - return err; + if(desc) desc->destroy((MP4DescriptorPtr)desc); + return err; } -MP4Err MP4NewIPMPToolListDescriptor( MP4Handle ipmpToolListDescrH ) +MP4Err MP4NewIPMPToolListDescriptor(MP4Handle ipmpToolListDescrH) { - MP4Err err; - MP4IPMPToolListDescriptorPtr toolList; - toolList = NULL; - err = MP4NoErr; - if ( ipmpToolListDescrH == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - /* create the ipmp tool list */ - err = MP4CreateIPMPToolListDescriptor( MP4IPMP_ToolListDescriptorTag, - 0, - 0, - (MP4DescriptorPtr *) &toolList ); - if (err) goto bail; - - /* save the ipmp tool list as a handle */ - err = toolList->calculateSize( (MP4DescriptorPtr)toolList ); if (err) goto bail; - err = MP4SetHandleSize( ipmpToolListDescrH, toolList->size ); if (err) goto bail; - err = toolList->serialize( (MP4DescriptorPtr)toolList, - *ipmpToolListDescrH ); if (err) goto bail; + MP4Err err; + MP4IPMPToolListDescriptorPtr toolList; + toolList = NULL; + err = MP4NoErr; + if(ipmpToolListDescrH == NULL) BAILWITHERROR(MP4BadParamErr); + + /* create the ipmp tool list */ + err = MP4CreateIPMPToolListDescriptor(MP4IPMP_ToolListDescriptorTag, 0, 0, + (MP4DescriptorPtr *)&toolList); + if(err) goto bail; + + /* save the ipmp tool list as a handle */ + err = toolList->calculateSize((MP4DescriptorPtr)toolList); + if(err) goto bail; + err = MP4SetHandleSize(ipmpToolListDescrH, toolList->size); + if(err) goto bail; + err = toolList->serialize((MP4DescriptorPtr)toolList, *ipmpToolListDescrH); + if(err) goto bail; bail: - if ( toolList ) toolList->destroy( (MP4DescriptorPtr) toolList ); - return err; + if(toolList) toolList->destroy((MP4DescriptorPtr)toolList); + return err; } -MP4Err MP4AddToolToIPMPToolList( MP4Handle ipmpToolListDescrH, - MP4Handle ipmpToolH ) +MP4Err MP4AddToolToIPMPToolList(MP4Handle ipmpToolListDescrH, MP4Handle ipmpToolH) { - MP4Err MP4CreateMemoryInputStream( char *base, u32 size, MP4InputStreamPtr *outStream ); - - MP4Err err; - u32 toolListSize, toolSize; - MP4InputStreamPtr is; - MP4IPMPToolListDescriptorPtr toolListDesc; - MP4DescriptorPtr tool; - - toolListDesc = NULL; - err = MP4NoErr; - if ( (ipmpToolListDescrH == NULL) || (ipmpToolH == NULL) ) - BAILWITHERROR( MP4BadParamErr ); - - /* parse the ipmpToolListDescriptor */ - err = MP4GetHandleSize( ipmpToolListDescrH, - &toolListSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *ipmpToolListDescrH, - toolListSize, - &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseDescriptor( is, (MP4DescriptorPtr *) &toolListDesc ); if (err) goto bail; - is->destroy( is ); - if ( toolListDesc == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - /* parse the tool */ - err = MP4GetHandleSize( ipmpToolH, &toolSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *ipmpToolH, - toolSize, - &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseDescriptor( is, &tool ); if (err) goto bail; - is->destroy( is ); - - /* add the tool to the ipmp tool list */ - err = toolListDesc->addDescriptor( (MP4DescriptorPtr) toolListDesc, - tool ); if (err) goto bail; - - /* save the tool list as a handle */ - err = toolListDesc->calculateSize( (MP4DescriptorPtr) toolListDesc ); if (err) goto bail; - err = MP4SetHandleSize( ipmpToolListDescrH, - toolListDesc->size ); if (err) goto bail; - err = toolListDesc->serialize( (MP4DescriptorPtr) toolListDesc, - *ipmpToolListDescrH ); if (err) goto bail; + MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); + + MP4Err err; + u32 toolListSize, toolSize; + MP4InputStreamPtr is; + MP4IPMPToolListDescriptorPtr toolListDesc; + MP4DescriptorPtr tool; + + toolListDesc = NULL; + err = MP4NoErr; + if((ipmpToolListDescrH == NULL) || (ipmpToolH == NULL)) BAILWITHERROR(MP4BadParamErr); + + /* parse the ipmpToolListDescriptor */ + err = MP4GetHandleSize(ipmpToolListDescrH, &toolListSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*ipmpToolListDescrH, toolListSize, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseDescriptor(is, (MP4DescriptorPtr *)&toolListDesc); + if(err) goto bail; + is->destroy(is); + if(toolListDesc == NULL) BAILWITHERROR(MP4BadParamErr); + + /* parse the tool */ + err = MP4GetHandleSize(ipmpToolH, &toolSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*ipmpToolH, toolSize, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseDescriptor(is, &tool); + if(err) goto bail; + is->destroy(is); + + /* add the tool to the ipmp tool list */ + err = toolListDesc->addDescriptor((MP4DescriptorPtr)toolListDesc, tool); + if(err) goto bail; + + /* save the tool list as a handle */ + err = toolListDesc->calculateSize((MP4DescriptorPtr)toolListDesc); + if(err) goto bail; + err = MP4SetHandleSize(ipmpToolListDescrH, toolListDesc->size); + if(err) goto bail; + err = toolListDesc->serialize((MP4DescriptorPtr)toolListDesc, *ipmpToolListDescrH); + if(err) goto bail; bail: - if ( toolListDesc ) toolListDesc->destroy( (MP4DescriptorPtr) toolListDesc ); - return err; + if(toolListDesc) toolListDesc->destroy((MP4DescriptorPtr)toolListDesc); + return err; } - -MP4Err MP4NewIPMPDescriptorPointer( MP4Handle ipmpDescPtrH, - u8 ipmpDescriptorId, - u16 ipmpToolDescrId ) +MP4Err MP4NewIPMPDescriptorPointer(MP4Handle ipmpDescPtrH, u8 ipmpDescriptorId, u16 ipmpToolDescrId) { - MP4Err err; - MP4IPMPDescriptorPointerPtr desc; - - err = MP4NoErr; - desc = NULL; - /* check the handle */ - if ( ipmpDescPtrH == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - /* check the IDs */ - if ( ipmpDescriptorId != 0xFF ) /* ipmp hooks */ - { - if ( ipmpToolDescrId != 0 ) - BAILWITHERROR( MP4BadParamErr ); - } - else /* ipmp extensions */ - { - if ( ipmpToolDescrId == 0 ) - BAILWITHERROR( MP4BadParamErr ); - } - - /* create the descriptor */ - err = MP4CreateIPMPDescriptorPointer( MP4IPMP_DescriptorPointerTag, - 0, - 0, - (MP4DescriptorPtr *) &desc ); if (err) goto bail; - desc->ipmpDescriptorId = ipmpDescriptorId; - desc->ipmpToolDescriptorId = ipmpToolDescrId; - - /* serialize it as a handle */ - err = desc->calculateSize( (MP4DescriptorPtr) desc ); if (err) goto bail; - err = MP4SetHandleSize( ipmpDescPtrH, desc->size ); if (err) goto bail; - err = desc->serialize( (MP4DescriptorPtr) desc, - *ipmpDescPtrH ); if (err) goto bail; + MP4Err err; + MP4IPMPDescriptorPointerPtr desc; + + err = MP4NoErr; + desc = NULL; + /* check the handle */ + if(ipmpDescPtrH == NULL) BAILWITHERROR(MP4BadParamErr); + + /* check the IDs */ + if(ipmpDescriptorId != 0xFF) /* ipmp hooks */ + { + if(ipmpToolDescrId != 0) BAILWITHERROR(MP4BadParamErr); + } + else /* ipmp extensions */ + { + if(ipmpToolDescrId == 0) BAILWITHERROR(MP4BadParamErr); + } + + /* create the descriptor */ + err = + MP4CreateIPMPDescriptorPointer(MP4IPMP_DescriptorPointerTag, 0, 0, (MP4DescriptorPtr *)&desc); + if(err) goto bail; + desc->ipmpDescriptorId = ipmpDescriptorId; + desc->ipmpToolDescriptorId = ipmpToolDescrId; + + /* serialize it as a handle */ + err = desc->calculateSize((MP4DescriptorPtr)desc); + if(err) goto bail; + err = MP4SetHandleSize(ipmpDescPtrH, desc->size); + if(err) goto bail; + err = desc->serialize((MP4DescriptorPtr)desc, *ipmpDescPtrH); + if(err) goto bail; bail: - if ( desc ) desc->destroy( (MP4DescriptorPtr) desc ); - return err; + if(desc) desc->destroy((MP4DescriptorPtr)desc); + return err; } - -MP4Err MP4NewIPMPToolDescriptor( MP4Handle ipmpToolDescH, - u16 ipmpToolDescrId, - u64 ipmpToolIdLowerPart, - u64 ipmpToolIdUpperPart, - MP4Handle ipmpInitializeH ) +MP4Err MP4NewIPMPToolDescriptor(MP4Handle ipmpToolDescH, u16 ipmpToolDescrId, + u64 ipmpToolIdLowerPart, u64 ipmpToolIdUpperPart, + MP4Handle ipmpInitializeH) { - MP4Err MP4CreateMemoryInputStream( char *base, u32 size, MP4InputStreamPtr *outStream ); - - MP4Err err; - MP4IPMPToolDescriptorPtr desc; - - err = MP4NoErr; - desc = NULL; - if ( (ipmpToolDescH == NULL) || (ipmpToolDescrId == 0) ) - BAILWITHERROR( MP4BadParamErr ); - - /* create the tool descriptor */ - err = MP4CreateIPMPToolDescriptor( MP4IPMP_ToolDescriptorTag, - 0, - 0, - (MP4DescriptorPtr *) &desc ); if (err) goto bail; - desc->ipmpToolDescriptorId = ipmpToolDescrId; - desc->ipmpToolId->lowerPart = ipmpToolIdLowerPart; - desc->ipmpToolId->upperPart = ipmpToolIdUpperPart; - - /* if there's some init data, add it to the descriptor */ - if ( ipmpInitializeH != NULL ) - { - MP4InputStreamPtr is; - MP4IPMPInitializePtr init; - u32 initSize; - - err = MP4CreateIPMPInitialize( &init ); if (err) goto bail; - err = MP4GetHandleSize( ipmpInitializeH, - &initSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *ipmpInitializeH, - initSize, - &is ); if (err) goto bail; - is->debugging = 0; - err = init->createFromInputStream( init, is ); if (err) goto bail; - is->destroy( is ); - desc->initData = init; - } + MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); - /* save it as handle */ - err = desc->calculateSize( (MP4DescriptorPtr) desc ); if (err) goto bail; - err = MP4SetHandleSize( ipmpToolDescH, - desc->size ); if (err) goto bail; - err = desc->serialize( (MP4DescriptorPtr) desc, - *ipmpToolDescH ); if (err) goto bail; + MP4Err err; + MP4IPMPToolDescriptorPtr desc; -bail: - if ( desc ) desc->destroy( (MP4DescriptorPtr) desc ); - return err; -} + err = MP4NoErr; + desc = NULL; + if((ipmpToolDescH == NULL) || (ipmpToolDescrId == 0)) BAILWITHERROR(MP4BadParamErr); + /* create the tool descriptor */ + err = MP4CreateIPMPToolDescriptor(MP4IPMP_ToolDescriptorTag, 0, 0, (MP4DescriptorPtr *)&desc); + if(err) goto bail; + desc->ipmpToolDescriptorId = ipmpToolDescrId; + desc->ipmpToolId->lowerPart = ipmpToolIdLowerPart; + desc->ipmpToolId->upperPart = ipmpToolIdUpperPart; -MP4Err MP4NewIPMPInitialize( MP4Handle ipmpInitializeH, - u8 controlPoint, - u8 sequenceCode ) -{ - MP4Err err; + /* if there's some init data, add it to the descriptor */ + if(ipmpInitializeH != NULL) + { + MP4InputStreamPtr is; MP4IPMPInitializePtr init; + u32 initSize; - init = NULL; - err = MP4NoErr; - if ( (ipmpInitializeH == NULL) || (controlPoint == 0xFF) ) - BAILWITHERROR( MP4BadParamErr ); - /* create the structure */ - err = MP4CreateIPMPInitialize( &init ); if (err) goto bail; - init->controlPointCode = controlPoint; - init->sequenceCode = sequenceCode; - - /* save it as a handle */ - err = init->calculateSize( init ); if (err) goto bail; - err = MP4SetHandleSize( ipmpInitializeH, - init->size ); if (err) goto bail; - err = init->serialize( init, - *ipmpInitializeH ); if (err) goto bail; + err = MP4CreateIPMPInitialize(&init); + if(err) goto bail; + err = MP4GetHandleSize(ipmpInitializeH, &initSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*ipmpInitializeH, initSize, &is); + if(err) goto bail; + is->debugging = 0; + err = init->createFromInputStream(init, is); + if(err) goto bail; + is->destroy(is); + desc->initData = init; + } + + /* save it as handle */ + err = desc->calculateSize((MP4DescriptorPtr)desc); + if(err) goto bail; + err = MP4SetHandleSize(ipmpToolDescH, desc->size); + if(err) goto bail; + err = desc->serialize((MP4DescriptorPtr)desc, *ipmpToolDescH); + if(err) goto bail; bail: - if ( init ) init->destroy( init ); - return err; + if(desc) desc->destroy((MP4DescriptorPtr)desc); + return err; } -MP4Err MP4AddIPMPDataToIPMPInitialize( MP4Handle ipmpInitializeH, - MP4Handle ipmpDataH ) +MP4Err MP4NewIPMPInitialize(MP4Handle ipmpInitializeH, u8 controlPoint, u8 sequenceCode) { - MP4Err MP4CreateMemoryInputStream( char* base, u32 size, MP4InputStreamPtr* outStream ); - - MP4Err err; - MP4IPMPInitializePtr init; - MP4IPMPXDataPtr data; - MP4InputStreamPtr is; - u32 initSize; - u32 dataSize; - - err = MP4NoErr; - init = NULL; - if ( (ipmpInitializeH == NULL) || (ipmpDataH == NULL) ) - BAILWITHERROR( MP4BadParamErr ); - /* build the MP4IPMPInitialize structure */ - err = MP4CreateIPMPInitialize( &init );if (err) goto bail; - err = MP4GetHandleSize( ipmpInitializeH, - &initSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *ipmpInitializeH, - initSize, - &is ); if (err) goto bail; - is->debugging = 0; - err = init->createFromInputStream( init, is ); if (err) goto bail; - is->destroy( is ); - - /* parse the data */ - err = MP4GetHandleSize( ipmpDataH, - &dataSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *ipmpDataH, - dataSize, - &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseIPMPXData( is, &data ); if (err) goto bail; - - /* add the data to the init structure */ - err = init->addIPMPXData( init, data ); if (err) goto bail; + MP4Err err; + MP4IPMPInitializePtr init; + + init = NULL; + err = MP4NoErr; + if((ipmpInitializeH == NULL) || (controlPoint == 0xFF)) BAILWITHERROR(MP4BadParamErr); + /* create the structure */ + err = MP4CreateIPMPInitialize(&init); + if(err) goto bail; + init->controlPointCode = controlPoint; + init->sequenceCode = sequenceCode; + + /* save it as a handle */ + err = init->calculateSize(init); + if(err) goto bail; + err = MP4SetHandleSize(ipmpInitializeH, init->size); + if(err) goto bail; + err = init->serialize(init, *ipmpInitializeH); + if(err) goto bail; - /* save it as a handle */ - err = init->calculateSize( init ); if (err) goto bail; - err = MP4SetHandleSize( ipmpInitializeH, - init->size ); if (err) goto bail; - err = init->serialize( init, - *ipmpInitializeH ); if (err) goto bail; bail: - if ( init ) init->destroy( init ); - return err; + if(init) init->destroy(init); + return err; } -MP4Err MP4AddIPMPDataToIPMPToolDescriptor( MP4Handle ipmpToolDescrH, - MP4Handle ipmpDataH ) +MP4Err MP4AddIPMPDataToIPMPInitialize(MP4Handle ipmpInitializeH, MP4Handle ipmpDataH) { - MP4Err MP4CreateMemoryInputStream( char* base, u32 size, MP4InputStreamPtr* outStream ); - - MP4Err err; - MP4IPMPToolDescriptorPtr desc; - MP4IPMPXDataPtr data; - MP4InputStreamPtr is; - u32 descSize; - u32 dataSize; - - err = MP4NoErr; - desc = NULL; - if ( (ipmpToolDescrH == NULL) || (ipmpDataH == NULL) ) - BAILWITHERROR( MP4BadParamErr ); - /* parse the descriptor */ - err = MP4GetHandleSize( ipmpToolDescrH, - &descSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *ipmpToolDescrH, - descSize, - &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseDescriptor( is, (MP4DescriptorPtr *) &desc );if (err) goto bail; - is->destroy( is ); - - /* parse the data */ - err = MP4GetHandleSize( ipmpDataH, - &dataSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *ipmpDataH, - dataSize, - &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseIPMPXData( is, &data ); if (err) goto bail; - - /* add the data to the descriptor */ - err = desc->addIPMPXData( (MP4DescriptorPtr) desc, data ); if (err) goto bail; - - /* save it as a handle */ - err = desc->calculateSize( (MP4DescriptorPtr)desc ); if (err) goto bail; - err = MP4SetHandleSize( ipmpToolDescrH, - desc->size ); if (err) goto bail; - err = desc->serialize( (MP4DescriptorPtr) desc, - *ipmpToolDescrH ); if (err) goto bail; + MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); + + MP4Err err; + MP4IPMPInitializePtr init; + MP4IPMPXDataPtr data; + MP4InputStreamPtr is; + u32 initSize; + u32 dataSize; + + err = MP4NoErr; + init = NULL; + if((ipmpInitializeH == NULL) || (ipmpDataH == NULL)) BAILWITHERROR(MP4BadParamErr); + /* build the MP4IPMPInitialize structure */ + err = MP4CreateIPMPInitialize(&init); + if(err) goto bail; + err = MP4GetHandleSize(ipmpInitializeH, &initSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*ipmpInitializeH, initSize, &is); + if(err) goto bail; + is->debugging = 0; + err = init->createFromInputStream(init, is); + if(err) goto bail; + is->destroy(is); + + /* parse the data */ + err = MP4GetHandleSize(ipmpDataH, &dataSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*ipmpDataH, dataSize, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseIPMPXData(is, &data); + if(err) goto bail; + + /* add the data to the init structure */ + err = init->addIPMPXData(init, data); + if(err) goto bail; + + /* save it as a handle */ + err = init->calculateSize(init); + if(err) goto bail; + err = MP4SetHandleSize(ipmpInitializeH, init->size); + if(err) goto bail; + err = init->serialize(init, *ipmpInitializeH); + if(err) goto bail; bail: - if ( desc ) desc->destroy( (MP4DescriptorPtr) desc ); - return err; + if(init) init->destroy(init); + return err; } -MP4Err MP4NewIPMPToolDescriptorUpdate( MP4Handle ipmpToolDescrUpdateH ) +MP4Err MP4AddIPMPDataToIPMPToolDescriptor(MP4Handle ipmpToolDescrH, MP4Handle ipmpDataH) { - MP4Err err; - MP4IPMPToolDescriptorUpdatePtr cmd; - - cmd = NULL; - err = MP4NoErr; - if ( ipmpToolDescrUpdateH == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - /* create the command */ - err = MP4CreateIPMPToolDescriptorUpdate( MP4IPMP_ToolDescriptorUpdateTag, - 0, - 0, - (MP4DescriptorPtr *) &cmd ); if (err) goto bail; - /* save it as a handle */ - err = cmd->calculateSize( (MP4DescriptorPtr) cmd ); if (err) goto bail; - err = MP4SetHandleSize( ipmpToolDescrUpdateH, - cmd->size ); - err = cmd->serialize( (MP4DescriptorPtr) cmd, - *ipmpToolDescrUpdateH ); if (err) goto bail; + MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); + + MP4Err err; + MP4IPMPToolDescriptorPtr desc; + MP4IPMPXDataPtr data; + MP4InputStreamPtr is; + u32 descSize; + u32 dataSize; + + err = MP4NoErr; + desc = NULL; + if((ipmpToolDescrH == NULL) || (ipmpDataH == NULL)) BAILWITHERROR(MP4BadParamErr); + /* parse the descriptor */ + err = MP4GetHandleSize(ipmpToolDescrH, &descSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*ipmpToolDescrH, descSize, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseDescriptor(is, (MP4DescriptorPtr *)&desc); + if(err) goto bail; + is->destroy(is); + + /* parse the data */ + err = MP4GetHandleSize(ipmpDataH, &dataSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*ipmpDataH, dataSize, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseIPMPXData(is, &data); + if(err) goto bail; + + /* add the data to the descriptor */ + err = desc->addIPMPXData((MP4DescriptorPtr)desc, data); + if(err) goto bail; + + /* save it as a handle */ + err = desc->calculateSize((MP4DescriptorPtr)desc); + if(err) goto bail; + err = MP4SetHandleSize(ipmpToolDescrH, desc->size); + if(err) goto bail; + err = desc->serialize((MP4DescriptorPtr)desc, *ipmpToolDescrH); + if(err) goto bail; bail: - if ( cmd ) cmd->destroy( (MP4DescriptorPtr) cmd ); - return err; + if(desc) desc->destroy((MP4DescriptorPtr)desc); + return err; } -MP4Err MP4AddIPMPToolDescriptorToUpdate( MP4Handle ipmpToolDescrUpdateH, - MP4Handle ipmpToolDescrH ) +MP4Err MP4NewIPMPToolDescriptorUpdate(MP4Handle ipmpToolDescrUpdateH) { - MP4Err MP4CreateMemoryInputStream( char *base, u32 size, MP4InputStreamPtr *outStream ); - - MP4Err err; - MP4IPMPToolDescriptorUpdatePtr cmd; - MP4InputStreamPtr is; - MP4IPMPToolDescriptorPtr desc; - u32 cmdSize; - u32 descSize; - - err = MP4NoErr; - cmd = NULL; - if ( (ipmpToolDescrUpdateH == NULL) || (ipmpToolDescrH == NULL) ) - BAILWITHERROR( MP4BadParamErr ); - - /* parse the command */ - err = MP4GetHandleSize( ipmpToolDescrUpdateH, - &cmdSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *ipmpToolDescrUpdateH, - cmdSize, - &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseCommand( is, (MP4DescriptorPtr *) &cmd ); if (err) goto bail; - is->destroy( is ); - - /* parse the descriptor */ - err = MP4GetHandleSize( ipmpToolDescrH, - &descSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *ipmpToolDescrH, - descSize, - &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseDescriptor( is, (MP4DescriptorPtr *) &desc ); if (err) goto bail; - is->destroy( is ); - - /* add the descriptor to the command */ - err = cmd->addDescriptor( (MP4DescriptorPtr) cmd, - (MP4DescriptorPtr) desc ); if (err) goto bail; - - /* serialize the command as a handle */ - err = cmd->calculateSize( (MP4DescriptorPtr) cmd ); if (err) goto bail; - err = MP4SetHandleSize( ipmpToolDescrUpdateH, - cmd->size ); if (err) goto bail; - err = cmd->serialize( (MP4DescriptorPtr) cmd, - *ipmpToolDescrUpdateH ); if (err) goto bail; + MP4Err err; + MP4IPMPToolDescriptorUpdatePtr cmd; + + cmd = NULL; + err = MP4NoErr; + if(ipmpToolDescrUpdateH == NULL) BAILWITHERROR(MP4BadParamErr); + + /* create the command */ + err = MP4CreateIPMPToolDescriptorUpdate(MP4IPMP_ToolDescriptorUpdateTag, 0, 0, + (MP4DescriptorPtr *)&cmd); + if(err) goto bail; + /* save it as a handle */ + err = cmd->calculateSize((MP4DescriptorPtr)cmd); + if(err) goto bail; + err = MP4SetHandleSize(ipmpToolDescrUpdateH, cmd->size); + err = cmd->serialize((MP4DescriptorPtr)cmd, *ipmpToolDescrUpdateH); + if(err) goto bail; bail: - if ( cmd ) cmd->destroy( (MP4DescriptorPtr) cmd ); - return err; + if(cmd) cmd->destroy((MP4DescriptorPtr)cmd); + return err; } +MP4Err MP4AddIPMPToolDescriptorToUpdate(MP4Handle ipmpToolDescrUpdateH, MP4Handle ipmpToolDescrH) +{ + MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); + + MP4Err err; + MP4IPMPToolDescriptorUpdatePtr cmd; + MP4InputStreamPtr is; + MP4IPMPToolDescriptorPtr desc; + u32 cmdSize; + u32 descSize; + + err = MP4NoErr; + cmd = NULL; + if((ipmpToolDescrUpdateH == NULL) || (ipmpToolDescrH == NULL)) BAILWITHERROR(MP4BadParamErr); + + /* parse the command */ + err = MP4GetHandleSize(ipmpToolDescrUpdateH, &cmdSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*ipmpToolDescrUpdateH, cmdSize, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseCommand(is, (MP4DescriptorPtr *)&cmd); + if(err) goto bail; + is->destroy(is); + + /* parse the descriptor */ + err = MP4GetHandleSize(ipmpToolDescrH, &descSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*ipmpToolDescrH, descSize, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseDescriptor(is, (MP4DescriptorPtr *)&desc); + if(err) goto bail; + is->destroy(is); + + /* add the descriptor to the command */ + err = cmd->addDescriptor((MP4DescriptorPtr)cmd, (MP4DescriptorPtr)desc); + if(err) goto bail; + + /* serialize the command as a handle */ + err = cmd->calculateSize((MP4DescriptorPtr)cmd); + if(err) goto bail; + err = MP4SetHandleSize(ipmpToolDescrUpdateH, cmd->size); + if(err) goto bail; + err = cmd->serialize((MP4DescriptorPtr)cmd, *ipmpToolDescrUpdateH); + if(err) goto bail; +bail: + if(cmd) cmd->destroy((MP4DescriptorPtr)cmd); + return err; +} diff --git a/IsoLib/libisomediafile/src/MP4IPMPXData.c b/IsoLib/libisomediafile/src/MP4IPMPXData.c index dcb2d46..ddb6e1b 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPXData.c +++ b/IsoLib/libisomediafile/src/MP4IPMPXData.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. @@ -25,85 +25,91 @@ derivative works. Copyright (c) 1999, 2000. #include "MP4Movies.h" #include "MP4Impl.h" -#define GET_IPMPXDATA_BYTE( varName, what ) \ - err = inputStream->read8( inputStream, &varName, what ); if (err) goto bail; \ - bytesRead ++ +#define GET_IPMPXDATA_BYTE(varName, what) \ + err = inputStream->read8(inputStream, &varName, what); \ + if(err) goto bail; \ + bytesRead++ -MP4Err MP4ParseIPMPXData( MP4InputStreamPtr inputStream, MP4IPMPXDataPtr *outData ) +MP4Err MP4ParseIPMPXData(MP4InputStreamPtr inputStream, MP4IPMPXDataPtr *outData) { - MP4Err err; - u32 tag; - u32 size; - u32 val; - MP4IPMPXDataPtr data; - u32 bytesRead; - u32 sizeBytes; - u32 version; - - err = MP4NoErr; - if ( (inputStream == NULL) || (outData == NULL) ) - BAILWITHERROR( MP4BadParamErr ) - bytesRead = 0; - GET_IPMPXDATA_BYTE( tag, "class tag" ); + MP4Err err; + u32 tag; + u32 size; + u32 val; + MP4IPMPXDataPtr data; + u32 bytesRead; + u32 sizeBytes; + u32 version; - /* get size */ - size = 0; - sizeBytes = 1; - do - { - GET_IPMPXDATA_BYTE( val, "size byte" ); - sizeBytes++; - size <<= 7; - size |= val & 0x7F; - } while ( val & 0x80 ); - size += sizeBytes; + err = MP4NoErr; + if((inputStream == NULL) || (outData == NULL)) BAILWITHERROR(MP4BadParamErr) + bytesRead = 0; + GET_IPMPXDATA_BYTE(tag, "class tag"); - switch ( tag ) - { - /* for now, just the default IPMPXData is implemented */ - default: - err = MP4CreateIPMPXDefaultData( tag, size, bytesRead, &data ); if (err) goto bail; - break; - } + /* get size */ + size = 0; + sizeBytes = 1; + do + { + GET_IPMPXDATA_BYTE(val, "size byte"); + sizeBytes++; + size <<= 7; + size |= val & 0x7F; + } while(val & 0x80); + size += sizeBytes; - /* read the version */ - err = inputStream->read8( inputStream, &version, NULL ); if (err) goto bail; - data->version = version; - data->bytesRead++; - if ( data->version != 0x01 ) /* only version 1 is currently supported */ - BAILWITHERROR( MP4BadDataErr ) + switch(tag) + { + /* for now, just the default IPMPXData is implemented */ + default: + err = MP4CreateIPMPXDefaultData(tag, size, bytesRead, &data); + if(err) goto bail; + break; + } - /* continue to read the stream */ - err = data->createFromInputStream( data, inputStream ); if (err) goto bail; - *outData = data; + /* read the version */ + err = inputStream->read8(inputStream, &version, NULL); + if(err) goto bail; + data->version = version; + data->bytesRead++; + if(data->version != 0x01) /* only version 1 is currently supported */ + BAILWITHERROR(MP4BadDataErr) + + /* continue to read the stream */ + err = data->createFromInputStream(data, inputStream); + if(err) goto bail; + *outData = data; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4EncodeBaseIPMPXData( struct MP4IPMPXDataRecord* self, char* buffer ) +MP4Err MP4EncodeBaseIPMPXData(struct MP4IPMPXDataRecord *self, char *buffer) { - MP4Err err; - u32 length; - u8 vals[ 4 ]; - err = MP4NoErr; - - self->bytesWritten = 0; - - length = self->size - IPMPXDATA_TAG_LEN_SIZE; - vals[ 3 ] = (u8) (length & 0x7f); length >>= 7; - vals[ 2 ] = (u8) ((length & 0x7f) | 0x80); length >>= 7; - vals[ 1 ] = (u8) ((length & 0x7f) | 0x80); length >>= 7; - vals[ 0 ] = (u8) ((length & 0x7f) | 0x80); - PUT8( tag ); - PUT8_V( vals[0] ); - PUT8_V( vals[1] ); - PUT8_V( vals[2] ); - PUT8_V( vals[3] ); - PUT8( version ); + MP4Err err; + u32 length; + u8 vals[4]; + err = MP4NoErr; + + self->bytesWritten = 0; + + length = self->size - IPMPXDATA_TAG_LEN_SIZE; + vals[3] = (u8)(length & 0x7f); + length >>= 7; + vals[2] = (u8)((length & 0x7f) | 0x80); + length >>= 7; + vals[1] = (u8)((length & 0x7f) | 0x80); + length >>= 7; + vals[0] = (u8)((length & 0x7f) | 0x80); + PUT8(tag); + PUT8_V(vals[0]); + PUT8_V(vals[1]); + PUT8_V(vals[2]); + PUT8_V(vals[3]); + PUT8(version); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4IPMPXData.h b/IsoLib/libisomediafile/src/MP4IPMPXData.h index 9c97e41..82d8ed2 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPXData.h +++ b/IsoLib/libisomediafile/src/MP4IPMPXData.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. @@ -26,93 +26,95 @@ derivative works. Copyright (c) 1999, 2000. #include "MP4LinkedList.h" #include "MP4InputStream.h" -enum +enum { - MP4IPMP_OpaqueDataTag = 0x01, - MP4IPMP_AudioWatermarkingInitTag= 0x02, - MP4IPMP_VideoWatermarkingInitTag= 0x03, - MP4IPMP_SelectiveDecryptionInitTag= 0x04, - MP4IPMP_KeyDataTag= 0x05, - MP4IPMP_SendAudioWatermarkTag= 0x06, - MP4IPMP_SendVideoWatermarkTag= 0x07, - MP4IPMP_RightsDataTag= 0x08, - MP4IPMP_Secure_ContainerTag = 0x09, - MP4IPMP_AddToolNotificationListenerTag = 0x0A, - MP4IPMP_RemoveToolNotificationListenerTag = 0x0B, - MP4IPMP_InitAuthenticationTag = 0x0C, - MP4IPMP_MutualAuthenticationTag = 0x0D, - MP4IPMP_UserQueryTag = 0x0E, - MP4IPMP_UserQueryResponseTag = 0x0F, - MP4IPMP_ToolParamCapabilitiesQueryTag = 0x10, - MP4IPMP_ToolParamCapabilitiesResponseTag = 0x11, - MP4IPMP_GetToolsTag = 0x12, - MP4IPMP_GetToolsResponseTag = 0x13, - MP4IPMP_GetToolContextTag = 0x14, - MP4IPMP_GetToolContextResponseTag = 0x15, - MP4IPMP_ConnectToolTag = 0x16, - MP4IPMP_DisconnectToolTag = 0x17, - MP4IPMP_NotifyToolEventTag = 0x18, - MP4IPMP_CanProcessTag = 0x19 + MP4IPMP_OpaqueDataTag = 0x01, + MP4IPMP_AudioWatermarkingInitTag = 0x02, + MP4IPMP_VideoWatermarkingInitTag = 0x03, + MP4IPMP_SelectiveDecryptionInitTag = 0x04, + MP4IPMP_KeyDataTag = 0x05, + MP4IPMP_SendAudioWatermarkTag = 0x06, + MP4IPMP_SendVideoWatermarkTag = 0x07, + MP4IPMP_RightsDataTag = 0x08, + MP4IPMP_Secure_ContainerTag = 0x09, + MP4IPMP_AddToolNotificationListenerTag = 0x0A, + MP4IPMP_RemoveToolNotificationListenerTag = 0x0B, + MP4IPMP_InitAuthenticationTag = 0x0C, + MP4IPMP_MutualAuthenticationTag = 0x0D, + MP4IPMP_UserQueryTag = 0x0E, + MP4IPMP_UserQueryResponseTag = 0x0F, + MP4IPMP_ToolParamCapabilitiesQueryTag = 0x10, + MP4IPMP_ToolParamCapabilitiesResponseTag = 0x11, + MP4IPMP_GetToolsTag = 0x12, + MP4IPMP_GetToolsResponseTag = 0x13, + MP4IPMP_GetToolContextTag = 0x14, + MP4IPMP_GetToolContextResponseTag = 0x15, + MP4IPMP_ConnectToolTag = 0x16, + MP4IPMP_DisconnectToolTag = 0x17, + MP4IPMP_NotifyToolEventTag = 0x18, + MP4IPMP_CanProcessTag = 0x19 }; #define IPMPXDATA_TAG_LEN_SIZE 5 typedef struct MP4IPMPByteArrayRecord { - u32 size; - char* data; + u32 size; + char *data; } MP4IPMPByteArray, *MP4IPMPByteArrayPtr; typedef struct MP4IPMPToolIdRecord { - u64 upperPart; - u64 lowerPart; + u64 upperPart; + u64 lowerPart; } MP4IPMPToolId, *MP4IPMPToolIdPtr; -#define MP4_IPMPX_DATA_BASE \ - u32 tag; \ - u32 size; \ - u8 version; \ - char* name; \ - u32 bytesRead; \ - u32 bytesWritten; \ - MP4Err (*createFromInputStream)( struct MP4IPMPXDataRecord* self, struct MP4InputStreamRecord* inputStream ); \ - MP4Err (*serialize)( struct MP4IPMPXDataRecord* self, char* buffer ); \ - MP4Err (*calculateSize)( struct MP4IPMPXDataRecord* self ); \ - void (*destroy)( struct MP4IPMPXDataRecord* self ); +#define MP4_IPMPX_DATA_BASE \ + u32 tag; \ + u32 size; \ + u8 version; \ + char *name; \ + u32 bytesRead; \ + u32 bytesWritten; \ + MP4Err (*createFromInputStream)(struct MP4IPMPXDataRecord * self, \ + struct MP4InputStreamRecord * inputStream); \ + MP4Err (*serialize)(struct MP4IPMPXDataRecord * self, char *buffer); \ + MP4Err (*calculateSize)(struct MP4IPMPXDataRecord * self); \ + void (*destroy)(struct MP4IPMPXDataRecord * self); typedef struct MP4IPMPXDataRecord { - MP4_IPMPX_DATA_BASE + MP4_IPMPX_DATA_BASE } MP4IPMPXData, *MP4IPMPXDataPtr; typedef struct MP4IPMPXDefaultDataRecord { - MP4_IPMPX_DATA_BASE - u32 dataLength; - char* data; + MP4_IPMPX_DATA_BASE + u32 dataLength; + char *data; } MP4IPMPXDefaultData, *MP4IPMPXDefaultDataPtr; typedef struct MP4IPMPInitializeRecord { - u32 size; - char *name; - u32 bytesRead; - u32 bytesWritten; - u8 controlPointCode; - u8 sequenceCode; - MP4LinkedList ipmpxData; - MP4Err (*createFromInputStream)( struct MP4IPMPInitializeRecord* self, struct MP4InputStreamRecord* inputStream ); - MP4Err (*serialize)( struct MP4IPMPInitializeRecord* self, char* buffer ); - MP4Err (*calculateSize)( struct MP4IPMPInitializeRecord* self ); - void (*destroy)( struct MP4IPMPInitializeRecord* self ); - MP4Err (*addIPMPXData)( struct MP4IPMPInitializeRecord *self, MP4IPMPXDataPtr data ); + u32 size; + char *name; + u32 bytesRead; + u32 bytesWritten; + u8 controlPointCode; + u8 sequenceCode; + MP4LinkedList ipmpxData; + MP4Err (*createFromInputStream)(struct MP4IPMPInitializeRecord *self, + struct MP4InputStreamRecord *inputStream); + MP4Err (*serialize)(struct MP4IPMPInitializeRecord *self, char *buffer); + MP4Err (*calculateSize)(struct MP4IPMPInitializeRecord *self); + void (*destroy)(struct MP4IPMPInitializeRecord *self); + MP4Err (*addIPMPXData)(struct MP4IPMPInitializeRecord *self, MP4IPMPXDataPtr data); } MP4IPMPInitialize, *MP4IPMPInitializePtr; -MP4Err MP4ParseIPMPXData( struct MP4InputStreamRecord* inputStream, MP4IPMPXDataPtr *outData ); +MP4Err MP4ParseIPMPXData(struct MP4InputStreamRecord *inputStream, MP4IPMPXDataPtr *outData); -MP4Err MP4EncodeBaseIPMPXData( struct MP4IPMPXDataRecord* self, char* buffer ); +MP4Err MP4EncodeBaseIPMPXData(struct MP4IPMPXDataRecord *self, char *buffer); -MP4Err MP4CreateIPMPInitialize( MP4IPMPInitializePtr *outIpmpInit ); -MP4Err MP4CreateIPMPXDefaultData( u32 tag, u32 size, u32 bytesRead, MP4IPMPXDataPtr *outData ); +MP4Err MP4CreateIPMPInitialize(MP4IPMPInitializePtr *outIpmpInit); +MP4Err MP4CreateIPMPXDefaultData(u32 tag, u32 size, u32 bytesRead, MP4IPMPXDataPtr *outData); #endif diff --git a/IsoLib/libisomediafile/src/MP4IPMPXDefaultData.c b/IsoLib/libisomediafile/src/MP4IPMPXDefaultData.c index 0fcd059..e48271d 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPXDefaultData.c +++ b/IsoLib/libisomediafile/src/MP4IPMPXDefaultData.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -24,94 +24,91 @@ derivative works. Copyright (c) 1999. #include "MP4IPMPXData.h" #include -static MP4Err calculateSize( struct MP4IPMPXDataRecord* s ) +static MP4Err calculateSize(struct MP4IPMPXDataRecord *s) { - MP4Err err; + MP4Err err; - MP4IPMPXDefaultDataPtr self = (MP4IPMPXDefaultDataPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - self->size = 6; /* tag + length word + version */ - self->size += self->dataLength; + MP4IPMPXDefaultDataPtr self = (MP4IPMPXDefaultDataPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + self->size = 6; /* tag + length word + version */ + self->size += self->dataLength; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4IPMPXDataRecord* s, char* buffer ) +static MP4Err serialize(struct MP4IPMPXDataRecord *s, char *buffer) { - MP4Err err; + MP4Err err; - MP4IPMPXDefaultDataPtr self = (MP4IPMPXDefaultDataPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4EncodeBaseIPMPXData( s, buffer ); if (err) goto bail; - buffer += IPMPXDATA_TAG_LEN_SIZE + 1; /* +1 for self->version */ - PUTBYTES( self->data, self->dataLength ); + MP4IPMPXDefaultDataPtr self = (MP4IPMPXDefaultDataPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + err = MP4EncodeBaseIPMPXData(s, buffer); + if(err) goto bail; + buffer += IPMPXDATA_TAG_LEN_SIZE + 1; /* +1 for self->version */ + PUTBYTES(self->data, self->dataLength); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4IPMPXDataRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4IPMPXDataRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; + MP4Err err; - MP4IPMPXDefaultDataPtr self = (MP4IPMPXDefaultDataPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - self->dataLength = self->size - self->bytesRead; - self->data = (char*) calloc( 1, self->dataLength ); - TESTMALLOC( self->data ); - GETBYTES( self->dataLength, data ); + MP4IPMPXDefaultDataPtr self = (MP4IPMPXDefaultDataPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + self->dataLength = self->size - self->bytesRead; + self->data = (char *)calloc(1, self->dataLength); + TESTMALLOC(self->data); + GETBYTES(self->dataLength, data); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static void destroy( struct MP4IPMPXDataRecord* s ) +static void destroy(struct MP4IPMPXDataRecord *s) { - MP4Err err; + MP4Err err; - MP4IPMPXDefaultDataPtr self = (MP4IPMPXDefaultDataPtr) s; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ); - if ( self->data ) - { - free( self->data ); - self->data = NULL; - } - free( s ); + MP4IPMPXDefaultDataPtr self = (MP4IPMPXDefaultDataPtr)s; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + if(self->data) + { + free(self->data); + self->data = NULL; + } + free(s); bail: - return; + return; } -MP4Err MP4CreateIPMPXDefaultData( u32 tag, u32 size, u32 bytesRead, MP4IPMPXDataPtr *outData ) +MP4Err MP4CreateIPMPXDefaultData(u32 tag, u32 size, u32 bytesRead, MP4IPMPXDataPtr *outData) { - MP4Err err; - MP4IPMPXDefaultDataPtr self; - err = MP4NoErr; - self = (MP4IPMPXDefaultDataPtr) calloc( 1, sizeof(MP4IPMPXDefaultData) ); - TESTMALLOC( self ); - self->tag = tag; - self->size = size; - self->name = "MP4IPMPXDefaultData"; - self->bytesRead = bytesRead; - self->createFromInputStream = createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->destroy = destroy; - *outData = (MP4IPMPXDataPtr) self; + MP4Err err; + MP4IPMPXDefaultDataPtr self; + err = MP4NoErr; + self = (MP4IPMPXDefaultDataPtr)calloc(1, sizeof(MP4IPMPXDefaultData)); + TESTMALLOC(self); + self->tag = tag; + self->size = size; + self->name = "MP4IPMPXDefaultData"; + self->bytesRead = bytesRead; + self->createFromInputStream = createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->destroy = destroy; + *outData = (MP4IPMPXDataPtr)self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/MP4Impl.h b/IsoLib/libisomediafile/src/MP4Impl.h index c4f1a84..8209041 100644 --- a/IsoLib/libisomediafile/src/MP4Impl.h +++ b/IsoLib/libisomediafile/src/MP4Impl.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4Impl.h,v 1.3 2002/10/01 12:49:19 julien Exp $ + $Id: MP4Impl.h,v 1.3 2002/10/01 12:49:19 julien Exp $ */ #ifndef INCLUDED_MP4IMPL_H #define INCLUDED_MP4IMPL_H @@ -32,632 +32,692 @@ derivative works. Copyright (c) 1999. #endif #ifndef NULL - #define NULL 0 +#define NULL 0 #endif -#define TESTMALLOC(ptr) \ - if ( (ptr) == 0 ) \ - { \ - err = MP4NoMemoryErr; \ - goto bail; \ - } +#define TESTMALLOC(ptr) \ + if((ptr) == 0) \ + { \ + err = MP4NoMemoryErr; \ + goto bail; \ + } #define BAILWITHERROR(v) \ - { \ - err = (v); \ - goto bail; \ - } - -#define TEST_ATOM_TYPE( atomName ) \ - if ( self->type != atomName ## Type ) \ - { \ - err = MP4BadParamErr; \ - goto bail; \ - } \ - -#define DEBUG_MSG( str ) \ - inputStream->msg( inputStream, str ); - -#define DEBUG_SPRINTF( fmt, var ) \ - { \ - char buf[ 80 ]; \ - sprintf( buf, fmt, (var) ); \ - inputStream->msg( inputStream, buf ); \ - } - -#define GETBYTES( length, membername ) \ - err = inputStream->readData( inputStream, length, self->membername, #membername ); if (err) goto bail; \ - self->bytesRead += length - -#define GETBYTES_V( length, var ) \ - err = inputStream->readData( inputStream, length, var, NULL ); if (err) goto bail; \ - self->bytesRead += length - -#define GETBYTES_MSG( length, membername, msg ) \ - err = inputStream->readData( inputStream, length, self->membername, msg ); if (err) goto bail; \ - self->bytesRead += length - -#define GETBYTES_V_MSG( length, var, msg ) \ - err = inputStream->readData( inputStream, length, var, msg ); if (err) goto bail; \ - self->bytesRead += length - -#define GET64( membername ) \ - { \ - u64 val64; \ - u32 val32; \ - err = inputStream->read32( inputStream, (u32 *) &val32, #membername ); if (err) goto bail; \ - val64 = val32; \ - val64 <<= 32; \ - err = inputStream->read32( inputStream, (u32 *) &val32, #membername ); if (err) goto bail; \ - val64 += val32; \ - self->membername = val64; \ - } \ - self->bytesRead += 8 - -#define GET64_MSG( membername, msg ) \ - { \ - u64 val64; \ - u32 val32; \ - err = inputStream->read32( inputStream, (u32 *) &val32, msg ); if (err) goto bail; \ - val64 = val32; \ - val64 <<= 32; \ - err = inputStream->read32( inputStream, (u32 *) &val32, msg ); if (err) goto bail; \ - val64 += val32; \ - self->membername = val64; \ - } \ - self->bytesRead += 8 - -#define GET64_V( varname ) \ - { \ - u64 val64; \ - u32 val32; \ - err = inputStream->read32( inputStream, (u32 *) &val32, #varname ); if (err) goto bail; \ - val64 = val32; \ - val64 <<= 32; \ - err = inputStream->read32( inputStream, (u32 *) &val32, #varname ); if (err) goto bail; \ - val64 += val32; \ - varname = val64; \ - } \ - self->bytesRead += 8 - -#define GET64_V_MSG( varname, msg ) \ - { \ - u64 val64; \ - u32 val32; \ - err = inputStream->read32( inputStream, (u32 *) &val32, msg ); if (err) goto bail; \ - val64 = val32; \ - val64 <<= 32; \ - err = inputStream->read32( inputStream, (u32 *) &val32, msg ); if (err) goto bail; \ - val64 += val32; \ - varname = val64; \ - } \ - self->bytesRead += 8 - -#define GET32( membername ) \ - err = inputStream->read32( inputStream, (u32 *) &self->membername, #membername ); if (err) goto bail; \ - self->bytesRead += 4 - -#define GET32_MSG( membername, msg ) \ - err = inputStream->read32( inputStream, (u32 *) &self->membername, msg ); if (err) goto bail; \ - self->bytesRead += 4 - -#define GET32_V( varname ) \ - err = inputStream->read32( inputStream, (u32 *) &varname, #varname ); if (err) goto bail; \ - self->bytesRead += 4 - -#define GET32_V_MSG( varname, msg ) \ - err = inputStream->read32( inputStream, (u32 *) &varname, msg ); if (err) goto bail; \ - self->bytesRead += 4 - -#define GET16( membername ) \ - err = inputStream->read16( inputStream, (u32 *) &self->membername, #membername ); if (err) goto bail; \ - self->bytesRead += 2 - -#define GET16_MSG( membername, msg ) \ - err = inputStream->read16( inputStream, (u32 *) &self->membername, msg ); if (err) goto bail; \ - self->bytesRead += 2 - -#define GET16_V( varname ) \ - err = inputStream->read16( inputStream, (u32 *) &varname , #varname); if (err) goto bail; \ - self->bytesRead += 2 - -#define GET16_V_MSG( varname, msg ) \ - err = inputStream->read16( inputStream, (u32 *) &varname , msg ); if (err) goto bail; \ - self->bytesRead += 2 - -#define GET8( membername ) \ - err = inputStream->read8( inputStream, (u32 *) &self->membername, #membername ); if (err) goto bail; \ - self->bytesRead += 1 - -#define GET8_MSG( membername, msg ) \ - err = inputStream->read8( inputStream, (u32 *) &self->membername, msg ); if (err) goto bail; \ - self->bytesRead += 1 - -#define GET8_V( varname ) \ - err = inputStream->read8( inputStream, (u32 *) &varname, #varname ); if (err) goto bail; \ - self->bytesRead += 1 - -#define GET8_V_MSG( varname, msg ) \ - err = inputStream->read8( inputStream, (u32 *) &varname, msg ); if (err) goto bail; \ - self->bytesRead += 1 - -#define GETATOM(membername) \ - err = MP4ParseAtom( inputStream, &self->membername ); if (err) goto bail; \ - self->bytesRead += self->membername->size; - -#define GETATOM_V(varname) \ - err = MP4ParseAtom( inputStream, &varname ); if (err) goto bail; \ - self->bytesRead += varname->size; - -#define GETATOM_LIST(listname) \ - { while (self->bytesRead < self->size) { \ - MP4AtomPtr atm; \ - err = MP4ParseAtom( inputStream, &atm ); if (err) goto bail; \ - self->bytesRead += atm->size; \ - if ( ((atm->type)== MP4FreeSpaceAtomType) || ((atm->type)== MP4SkipAtomType)) \ - atm->destroy( atm ); \ - else { err = MP4AddListEntry( (void*) atm, self->listname ); if (err) goto bail; } \ - } } - -#define PUTBYTES( src, len ) \ - if ( (self->bytesWritten + len) > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - memcpy( buffer, src, len ); \ - buffer += len; \ - self->bytesWritten += len - -#define PUT8( member ) \ - if ( (self->bytesWritten + 1) > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - *(u8*) buffer = (u8) self->member; \ - buffer += 1; \ - self->bytesWritten += 1 - -#define PUT8_V( var ) \ - if ( (self->bytesWritten + 1) > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - *(u8*) buffer = (u8) (var); \ - buffer += 1; \ - self->bytesWritten += 1 - -#define PUT16( member ) \ - if ( (self->bytesWritten + 2) > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - *(u8*) buffer = (u8) ((self->member >> 8) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) (self->member & 0xff); \ - buffer += 1; \ - self->bytesWritten += 2 - -#define PUT16_V( var ) \ - if ( (self->bytesWritten + 2) > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - *(u8*) buffer = (u8) ((var >> 8) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) (var & 0xff); \ - buffer += 1; \ - self->bytesWritten += 2 - -#define PUT24( member ) \ - if ( (self->bytesWritten + 3) > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - *(u8*) buffer = (u8) ((self->member >> 16) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((self->member >> 8) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) (self->member & 0xff); \ - buffer += 1; \ - self->bytesWritten += 3 - -#define PUT24_V( var ) \ - if ( (self->bytesWritten + 3) > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - *(u8*) buffer = (u8) ((var >> 16) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((var >> 8) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) (var & 0xff); \ - buffer += 1; \ - self->bytesWritten += 3 - -#define PUT32( member ) \ - if ( (self->bytesWritten + 4) > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - *(u8*) buffer = (u8) ((self->member >> 24) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((self->member >> 16) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((self->member >> 8) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) (self->member & 0xff); \ - buffer += 1; \ - self->bytesWritten += 4 - -#define PUT32_V( var ) \ - if ( (self->bytesWritten + 4) > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - *(u8*) buffer = (u8) ((var >> 24) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((var >> 16) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((var >> 8) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) (var & 0xff); \ - buffer += 1; \ - self->bytesWritten += 4 - -#define PUT64( member ) \ - if ( (self->bytesWritten + 8) > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - *(u8*) buffer = (u8) ((self->member >> 56) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((self->member >> 48) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((self->member >> 40) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((self->member >> 32) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((self->member >> 24) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((self->member >> 16) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((self->member >> 8) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) (self->member & 0xff); \ - buffer += 1; \ - self->bytesWritten += 8 - -#define PUT64_V( var ) \ - if ( (self->bytesWritten + 8) > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - *(u8*) buffer = (u8) ((var >> 56) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((var >> 48) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((var >> 40) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((var >> 32) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((var >> 24) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((var >> 16) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) ((var >> 8) & 0xff); \ - buffer += 1; \ - *(u8*) buffer = (u8) (var & 0xff); \ - buffer += 1; \ - self->bytesWritten += 8 - -#define ADD_DESCRIPTOR_SIZE( descName ) \ - if ( self->descName ) \ - { \ - err = self->descName->calculateSize( self->descName ); if (err) goto bail; \ - self->size += self->descName->size; \ - } \ - -#define ADD_ATOM_SIZE( descName ) \ - if ( self->descName ) \ - { \ - err = self->descName->calculateSize( self->descName ); if (err) goto bail; \ - self->size += self->descName->size; \ - } \ - - -#define ADD_DESCRIPTOR_LIST_SIZE( listName ) \ - if ( self->listName ) \ - { \ - err = MP4GetListEntryCount( self->listName, &count ); if (err) goto bail; \ - for ( i = 0; i < count; i++ ) \ - { \ - err = MP4GetListEntry( self->listName, i, (char **) &desc ); if (err) goto bail; \ - if ( desc ) \ - { \ - err = desc->calculateSize( desc ); if (err) goto bail; \ - self->size += desc->size; \ - } \ - } \ - } \ - -#define ADD_ATOM_LIST_SIZE( listName ) \ - if ( self->listName ) \ - { \ - u32 count; \ - u32 i; \ - err = MP4GetListEntryCount( self->listName, &count ); if (err) goto bail; \ - for ( i = 0; i < count; i++ ) \ - { \ - MP4AtomPtr desc; \ - err = MP4GetListEntry( self->listName, i, (char **) &desc ); if (err) goto bail; \ - if ( desc ) \ - { \ - err = desc->calculateSize( desc ); if (err) goto bail; \ - self->size += desc->size; \ - } \ - } \ - } \ - - -#define ADD_ATOM_LIST_SIZE_V( listName ) \ - if ( listName ) \ - { \ - u32 count; \ - u32 i; \ - err = MP4GetListEntryCount( listName, &count ); if (err) goto bail; \ - for ( i = 0; i < count; i++ ) \ - { \ - MP4AtomPtr desc; \ - err = MP4GetListEntry( listName, i, (char **) &desc ); if (err) goto bail; \ - if ( desc ) \ - { \ - err = desc->calculateSize( desc ); if (err) goto bail; \ - self->size += desc->size; \ - } \ - } \ - } \ - -#define SERIALIZE_DESCRIPTOR( desc ) \ - if ( self->desc ) \ - { \ - if ( self->bytesWritten + self->desc->size > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - err = self->desc->serialize( self->desc, buffer ); if (err) goto bail; \ - buffer += self->desc->bytesWritten; \ - self->bytesWritten += self->desc->bytesWritten; \ - } - -#define SERIALIZE_ATOM( desc ) \ - if ( self->desc ) \ - { \ - if ( self->bytesWritten + self->desc->size > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - err = self->desc->serialize( self->desc, buffer ); if (err) goto bail; \ - buffer += self->desc->bytesWritten; \ - self->bytesWritten += self->desc->bytesWritten; \ - } - -#define SERIALIZE_DESCRIPTOR_LIST( listName ) \ - if ( self->listName ) \ - { \ - u32 count; \ - u32 i; \ - struct MP4DescriptorRecord* desc; \ - err = MP4GetListEntryCount( self->listName, &count ); if (err) goto bail; \ - for ( i = 0; i < count; i++ ) \ - { \ - err = MP4GetListEntry( self->listName, i, (char **) &desc ); if (err) goto bail; \ - if ( desc ) \ - { \ - if ( self->bytesWritten + desc->size > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - err = desc->serialize( desc, buffer ); if (err) goto bail; \ - self->bytesWritten += desc->bytesWritten; \ - buffer += desc->bytesWritten; \ - } \ - } \ - } - -#define SERIALIZE_ATOM_LIST( listName ) \ - if ( self->listName ) \ - { \ - u32 count; \ - u32 i; \ - struct MP4Atom* desc; \ - err = MP4GetListEntryCount( self->listName, &count ); if (err) goto bail; \ - for ( i = 0; i < count; i++ ) \ - { \ - err = MP4GetListEntry( self->listName, i, (char **) &desc ); if (err) goto bail; \ - if ( desc ) \ - { \ - if ( self->bytesWritten + desc->size > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - err = desc->serialize( desc, buffer ); if (err) goto bail; \ - self->bytesWritten += desc->bytesWritten; \ - buffer += desc->bytesWritten; \ - } \ - } \ - } - -#define SERIALIZE_ATOM_LIST_V( listName ) \ - if ( listName ) \ - { \ - u32 count; \ - u32 i; \ - struct MP4Atom* desc; \ - err = MP4GetListEntryCount( listName, &count ); if (err) goto bail; \ - for ( i = 0; i < count; i++ ) \ - { \ - err = MP4GetListEntry( listName, i, (char **) &desc ); if (err) goto bail; \ - if ( desc ) \ - { \ - if ( self->bytesWritten + desc->size > self->size ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } \ - err = desc->serialize( desc, buffer ); if (err) goto bail; \ - self->bytesWritten += desc->bytesWritten; \ - buffer += desc->bytesWritten; \ - } \ - } \ - } - - -#define IMPLEMENT_NEW_ADDATOM(atomname) \ -static MP4Err addAtom( atomname ## Ptr self, MP4AtomPtr atom ) \ -{\ - MP4Err err;\ - err = MP4AddListEntry( atom, self->atomList); \ - return err; \ -} - -#define PARSE_ATOM_INCLUDES(atomname) \ - while ( self->bytesRead < self->size ) \ - { \ - MP4AtomPtr atom; \ - err = MP4ParseAtom( (MP4InputStreamPtr) inputStream, &atom ); \ - if (err) goto bail; \ - self->bytesRead += atom->size; \ - if ( ((atom->type)== MP4FreeSpaceAtomType) || ((atom->type)== MP4SkipAtomType)) \ - atom->destroy( atom ); \ - else { \ - err = addAtom( self, atom ); \ - if (err) goto bail; \ - } \ - } \ - if ( self->bytesRead != self->size ) \ - BAILWITHERROR( MP4BadDataErr ) - -#define PARSE_ATOM_LIST(atomname) \ - MP4Err err; \ - atomname ## Ptr self = (atomname ## Ptr) s; \ - err = MP4NoErr; \ - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) \ - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; \ - PARSE_ATOM_INCLUDES(atomname) - - -#define DESTROY_ATOM_LIST \ - if ( self->atomList ) \ - { \ - u32 atomListSize; \ - err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; \ - for ( i = 0; i < atomListSize; i++ ) \ - { \ - MP4AtomPtr a; \ - err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; \ - if ( a ) \ - a->destroy( a ); \ - } \ - err = MP4DeleteLinkedList( self->atomList ); if (err) goto bail; \ - } - -#define DESTROY_ATOM_LIST_V( atomList ) \ - if ( atomList ) \ - { \ - u32 atomListSize; \ - err = MP4GetListEntryCount( atomList, &atomListSize ); if (err) goto bail; \ - for ( i = 0; i < atomListSize; i++ ) \ - { \ - MP4AtomPtr a; \ - err = MP4GetListEntry( atomList, i, (char **) &a ); if (err) goto bail; \ - if ( a ) \ - a->destroy( a ); \ - } \ - err = MP4DeleteLinkedList( atomList ); if (err) goto bail; \ - } - -#define DESTROY_ATOM_LIST_F( atomList ) \ - if ( self->atomList ) \ - { \ - u32 atomListSize, i; \ - err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; \ - for ( i = 0; i < atomListSize; i++ ) \ - { \ - MP4AtomPtr a; \ - err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; \ - if ( a ) \ - a->destroy( a ); \ - } \ - err = MP4DeleteLinkedList( self->atomList ); if (err) goto bail; \ - } - -#define SETUP_BASE_DESCRIPTOR( classname ) \ - MP4Err err; \ - classname ## Ptr self; \ - err = MP4NoErr; \ - self = (classname ## Ptr) calloc( 1, sizeof(classname) ); \ - TESTMALLOC( self ) \ - self->tag = tag; \ - self->size = size; \ - self->name = #classname; \ - self->bytesRead = bytesRead; \ - self->createFromInputStream = createFromInputStream; \ - self->calculateSize = calculateSize; \ - self->serialize = serialize; \ - self->destroy = destroy; - -#define DESTROY_DESCRIPTOR( member ) \ - if ( self->member ) \ - self->member->destroy( self->member ) - -#define DESTROY_DESCRIPTOR_LIST( list ) \ - if ( self->list ) \ - { \ - MP4Err err; \ - u32 listSize; \ - u32 i; \ - err = MP4GetListEntryCount( self->list, &listSize ); if (err) goto bail; \ - for ( i = 0; i < listSize; i++ ) \ - { \ - MP4DescriptorPtr a; \ - err = MP4GetListEntry( self->list, i, (char **) &a ); if (err) goto bail; \ - if ( a ) \ - a->destroy( a ); \ - } \ - err = MP4DeleteLinkedList( self->list ); if (err) goto bail; \ - } - -#define DESTROY_DESCRIPTOR_LIST_V( list ) \ - if ( list ) \ - { \ - MP4Err err; \ - u32 listSize; \ - u32 i; \ - err = MP4GetListEntryCount( list, &listSize ); if (err) goto bail; \ - for ( i = 0; i < listSize; i++ ) \ - { \ - MP4DescriptorPtr a; \ - err = MP4GetListEntry( list, i, (char **) &a ); if (err) goto bail; \ - if ( a ) \ - a->destroy( a ); \ - } \ - err = MP4DeleteLinkedList( list ); if (err) goto bail; \ - } - + { \ + err = (v); \ + goto bail; \ + } + +#define TEST_ATOM_TYPE(atomName) \ + if(self->type != atomName##Type) \ + { \ + err = MP4BadParamErr; \ + goto bail; \ + } + +#define DEBUG_MSG(str) inputStream->msg(inputStream, str); + +#define DEBUG_SPRINTF(fmt, var) \ + { \ + char buf[80]; \ + sprintf(buf, fmt, (var)); \ + inputStream->msg(inputStream, buf); \ + } + +#define GETBYTES(length, membername) \ + err = inputStream->readData(inputStream, length, self->membername, #membername); \ + if(err) goto bail; \ + self->bytesRead += length + +#define GETBYTES_V(length, var) \ + err = inputStream->readData(inputStream, length, var, NULL); \ + if(err) goto bail; \ + self->bytesRead += length + +#define GETBYTES_MSG(length, membername, msg) \ + err = inputStream->readData(inputStream, length, self->membername, msg); \ + if(err) goto bail; \ + self->bytesRead += length + +#define GETBYTES_V_MSG(length, var, msg) \ + err = inputStream->readData(inputStream, length, var, msg); \ + if(err) goto bail; \ + self->bytesRead += length + +#define GET64(membername) \ + { \ + u64 val64; \ + u32 val32; \ + err = inputStream->read32(inputStream, (u32 *)&val32, #membername); \ + if(err) goto bail; \ + val64 = val32; \ + val64 <<= 32; \ + err = inputStream->read32(inputStream, (u32 *)&val32, #membername); \ + if(err) goto bail; \ + val64 += val32; \ + self->membername = val64; \ + } \ + self->bytesRead += 8 + +#define GET64_MSG(membername, msg) \ + { \ + u64 val64; \ + u32 val32; \ + err = inputStream->read32(inputStream, (u32 *)&val32, msg); \ + if(err) goto bail; \ + val64 = val32; \ + val64 <<= 32; \ + err = inputStream->read32(inputStream, (u32 *)&val32, msg); \ + if(err) goto bail; \ + val64 += val32; \ + self->membername = val64; \ + } \ + self->bytesRead += 8 + +#define GET64_V(varname) \ + { \ + u64 val64; \ + u32 val32; \ + err = inputStream->read32(inputStream, (u32 *)&val32, #varname); \ + if(err) goto bail; \ + val64 = val32; \ + val64 <<= 32; \ + err = inputStream->read32(inputStream, (u32 *)&val32, #varname); \ + if(err) goto bail; \ + val64 += val32; \ + varname = val64; \ + } \ + self->bytesRead += 8 + +#define GET64_V_MSG(varname, msg) \ + { \ + u64 val64; \ + u32 val32; \ + err = inputStream->read32(inputStream, (u32 *)&val32, msg); \ + if(err) goto bail; \ + val64 = val32; \ + val64 <<= 32; \ + err = inputStream->read32(inputStream, (u32 *)&val32, msg); \ + if(err) goto bail; \ + val64 += val32; \ + varname = val64; \ + } \ + self->bytesRead += 8 + +#define GET32(membername) \ + err = inputStream->read32(inputStream, (u32 *)&self->membername, #membername); \ + if(err) goto bail; \ + self->bytesRead += 4 + +#define GET32_MSG(membername, msg) \ + err = inputStream->read32(inputStream, (u32 *)&self->membername, msg); \ + if(err) goto bail; \ + self->bytesRead += 4 + +#define GET32_V(varname) \ + err = inputStream->read32(inputStream, (u32 *)&varname, #varname); \ + if(err) goto bail; \ + self->bytesRead += 4 + +#define GET32_V_MSG(varname, msg) \ + err = inputStream->read32(inputStream, (u32 *)&varname, msg); \ + if(err) goto bail; \ + self->bytesRead += 4 + +#define GET16(membername) \ + err = inputStream->read16(inputStream, (u32 *)&self->membername, #membername); \ + if(err) goto bail; \ + self->bytesRead += 2 + +#define GET16_MSG(membername, msg) \ + err = inputStream->read16(inputStream, (u32 *)&self->membername, msg); \ + if(err) goto bail; \ + self->bytesRead += 2 + +#define GET16_V(varname) \ + err = inputStream->read16(inputStream, (u32 *)&varname, #varname); \ + if(err) goto bail; \ + self->bytesRead += 2 + +#define GET16_V_MSG(varname, msg) \ + err = inputStream->read16(inputStream, (u32 *)&varname, msg); \ + if(err) goto bail; \ + self->bytesRead += 2 + +#define GET8(membername) \ + err = inputStream->read8(inputStream, (u32 *)&self->membername, #membername); \ + if(err) goto bail; \ + self->bytesRead += 1 + +#define GET8_MSG(membername, msg) \ + err = inputStream->read8(inputStream, (u32 *)&self->membername, msg); \ + if(err) goto bail; \ + self->bytesRead += 1 + +#define GET8_V(varname) \ + err = inputStream->read8(inputStream, (u32 *)&varname, #varname); \ + if(err) goto bail; \ + self->bytesRead += 1 + +#define GET8_V_MSG(varname, msg) \ + err = inputStream->read8(inputStream, (u32 *)&varname, msg); \ + if(err) goto bail; \ + self->bytesRead += 1 + +#define GETATOM(membername) \ + err = MP4ParseAtom(inputStream, &self->membername); \ + if(err) goto bail; \ + self->bytesRead += self->membername->size; + +#define GETATOM_V(varname) \ + err = MP4ParseAtom(inputStream, &varname); \ + if(err) goto bail; \ + self->bytesRead += varname->size; + +#define GETATOM_LIST(listname) \ + { \ + while(self->bytesRead < self->size) \ + { \ + MP4AtomPtr atm; \ + err = MP4ParseAtom(inputStream, &atm); \ + if(err) goto bail; \ + self->bytesRead += atm->size; \ + if(((atm->type) == MP4FreeSpaceAtomType) || ((atm->type) == MP4SkipAtomType)) \ + atm->destroy(atm); \ + else \ + { \ + err = MP4AddListEntry((void *)atm, self->listname); \ + if(err) goto bail; \ + } \ + } \ + } + +#define PUTBYTES(src, len) \ + if((self->bytesWritten + len) > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + memcpy(buffer, src, len); \ + buffer += len; \ + self->bytesWritten += len + +#define PUT8(member) \ + if((self->bytesWritten + 1) > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + *(u8 *)buffer = (u8)self->member; \ + buffer += 1; \ + self->bytesWritten += 1 + +#define PUT8_V(var) \ + if((self->bytesWritten + 1) > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + *(u8 *)buffer = (u8)(var); \ + buffer += 1; \ + self->bytesWritten += 1 + +#define PUT16(member) \ + if((self->bytesWritten + 2) > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + *(u8 *)buffer = (u8)((self->member >> 8) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)(self->member & 0xff); \ + buffer += 1; \ + self->bytesWritten += 2 + +#define PUT16_V(var) \ + if((self->bytesWritten + 2) > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + *(u8 *)buffer = (u8)((var >> 8) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)(var & 0xff); \ + buffer += 1; \ + self->bytesWritten += 2 + +#define PUT24(member) \ + if((self->bytesWritten + 3) > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + *(u8 *)buffer = (u8)((self->member >> 16) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((self->member >> 8) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)(self->member & 0xff); \ + buffer += 1; \ + self->bytesWritten += 3 + +#define PUT24_V(var) \ + if((self->bytesWritten + 3) > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + *(u8 *)buffer = (u8)((var >> 16) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((var >> 8) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)(var & 0xff); \ + buffer += 1; \ + self->bytesWritten += 3 + +#define PUT32(member) \ + if((self->bytesWritten + 4) > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + *(u8 *)buffer = (u8)((self->member >> 24) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((self->member >> 16) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((self->member >> 8) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)(self->member & 0xff); \ + buffer += 1; \ + self->bytesWritten += 4 + +#define PUT32_V(var) \ + if((self->bytesWritten + 4) > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + *(u8 *)buffer = (u8)((var >> 24) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((var >> 16) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((var >> 8) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)(var & 0xff); \ + buffer += 1; \ + self->bytesWritten += 4 + +#define PUT64(member) \ + if((self->bytesWritten + 8) > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + *(u8 *)buffer = (u8)((self->member >> 56) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((self->member >> 48) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((self->member >> 40) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((self->member >> 32) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((self->member >> 24) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((self->member >> 16) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((self->member >> 8) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)(self->member & 0xff); \ + buffer += 1; \ + self->bytesWritten += 8 + +#define PUT64_V(var) \ + if((self->bytesWritten + 8) > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + *(u8 *)buffer = (u8)((var >> 56) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((var >> 48) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((var >> 40) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((var >> 32) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((var >> 24) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((var >> 16) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)((var >> 8) & 0xff); \ + buffer += 1; \ + *(u8 *)buffer = (u8)(var & 0xff); \ + buffer += 1; \ + self->bytesWritten += 8 + +#define ADD_DESCRIPTOR_SIZE(descName) \ + if(self->descName) \ + { \ + err = self->descName->calculateSize(self->descName); \ + if(err) goto bail; \ + self->size += self->descName->size; \ + } + +#define ADD_ATOM_SIZE(descName) \ + if(self->descName) \ + { \ + err = self->descName->calculateSize(self->descName); \ + if(err) goto bail; \ + self->size += self->descName->size; \ + } + +#define ADD_DESCRIPTOR_LIST_SIZE(listName) \ + if(self->listName) \ + { \ + err = MP4GetListEntryCount(self->listName, &count); \ + if(err) goto bail; \ + for(i = 0; i < count; i++) \ + { \ + err = MP4GetListEntry(self->listName, i, (char **)&desc); \ + if(err) goto bail; \ + if(desc) \ + { \ + err = desc->calculateSize(desc); \ + if(err) goto bail; \ + self->size += desc->size; \ + } \ + } \ + } + +#define ADD_ATOM_LIST_SIZE(listName) \ + if(self->listName) \ + { \ + u32 count; \ + u32 i; \ + err = MP4GetListEntryCount(self->listName, &count); \ + if(err) goto bail; \ + for(i = 0; i < count; i++) \ + { \ + MP4AtomPtr desc; \ + err = MP4GetListEntry(self->listName, i, (char **)&desc); \ + if(err) goto bail; \ + if(desc) \ + { \ + err = desc->calculateSize(desc); \ + if(err) goto bail; \ + self->size += desc->size; \ + } \ + } \ + } + +#define ADD_ATOM_LIST_SIZE_V(listName) \ + if(listName) \ + { \ + u32 count; \ + u32 i; \ + err = MP4GetListEntryCount(listName, &count); \ + if(err) goto bail; \ + for(i = 0; i < count; i++) \ + { \ + MP4AtomPtr desc; \ + err = MP4GetListEntry(listName, i, (char **)&desc); \ + if(err) goto bail; \ + if(desc) \ + { \ + err = desc->calculateSize(desc); \ + if(err) goto bail; \ + self->size += desc->size; \ + } \ + } \ + } + +#define SERIALIZE_DESCRIPTOR(desc) \ + if(self->desc) \ + { \ + if(self->bytesWritten + self->desc->size > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + err = self->desc->serialize(self->desc, buffer); \ + if(err) goto bail; \ + buffer += self->desc->bytesWritten; \ + self->bytesWritten += self->desc->bytesWritten; \ + } + +#define SERIALIZE_ATOM(desc) \ + if(self->desc) \ + { \ + if(self->bytesWritten + self->desc->size > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + err = self->desc->serialize(self->desc, buffer); \ + if(err) goto bail; \ + buffer += self->desc->bytesWritten; \ + self->bytesWritten += self->desc->bytesWritten; \ + } + +#define SERIALIZE_DESCRIPTOR_LIST(listName) \ + if(self->listName) \ + { \ + u32 count; \ + u32 i; \ + struct MP4DescriptorRecord *desc; \ + err = MP4GetListEntryCount(self->listName, &count); \ + if(err) goto bail; \ + for(i = 0; i < count; i++) \ + { \ + err = MP4GetListEntry(self->listName, i, (char **)&desc); \ + if(err) goto bail; \ + if(desc) \ + { \ + if(self->bytesWritten + desc->size > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + err = desc->serialize(desc, buffer); \ + if(err) goto bail; \ + self->bytesWritten += desc->bytesWritten; \ + buffer += desc->bytesWritten; \ + } \ + } \ + } + +#define SERIALIZE_ATOM_LIST(listName) \ + if(self->listName) \ + { \ + u32 count; \ + u32 i; \ + struct MP4Atom *desc; \ + err = MP4GetListEntryCount(self->listName, &count); \ + if(err) goto bail; \ + for(i = 0; i < count; i++) \ + { \ + err = MP4GetListEntry(self->listName, i, (char **)&desc); \ + if(err) goto bail; \ + if(desc) \ + { \ + if(self->bytesWritten + desc->size > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + err = desc->serialize(desc, buffer); \ + if(err) goto bail; \ + self->bytesWritten += desc->bytesWritten; \ + buffer += desc->bytesWritten; \ + } \ + } \ + } + +#define SERIALIZE_ATOM_LIST_V(listName) \ + if(listName) \ + { \ + u32 count; \ + u32 i; \ + struct MP4Atom *desc; \ + err = MP4GetListEntryCount(listName, &count); \ + if(err) goto bail; \ + for(i = 0; i < count; i++) \ + { \ + err = MP4GetListEntry(listName, i, (char **)&desc); \ + if(err) goto bail; \ + if(desc) \ + { \ + if(self->bytesWritten + desc->size > self->size) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } \ + err = desc->serialize(desc, buffer); \ + if(err) goto bail; \ + self->bytesWritten += desc->bytesWritten; \ + buffer += desc->bytesWritten; \ + } \ + } \ + } + +#define IMPLEMENT_NEW_ADDATOM(atomname) \ + static MP4Err addAtom(atomname##Ptr self, MP4AtomPtr atom) \ + { \ + MP4Err err; \ + err = MP4AddListEntry(atom, self->atomList); \ + return err; \ + } + +#define PARSE_ATOM_INCLUDES(atomname) \ + while(self->bytesRead < self->size) \ + { \ + MP4AtomPtr atom; \ + err = MP4ParseAtom((MP4InputStreamPtr)inputStream, &atom); \ + if(err) goto bail; \ + self->bytesRead += atom->size; \ + if(((atom->type) == MP4FreeSpaceAtomType) || ((atom->type) == MP4SkipAtomType)) \ + atom->destroy(atom); \ + else \ + { \ + err = addAtom(self, atom); \ + if(err) goto bail; \ + } \ + } \ + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr) + +#define PARSE_ATOM_LIST(atomname) \ + MP4Err err; \ + atomname##Ptr self = (atomname##Ptr)s; \ + err = MP4NoErr; \ + if(self == NULL) BAILWITHERROR(MP4BadParamErr) \ + err = self->super->createFromInputStream(s, proto, (char *)inputStream); \ + if(err) goto bail; \ + PARSE_ATOM_INCLUDES(atomname) + +#define DESTROY_ATOM_LIST \ + if(self->atomList) \ + { \ + u32 atomListSize; \ + err = MP4GetListEntryCount(self->atomList, &atomListSize); \ + if(err) goto bail; \ + for(i = 0; i < atomListSize; i++) \ + { \ + MP4AtomPtr a; \ + err = MP4GetListEntry(self->atomList, i, (char **)&a); \ + if(err) goto bail; \ + if(a) a->destroy(a); \ + } \ + err = MP4DeleteLinkedList(self->atomList); \ + if(err) goto bail; \ + } + +#define DESTROY_ATOM_LIST_V(atomList) \ + if(atomList) \ + { \ + u32 atomListSize; \ + err = MP4GetListEntryCount(atomList, &atomListSize); \ + if(err) goto bail; \ + for(i = 0; i < atomListSize; i++) \ + { \ + MP4AtomPtr a; \ + err = MP4GetListEntry(atomList, i, (char **)&a); \ + if(err) goto bail; \ + if(a) a->destroy(a); \ + } \ + err = MP4DeleteLinkedList(atomList); \ + if(err) goto bail; \ + } + +#define DESTROY_ATOM_LIST_F(atomList) \ + if(self->atomList) \ + { \ + u32 atomListSize, i; \ + err = MP4GetListEntryCount(self->atomList, &atomListSize); \ + if(err) goto bail; \ + for(i = 0; i < atomListSize; i++) \ + { \ + MP4AtomPtr a; \ + err = MP4GetListEntry(self->atomList, i, (char **)&a); \ + if(err) goto bail; \ + if(a) a->destroy(a); \ + } \ + err = MP4DeleteLinkedList(self->atomList); \ + if(err) goto bail; \ + } + +#define SETUP_BASE_DESCRIPTOR(classname) \ + MP4Err err; \ + classname##Ptr self; \ + err = MP4NoErr; \ + self = (classname##Ptr)calloc(1, sizeof(classname)); \ + TESTMALLOC(self) \ + self->tag = tag; \ + self->size = size; \ + self->name = #classname; \ + self->bytesRead = bytesRead; \ + self->createFromInputStream = createFromInputStream; \ + self->calculateSize = calculateSize; \ + self->serialize = serialize; \ + self->destroy = destroy; + +#define DESTROY_DESCRIPTOR(member) \ + if(self->member) self->member->destroy(self->member) + +#define DESTROY_DESCRIPTOR_LIST(list) \ + if(self->list) \ + { \ + MP4Err err; \ + u32 listSize; \ + u32 i; \ + err = MP4GetListEntryCount(self->list, &listSize); \ + if(err) goto bail; \ + for(i = 0; i < listSize; i++) \ + { \ + MP4DescriptorPtr a; \ + err = MP4GetListEntry(self->list, i, (char **)&a); \ + if(err) goto bail; \ + if(a) a->destroy(a); \ + } \ + err = MP4DeleteLinkedList(self->list); \ + if(err) goto bail; \ + } + +#define DESTROY_DESCRIPTOR_LIST_V(list) \ + if(list) \ + { \ + MP4Err err; \ + u32 listSize; \ + u32 i; \ + err = MP4GetListEntryCount(list, &listSize); \ + if(err) goto bail; \ + for(i = 0; i < listSize; i++) \ + { \ + MP4DescriptorPtr a; \ + err = MP4GetListEntry(list, i, (char **)&a); \ + if(err) goto bail; \ + if(a) a->destroy(a); \ + } \ + err = MP4DeleteLinkedList(list); \ + if(err) goto bail; \ + } #endif diff --git a/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c b/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c index eb057ca..90aed79 100644 --- a/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,230 +15,244 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4InitialObjectDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4InitialObjectDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include #include -static MP4Err addDescriptor( struct MP4DescriptorRecord* s, MP4DescriptorPtr desc ) +static MP4Err addDescriptor(struct MP4DescriptorRecord *s, MP4DescriptorPtr desc) { - MP4Err err; - MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr) s; - err = MP4NoErr; - switch( desc->tag ) - { - case MP4ES_DescriptorTag: - err = MP4AddListEntry( desc, self->ESDescriptors ); if (err) goto bail; - break; - - case MP4ES_ID_IncDescriptorTag: - err = MP4AddListEntry( desc, self->ES_ID_IncDescriptors ); if (err) goto bail; - break; - - case MP4IPMP_DescriptorPointerTag: - err = MP4AddListEntry( desc, self->IPMPDescriptorPointers ); if (err) goto bail; - break; - - default: - err = MP4AddListEntry( desc, self->extensionDescriptors ); if (err) goto bail; - break; - } + MP4Err err; + MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr)s; + err = MP4NoErr; + switch(desc->tag) + { + case MP4ES_DescriptorTag: + err = MP4AddListEntry(desc, self->ESDescriptors); + if(err) goto bail; + break; + + case MP4ES_ID_IncDescriptorTag: + err = MP4AddListEntry(desc, self->ES_ID_IncDescriptors); + if(err) goto bail; + break; + + case MP4IPMP_DescriptorPointerTag: + err = MP4AddListEntry(desc, self->IPMPDescriptorPointers); + if(err) goto bail; + break; + + default: + err = MP4AddListEntry(desc, self->extensionDescriptors); + if(err) goto bail; + break; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - u32 count; - u32 i; - MP4DescriptorPtr desc; - MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr) s; - err = MP4NoErr; - self->size = DESCRIPTOR_TAG_LEN_SIZE; - self->size += 2; - if ( self->URLStringLength ) - self->size += self->URLStringLength + 1; - else - { - self->size += 5; - ADD_DESCRIPTOR_LIST_SIZE( ESDescriptors ); - ADD_DESCRIPTOR_LIST_SIZE( ES_ID_IncDescriptors ); - ADD_DESCRIPTOR_LIST_SIZE( OCIDescriptors ); - ADD_DESCRIPTOR_LIST_SIZE( IPMPDescriptorPointers ); - } - ADD_DESCRIPTOR_LIST_SIZE( extensionDescriptors ); + MP4Err err; + u32 count; + u32 i; + MP4DescriptorPtr desc; + MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr)s; + err = MP4NoErr; + self->size = DESCRIPTOR_TAG_LEN_SIZE; + self->size += 2; + if(self->URLStringLength) self->size += self->URLStringLength + 1; + else + { + self->size += 5; + ADD_DESCRIPTOR_LIST_SIZE(ESDescriptors); + ADD_DESCRIPTOR_LIST_SIZE(ES_ID_IncDescriptors); + ADD_DESCRIPTOR_LIST_SIZE(OCIDescriptors); + ADD_DESCRIPTOR_LIST_SIZE(IPMPDescriptorPointers); + } + ADD_DESCRIPTOR_LIST_SIZE(extensionDescriptors); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - u16 val; - MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr) s; - err = MP4NoErr; - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - - val = self->objectDescriptorID << 6; - if ( self->URLStringLength ) - val |= (1<<5); - if ( self->inlineProfileFlag ) - val |= (1<<4); - val |= 0xf; - PUT16_V( val ); - - if ( self->URLStringLength ) - { - PUT8( URLStringLength ); - PUTBYTES( self->URLString, self->URLStringLength ); - } - else - { - PUT8( OD_profileAndLevel ); - PUT8( scene_profileAndLevel ); - PUT8( audio_profileAndLevel ); - PUT8( visual_profileAndLevel ); - PUT8( graphics_profileAndLevel ); - SERIALIZE_DESCRIPTOR_LIST( ESDescriptors ); - SERIALIZE_DESCRIPTOR_LIST( ES_ID_IncDescriptors ); - SERIALIZE_DESCRIPTOR_LIST( OCIDescriptors ); - SERIALIZE_DESCRIPTOR_LIST( IPMPDescriptorPointers ); - } - SERIALIZE_DESCRIPTOR_LIST( extensionDescriptors ); - assert( self->bytesWritten == self->size ); + MP4Err err; + u16 val; + MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr)s; + err = MP4NoErr; + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + + val = self->objectDescriptorID << 6; + if(self->URLStringLength) val |= (1 << 5); + if(self->inlineProfileFlag) val |= (1 << 4); + val |= 0xf; + PUT16_V(val); + + if(self->URLStringLength) + { + PUT8(URLStringLength); + PUTBYTES(self->URLString, self->URLStringLength); + } + else + { + PUT8(OD_profileAndLevel); + PUT8(scene_profileAndLevel); + PUT8(audio_profileAndLevel); + PUT8(visual_profileAndLevel); + PUT8(graphics_profileAndLevel); + SERIALIZE_DESCRIPTOR_LIST(ESDescriptors); + SERIALIZE_DESCRIPTOR_LIST(ES_ID_IncDescriptors); + SERIALIZE_DESCRIPTOR_LIST(OCIDescriptors); + SERIALIZE_DESCRIPTOR_LIST(IPMPDescriptorPointers); + } + SERIALIZE_DESCRIPTOR_LIST(extensionDescriptors); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 val; - u32 urlflag; - MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr) s; - err = MP4NoErr; - GET16_V_MSG( val, NULL ); - self->objectDescriptorID = val >> 6; - urlflag = val & (1 << 5) ? 1 : 0; - self->inlineProfileFlag = val & (1 << 4) ? 1 : 0; - DEBUG_SPRINTF( "objectDescriptorID = %d", self->objectDescriptorID ); - DEBUG_SPRINTF( "urlflag = %d", urlflag ); - DEBUG_SPRINTF( "inlineProfileFlag = %d", self->inlineProfileFlag ); - - if ( urlflag ) - { - GET8( URLStringLength ); - self->URLString = (char*) calloc( 1, self->URLStringLength ); - TESTMALLOC( self->URLString ) - GETBYTES( self->URLStringLength, URLString ); - } - else - { - GET8( OD_profileAndLevel ); - GET8( scene_profileAndLevel ); - GET8( audio_profileAndLevel ); - GET8( visual_profileAndLevel ); - GET8( graphics_profileAndLevel ); - } - while ( self->bytesRead < self->size ) - { - MP4DescriptorPtr desc; - err = MP4ParseDescriptor( inputStream, &desc ); if (err) goto bail; - if ( (desc->tag >= MP4ContentClassificationDescriptorTag) && - (desc->tag <= MP4ISO_OCI_EXT_RANGE_END) ) - { - err = MP4AddListEntry( desc, self->OCIDescriptors ); if (err) goto bail; - } - else - { - switch( desc->tag ) - { - case MP4ES_DescriptorTag: - err = MP4AddListEntry( desc, self->ESDescriptors ); if (err) goto bail; - break; - - case MP4ES_ID_IncDescriptorTag: - err = MP4AddListEntry( desc, self->ES_ID_IncDescriptors ); if (err) goto bail; - break; - - case MP4IPMP_DescriptorPointerTag: - err = MP4AddListEntry( desc, self->IPMPDescriptorPointers ); if (err) goto bail; - break; - - default: - err = MP4AddListEntry( desc, self->extensionDescriptors ); if (err) goto bail; - break; - } - } - self->bytesRead += desc->size; - } - + MP4Err err; + u32 val; + u32 urlflag; + MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr)s; + err = MP4NoErr; + GET16_V_MSG(val, NULL); + self->objectDescriptorID = val >> 6; + urlflag = val & (1 << 5) ? 1 : 0; + self->inlineProfileFlag = val & (1 << 4) ? 1 : 0; + DEBUG_SPRINTF("objectDescriptorID = %d", self->objectDescriptorID); + DEBUG_SPRINTF("urlflag = %d", urlflag); + DEBUG_SPRINTF("inlineProfileFlag = %d", self->inlineProfileFlag); + + if(urlflag) + { + GET8(URLStringLength); + self->URLString = (char *)calloc(1, self->URLStringLength); + TESTMALLOC(self->URLString) + GETBYTES(self->URLStringLength, URLString); + } + else + { + GET8(OD_profileAndLevel); + GET8(scene_profileAndLevel); + GET8(audio_profileAndLevel); + GET8(visual_profileAndLevel); + GET8(graphics_profileAndLevel); + } + while(self->bytesRead < self->size) + { + MP4DescriptorPtr desc; + err = MP4ParseDescriptor(inputStream, &desc); + if(err) goto bail; + if((desc->tag >= MP4ContentClassificationDescriptorTag) && + (desc->tag <= MP4ISO_OCI_EXT_RANGE_END)) + { + err = MP4AddListEntry(desc, self->OCIDescriptors); + if(err) goto bail; + } + else + { + switch(desc->tag) + { + case MP4ES_DescriptorTag: + err = MP4AddListEntry(desc, self->ESDescriptors); + if(err) goto bail; + break; + + case MP4ES_ID_IncDescriptorTag: + err = MP4AddListEntry(desc, self->ES_ID_IncDescriptors); + if(err) goto bail; + break; + + case MP4IPMP_DescriptorPointerTag: + err = MP4AddListEntry(desc, self->IPMPDescriptorPointers); + if(err) goto bail; + break; + + default: + err = MP4AddListEntry(desc, self->extensionDescriptors); + if(err) goto bail; + break; + } + } + self->bytesRead += desc->size; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static void destroy( struct MP4DescriptorRecord* s ) + +static void destroy(struct MP4DescriptorRecord *s) { - MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr) s; - if ( self->URLString ) - { - free( self->URLString ); - self->URLString = NULL; - } - - DESTROY_DESCRIPTOR_LIST( ESDescriptors ); - DESTROY_DESCRIPTOR_LIST( ES_ID_IncDescriptors ); - DESTROY_DESCRIPTOR_LIST( OCIDescriptors ); - DESTROY_DESCRIPTOR_LIST( IPMPDescriptorPointers ); - DESTROY_DESCRIPTOR_LIST( extensionDescriptors ); - - free( self ); + MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr)s; + if(self->URLString) + { + free(self->URLString); + self->URLString = NULL; + } + + DESTROY_DESCRIPTOR_LIST(ESDescriptors); + DESTROY_DESCRIPTOR_LIST(ES_ID_IncDescriptors); + DESTROY_DESCRIPTOR_LIST(OCIDescriptors); + DESTROY_DESCRIPTOR_LIST(IPMPDescriptorPointers); + DESTROY_DESCRIPTOR_LIST(extensionDescriptors); + + free(self); bail: - return; + return; } -static MP4Err removeESDS( struct MP4DescriptorRecord* s ) +static MP4Err removeESDS(struct MP4DescriptorRecord *s) { - MP4Err err; - MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr) s; - err = MP4NoErr; - DESTROY_DESCRIPTOR_LIST( ESDescriptors ); - err = MP4MakeLinkedList( &self->ESDescriptors ); if (err) goto bail; - bail: - return err; + MP4Err err; + MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr)s; + err = MP4NoErr; + DESTROY_DESCRIPTOR_LIST(ESDescriptors); + err = MP4MakeLinkedList(&self->ESDescriptors); + if(err) goto bail; +bail: + return err; } -MP4Err MP4CreateInitialObjectDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateInitialObjectDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4InitialObjectDescriptor ) - self->addDescriptor = addDescriptor; - self->removeESDS = removeESDS; - err = MP4MakeLinkedList( &self->ESDescriptors ); if (err) goto bail; - err = MP4MakeLinkedList( &self->ES_ID_IncDescriptors ); if (err) goto bail; - err = MP4MakeLinkedList( &self->OCIDescriptors ); if (err) goto bail; - err = MP4MakeLinkedList( &self->IPMPDescriptorPointers ); if (err) goto bail; - err = MP4MakeLinkedList( &self->extensionDescriptors ); if (err) goto bail; - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4InitialObjectDescriptor) + self->addDescriptor = addDescriptor; + self->removeESDS = removeESDS; + err = MP4MakeLinkedList(&self->ESDescriptors); + if(err) goto bail; + err = MP4MakeLinkedList(&self->ES_ID_IncDescriptors); + if(err) goto bail; + err = MP4MakeLinkedList(&self->OCIDescriptors); + if(err) goto bail; + err = MP4MakeLinkedList(&self->IPMPDescriptorPointers); + if(err) goto bail; + err = MP4MakeLinkedList(&self->extensionDescriptors); + if(err) goto bail; + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4InputStream.c b/IsoLib/libisomediafile/src/MP4InputStream.c index 086a11d..8304fb5 100644 --- a/IsoLib/libisomediafile/src/MP4InputStream.c +++ b/IsoLib/libisomediafile/src/MP4InputStream.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,12 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4InputStream.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4InputStream.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4InputStream.h" - diff --git a/IsoLib/libisomediafile/src/MP4InputStream.h b/IsoLib/libisomediafile/src/MP4InputStream.h index 2990c7c..b4e5f77 100644 --- a/IsoLib/libisomediafile/src/MP4InputStream.h +++ b/IsoLib/libisomediafile/src/MP4InputStream.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4InputStream.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4InputStream.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #ifndef INCLUDED_MP4_INPUTSTREAM_H #define INCLUDED_MP4_INPUTSTREAM_H @@ -29,42 +29,43 @@ derivative works. Copyright (c) 1999. #include "MP4Movies.h" #include "FileMappingObject.h" -#define COMMON_INPUTSTREAM_FIELDS \ - u64 available; \ - u32 debugging; \ - u32 indent; \ - void (*msg)( struct MP4InputStreamRecord *self, char *msg ); \ - struct FileMappingObjectRecord* (*getFileMappingObject)( struct MP4InputStreamRecord *self ); \ - void (*destroy)( struct MP4InputStreamRecord *self ); \ - MP4Err (*read8)( struct MP4InputStreamRecord *self, u32 *outVal, char *msg ); \ - MP4Err (*read16)( struct MP4InputStreamRecord *self, u32 *outVal, char *msg ); \ - MP4Err (*read32)( struct MP4InputStreamRecord *self, u32 *outVal, char *msg ); \ - MP4Err (*readData)( struct MP4InputStreamRecord *self, u64 bytes, char *outData, char *msg ); \ - u64 (*getStreamOffset)( struct MP4InputStreamRecord *self ); \ - MP4Err (*skipData)( struct MP4InputStreamRecord *self, u64 bytes, char *msg ); - +#define COMMON_INPUTSTREAM_FIELDS \ + u64 available; \ + u32 debugging; \ + u32 indent; \ + void (*msg)(struct MP4InputStreamRecord * self, char *msg); \ + struct FileMappingObjectRecord *(*getFileMappingObject)(struct MP4InputStreamRecord * self); \ + void (*destroy)(struct MP4InputStreamRecord * self); \ + MP4Err (*read8)(struct MP4InputStreamRecord * self, u32 * outVal, char *msg); \ + MP4Err (*read16)(struct MP4InputStreamRecord * self, u32 * outVal, char *msg); \ + MP4Err (*read32)(struct MP4InputStreamRecord * self, u32 * outVal, char *msg); \ + MP4Err (*readData)(struct MP4InputStreamRecord * self, u64 bytes, char *outData, char *msg); \ + u64 (*getStreamOffset)(struct MP4InputStreamRecord * self); \ + MP4Err (*skipData)(struct MP4InputStreamRecord * self, u64 bytes, char *msg); + typedef struct MP4InputStreamRecord { - COMMON_INPUTSTREAM_FIELDS + COMMON_INPUTSTREAM_FIELDS } MP4InputStream, *MP4InputStreamPtr; typedef struct MP4MemoryInputStreamRecord { - COMMON_INPUTSTREAM_FIELDS - char *base; - char *ptr; - struct FileMappingObjectRecord* mapping; + COMMON_INPUTSTREAM_FIELDS + char *base; + char *ptr; + struct FileMappingObjectRecord *mapping; } MP4MemoryInputStream, *MP4MemoryInputStreamPtr; typedef struct MP4FileMappingInputStreamRecord { - COMMON_INPUTSTREAM_FIELDS - char *base; - u64 current_offset; - struct FileMappingObjectRecord* mapping; + COMMON_INPUTSTREAM_FIELDS + char *base; + u64 current_offset; + struct FileMappingObjectRecord *mapping; } MP4FileMappingInputStream, *MP4FileMappingInputStreamPtr; -MP4Err MP4CreateMemoryInputStream( char *base, u32 size, MP4InputStreamPtr *outStream ); -MP4Err MP4CreateFileMappingInputStream( struct FileMappingObjectRecord* mapping, MP4InputStreamPtr *outStream ); +MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); +MP4Err MP4CreateFileMappingInputStream(struct FileMappingObjectRecord *mapping, + MP4InputStreamPtr *outStream); #endif diff --git a/IsoLib/libisomediafile/src/MP4LinkedList.c b/IsoLib/libisomediafile/src/MP4LinkedList.c index e05e0b2..e795d9e 100644 --- a/IsoLib/libisomediafile/src/MP4LinkedList.c +++ b/IsoLib/libisomediafile/src/MP4LinkedList.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,208 +15,203 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: + $Id: */ #include "MP4LinkedList.h" #include "MP4Impl.h" #include #include -MP4Err MP4MakeLinkedList( MP4LinkedList *outList ) +MP4Err MP4MakeLinkedList(MP4LinkedList *outList) { - MP4Err err; - MP4LinkedList newList; - err = MP4NoErr; - - newList = (MP4LinkedList) calloc( 1, sizeof(MP4List) ); - TESTMALLOC( newList ) - newList->foundEntryNumber = -1; - *outList = newList; + MP4Err err; + MP4LinkedList newList; + err = MP4NoErr; + + newList = (MP4LinkedList)calloc(1, sizeof(MP4List)); + TESTMALLOC(newList) + newList->foundEntryNumber = -1; + *outList = newList; bail: - return err; + return err; } -MP4Err MP4PrependListEntry( MP4LinkedList list, void *item ) +MP4Err MP4PrependListEntry(MP4LinkedList list, void *item) { - MP4Err err; - MP4ListItemPtr entry; - - err = MP4NoErr; - entry = (MP4ListItemPtr) calloc( 1, sizeof(MP4ListItem) ); - TESTMALLOC( entry ); - entry->data = item; - if ( list->head == NULL ) - { - list->entryCount = 1; - list->tail = entry; - } - else - { - list->entryCount += 1; - entry->link = list->head; - } - list->head = entry; - list->foundEntryNumber = 0; - list->foundEntry = entry; + MP4Err err; + MP4ListItemPtr entry; + + err = MP4NoErr; + entry = (MP4ListItemPtr)calloc(1, sizeof(MP4ListItem)); + TESTMALLOC(entry); + entry->data = item; + if(list->head == NULL) + { + list->entryCount = 1; + list->tail = entry; + } + else + { + list->entryCount += 1; + entry->link = list->head; + } + list->head = entry; + list->foundEntryNumber = 0; + list->foundEntry = entry; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4AddListEntry( void* item, MP4LinkedList list ) +MP4Err MP4AddListEntry(void *item, MP4LinkedList list) { - MP4Err err; - MP4ListItemPtr entry; - - err = MP4NoErr; - if ( list == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - entry = (MP4ListItemPtr) calloc( 1, sizeof(MP4ListItem) ); - TESTMALLOC( entry ); - entry->data = item; - if ( list->head == NULL ) - { - list->head = entry; - list->entryCount = 1; - } - else - { - list->entryCount += 1; - list->tail->link = entry; - } - list->tail = entry; - list->foundEntryNumber = list->entryCount - 1; - list->foundEntry = entry; + MP4Err err; + MP4ListItemPtr entry; + + err = MP4NoErr; + if(list == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + entry = (MP4ListItemPtr)calloc(1, sizeof(MP4ListItem)); + TESTMALLOC(entry); + entry->data = item; + if(list->head == NULL) + { + list->head = entry; + list->entryCount = 1; + } + else + { + list->entryCount += 1; + list->tail->link = entry; + } + list->tail = entry; + list->foundEntryNumber = list->entryCount - 1; + list->foundEntry = entry; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4DeleteLinkedList( MP4LinkedList list ) +MP4Err MP4DeleteLinkedList(MP4LinkedList list) { - MP4Err err; - MP4ListItemPtr entry; - err = MP4NoErr; - if ( list == NULL ) - BAILWITHERROR( MP4BadParamErr ); - if ( list->head != NULL ) - { - entry = list->head; - do - { - MP4ListItemPtr lnk = entry->link; - free( entry ); - entry = lnk; - } while ( entry ); - } -/* - else - free( list ); -*/ - free(list); + MP4Err err; + MP4ListItemPtr entry; + err = MP4NoErr; + if(list == NULL) BAILWITHERROR(MP4BadParamErr); + if(list->head != NULL) + { + entry = list->head; + do + { + MP4ListItemPtr lnk = entry->link; + free(entry); + entry = lnk; + } while(entry); + } + /* + else + free( list ); + */ + free(list); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4GetListEntryCount( MP4LinkedList list, u32 *outCount ) +MP4Err MP4GetListEntryCount(MP4LinkedList list, u32 *outCount) { - MP4Err err; - err = MP4NoErr; - - if ( (list == 0) || (outCount == 0) ) - { - BAILWITHERROR( MP4BadParamErr ) - } - *outCount = list->entryCount; + MP4Err err; + err = MP4NoErr; + + if((list == 0) || (outCount == 0)) + { + BAILWITHERROR(MP4BadParamErr) + } + *outCount = list->entryCount; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4GetListEntry( MP4LinkedList list, u32 itemNumber, char **outItem ) +MP4Err MP4GetListEntry(MP4LinkedList list, u32 itemNumber, char **outItem) { - MP4Err err; - MP4ListItemPtr entry; - u32 i; - err = MP4NoErr; - if ( (list == NULL) || (outItem == NULL) || (itemNumber >= list->entryCount) ) - BAILWITHERROR( MP4BadParamErr ) - - if ( itemNumber < (u32) list->foundEntryNumber ) - { - /* if cached entry is too far, find the head */ - list->foundEntryNumber = 0; - list->foundEntry = list->head; - } - entry = list->foundEntry; - for ( i = list->foundEntryNumber; i < itemNumber; i++ ) - { - assert( entry->link != NULL ); - entry = entry->link; - } - list->foundEntryNumber = itemNumber; - list->foundEntry = entry; - *outItem = (char*) entry->data; - if ( list->foundEntryNumber == 0 ) - { - assert( list->foundEntry == list->head ); - } + MP4Err err; + MP4ListItemPtr entry; + u32 i; + err = MP4NoErr; + if((list == NULL) || (outItem == NULL) || (itemNumber >= list->entryCount)) + BAILWITHERROR(MP4BadParamErr) + + if(itemNumber < (u32)list->foundEntryNumber) + { + /* if cached entry is too far, find the head */ + list->foundEntryNumber = 0; + list->foundEntry = list->head; + } + entry = list->foundEntry; + for(i = list->foundEntryNumber; i < itemNumber; i++) + { + assert(entry->link != NULL); + entry = entry->link; + } + list->foundEntryNumber = itemNumber; + list->foundEntry = entry; + *outItem = (char *)entry->data; + if(list->foundEntryNumber == 0) + { + assert(list->foundEntry == list->head); + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -MP4Err MP4DeleteListEntry( MP4LinkedList list, u32 itemNumber ) +MP4Err MP4DeleteListEntry(MP4LinkedList list, u32 itemNumber) { - MP4Err err; - MP4ListItemPtr entry, lnk, previous; - u32 i; - err = MP4NoErr; - if ( (list == NULL) || (itemNumber >= list->entryCount) ) - BAILWITHERROR( MP4BadParamErr ); - - entry = list->head; - previous = list->head; - - for (i = 0; i < itemNumber; i++ ) - { - assert (entry->link != NULL ); - previous = entry; - entry = entry->link; - } - - lnk = entry->link; - free(entry); - - if (itemNumber == 0) - list->head = lnk; - else - previous->link = lnk; - - if (itemNumber == list->entryCount-1) - list->tail = previous; - - list->foundEntryNumber = 0; - list->foundEntry = list->head; - list->entryCount -= 1; + MP4Err err; + MP4ListItemPtr entry, lnk, previous; + u32 i; + err = MP4NoErr; + if((list == NULL) || (itemNumber >= list->entryCount)) BAILWITHERROR(MP4BadParamErr); + + entry = list->head; + previous = list->head; + + for(i = 0; i < itemNumber; i++) + { + assert(entry->link != NULL); + previous = entry; + entry = entry->link; + } + + lnk = entry->link; + free(entry); + + if(itemNumber == 0) list->head = lnk; + else + previous->link = lnk; + + if(itemNumber == list->entryCount - 1) list->tail = previous; + + list->foundEntryNumber = 0; + list->foundEntry = list->head; + list->entryCount -= 1; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - diff --git a/IsoLib/libisomediafile/src/MP4LinkedList.h b/IsoLib/libisomediafile/src/MP4LinkedList.h index fb4c79d..f65c118 100644 --- a/IsoLib/libisomediafile/src/MP4LinkedList.h +++ b/IsoLib/libisomediafile/src/MP4LinkedList.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,41 +15,40 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4LinkedList.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4LinkedList.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #ifndef INCLUDED_MP4_LINKED_LIST_H #define INCLUDED_MP4_LINKED_LIST_H #include "MP4Movies.h" - typedef struct MP4ListItem { - struct MP4ListItem* link; - void *data; + struct MP4ListItem *link; + void *data; } MP4ListItem, *MP4ListItemPtr; typedef struct MP4List { - struct MP4ListItem *head; - struct MP4ListItem *tail; - u32 entryCount; - int foundEntryNumber; - struct MP4ListItem *foundEntry; + struct MP4ListItem *head; + struct MP4ListItem *tail; + u32 entryCount; + int foundEntryNumber; + struct MP4ListItem *foundEntry; } MP4List, *MP4LinkedList; -MP4Err MP4MakeLinkedList( MP4LinkedList *outList ); -MP4Err MP4PrependListEntry( MP4LinkedList list, void *item ); -MP4Err MP4AddListEntry( void* item, MP4LinkedList list ); -MP4Err MP4DeleteLinkedList( MP4LinkedList list ); -MP4Err MP4GetListEntryCount( MP4LinkedList list, u32 *outCount ); -MP4Err MP4GetListEntry( MP4LinkedList list, u32 itemNumber, char* *outItem ); -MP4Err MP4DeleteListEntry( MP4LinkedList list, u32 itemNumber ); +MP4Err MP4MakeLinkedList(MP4LinkedList *outList); +MP4Err MP4PrependListEntry(MP4LinkedList list, void *item); +MP4Err MP4AddListEntry(void *item, MP4LinkedList list); +MP4Err MP4DeleteLinkedList(MP4LinkedList list); +MP4Err MP4GetListEntryCount(MP4LinkedList list, u32 *outCount); +MP4Err MP4GetListEntry(MP4LinkedList list, u32 itemNumber, char **outItem); +MP4Err MP4DeleteListEntry(MP4LinkedList list, u32 itemNumber); #endif diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index 7dddbab..70a912d 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: MP4Media.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4Media.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" @@ -30,2321 +30,2382 @@ derivative works. Copyright (c) 1999, 2000. #include #include -MP4Err MP4GetMediaESD( MP4Media theMedia, u32 index, MP4ES_DescriptorPtr *outESD, u32 *outDataReferenceIndex ); -MP4Err MP4GetMediaSampleDescIndex( MP4Media theMedia, u64 desiredTime, u32 *outSampleDescriptionIndex ); +MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr *outESD, + u32 *outDataReferenceIndex); +MP4Err MP4GetMediaSampleDescIndex(MP4Media theMedia, u64 desiredTime, + u32 *outSampleDescriptionIndex); -MP4_EXTERN ( MP4Err ) MP4BeginMediaEdits( MP4Media theMedia ) +MP4_EXTERN(MP4Err) MP4BeginMediaEdits(MP4Media theMedia) { - MP4Err err; - err = MP4NoErr; - if ( theMedia == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - /* finish this !!! */ - - bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + err = MP4NoErr; + if(theMedia == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + /* finish this !!! */ -MP4_EXTERN ( MP4Err ) MP4EndMediaEdits( MP4Media theMedia ) -{ - MP4MediaAtomPtr mdia; - MP4Err err; - err = MP4NoErr; - if ( theMedia == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) theMedia; - err = mdia->calculateDuration( mdia ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; -} +bail: + TEST_RETURN(err); -MP4_EXTERN ( MP4Err ) MP4AddMediaSampleReferencePad( MP4Media media, u64 dataOffset, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, - MP4Handle padsH ) -{ - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - err = mdia->addSampleReference( mdia, dataOffset, sampleCount, durationsH, sizesH, sampleEntryH, - decodingOffsetsH, syncSamplesH, padsH ); - - bail: - TEST_RETURN( err ); - - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4AddMediaSamplesPad( MP4Media media, MP4Handle sampleH, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, - MP4Handle padsH ) +MP4_EXTERN(MP4Err) MP4EndMediaEdits(MP4Media theMedia) { - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - err = mdia->addSamples( mdia, sampleH, sampleCount, durationsH, sizesH, sampleEntryH, - decodingOffsetsH, syncSamplesH, padsH ); - - bail: - TEST_RETURN( err ); - - return err; -} + MP4MediaAtomPtr mdia; + MP4Err err; + err = MP4NoErr; + if(theMedia == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)theMedia; + err = mdia->calculateDuration(mdia); + if(err) goto bail; +bail: + TEST_RETURN(err); -MP4_EXTERN ( MP4Err ) MP4AddMediaSampleReference( MP4Media media, u64 dataOffset, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH ) -{ - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - err = mdia->addSampleReference( mdia, dataOffset, sampleCount, durationsH, sizesH, sampleEntryH, - decodingOffsetsH, syncSamplesH, NULL ); - - bail: - TEST_RETURN( err ); - - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4AddMediaSamples( MP4Media media, MP4Handle sampleH, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH ) +MP4_EXTERN(MP4Err) +MP4AddMediaSampleReferencePad(MP4Media media, u64 dataOffset, u32 sampleCount, MP4Handle durationsH, + MP4Handle sizesH, MP4Handle sampleEntryH, MP4Handle decodingOffsetsH, + MP4Handle syncSamplesH, MP4Handle padsH) { - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - err = mdia->addSamples( mdia, sampleH, sampleCount, durationsH, sizesH, sampleEntryH, - decodingOffsetsH, syncSamplesH, NULL ); - - bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + MP4MediaAtomPtr mdia; -MP4_EXTERN( MP4Err ) -ISOAddGroupDescription( MP4Media media, u32 groupType, MP4Handle description, u32* index ) -{ - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - err = mdia->addGroupDescription( mdia, groupType, description, index ); - - bail: - TEST_RETURN( err ); - - return err; -} + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->addSampleReference(mdia, dataOffset, sampleCount, durationsH, sizesH, sampleEntryH, + decodingOffsetsH, syncSamplesH, padsH); -MP4_EXTERN( MP4Err ) -ISOGetGroupDescription( MP4Media media, u32 groupType, u32 index, MP4Handle description ) -{ - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - err = mdia->getGroupDescription( mdia, groupType, index, description ); - - bail: - TEST_RETURN( err ); - - return err; +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN( MP4Err ) -ISOSetSamplestoGroupType( MP4Media media, u32 enableCompactSamples ) +MP4_EXTERN(MP4Err) +MP4AddMediaSamplesPad(MP4Media media, MP4Handle sampleH, u32 sampleCount, MP4Handle durationsH, + MP4Handle sizesH, MP4Handle sampleEntryH, MP4Handle decodingOffsetsH, + MP4Handle syncSamplesH, MP4Handle padsH) { - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - mdia->enableCompactSamples = enableCompactSamples; - - bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + MP4MediaAtomPtr mdia; + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->addSamples(mdia, sampleH, sampleCount, durationsH, sizesH, sampleEntryH, + decodingOffsetsH, syncSamplesH, padsH); -MP4_EXTERN( MP4Err ) -ISOMapSamplestoGroup( MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count ) -{ - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - err = mdia->mapSamplestoGroup( mdia, groupType, group_index, sample_index, count ); - - bail: - TEST_RETURN( err ); - - return err; -} +bail: + TEST_RETURN(err); -MP4_EXTERN( MP4Err ) -ISOGetSampletoGroupMap( MP4Media media, u32 groupType, u32 sample_number, u32* group_index ) -{ - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - err = mdia->getSampleGroupMap( mdia, groupType, sample_number, group_index ); - - bail: - TEST_RETURN( err ); - - return err; + return err; } -MP4_EXTERN( MP4Err ) -ISOSetSampleDependency( MP4Media media, s32 sample_index, MP4Handle dependencies ) +MP4_EXTERN(MP4Err) +MP4AddMediaSampleReference(MP4Media media, u64 dataOffset, u32 sampleCount, MP4Handle durationsH, + MP4Handle sizesH, MP4Handle sampleEntryH, MP4Handle decodingOffsetsH, + MP4Handle syncSamplesH) { - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - err = mdia->setSampleDependency( mdia, sample_index, dependencies); - - bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + MP4MediaAtomPtr mdia; -MP4_EXTERN( MP4Err ) -ISOGetSampleDependency( MP4Media media, s32 sample_index, - u8* dependency ) -{ - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - err = mdia->getSampleDependency( mdia, sample_index, dependency ); - - bail: - TEST_RETURN( err ); - - return err; + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->addSampleReference(mdia, dataOffset, sampleCount, durationsH, sizesH, sampleEntryH, + decodingOffsetsH, syncSamplesH, NULL); + +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) ISOSetSampleSizeField( MP4Media media, u32 fieldsize ) +MP4_EXTERN(MP4Err) +MP4AddMediaSamples(MP4Media media, MP4Handle sampleH, u32 sampleCount, MP4Handle durationsH, + MP4Handle sizesH, MP4Handle sampleEntryH, MP4Handle decodingOffsetsH, + MP4Handle syncSamplesH) { - MP4Err err; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( media == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - err = mdia->setfieldsize( mdia, fieldsize ); - - bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + MP4MediaAtomPtr mdia; + + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->addSamples(mdia, sampleH, sampleCount, durationsH, sizesH, sampleEntryH, + decodingOffsetsH, syncSamplesH, NULL); +bail: + TEST_RETURN(err); -MP4_EXTERN ( MP4Err ) MP4SetMediaLanguage( MP4Media theMedia, char *threeCharCode ) -{ - MP4Err err; - u32 packedLanguage; - MP4MediaHeaderAtomPtr mediaHeader; - - err = MP4NoErr; - if ( (theMedia == NULL) || (threeCharCode == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mediaHeader = (MP4MediaHeaderAtomPtr) ((MP4MediaAtomPtr) theMedia)->mediaHeader; - if ( mediaHeader == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - packedLanguage = 0; - packedLanguage |= (*threeCharCode++ - 0x60) << 10; - packedLanguage |= (*threeCharCode++ - 0x60) << 5; - packedLanguage |= (*threeCharCode - 0x60); - mediaHeader->packedLanguage = packedLanguage; - bail: - TEST_RETURN( err ); - - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4SetMediaExtendedLanguageTag ( MP4Media theMedia, char *extended_language ) +MP4_EXTERN(MP4Err) +ISOAddGroupDescription(MP4Media media, u32 groupType, MP4Handle description, u32 *index) { - MP4Err err; - MP4MediaAtomPtr mdia; - MP4ExtendedLanguageTagAtomPtr elng; - - err = MP4NoErr; - if ( (theMedia == NULL) || (extended_language == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) theMedia; - - MP4CreateExtendedLanguageTagAtom( &elng ); - - elng->extended_language = calloc(strlen(extended_language) + 1, sizeof(char)); - strcpy(elng->extended_language, extended_language); - - mdia->setExtendedLanguageTag(mdia, (MP4AtomPtr) elng); + MP4Err err; + MP4MediaAtomPtr mdia; + + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->addGroupDescription(mdia, groupType, description, index); + bail: - TEST_RETURN( err ); - - return err; -} + TEST_RETURN(err); -MP4_EXTERN ( MP4Err ) MP4GetMediaLanguage( MP4Media theMedia, char *outThreeCharCode ) -{ - MP4Err err; - u32 packedLanguage; - MP4MediaHeaderAtomPtr mediaHeader; - - err = MP4NoErr; - if ( (theMedia == NULL) || (outThreeCharCode == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mediaHeader = (MP4MediaHeaderAtomPtr) ((MP4MediaAtomPtr) theMedia)->mediaHeader; - if ( mediaHeader == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - packedLanguage = mediaHeader->packedLanguage; - *outThreeCharCode++ = ((packedLanguage >> 10) & 0x1F) + 0x60; - *outThreeCharCode++ = ((packedLanguage >> 5) & 0x1F) + 0x60; - *outThreeCharCode = (packedLanguage & 0x1F) + 0x60; - bail: - TEST_RETURN( err ); - - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4GetMediaExtendedLanguageTag( MP4Media theMedia, char **extended_language ) +MP4_EXTERN(MP4Err) +ISOGetGroupDescription(MP4Media media, u32 groupType, u32 index, MP4Handle description) { - MP4Err err; - MP4MediaAtomPtr mdia; - MP4ExtendedLanguageTagAtomPtr elng; - - err = MP4NoErr; - if (theMedia == NULL) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) theMedia; - elng = (MP4ExtendedLanguageTagAtomPtr) mdia->extendedLanguageTag; - - if ( elng == NULL ) - { - *extended_language = NULL; - goto bail; - } - - *extended_language = calloc(strlen(elng->extended_language) + 1, sizeof(char)); - strcpy(*extended_language, elng->extended_language); -bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + MP4MediaAtomPtr mdia; + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->getGroupDescription(mdia, groupType, index, description); -ISO_EXTERN ( ISOErr ) MJ2SetMediaGraphicsMode( ISOMedia theMedia, u32 mode, const ISORGBColor *opColor ) -{ - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4VideoMediaHeaderAtomPtr vmhd; - u32 handlerType; - - err = MP4NoErr; - if ( (theMedia == NULL) || (opColor == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - - err = MP4GetMediaHandlerDescription( theMedia, &handlerType, NULL ); if (err) goto bail; - if ( handlerType != MP4VisualHandlerType ) - BAILWITHERROR( MP4NotImplementedErr ) - - minf = (MP4MediaInformationAtomPtr) ((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - vmhd = (MP4VideoMediaHeaderAtomPtr) minf->mediaHeader; - if ( vmhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - vmhd->graphicsMode = mode; - vmhd->opColorRed = (u32) opColor->red; - vmhd->opColorGreen = (u32) opColor->green; - vmhd->opColorBlue = (u32) opColor->blue; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISO_EXTERN ( ISOErr ) MJ2GetMediaGraphicsMode( ISOMedia theMedia, u32 *outMode, ISORGBColor *outOpColor ) +MP4_EXTERN(MP4Err) +ISOSetSamplestoGroupType(MP4Media media, u32 enableCompactSamples) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4VideoMediaHeaderAtomPtr vmhd; - u32 handlerType; - - err = MP4NoErr; - if ( (theMedia == NULL) || (outOpColor == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - - err = MP4GetMediaHandlerDescription( theMedia, &handlerType, NULL ); if (err) goto bail; - if ( handlerType != MP4VisualHandlerType ) - BAILWITHERROR( MP4NotImplementedErr ) - - minf = (MP4MediaInformationAtomPtr) ((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - vmhd = (MP4VideoMediaHeaderAtomPtr) minf->mediaHeader; - if ( vmhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - *outMode = vmhd->graphicsMode; - outOpColor->red = (u16) vmhd->opColorRed; - outOpColor->green = (u16) vmhd->opColorGreen; - outOpColor->blue = (u16) vmhd->opColorBlue; + MP4Err err; + MP4MediaAtomPtr mdia; + + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + mdia->enableCompactSamples = enableCompactSamples; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISO_EXTERN ( ISOErr ) MJ2SetMediaSoundBalance( ISOMedia theMedia, s16 balance ) +MP4_EXTERN(MP4Err) +ISOMapSamplestoGroup(MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SoundMediaHeaderAtomPtr smhd; - u32 handlerType; - - err = MP4NoErr; - if ( theMedia == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - - err = MP4GetMediaHandlerDescription( theMedia, &handlerType, NULL ); if (err) goto bail; - if ( handlerType != MP4AudioHandlerType ) - BAILWITHERROR( MP4NotImplementedErr ) - - minf = (MP4MediaInformationAtomPtr) ((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - smhd = (MP4SoundMediaHeaderAtomPtr) minf->mediaHeader; - if ( smhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - smhd->balance = (u32) balance; + MP4Err err; + MP4MediaAtomPtr mdia; + + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->mapSamplestoGroup(mdia, groupType, group_index, sample_index, count); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISO_EXTERN ( ISOErr ) MJ2GetMediaSoundBalance( ISOMedia theMedia, s16 *outBalance ) +MP4_EXTERN(MP4Err) +ISOGetSampletoGroupMap(MP4Media media, u32 groupType, u32 sample_number, u32 *group_index) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SoundMediaHeaderAtomPtr smhd; - u32 handlerType; - - err = MP4NoErr; - if ( (theMedia == NULL) || (outBalance == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - - err = MP4GetMediaHandlerDescription( theMedia, &handlerType, NULL ); if (err) goto bail; - if ( handlerType != MP4AudioHandlerType ) - BAILWITHERROR( MP4NotImplementedErr ) - - minf = (MP4MediaInformationAtomPtr) ((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - smhd = (MP4SoundMediaHeaderAtomPtr) minf->mediaHeader; - if ( smhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - *outBalance = (s16) smhd->balance; + MP4Err err; + MP4MediaAtomPtr mdia; + + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->getSampleGroupMap(mdia, groupType, sample_number, group_index); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4GetMediaTimeScale( MP4Media theMedia, u32 *outTimeScale ) +MP4_EXTERN(MP4Err) +ISOSetSampleDependency(MP4Media media, s32 sample_index, MP4Handle dependencies) { - MP4Err err; - MP4MediaHeaderAtomPtr mediaHeader; - - err = MP4NoErr; - if ( (theMedia == NULL) || (outTimeScale == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mediaHeader = (MP4MediaHeaderAtomPtr) ((MP4MediaAtomPtr) theMedia)->mediaHeader; - if ( mediaHeader == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - *outTimeScale = mediaHeader->timeScale; - bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + MP4MediaAtomPtr mdia; -MP4_EXTERN ( MP4Err ) MP4GetMediaDuration( MP4Media theMedia, u64 *outDuration ) -{ - MP4Err err; - MP4MediaHeaderAtomPtr mediaHeader; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - if ( (theMedia == NULL) || (outDuration == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) theMedia; - mediaHeader = (MP4MediaHeaderAtomPtr) (mdia)->mediaHeader; - if ( mediaHeader == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - err = mdia->calculateDuration( mdia ); if (err) goto bail; - *outDuration = mediaHeader->duration; - bail: - TEST_RETURN( err ); - - return err; -} + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->setSampleDependency(mdia, sample_index, dependencies); -MP4_EXTERN ( MP4Err ) MP4GetMediaTrack( MP4Media theMedia, MP4Track *outTrack ) -{ - MP4Err err; - - err = MP4NoErr; - if ( (theMedia == NULL) || (outTrack == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - *outTrack = (MP4Track) ((MP4MediaAtomPtr) theMedia)->mediaTrack; - bail: - TEST_RETURN( err ); - - return err; -} +bail: + TEST_RETURN(err); -MP4_EXTERN ( MP4Err ) MP4GetMediaSampleCount( MP4Media theMedia, u32 *outCount ) -{ - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4SampleSizeAtomPtr stsz; - - err = MP4NoErr; - if ( (theMedia == NULL) || (outCount == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stsz = (MP4SampleSizeAtomPtr) stbl->SampleSize; - if ( stsz == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - *outCount = stsz->sampleCount; - bail: - TEST_RETURN( err ); - - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4GetMediaSampleDescription( MP4Media theMedia, u32 index, - MP4Handle outDescriptionH, u32 *outDataReferenceIndex ) +MP4_EXTERN(MP4Err) +ISOGetSampleDependency(MP4Media media, s32 sample_index, u8 *dependency) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4SampleDescriptionAtomPtr stsd; - GenericSampleEntryAtomPtr entry; - - err = MP4NoErr; - if ( (theMedia == NULL) || (index == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stsd = (MP4SampleDescriptionAtomPtr) stbl->SampleDescription; - if ( stsd == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - if ( index > stsd->getEntryCount(stsd) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = stsd->getEntry( stsd, index, &entry ); if (err) goto bail; - if ( entry == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - if ( outDescriptionH ) - { - err = entry->calculateSize( (MP4AtomPtr) entry ); if (err) goto bail; - err = MP4SetHandleSize( outDescriptionH, entry->size ); if (err) goto bail; - err = entry->serialize( (MP4AtomPtr) entry, *outDescriptionH ); if (err) goto bail; - } - if ( outDataReferenceIndex ) - { - *outDataReferenceIndex = entry->dataReferenceIndex; - } - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaAtomPtr mdia; -} + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->getSampleDependency(mdia, sample_index, dependency); -MP4Err MP4GetMediaESD( MP4Media theMedia, u32 index, MP4ES_DescriptorPtr *outESD, u32 *outDataReferenceIndex ) -{ - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4SampleDescriptionAtomPtr stsd; - GenericSampleEntryAtomPtr entry; - MP4ESDAtomPtr ESD; - - err = MP4NoErr; - if ( (theMedia == NULL) || (index == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stsd = (MP4SampleDescriptionAtomPtr) stbl->SampleDescription; - if ( stsd == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - if ( index > stsd->getEntryCount(stsd) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = stsd->getEntry( stsd, index, &entry ); if (err) goto bail; - if ( entry == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - err = MP4GetListEntryAtom( entry->ExtensionAtomList, MP4ESDAtomType, (MP4AtomPtr*) &ESD ); - if ( err == MP4NotFoundErr ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - if ( outESD ) - { - MP4ES_DescriptorPtr esdDescriptor; - esdDescriptor = (MP4ES_DescriptorPtr) ESD->descriptor; - *outESD = esdDescriptor; - } - if ( outDataReferenceIndex ) - { - *outDataReferenceIndex = entry->dataReferenceIndex; - } - bail: - TEST_RETURN( err ); - - return err; +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4GetMediaDecoderConfig( MP4Media theMedia, u32 sampleDescIndex, MP4Handle decoderConfigH ) +MP4_EXTERN(MP4Err) ISOSetSampleSizeField(MP4Media media, u32 fieldsize) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4SampleDescriptionAtomPtr stsd; - GenericSampleEntryAtomPtr entry; - MP4ES_DescriptorPtr esdDescriptor; - MP4DescriptorPtr decoderConfig; - MP4ESDAtomPtr ESD; - - err = MP4NoErr; - if ( (theMedia == NULL) || (sampleDescIndex == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stsd = (MP4SampleDescriptionAtomPtr) stbl->SampleDescription; - if ( stsd == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - if ( sampleDescIndex > stsd->getEntryCount(stsd) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = stsd->getEntry( stsd, sampleDescIndex, &entry ); if (err) goto bail; - if ( entry == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - err = MP4GetListEntryAtom( entry->ExtensionAtomList, MP4ESDAtomType, (MP4AtomPtr*) &ESD ); - if ( err == MP4NotFoundErr ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - esdDescriptor = (MP4ES_DescriptorPtr) ESD->descriptor; - if ( esdDescriptor == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - decoderConfig = esdDescriptor->decoderConfig; - if ( decoderConfig ) - { - err = decoderConfig->calculateSize( decoderConfig ); if (err) goto bail; - err = MP4SetHandleSize( decoderConfigH, decoderConfig->size ); if (err) goto bail; - if ( decoderConfig->size ) - { - err = decoderConfig->serialize( decoderConfig, *decoderConfigH ); if (err) goto bail; - } - } - else - { - MP4SetHandleSize( decoderConfigH, 0 ); - } + MP4Err err; + MP4MediaAtomPtr mdia; - bail: - TEST_RETURN( err ); + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->setfieldsize(mdia, fieldsize); - return err; -} +bail: + TEST_RETURN(err); -MP4_EXTERN ( MP4Err ) MP4GetMediaDecoderType( MP4Media theMedia, u32 sampleDescIndex, - u32 *outObjectType, u32 *outStreamType, - u32 *outBufferSize, - MP4Handle specificInfoH ) -{ - return MP4GetMediaDecoderInformation( theMedia, sampleDescIndex, - outObjectType, outStreamType, - outBufferSize, - NULL, /* upstream */ - NULL, /* max */ - NULL, /* avg */ - specificInfoH ); + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetMediaDecoderInformation( MP4Media theMedia, - u32 sampleDescIndex, - u32 *outObjectType, - u32 *outStreamType, - u32 *outBufferSize, - u32 *outUpstream, - u32 *outMaxBitrate, - u32 *outAvgBitrate, - MP4Handle specificInfoH ) +MP4_EXTERN(MP4Err) MP4SetMediaLanguage(MP4Media theMedia, char *threeCharCode) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4SampleDescriptionAtomPtr stsd; - GenericSampleEntryAtomPtr entry; - MP4ES_DescriptorPtr esdDescriptor; - MP4DecoderConfigDescriptorPtr decoderConfig; - MP4ESDAtomPtr ESD; - - err = MP4NoErr; - if ( (theMedia == NULL) || (sampleDescIndex == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stsd = (MP4SampleDescriptionAtomPtr) stbl->SampleDescription; - if ( stsd == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - if ( sampleDescIndex > stsd->getEntryCount(stsd) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = stsd->getEntry( stsd, sampleDescIndex, &entry ); if (err) goto bail; - if ( entry == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - err = MP4GetListEntryAtom( entry->ExtensionAtomList, MP4ESDAtomType, (MP4AtomPtr*) &ESD ); - if ( err == MP4NotFoundErr ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - esdDescriptor = (MP4ES_DescriptorPtr) ESD->descriptor; - if ( esdDescriptor == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - decoderConfig = (MP4DecoderConfigDescriptorPtr) esdDescriptor->decoderConfig; - if ( decoderConfig ) - { - MP4DescriptorPtr specificInfo; - *outObjectType = decoderConfig->objectTypeIndication; - *outStreamType = decoderConfig->streamType; - *outBufferSize = decoderConfig->bufferSizeDB; - if ( outUpstream ) - { - *outUpstream = decoderConfig->upstream; - } - if ( outMaxBitrate ) - { - *outMaxBitrate = decoderConfig->maxBitrate; - } - if ( outAvgBitrate ) - { - *outAvgBitrate = decoderConfig->avgBitrate; - } - if ( specificInfoH ) - { - specificInfo = decoderConfig->decoderSpecificInfo; - if ( specificInfo ) - { - err = specificInfo->calculateSize( specificInfo ); if (err) goto bail; - err = MP4SetHandleSize( specificInfoH, specificInfo->size ); if (err) goto bail; - if ( specificInfo->size ) - { - u32 bytesSkipped; - char *cp = *specificInfoH; - err = specificInfo->serialize( specificInfo, *specificInfoH ); if (err) goto bail; - cp++; /* skip tag; */ - for( bytesSkipped = 1; *cp & 0x80; ) - { - cp++; - bytesSkipped++; - if ( bytesSkipped == specificInfo->size ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - } - bytesSkipped++; - /* rtm: changed memcpy to memmove, since memory may overlap */ - memmove( *specificInfoH, *specificInfoH + bytesSkipped, specificInfo->size - bytesSkipped ); - err = MP4SetHandleSize( specificInfoH, specificInfo->size - bytesSkipped ); if (err) goto bail; - } - } - } - else - { - MP4SetHandleSize( specificInfoH, 0 ); - } - } - else - { - if ( specificInfoH ) - { - MP4SetHandleSize( specificInfoH, 0 ); - } - } - - bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + u32 packedLanguage; + MP4MediaHeaderAtomPtr mediaHeader; -MP4_EXTERN ( MP4Err ) MP4GetMediaDataRefCount( MP4Media theMedia, u32 *outCount ) -{ - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - - err = MP4NoErr; - if ( (theMedia == NULL) || (outCount == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - dinf = (MP4DataInformationAtomPtr) minf->dataInformation; - if ( dinf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - *outCount = dref->getEntryCount( dref ); - bail: - TEST_RETURN( err ); - - return err; + err = MP4NoErr; + if((theMedia == NULL) || (threeCharCode == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + mediaHeader = (MP4MediaHeaderAtomPtr)((MP4MediaAtomPtr)theMedia)->mediaHeader; + if(mediaHeader == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + packedLanguage = 0; + packedLanguage |= (*threeCharCode++ - 0x60) << 10; + packedLanguage |= (*threeCharCode++ - 0x60) << 5; + packedLanguage |= (*threeCharCode - 0x60); + mediaHeader->packedLanguage = packedLanguage; +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4UseSignedCompositionTimeOffsets ( MP4Media media ) +MP4_EXTERN(MP4Err) MP4SetMediaExtendedLanguageTag(MP4Media theMedia, char *extended_language) { - MP4Err err; - MP4MediaAtomPtr mdia; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - - err = MP4NoErr; - - if (media == NULL) - { - BAILWITHERROR( MP4BadParamErr ); - } - mdia = (MP4MediaAtomPtr) media; - minf = (MP4MediaInformationAtomPtr) mdia->information; - if (minf == NULL) - { - BAILWITHERROR( MP4BadParamErr ); - } - - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if (stbl == NULL) - BAILWITHERROR( MP4InvalidMediaErr ); - - stbl->useSignedCompositionTimeOffsets = 1; + MP4Err err; + MP4MediaAtomPtr mdia; + MP4ExtendedLanguageTagAtomPtr elng; + + err = MP4NoErr; + if((theMedia == NULL) || (extended_language == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)theMedia; + + MP4CreateExtendedLanguageTagAtom(&elng); + + elng->extended_language = calloc(strlen(extended_language) + 1, sizeof(char)); + strcpy(elng->extended_language, extended_language); + + mdia->setExtendedLanguageTag(mdia, (MP4AtomPtr)elng); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } +MP4_EXTERN(MP4Err) MP4GetMediaLanguage(MP4Media theMedia, char *outThreeCharCode) +{ + MP4Err err; + u32 packedLanguage; + MP4MediaHeaderAtomPtr mediaHeader; + err = MP4NoErr; + if((theMedia == NULL) || (outThreeCharCode == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + mediaHeader = (MP4MediaHeaderAtomPtr)((MP4MediaAtomPtr)theMedia)->mediaHeader; + if(mediaHeader == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + packedLanguage = mediaHeader->packedLanguage; + *outThreeCharCode++ = ((packedLanguage >> 10) & 0x1F) + 0x60; + *outThreeCharCode++ = ((packedLanguage >> 5) & 0x1F) + 0x60; + *outThreeCharCode = (packedLanguage & 0x1F) + 0x60; +bail: + TEST_RETURN(err); -MP4_EXTERN ( MP4Err ) MP4CheckMediaDataReferences( MP4Media theMedia ) -{ - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - u32 count; - u32 dataEntryIndex; - - err = MP4NoErr; - if ( (theMedia == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - dinf = (MP4DataInformationAtomPtr) minf->dataInformation; - if ( dinf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - count = dref->getEntryCount( dref ); - for ( dataEntryIndex = 1; dataEntryIndex <= count; dataEntryIndex++ ) - { - err = minf->testDataEntry( minf, dataEntryIndex ); if (err) goto bail; - } - bail: - TEST_RETURN( err ); - - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4AddMediaDataReference( MP4Media theMedia, u32 *outReferenceIndex, MP4Handle urlHandle, MP4Handle urnHandle ) +MP4_EXTERN(MP4Err) MP4GetMediaExtendedLanguageTag(MP4Media theMedia, char **extended_language) { - MP4Err MP4CreateDataEntryURLAtom( MP4DataEntryURLAtomPtr *outAtom ); - MP4Err MP4CreateDataEntryURNAtom( MP4DataEntryURNAtomPtr *outAtom ); - - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - - err = MP4NoErr; - if ( (theMedia == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - dinf = (MP4DataInformationAtomPtr) minf->dataInformation; - if ( dinf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - if ( urlHandle == NULL ) - { - MP4Track track; - MP4Movie movie; - MP4PrivateMovieRecordPtr movieRecord; - MP4DataEntryURLAtomPtr url; - err = MP4GetMediaTrack( theMedia, &track ); if (err) goto bail; - err = MP4GetTrackMovie( track, &movie ); if (err) goto bail; - err = MP4CreateDataEntryURLAtom( &url ); if (err) goto bail; - movieRecord = (MP4PrivateMovieRecordPtr) movie; - - url->flags |= 1; - url->mdat = movieRecord->mdat; - err = dref->addDataEntry( dref, (MP4AtomPtr) url ); if (err) goto bail; - } - else if ( urnHandle == NULL ) - { - u32 sz; - MP4DataEntryURLAtomPtr url; - err = MP4CreateDataEntryURLAtom( &url ); if (err) goto bail; - err = MP4GetHandleSize( urlHandle, &sz ); if (err) goto bail; - url->locationLength = (u32) sz; - url->location = (char*) calloc( 1, sz ); - memcpy( url->location, *urlHandle, sz ); - err = dref->addDataEntry( dref, (MP4AtomPtr) url ); if (err) goto bail; - } - else - { - u32 sz; - MP4DataEntryURNAtomPtr urn; - err = MP4CreateDataEntryURNAtom( &urn ); if (err) goto bail; - err = MP4GetHandleSize( urlHandle, &sz ); if (err) goto bail; - urn->locationLength = (u32) sz; - urn->location = (char*) calloc( 1, sz ); - memcpy( urn->location, *urlHandle, sz ); - - err = MP4GetHandleSize( urnHandle, &sz ); if (err) goto bail; - urn->nameLength = (u32) sz; - urn->name = (char*) calloc( 1, sz ); - memcpy( urn->name, *urnHandle, sz ); - err = dref->addDataEntry( dref, (MP4AtomPtr) urn ); if (err) goto bail; - } - *outReferenceIndex = dref->getEntryCount( dref ); - bail: - TEST_RETURN( err ); - return err; -} + MP4Err err; + MP4MediaAtomPtr mdia; + MP4ExtendedLanguageTagAtomPtr elng; + err = MP4NoErr; + if(theMedia == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)theMedia; + elng = (MP4ExtendedLanguageTagAtomPtr)mdia->extendedLanguageTag; -MP4_EXTERN ( MP4Err ) MP4GetMediaDataReference( MP4Media theMedia, - u32 index, - MP4Handle referenceH, - MP4Handle urnH, - u32 *outReferenceType, - u32 *outReferenceAttributes ) -{ - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - MP4DataEntryAtomPtr referenceAtom; - MP4DataEntryURLAtomPtr url; - MP4DataEntryURNAtomPtr urn; - u32 referenceType; - u32 referenceFlags; - - err = MP4NoErr; - if ( (theMedia == NULL) || (index == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - dinf = (MP4DataInformationAtomPtr) minf->dataInformation; - if ( dinf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - if ( index > dref->getEntryCount(dref) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = dref->getEntry( dref, index, &referenceAtom ); if (err) goto bail; - if ( referenceAtom == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - referenceType = referenceAtom->type; - referenceFlags = referenceAtom->flags; - if ( outReferenceType ) - { - *outReferenceType = referenceType; - } - if ( outReferenceAttributes ) - { - *outReferenceAttributes = referenceFlags; - } - if ( referenceH || urnH ) - { - switch ( referenceType ) - { - case MP4DataEntryURLAtomType: - if ( referenceH ) - { - url = (MP4DataEntryURLAtomPtr) referenceAtom; - err = MP4SetHandleSize( referenceH, url->locationLength ); if (err) goto bail; - if ( url->locationLength ) - { - memcpy( *referenceH, url->location, url->locationLength ); - } - } - break; - - case MP4DataEntryURNAtomType: - if ( referenceH ) - { - url = (MP4DataEntryURLAtomPtr) referenceAtom; - err = MP4SetHandleSize( referenceH, url->locationLength ); if (err) goto bail; - if ( url->locationLength ) - { - memcpy( *referenceH, url->location, url->locationLength ); - } - } - if ( urnH ) - { - urn = (MP4DataEntryURNAtomPtr) referenceAtom; - err = MP4SetHandleSize( referenceH, urn->nameLength ); if (err) goto bail; - if ( urn->nameLength ) - { - memcpy( *referenceH, urn->location, urn->nameLength ); - } - } - break; - - default: - BAILWITHERROR( MP4InvalidMediaErr ); - break; - } - } - bail: - TEST_RETURN( err ); + if(elng == NULL) + { + *extended_language = NULL; + goto bail; + } - return err; -} + *extended_language = calloc(strlen(elng->extended_language) + 1, sizeof(char)); + strcpy(*extended_language, elng->extended_language); +bail: + TEST_RETURN(err); -MP4_EXTERN ( MP4Err ) MP4GetMediaHandlerDescription( MP4Media theMedia, u32 *outType, MP4Handle *outName ) -{ - MP4Err err; - MP4HandlerAtomPtr handler; - - err = MP4NoErr; - if ( (theMedia == NULL) || ((outType == NULL) && (outName == 0)) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - handler = (MP4HandlerAtomPtr) ((MP4MediaAtomPtr) theMedia)->handler; - if ( handler == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - if ( outType ) - { - *outType = handler->handlerType; - } - if ( outName ) - { - MP4Handle h; - err = MP4NewHandle( handler->nameLength, &h ); if (err) goto bail; - memcpy( *h, handler->nameUTF8, handler->nameLength ); - *outName = h; - } - bail: - TEST_RETURN( err ); - - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4GetMediaNextInterestingTime( MP4Media theMedia, - u32 interestingTimeFlags, /* eg: MP4NextTimeMediaSample */ - u64 searchFromTime, /* in Media time scale */ - u32 searchDirection, /* eg: MP4NextTimeSearchForward */ - u64 *outInterestingTime, /* in Media time scale */ - u64 *outInterestingDuration /* in Media's time coordinate system */ - ) +ISO_EXTERN(ISOErr) MJ2SetMediaGraphicsMode(ISOMedia theMedia, u32 mode, const ISORGBColor *opColor) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4TimeToSampleAtomPtr stts; - MP4SyncSampleAtomPtr stss; - s64 priorSample; - s64 exactSample; - s64 nextSample; - u32 sampleNumber; - s32 sampleDuration; - - err = MP4NoErr; - if ( (theMedia == NULL) || (interestingTimeFlags == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stts = (MP4TimeToSampleAtomPtr) stbl->TimeToSample; - if ( stts == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stss = (MP4SyncSampleAtomPtr) stbl->SyncSample; - err = stts->findSamples( stbl->TimeToSample, searchFromTime, - &priorSample, &exactSample, &nextSample, - &sampleNumber, &sampleDuration ); if (err) goto bail; - if ( outInterestingTime ) - { - if ( searchDirection == MP4NextTimeSearchForward ) - { - if ( (exactSample >= 0) && (interestingTimeFlags & MP4NextTimeEdgeOK) ) - { - *outInterestingTime = exactSample; - } - else - { - *outInterestingTime = nextSample; - } - - } - else - { - if ( (exactSample >= 0) && (interestingTimeFlags & MP4NextTimeEdgeOK) ) - { - *outInterestingTime = exactSample; - } - else - { - *outInterestingTime = priorSample; - } - } - } - if ( outInterestingDuration ) - { - *outInterestingDuration = sampleDuration; - } - - bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4VideoMediaHeaderAtomPtr vmhd; + u32 handlerType; -MP4Err MP4GetMediaSampleDescIndex( MP4Media theMedia, u64 desiredTime, u32 *outSampleDescriptionIndex ) -{ - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4TimeToSampleAtomPtr stts; - MP4SyncSampleAtomPtr stss; - MP4SampleSizeAtomPtr stsz; - MP4SampleToChunkAtomPtr stsc; - - s64 priorSample; - s64 exactSample; - s64 nextSample; - u32 sampleNumber; - s32 sampleDuration; - u32 chunkNumber; - u32 sampleDescriptionIndex; - u32 firstSampleNumberInChunk; - - err = MP4NoErr; - if ( (theMedia == NULL) || (outSampleDescriptionIndex == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stts = (MP4TimeToSampleAtomPtr) stbl->TimeToSample; - if ( stts == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stss = (MP4SyncSampleAtomPtr) stbl->SyncSample; - stsz = (MP4SampleSizeAtomPtr) stbl->SampleSize; - if ( stsz == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stsc = (MP4SampleToChunkAtomPtr) stbl->SampleToChunk; - if ( stsc == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - /* get sample number and time */ - err = stts->findSamples( stbl->TimeToSample, desiredTime, - &priorSample, &exactSample, &nextSample, - &sampleNumber, &sampleDuration ); if (err) goto bail; - - /* get sample description */ - err = stsc->lookupSample( stbl->SampleToChunk, sampleNumber, - &chunkNumber, &sampleDescriptionIndex, &firstSampleNumberInChunk ); if (err) goto bail; - - *outSampleDescriptionIndex = sampleDescriptionIndex; - bail: - TEST_RETURN( err ); - - return err; -} + err = MP4NoErr; + if((theMedia == NULL) || (opColor == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } -MP4_EXTERN ( MP4Err ) MP4GetMediaSample( MP4Media theMedia, MP4Handle outSample, u32 *outSize, - u64 desiredDecodingTime, u64 *outDecodingTime, u64 *outCompositionTime, u64 *outDuration, - MP4Handle outSampleDescription, u32 *outSampleDescriptionIndex, - u32 *outSampleFlags ) -{ - return MP4GetMediaSampleWithPad( theMedia, outSample, outSize, - desiredDecodingTime, outDecodingTime, outCompositionTime, outDuration, - outSampleDescription, outSampleDescriptionIndex, - outSampleFlags, NULL ); -} + err = MP4GetMediaHandlerDescription(theMedia, &handlerType, NULL); + if(err) goto bail; + if(handlerType != MP4VisualHandlerType) BAILWITHERROR(MP4NotImplementedErr) -MP4_EXTERN ( MP4Err ) MP4GetMediaSampleWithPad( MP4Media theMedia, MP4Handle outSample, u32 *outSize, - u64 desiredDecodingTime, u64 *outDecodingTime, u64 *outCompositionTime, u64 *outDuration, - MP4Handle outSampleDescription, u32 *outSampleDescriptionIndex, - u32 *outSampleFlags, u8* outPad ) -{ - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4TimeToSampleAtomPtr stts; - MP4CompositionOffsetAtomPtr ctts; - MP4SyncSampleAtomPtr stss; - MP4SampleSizeAtomPtr stsz; - MP4SampleToChunkAtomPtr stsc; - MP4ChunkOffsetAtomPtr stco; - MP4DataHandlerPtr dhlr; - MP4PaddingBitsAtomPtr padb; - - s64 priorSample; - s64 exactSample; - s64 nextSample; - u64 sampleDTS; - u32 sampleNumber; - s32 sampleDuration; - u32 sampleSize; - u32 chunkNumber; - u32 sampleDescriptionIndex; - u64 chunkOffset; - u32 dataReferenceIndex; - u32 firstSampleNumberInChunk; - u32 sampleOffsetWithinChunk; - - err = MP4NoErr; - if ( (theMedia == NULL) || (outSample == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stts = (MP4TimeToSampleAtomPtr) stbl->TimeToSample; - if ( stts == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - ctts = (MP4CompositionOffsetAtomPtr) stbl->CompositionOffset; - stss = (MP4SyncSampleAtomPtr) stbl->SyncSample; - stsz = (MP4SampleSizeAtomPtr) stbl->SampleSize; - if ( stsz == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stsc = (MP4SampleToChunkAtomPtr) stbl->SampleToChunk; - if ( stsc == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stco = (MP4ChunkOffsetAtomPtr) stbl->ChunkOffset; - if ( stco == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - padb = (MP4PaddingBitsAtomPtr) stbl->PaddingBits; - - /* get sample number and time */ - if ( outSampleFlags ) - { - *outSampleFlags = 0; - } - err = stts->findSamples( stbl->TimeToSample, desiredDecodingTime, - &priorSample, &exactSample, &nextSample, - &sampleNumber, &sampleDuration ); if (err) goto bail; - - if (exactSample != -1) - sampleDTS = exactSample; - else if (priorSample != -1) - sampleDTS = priorSample; - else - sampleDTS = nextSample; - - if ( outCompositionTime ) - { - s32 compositionTimeOffset; - compositionTimeOffset = 0; - if ( ctts ) { - err = ctts->getOffsetForSampleNumber( (MP4AtomPtr) ctts, sampleNumber, &compositionTimeOffset ); if (err) goto bail; - } - *outCompositionTime = sampleDTS + compositionTimeOffset; - } - - if ( ctts && outSampleFlags ) - *outSampleFlags |= MP4MediaSampleHasCTSOffset; - - - /* get sample description */ - err = stsc->lookupSample( stbl->SampleToChunk, sampleNumber, - &chunkNumber, &sampleDescriptionIndex, &firstSampleNumberInChunk ); if (err) goto bail; - - - if ( outSampleDescriptionIndex ) - { - *outSampleDescriptionIndex = sampleDescriptionIndex; - } - - /* get sample size */ - err = stsz->getSampleSizeAndOffset( stbl->SampleSize, sampleNumber, &sampleSize, firstSampleNumberInChunk, &sampleOffsetWithinChunk ); if (err) goto bail; - *outSize = sampleSize; - if (outPad) { - if (padb) - { - err = padb->getSamplePad( (MP4AtomPtr) padb, sampleNumber, outPad ); if (err) goto bail; - } - else *outPad = 0xF8; - } - - - /* get the chunk offset */ - err = stco->getChunkOffset( stbl->ChunkOffset, chunkNumber, &chunkOffset ); if (err) goto bail; - - /* get the sample */ - err = MP4GetMediaSampleDescription( theMedia, sampleDescriptionIndex, outSampleDescription, &dataReferenceIndex ); if (err) goto bail; - err = minf->openDataHandler( (MP4AtomPtr) minf, dataReferenceIndex ); if (err) goto bail; - dhlr = (MP4DataHandlerPtr) minf->dataHandler; - if ( dhlr == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - /* finally we can get the sample */ - err = MP4SetHandleSize( outSample, sampleSize ); if (err) goto bail; - err = dhlr->copyData( dhlr, (chunkOffset + sampleOffsetWithinChunk), *outSample, sampleSize ); if (err) goto bail; - - /* sync sample test */ - if ( outSampleFlags ) - { - if ( stss ) - { - u32 sync; - err = stss->isSyncSample( stbl->SyncSample, sampleNumber, &sync ); if (err) goto bail; - *outSampleFlags |= sync ? 0 : MP4MediaSampleNotSync; - } - } - if ( outDecodingTime ) - { - *outDecodingTime = sampleDTS; /* was exactSample ? exactSample : nextSample; but exactsample fails to -1 --dws */ - } - if ( outDuration ) - { - *outDuration = sampleDuration; - } - - bail: - TEST_RETURN( err ); - - return err; -} + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) BAILWITHERROR(MP4InvalidMediaErr); -MP4_EXTERN ( MP4Err ) MP4GetIndMediaSample( MP4Media theMedia, - u32 sampleNumber, - MP4Handle outSample, - u32 *outSize, - u64 *outDTS, - s32 *outCTSOffset, - u64 *outDuration, - u32 *outSampleFlags, - u32 *outSampleDescIndex - ) -{ - return MP4GetIndMediaSampleWithPad( - theMedia, sampleNumber, outSample, outSize, outDTS, outCTSOffset, - outDuration, outSampleFlags, outSampleDescIndex, NULL); -} - - -MP4_EXTERN ( MP4Err ) MP4GetIndMediaSampleWithPad( MP4Media theMedia, - u32 sampleNumber, - MP4Handle outSample, - u32 *outSize, - u64 *outDTS, - s32 *outCTSOffset, - u64 *outDuration, - u32 *outSampleFlags, - u32 *outSampleDescIndex, - u8 *outPad - ) -{ - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4TimeToSampleAtomPtr stts; - MP4CompositionOffsetAtomPtr ctts; - MP4SyncSampleAtomPtr stss; - MP4SampleSizeAtomPtr stsz; - MP4SampleToChunkAtomPtr stsc; - MP4ChunkOffsetAtomPtr stco; - MP4DataHandlerPtr dhlr; - MP4PaddingBitsAtomPtr padb; - - - u64 sampleDTS; - - s32 sampleDuration; - u32 sampleSize; - u32 chunkNumber; - u32 sampleDescriptionIndex; - u64 chunkOffset; - u32 dataReferenceIndex; - u32 firstSampleNumberInChunk; - u32 sampleOffsetWithinChunk; - - err = MP4NoErr; - if ( (theMedia == NULL) || (outSample == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stts = (MP4TimeToSampleAtomPtr) stbl->TimeToSample; - if ( stts == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - ctts = (MP4CompositionOffsetAtomPtr) stbl->CompositionOffset; - stss = (MP4SyncSampleAtomPtr) stbl->SyncSample; - stsz = (MP4SampleSizeAtomPtr) stbl->SampleSize; - if ( stsz == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stsc = (MP4SampleToChunkAtomPtr) stbl->SampleToChunk; - if ( stsc == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stco = (MP4ChunkOffsetAtomPtr) stbl->ChunkOffset; - if ( stco == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - padb = (MP4PaddingBitsAtomPtr) stbl->PaddingBits; - - if ( outSampleFlags ) - { - *outSampleFlags = 0; - } - /* get sample DTS */ - err = stts->getTimeForSampleNumber( stbl->TimeToSample, sampleNumber, &sampleDTS, &sampleDuration ); if (err) goto bail; - - if ( outSampleFlags && ctts ) - *outSampleFlags |= MP4MediaSampleHasCTSOffset; - - if ( outCTSOffset ) - { - s32 compositionOffset; - compositionOffset = 0; - if ( ctts ) - { - err = ctts->getOffsetForSampleNumber( (MP4AtomPtr) ctts, sampleNumber, &compositionOffset ); if (err) goto bail; - } - *outCTSOffset = compositionOffset; - } - - /* get sample description */ - err = stsc->lookupSample( stbl->SampleToChunk, sampleNumber, - &chunkNumber, &sampleDescriptionIndex, &firstSampleNumberInChunk ); if (err) goto bail; - - /* get sample size */ - err = stsz->getSampleSizeAndOffset( stbl->SampleSize, sampleNumber, &sampleSize, firstSampleNumberInChunk, &sampleOffsetWithinChunk ); if (err) goto bail; - *outSize = sampleSize; - if (outPad) { - if (padb) - { - err = padb->getSamplePad( (MP4AtomPtr) padb, sampleNumber, outPad ); if (err) goto bail; - } - else *outPad = 0xF8; - } - - /* get the chunk offset */ - err = stco->getChunkOffset( stbl->ChunkOffset, chunkNumber, &chunkOffset ); if (err) goto bail; - - /* get the sample */ - err = MP4GetMediaSampleDescription( theMedia, sampleDescriptionIndex, NULL, &dataReferenceIndex ); if (err) goto bail; - err = minf->openDataHandler( (MP4AtomPtr) minf, dataReferenceIndex ); if (err) goto bail; - dhlr = (MP4DataHandlerPtr) minf->dataHandler; - if ( dhlr == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - /* finally we can get the sample */ - err = MP4SetHandleSize( outSample, sampleSize ); if (err) goto bail; - if ( sampleSize > 0 ) - { - err = dhlr->copyData( dhlr, (chunkOffset + sampleOffsetWithinChunk), *outSample, sampleSize ); if (err) goto bail; - } - if ( outSampleDescIndex ) - { - *outSampleDescIndex = sampleDescriptionIndex; - } - - /* sync sample test */ - if ( outSampleFlags ) - { - if ( stss ) - { - u32 sync; - err = stss->isSyncSample( stbl->SyncSample, sampleNumber, &sync ); if (err) goto bail; - *outSampleFlags |= sync ? 0 : MP4MediaSampleNotSync; - } - } - - if ( outDTS ) - { - *outDTS = sampleDTS; - } - if ( outDuration ) - { - *outDuration = sampleDuration; - } - - bail: - TEST_RETURN( err ); - - return err; + vmhd = (MP4VideoMediaHeaderAtomPtr)minf->mediaHeader; + if(vmhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + vmhd->graphicsMode = mode; + vmhd->opColorRed = (u32)opColor->red; + vmhd->opColorGreen = (u32)opColor->green; + vmhd->opColorBlue = (u32)opColor->blue; +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4GetIndMediaSampleReference( MP4Media theMedia, - u32 sampleNumber, - u32 *outOffset, - u32 *outSize, - u32 *outDuration, - u32 *outSampleFlags, - u32 *outSampleDescIndex, - MP4Handle sampleDesc - ) +ISO_EXTERN(ISOErr) MJ2GetMediaGraphicsMode(ISOMedia theMedia, u32 *outMode, ISORGBColor *outOpColor) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4TimeToSampleAtomPtr stts; - MP4CompositionOffsetAtomPtr ctts; - MP4SyncSampleAtomPtr stss; - MP4SampleSizeAtomPtr stsz; - MP4SampleToChunkAtomPtr stsc; - MP4ChunkOffsetAtomPtr stco; - - u64 sampleDTS; - - s32 sampleDuration; - u32 sampleSize; - u32 chunkNumber; - u32 sampleDescriptionIndex; - u64 chunkOffset; - u32 dataReferenceIndex; - u32 firstSampleNumberInChunk; - u32 sampleOffsetWithinChunk; - - err = MP4NoErr; - if ( (theMedia == NULL) || (sampleNumber == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stts = (MP4TimeToSampleAtomPtr) stbl->TimeToSample; - if ( stts == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - ctts = (MP4CompositionOffsetAtomPtr) stbl->CompositionOffset; - stss = (MP4SyncSampleAtomPtr) stbl->SyncSample; - stsz = (MP4SampleSizeAtomPtr) stbl->SampleSize; - if ( stsz == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stsc = (MP4SampleToChunkAtomPtr) stbl->SampleToChunk; - if ( stsc == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stco = (MP4ChunkOffsetAtomPtr) stbl->ChunkOffset; - if ( stco == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - - if ( outSampleFlags ) - { - *outSampleFlags = 0; - } - /* get sample DTS */ - err = stts->getTimeForSampleNumber( stbl->TimeToSample, sampleNumber, &sampleDTS, &sampleDuration ); if (err) goto bail; - if ( ctts && outSampleFlags) - { - *outSampleFlags |= MP4MediaSampleHasCTSOffset; - } - - /* get sample description */ - err = stsc->lookupSample( stbl->SampleToChunk, sampleNumber, - &chunkNumber, &sampleDescriptionIndex, &firstSampleNumberInChunk ); if (err) goto bail; - - /* get sample size */ - err = stsz->getSampleSizeAndOffset( stbl->SampleSize, sampleNumber, &sampleSize, firstSampleNumberInChunk, &sampleOffsetWithinChunk ); if (err) goto bail; - *outSize = sampleSize; - - /* get the chunk offset */ - err = stco->getChunkOffset( stbl->ChunkOffset, chunkNumber, &chunkOffset ); if (err) goto bail; - - /* get the sample description */ - err = MP4GetMediaSampleDescription( theMedia, sampleDescriptionIndex, sampleDesc, &dataReferenceIndex ); if (err) goto bail; - - if ( outOffset ) - { - *outOffset = (u32) chunkOffset + sampleOffsetWithinChunk; - } - if ( outSampleDescIndex ) - { - *outSampleDescIndex = sampleDescriptionIndex; - } - /* sync sample test */ - if ( outSampleFlags ) - { - if ( stss ) - { - u32 sync; - err = stss->isSyncSample( stbl->SyncSample, sampleNumber, &sync ); if (err) goto bail; - *outSampleFlags |= sync ? 0 : MP4MediaSampleNotSync; - } - } - if ( outDuration ) - { - *outDuration = sampleDuration; - } - - bail: - TEST_RETURN( err ); - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4VideoMediaHeaderAtomPtr vmhd; + u32 handlerType; + + err = MP4NoErr; + if((theMedia == NULL) || (outOpColor == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + + err = MP4GetMediaHandlerDescription(theMedia, &handlerType, NULL); + if(err) goto bail; + if(handlerType != MP4VisualHandlerType) BAILWITHERROR(MP4NotImplementedErr) + + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + vmhd = (MP4VideoMediaHeaderAtomPtr)minf->mediaHeader; + if(vmhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + *outMode = vmhd->graphicsMode; + outOpColor->red = (u16)vmhd->opColorRed; + outOpColor->green = (u16)vmhd->opColorGreen; + outOpColor->blue = (u16)vmhd->opColorBlue; +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4MediaTimeToSampleNum( MP4Media theMedia, u64 mediaTime, u32 *outSampleNum, u64 *outSampleCTS, u64 *outSampleDTS, s32 *outSampleDuration ) +ISO_EXTERN(ISOErr) MJ2SetMediaSoundBalance(ISOMedia theMedia, s16 balance) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4TimeToSampleAtomPtr stts; - MP4CompositionOffsetAtomPtr ctts; - - s64 priorSample; - s64 exactSample; - s64 nextSample; - u64 sampleDTS; - u32 sampleNumber; - s32 sampleDuration; - - - err = MP4NoErr; - if ( (theMedia == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stts = (MP4TimeToSampleAtomPtr) stbl->TimeToSample; - if ( stts == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - ctts = (MP4CompositionOffsetAtomPtr) stbl->CompositionOffset; - /* get sample number and time */ - sampleNumber = 0; - err = stts->findSamples( stbl->TimeToSample, mediaTime, - &priorSample, &exactSample, &nextSample, - &sampleNumber, &sampleDuration ); if (err) goto bail; - - if (exactSample != -1) - sampleDTS = exactSample; - else { - if (priorSample != -1) - sampleDTS = priorSample; - else - sampleDTS = nextSample; - err = stts->findSamples( stbl->TimeToSample, sampleDTS, - &priorSample, &exactSample, &nextSample, - &sampleNumber, &sampleDuration ); if (err) goto bail; - if ((sampleDTS == -1) || (sampleNumber == 0)) BAILWITHERROR( MP4InternalErr ) - else sampleDTS = exactSample; - } - if ( outSampleCTS ) /* was DTS, changed dws 9/3/2001, changed also - to +, if order, and decoding to composition offset */ - { - s32 compositionOffset; - compositionOffset = 0; - if ( ctts ) - { - err = ctts->getOffsetForSampleNumber( (MP4AtomPtr) ctts, sampleNumber, &compositionOffset ); if (err) goto bail; - } - *outSampleCTS = sampleDTS + compositionOffset; - } - if ( outSampleNum ) - { - *outSampleNum = sampleNumber; - } - if ( outSampleDTS ) /* was CTS, changed DWS 9/3/2001 */ - { - *outSampleDTS = sampleDTS; - } - if ( outSampleDuration ) - { - *outSampleDuration = sampleDuration; - } - - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SoundMediaHeaderAtomPtr smhd; + u32 handlerType; + + err = MP4NoErr; + if(theMedia == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + + err = MP4GetMediaHandlerDescription(theMedia, &handlerType, NULL); + if(err) goto bail; + if(handlerType != MP4AudioHandlerType) BAILWITHERROR(MP4NotImplementedErr) + + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + smhd = (MP4SoundMediaHeaderAtomPtr)minf->mediaHeader; + if(smhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + smhd->balance = (u32)balance; +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4SampleNumToMediaTime( MP4Media theMedia, u32 sampleNum, u64 *outSampleCTS, u64 *outSampleDTS, s32 *outSampleDuration ) +ISO_EXTERN(ISOErr) MJ2GetMediaSoundBalance(ISOMedia theMedia, s16 *outBalance) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4TimeToSampleAtomPtr stts; - MP4CompositionOffsetAtomPtr ctts; - s32 sampleDuration; - u64 sampleDTS; - - err = MP4NoErr; - if ( (theMedia == NULL) || (sampleNum == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if ( stbl == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stts = (MP4TimeToSampleAtomPtr) stbl->TimeToSample; - if ( stts == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - ctts = (MP4CompositionOffsetAtomPtr) stbl->CompositionOffset; - /* get sample time and duration */ - err = stts->getTimeForSampleNumber( stbl->TimeToSample, sampleNum, &sampleDTS, &sampleDuration ); if (err) goto bail; - /* was sampleCTS, changed dws 9/3/2001 */ - - if ( outSampleCTS ) /* was DTS, decoding offset, ifs in other order, and -; all changed dws 9/3/2001 */ - { - s32 compositionOffset; - compositionOffset = 0; - if ( ctts ) - { - err = ctts->getOffsetForSampleNumber( (MP4AtomPtr) ctts, sampleNum, &compositionOffset ); if (err) goto bail; - } - *outSampleCTS = sampleDTS + compositionOffset; - } - if ( outSampleDTS ) - { - *outSampleDTS = sampleDTS; - } - if ( outSampleDuration ) - { - *outSampleDuration = sampleDuration; - } - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SoundMediaHeaderAtomPtr smhd; + u32 handlerType; + + err = MP4NoErr; + if((theMedia == NULL) || (outBalance == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + + err = MP4GetMediaHandlerDescription(theMedia, &handlerType, NULL); + if(err) goto bail; + if(handlerType != MP4AudioHandlerType) BAILWITHERROR(MP4NotImplementedErr) + + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + smhd = (MP4SoundMediaHeaderAtomPtr)minf->mediaHeader; + if(smhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + *outBalance = (s16)smhd->balance; +bail: + TEST_RETURN(err); + + return err; } -/* jlf 12/00: check a specific data ref */ -MP4_EXTERN ( MP4Err ) -MP4CheckMediaDataRef( MP4Media theMedia, u32 dataEntryIndex) +MP4_EXTERN(MP4Err) MP4GetMediaTimeScale(MP4Media theMedia, u32 *outTimeScale) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - - err = MP4NoErr; - if ( (theMedia == NULL) ) BAILWITHERROR( MP4BadParamErr ); - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) BAILWITHERROR( MP4InvalidMediaErr ); - dinf = (MP4DataInformationAtomPtr) minf->dataInformation; - if ( dinf == NULL ) BAILWITHERROR( MP4InvalidMediaErr ); - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) BAILWITHERROR( MP4InvalidMediaErr ); - - return minf->testDataEntry( minf, dataEntryIndex); + MP4Err err; + MP4MediaHeaderAtomPtr mediaHeader; + err = MP4NoErr; + if((theMedia == NULL) || (outTimeScale == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + mediaHeader = (MP4MediaHeaderAtomPtr)((MP4MediaAtomPtr)theMedia)->mediaHeader; + if(mediaHeader == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + *outTimeScale = mediaHeader->timeScale; bail: - return err; + TEST_RETURN(err); + + return err; } +MP4_EXTERN(MP4Err) MP4GetMediaDuration(MP4Media theMedia, u64 *outDuration) +{ + MP4Err err; + MP4MediaHeaderAtomPtr mediaHeader; + MP4MediaAtomPtr mdia; -/* Sample Auxiliary Information */ + err = MP4NoErr; + if((theMedia == NULL) || (outDuration == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)theMedia; + mediaHeader = (MP4MediaHeaderAtomPtr)(mdia)->mediaHeader; + if(mediaHeader == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + err = mdia->calculateDuration(mdia); + if(err) goto bail; + *outDuration = mediaHeader->duration; +bail: + TEST_RETURN(err); + return err; +} -MP4_EXTERN ( MP4Err ) -MP4SetupSampleAuxiliaryInformation( MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, - u8 default_sample_info_size ) +MP4_EXTERN(MP4Err) MP4GetMediaTrack(MP4Media theMedia, MP4Track *outTrack) { - MP4Err err; - MP4MediaAtomPtr mdia; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4SampleAuxiliaryInformationSizesAtomPtr saizExisting; - MP4SampleAuxiliaryInformationOffsetsAtomPtr saioExisting; - MP4SampleAuxiliaryInformationSizesAtomPtr saiz; - MP4SampleAuxiliaryInformationOffsetsAtomPtr saio; - - err = MP4NoErr; - mdia = NULL; - minf = NULL; - stbl = NULL; - - mdia = (MP4MediaAtomPtr) theMedia; - if (mdia == NULL) BAILWITHERROR( MP4BadParamErr ); - - minf = (MP4MediaInformationAtomPtr) mdia->information; - if (minf == NULL) BAILWITHERROR( MP4BadParamErr ); - - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if (stbl == NULL) BAILWITHERROR( MP4BadParamErr ); - - err = stbl->getSampleAuxiliaryInformation(stbl, isUsingAuxInfoPropertiesFlag, aux_info_type, aux_info_type_parameter, - &saizExisting, &saioExisting); if (err) goto bail; - - if (saizExisting != NULL) - BAILWITHERROR(MP4BadParamErr); - - err = MP4CreateSampleAuxiliaryInformationSizesAtom(&saiz); if (err) goto bail; - err = MP4CreateSampleAuxiliaryInformationOffsetsAtom(&saio); if (err) goto bail; - - if (isUsingAuxInfoPropertiesFlag != 0) - { - saiz->flags |= 1; - saio->flags |= 1; - saiz->aux_info_type = aux_info_type; - saio->aux_info_type = aux_info_type; - saiz->aux_info_type_parameter = aux_info_type_parameter; - saio->aux_info_type_parameter = aux_info_type_parameter; - } - - saiz->default_sample_info_size = default_sample_info_size; - - err = MP4AddListEntry(saiz, stbl->SampleAuxiliaryInformationSizes); if (err) goto bail; - err = MP4AddListEntry(saio, stbl->SampleAuxiliaryInformationOffsets); if (err) goto bail; + MP4Err err; + + err = MP4NoErr; + if((theMedia == NULL) || (outTrack == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + *outTrack = (MP4Track)((MP4MediaAtomPtr)theMedia)->mediaTrack; bail: - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4AddSampleAuxiliaryInformation( MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, - MP4Handle dataH, u32 sampleCount, MP4Handle sizesH ) +MP4_EXTERN(MP4Err) MP4GetMediaSampleCount(MP4Media theMedia, u32 *outCount) { - MP4Err err; - MP4MediaAtomPtr mdia; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4SampleAuxiliaryInformationSizesAtomPtr saiz; - MP4SampleAuxiliaryInformationOffsetsAtomPtr saio; - MP4TrackFragmentAtomPtr traf; - MP4DataInformationAtomPtr dinf; - MP4MediaDataAtomPtr mdat; - - u32 dataReferenceIndex; - u64 sampleOffset; - - err = MP4NoErr; - mdia = NULL; - minf = NULL; - stbl = NULL; - traf = NULL; - - if (sampleCount == 0) goto bail; - - mdia = (MP4MediaAtomPtr) theMedia; - if (mdia == NULL) BAILWITHERROR( MP4BadParamErr ); - - if (mdia->information->type == MP4MediaInformationAtomType) - { - minf = (MP4MediaInformationAtomPtr) mdia->information; - if (minf == NULL) BAILWITHERROR( MP4BadParamErr ); - - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if (stbl == NULL) BAILWITHERROR( MP4BadParamErr ); - - err = stbl->getSampleAuxiliaryInformation(stbl, isUsingAuxInfoPropertiesFlag, aux_info_type, aux_info_type_parameter, - &saiz, &saio); if (err) goto bail; - } - else if (mdia->information->type == MP4TrackFragmentAtomType) - { - traf = (MP4TrackFragmentAtomPtr) mdia->information; - if (traf == NULL) BAILWITHERROR( MP4BadParamErr ); - - err = traf->getSampleAuxiliaryInfoFromTrackFragment(traf, isUsingAuxInfoPropertiesFlag, aux_info_type, aux_info_type_parameter, - &saiz, &saio); if (err) goto bail; - } - - if (saiz == NULL) BAILWITHERROR( MP4BadParamErr ); - if (saio == NULL) BAILWITHERROR( MP4BadParamErr ); - - if (mdia->information->type == MP4MediaInformationAtomType) - { - dinf = (MP4DataInformationAtomPtr) minf->dataInformation; - if ( dinf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - err = stbl->getCurrentDataReferenceIndex( stbl, &dataReferenceIndex ); if (err) goto bail; - err = dinf->getOffset( dinf, dataReferenceIndex, &sampleOffset ); if (err) goto bail; - saio->totalOffset = sampleOffset; - - err = dinf->addSamples( dinf, sampleCount, dataReferenceIndex, dataH ); if (err) goto bail; - } - else if (mdia->information->type == MP4TrackFragmentAtomType) - { - mdat = traf->mdat; - saio->totalOffset = mdat->dataSize; - mdat->addData( mdat, dataH ); - } - else - if (traf == NULL) BAILWITHERROR( MP4BadParamErr ); - - err = saiz->addSizes((MP4AtomPtr) saiz, sampleCount, sizesH); if (err) goto bail; - err = saio->addOffsets((MP4AtomPtr) saio, sampleCount, sizesH); if (err) goto bail; + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4SampleSizeAtomPtr stsz; + + err = MP4NoErr; + if((theMedia == NULL) || (outCount == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stsz = (MP4SampleSizeAtomPtr)stbl->SampleSize; + if(stsz == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + *outCount = stsz->sampleCount; bail: - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetSampleAuxiliaryInformation( MP4Media theMedia, u32 *outCount, MP4Handle isUsingAuxInfoPropertiesFlags, - MP4Handle aux_info_types, MP4Handle aux_info_type_parameters ) +MP4_EXTERN(MP4Err) +MP4GetMediaSampleDescription(MP4Media theMedia, u32 index, MP4Handle outDescriptionH, + u32 *outDataReferenceIndex) { - MP4Err err; - MP4MediaAtomPtr mdia; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4SampleAuxiliaryInformationSizesAtomPtr saiz; - u32 i; - u8 *flags; - u32 *types; - u32 *parameters; - - - err = MP4NoErr; - mdia = NULL; - minf = NULL; - stbl = NULL; - - *outCount = 0; - - mdia = (MP4MediaAtomPtr) theMedia; - if (mdia == NULL) BAILWITHERROR( MP4BadParamErr ); - - minf = (MP4MediaInformationAtomPtr) mdia->information; - if (minf == NULL) BAILWITHERROR( MP4BadParamErr ); - - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if (stbl == NULL) BAILWITHERROR( MP4BadParamErr ); - - err = MP4SetHandleSize( isUsingAuxInfoPropertiesFlags, stbl->SampleAuxiliaryInformationSizes->entryCount * sizeof(u8) ); if (err) goto bail; - err = MP4SetHandleSize( aux_info_types, stbl->SampleAuxiliaryInformationSizes->entryCount * sizeof(u32) ); if (err) goto bail; - err = MP4SetHandleSize( aux_info_type_parameters, stbl->SampleAuxiliaryInformationSizes->entryCount * sizeof(u32) ); if (err) goto bail; - - flags = (u8*) isUsingAuxInfoPropertiesFlags; - types = (u32*) aux_info_types; - parameters = (u32*) aux_info_type_parameters; - - for (i = 0; i < stbl->SampleAuxiliaryInformationSizes->entryCount; i++) - { - err = MP4GetListEntry(stbl->SampleAuxiliaryInformationSizes, i, (char **) &saiz); if (err) goto bail; - - flags[i] = saiz->flags; - types[i] = saiz->aux_info_type; - parameters[i] = saiz->aux_info_type_parameter; - } - - *outCount = stbl->SampleAuxiliaryInformationSizes->entryCount; + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4SampleDescriptionAtomPtr stsd; + GenericSampleEntryAtomPtr entry; + + err = MP4NoErr; + if((theMedia == NULL) || (index == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stsd = (MP4SampleDescriptionAtomPtr)stbl->SampleDescription; + if(stsd == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + if(index > stsd->getEntryCount(stsd)) + { + BAILWITHERROR(MP4BadParamErr); + } + err = stsd->getEntry(stsd, index, &entry); + if(err) goto bail; + if(entry == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + if(outDescriptionH) + { + err = entry->calculateSize((MP4AtomPtr)entry); + if(err) goto bail; + err = MP4SetHandleSize(outDescriptionH, entry->size); + if(err) goto bail; + err = entry->serialize((MP4AtomPtr)entry, *outDescriptionH); + if(err) goto bail; + } + if(outDataReferenceIndex) + { + *outDataReferenceIndex = entry->dataReferenceIndex; + } bail: - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetSampleAuxiliaryInformationForSample( MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, u32 sampleNr, MP4Handle outDataH, u32 *outSize ) +MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr *outESD, + u32 *outDataReferenceIndex) { - MP4Err err; - MP4MediaAtomPtr mdia; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4SampleAuxiliaryInformationSizesAtomPtr saiz; - MP4SampleAuxiliaryInformationOffsetsAtomPtr saio; - MP4SampleToChunkAtomPtr stsc; - MP4DataHandlerPtr dhlr; - - u64 offset; - u32 sampleSize; - u32 chunkNumber; - u32 sampleDescriptionIndex; - u32 dataReferenceIndex; - u32 firstSampleNumberInChunk; - - err = MP4NoErr; - mdia = NULL; - minf = NULL; - stbl = NULL; - saiz = NULL; - saio = NULL; - *outSize = 0; - - mdia = (MP4MediaAtomPtr) theMedia; - if (mdia == NULL) BAILWITHERROR( MP4BadParamErr ); - - minf = (MP4MediaInformationAtomPtr) mdia->information; - if (minf == NULL) BAILWITHERROR( MP4BadParamErr ); - - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - if (stbl == NULL) BAILWITHERROR( MP4BadParamErr ); - - stsc = (MP4SampleToChunkAtomPtr) stbl->SampleToChunk; - if (stsc == NULL) BAILWITHERROR( MP4InvalidMediaErr ); - - err = stbl->getSampleAuxiliaryInformation(stbl, isUsingAuxInfoPropertiesFlag, aux_info_type, aux_info_type_parameter, - &saiz, &saio); if (err) goto bail; - - if (saiz == NULL) BAILWITHERROR( MP4BadParamErr ); - if (saio == NULL) BAILWITHERROR( MP4BadParamErr ); - - if (saiz->sample_count < sampleNr) BAILWITHERROR( MP4EOF ); - - err = stsc->lookupSample( stbl->SampleToChunk, sampleNr, - &chunkNumber, &sampleDescriptionIndex, &firstSampleNumberInChunk ); if (err) goto bail; - - err = MP4GetMediaSampleDescription( theMedia, sampleDescriptionIndex, NULL, &dataReferenceIndex ); if (err) goto bail; - err = minf->openDataHandler( (MP4AtomPtr) minf, dataReferenceIndex ); if (err) goto bail; - dhlr = (MP4DataHandlerPtr) minf->dataHandler; - - if (dhlr == NULL) BAILWITHERROR( MP4BadParamErr ); - - sampleSize = saiz->default_sample_info_size; - if (sampleSize == 0) - sampleSize = saiz->sample_info_sizes[sampleNr-1]; - - offset = saio->offsets[sampleNr -1]; - *outSize = sampleSize; - - err = MP4SetHandleSize( outDataH, sampleSize ); if (err) goto bail; - if (sampleSize > 0) - { - err = dhlr->copyData( dhlr, offset, *outDataH, sampleSize ); if (err) goto bail; - } - + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4SampleDescriptionAtomPtr stsd; + GenericSampleEntryAtomPtr entry; + MP4ESDAtomPtr ESD; + + err = MP4NoErr; + if((theMedia == NULL) || (index == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stsd = (MP4SampleDescriptionAtomPtr)stbl->SampleDescription; + if(stsd == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + if(index > stsd->getEntryCount(stsd)) + { + BAILWITHERROR(MP4BadParamErr); + } + err = stsd->getEntry(stsd, index, &entry); + if(err) goto bail; + if(entry == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + err = MP4GetListEntryAtom(entry->ExtensionAtomList, MP4ESDAtomType, (MP4AtomPtr *)&ESD); + if(err == MP4NotFoundErr) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + if(outESD) + { + MP4ES_DescriptorPtr esdDescriptor; + esdDescriptor = (MP4ES_DescriptorPtr)ESD->descriptor; + *outESD = esdDescriptor; + } + if(outDataReferenceIndex) + { + *outDataReferenceIndex = entry->dataReferenceIndex; + } +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) +MP4GetMediaDecoderConfig(MP4Media theMedia, u32 sampleDescIndex, MP4Handle decoderConfigH) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4SampleDescriptionAtomPtr stsd; + GenericSampleEntryAtomPtr entry; + MP4ES_DescriptorPtr esdDescriptor; + MP4DescriptorPtr decoderConfig; + MP4ESDAtomPtr ESD; + + err = MP4NoErr; + if((theMedia == NULL) || (sampleDescIndex == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stsd = (MP4SampleDescriptionAtomPtr)stbl->SampleDescription; + if(stsd == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + if(sampleDescIndex > stsd->getEntryCount(stsd)) + { + BAILWITHERROR(MP4BadParamErr); + } + err = stsd->getEntry(stsd, sampleDescIndex, &entry); + if(err) goto bail; + if(entry == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + err = MP4GetListEntryAtom(entry->ExtensionAtomList, MP4ESDAtomType, (MP4AtomPtr *)&ESD); + if(err == MP4NotFoundErr) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + esdDescriptor = (MP4ES_DescriptorPtr)ESD->descriptor; + if(esdDescriptor == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + decoderConfig = esdDescriptor->decoderConfig; + if(decoderConfig) + { + err = decoderConfig->calculateSize(decoderConfig); + if(err) goto bail; + err = MP4SetHandleSize(decoderConfigH, decoderConfig->size); + if(err) goto bail; + if(decoderConfig->size) + { + err = decoderConfig->serialize(decoderConfig, *decoderConfigH); + if(err) goto bail; + } + } + else + { + MP4SetHandleSize(decoderConfigH, 0); + } + +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) +MP4GetMediaDecoderType(MP4Media theMedia, u32 sampleDescIndex, u32 *outObjectType, + u32 *outStreamType, u32 *outBufferSize, MP4Handle specificInfoH) +{ + return MP4GetMediaDecoderInformation(theMedia, sampleDescIndex, outObjectType, outStreamType, + outBufferSize, NULL, /* upstream */ + NULL, /* max */ + NULL, /* avg */ + specificInfoH); +} + +MP4_EXTERN(MP4Err) +MP4GetMediaDecoderInformation(MP4Media theMedia, u32 sampleDescIndex, u32 *outObjectType, + u32 *outStreamType, u32 *outBufferSize, u32 *outUpstream, + u32 *outMaxBitrate, u32 *outAvgBitrate, MP4Handle specificInfoH) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4SampleDescriptionAtomPtr stsd; + GenericSampleEntryAtomPtr entry; + MP4ES_DescriptorPtr esdDescriptor; + MP4DecoderConfigDescriptorPtr decoderConfig; + MP4ESDAtomPtr ESD; + + err = MP4NoErr; + if((theMedia == NULL) || (sampleDescIndex == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stsd = (MP4SampleDescriptionAtomPtr)stbl->SampleDescription; + if(stsd == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + if(sampleDescIndex > stsd->getEntryCount(stsd)) + { + BAILWITHERROR(MP4BadParamErr); + } + err = stsd->getEntry(stsd, sampleDescIndex, &entry); + if(err) goto bail; + if(entry == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + err = MP4GetListEntryAtom(entry->ExtensionAtomList, MP4ESDAtomType, (MP4AtomPtr *)&ESD); + if(err == MP4NotFoundErr) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + esdDescriptor = (MP4ES_DescriptorPtr)ESD->descriptor; + if(esdDescriptor == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + decoderConfig = (MP4DecoderConfigDescriptorPtr)esdDescriptor->decoderConfig; + if(decoderConfig) + { + MP4DescriptorPtr specificInfo; + *outObjectType = decoderConfig->objectTypeIndication; + *outStreamType = decoderConfig->streamType; + *outBufferSize = decoderConfig->bufferSizeDB; + if(outUpstream) + { + *outUpstream = decoderConfig->upstream; + } + if(outMaxBitrate) + { + *outMaxBitrate = decoderConfig->maxBitrate; + } + if(outAvgBitrate) + { + *outAvgBitrate = decoderConfig->avgBitrate; + } + if(specificInfoH) + { + specificInfo = decoderConfig->decoderSpecificInfo; + if(specificInfo) + { + err = specificInfo->calculateSize(specificInfo); + if(err) goto bail; + err = MP4SetHandleSize(specificInfoH, specificInfo->size); + if(err) goto bail; + if(specificInfo->size) + { + u32 bytesSkipped; + char *cp = *specificInfoH; + err = specificInfo->serialize(specificInfo, *specificInfoH); + if(err) goto bail; + cp++; /* skip tag; */ + for(bytesSkipped = 1; *cp & 0x80;) + { + cp++; + bytesSkipped++; + if(bytesSkipped == specificInfo->size) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + } + bytesSkipped++; + /* rtm: changed memcpy to memmove, since memory may overlap */ + memmove(*specificInfoH, *specificInfoH + bytesSkipped, specificInfo->size - bytesSkipped); + err = MP4SetHandleSize(specificInfoH, specificInfo->size - bytesSkipped); + if(err) goto bail; + } + } + } + else + { + MP4SetHandleSize(specificInfoH, 0); + } + } + else + { + if(specificInfoH) + { + MP4SetHandleSize(specificInfoH, 0); + } + } + +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) MP4GetMediaDataRefCount(MP4Media theMedia, u32 *outCount) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + + err = MP4NoErr; + if((theMedia == NULL) || (outCount == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + dinf = (MP4DataInformationAtomPtr)minf->dataInformation; + if(dinf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + *outCount = dref->getEntryCount(dref); +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) MP4UseSignedCompositionTimeOffsets(MP4Media media) +{ + MP4Err err; + MP4MediaAtomPtr mdia; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + minf = (MP4MediaInformationAtomPtr)mdia->information; + if(minf == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + stbl->useSignedCompositionTimeOffsets = 1; +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) MP4CheckMediaDataReferences(MP4Media theMedia) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + u32 count; + u32 dataEntryIndex; + + err = MP4NoErr; + if((theMedia == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + dinf = (MP4DataInformationAtomPtr)minf->dataInformation; + if(dinf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + count = dref->getEntryCount(dref); + for(dataEntryIndex = 1; dataEntryIndex <= count; dataEntryIndex++) + { + err = minf->testDataEntry(minf, dataEntryIndex); + if(err) goto bail; + } +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) +MP4AddMediaDataReference(MP4Media theMedia, u32 *outReferenceIndex, MP4Handle urlHandle, + MP4Handle urnHandle) +{ + MP4Err MP4CreateDataEntryURLAtom(MP4DataEntryURLAtomPtr * outAtom); + MP4Err MP4CreateDataEntryURNAtom(MP4DataEntryURNAtomPtr * outAtom); + + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + + err = MP4NoErr; + if((theMedia == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + dinf = (MP4DataInformationAtomPtr)minf->dataInformation; + if(dinf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + if(urlHandle == NULL) + { + MP4Track track; + MP4Movie movie; + MP4PrivateMovieRecordPtr movieRecord; + MP4DataEntryURLAtomPtr url; + err = MP4GetMediaTrack(theMedia, &track); + if(err) goto bail; + err = MP4GetTrackMovie(track, &movie); + if(err) goto bail; + err = MP4CreateDataEntryURLAtom(&url); + if(err) goto bail; + movieRecord = (MP4PrivateMovieRecordPtr)movie; + + url->flags |= 1; + url->mdat = movieRecord->mdat; + err = dref->addDataEntry(dref, (MP4AtomPtr)url); + if(err) goto bail; + } + else if(urnHandle == NULL) + { + u32 sz; + MP4DataEntryURLAtomPtr url; + err = MP4CreateDataEntryURLAtom(&url); + if(err) goto bail; + err = MP4GetHandleSize(urlHandle, &sz); + if(err) goto bail; + url->locationLength = (u32)sz; + url->location = (char *)calloc(1, sz); + memcpy(url->location, *urlHandle, sz); + err = dref->addDataEntry(dref, (MP4AtomPtr)url); + if(err) goto bail; + } + else + { + u32 sz; + MP4DataEntryURNAtomPtr urn; + err = MP4CreateDataEntryURNAtom(&urn); + if(err) goto bail; + err = MP4GetHandleSize(urlHandle, &sz); + if(err) goto bail; + urn->locationLength = (u32)sz; + urn->location = (char *)calloc(1, sz); + memcpy(urn->location, *urlHandle, sz); + + err = MP4GetHandleSize(urnHandle, &sz); + if(err) goto bail; + urn->nameLength = (u32)sz; + urn->name = (char *)calloc(1, sz); + memcpy(urn->name, *urnHandle, sz); + err = dref->addDataEntry(dref, (MP4AtomPtr)urn); + if(err) goto bail; + } + *outReferenceIndex = dref->getEntryCount(dref); +bail: + TEST_RETURN(err); + return err; +} + +MP4_EXTERN(MP4Err) +MP4GetMediaDataReference(MP4Media theMedia, u32 index, MP4Handle referenceH, MP4Handle urnH, + u32 *outReferenceType, u32 *outReferenceAttributes) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + MP4DataEntryAtomPtr referenceAtom; + MP4DataEntryURLAtomPtr url; + MP4DataEntryURNAtomPtr urn; + u32 referenceType; + u32 referenceFlags; + + err = MP4NoErr; + if((theMedia == NULL) || (index == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + dinf = (MP4DataInformationAtomPtr)minf->dataInformation; + if(dinf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + if(index > dref->getEntryCount(dref)) + { + BAILWITHERROR(MP4BadParamErr); + } + err = dref->getEntry(dref, index, &referenceAtom); + if(err) goto bail; + if(referenceAtom == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + referenceType = referenceAtom->type; + referenceFlags = referenceAtom->flags; + if(outReferenceType) + { + *outReferenceType = referenceType; + } + if(outReferenceAttributes) + { + *outReferenceAttributes = referenceFlags; + } + if(referenceH || urnH) + { + switch(referenceType) + { + case MP4DataEntryURLAtomType: + if(referenceH) + { + url = (MP4DataEntryURLAtomPtr)referenceAtom; + err = MP4SetHandleSize(referenceH, url->locationLength); + if(err) goto bail; + if(url->locationLength) + { + memcpy(*referenceH, url->location, url->locationLength); + } + } + break; + + case MP4DataEntryURNAtomType: + if(referenceH) + { + url = (MP4DataEntryURLAtomPtr)referenceAtom; + err = MP4SetHandleSize(referenceH, url->locationLength); + if(err) goto bail; + if(url->locationLength) + { + memcpy(*referenceH, url->location, url->locationLength); + } + } + if(urnH) + { + urn = (MP4DataEntryURNAtomPtr)referenceAtom; + err = MP4SetHandleSize(referenceH, urn->nameLength); + if(err) goto bail; + if(urn->nameLength) + { + memcpy(*referenceH, urn->location, urn->nameLength); + } + } + break; + + default: + BAILWITHERROR(MP4InvalidMediaErr); + break; + } + } +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) +MP4GetMediaHandlerDescription(MP4Media theMedia, u32 *outType, MP4Handle *outName) +{ + MP4Err err; + MP4HandlerAtomPtr handler; + + err = MP4NoErr; + if((theMedia == NULL) || ((outType == NULL) && (outName == 0))) + { + BAILWITHERROR(MP4BadParamErr); + } + handler = (MP4HandlerAtomPtr)((MP4MediaAtomPtr)theMedia)->handler; + if(handler == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + if(outType) + { + *outType = handler->handlerType; + } + if(outName) + { + MP4Handle h; + err = MP4NewHandle(handler->nameLength, &h); + if(err) goto bail; + memcpy(*h, handler->nameUTF8, handler->nameLength); + *outName = h; + } +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) +MP4GetMediaNextInterestingTime(MP4Media theMedia, + u32 interestingTimeFlags, /* eg: MP4NextTimeMediaSample */ + u64 searchFromTime, /* in Media time scale */ + u32 searchDirection, /* eg: MP4NextTimeSearchForward */ + u64 *outInterestingTime, /* in Media time scale */ + u64 *outInterestingDuration /* in Media's time coordinate system */ +) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4TimeToSampleAtomPtr stts; + MP4SyncSampleAtomPtr stss; + s64 priorSample; + s64 exactSample; + s64 nextSample; + u32 sampleNumber; + s32 sampleDuration; + + err = MP4NoErr; + if((theMedia == NULL) || (interestingTimeFlags == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stts = (MP4TimeToSampleAtomPtr)stbl->TimeToSample; + if(stts == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stss = (MP4SyncSampleAtomPtr)stbl->SyncSample; + err = stts->findSamples(stbl->TimeToSample, searchFromTime, &priorSample, &exactSample, + &nextSample, &sampleNumber, &sampleDuration); + if(err) goto bail; + if(outInterestingTime) + { + if(searchDirection == MP4NextTimeSearchForward) + { + if((exactSample >= 0) && (interestingTimeFlags & MP4NextTimeEdgeOK)) + { + *outInterestingTime = exactSample; + } + else + { + *outInterestingTime = nextSample; + } + } + else + { + if((exactSample >= 0) && (interestingTimeFlags & MP4NextTimeEdgeOK)) + { + *outInterestingTime = exactSample; + } + else + { + *outInterestingTime = priorSample; + } + } + } + if(outInterestingDuration) + { + *outInterestingDuration = sampleDuration; + } + +bail: + TEST_RETURN(err); + + return err; +} + +MP4Err MP4GetMediaSampleDescIndex(MP4Media theMedia, u64 desiredTime, + u32 *outSampleDescriptionIndex) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4TimeToSampleAtomPtr stts; + MP4SyncSampleAtomPtr stss; + MP4SampleSizeAtomPtr stsz; + MP4SampleToChunkAtomPtr stsc; + + s64 priorSample; + s64 exactSample; + s64 nextSample; + u32 sampleNumber; + s32 sampleDuration; + u32 chunkNumber; + u32 sampleDescriptionIndex; + u32 firstSampleNumberInChunk; + + err = MP4NoErr; + if((theMedia == NULL) || (outSampleDescriptionIndex == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stts = (MP4TimeToSampleAtomPtr)stbl->TimeToSample; + if(stts == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stss = (MP4SyncSampleAtomPtr)stbl->SyncSample; + stsz = (MP4SampleSizeAtomPtr)stbl->SampleSize; + if(stsz == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stsc = (MP4SampleToChunkAtomPtr)stbl->SampleToChunk; + if(stsc == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + /* get sample number and time */ + err = stts->findSamples(stbl->TimeToSample, desiredTime, &priorSample, &exactSample, &nextSample, + &sampleNumber, &sampleDuration); + if(err) goto bail; + + /* get sample description */ + err = stsc->lookupSample(stbl->SampleToChunk, sampleNumber, &chunkNumber, &sampleDescriptionIndex, + &firstSampleNumberInChunk); + if(err) goto bail; + + *outSampleDescriptionIndex = sampleDescriptionIndex; +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) +MP4GetMediaSample(MP4Media theMedia, MP4Handle outSample, u32 *outSize, u64 desiredDecodingTime, + u64 *outDecodingTime, u64 *outCompositionTime, u64 *outDuration, + MP4Handle outSampleDescription, u32 *outSampleDescriptionIndex, + u32 *outSampleFlags) +{ + return MP4GetMediaSampleWithPad( + theMedia, outSample, outSize, desiredDecodingTime, outDecodingTime, outCompositionTime, + outDuration, outSampleDescription, outSampleDescriptionIndex, outSampleFlags, NULL); +} + +MP4_EXTERN(MP4Err) +MP4GetMediaSampleWithPad(MP4Media theMedia, MP4Handle outSample, u32 *outSize, + u64 desiredDecodingTime, u64 *outDecodingTime, u64 *outCompositionTime, + u64 *outDuration, MP4Handle outSampleDescription, + u32 *outSampleDescriptionIndex, u32 *outSampleFlags, u8 *outPad) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4TimeToSampleAtomPtr stts; + MP4CompositionOffsetAtomPtr ctts; + MP4SyncSampleAtomPtr stss; + MP4SampleSizeAtomPtr stsz; + MP4SampleToChunkAtomPtr stsc; + MP4ChunkOffsetAtomPtr stco; + MP4DataHandlerPtr dhlr; + MP4PaddingBitsAtomPtr padb; + + s64 priorSample; + s64 exactSample; + s64 nextSample; + u64 sampleDTS; + u32 sampleNumber; + s32 sampleDuration; + u32 sampleSize; + u32 chunkNumber; + u32 sampleDescriptionIndex; + u64 chunkOffset; + u32 dataReferenceIndex; + u32 firstSampleNumberInChunk; + u32 sampleOffsetWithinChunk; + + err = MP4NoErr; + if((theMedia == NULL) || (outSample == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stts = (MP4TimeToSampleAtomPtr)stbl->TimeToSample; + if(stts == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + ctts = (MP4CompositionOffsetAtomPtr)stbl->CompositionOffset; + stss = (MP4SyncSampleAtomPtr)stbl->SyncSample; + stsz = (MP4SampleSizeAtomPtr)stbl->SampleSize; + if(stsz == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stsc = (MP4SampleToChunkAtomPtr)stbl->SampleToChunk; + if(stsc == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stco = (MP4ChunkOffsetAtomPtr)stbl->ChunkOffset; + if(stco == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + padb = (MP4PaddingBitsAtomPtr)stbl->PaddingBits; + + /* get sample number and time */ + if(outSampleFlags) + { + *outSampleFlags = 0; + } + err = stts->findSamples(stbl->TimeToSample, desiredDecodingTime, &priorSample, &exactSample, + &nextSample, &sampleNumber, &sampleDuration); + if(err) goto bail; + + if(exactSample != -1) sampleDTS = exactSample; + else if(priorSample != -1) + sampleDTS = priorSample; + else + sampleDTS = nextSample; + + if(outCompositionTime) + { + s32 compositionTimeOffset; + compositionTimeOffset = 0; + if(ctts) + { + err = ctts->getOffsetForSampleNumber((MP4AtomPtr)ctts, sampleNumber, &compositionTimeOffset); + if(err) goto bail; + } + *outCompositionTime = sampleDTS + compositionTimeOffset; + } + + if(ctts && outSampleFlags) *outSampleFlags |= MP4MediaSampleHasCTSOffset; + + /* get sample description */ + err = stsc->lookupSample(stbl->SampleToChunk, sampleNumber, &chunkNumber, &sampleDescriptionIndex, + &firstSampleNumberInChunk); + if(err) goto bail; + + if(outSampleDescriptionIndex) + { + *outSampleDescriptionIndex = sampleDescriptionIndex; + } + + /* get sample size */ + err = stsz->getSampleSizeAndOffset(stbl->SampleSize, sampleNumber, &sampleSize, + firstSampleNumberInChunk, &sampleOffsetWithinChunk); + if(err) goto bail; + *outSize = sampleSize; + if(outPad) + { + if(padb) + { + err = padb->getSamplePad((MP4AtomPtr)padb, sampleNumber, outPad); + if(err) goto bail; + } + else + *outPad = 0xF8; + } + + /* get the chunk offset */ + err = stco->getChunkOffset(stbl->ChunkOffset, chunkNumber, &chunkOffset); + if(err) goto bail; + + /* get the sample */ + err = MP4GetMediaSampleDescription(theMedia, sampleDescriptionIndex, outSampleDescription, + &dataReferenceIndex); + if(err) goto bail; + err = minf->openDataHandler((MP4AtomPtr)minf, dataReferenceIndex); + if(err) goto bail; + dhlr = (MP4DataHandlerPtr)minf->dataHandler; + if(dhlr == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + /* finally we can get the sample */ + err = MP4SetHandleSize(outSample, sampleSize); + if(err) goto bail; + err = dhlr->copyData(dhlr, (chunkOffset + sampleOffsetWithinChunk), *outSample, sampleSize); + if(err) goto bail; + + /* sync sample test */ + if(outSampleFlags) + { + if(stss) + { + u32 sync; + err = stss->isSyncSample(stbl->SyncSample, sampleNumber, &sync); + if(err) goto bail; + *outSampleFlags |= sync ? 0 : MP4MediaSampleNotSync; + } + } + if(outDecodingTime) + { + *outDecodingTime = sampleDTS; /* was exactSample ? exactSample : nextSample; but exactsample + fails to -1 --dws */ + } + if(outDuration) + { + *outDuration = sampleDuration; + } + +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) +MP4GetIndMediaSample(MP4Media theMedia, u32 sampleNumber, MP4Handle outSample, u32 *outSize, + u64 *outDTS, s32 *outCTSOffset, u64 *outDuration, u32 *outSampleFlags, + u32 *outSampleDescIndex) +{ + return MP4GetIndMediaSampleWithPad(theMedia, sampleNumber, outSample, outSize, outDTS, + outCTSOffset, outDuration, outSampleFlags, outSampleDescIndex, + NULL); +} + +MP4_EXTERN(MP4Err) +MP4GetIndMediaSampleWithPad(MP4Media theMedia, u32 sampleNumber, MP4Handle outSample, u32 *outSize, + u64 *outDTS, s32 *outCTSOffset, u64 *outDuration, u32 *outSampleFlags, + u32 *outSampleDescIndex, u8 *outPad) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4TimeToSampleAtomPtr stts; + MP4CompositionOffsetAtomPtr ctts; + MP4SyncSampleAtomPtr stss; + MP4SampleSizeAtomPtr stsz; + MP4SampleToChunkAtomPtr stsc; + MP4ChunkOffsetAtomPtr stco; + MP4DataHandlerPtr dhlr; + MP4PaddingBitsAtomPtr padb; + + u64 sampleDTS; + + s32 sampleDuration; + u32 sampleSize; + u32 chunkNumber; + u32 sampleDescriptionIndex; + u64 chunkOffset; + u32 dataReferenceIndex; + u32 firstSampleNumberInChunk; + u32 sampleOffsetWithinChunk; + + err = MP4NoErr; + if((theMedia == NULL) || (outSample == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stts = (MP4TimeToSampleAtomPtr)stbl->TimeToSample; + if(stts == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + ctts = (MP4CompositionOffsetAtomPtr)stbl->CompositionOffset; + stss = (MP4SyncSampleAtomPtr)stbl->SyncSample; + stsz = (MP4SampleSizeAtomPtr)stbl->SampleSize; + if(stsz == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stsc = (MP4SampleToChunkAtomPtr)stbl->SampleToChunk; + if(stsc == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stco = (MP4ChunkOffsetAtomPtr)stbl->ChunkOffset; + if(stco == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + padb = (MP4PaddingBitsAtomPtr)stbl->PaddingBits; + + if(outSampleFlags) + { + *outSampleFlags = 0; + } + /* get sample DTS */ + err = stts->getTimeForSampleNumber(stbl->TimeToSample, sampleNumber, &sampleDTS, &sampleDuration); + if(err) goto bail; + + if(outSampleFlags && ctts) *outSampleFlags |= MP4MediaSampleHasCTSOffset; + + if(outCTSOffset) + { + s32 compositionOffset; + compositionOffset = 0; + if(ctts) + { + err = ctts->getOffsetForSampleNumber((MP4AtomPtr)ctts, sampleNumber, &compositionOffset); + if(err) goto bail; + } + *outCTSOffset = compositionOffset; + } + + /* get sample description */ + err = stsc->lookupSample(stbl->SampleToChunk, sampleNumber, &chunkNumber, &sampleDescriptionIndex, + &firstSampleNumberInChunk); + if(err) goto bail; + + /* get sample size */ + err = stsz->getSampleSizeAndOffset(stbl->SampleSize, sampleNumber, &sampleSize, + firstSampleNumberInChunk, &sampleOffsetWithinChunk); + if(err) goto bail; + *outSize = sampleSize; + if(outPad) + { + if(padb) + { + err = padb->getSamplePad((MP4AtomPtr)padb, sampleNumber, outPad); + if(err) goto bail; + } + else + *outPad = 0xF8; + } + + /* get the chunk offset */ + err = stco->getChunkOffset(stbl->ChunkOffset, chunkNumber, &chunkOffset); + if(err) goto bail; + + /* get the sample */ + err = MP4GetMediaSampleDescription(theMedia, sampleDescriptionIndex, NULL, &dataReferenceIndex); + if(err) goto bail; + err = minf->openDataHandler((MP4AtomPtr)minf, dataReferenceIndex); + if(err) goto bail; + dhlr = (MP4DataHandlerPtr)minf->dataHandler; + if(dhlr == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + /* finally we can get the sample */ + err = MP4SetHandleSize(outSample, sampleSize); + if(err) goto bail; + if(sampleSize > 0) + { + err = dhlr->copyData(dhlr, (chunkOffset + sampleOffsetWithinChunk), *outSample, sampleSize); + if(err) goto bail; + } + if(outSampleDescIndex) + { + *outSampleDescIndex = sampleDescriptionIndex; + } + + /* sync sample test */ + if(outSampleFlags) + { + if(stss) + { + u32 sync; + err = stss->isSyncSample(stbl->SyncSample, sampleNumber, &sync); + if(err) goto bail; + *outSampleFlags |= sync ? 0 : MP4MediaSampleNotSync; + } + } + + if(outDTS) + { + *outDTS = sampleDTS; + } + if(outDuration) + { + *outDuration = sampleDuration; + } + +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) +MP4GetIndMediaSampleReference(MP4Media theMedia, u32 sampleNumber, u32 *outOffset, u32 *outSize, + u32 *outDuration, u32 *outSampleFlags, u32 *outSampleDescIndex, + MP4Handle sampleDesc) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4TimeToSampleAtomPtr stts; + MP4CompositionOffsetAtomPtr ctts; + MP4SyncSampleAtomPtr stss; + MP4SampleSizeAtomPtr stsz; + MP4SampleToChunkAtomPtr stsc; + MP4ChunkOffsetAtomPtr stco; + + u64 sampleDTS; + + s32 sampleDuration; + u32 sampleSize; + u32 chunkNumber; + u32 sampleDescriptionIndex; + u64 chunkOffset; + u32 dataReferenceIndex; + u32 firstSampleNumberInChunk; + u32 sampleOffsetWithinChunk; + + err = MP4NoErr; + if((theMedia == NULL) || (sampleNumber == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stts = (MP4TimeToSampleAtomPtr)stbl->TimeToSample; + if(stts == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + ctts = (MP4CompositionOffsetAtomPtr)stbl->CompositionOffset; + stss = (MP4SyncSampleAtomPtr)stbl->SyncSample; + stsz = (MP4SampleSizeAtomPtr)stbl->SampleSize; + if(stsz == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stsc = (MP4SampleToChunkAtomPtr)stbl->SampleToChunk; + if(stsc == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stco = (MP4ChunkOffsetAtomPtr)stbl->ChunkOffset; + if(stco == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + + if(outSampleFlags) + { + *outSampleFlags = 0; + } + /* get sample DTS */ + err = stts->getTimeForSampleNumber(stbl->TimeToSample, sampleNumber, &sampleDTS, &sampleDuration); + if(err) goto bail; + if(ctts && outSampleFlags) + { + *outSampleFlags |= MP4MediaSampleHasCTSOffset; + } + + /* get sample description */ + err = stsc->lookupSample(stbl->SampleToChunk, sampleNumber, &chunkNumber, &sampleDescriptionIndex, + &firstSampleNumberInChunk); + if(err) goto bail; + + /* get sample size */ + err = stsz->getSampleSizeAndOffset(stbl->SampleSize, sampleNumber, &sampleSize, + firstSampleNumberInChunk, &sampleOffsetWithinChunk); + if(err) goto bail; + *outSize = sampleSize; + + /* get the chunk offset */ + err = stco->getChunkOffset(stbl->ChunkOffset, chunkNumber, &chunkOffset); + if(err) goto bail; + + /* get the sample description */ + err = MP4GetMediaSampleDescription(theMedia, sampleDescriptionIndex, sampleDesc, + &dataReferenceIndex); + if(err) goto bail; + + if(outOffset) + { + *outOffset = (u32)chunkOffset + sampleOffsetWithinChunk; + } + if(outSampleDescIndex) + { + *outSampleDescIndex = sampleDescriptionIndex; + } + /* sync sample test */ + if(outSampleFlags) + { + if(stss) + { + u32 sync; + err = stss->isSyncSample(stbl->SyncSample, sampleNumber, &sync); + if(err) goto bail; + *outSampleFlags |= sync ? 0 : MP4MediaSampleNotSync; + } + } + if(outDuration) + { + *outDuration = sampleDuration; + } + +bail: + TEST_RETURN(err); + return err; +} + +MP4_EXTERN(MP4Err) +MP4MediaTimeToSampleNum(MP4Media theMedia, u64 mediaTime, u32 *outSampleNum, u64 *outSampleCTS, + u64 *outSampleDTS, s32 *outSampleDuration) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4TimeToSampleAtomPtr stts; + MP4CompositionOffsetAtomPtr ctts; + + s64 priorSample; + s64 exactSample; + s64 nextSample; + u64 sampleDTS; + u32 sampleNumber; + s32 sampleDuration; + + err = MP4NoErr; + if((theMedia == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stts = (MP4TimeToSampleAtomPtr)stbl->TimeToSample; + if(stts == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + ctts = (MP4CompositionOffsetAtomPtr)stbl->CompositionOffset; + /* get sample number and time */ + sampleNumber = 0; + err = stts->findSamples(stbl->TimeToSample, mediaTime, &priorSample, &exactSample, &nextSample, + &sampleNumber, &sampleDuration); + if(err) goto bail; + + if(exactSample != -1) sampleDTS = exactSample; + else + { + if(priorSample != -1) sampleDTS = priorSample; + else + sampleDTS = nextSample; + err = stts->findSamples(stbl->TimeToSample, sampleDTS, &priorSample, &exactSample, &nextSample, + &sampleNumber, &sampleDuration); + if(err) goto bail; + if((sampleDTS == -1) || (sampleNumber == 0)) BAILWITHERROR(MP4InternalErr) + else + sampleDTS = exactSample; + } + if(outSampleCTS) /* was DTS, changed dws 9/3/2001, changed also - to +, if order, and decoding to + composition offset */ + { + s32 compositionOffset; + compositionOffset = 0; + if(ctts) + { + err = ctts->getOffsetForSampleNumber((MP4AtomPtr)ctts, sampleNumber, &compositionOffset); + if(err) goto bail; + } + *outSampleCTS = sampleDTS + compositionOffset; + } + if(outSampleNum) + { + *outSampleNum = sampleNumber; + } + if(outSampleDTS) /* was CTS, changed DWS 9/3/2001 */ + { + *outSampleDTS = sampleDTS; + } + if(outSampleDuration) + { + *outSampleDuration = sampleDuration; + } + +bail: + TEST_RETURN(err); + + return err; +} + +MP4_EXTERN(MP4Err) +MP4SampleNumToMediaTime(MP4Media theMedia, u32 sampleNum, u64 *outSampleCTS, u64 *outSampleDTS, + s32 *outSampleDuration) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4TimeToSampleAtomPtr stts; + MP4CompositionOffsetAtomPtr ctts; + s32 sampleDuration; + u64 sampleDTS; + + err = MP4NoErr; + if((theMedia == NULL) || (sampleNum == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stts = (MP4TimeToSampleAtomPtr)stbl->TimeToSample; + if(stts == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + ctts = (MP4CompositionOffsetAtomPtr)stbl->CompositionOffset; + /* get sample time and duration */ + err = stts->getTimeForSampleNumber(stbl->TimeToSample, sampleNum, &sampleDTS, &sampleDuration); + if(err) goto bail; + /* was sampleCTS, changed dws 9/3/2001 */ + + if(outSampleCTS) /* was DTS, decoding offset, ifs in other order, and -; all changed dws 9/3/2001 + */ + { + s32 compositionOffset; + compositionOffset = 0; + if(ctts) + { + err = ctts->getOffsetForSampleNumber((MP4AtomPtr)ctts, sampleNum, &compositionOffset); + if(err) goto bail; + } + *outSampleCTS = sampleDTS + compositionOffset; + } + if(outSampleDTS) + { + *outSampleDTS = sampleDTS; + } + if(outSampleDuration) + { + *outSampleDuration = sampleDuration; + } +bail: + TEST_RETURN(err); + + return err; +} + +/* jlf 12/00: check a specific data ref */ +MP4_EXTERN(MP4Err) +MP4CheckMediaDataRef(MP4Media theMedia, u32 dataEntryIndex) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + + err = MP4NoErr; + if((theMedia == NULL)) BAILWITHERROR(MP4BadParamErr); + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + dinf = (MP4DataInformationAtomPtr)minf->dataInformation; + if(dinf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + return minf->testDataEntry(minf, dataEntryIndex); + +bail: + return err; +} + +/* Sample Auxiliary Information */ + +MP4_EXTERN(MP4Err) +MP4SetupSampleAuxiliaryInformation(MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, + u32 aux_info_type, u32 aux_info_type_parameter, + u8 default_sample_info_size) +{ + MP4Err err; + MP4MediaAtomPtr mdia; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4SampleAuxiliaryInformationSizesAtomPtr saizExisting; + MP4SampleAuxiliaryInformationOffsetsAtomPtr saioExisting; + MP4SampleAuxiliaryInformationSizesAtomPtr saiz; + MP4SampleAuxiliaryInformationOffsetsAtomPtr saio; + + err = MP4NoErr; + mdia = NULL; + minf = NULL; + stbl = NULL; + + mdia = (MP4MediaAtomPtr)theMedia; + if(mdia == NULL) BAILWITHERROR(MP4BadParamErr); + + minf = (MP4MediaInformationAtomPtr)mdia->information; + if(minf == NULL) BAILWITHERROR(MP4BadParamErr); + + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) BAILWITHERROR(MP4BadParamErr); + + err = stbl->getSampleAuxiliaryInformation(stbl, isUsingAuxInfoPropertiesFlag, aux_info_type, + aux_info_type_parameter, &saizExisting, &saioExisting); + if(err) goto bail; + + if(saizExisting != NULL) BAILWITHERROR(MP4BadParamErr); + + err = MP4CreateSampleAuxiliaryInformationSizesAtom(&saiz); + if(err) goto bail; + err = MP4CreateSampleAuxiliaryInformationOffsetsAtom(&saio); + if(err) goto bail; + + if(isUsingAuxInfoPropertiesFlag != 0) + { + saiz->flags |= 1; + saio->flags |= 1; + saiz->aux_info_type = aux_info_type; + saio->aux_info_type = aux_info_type; + saiz->aux_info_type_parameter = aux_info_type_parameter; + saio->aux_info_type_parameter = aux_info_type_parameter; + } + + saiz->default_sample_info_size = default_sample_info_size; + + err = MP4AddListEntry(saiz, stbl->SampleAuxiliaryInformationSizes); + if(err) goto bail; + err = MP4AddListEntry(saio, stbl->SampleAuxiliaryInformationOffsets); + if(err) goto bail; +bail: + return err; +} + +MP4_EXTERN(MP4Err) +MP4AddSampleAuxiliaryInformation(MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, + u32 aux_info_type, u32 aux_info_type_parameter, MP4Handle dataH, + u32 sampleCount, MP4Handle sizesH) +{ + MP4Err err; + MP4MediaAtomPtr mdia; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4SampleAuxiliaryInformationSizesAtomPtr saiz; + MP4SampleAuxiliaryInformationOffsetsAtomPtr saio; + MP4TrackFragmentAtomPtr traf; + MP4DataInformationAtomPtr dinf; + MP4MediaDataAtomPtr mdat; + + u32 dataReferenceIndex; + u64 sampleOffset; + + err = MP4NoErr; + mdia = NULL; + minf = NULL; + stbl = NULL; + traf = NULL; + + if(sampleCount == 0) goto bail; + + mdia = (MP4MediaAtomPtr)theMedia; + if(mdia == NULL) BAILWITHERROR(MP4BadParamErr); + + if(mdia->information->type == MP4MediaInformationAtomType) + { + minf = (MP4MediaInformationAtomPtr)mdia->information; + if(minf == NULL) BAILWITHERROR(MP4BadParamErr); + + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) BAILWITHERROR(MP4BadParamErr); + + err = stbl->getSampleAuxiliaryInformation(stbl, isUsingAuxInfoPropertiesFlag, aux_info_type, + aux_info_type_parameter, &saiz, &saio); + if(err) goto bail; + } + else if(mdia->information->type == MP4TrackFragmentAtomType) + { + traf = (MP4TrackFragmentAtomPtr)mdia->information; + if(traf == NULL) BAILWITHERROR(MP4BadParamErr); + + err = traf->getSampleAuxiliaryInfoFromTrackFragment( + traf, isUsingAuxInfoPropertiesFlag, aux_info_type, aux_info_type_parameter, &saiz, &saio); + if(err) goto bail; + } + + if(saiz == NULL) BAILWITHERROR(MP4BadParamErr); + if(saio == NULL) BAILWITHERROR(MP4BadParamErr); + + if(mdia->information->type == MP4MediaInformationAtomType) + { + dinf = (MP4DataInformationAtomPtr)minf->dataInformation; + if(dinf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + err = stbl->getCurrentDataReferenceIndex(stbl, &dataReferenceIndex); + if(err) goto bail; + err = dinf->getOffset(dinf, dataReferenceIndex, &sampleOffset); + if(err) goto bail; + saio->totalOffset = sampleOffset; + + err = dinf->addSamples(dinf, sampleCount, dataReferenceIndex, dataH); + if(err) goto bail; + } + else if(mdia->information->type == MP4TrackFragmentAtomType) + { + mdat = traf->mdat; + saio->totalOffset = mdat->dataSize; + mdat->addData(mdat, dataH); + } + else if(traf == NULL) + BAILWITHERROR(MP4BadParamErr); + + err = saiz->addSizes((MP4AtomPtr)saiz, sampleCount, sizesH); + if(err) goto bail; + err = saio->addOffsets((MP4AtomPtr)saio, sampleCount, sizesH); + if(err) goto bail; +bail: + return err; +} + +MP4_EXTERN(MP4Err) +MP4GetSampleAuxiliaryInformation(MP4Media theMedia, u32 *outCount, + MP4Handle isUsingAuxInfoPropertiesFlags, MP4Handle aux_info_types, + MP4Handle aux_info_type_parameters) +{ + MP4Err err; + MP4MediaAtomPtr mdia; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4SampleAuxiliaryInformationSizesAtomPtr saiz; + u32 i; + u8 *flags; + u32 *types; + u32 *parameters; + + err = MP4NoErr; + mdia = NULL; + minf = NULL; + stbl = NULL; + + *outCount = 0; + + mdia = (MP4MediaAtomPtr)theMedia; + if(mdia == NULL) BAILWITHERROR(MP4BadParamErr); + + minf = (MP4MediaInformationAtomPtr)mdia->information; + if(minf == NULL) BAILWITHERROR(MP4BadParamErr); + + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) BAILWITHERROR(MP4BadParamErr); + + err = MP4SetHandleSize(isUsingAuxInfoPropertiesFlags, + stbl->SampleAuxiliaryInformationSizes->entryCount * sizeof(u8)); + if(err) goto bail; + err = MP4SetHandleSize(aux_info_types, + stbl->SampleAuxiliaryInformationSizes->entryCount * sizeof(u32)); + if(err) goto bail; + err = MP4SetHandleSize(aux_info_type_parameters, + stbl->SampleAuxiliaryInformationSizes->entryCount * sizeof(u32)); + if(err) goto bail; + + flags = (u8 *)isUsingAuxInfoPropertiesFlags; + types = (u32 *)aux_info_types; + parameters = (u32 *)aux_info_type_parameters; + + for(i = 0; i < stbl->SampleAuxiliaryInformationSizes->entryCount; i++) + { + err = MP4GetListEntry(stbl->SampleAuxiliaryInformationSizes, i, (char **)&saiz); + if(err) goto bail; + + flags[i] = saiz->flags; + types[i] = saiz->aux_info_type; + parameters[i] = saiz->aux_info_type_parameter; + } + + *outCount = stbl->SampleAuxiliaryInformationSizes->entryCount; +bail: + return err; +} + +MP4_EXTERN(MP4Err) +MP4GetSampleAuxiliaryInformationForSample(MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, + u32 aux_info_type, u32 aux_info_type_parameter, + u32 sampleNr, MP4Handle outDataH, u32 *outSize) +{ + MP4Err err; + MP4MediaAtomPtr mdia; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4SampleAuxiliaryInformationSizesAtomPtr saiz; + MP4SampleAuxiliaryInformationOffsetsAtomPtr saio; + MP4SampleToChunkAtomPtr stsc; + MP4DataHandlerPtr dhlr; + + u64 offset; + u32 sampleSize; + u32 chunkNumber; + u32 sampleDescriptionIndex; + u32 dataReferenceIndex; + u32 firstSampleNumberInChunk; + + err = MP4NoErr; + mdia = NULL; + minf = NULL; + stbl = NULL; + saiz = NULL; + saio = NULL; + *outSize = 0; + + mdia = (MP4MediaAtomPtr)theMedia; + if(mdia == NULL) BAILWITHERROR(MP4BadParamErr); + + minf = (MP4MediaInformationAtomPtr)mdia->information; + if(minf == NULL) BAILWITHERROR(MP4BadParamErr); + + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) BAILWITHERROR(MP4BadParamErr); + + stsc = (MP4SampleToChunkAtomPtr)stbl->SampleToChunk; + if(stsc == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + err = stbl->getSampleAuxiliaryInformation(stbl, isUsingAuxInfoPropertiesFlag, aux_info_type, + aux_info_type_parameter, &saiz, &saio); + if(err) goto bail; + + if(saiz == NULL) BAILWITHERROR(MP4BadParamErr); + if(saio == NULL) BAILWITHERROR(MP4BadParamErr); + + if(saiz->sample_count < sampleNr) BAILWITHERROR(MP4EOF); + + err = stsc->lookupSample(stbl->SampleToChunk, sampleNr, &chunkNumber, &sampleDescriptionIndex, + &firstSampleNumberInChunk); + if(err) goto bail; + + err = MP4GetMediaSampleDescription(theMedia, sampleDescriptionIndex, NULL, &dataReferenceIndex); + if(err) goto bail; + err = minf->openDataHandler((MP4AtomPtr)minf, dataReferenceIndex); + if(err) goto bail; + dhlr = (MP4DataHandlerPtr)minf->dataHandler; + + if(dhlr == NULL) BAILWITHERROR(MP4BadParamErr); + + sampleSize = saiz->default_sample_info_size; + if(sampleSize == 0) sampleSize = saiz->sample_info_sizes[sampleNr - 1]; + + offset = saio->offsets[sampleNr - 1]; + *outSize = sampleSize; + + err = MP4SetHandleSize(outDataH, sampleSize); + if(err) goto bail; + if(sampleSize > 0) + { + err = dhlr->copyData(dhlr, offset, *outDataH, sampleSize); + if(err) goto bail; + } + bail: - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4MemoryInputStream.c b/IsoLib/libisomediafile/src/MP4MemoryInputStream.c index b8b4625..2982d5c 100644 --- a/IsoLib/libisomediafile/src/MP4MemoryInputStream.c +++ b/IsoLib/libisomediafile/src/MP4MemoryInputStream.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,210 +15,218 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4MemoryInputStream.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4MemoryInputStream.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4InputStream.h" #include "MP4Impl.h" #include #include -static MP4Err readData( struct MP4InputStreamRecord *s, u64 bytes, char *outData, char *msg ); +static MP4Err readData(struct MP4InputStreamRecord *s, u64 bytes, char *outData, char *msg); -#define CHECK_AVAIL( bytes ) \ - if ( self->available < bytes ) \ - { \ - err = MP4IOErr; \ - goto bail; \ - } +#define CHECK_AVAIL(bytes) \ + if(self->available < bytes) \ + { \ + err = MP4IOErr; \ + goto bail; \ + } -static void doIndent( struct MP4InputStreamRecord *self ) +static void doIndent(struct MP4InputStreamRecord *self) { - u32 i; - for ( i = 0; i < self->indent; i++ ) - fprintf( stdout, " " ); + u32 i; + for(i = 0; i < self->indent; i++) + fprintf(stdout, " "); } -static void msg( struct MP4InputStreamRecord *self, char *msg ) +static void msg(struct MP4InputStreamRecord *self, char *msg) { - if ( self->debugging ) - { - doIndent( self ); - fprintf( stdout, "%s\n", msg ); - } + if(self->debugging) + { + doIndent(self); + fprintf(stdout, "%s\n", msg); + } } -static void destroy( struct MP4InputStreamRecord *s ) +static void destroy(struct MP4InputStreamRecord *s) { - MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr) s; + MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr)s; - if ( self ) - if ( self->mapping ) - self->mapping->destroy( self->mapping ); + if(self) + if(self->mapping) self->mapping->destroy(self->mapping); - free(s); + free(s); } -static FileMappingObject getFileMappingObject( struct MP4InputStreamRecord *s ) +static FileMappingObject getFileMappingObject(struct MP4InputStreamRecord *s) { - MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr) s; - return self->mapping; + MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr)s; + return self->mapping; } -static MP4Err read8( struct MP4InputStreamRecord *s, u32 *outVal, char *msg ) +static MP4Err read8(struct MP4InputStreamRecord *s, u32 *outVal, char *msg) { - MP4Err err; - u8 val; - MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr) s; - err = MP4NoErr; - if ( (s == 0) || (outVal == 0) ) - BAILWITHERROR( MP4BadParamErr ); - err = readData( s, 1, (char*) &val, NULL ); - *outVal = val; - if ( msg && self->debugging ) - { - doIndent( s ); - fprintf( stdout, "%s = %d\n", msg, val ); - } + MP4Err err; + u8 val; + MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr)s; + err = MP4NoErr; + if((s == 0) || (outVal == 0)) BAILWITHERROR(MP4BadParamErr); + err = readData(s, 1, (char *)&val, NULL); + *outVal = val; + if(msg && self->debugging) + { + doIndent(s); + fprintf(stdout, "%s = %d\n", msg, val); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err read16( struct MP4InputStreamRecord *s, u32 *outVal, char *msg ) +static MP4Err read16(struct MP4InputStreamRecord *s, u32 *outVal, char *msg) { - u8 a; - int val; - MP4Err err; - MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr) s; - err = MP4NoErr; - CHECK_AVAIL( 2 ) - err = readData( s, 1, (char *) &a, NULL ); if (err) goto bail; - val = a << 8; - err = readData( s, 1, (char *) &a, NULL ); if (err) goto bail; - val |= a; - *outVal = val; - if ( msg && self->debugging ) - { - doIndent( s ); - fprintf( stdout, "%s = %d\n", msg, val ); - } + u8 a; + int val; + MP4Err err; + MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr)s; + err = MP4NoErr; + CHECK_AVAIL(2) + err = readData(s, 1, (char *)&a, NULL); + if(err) goto bail; + val = a << 8; + err = readData(s, 1, (char *)&a, NULL); + if(err) goto bail; + val |= a; + *outVal = val; + if(msg && self->debugging) + { + doIndent(s); + fprintf(stdout, "%s = %d\n", msg, val); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err read32( struct MP4InputStreamRecord *s, u32 *outVal, char *msg ) +static MP4Err read32(struct MP4InputStreamRecord *s, u32 *outVal, char *msg) { - unsigned int hw; - unsigned int lw; - MP4Err err; - MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr) s; - err = MP4NoErr; - CHECK_AVAIL( 4 ) - err = read16( s, &hw, NULL ); if (err) goto bail; - err = read16( s, &lw, NULL ); if (err) goto bail; - *outVal = (hw << 16) | lw; - if ( msg && self->debugging ) - { - doIndent( s ); - fprintf( stdout, "%s = %d\n", msg, *outVal ); - } + unsigned int hw; + unsigned int lw; + MP4Err err; + MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr)s; + err = MP4NoErr; + CHECK_AVAIL(4) + err = read16(s, &hw, NULL); + if(err) goto bail; + err = read16(s, &lw, NULL); + if(err) goto bail; + *outVal = (hw << 16) | lw; + if(msg && self->debugging) + { + doIndent(s); + fprintf(stdout, "%s = %d\n", msg, *outVal); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err skipData( struct MP4InputStreamRecord *s, u64 bytes, char *msg ) +static MP4Err skipData(struct MP4InputStreamRecord *s, u64 bytes, char *msg) { - MP4Err err; - MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr) s; - u32 to_read; - - if (bytes >> 32) { BAILWITHERROR( MP4NotImplementedErr ); } - to_read = (u32) bytes; - - err = MP4NoErr; - CHECK_AVAIL( bytes ) - - self->ptr += to_read; - self->available -= to_read; - if ( msg && self->debugging ) - { - doIndent( s ); - fprintf( stdout, "%s = [%d bytes of data skipped]\n", msg, to_read ); - } + MP4Err err; + MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr)s; + u32 to_read; + + if(bytes >> 32) + { + BAILWITHERROR(MP4NotImplementedErr); + } + to_read = (u32)bytes; + + err = MP4NoErr; + CHECK_AVAIL(bytes) + + self->ptr += to_read; + self->available -= to_read; + if(msg && self->debugging) + { + doIndent(s); + fprintf(stdout, "%s = [%d bytes of data skipped]\n", msg, to_read); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err readData( struct MP4InputStreamRecord *s, u64 bytes, char *outData, char *msg ) +static MP4Err readData(struct MP4InputStreamRecord *s, u64 bytes, char *outData, char *msg) { - MP4Err err; - MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr) s; - u32 to_read; - - if (bytes >> 32) { BAILWITHERROR( MP4NotImplementedErr ); } - to_read = (u32) bytes; - - err = MP4NoErr; - CHECK_AVAIL( bytes ) - memcpy( outData, self->ptr, to_read ); - self->ptr += to_read; - self->available -= to_read; - if ( msg && self->debugging ) - { - doIndent( s ); - fprintf( stdout, "%s = [%d bytes of data]\n", msg, to_read ); - } + MP4Err err; + MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr)s; + u32 to_read; + + if(bytes >> 32) + { + BAILWITHERROR(MP4NotImplementedErr); + } + to_read = (u32)bytes; + + err = MP4NoErr; + CHECK_AVAIL(bytes) + memcpy(outData, self->ptr, to_read); + self->ptr += to_read; + self->available -= to_read; + if(msg && self->debugging) + { + doIndent(s); + fprintf(stdout, "%s = [%d bytes of data]\n", msg, to_read); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static u64 getStreamOffset( struct MP4InputStreamRecord *s ) +static u64 getStreamOffset(struct MP4InputStreamRecord *s) { - MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr) s; - return (self->ptr) - (self->base); + MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr)s; + return (self->ptr) - (self->base); } -MP4Err MP4CreateMemoryInputStream( char *base, u32 size, MP4InputStreamPtr *outStream ) +MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream) { - MP4Err MP4CreateMemoryFileMappingObject( char *src, u32 size, FileMappingObject *outObject ); - - MP4Err err; - MP4MemoryInputStreamPtr is; - - err = MP4NoErr; - is = (MP4MemoryInputStreamPtr) calloc( 1, sizeof(MP4MemoryInputStream) ); - TESTMALLOC( is ) - is->available = size; - is->base = base; - is->ptr = base; - is->destroy = destroy; - is->read8 = read8; - is->read16 = read16; - is->read32 = read32; - is->readData = readData; - is->skipData = skipData; - is->getStreamOffset = getStreamOffset; - is->msg = msg; - is->getFileMappingObject = getFileMappingObject; - err = MP4CreateMemoryFileMappingObject( base, size, &is->mapping ); - *outStream = (MP4InputStreamPtr) is; + MP4Err MP4CreateMemoryFileMappingObject(char *src, u32 size, FileMappingObject *outObject); + + MP4Err err; + MP4MemoryInputStreamPtr is; + + err = MP4NoErr; + is = (MP4MemoryInputStreamPtr)calloc(1, sizeof(MP4MemoryInputStream)); + TESTMALLOC(is) + is->available = size; + is->base = base; + is->ptr = base; + is->destroy = destroy; + is->read8 = read8; + is->read16 = read16; + is->read32 = read32; + is->readData = readData; + is->skipData = skipData; + is->getStreamOffset = getStreamOffset; + is->msg = msg; + is->getFileMappingObject = getFileMappingObject; + err = MP4CreateMemoryFileMappingObject(base, size, &is->mapping); + *outStream = (MP4InputStreamPtr)is; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4MovieFile.c b/IsoLib/libisomediafile/src/MP4MovieFile.c index f6afe35..39b5ef6 100644 --- a/IsoLib/libisomediafile/src/MP4MovieFile.c +++ b/IsoLib/libisomediafile/src/MP4MovieFile.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -28,405 +28,462 @@ derivative works. Copyright (c) 1999. #include "MJ2Atoms.h" #include -static MP4Err LocalPutMovieIntoHandle( MP4Movie theMovie, MP4Handle movieH, u32 include_mdat ) +static MP4Err LocalPutMovieIntoHandle(MP4Movie theMovie, MP4Handle movieH, u32 include_mdat) { - MP4Err MP4MovieCreateDescriptors( MP4Movie theMovie ); - - MP4Err err; - MP4PrivateMovieRecordPtr movie; - MP4MovieAtomPtr moov; - MP4MediaDataAtomPtr mdat; - MP4AtomPtr meta; - MP4AtomPtr meco; - u32 prepend_size; - u32 pre_data_size; - u32 move_up; - u32 mdat_size; - u32 moov_size; - - char* write_location; - MP4AtomPtr headatom; - - err = MP4NoErr; - if ( (theMovie == NULL) ) - BAILWITHERROR( MP4BadParamErr ); - /* if movieH is NULL, then we append the movie into the prepend_handle */ - - movie = (MP4PrivateMovieRecordPtr) theMovie; - moov = (MP4MovieAtomPtr) movie->moovAtomPtr; - meta = movie->meta; - meco = movie->meco; - - if (movie->fileType == ISOMPEG4FileType) - err = MP4MovieCreateDescriptors( theMovie ); - else if (moov) { - err = moov->calculateDuration( moov ); - if (err) goto bail; - } - - if (movie->prepend_handle) - MP4GetHandleSize( movie->prepend_handle, &prepend_size ); - else prepend_size = 0; - pre_data_size = prepend_size; - - if (prepend_size == 0) { - /* add the signature atom to the front of the file */ - headatom = movie->sgnt; - if (headatom) { - err = headatom->calculateSize( headatom ); if (err) goto bail; - pre_data_size += headatom->size; - } - - /* add the file type atom after the signature atom */ - headatom = movie->ftyp; - if (headatom) { - err = headatom->calculateSize( headatom ); if (err) goto bail; - pre_data_size += headatom->size; - } - - /* add the header atom after the file type atom */ - headatom = movie->jp2h; - if (headatom) { - err = headatom->calculateSize( headatom ); if (err) goto bail; - pre_data_size += headatom->size; - } - } - - if (meta) { - err = meta->calculateSize( meta ); if (err) goto bail; - pre_data_size += meta->size; - } - - if (meco) { - err = meco->calculateSize( meco ); if (err) goto bail; - pre_data_size += meco->size; + MP4Err MP4MovieCreateDescriptors(MP4Movie theMovie); + + MP4Err err; + MP4PrivateMovieRecordPtr movie; + MP4MovieAtomPtr moov; + MP4MediaDataAtomPtr mdat; + MP4AtomPtr meta; + MP4AtomPtr meco; + u32 prepend_size; + u32 pre_data_size; + u32 move_up; + u32 mdat_size; + u32 moov_size; + + char *write_location; + MP4AtomPtr headatom; + + err = MP4NoErr; + if((theMovie == NULL)) BAILWITHERROR(MP4BadParamErr); + /* if movieH is NULL, then we append the movie into the prepend_handle */ + + movie = (MP4PrivateMovieRecordPtr)theMovie; + moov = (MP4MovieAtomPtr)movie->moovAtomPtr; + meta = movie->meta; + meco = movie->meco; + + if(movie->fileType == ISOMPEG4FileType) err = MP4MovieCreateDescriptors(theMovie); + else if(moov) + { + err = moov->calculateDuration(moov); + if(err) goto bail; + } + + if(movie->prepend_handle) MP4GetHandleSize(movie->prepend_handle, &prepend_size); + else + prepend_size = 0; + pre_data_size = prepend_size; + + if(prepend_size == 0) + { + /* add the signature atom to the front of the file */ + headatom = movie->sgnt; + if(headatom) + { + err = headatom->calculateSize(headatom); + if(err) goto bail; + pre_data_size += headatom->size; + } + + /* add the file type atom after the signature atom */ + headatom = movie->ftyp; + if(headatom) + { + err = headatom->calculateSize(headatom); + if(err) goto bail; + pre_data_size += headatom->size; + } + + /* add the header atom after the file type atom */ + headatom = movie->jp2h; + if(headatom) + { + err = headatom->calculateSize(headatom); + if(err) goto bail; + pre_data_size += headatom->size; + } + } + + if(meta) + { + err = meta->calculateSize(meta); + if(err) goto bail; + pre_data_size += meta->size; + } + + if(meco) + { + err = meco->calculateSize(meco); + if(err) goto bail; + pre_data_size += meco->size; + } + + if(moov) + { + err = moov->calculateSize((MP4AtomPtr)moov); + if(err) goto bail; + moov_size = moov->size; + } + else + moov_size = 0; + + move_up = pre_data_size + moov_size + 8; + + mdat = (MP4MediaDataAtomPtr)movie->mdat; + if(mdat) + { + err = mdat->calculateSize((MP4AtomPtr)mdat); + if(err) goto bail; + if((include_mdat) && (mdat->size == 1)) + { + BAILWITHERROR(MP4NotImplementedErr); + } + + if(mdat->size == 1) move_up += 8; + + mdat_size = (include_mdat ? mdat->size : 0); + + /* adjust mdat-related chunk offsets so they reflect the offset of the mdat within the movie + * handle */ + if(moov) + { + err = moov->mdatMoved(moov, 0, mdat->dataSize, move_up); + if(err) goto bail; + } + if(meta) + { + ISOMetaAtomPtr myMeta; + myMeta = (ISOMetaAtomPtr)meta; + err = myMeta->mdatMoved(myMeta, 0, mdat->dataSize, move_up); + if(err) goto bail; + } + + if(meco) + { + ISOAdditionalMetaDataContainerAtomPtr myMeco; + myMeco = (ISOAdditionalMetaDataContainerAtomPtr)meco; + err = myMeco->mdatMoved(myMeco, 0, mdat->dataSize, move_up); + if(err) goto bail; + } + } + else + mdat_size = 0; + + if(movieH == NULL) + { + if(movie->prepend_handle == NULL) + err = MP4NewHandle(pre_data_size + moov_size + mdat_size, &(movie->prepend_handle)); + else + err = MP4SetHandleSize(movie->prepend_handle, pre_data_size + moov_size + mdat_size); + if(err) goto bail; + write_location = (*(movie->prepend_handle)) + prepend_size; + } + else + { + err = MP4SetHandleSize(movieH, pre_data_size + moov_size + mdat_size); + if(err) goto bail; + + if(movie->prepend_handle != NULL) + memcpy((char *)*movieH, (char *)*(movie->prepend_handle), prepend_size); + write_location = (*movieH) + prepend_size; + } + + if(prepend_size == 0) + { + /* add the signature atom to the front of the file */ + headatom = movie->sgnt; + if(headatom) + { + err = headatom->serialize(headatom, write_location); + if(err) goto bail; + write_location += headatom->size; } - if (moov) - { - err = moov->calculateSize( (MP4AtomPtr) moov ); if (err) goto bail; - moov_size = moov->size; - } - else moov_size = 0; - - move_up = pre_data_size + moov_size + 8; - - mdat = (MP4MediaDataAtomPtr) movie->mdat; - if (mdat) { - err = mdat->calculateSize( (MP4AtomPtr) mdat ); if (err) goto bail; - if ((include_mdat) && (mdat->size == 1)) { BAILWITHERROR( MP4NotImplementedErr ); } - - if (mdat->size == 1) move_up += 8; - - mdat_size = (include_mdat ? mdat->size : 0); - - /* adjust mdat-related chunk offsets so they reflect the offset of the mdat within the movie handle */ - if (moov) { - err = moov->mdatMoved( moov, 0, mdat->dataSize, move_up ); if (err) goto bail; - } - if (meta) { - ISOMetaAtomPtr myMeta; - myMeta = (ISOMetaAtomPtr) meta; - err = myMeta->mdatMoved( myMeta, 0, mdat->dataSize, move_up ); if (err) goto bail; - } - - if (meco) { - ISOAdditionalMetaDataContainerAtomPtr myMeco; - myMeco = (ISOAdditionalMetaDataContainerAtomPtr) meco; - err = myMeco->mdatMoved( myMeco, 0, mdat->dataSize, move_up ); if (err) goto bail; - } - } - else mdat_size = 0; - - if (movieH == NULL) { - if (movie->prepend_handle == NULL) - err = MP4NewHandle( pre_data_size + moov_size + mdat_size, &(movie->prepend_handle) ); - else - err = MP4SetHandleSize( movie->prepend_handle, pre_data_size + moov_size + mdat_size ); - if (err) goto bail; - write_location = (*(movie->prepend_handle)) + prepend_size; - } - else - { - err = MP4SetHandleSize( movieH, pre_data_size + moov_size + mdat_size); if (err) goto bail; - - if (movie->prepend_handle != NULL) memcpy( (char*) *movieH, (char*) *(movie->prepend_handle), prepend_size ); - write_location = (*movieH) + prepend_size; - } - - if (prepend_size == 0) { - /* add the signature atom to the front of the file */ - headatom = movie->sgnt; - if (headatom) { - err = headatom->serialize( headatom, write_location ); if (err) goto bail; - write_location += headatom->size; - } - - /* add the file type atom after the signature atom */ - headatom = movie->ftyp; - if (headatom) { - err = headatom->serialize( headatom, write_location ); if (err) goto bail; - write_location += headatom->size; - } - - /* add the header atom after the file type atom */ - headatom = movie->jp2h; - if (headatom) { - err = headatom->serialize( headatom, write_location ); if (err) goto bail; - write_location += headatom->size; - } - } - - if (meta) { - err = meta->serialize( meta, write_location ); if (err) goto bail; - write_location += meta->size; - } - - if (meco) { - err = meco->serialize( meco, write_location ); if (err) goto bail; - write_location += meco->size; + /* add the file type atom after the signature atom */ + headatom = movie->ftyp; + if(headatom) + { + err = headatom->serialize(headatom, write_location); + if(err) goto bail; + write_location += headatom->size; } - if (moov) { - err = moov->serialize( (MP4AtomPtr) moov, write_location ); if (err) goto bail; - write_location += moov->size; - } - - if (mdat) { - /* back out the adjust mdat-related chunk offsets */ - if (moov) { - err = moov->mdatMoved( moov, move_up, mdat->dataSize + move_up, - ((s32) move_up) ); if (err) goto bail; - } - if (meta) { - ISOMetaAtomPtr myMeta; - myMeta = (ISOMetaAtomPtr) meta; - err = myMeta->mdatMoved( myMeta, move_up, mdat->dataSize + move_up, - ((s32) move_up) ); if (err) goto bail; - } - - if (meco) { - ISOAdditionalMetaDataContainerAtomPtr myMeco; - myMeco = (ISOAdditionalMetaDataContainerAtomPtr) meco; - err = myMeco->mdatMoved( myMeco, move_up, mdat->dataSize + move_up, - ((s32) move_up) ); if (err) goto bail; - } - - if (include_mdat) { - err = mdat->serialize( (MP4AtomPtr) mdat, write_location ); if (err) goto bail; - write_location += mdat->size; - } - } - + /* add the header atom after the file type atom */ + headatom = movie->jp2h; + if(headatom) + { + err = headatom->serialize(headatom, write_location); + if(err) goto bail; + write_location += headatom->size; + } + } + + if(meta) + { + err = meta->serialize(meta, write_location); + if(err) goto bail; + write_location += meta->size; + } + + if(meco) + { + err = meco->serialize(meco, write_location); + if(err) goto bail; + write_location += meco->size; + } + + if(moov) + { + err = moov->serialize((MP4AtomPtr)moov, write_location); + if(err) goto bail; + write_location += moov->size; + } + + if(mdat) + { + /* back out the adjust mdat-related chunk offsets */ + if(moov) + { + err = moov->mdatMoved(moov, move_up, mdat->dataSize + move_up, -((s32)move_up)); + if(err) goto bail; + } + if(meta) + { + ISOMetaAtomPtr myMeta; + myMeta = (ISOMetaAtomPtr)meta; + err = myMeta->mdatMoved(myMeta, move_up, mdat->dataSize + move_up, -((s32)move_up)); + if(err) goto bail; + } + + if(meco) + { + ISOAdditionalMetaDataContainerAtomPtr myMeco; + myMeco = (ISOAdditionalMetaDataContainerAtomPtr)meco; + err = myMeco->mdatMoved(myMeco, move_up, mdat->dataSize + move_up, -((s32)move_up)); + if(err) goto bail; + } + + if(include_mdat) + { + err = mdat->serialize((MP4AtomPtr)mdat, write_location); + if(err) goto bail; + write_location += mdat->size; + } + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4PutMovieIntoHandle( MP4Movie theMovie, MP4Handle movieH ) +MP4_EXTERN(MP4Err) +MP4PutMovieIntoHandle(MP4Movie theMovie, MP4Handle movieH) { - return LocalPutMovieIntoHandle( theMovie, movieH, 1 ); + return LocalPutMovieIntoHandle(theMovie, movieH, 1); } -MP4_EXTERN ( MP4Err ) -MP4WriteMovieToFile( MP4Movie theMovie, const char *filename ) +MP4_EXTERN(MP4Err) +MP4WriteMovieToFile(MP4Movie theMovie, const char *filename) { - MP4Err err; - size_t written; - MP4Handle movieH; - FILE *fd; - u32 handleSize; - MP4PrivateMovieRecordPtr movie; - MP4MediaDataAtomPtr mdat; - - movie = (MP4PrivateMovieRecordPtr) theMovie; - mdat = (MP4MediaDataAtomPtr) movie->mdat; - - err = MP4NoErr; - movieH = NULL; - fd = NULL; - if ( (theMovie == NULL) || (filename == NULL) ) - BAILWITHERROR( MP4BadParamErr ); + MP4Err err; + size_t written; + MP4Handle movieH; + FILE *fd; + u32 handleSize; + MP4PrivateMovieRecordPtr movie; + MP4MediaDataAtomPtr mdat; + + movie = (MP4PrivateMovieRecordPtr)theMovie; + mdat = (MP4MediaDataAtomPtr)movie->mdat; + + err = MP4NoErr; + movieH = NULL; + fd = NULL; + if((theMovie == NULL) || (filename == NULL)) BAILWITHERROR(MP4BadParamErr); #ifdef macintosh + { + int len; + int i; + char *s; + if(*filename == '/') filename++; + s = (char *)filename; + len = strlen(s); + for(i = 0; i < len; i++) { - int len; - int i; - char *s; - if ( *filename == '/' ) - filename++; - s = (char *) filename; - len = strlen( s ); - for ( i = 0; i < len; i++ ) - { - if ( s[i] == '/' ) - s[i] = ':'; - } + if(s[i] == '/') s[i] = ':'; } + } #endif - fd = fopen( filename, "wb" ); - if ( fd == NULL ) - BAILWITHERROR( MP4IOErr ); - err = MP4NewHandle( 0, &movieH ); if (err) goto bail; - err = LocalPutMovieIntoHandle( theMovie, movieH, 0 ); if (err) goto bail; - err = MP4GetHandleSize( movieH, &handleSize ); if (err) goto bail; - written = fwrite( *movieH, 1, handleSize, fd ); - if ( written != handleSize ) - BAILWITHERROR( MP4IOErr ); - err = mdat->writeToFile( mdat, fd ); - + fd = fopen(filename, "wb"); + if(fd == NULL) BAILWITHERROR(MP4IOErr); + err = MP4NewHandle(0, &movieH); + if(err) goto bail; + err = LocalPutMovieIntoHandle(theMovie, movieH, 0); + if(err) goto bail; + err = MP4GetHandleSize(movieH, &handleSize); + if(err) goto bail; + written = fwrite(*movieH, 1, handleSize, fd); + if(written != handleSize) BAILWITHERROR(MP4IOErr); + err = mdat->writeToFile(mdat, fd); + bail: - if ( movieH ) - { - MP4DisposeHandle( movieH ); - movieH = NULL; - } - if ( fd ) - { - fclose( fd ); - fd = NULL; - } - - TEST_RETURN( err ); - - return err; + if(movieH) + { + MP4DisposeHandle(movieH); + movieH = NULL; + } + if(fd) + { + fclose(fd); + fd = NULL; + } + + TEST_RETURN(err); + + return err; } -ISO_EXTERN ( MP4Err ) -ISOStartMovieFragment( MP4Movie theMovie ) +ISO_EXTERN(MP4Err) +ISOStartMovieFragment(MP4Movie theMovie) { - MP4Err MP4CreateMovieFragmentAtom( MP4MovieFragmentAtomPtr *outAtom ); - MP4Err MP4CreateMovieFragmentHeaderAtom( MP4MovieFragmentHeaderAtomPtr *outAtom ); - MP4Err MP4CreateMediaDataAtom( MP4MediaDataAtomPtr *outAtom ); - - MP4Err err; - MP4PrivateMovieRecordPtr movie; - MP4MovieFragmentAtomPtr moof; - MP4MovieFragmentHeaderAtomPtr mfhd; - MP4MovieExtendsAtomPtr mvex; - MP4MediaDataAtomPtr mdat; - MP4MovieAtomPtr moov; - u32 fragment_sequence; - - err = MP4NoErr; - movie = (MP4PrivateMovieRecordPtr) theMovie; - - if ((movie->fileType == ISO3GPPFileType) || (movie->fileType == ISOQuickTimeFileType)) - BAILWITHERROR( ISONotImplementedErr ); - - if ((movie->moovAtomPtr)->type == MP4MovieAtomType) { - moov = (MP4MovieAtomPtr) (movie->moovAtomPtr); - - mvex = (MP4MovieExtendsAtomPtr) moov->mvex; - if (mvex == NULL) BAILWITHERROR( MP4BadParamErr ) - err = mvex->setSampleDescriptionIndexes( mvex, (MP4AtomPtr) moov ); if (err) goto bail; - } - - err = LocalPutMovieIntoHandle( theMovie, NULL, 1 ); if (err) goto bail; - - if ((movie->moovAtomPtr)->type == MP4MovieFragmentAtomType) - { - moof = (MP4MovieFragmentAtomPtr) movie->moovAtomPtr; - mfhd = (MP4MovieFragmentHeaderAtomPtr) moof->mfhd; - fragment_sequence = mfhd->sequence_number + 1; - moof->destroy( movie->moovAtomPtr ); /* the old moof */ - } - else - { - movie->true_moov = movie->moovAtomPtr; - fragment_sequence = 1; - } - - moov = (MP4MovieAtomPtr) (movie->true_moov); - - mvex = (MP4MovieExtendsAtomPtr) moov->mvex; - - if (mvex == NULL) BAILWITHERROR( MP4BadParamErr ) - - err = MP4CreateMovieFragmentAtom( (MP4MovieFragmentAtomPtr *) &moof ); if (err) goto bail; - movie->moovAtomPtr = (MP4AtomPtr) moof; - -/* if (movie->movieFragments == NULL) { - err = MP4MakeLinkedList( &movie->movieFragments ); if (err) goto bail; - } - err = MP4AddListEntry( moof, movie->movieFragments ); if (err) goto bail; -*/ - - err = MP4CreateMovieFragmentHeaderAtom( &mfhd ); if (err) goto bail; - mfhd->sequence_number = fragment_sequence; - moof->mfhd = (MP4AtomPtr) mfhd; - - mdat = (MP4MediaDataAtomPtr) movie->mdat; - if (mdat) mdat->destroy( (MP4AtomPtr) mdat ); - err = MP4CreateMediaDataAtom( &mdat ); if (err) goto bail; - movie->mdat = (MP4AtomPtr) mdat; - - mvex->maketrackfragments( mvex, moof, moov, mdat ); - + MP4Err MP4CreateMovieFragmentAtom(MP4MovieFragmentAtomPtr * outAtom); + MP4Err MP4CreateMovieFragmentHeaderAtom(MP4MovieFragmentHeaderAtomPtr * outAtom); + MP4Err MP4CreateMediaDataAtom(MP4MediaDataAtomPtr * outAtom); + + MP4Err err; + MP4PrivateMovieRecordPtr movie; + MP4MovieFragmentAtomPtr moof; + MP4MovieFragmentHeaderAtomPtr mfhd; + MP4MovieExtendsAtomPtr mvex; + MP4MediaDataAtomPtr mdat; + MP4MovieAtomPtr moov; + u32 fragment_sequence; + + err = MP4NoErr; + movie = (MP4PrivateMovieRecordPtr)theMovie; + + if((movie->fileType == ISO3GPPFileType) || (movie->fileType == ISOQuickTimeFileType)) + BAILWITHERROR(ISONotImplementedErr); + + if((movie->moovAtomPtr)->type == MP4MovieAtomType) + { + moov = (MP4MovieAtomPtr)(movie->moovAtomPtr); + + mvex = (MP4MovieExtendsAtomPtr)moov->mvex; + if(mvex == NULL) BAILWITHERROR(MP4BadParamErr) + err = mvex->setSampleDescriptionIndexes(mvex, (MP4AtomPtr)moov); + if(err) goto bail; + } + + err = LocalPutMovieIntoHandle(theMovie, NULL, 1); + if(err) goto bail; + + if((movie->moovAtomPtr)->type == MP4MovieFragmentAtomType) + { + moof = (MP4MovieFragmentAtomPtr)movie->moovAtomPtr; + mfhd = (MP4MovieFragmentHeaderAtomPtr)moof->mfhd; + fragment_sequence = mfhd->sequence_number + 1; + moof->destroy(movie->moovAtomPtr); /* the old moof */ + } + else + { + movie->true_moov = movie->moovAtomPtr; + fragment_sequence = 1; + } + + moov = (MP4MovieAtomPtr)(movie->true_moov); + + mvex = (MP4MovieExtendsAtomPtr)moov->mvex; + + if(mvex == NULL) BAILWITHERROR(MP4BadParamErr) + + err = MP4CreateMovieFragmentAtom((MP4MovieFragmentAtomPtr *)&moof); + if(err) goto bail; + movie->moovAtomPtr = (MP4AtomPtr)moof; + + /* if (movie->movieFragments == NULL) { + err = MP4MakeLinkedList( &movie->movieFragments ); if (err) goto bail; + } + err = MP4AddListEntry( moof, movie->movieFragments ); if (err) goto bail; + */ + + err = MP4CreateMovieFragmentHeaderAtom(&mfhd); + if(err) goto bail; + mfhd->sequence_number = fragment_sequence; + moof->mfhd = (MP4AtomPtr)mfhd; + + mdat = (MP4MediaDataAtomPtr)movie->mdat; + if(mdat) mdat->destroy((MP4AtomPtr)mdat); + err = MP4CreateMediaDataAtom(&mdat); + if(err) goto bail; + movie->mdat = (MP4AtomPtr)mdat; + + mvex->maketrackfragments(mvex, moof, moov, mdat); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISO_EXTERN ( MP4Err ) -ISOAddDelayToTrackFragmentDecodeTime( MP4Movie theMovie, u32 delay ) +ISO_EXTERN(MP4Err) +ISOAddDelayToTrackFragmentDecodeTime(MP4Movie theMovie, u32 delay) { - u32 i; - MP4Err err; - MP4PrivateMovieRecordPtr movie; - MP4MovieFragmentAtomPtr moof; - MP4AtomPtr moofEntry; - MP4TrackFragmentAtomPtr traf; - MP4TrackExtendsAtomPtr trex; - MP4TrackFragmentDecodeTimeAtomPtr tfdt; - - err = MP4NoErr; - movie = (MP4PrivateMovieRecordPtr) theMovie; - - if (movie->moovAtomPtr->type != MP4MovieFragmentAtomType) - BAILWITHERROR(MP4InvalidMediaErr); - - moof = (MP4MovieFragmentAtomPtr) movie->moovAtomPtr; - - for (i = 0; i < moof->atomList->entryCount; i++) + u32 i; + MP4Err err; + MP4PrivateMovieRecordPtr movie; + MP4MovieFragmentAtomPtr moof; + MP4AtomPtr moofEntry; + MP4TrackFragmentAtomPtr traf; + MP4TrackExtendsAtomPtr trex; + MP4TrackFragmentDecodeTimeAtomPtr tfdt; + + err = MP4NoErr; + movie = (MP4PrivateMovieRecordPtr)theMovie; + + if(movie->moovAtomPtr->type != MP4MovieFragmentAtomType) BAILWITHERROR(MP4InvalidMediaErr); + + moof = (MP4MovieFragmentAtomPtr)movie->moovAtomPtr; + + for(i = 0; i < moof->atomList->entryCount; i++) + { + MP4GetListEntry(moof->atomList, i, (char **)moofEntry); + if(moofEntry->type == MP4TrackFragmentAtomType) { - MP4GetListEntry(moof->atomList, i, (char **) moofEntry); - if (moofEntry->type == MP4TrackFragmentAtomType) - { - traf = (MP4TrackFragmentAtomPtr) moofEntry; - trex = (MP4TrackExtendsAtomPtr) traf->trex; - tfdt = (MP4TrackFragmentDecodeTimeAtomPtr) traf->tfdt; - trex->baseMediaDecodeTime += delay; - tfdt->baseMediaDecodeTime += delay; - } + traf = (MP4TrackFragmentAtomPtr)moofEntry; + trex = (MP4TrackExtendsAtomPtr)traf->trex; + tfdt = (MP4TrackFragmentDecodeTimeAtomPtr)traf->tfdt; + trex->baseMediaDecodeTime += delay; + tfdt->baseMediaDecodeTime += delay; } - + } + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -ISO_EXTERN ( MP4Err ) -ISOSetCompositonToDecodePropertiesForFragments( MP4Movie theMovie, u32 trackID, s32 compositionToDTSShift, s32 leastDecodeToDisplayDelta, - s32 greatestDecodeToDisplayDelta, s32 compositionStartTime, s32 compositionEndTime ) +ISO_EXTERN(MP4Err) +ISOSetCompositonToDecodePropertiesForFragments(MP4Movie theMovie, u32 trackID, + s32 compositionToDTSShift, + s32 leastDecodeToDisplayDelta, + s32 greatestDecodeToDisplayDelta, + s32 compositionStartTime, s32 compositionEndTime) { - MP4Err err; - MP4PrivateMovieRecordPtr movie; - MP4MovieAtomPtr moov; - MP4MovieExtendsAtomPtr mvex; - - err = MP4NoErr; - movie = (MP4PrivateMovieRecordPtr) theMovie; - - moov = (MP4MovieAtomPtr) (movie->moovAtomPtr); - - mvex = (MP4MovieExtendsAtomPtr) moov->mvex; - if (mvex == NULL) BAILWITHERROR( MP4BadParamErr ) - - err = mvex->setCompositionToDecodeProperties(mvex, trackID, compositionToDTSShift, leastDecodeToDisplayDelta, - greatestDecodeToDisplayDelta, compositionStartTime, compositionEndTime); + MP4Err err; + MP4PrivateMovieRecordPtr movie; + MP4MovieAtomPtr moov; + MP4MovieExtendsAtomPtr mvex; + + err = MP4NoErr; + movie = (MP4PrivateMovieRecordPtr)theMovie; + + moov = (MP4MovieAtomPtr)(movie->moovAtomPtr); + + mvex = (MP4MovieExtendsAtomPtr)moov->mvex; + if(mvex == NULL) BAILWITHERROR(MP4BadParamErr) + + err = mvex->setCompositionToDecodeProperties( + mvex, trackID, compositionToDTSShift, leastDecodeToDisplayDelta, greatestDecodeToDisplayDelta, + compositionStartTime, compositionEndTime); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/MP4Movies.c b/IsoLib/libisomediafile/src/MP4Movies.c index 5a8dc5f..d87f63a 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.c +++ b/IsoLib/libisomediafile/src/MP4Movies.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: MP4Movies.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4Movies.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" @@ -42,920 +42,979 @@ derivative works. Copyright (c) 1999, 2000. #include #include -MP4Err makeESD( MP4Movie theMovie, u32 trackNumber, u64 cts, MP4SLConfig slconfig, MP4DescriptorPtr *outDesc ); -MP4Err MP4MovieCreateDescriptors( MP4Movie theMovie ); -MP4Err MP4MovieAddTrackES_IDToIOD( MP4Movie theMovie, MP4Track theTrack ); -MP4Err MP4GetMovieObjectDescriptorUsingSLConfig( MP4Movie theMovie, MP4SLConfig slconfig, MP4Handle outDescriptorH ); +MP4Err makeESD(MP4Movie theMovie, u32 trackNumber, u64 cts, MP4SLConfig slconfig, + MP4DescriptorPtr *outDesc); +MP4Err MP4MovieCreateDescriptors(MP4Movie theMovie); +MP4Err MP4MovieAddTrackES_IDToIOD(MP4Movie theMovie, MP4Track theTrack); +MP4Err MP4GetMovieObjectDescriptorUsingSLConfig(MP4Movie theMovie, MP4SLConfig slconfig, + MP4Handle outDescriptorH); -MP4_EXTERN ( MP4Err ) MergeMovieFragments( MP4PrivateMovieRecordPtr movie ); -MP4_EXTERN ( MP4Err ) MergeMovieData( MP4PrivateMovieRecordPtr movie ); +MP4_EXTERN(MP4Err) MergeMovieFragments(MP4PrivateMovieRecordPtr movie); +MP4_EXTERN(MP4Err) MergeMovieData(MP4PrivateMovieRecordPtr movie); -MP4_EXTERN ( MP4Err ) -MP4DisposeMovie( MP4Movie theMovie ) +MP4_EXTERN(MP4Err) +MP4DisposeMovie(MP4Movie theMovie) { - GETMOOV( theMovie ); - - if ( moov->inputStream ) - moov->inputStream->destroy( moov->inputStream ); - - if ( moov->fileMappingObject ) - { - moov->fileMappingObject->close( moov->fileMappingObject ); - moov->fileMappingObject->destroy( moov->fileMappingObject ); - } + GETMOOV(theMovie); - if ( moov->inMemoryDataHandler ) - { - MP4DataHandlerPtr dh = (MP4DataHandlerPtr)moov->inMemoryDataHandler; + if(moov->inputStream) moov->inputStream->destroy(moov->inputStream); - dh->close( dh ); - } + if(moov->fileMappingObject) + { + moov->fileMappingObject->close(moov->fileMappingObject); + moov->fileMappingObject->destroy(moov->fileMappingObject); + } - if ( moov->moovAtomPtr ) - moov->moovAtomPtr->destroy( moov->moovAtomPtr ); - - if (( moov->true_moov ) && ( moov->true_moov != moov->moovAtomPtr)) - moov->true_moov->destroy( moov->true_moov ); - - if ( moov->mdat ) - moov->mdat->destroy( moov->mdat ); - - if ( moov->meta ) - moov->meta->destroy( moov->meta ); - - - if ( moov->jp2h ) - moov->jp2h->destroy( moov->jp2h ); - - if ( moov->ftyp ) - moov->ftyp->destroy( moov->ftyp ); - - if ( moov->sgnt ) - moov->sgnt->destroy( moov->sgnt ); - - if ( moov->prepend_handle) - MP4DisposeHandle( moov->prepend_handle ); - - if ( moov ) - free( moov ); -bail: - TEST_RETURN( err ); + if(moov->inMemoryDataHandler) + { + MP4DataHandlerPtr dh = (MP4DataHandlerPtr)moov->inMemoryDataHandler; - return err; -} + dh->close(dh); + } -static MP4Err -parseMovie( MP4Movie *theMovie, MP4PrivateMovieRecordPtr moov, int openMovieFlags ) -{ - MP4Err err; - MP4AtomPtr anAtomPtr; - int debug; - int finished; - - err = MP4NoErr; - if ( (moov == NULL) || (moov->inputStream == NULL) ) - BAILWITHERROR( MP4BadParamErr ); + if(moov->moovAtomPtr) moov->moovAtomPtr->destroy(moov->moovAtomPtr); - debug = openMovieFlags & MP4OpenMovieDebug; + if((moov->true_moov) && (moov->true_moov != moov->moovAtomPtr)) + moov->true_moov->destroy(moov->true_moov); - moov->inputStream->debugging = debug; - for ( finished = 0; !finished; ) - { - err = MP4ParseAtom( moov->inputStream, &anAtomPtr ); - if ( err == MP4EOF ) - { - err = MP4NoErr; - finished = 1; - break; - } - if ( err ) goto bail; - switch( anAtomPtr->type ) - { - case MP4MovieAtomType: - if ( moov->moovAtomPtr ) BAILWITHERROR( MP4BadDataErr ) - else - { - MP4MovieAtomPtr m = (MP4MovieAtomPtr) anAtomPtr; - m->setupTracks( m, moov ); - moov->moovAtomPtr = anAtomPtr; - } - break; - case MP4MediaDataAtomType: - { - MP4MediaDataAtomPtr mdat; - mdat = (MP4MediaDataAtomPtr) anAtomPtr; - /* open in place here is not ideal, as the mdat is read and discarded, but it is - a start. note that movies opened in place cannot be written back to disc */ - if ((openMovieFlags & MP4OpenMovieInPlace) || (mdat->dataSize == 0)) - anAtomPtr->destroy( anAtomPtr ); - else if ( moov->mdat == NULL ) - moov->mdat = anAtomPtr; - else { - if (moov->mdatList == NULL) { - err = MP4MakeLinkedList( &moov->mdatList ); if (err) goto bail; - } - err = MP4AddListEntry( anAtomPtr, moov->mdatList ); if (err) goto bail; - } - } - break; - case MP4MovieFragmentAtomType: - if (moov->movieFragments == NULL) { - err = MP4MakeLinkedList( &moov->movieFragments ); if (err) goto bail; - } - err = MP4AddListEntry( anAtomPtr, moov->movieFragments ); if (err) goto bail; - break; - case ISOFileTypeAtomType: - if ( moov->ftyp ) BAILWITHERROR( MP4BadDataErr ) - else moov->ftyp = anAtomPtr; - break; - case MJ2JPEG2000SignatureAtomType: - if ( moov->sgnt ) BAILWITHERROR( MP4BadDataErr ) - else moov->sgnt = anAtomPtr; - break; - case MJ2JP2HeaderAtomType: - if ( moov->jp2h ) BAILWITHERROR( MP4BadDataErr ) - else moov->jp2h = anAtomPtr; - break; - case MP4FreeSpaceAtomType: - case MP4SkipAtomType: - anAtomPtr->destroy( anAtomPtr ); - break; - case ISOMetaAtomType: - if ( moov->meta ) BAILWITHERROR( MP4BadDataErr ) - else moov->meta = anAtomPtr; - break; - case ISOAdditionalMetaDataContainerAtomType: - if ( moov->meco ) BAILWITHERROR( MP4BadDataErr ) - else moov->meco = anAtomPtr; - break; - default: - anAtomPtr->destroy( anAtomPtr ); - /* TODO: Save other top-level atoms -- if any, but this should be it */ - break; - } - if ( moov->inputStream->available == 0 ) - finished = 1; - } - /* only mp4v1 files have no ftyp, and they have to have a moov */ - if ((moov->moovAtomPtr == NULL) && (moov->ftyp == NULL)) - BAILWITHERROR( MP4BadDataErr ) - - err = MergeMovieFragments( moov ); if (err) goto bail; - - if ( moov->mdat != NULL ) { - err = MergeMovieData( moov ); if (err) goto bail; - } - - if ( err == MP4NoErr ) - *theMovie = (MP4Movie) moov; + if(moov->mdat) moov->mdat->destroy(moov->mdat); + + if(moov->meta) moov->meta->destroy(moov->meta); + + if(moov->jp2h) moov->jp2h->destroy(moov->jp2h); + + if(moov->ftyp) moov->ftyp->destroy(moov->ftyp); + + if(moov->sgnt) moov->sgnt->destroy(moov->sgnt); + + if(moov->prepend_handle) MP4DisposeHandle(moov->prepend_handle); + + if(moov) free(moov); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - if ( err != MP4NoErr ) - { - if ( moov ) { - if (moov->inputStream) { - moov->inputStream->destroy(moov->inputStream); - } - if (moov->fileMappingObject) { - moov->fileMappingObject->close(moov->fileMappingObject); - moov->fileMappingObject->destroy(moov->fileMappingObject); - } - free( moov ); - } - } - return err; + return err; } -MP4_EXTERN ( MP4Err ) MergeMovieFragments( MP4PrivateMovieRecordPtr movie ) +static MP4Err parseMovie(MP4Movie *theMovie, MP4PrivateMovieRecordPtr moov, int openMovieFlags) { - u32 i, seq; - MP4Err err; - u32 fragmentCount; - MP4MovieAtomPtr moov; - err = MP4NoErr; - - if (movie->movieFragments == NULL) goto bail; - seq = 0; - - MP4GetListEntryCount( movie->movieFragments, &fragmentCount ); - for( i = 0; i < fragmentCount; i++ ) - { - MP4MovieFragmentAtomPtr moof; - MP4MovieFragmentHeaderAtomPtr mfhd; - - err = MP4GetListEntry( movie->movieFragments, i, (char **) &moof ); if (err) goto bail; - - mfhd = (MP4MovieFragmentHeaderAtomPtr) moof->mfhd; - if (mfhd == NULL) BAILWITHERROR( MP4BadDataErr ); - if (i==0) seq = mfhd->sequence_number; - else { - if (mfhd->sequence_number <= seq) BAILWITHERROR( MP4BadDataErr ); - seq = mfhd->sequence_number; - } - - - err = moof->mergeFragments( moof, (MP4MovieAtomPtr) (movie->moovAtomPtr) ); if (err) goto bail; - } - DESTROY_ATOM_LIST_V( movie->movieFragments ) - moov = (MP4MovieAtomPtr) movie->moovAtomPtr; - err = moov->calculateDuration( moov ); + MP4Err err; + MP4AtomPtr anAtomPtr; + int debug; + int finished; + + err = MP4NoErr; + if((moov == NULL) || (moov->inputStream == NULL)) BAILWITHERROR(MP4BadParamErr); + + debug = openMovieFlags & MP4OpenMovieDebug; + + moov->inputStream->debugging = debug; + for(finished = 0; !finished;) + { + err = MP4ParseAtom(moov->inputStream, &anAtomPtr); + if(err == MP4EOF) + { + err = MP4NoErr; + finished = 1; + break; + } + if(err) goto bail; + switch(anAtomPtr->type) + { + case MP4MovieAtomType: + if(moov->moovAtomPtr) BAILWITHERROR(MP4BadDataErr) + else + { + MP4MovieAtomPtr m = (MP4MovieAtomPtr)anAtomPtr; + m->setupTracks(m, moov); + moov->moovAtomPtr = anAtomPtr; + } + break; + case MP4MediaDataAtomType: + { + MP4MediaDataAtomPtr mdat; + mdat = (MP4MediaDataAtomPtr)anAtomPtr; + /* open in place here is not ideal, as the mdat is read and discarded, but it is + a start. note that movies opened in place cannot be written back to disc */ + if((openMovieFlags & MP4OpenMovieInPlace) || (mdat->dataSize == 0)) + anAtomPtr->destroy(anAtomPtr); + else if(moov->mdat == NULL) + moov->mdat = anAtomPtr; + else + { + if(moov->mdatList == NULL) + { + err = MP4MakeLinkedList(&moov->mdatList); + if(err) goto bail; + } + err = MP4AddListEntry(anAtomPtr, moov->mdatList); + if(err) goto bail; + } + } + break; + case MP4MovieFragmentAtomType: + if(moov->movieFragments == NULL) + { + err = MP4MakeLinkedList(&moov->movieFragments); + if(err) goto bail; + } + err = MP4AddListEntry(anAtomPtr, moov->movieFragments); + if(err) goto bail; + break; + case ISOFileTypeAtomType: + if(moov->ftyp) BAILWITHERROR(MP4BadDataErr) + else + moov->ftyp = anAtomPtr; + break; + case MJ2JPEG2000SignatureAtomType: + if(moov->sgnt) BAILWITHERROR(MP4BadDataErr) + else + moov->sgnt = anAtomPtr; + break; + case MJ2JP2HeaderAtomType: + if(moov->jp2h) BAILWITHERROR(MP4BadDataErr) + else + moov->jp2h = anAtomPtr; + break; + case MP4FreeSpaceAtomType: + case MP4SkipAtomType: + anAtomPtr->destroy(anAtomPtr); + break; + case ISOMetaAtomType: + if(moov->meta) BAILWITHERROR(MP4BadDataErr) + else + moov->meta = anAtomPtr; + break; + case ISOAdditionalMetaDataContainerAtomType: + if(moov->meco) BAILWITHERROR(MP4BadDataErr) + else + moov->meco = anAtomPtr; + break; + default: + anAtomPtr->destroy(anAtomPtr); + /* TODO: Save other top-level atoms -- if any, but this should be it */ + break; + } + if(moov->inputStream->available == 0) finished = 1; + } + /* only mp4v1 files have no ftyp, and they have to have a moov */ + if((moov->moovAtomPtr == NULL) && (moov->ftyp == NULL)) BAILWITHERROR(MP4BadDataErr) + + err = MergeMovieFragments(moov); + if(err) goto bail; + + if(moov->mdat != NULL) + { + err = MergeMovieData(moov); + if(err) goto bail; + } + + if(err == MP4NoErr) *theMovie = (MP4Movie)moov; bail: - TEST_RETURN( err ); + TEST_RETURN(err); + + if(err != MP4NoErr) + { + if(moov) + { + if(moov->inputStream) + { + moov->inputStream->destroy(moov->inputStream); + } + if(moov->fileMappingObject) + { + moov->fileMappingObject->close(moov->fileMappingObject); + moov->fileMappingObject->destroy(moov->fileMappingObject); + } + free(moov); + } + } + return err; +} - return err; +MP4_EXTERN(MP4Err) MergeMovieFragments(MP4PrivateMovieRecordPtr movie) +{ + u32 i, seq; + MP4Err err; + u32 fragmentCount; + MP4MovieAtomPtr moov; + err = MP4NoErr; + + if(movie->movieFragments == NULL) goto bail; + seq = 0; + + MP4GetListEntryCount(movie->movieFragments, &fragmentCount); + for(i = 0; i < fragmentCount; i++) + { + MP4MovieFragmentAtomPtr moof; + MP4MovieFragmentHeaderAtomPtr mfhd; + + err = MP4GetListEntry(movie->movieFragments, i, (char **)&moof); + if(err) goto bail; + + mfhd = (MP4MovieFragmentHeaderAtomPtr)moof->mfhd; + if(mfhd == NULL) BAILWITHERROR(MP4BadDataErr); + if(i == 0) seq = mfhd->sequence_number; + else + { + if(mfhd->sequence_number <= seq) BAILWITHERROR(MP4BadDataErr); + seq = mfhd->sequence_number; + } + + err = moof->mergeFragments(moof, (MP4MovieAtomPtr)(movie->moovAtomPtr)); + if(err) goto bail; + } + DESTROY_ATOM_LIST_V(movie->movieFragments) + moov = (MP4MovieAtomPtr)movie->moovAtomPtr; + err = moov->calculateDuration(moov); +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MergeMovieData( MP4PrivateMovieRecordPtr movie ) +MP4_EXTERN(MP4Err) MergeMovieData(MP4PrivateMovieRecordPtr movie) { - u32 i; - MP4Err err; - MP4MovieAtomPtr moov; - MP4MediaDataAtomPtr mdat; - MP4MediaDataAtomPtr secondary_mdat; - u32 mdatCount; - u32 offset; - ISOMetaAtomPtr meta; - - err = MP4NoErr; - - moov = (MP4MovieAtomPtr) movie->moovAtomPtr; - mdat = (MP4MediaDataAtomPtr) movie->mdat; - if (mdat == NULL) goto bail; - - offset = (u32) mdat->dataOffset; - - if (moov) { - moov->mdatArrived( moov, (MP4AtomPtr) mdat ); - moov->mdatMoved( moov, offset, mdat->dataSize + offset, -((s32) offset) ); - } - - meta = (ISOMetaAtomPtr) movie->meta; - if (meta) { - err = meta->setMdat( meta, (MP4AtomPtr) mdat ); if (err) goto bail; - err = meta->mdatMoved( meta, offset, mdat->dataSize + offset, -((s32) offset) ); if (err) goto bail; - } - - if (movie->mdatList != NULL) { - err = MP4GetListEntryCount( movie->mdatList, &mdatCount ); - - for ( i = 0; i < mdatCount; i++ ) - { - err = MP4GetListEntry( movie->mdatList, i, (char**) &secondary_mdat ); if (err) goto bail; - offset = (u32) secondary_mdat->dataOffset; - if (moov) { - err = moov->mdatMoved( moov, offset, secondary_mdat->dataSize + offset, - (s32) (mdat->dataSize - offset) ); - } - if (meta) { - err = meta->mdatMoved( meta, offset, secondary_mdat->dataSize + offset, - (s32) (mdat->dataSize - offset) ); - } - err = mdat->addMdat( mdat, secondary_mdat ); if (err) goto bail; - } - DESTROY_ATOM_LIST_V( movie->mdatList ) - } + u32 i; + MP4Err err; + MP4MovieAtomPtr moov; + MP4MediaDataAtomPtr mdat; + MP4MediaDataAtomPtr secondary_mdat; + u32 mdatCount; + u32 offset; + ISOMetaAtomPtr meta; + + err = MP4NoErr; + + moov = (MP4MovieAtomPtr)movie->moovAtomPtr; + mdat = (MP4MediaDataAtomPtr)movie->mdat; + if(mdat == NULL) goto bail; + + offset = (u32)mdat->dataOffset; + + if(moov) + { + moov->mdatArrived(moov, (MP4AtomPtr)mdat); + moov->mdatMoved(moov, offset, mdat->dataSize + offset, -((s32)offset)); + } + + meta = (ISOMetaAtomPtr)movie->meta; + if(meta) + { + err = meta->setMdat(meta, (MP4AtomPtr)mdat); + if(err) goto bail; + err = meta->mdatMoved(meta, offset, mdat->dataSize + offset, -((s32)offset)); + if(err) goto bail; + } + + if(movie->mdatList != NULL) + { + err = MP4GetListEntryCount(movie->mdatList, &mdatCount); + + for(i = 0; i < mdatCount; i++) + { + err = MP4GetListEntry(movie->mdatList, i, (char **)&secondary_mdat); + if(err) goto bail; + offset = (u32)secondary_mdat->dataOffset; + if(moov) + { + err = moov->mdatMoved(moov, offset, secondary_mdat->dataSize + offset, + (s32)(mdat->dataSize - offset)); + } + if(meta) + { + err = meta->mdatMoved(meta, offset, secondary_mdat->dataSize + offset, + (s32)(mdat->dataSize - offset)); + } + err = mdat->addMdat(mdat, secondary_mdat); + if(err) goto bail; + } + DESTROY_ATOM_LIST_V(movie->mdatList) + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4NewMovieFromHandle( MP4Movie *theMovie, MP4Handle movieH, u32 newMovieFlags ) +MP4_EXTERN(MP4Err) +MP4NewMovieFromHandle(MP4Movie *theMovie, MP4Handle movieH, u32 newMovieFlags) { - MP4Err err; - MP4PrivateMovieRecordPtr moov; - u32 handleSize; - - err = MP4NoErr; - moov = (MP4PrivateMovieRecordPtr) calloc( 1, sizeof(MP4PrivateMovieRecord) ); - TESTMALLOC( moov ); - moov->referenceCount = 1; - moov->prepend_handle = NULL; - moov->moovAtomPtr = NULL; - err = MP4GetHandleSize( movieH, &handleSize ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *movieH, handleSize, &moov->inputStream ); if (err) goto bail; - err = parseMovie( theMovie, moov, newMovieFlags ); if (err) goto bail; + MP4Err err; + MP4PrivateMovieRecordPtr moov; + u32 handleSize; + + err = MP4NoErr; + moov = (MP4PrivateMovieRecordPtr)calloc(1, sizeof(MP4PrivateMovieRecord)); + TESTMALLOC(moov); + moov->referenceCount = 1; + moov->prepend_handle = NULL; + moov->moovAtomPtr = NULL; + err = MP4GetHandleSize(movieH, &handleSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*movieH, handleSize, &moov->inputStream); + if(err) goto bail; + err = parseMovie(theMovie, moov, newMovieFlags); + if(err) goto bail; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) -MP4OpenMovieFile( MP4Movie *theMovie, const char *movieURL, int openMovieFlags ) +MP4_EXTERN(MP4Err) +MP4OpenMovieFile(MP4Movie *theMovie, const char *movieURL, int openMovieFlags) { - MP4Err err; - MP4PrivateMovieRecordPtr moov; - - err = MP4NoErr; - moov = (MP4PrivateMovieRecordPtr) calloc( 1, sizeof(MP4PrivateMovieRecord) ); - TESTMALLOC( moov ); - moov->referenceCount = 1; - moov->prepend_handle = NULL; - moov->moovAtomPtr = NULL; - err = MP4CreateFileMappingObject( (char*) movieURL, (struct FileMappingObjectRecord **) &moov->fileMappingObject ); if (err) goto bail; - err = MP4CreateFileMappingInputStream( moov->fileMappingObject, &moov->inputStream ); if (err) goto bail; - err = parseMovie( theMovie, moov, openMovieFlags ); if (err) goto bail; + MP4Err err; + MP4PrivateMovieRecordPtr moov; + + err = MP4NoErr; + moov = (MP4PrivateMovieRecordPtr)calloc(1, sizeof(MP4PrivateMovieRecord)); + TESTMALLOC(moov); + moov->referenceCount = 1; + moov->prepend_handle = NULL; + moov->moovAtomPtr = NULL; + err = MP4CreateFileMappingObject((char *)movieURL, + (struct FileMappingObjectRecord **)&moov->fileMappingObject); + if(err) goto bail; + err = MP4CreateFileMappingInputStream(moov->fileMappingObject, &moov->inputStream); + if(err) goto bail; + err = parseMovie(theMovie, moov, openMovieFlags); + if(err) goto bail; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } - - /* */ -MP4_EXTERN ( MP4Err ) -MP4GetMovieTrackCount( MP4Movie theMovie, u32* outTrackCount ) +MP4_EXTERN(MP4Err) +MP4GetMovieTrackCount(MP4Movie theMovie, u32 *outTrackCount) { - GETMOVIEATOM( theMovie ); - *outTrackCount = movieAtom->getTrackCount( movieAtom ); + GETMOVIEATOM(theMovie); + *outTrackCount = movieAtom->getTrackCount(movieAtom); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetMovieDuration( MP4Movie theMovie, u64* outDuration ) +MP4_EXTERN(MP4Err) +MP4GetMovieDuration(MP4Movie theMovie, u64 *outDuration) { - GETMOVIEHEADERATOM( theMovie ); - if ( outDuration == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - if ( movieHeaderAtom == 0 ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - err = movieAtom->calculateDuration( movieAtom ); if (err) goto bail; - *outDuration = movieHeaderAtom->duration; + GETMOVIEHEADERATOM(theMovie); + if(outDuration == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + if(movieHeaderAtom == 0) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + err = movieAtom->calculateDuration(movieAtom); + if(err) goto bail; + *outDuration = movieHeaderAtom->duration; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetMovieTimeScale( MP4Movie theMovie, u32* outTimeScale ) +MP4_EXTERN(MP4Err) +MP4GetMovieTimeScale(MP4Movie theMovie, u32 *outTimeScale) { - GETMOVIEHEADERATOM( theMovie ); - if ( outTimeScale == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - if ( movieHeaderAtom == 0 ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - *outTimeScale = movieHeaderAtom->timeScale; + GETMOVIEHEADERATOM(theMovie); + if(outTimeScale == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + if(movieHeaderAtom == 0) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + *outTimeScale = movieHeaderAtom->timeScale; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetMovieUserData( MP4Movie theMovie, MP4UserData* outUserData ) +MP4_EXTERN(MP4Err) +MP4GetMovieUserData(MP4Movie theMovie, MP4UserData *outUserData) { - MP4UserData udta; - GETMOVIEATOM( theMovie ); - if ( outUserData == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - udta = (MP4UserData) movieAtom->udta; - if ( movieAtom->udta == 0 ) - { - err = MP4NewUserData( &udta ); if (err) goto bail; - err = movieAtom->addAtom( movieAtom, (MP4AtomPtr) udta ); if (err) goto bail; - } - *outUserData = (MP4UserData) udta; + MP4UserData udta; + GETMOVIEATOM(theMovie); + if(outUserData == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + udta = (MP4UserData)movieAtom->udta; + if(movieAtom->udta == 0) + { + err = MP4NewUserData(&udta); + if(err) goto bail; + err = movieAtom->addAtom(movieAtom, (MP4AtomPtr)udta); + if(err) goto bail; + } + *outUserData = (MP4UserData)udta; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4AddAtomToMovie( MP4Movie theMovie, MP4GenericAtom the_atom ) +MP4_EXTERN(MP4Err) MP4AddAtomToMovie(MP4Movie theMovie, MP4GenericAtom the_atom) { - GETMOVIEATOM( theMovie ); + GETMOVIEATOM(theMovie); - err = MP4NoErr; - err = movieAtom->addAtom( movieAtom, (MP4AtomPtr) the_atom ); if (err) goto bail; + err = MP4NoErr; + err = movieAtom->addAtom(movieAtom, (MP4AtomPtr)the_atom); + if(err) goto bail; - bail: - TEST_RETURN( err ); +bail: + TEST_RETURN(err); - return err; + return err; } -MP4Err makeESD( MP4Movie theMovie, u32 trackNumber, u64 cts, MP4SLConfig inSLConfig, MP4DescriptorPtr *outDesc ) +MP4Err makeESD(MP4Movie theMovie, u32 trackNumber, u64 cts, MP4SLConfig inSLConfig, + MP4DescriptorPtr *outDesc) { - MP4Err MP4GetMediaSampleDescIndex( MP4Media theMedia, u64 desiredTime, u32 *outSampleDescriptionIndex ); - MP4Err MP4GetMediaESD( MP4Media theMedia, u32 index, MP4ES_DescriptorPtr *outESD, u32 *outDataReferenceIndex ); - MP4Err MP4CreateSLConfigDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - MP4Err MP4CreateES_Descriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - - MP4Err err; - MP4ES_DescriptorPtr esd; - MP4ES_DescriptorPtr esdInFile; - MP4SLConfigDescriptorPtr slconfig; - MP4TrackReferenceTypeAtomPtr dpnd; - MP4Track theTrack; - MP4Media theMedia; - u32 sampleDescIndex; - - err = MP4GetMovieTrack( theMovie, trackNumber, &theTrack ); if (err) goto bail; - err = MP4GetTrackMedia( theTrack, &theMedia ); if (err) goto bail; - err = MP4GetMediaSampleDescIndex( theMedia, cts, &sampleDescIndex ); if (err) goto bail; - err = MP4GetMediaESD( theMedia, sampleDescIndex, &esdInFile, 0 ); if (err) goto bail; - /* - err = MP4CreateES_Descriptor( MP4ES_DescriptorTag, 0, 0, (MP4DescriptorPtr*) &esd ); if (err) goto bail; - *esd = *esdInFile; - */ - /* We don't want a shallow copy, we want a deep copy */ - err = MP4CopyDescriptor( (MP4DescriptorPtr) esdInFile, (MP4DescriptorPtr*) &esd ); if (err) goto bail; - - esd->ESID = trackNumber; - - /* stream dependancy */ - err = MP4GetTrackReferenceType( theTrack, MP4StreamDependenceAtomType, &dpnd ); if (err) goto bail; - if ( dpnd && (dpnd->trackIDCount) ) - esd->dependsOnES = dpnd->trackIDs[0]; - - /* JLF 11/00 */ - /* OCR dependancy */ - err = MP4GetTrackReferenceType( theTrack, MP4SyncTrackReferenceAtomType, &dpnd ); if (err) goto bail; - if ( dpnd && (dpnd->trackIDCount) ) - esd->OCRESID = dpnd->trackIDs[0]; - - /* - handle SLConfig - */ - if ( inSLConfig ) - { - u32 movieTimeScale; - u32 mediaTimeScale; - - slconfig = (MP4SLConfigDescriptorPtr) malloc( sizeof(MP4SLConfigDescriptor) ); - if ( slconfig == NULL ) - { - BAILWITHERROR( MP4NoMemoryErr ); - } - *slconfig = *( (MP4SLConfigDescriptorPtr) inSLConfig); - err = MP4GetMovieTimeScale( theMovie, &movieTimeScale ); if (err) goto bail; - err = MP4GetMediaTimeScale( theMedia, &mediaTimeScale ); if (err) goto bail; - slconfig->timestampResolution = mediaTimeScale; - slconfig->OCRResolution = movieTimeScale; - slconfig->timeScale = mediaTimeScale; - slconfig->AUDuration = mediaTimeScale; - slconfig->CUDuration = mediaTimeScale; - } - else - { - slconfig = (MP4SLConfigDescriptorPtr) esd->slConfig; - if ( slconfig == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - if ( slconfig->predefined == SLConfigPredefinedMP4 ) - { - u32 movieTimeScale; - u32 mediaTimeScale; - - err = MP4GetMovieTimeScale( theMovie, &movieTimeScale ); if (err) goto bail; - err = MP4GetMediaTimeScale( theMedia, &mediaTimeScale ); if (err) goto bail; - err = MP4CreateSLConfigDescriptor( MP4SLConfigDescriptorTag, 0, 0, - (MP4DescriptorPtr *) &slconfig ); if (err) goto bail; - slconfig->predefined = 0; - slconfig->useAccessUnitStartFlag = 0; - slconfig->useAccessUnitEndFlag = 0; - slconfig->useRandomAccessPointFlag = 1; - slconfig->useRandomAccessUnitsOnlyFlag = 0; - slconfig->usePaddingFlag = 0; - slconfig->useTimestampsFlag = 1; - slconfig->useIdleFlag = 0; - slconfig->durationFlag = 0; - slconfig->timestampResolution = mediaTimeScale; - slconfig->OCRResolution = movieTimeScale; - slconfig->timestampLength = 32; - slconfig->OCRLength = 0; - slconfig->AULength = 0; - slconfig->instantBitrateLength = 0; - slconfig->degradationPriorityLength = 0; - slconfig->AUSeqNumLength = 0; - slconfig->packetSeqNumLength = 5; - slconfig->timeScale = mediaTimeScale; - slconfig->AUDuration = mediaTimeScale; - slconfig->CUDuration = mediaTimeScale; - slconfig->startDTS = 0; - slconfig->startCTS = 0; - } - } - - if (esd->slConfig) { - esd->slConfig->destroy( esd->slConfig ); - } - esd->slConfig = (MP4DescriptorPtr) slconfig; - - *outDesc = (MP4DescriptorPtr) esd; + MP4Err MP4GetMediaSampleDescIndex(MP4Media theMedia, u64 desiredTime, + u32 * outSampleDescriptionIndex); + MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr * outESD, + u32 * outDataReferenceIndex); + MP4Err MP4CreateSLConfigDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); + MP4Err MP4CreateES_Descriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); + + MP4Err err; + MP4ES_DescriptorPtr esd; + MP4ES_DescriptorPtr esdInFile; + MP4SLConfigDescriptorPtr slconfig; + MP4TrackReferenceTypeAtomPtr dpnd; + MP4Track theTrack; + MP4Media theMedia; + u32 sampleDescIndex; + + err = MP4GetMovieTrack(theMovie, trackNumber, &theTrack); + if(err) goto bail; + err = MP4GetTrackMedia(theTrack, &theMedia); + if(err) goto bail; + err = MP4GetMediaSampleDescIndex(theMedia, cts, &sampleDescIndex); + if(err) goto bail; + err = MP4GetMediaESD(theMedia, sampleDescIndex, &esdInFile, 0); + if(err) goto bail; + /* + err = MP4CreateES_Descriptor( MP4ES_DescriptorTag, 0, 0, (MP4DescriptorPtr*) &esd ); if (err) goto + bail; *esd = *esdInFile; + */ + /* We don't want a shallow copy, we want a deep copy */ + err = MP4CopyDescriptor((MP4DescriptorPtr)esdInFile, (MP4DescriptorPtr *)&esd); + if(err) goto bail; + + esd->ESID = trackNumber; + + /* stream dependancy */ + err = MP4GetTrackReferenceType(theTrack, MP4StreamDependenceAtomType, &dpnd); + if(err) goto bail; + if(dpnd && (dpnd->trackIDCount)) esd->dependsOnES = dpnd->trackIDs[0]; + + /* JLF 11/00 */ + /* OCR dependancy */ + err = MP4GetTrackReferenceType(theTrack, MP4SyncTrackReferenceAtomType, &dpnd); + if(err) goto bail; + if(dpnd && (dpnd->trackIDCount)) esd->OCRESID = dpnd->trackIDs[0]; + + /* + handle SLConfig + */ + if(inSLConfig) + { + u32 movieTimeScale; + u32 mediaTimeScale; + + slconfig = (MP4SLConfigDescriptorPtr)malloc(sizeof(MP4SLConfigDescriptor)); + if(slconfig == NULL) + { + BAILWITHERROR(MP4NoMemoryErr); + } + *slconfig = *((MP4SLConfigDescriptorPtr)inSLConfig); + err = MP4GetMovieTimeScale(theMovie, &movieTimeScale); + if(err) goto bail; + err = MP4GetMediaTimeScale(theMedia, &mediaTimeScale); + if(err) goto bail; + slconfig->timestampResolution = mediaTimeScale; + slconfig->OCRResolution = movieTimeScale; + slconfig->timeScale = mediaTimeScale; + slconfig->AUDuration = mediaTimeScale; + slconfig->CUDuration = mediaTimeScale; + } + else + { + slconfig = (MP4SLConfigDescriptorPtr)esd->slConfig; + if(slconfig == NULL) BAILWITHERROR(MP4InvalidMediaErr); + if(slconfig->predefined == SLConfigPredefinedMP4) + { + u32 movieTimeScale; + u32 mediaTimeScale; + + err = MP4GetMovieTimeScale(theMovie, &movieTimeScale); + if(err) goto bail; + err = MP4GetMediaTimeScale(theMedia, &mediaTimeScale); + if(err) goto bail; + err = MP4CreateSLConfigDescriptor(MP4SLConfigDescriptorTag, 0, 0, + (MP4DescriptorPtr *)&slconfig); + if(err) goto bail; + slconfig->predefined = 0; + slconfig->useAccessUnitStartFlag = 0; + slconfig->useAccessUnitEndFlag = 0; + slconfig->useRandomAccessPointFlag = 1; + slconfig->useRandomAccessUnitsOnlyFlag = 0; + slconfig->usePaddingFlag = 0; + slconfig->useTimestampsFlag = 1; + slconfig->useIdleFlag = 0; + slconfig->durationFlag = 0; + slconfig->timestampResolution = mediaTimeScale; + slconfig->OCRResolution = movieTimeScale; + slconfig->timestampLength = 32; + slconfig->OCRLength = 0; + slconfig->AULength = 0; + slconfig->instantBitrateLength = 0; + slconfig->degradationPriorityLength = 0; + slconfig->AUSeqNumLength = 0; + slconfig->packetSeqNumLength = 5; + slconfig->timeScale = mediaTimeScale; + slconfig->AUDuration = mediaTimeScale; + slconfig->CUDuration = mediaTimeScale; + slconfig->startDTS = 0; + slconfig->startCTS = 0; + } + } + + if(esd->slConfig) + { + esd->slConfig->destroy(esd->slConfig); + } + esd->slConfig = (MP4DescriptorPtr)slconfig; + + *outDesc = (MP4DescriptorPtr)esd; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetMovieIODInlineProfileFlag( MP4Movie theMovie, u8* outFlag ) +MP4_EXTERN(MP4Err) +MP4GetMovieIODInlineProfileFlag(MP4Movie theMovie, u8 *outFlag) { - MP4InitialObjectDescriptorPtr iod; - GETIODATOM( theMovie ); - - if ( outFlag == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - if ( iodAtom->ODSize == 0) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - iod = (MP4InitialObjectDescriptorPtr) iodAtom->descriptor; - if ( iod == 0 ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - /* jlf 12/00: escape sequence for OD */ - if (iod->tag == MP4_OD_Tag) return MP4HasRootOD; - - *outFlag = (iod->inlineProfileFlag != 0); + MP4InitialObjectDescriptorPtr iod; + GETIODATOM(theMovie); + + if(outFlag == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + if(iodAtom->ODSize == 0) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + iod = (MP4InitialObjectDescriptorPtr)iodAtom->descriptor; + if(iod == 0) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + /* jlf 12/00: escape sequence for OD */ + if(iod->tag == MP4_OD_Tag) return MP4HasRootOD; + + *outFlag = (iod->inlineProfileFlag != 0); bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) -MP4SetMovieIODInlineProfileFlag( MP4Movie theMovie, u8 theFlag ) +MP4_EXTERN(MP4Err) +MP4SetMovieIODInlineProfileFlag(MP4Movie theMovie, u8 theFlag) { - MP4InitialObjectDescriptorPtr iod; - GETIODATOM( theMovie ); - - if ( iodAtom->ODSize == 0) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - iod = (MP4InitialObjectDescriptorPtr) iodAtom->descriptor; - if ( iod == 0 ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - /* jlf 12/00: escape sequence for OD */ - if ((iod->tag == MP4_OD_Tag) || (iod->tag == MP4ObjectDescriptorTag)) return MP4HasRootOD; - iod->inlineProfileFlag = (theFlag != 0); + MP4InitialObjectDescriptorPtr iod; + GETIODATOM(theMovie); + + if(iodAtom->ODSize == 0) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + iod = (MP4InitialObjectDescriptorPtr)iodAtom->descriptor; + if(iod == 0) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + /* jlf 12/00: escape sequence for OD */ + if((iod->tag == MP4_OD_Tag) || (iod->tag == MP4ObjectDescriptorTag)) return MP4HasRootOD; + iod->inlineProfileFlag = (theFlag != 0); bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetMovieProfilesAndLevels( MP4Movie theMovie, u8 *outOD, u8 *outScene, - u8 *outAudio, u8 *outVisual, u8 *outGraphics ) +MP4_EXTERN(MP4Err) +MP4GetMovieProfilesAndLevels(MP4Movie theMovie, u8 *outOD, u8 *outScene, u8 *outAudio, + u8 *outVisual, u8 *outGraphics) { - MP4InitialObjectDescriptorPtr iodDesc; - GETIODATOM( theMovie ); - - if ( iodAtom->ODSize == 0) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - iodDesc = (MP4InitialObjectDescriptorPtr) iodAtom->descriptor; - if ( iodDesc == 0 ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - /* jlf 12/00: escape sequence for OD */ - if ((iodDesc->tag == MP4_OD_Tag) || (iodDesc->tag == MP4ObjectDescriptorTag)) return MP4HasRootOD; - - if ( outOD ) - { - *outOD = (u8) iodDesc->OD_profileAndLevel; - } - if ( outScene ) - { - *outScene = (u8) iodDesc->scene_profileAndLevel; - } - if ( outAudio ) - { - *outAudio = (u8) iodDesc->audio_profileAndLevel; - } - if ( outVisual ) - { - *outVisual = (u8) iodDesc->visual_profileAndLevel; - } - if ( outGraphics ) - { - *outGraphics = (u8) iodDesc->graphics_profileAndLevel; - } + MP4InitialObjectDescriptorPtr iodDesc; + GETIODATOM(theMovie); + + if(iodAtom->ODSize == 0) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + iodDesc = (MP4InitialObjectDescriptorPtr)iodAtom->descriptor; + if(iodDesc == 0) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + /* jlf 12/00: escape sequence for OD */ + if((iodDesc->tag == MP4_OD_Tag) || (iodDesc->tag == MP4ObjectDescriptorTag)) return MP4HasRootOD; + + if(outOD) + { + *outOD = (u8)iodDesc->OD_profileAndLevel; + } + if(outScene) + { + *outScene = (u8)iodDesc->scene_profileAndLevel; + } + if(outAudio) + { + *outAudio = (u8)iodDesc->audio_profileAndLevel; + } + if(outVisual) + { + *outVisual = (u8)iodDesc->visual_profileAndLevel; + } + if(outGraphics) + { + *outGraphics = (u8)iodDesc->graphics_profileAndLevel; + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetMovieInitialObjectDescriptor( MP4Movie theMovie, MP4Handle outDescriptorH ) +MP4_EXTERN(MP4Err) +MP4GetMovieInitialObjectDescriptor(MP4Movie theMovie, MP4Handle outDescriptorH) { - return MP4GetMovieInitialObjectDescriptorUsingSLConfig( theMovie, 0, outDescriptorH ); + return MP4GetMovieInitialObjectDescriptorUsingSLConfig(theMovie, 0, outDescriptorH); } -MP4_EXTERN ( MP4Err ) -MP4GetMovieInitialObjectDescriptorUsingSLConfig( MP4Movie theMovie, MP4SLConfig slconfig, MP4Handle outDescriptorH ) +MP4_EXTERN(MP4Err) +MP4GetMovieInitialObjectDescriptorUsingSLConfig(MP4Movie theMovie, MP4SLConfig slconfig, + MP4Handle outDescriptorH) { - MP4Err MP4CreateSLConfigDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - MP4Err MP4GetMediaESD( MP4Media theMedia, u32 index, MP4ES_DescriptorPtr *outESD, u32 *outDataReferenceIndex ); - MP4Err MP4GetMovieObjectDescriptorUsingSLConfig( MP4Movie theMovie, MP4SLConfig slconfig, MP4Handle outDescriptorH ); - - MP4InitialObjectDescriptorPtr iodDesc; - MP4LinkedList incDescriptors; - GETIODATOM( theMovie ); - - if (iodAtom && ( iodAtom->ODSize )) - { - u32 count; - u32 i; - u32 trackCount; - - /* jlf 11/00 : if this is an OD, extract directly the OD. */ - if (iodAtom->descriptor->tag == MP4_OD_Tag) { - return MP4GetMovieObjectDescriptorUsingSLConfig(theMovie, slconfig, outDescriptorH); - } - - err = MP4GetMovieTrackCount( theMovie, &trackCount ); if (err) goto bail; - iodDesc = (MP4InitialObjectDescriptorPtr) iodAtom->descriptor; - err = MP4GetListEntryCount( iodDesc->ES_ID_IncDescriptors, &count ); if (err) goto bail; - - /* - get and rewrite ES_Descriptors, placing each in iodDesc - */ - for ( i = 0; i < count; i++ ) - { - - MP4ES_ID_IncDescriptorPtr inc; - MP4ES_DescriptorPtr esd; - - err = MP4GetListEntry( iodDesc->ES_ID_IncDescriptors, i, (char **) &inc ); if (err) goto bail; - err = makeESD( theMovie, inc->trackID, 0, slconfig, (MP4DescriptorPtr *) &esd ); if (err) goto bail; - /* add esd to iodDesc */ - err = iodDesc->addDescriptor( (MP4DescriptorPtr) iodDesc, (MP4DescriptorPtr) esd ); if (err) goto bail; - } - /* - err = MP4DeleteLinkedList( iodDesc->ES_ID_IncDescriptors ); if (err) goto bail; - */ - incDescriptors = iodDesc->ES_ID_IncDescriptors; - iodDesc->ES_ID_IncDescriptors = NULL; - iodDesc->tag = MP4InitialObjectDescriptorTag; - err = iodDesc->calculateSize( (MP4DescriptorPtr) iodDesc ); if (err) goto bail; - err = MP4SetHandleSize( outDescriptorH, iodDesc->size ); if (err) goto bail; - err = iodDesc->serialize((MP4DescriptorPtr) iodDesc, *outDescriptorH ); if (err) goto bail; - err = iodDesc->removeESDS( (MP4DescriptorPtr) iodDesc ); if (err) goto bail; - iodDesc->ES_ID_IncDescriptors = incDescriptors; - iodDesc->tag = MP4_IOD_Tag; - } - else err = MP4BadDataErr; + MP4Err MP4CreateSLConfigDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); + MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr * outESD, + u32 * outDataReferenceIndex); + MP4Err MP4GetMovieObjectDescriptorUsingSLConfig(MP4Movie theMovie, MP4SLConfig slconfig, + MP4Handle outDescriptorH); + + MP4InitialObjectDescriptorPtr iodDesc; + MP4LinkedList incDescriptors; + GETIODATOM(theMovie); + + if(iodAtom && (iodAtom->ODSize)) + { + u32 count; + u32 i; + u32 trackCount; + + /* jlf 11/00 : if this is an OD, extract directly the OD. */ + if(iodAtom->descriptor->tag == MP4_OD_Tag) + { + return MP4GetMovieObjectDescriptorUsingSLConfig(theMovie, slconfig, outDescriptorH); + } + + err = MP4GetMovieTrackCount(theMovie, &trackCount); + if(err) goto bail; + iodDesc = (MP4InitialObjectDescriptorPtr)iodAtom->descriptor; + err = MP4GetListEntryCount(iodDesc->ES_ID_IncDescriptors, &count); + if(err) goto bail; + + /* + get and rewrite ES_Descriptors, placing each in iodDesc + */ + for(i = 0; i < count; i++) + { + + MP4ES_ID_IncDescriptorPtr inc; + MP4ES_DescriptorPtr esd; + + err = MP4GetListEntry(iodDesc->ES_ID_IncDescriptors, i, (char **)&inc); + if(err) goto bail; + err = makeESD(theMovie, inc->trackID, 0, slconfig, (MP4DescriptorPtr *)&esd); + if(err) goto bail; + /* add esd to iodDesc */ + err = iodDesc->addDescriptor((MP4DescriptorPtr)iodDesc, (MP4DescriptorPtr)esd); + if(err) goto bail; + } + /* +err = MP4DeleteLinkedList( iodDesc->ES_ID_IncDescriptors ); if (err) goto bail; +*/ + incDescriptors = iodDesc->ES_ID_IncDescriptors; + iodDesc->ES_ID_IncDescriptors = NULL; + iodDesc->tag = MP4InitialObjectDescriptorTag; + err = iodDesc->calculateSize((MP4DescriptorPtr)iodDesc); + if(err) goto bail; + err = MP4SetHandleSize(outDescriptorH, iodDesc->size); + if(err) goto bail; + err = iodDesc->serialize((MP4DescriptorPtr)iodDesc, *outDescriptorH); + if(err) goto bail; + err = iodDesc->removeESDS((MP4DescriptorPtr)iodDesc); + if(err) goto bail; + iodDesc->ES_ID_IncDescriptors = incDescriptors; + iodDesc->tag = MP4_IOD_Tag; + } + else + err = MP4BadDataErr; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetMovieIndTrack( MP4Movie theMovie, u32 trackIndex, MP4Track *outTrack ) +MP4_EXTERN(MP4Err) +MP4GetMovieIndTrack(MP4Movie theMovie, u32 trackIndex, MP4Track *outTrack) { - MP4AtomPtr aTrack; - GETMOVIEATOM( theMovie ); - if ( (trackIndex == 0) || (trackIndex > movieAtom->getTrackCount(movieAtom)) ) - BAILWITHERROR( MP4BadParamErr ) - err = movieAtom->getIndTrack( movieAtom, trackIndex, &aTrack ); if (err) goto bail; - if ( aTrack == NULL ) - BAILWITHERROR( MP4BadDataErr ) - *outTrack = (MP4Track) aTrack; + MP4AtomPtr aTrack; + GETMOVIEATOM(theMovie); + if((trackIndex == 0) || (trackIndex > movieAtom->getTrackCount(movieAtom))) + BAILWITHERROR(MP4BadParamErr) + err = movieAtom->getIndTrack(movieAtom, trackIndex, &aTrack); + if(err) goto bail; + if(aTrack == NULL) BAILWITHERROR(MP4BadDataErr) + *outTrack = (MP4Track)aTrack; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetMovieTrack( MP4Movie theMovie, u32 trackID, MP4Track *outTrack ) +MP4_EXTERN(MP4Err) +MP4GetMovieTrack(MP4Movie theMovie, u32 trackID, MP4Track *outTrack) { - u32 i; - u32 trackCount; - - MP4Err err; - err = MP4GetMovieTrackCount( theMovie, &trackCount ); if (err) goto bail; - if ( trackCount == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - for ( i = 1; i <= trackCount; i++ ) - { - MP4Track t; - u32 id; - err = MP4GetMovieIndTrack( theMovie, i, &t ); if (err) goto bail; - err = MP4GetTrackID( t, &id ); if (err) goto bail; - if ( id == trackID ) - { - *outTrack = t; - break; - } - else if ( i == trackCount ) - err = MP4BadParamErr; - } + u32 i; + u32 trackCount; + + MP4Err err; + err = MP4GetMovieTrackCount(theMovie, &trackCount); + if(err) goto bail; + if(trackCount == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + for(i = 1; i <= trackCount; i++) + { + MP4Track t; + u32 id; + err = MP4GetMovieIndTrack(theMovie, i, &t); + if(err) goto bail; + err = MP4GetTrackID(t, &id); + if(err) goto bail; + if(id == trackID) + { + *outTrack = t; + break; + } + else if(i == trackCount) + err = MP4BadParamErr; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4SetMovieTimeScale( MP4Movie theMovie, u32 timeScale ) +MP4_EXTERN(MP4Err) +MP4SetMovieTimeScale(MP4Movie theMovie, u32 timeScale) { - GETMOVIEATOM( theMovie ); - if ( timeScale == 0 ) - BAILWITHERROR( MP4BadParamErr ); - assert( movieAtom->setTimeScale ); - err = movieAtom->setTimeScale( movieAtom, timeScale ); if (err) goto bail; + GETMOVIEATOM(theMovie); + if(timeScale == 0) BAILWITHERROR(MP4BadParamErr); + assert(movieAtom->setTimeScale); + err = movieAtom->setTimeScale(movieAtom, timeScale); + if(err) goto bail; bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) -MJ2SetMovieMatrix( ISOMovie theMovie, u32 matrix[9] ) +ISO_EXTERN(ISOErr) +MJ2SetMovieMatrix(ISOMovie theMovie, u32 matrix[9]) { - u32 aMatrix[9]; - GETMOVIEATOM( theMovie ); - if ( matrix == NULL ) { - /* if we are passed a NULL matrix, use the identity matrix */ - aMatrix[0] = 0x00010000; - aMatrix[1] = 0; - aMatrix[2] = 0; - aMatrix[3] = 0; - aMatrix[4] = 0x00010000; - aMatrix[5] = 0; - aMatrix[6] = 0; - aMatrix[7] = 0; - aMatrix[8] = 0x40000000; - } else { - memcpy( &aMatrix, matrix, sizeof(ISOMatrixRecord) ); - } - err = movieAtom->setMatrix( movieAtom, aMatrix ); + u32 aMatrix[9]; + GETMOVIEATOM(theMovie); + if(matrix == NULL) + { + /* if we are passed a NULL matrix, use the identity matrix */ + aMatrix[0] = 0x00010000; + aMatrix[1] = 0; + aMatrix[2] = 0; + aMatrix[3] = 0; + aMatrix[4] = 0x00010000; + aMatrix[5] = 0; + aMatrix[6] = 0; + aMatrix[7] = 0; + aMatrix[8] = 0x40000000; + } + else + { + memcpy(&aMatrix, matrix, sizeof(ISOMatrixRecord)); + } + err = movieAtom->setMatrix(movieAtom, aMatrix); bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) -MJ2GetMovieMatrix( ISOMovie theMovie, u32 outMatrix[9] ) +ISO_EXTERN(ISOErr) +MJ2GetMovieMatrix(ISOMovie theMovie, u32 outMatrix[9]) { - GETMOVIEATOM( theMovie ); - if ( outMatrix == NULL ) - BAILWITHERROR( MP4BadParamErr ); - assert( movieAtom->getMatrix ); - err = movieAtom->getMatrix( movieAtom, outMatrix ); + GETMOVIEATOM(theMovie); + if(outMatrix == NULL) BAILWITHERROR(MP4BadParamErr); + assert(movieAtom->getMatrix); + err = movieAtom->getMatrix(movieAtom, outMatrix); bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) -MJ2SetMoviePreferredRate( ISOMovie theMovie, u32 rate ) +ISO_EXTERN(ISOErr) +MJ2SetMoviePreferredRate(ISOMovie theMovie, u32 rate) { - GETMOVIEATOM( theMovie ); - assert( movieAtom->setPreferredRate ); - err = movieAtom->setPreferredRate( movieAtom, rate ); + GETMOVIEATOM(theMovie); + assert(movieAtom->setPreferredRate); + err = movieAtom->setPreferredRate(movieAtom, rate); bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) -MJ2GetMoviePreferredRate( ISOMovie theMovie, u32 *outRate ) +ISO_EXTERN(ISOErr) +MJ2GetMoviePreferredRate(ISOMovie theMovie, u32 *outRate) { - GETMOVIEATOM( theMovie ); - if ( outRate == NULL ) - BAILWITHERROR( MP4BadParamErr ); - assert( movieAtom->getPreferredRate ); - err = movieAtom->getPreferredRate( movieAtom, outRate ); + GETMOVIEATOM(theMovie); + if(outRate == NULL) BAILWITHERROR(MP4BadParamErr); + assert(movieAtom->getPreferredRate); + err = movieAtom->getPreferredRate(movieAtom, outRate); bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) -MJ2SetMoviePreferredVolume( ISOMovie theMovie, s16 volume ) +ISO_EXTERN(ISOErr) +MJ2SetMoviePreferredVolume(ISOMovie theMovie, s16 volume) { - GETMOVIEATOM( theMovie ); - assert( movieAtom->setPreferredVolume ); - err = movieAtom->setPreferredVolume( movieAtom, volume ); + GETMOVIEATOM(theMovie); + assert(movieAtom->setPreferredVolume); + err = movieAtom->setPreferredVolume(movieAtom, volume); bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) -MJ2GetMoviePreferredVolume( ISOMovie theMovie, s16 *outVolume ) +ISO_EXTERN(ISOErr) +MJ2GetMoviePreferredVolume(ISOMovie theMovie, s16 *outVolume) { - GETMOVIEATOM( theMovie ); - if ( outVolume == NULL ) - BAILWITHERROR( MP4BadParamErr ); - assert( movieAtom->getPreferredVolume ); - err = movieAtom->getPreferredVolume( movieAtom, outVolume ); + GETMOVIEATOM(theMovie); + if(outVolume == NULL) BAILWITHERROR(MP4BadParamErr); + assert(movieAtom->getPreferredVolume); + err = movieAtom->getPreferredVolume(movieAtom, outVolume); bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) -ISOSetMovieBrand( ISOMovie theMovie, u32 brand, u32 minorversion ) +ISO_EXTERN(ISOErr) +ISOSetMovieBrand(ISOMovie theMovie, u32 brand, u32 minorversion) { - ISOFileTypeAtomPtr ftyp; - GETMOOV( theMovie ); + ISOFileTypeAtomPtr ftyp; + GETMOOV(theMovie); - ftyp = (ISOFileTypeAtomPtr)moov->ftyp; - if (ftyp) - err = ftyp->setBrand( ftyp, brand, minorversion ); - else BAILWITHERROR( MP4NoQTAtomErr ) + ftyp = (ISOFileTypeAtomPtr)moov->ftyp; + if(ftyp) err = ftyp->setBrand(ftyp, brand, minorversion); + else + BAILWITHERROR(MP4NoQTAtomErr) bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) -ISOSetMovieCompatibleBrand( ISOMovie theMovie, u32 brand ) +ISO_EXTERN(ISOErr) +ISOSetMovieCompatibleBrand(ISOMovie theMovie, u32 brand) { - ISOFileTypeAtomPtr ftyp; - GETMOOV( theMovie ); - ftyp = (ISOFileTypeAtomPtr) moov->ftyp; - if (ftyp) - err = ftyp->addStandard( ftyp, brand ); - else BAILWITHERROR( MP4NoQTAtomErr ) + ISOFileTypeAtomPtr ftyp; + GETMOOV(theMovie); + ftyp = (ISOFileTypeAtomPtr)moov->ftyp; + if(ftyp) err = ftyp->addStandard(ftyp, brand); + else + BAILWITHERROR(MP4NoQTAtomErr) bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) -ISOGetMovieBrand( ISOMovie theMovie, u32* brand, u32* minorversion ) +ISO_EXTERN(ISOErr) +ISOGetMovieBrand(ISOMovie theMovie, u32 *brand, u32 *minorversion) { - ISOFileTypeAtomPtr ftyp; - GETMOOV( theMovie ); + ISOFileTypeAtomPtr ftyp; + GETMOOV(theMovie); - ftyp = (ISOFileTypeAtomPtr)moov->ftyp; - if (ftyp) - err = ftyp->getBrand( ftyp, brand, minorversion ); - else BAILWITHERROR( MP4NoQTAtomErr ) + ftyp = (ISOFileTypeAtomPtr)moov->ftyp; + if(ftyp) err = ftyp->getBrand(ftyp, brand, minorversion); + else + BAILWITHERROR(MP4NoQTAtomErr) bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( u32 ) -ISOIsMovieCompatibleBrand( ISOMovie theMovie, u32 brand ) +ISO_EXTERN(u32) +ISOIsMovieCompatibleBrand(ISOMovie theMovie, u32 brand) { - ISOFileTypeAtomPtr ftyp; - u32 outval = 0; - - GETMOOV( theMovie ); - ftyp = (ISOFileTypeAtomPtr) moov->ftyp; - if (ftyp) - outval = ftyp->getStandard( ftyp, brand ); - else BAILWITHERROR( MP4NoQTAtomErr ) + ISOFileTypeAtomPtr ftyp; + u32 outval = 0; + + GETMOOV(theMovie); + ftyp = (ISOFileTypeAtomPtr)moov->ftyp; + if(ftyp) outval = ftyp->getStandard(ftyp, brand); + else + BAILWITHERROR(MP4NoQTAtomErr) bail: - TEST_RETURN( err ); - return outval; + TEST_RETURN(err); + return outval; } -MP4_EXTERN ( MP4Err ) -MP4NewMovieTrack( MP4Movie theMovie, u32 newTrackFlags, MP4Track *outTrack ) +MP4_EXTERN(MP4Err) +MP4NewMovieTrack(MP4Movie theMovie, u32 newTrackFlags, MP4Track *outTrack) { - MP4TrackAtomPtr trak; - GETMOVIEATOM( theMovie ); - err = movieAtom->newTrack( movieAtom, newTrackFlags, (MP4AtomPtr*) &trak ); if (err) goto bail; - err = trak->setMdat( trak, moov->mdat ); if (err) goto bail; - trak->moov = moov; - *outTrack = (MP4Track) trak; - + MP4TrackAtomPtr trak; + GETMOVIEATOM(theMovie); + err = movieAtom->newTrack(movieAtom, newTrackFlags, (MP4AtomPtr *)&trak); + if(err) goto bail; + err = trak->setMdat(trak, moov->mdat); + if(err) goto bail; + trak->moov = moov; + *outTrack = (MP4Track)trak; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) -MP4NewMovieTrackWithID( MP4Movie theMovie, u32 newTrackFlags, u32 newTrackID, MP4Track *outTrack ) +MP4_EXTERN(MP4Err) +MP4NewMovieTrackWithID(MP4Movie theMovie, u32 newTrackFlags, u32 newTrackID, MP4Track *outTrack) { - MP4TrackAtomPtr trak; - GETMOVIEATOM( theMovie ); - err = movieAtom->newTrackWithID( movieAtom, newTrackFlags, newTrackID, (MP4AtomPtr*) &trak ); if (err) goto bail; - err = trak->setMdat( trak, moov->mdat ); if (err) goto bail; - trak->moov = moov; - *outTrack = (MP4Track) trak; + MP4TrackAtomPtr trak; + GETMOVIEATOM(theMovie); + err = movieAtom->newTrackWithID(movieAtom, newTrackFlags, newTrackID, (MP4AtomPtr *)&trak); + if(err) goto bail; + err = trak->setMdat(trak, moov->mdat); + if(err) goto bail; + trak->moov = moov; + *outTrack = (MP4Track)trak; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } #if 0 @@ -997,21 +1056,18 @@ MP4SetMovieInitialODTrack( MP4Movie theMovie, MP4Track theODTrack ) } #endif -MP4_EXTERN ( MP4Err ) -MP4NewMovie( MP4Movie *outMovie, u32 initialODID, - u8 OD_profileAndLevel, u8 scene_profileAndLevel, - u8 audio_profileAndLevel, u8 visual_profileAndLevel, - u8 graphics_profileAndLevel ) +MP4_EXTERN(MP4Err) +MP4NewMovie(MP4Movie *outMovie, u32 initialODID, u8 OD_profileAndLevel, u8 scene_profileAndLevel, + u8 audio_profileAndLevel, u8 visual_profileAndLevel, u8 graphics_profileAndLevel) { - return MP4NewMovieExt( outMovie, initialODID, - OD_profileAndLevel, scene_profileAndLevel, - audio_profileAndLevel, visual_profileAndLevel, - graphics_profileAndLevel, - "", - (u8) ( ((OD_profileAndLevel == 0) && (scene_profileAndLevel == 0) && - (audio_profileAndLevel == 0) && (visual_profileAndLevel == 0) && - (graphics_profileAndLevel == 0)) ? 1 : 0 ) ); - + return MP4NewMovieExt(outMovie, initialODID, OD_profileAndLevel, scene_profileAndLevel, + audio_profileAndLevel, visual_profileAndLevel, graphics_profileAndLevel, "", + (u8)(((OD_profileAndLevel == 0) && (scene_profileAndLevel == 0) && + (audio_profileAndLevel == 0) && (visual_profileAndLevel == 0) && + (graphics_profileAndLevel == 0)) + ? 1 + : 0)); + #if 0 MP4Err MP4CreateInitialObjectDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); MP4Err MP4CreateMediaDataAtom( MP4MediaDataAtomPtr *outAtom ); @@ -1076,33 +1132,30 @@ MP4NewMovie( MP4Movie *outMovie, u32 initialODID, TEST_RETURN( err ); return err; -#endif +#endif } -MP4Err MP4MovieCreateDescriptors( MP4Movie theMovie ) +MP4Err MP4MovieCreateDescriptors(MP4Movie theMovie) { - MP4Err MP4CreateES_ID_IncDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - MP4ObjectDescriptorAtomPtr iods; - MP4DescriptorPtr desc; - MP4PrivateMovieRecordPtr movieRecord; - - GETMOVIEATOM( theMovie ); - - /* return with no error for non-MPEG-4 movies */ - movieRecord = (MP4PrivateMovieRecordPtr) theMovie; - if (movieRecord->fileType != ISOMPEG4FileType) - return ISONoErr; - - err = movieAtom->calculateDuration( movieAtom ); if (err) goto bail; - - iods = (MP4ObjectDescriptorAtomPtr) movieAtom->iods; - if ( iods == NULL ) - BAILWITHERROR( MP4NoErr ); /* was MP4InvalidMediaErr -- iods is now optional */ - desc = (MP4DescriptorPtr) iods->descriptor; - if ( desc == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - if ( (desc->tag != MP4_IOD_Tag) && (desc->tag != MP4_OD_Tag)) - BAILWITHERROR( MP4InvalidMediaErr ); + MP4Err MP4CreateES_ID_IncDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); + MP4ObjectDescriptorAtomPtr iods; + MP4DescriptorPtr desc; + MP4PrivateMovieRecordPtr movieRecord; + + GETMOVIEATOM(theMovie); + + /* return with no error for non-MPEG-4 movies */ + movieRecord = (MP4PrivateMovieRecordPtr)theMovie; + if(movieRecord->fileType != ISOMPEG4FileType) return ISONoErr; + + err = movieAtom->calculateDuration(movieAtom); + if(err) goto bail; + + iods = (MP4ObjectDescriptorAtomPtr)movieAtom->iods; + if(iods == NULL) BAILWITHERROR(MP4NoErr); /* was MP4InvalidMediaErr -- iods is now optional */ + desc = (MP4DescriptorPtr)iods->descriptor; + if(desc == NULL) BAILWITHERROR(MP4InvalidMediaErr); + if((desc->tag != MP4_IOD_Tag) && (desc->tag != MP4_OD_Tag)) BAILWITHERROR(MP4InvalidMediaErr); #if 0 if ( moov->initialBIFS ) @@ -1121,323 +1174,362 @@ MP4Err MP4MovieCreateDescriptors( MP4Movie theMovie ) } #endif bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4MovieAddTrackES_IDToIOD( MP4Movie theMovie, MP4Track theTrack ) +MP4Err MP4MovieAddTrackES_IDToIOD(MP4Movie theMovie, MP4Track theTrack) { - MP4Err MP4CreateES_ID_IncDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - MP4ObjectDescriptorAtomPtr iods; - MP4InitialObjectDescriptorPtr iod; - MP4ES_ID_IncDescriptorPtr inc; - - GETMOVIEATOM( theMovie ); - if ( theTrack == 0 ) - BAILWITHERROR( MP4BadParamErr ); - iods = (MP4ObjectDescriptorAtomPtr) movieAtom->iods; - if ( iods == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - iod = (MP4InitialObjectDescriptorPtr) iods->descriptor; - if ( (iod == NULL) || (iod->ES_ID_IncDescriptors == NULL) ) - BAILWITHERROR( MP4InvalidMediaErr ); - - err = MP4CreateES_ID_IncDescriptor( MP4ES_ID_IncDescriptorTag, 0, 0, (MP4DescriptorPtr*) &inc ); - if (err) goto bail; - err = MP4GetTrackID( theTrack, &inc->trackID ); - if (err) goto bail; - err = iod->addDescriptor( (MP4DescriptorPtr) iod, (MP4DescriptorPtr) inc ); - if (err) goto bail; + MP4Err MP4CreateES_ID_IncDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); + MP4ObjectDescriptorAtomPtr iods; + MP4InitialObjectDescriptorPtr iod; + MP4ES_ID_IncDescriptorPtr inc; + + GETMOVIEATOM(theMovie); + if(theTrack == 0) BAILWITHERROR(MP4BadParamErr); + iods = (MP4ObjectDescriptorAtomPtr)movieAtom->iods; + if(iods == NULL) BAILWITHERROR(MP4InvalidMediaErr); + iod = (MP4InitialObjectDescriptorPtr)iods->descriptor; + if((iod == NULL) || (iod->ES_ID_IncDescriptors == NULL)) BAILWITHERROR(MP4InvalidMediaErr); + + err = MP4CreateES_ID_IncDescriptor(MP4ES_ID_IncDescriptorTag, 0, 0, (MP4DescriptorPtr *)&inc); + if(err) goto bail; + err = MP4GetTrackID(theTrack, &inc->trackID); + if(err) goto bail; + err = iod->addDescriptor((MP4DescriptorPtr)iod, (MP4DescriptorPtr)inc); + if(err) goto bail; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } #define MAC_EPOCH 2082844800 -MP4Err MP4GetCurrentTime( u64 *outTime ) +MP4Err MP4GetCurrentTime(u64 *outTime) { - MP4Err err; - unsigned long calctime; - u64 ret; - err = MP4NoErr; - if ( outTime == NULL ) - BAILWITHERROR( MP4BadParamErr ) + MP4Err err; + unsigned long calctime; + u64 ret; + err = MP4NoErr; + if(outTime == NULL) BAILWITHERROR(MP4BadParamErr) #ifdef macintosh - GetDateTime( &calctime ); + GetDateTime(&calctime); #else - { - time_t t; - t = time( NULL ); - calctime = t + MAC_EPOCH; - } + { + time_t t; + t = time(NULL); + calctime = t + MAC_EPOCH; + } #endif - ret = calctime; - *outTime = ret; + ret = calctime; + *outTime = ret; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISO_EXTERN ( MP4Err ) -NewMPEG21( MP4Movie *outMovie ) +ISO_EXTERN(MP4Err) +NewMPEG21(MP4Movie *outMovie) { - return ISONewMetaMovie( outMovie, ISOMPEG21Brand, ISOMPEG21Brand, 0); + return ISONewMetaMovie(outMovie, ISOMPEG21Brand, ISOMPEG21Brand, 0); } -ISO_EXTERN (MP4Err) -ISONewMetaMovie( MP4Movie *outMovie, u32 handlertype, u32 brand, u32 minorversion ) +ISO_EXTERN(MP4Err) +ISONewMetaMovie(MP4Movie *outMovie, u32 handlertype, u32 brand, u32 minorversion) { - MP4Err MP4CreateMediaDataAtom( MP4MediaDataAtomPtr *outAtom ); - MP4Err err; - MP4PrivateMovieRecordPtr movie; - ISOFileTypeAtomPtr ftyp; - MP4MediaDataAtomPtr mdat; - ISOMeta meta; - - movie = (MP4PrivateMovieRecordPtr) calloc( 1, sizeof(MP4PrivateMovieRecord) ); - TESTMALLOC(movie); - movie->referenceCount = 1; - movie->prepend_handle = NULL; - - err = MP4CreateMediaDataAtom( &mdat ); - movie->mdat = (MP4AtomPtr) mdat; - { - MP4DataHandlerPtr dh; - err = MP4CreateMdatDataHandler( mdat, &dh ); if (err) goto bail; - movie->inMemoryDataHandler = dh; - } - movie->fileType = ISOMPEG21FileType; - err = MJ2CreateFileTypeAtom( &ftyp ); if (err) goto bail; - err = ftyp->setBrand( ftyp, brand, minorversion ); if (err) goto bail; - err = ftyp->calculateSize( (MP4AtomPtr) ftyp ); if (err) goto bail; - movie->ftyp = (MP4AtomPtr) ftyp; - - err = ISONewFileMeta( (MP4Movie) movie, handlertype, &meta); if (err) goto bail; - - *outMovie = (MP4Movie) movie; + MP4Err MP4CreateMediaDataAtom(MP4MediaDataAtomPtr * outAtom); + MP4Err err; + MP4PrivateMovieRecordPtr movie; + ISOFileTypeAtomPtr ftyp; + MP4MediaDataAtomPtr mdat; + ISOMeta meta; + + movie = (MP4PrivateMovieRecordPtr)calloc(1, sizeof(MP4PrivateMovieRecord)); + TESTMALLOC(movie); + movie->referenceCount = 1; + movie->prepend_handle = NULL; + + err = MP4CreateMediaDataAtom(&mdat); + movie->mdat = (MP4AtomPtr)mdat; + { + MP4DataHandlerPtr dh; + err = MP4CreateMdatDataHandler(mdat, &dh); + if(err) goto bail; + movie->inMemoryDataHandler = dh; + } + movie->fileType = ISOMPEG21FileType; + err = MJ2CreateFileTypeAtom(&ftyp); + if(err) goto bail; + err = ftyp->setBrand(ftyp, brand, minorversion); + if(err) goto bail; + err = ftyp->calculateSize((MP4AtomPtr)ftyp); + if(err) goto bail; + movie->ftyp = (MP4AtomPtr)ftyp; + + err = ISONewFileMeta((MP4Movie)movie, handlertype, &meta); + if(err) goto bail; + + *outMovie = (MP4Movie)movie; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } /* Til end of file: JLF, 11/00 : modif to support OD in the iods atom (creation and extraction) */ -MP4_EXTERN ( MP4Err ) -MP4NewMovieExt( MP4Movie *outMovie, u32 initialODID, - u8 OD_profileAndLevel, u8 scene_profileAndLevel, - u8 audio_profileAndLevel, u8 visual_profileAndLevel, - u8 graphics_profileAndLevel, - char *url, - u8 IsExchangeFile) +MP4_EXTERN(MP4Err) +MP4NewMovieExt(MP4Movie *outMovie, u32 initialODID, u8 OD_profileAndLevel, u8 scene_profileAndLevel, + u8 audio_profileAndLevel, u8 visual_profileAndLevel, u8 graphics_profileAndLevel, + char *url, u8 IsExchangeFile) { - MP4Err MP4CreateInitialObjectDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - MP4Err MP4CreateObjectDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - MP4Err MP4CreateMediaDataAtom( MP4MediaDataAtomPtr *outAtom ); - MP4Err MP4CreateMovieAtom( MP4MovieAtomPtr *outAtom ); - MP4Err MP4CreateMovieHeaderAtom( MP4MovieHeaderAtomPtr *outAtom ); - MP4Err MP4CreateObjectDescriptorAtom( MP4ObjectDescriptorAtomPtr *outAtom ); - - u64 now; - MP4Err err; - MP4PrivateMovieRecordPtr movie; - MP4MovieAtomPtr moov; - MP4MovieHeaderAtomPtr mvhd; - MP4ObjectDescriptorAtomPtr iods; - MP4MediaDataAtomPtr mdat; - MP4InitialObjectDescriptorPtr iod; - MP4ObjectDescriptorPtr od; - ISOFileTypeAtomPtr ftyp; - - movie = (MP4PrivateMovieRecordPtr) calloc( 1, sizeof(MP4PrivateMovieRecord) ); - if ( movie == NULL ) - { - err = MP4NoMemoryErr; - goto bail; - } - movie->referenceCount = 1; - movie->prepend_handle = NULL; - err = MP4GetCurrentTime( &now ); if (err) goto bail; - err = MP4CreateMovieAtom( (MP4MovieAtomPtr *) &movie->moovAtomPtr ); if (err) goto bail; - moov = (MP4MovieAtomPtr) movie->moovAtomPtr; - err = MP4CreateMovieHeaderAtom( &mvhd ); if (err) goto bail; - mvhd->nextTrackID = 1; - mvhd->creationTime = now; - mvhd->modificationTime = now; - err = moov->addAtom( moov, (MP4AtomPtr) mvhd ); if (err) goto bail; - moov->setTimeScale( moov, 600 ); - - if (initialODID != 0) { - err = MP4CreateObjectDescriptorAtom( &iods ); if (err) goto bail; - - /* here we have fun */ - if (IsExchangeFile) { - err = MP4CreateObjectDescriptor(MP4_OD_Tag, 0, 0, (MP4DescriptorPtr*)&od ); if (err) goto bail; - od->objectDescriptorID = initialODID; - if (strlen(url)) { - od->URLStringLength = strlen(url); - od->URLString = (char*) malloc(sizeof(char) * od->URLStringLength); - strcpy(od->URLString, url); - } else { - od->URLStringLength = 0; - } - err = iods->setDescriptor( (MP4AtomPtr) iods, (char*) od ); if (err) goto bail; - } else { - err = MP4CreateInitialObjectDescriptor( MP4_IOD_Tag, 0, 0, (MP4DescriptorPtr*)&iod ); if (err) goto bail; - iod->objectDescriptorID = initialODID; - iod->OD_profileAndLevel = OD_profileAndLevel; - iod->scene_profileAndLevel = scene_profileAndLevel; - iod->audio_profileAndLevel = audio_profileAndLevel; - iod->visual_profileAndLevel = visual_profileAndLevel; - iod->graphics_profileAndLevel = graphics_profileAndLevel; - if (strlen(url)) { - iod->URLStringLength = strlen(url); - iod->URLString = (char*) malloc(sizeof(char) * iod->URLStringLength); - strcpy(iod->URLString, url); - } else { - iod->URLStringLength = 0; - } - err = iods->setDescriptor( (MP4AtomPtr) iods, (char*) iod ); if (err) goto bail; - } - err = moov->addAtom( moov, (MP4AtomPtr) iods ); if (err) goto bail; - } - err = MP4CreateMediaDataAtom( &mdat ); - movie->mdat = (MP4AtomPtr) mdat; - { - MP4DataHandlerPtr dh; - err = MP4CreateMdatDataHandler( mdat, &dh ); if (err) goto bail; - movie->inMemoryDataHandler = dh; - } - movie->fileType = ISOMPEG4FileType; - - err = MJ2CreateFileTypeAtom( &ftyp ); if (err) goto bail; - err = ftyp->setBrand( ftyp, ISOMpeg4V2Brand, 0 ); if (err) goto bail; - err = ftyp->addStandard( ftyp, ISOISOBrand ); if (err) goto bail; - err = ftyp->calculateSize( (MP4AtomPtr) ftyp ); if (err) goto bail; - movie->ftyp = (MP4AtomPtr) ftyp; - - *outMovie = (MP4Movie) movie; + MP4Err MP4CreateInitialObjectDescriptor(u32 tag, u32 size, u32 bytesRead, + MP4DescriptorPtr * outDesc); + MP4Err MP4CreateObjectDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); + MP4Err MP4CreateMediaDataAtom(MP4MediaDataAtomPtr * outAtom); + MP4Err MP4CreateMovieAtom(MP4MovieAtomPtr * outAtom); + MP4Err MP4CreateMovieHeaderAtom(MP4MovieHeaderAtomPtr * outAtom); + MP4Err MP4CreateObjectDescriptorAtom(MP4ObjectDescriptorAtomPtr * outAtom); + + u64 now; + MP4Err err; + MP4PrivateMovieRecordPtr movie; + MP4MovieAtomPtr moov; + MP4MovieHeaderAtomPtr mvhd; + MP4ObjectDescriptorAtomPtr iods; + MP4MediaDataAtomPtr mdat; + MP4InitialObjectDescriptorPtr iod; + MP4ObjectDescriptorPtr od; + ISOFileTypeAtomPtr ftyp; + + movie = (MP4PrivateMovieRecordPtr)calloc(1, sizeof(MP4PrivateMovieRecord)); + if(movie == NULL) + { + err = MP4NoMemoryErr; + goto bail; + } + movie->referenceCount = 1; + movie->prepend_handle = NULL; + err = MP4GetCurrentTime(&now); + if(err) goto bail; + err = MP4CreateMovieAtom((MP4MovieAtomPtr *)&movie->moovAtomPtr); + if(err) goto bail; + moov = (MP4MovieAtomPtr)movie->moovAtomPtr; + err = MP4CreateMovieHeaderAtom(&mvhd); + if(err) goto bail; + mvhd->nextTrackID = 1; + mvhd->creationTime = now; + mvhd->modificationTime = now; + err = moov->addAtom(moov, (MP4AtomPtr)mvhd); + if(err) goto bail; + moov->setTimeScale(moov, 600); + + if(initialODID != 0) + { + err = MP4CreateObjectDescriptorAtom(&iods); + if(err) goto bail; + + /* here we have fun */ + if(IsExchangeFile) + { + err = MP4CreateObjectDescriptor(MP4_OD_Tag, 0, 0, (MP4DescriptorPtr *)&od); + if(err) goto bail; + od->objectDescriptorID = initialODID; + if(strlen(url)) + { + od->URLStringLength = strlen(url); + od->URLString = (char *)malloc(sizeof(char) * od->URLStringLength); + strcpy(od->URLString, url); + } + else + { + od->URLStringLength = 0; + } + err = iods->setDescriptor((MP4AtomPtr)iods, (char *)od); + if(err) goto bail; + } + else + { + err = MP4CreateInitialObjectDescriptor(MP4_IOD_Tag, 0, 0, (MP4DescriptorPtr *)&iod); + if(err) goto bail; + iod->objectDescriptorID = initialODID; + iod->OD_profileAndLevel = OD_profileAndLevel; + iod->scene_profileAndLevel = scene_profileAndLevel; + iod->audio_profileAndLevel = audio_profileAndLevel; + iod->visual_profileAndLevel = visual_profileAndLevel; + iod->graphics_profileAndLevel = graphics_profileAndLevel; + if(strlen(url)) + { + iod->URLStringLength = strlen(url); + iod->URLString = (char *)malloc(sizeof(char) * iod->URLStringLength); + strcpy(iod->URLString, url); + } + else + { + iod->URLStringLength = 0; + } + err = iods->setDescriptor((MP4AtomPtr)iods, (char *)iod); + if(err) goto bail; + } + err = moov->addAtom(moov, (MP4AtomPtr)iods); + if(err) goto bail; + } + err = MP4CreateMediaDataAtom(&mdat); + movie->mdat = (MP4AtomPtr)mdat; + { + MP4DataHandlerPtr dh; + err = MP4CreateMdatDataHandler(mdat, &dh); + if(err) goto bail; + movie->inMemoryDataHandler = dh; + } + movie->fileType = ISOMPEG4FileType; + + err = MJ2CreateFileTypeAtom(&ftyp); + if(err) goto bail; + err = ftyp->setBrand(ftyp, ISOMpeg4V2Brand, 0); + if(err) goto bail; + err = ftyp->addStandard(ftyp, ISOISOBrand); + if(err) goto bail; + err = ftyp->calculateSize((MP4AtomPtr)ftyp); + if(err) goto bail; + movie->ftyp = (MP4AtomPtr)ftyp; + + *outMovie = (MP4Movie)movie; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - /* jlf 11/00: Handle ObjectDescriptor in the iods atom for exchange files */ -MP4Err -MP4GetMovieObjectDescriptorUsingSLConfig( MP4Movie theMovie, MP4SLConfig slconfig, MP4Handle outDescriptorH ) +MP4Err MP4GetMovieObjectDescriptorUsingSLConfig(MP4Movie theMovie, MP4SLConfig slconfig, + MP4Handle outDescriptorH) { - MP4Err MP4CreateSLConfigDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - MP4Err MP4GetMediaESD( MP4Media theMedia, u32 index, MP4ES_DescriptorPtr *outESD, u32 *outDataReferenceIndex ); - - MP4ObjectDescriptorPtr odDesc; - MP4LinkedList incDescriptors; - GETIODATOM( theMovie ); - - if ( iodAtom->ODSize ) { - u32 count; - u32 i; - u32 trackCount; - - err = MP4GetMovieTrackCount( theMovie, &trackCount ); if (err) goto bail; - odDesc = (MP4ObjectDescriptorPtr) iodAtom->descriptor; - - /* check that there's no ES_ID_Ref */ - err = MP4GetListEntryCount( odDesc->ES_ID_RefDescriptors, &count ); if (err) goto bail; - if (count) BAILWITHERROR( MP4BadDataErr ); - - err = MP4GetListEntryCount( odDesc->ES_ID_IncDescriptors, &count ); if (err) goto bail; - - /* - get and rewrite ES_Descriptors, placing each in odDesc - */ - for ( i = 0; i < count; i++ ) - { - - MP4ES_ID_IncDescriptorPtr inc; - MP4ES_DescriptorPtr esd; - - err = MP4GetListEntry( odDesc->ES_ID_IncDescriptors, i, (char **) &inc); if (err) goto bail; - err = makeESD( theMovie, inc->trackID, 0, slconfig, (MP4DescriptorPtr *) &esd ); if (err) goto bail; - /* add esd to odDesc */ - err = odDesc->addDescriptor( (MP4DescriptorPtr) odDesc, (MP4DescriptorPtr) esd ); if (err) goto bail; - } - incDescriptors = odDesc->ES_ID_IncDescriptors; - odDesc->ES_ID_IncDescriptors = NULL; - odDesc->tag = MP4ObjectDescriptorTag; - err = odDesc->calculateSize( (MP4DescriptorPtr) odDesc ); if (err) goto bail; - err = MP4SetHandleSize( outDescriptorH, odDesc->size ); if (err) goto bail; - err = odDesc->serialize((MP4DescriptorPtr) odDesc, *outDescriptorH ); if (err) goto bail; - err = odDesc->removeESDS( (MP4DescriptorPtr) odDesc ); if (err) goto bail; - odDesc->ES_ID_IncDescriptors = incDescriptors; - odDesc->tag = MP4_OD_Tag; - } + MP4Err MP4CreateSLConfigDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); + MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr * outESD, + u32 * outDataReferenceIndex); + + MP4ObjectDescriptorPtr odDesc; + MP4LinkedList incDescriptors; + GETIODATOM(theMovie); + + if(iodAtom->ODSize) + { + u32 count; + u32 i; + u32 trackCount; + + err = MP4GetMovieTrackCount(theMovie, &trackCount); + if(err) goto bail; + odDesc = (MP4ObjectDescriptorPtr)iodAtom->descriptor; + + /* check that there's no ES_ID_Ref */ + err = MP4GetListEntryCount(odDesc->ES_ID_RefDescriptors, &count); + if(err) goto bail; + if(count) BAILWITHERROR(MP4BadDataErr); + + err = MP4GetListEntryCount(odDesc->ES_ID_IncDescriptors, &count); + if(err) goto bail; + + /* + get and rewrite ES_Descriptors, placing each in odDesc + */ + for(i = 0; i < count; i++) + { + + MP4ES_ID_IncDescriptorPtr inc; + MP4ES_DescriptorPtr esd; + + err = MP4GetListEntry(odDesc->ES_ID_IncDescriptors, i, (char **)&inc); + if(err) goto bail; + err = makeESD(theMovie, inc->trackID, 0, slconfig, (MP4DescriptorPtr *)&esd); + if(err) goto bail; + /* add esd to odDesc */ + err = odDesc->addDescriptor((MP4DescriptorPtr)odDesc, (MP4DescriptorPtr)esd); + if(err) goto bail; + } + incDescriptors = odDesc->ES_ID_IncDescriptors; + odDesc->ES_ID_IncDescriptors = NULL; + odDesc->tag = MP4ObjectDescriptorTag; + err = odDesc->calculateSize((MP4DescriptorPtr)odDesc); + if(err) goto bail; + err = MP4SetHandleSize(outDescriptorH, odDesc->size); + if(err) goto bail; + err = odDesc->serialize((MP4DescriptorPtr)odDesc, *outDescriptorH); + if(err) goto bail; + err = odDesc->removeESDS((MP4DescriptorPtr)odDesc); + if(err) goto bail; + odDesc->ES_ID_IncDescriptors = incDescriptors; + odDesc->tag = MP4_OD_Tag; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - /* JLF 11/00 : add descriptor to IOD/OD of the movie */ -MP4_EXTERN ( MP4Err ) +MP4_EXTERN(MP4Err) MP4AddDescToMovieIOD(MP4Movie theMovie, MP4Handle descriptorH) { - MP4Err MP4CreateMemoryInputStream( char *base, u32 size, MP4InputStreamPtr *outStream ); - - MP4InitialObjectDescriptorPtr iod; - MP4ObjectDescriptorPtr od; - MP4InputStreamPtr is; - MP4DescriptorPtr desc; - u32 size; - - GETIODATOM( theMovie ); - - /* parse our descriptor... */ - err = MP4GetHandleSize( descriptorH, &size ); if (err) goto bail; - err = MP4CreateMemoryInputStream(*descriptorH, size, &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseDescriptor( is, (MP4DescriptorPtr *)&desc); if (err) goto bail; - is->destroy(is); - - /* quick check for the desc type */ - switch (desc->tag) { - case MP4ForbiddenZeroDescriptorTag: - case MP4ObjectDescriptorTag: - case MP4InitialObjectDescriptorTag: - case MP4ES_DescriptorTag: - case MP4DecoderConfigDescriptorTag: - case MP4DecSpecificInfoDescriptorTag: - case MP4SLConfigDescriptorTag: - case MP4IPMP_DescriptorTag: - case MPM4QoS_DescriptorTag: - case MP4ES_ID_IncDescriptorTag: - case MP4ES_ID_RefDescriptorTag: - case MP4_IOD_Tag: - case MP4_OD_Tag: - return MP4BadParamErr; - } - - switch (iodAtom->descriptor->tag) { - case MP4_IOD_Tag: - iod = (MP4InitialObjectDescriptorPtr) iodAtom->descriptor; - err = iod->addDescriptor((MP4DescriptorPtr) iod, desc); - if (err) goto bail; - break; - - case MP4_OD_Tag: - od = (MP4ObjectDescriptorPtr) iodAtom->descriptor; - err = od->addDescriptor((MP4DescriptorPtr) od, desc); - if (err) goto bail; - break; - default: - return MP4InvalidMediaErr; - } + MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); + + MP4InitialObjectDescriptorPtr iod; + MP4ObjectDescriptorPtr od; + MP4InputStreamPtr is; + MP4DescriptorPtr desc; + u32 size; + + GETIODATOM(theMovie); + + /* parse our descriptor... */ + err = MP4GetHandleSize(descriptorH, &size); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*descriptorH, size, &is); + if(err) goto bail; + is->debugging = 0; + err = MP4ParseDescriptor(is, (MP4DescriptorPtr *)&desc); + if(err) goto bail; + is->destroy(is); + + /* quick check for the desc type */ + switch(desc->tag) + { + case MP4ForbiddenZeroDescriptorTag: + case MP4ObjectDescriptorTag: + case MP4InitialObjectDescriptorTag: + case MP4ES_DescriptorTag: + case MP4DecoderConfigDescriptorTag: + case MP4DecSpecificInfoDescriptorTag: + case MP4SLConfigDescriptorTag: + case MP4IPMP_DescriptorTag: + case MPM4QoS_DescriptorTag: + case MP4ES_ID_IncDescriptorTag: + case MP4ES_ID_RefDescriptorTag: + case MP4_IOD_Tag: + case MP4_OD_Tag: + return MP4BadParamErr; + } + + switch(iodAtom->descriptor->tag) + { + case MP4_IOD_Tag: + iod = (MP4InitialObjectDescriptorPtr)iodAtom->descriptor; + err = iod->addDescriptor((MP4DescriptorPtr)iod, desc); + if(err) goto bail; + break; + + case MP4_OD_Tag: + od = (MP4ObjectDescriptorPtr)iodAtom->descriptor; + err = od->addDescriptor((MP4DescriptorPtr)od, desc); + if(err) goto bail; + break; + default: + return MP4InvalidMediaErr; + } bail: - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4Movies.h b/IsoLib/libisomediafile/src/MP4Movies.h index c017868..d81e85b 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.h +++ b/IsoLib/libisomediafile/src/MP4Movies.h @@ -1,6 +1,6 @@ /* - This header file may be freely copied and distributed. - + This header file may be freely copied and distributed. + */ #ifndef INCLUDED_MP4MOVIE_H @@ -9,905 +9,842 @@ #include "MP4OSMacros.h" #ifdef __cplusplus -extern "C" { +extern "C" +{ #endif #define ISMACrypt -typedef int MP4Err; - -enum -{ - /* JLF 12/00 : support for OD, returned by MP4GetInline... and MP4GetProfiles... */ - MP4HasRootOD = 2, - MP4EOF = 1, - MP4NoErr = 0, - MP4FileNotFoundErr = -1, - MP4BadParamErr = -2, - MP4NoMemoryErr = -3, - MP4IOErr = -4, - MP4NoLargeAtomSupportErr = -5, - MP4BadDataErr = -6, - MP4VersionNotSupportedErr = -7, - MP4InvalidMediaErr = -8, - MP4InternalErr = -9, - MP4NotFoundErr = -10, - MP4DataEntryTypeNotSupportedErr = -100, - MP4NoQTAtomErr = -500, - MP4NotImplementedErr = -1000 -}; - - -enum -{ - MP4OpenMovieNormal = 0, - MP4OpenMovieDebug = (1 << 0), - MP4OpenMovieInPlace = (1 << 1) - -}; - -enum -{ - MP4NewTrackIsVisual = (1 << 1), - MP4NewTrackIsAudio = (1 << 2), - MP4NewTrackIsMetadata = (1 << 3), - MP4NewTrackIsPrivate = (1 << 8) -}; - -enum -{ - MP4ObjectDescriptorHandlerType = MP4_FOUR_CHAR_CODE( 'o', 'd', 's', 'm' ), - MP4ClockReferenceHandlerType = MP4_FOUR_CHAR_CODE( 'c', 'r', 's', 'm' ), - MP4SceneDescriptionHandlerType = MP4_FOUR_CHAR_CODE( 's', 'd', 's', 'm' ), - MP4VisualHandlerType = MP4_FOUR_CHAR_CODE( 'v', 'i', 'd', 'e' ), - MP4AudioHandlerType = MP4_FOUR_CHAR_CODE( 's', 'o', 'u', 'n' ), - MP4MPEG7HandlerType = MP4_FOUR_CHAR_CODE( 'm', '7', 's', 'm' ), - MP4OCIHandlerType = MP4_FOUR_CHAR_CODE( 'o', 'c', 's', 'm' ), - MP4IPMPHandlerType = MP4_FOUR_CHAR_CODE( 'i', 'p', 's', 'm' ), - MP4MPEGJHandlerType = MP4_FOUR_CHAR_CODE( 'm', 'j', 's', 'm' ), - MP4HintHandlerType = MP4_FOUR_CHAR_CODE( 'h', 'i', 'n', 't' ), - MP4TextHandlerType = MP4_FOUR_CHAR_CODE( 't', 'e', 'x', 't' ), - MP7TextHandlerType = MP4_FOUR_CHAR_CODE( 'm', 'p', '7', 't' ), - MP7BinaryHandlerType = MP4_FOUR_CHAR_CODE( 'm', 'p', '7', 'b' ), - MP21HandlerType = MP4_FOUR_CHAR_CODE( 'm', 'p', '2', '1' ), - MP4NullHandlerType = MP4_FOUR_CHAR_CODE( 'n', 'u', 'l', 'l' ), - MP4MetaHandlerType = MP4_FOUR_CHAR_CODE( 'm', 'e', 't', 'a' ), - - ISOXMLAtomType = MP4_FOUR_CHAR_CODE( 'x', 'm', 'l', ' ' ), - ISOBinaryXMLAtomType = MP4_FOUR_CHAR_CODE( 'b', 'x', 'm', 'l' ) - -}; - -enum -{ - MP4IPMP_NoControlPoint = 0x00, - MP4IPMP_DB_Decoder_ControlPoint = 0x01, - MP4IPMP_Decoder_CB_ControlPoint = 0x02, + typedef int MP4Err; + + enum + { + /* JLF 12/00 : support for OD, returned by MP4GetInline... and MP4GetProfiles... */ + MP4HasRootOD = 2, + MP4EOF = 1, + MP4NoErr = 0, + MP4FileNotFoundErr = -1, + MP4BadParamErr = -2, + MP4NoMemoryErr = -3, + MP4IOErr = -4, + MP4NoLargeAtomSupportErr = -5, + MP4BadDataErr = -6, + MP4VersionNotSupportedErr = -7, + MP4InvalidMediaErr = -8, + MP4InternalErr = -9, + MP4NotFoundErr = -10, + MP4DataEntryTypeNotSupportedErr = -100, + MP4NoQTAtomErr = -500, + MP4NotImplementedErr = -1000 + }; + + enum + { + MP4OpenMovieNormal = 0, + MP4OpenMovieDebug = (1 << 0), + MP4OpenMovieInPlace = (1 << 1) + + }; + + enum + { + MP4NewTrackIsVisual = (1 << 1), + MP4NewTrackIsAudio = (1 << 2), + MP4NewTrackIsMetadata = (1 << 3), + MP4NewTrackIsPrivate = (1 << 8) + }; + + enum + { + MP4ObjectDescriptorHandlerType = MP4_FOUR_CHAR_CODE('o', 'd', 's', 'm'), + MP4ClockReferenceHandlerType = MP4_FOUR_CHAR_CODE('c', 'r', 's', 'm'), + MP4SceneDescriptionHandlerType = MP4_FOUR_CHAR_CODE('s', 'd', 's', 'm'), + MP4VisualHandlerType = MP4_FOUR_CHAR_CODE('v', 'i', 'd', 'e'), + MP4AudioHandlerType = MP4_FOUR_CHAR_CODE('s', 'o', 'u', 'n'), + MP4MPEG7HandlerType = MP4_FOUR_CHAR_CODE('m', '7', 's', 'm'), + MP4OCIHandlerType = MP4_FOUR_CHAR_CODE('o', 'c', 's', 'm'), + MP4IPMPHandlerType = MP4_FOUR_CHAR_CODE('i', 'p', 's', 'm'), + MP4MPEGJHandlerType = MP4_FOUR_CHAR_CODE('m', 'j', 's', 'm'), + MP4HintHandlerType = MP4_FOUR_CHAR_CODE('h', 'i', 'n', 't'), + MP4TextHandlerType = MP4_FOUR_CHAR_CODE('t', 'e', 'x', 't'), + MP7TextHandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '7', 't'), + MP7BinaryHandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '7', 'b'), + MP21HandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '2', '1'), + MP4NullHandlerType = MP4_FOUR_CHAR_CODE('n', 'u', 'l', 'l'), + MP4MetaHandlerType = MP4_FOUR_CHAR_CODE('m', 'e', 't', 'a'), + + ISOXMLAtomType = MP4_FOUR_CHAR_CODE('x', 'm', 'l', ' '), + ISOBinaryXMLAtomType = MP4_FOUR_CHAR_CODE('b', 'x', 'm', 'l') + + }; + + enum + { + MP4IPMP_NoControlPoint = 0x00, + MP4IPMP_DB_Decoder_ControlPoint = 0x01, + MP4IPMP_Decoder_CB_ControlPoint = 0x02, MP4IPMP_CB_Compositor_ControlPoint = 0x03, - MP4IPMP_BIFSTree_ControlPoint = 0x04 -}; - -enum -{ - does_depend_on = 0x10, - does_not_depend_on = 0x20, - - is_depended_on = 0x4, - is_not_depended_on = 0x8, - - has_redundancy = 1, - has_no_redundancy = 2 -}; - -#define GETMOOV( arg ) \ - MP4PrivateMovieRecordPtr moov; \ - MP4Err err; \ - err = MP4NoErr; \ - if ( arg == NULL ) \ - BAILWITHERROR( MP4BadParamErr ) \ - moov = (MP4PrivateMovieRecordPtr) arg - -#define GETMOVIEATOM(arg) \ - MP4MovieAtomPtr movieAtom; \ - GETMOOV(arg); \ - movieAtom = (MP4MovieAtomPtr) moov->moovAtomPtr - -#define GETMOVIEHEADERATOM(arg) \ - MP4MovieHeaderAtomPtr movieHeaderAtom; \ - GETMOVIEATOM(arg); \ - movieHeaderAtom = (MP4MovieHeaderAtomPtr) movieAtom->mvhd - -#define GETIODATOM(arg) \ - MP4ObjectDescriptorAtomPtr iodAtom; \ - GETMOVIEATOM(arg); \ - iodAtom = (MP4ObjectDescriptorAtomPtr) movieAtom->iods; - -struct MP4MovieRecord -{ - void* data; -}; -typedef struct MP4MovieRecord MP4MovieRecord; -typedef MP4MovieRecord* MP4Movie; - -struct MP4TrackRecord -{ - void* data; -}; -typedef struct MP4TrackRecord MP4TrackRecord; -typedef MP4TrackRecord* MP4Track; - -struct MP4MediaRecord -{ - void* data; -}; -typedef struct MP4MediaRecord MP4MediaRecord; -typedef MP4MediaRecord* MP4Media; - -struct MP4TrackReaderRecord -{ - void *data; -}; -typedef struct MP4TrackReaderRecord MP4TrackReaderRecord; -typedef MP4TrackReaderRecord* MP4TrackReader; - -struct MP4UserDataRecord -{ - void *data; -}; -typedef struct MP4UserDataRecord MP4UserDataRecord; -typedef MP4UserDataRecord* MP4UserData; - -struct MP4SLConfigRecord -{ - void *data; -}; -typedef struct MP4SLConfigRecord MP4SLConfigRecord; -typedef MP4SLConfigRecord* MP4SLConfig; - -struct MP4GenericAtomRecord -{ - void *data; -}; -typedef struct MP4GenericAtomRecord MP4GenericAtomRecord; -typedef MP4GenericAtomRecord* MP4GenericAtom; + MP4IPMP_BIFSTree_ControlPoint = 0x04 + }; + + enum + { + does_depend_on = 0x10, + does_not_depend_on = 0x20, + + is_depended_on = 0x4, + is_not_depended_on = 0x8, + + has_redundancy = 1, + has_no_redundancy = 2 + }; + +#define GETMOOV(arg) \ + MP4PrivateMovieRecordPtr moov; \ + MP4Err err; \ + err = MP4NoErr; \ + if(arg == NULL) BAILWITHERROR(MP4BadParamErr) \ + moov = (MP4PrivateMovieRecordPtr)arg + +#define GETMOVIEATOM(arg) \ + MP4MovieAtomPtr movieAtom; \ + GETMOOV(arg); \ + movieAtom = (MP4MovieAtomPtr)moov->moovAtomPtr + +#define GETMOVIEHEADERATOM(arg) \ + MP4MovieHeaderAtomPtr movieHeaderAtom; \ + GETMOVIEATOM(arg); \ + movieHeaderAtom = (MP4MovieHeaderAtomPtr)movieAtom->mvhd + +#define GETIODATOM(arg) \ + MP4ObjectDescriptorAtomPtr iodAtom; \ + GETMOVIEATOM(arg); \ + iodAtom = (MP4ObjectDescriptorAtomPtr)movieAtom->iods; + + struct MP4MovieRecord + { + void *data; + }; + typedef struct MP4MovieRecord MP4MovieRecord; + typedef MP4MovieRecord *MP4Movie; + + struct MP4TrackRecord + { + void *data; + }; + typedef struct MP4TrackRecord MP4TrackRecord; + typedef MP4TrackRecord *MP4Track; + + struct MP4MediaRecord + { + void *data; + }; + typedef struct MP4MediaRecord MP4MediaRecord; + typedef MP4MediaRecord *MP4Media; + + struct MP4TrackReaderRecord + { + void *data; + }; + typedef struct MP4TrackReaderRecord MP4TrackReaderRecord; + typedef MP4TrackReaderRecord *MP4TrackReader; + + struct MP4UserDataRecord + { + void *data; + }; + typedef struct MP4UserDataRecord MP4UserDataRecord; + typedef MP4UserDataRecord *MP4UserData; + + struct MP4SLConfigRecord + { + void *data; + }; + typedef struct MP4SLConfigRecord MP4SLConfigRecord; + typedef MP4SLConfigRecord *MP4SLConfig; + + struct MP4GenericAtomRecord + { + void *data; + }; + typedef struct MP4GenericAtomRecord MP4GenericAtomRecord; + typedef MP4GenericAtomRecord *MP4GenericAtom; #ifdef PRAGMA_EXPORT #pragma export on #endif -/* MP4Handle related */ - -typedef char **MP4Handle; + /* MP4Handle related */ -MP4_EXTERN ( MP4Err ) -MP4NewHandle( u32 handleSize, MP4Handle *outHandle ); + typedef char **MP4Handle; -MP4_EXTERN ( MP4Err ) -MP4SetHandleSize( MP4Handle h, u32 handleSize ); + MP4_EXTERN(MP4Err) + MP4NewHandle(u32 handleSize, MP4Handle *outHandle); -MP4_EXTERN ( MP4Err ) -MP4DisposeHandle( MP4Handle h ); + MP4_EXTERN(MP4Err) + MP4SetHandleSize(MP4Handle h, u32 handleSize); -MP4_EXTERN ( MP4Err ) -MP4GetHandleSize( MP4Handle h, u32 *outHandleSize ); + MP4_EXTERN(MP4Err) + MP4DisposeHandle(MP4Handle h); -MP4_EXTERN ( MP4Err ) -MP4HandleCat(MP4Handle theDstHandle, MP4Handle theSrcHandle); /* FB_RESO 09/02 */ + MP4_EXTERN(MP4Err) + MP4GetHandleSize(MP4Handle h, u32 *outHandleSize); -MP4_EXTERN ( MP4Err ) -MP4SetHandleOffset( MP4Handle theHandle, u32 offset ); + MP4_EXTERN(MP4Err) + MP4HandleCat(MP4Handle theDstHandle, MP4Handle theSrcHandle); /* FB_RESO 09/02 */ -/* Movie related */ + MP4_EXTERN(MP4Err) + MP4SetHandleOffset(MP4Handle theHandle, u32 offset); -MP4_EXTERN( MP4Err ) -MP4DisposeMovie( MP4Movie theMovie ); + /* Movie related */ -MP4_EXTERN ( MP4Err ) -MP4GetMovieDuration( MP4Movie theMovie, u64* outDuration ); + MP4_EXTERN(MP4Err) + MP4DisposeMovie(MP4Movie theMovie); -MP4_EXTERN ( MP4Err ) -MP4GetMovieInitialObjectDescriptor( MP4Movie theMovie, MP4Handle outDescriptorH ); + MP4_EXTERN(MP4Err) + MP4GetMovieDuration(MP4Movie theMovie, u64 *outDuration); -MP4_EXTERN ( MP4Err ) -MP4GetMovieInitialObjectDescriptorUsingSLConfig( MP4Movie theMovie, MP4SLConfig slconfig, MP4Handle outDescriptorH ); + MP4_EXTERN(MP4Err) + MP4GetMovieInitialObjectDescriptor(MP4Movie theMovie, MP4Handle outDescriptorH); -MP4_EXTERN ( MP4Err ) -MP4GetMovieIODInlineProfileFlag( MP4Movie theMovie, u8* outFlag ); + MP4_EXTERN(MP4Err) + MP4GetMovieInitialObjectDescriptorUsingSLConfig(MP4Movie theMovie, MP4SLConfig slconfig, + MP4Handle outDescriptorH); -MP4_EXTERN ( MP4Err ) -MP4GetMovieProfilesAndLevels( MP4Movie theMovie, u8 *outOD, u8 *outScene, u8 *outAudio, u8 *outVisual, u8 *outGraphics ); + MP4_EXTERN(MP4Err) + MP4GetMovieIODInlineProfileFlag(MP4Movie theMovie, u8 *outFlag); -MP4_EXTERN ( MP4Err ) -MP4GetMovieTimeScale( MP4Movie theMovie, u32* outTimeScale ); + MP4_EXTERN(MP4Err) + MP4GetMovieProfilesAndLevels(MP4Movie theMovie, u8 *outOD, u8 *outScene, u8 *outAudio, + u8 *outVisual, u8 *outGraphics); -MP4_EXTERN ( MP4Err ) -MP4GetMovieTrack( MP4Movie theMovie, u32 trackID, MP4Track *outTrack ); + MP4_EXTERN(MP4Err) + MP4GetMovieTimeScale(MP4Movie theMovie, u32 *outTimeScale); + MP4_EXTERN(MP4Err) + MP4GetMovieTrack(MP4Movie theMovie, u32 trackID, MP4Track *outTrack); -MP4_EXTERN ( MP4Err ) -MP4GetMovieUserData( MP4Movie theMovie, MP4UserData* outUserData ); + MP4_EXTERN(MP4Err) + MP4GetMovieUserData(MP4Movie theMovie, MP4UserData *outUserData); -MP4_EXTERN ( MP4Err ) -MP4AddAtomToMovie( MP4Movie theMovie, MP4GenericAtom the_atom ); + MP4_EXTERN(MP4Err) + MP4AddAtomToMovie(MP4Movie theMovie, MP4GenericAtom the_atom); + MP4_EXTERN(MP4Err) + MP4NewMovie(MP4Movie *outMovie, u32 initialODID, u8 OD_profileAndLevel, u8 scene_profileAndLevel, + u8 audio_profileAndLevel, u8 visual_profileAndLevel, u8 graphics_profileAndLevel); -MP4_EXTERN ( MP4Err ) -MP4NewMovie( MP4Movie *outMovie, u32 initialODID, - u8 OD_profileAndLevel, u8 scene_profileAndLevel, - u8 audio_profileAndLevel, u8 visual_profileAndLevel, - u8 graphics_profileAndLevel ); + MP4_EXTERN(MP4Err) + MP4NewMovieFromHandle(MP4Movie *outMovie, MP4Handle movieH, u32 newMovieFlags); -MP4_EXTERN ( MP4Err ) -MP4NewMovieFromHandle( MP4Movie *outMovie, MP4Handle movieH, u32 newMovieFlags ); + MP4_EXTERN(MP4Err) + NewMPEG21(MP4Movie *outMovie); -MP4_EXTERN ( MP4Err ) -NewMPEG21( MP4Movie *outMovie ); + MP4_EXTERN(MP4Err) + ISONewMetaMovie(MP4Movie *outMovie, u32 handlertype, u32 brand, u32 minorversion); -MP4_EXTERN (MP4Err) -ISONewMetaMovie( MP4Movie *outMovie, u32 handlertype, u32 brand, u32 minorversion ); + /* + MP4_EXTERN ( MP4Err ) + MP4SetMovieInitialBIFSTrack( MP4Movie theMovie, MP4Track theBIFSTrack ); -/* -MP4_EXTERN ( MP4Err ) -MP4SetMovieInitialBIFSTrack( MP4Movie theMovie, MP4Track theBIFSTrack ); + MP4_EXTERN ( MP4Err ) + MP4SetMovieInitialODTrack( MP4Movie theMovie, MP4Track theODTrack ); + */ -MP4_EXTERN ( MP4Err ) -MP4SetMovieInitialODTrack( MP4Movie theMovie, MP4Track theODTrack ); -*/ + MP4_EXTERN(MP4Err) + MP4SetMovieIODInlineProfileFlag(MP4Movie theMovie, u8 theFlag); -MP4_EXTERN ( MP4Err ) -MP4SetMovieIODInlineProfileFlag( MP4Movie theMovie, u8 theFlag ); + MP4_EXTERN(MP4Err) + MP4SetMovieTimeScale(MP4Movie theMovie, u32 timeScale); -MP4_EXTERN ( MP4Err ) -MP4SetMovieTimeScale( MP4Movie theMovie, u32 timeScale ); + /* Dealing with Movie files */ + MP4_EXTERN(MP4Err) + MP4OpenMovieFile(MP4Movie *theMovie, const char *movieURL, int openMovieFlags); -/* Dealing with Movie files */ + MP4_EXTERN(MP4Err) + MP4PutMovieIntoHandle(MP4Movie theMovie, MP4Handle movieH); -MP4_EXTERN ( MP4Err ) -MP4OpenMovieFile( MP4Movie *theMovie, - const char *movieURL, - int openMovieFlags ); - -MP4_EXTERN ( MP4Err ) -MP4PutMovieIntoHandle( MP4Movie theMovie, MP4Handle movieH ); + MP4_EXTERN(MP4Err) + MP4WriteMovieToFile(MP4Movie theMovie, const char *filename); -MP4_EXTERN ( MP4Err ) -MP4WriteMovieToFile( MP4Movie theMovie, const char *filename ); + /* Track related */ + enum + { + MP4HintTrackReferenceType = MP4_FOUR_CHAR_CODE('h', 'i', 'n', 't'), + MP4StreamDependencyReferenceType = MP4_FOUR_CHAR_CODE('d', 'p', 'n', 'd'), + MP4ODTrackReferenceType = MP4_FOUR_CHAR_CODE('m', 'p', 'o', 'd'), + /* JLF 12/00: added "sync" type for OCR_ES_ID (was broken before) */ + MP4SyncTrackReferenceType = MP4_FOUR_CHAR_CODE('s', 'y', 'n', 'c'), + MP4DescTrackReferenceType = MP4_FOUR_CHAR_CODE('c', 'd', 's', 'c') + }; -/* Track related */ + MP4_EXTERN(MP4Err) + MP4AddTrackReference(MP4Track theTrack, MP4Track dependsOn, u32 referenceType, + u32 *outReferenceIndex); -enum -{ - MP4HintTrackReferenceType = MP4_FOUR_CHAR_CODE( 'h', 'i', 'n', 't' ), - MP4StreamDependencyReferenceType = MP4_FOUR_CHAR_CODE( 'd', 'p', 'n', 'd' ), - MP4ODTrackReferenceType = MP4_FOUR_CHAR_CODE( 'm', 'p', 'o', 'd' ), - /* JLF 12/00: added "sync" type for OCR_ES_ID (was broken before) */ - MP4SyncTrackReferenceType = MP4_FOUR_CHAR_CODE( 's', 'y', 'n', 'c' ), - MP4DescTrackReferenceType = MP4_FOUR_CHAR_CODE( 'c', 'd', 's', 'c' ) -}; + MP4_EXTERN(MP4Err) + MP4AddTrackReferenceWithID(MP4Track theTrack, u32 dependsOnID, u32 dependencyType, + u32 *outReferenceIndex); -MP4_EXTERN ( MP4Err ) -MP4AddTrackReference( MP4Track theTrack, MP4Track dependsOn, u32 referenceType, u32 *outReferenceIndex ); + MP4_EXTERN(MP4Err) + MP4AddTrackToMovieIOD(MP4Track theTrack); -MP4_EXTERN ( MP4Err ) -MP4AddTrackReferenceWithID( MP4Track theTrack, u32 dependsOnID, u32 dependencyType, u32 *outReferenceIndex ); + MP4_EXTERN(MP4Err) + MP4GetMovieIndTrack(MP4Movie theMovie, u32 trackIndex, MP4Track *outTrack); -MP4_EXTERN ( MP4Err ) -MP4AddTrackToMovieIOD( MP4Track theTrack ); + /* + MP4_EXTERN ( MP4Err ) + MP4GetMovieInitialBIFSTrack( MP4Movie theMovie, MP4Track *outBIFSTrack ); + */ -MP4_EXTERN ( MP4Err ) -MP4GetMovieIndTrack( MP4Movie theMovie, u32 trackIndex, MP4Track *outTrack ); + MP4_EXTERN(MP4Err) + MP4GetMovieTrackCount(MP4Movie theMovie, u32 *outTrackCount); -/* -MP4_EXTERN ( MP4Err ) -MP4GetMovieInitialBIFSTrack( MP4Movie theMovie, MP4Track *outBIFSTrack ); -*/ + MP4_EXTERN(MP4Err) + MP4GetTrackDuration(MP4Track theTrack, u64 *outDuration); -MP4_EXTERN ( MP4Err ) -MP4GetMovieTrackCount( MP4Movie theMovie, u32* outTrackCount ); + MP4_EXTERN(MP4Err) + MP4GetTrackEnabled(MP4Track theTrack, u32 *outEnabled); -MP4_EXTERN ( MP4Err ) -MP4GetTrackDuration( MP4Track theTrack, u64 *outDuration ); + MP4_EXTERN(MP4Err) + MP4GetTrackID(MP4Track theTrack, u32 *outTrackID); -MP4_EXTERN ( MP4Err ) -MP4GetTrackEnabled( MP4Track theTrack, u32 *outEnabled ); + MP4_EXTERN(MP4Err) + MP4GetTrackMedia(MP4Track theTrack, MP4Media *outMedia); -MP4_EXTERN ( MP4Err ) -MP4GetTrackID( MP4Track theTrack, u32 *outTrackID ); + MP4_EXTERN(MP4Err) + MP4GetTrackMovie(MP4Track theTrack, MP4Movie *outMovie); -MP4_EXTERN ( MP4Err ) -MP4GetTrackMedia( MP4Track theTrack, MP4Media *outMedia ); + MP4_EXTERN(MP4Err) + MP4GetTrackOffset(MP4Track track, u32 *outMovieOffsetTime); -MP4_EXTERN ( MP4Err ) -MP4GetTrackMovie( MP4Track theTrack, MP4Movie *outMovie ); + MP4_EXTERN(MP4Err) + MP4GetTrackReference(MP4Track theTrack, u32 referenceType, u32 referenceIndex, + MP4Track *outReferencedTrack); -MP4_EXTERN ( MP4Err ) -MP4GetTrackOffset( MP4Track track, u32 *outMovieOffsetTime ); + MP4_EXTERN(MP4Err) + MP4GetTrackReferenceCount(MP4Track theTrack, u32 referenceType, u32 *outReferenceCount); -MP4_EXTERN ( MP4Err ) -MP4GetTrackReference( MP4Track theTrack, u32 referenceType, u32 referenceIndex, MP4Track *outReferencedTrack ); + MP4_EXTERN(MP4Err) + MP4GetTrackUserData(MP4Track theTrack, MP4UserData *outUserData); -MP4_EXTERN ( MP4Err ) -MP4GetTrackReferenceCount( MP4Track theTrack, u32 referenceType, u32 *outReferenceCount ); + MP4_EXTERN(MP4Err) + MP4AddAtomToTrack(MP4Track theTrack, MP4GenericAtom the_atom); -MP4_EXTERN ( MP4Err ) -MP4GetTrackUserData( MP4Track theTrack, MP4UserData* outUserData ); + MP4_EXTERN(MP4Err) + MP4InsertMediaIntoTrack(MP4Track trak, s32 trackStartTime, s32 mediaStartTime, + u64 segmentDuration, s32 mediaRate); -MP4_EXTERN ( MP4Err ) -MP4AddAtomToTrack( MP4Track theTrack, MP4GenericAtom the_atom ); + MP4_EXTERN(MP4Err) + MP4NewMovieTrack(MP4Movie theMovie, u32 newTrackFlags, MP4Track *outTrack); -MP4_EXTERN ( MP4Err ) -MP4InsertMediaIntoTrack( MP4Track trak, s32 trackStartTime, s32 mediaStartTime, u64 segmentDuration, s32 mediaRate ); + MP4_EXTERN(MP4Err) + MP4NewMovieTrackWithID(MP4Movie theMovie, u32 newTrackFlags, u32 newTrackID, MP4Track *outTrack); -MP4_EXTERN ( MP4Err ) -MP4NewMovieTrack( MP4Movie theMovie, u32 newTrackFlags, MP4Track *outTrack ); + MP4_EXTERN(MP4Err) + MP4NewTrackMedia(MP4Track theTrack, MP4Media *outMedia, u32 handlerType, u32 timeScale, + MP4Handle dataReference); -MP4_EXTERN ( MP4Err ) -MP4NewMovieTrackWithID( MP4Movie theMovie, u32 newTrackFlags, u32 newTrackID, MP4Track *outTrack ); + MP4_EXTERN(MP4Err) + MP4SetTrackEnabled(MP4Track theTrack, u32 enabled); -MP4_EXTERN ( MP4Err ) -MP4NewTrackMedia( MP4Track theTrack, MP4Media *outMedia, u32 handlerType, u32 timeScale, MP4Handle dataReference ); + MP4_EXTERN(MP4Err) + MP4SetTrackOffset(MP4Track track, u32 movieOffsetTime); -MP4_EXTERN ( MP4Err ) -MP4SetTrackEnabled( MP4Track theTrack, u32 enabled ); + MP4_EXTERN(MP4Err) + MP4TrackTimeToMediaTime(MP4Track theTrack, u64 inTrackTime, s64 *outMediaTime); -MP4_EXTERN ( MP4Err ) -MP4SetTrackOffset( MP4Track track, u32 movieOffsetTime ); + /* Media related */ -MP4_EXTERN ( MP4Err ) -MP4TrackTimeToMediaTime( MP4Track theTrack, u64 inTrackTime, s64 *outMediaTime ); + MP4_EXTERN(MP4Err) + MP4AddMediaDataReference(MP4Media theMedia, u32 *outReferenceIndex, MP4Handle urlHandle, + MP4Handle urnHandle); + MP4_EXTERN(MP4Err) + MP4AddMediaSampleReference(MP4Media media, u64 dataOffset, u32 sampleCount, MP4Handle durationsH, + MP4Handle sizesH, MP4Handle sampleEntryH, MP4Handle decodingOffsetsH, + MP4Handle syncSamplesH); -/* Media related */ + MP4_EXTERN(MP4Err) + MP4AddMediaSamples(MP4Media media, MP4Handle sampleH, u32 sampleCount, MP4Handle durationsH, + MP4Handle sizesH, MP4Handle sampleEntryH, MP4Handle decodingOffsetsH, + MP4Handle syncSamplesH); -MP4_EXTERN ( MP4Err ) -MP4AddMediaDataReference( MP4Media theMedia, u32 *outReferenceIndex, MP4Handle urlHandle, MP4Handle urnHandle ); + MP4_EXTERN(MP4Err) + MP4AddMediaSampleReferencePad(MP4Media media, u64 dataOffset, u32 sampleCount, + MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, + MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, + MP4Handle padsH); -MP4_EXTERN ( MP4Err ) -MP4AddMediaSampleReference( MP4Media media, u64 dataOffset, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH ); + MP4_EXTERN(MP4Err) + MP4AddMediaSamplesPad(MP4Media media, MP4Handle sampleH, u32 sampleCount, MP4Handle durationsH, + MP4Handle sizesH, MP4Handle sampleEntryH, MP4Handle decodingOffsetsH, + MP4Handle syncSamplesH, MP4Handle padsH); -MP4_EXTERN ( MP4Err ) -MP4AddMediaSamples( MP4Media media, MP4Handle sampleH, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH ); + MP4_EXTERN(MP4Err) + ISOAddGroupDescription(MP4Media media, u32 groupType, MP4Handle description, u32 *index); -MP4_EXTERN ( MP4Err ) -MP4AddMediaSampleReferencePad( MP4Media media, u64 dataOffset, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ); + MP4_EXTERN(MP4Err) + ISOGetGroupDescription(MP4Media media, u32 groupType, u32 index, MP4Handle description); -MP4_EXTERN ( MP4Err ) -MP4AddMediaSamplesPad( MP4Media media, MP4Handle sampleH, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ); + MP4_EXTERN(MP4Err) + ISOSetSamplestoGroupType(MP4Media media, u32 enableCompactSamples); -MP4_EXTERN( MP4Err ) -ISOAddGroupDescription( MP4Media media, u32 groupType, MP4Handle description, u32* index ); + MP4_EXTERN(MP4Err) + ISOMapSamplestoGroup(MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count); -MP4_EXTERN( MP4Err ) -ISOGetGroupDescription( MP4Media media, u32 groupType, u32 index, MP4Handle description ); + MP4_EXTERN(MP4Err) + ISOGetSampletoGroupMap(MP4Media media, u32 groupType, u32 sample_number, u32 *group_index); -MP4_EXTERN( MP4Err ) -ISOSetSamplestoGroupType( MP4Media media, u32 enableCompactSamples ); + MP4_EXTERN(MP4Err) + ISOSetSampleDependency(MP4Media media, s32 sample_index, MP4Handle dependencies); -MP4_EXTERN( MP4Err ) -ISOMapSamplestoGroup( MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count ); + MP4_EXTERN(MP4Err) + ISOGetSampleDependency(MP4Media media, s32 sample_index, u8 *dependency); -MP4_EXTERN( MP4Err ) -ISOGetSampletoGroupMap( MP4Media media, u32 groupType, u32 sample_number, u32* group_index ); + MP4_EXTERN(MP4Err) + MP4BeginMediaEdits(MP4Media theMedia); -MP4_EXTERN( MP4Err ) -ISOSetSampleDependency( MP4Media media, s32 sample_index, MP4Handle dependencies ); + MP4_EXTERN(MP4Err) + MP4CheckMediaDataReferences(MP4Media theMedia); + + MP4_EXTERN(MP4Err) + MP4EndMediaEdits(MP4Media theMedia); + + MP4_EXTERN(MP4Err) + MP4GetIndMediaSampleWithPad(MP4Media theMedia, u32 sampleNumber, MP4Handle outSample, + u32 *outSize, u64 *outDTS, s32 *outCTSOffset, u64 *outDuration, + u32 *outSampleFlags, u32 *outSampleDescIndex, u8 *outPad); + + MP4_EXTERN(MP4Err) + MP4GetIndMediaSample(MP4Media theMedia, u32 sampleNumber, MP4Handle outSample, u32 *outSize, + u64 *outDTS, s32 *outCTSOffset, u64 *outDuration, u32 *outSampleFlags, + u32 *outSampleDescIndex); + + MP4_EXTERN(MP4Err) + MP4GetIndMediaSampleReference(MP4Media theMedia, u32 sampleNumber, u32 *outOffset, u32 *outSize, + u32 *outDuration, u32 *outSampleFlags, u32 *outSampleDescIndex, + MP4Handle sampleDesc); + + MP4_EXTERN(MP4Err) + MP4GetMediaDataRefCount(MP4Media theMedia, u32 *outCount); + + MP4_EXTERN(MP4Err) + MP4UseSignedCompositionTimeOffsets(MP4Media media); + + /* data reference attributes */ + enum + { + MP4DataRefSelfReferenceMask = (1 << 0) + }; + + enum + { + MP4URLDataReferenceType = MP4_FOUR_CHAR_CODE('u', 'r', 'l', ' '), + MP4URNDataReferenceType = MP4_FOUR_CHAR_CODE('u', 'r', 'n', ' ') + }; + + MP4_EXTERN(MP4Err) + MP4GetMediaDataReference(MP4Media theMedia, u32 index, MP4Handle referenceURL, + MP4Handle referenceURN, u32 *outReferenceType, + u32 *outReferenceAttributes); + + MP4_EXTERN(MP4Err) + MP4GetMediaDuration(MP4Media theMedia, u64 *outDuration); + + MP4_EXTERN(MP4Err) + MP4GetMediaHandlerDescription(MP4Media theMedia, u32 *outType, MP4Handle *outName); + + MP4_EXTERN(MP4Err) + MP4GetMediaLanguage(MP4Media theMedia, char *outThreeCharCode); + + MP4_EXTERN(MP4Err) + MP4GetMediaExtendedLanguageTag(MP4Media theMedia, char **extended_language); + + /* flags for NextInterestingTime */ + enum + { + MP4NextTimeSearchForward = 0, + MP4NextTimeSearchBackward = -1, + MP4NextTimeMediaSample = (1 << 0), + MP4NextTimeMediaEdit = (1 << 1), + MP4NextTimeTrackEdit = (1 << 2), + MP4NextTimeSyncSample = (1 << 3), + MP4NextTimeEdgeOK = (1 << 4) + }; + + /* NB: This ignores any edit list present in the Media's Track */ + MP4_EXTERN(MP4Err) + MP4GetMediaNextInterestingTime(MP4Media theMedia, + u32 interestingTimeFlags, /* eg: MP4NextTimeMediaSample */ + u64 searchFromTime, /* in Media time scale */ + u32 searchDirection, /* eg: MP4NextTimeSearchForward */ + u64 *outInterestingTime, /* in Media time scale */ + u64 *outInterestingDuration /* in Media's time coordinate system */ + ); + + /* flags for GetMediaSample */ + enum + { + MP4MediaSampleNotSync = (1 << 0), + MP4MediaSampleHasCTSOffset = (1 << 1) + }; + + MP4_EXTERN(MP4Err) + MP4GetMediaSample(MP4Media theMedia, MP4Handle outSample, u32 *outSize, u64 desiredDecodingTime, + u64 *outDecodingTime, u64 *outCompositionTime, u64 *outDuration, + MP4Handle outSampleDescription, u32 *outSampleDescriptionIndex, + u32 *outSampleFlags); + + MP4_EXTERN(MP4Err) + MP4GetMediaSampleWithPad(MP4Media theMedia, MP4Handle outSample, u32 *outSize, + u64 desiredDecodingTime, u64 *outDecodingTime, u64 *outCompositionTime, + u64 *outDuration, MP4Handle outSampleDescription, + u32 *outSampleDescriptionIndex, u32 *outSampleFlags, u8 *outPad); + + MP4_EXTERN(MP4Err) + MP4GetMediaSampleCount(MP4Media theMedia, u32 *outCount); + + MP4_EXTERN(MP4Err) + MP4GetMediaSampleDescription(MP4Media theMedia, u32 index, MP4Handle outDescriptionH, + u32 *outDataReferenceIndex); + + MP4_EXTERN(MP4Err) + MP4GetMediaTimeScale(MP4Media theMedia, u32 *outTimeScale); + + MP4_EXTERN(MP4Err) + MP4GetMediaTrack(MP4Media theMedia, MP4Track *outTrack); + + MP4_EXTERN(MP4Err) + MP4MediaTimeToSampleNum(MP4Media theMedia, u64 mediaTime, u32 *outSampleNum, u64 *outSampleCTS, + u64 *outSampleDTS, s32 *outSampleDuration); + + MP4_EXTERN(MP4Err) + MP4SampleNumToMediaTime(MP4Media theMedia, u32 sampleNum, u64 *outSampleCTS, u64 *outSampleDTS, + s32 *outSampleDuration); + + MP4_EXTERN(MP4Err) + MP4SetMediaLanguage(MP4Media theMedia, char *threeCharCode); + + MP4_EXTERN(MP4Err) + MP4SetMediaExtendedLanguageTag(MP4Media theMedia, char *extended_language); + + MP4_EXTERN(MP4Err) + ISOSetSampleSizeField(MP4Media theMedia, u32 fieldsize); + + /* Sync Layer media access routines */ + + MP4_EXTERN(MP4Err) + MP4GetElementaryStreamPacket(MP4Media theMedia, MP4Handle outSample, u32 *outSize, + u32 sequenceNumber, u64 desiredTime, u64 *outActualTime, + u64 *outDuration); + + MP4_EXTERN(MP4Err) + MP4GetMediaDecoderConfig(MP4Media theMedia, u32 sampleDescIndex, MP4Handle decoderConfigH); + + MP4_EXTERN(MP4Err) + MP4GetMediaDecoderInformation(MP4Media theMedia, u32 sampleDescIndex, u32 *outObjectType, + u32 *outStreamType, u32 *outBufferSize, u32 *outUpstream, + u32 *outMaxBitrate, u32 *outAvgBitrate, MP4Handle specificInfoH); + + MP4_EXTERN(MP4Err) + MP4GetMediaDecoderType(MP4Media theMedia, u32 sampleDescIndex, u32 *outObjectType, + u32 *outStreamType, u32 *outBufferSize, MP4Handle specificInfoH); + + MP4_EXTERN(MP4Err) + MP4NewSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, + u32 objectTypeIndication, u32 streamType, u32 decoderBufferSize, + u32 maxBitrate, u32 avgBitrate, MP4Handle decoderSpecificInfoH); + + MP4_EXTERN(MP4Err) + ISONewGeneralSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 sampleEntryType, + MP4GenericAtom extensionAtom); + + MP4_EXTERN(MP4Err) + MP4NewSampleDescriptionWithOCRAssociation(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 objectTypeIndication, + u32 streamType, u32 decoderBufferSize, u32 maxBitrate, + u32 avgBitrate, MP4Handle decoderSpecificInfoH, + u32 theOCRESID); + + MP4_EXTERN(MP4Err) + ISOAddAtomToSampleDescription(MP4Handle sampleEntryH, MP4GenericAtom extensionAtom); + + MP4_EXTERN(MP4Err) + ISOGetAtomFromSampleDescription(MP4Handle sampleEntryH, u32 atomType, MP4GenericAtom *outAtom); + + MP4_EXTERN(MP4Err) + ISONewXMLMetaDataSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, char *content_encoding, + char *xml_namespace, char *schema_location); -MP4_EXTERN( MP4Err ) -ISOGetSampleDependency( MP4Media media, s32 sample_index, u8* dependency ); + MP4_EXTERN(MP4Err) + ISONewTextMetaDataSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, char *content_encoding, + char *mime_format); -MP4_EXTERN ( MP4Err ) -MP4BeginMediaEdits( MP4Media theMedia ); + /* TrackReader stuff */ -MP4_EXTERN ( MP4Err ) -MP4CheckMediaDataReferences( MP4Media theMedia ); + MP4_EXTERN(MP4Err) + MP4CreateTrackReader(MP4Track theTrack, MP4TrackReader *outReader); -MP4_EXTERN ( MP4Err ) -MP4EndMediaEdits( MP4Media theMedia ); + MP4_EXTERN(MP4Err) + MP4DisposeTrackReader(MP4TrackReader theReader); -MP4_EXTERN ( MP4Err ) -MP4GetIndMediaSampleWithPad( MP4Media theMedia, - u32 sampleNumber, - MP4Handle outSample, - u32 *outSize, - u64 *outDTS, - s32 *outCTSOffset, - u64 *outDuration, - u32 *outSampleFlags, - u32 *outSampleDescIndex, - u8 *outPad - ); - -MP4_EXTERN ( MP4Err ) -MP4GetIndMediaSample( MP4Media theMedia, - u32 sampleNumber, - MP4Handle outSample, - u32 *outSize, - u64 *outDTS, - s32 *outCTSOffset, - u64 *outDuration, - u32 *outSampleFlags, - u32 *outSampleDescIndex - ); - -MP4_EXTERN ( MP4Err ) -MP4GetIndMediaSampleReference( MP4Media theMedia, - u32 sampleNumber, - u32 *outOffset, - u32 *outSize, - u32 *outDuration, - u32 *outSampleFlags, - u32 *outSampleDescIndex, - MP4Handle sampleDesc - ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaDataRefCount( MP4Media theMedia, u32 *outCount ); - -MP4_EXTERN ( MP4Err ) -MP4UseSignedCompositionTimeOffsets ( MP4Media media ); - -/* data reference attributes */ -enum -{ - MP4DataRefSelfReferenceMask = (1<<0) -}; + MP4_EXTERN(MP4Err) + MP4TrackReaderGetCurrentDecoderConfig(MP4TrackReader theReader, MP4Handle decoderConfigH); -enum -{ - MP4URLDataReferenceType = MP4_FOUR_CHAR_CODE( 'u', 'r', 'l', ' ' ), - MP4URNDataReferenceType = MP4_FOUR_CHAR_CODE( 'u', 'r', 'n', ' ' ) -}; - -MP4_EXTERN ( MP4Err ) -MP4GetMediaDataReference( MP4Media theMedia, - u32 index, - MP4Handle referenceURL, - MP4Handle referenceURN, - u32 *outReferenceType, - u32 *outReferenceAttributes ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaDuration( MP4Media theMedia, u64 *outDuration ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaHandlerDescription( MP4Media theMedia, u32 *outType, MP4Handle *outName ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaLanguage( MP4Media theMedia, char *outThreeCharCode ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaExtendedLanguageTag( MP4Media theMedia, char **extended_language ); - -/* flags for NextInterestingTime */ -enum -{ - MP4NextTimeSearchForward = 0, - MP4NextTimeSearchBackward = -1, - MP4NextTimeMediaSample = (1 << 0), - MP4NextTimeMediaEdit = (1 << 1), - MP4NextTimeTrackEdit = (1 << 2), - MP4NextTimeSyncSample = (1 << 3), - MP4NextTimeEdgeOK = (1 << 4) -}; - -/* NB: This ignores any edit list present in the Media's Track */ -MP4_EXTERN ( MP4Err ) -MP4GetMediaNextInterestingTime( MP4Media theMedia, - u32 interestingTimeFlags, /* eg: MP4NextTimeMediaSample */ - u64 searchFromTime, /* in Media time scale */ - u32 searchDirection, /* eg: MP4NextTimeSearchForward */ - u64 *outInterestingTime, /* in Media time scale */ - u64 *outInterestingDuration /* in Media's time coordinate system */ - ); - -/* flags for GetMediaSample */ -enum -{ - MP4MediaSampleNotSync = (1 << 0), - MP4MediaSampleHasCTSOffset = (1 << 1) -}; - -MP4_EXTERN ( MP4Err ) -MP4GetMediaSample( MP4Media theMedia, MP4Handle outSample, u32 *outSize, - u64 desiredDecodingTime, u64 *outDecodingTime, u64 *outCompositionTime, u64 *outDuration, - MP4Handle outSampleDescription, u32 *outSampleDescriptionIndex, - u32 *outSampleFlags ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaSampleWithPad( MP4Media theMedia, MP4Handle outSample, u32 *outSize, - u64 desiredDecodingTime, u64 *outDecodingTime, u64 *outCompositionTime, u64 *outDuration, - MP4Handle outSampleDescription, u32 *outSampleDescriptionIndex, - u32 *outSampleFlags, u8* outPad ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaSampleCount( MP4Media theMedia, u32 *outCount ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaSampleDescription( MP4Media theMedia, u32 index, MP4Handle outDescriptionH, u32 *outDataReferenceIndex ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaTimeScale( MP4Media theMedia, u32 *outTimeScale ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaTrack( MP4Media theMedia, MP4Track *outTrack ); - -MP4_EXTERN ( MP4Err ) -MP4MediaTimeToSampleNum( MP4Media theMedia, u64 mediaTime, u32 *outSampleNum, u64 *outSampleCTS, u64 *outSampleDTS, s32 *outSampleDuration ); - -MP4_EXTERN ( MP4Err ) -MP4SampleNumToMediaTime( MP4Media theMedia, u32 sampleNum, u64 *outSampleCTS, u64 *outSampleDTS, s32 *outSampleDuration ); - -MP4_EXTERN ( MP4Err ) -MP4SetMediaLanguage( MP4Media theMedia, char *threeCharCode ); - -MP4_EXTERN ( MP4Err ) -MP4SetMediaExtendedLanguageTag( MP4Media theMedia, char *extended_language ); - -MP4_EXTERN ( MP4Err ) -ISOSetSampleSizeField ( MP4Media theMedia, u32 fieldsize ); - -/* Sync Layer media access routines */ - -MP4_EXTERN ( MP4Err ) -MP4GetElementaryStreamPacket( MP4Media theMedia, MP4Handle outSample, u32 *outSize, - u32 sequenceNumber, u64 desiredTime, u64 *outActualTime, u64 *outDuration ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaDecoderConfig( MP4Media theMedia, u32 sampleDescIndex, MP4Handle decoderConfigH ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaDecoderInformation( MP4Media theMedia, - u32 sampleDescIndex, - u32 *outObjectType, - u32 *outStreamType, - u32 *outBufferSize, - u32 *outUpstream, - u32 *outMaxBitrate, - u32 *outAvgBitrate, - MP4Handle specificInfoH ); - -MP4_EXTERN ( MP4Err ) -MP4GetMediaDecoderType( MP4Media theMedia, - u32 sampleDescIndex, - u32 *outObjectType, - u32 *outStreamType, - u32 *outBufferSize, - MP4Handle specificInfoH ); - -MP4_EXTERN ( MP4Err ) -MP4NewSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 objectTypeIndication, - u32 streamType, - u32 decoderBufferSize, - u32 maxBitrate, - u32 avgBitrate, - MP4Handle decoderSpecificInfoH ); - -MP4_EXTERN ( MP4Err ) ISONewGeneralSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 sampleEntryType, - MP4GenericAtom extensionAtom ); - -MP4_EXTERN ( MP4Err ) -MP4NewSampleDescriptionWithOCRAssociation( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - u32 objectTypeIndication, - u32 streamType, - u32 decoderBufferSize, - u32 maxBitrate, - u32 avgBitrate, - MP4Handle decoderSpecificInfoH, - u32 theOCRESID ); - -MP4_EXTERN ( MP4Err ) ISOAddAtomToSampleDescription(MP4Handle sampleEntryH, MP4GenericAtom extensionAtom); - -MP4_EXTERN ( MP4Err ) ISOGetAtomFromSampleDescription(MP4Handle sampleEntryH, u32 atomType, MP4GenericAtom* outAtom); - -MP4_EXTERN ( MP4Err ) ISONewXMLMetaDataSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - char* content_encoding, - char* xml_namespace, - char* schema_location ); - -MP4_EXTERN ( MP4Err ) ISONewTextMetaDataSampleDescription( MP4Track theTrack, - MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, - char* content_encoding, - char* mime_format ); - -/* TrackReader stuff */ - -MP4_EXTERN ( MP4Err ) -MP4CreateTrackReader( MP4Track theTrack, MP4TrackReader *outReader ); - -MP4_EXTERN ( MP4Err ) -MP4DisposeTrackReader( MP4TrackReader theReader ); - -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetCurrentDecoderConfig( MP4TrackReader theReader, MP4Handle decoderConfigH ); - -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetCurrentSampleDescription( MP4TrackReader theReader, MP4Handle sampleEntryH ); -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetCurrentSampleDescriptionIndex( MP4TrackReader theReader, u32 *index ); - -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetNextAccessUnit( MP4TrackReader theReader, MP4Handle outAccessUnit, u32 *outSize, u32 *outSampleFlags, - s32 *outCTS, s32 *outDTS ); - -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetNextAccessUnitWithDuration( MP4TrackReader theReader, - MP4Handle outAccessUnit, - u32 *outSize, u32 *outSampleFlags, - s32 *outCTS, s32 *outDTS, - u32 *outDuration ); - -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetNextAccessUnitWithPad( MP4TrackReader theReader, - MP4Handle outAccessUnit, - u32 *outSize, u32 *outSampleFlags, - s32 *outCTS, s32 *outDTS, - u8 *outPad ); -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetNextPacket( MP4TrackReader theReader, MP4Handle outPacket, u32 *outSize ); - -MP4_EXTERN ( MP4Err ) -MP4TrackReaderSetSLConfig( MP4TrackReader theReader, MP4SLConfig slConfig ); - -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetCurrentSampleNumber( MP4TrackReader theReader, u32 *sampleNumber ); - - - -/* Sample Auxiliary Information */ - -MP4_EXTERN ( MP4Err ) -MP4SetupSampleAuxiliaryInformation( MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, - u8 default_sample_info_size ); -MP4_EXTERN ( MP4Err ) -MP4AddSampleAuxiliaryInformation( MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, - MP4Handle dataH, u32 sampleCount, MP4Handle sizesH ); - -MP4_EXTERN ( MP4Err ) -MP4GetSampleAuxiliaryInformation( MP4Media theMedia, u32 *outCount, MP4Handle isUsingAuxInfoPropertiesFlags, - MP4Handle aux_info_types, MP4Handle aux_info_type_parameters ); - -MP4_EXTERN ( MP4Err ) -MP4GetSampleAuxiliaryInformationForSample( MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, - u32 sampleNr, MP4Handle outDataH, u32 *outSize ); - -/* User Data */ - -MP4_EXTERN ( MP4Err ) -MP4AddUserData( MP4UserData theUserData, MP4Handle dataH, u32 userDataType, u32 *outIndex ); - -MP4_EXTERN ( MP4Err ) -MP4GetIndUserDataType( MP4UserData theUserData, u32 typeIndex, u32 *outType ); - -MP4_EXTERN ( MP4Err ) -MP4GetUserDataEntryCount( MP4UserData theUserData, u32 userDataType, u32 *outCount ); - -MP4_EXTERN ( MP4Err ) -MP4GetUserDataItem( MP4UserData theUserData, MP4Handle dataH, u32 userDataType, u32 itemIndex ); - -MP4_EXTERN ( MP4Err ) -MP4GetAtomFromUserData( MP4UserData theUserData, MP4GenericAtom *outAtom, u32 userDataType, u32 itemIndex ); - -MP4_EXTERN ( MP4Err ) -MP4GetUserDataTypeCount( MP4UserData theUserData, u32 *outCount ); - -MP4_EXTERN ( MP4Err ) -MP4DeleteUserDataItem( MP4UserData theUserData, u32 userDataType, u32 itemIndex ); - -MP4_EXTERN ( MP4Err ) -MP4NewUserData( MP4UserData *outUserData ); - -MP4_EXTERN ( MP4Err ) -MP4NewForeignAtom( MP4GenericAtom *outAtom, u32 atomType, MP4Handle atomPayload ); - -MP4_EXTERN ( MP4Err ) -MP4NewUUIDAtom( MP4GenericAtom *outAtom, u8 the_uuid[16], MP4Handle atomPayload ); - -MP4_EXTERN ( MP4Err ) -MP4GetForeignAtom( MP4GenericAtom atom, u32* atomType, u8 the_uuid[16], MP4Handle atomPayload ); - -/* SLConfig */ - -typedef struct MP4SLConfigSettingsRecord -{ - u32 predefined; - u32 useAccessUnitStartFlag; - u32 useAccessUnitEndFlag; - u32 useRandomAccessPointFlag; - u32 useRandomAccessUnitsOnlyFlag; - u32 usePaddingFlag; - u32 useTimestampsFlag; - u32 useIdleFlag; - u32 durationFlag; - u32 timestampResolution; - u32 OCRResolution; - u32 timestampLength; - u32 OCRLength; - u32 AULength; - u32 instantBitrateLength; - u32 degradationPriorityLength; - u32 AUSeqNumLength; - u32 packetSeqNumLength; - u32 timeScale; - u32 AUDuration; - u32 CUDuration; - u64 startDTS; - u64 startCTS; - u32 OCRESID; -} MP4SLConfigSettings, *MP4SLConfigSettingsPtr; - -MP4_EXTERN ( MP4Err ) -MP4NewSLConfig( MP4SLConfigSettingsPtr settings, MP4SLConfig *outSLConfig ); - -MP4_EXTERN ( MP4Err ) -MP4GetSLConfigSettings( MP4SLConfig config, MP4SLConfigSettingsPtr outSettings ); - -MP4_EXTERN ( MP4Err ) -MP4SetSLConfigSettings( MP4SLConfig config, MP4SLConfigSettingsPtr settings ); + MP4_EXTERN(MP4Err) + MP4TrackReaderGetCurrentSampleDescription(MP4TrackReader theReader, MP4Handle sampleEntryH); + MP4_EXTERN(MP4Err) + MP4TrackReaderGetCurrentSampleDescriptionIndex(MP4TrackReader theReader, u32 *index); + + MP4_EXTERN(MP4Err) + MP4TrackReaderGetNextAccessUnit(MP4TrackReader theReader, MP4Handle outAccessUnit, u32 *outSize, + u32 *outSampleFlags, s32 *outCTS, s32 *outDTS); + + MP4_EXTERN(MP4Err) + MP4TrackReaderGetNextAccessUnitWithDuration(MP4TrackReader theReader, MP4Handle outAccessUnit, + u32 *outSize, u32 *outSampleFlags, s32 *outCTS, + s32 *outDTS, u32 *outDuration); + + MP4_EXTERN(MP4Err) + MP4TrackReaderGetNextAccessUnitWithPad(MP4TrackReader theReader, MP4Handle outAccessUnit, + u32 *outSize, u32 *outSampleFlags, s32 *outCTS, + s32 *outDTS, u8 *outPad); + MP4_EXTERN(MP4Err) + MP4TrackReaderGetNextPacket(MP4TrackReader theReader, MP4Handle outPacket, u32 *outSize); + + MP4_EXTERN(MP4Err) + MP4TrackReaderSetSLConfig(MP4TrackReader theReader, MP4SLConfig slConfig); + + MP4_EXTERN(MP4Err) + MP4TrackReaderGetCurrentSampleNumber(MP4TrackReader theReader, u32 *sampleNumber); + + /* Sample Auxiliary Information */ + + MP4_EXTERN(MP4Err) + MP4SetupSampleAuxiliaryInformation(MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, + u32 aux_info_type, u32 aux_info_type_parameter, + u8 default_sample_info_size); + MP4_EXTERN(MP4Err) + MP4AddSampleAuxiliaryInformation(MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, + u32 aux_info_type, u32 aux_info_type_parameter, MP4Handle dataH, + u32 sampleCount, MP4Handle sizesH); + + MP4_EXTERN(MP4Err) + MP4GetSampleAuxiliaryInformation(MP4Media theMedia, u32 *outCount, + MP4Handle isUsingAuxInfoPropertiesFlags, + MP4Handle aux_info_types, MP4Handle aux_info_type_parameters); + + MP4_EXTERN(MP4Err) + MP4GetSampleAuxiliaryInformationForSample(MP4Media theMedia, u8 isUsingAuxInfoPropertiesFlag, + u32 aux_info_type, u32 aux_info_type_parameter, + u32 sampleNr, MP4Handle outDataH, u32 *outSize); + + /* User Data */ + + MP4_EXTERN(MP4Err) + MP4AddUserData(MP4UserData theUserData, MP4Handle dataH, u32 userDataType, u32 *outIndex); + + MP4_EXTERN(MP4Err) + MP4GetIndUserDataType(MP4UserData theUserData, u32 typeIndex, u32 *outType); + + MP4_EXTERN(MP4Err) + MP4GetUserDataEntryCount(MP4UserData theUserData, u32 userDataType, u32 *outCount); + + MP4_EXTERN(MP4Err) + MP4GetUserDataItem(MP4UserData theUserData, MP4Handle dataH, u32 userDataType, u32 itemIndex); + + MP4_EXTERN(MP4Err) + MP4GetAtomFromUserData(MP4UserData theUserData, MP4GenericAtom *outAtom, u32 userDataType, + u32 itemIndex); + + MP4_EXTERN(MP4Err) + MP4GetUserDataTypeCount(MP4UserData theUserData, u32 *outCount); + + MP4_EXTERN(MP4Err) + MP4DeleteUserDataItem(MP4UserData theUserData, u32 userDataType, u32 itemIndex); + + MP4_EXTERN(MP4Err) + MP4NewUserData(MP4UserData *outUserData); + + MP4_EXTERN(MP4Err) + MP4NewForeignAtom(MP4GenericAtom *outAtom, u32 atomType, MP4Handle atomPayload); + + MP4_EXTERN(MP4Err) + MP4NewUUIDAtom(MP4GenericAtom *outAtom, u8 the_uuid[16], MP4Handle atomPayload); + + MP4_EXTERN(MP4Err) + MP4GetForeignAtom(MP4GenericAtom atom, u32 *atomType, u8 the_uuid[16], MP4Handle atomPayload); + + /* SLConfig */ + + typedef struct MP4SLConfigSettingsRecord + { + u32 predefined; + u32 useAccessUnitStartFlag; + u32 useAccessUnitEndFlag; + u32 useRandomAccessPointFlag; + u32 useRandomAccessUnitsOnlyFlag; + u32 usePaddingFlag; + u32 useTimestampsFlag; + u32 useIdleFlag; + u32 durationFlag; + u32 timestampResolution; + u32 OCRResolution; + u32 timestampLength; + u32 OCRLength; + u32 AULength; + u32 instantBitrateLength; + u32 degradationPriorityLength; + u32 AUSeqNumLength; + u32 packetSeqNumLength; + u32 timeScale; + u32 AUDuration; + u32 CUDuration; + u64 startDTS; + u64 startCTS; + u32 OCRESID; + } MP4SLConfigSettings, *MP4SLConfigSettingsPtr; + + MP4_EXTERN(MP4Err) + MP4NewSLConfig(MP4SLConfigSettingsPtr settings, MP4SLConfig *outSLConfig); + + MP4_EXTERN(MP4Err) + MP4GetSLConfigSettings(MP4SLConfig config, MP4SLConfigSettingsPtr outSettings); + + MP4_EXTERN(MP4Err) + MP4SetSLConfigSettings(MP4SLConfig config, MP4SLConfigSettingsPtr settings); #ifndef INCLUDED_ISOMOVIE_H #include "ISOMovies.h" #endif - -/* JLF 12/00: added support for URL and for exchange files */ -MP4_EXTERN ( MP4Err ) -MP4NewMovieExt( MP4Movie *outMovie, u32 initialODID, - u8 OD_profileAndLevel, u8 scene_profileAndLevel, - u8 audio_profileAndLevel, u8 visual_profileAndLevel, - u8 graphics_profileAndLevel, - char *url, - u8 IsExchangeFile); - - - -/* JLF 12/00: added support for stream priority */ -MP4_EXTERN ( MP4Err ) -MP4SetSampleDescriptionPriority(MP4Handle sampleEntryH, u32 priority); - -/* JLF 12/00: added support for descriptors in the ESD */ -MP4_EXTERN ( MP4Err ) -MP4AddDescToSampleDescription(MP4Handle sampleEntryH, MP4Handle descriptorH); - -/* JLF 12/00: added support for descriptors in the OD/IOD */ -MP4_EXTERN ( MP4Err ) -MP4AddDescToMovieIOD(MP4Movie theMovie, MP4Handle descriptorH); - -/* JLF 12/00: checking of a specific data entry. */ -MP4_EXTERN ( MP4Err ) -MP4CheckMediaDataRef( MP4Media theMedia, u32 dataEntryIndex); - - -MP4_EXTERN ( MP4Err ) -ISOSetSampleDescriptionDimensions(MP4Handle sampleEntryH, u16 width, u16 height); -MP4_EXTERN ( MP4Err ) -ISOSetSampleDescriptionType(MP4Handle sampleEntryH, u32 type); - -MP4_EXTERN ( MP4Err ) -ISOGetSampleDescriptionDimensions(MP4Handle sampleEntryH, u16 *width, u16 *height); -MP4_EXTERN ( MP4Err ) -ISOGetSampleDescriptionType(MP4Handle sampleEntryH, u32 *type); - -MP4_EXTERN ( MP4Err ) -ISOStartMovieFragment( MP4Movie theMovie ); -MP4_EXTERN ( MP4Err ) -ISOAddDelayToTrackFragmentDecodeTime( MP4Movie theMovie, u32 delay ); -MP4_EXTERN ( MP4Err ) -ISOSetTrackFragmentDefaults( MP4Track theTrack, u32 duration, u32 size, u32 is_sync, u8 pad ); -MP4_EXTERN ( MP4Err ) -ISOSetCompositonToDecodePropertiesForFragments( MP4Movie theMovie, u32 trackID, s32 compositionToDTSShift, - s32 leastDecodeToDisplayDelta, s32 greatestDecodeToDisplayDelta, s32 compositionStartTime, s32 compositionEndTime ); - -/* JB_RESO 09/02 adding support for IPMPX */ -MP4_EXTERN ( MP4Err ) -MP4NewIPMPTool( MP4Handle ipmpToolH, - u64 ipmpToolIdLowerPart, - u64 ipmpToolIdUpperPart, - MP4Handle altGroupInfoH, - MP4Handle parametricInfoH ); - -/* JB_RESO 09/02 adding support for IPMPX */ -MP4_EXTERN ( MP4Err ) -MP4AddUrlToIPMPTool( MP4Handle ipmpToolH, - MP4Handle urlH ); - -/* JB_RESO 09/02 adding support for IPMPX */ -MP4_EXTERN ( MP4Err ) -MP4NewIPMPToolListDescriptor( MP4Handle ipmpToolListDescrH ); - -/* JB_RESO 09/02 adding support for IPMPX */ -MP4_EXTERN ( MP4Err ) -MP4AddToolToIPMPToolList( MP4Handle ipmpToolListDescrH, - MP4Handle ipmpToolH ); - -/* JB_RESO 09/02 adding support for IPMPX */ -MP4_EXTERN ( MP4Err ) -MP4NewIPMPDescriptorPointer( MP4Handle ipmpDescPtrH, - u8 ipmpDescriptorId, - u16 ipmpToolDescrId ); - -/* JB_RESO 09/02 adding support for IPMPX */ -MP4_EXTERN ( MP4Err ) -MP4NewIPMPToolDescriptor( MP4Handle ipmpToolDescH, - u16 ipmpToolDescrId, - u64 ipmpToolIdLowerPart, - u64 ipmpToolIdUpperPart, - MP4Handle ipmpInitializeH ); - -/* JB_RESO 09/02 adding support for IPMPX */ -MP4_EXTERN ( MP4Err ) -MP4NewIPMPInitialize( MP4Handle ipmpInitializeH, - u8 controlPoint, - u8 sequenceCode ); - -/* JB_RESO 09/02 adding support for IPMPX */ -MP4_EXTERN ( MP4Err ) -MP4AddIPMPDataToIPMPInitialize( MP4Handle ipmpInitializeH, - MP4Handle ipmpDataH ); - -/* JB_RESO 09/02 adding support for IPMPX */ -MP4_EXTERN( MP4Err ) -MP4AddIPMPDataToIPMPToolDescriptor( MP4Handle ipmpToolDescrH, - MP4Handle ipmpDataH ); - -/* JB_RESO 09/02 adding support for IPMPX */ -MP4_EXTERN( MP4Err ) -MP4NewIPMPToolDescriptorUpdate( MP4Handle ipmpToolDescrUpdateH ); - -/* JB_RESO 09/02 adding support for IPMPX */ -MP4_EXTERN( MP4Err ) -MP4AddIPMPToolDescriptorToUpdate( MP4Handle ipmpToolDescrUpdateH, - MP4Handle ipmpToolDescrH ); + /* JLF 12/00: added support for URL and for exchange files */ + MP4_EXTERN(MP4Err) + MP4NewMovieExt(MP4Movie *outMovie, u32 initialODID, u8 OD_profileAndLevel, + u8 scene_profileAndLevel, u8 audio_profileAndLevel, u8 visual_profileAndLevel, + u8 graphics_profileAndLevel, char *url, u8 IsExchangeFile); + + /* JLF 12/00: added support for stream priority */ + MP4_EXTERN(MP4Err) + MP4SetSampleDescriptionPriority(MP4Handle sampleEntryH, u32 priority); + + /* JLF 12/00: added support for descriptors in the ESD */ + MP4_EXTERN(MP4Err) + MP4AddDescToSampleDescription(MP4Handle sampleEntryH, MP4Handle descriptorH); + + /* JLF 12/00: added support for descriptors in the OD/IOD */ + MP4_EXTERN(MP4Err) + MP4AddDescToMovieIOD(MP4Movie theMovie, MP4Handle descriptorH); + + /* JLF 12/00: checking of a specific data entry. */ + MP4_EXTERN(MP4Err) + MP4CheckMediaDataRef(MP4Media theMedia, u32 dataEntryIndex); + + MP4_EXTERN(MP4Err) + ISOSetSampleDescriptionDimensions(MP4Handle sampleEntryH, u16 width, u16 height); + MP4_EXTERN(MP4Err) + ISOSetSampleDescriptionType(MP4Handle sampleEntryH, u32 type); + + MP4_EXTERN(MP4Err) + ISOGetSampleDescriptionDimensions(MP4Handle sampleEntryH, u16 *width, u16 *height); + MP4_EXTERN(MP4Err) + ISOGetSampleDescriptionType(MP4Handle sampleEntryH, u32 *type); + + MP4_EXTERN(MP4Err) + ISOStartMovieFragment(MP4Movie theMovie); + MP4_EXTERN(MP4Err) + ISOAddDelayToTrackFragmentDecodeTime(MP4Movie theMovie, u32 delay); + MP4_EXTERN(MP4Err) + ISOSetTrackFragmentDefaults(MP4Track theTrack, u32 duration, u32 size, u32 is_sync, u8 pad); + MP4_EXTERN(MP4Err) + ISOSetCompositonToDecodePropertiesForFragments(MP4Movie theMovie, u32 trackID, + s32 compositionToDTSShift, + s32 leastDecodeToDisplayDelta, + s32 greatestDecodeToDisplayDelta, + s32 compositionStartTime, s32 compositionEndTime); + + /* JB_RESO 09/02 adding support for IPMPX */ + MP4_EXTERN(MP4Err) + MP4NewIPMPTool(MP4Handle ipmpToolH, u64 ipmpToolIdLowerPart, u64 ipmpToolIdUpperPart, + MP4Handle altGroupInfoH, MP4Handle parametricInfoH); + + /* JB_RESO 09/02 adding support for IPMPX */ + MP4_EXTERN(MP4Err) + MP4AddUrlToIPMPTool(MP4Handle ipmpToolH, MP4Handle urlH); + + /* JB_RESO 09/02 adding support for IPMPX */ + MP4_EXTERN(MP4Err) + MP4NewIPMPToolListDescriptor(MP4Handle ipmpToolListDescrH); + + /* JB_RESO 09/02 adding support for IPMPX */ + MP4_EXTERN(MP4Err) + MP4AddToolToIPMPToolList(MP4Handle ipmpToolListDescrH, MP4Handle ipmpToolH); + + /* JB_RESO 09/02 adding support for IPMPX */ + MP4_EXTERN(MP4Err) + MP4NewIPMPDescriptorPointer(MP4Handle ipmpDescPtrH, u8 ipmpDescriptorId, u16 ipmpToolDescrId); + + /* JB_RESO 09/02 adding support for IPMPX */ + MP4_EXTERN(MP4Err) + MP4NewIPMPToolDescriptor(MP4Handle ipmpToolDescH, u16 ipmpToolDescrId, u64 ipmpToolIdLowerPart, + u64 ipmpToolIdUpperPart, MP4Handle ipmpInitializeH); + + /* JB_RESO 09/02 adding support for IPMPX */ + MP4_EXTERN(MP4Err) + MP4NewIPMPInitialize(MP4Handle ipmpInitializeH, u8 controlPoint, u8 sequenceCode); + + /* JB_RESO 09/02 adding support for IPMPX */ + MP4_EXTERN(MP4Err) + MP4AddIPMPDataToIPMPInitialize(MP4Handle ipmpInitializeH, MP4Handle ipmpDataH); + + /* JB_RESO 09/02 adding support for IPMPX */ + MP4_EXTERN(MP4Err) + MP4AddIPMPDataToIPMPToolDescriptor(MP4Handle ipmpToolDescrH, MP4Handle ipmpDataH); + + /* JB_RESO 09/02 adding support for IPMPX */ + MP4_EXTERN(MP4Err) + MP4NewIPMPToolDescriptorUpdate(MP4Handle ipmpToolDescrUpdateH); + + /* JB_RESO 09/02 adding support for IPMPX */ + MP4_EXTERN(MP4Err) + MP4AddIPMPToolDescriptorToUpdate(MP4Handle ipmpToolDescrUpdateH, MP4Handle ipmpToolDescrH); #ifdef ISMACrypt -MP4_EXTERN ( MP4Err ) ISMATransformSampleEntry( u32 newTrackFlags, MP4Handle insampleEntryH, - u8 selective_encryption, u8 key_indicator_length, u8 IV_length, - char* kms_URL, - MP4Handle outsampleEntryH ); - -MP4_EXTERN ( MP4Err ) ISMAUnTransformSampleEntry( MP4Handle insampleEntryH, - u8* selective_encryption, u8* key_indicator_length, u8* IV_length, - char** kms_URL, - MP4Handle outsampleEntryH ); - -MP4_EXTERN ( MP4Err ) ISMATransformSampleEntrySalt( u32 newTrackFlags, MP4Handle insampleEntryH, - u8 selective_encryption, u8 key_indicator_length, u8 IV_length, - char* kms_URL, u64 salt, - MP4Handle outsampleEntryH ); - -MP4_EXTERN ( MP4Err ) ISMAUnTransformSampleEntrySalt( MP4Handle insampleEntryH, - u8* selective_encryption, u8* key_indicator_length, u8* IV_length, - char** kms_URL, u64* salt, - MP4Handle outsampleEntryH ); + MP4_EXTERN(MP4Err) + ISMATransformSampleEntry(u32 newTrackFlags, MP4Handle insampleEntryH, u8 selective_encryption, + u8 key_indicator_length, u8 IV_length, char *kms_URL, + MP4Handle outsampleEntryH); + + MP4_EXTERN(MP4Err) + ISMAUnTransformSampleEntry(MP4Handle insampleEntryH, u8 *selective_encryption, + u8 *key_indicator_length, u8 *IV_length, char **kms_URL, + MP4Handle outsampleEntryH); + + MP4_EXTERN(MP4Err) + ISMATransformSampleEntrySalt(u32 newTrackFlags, MP4Handle insampleEntryH, u8 selective_encryption, + u8 key_indicator_length, u8 IV_length, char *kms_URL, u64 salt, + MP4Handle outsampleEntryH); + + MP4_EXTERN(MP4Err) + ISMAUnTransformSampleEntrySalt(MP4Handle insampleEntryH, u8 *selective_encryption, + u8 *key_indicator_length, u8 *IV_length, char **kms_URL, u64 *salt, + MP4Handle outsampleEntryH); #define ISMA_selective_encrypt 0x80 #endif -MP4_EXTERN ( MP4Err ) -MP4GetTrackEditlistEntryCount( MP4Track theTrack, u32* entryCount ); + MP4_EXTERN(MP4Err) + MP4GetTrackEditlistEntryCount(MP4Track theTrack, u32 *entryCount); -MP4_EXTERN ( MP4Err ) -MP4GetTrackEditlist( MP4Track theTrack, u64* outSegmentDuration, s64* outMediaTime, u32 entryIndex /* index is one based */ ); + MP4_EXTERN(MP4Err) + MP4GetTrackEditlist(MP4Track theTrack, u64 *outSegmentDuration, s64 *outMediaTime, + u32 entryIndex /* index is one based */); #ifdef __cplusplus } diff --git a/IsoLib/libisomediafile/src/MP4ODTrackReader.c b/IsoLib/libisomediafile/src/MP4ODTrackReader.c index cd2bbe3..8d504b5 100644 --- a/IsoLib/libisomediafile/src/MP4ODTrackReader.c +++ b/IsoLib/libisomediafile/src/MP4ODTrackReader.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,29 +15,31 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4ODTrackReader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4ODTrackReader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4TrackReader.h" #include "MP4Impl.h" #include "MP4Atoms.h" -MP4Err MP4CreateODTrackReader( MP4Movie theMovie, MP4Track theTrack, MP4TrackReaderPtr *outReader ) +MP4Err MP4CreateODTrackReader(MP4Movie theMovie, MP4Track theTrack, MP4TrackReaderPtr *outReader) { - MP4Err MP4CreateOrdinaryTrackReader( MP4Movie theMovie, MP4Track theTrack, MP4TrackReaderPtr *outReader ); - - MP4Err err; - - err = MP4CreateOrdinaryTrackReader( theMovie, theTrack, outReader ); if (err) goto bail; - (*outReader)->isODTrack = 1; + MP4Err MP4CreateOrdinaryTrackReader(MP4Movie theMovie, MP4Track theTrack, + MP4TrackReaderPtr * outReader); + + MP4Err err; + + err = MP4CreateOrdinaryTrackReader(theMovie, theTrack, outReader); + if(err) goto bail; + (*outReader)->isODTrack = 1; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c b/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c index c671cd4..aa7c18a 100644 --- a/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,219 +15,237 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4ObjectDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4ObjectDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include #include -static MP4Err addDescriptor( struct MP4DescriptorRecord* s, MP4DescriptorPtr desc ) +static MP4Err addDescriptor(struct MP4DescriptorRecord *s, MP4DescriptorPtr desc) { - MP4Err err; - MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr) s; - err = MP4NoErr; - switch( desc->tag ) - { - case MP4ES_DescriptorTag: - err = MP4AddListEntry( desc, self->ESDescriptors ); if (err) goto bail; - break; - - case MP4ES_ID_IncDescriptorTag: - err = MP4AddListEntry( desc, self->ES_ID_IncDescriptors ); if (err) goto bail; - break; - - case MP4ES_ID_RefDescriptorTag: - err = MP4AddListEntry( desc, self->ES_ID_RefDescriptors ); if (err) goto bail; - break; - - case MP4IPMP_DescriptorPointerTag: - err = MP4AddListEntry( desc, self->IPMPDescriptorPointers ); if (err) goto bail; - break; - - default: - err = MP4AddListEntry( desc, self->extensionDescriptors ); if (err) goto bail; - break; - } + MP4Err err; + MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr)s; + err = MP4NoErr; + switch(desc->tag) + { + case MP4ES_DescriptorTag: + err = MP4AddListEntry(desc, self->ESDescriptors); + if(err) goto bail; + break; + + case MP4ES_ID_IncDescriptorTag: + err = MP4AddListEntry(desc, self->ES_ID_IncDescriptors); + if(err) goto bail; + break; + + case MP4ES_ID_RefDescriptorTag: + err = MP4AddListEntry(desc, self->ES_ID_RefDescriptors); + if(err) goto bail; + break; + + case MP4IPMP_DescriptorPointerTag: + err = MP4AddListEntry(desc, self->IPMPDescriptorPointers); + if(err) goto bail; + break; + + default: + err = MP4AddListEntry(desc, self->extensionDescriptors); + if(err) goto bail; + break; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - u32 count; - u32 i; - MP4DescriptorPtr desc; - MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr) s; - err = MP4NoErr; - self->size = DESCRIPTOR_TAG_LEN_SIZE; - self->size += 2; - if ( self->URLStringLength ) - self->size += self->URLStringLength + 1; - ADD_DESCRIPTOR_LIST_SIZE( ESDescriptors ); - ADD_DESCRIPTOR_LIST_SIZE( ES_ID_IncDescriptors ); - ADD_DESCRIPTOR_LIST_SIZE( ES_ID_RefDescriptors ); - ADD_DESCRIPTOR_LIST_SIZE( OCIDescriptors ); - ADD_DESCRIPTOR_LIST_SIZE( IPMPDescriptorPointers ); - ADD_DESCRIPTOR_LIST_SIZE( extensionDescriptors ); + MP4Err err; + u32 count; + u32 i; + MP4DescriptorPtr desc; + MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr)s; + err = MP4NoErr; + self->size = DESCRIPTOR_TAG_LEN_SIZE; + self->size += 2; + if(self->URLStringLength) self->size += self->URLStringLength + 1; + ADD_DESCRIPTOR_LIST_SIZE(ESDescriptors); + ADD_DESCRIPTOR_LIST_SIZE(ES_ID_IncDescriptors); + ADD_DESCRIPTOR_LIST_SIZE(ES_ID_RefDescriptors); + ADD_DESCRIPTOR_LIST_SIZE(OCIDescriptors); + ADD_DESCRIPTOR_LIST_SIZE(IPMPDescriptorPointers); + ADD_DESCRIPTOR_LIST_SIZE(extensionDescriptors); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - u16 val; - MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr) s; - err = MP4NoErr; - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - - val = self->objectDescriptorID << 6; - if ( self->URLStringLength ) - val |= (1<<5); - val |= 0x1f; - PUT16_V( val ); - - if ( self->URLStringLength ) - { - PUT8( URLStringLength ); - PUTBYTES( self->URLString, self->URLStringLength ); - } - SERIALIZE_DESCRIPTOR_LIST( ESDescriptors ); - SERIALIZE_DESCRIPTOR_LIST( ES_ID_IncDescriptors ); - SERIALIZE_DESCRIPTOR_LIST( ES_ID_RefDescriptors ); - SERIALIZE_DESCRIPTOR_LIST( OCIDescriptors ); - SERIALIZE_DESCRIPTOR_LIST( IPMPDescriptorPointers ); - SERIALIZE_DESCRIPTOR_LIST( extensionDescriptors ); + MP4Err err; + u16 val; + MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr)s; + err = MP4NoErr; + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + + val = self->objectDescriptorID << 6; + if(self->URLStringLength) val |= (1 << 5); + val |= 0x1f; + PUT16_V(val); + + if(self->URLStringLength) + { + PUT8(URLStringLength); + PUTBYTES(self->URLString, self->URLStringLength); + } + SERIALIZE_DESCRIPTOR_LIST(ESDescriptors); + SERIALIZE_DESCRIPTOR_LIST(ES_ID_IncDescriptors); + SERIALIZE_DESCRIPTOR_LIST(ES_ID_RefDescriptors); + SERIALIZE_DESCRIPTOR_LIST(OCIDescriptors); + SERIALIZE_DESCRIPTOR_LIST(IPMPDescriptorPointers); + SERIALIZE_DESCRIPTOR_LIST(extensionDescriptors); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 val; - u32 urlflag; - MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr) s; - err = MP4NoErr; - GET16_V_MSG( val, NULL ); - self->objectDescriptorID = val >> 6; - urlflag = val & (1 << 5) ? 1 : 0; - DEBUG_SPRINTF( "objectDescriptorID = %d", self->objectDescriptorID ); - DEBUG_SPRINTF( "urlflag = %d", urlflag ); - - if ( urlflag ) - { - GET8( URLStringLength ); - self->URLString = (char*) calloc( 1, self->URLStringLength ); - TESTMALLOC( self->URLString ) - GETBYTES( self->URLStringLength, URLString ); - } - while ( self->bytesRead < self->size ) - { - MP4DescriptorPtr desc; - err = MP4ParseDescriptor( inputStream, &desc ); if (err) goto bail; - if ( (desc->tag >= MP4ContentClassificationDescriptorTag) && - (desc->tag <= MP4ISO_OCI_EXT_RANGE_END) ) - { - err = MP4AddListEntry( desc, self->OCIDescriptors ); if (err) goto bail; - } - else - { - switch( desc->tag ) - { - case MP4ES_DescriptorTag: - err = MP4AddListEntry( desc, self->ESDescriptors ); if (err) goto bail; - break; - - case MP4ES_ID_IncDescriptorTag: - err = MP4AddListEntry( desc, self->ES_ID_IncDescriptors ); if (err) goto bail; - break; - - case MP4ES_ID_RefDescriptorTag: - err = MP4AddListEntry( desc, self->ES_ID_RefDescriptors ); if (err) goto bail; - break; - - case MP4IPMP_DescriptorPointerTag: - err = MP4AddListEntry( desc, self->IPMPDescriptorPointers ); if (err) goto bail; - break; - - default: - err = MP4AddListEntry( desc, self->extensionDescriptors ); if (err) goto bail; - break; - } - } - self->bytesRead += desc->size; - } - + MP4Err err; + u32 val; + u32 urlflag; + MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr)s; + err = MP4NoErr; + GET16_V_MSG(val, NULL); + self->objectDescriptorID = val >> 6; + urlflag = val & (1 << 5) ? 1 : 0; + DEBUG_SPRINTF("objectDescriptorID = %d", self->objectDescriptorID); + DEBUG_SPRINTF("urlflag = %d", urlflag); + + if(urlflag) + { + GET8(URLStringLength); + self->URLString = (char *)calloc(1, self->URLStringLength); + TESTMALLOC(self->URLString) + GETBYTES(self->URLStringLength, URLString); + } + while(self->bytesRead < self->size) + { + MP4DescriptorPtr desc; + err = MP4ParseDescriptor(inputStream, &desc); + if(err) goto bail; + if((desc->tag >= MP4ContentClassificationDescriptorTag) && + (desc->tag <= MP4ISO_OCI_EXT_RANGE_END)) + { + err = MP4AddListEntry(desc, self->OCIDescriptors); + if(err) goto bail; + } + else + { + switch(desc->tag) + { + case MP4ES_DescriptorTag: + err = MP4AddListEntry(desc, self->ESDescriptors); + if(err) goto bail; + break; + + case MP4ES_ID_IncDescriptorTag: + err = MP4AddListEntry(desc, self->ES_ID_IncDescriptors); + if(err) goto bail; + break; + + case MP4ES_ID_RefDescriptorTag: + err = MP4AddListEntry(desc, self->ES_ID_RefDescriptors); + if(err) goto bail; + break; + + case MP4IPMP_DescriptorPointerTag: + err = MP4AddListEntry(desc, self->IPMPDescriptorPointers); + if(err) goto bail; + break; + + default: + err = MP4AddListEntry(desc, self->extensionDescriptors); + if(err) goto bail; + break; + } + } + self->bytesRead += desc->size; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static void destroy( struct MP4DescriptorRecord* s ) + +static void destroy(struct MP4DescriptorRecord *s) { - MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr) s; - if ( self->URLString ) - { - free( self->URLString ); - self->URLString = NULL; - } - - DESTROY_DESCRIPTOR_LIST( ESDescriptors ); - DESTROY_DESCRIPTOR_LIST( ES_ID_IncDescriptors ); - DESTROY_DESCRIPTOR_LIST( ES_ID_RefDescriptors ); - DESTROY_DESCRIPTOR_LIST( OCIDescriptors ); - DESTROY_DESCRIPTOR_LIST( IPMPDescriptorPointers ); - DESTROY_DESCRIPTOR_LIST( extensionDescriptors ); - - free( self ); + MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr)s; + if(self->URLString) + { + free(self->URLString); + self->URLString = NULL; + } + + DESTROY_DESCRIPTOR_LIST(ESDescriptors); + DESTROY_DESCRIPTOR_LIST(ES_ID_IncDescriptors); + DESTROY_DESCRIPTOR_LIST(ES_ID_RefDescriptors); + DESTROY_DESCRIPTOR_LIST(OCIDescriptors); + DESTROY_DESCRIPTOR_LIST(IPMPDescriptorPointers); + DESTROY_DESCRIPTOR_LIST(extensionDescriptors); + + free(self); bail: - return; + return; } -static MP4Err removeESDS( struct MP4DescriptorRecord* s ) +static MP4Err removeESDS(struct MP4DescriptorRecord *s) { - MP4Err err; - MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr) s; - err = MP4NoErr; - DESTROY_DESCRIPTOR_LIST( ESDescriptors ); - err = MP4MakeLinkedList( &self->ESDescriptors ); if (err) goto bail; - bail: - return err; + MP4Err err; + MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr)s; + err = MP4NoErr; + DESTROY_DESCRIPTOR_LIST(ESDescriptors); + err = MP4MakeLinkedList(&self->ESDescriptors); + if(err) goto bail; +bail: + return err; } -MP4Err MP4CreateObjectDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateObjectDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4ObjectDescriptor ) - self->addDescriptor = addDescriptor; - self->removeESDS = removeESDS; - err = MP4MakeLinkedList( &self->ESDescriptors ); if (err) goto bail; - - err = MP4MakeLinkedList( &self->ES_ID_IncDescriptors ); if (err) goto bail; - err = MP4MakeLinkedList( &self->ES_ID_RefDescriptors ); if (err) goto bail; - err = MP4MakeLinkedList( &self->OCIDescriptors ); if (err) goto bail; - err = MP4MakeLinkedList( &self->IPMPDescriptorPointers ); if (err) goto bail; - err = MP4MakeLinkedList( &self->extensionDescriptors ); if (err) goto bail; - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4ObjectDescriptor) + self->addDescriptor = addDescriptor; + self->removeESDS = removeESDS; + err = MP4MakeLinkedList(&self->ESDescriptors); + if(err) goto bail; + + err = MP4MakeLinkedList(&self->ES_ID_IncDescriptors); + if(err) goto bail; + err = MP4MakeLinkedList(&self->ES_ID_RefDescriptors); + if(err) goto bail; + err = MP4MakeLinkedList(&self->OCIDescriptors); + if(err) goto bail; + err = MP4MakeLinkedList(&self->IPMPDescriptorPointers); + if(err) goto bail; + err = MP4MakeLinkedList(&self->extensionDescriptors); + if(err) goto bail; + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c b/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c index eb32082..a349c96 100644 --- a/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c +++ b/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4OrdinaryTrackReader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4OrdinaryTrackReader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4TrackReader.h" @@ -30,329 +30,330 @@ derivative works. Copyright (c) 1999. #include #include -static void put32( u32 val, char *buf ) +static void put32(u32 val, char *buf) { - buf[3] = val & 0xFF; - buf[2] = (val >> 8) & 0xFF; - buf[1] = (val >> 16) & 0xFF; - buf[0] = (val >> 24) & 0xFF; + buf[3] = val & 0xFF; + buf[2] = (val >> 8) & 0xFF; + buf[1] = (val >> 16) & 0xFF; + buf[0] = (val >> 24) & 0xFF; } -static MP4Err destroy(struct MP4TrackReaderStruct* self ) +static MP4Err destroy(struct MP4TrackReaderStruct *self) { - MP4DisposeHandle( self->sampleH ); - self->sampleH = NULL; - free( self ); - return MP4NoErr; + MP4DisposeHandle(self->sampleH); + self->sampleH = NULL; + free(self); + return MP4NoErr; } -static MP4Err getNextSegment( MP4TrackReaderPtr self ) +static MP4Err getNextSegment(MP4TrackReaderPtr self) { - MP4Err err; - MP4EditListAtomPtr elst; - u64 segmentDuration; - u64 segmentMediaDuration; - u32 segmentEndSampleNumber; - - err = MP4NoErr; - - elst = (MP4EditListAtomPtr) self->elst; - if ( elst == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - for ( ;; ) - { - u32 empty; - err = elst->isEmptyEdit( elst, self->nextSegment, &empty ); if (err) goto bail; - if ( empty ) + MP4Err err; + MP4EditListAtomPtr elst; + u64 segmentDuration; + u64 segmentMediaDuration; + u32 segmentEndSampleNumber; + + err = MP4NoErr; + + elst = (MP4EditListAtomPtr)self->elst; + if(elst == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + for(;;) + { + u32 empty; + err = elst->isEmptyEdit(elst, self->nextSegment, &empty); + if(err) goto bail; + if(empty) + { + if(self->nextSegment == self->trackSegments) { - if ( self->nextSegment == self->trackSegments ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - else - self->nextSegment++; + BAILWITHERROR(MP4InvalidMediaErr); } else - break; - } - err = elst->getIndSegmentTime( (MP4AtomPtr) elst, - self->nextSegment, - &self->segmentMovieTime, - &self->segmentMediaTime, - &segmentDuration ); if (err) goto bail; + self->nextSegment++; + } + else + break; + } + err = elst->getIndSegmentTime((MP4AtomPtr)elst, self->nextSegment, &self->segmentMovieTime, + &self->segmentMediaTime, &segmentDuration); + if(err) goto bail; - err = MP4MediaTimeToSampleNum( self->media, - self->segmentMediaTime, - &self->nextSampleNumber, NULL, NULL, NULL ); if (err) goto bail; + err = MP4MediaTimeToSampleNum(self->media, self->segmentMediaTime, &self->nextSampleNumber, NULL, + NULL, NULL); + if(err) goto bail; - self->segmentEndTime = self->mediaTimeScale * (self->segmentMovieTime + segmentDuration) - / self->movieTimeScale; + self->segmentEndTime = + self->mediaTimeScale * (self->segmentMovieTime + segmentDuration) / self->movieTimeScale; - segmentMediaDuration = (self->mediaTimeScale * segmentDuration) - / self->movieTimeScale; + segmentMediaDuration = (self->mediaTimeScale * segmentDuration) / self->movieTimeScale; - err = MP4MediaTimeToSampleNum( self->media, - self->segmentMediaTime + segmentMediaDuration, - &segmentEndSampleNumber, NULL, NULL, NULL ); if (err) goto bail; + err = MP4MediaTimeToSampleNum(self->media, self->segmentMediaTime + segmentMediaDuration, + &segmentEndSampleNumber, NULL, NULL, NULL); + if(err) goto bail; - if ( segmentEndSampleNumber < self->nextSampleNumber ) - BAILWITHERROR( MP4InvalidMediaErr ); + if(segmentEndSampleNumber < self->nextSampleNumber) BAILWITHERROR(MP4InvalidMediaErr); - self->segmentSampleCount = (segmentEndSampleNumber - self->nextSampleNumber); - self->segmentBeginTime = (self->mediaTimeScale * self->segmentMovieTime) / self->movieTimeScale; - bail: - TEST_RETURN( err ); + self->segmentSampleCount = (segmentEndSampleNumber - self->nextSampleNumber); + self->segmentBeginTime = (self->mediaTimeScale * self->segmentMovieTime) / self->movieTimeScale; +bail: + TEST_RETURN(err); - return err; + return err; } - -static MP4Err getNextAccessUnit( struct MP4TrackReaderStruct* self, MP4Handle outAccessUnit, - u32 *outSize, u32 *outSampleFlags, - s32 *outCTS, s32 *outDTS, u32 *outDuration, u8* outPad ) +static MP4Err getNextAccessUnit(struct MP4TrackReaderStruct *self, MP4Handle outAccessUnit, + u32 *outSize, u32 *outSampleFlags, s32 *outCTS, s32 *outDTS, + u32 *outDuration, u8 *outPad) { - MP4Err err; - u32 sampleFlags; - u64 sampleDTS; - s32 sampleCTSOffset; - u64 duration; - - - err = MP4NoErr; - - if ( self->nextSegment > self->trackSegments ) - { - BAILWITHERROR( MP4EOF ) - } - if ( (self->elst == 0) && (self->nextSampleNumber > self->segmentSampleCount) ) - { - BAILWITHERROR( MP4EOF ) - } - - /* first get the sample */ - err = MP4GetIndMediaSampleWithPad( self->media, - self->nextSampleNumber, - outAccessUnit, outSize, - &sampleDTS, &sampleCTSOffset, - &duration, &sampleFlags, &self->sampleDescIndex, outPad ); if (err) goto bail; - self->currentSampleNumber = self->nextSampleNumber; - - if ( self->isODTrack ) - { - MP4Err MP4GetTrackReferenceType( MP4Track track, - u32 atomType, - MP4TrackReferenceTypeAtomPtr *outAtom ); - MP4Err rewriteODFrame( MP4Track track, - MP4Handle sampleH, - u64 cts, - MP4TrackReferenceTypeAtomPtr mpod, MP4SLConfig slconfig ); - - MP4TrackReferenceTypeAtomPtr mpod; - err = MP4GetTrackReferenceType( self->track, - MP4ODTrackReferenceAtomType, - &mpod ); if (err) goto bail; - if ( mpod ) - { - u32 sz; - err = rewriteODFrame( self->track, outAccessUnit, sampleDTS, mpod, self->slconfig ); if (err) goto bail; - err = MP4GetHandleSize( outAccessUnit, &sz ); if (err) goto bail; - *outSize = sz; - } - } - self->nextSampleNumber += 1; - *outSampleFlags = sampleFlags; - *outDTS = (u32)(sampleDTS - self->segmentMediaTime + self->segmentBeginTime); - - if ( sampleFlags & MP4MediaSampleHasCTSOffset ) - *outCTS = (u32) ((*outDTS + sampleCTSOffset) & 0xFFFFFFFF); - else - *outCTS = *outDTS; - - if ( (self->elst) && ((duration + *outDTS) >= self->segmentEndTime) ) - { - if (outDuration) *outDuration = (u32) (self->segmentEndTime - *outDTS); - - self->nextSegment += 1; - if ( self->nextSegment <= self->trackSegments ) - { - err = getNextSegment( self ); if (err) goto bail; - } - } - else if ( outDuration ) - { - *outDuration = (u32)duration; - } - bail: - return err; + MP4Err err; + u32 sampleFlags; + u64 sampleDTS; + s32 sampleCTSOffset; + u64 duration; + + err = MP4NoErr; + + if(self->nextSegment > self->trackSegments) + { + BAILWITHERROR(MP4EOF) + } + if((self->elst == 0) && (self->nextSampleNumber > self->segmentSampleCount)) + { + BAILWITHERROR(MP4EOF) + } + + /* first get the sample */ + err = MP4GetIndMediaSampleWithPad(self->media, self->nextSampleNumber, outAccessUnit, outSize, + &sampleDTS, &sampleCTSOffset, &duration, &sampleFlags, + &self->sampleDescIndex, outPad); + if(err) goto bail; + self->currentSampleNumber = self->nextSampleNumber; + + if(self->isODTrack) + { + MP4Err MP4GetTrackReferenceType(MP4Track track, u32 atomType, + MP4TrackReferenceTypeAtomPtr * outAtom); + MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, + MP4TrackReferenceTypeAtomPtr mpod, MP4SLConfig slconfig); + + MP4TrackReferenceTypeAtomPtr mpod; + err = MP4GetTrackReferenceType(self->track, MP4ODTrackReferenceAtomType, &mpod); + if(err) goto bail; + if(mpod) + { + u32 sz; + err = rewriteODFrame(self->track, outAccessUnit, sampleDTS, mpod, self->slconfig); + if(err) goto bail; + err = MP4GetHandleSize(outAccessUnit, &sz); + if(err) goto bail; + *outSize = sz; + } + } + self->nextSampleNumber += 1; + *outSampleFlags = sampleFlags; + *outDTS = (u32)(sampleDTS - self->segmentMediaTime + self->segmentBeginTime); + + if(sampleFlags & MP4MediaSampleHasCTSOffset) + *outCTS = (u32)((*outDTS + sampleCTSOffset) & 0xFFFFFFFF); + else + *outCTS = *outDTS; + + if((self->elst) && ((duration + *outDTS) >= self->segmentEndTime)) + { + if(outDuration) *outDuration = (u32)(self->segmentEndTime - *outDTS); + + self->nextSegment += 1; + if(self->nextSegment <= self->trackSegments) + { + err = getNextSegment(self); + if(err) goto bail; + } + } + else if(outDuration) + { + *outDuration = (u32)duration; + } +bail: + return err; } -static MP4Err setSLConfig( struct MP4TrackReaderStruct* self, MP4SLConfig slconfig ) +static MP4Err setSLConfig(struct MP4TrackReaderStruct *self, MP4SLConfig slconfig) { - self->slconfig = slconfig; - return MP4NoErr; + self->slconfig = slconfig; + return MP4NoErr; } -static MP4Err getNextPacket( MP4TrackReaderPtr self, MP4Handle outPacket, u32 *outSize ) +static MP4Err getNextPacket(MP4TrackReaderPtr self, MP4Handle outPacket, u32 *outSize) { - MP4Err err; - u32 sampleSize; - u32 sampleFlags; - u32 packetSize; - char header[ 40 ]; - u32 headerBytes; - u8 val; - s32 packetCTS; - s32 packetDTS; - - err = MP4NoErr; - if ( self->slconfig ) - { - /* - We don't support packetization with - arbitrary SLConfigs yet!!! - */ - BAILWITHERROR( MP4NotImplementedErr ); - } - err = getNextAccessUnit( self, self->sampleH, &sampleSize, - &sampleFlags, &packetCTS, &packetDTS, 0, NULL ); if (err) goto bail; - - /* make packet header */ - self->sequenceNumber += 1; - self->sequenceNumber &= 0x1F; - - /* note that we hardwire seqnum to 5 bits */ - val = (self->sequenceNumber & 0x1F) << 3; - if ( (sampleFlags & MP4MediaSampleNotSync) == 0 ) - val |= (1 << 2); - if ( sampleFlags & MP4MediaSampleHasCTSOffset ) - val |= (1 << 1); - val |= 1; /* we always have CTS */ - headerBytes = 0; - header[ headerBytes++ ] = val; - - if ( sampleFlags & MP4MediaSampleHasCTSOffset ) - { - put32( packetDTS, header + headerBytes ); - headerBytes += 4; - } - put32( packetCTS, header + headerBytes ); - headerBytes += 4; - - /* size output handle */ - packetSize = sampleSize + headerBytes; - err = MP4SetHandleSize( outPacket, packetSize ); if (err) goto bail; - - /* copy header and sample into output handle */ - memcpy( *outPacket, header, headerBytes ); - memcpy( *outPacket + headerBytes, *self->sampleH, sampleSize ); - *outSize = packetSize; + MP4Err err; + u32 sampleSize; + u32 sampleFlags; + u32 packetSize; + char header[40]; + u32 headerBytes; + u8 val; + s32 packetCTS; + s32 packetDTS; + + err = MP4NoErr; + if(self->slconfig) + { + /* + We don't support packetization with + arbitrary SLConfigs yet!!! + */ + BAILWITHERROR(MP4NotImplementedErr); + } + err = getNextAccessUnit(self, self->sampleH, &sampleSize, &sampleFlags, &packetCTS, &packetDTS, 0, + NULL); + if(err) goto bail; + + /* make packet header */ + self->sequenceNumber += 1; + self->sequenceNumber &= 0x1F; + + /* note that we hardwire seqnum to 5 bits */ + val = (self->sequenceNumber & 0x1F) << 3; + if((sampleFlags & MP4MediaSampleNotSync) == 0) val |= (1 << 2); + if(sampleFlags & MP4MediaSampleHasCTSOffset) val |= (1 << 1); + val |= 1; /* we always have CTS */ + headerBytes = 0; + header[headerBytes++] = val; + + if(sampleFlags & MP4MediaSampleHasCTSOffset) + { + put32(packetDTS, header + headerBytes); + headerBytes += 4; + } + put32(packetCTS, header + headerBytes); + headerBytes += 4; + + /* size output handle */ + packetSize = sampleSize + headerBytes; + err = MP4SetHandleSize(outPacket, packetSize); + if(err) goto bail; + + /* copy header and sample into output handle */ + memcpy(*outPacket, header, headerBytes); + memcpy(*outPacket + headerBytes, *self->sampleH, sampleSize); + *outSize = packetSize; bail: - return err; + return err; } -static MP4Err setupReader( MP4TrackReaderPtr self ) +static MP4Err setupReader(MP4TrackReaderPtr self) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4EditAtomPtr edts; - u32 editCount; - u32 sampleCount; - - err = MP4NoErr; - trak = (MP4TrackAtomPtr) self->track; - edts = (MP4EditAtomPtr) trak->trackEditAtom; - - editCount = 0; - if (edts != 0) { - MP4EditListAtomPtr elst; - elst = (MP4EditListAtomPtr) (edts->editListAtom); - if (elst != 0) - editCount = elst->getEntryCount( elst ); - } - - if ( editCount == 0 ) - { - err = MP4GetMediaSampleCount( self->media, &sampleCount ); if (err) goto bail; - self->elst = 0; - self->trackSegments = 1; - self->nextSegment = 0; - self->segmentSampleCount = sampleCount; - self->nextSampleNumber = 1; - self->segmentMovieTime = 0; - self->sampleDescIndex = 1; - self->segmentBeginTime = 0; - self->segmentMediaTime = 0; - } - else - { - self->elst = (MP4EditListAtomPtr) edts->editListAtom; - self->trackSegments = self->elst->getEntryCount( self->elst ); - self->nextSegment = 1; - self->sampleDescIndex = 1; - err = getNextSegment( self ); if (err) goto bail; - } - self->currentSampleNumber = 0; - - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4TrackAtomPtr trak; + MP4EditAtomPtr edts; + u32 editCount; + u32 sampleCount; + + err = MP4NoErr; + trak = (MP4TrackAtomPtr)self->track; + edts = (MP4EditAtomPtr)trak->trackEditAtom; + + editCount = 0; + if(edts != 0) + { + MP4EditListAtomPtr elst; + elst = (MP4EditListAtomPtr)(edts->editListAtom); + if(elst != 0) editCount = elst->getEntryCount(elst); + } + + if(editCount == 0) + { + err = MP4GetMediaSampleCount(self->media, &sampleCount); + if(err) goto bail; + self->elst = 0; + self->trackSegments = 1; + self->nextSegment = 0; + self->segmentSampleCount = sampleCount; + self->nextSampleNumber = 1; + self->segmentMovieTime = 0; + self->sampleDescIndex = 1; + self->segmentBeginTime = 0; + self->segmentMediaTime = 0; + } + else + { + self->elst = (MP4EditListAtomPtr)edts->editListAtom; + self->trackSegments = self->elst->getEntryCount(self->elst); + self->nextSegment = 1; + self->sampleDescIndex = 1; + err = getNextSegment(self); + if(err) goto bail; + } + self->currentSampleNumber = 0; + +bail: + TEST_RETURN(err); + + return err; } -MP4Err MP4CreateOrdinaryTrackReader( MP4Movie theMovie, MP4Track theTrack, MP4TrackReaderPtr *outReader ) +MP4Err MP4CreateOrdinaryTrackReader(MP4Movie theMovie, MP4Track theTrack, + MP4TrackReaderPtr *outReader) { - MP4Err err; - MP4TrackReaderPtr self; - - err = MP4NoErr; - self = (MP4TrackReaderPtr) calloc( 1, sizeof(struct MP4TrackReaderStruct) ); - TESTMALLOC( self ) - self->movie = theMovie; - self->track = theTrack; - self->destroy = destroy; - self->getNextPacket = getNextPacket; - self->getNextAccessUnit = getNextAccessUnit; - self->setSLConfig = setSLConfig; - err = MP4NewHandle( 4096, &self->sampleH ); if (err) goto bail; - err = MP4GetTrackMedia( theTrack, &self->media ); if (err) goto bail; - err = MP4CheckMediaDataReferences( self->media ); if (err) goto bail; - err = MP4GetMovieTimeScale( theMovie, &self->movieTimeScale ); if (err) goto bail; - err = MP4GetMediaTimeScale( self->media, &self->mediaTimeScale ); if (err) goto bail; - err = setupReader( self ); if (err) goto bail; - *outReader = self; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4TrackReaderPtr self; + + err = MP4NoErr; + self = (MP4TrackReaderPtr)calloc(1, sizeof(struct MP4TrackReaderStruct)); + TESTMALLOC(self) + self->movie = theMovie; + self->track = theTrack; + self->destroy = destroy; + self->getNextPacket = getNextPacket; + self->getNextAccessUnit = getNextAccessUnit; + self->setSLConfig = setSLConfig; + err = MP4NewHandle(4096, &self->sampleH); + if(err) goto bail; + err = MP4GetTrackMedia(theTrack, &self->media); + if(err) goto bail; + err = MP4CheckMediaDataReferences(self->media); + if(err) goto bail; + err = MP4GetMovieTimeScale(theMovie, &self->movieTimeScale); + if(err) goto bail; + err = MP4GetMediaTimeScale(self->media, &self->mediaTimeScale); + if(err) goto bail; + err = setupReader(self); + if(err) goto bail; + *outReader = self; +bail: + TEST_RETURN(err); + + return err; } /* Guido : inserted to clean-up resources */ -MP4Err MP4DisposeOrdinaryTrackReader( MP4TrackReaderPtr self ) +MP4Err MP4DisposeOrdinaryTrackReader(MP4TrackReaderPtr self) { - MP4Err err; - MP4Media theMedia; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - if (self == NULL) - { - BAILWITHERROR( MP4BadParamErr ); - } - theMedia = self->media; - if (theMedia == NULL) - { - BAILWITHERROR( MP4BadParamErr ); - } - minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr) theMedia)->information; - if ( minf == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - err = minf->closeDataHandler( (MP4AtomPtr) minf ); if (err) goto bail; - - bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + MP4Media theMedia; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + if(self == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + theMedia = self->media; + if(theMedia == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; + if(minf == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + err = minf->closeDataHandler((MP4AtomPtr)minf); + if(err) goto bail; + +bail: + TEST_RETURN(err); + return err; +} diff --git a/IsoLib/libisomediafile/src/MP4SLPacket.c b/IsoLib/libisomediafile/src/MP4SLPacket.c index c8fe2d3..0c6c1fa 100644 --- a/IsoLib/libisomediafile/src/MP4SLPacket.c +++ b/IsoLib/libisomediafile/src/MP4SLPacket.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4SLPacket.c,v 1.2 2002/10/01 12:49:19 julien Exp $ + $Id: MP4SLPacket.c,v 1.2 2002/10/01 12:49:19 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" @@ -30,282 +30,298 @@ derivative works. Copyright (c) 1999. #include #include -MP4Err rewriteODFrame( MP4Track track, - MP4Handle sampleH, - u64 cts, - MP4TrackReferenceTypeAtomPtr mpod, MP4SLConfig slconfig ); +MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackReferenceTypeAtomPtr mpod, + MP4SLConfig slconfig); -MP4Err rewriteIPMPDescriptorPointers( MP4DescriptorPtr desc, - MP4TrackReferenceTypeAtomPtr mpod ); +MP4Err rewriteIPMPDescriptorPointers(MP4DescriptorPtr desc, MP4TrackReferenceTypeAtomPtr mpod); - -MP4Err rewriteODFrame( MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackReferenceTypeAtomPtr mpod, MP4SLConfig slconfig ) +MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackReferenceTypeAtomPtr mpod, + MP4SLConfig slconfig) { - MP4Err makeESD( MP4Movie theMovie, u32 trackNumber, u64 cts, MP4SLConfig slconfig, MP4DescriptorPtr *outDesc ); - MP4Err MP4ParseCommand( MP4InputStreamPtr inputStream, MP4DescriptorPtr *outDesc ); - - MP4Err err; - u32 unitSize; - MP4InputStreamPtr is; - MP4Movie theMovie; - MP4LinkedList descList; - u32 commandSize; - u32 numCmds; - char *buffer; - u32 i; - u32 j; + MP4Err makeESD(MP4Movie theMovie, u32 trackNumber, u64 cts, MP4SLConfig slconfig, + MP4DescriptorPtr * outDesc); + MP4Err MP4ParseCommand(MP4InputStreamPtr inputStream, MP4DescriptorPtr * outDesc); + + MP4Err err; + u32 unitSize; + MP4InputStreamPtr is; + MP4Movie theMovie; + MP4LinkedList descList; + u32 commandSize; + u32 numCmds; + char *buffer; + u32 i; + u32 j; + + err = MP4NoErr; + err = MP4GetHandleSize(sampleH, &unitSize); + if(err) goto bail; + err = MP4GetTrackMovie(track, &theMovie); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*sampleH, unitSize, &is); + if(err) goto bail; + err = MP4MakeLinkedList(&descList); + if(err) goto bail; + is->debugging = 0; + commandSize = 0; + numCmds = 0; + while(is->available > 0) + { + MP4DescriptorPtr desc; + MP4ObjectDescriptorUpdatePtr odUpdate; + MP4ESDescriptorUpdatePtr esUpdate; + u32 odCount; + u32 esCount; + + /* err = MP4ParseDescriptor( is, &desc ); if (err) goto bail; */ + err = MP4ParseCommand(is, &desc); + if(err) goto bail; + numCmds += 1; + switch(desc->tag) + { + case MP4ObjectDescriptorUpdateTag: + odUpdate = (MP4ObjectDescriptorUpdatePtr)desc; + err = MP4GetListEntryCount(odUpdate->objectDescriptors, &odCount); + if(err) goto bail; + for(i = 0; i < odCount; i++) + { + MP4ObjectDescriptorPtr od; + err = MP4GetListEntry(odUpdate->objectDescriptors, i, (char **)&od); + if(err) goto bail; + /* JB_RESO 09/02 rewrite IPMPDescriptorPointers if needed */ + err = rewriteIPMPDescriptorPointers((MP4DescriptorPtr)od, mpod); + if(err) goto bail; + + err = MP4GetListEntryCount(od->ES_ID_RefDescriptors, &esCount); + if(err) goto bail; + for(j = 0; j < esCount; j++) + { + MP4ES_ID_RefDescriptorPtr ref; + MP4DescriptorPtr esd; + int trackNumber; + err = MP4GetListEntry(od->ES_ID_RefDescriptors, j, (char **)&ref); + if(err) goto bail; + if(ref->refIndex > mpod->trackIDCount) BAILWITHERROR(MP4InvalidMediaErr); + trackNumber = mpod->trackIDs[ref->refIndex - 1]; + err = makeESD(theMovie, trackNumber, cts, slconfig, &esd); + if(err) goto bail; + /* JB_RESO 09/02 rewrite IPMPDescriptorPointers if needed */ + err = rewriteIPMPDescriptorPointers((MP4DescriptorPtr)esd, mpod); + if(err) goto bail; + err = od->addDescriptor((MP4DescriptorPtr)od, esd); + if(err) goto bail; + } + /* --awm to avoid putting the ES_ID_Ref descriptors in the output */ + DESTROY_DESCRIPTOR_LIST_V(od->ES_ID_RefDescriptors); + od->ES_ID_RefDescriptors = NULL; + } + break; + + case MP4ESDescriptorUpdateTag: + esUpdate = (MP4ESDescriptorUpdatePtr)desc; + err = MP4GetListEntryCount(esUpdate->ES_ID_RefDescriptors, &esCount); + if(err) goto bail; + for(j = 0; j < esCount; j++) + { + MP4ES_ID_RefDescriptorPtr ref; + MP4DescriptorPtr esd; + int trackNumber; + err = MP4GetListEntry(esUpdate->ES_ID_RefDescriptors, j, (char **)&ref); + if(err) goto bail; + if(ref->refIndex > mpod->trackIDCount) BAILWITHERROR(MP4InvalidMediaErr); + trackNumber = mpod->trackIDs[ref->refIndex - 1]; + err = makeESD(theMovie, trackNumber, cts, slconfig, &esd); + if(err) goto bail; + /* JB_RESO 09/02 rewrite IPMPDescriptorPointers if needed */ + err = rewriteIPMPDescriptorPointers((MP4DescriptorPtr)esd, mpod); + if(err) goto bail; + err = esUpdate->addDescriptor((MP4DescriptorPtr)esUpdate, esd); + if(err) goto bail; + } + /* --awm to avoid putting the ES_ID_Ref descriptors in the output */ + DESTROY_DESCRIPTOR_LIST_V(esUpdate->ES_ID_RefDescriptors); + esUpdate->ES_ID_RefDescriptors = NULL; + break; + + default: + break; + } + err = MP4AddListEntry(desc, descList); + if(err) goto bail; + err = desc->calculateSize(desc); + if(err) goto bail; + commandSize += desc->size; + } - err = MP4NoErr; - err = MP4GetHandleSize( sampleH, &unitSize ); if (err) goto bail; - err = MP4GetTrackMovie( track, &theMovie ); if (err) goto bail; - err = MP4CreateMemoryInputStream( *sampleH, unitSize, &is ); if (err) goto bail; - err = MP4MakeLinkedList( &descList ); if (err) goto bail; - is->debugging = 0; - commandSize = 0; - numCmds = 0; - while ( is->available > 0 ) - { - MP4DescriptorPtr desc; - MP4ObjectDescriptorUpdatePtr odUpdate; - MP4ESDescriptorUpdatePtr esUpdate; - u32 odCount; - u32 esCount; - - /* err = MP4ParseDescriptor( is, &desc ); if (err) goto bail; */ - err = MP4ParseCommand( is, &desc ); if (err) goto bail; - numCmds += 1; - switch ( desc->tag ) - { - case MP4ObjectDescriptorUpdateTag: - odUpdate = (MP4ObjectDescriptorUpdatePtr) desc; - err = MP4GetListEntryCount( odUpdate->objectDescriptors, &odCount ); if (err) goto bail; - for ( i = 0; i < odCount; i++ ) - { - MP4ObjectDescriptorPtr od; - err = MP4GetListEntry( odUpdate->objectDescriptors, i, (char **) &od ); if (err) goto bail; - /* JB_RESO 09/02 rewrite IPMPDescriptorPointers if needed */ - err = rewriteIPMPDescriptorPointers( (MP4DescriptorPtr) od, - mpod ); if (err) goto bail; + err = MP4SetHandleSize(sampleH, commandSize); + if(err) goto bail; + buffer = *sampleH; - err = MP4GetListEntryCount( od->ES_ID_RefDescriptors, &esCount ); if (err) goto bail; - for( j = 0; j < esCount; j++ ) - { - MP4ES_ID_RefDescriptorPtr ref; - MP4DescriptorPtr esd; - int trackNumber; - err = MP4GetListEntry( od->ES_ID_RefDescriptors, j, (char**) &ref ); if (err) goto bail; - if ( ref->refIndex > mpod->trackIDCount ) - BAILWITHERROR( MP4InvalidMediaErr ); - trackNumber = mpod->trackIDs[ ref->refIndex - 1 ]; - err = makeESD( theMovie, trackNumber, cts, slconfig, &esd ); if (err) goto bail; - /* JB_RESO 09/02 rewrite IPMPDescriptorPointers if needed */ - err = rewriteIPMPDescriptorPointers( (MP4DescriptorPtr) esd, - mpod ); if (err) goto bail; - err = od->addDescriptor( (MP4DescriptorPtr) od, esd ); if (err) goto bail; - } - /* --awm to avoid putting the ES_ID_Ref descriptors in the output */ - DESTROY_DESCRIPTOR_LIST_V( od->ES_ID_RefDescriptors ); - od->ES_ID_RefDescriptors = NULL; - } - break; - - case MP4ESDescriptorUpdateTag: - esUpdate = (MP4ESDescriptorUpdatePtr) desc; - err = MP4GetListEntryCount( esUpdate->ES_ID_RefDescriptors, &esCount ); if (err) goto bail; - for( j = 0; j < esCount; j++ ) - { - MP4ES_ID_RefDescriptorPtr ref; - MP4DescriptorPtr esd; - int trackNumber; - err = MP4GetListEntry( esUpdate->ES_ID_RefDescriptors, j, (char **) &ref ); if (err) goto bail; - if ( ref->refIndex > mpod->trackIDCount ) - BAILWITHERROR( MP4InvalidMediaErr ); - trackNumber = mpod->trackIDs[ ref->refIndex - 1 ]; - err = makeESD( theMovie, trackNumber, cts, slconfig, &esd ); if (err) goto bail; - /* JB_RESO 09/02 rewrite IPMPDescriptorPointers if needed */ - err = rewriteIPMPDescriptorPointers( (MP4DescriptorPtr) esd, - mpod ); if (err) goto bail; - err = esUpdate->addDescriptor( (MP4DescriptorPtr) esUpdate, esd ); if (err) goto bail; - } - /* --awm to avoid putting the ES_ID_Ref descriptors in the output */ - DESTROY_DESCRIPTOR_LIST_V( esUpdate->ES_ID_RefDescriptors ); - esUpdate->ES_ID_RefDescriptors = NULL; - break; - - default: - break; - } - err = MP4AddListEntry( desc, descList ); if (err) goto bail; - err = desc->calculateSize( desc ); if (err) goto bail; - commandSize += desc->size; - } + for(i = 0; i < numCmds; i++) + { + MP4DescriptorPtr desc; + err = MP4GetListEntry(descList, i, (char **)&desc); + if(err) goto bail; + err = desc->serialize(desc, buffer); + if(err) goto bail; + buffer += desc->size; + } - err = MP4SetHandleSize( sampleH, commandSize ); if (err) goto bail; - buffer = *sampleH; - - for ( i = 0; i < numCmds; i++ ) - { - MP4DescriptorPtr desc; - err = MP4GetListEntry( descList, i, (char **) &desc ); if (err) goto bail; - err = desc->serialize( desc, buffer ); if (err) goto bail; - buffer += desc->size; - } - - /* MP4DeleteLinkedList( descList ); */ - /* Just deleting the list still leaves the allocated descriptors hanging around -- dws */ - DESTROY_DESCRIPTOR_LIST_V( descList ); + /* MP4DeleteLinkedList( descList ); */ + /* Just deleting the list still leaves the allocated descriptors hanging around -- dws */ + DESTROY_DESCRIPTOR_LIST_V(descList); bail: - if (is) { - is->destroy( is ); - is = NULL; - } - TEST_RETURN( err ); + if(is) + { + is->destroy(is); + is = NULL; + } + TEST_RETURN(err); - return err; + return err; } -static void put32( u32 val, char *buf ) +static void put32(u32 val, char *buf) { - buf[3] = val & 0xFF; - buf[2] = (val >> 8) & 0xFF; - buf[1] = (val >> 16) & 0xFF; - buf[0] = (val >> 24) & 0xFF; + buf[3] = val & 0xFF; + buf[2] = (val >> 8) & 0xFF; + buf[1] = (val >> 16) & 0xFF; + buf[0] = (val >> 24) & 0xFF; } -MP4_EXTERN ( MP4Err ) -MP4GetElementaryStreamPacket( MP4Media theMedia, MP4Handle outPacket, u32 *outSize, - u32 sequenceNumber, u64 desiredDecodingTime, u64 *outActualTime, u64 *outDuration ) +MP4_EXTERN(MP4Err) +MP4GetElementaryStreamPacket(MP4Media theMedia, MP4Handle outPacket, u32 *outSize, + u32 sequenceNumber, u64 desiredDecodingTime, u64 *outActualTime, + u64 *outDuration) { - MP4Err err; - MP4Handle sampleH; - u32 sampleSize; - u32 sampleFlags; - u32 packetSize; - u32 handlerType; - MP4Track track; - char header[ 40 ]; - u32 headerBytes; - u8 val; - u32 cts; - u32 dts; - u64 sampleCTS; + MP4Err err; + MP4Handle sampleH; + u32 sampleSize; + u32 sampleFlags; + u32 packetSize; + u32 handlerType; + MP4Track track; + char header[40]; + u32 headerBytes; + u8 val; + u32 cts; + u32 dts; + u64 sampleCTS; - err = MP4NoErr; - err = MP4NewHandle( 4096, &sampleH ); if (err) goto bail; - err = MP4GetMediaTrack( theMedia, &track ); if (err) goto bail; + err = MP4NoErr; + err = MP4NewHandle(4096, &sampleH); + if(err) goto bail; + err = MP4GetMediaTrack(theMedia, &track); + if(err) goto bail; - /* first get the sample */ - err = MP4GetMediaSample( theMedia, sampleH, &sampleSize, - desiredDecodingTime, outActualTime, &sampleCTS, outDuration, - NULL, NULL, &sampleFlags ); if (err) goto bail; - - /* if OD stream, rewrite media */ - err = MP4GetMediaHandlerDescription( theMedia, &handlerType, NULL ); if (err) goto bail; + /* first get the sample */ + err = MP4GetMediaSample(theMedia, sampleH, &sampleSize, desiredDecodingTime, outActualTime, + &sampleCTS, outDuration, NULL, NULL, &sampleFlags); + if(err) goto bail; - if ( handlerType == MP4ClockReferenceHandlerType ) - BAILWITHERROR( MP4NotImplementedErr ) + /* if OD stream, rewrite media */ + err = MP4GetMediaHandlerDescription(theMedia, &handlerType, NULL); + if(err) goto bail; - if ( handlerType == MP4ObjectDescriptorHandlerType ) - { - MP4TrackReferenceTypeAtomPtr mpod; + if(handlerType == MP4ClockReferenceHandlerType) BAILWITHERROR(MP4NotImplementedErr) - err = MP4GetTrackReferenceType( track, MP4ODTrackReferenceAtomType, &mpod ); if (err) goto bail; - if ( mpod ) - { - u32 sz; - err = rewriteODFrame( track, sampleH, *outActualTime, mpod, 0 ); if (err) goto bail; - err = MP4GetHandleSize( sampleH, &sz ); if (err) goto bail; - sampleSize = sz; - } - } + if(handlerType == MP4ObjectDescriptorHandlerType) + { + MP4TrackReferenceTypeAtomPtr mpod; - /* make packet header */ - dts = (u32) (*outActualTime & 0xFFFFFFFF); - cts = (u32) (sampleCTS & 0xFFFFFFFF); - - /* note that we hardwire seqnum to 5 bits */ - val = (sequenceNumber & 0x1F) << 3; - if ( (sampleFlags & MP4MediaSampleNotSync) == 0 ) - val |= (1 << 2); - if ( sampleFlags & MP4MediaSampleHasCTSOffset ) - val |= (1 << 1); - val |= 1; /* we always have CTS */ - headerBytes = 0; - header[ headerBytes++ ] = val; + err = MP4GetTrackReferenceType(track, MP4ODTrackReferenceAtomType, &mpod); + if(err) goto bail; + if(mpod) + { + u32 sz; + err = rewriteODFrame(track, sampleH, *outActualTime, mpod, 0); + if(err) goto bail; + err = MP4GetHandleSize(sampleH, &sz); + if(err) goto bail; + sampleSize = sz; + } + } + + /* make packet header */ + dts = (u32)(*outActualTime & 0xFFFFFFFF); + cts = (u32)(sampleCTS & 0xFFFFFFFF); - if ( sampleFlags & MP4MediaSampleHasCTSOffset ) - { - put32( dts, header + headerBytes ); - headerBytes += 4; - } - put32( cts, header + headerBytes ); - headerBytes += 4; - put32( sampleSize, header + headerBytes ); - headerBytes += 4; + /* note that we hardwire seqnum to 5 bits */ + val = (sequenceNumber & 0x1F) << 3; + if((sampleFlags & MP4MediaSampleNotSync) == 0) val |= (1 << 2); + if(sampleFlags & MP4MediaSampleHasCTSOffset) val |= (1 << 1); + val |= 1; /* we always have CTS */ + headerBytes = 0; + header[headerBytes++] = val; - /* size output handle */ - packetSize = sampleSize + headerBytes; - err = MP4SetHandleSize( outPacket, packetSize ); if (err) goto bail; + if(sampleFlags & MP4MediaSampleHasCTSOffset) + { + put32(dts, header + headerBytes); + headerBytes += 4; + } + put32(cts, header + headerBytes); + headerBytes += 4; + put32(sampleSize, header + headerBytes); + headerBytes += 4; - /* copy header and sample into output handle */ - memcpy( *outPacket, header, headerBytes ); - memcpy( *outPacket + headerBytes, *sampleH, sampleSize ); - *outSize = packetSize; - MP4DisposeHandle( sampleH ); + /* size output handle */ + packetSize = sampleSize + headerBytes; + err = MP4SetHandleSize(outPacket, packetSize); + if(err) goto bail; + + /* copy header and sample into output handle */ + memcpy(*outPacket, header, headerBytes); + memcpy(*outPacket + headerBytes, *sampleH, sampleSize); + *outSize = packetSize; + MP4DisposeHandle(sampleH); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - if ( err ) - { - if ( sampleH ) - MP4DisposeHandle( sampleH ); - } - return err; + if(err) + { + if(sampleH) MP4DisposeHandle(sampleH); + } + return err; } /** -* JB_RESO 09/02 rewrite the IPMPDescriptorPointers -*/ -MP4Err rewriteIPMPDescriptorPointers( MP4DescriptorPtr desc, - MP4TrackReferenceTypeAtomPtr mpod ) + * JB_RESO 09/02 rewrite the IPMPDescriptorPointers + */ +MP4Err rewriteIPMPDescriptorPointers(MP4DescriptorPtr desc, MP4TrackReferenceTypeAtomPtr mpod) { - u32 k; - u32 ipmpDescPointersCount; - MP4Err err; - MP4LinkedList ipmpDescPointersList; + u32 k; + u32 ipmpDescPointersCount; + MP4Err err; + MP4LinkedList ipmpDescPointersList; - err = MP4NoErr; - /* if ( desc->name == "MP4ES_Descriptor" ) fb_reso */ - if ( desc->tag == MP4ES_DescriptorTag ) /* fb_reso */ - { - ipmpDescPointersList = ((MP4ES_DescriptorPtr) desc)->IPMPDescriptorPointers; - } - /* else if ( desc->name = "MP4ObjectDescriptor" ) fb_reso */ - else if ( desc->tag == MP4ObjectDescriptorTag ) /* fb_reso */ - { - ipmpDescPointersList = ((MP4ObjectDescriptorPtr) desc)->IPMPDescriptorPointers; - } - else - BAILWITHERROR( MP4BadParamErr ); + err = MP4NoErr; + /* if ( desc->name == "MP4ES_Descriptor" ) fb_reso */ + if(desc->tag == MP4ES_DescriptorTag) /* fb_reso */ + { + ipmpDescPointersList = ((MP4ES_DescriptorPtr)desc)->IPMPDescriptorPointers; + } + /* else if ( desc->name = "MP4ObjectDescriptor" ) fb_reso */ + else if(desc->tag == MP4ObjectDescriptorTag) /* fb_reso */ + { + ipmpDescPointersList = ((MP4ObjectDescriptorPtr)desc)->IPMPDescriptorPointers; + } + else + BAILWITHERROR(MP4BadParamErr); - err = MP4GetListEntryCount( ipmpDescPointersList, - &ipmpDescPointersCount ); if (err) goto bail; - for ( k = 0; k < ipmpDescPointersCount; k++ ) + err = MP4GetListEntryCount(ipmpDescPointersList, &ipmpDescPointersCount); + if(err) goto bail; + for(k = 0; k < ipmpDescPointersCount; k++) + { + MP4IPMPDescriptorPointerPtr ipmpDescPtr; + err = MP4GetListEntry(ipmpDescPointersList, k, (char **)&ipmpDescPtr); + if(err) goto bail; + if((ipmpDescPtr->ipmpEsId != 0) || (ipmpDescPtr->ipmpEsId != 0xFFFF)) { - MP4IPMPDescriptorPointerPtr ipmpDescPtr; - err = MP4GetListEntry( ipmpDescPointersList, - k, - (char **) &ipmpDescPtr ); if (err) goto bail; - if ( (ipmpDescPtr->ipmpEsId != 0) - || (ipmpDescPtr->ipmpEsId != 0xFFFF) ) - { - /* rewrite the good ID */ - ipmpDescPtr->ipmpEsId - = mpod->trackIDs[ ipmpDescPtr->ipmpEsId - 1 ]; - } + /* rewrite the good ID */ + ipmpDescPtr->ipmpEsId = mpod->trackIDs[ipmpDescPtr->ipmpEsId - 1]; } + } bail: - return err; + return err; } - diff --git a/IsoLib/libisomediafile/src/MP4TrackReader.c b/IsoLib/libisomediafile/src/MP4TrackReader.c index c6ecd06..3f6cbf4 100644 --- a/IsoLib/libisomediafile/src/MP4TrackReader.c +++ b/IsoLib/libisomediafile/src/MP4TrackReader.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,212 +15,214 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4TrackReader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4TrackReader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4TrackReader.h" #include "MP4Impl.h" #include -MP4Err MP4CreateOrdinaryTrackReader( MP4Movie theMovie, MP4Track theTrack, MP4TrackReaderPtr *outReader ); -MP4Err MP4CreateODTrackReader( MP4Movie theMovie, MP4Track theTrack, MP4TrackReaderPtr *outReader ); +MP4Err MP4CreateOrdinaryTrackReader(MP4Movie theMovie, MP4Track theTrack, + MP4TrackReaderPtr *outReader); +MP4Err MP4CreateODTrackReader(MP4Movie theMovie, MP4Track theTrack, MP4TrackReaderPtr *outReader); /* Guido : inserted to clean-up resources */ -MP4Err MP4DisposeOrdinaryTrackReader( MP4TrackReaderPtr theReader ); +MP4Err MP4DisposeOrdinaryTrackReader(MP4TrackReaderPtr theReader); -MP4_EXTERN ( MP4Err ) -MP4CreateTrackReader( MP4Track theTrack, MP4TrackReader *outReader ) +MP4_EXTERN(MP4Err) +MP4CreateTrackReader(MP4Track theTrack, MP4TrackReader *outReader) { - MP4Err err; - MP4Movie theMovie; - MP4Media theMedia; - u32 handlerType; - MP4TrackReaderPtr reader; - err = MP4NoErr; - if ( (theTrack == 0) || (outReader == 0) ) - BAILWITHERROR( MP4BadParamErr ) - err = MP4GetTrackMovie( theTrack, &theMovie ); if (err) goto bail; - err = MP4GetTrackMedia( theTrack, &theMedia ); if (err) goto bail; - err = MP4GetMediaHandlerDescription( theMedia, &handlerType, NULL ); if (err) goto bail; - switch ( handlerType ) - { - case MP4ObjectDescriptorHandlerType: - err = MP4CreateODTrackReader( theMovie, theTrack, &reader ); if (err) goto bail; - break; - - default: - err = MP4CreateOrdinaryTrackReader( theMovie, theTrack, &reader ); if (err) goto bail; - break; - } - *outReader = (MP4TrackReader) reader; + MP4Err err; + MP4Movie theMovie; + MP4Media theMedia; + u32 handlerType; + MP4TrackReaderPtr reader; + err = MP4NoErr; + if((theTrack == 0) || (outReader == 0)) BAILWITHERROR(MP4BadParamErr) + err = MP4GetTrackMovie(theTrack, &theMovie); + if(err) goto bail; + err = MP4GetTrackMedia(theTrack, &theMedia); + if(err) goto bail; + err = MP4GetMediaHandlerDescription(theMedia, &handlerType, NULL); + if(err) goto bail; + switch(handlerType) + { + case MP4ObjectDescriptorHandlerType: + err = MP4CreateODTrackReader(theMovie, theTrack, &reader); + if(err) goto bail; + break; + + default: + err = MP4CreateOrdinaryTrackReader(theMovie, theTrack, &reader); + if(err) goto bail; + break; + } + *outReader = (MP4TrackReader)reader; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetCurrentDecoderConfig( MP4TrackReader theReader, MP4Handle decoderConfigH ) +MP4_EXTERN(MP4Err) +MP4TrackReaderGetCurrentDecoderConfig(MP4TrackReader theReader, MP4Handle decoderConfigH) { - MP4Err err = MP4NoErr; - MP4TrackReaderPtr reader; + MP4Err err = MP4NoErr; + MP4TrackReaderPtr reader; - if ( (theReader == 0) || (decoderConfigH == 0) ) - BAILWITHERROR( MP4BadParamErr ) - reader = (MP4TrackReaderPtr) theReader; - err = MP4GetMediaDecoderConfig( reader->media, reader->sampleDescIndex, decoderConfigH ); if (err) goto bail; + if((theReader == 0) || (decoderConfigH == 0)) BAILWITHERROR(MP4BadParamErr) + reader = (MP4TrackReaderPtr)theReader; + err = MP4GetMediaDecoderConfig(reader->media, reader->sampleDescIndex, decoderConfigH); + if(err) goto bail; bail: - assert( (err == 0) || (err == MP4EOF) ); - return err; + assert((err == 0) || (err == MP4EOF)); + return err; } -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetCurrentSampleDescription( MP4TrackReader theReader, MP4Handle sampleEntryH ) +MP4_EXTERN(MP4Err) +MP4TrackReaderGetCurrentSampleDescription(MP4TrackReader theReader, MP4Handle sampleEntryH) { - MP4Err err; - MP4TrackReaderPtr reader; - - err = MP4NoErr; - if ( (theReader == 0) || (sampleEntryH == 0) ) - BAILWITHERROR( MP4BadParamErr ) - reader = (MP4TrackReaderPtr) theReader; - err = MP4GetMediaSampleDescription( reader->media, reader->sampleDescIndex, sampleEntryH, NULL ); if (err) goto bail; + MP4Err err; + MP4TrackReaderPtr reader; + + err = MP4NoErr; + if((theReader == 0) || (sampleEntryH == 0)) BAILWITHERROR(MP4BadParamErr) + reader = (MP4TrackReaderPtr)theReader; + err = MP4GetMediaSampleDescription(reader->media, reader->sampleDescIndex, sampleEntryH, NULL); + if(err) goto bail; bail: - assert( (err == 0) || (err == MP4EOF) ); - return err; + assert((err == 0) || (err == MP4EOF)); + return err; } -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetCurrentSampleDescriptionIndex( MP4TrackReader theReader, u32 *index ) +MP4_EXTERN(MP4Err) +MP4TrackReaderGetCurrentSampleDescriptionIndex(MP4TrackReader theReader, u32 *index) { - MP4Err err; - MP4TrackReaderPtr reader; - - err = MP4NoErr; - if ( (theReader == 0) ) - BAILWITHERROR( MP4BadParamErr ) - reader = (MP4TrackReaderPtr) theReader; - *index = reader->sampleDescIndex; + MP4Err err; + MP4TrackReaderPtr reader; + + err = MP4NoErr; + if((theReader == 0)) BAILWITHERROR(MP4BadParamErr) + reader = (MP4TrackReaderPtr)theReader; + *index = reader->sampleDescIndex; bail: - assert( (err == 0) || (err == MP4EOF) ); - return err; + assert((err == 0) || (err == MP4EOF)); + return err; } -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetNextAccessUnit( MP4TrackReader theReader, MP4Handle outAccessUnit, - u32 *outSize, u32 *outSampleFlags, - s32 *outCTS, s32 *outDTS ) +MP4_EXTERN(MP4Err) +MP4TrackReaderGetNextAccessUnit(MP4TrackReader theReader, MP4Handle outAccessUnit, u32 *outSize, + u32 *outSampleFlags, s32 *outCTS, s32 *outDTS) { - return MP4TrackReaderGetNextAccessUnitWithDuration( theReader, outAccessUnit, outSize, - outSampleFlags, outCTS, outDTS, 0 ); + return MP4TrackReaderGetNextAccessUnitWithDuration(theReader, outAccessUnit, outSize, + outSampleFlags, outCTS, outDTS, 0); } -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetNextAccessUnitWithDuration( MP4TrackReader theReader, MP4Handle outAccessUnit, - u32 *outSize, u32 *outSampleFlags, - s32 *outCTS, s32 *outDTS, u32 *outDuration ) +MP4_EXTERN(MP4Err) +MP4TrackReaderGetNextAccessUnitWithDuration(MP4TrackReader theReader, MP4Handle outAccessUnit, + u32 *outSize, u32 *outSampleFlags, s32 *outCTS, + s32 *outDTS, u32 *outDuration) { - MP4Err err; - MP4TrackReaderPtr reader; - - err = MP4NoErr; - if ( (theReader == 0) || (outAccessUnit == 0) ) - BAILWITHERROR( MP4BadParamErr ) - reader = (MP4TrackReaderPtr) theReader; - *outSize = 0; - err = reader->getNextAccessUnit( reader, outAccessUnit, outSize, - outSampleFlags, outCTS, outDTS, outDuration, 0 ); if (err) goto bail; + MP4Err err; + MP4TrackReaderPtr reader; + + err = MP4NoErr; + if((theReader == 0) || (outAccessUnit == 0)) BAILWITHERROR(MP4BadParamErr) + reader = (MP4TrackReaderPtr)theReader; + *outSize = 0; + err = reader->getNextAccessUnit(reader, outAccessUnit, outSize, outSampleFlags, outCTS, outDTS, + outDuration, 0); + if(err) goto bail; bail: - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetNextAccessUnitWithPad( MP4TrackReader theReader, MP4Handle outAccessUnit, - u32 *outSize, u32 *outSampleFlags, - s32 *outCTS, s32 *outDTS, u8 *outPad ) +MP4_EXTERN(MP4Err) +MP4TrackReaderGetNextAccessUnitWithPad(MP4TrackReader theReader, MP4Handle outAccessUnit, + u32 *outSize, u32 *outSampleFlags, s32 *outCTS, s32 *outDTS, + u8 *outPad) { - MP4Err err; - MP4TrackReaderPtr reader; - - err = MP4NoErr; - if ( (theReader == 0) || (outAccessUnit == 0) ) - BAILWITHERROR( MP4BadParamErr ) - reader = (MP4TrackReaderPtr) theReader; - *outSize = 0; - err = reader->getNextAccessUnit( reader, outAccessUnit, outSize, - outSampleFlags, outCTS, outDTS, 0, outPad ); if (err) goto bail; + MP4Err err; + MP4TrackReaderPtr reader; + + err = MP4NoErr; + if((theReader == 0) || (outAccessUnit == 0)) BAILWITHERROR(MP4BadParamErr) + reader = (MP4TrackReaderPtr)theReader; + *outSize = 0; + err = reader->getNextAccessUnit(reader, outAccessUnit, outSize, outSampleFlags, outCTS, outDTS, 0, + outPad); + if(err) goto bail; bail: - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4TrackReaderSetSLConfig( MP4TrackReader theReader, MP4SLConfig slConfig ) +MP4_EXTERN(MP4Err) +MP4TrackReaderSetSLConfig(MP4TrackReader theReader, MP4SLConfig slConfig) { - MP4Err err; - MP4TrackReaderPtr reader; - - err = MP4NoErr; - if ( (theReader == 0) || (slConfig == 0) ) - BAILWITHERROR( MP4BadParamErr ) - reader = (MP4TrackReaderPtr) theReader; - err = reader->setSLConfig( reader, slConfig ); if (err) goto bail; + MP4Err err; + MP4TrackReaderPtr reader; + + err = MP4NoErr; + if((theReader == 0) || (slConfig == 0)) BAILWITHERROR(MP4BadParamErr) + reader = (MP4TrackReaderPtr)theReader; + err = reader->setSLConfig(reader, slConfig); + if(err) goto bail; bail: - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetNextPacket( MP4TrackReader theReader, MP4Handle outSample, u32 *outSize ) +MP4_EXTERN(MP4Err) +MP4TrackReaderGetNextPacket(MP4TrackReader theReader, MP4Handle outSample, u32 *outSize) { - MP4Err err; - MP4TrackReaderPtr reader; - - err = MP4NoErr; - if ( (theReader == 0) || (outSample == 0) ) - BAILWITHERROR( MP4BadParamErr ) - reader = (MP4TrackReaderPtr) theReader; - *outSize = 0; - err = reader->getNextPacket( reader, outSample, outSize ); if (err) goto bail; + MP4Err err; + MP4TrackReaderPtr reader; + + err = MP4NoErr; + if((theReader == 0) || (outSample == 0)) BAILWITHERROR(MP4BadParamErr) + reader = (MP4TrackReaderPtr)theReader; + *outSize = 0; + err = reader->getNextPacket(reader, outSample, outSize); + if(err) goto bail; bail: - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4TrackReaderGetCurrentSampleNumber( MP4TrackReader theReader, u32 *sampleNumber ) +MP4_EXTERN(MP4Err) +MP4TrackReaderGetCurrentSampleNumber(MP4TrackReader theReader, u32 *sampleNumber) { - MP4Err err; - MP4TrackReaderPtr reader; - - err = MP4NoErr; - if ( (theReader == 0) || (sampleNumber == 0) ) - BAILWITHERROR( MP4BadParamErr ) - reader = (MP4TrackReaderPtr) theReader; - *sampleNumber = reader->currentSampleNumber; - + MP4Err err; + MP4TrackReaderPtr reader; + + err = MP4NoErr; + if((theReader == 0) || (sampleNumber == 0)) BAILWITHERROR(MP4BadParamErr) + reader = (MP4TrackReaderPtr)theReader; + *sampleNumber = reader->currentSampleNumber; + bail: - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4DisposeTrackReader( MP4TrackReader theReader ) +MP4_EXTERN(MP4Err) +MP4DisposeTrackReader(MP4TrackReader theReader) { - MP4Err err; - MP4TrackReaderPtr reader; - - err = MP4NoErr; - if ( theReader == 0 ) - BAILWITHERROR( MP4BadParamErr ) - reader = (MP4TrackReaderPtr) theReader; -/* Guido : inserted to clean-up resources */ - err = MP4DisposeOrdinaryTrackReader( reader ); if (err) goto bail; - err = reader->destroy( reader ); if (err) goto bail; + MP4Err err; + MP4TrackReaderPtr reader; + + err = MP4NoErr; + if(theReader == 0) BAILWITHERROR(MP4BadParamErr) + reader = (MP4TrackReaderPtr)theReader; + /* Guido : inserted to clean-up resources */ + err = MP4DisposeOrdinaryTrackReader(reader); + if(err) goto bail; + err = reader->destroy(reader); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; - + return err; } diff --git a/IsoLib/libisomediafile/src/MP4TrackReader.h b/IsoLib/libisomediafile/src/MP4TrackReader.h index 1a89510..b8de546 100644 --- a/IsoLib/libisomediafile/src/MP4TrackReader.h +++ b/IsoLib/libisomediafile/src/MP4TrackReader.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,51 +15,54 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4TrackReader.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4TrackReader.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #ifndef INCLUDED_MP4_TRACK_READER_H #define INCLUDED_MP4_TRACK_READER_H #include "MP4Atoms.h" -#define TRACK_READER_ENTRIES \ - MP4Err (*destroy)( struct MP4TrackReaderStruct* self ); \ - MP4Err (*getNextAccessUnit)( struct MP4TrackReaderStruct* self, MP4Handle outAccessUnit, u32 *outSize, u32 *outSampleFlags, s32 *outCTS, s32 *outDTS, u32 *outDuration, u8* outPad ); \ - MP4Err (*getNextPacket)( struct MP4TrackReaderStruct* self, MP4Handle outSample, u32 *outSize ); \ - MP4Err (*setSLConfig)( struct MP4TrackReaderStruct* self, MP4SLConfig slconfig ); \ - MP4Movie movie; \ - MP4Track track; \ - MP4Media media; \ - MP4Handle sampleH; \ - MP4SLConfig slconfig; \ - MP4EditListAtomPtr elst; \ - u32 movieTimeScale; \ - u32 mediaTimeScale; \ - u32 trackSegments; \ - u32 nextSegment; \ - u64 segmentEndTime; \ - u64 segmentMovieTime; \ - s64 segmentMediaTime; \ - u64 segmentBeginTime; \ - u32 sequenceNumber; \ - u32 segmentSampleCount; \ - u32 sampleDescIndex; \ - u32 currentSampleNumber; \ - u32 nextSampleNumber; +#define TRACK_READER_ENTRIES \ + MP4Err (*destroy)(struct MP4TrackReaderStruct * self); \ + MP4Err (*getNextAccessUnit)(struct MP4TrackReaderStruct * self, MP4Handle outAccessUnit, \ + u32 * outSize, u32 * outSampleFlags, s32 * outCTS, s32 * outDTS, \ + u32 * outDuration, u8 * outPad); \ + MP4Err (*getNextPacket)(struct MP4TrackReaderStruct * self, MP4Handle outSample, u32 * outSize); \ + MP4Err (*setSLConfig)(struct MP4TrackReaderStruct * self, MP4SLConfig slconfig); \ + MP4Movie movie; \ + MP4Track track; \ + MP4Media media; \ + MP4Handle sampleH; \ + MP4SLConfig slconfig; \ + MP4EditListAtomPtr elst; \ + u32 movieTimeScale; \ + u32 mediaTimeScale; \ + u32 trackSegments; \ + u32 nextSegment; \ + u64 segmentEndTime; \ + u64 segmentMovieTime; \ + s64 segmentMediaTime; \ + u64 segmentBeginTime; \ + u32 sequenceNumber; \ + u32 segmentSampleCount; \ + u32 sampleDescIndex; \ + u32 currentSampleNumber; \ + u32 nextSampleNumber; typedef struct MP4TrackReaderStruct { - TRACK_READER_ENTRIES - u32 isODTrack; -} *MP4TrackReaderPtr; + TRACK_READER_ENTRIES + u32 isODTrack; +} * MP4TrackReaderPtr; -MP4Err MP4CreateODTrackReader( MP4Movie theMovie, MP4Track theTrack, MP4TrackReaderPtr *outReader ); -MP4Err MP4CreateOrdinaryTrackReader( MP4Movie theMovie, MP4Track theTrack, MP4TrackReaderPtr *outReader ); -MP4Err MP4DisposeOrdinaryTrackReader( MP4TrackReaderPtr theReader ); +MP4Err MP4CreateODTrackReader(MP4Movie theMovie, MP4Track theTrack, MP4TrackReaderPtr *outReader); +MP4Err MP4CreateOrdinaryTrackReader(MP4Movie theMovie, MP4Track theTrack, + MP4TrackReaderPtr *outReader); +MP4Err MP4DisposeOrdinaryTrackReader(MP4TrackReaderPtr theReader); #endif diff --git a/IsoLib/libisomediafile/src/MP4UserData.c b/IsoLib/libisomediafile/src/MP4UserData.c index 4e187b7..f5f6def 100644 --- a/IsoLib/libisomediafile/src/MP4UserData.c +++ b/IsoLib/libisomediafile/src/MP4UserData.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,258 +15,278 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4UserData.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4UserData.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" #include -MP4_EXTERN ( MP4Err ) -MP4AddUserData( MP4UserData theUserData, MP4Handle dataH, u32 userDataType, u32 *outIndex ) +MP4_EXTERN(MP4Err) +MP4AddUserData(MP4UserData theUserData, MP4Handle dataH, u32 userDataType, u32 *outIndex) { - MP4Err err; - MP4UserDataAtomPtr udta; - err = MP4NoErr; - if ( (theUserData == NULL) || (dataH == NULL) || (userDataType == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - udta = (MP4UserDataAtomPtr) theUserData; - err = udta->addUserData( udta, dataH, userDataType, outIndex ); if (err) goto bail; + MP4Err err; + MP4UserDataAtomPtr udta; + err = MP4NoErr; + if((theUserData == NULL) || (dataH == NULL) || (userDataType == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + udta = (MP4UserDataAtomPtr)theUserData; + err = udta->addUserData(udta, dataH, userDataType, outIndex); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetUserDataEntryCount( MP4UserData theUserData, u32 userDataType, u32 *outCount ) +MP4_EXTERN(MP4Err) +MP4GetUserDataEntryCount(MP4UserData theUserData, u32 userDataType, u32 *outCount) { - MP4Err err; - MP4UserDataAtomPtr udta; - err = MP4NoErr; - if ( (theUserData == NULL) || (outCount == NULL) || (userDataType == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - udta = (MP4UserDataAtomPtr) theUserData; - if ( udta->getEntryCount == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = udta->getEntryCount( udta, userDataType, outCount ); if (err) goto bail; + MP4Err err; + MP4UserDataAtomPtr udta; + err = MP4NoErr; + if((theUserData == NULL) || (outCount == NULL) || (userDataType == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + udta = (MP4UserDataAtomPtr)theUserData; + if(udta->getEntryCount == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + err = udta->getEntryCount(udta, userDataType, outCount); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetIndUserDataType( MP4UserData theUserData, u32 typeIndex, u32 *outType ) +MP4_EXTERN(MP4Err) +MP4GetIndUserDataType(MP4UserData theUserData, u32 typeIndex, u32 *outType) { - MP4Err err; - MP4UserDataAtomPtr udta; - err = MP4NoErr; - if ( (theUserData == NULL) || (outType == NULL) || (typeIndex == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - udta = (MP4UserDataAtomPtr) theUserData; - if ( udta->getIndType == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = udta->getIndType( udta, typeIndex, outType ); if (err) goto bail; + MP4Err err; + MP4UserDataAtomPtr udta; + err = MP4NoErr; + if((theUserData == NULL) || (outType == NULL) || (typeIndex == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + udta = (MP4UserDataAtomPtr)theUserData; + if(udta->getIndType == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + err = udta->getIndType(udta, typeIndex, outType); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetUserDataTypeCount( MP4UserData theUserData, u32 *outCount ) +MP4_EXTERN(MP4Err) +MP4GetUserDataTypeCount(MP4UserData theUserData, u32 *outCount) { - MP4Err err; - MP4UserDataAtomPtr udta; - err = MP4NoErr; - if ( (theUserData == NULL) || (outCount == NULL) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - udta = (MP4UserDataAtomPtr) theUserData; - if ( udta->getTypeCount == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = udta->getTypeCount( udta, outCount ); if (err) goto bail; + MP4Err err; + MP4UserDataAtomPtr udta; + err = MP4NoErr; + if((theUserData == NULL) || (outCount == NULL)) + { + BAILWITHERROR(MP4BadParamErr); + } + udta = (MP4UserDataAtomPtr)theUserData; + if(udta->getTypeCount == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + err = udta->getTypeCount(udta, outCount); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetUserDataItem( MP4UserData theUserData, MP4Handle dataH, u32 userDataType, u32 itemIndex ) +MP4_EXTERN(MP4Err) +MP4GetUserDataItem(MP4UserData theUserData, MP4Handle dataH, u32 userDataType, u32 itemIndex) { - MP4Err err; - MP4UserDataAtomPtr udta; - err = MP4NoErr; - if ( (theUserData == NULL) || (dataH == NULL) || (userDataType == 0) || (itemIndex == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - udta = (MP4UserDataAtomPtr) theUserData; - if ( udta->getItem == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = udta->getItem( udta, dataH, userDataType, itemIndex ); if (err) goto bail; + MP4Err err; + MP4UserDataAtomPtr udta; + err = MP4NoErr; + if((theUserData == NULL) || (dataH == NULL) || (userDataType == 0) || (itemIndex == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + udta = (MP4UserDataAtomPtr)theUserData; + if(udta->getItem == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + err = udta->getItem(udta, dataH, userDataType, itemIndex); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetAtomFromUserData( MP4UserData theUserData, MP4GenericAtom *outAtom, u32 userDataType, u32 itemIndex ) +MP4_EXTERN(MP4Err) +MP4GetAtomFromUserData(MP4UserData theUserData, MP4GenericAtom *outAtom, u32 userDataType, + u32 itemIndex) { - MP4Err err; - MP4UserDataAtomPtr udta; - MP4AtomPtr atom; - - err = MP4NoErr; - if ( (theUserData == NULL) || (userDataType == 0) || (itemIndex == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - udta = (MP4UserDataAtomPtr) theUserData; - if ( udta->getItem == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = udta->getAtom( udta, &atom, userDataType, itemIndex ); if (err) goto bail; - - *outAtom = (MP4GenericAtom) atom; + MP4Err err; + MP4UserDataAtomPtr udta; + MP4AtomPtr atom; + + err = MP4NoErr; + if((theUserData == NULL) || (userDataType == 0) || (itemIndex == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + udta = (MP4UserDataAtomPtr)theUserData; + if(udta->getItem == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + err = udta->getAtom(udta, &atom, userDataType, itemIndex); + if(err) goto bail; + + *outAtom = (MP4GenericAtom)atom; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4DeleteUserDataItem( MP4UserData theUserData, u32 userDataType, u32 itemIndex ) +MP4_EXTERN(MP4Err) +MP4DeleteUserDataItem(MP4UserData theUserData, u32 userDataType, u32 itemIndex) { - MP4Err err; - MP4UserDataAtomPtr udta; - err = MP4NoErr; - if ( (theUserData == NULL) || (userDataType == 0) || (itemIndex == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - udta = (MP4UserDataAtomPtr) theUserData; - if ( udta->deleteItem == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = udta->deleteItem( udta, userDataType, itemIndex ); if (err) goto bail; + MP4Err err; + MP4UserDataAtomPtr udta; + err = MP4NoErr; + if((theUserData == NULL) || (userDataType == 0) || (itemIndex == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + udta = (MP4UserDataAtomPtr)theUserData; + if(udta->deleteItem == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + err = udta->deleteItem(udta, userDataType, itemIndex); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4NewUserData( MP4UserData *outUserData ) +MP4_EXTERN(MP4Err) +MP4NewUserData(MP4UserData *outUserData) { - MP4Err err; - MP4AtomPtr udta; - err = MP4NoErr; - err = MP4CreateAtom( MP4UserDataAtomType, &udta ); if (err) goto bail; - *outUserData = (MP4UserData) udta; + MP4Err err; + MP4AtomPtr udta; + err = MP4NoErr; + err = MP4CreateAtom(MP4UserDataAtomType, &udta); + if(err) goto bail; + *outUserData = (MP4UserData)udta; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4NewForeignAtom( MP4GenericAtom *outAtom, u32 atomType, MP4Handle atomPayload ) +MP4_EXTERN(MP4Err) +MP4NewForeignAtom(MP4GenericAtom *outAtom, u32 atomType, MP4Handle atomPayload) { - MP4Err err; - MP4AtomPtr the_atom; - MP4UnknownAtomPtr self; - - err = MP4NoErr; - err = MP4CreateUnknownAtom((MP4UnknownAtomPtr *) &the_atom ); if (err) goto bail; - self = (MP4UnknownAtomPtr) the_atom; - self->type = atomType; - - err = MP4GetHandleSize( atomPayload, &(self->dataSize) ); if (err) goto bail; - - self->data = (char *) malloc( self->dataSize ); - if (!(self->data)) { err = MP4NoMemoryErr; goto bail; } - memcpy( self->data, *atomPayload, self->dataSize ); - - *outAtom = (MP4GenericAtom) the_atom; + MP4Err err; + MP4AtomPtr the_atom; + MP4UnknownAtomPtr self; + + err = MP4NoErr; + err = MP4CreateUnknownAtom((MP4UnknownAtomPtr *)&the_atom); + if(err) goto bail; + self = (MP4UnknownAtomPtr)the_atom; + self->type = atomType; + + err = MP4GetHandleSize(atomPayload, &(self->dataSize)); + if(err) goto bail; + + self->data = (char *)malloc(self->dataSize); + if(!(self->data)) + { + err = MP4NoMemoryErr; + goto bail; + } + memcpy(self->data, *atomPayload, self->dataSize); + + *outAtom = (MP4GenericAtom)the_atom; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetForeignAtom( MP4GenericAtom atom, u32* atomType, u8 the_uuid[16], MP4Handle atomPayload ) +MP4_EXTERN(MP4Err) +MP4GetForeignAtom(MP4GenericAtom atom, u32 *atomType, u8 the_uuid[16], MP4Handle atomPayload) { - MP4Err err; - MP4AtomPtr the_atom; - MP4UnknownAtomPtr self; - - err = MP4NoErr; - the_atom = (MP4AtomPtr) atom; - self = (MP4UnknownAtomPtr) the_atom; - *atomType = self->type; - - err = MP4SetHandleSize( atomPayload, self->dataSize ); if (err) goto bail; - - memcpy( *atomPayload, self->data, self->dataSize ); - if ((self->type == MP4ExtendedAtomType) && the_uuid) - memcpy( the_uuid, &(self->uuid), 16 ); + MP4Err err; + MP4AtomPtr the_atom; + MP4UnknownAtomPtr self; + + err = MP4NoErr; + the_atom = (MP4AtomPtr)atom; + self = (MP4UnknownAtomPtr)the_atom; + *atomType = self->type; + + err = MP4SetHandleSize(atomPayload, self->dataSize); + if(err) goto bail; + + memcpy(*atomPayload, self->data, self->dataSize); + if((self->type == MP4ExtendedAtomType) && the_uuid) memcpy(the_uuid, &(self->uuid), 16); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) -MP4NewUUIDAtom( MP4GenericAtom *outAtom, u8 the_uuid[16], MP4Handle atomPayload ) +MP4_EXTERN(MP4Err) +MP4NewUUIDAtom(MP4GenericAtom *outAtom, u8 the_uuid[16], MP4Handle atomPayload) { - MP4Err err; - MP4AtomPtr the_atom; - MP4UnknownAtomPtr self; - - err = MP4NoErr; - err = MP4CreateAtom( MP4ExtendedAtomType, &the_atom ); if (err) goto bail; - self = (MP4UnknownAtomPtr) the_atom; - self->type = MP4ExtendedAtomType; - - err = MP4GetHandleSize( atomPayload, &(self->dataSize) ); if (err) goto bail; - - self->data = (char*) malloc( self->dataSize ); - if (!(self->data)) { err = MP4NoMemoryErr; goto bail; } - memcpy( self->data, *atomPayload, self->dataSize ); - - memcpy( &(self->uuid), the_uuid, 16 ); - - *outAtom = (MP4GenericAtom) the_atom; + MP4Err err; + MP4AtomPtr the_atom; + MP4UnknownAtomPtr self; + + err = MP4NoErr; + err = MP4CreateAtom(MP4ExtendedAtomType, &the_atom); + if(err) goto bail; + self = (MP4UnknownAtomPtr)the_atom; + self->type = MP4ExtendedAtomType; + + err = MP4GetHandleSize(atomPayload, &(self->dataSize)); + if(err) goto bail; + + self->data = (char *)malloc(self->dataSize); + if(!(self->data)) + { + err = MP4NoMemoryErr; + goto bail; + } + memcpy(self->data, *atomPayload, self->dataSize); + + memcpy(&(self->uuid), the_uuid, 16); + + *outAtom = (MP4GenericAtom)the_atom; bail: - TEST_RETURN( err ); - - return err; -} + TEST_RETURN(err); + return err; +} diff --git a/IsoLib/libisomediafile/src/MPEGMediaHeaderAtom.c b/IsoLib/libisomediafile/src/MPEGMediaHeaderAtom.c index 7fdeb86..7c29c19 100644 --- a/IsoLib/libisomediafile/src/MPEGMediaHeaderAtom.c +++ b/IsoLib/libisomediafile/src/MPEGMediaHeaderAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,96 +15,95 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MPEGMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MPEGMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4MPEGMediaHeaderAtomPtr self = (MP4MPEGMediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4MPEGMediaHeaderAtomPtr self = (MP4MPEGMediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - /*MP4MPEGMediaHeaderAtomPtr self = (MP4MPEGMediaHeaderAtomPtr) s;*/ - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; + MP4Err err; + /*MP4MPEGMediaHeaderAtomPtr self = (MP4MPEGMediaHeaderAtomPtr) s;*/ + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4MPEGMediaHeaderAtomPtr self = (MP4MPEGMediaHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; + MP4Err err; + MP4MPEGMediaHeaderAtomPtr self = (MP4MPEGMediaHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateMPEGMediaHeaderAtom( MP4MPEGMediaHeaderAtomPtr *outAtom ) +MP4Err MP4CreateMPEGMediaHeaderAtom(MP4MPEGMediaHeaderAtomPtr *outAtom) { - MP4Err err; - MP4MPEGMediaHeaderAtomPtr self; - - self = (MP4MPEGMediaHeaderAtomPtr) calloc( 1, sizeof(MP4MPEGMediaHeaderAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4MPEGMediaHeaderAtomType; - self->name = "mpeg media header"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4MPEGMediaHeaderAtomPtr self; + + self = (MP4MPEGMediaHeaderAtomPtr)calloc(1, sizeof(MP4MPEGMediaHeaderAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4MPEGMediaHeaderAtomType; + self->name = "mpeg media header"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MPEGSampleEntryAtom.c b/IsoLib/libisomediafile/src/MPEGSampleEntryAtom.c index 9592a87..82c22b4 100644 --- a/IsoLib/libisomediafile/src/MPEGSampleEntryAtom.c +++ b/IsoLib/libisomediafile/src/MPEGSampleEntryAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,107 +15,109 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MPEGSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MPEGSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4MPEGSampleEntryAtomPtr self; - err = MP4NoErr; - self = (MP4MPEGSampleEntryAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST_F( ExtensionAtomList ) - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4MPEGSampleEntryAtomPtr self; + err = MP4NoErr; + self = (MP4MPEGSampleEntryAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST_F(ExtensionAtomList) + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } - -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4MPEGSampleEntryAtomPtr self = (MP4MPEGSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( self->reserved, 6 ); - PUT16( dataReferenceIndex ); - SERIALIZE_ATOM_LIST( ExtensionAtomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4MPEGSampleEntryAtomPtr self = (MP4MPEGSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(self->reserved, 6); + PUT16(dataReferenceIndex); + SERIALIZE_ATOM_LIST(ExtensionAtomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4MPEGSampleEntryAtomPtr self = (MP4MPEGSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 8; - ADD_ATOM_LIST_SIZE( ExtensionAtomList ); + MP4Err err; + MP4MPEGSampleEntryAtomPtr self = (MP4MPEGSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 8; + ADD_ATOM_LIST_SIZE(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4MPEGSampleEntryAtomPtr self = (MP4MPEGSampleEntryAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GETBYTES( 6, reserved ); - GET16( dataReferenceIndex ); - GETATOM_LIST( ExtensionAtomList ); + MP4Err err; + MP4MPEGSampleEntryAtomPtr self = (MP4MPEGSampleEntryAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GETBYTES(6, reserved); + GET16(dataReferenceIndex); + GETATOM_LIST(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateMPEGSampleEntryAtom( MP4MPEGSampleEntryAtomPtr *outAtom ) +MP4Err MP4CreateMPEGSampleEntryAtom(MP4MPEGSampleEntryAtomPtr *outAtom) { - MP4Err err; - MP4MPEGSampleEntryAtomPtr self; - - self = (MP4MPEGSampleEntryAtomPtr) calloc( 1, sizeof(MP4MPEGSampleEntryAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4MPEGSampleEntryAtomType; - self->name = "MPEG sample entry"; - err = MP4MakeLinkedList( &self->ExtensionAtomList ); if (err) goto bail; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4MPEGSampleEntryAtomPtr self; + + self = (MP4MPEGSampleEntryAtomPtr)calloc(1, sizeof(MP4MPEGSampleEntryAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4MPEGSampleEntryAtomType; + self->name = "MPEG sample entry"; + err = MP4MakeLinkedList(&self->ExtensionAtomList); + if(err) goto bail; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MdatDataHandler.c b/IsoLib/libisomediafile/src/MdatDataHandler.c index 0eb0c3f..f6f25b4 100644 --- a/IsoLib/libisomediafile/src/MdatDataHandler.c +++ b/IsoLib/libisomediafile/src/MdatDataHandler.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MdatDataHandler.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MdatDataHandler.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Movies.h" #include "MP4Impl.h" @@ -30,75 +30,78 @@ derivative works. Copyright (c) 1999. #include #include -static MP4Err doOpen( struct MP4DataHandler * s, - struct MP4InputStreamRecord* inputStream, - MP4DataEntryAtomPtr dataEntry ) +static MP4Err doOpen(struct MP4DataHandler *s, struct MP4InputStreamRecord *inputStream, + MP4DataEntryAtomPtr dataEntry) { - u64 b; - MP4DataEntryAtomPtr d; - - b=inputStream->available; - d=dataEntry; - - if (s==NULL) return MP4BadParamErr; else return MP4NoErr; + u64 b; + MP4DataEntryAtomPtr d; + + b = inputStream->available; + d = dataEntry; + + if(s == NULL) return MP4BadParamErr; + else + return MP4NoErr; } -static MP4Err doClose( struct MP4DataHandler *s ) +static MP4Err doClose(struct MP4DataHandler *s) { - free( s ); - return MP4NoErr; + free(s); + return MP4NoErr; } -static MP4Err copyData( struct MP4DataHandler *s, u64 offset, char *dst, u32 bytes ) +static MP4Err copyData(struct MP4DataHandler *s, u64 offset, char *dst, u32 bytes) { - MP4Err err; - MP4MdatDataHandlerPtr self = (MP4MdatDataHandlerPtr) s; - - err = MP4NoErr; - if ( (self == NULL) || (self->mdat == NULL) || (self->mdat->data == NULL) - || (self->mdat->dataSize < (offset + bytes)) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - else - { - char *src = self->mdat->data; - if (offset >> 32) - { BAILWITHERROR( MP4NotImplementedErr ); } - src += offset; - memcpy( dst, src, bytes ); - } - bail: - TEST_RETURN( err ); + MP4Err err; + MP4MdatDataHandlerPtr self = (MP4MdatDataHandlerPtr)s; + + err = MP4NoErr; + if((self == NULL) || (self->mdat == NULL) || (self->mdat->data == NULL) || + (self->mdat->dataSize < (offset + bytes))) + { + BAILWITHERROR(MP4BadParamErr); + } + else + { + char *src = self->mdat->data; + if(offset >> 32) + { + BAILWITHERROR(MP4NotImplementedErr); + } + src += offset; + memcpy(dst, src, bytes); + } +bail: + TEST_RETURN(err); - return err; + return err; } -static MP4Err getDataSize( struct MP4DataHandler *s, u64* bytes ) +static MP4Err getDataSize(struct MP4DataHandler *s, u64 *bytes) { - MP4MdatDataHandlerPtr self = (MP4MdatDataHandlerPtr) s; - if ( (self == NULL) || (self->mdat == NULL) ) return MP4BadParamErr; - - *bytes = (self->mdat)->dataSize; - return MP4NoErr; + MP4MdatDataHandlerPtr self = (MP4MdatDataHandlerPtr)s; + if((self == NULL) || (self->mdat == NULL)) return MP4BadParamErr; + + *bytes = (self->mdat)->dataSize; + return MP4NoErr; } -MP4Err MP4CreateMdatDataHandler( MP4MediaDataAtomPtr mdat, MP4DataHandlerPtr *outDataHandler ) +MP4Err MP4CreateMdatDataHandler(MP4MediaDataAtomPtr mdat, MP4DataHandlerPtr *outDataHandler) { - MP4Err err; - MP4MdatDataHandlerPtr self; - - err = MP4NoErr; - self = (MP4MdatDataHandlerPtr) calloc( 1, sizeof(MP4MdatDataHandler) ); - TESTMALLOC( self ); - self->copyData = copyData; - self->mdat = mdat; - self->open = doOpen; - self->close = doClose; - self->getDataSize = getDataSize; - - *outDataHandler = (MP4DataHandlerPtr) self; - bail: - TEST_RETURN( err ); - return err; + MP4Err err; + MP4MdatDataHandlerPtr self; + + err = MP4NoErr; + self = (MP4MdatDataHandlerPtr)calloc(1, sizeof(MP4MdatDataHandler)); + TESTMALLOC(self); + self->copyData = copyData; + self->mdat = mdat; + self->open = doOpen; + self->close = doClose; + self->getDataSize = getDataSize; + + *outDataHandler = (MP4DataHandlerPtr)self; +bail: + TEST_RETURN(err); + return err; } diff --git a/IsoLib/libisomediafile/src/MdatDataHandler.h b/IsoLib/libisomediafile/src/MdatDataHandler.h index e2b22f0..2c90fd4 100644 --- a/IsoLib/libisomediafile/src/MdatDataHandler.h +++ b/IsoLib/libisomediafile/src/MdatDataHandler.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MdatDataHandler.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MdatDataHandler.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #ifndef INCLUDED_MDAT_DATAHANDLER_H #define INCLUDED_MDAT_DATAHANDLER_H @@ -32,10 +32,10 @@ derivative works. Copyright (c) 1999. typedef struct MP4MdatDataHandler { - COMMON_DATAHANDLER_FIELDS - MP4MediaDataAtomPtr mdat; + COMMON_DATAHANDLER_FIELDS + MP4MediaDataAtomPtr mdat; } MP4MdatDataHandler, *MP4MdatDataHandlerPtr; -MP4Err MP4CreateMdatDataHandler( MP4MediaDataAtomPtr mdat, MP4DataHandlerPtr *outDataHandler ); +MP4Err MP4CreateMdatDataHandler(MP4MediaDataAtomPtr mdat, MP4DataHandlerPtr *outDataHandler); #endif diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index 8a54ea4..8dcaa5b 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MediaAtom.c,v 1.2 2002/10/01 12:49:19 julien Exp $ + $Id: MediaAtom.c,v 1.2 2002/10/01 12:49:19 julien Exp $ */ #include "MP4Atoms.h" @@ -31,724 +31,778 @@ derivative works. Copyright (c) 1999. MP4Err MP4ParseODFrame(struct MP4MediaAtom *self, MP4Handle sampleH, MP4Handle sizesH); -MP4Err storeIPMPDescriptorPointers( MP4DescriptorPtr desc, - MP4TrackReferenceTypeAtomPtr mpod ); +MP4Err storeIPMPDescriptorPointers(MP4DescriptorPtr desc, MP4TrackReferenceTypeAtomPtr mpod); -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4MediaAtomPtr self; - u32 i; - err = MP4NoErr; - self = (MP4MediaAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); - bail: - TEST_RETURN( err ); - - return; + MP4Err err; + MP4MediaAtomPtr self; + u32 i; + err = MP4NoErr; + self = (MP4MediaAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); +bail: + TEST_RETURN(err); + + return; } -static MP4Err calculateDuration( struct MP4MediaAtom *self ) +static MP4Err calculateDuration(struct MP4MediaAtom *self) { - MP4Err err; - u32 mediaDuration; - MP4MediaInformationAtomPtr minf; - MP4MediaHeaderAtomPtr mdhd; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; - if ( minf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - mdhd = (MP4MediaHeaderAtomPtr) self->mediaHeader; - if ( mdhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - err = minf->getMediaDuration( minf, &mediaDuration ); if (err) goto bail; - mdhd->duration = mediaDuration; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + u32 mediaDuration; + MP4MediaInformationAtomPtr minf; + MP4MediaHeaderAtomPtr mdhd; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; + if(minf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + mdhd = (MP4MediaHeaderAtomPtr)self->mediaHeader; + if(mdhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + err = minf->getMediaDuration(minf, &mediaDuration); + if(err) goto bail; + mdhd->duration = mediaDuration; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err mdatMoved( struct MP4MediaAtom* self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) +static MP4Err mdatMoved(struct MP4MediaAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - err = MP4NoErr; - - minf = (MP4MediaInformationAtomPtr) self->information; - if ( minf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - err = minf->mdatMoved( minf, mdatBase, mdatEnd, mdatOffset ); if (err) goto bail; - bail: - TEST_RETURN( err ); - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + err = MP4NoErr; + + minf = (MP4MediaInformationAtomPtr)self->information; + if(minf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + err = minf->mdatMoved(minf, mdatBase, mdatEnd, mdatOffset); + if(err) goto bail; +bail: + TEST_RETURN(err); + return err; } -static MP4Err addAtom( MP4MediaAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4MediaAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - if ( atom == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; - switch( atom->type ) - { - case MP4MediaHeaderAtomType: - if ( self->mediaHeader ) - BAILWITHERROR( MP4BadDataErr ) - self->mediaHeader = atom; - break; - - case MP4ExtendedLanguageTagAtomType: - if ( self->extendedLanguageTag ) - BAILWITHERROR( MP4BadDataErr ) - self->extendedLanguageTag = atom; - break; - - case MP4HandlerAtomType: - if ( self->handler ) - BAILWITHERROR( MP4BadDataErr ) - self->handler = atom; - break; - - case MP4MediaInformationAtomType: - if ( self->information ) - BAILWITHERROR( MP4BadDataErr ) - self->information = atom; - break; - } - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + err = MP4NoErr; + if(atom == NULL) BAILWITHERROR(MP4BadParamErr); + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; + switch(atom->type) + { + case MP4MediaHeaderAtomType: + if(self->mediaHeader) BAILWITHERROR(MP4BadDataErr) + self->mediaHeader = atom; + break; + + case MP4ExtendedLanguageTagAtomType: + if(self->extendedLanguageTag) BAILWITHERROR(MP4BadDataErr) + self->extendedLanguageTag = atom; + break; + + case MP4HandlerAtomType: + if(self->handler) BAILWITHERROR(MP4BadDataErr) + self->handler = atom; + break; + + case MP4MediaInformationAtomType: + if(self->information) BAILWITHERROR(MP4BadDataErr) + self->information = atom; + break; + } +bail: + TEST_RETURN(err); + + return err; } -static MP4Err setupNew( struct MP4MediaAtom *self, MP4AtomPtr track, u32 mediaType, u32 timeScale, MP4Handle dataHandlerH ) +static MP4Err setupNew(struct MP4MediaAtom *self, MP4AtomPtr track, u32 mediaType, u32 timeScale, + MP4Handle dataHandlerH) { - MP4Err MP4CreateMediaHeaderAtom( MP4MediaHeaderAtomPtr *outAtom ); - MP4Err MP4CreateMediaInformationAtom( MP4MediaInformationAtomPtr *outAtom ); - MP4Err MP4CreateHandlerAtom( MP4HandlerAtomPtr *outAtom ); - void MP4TypeToString( u32 inType, char* ioStr ); - - char name[ 8 ]; - MP4Err err; - u64 currentTime; - MP4MediaHeaderAtomPtr mdhd; - MP4MediaInformationAtomPtr minf; - MP4HandlerAtomPtr hdlr; - MP4AtomPtr mdat; - - err = MP4NoErr; - self->mediaTrack = track; - mdat = ((MP4TrackAtomPtr) track)->mdat; - err = MP4CreateMediaHeaderAtom( &mdhd ); if (err) goto bail; - err = MP4CreateMediaInformationAtom( &minf ); if (err) goto bail; - err = MP4CreateHandlerAtom( &hdlr ); if (err) goto bail; - - err = MP4GetCurrentTime( ¤tTime ); if (err) goto bail; - mdhd->timeScale = timeScale; - mdhd->creationTime = currentTime; - mdhd->modificationTime = currentTime; - mdhd->packedLanguage = 21956; - - hdlr->handlerType = mediaType; - MP4TypeToString( mediaType, name ); - hdlr->setName( (MP4AtomPtr) hdlr, name, hdlr->is_qt ); - - err = minf->setupNewMedia( minf, mediaType, dataHandlerH, mdat ); - - err = addAtom( self, (MP4AtomPtr) mdhd ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) hdlr ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) minf ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err MP4CreateMediaHeaderAtom(MP4MediaHeaderAtomPtr * outAtom); + MP4Err MP4CreateMediaInformationAtom(MP4MediaInformationAtomPtr * outAtom); + MP4Err MP4CreateHandlerAtom(MP4HandlerAtomPtr * outAtom); + void MP4TypeToString(u32 inType, char *ioStr); + + char name[8]; + MP4Err err; + u64 currentTime; + MP4MediaHeaderAtomPtr mdhd; + MP4MediaInformationAtomPtr minf; + MP4HandlerAtomPtr hdlr; + MP4AtomPtr mdat; + + err = MP4NoErr; + self->mediaTrack = track; + mdat = ((MP4TrackAtomPtr)track)->mdat; + err = MP4CreateMediaHeaderAtom(&mdhd); + if(err) goto bail; + err = MP4CreateMediaInformationAtom(&minf); + if(err) goto bail; + err = MP4CreateHandlerAtom(&hdlr); + if(err) goto bail; + + err = MP4GetCurrentTime(¤tTime); + if(err) goto bail; + mdhd->timeScale = timeScale; + mdhd->creationTime = currentTime; + mdhd->modificationTime = currentTime; + mdhd->packedLanguage = 21956; + + hdlr->handlerType = mediaType; + MP4TypeToString(mediaType, name); + hdlr->setName((MP4AtomPtr)hdlr, name, hdlr->is_qt); + + err = minf->setupNewMedia(minf, mediaType, dataHandlerH, mdat); + + err = addAtom(self, (MP4AtomPtr)mdhd); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)hdlr); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)minf); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err addSampleReference( struct MP4MediaAtom *self, u64 dataOffset, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ) +static MP4Err addSampleReference(struct MP4MediaAtom *self, u64 dataOffset, u32 sampleCount, + MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, + MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, + MP4Handle padsH) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; - assert( minf ); - assert( minf->addSampleReference ); - err = minf->addSampleReference( minf, dataOffset, sampleCount, durationsH, sizesH, sampleEntryH, decodingOffsetsH, syncSamplesH, padsH ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; + assert(minf); + assert(minf->addSampleReference); + err = minf->addSampleReference(minf, dataOffset, sampleCount, durationsH, sizesH, sampleEntryH, + decodingOffsetsH, syncSamplesH, padsH); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err setfieldsize( struct MP4MediaAtom* self, u32 fieldsize ) +static MP4Err setfieldsize(struct MP4MediaAtom *self, u32 fieldsize) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; - assert( minf ); - assert( minf->setfieldsize ); - err = minf->setfieldsize( minf, fieldsize ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; + assert(minf); + assert(minf->setfieldsize); + err = minf->setfieldsize(minf, fieldsize); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err settrackfragment (struct MP4MediaAtom *self, MP4AtomPtr fragment) +static MP4Err settrackfragment(struct MP4MediaAtom *self, MP4AtomPtr fragment) { - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - MP4TrackFragmentAtomPtr traf; - - if (self->true_minf == NULL) self->true_minf = self->information; - self->information = fragment; - - minf = (MP4MediaInformationAtomPtr) self->true_minf; - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - traf = (MP4TrackFragmentAtomPtr) fragment; - - traf->useSignedCompositionTimeOffsets = stbl->useSignedCompositionTimeOffsets; - - if (stbl->SampleAuxiliaryInformationSizes->entryCount != 0) + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4TrackFragmentAtomPtr traf; + + if(self->true_minf == NULL) self->true_minf = self->information; + self->information = fragment; + + minf = (MP4MediaInformationAtomPtr)self->true_minf; + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + traf = (MP4TrackFragmentAtomPtr)fragment; + + traf->useSignedCompositionTimeOffsets = stbl->useSignedCompositionTimeOffsets; + + if(stbl->SampleAuxiliaryInformationSizes->entryCount != 0) + { + u32 i; + MP4SampleAuxiliaryInformationSizesAtomPtr saizOld; + MP4SampleAuxiliaryInformationSizesAtomPtr saizNew; + MP4SampleAuxiliaryInformationOffsetsAtomPtr saioOld; + MP4SampleAuxiliaryInformationOffsetsAtomPtr saioNew; + + for(i = 0; i < stbl->SampleAuxiliaryInformationSizes->entryCount; i++) { - u32 i; - MP4SampleAuxiliaryInformationSizesAtomPtr saizOld; - MP4SampleAuxiliaryInformationSizesAtomPtr saizNew; - MP4SampleAuxiliaryInformationOffsetsAtomPtr saioOld; - MP4SampleAuxiliaryInformationOffsetsAtomPtr saioNew; - - for (i = 0; i < stbl->SampleAuxiliaryInformationSizes->entryCount; i++) - { - MP4GetListEntry(stbl->SampleAuxiliaryInformationSizes, i, (char **) &saizOld); - MP4GetListEntry(stbl->SampleAuxiliaryInformationOffsets, i, (char **) &saioOld); - - MP4CreateSampleAuxiliaryInformationSizesAtom(&saizNew); - saizNew->aux_info_type = saizOld->aux_info_type; - saizNew->aux_info_type_parameter = saizOld->aux_info_type_parameter; - saizNew->default_sample_info_size = saizOld->default_sample_info_size; - saizNew->flags = saizOld->flags; - - MP4CreateSampleAuxiliaryInformationOffsetsAtom(&saioNew); - saioNew->aux_info_type = saioOld->aux_info_type; - saioNew->aux_info_type_parameter = saioOld->aux_info_type_parameter; - saioNew->flags = saioOld->flags; - - MP4AddListEntry(saizNew, traf->saizList); - MP4AddListEntry(saioNew, traf->saioList); - } + MP4GetListEntry(stbl->SampleAuxiliaryInformationSizes, i, (char **)&saizOld); + MP4GetListEntry(stbl->SampleAuxiliaryInformationOffsets, i, (char **)&saioOld); + + MP4CreateSampleAuxiliaryInformationSizesAtom(&saizNew); + saizNew->aux_info_type = saizOld->aux_info_type; + saizNew->aux_info_type_parameter = saizOld->aux_info_type_parameter; + saizNew->default_sample_info_size = saizOld->default_sample_info_size; + saizNew->flags = saizOld->flags; + + MP4CreateSampleAuxiliaryInformationOffsetsAtom(&saioNew); + saioNew->aux_info_type = saioOld->aux_info_type; + saioNew->aux_info_type_parameter = saioOld->aux_info_type_parameter; + saioNew->flags = saioOld->flags; + + MP4AddListEntry(saizNew, traf->saizList); + MP4AddListEntry(saioNew, traf->saioList); } - - return MP4NoErr; + } + + return MP4NoErr; } -static MP4Err addSamples( struct MP4MediaAtom *self, MP4Handle sampleH, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ) +static MP4Err addSamples(struct MP4MediaAtom *self, MP4Handle sampleH, u32 sampleCount, + MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, + MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; - assert( minf ); - assert( minf->addSamples ); - - /*JLF 06/00 (jlefeuvre@e-vue.com) - Check for the sample type, if it's an OD command frame, rewrite it in case - it contains ESDescriptors instead of ES_ID_RefDescriptors - */ - if ((sampleCount > 0) && - ( ((MP4HandlerAtomPtr)self->handler)->handlerType == MP4ObjectDescriptorHandlerType)) { - - /* Warning, only one OD-AU can be handled within each call.*/ - if (sampleCount != 1) { - BAILWITHERROR( MP4NotImplementedErr) - } - /* rewrite the OD Access Unit (don't forget the size !!) */ - err = MP4ParseODFrame(self, sampleH, sizesH); if (err) goto bail; - } - - err = minf->addSamples( minf, sampleH, sampleCount, durationsH, sizesH, sampleEntryH, decodingOffsetsH, syncSamplesH, padsH ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; + assert(minf); + assert(minf->addSamples); + + /*JLF 06/00 (jlefeuvre@e-vue.com) + Check for the sample type, if it's an OD command frame, rewrite it in case + it contains ESDescriptors instead of ES_ID_RefDescriptors + */ + if((sampleCount > 0) && + (((MP4HandlerAtomPtr)self->handler)->handlerType == MP4ObjectDescriptorHandlerType)) + { + + /* Warning, only one OD-AU can be handled within each call.*/ + if(sampleCount != 1) + { + BAILWITHERROR(MP4NotImplementedErr) + } + /* rewrite the OD Access Unit (don't forget the size !!) */ + err = MP4ParseODFrame(self, sampleH, sizesH); + if(err) goto bail; + } + + err = minf->addSamples(minf, sampleH, sampleCount, durationsH, sizesH, sampleEntryH, + decodingOffsetsH, syncSamplesH, padsH); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err extendLastSampleDuration( struct MP4MediaAtom *self, u32 duration ) +static MP4Err extendLastSampleDuration(struct MP4MediaAtom *self, u32 duration) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; - assert( minf ); - assert( minf->extendLastSampleDuration ); - - err = minf->extendLastSampleDuration( minf, duration ); if (err) goto bail; + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; + assert(minf); + assert(minf->extendLastSampleDuration); + + err = minf->extendLastSampleDuration(minf, duration); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err addGroupDescription(struct MP4MediaAtom *self, u32 groupType, MP4Handle description, u32 *index ) +static MP4Err addGroupDescription(struct MP4MediaAtom *self, u32 groupType, MP4Handle description, + u32 *index) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; /* this can be 'traf' if fragmented */ - assert( minf ); - assert( minf->addGroupDescription ); - err = minf->addGroupDescription( minf, groupType, description, index ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; /* this can be 'traf' if fragmented */ + assert(minf); + assert(minf->addGroupDescription); + err = minf->addGroupDescription(minf, groupType, description, index); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err getGroupDescription(struct MP4MediaAtom *self, u32 groupType, u32 index, MP4Handle description ) +static MP4Err getGroupDescription(struct MP4MediaAtom *self, u32 groupType, u32 index, + MP4Handle description) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; - assert( minf ); - assert( minf->getGroupDescription ); - err = minf->getGroupDescription( minf, groupType, index, description ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; + assert(minf); + assert(minf->getGroupDescription); + err = minf->getGroupDescription(minf, groupType, index, description); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err mapSamplestoGroup(struct MP4MediaAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count ) +static MP4Err mapSamplestoGroup(struct MP4MediaAtom *self, u32 groupType, u32 group_index, + s32 sample_index, u32 count) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; /* this can be 'traf' if fragmented */ - assert( minf ); - assert( minf->mapSamplestoGroup ); - err = minf->mapSamplestoGroup( minf, groupType, group_index, sample_index, count, self->enableCompactSamples ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; /* this can be 'traf' if fragmented */ + assert(minf); + assert(minf->mapSamplestoGroup); + err = minf->mapSamplestoGroup(minf, groupType, group_index, sample_index, count, + self->enableCompactSamples); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err getSampleGroupMap(struct MP4MediaAtom *self, u32 groupType, u32 sample_number, u32* group_index ) +static MP4Err getSampleGroupMap(struct MP4MediaAtom *self, u32 groupType, u32 sample_number, + u32 *group_index) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; - assert( minf ); - assert( minf->getSampleGroupMap ); - err = minf->getSampleGroupMap( minf, groupType, sample_number, group_index ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; + assert(minf); + assert(minf->getSampleGroupMap); + err = minf->getSampleGroupMap(minf, groupType, sample_number, group_index); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err setSampleDependency( struct MP4MediaAtom *self, s32 sample_index, MP4Handle dependencies ) +static MP4Err setSampleDependency(struct MP4MediaAtom *self, s32 sample_index, + MP4Handle dependencies) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; - assert( minf ); - assert( minf->setSampleDependency ); - err = minf->setSampleDependency( minf, sample_index, dependencies ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; + assert(minf); + assert(minf->setSampleDependency); + err = minf->setSampleDependency(minf, sample_index, dependencies); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err getSampleDependency( struct MP4MediaAtom *self, u32 sampleNumber, u8* dependency ) +static MP4Err getSampleDependency(struct MP4MediaAtom *self, u32 sampleNumber, u8 *dependency) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; - assert( minf ); - assert( minf->getSampleDependency ); - err = minf->getSampleDependency( minf, sampleNumber, dependency ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; + assert(minf); + assert(minf->getSampleDependency); + err = minf->getSampleDependency(minf, sampleNumber, dependency); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err setSampleEntry( struct MP4MediaAtom *self, MP4AtomPtr entry ) +static MP4Err setSampleEntry(struct MP4MediaAtom *self, MP4AtomPtr entry) { - MP4Err err; - MP4MediaInformationAtomPtr minf; - - err = MP4NoErr; - minf = (MP4MediaInformationAtomPtr) self->information; - assert( minf ); - assert( minf->setSampleEntry ); - err = minf->setSampleEntry( minf, entry ); if (err) goto bail; + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; + assert(minf); + assert(minf->setSampleEntry); + err = minf->setSampleEntry(minf, entry); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err setExtendedLanguageTag( struct MP4MediaAtom *self, MP4AtomPtr elng ) +static MP4Err setExtendedLanguageTag(struct MP4MediaAtom *self, MP4AtomPtr elng) { - MP4Err err; - - err = MP4NoErr; - err = addAtom( self, elng ); if (err) goto bail; + MP4Err err; + + err = MP4NoErr; + err = addAtom(self, elng); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4MediaAtomPtr self = (MP4MediaAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaAtomPtr self = (MP4MediaAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); +bail: + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4MediaAtomPtr self = (MP4MediaAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE( atomList ); - bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + MP4MediaAtomPtr self = (MP4MediaAtomPtr)s; + err = MP4NoErr; + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); +bail: + TEST_RETURN(err); + + return err; +} -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MP4MediaAtom) - bail: - TEST_RETURN( err ); + PARSE_ATOM_LIST(MP4MediaAtom) +bail: + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateMediaAtom( MP4MediaAtomPtr *outAtom ) +MP4Err MP4CreateMediaAtom(MP4MediaAtomPtr *outAtom) { - MP4Err err; - MP4MediaAtomPtr self; - - self = (MP4MediaAtomPtr) calloc( 1, sizeof(MP4MediaAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4MediaAtomType; - self->name = "media"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addSamples = addSamples; - self->calculateDuration = calculateDuration; - self->setfieldsize = setfieldsize; - self->setupNew = setupNew; - self->mdatMoved = mdatMoved; - self->addSampleReference = addSampleReference; - self->settrackfragment = settrackfragment; - self->addGroupDescription = addGroupDescription; - self->mapSamplestoGroup = mapSamplestoGroup; - self->getSampleGroupMap = getSampleGroupMap; - self->getGroupDescription = getGroupDescription; - - self->setSampleDependency = setSampleDependency; - self->getSampleDependency = getSampleDependency; - - self->extendLastSampleDuration = extendLastSampleDuration; - self->setSampleEntry = setSampleEntry; - self->setExtendedLanguageTag = setExtendedLanguageTag; - self->extendedLanguageTag = NULL; - - *outAtom = self; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4MediaAtomPtr self; + + self = (MP4MediaAtomPtr)calloc(1, sizeof(MP4MediaAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4MediaAtomType; + self->name = "media"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addSamples = addSamples; + self->calculateDuration = calculateDuration; + self->setfieldsize = setfieldsize; + self->setupNew = setupNew; + self->mdatMoved = mdatMoved; + self->addSampleReference = addSampleReference; + self->settrackfragment = settrackfragment; + self->addGroupDescription = addGroupDescription; + self->mapSamplestoGroup = mapSamplestoGroup; + self->getSampleGroupMap = getSampleGroupMap; + self->getGroupDescription = getGroupDescription; + + self->setSampleDependency = setSampleDependency; + self->getSampleDependency = getSampleDependency; + + self->extendLastSampleDuration = extendLastSampleDuration; + self->setSampleEntry = setSampleEntry; + self->setExtendedLanguageTag = setExtendedLanguageTag; + self->extendedLanguageTag = NULL; + + *outAtom = self; +bail: + TEST_RETURN(err); + + return err; } -/*JLF 06/00 (jlefeuvre@e-vue.com) Rewriting the OD frame and +/*JLF 06/00 (jlefeuvre@e-vue.com) Rewriting the OD frame and replace ESDescriptors by ES_ID_RefDescriptors */ /* JB_RESO 09/02 also take care of the IPMPDecriptorPointers */ MP4Err MP4ParseODFrame(struct MP4MediaAtom *self, MP4Handle sampleH, MP4Handle sizesH) { - MP4Err err = MP4NoErr; - - u32 commandSize = 0; - u32 numCmds = 0; - char *encodedCmds = NULL; - char *buffer; - u32 i; - u32 j; - u32 frameSize; - MP4InputStreamPtr is; - MP4LinkedList descList; - MP4TrackReferenceAtomPtr tref; - MP4TrackGroupAtomPtr trgr; - MP4TrackAtomPtr trak; - MP4TrackReferenceTypeAtomPtr mpod; - MP4TrackGroupTypeAtomPtr msrc; - - MP4Err MP4CreateTrackReferenceAtom(MP4TrackReferenceAtomPtr *outAtom); - MP4Err MP4CreateTrackReferenceTypeAtom( u32 atomType, MP4TrackReferenceTypeAtomPtr *outAtom ); - MP4Err MP4CreateTrackGroupAtom(MP4TrackGroupAtomPtr *outAtom); - MP4Err MP4CreateTrackGroupTypeAtom(u32 atomType, MP4TrackGroupTypeAtomPtr *outAtom); - MP4Err MP4ParseCommand( MP4InputStreamPtr inputStream, MP4DescriptorPtr *outDesc ); - MP4Err MP4CreateES_ID_RefDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ); - - err = MP4GetHandleSize( sampleH, &frameSize); if (err) goto bail; - err = MP4CreateMemoryInputStream( *sampleH, frameSize, &is ); if (err) goto bail; - err = MP4MakeLinkedList( &descList ); if (err) goto bail; - - - trak = (MP4TrackAtomPtr) self->mediaTrack; - tref = (MP4TrackReferenceAtom *) trak->trackReferences; - if (tref == NULL) { - err = MP4CreateTrackReferenceAtom(&tref); if (err) goto bail; - trak->addAtom(trak, (MP4AtomPtr) tref); if (err) goto bail; - } - - err = tref->findAtomOfType(tref, MP4ODTrackReferenceAtomType, (MP4AtomPtr *) &mpod); - if (err) goto bail; - if (mpod == NULL) { - err = MP4CreateTrackReferenceTypeAtom(MP4ODTrackReferenceAtomType, &mpod); - tref->addAtom(tref, (MP4AtomPtr) mpod); - } - - /* Track Group */ - trgr = (MP4TrackGroupAtom *)trak->trackGroups; - if (trgr == NULL) { - err = MP4CreateTrackGroupAtom(&trgr); if (err) goto bail; - trak->addAtom(trak, (MP4AtomPtr)trgr); if (err) goto bail; - } - - err = trgr->findAtomOfType(trgr, MP4_FOUR_CHAR_CODE('m', 's', 'r', 'c'), (MP4AtomPtr *)&msrc); - if (err) goto bail; - if (msrc == NULL) { - err = MP4CreateTrackGroupTypeAtom(MP4_FOUR_CHAR_CODE('m', 's', 'r', 'c'), &msrc); - trgr->addAtom(trgr, (MP4AtomPtr)msrc); - } - - while (is->available > 0) { - - MP4DescriptorPtr desc; - MP4ObjectDescriptorUpdatePtr odUpdate; - MP4ESDescriptorUpdatePtr esUpdate; - u32 odCount; - u32 esCount; - - err = MP4ParseCommand(is, &desc); if (err) goto bail; -/* if (!desc) goto bail;*/ - numCmds += 1; - - switch (desc->tag) { - /* ObjectDescriptor UPDATE COMMAND */ - case MP4ObjectDescriptorUpdateTag: - odUpdate = (MP4ObjectDescriptorUpdatePtr) desc; - err = MP4GetListEntryCount( odUpdate->objectDescriptors, &odCount ); if (err) goto bail; - if (err) goto bail; - - for ( i = 0; i < odCount; i++ ) { - MP4ObjectDescriptorPtr od; - err = MP4GetListEntry( odUpdate->objectDescriptors, i, (char **) &od ); if (err) goto bail; - err = MP4GetListEntryCount(od->ESDescriptors, &esCount ); if (err) goto bail; - /* JB_RESO rewrite IPMPDescriptorPointers */ - err = storeIPMPDescriptorPointers( (MP4DescriptorPtr) od, - mpod ); if (err) goto bail; - - /* Guido 11/10/00 : also rewrite the OD TAG */ - od->tag = MP4_OD_Tag; - - for( j = 0; j < esCount; j++ ) { - MP4ES_ID_RefDescriptorPtr ref; - MP4ES_DescriptorPtr esd; - - err = MP4GetListEntry( od->ESDescriptors, j, (char**) &esd); if (err) goto bail; - if (err) goto bail; - - /* TO DO in libisomp4 : Check if this ES is in the movie - ES_ID == TrackID */ - err = mpod->addTrackID(mpod, esd->ESID); - if (err) goto bail; - - /* JB_RESO rewrite IPMPDescriptorPointers */ - err = storeIPMPDescriptorPointers( (MP4DescriptorPtr) esd, - mpod ); if (err) goto bail; - - /* The ref_index == mpod->TrackIdCount after adding the ref (NON NULL) */ - err = MP4CreateES_ID_RefDescriptor(MP4ES_ID_RefDescriptorTag, 0 , 0, (MP4DescriptorPtr *) &ref); - if (err) goto bail; - assert(ref); - ref->refIndex = mpod->trackIDCount; - err = od->addDescriptor((MP4DescriptorPtr) od, (MP4DescriptorPtr) ref); - if (err) goto bail; - - } - /* Remove the ESDescriptor List from each OD present in the ObjectDescriptor !! */ - if (od->ESDescriptors) { - DESTROY_DESCRIPTOR_LIST_V(od->ESDescriptors); - od->ESDescriptors = NULL; - } - } - - break; - - - /* ElementaryStreamDescriptor UPDATE COMMAND */ - case MP4ESDescriptorUpdateTag: - esUpdate = (MP4ESDescriptorUpdatePtr) desc; - err = MP4GetListEntryCount( esUpdate->ESDescriptors, &esCount ); if (err) goto bail; - for (j = 0; j < esCount; j++) { - MP4ES_ID_RefDescriptorPtr ref; - MP4ES_DescriptorPtr esd; - - err = MP4GetListEntry( esUpdate->ESDescriptors, j, (char **) &esd ); if (err) goto bail; - - /* TO DO in libisomp4 : Check if this ES is in the movie */ - /* ES_ID == TrackID */ - err = mpod->addTrackID(mpod, esd->ESID); - if (err ) goto bail; - - /* JB_RESO rewrite IPMPDescriptorPointers */ - err = storeIPMPDescriptorPointers( (MP4DescriptorPtr) esd, - mpod ); if (err) goto bail; - - err = MP4CreateES_ID_RefDescriptor(MP4ES_ID_RefDescriptorTag, 0 ,0, (MP4DescriptorPtr *) &ref); - if (err) goto bail; - assert(ref); - ref->refIndex = mpod->trackIDCount; - err = esUpdate->addDescriptor((MP4DescriptorPtr) esUpdate, (MP4DescriptorPtr) ref); - if (err) goto bail; - } - - /* Remove the ESDescriptors from the ES Listr present in this update!! */ - if (esUpdate->ESDescriptors) { - DESTROY_DESCRIPTOR_LIST_V(esUpdate->ESDescriptors); - esUpdate->ESDescriptors = NULL; - } - - break; - - default: - break; - } - err = MP4AddListEntry( desc, descList ); if (err) goto bail; - err = desc->calculateSize( desc ); if (err) goto bail; - commandSize += desc->size; - } - - encodedCmds = (char*) calloc( 1, commandSize ); - buffer = encodedCmds; - TESTMALLOC( encodedCmds ) - - for ( i = 0; i < numCmds; i++ ) { - MP4DescriptorPtr desc; - err = MP4GetListEntry( descList, i, (char **) &desc ); if (err) goto bail; - err = desc->serialize( desc, buffer ); if (err) goto bail; - buffer += desc->size; - } - err = MP4SetHandleSize( sampleH, commandSize ); if (err) goto bail; - memcpy( *sampleH, encodedCmds, commandSize ); - free( encodedCmds ); - - *(u32 *) *sizesH = commandSize; + MP4Err err = MP4NoErr; + + u32 commandSize = 0; + u32 numCmds = 0; + char *encodedCmds = NULL; + char *buffer; + u32 i; + u32 j; + u32 frameSize; + MP4InputStreamPtr is; + MP4LinkedList descList; + MP4TrackReferenceAtomPtr tref; + MP4TrackGroupAtomPtr trgr; + MP4TrackAtomPtr trak; + MP4TrackReferenceTypeAtomPtr mpod; + MP4TrackGroupTypeAtomPtr msrc; + + MP4Err MP4CreateTrackReferenceAtom(MP4TrackReferenceAtomPtr * outAtom); + MP4Err MP4CreateTrackReferenceTypeAtom(u32 atomType, MP4TrackReferenceTypeAtomPtr * outAtom); + MP4Err MP4CreateTrackGroupAtom(MP4TrackGroupAtomPtr * outAtom); + MP4Err MP4CreateTrackGroupTypeAtom(u32 atomType, MP4TrackGroupTypeAtomPtr * outAtom); + MP4Err MP4ParseCommand(MP4InputStreamPtr inputStream, MP4DescriptorPtr * outDesc); + MP4Err MP4CreateES_ID_RefDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); + + err = MP4GetHandleSize(sampleH, &frameSize); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*sampleH, frameSize, &is); + if(err) goto bail; + err = MP4MakeLinkedList(&descList); + if(err) goto bail; + + trak = (MP4TrackAtomPtr)self->mediaTrack; + tref = (MP4TrackReferenceAtom *)trak->trackReferences; + if(tref == NULL) + { + err = MP4CreateTrackReferenceAtom(&tref); + if(err) goto bail; + trak->addAtom(trak, (MP4AtomPtr)tref); + if(err) goto bail; + } + + err = tref->findAtomOfType(tref, MP4ODTrackReferenceAtomType, (MP4AtomPtr *)&mpod); + if(err) goto bail; + if(mpod == NULL) + { + err = MP4CreateTrackReferenceTypeAtom(MP4ODTrackReferenceAtomType, &mpod); + tref->addAtom(tref, (MP4AtomPtr)mpod); + } + + /* Track Group */ + trgr = (MP4TrackGroupAtom *)trak->trackGroups; + if(trgr == NULL) + { + err = MP4CreateTrackGroupAtom(&trgr); + if(err) goto bail; + trak->addAtom(trak, (MP4AtomPtr)trgr); + if(err) goto bail; + } + + err = trgr->findAtomOfType(trgr, MP4_FOUR_CHAR_CODE('m', 's', 'r', 'c'), (MP4AtomPtr *)&msrc); + if(err) goto bail; + if(msrc == NULL) + { + err = MP4CreateTrackGroupTypeAtom(MP4_FOUR_CHAR_CODE('m', 's', 'r', 'c'), &msrc); + trgr->addAtom(trgr, (MP4AtomPtr)msrc); + } + + while(is->available > 0) + { + + MP4DescriptorPtr desc; + MP4ObjectDescriptorUpdatePtr odUpdate; + MP4ESDescriptorUpdatePtr esUpdate; + u32 odCount; + u32 esCount; + + err = MP4ParseCommand(is, &desc); + if(err) goto bail; + /* if (!desc) goto bail;*/ + numCmds += 1; + + switch(desc->tag) + { + /* ObjectDescriptor UPDATE COMMAND */ + case MP4ObjectDescriptorUpdateTag: + odUpdate = (MP4ObjectDescriptorUpdatePtr)desc; + err = MP4GetListEntryCount(odUpdate->objectDescriptors, &odCount); + if(err) goto bail; + if(err) goto bail; + + for(i = 0; i < odCount; i++) + { + MP4ObjectDescriptorPtr od; + err = MP4GetListEntry(odUpdate->objectDescriptors, i, (char **)&od); + if(err) goto bail; + err = MP4GetListEntryCount(od->ESDescriptors, &esCount); + if(err) goto bail; + /* JB_RESO rewrite IPMPDescriptorPointers */ + err = storeIPMPDescriptorPointers((MP4DescriptorPtr)od, mpod); + if(err) goto bail; + + /* Guido 11/10/00 : also rewrite the OD TAG */ + od->tag = MP4_OD_Tag; + + for(j = 0; j < esCount; j++) + { + MP4ES_ID_RefDescriptorPtr ref; + MP4ES_DescriptorPtr esd; + + err = MP4GetListEntry(od->ESDescriptors, j, (char **)&esd); + if(err) goto bail; + if(err) goto bail; + + /* TO DO in libisomp4 : Check if this ES is in the movie + ES_ID == TrackID */ + err = mpod->addTrackID(mpod, esd->ESID); + if(err) goto bail; + + /* JB_RESO rewrite IPMPDescriptorPointers */ + err = storeIPMPDescriptorPointers((MP4DescriptorPtr)esd, mpod); + if(err) goto bail; + + /* The ref_index == mpod->TrackIdCount after adding the ref (NON NULL) */ + err = MP4CreateES_ID_RefDescriptor(MP4ES_ID_RefDescriptorTag, 0, 0, + (MP4DescriptorPtr *)&ref); + if(err) goto bail; + assert(ref); + ref->refIndex = mpod->trackIDCount; + err = od->addDescriptor((MP4DescriptorPtr)od, (MP4DescriptorPtr)ref); + if(err) goto bail; + } + /* Remove the ESDescriptor List from each OD present in the ObjectDescriptor !! */ + if(od->ESDescriptors) + { + DESTROY_DESCRIPTOR_LIST_V(od->ESDescriptors); + od->ESDescriptors = NULL; + } + } + + break; + + /* ElementaryStreamDescriptor UPDATE COMMAND */ + case MP4ESDescriptorUpdateTag: + esUpdate = (MP4ESDescriptorUpdatePtr)desc; + err = MP4GetListEntryCount(esUpdate->ESDescriptors, &esCount); + if(err) goto bail; + for(j = 0; j < esCount; j++) + { + MP4ES_ID_RefDescriptorPtr ref; + MP4ES_DescriptorPtr esd; + + err = MP4GetListEntry(esUpdate->ESDescriptors, j, (char **)&esd); + if(err) goto bail; + + /* TO DO in libisomp4 : Check if this ES is in the movie */ + /* ES_ID == TrackID */ + err = mpod->addTrackID(mpod, esd->ESID); + if(err) goto bail; + + /* JB_RESO rewrite IPMPDescriptorPointers */ + err = storeIPMPDescriptorPointers((MP4DescriptorPtr)esd, mpod); + if(err) goto bail; + + err = + MP4CreateES_ID_RefDescriptor(MP4ES_ID_RefDescriptorTag, 0, 0, (MP4DescriptorPtr *)&ref); + if(err) goto bail; + assert(ref); + ref->refIndex = mpod->trackIDCount; + err = esUpdate->addDescriptor((MP4DescriptorPtr)esUpdate, (MP4DescriptorPtr)ref); + if(err) goto bail; + } + + /* Remove the ESDescriptors from the ES Listr present in this update!! */ + if(esUpdate->ESDescriptors) + { + DESTROY_DESCRIPTOR_LIST_V(esUpdate->ESDescriptors); + esUpdate->ESDescriptors = NULL; + } + + break; + + default: + break; + } + err = MP4AddListEntry(desc, descList); + if(err) goto bail; + err = desc->calculateSize(desc); + if(err) goto bail; + commandSize += desc->size; + } + + encodedCmds = (char *)calloc(1, commandSize); + buffer = encodedCmds; + TESTMALLOC(encodedCmds) + + for(i = 0; i < numCmds; i++) + { + MP4DescriptorPtr desc; + err = MP4GetListEntry(descList, i, (char **)&desc); + if(err) goto bail; + err = desc->serialize(desc, buffer); + if(err) goto bail; + buffer += desc->size; + } + err = MP4SetHandleSize(sampleH, commandSize); + if(err) goto bail; + memcpy(*sampleH, encodedCmds, commandSize); + free(encodedCmds); + + *(u32 *)*sizesH = commandSize; bail: - if (is) - is->destroy(is); - if (descList) { - DESTROY_DESCRIPTOR_LIST_V(descList); - } - TEST_RETURN( err ); - return err; + if(is) is->destroy(is); + if(descList) + { + DESTROY_DESCRIPTOR_LIST_V(descList); + } + TEST_RETURN(err); + return err; } -MP4Err storeIPMPDescriptorPointers( MP4DescriptorPtr desc, - MP4TrackReferenceTypeAtomPtr mpod ) +MP4Err storeIPMPDescriptorPointers(MP4DescriptorPtr desc, MP4TrackReferenceTypeAtomPtr mpod) { - u32 k; - u32 ipmpDescPointersCount; - u32 err; - MP4LinkedList ipmpDescPointersList; - - err = MP4NoErr; - /* if ( desc->name == "MP4ES_Descriptor" ) fb_reso */ - if ( desc->tag == MP4ES_DescriptorTag ) /* fb_reso */ - { - ipmpDescPointersList = ((MP4ES_DescriptorPtr) desc)->IPMPDescriptorPointers; - } - /* else if ( desc->name = "MP4ObjectDescriptor" ) fb_reso */ - else if ( desc->tag == MP4ObjectDescriptorTag ) /* fb_reso */ + u32 k; + u32 ipmpDescPointersCount; + u32 err; + MP4LinkedList ipmpDescPointersList; + + err = MP4NoErr; + /* if ( desc->name == "MP4ES_Descriptor" ) fb_reso */ + if(desc->tag == MP4ES_DescriptorTag) /* fb_reso */ + { + ipmpDescPointersList = ((MP4ES_DescriptorPtr)desc)->IPMPDescriptorPointers; + } + /* else if ( desc->name = "MP4ObjectDescriptor" ) fb_reso */ + else if(desc->tag == MP4ObjectDescriptorTag) /* fb_reso */ + { + ipmpDescPointersList = ((MP4ObjectDescriptorPtr)desc)->IPMPDescriptorPointers; + } + else + BAILWITHERROR(MP4BadParamErr); + + err = MP4GetListEntryCount(ipmpDescPointersList, &ipmpDescPointersCount); + if(err) goto bail; + for(k = 0; k < ipmpDescPointersCount; k++) + { + MP4IPMPDescriptorPointerPtr ipmpDescPtr; + err = MP4GetListEntry(ipmpDescPointersList, k, (char **)&ipmpDescPtr); + if(err) goto bail; + if((ipmpDescPtr->ipmpEsId != 0) && (ipmpDescPtr->ipmpEsId != 0xFFFF)) { - ipmpDescPointersList = ((MP4ObjectDescriptorPtr) desc)->IPMPDescriptorPointers; - } - else - BAILWITHERROR( MP4BadParamErr ); - - err = MP4GetListEntryCount( ipmpDescPointersList, - &ipmpDescPointersCount ); if (err) goto bail; - for ( k = 0; k < ipmpDescPointersCount; k++ ) - { - MP4IPMPDescriptorPointerPtr ipmpDescPtr; - err = MP4GetListEntry( ipmpDescPointersList, - k, - (char **) &ipmpDescPtr ); if (err) goto bail; - if ( (ipmpDescPtr->ipmpEsId != 0) - && (ipmpDescPtr->ipmpEsId != 0xFFFF) ) - { - /* TO DO in libisomp4 : Check if this ES is in the movie - ES_ID == TrackID */ - err = mpod->addTrackID(mpod, ipmpDescPtr->ipmpEsId); if (err) goto bail; - /* change the id */ - ipmpDescPtr->ipmpEsId = mpod->trackIDCount; - } + /* TO DO in libisomp4 : Check if this ES is in the movie + ES_ID == TrackID */ + err = mpod->addTrackID(mpod, ipmpDescPtr->ipmpEsId); + if(err) goto bail; + /* change the id */ + ipmpDescPtr->ipmpEsId = mpod->trackIDCount; } + } bail: - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MediaDataAtom.c b/IsoLib/libisomediafile/src/MediaDataAtom.c index 0f2debb..9b9139f 100644 --- a/IsoLib/libisomediafile/src/MediaDataAtom.c +++ b/IsoLib/libisomediafile/src/MediaDataAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MediaDataAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MediaDataAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -33,263 +33,272 @@ derivative works. Copyright (c) 1999. /* define FORCE_OFFSET 0x100000000ll */ -static MP4Err calculateSize( struct MP4Atom* s ); +static MP4Err calculateSize(struct MP4Atom *s); -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4MediaDataAtomPtr self; - self = (MP4MediaDataAtomPtr) s; - if ( self->data ) - { - free( self->data ); - self->data = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4MediaDataAtomPtr self; + self = (MP4MediaDataAtomPtr)s; + if(self->data) + { + free(self->data); + self->data = NULL; + } + if(self->super) self->super->destroy(s); } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4MediaDataAtomPtr self = (MP4MediaDataAtomPtr) s; - err = MP4NoErr; - - if (self->size == 1) { BAILWITHERROR( MP4NotImplementedErr ); } - - if (self->size > 0) { - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( self->data, (u32) self->dataSize ); - assert( self->bytesWritten == self->size ); - } + MP4Err err; + MP4MediaDataAtomPtr self = (MP4MediaDataAtomPtr)s; + err = MP4NoErr; + + if(self->size == 1) + { + BAILWITHERROR(MP4NotImplementedErr); + } + + if(self->size > 0) + { + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(self->data, (u32)self->dataSize); + assert(self->bytesWritten == self->size); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err writeToFile( struct MP4MediaDataAtom *self, FILE *fd ) +static MP4Err writeToFile(struct MP4MediaDataAtom *self, FILE *fd) { - MP4Err err; - size_t written; - char buffer[ 16 ]; + MP4Err err; + size_t written; + char buffer[16]; #ifdef FORCE_OFFSET - s32 sought; + s32 sought; #endif - err = MP4NoErr; - if ( fd == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = calculateSize( (MP4AtomPtr) self ); if (err) goto bail; - if (self->size > 0) { - err = MP4SerializeCommonBaseAtomFields( (MP4AtomPtr) self, buffer ); if (err) goto bail; - written = fwrite( buffer, 1, self->bytesWritten, fd ); - if ( written != self->bytesWritten ) - BAILWITHERROR( MP4IOErr ) + err = MP4NoErr; + if(fd == NULL) BAILWITHERROR(MP4BadParamErr) + err = calculateSize((MP4AtomPtr)self); + if(err) goto bail; + if(self->size > 0) + { + err = MP4SerializeCommonBaseAtomFields((MP4AtomPtr)self, buffer); + if(err) goto bail; + written = fwrite(buffer, 1, self->bytesWritten, fd); + if(written != self->bytesWritten) BAILWITHERROR(MP4IOErr) #ifdef FORCE_OFFSET - sought = fseeko( fd, FORCE_OFFSET, SEEK_CUR ); - if ( sought != 0 ) - BAILWITHERROR( MP4IOErr ); + sought = fseeko(fd, FORCE_OFFSET, SEEK_CUR); + if(sought != 0) BAILWITHERROR(MP4IOErr); - written = fwrite( self->data, 1, self->dataSize - FORCE_OFFSET, fd ); - if ( written != (self->dataSize - FORCE_OFFSET) ) - BAILWITHERROR( MP4IOErr ) + written = fwrite(self->data, 1, self->dataSize - FORCE_OFFSET, fd); + if(written != (self->dataSize - FORCE_OFFSET)) BAILWITHERROR(MP4IOErr) #else - written = fwrite( self->data, 1, (size_t) self->dataSize, fd ); - if ( written != self->dataSize ) - BAILWITHERROR( MP4IOErr ) + written = fwrite(self->data, 1, (size_t)self->dataSize, fd); + if(written != self->dataSize) BAILWITHERROR(MP4IOErr) #endif - self->bytesWritten += written; - /* this is not reliable because bytesWritten is only a 32 and we may have written more */ - } + self->bytesWritten += written; + /* this is not reliable because bytesWritten is only a 32 and we may have written more */ + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4MediaDataAtomPtr self = (MP4MediaDataAtomPtr) s; - err = MP4NoErr; - - if (self->dataSize == 0) self->size = 0; - else { - if ((self->dataSize) >> 32) { - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size64 = self->dataSize + self->size + 8; - self->size = 1; - } - else { - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += (u32) self->dataSize; - } - } + MP4Err err; + MP4MediaDataAtomPtr self = (MP4MediaDataAtomPtr)s; + err = MP4NoErr; + + if(self->dataSize == 0) self->size = 0; + else + { + if((self->dataSize) >> 32) + { + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size64 = self->dataSize + self->size + 8; + self->size = 1; + } + else + { + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += (u32)self->dataSize; + } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addData( struct MP4MediaDataAtom *self, MP4Handle dataH ) +static MP4Err addData(struct MP4MediaDataAtom *self, MP4Handle dataH) { - MP4Err err; - u32 size; - size_t newSize; - - err = MP4NoErr; - err = MP4GetHandleSize( dataH, &size ); if (err) goto bail; - if ( size > 0 ) - { + MP4Err err; + u32 size; + size_t newSize; + + err = MP4NoErr; + err = MP4GetHandleSize(dataH, &size); + if(err) goto bail; + if(size > 0) + { #ifdef FORCE_OFFSET - newSize = self->dataSize + size - FORCE_OFFSET; + newSize = self->dataSize + size - FORCE_OFFSET; #else - newSize = (size_t) (self->dataSize + size); + newSize = (size_t)(self->dataSize + size); #endif - if (newSize > self->allocatedSize) { - self->allocatedSize += allocation_size; - if (newSize > self->allocatedSize) - self->allocatedSize = newSize; - - if (self->data != NULL) - self->data = (char*) realloc( self->data, self->allocatedSize ); - else - self->data = (char*) calloc( self->allocatedSize, 1 ); - TESTMALLOC( self->data ); - } + if(newSize > self->allocatedSize) + { + self->allocatedSize += allocation_size; + if(newSize > self->allocatedSize) self->allocatedSize = newSize; + + if(self->data != NULL) self->data = (char *)realloc(self->data, self->allocatedSize); + else + self->data = (char *)calloc(self->allocatedSize, 1); + TESTMALLOC(self->data); + } #ifdef FORCE_OFFSET - memcpy( self->data + self->dataSize - FORCE_OFFSET, *dataH, size ); + memcpy(self->data + self->dataSize - FORCE_OFFSET, *dataH, size); #else - memcpy( self->data + self->dataSize, *dataH, size ); + memcpy(self->data + self->dataSize, *dataH, size); #endif - self->dataSize += size; - } + self->dataSize += size; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addMdat( struct MP4MediaDataAtom *self, struct MP4MediaDataAtom *other_mdat ) +static MP4Err addMdat(struct MP4MediaDataAtom *self, struct MP4MediaDataAtom *other_mdat) { - MP4Err err; - u32 size; - size_t newSize; - - err = MP4NoErr; - if ((other_mdat->dataSize + self->dataSize) >> 32) { BAILWITHERROR( MP4NotImplementedErr ); } - - size = (u32) (other_mdat->dataSize); - - if ( size > 0 ) - { - newSize = (size_t) (self->dataSize + size); - if (newSize > self->allocatedSize) { - self->allocatedSize += allocation_size; - if (newSize > self->allocatedSize) - self->allocatedSize = newSize; - - if (self->data != NULL) - self->data = (char*) realloc( self->data, self->allocatedSize ); - else - self->data = (char*) calloc( self->allocatedSize, 1 ); - TESTMALLOC( self->data ); - } - - memcpy( self->data + self->dataSize, other_mdat->data, size ); - self->dataSize += size; - } + MP4Err err; + u32 size; + size_t newSize; + + err = MP4NoErr; + if((other_mdat->dataSize + self->dataSize) >> 32) + { + BAILWITHERROR(MP4NotImplementedErr); + } + + size = (u32)(other_mdat->dataSize); + + if(size > 0) + { + newSize = (size_t)(self->dataSize + size); + if(newSize > self->allocatedSize) + { + self->allocatedSize += allocation_size; + if(newSize > self->allocatedSize) self->allocatedSize = newSize; + + if(self->data != NULL) self->data = (char *)realloc(self->data, self->allocatedSize); + else + self->data = (char *)calloc(self->allocatedSize, 1); + TESTMALLOC(self->data); + } + + memcpy(self->data + self->dataSize, other_mdat->data, size); + self->dataSize += size; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u64 bytesToRead; - MP4MediaDataAtomPtr self = (MP4MediaDataAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); - - if (s->size ==1) - bytesToRead = s->size64 - s->bytesRead; - else bytesToRead = s->size - s->bytesRead; - - self->dataSize = 0; - /* it's possible to cause read files to use the filemappingdatahandler by - discarding the data here, and setting dataSize to 0; note that files - read this way cannot be re-written to another file, only read. see also - the flag MP4OpenMovieInPlace, which needs to be propagated here, and then - the file mapping stream should also have a 'skip data' entry. - - We currently do this for large files (> 2GB) as the entire input stream - machinery assumes 32-bit sizes, and so on */ - - if ((bytesToRead >> 31) > 0) { - self->data = NULL; - self->dataSize = 0; - self->dataOffset = self->streamOffset + self->bytesRead; - err = inputStream->skipData( inputStream, bytesToRead, "data" ); - } - else if (bytesToRead > 0) { - self->data = (char*) calloc( 1, (size_t) bytesToRead ); - TESTMALLOC( self->data ) - - self->dataOffset = self->streamOffset + self->bytesRead; - - err = inputStream->readData( inputStream, bytesToRead, self->data, "data" ); - if ( err ) goto bail; - - s->bytesRead += (u32) bytesToRead; - self->dataSize = bytesToRead; - self->allocatedSize = (u32) bytesToRead; - } - + MP4Err err; + u64 bytesToRead; + MP4MediaDataAtomPtr self = (MP4MediaDataAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + + if(s->size == 1) bytesToRead = s->size64 - s->bytesRead; + else + bytesToRead = s->size - s->bytesRead; + + self->dataSize = 0; + /* it's possible to cause read files to use the filemappingdatahandler by + discarding the data here, and setting dataSize to 0; note that files + read this way cannot be re-written to another file, only read. see also + the flag MP4OpenMovieInPlace, which needs to be propagated here, and then + the file mapping stream should also have a 'skip data' entry. + + We currently do this for large files (> 2GB) as the entire input stream + machinery assumes 32-bit sizes, and so on */ + + if((bytesToRead >> 31) > 0) + { + self->data = NULL; + self->dataSize = 0; + self->dataOffset = self->streamOffset + self->bytesRead; + err = inputStream->skipData(inputStream, bytesToRead, "data"); + } + else if(bytesToRead > 0) + { + self->data = (char *)calloc(1, (size_t)bytesToRead); + TESTMALLOC(self->data) + + self->dataOffset = self->streamOffset + self->bytesRead; + + err = inputStream->readData(inputStream, bytesToRead, self->data, "data"); + if(err) goto bail; + + s->bytesRead += (u32)bytesToRead; + self->dataSize = bytesToRead; + self->allocatedSize = (u32)bytesToRead; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - if ( err && self->data ) - { - free( self->data ); - } - return err; + if(err && self->data) + { + free(self->data); + } + return err; } -MP4Err MP4CreateMediaDataAtom( MP4MediaDataAtomPtr *outAtom ) +MP4Err MP4CreateMediaDataAtom(MP4MediaDataAtomPtr *outAtom) { - MP4Err err; - MP4MediaDataAtomPtr self; - - self = (MP4MediaDataAtomPtr) calloc( 1, sizeof(MP4MediaDataAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4MediaDataAtomType; - self->name = "media data"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->data = NULL; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addData = addData; - self->writeToFile = writeToFile; - self->addMdat = addMdat; - + MP4Err err; + MP4MediaDataAtomPtr self; + + self = (MP4MediaDataAtomPtr)calloc(1, sizeof(MP4MediaDataAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4MediaDataAtomType; + self->name = "media data"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->data = NULL; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addData = addData; + self->writeToFile = writeToFile; + self->addMdat = addMdat; + #ifdef FORCE_OFFSET - self->dataSize = FORCE_OFFSET; + self->dataSize = FORCE_OFFSET; #endif - - *outAtom = self; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MediaHeaderAtom.c b/IsoLib/libisomediafile/src/MediaHeaderAtom.c index c795c69..7c7c2a6 100644 --- a/IsoLib/libisomediafile/src/MediaHeaderAtom.c +++ b/IsoLib/libisomediafile/src/MediaHeaderAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,135 +15,134 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4MediaHeaderAtomPtr self = (MP4MediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - if ( self->version == 1 ) - { - PUT64( creationTime ); - PUT64( modificationTime ); - PUT32( timeScale ); - PUT64( duration ); - } - else - { - PUT32( creationTime ); - PUT32( modificationTime ); - PUT32( timeScale ); - PUT32( duration ); - } - PUT16( packedLanguage ); - PUT16( qt_quality ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4MediaHeaderAtomPtr self = (MP4MediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + if(self->version == 1) + { + PUT64(creationTime); + PUT64(modificationTime); + PUT32(timeScale); + PUT64(duration); + } + else + { + PUT32(creationTime); + PUT32(modificationTime); + PUT32(timeScale); + PUT32(duration); + } + PUT16(packedLanguage); + PUT16(qt_quality); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4MediaHeaderAtomPtr self = (MP4MediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4; - self->size += self->version == 1 ? (3*8)+4 : (4*4); + MP4Err err; + MP4MediaHeaderAtomPtr self = (MP4MediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4; + self->size += self->version == 1 ? (3 * 8) + 4 : (4 * 4); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4MediaHeaderAtomPtr self = (MP4MediaHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - if ( self->version == 1 ) - { - GET64( creationTime ); - GET64( modificationTime ); - GET32( timeScale ); - GET64( duration ); - } - else - { - u32 val; - GET32_V_MSG( val, "creationTime" ); - self->creationTime = val; - GET32_V_MSG( val, "modificationTime" ); - self->modificationTime = val; - GET32( timeScale ); - GET32_V_MSG( val, "duration" ); - self->duration = val; - } - GET16( packedLanguage ); - GET16( qt_quality ); + MP4Err err; + MP4MediaHeaderAtomPtr self = (MP4MediaHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + if(self->version == 1) + { + GET64(creationTime); + GET64(modificationTime); + GET32(timeScale); + GET64(duration); + } + else + { + u32 val; + GET32_V_MSG(val, "creationTime"); + self->creationTime = val; + GET32_V_MSG(val, "modificationTime"); + self->modificationTime = val; + GET32(timeScale); + GET32_V_MSG(val, "duration"); + self->duration = val; + } + GET16(packedLanguage); + GET16(qt_quality); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateMediaHeaderAtom( MP4MediaHeaderAtomPtr *outAtom ) +MP4Err MP4CreateMediaHeaderAtom(MP4MediaHeaderAtomPtr *outAtom) { - MP4Err err; - MP4MediaHeaderAtomPtr self; - - self = (MP4MediaHeaderAtomPtr) calloc( 1, sizeof(MP4MediaHeaderAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4MediaHeaderAtomType; - self->name = "media header"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4MediaHeaderAtomPtr self; + + self = (MP4MediaHeaderAtomPtr)calloc(1, sizeof(MP4MediaHeaderAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4MediaHeaderAtomType; + self->name = "media header"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MediaInformationAtom.c b/IsoLib/libisomediafile/src/MediaInformationAtom.c index 6c71a8c..3c4d3d1 100644 --- a/IsoLib/libisomediafile/src/MediaInformationAtom.c +++ b/IsoLib/libisomediafile/src/MediaInformationAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MediaInformationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MediaInformationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -31,710 +31,753 @@ derivative works. Copyright (c) 1999. extern u32 MP4SampleEntryProtos[]; -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4MediaInformationAtomPtr self; - u32 i; - err = MP4NoErr; - self = (MP4MediaInformationAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->atomList ) - { - u32 atomListSize; - err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; - - for ( i = 0; i < atomListSize; i++ ) - { - MP4AtomPtr a; - err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; - if ( a ) - a->destroy( a ); - } - err = MP4DeleteLinkedList( self->atomList ); if (err) goto bail; - self->atomList = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4MediaInformationAtomPtr self; + u32 i; + err = MP4NoErr; + self = (MP4MediaInformationAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->atomList) + { + u32 atomListSize; + err = MP4GetListEntryCount(self->atomList, &atomListSize); + if(err) goto bail; + + for(i = 0; i < atomListSize; i++) + { + MP4AtomPtr a; + err = MP4GetListEntry(self->atomList, i, (char **)&a); + if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(self->atomList); + if(err) goto bail; + self->atomList = NULL; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err addAtom( MP4MediaInformationAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4MediaInformationAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; - switch( atom->type ) - { - case MP4MediaHeaderAtomType: - case MP4VideoMediaHeaderAtomType: - case MP4SoundMediaHeaderAtomType: - case MP4HintMediaHeaderAtomType: - if ( self->mediaHeader ) - BAILWITHERROR( MP4BadDataErr ) - self->mediaHeader = atom; - break; - - case MP4DataInformationAtomType: - if ( self->dataInformation ) - BAILWITHERROR( MP4BadDataErr ) - self->dataInformation = atom; - break; - - case MP4SampleTableAtomType: - if ( self->sampleTable ) - BAILWITHERROR( MP4BadDataErr ) - self->sampleTable = atom; - break; - } + MP4Err err; + err = MP4NoErr; + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; + switch(atom->type) + { + case MP4MediaHeaderAtomType: + case MP4VideoMediaHeaderAtomType: + case MP4SoundMediaHeaderAtomType: + case MP4HintMediaHeaderAtomType: + if(self->mediaHeader) BAILWITHERROR(MP4BadDataErr) + self->mediaHeader = atom; + break; + + case MP4DataInformationAtomType: + if(self->dataInformation) BAILWITHERROR(MP4BadDataErr) + self->dataInformation = atom; + break; + + case MP4SampleTableAtomType: + if(self->sampleTable) BAILWITHERROR(MP4BadDataErr) + self->sampleTable = atom; + break; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err testDataEntry( struct MP4MediaInformationAtom *self, u32 dataEntryIndex ) +static MP4Err testDataEntry(struct MP4MediaInformationAtom *self, u32 dataEntryIndex) { - MP4Err err; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - MP4DataEntryAtomPtr dataEntryAtom; - - err = MP4NoErr; - if ( (self == NULL) || (dataEntryIndex == 0) ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->dataHandler && (self->dataEntryIndex == dataEntryIndex) ) - { - /* already open */ - } - else - { - dinf = (MP4DataInformationAtomPtr) self->dataInformation; - if ( dinf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - if ( dataEntryIndex > dref->getEntryCount(dref) ) - BAILWITHERROR( MP4BadParamErr ) - err = dref->getEntry( dref, dataEntryIndex, &dataEntryAtom ); if (err) goto bail; - if ( dataEntryAtom == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - err = MP4PreflightDataHandler( self->inputStream, dataEntryAtom ); if (err) goto bail; - } + MP4Err err; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + MP4DataEntryAtomPtr dataEntryAtom; + + err = MP4NoErr; + if((self == NULL) || (dataEntryIndex == 0)) BAILWITHERROR(MP4BadParamErr) + if(self->dataHandler && (self->dataEntryIndex == dataEntryIndex)) + { + /* already open */ + } + else + { + dinf = (MP4DataInformationAtomPtr)self->dataInformation; + if(dinf == NULL) BAILWITHERROR(MP4InvalidMediaErr) + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) BAILWITHERROR(MP4InvalidMediaErr) + if(dataEntryIndex > dref->getEntryCount(dref)) BAILWITHERROR(MP4BadParamErr) + err = dref->getEntry(dref, dataEntryIndex, &dataEntryAtom); + if(err) goto bail; + if(dataEntryAtom == NULL) BAILWITHERROR(MP4InvalidMediaErr) + err = MP4PreflightDataHandler(self->inputStream, dataEntryAtom); + if(err) goto bail; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } /* Guido : inserted to clean-up resources */ -static MP4Err closeDataHandler( MP4AtomPtr s ) +static MP4Err closeDataHandler(MP4AtomPtr s) { - MP4Err err; - MP4MediaInformationAtomPtr self; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - MP4DataEntryAtomPtr dataEntryAtom; - - err = MP4NoErr; - if (s == NULL) - BAILWITHERROR( MP4BadParamErr ) - self = (MP4MediaInformationAtomPtr) s; - dinf = (MP4DataInformationAtomPtr) self->dataInformation; - if ( dinf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - /* If no Access Unit was requested, dataEntryIndex was not initialized */ - /* - if (self->dataEntryIndex > 0) - { - err = dref->getEntry( dref, self->dataEntryIndex, &dataEntryAtom ); if (err) goto bail; - } - if ( dataEntryAtom == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - if ( self->dataHandler ) - { - err = MP4DisposeDataHandler( (MP4DataHandlerPtr) self->dataHandler, dataEntryAtom ); if (err) goto bail; - self->dataHandler = NULL; - } - self->dataEntryIndex = 0; - */ - - /* GUIDO: if no Access Unit was requested, or openDataHandler failed, - dataHandler is NULL and dataEntryIndex is 0 */ - if ( self->dataHandler ) - { - if ( self->dataEntryIndex == 0) - BAILWITHERROR( MP4InvalidMediaErr ) - err = dref->getEntry( dref, self->dataEntryIndex, &dataEntryAtom ); if (err) goto bail; - if ( dataEntryAtom == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - err = MP4DisposeDataHandler( (MP4DataHandlerPtr) self->dataHandler, dataEntryAtom ); if (err) goto bail; - self->dataHandler = NULL; - self->dataEntryIndex = 0; - } + MP4Err err; + MP4MediaInformationAtomPtr self; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + MP4DataEntryAtomPtr dataEntryAtom; + + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + self = (MP4MediaInformationAtomPtr)s; + dinf = (MP4DataInformationAtomPtr)self->dataInformation; + if(dinf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) BAILWITHERROR(MP4InvalidMediaErr); + /* If no Access Unit was requested, dataEntryIndex was not initialized */ + /* + if (self->dataEntryIndex > 0) + { + err = dref->getEntry( dref, self->dataEntryIndex, &dataEntryAtom ); if (err) goto bail; + } + if ( dataEntryAtom == NULL ) + BAILWITHERROR( MP4InvalidMediaErr ) + if ( self->dataHandler ) + { + err = MP4DisposeDataHandler( (MP4DataHandlerPtr) self->dataHandler, dataEntryAtom ); if + (err) goto bail; self->dataHandler = NULL; + } + self->dataEntryIndex = 0; + */ + + /* GUIDO: if no Access Unit was requested, or openDataHandler failed, + dataHandler is NULL and dataEntryIndex is 0 */ + if(self->dataHandler) + { + if(self->dataEntryIndex == 0) BAILWITHERROR(MP4InvalidMediaErr) + err = dref->getEntry(dref, self->dataEntryIndex, &dataEntryAtom); + if(err) goto bail; + if(dataEntryAtom == NULL) BAILWITHERROR(MP4InvalidMediaErr) + err = MP4DisposeDataHandler((MP4DataHandlerPtr)self->dataHandler, dataEntryAtom); + if(err) goto bail; + self->dataHandler = NULL; + self->dataEntryIndex = 0; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err openDataHandler( MP4AtomPtr s, u32 dataEntryIndex ) +static MP4Err openDataHandler(MP4AtomPtr s, u32 dataEntryIndex) { - MP4Err err; - MP4MediaInformationAtomPtr self; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - MP4DataEntryAtomPtr dataEntryAtom; - - err = MP4NoErr; - if ( (s == NULL) || (dataEntryIndex == 0) ) - BAILWITHERROR( MP4BadParamErr ) - self = (MP4MediaInformationAtomPtr) s; - if ( self->dataHandler && (self->dataEntryIndex == dataEntryIndex) ) - { - /* desired one is already open */ - } - else - { - if ( self->dataHandler ) - { - /* close the current one */ -/* Guido : changed because I have now a function to close cleanly */ - err = closeDataHandler((MP4AtomPtr)self); if (err) goto bail; -/* MP4DataHandlerPtr dh = (MP4DataHandlerPtr) self->dataHandler; - if ( dh->close ) - { - dh->close( dh ); - self->dataHandler = NULL; - } -*/ - } - dinf = (MP4DataInformationAtomPtr) self->dataInformation; - if ( dinf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - if ( dataEntryIndex > dref->getEntryCount(dref) ) - BAILWITHERROR( MP4BadParamErr ) - err = dref->getEntry( dref, dataEntryIndex, &dataEntryAtom ); if (err) goto bail; - if ( dataEntryAtom == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - - err = MP4CreateDataHandler( self->inputStream, dataEntryAtom, (struct MP4DataHandler **) &self->dataHandler ); if (err) goto bail; - self->dataEntryIndex = dataEntryIndex; - } + MP4Err err; + MP4MediaInformationAtomPtr self; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + MP4DataEntryAtomPtr dataEntryAtom; + + err = MP4NoErr; + if((s == NULL) || (dataEntryIndex == 0)) BAILWITHERROR(MP4BadParamErr) + self = (MP4MediaInformationAtomPtr)s; + if(self->dataHandler && (self->dataEntryIndex == dataEntryIndex)) + { + /* desired one is already open */ + } + else + { + if(self->dataHandler) + { + /* close the current one */ + /* Guido : changed because I have now a function to close cleanly */ + err = closeDataHandler((MP4AtomPtr)self); + if(err) goto bail; + /* MP4DataHandlerPtr dh = (MP4DataHandlerPtr) self->dataHandler; + if ( dh->close ) + { + dh->close( dh ); + self->dataHandler = NULL; + } + */ + } + dinf = (MP4DataInformationAtomPtr)self->dataInformation; + if(dinf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) BAILWITHERROR(MP4InvalidMediaErr); + if(dataEntryIndex > dref->getEntryCount(dref)) BAILWITHERROR(MP4BadParamErr) + err = dref->getEntry(dref, dataEntryIndex, &dataEntryAtom); + if(err) goto bail; + if(dataEntryAtom == NULL) BAILWITHERROR(MP4InvalidMediaErr) + + err = MP4CreateDataHandler(self->inputStream, dataEntryAtom, + (struct MP4DataHandler **)&self->dataHandler); + if(err) goto bail; + self->dataEntryIndex = dataEntryIndex; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4MediaInformationAtomPtr self = (MP4MediaInformationAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4MediaInformationAtomPtr self = (MP4MediaInformationAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err mdatArrived( struct MP4MediaInformationAtom *self, MP4AtomPtr mdat ) +static MP4Err mdatArrived(struct MP4MediaInformationAtom *self, MP4AtomPtr mdat) { - - MP4Err err; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - MP4DataEntryAtomPtr dataEntryAtom; - u32 count; - u32 i; - - err = MP4NoErr; - - dinf = (MP4DataInformationAtomPtr) self->dataInformation; - if (dinf==NULL) BAILWITHERROR( MP4InvalidMediaErr ) - - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if (dref==NULL) BAILWITHERROR( MP4InvalidMediaErr ) - - count = dref->getEntryCount( dref ); - for (i=0; igetEntry( dref, i+1, &dataEntryAtom ); - if (err) goto bail; - - if (dataEntryAtom->flags == 1) - dataEntryAtom->mdat = mdat; - } - + + MP4Err err; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + MP4DataEntryAtomPtr dataEntryAtom; + u32 count; + u32 i; + + err = MP4NoErr; + + dinf = (MP4DataInformationAtomPtr)self->dataInformation; + if(dinf == NULL) BAILWITHERROR(MP4InvalidMediaErr) + + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) BAILWITHERROR(MP4InvalidMediaErr) + + count = dref->getEntryCount(dref); + for(i = 0; i < count; i++) + { + err = dref->getEntry(dref, i + 1, &dataEntryAtom); + if(err) goto bail; + + if(dataEntryAtom->flags == 1) dataEntryAtom->mdat = mdat; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err setupNewMedia( struct MP4MediaInformationAtom *self, u32 handlerType, MP4Handle dataH, MP4AtomPtr mdat ) +static MP4Err setupNewMedia(struct MP4MediaInformationAtom *self, u32 handlerType, MP4Handle dataH, + MP4AtomPtr mdat) { - MP4Err MP4CreateDataInformationAtom( MP4DataInformationAtomPtr *outAtom ); - MP4Err MP4CreateSampleTableAtom( MP4SampleTableAtomPtr *outAtom ); - MP4Err MP4CreateVideoMediaHeaderAtom( MP4VideoMediaHeaderAtomPtr *outAtom ); - MP4Err MP4CreateSoundMediaHeaderAtom( MP4SoundMediaHeaderAtomPtr *outAtom ); - MP4Err MP4CreateHintMediaHeaderAtom( MP4HintMediaHeaderAtomPtr *outAtom ); - MP4Err MP4CreateMPEGMediaHeaderAtom( MP4MPEGMediaHeaderAtomPtr *outAtom ); - MP4Err MP4CreateDataReferenceAtom( MP4DataReferenceAtomPtr *outAtom ); - MP4Err MP4CreateDataEntryURLAtom( MP4DataEntryURLAtomPtr *outAtom ); - - MP4Err err; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - MP4DataEntryURLAtomPtr dataEntryAtom; - MP4SampleTableAtomPtr stbl; - MP4AtomPtr mdhd; - err = MP4NoErr; - - /* media header */ - mdhd = NULL; - switch ( handlerType ) - { - case MP4VisualHandlerType: - err = MP4CreateVideoMediaHeaderAtom( (MP4VideoMediaHeaderAtomPtr*) &mdhd ); if (err) goto bail; - break; - - case MP4AudioHandlerType: - err = MP4CreateSoundMediaHeaderAtom( (MP4SoundMediaHeaderAtomPtr*) &mdhd ); if (err) goto bail; - break; - - case MP4HintHandlerType: - err = MP4CreateHintMediaHeaderAtom( (MP4HintMediaHeaderAtomPtr*) &mdhd ); if (err) goto bail; - break; - - /* Note that MP4TextHandlerType uses the MP4MPEGMediaHeaderAtom, i.e. the default is right */ - default: - err = MP4CreateMPEGMediaHeaderAtom( (MP4MPEGMediaHeaderAtomPtr*) &mdhd ); if (err) goto bail; - break; - } - if ( mdhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - - err = addAtom( self, mdhd ); if (err) goto bail; - - err = MP4CreateDataInformationAtom( &dinf ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) dinf ); if (err) goto bail; - err = MP4CreateSampleTableAtom( &stbl ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) stbl ); if (err) goto bail; - err = stbl->setupNew( stbl ); if (err) goto bail; - - /* data information */ - err = MP4CreateDataReferenceAtom( &dref ); if (err) goto bail; - err = MP4CreateDataEntryURLAtom( &dataEntryAtom ); if (err) goto bail; - if ( dataH == NULL ) - { - dataEntryAtom->flags |= 1; - dataEntryAtom->mdat = mdat; - } - else - { - u32 sz; - err = MP4GetHandleSize( dataH, &sz ); if (err) goto bail; - dataEntryAtom->locationLength = (u32) sz; - dataEntryAtom->location = (char*) calloc( 1, sz ); - TESTMALLOC( dataEntryAtom->location ) - memcpy( dataEntryAtom->location, *dataH, sz ); - } - err = dref->addDataEntry( dref, (MP4AtomPtr) dataEntryAtom ); if (err) goto bail; - err = dinf->addAtom( dinf, (MP4AtomPtr) dref ); if (err) goto bail; + MP4Err MP4CreateDataInformationAtom(MP4DataInformationAtomPtr * outAtom); + MP4Err MP4CreateSampleTableAtom(MP4SampleTableAtomPtr * outAtom); + MP4Err MP4CreateVideoMediaHeaderAtom(MP4VideoMediaHeaderAtomPtr * outAtom); + MP4Err MP4CreateSoundMediaHeaderAtom(MP4SoundMediaHeaderAtomPtr * outAtom); + MP4Err MP4CreateHintMediaHeaderAtom(MP4HintMediaHeaderAtomPtr * outAtom); + MP4Err MP4CreateMPEGMediaHeaderAtom(MP4MPEGMediaHeaderAtomPtr * outAtom); + MP4Err MP4CreateDataReferenceAtom(MP4DataReferenceAtomPtr * outAtom); + MP4Err MP4CreateDataEntryURLAtom(MP4DataEntryURLAtomPtr * outAtom); + + MP4Err err; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + MP4DataEntryURLAtomPtr dataEntryAtom; + MP4SampleTableAtomPtr stbl; + MP4AtomPtr mdhd; + err = MP4NoErr; + + /* media header */ + mdhd = NULL; + switch(handlerType) + { + case MP4VisualHandlerType: + err = MP4CreateVideoMediaHeaderAtom((MP4VideoMediaHeaderAtomPtr *)&mdhd); + if(err) goto bail; + break; + + case MP4AudioHandlerType: + err = MP4CreateSoundMediaHeaderAtom((MP4SoundMediaHeaderAtomPtr *)&mdhd); + if(err) goto bail; + break; + + case MP4HintHandlerType: + err = MP4CreateHintMediaHeaderAtom((MP4HintMediaHeaderAtomPtr *)&mdhd); + if(err) goto bail; + break; + + /* Note that MP4TextHandlerType uses the MP4MPEGMediaHeaderAtom, i.e. the default is right */ + default: + err = MP4CreateMPEGMediaHeaderAtom((MP4MPEGMediaHeaderAtomPtr *)&mdhd); + if(err) goto bail; + break; + } + if(mdhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + + err = addAtom(self, mdhd); + if(err) goto bail; + + err = MP4CreateDataInformationAtom(&dinf); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)dinf); + if(err) goto bail; + err = MP4CreateSampleTableAtom(&stbl); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)stbl); + if(err) goto bail; + err = stbl->setupNew(stbl); + if(err) goto bail; + + /* data information */ + err = MP4CreateDataReferenceAtom(&dref); + if(err) goto bail; + err = MP4CreateDataEntryURLAtom(&dataEntryAtom); + if(err) goto bail; + if(dataH == NULL) + { + dataEntryAtom->flags |= 1; + dataEntryAtom->mdat = mdat; + } + else + { + u32 sz; + err = MP4GetHandleSize(dataH, &sz); + if(err) goto bail; + dataEntryAtom->locationLength = (u32)sz; + dataEntryAtom->location = (char *)calloc(1, sz); + TESTMALLOC(dataEntryAtom->location) + memcpy(dataEntryAtom->location, *dataH, sz); + } + err = dref->addDataEntry(dref, (MP4AtomPtr)dataEntryAtom); + if(err) goto bail; + err = dinf->addAtom(dinf, (MP4AtomPtr)dref); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err addSampleReference( struct MP4MediaInformationAtom *self, u64 dataOffset, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ) +static MP4Err addSampleReference(struct MP4MediaInformationAtom *self, u64 dataOffset, + u32 sampleCount, MP4Handle durationsH, MP4Handle sizesH, + MP4Handle sampleEntryH, MP4Handle decodingOffsetsH, + MP4Handle syncSamplesH, MP4Handle padsH) { - MP4Err err; - u32 dataReferenceIndex; - MP4SampleTableAtomPtr stbl; - MP4DataInformationAtomPtr dinf; - - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - if ( stbl == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - dinf = (MP4DataInformationAtomPtr) self->dataInformation; - if ( dinf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - if ( sampleEntryH != NULL ) - { - MP4Err MP4CreateMemoryInputStream( char *base, u32 size, MP4InputStreamPtr *outStream ); -/* MP4Err MP4ParseAtom( MP4InputStreamPtr inputStream, MP4AtomPtr *outAtom ); */ - MP4Err MP4ParseAtomUsingProtoList( MP4InputStreamPtr inputStream, u32* protoList, u32 defaultAtom, MP4AtomPtr *outAtom ); - - MP4InputStreamPtr is; - u32 size; - MP4AtomPtr entry; - err = MP4GetHandleSize( sampleEntryH, &size ); if (err) goto bail; - err = MP4CreateMemoryInputStream(*sampleEntryH, size, &is ); if (err) goto bail; - is->debugging = 0; -/* err = MP4ParseAtom( is, &entry ); if (err) goto bail; */ - err = MP4ParseAtomUsingProtoList( is, MP4SampleEntryProtos, MP4GenericSampleEntryAtomType, &entry ); if (err) goto bail; - - err = stbl->setSampleEntry( stbl, entry ); if (err) goto bail; - - if (is) { - is->destroy( is ); - is = NULL; - } - } - err = stbl->getCurrentDataReferenceIndex( stbl, &dataReferenceIndex ); if (err) goto bail; - - err = stbl->addSamples( stbl, sampleCount, dataOffset, durationsH, sizesH, decodingOffsetsH, syncSamplesH, padsH ); if (err) goto bail; - err = dinf->addSampleReference( dinf, sampleCount, dataReferenceIndex, dataOffset, sizesH ); if (err) goto bail; + MP4Err err; + u32 dataReferenceIndex; + MP4SampleTableAtomPtr stbl; + MP4DataInformationAtomPtr dinf; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + if(stbl == NULL) BAILWITHERROR(MP4InvalidMediaErr) + dinf = (MP4DataInformationAtomPtr)self->dataInformation; + if(dinf == NULL) BAILWITHERROR(MP4InvalidMediaErr) + if(sampleEntryH != NULL) + { + MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); + /* MP4Err MP4ParseAtom( MP4InputStreamPtr inputStream, MP4AtomPtr *outAtom ); */ + MP4Err MP4ParseAtomUsingProtoList(MP4InputStreamPtr inputStream, u32 * protoList, + u32 defaultAtom, MP4AtomPtr * outAtom); + + MP4InputStreamPtr is; + u32 size; + MP4AtomPtr entry; + err = MP4GetHandleSize(sampleEntryH, &size); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*sampleEntryH, size, &is); + if(err) goto bail; + is->debugging = 0; + /* err = MP4ParseAtom( is, &entry ); if (err) goto bail; */ + err = + MP4ParseAtomUsingProtoList(is, MP4SampleEntryProtos, MP4GenericSampleEntryAtomType, &entry); + if(err) goto bail; + + err = stbl->setSampleEntry(stbl, entry); + if(err) goto bail; + + if(is) + { + is->destroy(is); + is = NULL; + } + } + err = stbl->getCurrentDataReferenceIndex(stbl, &dataReferenceIndex); + if(err) goto bail; + + err = stbl->addSamples(stbl, sampleCount, dataOffset, durationsH, sizesH, decodingOffsetsH, + syncSamplesH, padsH); + if(err) goto bail; + err = dinf->addSampleReference(dinf, sampleCount, dataReferenceIndex, dataOffset, sizesH); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err setfieldsize( struct MP4MediaInformationAtom* self, u32 fieldsize ) +static MP4Err setfieldsize(struct MP4MediaInformationAtom *self, u32 fieldsize) { - MP4Err err; - MP4SampleTableAtomPtr stbl; - - err = MP4NoErr; - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - assert( stbl ); - assert( stbl->setfieldsize ); - err = stbl->setfieldsize( stbl, fieldsize ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + assert(stbl); + assert(stbl->setfieldsize); + err = stbl->setfieldsize(stbl, fieldsize); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err extendLastSampleDuration( struct MP4MediaInformationAtom *self, u32 duration ) +static MP4Err extendLastSampleDuration(struct MP4MediaInformationAtom *self, u32 duration) { - MP4Err err; - MP4SampleTableAtomPtr stbl; - - err = MP4NoErr; - - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - if ( stbl == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - err = stbl->extendLastSampleDuration( stbl, duration ); - + MP4Err err; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + if(stbl == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + err = stbl->extendLastSampleDuration(stbl, duration); + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err addSamples( struct MP4MediaInformationAtom *self, MP4Handle sampleH, - u32 sampleCount, MP4Handle durationsH, MP4Handle sizesH, - MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ) +static MP4Err addSamples(struct MP4MediaInformationAtom *self, MP4Handle sampleH, u32 sampleCount, + MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, + MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH) { - MP4Err err; - u64 sampleOffset; - u32 dataReferenceIndex; - MP4SampleTableAtomPtr stbl; - MP4DataInformationAtomPtr dinf; - - err = MP4NoErr; - - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - if ( stbl == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - dinf = (MP4DataInformationAtomPtr) self->dataInformation; - if ( dinf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - if ( sampleEntryH != NULL ) - { - MP4Err MP4CreateMemoryInputStream( char *base, u32 size, MP4InputStreamPtr *outStream ); - MP4Err MP4ParseAtomUsingProtoList( MP4InputStreamPtr inputStream, u32* protoList, u32 defaultAtom, MP4AtomPtr *outAtom ); - - MP4InputStreamPtr is; - u32 size; - MP4AtomPtr entry; - err = MP4GetHandleSize( sampleEntryH, &size ); if (err) goto bail; - err = MP4CreateMemoryInputStream(*sampleEntryH, size, &is ); if (err) goto bail; - is->debugging = 0; - err = MP4ParseAtomUsingProtoList( is, MP4SampleEntryProtos, MP4GenericSampleEntryAtomType, &entry ); if (err) goto bail; - err = stbl->setSampleEntry( stbl, entry ); if (err) goto bail; - - if (is) { - is->destroy( is ); - is = NULL; - } - } - if (sampleCount > 0) { - err = stbl->getCurrentDataReferenceIndex( stbl, &dataReferenceIndex ); if (err) goto bail; - err = dinf->getOffset( dinf, dataReferenceIndex, &sampleOffset ); if (err) goto bail; - err = stbl->addSamples( stbl, sampleCount, sampleOffset, durationsH, sizesH, decodingOffsetsH, syncSamplesH, padsH ); if (err) goto bail; - err = dinf->addSamples( dinf, sampleCount, dataReferenceIndex, sampleH ); if (err) goto bail; - } + MP4Err err; + u64 sampleOffset; + u32 dataReferenceIndex; + MP4SampleTableAtomPtr stbl; + MP4DataInformationAtomPtr dinf; + + err = MP4NoErr; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + if(stbl == NULL) BAILWITHERROR(MP4InvalidMediaErr) + dinf = (MP4DataInformationAtomPtr)self->dataInformation; + if(dinf == NULL) BAILWITHERROR(MP4InvalidMediaErr) + if(sampleEntryH != NULL) + { + MP4Err MP4CreateMemoryInputStream(char *base, u32 size, MP4InputStreamPtr *outStream); + MP4Err MP4ParseAtomUsingProtoList(MP4InputStreamPtr inputStream, u32 * protoList, + u32 defaultAtom, MP4AtomPtr * outAtom); + + MP4InputStreamPtr is; + u32 size; + MP4AtomPtr entry; + err = MP4GetHandleSize(sampleEntryH, &size); + if(err) goto bail; + err = MP4CreateMemoryInputStream(*sampleEntryH, size, &is); + if(err) goto bail; + is->debugging = 0; + err = + MP4ParseAtomUsingProtoList(is, MP4SampleEntryProtos, MP4GenericSampleEntryAtomType, &entry); + if(err) goto bail; + err = stbl->setSampleEntry(stbl, entry); + if(err) goto bail; + + if(is) + { + is->destroy(is); + is = NULL; + } + } + if(sampleCount > 0) + { + err = stbl->getCurrentDataReferenceIndex(stbl, &dataReferenceIndex); + if(err) goto bail; + err = dinf->getOffset(dinf, dataReferenceIndex, &sampleOffset); + if(err) goto bail; + err = stbl->addSamples(stbl, sampleCount, sampleOffset, durationsH, sizesH, decodingOffsetsH, + syncSamplesH, padsH); + if(err) goto bail; + err = dinf->addSamples(dinf, sampleCount, dataReferenceIndex, sampleH); + if(err) goto bail; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addGroupDescription(struct MP4MediaInformationAtom *self, u32 groupType, MP4Handle description, u32 *index ) +static MP4Err addGroupDescription(struct MP4MediaInformationAtom *self, u32 groupType, + MP4Handle description, u32 *index) { - MP4Err err; - MP4SampleTableAtomPtr stbl; - - err = MP4NoErr; - - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - assert( stbl ); - assert( stbl->addGroupDescription ); - err = stbl->addGroupDescription( stbl, groupType, description, index ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + assert(stbl); + assert(stbl->addGroupDescription); + err = stbl->addGroupDescription(stbl, groupType, description, index); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err getGroupDescription(struct MP4MediaInformationAtom *self, u32 groupType, u32 index, MP4Handle description ) +static MP4Err getGroupDescription(struct MP4MediaInformationAtom *self, u32 groupType, u32 index, + MP4Handle description) { - MP4Err err; - MP4SampleTableAtomPtr stbl; - - err = MP4NoErr; - - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - assert( stbl ); - assert( stbl->getGroupDescription ); - err = stbl->getGroupDescription( stbl, groupType, index, description ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + assert(stbl); + assert(stbl->getGroupDescription); + err = stbl->getGroupDescription(stbl, groupType, index, description); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ) +static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *self, u32 groupType, + u32 group_index, s32 sample_index, u32 count, + u32 enableCompactSamples) { - MP4Err err; - MP4SampleTableAtomPtr stbl; - - err = MP4NoErr; - - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - assert( stbl ); - assert( stbl->mapSamplestoGroup ); - err = stbl->mapSamplestoGroup( stbl, groupType, group_index, sample_index, count, enableCompactSamples ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + assert(stbl); + assert(stbl->mapSamplestoGroup); + err = stbl->mapSamplestoGroup(stbl, groupType, group_index, sample_index, count, + enableCompactSamples); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err getSampleGroupMap(struct MP4MediaInformationAtom *self, u32 groupType, u32 sample_number, u32* group_index ) +static MP4Err getSampleGroupMap(struct MP4MediaInformationAtom *self, u32 groupType, + u32 sample_number, u32 *group_index) { - MP4Err err; - MP4SampleTableAtomPtr stbl; - - err = MP4NoErr; - - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - assert( stbl ); - assert( stbl->getSampleGroupMap ); - err = stbl->getSampleGroupMap( stbl, groupType, sample_number, group_index ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + assert(stbl); + assert(stbl->getSampleGroupMap); + err = stbl->getSampleGroupMap(stbl, groupType, sample_number, group_index); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err setSampleDependency( struct MP4MediaInformationAtom *self, s32 sample_index, MP4Handle dependencies ) +static MP4Err setSampleDependency(struct MP4MediaInformationAtom *self, s32 sample_index, + MP4Handle dependencies) { - MP4Err err; - MP4SampleTableAtomPtr stbl; - - err = MP4NoErr; - - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - assert( stbl ); - assert( stbl->setSampleDependency ); - err = stbl->setSampleDependency( stbl, sample_index, dependencies ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + assert(stbl); + assert(stbl->setSampleDependency); + err = stbl->setSampleDependency(stbl, sample_index, dependencies); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err getSampleDependency( struct MP4MediaInformationAtom *self, u32 sampleNumber, u8* dependency ) +static MP4Err getSampleDependency(struct MP4MediaInformationAtom *self, u32 sampleNumber, + u8 *dependency) { - MP4Err err; - MP4SampleTableAtomPtr stbl; - - err = MP4NoErr; - - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - assert( stbl ); - assert( stbl->getSampleDependency ); - err = stbl->getSampleDependency( stbl, sampleNumber, dependency ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + assert(stbl); + assert(stbl->getSampleDependency); + err = stbl->getSampleDependency(stbl, sampleNumber, dependency); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err setSampleEntry( struct MP4MediaInformationAtom *self, MP4AtomPtr entry ) +static MP4Err setSampleEntry(struct MP4MediaInformationAtom *self, MP4AtomPtr entry) { - MP4Err err; - MP4SampleTableAtomPtr stbl; - - err = MP4NoErr; - - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - assert( stbl ); - assert( stbl->setSampleEntry ); - err = stbl->setSampleEntry( stbl, entry ); if (err) goto bail; + MP4Err err; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + assert(stbl); + assert(stbl->setSampleEntry); + err = stbl->setSampleEntry(stbl, entry); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err mdatMoved( struct MP4MediaInformationAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) +static MP4Err mdatMoved(struct MP4MediaInformationAtom *self, u64 mdatBase, u64 mdatEnd, + s32 mdatOffset) { - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - MP4SampleTableAtomPtr stbl; - MP4SampleToChunkAtomPtr stsc; - MP4ChunkOffsetAtomPtr stco; - MP4SampleDescriptionAtomPtr stsd; - MP4Err err; - u32 i; - - err = MP4NoErr; - dinf = (MP4DataInformationAtomPtr) self->dataInformation; - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - if ( (dinf == NULL) || (stbl == NULL) ) - BAILWITHERROR( MP4InvalidMediaErr ) - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - stsc = (MP4SampleToChunkAtomPtr) stbl->SampleToChunk; - stco = (MP4ChunkOffsetAtomPtr) stbl->ChunkOffset; - stsd = (MP4SampleDescriptionAtomPtr) stbl->SampleDescription; - if ( (stsc == NULL) || (stco == NULL) || (stsd == NULL) ) - BAILWITHERROR( MP4InvalidMediaErr ) - - err = stsc->mdatMoved( stsc, mdatBase, mdatEnd, mdatOffset, stsd, dref, stco ); if (err) goto bail; - - for (i = 0; i < stbl->SampleAuxiliaryInformationOffsets->entryCount; i++) - { - MP4SampleAuxiliaryInformationOffsetsAtomPtr saio; - err = MP4GetListEntry(stbl->SampleAuxiliaryInformationOffsets, i, (char **) &saio); if (err) goto bail; - err = saio->mdatMoved((MP4AtomPtr) saio, mdatBase, mdatEnd, mdatOffset); if (err) goto bail; - } - + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + MP4SampleTableAtomPtr stbl; + MP4SampleToChunkAtomPtr stsc; + MP4ChunkOffsetAtomPtr stco; + MP4SampleDescriptionAtomPtr stsd; + MP4Err err; + u32 i; + + err = MP4NoErr; + dinf = (MP4DataInformationAtomPtr)self->dataInformation; + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + if((dinf == NULL) || (stbl == NULL)) BAILWITHERROR(MP4InvalidMediaErr) + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) BAILWITHERROR(MP4InvalidMediaErr) + stsc = (MP4SampleToChunkAtomPtr)stbl->SampleToChunk; + stco = (MP4ChunkOffsetAtomPtr)stbl->ChunkOffset; + stsd = (MP4SampleDescriptionAtomPtr)stbl->SampleDescription; + if((stsc == NULL) || (stco == NULL) || (stsd == NULL)) BAILWITHERROR(MP4InvalidMediaErr) + + err = stsc->mdatMoved(stsc, mdatBase, mdatEnd, mdatOffset, stsd, dref, stco); + if(err) goto bail; + + for(i = 0; i < stbl->SampleAuxiliaryInformationOffsets->entryCount; i++) + { + MP4SampleAuxiliaryInformationOffsetsAtomPtr saio; + err = MP4GetListEntry(stbl->SampleAuxiliaryInformationOffsets, i, (char **)&saio); + if(err) goto bail; + err = saio->mdatMoved((MP4AtomPtr)saio, mdatBase, mdatEnd, mdatOffset); + if(err) goto bail; + } + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getMediaDuration( struct MP4MediaInformationAtom *self, u32 *outDuration ) +static MP4Err getMediaDuration(struct MP4MediaInformationAtom *self, u32 *outDuration) { - MP4Err err; - MP4SampleTableAtomPtr stbl; - err = MP4NoErr; - - if ( self->sampleTable == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - stbl = (MP4SampleTableAtomPtr) self->sampleTable; - err = stbl->calculateDuration( stbl, outDuration ); + MP4Err err; + MP4SampleTableAtomPtr stbl; + err = MP4NoErr; + + if(self->sampleTable == NULL) BAILWITHERROR(MP4InvalidMediaErr); + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + err = stbl->calculateDuration(stbl, outDuration); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4MediaInformationAtomPtr self = (MP4MediaInformationAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE( atomList ); + MP4Err err; + MP4MediaInformationAtomPtr self = (MP4MediaInformationAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MP4MediaInformationAtom) - self->inputStream = inputStream; + PARSE_ATOM_LIST(MP4MediaInformationAtom) + self->inputStream = inputStream; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateMediaInformationAtom( MP4MediaInformationAtomPtr *outAtom ) +MP4Err MP4CreateMediaInformationAtom(MP4MediaInformationAtomPtr *outAtom) { - MP4Err err; - MP4MediaInformationAtomPtr self; - - self = (MP4MediaInformationAtomPtr) calloc( 1, sizeof(MP4MediaInformationAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4MediaInformationAtomType; - self->name = "media information"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->closeDataHandler = closeDataHandler; - self->openDataHandler = openDataHandler; - self->setupNewMedia = setupNewMedia; - self->getMediaDuration = getMediaDuration; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addSamples = addSamples; - self->setfieldsize = setfieldsize; - self->mdatMoved = mdatMoved; - self->mdatArrived = mdatArrived; - self->addSampleReference = addSampleReference; - self->testDataEntry = testDataEntry; - self->addGroupDescription = addGroupDescription; - self->mapSamplestoGroup = mapSamplestoGroup; - self->getSampleGroupMap = getSampleGroupMap; - self->getGroupDescription = getGroupDescription; - self->getSampleDependency = getSampleDependency; - self->setSampleDependency = setSampleDependency; - self->extendLastSampleDuration = extendLastSampleDuration; - self->setSampleEntry = setSampleEntry; - - *outAtom = self; + MP4Err err; + MP4MediaInformationAtomPtr self; + + self = (MP4MediaInformationAtomPtr)calloc(1, sizeof(MP4MediaInformationAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4MediaInformationAtomType; + self->name = "media information"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->closeDataHandler = closeDataHandler; + self->openDataHandler = openDataHandler; + self->setupNewMedia = setupNewMedia; + self->getMediaDuration = getMediaDuration; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addSamples = addSamples; + self->setfieldsize = setfieldsize; + self->mdatMoved = mdatMoved; + self->mdatArrived = mdatArrived; + self->addSampleReference = addSampleReference; + self->testDataEntry = testDataEntry; + self->addGroupDescription = addGroupDescription; + self->mapSamplestoGroup = mapSamplestoGroup; + self->getSampleGroupMap = getSampleGroupMap; + self->getGroupDescription = getGroupDescription; + self->getSampleDependency = getSampleDependency; + self->setSampleDependency = setSampleDependency; + self->extendLastSampleDuration = extendLastSampleDuration; + self->setSampleEntry = setSampleEntry; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MemoryFileMappingObject.c b/IsoLib/libisomediafile/src/MemoryFileMappingObject.c index 9fe505a..365fd65 100644 --- a/IsoLib/libisomediafile/src/MemoryFileMappingObject.c +++ b/IsoLib/libisomediafile/src/MemoryFileMappingObject.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,83 +15,79 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MemoryFileMappingObject.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MemoryFileMappingObject.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "FileMappingObject.h" #include -static MP4Err doClose( struct FileMappingObjectRecord *s ); -static MP4Err doOpen( struct FileMappingObjectRecord *s, const char *filename ); -static MP4Err isYourFile( struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile ); +static MP4Err doClose(struct FileMappingObjectRecord *s); +static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *filename); +static MP4Err isYourFile(struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile); -static MP4Err destroy( struct FileMappingObjectRecord* s ) +static MP4Err destroy(struct FileMappingObjectRecord *s) { - MP4Err err; + MP4Err err; - free( s ); - - err = MP4NoErr; - return err; + free(s); + + err = MP4NoErr; + return err; } -static MP4Err doOpen( struct FileMappingObjectRecord* s, const char *filename ) +static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *filename) { - MP4Err err; - err = MP4NoErr; - if ((s==NULL) || ( filename != NULL )) - BAILWITHERROR( MP4BadParamErr ); + MP4Err err; + err = MP4NoErr; + if((s == NULL) || (filename != NULL)) BAILWITHERROR(MP4BadParamErr); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err doClose( struct FileMappingObjectRecord* s) +static MP4Err doClose(struct FileMappingObjectRecord *s) { - MP4Err err; - - if (s==NULL) - err = MP4BadParamErr; - err = MP4NoErr; - return err; + MP4Err err; + + if(s == NULL) err = MP4BadParamErr; + err = MP4NoErr; + return err; } -static MP4Err isYourFile( struct FileMappingObjectRecord* s, const char *filename, u32 *outSameFile ) +static MP4Err isYourFile(struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile) { - MP4Err err; - err = MP4NoErr; - if (s==NULL) - err = MP4BadParamErr; - *outSameFile = (filename == NULL); - return err; + MP4Err err; + err = MP4NoErr; + if(s == NULL) err = MP4BadParamErr; + *outSameFile = (filename == NULL); + return err; } - -MP4Err MP4CreateMemoryFileMappingObject( char *src, u32 size, FileMappingObject *outObject ) +MP4Err MP4CreateMemoryFileMappingObject(char *src, u32 size, FileMappingObject *outObject) { - MP4Err err; - FileMappingObject self; - - err = MP4NoErr; - self = (FileMappingObject) calloc( 1, sizeof(FileMappingObjectRecord) ); - TESTMALLOC( self ); - self->destroy = destroy; - self->open = doOpen; - self->close = doClose; - self->isYourFile = isYourFile; - self->copyData = 0; - - self->data = src; - self->size64 = size; - *outObject = (FileMappingObject) self; + MP4Err err; + FileMappingObject self; + + err = MP4NoErr; + self = (FileMappingObject)calloc(1, sizeof(FileMappingObjectRecord)); + TESTMALLOC(self); + self->destroy = destroy; + self->open = doOpen; + self->close = doClose; + self->isYourFile = isYourFile; + self->copyData = 0; + + self->data = src; + self->size64 = size; + *outObject = (FileMappingObject)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MetaAtom.c b/IsoLib/libisomediafile/src/MetaAtom.c index 4443c6d..7591fc6 100644 --- a/IsoLib/libisomediafile/src/MetaAtom.c +++ b/IsoLib/libisomediafile/src/MetaAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MetaAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MetaAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -29,300 +29,337 @@ derivative works. Copyright (c) 1999. #include "MdatDataHandler.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISOMetaAtomPtr self; - u32 i; - - self = (ISOMetaAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + ISOMetaAtomPtr self; + u32 i; + + self = (ISOMetaAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - ISOMetaAtomPtr self = (ISOMetaAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + ISOMetaAtomPtr self = (ISOMetaAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err closeDataHandler( ISOMetaAtomPtr self ) +static MP4Err closeDataHandler(ISOMetaAtomPtr self) { - MP4Err err; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - MP4DataEntryAtomPtr dataEntryAtom; - MP4DataHandlerPtr dhlr; - - err = MP4NoErr; - - dhlr = (MP4DataHandlerPtr) self->dataHandler; - if (!dhlr) return MP4NoErr; - - if ( self->dataEntryIndex == 0) - { - err = dhlr->close( self->dataHandler ); if (err) goto bail; - } - else if (self->dataEntryIndex != -1) { - dinf = (MP4DataInformationAtomPtr) self->dinf; - if ( dinf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - err = dref->getEntry( dref, self->dataEntryIndex, &dataEntryAtom ); if (err) goto bail; - if ( dataEntryAtom == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - err = MP4DisposeDataHandler( dhlr, dataEntryAtom ); if (err) goto bail; - } - self->dataHandler = NULL; - self->dataEntryIndex = -1; + MP4Err err; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + MP4DataEntryAtomPtr dataEntryAtom; + MP4DataHandlerPtr dhlr; + + err = MP4NoErr; + + dhlr = (MP4DataHandlerPtr)self->dataHandler; + if(!dhlr) return MP4NoErr; + + if(self->dataEntryIndex == 0) + { + err = dhlr->close(self->dataHandler); + if(err) goto bail; + } + else if(self->dataEntryIndex != -1) + { + dinf = (MP4DataInformationAtomPtr)self->dinf; + if(dinf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + err = dref->getEntry(dref, self->dataEntryIndex, &dataEntryAtom); + if(err) goto bail; + if(dataEntryAtom == NULL) BAILWITHERROR(MP4InvalidMediaErr) + err = MP4DisposeDataHandler(dhlr, dataEntryAtom); + if(err) goto bail; + } + self->dataHandler = NULL; + self->dataEntryIndex = -1; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err openDataHandler( ISOMetaAtomPtr self, u32 dataEntryIndex ) +static MP4Err openDataHandler(ISOMetaAtomPtr self, u32 dataEntryIndex) { - MP4Err err; - MP4DataInformationAtomPtr dinf; - MP4DataReferenceAtomPtr dref; - MP4DataEntryAtomPtr dataEntryAtom; - - err = MP4NoErr; - - if (dataEntryIndex == 0) { - err = MP4CreateMdatDataHandler( (MP4MediaDataAtomPtr) self->mdat, (struct MP4DataHandler **) &self->dataHandler); if (err) goto bail; - } - else - { - dinf = (MP4DataInformationAtomPtr) self->dinf; - if ( dinf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - dref = (MP4DataReferenceAtomPtr) dinf->dataReference; - if ( dref == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - if ( dataEntryIndex > dref->getEntryCount(dref) ) - BAILWITHERROR( MP4BadParamErr ) - err = dref->getEntry( dref, dataEntryIndex, &dataEntryAtom ); if (err) goto bail; - if ( dataEntryAtom == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - - err = MP4CreateDataHandler( self->inputStream, dataEntryAtom, (struct MP4DataHandler **) &self->dataHandler ); if (err) goto bail; - } - self->dataEntryIndex = dataEntryIndex; + MP4Err err; + MP4DataInformationAtomPtr dinf; + MP4DataReferenceAtomPtr dref; + MP4DataEntryAtomPtr dataEntryAtom; + + err = MP4NoErr; + + if(dataEntryIndex == 0) + { + err = MP4CreateMdatDataHandler((MP4MediaDataAtomPtr)self->mdat, + (struct MP4DataHandler **)&self->dataHandler); + if(err) goto bail; + } + else + { + dinf = (MP4DataInformationAtomPtr)self->dinf; + if(dinf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + dref = (MP4DataReferenceAtomPtr)dinf->dataReference; + if(dref == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + if(dataEntryIndex > dref->getEntryCount(dref)) BAILWITHERROR(MP4BadParamErr) + err = dref->getEntry(dref, dataEntryIndex, &dataEntryAtom); + if(err) goto bail; + if(dataEntryAtom == NULL) BAILWITHERROR(MP4InvalidMediaErr) + + err = MP4CreateDataHandler(self->inputStream, dataEntryAtom, + (struct MP4DataHandler **)&self->dataHandler); + if(err) goto bail; + } + self->dataEntryIndex = dataEntryIndex; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISOMetaAtomPtr self = (ISOMetaAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; + MP4Err err; + ISOMetaAtomPtr self = (ISOMetaAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; - ADD_ATOM_LIST_SIZE( atomList ); + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addAtom( ISOMetaAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(ISOMetaAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - ISOItemLocationAtomPtr iloc; - err = MP4NoErr; - - if ( self == 0 ) - BAILWITHERROR( MP4BadParamErr ); - switch (atom->type) { - case MP4HandlerAtomType: - if (self->hdlr) { BAILWITHERROR(MP4BadParamErr); } - self->hdlr = atom; - break; - - case MP4DataInformationAtomType: - if (self->dinf) { BAILWITHERROR(MP4BadParamErr); } - self->dinf = atom; - break; - - case ISOItemLocationAtomType: - if (self->iloc) { BAILWITHERROR(MP4BadParamErr); } - self->iloc = atom; - iloc = (ISOItemLocationAtomPtr) atom; - err = iloc->setItemsMeta(iloc, (MP4AtomPtr) self); if (err) goto bail; - break; - - case ISOPrimaryItemAtomType: - if (self->pitm) { BAILWITHERROR(MP4BadParamErr); } - self->pitm = atom; - break; - - case ISOItemInfoAtomType: - if (self->iinf) { BAILWITHERROR(MP4BadParamErr); } - self->iinf = atom; - break; - - case ISOItemReferenceAtomType: - if (self->iref) { BAILWITHERROR(MP4BadParamErr); } - self->iref = atom; - break; - - case ISOItemDataAtomType: - if (self->idat) { BAILWITHERROR(MP4BadParamErr); } - self->idat = atom; - break; - - case ISOItemProtectionAtomType: - if (self->ipro) { BAILWITHERROR(MP4BadParamErr); } - self->ipro = atom; - break; - case MP4ItemPropertiesAtomType: - if (self->iprp) { BAILWITHERROR(MP4BadParamErr); } - self->iprp = atom; - break; - } - err = MP4AddListEntry( atom, self->atomList ); + MP4Err err; + ISOItemLocationAtomPtr iloc; + err = MP4NoErr; + + if(self == 0) BAILWITHERROR(MP4BadParamErr); + switch(atom->type) + { + case MP4HandlerAtomType: + if(self->hdlr) + { + BAILWITHERROR(MP4BadParamErr); + } + self->hdlr = atom; + break; + + case MP4DataInformationAtomType: + if(self->dinf) + { + BAILWITHERROR(MP4BadParamErr); + } + self->dinf = atom; + break; + + case ISOItemLocationAtomType: + if(self->iloc) + { + BAILWITHERROR(MP4BadParamErr); + } + self->iloc = atom; + iloc = (ISOItemLocationAtomPtr)atom; + err = iloc->setItemsMeta(iloc, (MP4AtomPtr)self); + if(err) goto bail; + break; + + case ISOPrimaryItemAtomType: + if(self->pitm) + { + BAILWITHERROR(MP4BadParamErr); + } + self->pitm = atom; + break; + + case ISOItemInfoAtomType: + if(self->iinf) + { + BAILWITHERROR(MP4BadParamErr); + } + self->iinf = atom; + break; + + case ISOItemReferenceAtomType: + if(self->iref) + { + BAILWITHERROR(MP4BadParamErr); + } + self->iref = atom; + break; + + case ISOItemDataAtomType: + if(self->idat) + { + BAILWITHERROR(MP4BadParamErr); + } + self->idat = atom; + break; + + case ISOItemProtectionAtomType: + if(self->ipro) + { + BAILWITHERROR(MP4BadParamErr); + } + self->ipro = atom; + break; + case MP4ItemPropertiesAtomType: + if(self->iprp) + { + BAILWITHERROR(MP4BadParamErr); + } + self->iprp = atom; + break; + } + err = MP4AddListEntry(atom, self->atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getData(ISOMetaAtomPtr self, u32 box_type, MP4Handle data, u8 is_full_atom ) +static MP4Err getData(ISOMetaAtomPtr self, u32 box_type, MP4Handle data, u8 is_full_atom) { - MP4Err err; - u32 i, count; - - err = MP4NoErr; - if ( (self == NULL) ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->atomList ) - { - err = MP4GetListEntryCount( self->atomList, &count ); if (err) goto bail; - - for ( i = 0; i < count; i++ ) - { - MP4UnknownAtomPtr a; - err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; - - if (a->type == box_type) { - u32 len; - char* dataPtr; - len = a->dataSize; - dataPtr = a->data; - if (is_full_atom) { len -= 4; dataPtr += 4; } - if (len <= 0) BAILWITHERROR(MP4BadDataErr); - err = MP4SetHandleSize( data, len ); if (err) goto bail; - memcpy( *data, dataPtr, len ); - goto bail; - } - } - } - err = MP4NotFoundErr; - + MP4Err err; + u32 i, count; + + err = MP4NoErr; + if((self == NULL)) BAILWITHERROR(MP4BadParamErr) + + if(self->atomList) + { + err = MP4GetListEntryCount(self->atomList, &count); + if(err) goto bail; + + for(i = 0; i < count; i++) + { + MP4UnknownAtomPtr a; + err = MP4GetListEntry(self->atomList, i, (char **)&a); + if(err) goto bail; + + if(a->type == box_type) + { + u32 len; + char *dataPtr; + len = a->dataSize; + dataPtr = a->data; + if(is_full_atom) + { + len -= 4; + dataPtr += 4; + } + if(len <= 0) BAILWITHERROR(MP4BadDataErr); + err = MP4SetHandleSize(data, len); + if(err) goto bail; + memcpy(*data, dataPtr, len); + goto bail; + } + } + } + err = MP4NotFoundErr; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(ISOMetaAtom) - self->inputStream = inputStream; + PARSE_ATOM_LIST(ISOMetaAtom) + self->inputStream = inputStream; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err setMdat( ISOMetaAtomPtr self, MP4AtomPtr mdat ) +static MP4Err setMdat(ISOMetaAtomPtr self, MP4AtomPtr mdat) { - self->mdat = mdat; - return MP4NoErr; + self->mdat = mdat; + return MP4NoErr; } -static MP4Err mdatMoved(ISOMetaAtomPtr self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) +static MP4Err mdatMoved(ISOMetaAtomPtr self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset) { - MP4Err err; - ISOItemLocationAtomPtr iloc; - err = MP4NoErr; - iloc = (ISOItemLocationAtomPtr) self->iloc; + MP4Err err; + ISOItemLocationAtomPtr iloc; + err = MP4NoErr; + iloc = (ISOItemLocationAtomPtr)self->iloc; - - if (iloc) err = iloc->mdatMoved( iloc, mdatBase, mdatEnd, mdatOffset); + if(iloc) err = iloc->mdatMoved(iloc, mdatBase, mdatEnd, mdatOffset); - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err ISOCreateMetaAtom( ISOMetaAtomPtr *outAtom ) +MP4Err ISOCreateMetaAtom(ISOMetaAtomPtr *outAtom) { - MP4Err err; - ISOMetaAtomPtr self; - - self = (ISOMetaAtomPtr) calloc( 1, sizeof(ISOMetaAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOMetaAtomType; - self->name = "meta"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - err = MP4MakeLinkedList( &self->atomList ); - if ( err ) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addAtom = addAtom; - self->setMdat = setMdat; - self->mdatMoved = mdatMoved; - self->getData = getData; - self->next_item_ID = 1; - self->openDataHandler = openDataHandler; - self->closeDataHandler = closeDataHandler; - self->dataEntryIndex = -1; - self->relatedMeco = NULL; - self->iref = NULL; - self->iprp = NULL; - - *outAtom = self; + MP4Err err; + ISOMetaAtomPtr self; + + self = (ISOMetaAtomPtr)calloc(1, sizeof(ISOMetaAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOMetaAtomType; + self->name = "meta"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addAtom = addAtom; + self->setMdat = setMdat; + self->mdatMoved = mdatMoved; + self->getData = getData; + self->next_item_ID = 1; + self->openDataHandler = openDataHandler; + self->closeDataHandler = closeDataHandler; + self->dataEntryIndex = -1; + self->relatedMeco = NULL; + self->iref = NULL; + self->iprp = NULL; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MetaboxRelationAtom.c b/IsoLib/libisomediafile/src/MetaboxRelationAtom.c index 997ee57..6e335b7 100644 --- a/IsoLib/libisomediafile/src/MetaboxRelationAtom.c +++ b/IsoLib/libisomediafile/src/MetaboxRelationAtom.c @@ -28,98 +28,99 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISOMetaboxRelationAtomPtr self = (ISOMetaboxRelationAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + ISOMetaboxRelationAtomPtr self = (ISOMetaboxRelationAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - ISOMetaboxRelationAtomPtr self = (ISOMetaboxRelationAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - PUT32( first_metabox_handler_type ); - PUT32( second_metabox_handler_type ); - PUT8( metabox_relation ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + ISOMetaboxRelationAtomPtr self = (ISOMetaboxRelationAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + PUT32(first_metabox_handler_type); + PUT32(second_metabox_handler_type); + PUT8(metabox_relation); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISOMetaboxRelationAtomPtr self = (ISOMetaboxRelationAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 9; + MP4Err err; + ISOMetaboxRelationAtomPtr self = (ISOMetaboxRelationAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 9; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - ISOMetaboxRelationAtomPtr self = (ISOMetaboxRelationAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( first_metabox_handler_type ); - GET32( second_metabox_handler_type ); - GET8( metabox_relation ); - - assert( self->bytesRead == self->size ); - + MP4Err err; + ISOMetaboxRelationAtomPtr self = (ISOMetaboxRelationAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(first_metabox_handler_type); + GET32(second_metabox_handler_type); + GET8(metabox_relation); + + assert(self->bytesRead == self->size); + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err ISOCreateMetaboxRelationAtom( ISOMetaboxRelationAtomPtr *outAtom ) +MP4Err ISOCreateMetaboxRelationAtom(ISOMetaboxRelationAtomPtr *outAtom) { - MP4Err err; - ISOMetaboxRelationAtomPtr self; - - self = (ISOMetaboxRelationAtomPtr) calloc( 1, sizeof(ISOMetaboxRelationAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOMetaboxRelationAtomType; - self->name = "metabox relation"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + ISOMetaboxRelationAtomPtr self; + + self = (ISOMetaboxRelationAtomPtr)calloc(1, sizeof(ISOMetaboxRelationAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOMetaboxRelationAtomType; + self->name = "metabox relation"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/MovieAtom.c b/IsoLib/libisomediafile/src/MovieAtom.c index ab9006f..96b9d05 100644 --- a/IsoLib/libisomediafile/src/MovieAtom.c +++ b/IsoLib/libisomediafile/src/MovieAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,687 +15,695 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include #include -static MP4Err addAtom( MP4MovieAtomPtr self, MP4AtomPtr atom ); +static MP4Err addAtom(MP4MovieAtomPtr self, MP4AtomPtr atom); -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4MovieAtomPtr self; - u32 i; - err = MP4NoErr; - self = (MP4MovieAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - err = MP4DeleteLinkedList( self->trackList ); if (err) goto bail; - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4MovieAtomPtr self; + u32 i; + err = MP4NoErr; + self = (MP4MovieAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + err = MP4DeleteLinkedList(self->trackList); + if(err) goto bail; + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err getNextTrackID( MP4MovieAtomPtr self, u32 *outID ) +static MP4Err getNextTrackID(MP4MovieAtomPtr self, u32 *outID) { - MP4MovieHeaderAtomPtr mvhd; - MP4Err err; - err = MP4NoErr; - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - *outID = mvhd->nextTrackID; + MP4MovieHeaderAtomPtr mvhd; + MP4Err err; + err = MP4NoErr; + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + *outID = mvhd->nextTrackID; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } /* - Try to reserve the specified track ID. - Sets *outSuccess nonzero if we may use the requested trackID. - Has a side effect of setting the movie's nextTrackID to one - greater than the requested trackID if this would make it the - highest numbered track in the movie. + Try to reserve the specified track ID. + Sets *outSuccess nonzero if we may use the requested trackID. + Has a side effect of setting the movie's nextTrackID to one + greater than the requested trackID if this would make it the + highest numbered track in the movie. */ -static MP4Err requestTrackID( struct MP4MovieAtom* self, u32 trackID, u32 *outSuccess ) +static MP4Err requestTrackID(struct MP4MovieAtom *self, u32 trackID, u32 *outSuccess) { - MP4MovieHeaderAtomPtr mvhd; - MP4Err err; - - err = MP4NoErr; - if ( (outSuccess == 0) || (trackID == 0) ) - BAILWITHERROR( MP4BadParamErr ); - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - *outSuccess = 0; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - if ( trackID >= mvhd->nextTrackID ) - { - mvhd->nextTrackID = trackID + 1; - *outSuccess = 1; - } - else - { - u32 i; - u32 trackCount = 0; - err = MP4GetListEntryCount( self->trackList, &trackCount ); if (err) goto bail; - for ( i = 0; i < trackCount; i++ ) - { - MP4TrackAtomPtr trak; - MP4TrackHeaderAtomPtr tkhd; - err = MP4GetListEntry( self->trackList, i, (char**) &trak ); if (err) goto bail; - if ( trak == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - tkhd = (MP4TrackHeaderAtomPtr) trak->trackHeader; - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - if ( tkhd->trackID == trackID ) - goto bail; - } - *outSuccess = 1; - } + MP4MovieHeaderAtomPtr mvhd; + MP4Err err; + + err = MP4NoErr; + if((outSuccess == 0) || (trackID == 0)) BAILWITHERROR(MP4BadParamErr); + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + *outSuccess = 0; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + if(trackID >= mvhd->nextTrackID) + { + mvhd->nextTrackID = trackID + 1; + *outSuccess = 1; + } + else + { + u32 i; + u32 trackCount = 0; + err = MP4GetListEntryCount(self->trackList, &trackCount); + if(err) goto bail; + for(i = 0; i < trackCount; i++) + { + MP4TrackAtomPtr trak; + MP4TrackHeaderAtomPtr tkhd; + err = MP4GetListEntry(self->trackList, i, (char **)&trak); + if(err) goto bail; + if(trak == NULL) BAILWITHERROR(MP4InvalidMediaErr); + tkhd = (MP4TrackHeaderAtomPtr)trak->trackHeader; + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + if(tkhd->trackID == trackID) goto bail; + } + *outSuccess = 1; + } bail: - return err; + return err; } -static MP4Err newTrackWithID( struct MP4MovieAtom* self, u32 newTrackFlags, u32 newTrackID, MP4AtomPtr *outTrack ) +static MP4Err newTrackWithID(struct MP4MovieAtom *self, u32 newTrackFlags, u32 newTrackID, + MP4AtomPtr *outTrack) { - MP4Err MP4CreateTrackAtom( MP4TrackAtomPtr *outAtom ); - MP4Err MP4CreateTrackHeaderAtom( MP4TrackHeaderAtomPtr *outAtom ); - - MP4MovieHeaderAtomPtr mvhd; - MP4TrackAtomPtr trak; - MP4TrackHeaderAtomPtr tkhd; - u32 success; - MP4Err err; - err = MP4NoErr; - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - - err = requestTrackID( self, newTrackID, &success ); if (err) goto bail; - if ( success == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = MP4CreateTrackAtom( &trak ); if (err) goto bail; - err = MP4CreateTrackHeaderAtom( &tkhd ); if (err) goto bail; - trak->newTrackFlags = newTrackFlags; - tkhd->trackID = newTrackID; - err = MP4GetCurrentTime( &tkhd->creationTime ); if (err) goto bail; - tkhd->modificationTime = tkhd->creationTime; - if ( newTrackFlags & MP4NewTrackIsVisual ) - { - tkhd->qt_trackWidth = (320 << 16); - tkhd->qt_trackHeight = (240 << 16); - } - else if ( newTrackFlags & MP4NewTrackIsAudio ) - { - tkhd->qt_volume = (1 << 8); - } - err = trak->addAtom( trak, (MP4AtomPtr) tkhd ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) trak ); if (err) goto bail; - *outTrack = (MP4AtomPtr) trak; + MP4Err MP4CreateTrackAtom(MP4TrackAtomPtr * outAtom); + MP4Err MP4CreateTrackHeaderAtom(MP4TrackHeaderAtomPtr * outAtom); + + MP4MovieHeaderAtomPtr mvhd; + MP4TrackAtomPtr trak; + MP4TrackHeaderAtomPtr tkhd; + u32 success; + MP4Err err; + err = MP4NoErr; + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + + err = requestTrackID(self, newTrackID, &success); + if(err) goto bail; + if(success == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + err = MP4CreateTrackAtom(&trak); + if(err) goto bail; + err = MP4CreateTrackHeaderAtom(&tkhd); + if(err) goto bail; + trak->newTrackFlags = newTrackFlags; + tkhd->trackID = newTrackID; + err = MP4GetCurrentTime(&tkhd->creationTime); + if(err) goto bail; + tkhd->modificationTime = tkhd->creationTime; + if(newTrackFlags & MP4NewTrackIsVisual) + { + tkhd->qt_trackWidth = (320 << 16); + tkhd->qt_trackHeight = (240 << 16); + } + else if(newTrackFlags & MP4NewTrackIsAudio) + { + tkhd->qt_volume = (1 << 8); + } + err = trak->addAtom(trak, (MP4AtomPtr)tkhd); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)trak); + if(err) goto bail; + *outTrack = (MP4AtomPtr)trak; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err newTrack( struct MP4MovieAtom* self, u32 newTrackFlags, MP4AtomPtr *outTrack ) +static MP4Err newTrack(struct MP4MovieAtom *self, u32 newTrackFlags, MP4AtomPtr *outTrack) { - MP4MovieHeaderAtomPtr mvhd; - MP4Err err = MP4NoErr; - - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - err = newTrackWithID( self, newTrackFlags, mvhd->nextTrackID, outTrack ); + MP4MovieHeaderAtomPtr mvhd; + MP4Err err = MP4NoErr; + + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + err = newTrackWithID(self, newTrackFlags, mvhd->nextTrackID, outTrack); bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } - -static MP4Err setTimeScale( struct MP4MovieAtom* self, u32 timeScale ) + +static MP4Err setTimeScale(struct MP4MovieAtom *self, u32 timeScale) { - MP4MovieHeaderAtomPtr mvhd; - MP4Err err; - err = MP4NoErr; - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - mvhd->timeScale = timeScale; - /* - !!! TODO: For each track, recalculate durations, including - segment times in edit lists !!! - */ + MP4MovieHeaderAtomPtr mvhd; + MP4Err err; + err = MP4NoErr; + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + mvhd->timeScale = timeScale; + /* + !!! TODO: For each track, recalculate durations, including + segment times in edit lists !!! + */ bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getTimeScale( struct MP4MovieAtom* self, u32 *outTimeScale ) +static MP4Err getTimeScale(struct MP4MovieAtom *self, u32 *outTimeScale) { - MP4MovieHeaderAtomPtr mvhd; - MP4Err err; - err = MP4NoErr; - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - *outTimeScale = mvhd->timeScale; + MP4MovieHeaderAtomPtr mvhd; + MP4Err err; + err = MP4NoErr; + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + *outTimeScale = mvhd->timeScale; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err setMatrix( struct MP4MovieAtom* self, u32 matrix[9] ) +static MP4Err setMatrix(struct MP4MovieAtom *self, u32 matrix[9]) { - MP4MovieHeaderAtomPtr mvhd; - MP4Err err; - err = MP4NoErr; - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - memcpy( &(mvhd->qt_matrixA), matrix, sizeof(ISOMatrixRecord) ); + MP4MovieHeaderAtomPtr mvhd; + MP4Err err; + err = MP4NoErr; + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + memcpy(&(mvhd->qt_matrixA), matrix, sizeof(ISOMatrixRecord)); /* mvhd->qt_matrixA = matrix[0]; - mvhd->qt_matrixB = matrix[1]; - mvhd->qt_matrixU = matrix[2]; - mvhd->qt_matrixC = matrix[3]; - mvhd->qt_matrixD = matrix[4]; - mvhd->qt_matrixV = matrix[5]; - mvhd->qt_matrixX = matrix[6]; - mvhd->qt_matrixY = matrix[7]; - mvhd->qt_matrixW = matrix[8]; */ + mvhd->qt_matrixB = matrix[1]; + mvhd->qt_matrixU = matrix[2]; + mvhd->qt_matrixC = matrix[3]; + mvhd->qt_matrixD = matrix[4]; + mvhd->qt_matrixV = matrix[5]; + mvhd->qt_matrixX = matrix[6]; + mvhd->qt_matrixY = matrix[7]; + mvhd->qt_matrixW = matrix[8]; */ bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getMatrix( struct MP4MovieAtom* self, u32 outMatrix[9] ) +static MP4Err getMatrix(struct MP4MovieAtom *self, u32 outMatrix[9]) { - MP4MovieHeaderAtomPtr mvhd; - MP4Err err; - err = MP4NoErr; - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - memcpy( outMatrix, &(mvhd->qt_matrixA), sizeof(ISOMatrixRecord) ); + MP4MovieHeaderAtomPtr mvhd; + MP4Err err; + err = MP4NoErr; + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + memcpy(outMatrix, &(mvhd->qt_matrixA), sizeof(ISOMatrixRecord)); /* outMatrix[0] = mvhd->qt_matrixA; - outMatrix[1] = mvhd->qt_matrixB; - outMatrix[2] = mvhd->qt_matrixU; - outMatrix[3] = mvhd->qt_matrixC; - outMatrix[4] = mvhd->qt_matrixD; - outMatrix[5] = mvhd->qt_matrixV; - outMatrix[6] = mvhd->qt_matrixX; - outMatrix[7] = mvhd->qt_matrixY; - outMatrix[8] = mvhd->qt_matrixW; */ + outMatrix[1] = mvhd->qt_matrixB; + outMatrix[2] = mvhd->qt_matrixU; + outMatrix[3] = mvhd->qt_matrixC; + outMatrix[4] = mvhd->qt_matrixD; + outMatrix[5] = mvhd->qt_matrixV; + outMatrix[6] = mvhd->qt_matrixX; + outMatrix[7] = mvhd->qt_matrixY; + outMatrix[8] = mvhd->qt_matrixW; */ bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err setPreferredRate( struct MP4MovieAtom* self, u32 rate ) +static MP4Err setPreferredRate(struct MP4MovieAtom *self, u32 rate) { - MP4MovieHeaderAtomPtr mvhd; - MP4Err err; - err = MP4NoErr; - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - mvhd->qt_preferredRate = rate; + MP4MovieHeaderAtomPtr mvhd; + MP4Err err; + err = MP4NoErr; + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + mvhd->qt_preferredRate = rate; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getPreferredRate( struct MP4MovieAtom* self, u32 *outRate ) +static MP4Err getPreferredRate(struct MP4MovieAtom *self, u32 *outRate) { - MP4MovieHeaderAtomPtr mvhd; - MP4Err err; - err = MP4NoErr; - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - if ( outRate == NULL ) - BAILWITHERROR( MP4BadParamErr ); - *outRate = mvhd->qt_preferredRate; + MP4MovieHeaderAtomPtr mvhd; + MP4Err err; + err = MP4NoErr; + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + if(outRate == NULL) BAILWITHERROR(MP4BadParamErr); + *outRate = mvhd->qt_preferredRate; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err setPreferredVolume( struct MP4MovieAtom* self, s16 volume ) +static MP4Err setPreferredVolume(struct MP4MovieAtom *self, s16 volume) { - MP4MovieHeaderAtomPtr mvhd; - MP4Err err; - err = MP4NoErr; - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - mvhd->qt_preferredVolume = volume; + MP4MovieHeaderAtomPtr mvhd; + MP4Err err; + err = MP4NoErr; + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + mvhd->qt_preferredVolume = volume; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getPreferredVolume( struct MP4MovieAtom* self, s16 *outVolume ) +static MP4Err getPreferredVolume(struct MP4MovieAtom *self, s16 *outVolume) { - MP4MovieHeaderAtomPtr mvhd; - MP4Err err; - err = MP4NoErr; - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - if ( outVolume == NULL ) - BAILWITHERROR( MP4BadParamErr ); - *outVolume = (s16) mvhd->qt_preferredVolume; + MP4MovieHeaderAtomPtr mvhd; + MP4Err err; + err = MP4NoErr; + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + if(outVolume == NULL) BAILWITHERROR(MP4BadParamErr); + *outVolume = (s16)mvhd->qt_preferredVolume; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err addTrack( struct MP4MovieAtom* self, MP4AtomPtr track ) +static MP4Err addTrack(struct MP4MovieAtom *self, MP4AtomPtr track) { - MP4Err err; - err = MP4NoErr; - err = addAtom( self, track ); if (err) goto bail; + MP4Err err; + err = MP4NoErr; + err = addAtom(self, track); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addAtom( MP4MovieAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4MovieAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - assert( atom ); - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; - switch( atom->type ) - { - case MP4ObjectDescriptorAtomType: - if ( self->iods ) - BAILWITHERROR( MP4BadDataErr ) - self->iods = atom; - break; - - case MP4MovieHeaderAtomType: - if ( self->mvhd ) - BAILWITHERROR( MP4BadDataErr ) - self->mvhd = atom; - break; - - case MP4UserDataAtomType: - if ( self->udta ) - BAILWITHERROR( MP4BadDataErr ) - self->udta = atom; - break; - - case MP4TrackAtomType: - err = MP4AddListEntry( atom, self->trackList ); if (err) goto bail; - break; - - case ISOMetaAtomType: - if ( self->meta ) - BAILWITHERROR( MP4BadDataErr ) - self->meta = atom; - break; - - case ISOAdditionalMetaDataContainerAtomType: - if ( self->meco ) - BAILWITHERROR( MP4BadDataErr ) - self->meco = atom; - break; - - case MP4MovieExtendsAtomType: - if ( self->mvex ) - BAILWITHERROR( MP4BadDataErr ) - self->mvex = atom; - break; - } + MP4Err err; + err = MP4NoErr; + assert(atom); + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; + switch(atom->type) + { + case MP4ObjectDescriptorAtomType: + if(self->iods) BAILWITHERROR(MP4BadDataErr) + self->iods = atom; + break; + + case MP4MovieHeaderAtomType: + if(self->mvhd) BAILWITHERROR(MP4BadDataErr) + self->mvhd = atom; + break; + + case MP4UserDataAtomType: + if(self->udta) BAILWITHERROR(MP4BadDataErr) + self->udta = atom; + break; + + case MP4TrackAtomType: + err = MP4AddListEntry(atom, self->trackList); + if(err) goto bail; + break; + + case ISOMetaAtomType: + if(self->meta) BAILWITHERROR(MP4BadDataErr) + self->meta = atom; + break; + + case ISOAdditionalMetaDataContainerAtomType: + if(self->meco) BAILWITHERROR(MP4BadDataErr) + self->meco = atom; + break; + + case MP4MovieExtendsAtomType: + if(self->mvex) BAILWITHERROR(MP4BadDataErr) + self->mvex = atom; + break; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static u32 getTrackCount( MP4MovieAtomPtr self ) +static u32 getTrackCount(MP4MovieAtomPtr self) { - u32 trackCount = 0; - MP4GetListEntryCount( self->trackList, &trackCount ); - return trackCount; + u32 trackCount = 0; + MP4GetListEntryCount(self->trackList, &trackCount); + return trackCount; } -static MP4Err setupTracks( MP4MovieAtomPtr self, MP4PrivateMovieRecordPtr moov ) +static MP4Err setupTracks(MP4MovieAtomPtr self, MP4PrivateMovieRecordPtr moov) { - u32 trackIdx; - u32 i; - MP4Err err; - u32 trackCount; - err = MP4NoErr; - - self->moov = moov; - trackCount = getTrackCount( self ); - for( i = 0, trackIdx = 0; i < trackCount; i++ ) - { - MP4TrackAtomPtr atom; - err = MP4GetListEntry( self->trackList, i, (char **) &atom ); if (err) goto bail; - atom->moov = self->moov; - } + u32 trackIdx; + u32 i; + MP4Err err; + u32 trackCount; + err = MP4NoErr; + + self->moov = moov; + trackCount = getTrackCount(self); + for(i = 0, trackIdx = 0; i < trackCount; i++) + { + MP4TrackAtomPtr atom; + err = MP4GetListEntry(self->trackList, i, (char **)&atom); + if(err) goto bail; + atom->moov = self->moov; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getIndTrack( struct MP4MovieAtom* self, u32 trackNumber, MP4AtomPtr *outTrack ) +static MP4Err getIndTrack(struct MP4MovieAtom *self, u32 trackNumber, MP4AtomPtr *outTrack) { - MP4Err err; - - err = MP4NoErr; - if ( (trackNumber == 0) || (outTrack == NULL) || (trackNumber > getTrackCount(self)) ) - BAILWITHERROR( MP4BadParamErr ) - err = MP4GetListEntry( self->trackList, trackNumber - 1, (char**) outTrack ); if (err) goto bail; + MP4Err err; + + err = MP4NoErr; + if((trackNumber == 0) || (outTrack == NULL) || (trackNumber > getTrackCount(self))) + BAILWITHERROR(MP4BadParamErr) + err = MP4GetListEntry(self->trackList, trackNumber - 1, (char **)outTrack); + if(err) goto bail; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getTrackExtendsAtom( struct MP4MovieAtom* self, u32 trackID, MP4AtomPtr *outTrack ) +static MP4Err getTrackExtendsAtom(struct MP4MovieAtom *self, u32 trackID, MP4AtomPtr *outTrack) { - MP4Err err; - MP4MovieExtendsAtomPtr mvex; - - err = MP4NoErr; - if ( (trackID == 0) || (outTrack == NULL) ) - BAILWITHERROR( MP4BadParamErr ) - mvex = (MP4MovieExtendsAtomPtr) self->mvex; - err = mvex->getTrackExtendsAtom( mvex, trackID, outTrack ); if (err) goto bail; + MP4Err err; + MP4MovieExtendsAtomPtr mvex; + + err = MP4NoErr; + if((trackID == 0) || (outTrack == NULL)) BAILWITHERROR(MP4BadParamErr) + mvex = (MP4MovieExtendsAtomPtr)self->mvex; + err = mvex->getTrackExtendsAtom(mvex, trackID, outTrack); + if(err) goto bail; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getTrackMedia( struct MP4MovieAtom* self, u32 trackID, MP4AtomPtr *outTrack ) +static MP4Err getTrackMedia(struct MP4MovieAtom *self, u32 trackID, MP4AtomPtr *outTrack) { - u32 trackIdx; - u32 i; - MP4Err err; - u32 trackCount; - err = MP4NoErr; - - if ( (trackID == 0) || (outTrack == NULL) ) - BAILWITHERROR( MP4BadParamErr ) - - MP4GetListEntryCount( self->trackList, &trackCount ); - for( i = 0, trackIdx = 0; i < trackCount; i++ ) - { - MP4TrackAtomPtr trak; - - err = MP4GetListEntry( self->trackList, i, (char **) &trak ); if (err) goto bail; - - if (trak->type == MP4TrackAtomType) - { - MP4TrackHeaderAtomPtr tkhd; - tkhd = (MP4TrackHeaderAtomPtr) trak->trackHeader; - if (tkhd->trackID == trackID) { - *outTrack = (MP4AtomPtr) (trak->trackMedia); - break; - } - } - } + u32 trackIdx; + u32 i; + MP4Err err; + u32 trackCount; + err = MP4NoErr; + + if((trackID == 0) || (outTrack == NULL)) BAILWITHERROR(MP4BadParamErr) + + MP4GetListEntryCount(self->trackList, &trackCount); + for(i = 0, trackIdx = 0; i < trackCount; i++) + { + MP4TrackAtomPtr trak; + + err = MP4GetListEntry(self->trackList, i, (char **)&trak); + if(err) goto bail; + + if(trak->type == MP4TrackAtomType) + { + MP4TrackHeaderAtomPtr tkhd; + tkhd = (MP4TrackHeaderAtomPtr)trak->trackHeader; + if(tkhd->trackID == trackID) + { + *outTrack = (MP4AtomPtr)(trak->trackMedia); + break; + } + } + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getSampleDescriptionIndex( struct MP4MovieAtom *self, u32 trackID, u32* sd_index ) +static MP4Err getSampleDescriptionIndex(struct MP4MovieAtom *self, u32 trackID, u32 *sd_index) { - MP4MediaAtomPtr mdia; - MP4SampleTableAtomPtr stbl; - MP4Err err; - - err = MP4NoErr; - - err = getTrackMedia( self, trackID, (MP4AtomPtr*) &mdia ); if (err) goto bail; - stbl = ((MP4SampleTableAtomPtr) - ((MP4MediaInformationAtomPtr) - mdia->information)->sampleTable); - - *sd_index = stbl->getCurrentSampleEntryIndex( stbl ); - + MP4MediaAtomPtr mdia; + MP4SampleTableAtomPtr stbl; + MP4Err err; + + err = MP4NoErr; + + err = getTrackMedia(self, trackID, (MP4AtomPtr *)&mdia); + if(err) goto bail; + stbl = ((MP4SampleTableAtomPtr)((MP4MediaInformationAtomPtr)mdia->information)->sampleTable); + + *sd_index = stbl->getCurrentSampleEntryIndex(stbl); + bail: - TEST_RETURN( err ); - return err; -} + TEST_RETURN(err); + return err; +} -static MP4Err settrackfragment (struct MP4MovieAtom *self, u32 trackID, MP4AtomPtr fragment ) +static MP4Err settrackfragment(struct MP4MovieAtom *self, u32 trackID, MP4AtomPtr fragment) { - u32 trackIdx; - u32 i; - MP4Err err; - u32 trackCount; - err = MP4NoErr; - - trackCount = getTrackCount( self ); - for( i = 0, trackIdx = 0; i < trackCount; i++ ) - { - MP4TrackAtomPtr atom; - err = MP4GetListEntry( self->trackList, i, (char **) &atom ); if (err) goto bail; - err = atom->settrackfragment( atom, trackID, fragment ); if (err) goto bail; - } + u32 trackIdx; + u32 i; + MP4Err err; + u32 trackCount; + err = MP4NoErr; + + trackCount = getTrackCount(self); + for(i = 0, trackIdx = 0; i < trackCount; i++) + { + MP4TrackAtomPtr atom; + err = MP4GetListEntry(self->trackList, i, (char **)&atom); + if(err) goto bail; + err = atom->settrackfragment(atom, trackID, fragment); + if(err) goto bail; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateDuration( struct MP4MovieAtom* self ) +static MP4Err calculateDuration(struct MP4MovieAtom *self) { - MP4MovieHeaderAtomPtr mvhd; - u32 maxDuration; - u32 timeScale; - u32 trackCount; - u32 i; - MP4Err err; - - maxDuration = 0; - err = MP4NoErr; - mvhd = (MP4MovieHeaderAtomPtr) self->mvhd; - if ( mvhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - err = getTimeScale( self, &timeScale ); if (err) goto bail; - trackCount = getTrackCount( self ); - - for ( i = 0; i < trackCount; i++ ) - { - MP4TrackAtomPtr trak; - u32 trackDuration; - - err = MP4GetListEntry( self->trackList, i, (char**) &trak ); if (err) goto bail; - if ( trak == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - err = trak->calculateDuration( trak, timeScale ); if (err) goto bail; - err = trak->getDuration( trak, &trackDuration ); if (err) goto bail; - if ( trackDuration > maxDuration ) - maxDuration = trackDuration; - } - mvhd->duration = maxDuration; + MP4MovieHeaderAtomPtr mvhd; + u32 maxDuration; + u32 timeScale; + u32 trackCount; + u32 i; + MP4Err err; + + maxDuration = 0; + err = MP4NoErr; + mvhd = (MP4MovieHeaderAtomPtr)self->mvhd; + if(mvhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + err = getTimeScale(self, &timeScale); + if(err) goto bail; + trackCount = getTrackCount(self); + + for(i = 0; i < trackCount; i++) + { + MP4TrackAtomPtr trak; + u32 trackDuration; + + err = MP4GetListEntry(self->trackList, i, (char **)&trak); + if(err) goto bail; + if(trak == NULL) BAILWITHERROR(MP4InvalidMediaErr); + err = trak->calculateDuration(trak, timeScale); + if(err) goto bail; + err = trak->getDuration(trak, &trackDuration); + if(err) goto bail; + if(trackDuration > maxDuration) maxDuration = trackDuration; + } + mvhd->duration = maxDuration; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err mdatMoved( struct MP4MovieAtom* self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) +static MP4Err mdatMoved(struct MP4MovieAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset) { - u32 trackCount; - u32 i; - MP4Err err; - ISOMetaAtomPtr meta; - ISOAdditionalMetaDataContainerAtomPtr meco; - - err = MP4NoErr; - - trackCount = getTrackCount( self ); - - for ( i = 0; i < trackCount; i++ ) - { - MP4TrackAtomPtr trak; - err = MP4GetListEntry( self->trackList, i, (char**) &trak ); if (err) goto bail; - if ( trak == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - err = trak->mdatMoved( trak, mdatBase, mdatEnd, mdatOffset ); if (err) goto bail; - } - - meta = (ISOMetaAtomPtr) self->meta; - if (meta) { - err = meta->mdatMoved( meta, mdatBase, mdatEnd, mdatOffset ); if (err) goto bail; - } - - meco = (ISOAdditionalMetaDataContainerAtomPtr) self->meco; - if (meco) { - err = meco->mdatMoved( meco, mdatBase, mdatEnd, mdatOffset ); if (err) goto bail; - } + u32 trackCount; + u32 i; + MP4Err err; + ISOMetaAtomPtr meta; + ISOAdditionalMetaDataContainerAtomPtr meco; + + err = MP4NoErr; + + trackCount = getTrackCount(self); + + for(i = 0; i < trackCount; i++) + { + MP4TrackAtomPtr trak; + err = MP4GetListEntry(self->trackList, i, (char **)&trak); + if(err) goto bail; + if(trak == NULL) BAILWITHERROR(MP4InvalidMediaErr); + err = trak->mdatMoved(trak, mdatBase, mdatEnd, mdatOffset); + if(err) goto bail; + } + + meta = (ISOMetaAtomPtr)self->meta; + if(meta) + { + err = meta->mdatMoved(meta, mdatBase, mdatEnd, mdatOffset); + if(err) goto bail; + } + + meco = (ISOAdditionalMetaDataContainerAtomPtr)self->meco; + if(meco) + { + err = meco->mdatMoved(meco, mdatBase, mdatEnd, mdatOffset); + if(err) goto bail; + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err mdatArrived( struct MP4MovieAtom* self, MP4AtomPtr mdat ) +static MP4Err mdatArrived(struct MP4MovieAtom *self, MP4AtomPtr mdat) { - u32 trackCount; - u32 i; - MP4Err err; - ISOMetaAtomPtr meta; - ISOAdditionalMetaDataContainerAtomPtr meco; - - err = MP4NoErr; - - meta = (ISOMetaAtomPtr) self->meta; - if (meta) { meta->setMdat( meta, mdat ); } - - meco = (ISOAdditionalMetaDataContainerAtomPtr) self->meco; - if (meco) { meco->setMdat( meco, mdat ); } - - trackCount = getTrackCount( self ); - - for ( i = 0; i < trackCount; i++ ) - { - MP4TrackAtomPtr trak; - err = MP4GetListEntry( self->trackList, i, (char**) &trak ); if (err) goto bail; - if ( trak == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - err = trak->mdatArrived( trak, mdat ); if (err) goto bail; - } + u32 trackCount; + u32 i; + MP4Err err; + ISOMetaAtomPtr meta; + ISOAdditionalMetaDataContainerAtomPtr meco; + + err = MP4NoErr; + + meta = (ISOMetaAtomPtr)self->meta; + if(meta) + { + meta->setMdat(meta, mdat); + } + + meco = (ISOAdditionalMetaDataContainerAtomPtr)self->meco; + if(meco) + { + meco->setMdat(meco, mdat); + } + + trackCount = getTrackCount(self); + + for(i = 0; i < trackCount; i++) + { + MP4TrackAtomPtr trak; + err = MP4GetListEntry(self->trackList, i, (char **)&trak); + if(err) goto bail; + if(trak == NULL) BAILWITHERROR(MP4InvalidMediaErr); + err = trak->mdatArrived(trak, mdat); + if(err) goto bail; + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4MovieAtomPtr self = (MP4MovieAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4MovieAtomPtr self = (MP4MovieAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4MovieAtomPtr self = (MP4MovieAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE( atomList ); + MP4Err err; + MP4MovieAtomPtr self = (MP4MovieAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MP4MovieAtom) + PARSE_ATOM_LIST(MP4MovieAtom) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateMovieAtom( MP4MovieAtomPtr *outAtom ) +MP4Err MP4CreateMovieAtom(MP4MovieAtomPtr *outAtom) { - MP4Err err; - MP4MovieAtomPtr self; - - self = (MP4MovieAtomPtr) calloc( 1, sizeof(MP4MovieAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); if ( err ) goto bail; - self->type = MP4MovieAtomType; - self->name = "movie"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->setupTracks = setupTracks; - self->addTrack = addTrack; - self->addAtom = addAtom; - self->newTrack = newTrack; - self->calculateDuration = calculateDuration; - self->getNextTrackID = getNextTrackID; - self->setTimeScale = setTimeScale; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->trackList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->getTrackCount = getTrackCount; - self->getIndTrack = getIndTrack; - self->getTimeScale = getTimeScale; - self->setMatrix = setMatrix; - self->getMatrix = getMatrix; - self->setPreferredRate = setPreferredRate; - self->getPreferredRate = getPreferredRate; - self->setPreferredVolume = setPreferredVolume; - self->getPreferredVolume = getPreferredVolume; - self->mdatMoved = mdatMoved; - self->mdatArrived = mdatArrived; - self->newTrackWithID = newTrackWithID; - self->settrackfragment = settrackfragment; - self->getTrackExtendsAtom = getTrackExtendsAtom; - self->getTrackMedia = getTrackMedia; - self->getSampleDescriptionIndex = getSampleDescriptionIndex; - - self->meta = NULL; - self->meco = NULL; - - *outAtom = self; + MP4Err err; + MP4MovieAtomPtr self; + + self = (MP4MovieAtomPtr)calloc(1, sizeof(MP4MovieAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4MovieAtomType; + self->name = "movie"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->setupTracks = setupTracks; + self->addTrack = addTrack; + self->addAtom = addAtom; + self->newTrack = newTrack; + self->calculateDuration = calculateDuration; + self->getNextTrackID = getNextTrackID; + self->setTimeScale = setTimeScale; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + err = MP4MakeLinkedList(&self->trackList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->getTrackCount = getTrackCount; + self->getIndTrack = getIndTrack; + self->getTimeScale = getTimeScale; + self->setMatrix = setMatrix; + self->getMatrix = getMatrix; + self->setPreferredRate = setPreferredRate; + self->getPreferredRate = getPreferredRate; + self->setPreferredVolume = setPreferredVolume; + self->getPreferredVolume = getPreferredVolume; + self->mdatMoved = mdatMoved; + self->mdatArrived = mdatArrived; + self->newTrackWithID = newTrackWithID; + self->settrackfragment = settrackfragment; + self->getTrackExtendsAtom = getTrackExtendsAtom; + self->getTrackMedia = getTrackMedia; + self->getSampleDescriptionIndex = getSampleDescriptionIndex; + + self->meta = NULL; + self->meco = NULL; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MovieExtendsAtom.c b/IsoLib/libisomediafile/src/MovieExtendsAtom.c index c565011..a8b5ce9 100644 --- a/IsoLib/libisomediafile/src/MovieExtendsAtom.c +++ b/IsoLib/libisomediafile/src/MovieExtendsAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,322 +15,354 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieExtendsAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieExtendsAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include +static void destroy(MP4AtomPtr s) +{ + MP4Err err; + MP4MovieExtendsAtomPtr self; + + self = (MP4MovieExtendsAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = MP4DeleteLinkedList(self->trackExtendsList); + if(err) goto bail; + err = MP4DeleteLinkedList(self->trackExtensionPropertiesList); + if(err) goto bail; + + if(self->super) self->super->destroy(s); + +bail: + TEST_RETURN(err); + + return; +} -static void destroy( MP4AtomPtr s ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4MovieExtendsAtomPtr self; + MP4Err err; + MP4MovieExtendsAtomPtr self = (MP4MovieExtendsAtomPtr)s; + err = MP4NoErr; - self = (MP4MovieExtendsAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = MP4DeleteLinkedList( self->trackExtendsList ); if (err) goto bail; - err = MP4DeleteLinkedList( self->trackExtensionPropertiesList ); if (err) goto bail; - - if ( self->super ) - self->super->destroy( s ); + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(trackExtendsList); + SERIALIZE_ATOM_LIST(trackExtensionPropertiesList); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4MovieExtendsAtomPtr self = (MP4MovieExtendsAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( trackExtendsList ); - SERIALIZE_ATOM_LIST( trackExtensionPropertiesList ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4MovieExtendsAtomPtr self = (MP4MovieExtendsAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(trackExtendsList); + ADD_ATOM_LIST_SIZE(trackExtensionPropertiesList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err addAtom(MP4MovieExtendsAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - MP4MovieExtendsAtomPtr self = (MP4MovieExtendsAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - - ADD_ATOM_LIST_SIZE( trackExtendsList ); - ADD_ATOM_LIST_SIZE( trackExtensionPropertiesList ); + MP4Err err; + err = MP4NoErr; + + if(self == 0) BAILWITHERROR(MP4BadParamErr); + + switch(atom->type) + { + case MP4TrackExtendsAtomType: + err = MP4AddListEntry(atom, self->trackExtendsList); + break; + case MP4TrackExtensionPropertiesAtomType: + err = MP4AddListEntry(atom, self->trackExtensionPropertiesList); + break; + default: + BAILWITHERROR(MP4BadDataErr) + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addAtom( MP4MovieExtendsAtomPtr self, MP4AtomPtr atom ) +static MP4Err setCompositionToDecodeProperties(struct MP4MovieExtendsAtom *self, u32 trackID, + s32 compositionToDTSShift, + s32 leastDecodeToDisplayDelta, + s32 greatestDecodeToDisplayDelta, + s32 compositionStartTime, s32 compositionEndTime) { - MP4Err err; - err = MP4NoErr; - - if ( self == 0 ) - BAILWITHERROR( MP4BadParamErr ); - - switch (atom->type) - { - case MP4TrackExtendsAtomType: err = MP4AddListEntry( atom, self->trackExtendsList ); break; - case MP4TrackExtensionPropertiesAtomType: err = MP4AddListEntry( atom, self->trackExtensionPropertiesList ); break; - default: BAILWITHERROR( MP4BadDataErr ) - } + MP4Err err; + MP4TrackExtensionPropertiesAtomPtr trep; + MP4CompositionToDecodeAtomPtr cslg; + u8 createCslg; + + err = MP4NoErr; + createCslg = 0; + + trep = NULL; + self->getTrackExtensionPropertiesAtom(self, trackID, (MP4AtomPtr *)&trep); + + if(trep != NULL) + { + cslg = NULL; + trep->getAtom(trep, MP4CompositionToDecodeAtomType, (MP4AtomPtr *)&cslg); + if(cslg == NULL) createCslg = 1; + } + else + { + err = MP4CreateTrackExtensionPropertiesAtom(&trep); + if(err) goto bail; + trep->track_id = trackID; + err = self->addAtom(self, (MP4AtomPtr)trep); + if(err) goto bail; + createCslg = 1; + } + + if(createCslg == 1) + { + err = MP4CreateCompositionToDecodeAtom(&cslg); + if(err) goto bail; + trep->addAtom(trep, (MP4AtomPtr)cslg); + } + + cslg->compositionToDTSShift = compositionToDTSShift; + cslg->leastDecodeToDisplayDelta = leastDecodeToDisplayDelta; + cslg->greatestDecodeToDisplayDelta = greatestDecodeToDisplayDelta; + cslg->compositionStartTime = compositionStartTime; + cslg->compositionEndTime = compositionEndTime; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err setCompositionToDecodeProperties(struct MP4MovieExtendsAtom *self, u32 trackID, s32 compositionToDTSShift, s32 leastDecodeToDisplayDelta, - s32 greatestDecodeToDisplayDelta, s32 compositionStartTime, s32 compositionEndTime) +static MP4Err maketrackfragments(struct MP4MovieExtendsAtom *self, MP4MovieFragmentAtomPtr moof, + MP4MovieAtomPtr moov, MP4MediaDataAtomPtr mdat) { - MP4Err err; - MP4TrackExtensionPropertiesAtomPtr trep; - MP4CompositionToDecodeAtomPtr cslg; - u8 createCslg; - - err = MP4NoErr; - createCslg = 0; - - trep = NULL; - self->getTrackExtensionPropertiesAtom(self, trackID, (MP4AtomPtr *) &trep); - - if (trep != NULL) - { - cslg = NULL; - trep->getAtom(trep, MP4CompositionToDecodeAtomType, (MP4AtomPtr *) &cslg); - if (cslg == NULL) - createCslg = 1; - } - else - { - err = MP4CreateTrackExtensionPropertiesAtom(&trep); if (err) goto bail; - trep->track_id = trackID; - err = self->addAtom(self, (MP4AtomPtr) trep); if (err) goto bail; - createCslg = 1; - } - - if (createCslg == 1) + u32 trackIdx; + u32 i; + MP4Err err; + u32 trackCount; + err = MP4NoErr; + + MP4GetListEntryCount(self->trackExtendsList, &trackCount); + for(i = 0, trackIdx = 0; i < trackCount; i++) + { + MP4TrackExtendsAtomPtr trex; + MP4TrackFragmentAtomPtr traf; + MP4TrackFragmentHeaderAtomPtr tfhd; + MP4TrackFragmentDecodeTimeAtomPtr tfdt; + + err = MP4GetListEntry(self->trackExtendsList, i, (char **)&trex); + if(err) goto bail; + + err = MP4CreateTrackFragmentAtom(&traf); + if(err) goto bail; + err = MP4CreateTrackFragmentHeaderAtom(&tfhd); + if(err) goto bail; + err = MP4CreateTrackFragmentDecodeTimeAtom(&tfdt); + if(err) goto bail; + + traf->tfhd = (MP4AtomPtr)tfhd; + traf->tfdt = (MP4AtomPtr)tfdt; + traf->trex = (MP4AtomPtr)trex; + traf->mdat = mdat; + + traf->default_sample_description_index = trex->default_sample_description_index; + traf->default_sample_duration = trex->default_sample_duration; + traf->default_sample_size = trex->default_sample_size; + traf->default_sample_flags = trex->default_sample_flags; + + if(trex->isInitialMediaDecodeTimeAdded == 0) { - err = MP4CreateCompositionToDecodeAtom(&cslg); if (err) goto bail; - trep->addAtom(trep, (MP4AtomPtr) cslg); + MP4MediaAtomPtr mdia; + MP4Track trak; + u64 initialMediaDuration; + + err = moov->getTrackMedia(moov, trex->trackID, (MP4AtomPtr *)&mdia); + if(err) goto bail; + err = MP4GetMediaTrack((MP4Media)mdia, &trak); + if(err) goto bail; + err = MP4GetMediaDuration((MP4Media)mdia, &initialMediaDuration); + if(err) goto bail; + + trex->baseMediaDecodeTime = initialMediaDuration; + trex->isInitialMediaDecodeTimeAdded = 1; } - - cslg->compositionToDTSShift = compositionToDTSShift; - cslg->leastDecodeToDisplayDelta = leastDecodeToDisplayDelta; - cslg->greatestDecodeToDisplayDelta = greatestDecodeToDisplayDelta; - cslg->compositionStartTime = compositionStartTime; - cslg->compositionEndTime = compositionEndTime; -bail: - TEST_RETURN( err ); - - return err; -} + tfdt->baseMediaDecodeTime = trex->baseMediaDecodeTime; -static MP4Err maketrackfragments (struct MP4MovieExtendsAtom *self, MP4MovieFragmentAtomPtr moof, MP4MovieAtomPtr moov, MP4MediaDataAtomPtr mdat ) -{ - u32 trackIdx; - u32 i; - MP4Err err; - u32 trackCount; - err = MP4NoErr; - - MP4GetListEntryCount( self->trackExtendsList, &trackCount ); - for( i = 0, trackIdx = 0; i < trackCount; i++ ) - { - MP4TrackExtendsAtomPtr trex; - MP4TrackFragmentAtomPtr traf; - MP4TrackFragmentHeaderAtomPtr tfhd; - MP4TrackFragmentDecodeTimeAtomPtr tfdt; - - err = MP4GetListEntry( self->trackExtendsList, i, (char **) &trex ); if (err) goto bail; - - err = MP4CreateTrackFragmentAtom( &traf ); if (err) goto bail; - err = MP4CreateTrackFragmentHeaderAtom( &tfhd ); if (err) goto bail; - err = MP4CreateTrackFragmentDecodeTimeAtom( &tfdt ); if (err) goto bail; - - traf->tfhd = (MP4AtomPtr) tfhd; - traf->tfdt = (MP4AtomPtr) tfdt; - traf->trex = (MP4AtomPtr) trex; - traf->mdat = mdat; - - traf->default_sample_description_index = trex->default_sample_description_index; - traf->default_sample_duration = trex->default_sample_duration; - traf->default_sample_size = trex->default_sample_size; - traf->default_sample_flags = trex->default_sample_flags; - - if (trex->isInitialMediaDecodeTimeAdded == 0) - { - MP4MediaAtomPtr mdia; - MP4Track trak; - u64 initialMediaDuration; - - err = moov->getTrackMedia( moov, trex->trackID, (MP4AtomPtr*) &mdia ); if (err) goto bail; - err = MP4GetMediaTrack( (MP4Media) mdia, &trak ); if (err) goto bail; - err = MP4GetMediaDuration( (MP4Media) mdia, &initialMediaDuration ); if (err) goto bail; - - trex->baseMediaDecodeTime = initialMediaDuration; - trex->isInitialMediaDecodeTimeAdded = 1; - } - - tfdt->baseMediaDecodeTime = trex->baseMediaDecodeTime; - - tfhd->trackID = trex->trackID; - tfhd->sample_description_index = trex->default_sample_description_index; - /* if we ever allow flipping of sample descriptions, this should be copied from the - last fragment, and only the movie for the first one */ - - err = moov->settrackfragment( moov, trex->trackID, (MP4AtomPtr) traf ); if (err) goto bail; - err = moof->addAtom( moof, (MP4AtomPtr) traf ); if (err) goto bail; - } + tfhd->trackID = trex->trackID; + tfhd->sample_description_index = trex->default_sample_description_index; + /* if we ever allow flipping of sample descriptions, this should be copied from the + last fragment, and only the movie for the first one */ + + err = moov->settrackfragment(moov, trex->trackID, (MP4AtomPtr)traf); + if(err) goto bail; + err = moof->addAtom(moof, (MP4AtomPtr)traf); + if(err) goto bail; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getTrackExtendsAtom( struct MP4MovieExtendsAtom* self, u32 trackID, MP4AtomPtr *outTrack ) +static MP4Err getTrackExtendsAtom(struct MP4MovieExtendsAtom *self, u32 trackID, + MP4AtomPtr *outTrack) { - u32 i; - MP4Err err; - u32 trackCount; - err = MP4NoErr; - - MP4GetListEntryCount( self->trackExtendsList, &trackCount ); - for( i = 0; i < trackCount; i++ ) - { - MP4TrackExtendsAtomPtr trex; - - err = MP4GetListEntry( self->trackExtendsList, i, (char **) &trex ); if (err) goto bail; - - if ((trex->type == MP4TrackExtendsAtomType) && (trex->trackID == trackID)) { - *outTrack = (MP4AtomPtr) trex; - break; - } - } + u32 i; + MP4Err err; + u32 trackCount; + err = MP4NoErr; + + MP4GetListEntryCount(self->trackExtendsList, &trackCount); + for(i = 0; i < trackCount; i++) + { + MP4TrackExtendsAtomPtr trex; + + err = MP4GetListEntry(self->trackExtendsList, i, (char **)&trex); + if(err) goto bail; + + if((trex->type == MP4TrackExtendsAtomType) && (trex->trackID == trackID)) + { + *outTrack = (MP4AtomPtr)trex; + break; + } + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getTrackExtensionPropertiesAtom( struct MP4MovieExtendsAtom* self, u32 trackID, MP4AtomPtr *outProbs ) +static MP4Err getTrackExtensionPropertiesAtom(struct MP4MovieExtendsAtom *self, u32 trackID, + MP4AtomPtr *outProbs) { - u32 i; - MP4Err err; - u32 probCount; - err = MP4NoErr; - - MP4GetListEntryCount( self->trackExtensionPropertiesList, &probCount ); - for( i = 0; i < probCount; i++ ) + u32 i; + MP4Err err; + u32 probCount; + err = MP4NoErr; + + MP4GetListEntryCount(self->trackExtensionPropertiesList, &probCount); + for(i = 0; i < probCount; i++) + { + MP4TrackExtensionPropertiesAtomPtr trep; + + err = MP4GetListEntry(self->trackExtendsList, i, (char **)&trep); + if(err) goto bail; + + if((trep->type == MP4TrackExtensionPropertiesAtomType) && (trep->track_id == trackID)) { - MP4TrackExtensionPropertiesAtomPtr trep; - - err = MP4GetListEntry( self->trackExtendsList, i, (char **) &trep ); if (err) goto bail; - - if ((trep->type == MP4TrackExtensionPropertiesAtomType) && (trep->track_id == trackID)) { - *outProbs = (MP4AtomPtr) trep; - break; - } + *outProbs = (MP4AtomPtr)trep; + break; } + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err setSampleDescriptionIndexes( struct MP4MovieExtendsAtom* self, MP4AtomPtr moov ) +static MP4Err setSampleDescriptionIndexes(struct MP4MovieExtendsAtom *self, MP4AtomPtr moov) { - u32 i; - MP4Err err; - u32 trackCount; - err = MP4NoErr; - - MP4GetListEntryCount( self->trackExtendsList, &trackCount ); - for( i = 0; i < trackCount; i++ ) - { - MP4TrackExtendsAtomPtr trex; - u32 sd_index; - - err = MP4GetListEntry( self->trackExtendsList, i, (char **) &trex ); if (err) goto bail; - - err = ((MP4MovieAtomPtr) moov)->getSampleDescriptionIndex( (MP4MovieAtom*) moov, trex->trackID, &sd_index ); if (err) goto bail; - trex->default_sample_description_index = sd_index; - } + u32 i; + MP4Err err; + u32 trackCount; + err = MP4NoErr; + + MP4GetListEntryCount(self->trackExtendsList, &trackCount); + for(i = 0; i < trackCount; i++) + { + MP4TrackExtendsAtomPtr trex; + u32 sd_index; + + err = MP4GetListEntry(self->trackExtendsList, i, (char **)&trex); + if(err) goto bail; + + err = ((MP4MovieAtomPtr)moov) + ->getSampleDescriptionIndex((MP4MovieAtom *)moov, trex->trackID, &sd_index); + if(err) goto bail; + trex->default_sample_description_index = sd_index; + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4MovieExtendsAtomPtr self = (MP4MovieExtendsAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GETATOM_LIST( trackExtendsList ); - GETATOM_LIST( trackExtensionPropertiesList ); - - assert( self->bytesRead == self->size ); - + MP4Err err; + MP4MovieExtendsAtomPtr self = (MP4MovieExtendsAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GETATOM_LIST(trackExtendsList); + GETATOM_LIST(trackExtensionPropertiesList); + + assert(self->bytesRead == self->size); + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err MP4CreateMovieExtendsAtom( MP4MovieExtendsAtomPtr *outAtom ) +MP4Err MP4CreateMovieExtendsAtom(MP4MovieExtendsAtomPtr *outAtom) { - MP4Err err; - MP4MovieExtendsAtomPtr self; - - self = (MP4MovieExtendsAtomPtr) calloc( 1, sizeof(MP4MovieExtendsAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4MovieExtendsAtomType; - self->name = "movie extends"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addAtom = addAtom; - self->maketrackfragments = maketrackfragments; - self->getTrackExtendsAtom = getTrackExtendsAtom; - self->getTrackExtensionPropertiesAtom = getTrackExtensionPropertiesAtom; - self->setSampleDescriptionIndexes = setSampleDescriptionIndexes; - self->setCompositionToDecodeProperties = setCompositionToDecodeProperties; - - err = MP4MakeLinkedList( &self->trackExtendsList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->trackExtensionPropertiesList ); if (err) goto bail; - - *outAtom = self; + MP4Err err; + MP4MovieExtendsAtomPtr self; + + self = (MP4MovieExtendsAtomPtr)calloc(1, sizeof(MP4MovieExtendsAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4MovieExtendsAtomType; + self->name = "movie extends"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addAtom = addAtom; + self->maketrackfragments = maketrackfragments; + self->getTrackExtendsAtom = getTrackExtendsAtom; + self->getTrackExtensionPropertiesAtom = getTrackExtensionPropertiesAtom; + self->setSampleDescriptionIndexes = setSampleDescriptionIndexes; + self->setCompositionToDecodeProperties = setCompositionToDecodeProperties; + + err = MP4MakeLinkedList(&self->trackExtendsList); + if(err) goto bail; + err = MP4MakeLinkedList(&self->trackExtensionPropertiesList); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MovieFragmentAtom.c b/IsoLib/libisomediafile/src/MovieFragmentAtom.c index d189a09..5268390 100644 --- a/IsoLib/libisomediafile/src/MovieFragmentAtom.c +++ b/IsoLib/libisomediafile/src/MovieFragmentAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,265 +15,283 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieFragmentAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieFragmentAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include - -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4MovieFragmentAtomPtr self; + MP4Err err; + MP4MovieFragmentAtomPtr self; - self = (MP4MovieFragmentAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST_F( atomList ); - (self->mfhd)->destroy( (MP4AtomPtr) (self->mfhd) ); - if ( self->super ) - self->super->destroy( s ); + self = (MP4MovieFragmentAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST_F(atomList); + (self->mfhd)->destroy((MP4AtomPtr)(self->mfhd)); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err mdatMoved( struct MP4MovieAtom* s, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) +static MP4Err mdatMoved(struct MP4MovieAtom *s, u64 mdatBase, u64 mdatEnd, s32 mdatOffset) { - u32 trackCount; - u32 i; - MP4Err err; - MP4MovieFragmentAtomPtr self; - - self = (MP4MovieFragmentAtomPtr) s; - - err = MP4NoErr; - - MP4GetListEntryCount( self->atomList, &trackCount ); - - for ( i = 0; i < trackCount; i++ ) - { - MP4TrackFragmentAtomPtr traf; - err = MP4GetListEntry( self->atomList, i, (char**) &traf ); if (err) goto bail; - if ( traf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - err = traf->mdatMoved( (struct MP4MediaInformationAtom *) traf, mdatBase, mdatEnd, mdatOffset ); if (err) goto bail; - } + u32 trackCount; + u32 i; + MP4Err err; + MP4MovieFragmentAtomPtr self; + + self = (MP4MovieFragmentAtomPtr)s; + + err = MP4NoErr; + + MP4GetListEntryCount(self->atomList, &trackCount); + + for(i = 0; i < trackCount; i++) + { + MP4TrackFragmentAtomPtr traf; + err = MP4GetListEntry(self->atomList, i, (char **)&traf); + if(err) goto bail; + if(traf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + err = traf->mdatMoved((struct MP4MediaInformationAtom *)traf, mdatBase, mdatEnd, mdatOffset); + if(err) goto bail; + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err mergeFragments( struct MP4MovieFragmentAtom* self, MP4MovieAtomPtr moov ) +static MP4Err mergeFragments(struct MP4MovieFragmentAtom *self, MP4MovieAtomPtr moov) { - u32 trackCount; - u32 i; - MP4Err err; - - u64 base_offset; - u32 traf_data_end; - - err = MP4NoErr; - - MP4GetListEntryCount( self->atomList, &trackCount ); - - base_offset = self->streamOffset; - - for ( i = 0; i < trackCount; i++ ) - { - MP4TrackFragmentAtomPtr traf; - MP4TrackFragmentHeaderAtomPtr tfhd; - MP4TrackExtendsAtomPtr trex; - MP4MediaAtomPtr mdia; - MP4Track trak; - u64 mediaDuration, initialMediaDuration; - u32 tfhd_flags; - - err = MP4GetListEntry( self->atomList, i, (char**) &traf ); if (err) goto bail; - if ( traf == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - tfhd = (MP4TrackFragmentHeaderAtomPtr) traf->tfhd; - - err = moov->getTrackExtendsAtom( moov, tfhd->trackID, (MP4AtomPtr*) &trex ); if (err) goto bail; - - traf->default_sample_description_index = trex->default_sample_description_index; - traf->default_sample_duration = trex->default_sample_duration; - traf->default_sample_size = trex->default_sample_size; - traf->default_sample_flags = trex->default_sample_flags; - - tfhd_flags = tfhd->flags; - - if ((tfhd_flags & tfhd_sample_description_index_present)==0) - tfhd->sample_description_index = trex->default_sample_description_index; - if ((tfhd_flags & tfhd_default_sample_duration_present)==0) - tfhd->default_sample_duration = trex->default_sample_duration; - if ((tfhd_flags & tfhd_default_sample_size_present)==0) - tfhd->default_sample_size = trex->default_sample_size; - if ((tfhd_flags & tfhd_default_sample_flags_present)==0) - tfhd->default_sample_flags = trex->default_sample_flags; - if ((tfhd_flags & tfhd_base_data_offset_present)==0) - tfhd->base_data_offset = (tfhd_flags & tfhd_default_base_is_moof ? - self->streamOffset : base_offset); - - err = traf->calculateDataEnd( traf, &traf_data_end ); if (err) goto bail; - base_offset = traf_data_end; - - err = moov->getTrackMedia( moov, tfhd->trackID, (MP4AtomPtr*) &mdia ); if (err) goto bail; - err = MP4GetMediaTrack( (MP4Media) mdia, &trak ); if (err) goto bail; - - err = MP4GetMediaDuration( (MP4Media) mdia, &initialMediaDuration ); if (err) goto bail; - - if ( traf->tfdt ) - { - MP4TrackFragmentDecodeTimeAtomPtr tfdt; - tfdt = (MP4TrackFragmentDecodeTimeAtomPtr) traf->tfdt; - - if ( tfdt->baseMediaDecodeTime < initialMediaDuration ) - BAILWITHERROR( MP4InvalidMediaErr ); - - if ( tfdt->baseMediaDecodeTime > initialMediaDuration ) - err = mdia->extendLastSampleDuration( mdia, tfdt->baseMediaDecodeTime - initialMediaDuration ); if (err) goto bail; - } - - if ( (tfhd_flags & tfhd_duration_is_empty) ) /* BAILWITHERROR( MP4NotImplementedErr ) */ - { - /* if there is not already an edit list, and there is media, insert an edit covering the current track duration */ - if ((initialMediaDuration>0) && (((MP4TrackAtomPtr) trak)->trackEditAtom == 0)) { - err = MP4InsertMediaIntoTrack( trak, -1, 0, initialMediaDuration, 1 ); - if (err) goto bail; - } - err = MP4InsertMediaIntoTrack( trak, -1, -1, tfhd->default_sample_duration, 1 ); if (err) goto bail; - } - else - { - err = MP4BeginMediaEdits( (MP4Media) mdia ); if (err) goto bail; - err = traf->mergeRuns( traf, mdia ); - - err = traf->mergeSampleAuxiliaryInformation( traf, mdia ); - - err = MP4EndMediaEdits( (MP4Media) mdia ); if (err) goto bail; - - err = MP4GetMediaDuration( (MP4Media) mdia, &mediaDuration ); if (err) goto bail; - if (((MP4TrackAtomPtr) trak)->trackEditAtom) { - err = MP4InsertMediaIntoTrack( trak, -1, (s32) initialMediaDuration, mediaDuration-initialMediaDuration, 1 ); - if (err) goto bail; - } - } - - } + u32 trackCount; + u32 i; + MP4Err err; + + u64 base_offset; + u32 traf_data_end; + + err = MP4NoErr; + + MP4GetListEntryCount(self->atomList, &trackCount); + + base_offset = self->streamOffset; + + for(i = 0; i < trackCount; i++) + { + MP4TrackFragmentAtomPtr traf; + MP4TrackFragmentHeaderAtomPtr tfhd; + MP4TrackExtendsAtomPtr trex; + MP4MediaAtomPtr mdia; + MP4Track trak; + u64 mediaDuration, initialMediaDuration; + u32 tfhd_flags; + + err = MP4GetListEntry(self->atomList, i, (char **)&traf); + if(err) goto bail; + if(traf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + tfhd = (MP4TrackFragmentHeaderAtomPtr)traf->tfhd; + + err = moov->getTrackExtendsAtom(moov, tfhd->trackID, (MP4AtomPtr *)&trex); + if(err) goto bail; + + traf->default_sample_description_index = trex->default_sample_description_index; + traf->default_sample_duration = trex->default_sample_duration; + traf->default_sample_size = trex->default_sample_size; + traf->default_sample_flags = trex->default_sample_flags; + + tfhd_flags = tfhd->flags; + + if((tfhd_flags & tfhd_sample_description_index_present) == 0) + tfhd->sample_description_index = trex->default_sample_description_index; + if((tfhd_flags & tfhd_default_sample_duration_present) == 0) + tfhd->default_sample_duration = trex->default_sample_duration; + if((tfhd_flags & tfhd_default_sample_size_present) == 0) + tfhd->default_sample_size = trex->default_sample_size; + if((tfhd_flags & tfhd_default_sample_flags_present) == 0) + tfhd->default_sample_flags = trex->default_sample_flags; + if((tfhd_flags & tfhd_base_data_offset_present) == 0) + tfhd->base_data_offset = + (tfhd_flags & tfhd_default_base_is_moof ? self->streamOffset : base_offset); + + err = traf->calculateDataEnd(traf, &traf_data_end); + if(err) goto bail; + base_offset = traf_data_end; + + err = moov->getTrackMedia(moov, tfhd->trackID, (MP4AtomPtr *)&mdia); + if(err) goto bail; + err = MP4GetMediaTrack((MP4Media)mdia, &trak); + if(err) goto bail; + + err = MP4GetMediaDuration((MP4Media)mdia, &initialMediaDuration); + if(err) goto bail; + + if(traf->tfdt) + { + MP4TrackFragmentDecodeTimeAtomPtr tfdt; + tfdt = (MP4TrackFragmentDecodeTimeAtomPtr)traf->tfdt; + + if(tfdt->baseMediaDecodeTime < initialMediaDuration) BAILWITHERROR(MP4InvalidMediaErr); + + if(tfdt->baseMediaDecodeTime > initialMediaDuration) + err = + mdia->extendLastSampleDuration(mdia, tfdt->baseMediaDecodeTime - initialMediaDuration); + if(err) goto bail; + } + + if((tfhd_flags & tfhd_duration_is_empty)) /* BAILWITHERROR( MP4NotImplementedErr ) */ + { + /* if there is not already an edit list, and there is media, insert an edit covering the + * current track duration */ + if((initialMediaDuration > 0) && (((MP4TrackAtomPtr)trak)->trackEditAtom == 0)) + { + err = MP4InsertMediaIntoTrack(trak, -1, 0, initialMediaDuration, 1); + if(err) goto bail; + } + err = MP4InsertMediaIntoTrack(trak, -1, -1, tfhd->default_sample_duration, 1); + if(err) goto bail; + } + else + { + err = MP4BeginMediaEdits((MP4Media)mdia); + if(err) goto bail; + err = traf->mergeRuns(traf, mdia); + + err = traf->mergeSampleAuxiliaryInformation(traf, mdia); + + err = MP4EndMediaEdits((MP4Media)mdia); + if(err) goto bail; + + err = MP4GetMediaDuration((MP4Media)mdia, &mediaDuration); + if(err) goto bail; + if(((MP4TrackAtomPtr)trak)->trackEditAtom) + { + err = MP4InsertMediaIntoTrack(trak, -1, (s32)initialMediaDuration, + mediaDuration - initialMediaDuration, 1); + if(err) goto bail; + } + } + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4MovieFragmentAtomPtr self = (MP4MovieFragmentAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM( mfhd ); - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4MovieFragmentAtomPtr self = (MP4MovieFragmentAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM(mfhd); + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4MovieFragmentAtomPtr self = (MP4MovieFragmentAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_SIZE( mfhd ); - ADD_ATOM_LIST_SIZE( atomList ); + MP4Err err; + MP4MovieFragmentAtomPtr self = (MP4MovieFragmentAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_SIZE(mfhd); + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateDuration( struct MP4MovieAtom* self ) +static MP4Err calculateDuration(struct MP4MovieAtom *self) { - MP4Err err; - err = MP4NoErr; + MP4Err err; + err = MP4NoErr; - if ( self == 0 ) - BAILWITHERROR( MP4BadParamErr ); + if(self == 0) BAILWITHERROR(MP4BadParamErr); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addAtom( MP4MovieFragmentAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4MovieFragmentAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - - if ( self == 0 ) - BAILWITHERROR( MP4BadParamErr ); - switch (atom->type) { - case MP4MovieFragmentHeaderAtomType: self->mfhd = atom; break; - case MP4TrackFragmentAtomType: - default: err = MP4AddListEntry( atom, self->atomList ); break; - } - + MP4Err err; + err = MP4NoErr; + + if(self == 0) BAILWITHERROR(MP4BadParamErr); + switch(atom->type) + { + case MP4MovieFragmentHeaderAtomType: + self->mfhd = atom; + break; + case MP4TrackFragmentAtomType: + default: + err = MP4AddListEntry(atom, self->atomList); + break; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MP4MovieFragmentAtom) + PARSE_ATOM_LIST(MP4MovieFragmentAtom) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateMovieFragmentAtom( MP4MovieFragmentAtomPtr *outAtom ) +MP4Err MP4CreateMovieFragmentAtom(MP4MovieFragmentAtomPtr *outAtom) { - MP4Err err; - MP4MovieFragmentAtomPtr self; - - self = (MP4MovieFragmentAtomPtr) calloc( 1, sizeof(MP4MovieFragmentAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4MovieFragmentAtomType; - self->name = "movie fragment"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->mdatMoved = mdatMoved; - self->calculateDuration = calculateDuration; - self->addAtom = addAtom; - self->mergeFragments = mergeFragments; - - *outAtom = self; + MP4Err err; + MP4MovieFragmentAtomPtr self; + + self = (MP4MovieFragmentAtomPtr)calloc(1, sizeof(MP4MovieFragmentAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4MovieFragmentAtomType; + self->name = "movie fragment"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->mdatMoved = mdatMoved; + self->calculateDuration = calculateDuration; + self->addAtom = addAtom; + self->mergeFragments = mergeFragments; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MovieFragmentHeaderAtom.c b/IsoLib/libisomediafile/src/MovieFragmentHeaderAtom.c index c48a3f3..d94e025 100644 --- a/IsoLib/libisomediafile/src/MovieFragmentHeaderAtom.c +++ b/IsoLib/libisomediafile/src/MovieFragmentHeaderAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,99 +15,100 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieFragmentHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieFragmentHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4MovieFragmentHeaderAtomPtr self = (MP4MovieFragmentHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( sequence_number ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4MovieFragmentHeaderAtomPtr self = (MP4MovieFragmentHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(sequence_number); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4MovieFragmentHeaderAtomPtr self = (MP4MovieFragmentHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4; + MP4Err err; + MP4MovieFragmentHeaderAtomPtr self = (MP4MovieFragmentHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4MovieFragmentHeaderAtomPtr self = (MP4MovieFragmentHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( sequence_number ); + MP4Err err; + MP4MovieFragmentHeaderAtomPtr self = (MP4MovieFragmentHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(sequence_number); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateMovieFragmentHeaderAtom( MP4MovieFragmentHeaderAtomPtr *outAtom ) +MP4Err MP4CreateMovieFragmentHeaderAtom(MP4MovieFragmentHeaderAtomPtr *outAtom) { - MP4Err err; - MP4MovieFragmentHeaderAtomPtr self; - - self = (MP4MovieFragmentHeaderAtomPtr) calloc( 1, sizeof(MP4MovieFragmentHeaderAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4MovieFragmentHeaderAtomType; - self->name = "movie fragment header"; - self->flags = 0; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4MovieFragmentHeaderAtomPtr self; + + self = (MP4MovieFragmentHeaderAtomPtr)calloc(1, sizeof(MP4MovieFragmentHeaderAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4MovieFragmentHeaderAtomType; + self->name = "movie fragment header"; + self->flags = 0; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MovieHeaderAtom.c b/IsoLib/libisomediafile/src/MovieHeaderAtom.c index 17a89f1..22e2166 100644 --- a/IsoLib/libisomediafile/src/MovieHeaderAtom.c +++ b/IsoLib/libisomediafile/src/MovieHeaderAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,181 +15,179 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - - MP4MovieHeaderAtomPtr self = (MP4MovieHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - if ( self->version == 1 ) - { - PUT64( creationTime ); - PUT64( modificationTime ); - PUT32( timeScale ); - PUT64( duration ); - } - else - { - PUT32( creationTime ); - PUT32( modificationTime ); - PUT32( timeScale ); - PUT32( duration ); - } - PUT32( qt_preferredRate ); - PUT16( qt_preferredVolume ); - PUTBYTES( self->qt_reserved, 10 ); - PUT32( qt_matrixA ); - PUT32( qt_matrixB ); - PUT32( qt_matrixU ); - PUT32( qt_matrixC ); - PUT32( qt_matrixD ); - PUT32( qt_matrixV ); - PUT32( qt_matrixX ); - PUT32( qt_matrixY ); - PUT32( qt_matrixW ); - PUT32( qt_previewTime ); - PUT32( qt_previewDuration ); - PUT32( qt_posterTime ); - PUT32( qt_selectionTime ); - PUT32( qt_selectionDuration ); - PUT32( qt_currentTime ); - PUT32( nextTrackID ); - - - assert( self->bytesWritten == self->size ); + MP4Err err; + + MP4MovieHeaderAtomPtr self = (MP4MovieHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + if(self->version == 1) + { + PUT64(creationTime); + PUT64(modificationTime); + PUT32(timeScale); + PUT64(duration); + } + else + { + PUT32(creationTime); + PUT32(modificationTime); + PUT32(timeScale); + PUT32(duration); + } + PUT32(qt_preferredRate); + PUT16(qt_preferredVolume); + PUTBYTES(self->qt_reserved, 10); + PUT32(qt_matrixA); + PUT32(qt_matrixB); + PUT32(qt_matrixU); + PUT32(qt_matrixC); + PUT32(qt_matrixD); + PUT32(qt_matrixV); + PUT32(qt_matrixX); + PUT32(qt_matrixY); + PUT32(qt_matrixW); + PUT32(qt_previewTime); + PUT32(qt_previewDuration); + PUT32(qt_posterTime); + PUT32(qt_selectionTime); + PUT32(qt_selectionDuration); + PUT32(qt_currentTime); + PUT32(nextTrackID); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4MovieHeaderAtomPtr self = (MP4MovieHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += (17*4)+(1*2)+10; - if ( self->version == 1 ) - self->size += (3*8)+(1*4); - else - self->size += (4*4); + MP4Err err; + MP4MovieHeaderAtomPtr self = (MP4MovieHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += (17 * 4) + (1 * 2) + 10; + if(self->version == 1) self->size += (3 * 8) + (1 * 4); + else + self->size += (4 * 4); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4MovieHeaderAtomPtr self = (MP4MovieHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - if ( self->version == 1 ) - { - GET64( creationTime ); - GET64( modificationTime ); - GET32( timeScale ); - GET64( duration ); - } - else - { - u32 val; - GET32_V_MSG( val, "creationTime" ); - self->creationTime = val; - GET32_V_MSG( val, "modificationTime" ); - self->modificationTime = val; - - GET32( timeScale ); - GET32_V_MSG( val, "duration" ); - self->duration = val; - } - GET32( qt_preferredRate ); - GET16( qt_preferredVolume ); - GETBYTES( 10, qt_reserved ); - GET32( qt_matrixA ); - GET32( qt_matrixB ); - GET32( qt_matrixU ); - GET32( qt_matrixC ); - GET32( qt_matrixD ); - GET32( qt_matrixV ); - GET32( qt_matrixX ); - GET32( qt_matrixY ); - GET32( qt_matrixW ); - GET32( qt_previewTime ); - GET32( qt_previewDuration ); - GET32( qt_posterTime ); - GET32( qt_selectionTime ); - GET32( qt_selectionDuration ); - GET32( qt_currentTime ); - GET32( nextTrackID ); + MP4Err err; + MP4MovieHeaderAtomPtr self = (MP4MovieHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + if(self->version == 1) + { + GET64(creationTime); + GET64(modificationTime); + GET32(timeScale); + GET64(duration); + } + else + { + u32 val; + GET32_V_MSG(val, "creationTime"); + self->creationTime = val; + GET32_V_MSG(val, "modificationTime"); + self->modificationTime = val; + + GET32(timeScale); + GET32_V_MSG(val, "duration"); + self->duration = val; + } + GET32(qt_preferredRate); + GET16(qt_preferredVolume); + GETBYTES(10, qt_reserved); + GET32(qt_matrixA); + GET32(qt_matrixB); + GET32(qt_matrixU); + GET32(qt_matrixC); + GET32(qt_matrixD); + GET32(qt_matrixV); + GET32(qt_matrixX); + GET32(qt_matrixY); + GET32(qt_matrixW); + GET32(qt_previewTime); + GET32(qt_previewDuration); + GET32(qt_posterTime); + GET32(qt_selectionTime); + GET32(qt_selectionDuration); + GET32(qt_currentTime); + GET32(nextTrackID); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateMovieHeaderAtom( MP4MovieHeaderAtomPtr *outAtom ) +MP4Err MP4CreateMovieHeaderAtom(MP4MovieHeaderAtomPtr *outAtom) { - MP4Err err; - MP4MovieHeaderAtomPtr self; - - self = (MP4MovieHeaderAtomPtr) calloc( 1, sizeof(MP4MovieHeaderAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4MovieHeaderAtomType; - self->name = "movie header"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->qt_preferredRate = (1<<16); - self->qt_preferredVolume = (1<<8); - self->qt_matrixA = (1<<16); - self->qt_matrixD = (1<<16); - self->qt_matrixW = (1<<30); - *outAtom = self; + MP4Err err; + MP4MovieHeaderAtomPtr self; + + self = (MP4MovieHeaderAtomPtr)calloc(1, sizeof(MP4MovieHeaderAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4MovieHeaderAtomType; + self->name = "movie header"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->qt_preferredRate = (1 << 16); + self->qt_preferredVolume = (1 << 8); + self->qt_matrixA = (1 << 16); + self->qt_matrixD = (1 << 16); + self->qt_matrixW = (1 << 30); + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/MovieTracks.c b/IsoLib/libisomediafile/src/MovieTracks.c index 0624080..963401d 100644 --- a/IsoLib/libisomediafile/src/MovieTracks.c +++ b/IsoLib/libisomediafile/src/MovieTracks.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieTracks.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieTracks.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Movies.h" @@ -31,1053 +31,1156 @@ derivative works. Copyright (c) 1999. #include #include -MP4_EXTERN ( MP4Err ) MP4GetTrackID( MP4Track theTrack, u32 *outTrackID ) +MP4_EXTERN(MP4Err) MP4GetTrackID(MP4Track theTrack, u32 *outTrackID) { - MP4Err err; - MP4TrackAtomPtr trackAtom; - MP4TrackHeaderAtomPtr trackHeaderAtom; - err = MP4NoErr; - if ( theTrack == NULL ) - BAILWITHERROR( MP4BadParamErr ) - trackAtom = (MP4TrackAtomPtr) theTrack; - trackHeaderAtom = (MP4TrackHeaderAtomPtr) trackAtom->trackHeader; - *outTrackID = trackHeaderAtom->trackID; - bail: - TEST_RETURN( err ); - - return err; -} + MP4Err err; + MP4TrackAtomPtr trackAtom; + MP4TrackHeaderAtomPtr trackHeaderAtom; + err = MP4NoErr; + if(theTrack == NULL) BAILWITHERROR(MP4BadParamErr) + trackAtom = (MP4TrackAtomPtr)theTrack; + trackHeaderAtom = (MP4TrackHeaderAtomPtr)trackAtom->trackHeader; + *outTrackID = trackHeaderAtom->trackID; +bail: + TEST_RETURN(err); -MP4_EXTERN ( MP4Err ) MP4GetTrackEnabled( MP4Track theTrack, u32 *outEnabled ) -{ - MP4Err err; - MP4TrackAtomPtr trackAtom; - err = MP4NoErr; - if ( theTrack == NULL ) - BAILWITHERROR( MP4BadParamErr ) - trackAtom = (MP4TrackAtomPtr) theTrack; - err = trackAtom->getEnabled( trackAtom, outEnabled ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4SetTrackEnabled( MP4Track theTrack, u32 enabled ) +MP4_EXTERN(MP4Err) MP4GetTrackEnabled(MP4Track theTrack, u32 *outEnabled) { - MP4Err err; - MP4TrackAtomPtr trackAtom; - err = MP4NoErr; - if ( theTrack == NULL ) - BAILWITHERROR( MP4BadParamErr ) - trackAtom = (MP4TrackAtomPtr) theTrack; - err = trackAtom->setEnabled( trackAtom, enabled ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4TrackAtomPtr trackAtom; + err = MP4NoErr; + if(theTrack == NULL) BAILWITHERROR(MP4BadParamErr) + trackAtom = (MP4TrackAtomPtr)theTrack; + err = trackAtom->getEnabled(trackAtom, outEnabled); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4AddTrackReferenceWithID( MP4Track theTrack, u32 dependsOnID, u32 dependencyType, u32 *outReferenceIndex ) +MP4_EXTERN(MP4Err) MP4SetTrackEnabled(MP4Track theTrack, u32 enabled) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4TrackReferenceAtomPtr tref; - MP4TrackReferenceTypeAtomPtr dpnd; - - err = MP4NoErr; - if ( (theTrack == NULL) || (dependsOnID == 0) ) - BAILWITHERROR( MP4BadParamErr ); - trak = (MP4TrackAtomPtr) theTrack; - tref = (MP4TrackReferenceAtomPtr) trak->trackReferences; - if ( tref == NULL ) - { - MP4Err MP4CreateTrackReferenceAtom( MP4TrackReferenceAtomPtr *outAtom ); - err = MP4CreateTrackReferenceAtom( &tref ); if (err) goto bail; - err = trak->addAtom( trak, (MP4AtomPtr) tref ); if (err) goto bail; - } - err = tref->findAtomOfType( tref, dependencyType, (MP4AtomPtr*) &dpnd ); if (err) goto bail; - if ( dpnd == NULL ) - { - MP4Err MP4CreateTrackReferenceTypeAtom( u32 atomType, MP4TrackReferenceTypeAtomPtr *outAtom ); - err = MP4CreateTrackReferenceTypeAtom( dependencyType, &dpnd ); if (err) goto bail; - err = tref->addAtom( tref, (MP4AtomPtr) dpnd ); if (err) goto bail; - } - err = dpnd->addTrackID( dpnd, dependsOnID ); if (err) goto bail; - *outReferenceIndex = dpnd->trackIDCount; - bail: - TEST_RETURN( err ); - return err; + MP4Err err; + MP4TrackAtomPtr trackAtom; + err = MP4NoErr; + if(theTrack == NULL) BAILWITHERROR(MP4BadParamErr) + trackAtom = (MP4TrackAtomPtr)theTrack; + err = trackAtom->setEnabled(trackAtom, enabled); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4AddTrackReference( MP4Track theTrack, MP4Track dependsOn, u32 dependencyType, u32 *outReferenceIndex ) +MP4_EXTERN(MP4Err) +MP4AddTrackReferenceWithID(MP4Track theTrack, u32 dependsOnID, u32 dependencyType, + u32 *outReferenceIndex) { - MP4Err err; - u32 dependsOnID; - - err = MP4NoErr; - if ( (theTrack == NULL) || (dependsOn == NULL) ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4GetTrackID( dependsOn, &dependsOnID ); if (err) goto bail; - if ( dependsOnID == 0 ) - BAILWITHERROR( MP4InvalidMediaErr ); - err = MP4AddTrackReferenceWithID( theTrack, dependsOnID, dependencyType, outReferenceIndex ); if (err) goto bail; - bail: - TEST_RETURN( err ); - return err; -} + MP4Err err; + MP4TrackAtomPtr trak; + MP4TrackReferenceAtomPtr tref; + MP4TrackReferenceTypeAtomPtr dpnd; + err = MP4NoErr; + if((theTrack == NULL) || (dependsOnID == 0)) BAILWITHERROR(MP4BadParamErr); + trak = (MP4TrackAtomPtr)theTrack; + tref = (MP4TrackReferenceAtomPtr)trak->trackReferences; + if(tref == NULL) + { + MP4Err MP4CreateTrackReferenceAtom(MP4TrackReferenceAtomPtr * outAtom); + err = MP4CreateTrackReferenceAtom(&tref); + if(err) goto bail; + err = trak->addAtom(trak, (MP4AtomPtr)tref); + if(err) goto bail; + } + err = tref->findAtomOfType(tref, dependencyType, (MP4AtomPtr *)&dpnd); + if(err) goto bail; + if(dpnd == NULL) + { + MP4Err MP4CreateTrackReferenceTypeAtom(u32 atomType, MP4TrackReferenceTypeAtomPtr * outAtom); + err = MP4CreateTrackReferenceTypeAtom(dependencyType, &dpnd); + if(err) goto bail; + err = tref->addAtom(tref, (MP4AtomPtr)dpnd); + if(err) goto bail; + } + err = dpnd->addTrackID(dpnd, dependsOnID); + if(err) goto bail; + *outReferenceIndex = dpnd->trackIDCount; +bail: + TEST_RETURN(err); + return err; +} +MP4_EXTERN(MP4Err) +MP4AddTrackReference(MP4Track theTrack, MP4Track dependsOn, u32 dependencyType, + u32 *outReferenceIndex) +{ + MP4Err err; + u32 dependsOnID; -MP4_EXTERN(MP4Err) MP4AddSubSampleInformationToTrack(MP4Track theTrack, MP4GenericAtom *subs) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4MediaAtomPtr mdia; - u32 entryCount,i; - MP4SampleTableAtomPtr stbl = NULL; - MP4MediaInformationAtomPtr minf = NULL; + err = MP4NoErr; + if((theTrack == NULL) || (dependsOn == NULL)) BAILWITHERROR(MP4BadParamErr); + err = MP4GetTrackID(dependsOn, &dependsOnID); + if(err) goto bail; + if(dependsOnID == 0) BAILWITHERROR(MP4InvalidMediaErr); + err = MP4AddTrackReferenceWithID(theTrack, dependsOnID, dependencyType, outReferenceIndex); + if(err) goto bail; +bail: + TEST_RETURN(err); + return err; +} - err = MP4NoErr; +MP4_EXTERN(MP4Err) MP4AddSubSampleInformationToTrack(MP4Track theTrack, MP4GenericAtom *subs) +{ + MP4Err err; + MP4TrackAtomPtr trak; + MP4MediaAtomPtr mdia; + u32 entryCount, i; + MP4SampleTableAtomPtr stbl = NULL; + MP4MediaInformationAtomPtr minf = NULL; - if ((theTrack == NULL)) - BAILWITHERROR(MP4BadParamErr); - trak = (MP4TrackAtomPtr)theTrack; + err = MP4NoErr; - mdia = (MP4MediaAtomPtr)trak->trackMedia; - if (mdia->information && ((MP4AtomPtr)mdia->information)->type == MP4MediaInformationAtomType) { - minf = (MP4MediaInformationAtomPtr)mdia->information; - } - else if (mdia->true_minf != NULL) - { - minf = (MP4MediaInformationAtomPtr)mdia->true_minf; - } - if (minf == NULL) BAILWITHERROR(MP4BadDataErr); + if((theTrack == NULL)) BAILWITHERROR(MP4BadParamErr); + trak = (MP4TrackAtomPtr)theTrack; - err = MP4GetListEntryCount(minf->atomList, &entryCount); if (err) goto bail; - for (i = 0; i < entryCount; i++) { - MP4AtomPtr anAtom; - err = MP4GetListEntry(minf->atomList, i, (char**)&anAtom); if (err) goto bail; - if (anAtom->type == MP4SampleTableAtomType) { - stbl = (MP4SampleTableAtomPtr)anAtom; - break; - } - } - if (stbl == NULL) BAILWITHERROR(MP4BadDataErr); + mdia = (MP4MediaAtomPtr)trak->trackMedia; + if(mdia->information && ((MP4AtomPtr)mdia->information)->type == MP4MediaInformationAtomType) + { + minf = (MP4MediaInformationAtomPtr)mdia->information; + } + else if(mdia->true_minf != NULL) + { + minf = (MP4MediaInformationAtomPtr)mdia->true_minf; + } + if(minf == NULL) BAILWITHERROR(MP4BadDataErr); + + err = MP4GetListEntryCount(minf->atomList, &entryCount); + if(err) goto bail; + for(i = 0; i < entryCount; i++) + { + MP4AtomPtr anAtom; + err = MP4GetListEntry(minf->atomList, i, (char **)&anAtom); + if(err) goto bail; + if(anAtom->type == MP4SampleTableAtomType) + { + stbl = (MP4SampleTableAtomPtr)anAtom; + break; + } + } + if(stbl == NULL) BAILWITHERROR(MP4BadDataErr); - MP4CreateSubSampleInformationAtom((MP4SubSampleInformationAtomPtr *)subs); + MP4CreateSubSampleInformationAtom((MP4SubSampleInformationAtomPtr *)subs); - err = MP4AddListEntry((void*)*subs, stbl->atomList); + err = MP4AddListEntry((void *)*subs, stbl->atomList); bail: - TEST_RETURN(err); - return err; + TEST_RETURN(err); + return err; } -MP4_EXTERN(MP4Err) MP4SetSubSampleInformationFlags(MP4GenericAtom subsample, u32 flags) { - MP4Err err; - MP4SubSampleInformationAtomPtr subs; +MP4_EXTERN(MP4Err) MP4SetSubSampleInformationFlags(MP4GenericAtom subsample, u32 flags) +{ + MP4Err err; + MP4SubSampleInformationAtomPtr subs; - err = MP4NoErr; - if ((subsample == NULL)) - BAILWITHERROR(MP4BadParamErr); - subs = (MP4SubSampleInformationAtomPtr)subsample; + err = MP4NoErr; + if((subsample == NULL)) BAILWITHERROR(MP4BadParamErr); + subs = (MP4SubSampleInformationAtomPtr)subsample; - subs->flags = flags; + subs->flags = flags; bail: - TEST_RETURN(err); - return err; + TEST_RETURN(err); + return err; } +MP4_EXTERN(MP4Err) +MP4GetSubSampleInformationEntryFromTrack(MP4Track theTrack, u32 *flags, u32 *entry_count, + u32 **sample_delta, u32 **subsample_count, + u32 ***subsample_size_array, + u32 ***subsample_priority_array, + u32 ***subsample_discardable_array) +{ + MP4Err err; + MP4TrackAtomPtr trak; + MP4MediaAtomPtr mdia; + MP4MediaInformationAtomPtr minf = NULL; + MP4SubSampleInformationAtomPtr subs = NULL; + u32 entryCount, i, j; + MP4SampleTableAtomPtr stbl = NULL; + err = MP4NoErr; + + if((theTrack == NULL)) BAILWITHERROR(MP4BadParamErr); + trak = (MP4TrackAtomPtr)theTrack; + + mdia = (MP4MediaAtomPtr)trak->trackMedia; + if(mdia->information && ((MP4AtomPtr)mdia->information)->type == MP4MediaInformationAtomType) + { + minf = (MP4MediaInformationAtomPtr)mdia->information; + } + else if(mdia->true_minf != NULL) + { + minf = (MP4MediaInformationAtomPtr)mdia->true_minf; + } + if(minf == NULL) BAILWITHERROR(MP4NotFoundErr); + + err = MP4GetListEntryCount(minf->atomList, &entryCount); + if(err) goto bail; + for(i = 0; i < entryCount; i++) + { + MP4AtomPtr anAtom; + err = MP4GetListEntry(minf->atomList, i, (char **)&anAtom); + if(err) goto bail; + if(anAtom->type == MP4SampleTableAtomType) + { + stbl = (MP4SampleTableAtomPtr)anAtom; + break; + } + } -MP4_EXTERN(MP4Err) MP4GetSubSampleInformationEntryFromTrack(MP4Track theTrack, u32* flags, u32 *entry_count, u32 **sample_delta, - u32 **subsample_count, u32 ***subsample_size_array, u32 ***subsample_priority_array, - u32 ***subsample_discardable_array) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4MediaAtomPtr mdia; - MP4MediaInformationAtomPtr minf = NULL; - MP4SubSampleInformationAtomPtr subs = NULL; - u32 entryCount, i, j; - MP4SampleTableAtomPtr stbl = NULL; - err = MP4NoErr; - - if ((theTrack == NULL)) - BAILWITHERROR(MP4BadParamErr); - trak = (MP4TrackAtomPtr)theTrack; - - mdia = (MP4MediaAtomPtr)trak->trackMedia; - if (mdia->information && ((MP4AtomPtr)mdia->information)->type == MP4MediaInformationAtomType) { - minf = (MP4MediaInformationAtomPtr)mdia->information; - } else if (mdia->true_minf != NULL) { - minf = (MP4MediaInformationAtomPtr)mdia->true_minf; - } - if (minf == NULL) BAILWITHERROR(MP4NotFoundErr); - - err = MP4GetListEntryCount(minf->atomList, &entryCount); if (err) goto bail; - for (i = 0; i < entryCount; i++) { - MP4AtomPtr anAtom; - err = MP4GetListEntry(minf->atomList, i, (char**)&anAtom); if (err) goto bail; - if (anAtom->type == MP4SampleTableAtomType) { - stbl = (MP4SampleTableAtomPtr)anAtom; - break; - } - } - - if (stbl == NULL) BAILWITHERROR(MP4NotFoundErr); - - err = MP4GetListEntryCount(stbl->atomList, &entryCount); if (err) goto bail; - for (i = 0; i < entryCount; i++) { - MP4AtomPtr anAtom; - err = MP4GetListEntry(stbl->atomList, i, (char**)&anAtom); if (err) goto bail; - if (anAtom->type == MP4SubSampleInformationAtomType) { - subs = (MP4SubSampleInformationAtomPtr)anAtom; - break; - } - } - - if (subs == NULL) BAILWITHERROR(MP4NotFoundErr); - - *flags = subs->flags; - *entry_count = subs->entry_count; - *sample_delta = (u32 *)malloc(subs->entry_count* sizeof(u32)); TESTMALLOC(*sample_delta); - *subsample_count = (u32 *)malloc(subs->entry_count* sizeof(u32)); TESTMALLOC(*subsample_count); - *subsample_size_array = (u32 **)malloc(subs->entry_count* sizeof(u32 *)); TESTMALLOC(*subsample_size_array); - *subsample_priority_array = (u32 **)malloc(subs->entry_count* sizeof(u32 *)); TESTMALLOC(*subsample_priority_array); - *subsample_discardable_array = (u32 **)malloc(subs->entry_count* sizeof(u32 *)); TESTMALLOC(*subsample_discardable_array); - - for (i = 0; i < subs->entry_count; i++) { - (*sample_delta)[i] = subs->sample_delta[i]; - (*subsample_count)[i] = subs->subsample_count[i]; - - if (subs->subsample_count[i]) { - (*subsample_size_array)[i] = (u32 *)malloc(subs->subsample_count[i]* sizeof(u32)); TESTMALLOC((*subsample_size_array)[i]); - (*subsample_priority_array)[i] = (u32 *)malloc(subs->subsample_count[i]* sizeof(u32)); TESTMALLOC((*subsample_priority_array)[i]); - (*subsample_discardable_array)[i] = (u32 *)malloc(subs->subsample_count[i]* sizeof(u32)); TESTMALLOC((*subsample_discardable_array)[i]); - for (j = 0; j < subs->subsample_count[i]; j++) { - (*subsample_size_array)[i][j] = subs->subsample_size[i][j]; - (*subsample_priority_array)[i][j] = subs->subsample_priority[i][j]; - (*subsample_discardable_array)[i][j] = subs->discardable[i][j]; - } - } - } + if(stbl == NULL) BAILWITHERROR(MP4NotFoundErr); + + err = MP4GetListEntryCount(stbl->atomList, &entryCount); + if(err) goto bail; + for(i = 0; i < entryCount; i++) + { + MP4AtomPtr anAtom; + err = MP4GetListEntry(stbl->atomList, i, (char **)&anAtom); + if(err) goto bail; + if(anAtom->type == MP4SubSampleInformationAtomType) + { + subs = (MP4SubSampleInformationAtomPtr)anAtom; + break; + } + } + + if(subs == NULL) BAILWITHERROR(MP4NotFoundErr); + + *flags = subs->flags; + *entry_count = subs->entry_count; + *sample_delta = (u32 *)malloc(subs->entry_count * sizeof(u32)); + TESTMALLOC(*sample_delta); + *subsample_count = (u32 *)malloc(subs->entry_count * sizeof(u32)); + TESTMALLOC(*subsample_count); + *subsample_size_array = (u32 **)malloc(subs->entry_count * sizeof(u32 *)); + TESTMALLOC(*subsample_size_array); + *subsample_priority_array = (u32 **)malloc(subs->entry_count * sizeof(u32 *)); + TESTMALLOC(*subsample_priority_array); + *subsample_discardable_array = (u32 **)malloc(subs->entry_count * sizeof(u32 *)); + TESTMALLOC(*subsample_discardable_array); + + for(i = 0; i < subs->entry_count; i++) + { + (*sample_delta)[i] = subs->sample_delta[i]; + (*subsample_count)[i] = subs->subsample_count[i]; + + if(subs->subsample_count[i]) + { + (*subsample_size_array)[i] = (u32 *)malloc(subs->subsample_count[i] * sizeof(u32)); + TESTMALLOC((*subsample_size_array)[i]); + (*subsample_priority_array)[i] = (u32 *)malloc(subs->subsample_count[i] * sizeof(u32)); + TESTMALLOC((*subsample_priority_array)[i]); + (*subsample_discardable_array)[i] = (u32 *)malloc(subs->subsample_count[i] * sizeof(u32)); + TESTMALLOC((*subsample_discardable_array)[i]); + for(j = 0; j < subs->subsample_count[i]; j++) + { + (*subsample_size_array)[i][j] = subs->subsample_size[i][j]; + (*subsample_priority_array)[i][j] = subs->subsample_priority[i][j]; + (*subsample_discardable_array)[i][j] = subs->discardable[i][j]; + } + } + } bail: - TEST_RETURN(err); - return err; + TEST_RETURN(err); + return err; } -MP4_EXTERN(MP4Err) MP4AddSubSampleInformationEntry(MP4GenericAtom subsample, u32 sample_delta, - u32 subsample_count, MP4Handle subsample_size_array, MP4Handle subsample_priority_array, - MP4Handle subsample_discardable_array) { - MP4Err err; - MP4SubSampleInformationAtomPtr subs; +MP4_EXTERN(MP4Err) +MP4AddSubSampleInformationEntry(MP4GenericAtom subsample, u32 sample_delta, u32 subsample_count, + MP4Handle subsample_size_array, MP4Handle subsample_priority_array, + MP4Handle subsample_discardable_array) +{ + MP4Err err; + MP4SubSampleInformationAtomPtr subs; - err = MP4NoErr; - if ((subsample == NULL)) - BAILWITHERROR(MP4BadParamErr); - subs = (MP4SubSampleInformationAtomPtr)subsample; + err = MP4NoErr; + if((subsample == NULL)) BAILWITHERROR(MP4BadParamErr); + subs = (MP4SubSampleInformationAtomPtr)subsample; - err = subs->addEntry((MP4AtomPtr)subs, sample_delta, subsample_count, subsample_size_array, subsample_priority_array, subsample_discardable_array); + err = subs->addEntry((MP4AtomPtr)subs, sample_delta, subsample_count, subsample_size_array, + subsample_priority_array, subsample_discardable_array); bail: - TEST_RETURN(err); - return err; + TEST_RETURN(err); + return err; } +MP4_EXTERN(MP4Err) MP4AddTrackGroup(MP4Track theTrack, u32 groupID, u32 dependencyType) +{ + MP4Err err; + MP4TrackAtomPtr trak; + MP4TrackGroupAtomPtr trgr; + MP4TrackGroupTypeAtomPtr msrc; -MP4_EXTERN(MP4Err) MP4AddTrackGroup(MP4Track theTrack, u32 groupID, u32 dependencyType) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4TrackGroupAtomPtr trgr; - MP4TrackGroupTypeAtomPtr msrc; - - err = MP4NoErr; - if ((theTrack == NULL)) - BAILWITHERROR(MP4BadParamErr); - trak = (MP4TrackAtomPtr)theTrack; - trgr = (MP4TrackGroupAtomPtr)trak->trackGroups; - if (trgr == NULL) { - MP4Err MP4CreateTrackGroupAtom(MP4TrackGroupAtomPtr *outAtom); - err = MP4CreateTrackGroupAtom(&trgr); if (err) goto bail; - err = trak->addAtom(trak, (MP4AtomPtr)trgr); if (err) goto bail; - } - err = trgr->findAtomOfType(trgr, dependencyType, (MP4AtomPtr*)&msrc); if (err) goto bail; - if (msrc == NULL) { - err = MP4CreateTrackGroupTypeAtom(dependencyType, &msrc); if (err) goto bail; - err = trgr->addAtom(trgr, (MP4AtomPtr)msrc); if (err) goto bail; - } - err = msrc->setGroupID(msrc, groupID); if (err) goto bail; + err = MP4NoErr; + if((theTrack == NULL)) BAILWITHERROR(MP4BadParamErr); + trak = (MP4TrackAtomPtr)theTrack; + trgr = (MP4TrackGroupAtomPtr)trak->trackGroups; + if(trgr == NULL) + { + MP4Err MP4CreateTrackGroupAtom(MP4TrackGroupAtomPtr * outAtom); + err = MP4CreateTrackGroupAtom(&trgr); + if(err) goto bail; + err = trak->addAtom(trak, (MP4AtomPtr)trgr); + if(err) goto bail; + } + err = trgr->findAtomOfType(trgr, dependencyType, (MP4AtomPtr *)&msrc); + if(err) goto bail; + if(msrc == NULL) + { + err = MP4CreateTrackGroupTypeAtom(dependencyType, &msrc); + if(err) goto bail; + err = trgr->addAtom(trgr, (MP4AtomPtr)msrc); + if(err) goto bail; + } + err = msrc->setGroupID(msrc, groupID); + if(err) goto bail; bail: - TEST_RETURN(err); - return err; + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) MP4AddTrackToMovieIOD( MP4Track theTrack ) +MP4_EXTERN(MP4Err) MP4AddTrackToMovieIOD(MP4Track theTrack) { - MP4Err MP4MovieAddTrackES_IDToIOD( MP4Movie theMovie, MP4Track theTrack ); - MP4Movie itsMovie; - MP4Err err; - if ( theTrack == 0 ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4GetTrackMovie( theTrack, &itsMovie ); if (err) goto bail; - err = MP4MovieAddTrackES_IDToIOD( itsMovie, theTrack ); if (err) goto bail; - bail: - TEST_RETURN( err ); - return err; + MP4Err MP4MovieAddTrackES_IDToIOD(MP4Movie theMovie, MP4Track theTrack); + MP4Movie itsMovie; + MP4Err err; + if(theTrack == 0) BAILWITHERROR(MP4BadParamErr); + err = MP4GetTrackMovie(theTrack, &itsMovie); + if(err) goto bail; + err = MP4MovieAddTrackES_IDToIOD(itsMovie, theTrack); + if(err) goto bail; +bail: + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) MP4GetTrackDuration( MP4Track theTrack, u64 *outDuration ) +MP4_EXTERN(MP4Err) MP4GetTrackDuration(MP4Track theTrack, u64 *outDuration) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4Movie moov; - MP4Media mdia; - u32 ts; - u64 duration; - u32 trakDuration; - - if ( (theTrack == 0) || (outDuration == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = MP4GetTrackMovie( theTrack, &moov ); if (err) goto bail; - err = MP4GetTrackMedia( theTrack, &mdia ); if (err) goto bail; - err = MP4GetMovieTimeScale( moov, &ts ); if (err) goto bail; - err = MP4GetMediaDuration( mdia, &duration ); if (err) goto bail; - trak = (MP4TrackAtomPtr) theTrack; - err = trak->calculateDuration( trak, ts ); if (err) goto bail; - err = trak->getDuration( trak, &trakDuration ); if (err) goto bail; - *outDuration = (u64) trakDuration; + MP4Err err; + MP4TrackAtomPtr trak; + MP4Movie moov; + MP4Media mdia; + u32 ts; + u64 duration; + u32 trakDuration; + + if((theTrack == 0) || (outDuration == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + err = MP4GetTrackMovie(theTrack, &moov); + if(err) goto bail; + err = MP4GetTrackMedia(theTrack, &mdia); + if(err) goto bail; + err = MP4GetMovieTimeScale(moov, &ts); + if(err) goto bail; + err = MP4GetMediaDuration(mdia, &duration); + if(err) goto bail; + trak = (MP4TrackAtomPtr)theTrack; + err = trak->calculateDuration(trak, ts); + if(err) goto bail; + err = trak->getDuration(trak, &trakDuration); + if(err) goto bail; + *outDuration = (u64)trakDuration; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) MJ2SetTrackMatrix( ISOTrack theTrack, u32 matrix[9] ) +ISO_EXTERN(ISOErr) MJ2SetTrackMatrix(ISOTrack theTrack, u32 matrix[9]) { - MP4Err err; - MP4TrackAtomPtr trak; - u32 aMatrix[9]; - - if ( theTrack == 0 ) { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - - if ( matrix == NULL ) { - /* if we are passed a NULL matrix, use the identity matrix */ - aMatrix[0] = 0x00010000; - aMatrix[1] = 0; - aMatrix[2] = 0; - aMatrix[3] = 0; - aMatrix[4] = 0x00010000; - aMatrix[5] = 0; - aMatrix[6] = 0; - aMatrix[7] = 0; - aMatrix[8] = 0x40000000; - } else { - memcpy( &aMatrix, matrix, sizeof(ISOMatrixRecord) ); - } - err = trak->setMatrix( trak, aMatrix ); + MP4Err err; + MP4TrackAtomPtr trak; + u32 aMatrix[9]; + + if(theTrack == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + + if(matrix == NULL) + { + /* if we are passed a NULL matrix, use the identity matrix */ + aMatrix[0] = 0x00010000; + aMatrix[1] = 0; + aMatrix[2] = 0; + aMatrix[3] = 0; + aMatrix[4] = 0x00010000; + aMatrix[5] = 0; + aMatrix[6] = 0; + aMatrix[7] = 0; + aMatrix[8] = 0x40000000; + } + else + { + memcpy(&aMatrix, matrix, sizeof(ISOMatrixRecord)); + } + err = trak->setMatrix(trak, aMatrix); bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) MJ2GetTrackMatrix( ISOTrack theTrack, u32 outMatrix[9] ) +ISO_EXTERN(ISOErr) MJ2GetTrackMatrix(ISOTrack theTrack, u32 outMatrix[9]) { - MP4Err err; - MP4TrackAtomPtr trak; - - if ( theTrack == 0 ) { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - - if ( outMatrix == NULL ) - BAILWITHERROR( MP4BadParamErr ); - - err = trak->getMatrix( trak, outMatrix ); + MP4Err err; + MP4TrackAtomPtr trak; + + if(theTrack == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + + if(outMatrix == NULL) BAILWITHERROR(MP4BadParamErr); + + err = trak->getMatrix(trak, outMatrix); bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) MJ2SetTrackLayer( ISOTrack theTrack, s16 layer ) +ISO_EXTERN(ISOErr) MJ2SetTrackLayer(ISOTrack theTrack, s16 layer) { - MP4Err err; - MP4TrackAtomPtr trak; - - if ( theTrack == 0 ) { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; + MP4Err err; + MP4TrackAtomPtr trak; - err = trak->setLayer( trak, layer ); + if(theTrack == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + + err = trak->setLayer(trak, layer); bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) MJ2GetTrackLayer( ISOTrack theTrack, s16 *outLayer ) +ISO_EXTERN(ISOErr) MJ2GetTrackLayer(ISOTrack theTrack, s16 *outLayer) { - MP4Err err; - MP4TrackAtomPtr trak; - - if ( theTrack == 0 ) { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - - if ( outLayer == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = trak->getLayer( trak, outLayer ); + MP4Err err; + MP4TrackAtomPtr trak; + + if(theTrack == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + + if(outLayer == NULL) BAILWITHERROR(MP4BadParamErr); + err = trak->getLayer(trak, outLayer); bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) MJ2SetTrackDimensions( ISOTrack theTrack, u32 width, u32 height ) +ISO_EXTERN(ISOErr) MJ2SetTrackDimensions(ISOTrack theTrack, u32 width, u32 height) { - MP4Err err; - MP4TrackAtomPtr trak; - - if ( theTrack == 0 ) { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; + MP4Err err; + MP4TrackAtomPtr trak; + + if(theTrack == 0) + { + BAILWITHERROR(MP4BadParamErr); + } - err = trak->setDimensions( trak, width, height ); + trak = (MP4TrackAtomPtr)theTrack; -bail: - TEST_RETURN( err ); - return err; + err = trak->setDimensions(trak, width, height); +bail: + TEST_RETURN(err); + return err; } -ISO_EXTERN ( ISOErr ) MJ2GetTrackDimensions( ISOTrack theTrack, u32 *outWidth, u32 *outHeight ) +ISO_EXTERN(ISOErr) MJ2GetTrackDimensions(ISOTrack theTrack, u32 *outWidth, u32 *outHeight) { - MP4Err err; - MP4TrackAtomPtr trak; - - if ( theTrack == 0 ) { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - - if ( ( outWidth == NULL ) || ( outHeight == NULL ) ) - BAILWITHERROR( MP4BadParamErr ); - err = trak->getDimensions( trak, outWidth, outHeight ); + MP4Err err; + MP4TrackAtomPtr trak; + + if(theTrack == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + + if((outWidth == NULL) || (outHeight == NULL)) BAILWITHERROR(MP4BadParamErr); + err = trak->getDimensions(trak, outWidth, outHeight); bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) MJ2SetTrackVolume( ISOTrack theTrack, s16 volume ) +ISO_EXTERN(ISOErr) MJ2SetTrackVolume(ISOTrack theTrack, s16 volume) { - MP4Err err; - MP4TrackAtomPtr trak; - - if ( theTrack == 0 ) { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - assert( trak->setVolume ); - err = trak->setVolume( trak, volume ); + MP4Err err; + MP4TrackAtomPtr trak; + + if(theTrack == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + assert(trak->setVolume); + err = trak->setVolume(trak, volume); bail: - return err; + return err; } -ISO_EXTERN ( ISOErr ) MJ2GetTrackVolume( ISOTrack theTrack, s16 *outVolume ) +ISO_EXTERN(ISOErr) MJ2GetTrackVolume(ISOTrack theTrack, s16 *outVolume) { - MP4Err err; - MP4TrackAtomPtr trak; - - if ( theTrack == 0 ) { - BAILWITHERROR( MP4BadParamErr ); - } - - trak = (MP4TrackAtomPtr) theTrack; - - if ( outVolume == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = trak->getVolume( trak, outVolume ); + MP4Err err; + MP4TrackAtomPtr trak; + + if(theTrack == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + + trak = (MP4TrackAtomPtr)theTrack; + + if(outVolume == NULL) BAILWITHERROR(MP4BadParamErr); + err = trak->getVolume(trak, outVolume); bail: - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4GetTrackReference( MP4Track theTrack, u32 referenceType, u32 referenceIndex, MP4Track *outReferencedTrack ) +MP4_EXTERN(MP4Err) +MP4GetTrackReference(MP4Track theTrack, u32 referenceType, u32 referenceIndex, + MP4Track *outReferencedTrack) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4Movie moov; - MP4TrackReferenceAtomPtr tref; - MP4TrackReferenceTypeAtomPtr dpnd; - u32 selectedTrackID; - - err = MP4NoErr; - if ( (theTrack == NULL) || (referenceType == 0) || (referenceIndex == 0) || (outReferencedTrack == NULL) ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4GetTrackMovie( theTrack, &moov ); if (err) goto bail; - trak = (MP4TrackAtomPtr) theTrack; - tref = (MP4TrackReferenceAtomPtr) trak->trackReferences; - if ( tref == NULL ) - BAILWITHERROR( MP4BadParamErr ); - err = tref->findAtomOfType( tref, referenceType, (MP4AtomPtr*) &dpnd ); if (err) goto bail; - if ( (dpnd == NULL) || (dpnd->trackIDCount < referenceIndex) ) - BAILWITHERROR( MP4BadParamErr ); - selectedTrackID = dpnd->trackIDs[ referenceIndex - 1 ]; - if ( selectedTrackID == 0 ) - BAILWITHERROR( MP4InvalidMediaErr ); - err = MP4GetMovieTrack( moov, selectedTrackID, outReferencedTrack ); if (err) goto bail; - bail: - TEST_RETURN( err ); - return err; + MP4Err err; + MP4TrackAtomPtr trak; + MP4Movie moov; + MP4TrackReferenceAtomPtr tref; + MP4TrackReferenceTypeAtomPtr dpnd; + u32 selectedTrackID; + + err = MP4NoErr; + if((theTrack == NULL) || (referenceType == 0) || (referenceIndex == 0) || + (outReferencedTrack == NULL)) + BAILWITHERROR(MP4BadParamErr); + err = MP4GetTrackMovie(theTrack, &moov); + if(err) goto bail; + trak = (MP4TrackAtomPtr)theTrack; + tref = (MP4TrackReferenceAtomPtr)trak->trackReferences; + if(tref == NULL) BAILWITHERROR(MP4BadParamErr); + err = tref->findAtomOfType(tref, referenceType, (MP4AtomPtr *)&dpnd); + if(err) goto bail; + if((dpnd == NULL) || (dpnd->trackIDCount < referenceIndex)) BAILWITHERROR(MP4BadParamErr); + selectedTrackID = dpnd->trackIDs[referenceIndex - 1]; + if(selectedTrackID == 0) BAILWITHERROR(MP4InvalidMediaErr); + err = MP4GetMovieTrack(moov, selectedTrackID, outReferencedTrack); + if(err) goto bail; +bail: + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) MP4GetTrackReferenceCount( MP4Track theTrack, u32 referenceType, u32 *outReferenceCount ) +MP4_EXTERN(MP4Err) +MP4GetTrackReferenceCount(MP4Track theTrack, u32 referenceType, u32 *outReferenceCount) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4TrackReferenceAtomPtr tref; - MP4TrackReferenceTypeAtomPtr dpnd; - - err = MP4NoErr; - if ( (theTrack == NULL) || (referenceType == 0) || (outReferenceCount == NULL) ) - BAILWITHERROR( MP4BadParamErr ); - trak = (MP4TrackAtomPtr) theTrack; - tref = (MP4TrackReferenceAtomPtr) trak->trackReferences; - *outReferenceCount = 0; - if ( tref != NULL ) - { - err = tref->findAtomOfType( tref, referenceType, (MP4AtomPtr*) &dpnd ); - if ( (err == MP4NoErr) && (dpnd != NULL) ) - *outReferenceCount = dpnd->trackIDCount; - else - err = MP4NoErr; - } - bail: - TEST_RETURN( err ); - return err; -} + MP4Err err; + MP4TrackAtomPtr trak; + MP4TrackReferenceAtomPtr tref; + MP4TrackReferenceTypeAtomPtr dpnd; -MP4_EXTERN(MP4Err) MP4GetTrackGroup(MP4Track theTrack, u32 groupType, u32 *outGroupId) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4Movie moov; - MP4TrackGroupAtomPtr trgr; - MP4TrackGroupTypeAtomPtr msrc; - - err = MP4NoErr; - if ((theTrack == NULL) || (groupType == 0)) - BAILWITHERROR(MP4BadParamErr); - err = MP4GetTrackMovie(theTrack, &moov); if (err) goto bail; - trak = (MP4TrackAtomPtr)theTrack; - trgr = (MP4TrackGroupAtomPtr)trak->trackGroups; - if (trgr == NULL) - BAILWITHERROR(MP4BadParamErr); - err = trgr->findAtomOfType(trgr, groupType, (MP4AtomPtr*)&msrc); if (err) goto bail; - if ((msrc == NULL)) - BAILWITHERROR(MP4BadParamErr); - - *outGroupId = msrc->track_group_id; + err = MP4NoErr; + if((theTrack == NULL) || (referenceType == 0) || (outReferenceCount == NULL)) + BAILWITHERROR(MP4BadParamErr); + trak = (MP4TrackAtomPtr)theTrack; + tref = (MP4TrackReferenceAtomPtr)trak->trackReferences; + *outReferenceCount = 0; + if(tref != NULL) + { + err = tref->findAtomOfType(tref, referenceType, (MP4AtomPtr *)&dpnd); + if((err == MP4NoErr) && (dpnd != NULL)) *outReferenceCount = dpnd->trackIDCount; + else + err = MP4NoErr; + } bail: - TEST_RETURN(err); - return err; + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) MP4GetTrackMovie( MP4Track theTrack, MP4Movie *outMovie ) +MP4_EXTERN(MP4Err) MP4GetTrackGroup(MP4Track theTrack, u32 groupType, u32 *outGroupId) { - MP4Err err; - MP4TrackAtomPtr trackAtom; - trackAtom = (MP4TrackAtomPtr) theTrack; - err = MP4NoErr; - if ( theTrack == NULL ) - BAILWITHERROR( MP4BadParamErr ) - *outMovie = (MP4Movie) trackAtom->moov; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4TrackAtomPtr trak; + MP4Movie moov; + MP4TrackGroupAtomPtr trgr; + MP4TrackGroupTypeAtomPtr msrc; + + err = MP4NoErr; + if((theTrack == NULL) || (groupType == 0)) BAILWITHERROR(MP4BadParamErr); + err = MP4GetTrackMovie(theTrack, &moov); + if(err) goto bail; + trak = (MP4TrackAtomPtr)theTrack; + trgr = (MP4TrackGroupAtomPtr)trak->trackGroups; + if(trgr == NULL) BAILWITHERROR(MP4BadParamErr); + err = trgr->findAtomOfType(trgr, groupType, (MP4AtomPtr *)&msrc); + if(err) goto bail; + if((msrc == NULL)) BAILWITHERROR(MP4BadParamErr); + + *outGroupId = msrc->track_group_id; +bail: + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) MP4GetTrackMedia( MP4Track theTrack, MP4Media *outMedia ) +MP4_EXTERN(MP4Err) MP4GetTrackMovie(MP4Track theTrack, MP4Movie *outMovie) { - MP4Err err; - MP4TrackAtomPtr trackAtom; - trackAtom = (MP4TrackAtomPtr) theTrack; - err = MP4NoErr; - if ( theTrack == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - if ( trackAtom->trackMedia ) - { - *outMedia = (MP4Media) trackAtom->trackMedia; - } - else - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4TrackAtomPtr trackAtom; + trackAtom = (MP4TrackAtomPtr)theTrack; + err = MP4NoErr; + if(theTrack == NULL) BAILWITHERROR(MP4BadParamErr) + *outMovie = (MP4Movie)trackAtom->moov; +bail: + TEST_RETURN(err); + + return err; } +MP4_EXTERN(MP4Err) MP4GetTrackMedia(MP4Track theTrack, MP4Media *outMedia) +{ + MP4Err err; + MP4TrackAtomPtr trackAtom; + trackAtom = (MP4TrackAtomPtr)theTrack; + err = MP4NoErr; + if(theTrack == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + if(trackAtom->trackMedia) + { + *outMedia = (MP4Media)trackAtom->trackMedia; + } + else + { + BAILWITHERROR(MP4InvalidMediaErr); + } +bail: + TEST_RETURN(err); + + return err; +} -MP4_EXTERN ( MP4Err ) MP4GetTrackUserData( MP4Track theTrack, MP4UserData* outUserData ) +MP4_EXTERN(MP4Err) MP4GetTrackUserData(MP4Track theTrack, MP4UserData *outUserData) { - MP4Err err; - MP4UserData udta; - MP4TrackAtomPtr trackAtom; - trackAtom = (MP4TrackAtomPtr) theTrack; - err = MP4NoErr; - if ( theTrack == NULL ) - BAILWITHERROR( MP4BadParamErr ) - udta = (MP4UserData) trackAtom->udta; - if ( trackAtom->udta == 0 ) - { - err = MP4NewUserData( &udta ); if (err) goto bail; - err = trackAtom->addAtom( trackAtom, (MP4AtomPtr) udta ); if (err) goto bail; - } - *outUserData = (MP4UserData) udta; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4UserData udta; + MP4TrackAtomPtr trackAtom; + trackAtom = (MP4TrackAtomPtr)theTrack; + err = MP4NoErr; + if(theTrack == NULL) BAILWITHERROR(MP4BadParamErr) + udta = (MP4UserData)trackAtom->udta; + if(trackAtom->udta == 0) + { + err = MP4NewUserData(&udta); + if(err) goto bail; + err = trackAtom->addAtom(trackAtom, (MP4AtomPtr)udta); + if(err) goto bail; + } + *outUserData = (MP4UserData)udta; +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4AddAtomToTrack( MP4Track theTrack, MP4GenericAtom the_atom ) +MP4_EXTERN(MP4Err) MP4AddAtomToTrack(MP4Track theTrack, MP4GenericAtom the_atom) { - MP4Err err; - MP4TrackAtomPtr trackAtom; + MP4Err err; + MP4TrackAtomPtr trackAtom; - trackAtom = (MP4TrackAtomPtr) theTrack; - err = MP4NoErr; - err = trackAtom->addAtom( trackAtom, (MP4AtomPtr) the_atom ); if (err) goto bail; + trackAtom = (MP4TrackAtomPtr)theTrack; + err = MP4NoErr; + err = trackAtom->addAtom(trackAtom, (MP4AtomPtr)the_atom); + if(err) goto bail; - bail: - TEST_RETURN( err ); +bail: + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4NewTrackMedia( MP4Track theTrack, MP4Media *outMedia, u32 mediaType, u32 timeScale, MP4Handle dataReference ) +MP4_EXTERN(MP4Err) +MP4NewTrackMedia(MP4Track theTrack, MP4Media *outMedia, u32 mediaType, u32 timeScale, + MP4Handle dataReference) { - MP4Err err; - MP4TrackAtomPtr trackAtom; - trackAtom = (MP4TrackAtomPtr) theTrack; - err = MP4NoErr; - if ( theTrack == NULL ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = trackAtom->newMedia( trackAtom, outMedia, mediaType, timeScale, dataReference ); if (err) goto bail; - - if (((trackAtom->moov)->fileType) == ISOQuickTimeFileType) { - MP4MediaAtomPtr mdia; - MP4HandlerAtomPtr hdlr; - mdia = (MP4MediaAtomPtr) trackAtom->trackMedia; - hdlr = (MP4HandlerAtomPtr) mdia->handler; - hdlr->setName( (MP4AtomPtr) hdlr, hdlr->nameUTF8, 1); - } - - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4TrackAtomPtr trackAtom; + trackAtom = (MP4TrackAtomPtr)theTrack; + err = MP4NoErr; + if(theTrack == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + err = trackAtom->newMedia(trackAtom, outMedia, mediaType, timeScale, dataReference); + if(err) goto bail; + + if(((trackAtom->moov)->fileType) == ISOQuickTimeFileType) + { + MP4MediaAtomPtr mdia; + MP4HandlerAtomPtr hdlr; + mdia = (MP4MediaAtomPtr)trackAtom->trackMedia; + hdlr = (MP4HandlerAtomPtr)mdia->handler; + hdlr->setName((MP4AtomPtr)hdlr, hdlr->nameUTF8, 1); + } + +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4InsertMediaIntoTrack( MP4Track track, s32 trackStartTime, s32 mediaStartTime, u64 mediaDuration, s32 mediaRate ) +MP4_EXTERN(MP4Err) +MP4InsertMediaIntoTrack(MP4Track track, s32 trackStartTime, s32 mediaStartTime, u64 mediaDuration, + s32 mediaRate) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4MediaAtomPtr mdia; - u64 outDuration = 0; - - err = MP4NoErr; - if ( (track == 0) || (mediaRate < 0) || (mediaRate > 1) ) - BAILWITHERROR( MP4BadParamErr ); - trak = (MP4TrackAtomPtr) track; - mdia = (MP4MediaAtomPtr) trak->trackMedia; - - err = MP4GetTrackDuration( track, &outDuration ); - if (err) - { - goto bail; - } - - if ( (trackStartTime == 0) && (mediaStartTime == 0) && (mediaRate == 1) && (mediaDuration == outDuration) ) - { - if ( mediaDuration == 0 ) - BAILWITHERROR( MP4BadParamErr ); - } - else - { - /* need an edit list */ - MP4EditAtomPtr edts; - MP4EditListAtomPtr elst; - u32 movieTimeScale, mediaTimeScale; - - err = MP4GetMovieTimeScale( (MP4Movie) trak->moov, &movieTimeScale ); if (err) goto bail; - err = MP4GetMediaTimeScale( (MP4Media) mdia, &mediaTimeScale ); if (err) goto bail; - mediaDuration = (mediaDuration * movieTimeScale) / mediaTimeScale; - - edts = (MP4EditAtomPtr) trak->trackEditAtom; - - if ( edts == 0 ) - { - /* no edits yet */ - MP4Err MP4CreateEditAtom( MP4EditAtomPtr *outAtom ); + MP4Err err; + MP4TrackAtomPtr trak; + MP4MediaAtomPtr mdia; + u64 outDuration = 0; - err = MP4CreateEditAtom( &edts ); if (err) goto bail; - err = trak->addAtom( trak, (MP4AtomPtr) edts ); if (err) goto bail; - } - elst = (MP4EditListAtomPtr) edts->editListAtom; - if ( elst == 0 ) - { - MP4Err MP4CreateEditListAtom( MP4EditListAtomPtr *outAtom ); + err = MP4NoErr; + if((track == 0) || (mediaRate < 0) || (mediaRate > 1)) BAILWITHERROR(MP4BadParamErr); + trak = (MP4TrackAtomPtr)track; + mdia = (MP4MediaAtomPtr)trak->trackMedia; + + err = MP4GetTrackDuration(track, &outDuration); + if(err) + { + goto bail; + } - err = MP4CreateEditListAtom( &elst ); if (err) goto bail; - err = edts->addAtom( edts, (MP4AtomPtr) elst ); if (err) goto bail; - } - err = elst->insertSegment( elst, trackStartTime, mediaStartTime, mediaDuration, mediaRate ); if (err) goto bail; - } - if ( trak->moov->inMemoryDataHandler ) - { - if ( mdia ) + if((trackStartTime == 0) && (mediaStartTime == 0) && (mediaRate == 1) && + (mediaDuration == outDuration)) + { + if(mediaDuration == 0) BAILWITHERROR(MP4BadParamErr); + } + else + { + /* need an edit list */ + MP4EditAtomPtr edts; + MP4EditListAtomPtr elst; + u32 movieTimeScale, mediaTimeScale; + + err = MP4GetMovieTimeScale((MP4Movie)trak->moov, &movieTimeScale); + if(err) goto bail; + err = MP4GetMediaTimeScale((MP4Media)mdia, &mediaTimeScale); + if(err) goto bail; + mediaDuration = (mediaDuration * movieTimeScale) / mediaTimeScale; + + edts = (MP4EditAtomPtr)trak->trackEditAtom; + + if(edts == 0) + { + /* no edits yet */ + MP4Err MP4CreateEditAtom(MP4EditAtomPtr * outAtom); + + err = MP4CreateEditAtom(&edts); + if(err) goto bail; + err = trak->addAtom(trak, (MP4AtomPtr)edts); + if(err) goto bail; + } + elst = (MP4EditListAtomPtr)edts->editListAtom; + if(elst == 0) + { + MP4Err MP4CreateEditListAtom(MP4EditListAtomPtr * outAtom); + + err = MP4CreateEditListAtom(&elst); + if(err) goto bail; + err = edts->addAtom(edts, (MP4AtomPtr)elst); + if(err) goto bail; + } + err = elst->insertSegment(elst, trackStartTime, mediaStartTime, mediaDuration, mediaRate); + if(err) goto bail; + } + if(trak->moov->inMemoryDataHandler) + { + if(mdia) + { + MP4MediaInformationAtomPtr minf; + minf = (MP4MediaInformationAtomPtr)mdia->information; + if(minf) { - MP4MediaInformationAtomPtr minf; - minf = (MP4MediaInformationAtomPtr) mdia->information; - if ( minf ) - { - if ( minf->dataHandler == 0 ) - { - minf->dataHandler = trak->moov->inMemoryDataHandler; - if ( minf->dataEntryIndex == 0 ) - { - minf->dataEntryIndex = 1; - } - } - } + if(minf->dataHandler == 0) + { + minf->dataHandler = trak->moov->inMemoryDataHandler; + if(minf->dataEntryIndex == 0) + { + minf->dataEntryIndex = 1; + } + } } - } - bail: - TEST_RETURN( err ); + } + } +bail: + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4GetTrackOffset( MP4Track track, u32 *outMovieOffsetTime ) +MP4_EXTERN(MP4Err) MP4GetTrackOffset(MP4Track track, u32 *outMovieOffsetTime) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4EditAtomPtr edts; - MP4EditListAtomPtr elst; + MP4Err err; + MP4TrackAtomPtr trak; + MP4EditAtomPtr edts; + MP4EditListAtomPtr elst; - err = MP4NoErr; - if ( (track == 0) || (outMovieOffsetTime == 0) ) - BAILWITHERROR( MP4BadParamErr ); + err = MP4NoErr; + if((track == 0) || (outMovieOffsetTime == 0)) BAILWITHERROR(MP4BadParamErr); - /* see if we have an edit list */ - trak = (MP4TrackAtomPtr) track; - edts = (MP4EditAtomPtr) trak->trackEditAtom; + /* see if we have an edit list */ + trak = (MP4TrackAtomPtr)track; + edts = (MP4EditAtomPtr)trak->trackEditAtom; - if ( edts == 0 ) - { + if(edts == 0) + { + *outMovieOffsetTime = 0; + } + else + { + elst = (MP4EditListAtomPtr)edts->editListAtom; + if(elst == 0) + { *outMovieOffsetTime = 0; - } - else - { - elst = (MP4EditListAtomPtr) edts->editListAtom; - if ( elst == 0 ) - { - *outMovieOffsetTime = 0; - } - else - { - err = elst->getTrackOffset( elst, outMovieOffsetTime ); if (err) goto bail; - } - } - bail: - TEST_RETURN( err ); + } + else + { + err = elst->getTrackOffset(elst, outMovieOffsetTime); + if(err) goto bail; + } + } +bail: + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) MP4SetTrackOffset( MP4Track track, u32 movieOffsetTime ) +MP4_EXTERN(MP4Err) MP4SetTrackOffset(MP4Track track, u32 movieOffsetTime) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4EditAtomPtr edts; - MP4EditListAtomPtr elst; - u64 trackDuration; + MP4Err err; + MP4TrackAtomPtr trak; + MP4EditAtomPtr edts; + MP4EditListAtomPtr elst; + u64 trackDuration; - err = MP4NoErr; - if ( (track == 0) ) - BAILWITHERROR( MP4BadParamErr ); + err = MP4NoErr; + if((track == 0)) BAILWITHERROR(MP4BadParamErr); - err = MP4GetTrackDuration( track, &trackDuration ); if (err) goto bail; + err = MP4GetTrackDuration(track, &trackDuration); + if(err) goto bail; - /* need an edit list */ - trak = (MP4TrackAtomPtr) track; - edts = (MP4EditAtomPtr) trak->trackEditAtom; + /* need an edit list */ + trak = (MP4TrackAtomPtr)track; + edts = (MP4EditAtomPtr)trak->trackEditAtom; - if ( edts == 0 ) - { - /* no edits yet */ - MP4Err MP4CreateEditAtom( MP4EditAtomPtr *outAtom ); - - err = MP4CreateEditAtom( &edts ); if (err) goto bail; - err = trak->addAtom( trak, (MP4AtomPtr) edts ); if (err) goto bail; - } - elst = (MP4EditListAtomPtr) edts->editListAtom; - if ( elst == 0 ) - { - MP4Err MP4CreateEditListAtom( MP4EditListAtomPtr *outAtom ); - - err = MP4CreateEditListAtom( &elst ); if (err) goto bail; - err = edts->addAtom( edts, (MP4AtomPtr) elst ); if (err) goto bail; - } - err = elst->setTrackOffset( elst, movieOffsetTime, trackDuration ); if (err) goto bail; + if(edts == 0) + { + /* no edits yet */ + MP4Err MP4CreateEditAtom(MP4EditAtomPtr * outAtom); + + err = MP4CreateEditAtom(&edts); + if(err) goto bail; + err = trak->addAtom(trak, (MP4AtomPtr)edts); + if(err) goto bail; + } + elst = (MP4EditListAtomPtr)edts->editListAtom; + if(elst == 0) + { + MP4Err MP4CreateEditListAtom(MP4EditListAtomPtr * outAtom); + + err = MP4CreateEditListAtom(&elst); + if(err) goto bail; + err = edts->addAtom(edts, (MP4AtomPtr)elst); + if(err) goto bail; + } + err = elst->setTrackOffset(elst, movieOffsetTime, trackDuration); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4GetTrackReferenceType( MP4Track track, u32 atomType, MP4TrackReferenceTypeAtomPtr *outAtom ) +MP4Err MP4GetTrackReferenceType(MP4Track track, u32 atomType, MP4TrackReferenceTypeAtomPtr *outAtom) { - MP4Err err; - MP4TrackReferenceAtomPtr tref; - MP4TrackReferenceTypeAtomPtr foundAtom; - MP4TrackAtomPtr trak; - - err = MP4NoErr; - trak = (MP4TrackAtomPtr) track; - - if ( (track == 0) || (outAtom == 0) ) - BAILWITHERROR( MP4BadParamErr ) - foundAtom = 0; - tref = (MP4TrackReferenceAtomPtr) trak->trackReferences; - if ( tref ) - { - err = tref->findAtomOfType( tref, atomType, (MP4AtomPtr*) &foundAtom ); if (err) goto bail; - } - *outAtom = foundAtom; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4TrackReferenceAtomPtr tref; + MP4TrackReferenceTypeAtomPtr foundAtom; + MP4TrackAtomPtr trak; + + err = MP4NoErr; + trak = (MP4TrackAtomPtr)track; + + if((track == 0) || (outAtom == 0)) BAILWITHERROR(MP4BadParamErr) + foundAtom = 0; + tref = (MP4TrackReferenceAtomPtr)trak->trackReferences; + if(tref) + { + err = tref->findAtomOfType(tref, atomType, (MP4AtomPtr *)&foundAtom); + if(err) goto bail; + } + *outAtom = foundAtom; +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4TrackTimeToMediaTime( MP4Track theTrack, u64 inTrackTime, s64 *outMediaTime ) +MP4_EXTERN(MP4Err) MP4TrackTimeToMediaTime(MP4Track theTrack, u64 inTrackTime, s64 *outMediaTime) { - MP4Err err; - MP4Movie theMovie; - MP4Media theMedia; - u32 movieTimeScale; - u32 mediaTimeScale; - s64 mediaTime; - MP4TrackAtomPtr trak; - MP4EditAtomPtr edts; - MP4EditListAtomPtr elst; - - err = MP4NoErr; - if ( (theTrack == 0) || (outMediaTime == 0) ) - BAILWITHERROR( MP4BadParamErr ) - - err = MP4GetTrackMovie( theTrack, &theMovie ); if (err) goto bail; - err = MP4GetMovieTimeScale( theMovie, &movieTimeScale ); if (err) goto bail; - err = MP4GetTrackMedia( theTrack, &theMedia ); if (err) goto bail; - err = MP4GetMediaTimeScale( theMedia, &mediaTimeScale ); if (err) goto bail; - - if ( (movieTimeScale == 0) ) - BAILWITHERROR( MP4InvalidMediaErr ) - - trak = (MP4TrackAtomPtr) theTrack; - edts = (MP4EditAtomPtr) trak->trackEditAtom; - if ( edts == 0 ) - { - /* no edits */ - mediaTime = (inTrackTime / movieTimeScale) * mediaTimeScale; + MP4Err err; + MP4Movie theMovie; + MP4Media theMedia; + u32 movieTimeScale; + u32 mediaTimeScale; + s64 mediaTime; + MP4TrackAtomPtr trak; + MP4EditAtomPtr edts; + MP4EditListAtomPtr elst; + + err = MP4NoErr; + if((theTrack == 0) || (outMediaTime == 0)) BAILWITHERROR(MP4BadParamErr) + + err = MP4GetTrackMovie(theTrack, &theMovie); + if(err) goto bail; + err = MP4GetMovieTimeScale(theMovie, &movieTimeScale); + if(err) goto bail; + err = MP4GetTrackMedia(theTrack, &theMedia); + if(err) goto bail; + err = MP4GetMediaTimeScale(theMedia, &mediaTimeScale); + if(err) goto bail; + + if((movieTimeScale == 0)) BAILWITHERROR(MP4InvalidMediaErr) + + trak = (MP4TrackAtomPtr)theTrack; + edts = (MP4EditAtomPtr)trak->trackEditAtom; + if(edts == 0) + { + /* no edits */ + mediaTime = (inTrackTime / movieTimeScale) * mediaTimeScale; + *outMediaTime = mediaTime; + } + else + { + /* edit atom is present */ + u32 editCount; + + elst = (MP4EditListAtomPtr)edts->editListAtom; + if(elst != 0) editCount = elst->getEntryCount(elst); + else + editCount = 0; + + if(editCount == 0) + { + /* edit atom but no useful edit list, hmm... */ + mediaTime = (inTrackTime / movieTimeScale) * mediaTimeScale; *outMediaTime = mediaTime; - } - else - { - /* edit atom is present */ - u32 editCount; - - elst = (MP4EditListAtomPtr) edts->editListAtom; - if (elst != 0) - editCount = elst->getEntryCount(elst); - else editCount = 0; - - if ( editCount == 0 ) - { - /* edit atom but no useful edit list, hmm... */ - mediaTime = (inTrackTime / movieTimeScale) * mediaTimeScale; - *outMediaTime = mediaTime; - } - else - { - /* edit list is present and has entries */ - u32 mediaRate; - u64 prior; - u64 next; - err = elst->getTimeAndRate( (MP4AtomPtr) elst, inTrackTime, movieTimeScale, - mediaTimeScale, &mediaTime, &mediaRate, &prior, &next ); if (err) goto bail; - *outMediaTime = mediaTime; - } - } - bail: - TEST_RETURN( err ); + } + else + { + /* edit list is present and has entries */ + u32 mediaRate; + u64 prior; + u64 next; + err = elst->getTimeAndRate((MP4AtomPtr)elst, inTrackTime, movieTimeScale, mediaTimeScale, + &mediaTime, &mediaRate, &prior, &next); + if(err) goto bail; + *outMediaTime = mediaTime; + } + } +bail: + TEST_RETURN(err); - return err; + return err; } -ISO_EXTERN ( MP4Err ) ISOSetTrackFragmentDefaults( MP4Track theTrack, u32 duration, u32 size, u32 is_sync, u8 pad ) +ISO_EXTERN(MP4Err) +ISOSetTrackFragmentDefaults(MP4Track theTrack, u32 duration, u32 size, u32 is_sync, u8 pad) { - MP4Err MP4CreateMovieExtendsAtom( MP4MovieExtendsAtomPtr *outAtom ); - MP4Err MP4CreateTrackExtendsAtom( MP4TrackExtendsAtomPtr *outAtom ); - - MP4TrackAtomPtr trak; - MP4Err err; - MP4Movie theMovie; - MP4TrackExtendsAtomPtr trex; - MP4TrackHeaderAtomPtr tkhd; - /* MP4SampleTableAtomPtr stbl; */ - MP4MovieExtendsAtomPtr mvex; - - err = MP4NoErr; - trak = (MP4TrackAtomPtr) theTrack; - err = MP4GetTrackMovie( theTrack, &theMovie ); if (err) goto bail; - - /* This function needs a re-write to be more object-oriented...*/ - - { - GETMOVIEATOM( theMovie ); - if (movieAtom->mvex == NULL) { - err = MP4CreateMovieExtendsAtom( &mvex ); if (err) goto bail; - err = movieAtom->addAtom( movieAtom, (MP4AtomPtr) mvex ); if (err) goto bail; - } - else mvex = (MP4MovieExtendsAtomPtr) (movieAtom->mvex); - - err = MP4CreateTrackExtendsAtom( &trex ); if (err) goto bail; - tkhd = (MP4TrackHeaderAtomPtr) trak->trackHeader; - - trex->trackID = tkhd->trackID; - trex->default_sample_duration = duration; - trex->default_sample_size = size; - trex->default_sample_flags = ((pad & 7)<<17) | (is_sync ? 0 : fragment_difference_sample_flag ); - - /* stbl = ((MP4SampleTableAtomPtr) - ((MP4MediaInformationAtomPtr) - ((MP4MediaAtomPtr) - (trak->trackMedia))->information)->sampleTable); - - trex->default_sample_description_index = stbl->getCurrentSampleEntryIndex( stbl ); */ - - err = mvex->addAtom( mvex, (MP4AtomPtr) trex ); if (err) goto bail; - } -bail: - TEST_RETURN( err ); + MP4Err MP4CreateMovieExtendsAtom(MP4MovieExtendsAtomPtr * outAtom); + MP4Err MP4CreateTrackExtendsAtom(MP4TrackExtendsAtomPtr * outAtom); + + MP4TrackAtomPtr trak; + MP4Err err; + MP4Movie theMovie; + MP4TrackExtendsAtomPtr trex; + MP4TrackHeaderAtomPtr tkhd; + /* MP4SampleTableAtomPtr stbl; */ + MP4MovieExtendsAtomPtr mvex; + + err = MP4NoErr; + trak = (MP4TrackAtomPtr)theTrack; + err = MP4GetTrackMovie(theTrack, &theMovie); + if(err) goto bail; + + /* This function needs a re-write to be more object-oriented...*/ + + { + GETMOVIEATOM(theMovie); + if(movieAtom->mvex == NULL) + { + err = MP4CreateMovieExtendsAtom(&mvex); + if(err) goto bail; + err = movieAtom->addAtom(movieAtom, (MP4AtomPtr)mvex); + if(err) goto bail; + } + else + mvex = (MP4MovieExtendsAtomPtr)(movieAtom->mvex); + + err = MP4CreateTrackExtendsAtom(&trex); + if(err) goto bail; + tkhd = (MP4TrackHeaderAtomPtr)trak->trackHeader; - return err; + trex->trackID = tkhd->trackID; + trex->default_sample_duration = duration; + trex->default_sample_size = size; + trex->default_sample_flags = + ((pad & 7) << 17) | (is_sync ? 0 : fragment_difference_sample_flag); + /* stbl = ((MP4SampleTableAtomPtr) + ((MP4MediaInformationAtomPtr) + ((MP4MediaAtomPtr) + (trak->trackMedia))->information)->sampleTable); + + trex->default_sample_description_index = stbl->getCurrentSampleEntryIndex( stbl ); */ + + err = mvex->addAtom(mvex, (MP4AtomPtr)trex); + if(err) goto bail; + } +bail: + TEST_RETURN(err); + + return err; } -MP4_EXTERN ( MP4Err ) MP4GetTrackEditlistEntryCount( MP4Track theTrack, u32* entryCount ) +MP4_EXTERN(MP4Err) MP4GetTrackEditlistEntryCount(MP4Track theTrack, u32 *entryCount) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4EditAtomPtr edts; + MP4Err err; + MP4TrackAtomPtr trak; + MP4EditAtomPtr edts; MP4EditListAtomPtr elst; err = MP4NoErr; - if (theTrack == 0) { - BAILWITHERROR( MP4BadParamErr ); + if(theTrack == 0) + { + BAILWITHERROR(MP4BadParamErr); } - trak = (MP4TrackAtomPtr) theTrack; - edts = (MP4EditAtomPtr) trak->trackEditAtom; - + trak = (MP4TrackAtomPtr)theTrack; + edts = (MP4EditAtomPtr)trak->trackEditAtom; + *entryCount = 0; - if (edts == 0) { + if(edts == 0) + { /* no edits */ - BAILWITHERROR( MP4NotFoundErr ); - } else { + BAILWITHERROR(MP4NotFoundErr); + } + else + { /* edit atom is present */ elst = (MP4EditListAtomPtr)edts->editListAtom; - if (elst != 0) { - *entryCount = elst->getEntryCount(elst); + if(elst != 0) + { + *entryCount = elst->getEntryCount(elst); } } bail: - TEST_RETURN( err ); + TEST_RETURN(err); return err; } -MP4_EXTERN ( MP4Err ) MP4GetTrackEditlist( MP4Track theTrack, u64* outSegmentDuration, s64* outMediaTime, u32 entryIndex ) +MP4_EXTERN(MP4Err) +MP4GetTrackEditlist(MP4Track theTrack, u64 *outSegmentDuration, s64 *outMediaTime, u32 entryIndex) { - MP4Err err; - MP4TrackAtomPtr trak; - MP4EditAtomPtr edts; + MP4Err err; + MP4TrackAtomPtr trak; + MP4EditAtomPtr edts; MP4EditListAtomPtr elst; err = MP4NoErr; - if ((theTrack == 0) || (outSegmentDuration == 0) || (outMediaTime == 0)) { - BAILWITHERROR( MP4BadParamErr ); + if((theTrack == 0) || (outSegmentDuration == 0) || (outMediaTime == 0)) + { + BAILWITHERROR(MP4BadParamErr); } - trak = (MP4TrackAtomPtr) theTrack; - edts = (MP4EditAtomPtr) trak->trackEditAtom; + trak = (MP4TrackAtomPtr)theTrack; + edts = (MP4EditAtomPtr)trak->trackEditAtom; - if (edts == 0) { + if(edts == 0) + { /* no edits */ - BAILWITHERROR( MP4NotFoundErr ); - } else { + BAILWITHERROR(MP4NotFoundErr); + } + else + { /* edit atom is present */ u32 editCount; - - elst = (MP4EditListAtomPtr) edts->editListAtom; - if (elst != 0) { - editCount = elst->getEntryCount(elst); - } else { + + elst = (MP4EditListAtomPtr)edts->editListAtom; + if(elst != 0) + { + editCount = elst->getEntryCount(elst); + } + else + { editCount = 0; } - if (entryIndex > editCount) { - BAILWITHERROR( MP4BadParamErr ); + if(entryIndex > editCount) + { + BAILWITHERROR(MP4BadParamErr); } - if (editCount == 0) { + if(editCount == 0) + { /* edit atom but no useful edit list, hmm... */ - BAILWITHERROR( MP4NotFoundErr ); - } else { + BAILWITHERROR(MP4NotFoundErr); + } + else + { /* edit list is present and has entries */ - err = elst->getIndSegmentTime((MP4AtomPtr)elst, - entryIndex, /* segmentIndex, one based */ - 0, - outMediaTime, - outSegmentDuration); - if (err) { + err = elst->getIndSegmentTime((MP4AtomPtr)elst, entryIndex, /* segmentIndex, one based */ + 0, outMediaTime, outSegmentDuration); + if(err) + { goto bail; } } } - - bail: - TEST_RETURN( err ); + +bail: + TEST_RETURN(err); return err; } diff --git a/IsoLib/libisomediafile/src/MovieTracks.h b/IsoLib/libisomediafile/src/MovieTracks.h index 012c424..8e3a470 100644 --- a/IsoLib/libisomediafile/src/MovieTracks.h +++ b/IsoLib/libisomediafile/src/MovieTracks.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,18 +15,19 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieTracks.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieTracks.h,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #ifndef INCLUDED_MOVIETRACKS_H #define INCLUDED_MOVIETRACKS_H #include "MP4Atoms.h" -MP4Err MP4GetTrackReferenceType( MP4Track track, u32 atomType, MP4TrackReferenceTypeAtomPtr *outAtom ); +MP4Err MP4GetTrackReferenceType(MP4Track track, u32 atomType, + MP4TrackReferenceTypeAtomPtr *outAtom); #endif diff --git a/IsoLib/libisomediafile/src/ODUpdateCommand.c b/IsoLib/libisomediafile/src/ODUpdateCommand.c index 3fdb806..5d11ee5 100644 --- a/IsoLib/libisomediafile/src/ODUpdateCommand.c +++ b/IsoLib/libisomediafile/src/ODUpdateCommand.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,122 +15,129 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ODUpdateCommand.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: ODUpdateCommand.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include -static MP4Err addDescriptor( struct MP4DescriptorRecord* s, MP4DescriptorPtr desc ) +static MP4Err addDescriptor(struct MP4DescriptorRecord *s, MP4DescriptorPtr desc) { - MP4Err err; - MP4ObjectDescriptorUpdatePtr self = (MP4ObjectDescriptorUpdatePtr) s; - err = MP4NoErr; - switch( desc->tag ) - { - case MP4ObjectDescriptorTag: - err = MP4AddListEntry( desc, self->objectDescriptors ); if (err) goto bail; - break; - - default: - err = MP4AddListEntry( desc, self->extensionDescriptors ); if (err) goto bail; - break; - } + MP4Err err; + MP4ObjectDescriptorUpdatePtr self = (MP4ObjectDescriptorUpdatePtr)s; + err = MP4NoErr; + switch(desc->tag) + { + case MP4ObjectDescriptorTag: + err = MP4AddListEntry(desc, self->objectDescriptors); + if(err) goto bail; + break; + + default: + err = MP4AddListEntry(desc, self->extensionDescriptors); + if(err) goto bail; + break; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - u32 count; - u32 i; - MP4DescriptorPtr desc; - MP4ObjectDescriptorUpdatePtr self = (MP4ObjectDescriptorUpdatePtr) s; - err = MP4NoErr; - self->size = DESCRIPTOR_TAG_LEN_SIZE; - ADD_DESCRIPTOR_LIST_SIZE( objectDescriptors ); - ADD_DESCRIPTOR_LIST_SIZE( extensionDescriptors ); + MP4Err err; + u32 count; + u32 i; + MP4DescriptorPtr desc; + MP4ObjectDescriptorUpdatePtr self = (MP4ObjectDescriptorUpdatePtr)s; + err = MP4NoErr; + self->size = DESCRIPTOR_TAG_LEN_SIZE; + ADD_DESCRIPTOR_LIST_SIZE(objectDescriptors); + ADD_DESCRIPTOR_LIST_SIZE(extensionDescriptors); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - MP4Err err; - MP4ObjectDescriptorUpdatePtr self = (MP4ObjectDescriptorUpdatePtr) s; - err = MP4NoErr; - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - + MP4Err err; + MP4ObjectDescriptorUpdatePtr self = (MP4ObjectDescriptorUpdatePtr)s; + err = MP4NoErr; + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; - SERIALIZE_DESCRIPTOR_LIST( objectDescriptors ); - SERIALIZE_DESCRIPTOR_LIST( extensionDescriptors ); + SERIALIZE_DESCRIPTOR_LIST(objectDescriptors); + SERIALIZE_DESCRIPTOR_LIST(extensionDescriptors); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4ObjectDescriptorUpdatePtr self = (MP4ObjectDescriptorUpdatePtr) s; - err = MP4NoErr; - while ( self->bytesRead < self->size ) - { - MP4DescriptorPtr desc; - err = MP4ParseDescriptor( inputStream, &desc ); if (err) goto bail; - switch( desc->tag ) - { - case MP4ObjectDescriptorTag: - err = MP4AddListEntry( desc, self->objectDescriptors ); if (err) goto bail; - break; - - default: - err = MP4AddListEntry( desc, self->extensionDescriptors ); if (err) goto bail; - break; - } - self->bytesRead += desc->size; - } - + MP4Err err; + MP4ObjectDescriptorUpdatePtr self = (MP4ObjectDescriptorUpdatePtr)s; + err = MP4NoErr; + while(self->bytesRead < self->size) + { + MP4DescriptorPtr desc; + err = MP4ParseDescriptor(inputStream, &desc); + if(err) goto bail; + switch(desc->tag) + { + case MP4ObjectDescriptorTag: + err = MP4AddListEntry(desc, self->objectDescriptors); + if(err) goto bail; + break; + + default: + err = MP4AddListEntry(desc, self->extensionDescriptors); + if(err) goto bail; + break; + } + self->bytesRead += desc->size; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static void destroy( struct MP4DescriptorRecord* s ) + +static void destroy(struct MP4DescriptorRecord *s) { - MP4ObjectDescriptorUpdatePtr self = (MP4ObjectDescriptorUpdatePtr) s; - DESTROY_DESCRIPTOR_LIST( objectDescriptors ) - DESTROY_DESCRIPTOR_LIST( extensionDescriptors ) + MP4ObjectDescriptorUpdatePtr self = (MP4ObjectDescriptorUpdatePtr)s; + DESTROY_DESCRIPTOR_LIST(objectDescriptors) + DESTROY_DESCRIPTOR_LIST(extensionDescriptors) - free( s ); + free(s); bail: - return; + return; } -MP4Err MP4CreateObjectDescriptorUpdate( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateObjectDescriptorUpdate(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4ObjectDescriptorUpdate ) - self->addDescriptor = addDescriptor; - err = MP4MakeLinkedList( &self->objectDescriptors ); if (err) goto bail; - err = MP4MakeLinkedList( &self->extensionDescriptors ); if (err) goto bail; - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4ObjectDescriptorUpdate) + self->addDescriptor = addDescriptor; + err = MP4MakeLinkedList(&self->objectDescriptors); + if(err) goto bail; + err = MP4MakeLinkedList(&self->extensionDescriptors); + if(err) goto bail; + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ObjectDescriptorAtom.c b/IsoLib/libisomediafile/src/ObjectDescriptorAtom.c index 22437c1..5f8846b 100644 --- a/IsoLib/libisomediafile/src/ObjectDescriptorAtom.c +++ b/IsoLib/libisomediafile/src/ObjectDescriptorAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,129 +15,129 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ObjectDescriptorAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: ObjectDescriptorAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include "MP4Descriptors.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4ObjectDescriptorAtomPtr self = (MP4ObjectDescriptorAtomPtr) s; - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->descriptor ) - { - self->descriptor->destroy( self->descriptor ); - self->descriptor = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4ObjectDescriptorAtomPtr self = (MP4ObjectDescriptorAtomPtr)s; + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->descriptor) + { + self->descriptor->destroy(self->descriptor); + self->descriptor = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err setDescriptor( struct MP4Atom* s, struct MP4DescriptorRecord *desc ) +static MP4Err setDescriptor(struct MP4Atom *s, struct MP4DescriptorRecord *desc) { - MP4Err err; - MP4ObjectDescriptorAtomPtr self = (MP4ObjectDescriptorAtomPtr) s; - err = MP4NoErr; - - if ( self->descriptor ) - BAILWITHERROR( MP4BadParamErr ); - self->descriptor = desc; - err = desc->calculateSize( desc ); if (err) goto bail; - self->ODSize = desc->size; + MP4Err err; + MP4ObjectDescriptorAtomPtr self = (MP4ObjectDescriptorAtomPtr)s; + err = MP4NoErr; + + if(self->descriptor) BAILWITHERROR(MP4BadParamErr); + self->descriptor = desc; + err = desc->calculateSize(desc); + if(err) goto bail; + self->ODSize = desc->size; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -typedef MP4Err (*sdfunc)( struct MP4Atom* s, char *desc ); +typedef MP4Err (*sdfunc)(struct MP4Atom *s, char *desc); -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4ObjectDescriptorAtomPtr self = (MP4ObjectDescriptorAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_DESCRIPTOR( descriptor ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4ObjectDescriptorAtomPtr self = (MP4ObjectDescriptorAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_DESCRIPTOR(descriptor); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4ObjectDescriptorAtomPtr self = (MP4ObjectDescriptorAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - ADD_DESCRIPTOR_SIZE( descriptor ); + MP4Err err; + MP4ObjectDescriptorAtomPtr self = (MP4ObjectDescriptorAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + ADD_DESCRIPTOR_SIZE(descriptor); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4ObjectDescriptorAtomPtr self = (MP4ObjectDescriptorAtomPtr) s; - - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - err = MP4ParseDescriptor( inputStream, &self->descriptor ); if (err) goto bail; - self->ODSize = self->descriptor->size; + MP4Err err; + MP4ObjectDescriptorAtomPtr self = (MP4ObjectDescriptorAtomPtr)s; + + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + err = MP4ParseDescriptor(inputStream, &self->descriptor); + if(err) goto bail; + self->ODSize = self->descriptor->size; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateObjectDescriptorAtom( MP4ObjectDescriptorAtomPtr *outAtom ) +MP4Err MP4CreateObjectDescriptorAtom(MP4ObjectDescriptorAtomPtr *outAtom) { - MP4Err err; - MP4ObjectDescriptorAtomPtr self; - - self = (MP4ObjectDescriptorAtomPtr) calloc( 1, sizeof(MP4ObjectDescriptorAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4ObjectDescriptorAtomType; - self->name = "object descriptor"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->setDescriptor = (sdfunc) setDescriptor; - *outAtom = self; + MP4Err err; + MP4ObjectDescriptorAtomPtr self; + + self = (MP4ObjectDescriptorAtomPtr)calloc(1, sizeof(MP4ObjectDescriptorAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4ObjectDescriptorAtomType; + self->name = "object descriptor"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->setDescriptor = (sdfunc)setDescriptor; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ObjectDescriptorMediaHeader.c b/IsoLib/libisomediafile/src/ObjectDescriptorMediaHeader.c index 3a48a0d..7c5a47b 100644 --- a/IsoLib/libisomediafile/src/ObjectDescriptorMediaHeader.c +++ b/IsoLib/libisomediafile/src/ObjectDescriptorMediaHeader.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,93 +15,95 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ObjectDescriptorMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: ObjectDescriptorMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4ObjectDescriptorMediaHeaderAtomPtr self = (MP4ObjectDescriptorMediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4ObjectDescriptorMediaHeaderAtomPtr self = (MP4ObjectDescriptorMediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - /*MP4ObjectDescriptorMediaHeaderAtomPtr self = (MP4ObjectDescriptorMediaHeaderAtomPtr) s;*/ - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; + MP4Err err; + /*MP4ObjectDescriptorMediaHeaderAtomPtr self = (MP4ObjectDescriptorMediaHeaderAtomPtr) s;*/ + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4ObjectDescriptorMediaHeaderAtomPtr self = (MP4ObjectDescriptorMediaHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; + MP4Err err; + MP4ObjectDescriptorMediaHeaderAtomPtr self = (MP4ObjectDescriptorMediaHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateObjectDescriptorMediaHeaderAtom( MP4ObjectDescriptorMediaHeaderAtomPtr *outAtom ) +MP4Err MP4CreateObjectDescriptorMediaHeaderAtom(MP4ObjectDescriptorMediaHeaderAtomPtr *outAtom) { - MP4Err err; - MP4ObjectDescriptorMediaHeaderAtomPtr self; - - self = (MP4ObjectDescriptorMediaHeaderAtomPtr) calloc( 1, sizeof(MP4ObjectDescriptorMediaHeaderAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4ObjectDescriptorMediaHeaderAtomType; - self->name = "object descriptor media header"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4ObjectDescriptorMediaHeaderAtomPtr self; + + self = + (MP4ObjectDescriptorMediaHeaderAtomPtr)calloc(1, sizeof(MP4ObjectDescriptorMediaHeaderAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4ObjectDescriptorMediaHeaderAtomType; + self->name = "object descriptor media header"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/OriginalFormatAtom.c b/IsoLib/libisomediafile/src/OriginalFormatAtom.c index 316c3d7..27214d4 100644 --- a/IsoLib/libisomediafile/src/OriginalFormatAtom.c +++ b/IsoLib/libisomediafile/src/OriginalFormatAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: OriginalFormatAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: OriginalFormatAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -30,94 +30,94 @@ derivative works. Copyright (c) 1999. #ifdef ISMACrypt -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4OriginalFormatAtomPtr self = (MP4OriginalFormatAtomPtr) s; - err = MP4NoErr; + MP4Err err; + MP4OriginalFormatAtomPtr self = (MP4OriginalFormatAtomPtr)s; + err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) + if(self == NULL) BAILWITHERROR(MP4BadParamErr) - if ( self->super ) - self->super->destroy( s ); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4OriginalFormatAtomPtr self = (MP4OriginalFormatAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( (MP4AtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( original_format ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4OriginalFormatAtomPtr self = (MP4OriginalFormatAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields((MP4AtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(original_format); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4OriginalFormatAtomPtr self = (MP4OriginalFormatAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( (MP4AtomPtr) s ); if (err) goto bail; - self->size += 4; + MP4Err err; + MP4OriginalFormatAtomPtr self = (MP4OriginalFormatAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)s); + if(err) goto bail; + self->size += 4; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4OriginalFormatAtomPtr self = (MP4OriginalFormatAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - GET32( original_format ); - assert( self->bytesRead == self->size ); + MP4Err err; + MP4OriginalFormatAtomPtr self = (MP4OriginalFormatAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + GET32(original_format); + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateOriginalFormatAtom( MP4OriginalFormatAtomPtr *outAtom ) +MP4Err MP4CreateOriginalFormatAtom(MP4OriginalFormatAtomPtr *outAtom) { - MP4Err err; - MP4OriginalFormatAtomPtr self; - - self = (MP4OriginalFormatAtomPtr) calloc( 1, sizeof(MP4OriginalFormatAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4OriginalFormatAtomType; - self->name = "OriginalFormatBox"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4OriginalFormatAtomPtr self; + + self = (MP4OriginalFormatAtomPtr)calloc(1, sizeof(MP4OriginalFormatAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4OriginalFormatAtomType; + self->name = "OriginalFormatBox"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } #endif - diff --git a/IsoLib/libisomediafile/src/PCMConfigAtom.c b/IsoLib/libisomediafile/src/PCMConfigAtom.c old mode 100755 new mode 100644 index a182383..cdc6bf3 --- a/IsoLib/libisomediafile/src/PCMConfigAtom.c +++ b/IsoLib/libisomediafile/src/PCMConfigAtom.c @@ -25,103 +25,104 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4PCMConfigAtomPtr self = (MP4PCMConfigAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4PCMConfigAtomPtr self = (MP4PCMConfigAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - u8 tmp8; - MP4Err err; - MP4PCMConfigAtomPtr self = (MP4PCMConfigAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - tmp8 = self->format_flags; - PUT8_V(tmp8); - tmp8 = self->PCM_sample_size; - PUT8_V(tmp8); - - assert( self->bytesWritten == self->size ); + u8 tmp8; + MP4Err err; + MP4PCMConfigAtomPtr self = (MP4PCMConfigAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + tmp8 = self->format_flags; + PUT8_V(tmp8); + tmp8 = self->PCM_sample_size; + PUT8_V(tmp8); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4PCMConfigAtomPtr self = (MP4PCMConfigAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - - self->size += 2; - + MP4Err err; + MP4PCMConfigAtomPtr self = (MP4PCMConfigAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + self->size += 2; + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - u32 tmp8; - MP4Err err; - MP4PCMConfigAtomPtr self = (MP4PCMConfigAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET8_V(tmp8); - self->format_flags = tmp8; - GET8_V(tmp8); - self->PCM_sample_size = tmp8; - - assert( self->bytesRead == self->size ); + u32 tmp8; + MP4Err err; + MP4PCMConfigAtomPtr self = (MP4PCMConfigAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET8_V(tmp8); + self->format_flags = tmp8; + GET8_V(tmp8); + self->PCM_sample_size = tmp8; + + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err MP4CreatePCMConfigAtom( MP4PCMConfigAtomPtr *outAtom ) +MP4Err MP4CreatePCMConfigAtom(MP4PCMConfigAtomPtr *outAtom) { - MP4Err err; - MP4PCMConfigAtomPtr self; - - self = (MP4PCMConfigAtomPtr) calloc( 1, sizeof(MP4PCMConfigAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4PCMConfigAtomType; - self->name = "PCM configuration"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4PCMConfigAtomPtr self; + + self = (MP4PCMConfigAtomPtr)calloc(1, sizeof(MP4PCMConfigAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4PCMConfigAtomType; + self->name = "PCM configuration"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/PaddingBitsAtom.c b/IsoLib/libisomediafile/src/PaddingBitsAtom.c index 5c0cda5..77d0360 100644 --- a/IsoLib/libisomediafile/src/PaddingBitsAtom.c +++ b/IsoLib/libisomediafile/src/PaddingBitsAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,198 +15,210 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: PaddingBitsAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: PaddingBitsAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4PaddingBitsAtomPtr self; - err = MP4NoErr; - self = (MP4PaddingBitsAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->pads ) - { - free( self->pads ); - self->pads = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4PaddingBitsAtomPtr self; + err = MP4NoErr; + self = (MP4PaddingBitsAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->pads) + { + free(self->pads); + self->pads = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err addSamplePads( struct MP4PaddingBitsAtom *self, u32 sampleCount, MP4Handle padsH ) +static MP4Err addSamplePads(struct MP4PaddingBitsAtom *self, u32 sampleCount, MP4Handle padsH) { - MP4Err err; - u8 *PaddingBits; - u32 padsCount; - u8 *newpads; - u8 defaultpad; - u8 dodefault; - u32 i; - - err = MP4NoErr; - - dodefault =1; - defaultpad=0; - PaddingBits = NULL; - - if (padsH!=NULL) - { - PaddingBits = (u8 *) *padsH; - err = MP4GetHandleSize( padsH, &padsCount ); if (err) goto bail; - switch (padsCount) { - case 0: break; - case 1: defaultpad=*PaddingBits; break; - default: dodefault=0; assert( sampleCount==padsCount ); break; - } - } - - newpads = (u8*) calloc( sampleCount + self->sampleCount + 1, sizeof(u8) ); - /* we add so we can easily pack up (see below) */ - TESTMALLOC( newpads ); - if ( self->sampleCount > 0) - memcpy( newpads, self->pads, self->sampleCount ); - - if (dodefault==0) { - memcpy( newpads + self->sampleCount, PaddingBits, padsCount ); - } - else - { - for (i=0; isampleCount] = defaultpad; - } - - if ( self->sampleCount > 0) free( self->pads ); - self->pads = newpads; - - self->sampleCount += sampleCount; + MP4Err err; + u8 *PaddingBits; + u32 padsCount; + u8 *newpads; + u8 defaultpad; + u8 dodefault; + u32 i; + + err = MP4NoErr; + + dodefault = 1; + defaultpad = 0; + PaddingBits = NULL; + + if(padsH != NULL) + { + PaddingBits = (u8 *)*padsH; + err = MP4GetHandleSize(padsH, &padsCount); + if(err) goto bail; + switch(padsCount) + { + case 0: + break; + case 1: + defaultpad = *PaddingBits; + break; + default: + dodefault = 0; + assert(sampleCount == padsCount); + break; + } + } + + newpads = (u8 *)calloc(sampleCount + self->sampleCount + 1, sizeof(u8)); + /* we add so we can easily pack up (see below) */ + TESTMALLOC(newpads); + if(self->sampleCount > 0) memcpy(newpads, self->pads, self->sampleCount); + + if(dodefault == 0) + { + memcpy(newpads + self->sampleCount, PaddingBits, padsCount); + } + else + { + for(i = 0; i < sampleCount; i++) + newpads[i + self->sampleCount] = defaultpad; + } + + if(self->sampleCount > 0) free(self->pads); + self->pads = newpads; + + self->sampleCount += sampleCount; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getPaddingBits( MP4AtomPtr s, u32 sampleNumber, u8 *outPad ) +static MP4Err getPaddingBits(MP4AtomPtr s, u32 sampleNumber, u8 *outPad) { - MP4Err err; - MP4PaddingBitsAtomPtr self = (MP4PaddingBitsAtomPtr) s; - - err = MP4NoErr; - if ( (self == NULL) || (outPad == NULL) || (sampleNumber > self->sampleCount) || (sampleNumber == 0) ) - BAILWITHERROR( MP4BadParamErr ) - - if (self->pads == NULL) *outPad = 0; - else - *outPad = self->pads[sampleNumber - 1]; - - + MP4Err err; + MP4PaddingBitsAtomPtr self = (MP4PaddingBitsAtomPtr)s; + + err = MP4NoErr; + if((self == NULL) || (outPad == NULL) || (sampleNumber > self->sampleCount) || + (sampleNumber == 0)) + BAILWITHERROR(MP4BadParamErr) + + if(self->pads == NULL) *outPad = 0; + else + *outPad = self->pads[sampleNumber - 1]; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - MP4PaddingBitsAtomPtr self = (MP4PaddingBitsAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( sampleCount ); - for ( i = 0; i < ((self->sampleCount+1)/2); i++ ) - { - PUT8_V( (self->pads[i*2] & 7) | ((self->pads[i*2+1] & 7)<<4) ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + MP4PaddingBitsAtomPtr self = (MP4PaddingBitsAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(sampleCount); + for(i = 0; i < ((self->sampleCount + 1) / 2); i++) + { + PUT8_V((self->pads[i * 2] & 7) | ((self->pads[i * 2 + 1] & 7) << 4)); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4PaddingBitsAtomPtr self = (MP4PaddingBitsAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += ((self->sampleCount+1)/2) + 4; + MP4Err err; + MP4PaddingBitsAtomPtr self = (MP4PaddingBitsAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += ((self->sampleCount + 1) / 2) + 4; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 entries; - u8* p; - MP4PaddingBitsAtomPtr self = (MP4PaddingBitsAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( sampleCount ); - - self->pads = (u8 *) calloc( self->sampleCount + 1, sizeof(u8) ); - TESTMALLOC( self->pads ); - p = self->pads; - for ( entries = 0; entries < self->sampleCount; entries = entries + 2 ) - { - u32 pad; - GET8_V_MSG( pad, NULL ); - *p = pad & 7; p++; pad = pad >> 4; - *p = pad & 7; p++; - } - + MP4Err err; + u32 entries; + u8 *p; + MP4PaddingBitsAtomPtr self = (MP4PaddingBitsAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(sampleCount); + + self->pads = (u8 *)calloc(self->sampleCount + 1, sizeof(u8)); + TESTMALLOC(self->pads); + p = self->pads; + for(entries = 0; entries < self->sampleCount; entries = entries + 2) + { + u32 pad; + GET8_V_MSG(pad, NULL); + *p = pad & 7; + p++; + pad = pad >> 4; + *p = pad & 7; + p++; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreatePaddingBitsAtom( MP4PaddingBitsAtomPtr *outAtom ) +MP4Err MP4CreatePaddingBitsAtom(MP4PaddingBitsAtomPtr *outAtom) { - MP4Err err; - MP4PaddingBitsAtomPtr self; - - self = (MP4PaddingBitsAtomPtr) calloc( 1, sizeof(MP4PaddingBitsAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4PaddingBitsAtomType; - self->name = "padding bits"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->getSamplePad = getPaddingBits; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addSamplePads = addSamplePads; - *outAtom = self; + MP4Err err; + MP4PaddingBitsAtomPtr self; + + self = (MP4PaddingBitsAtomPtr)calloc(1, sizeof(MP4PaddingBitsAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4PaddingBitsAtomType; + self->name = "padding bits"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->getSamplePad = getPaddingBits; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addSamplePads = addSamplePads; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/PrimaryItemAtom.c b/IsoLib/libisomediafile/src/PrimaryItemAtom.c index c671b26..f332920 100644 --- a/IsoLib/libisomediafile/src/PrimaryItemAtom.c +++ b/IsoLib/libisomediafile/src/PrimaryItemAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,101 +15,102 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: PrimaryItemAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: PrimaryItemAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - ISOPrimaryItemAtomPtr self = (ISOPrimaryItemAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT16( item_ID ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + ISOPrimaryItemAtomPtr self = (ISOPrimaryItemAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT16(item_ID); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISOPrimaryItemAtomPtr self = (ISOPrimaryItemAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 2; + MP4Err err; + ISOPrimaryItemAtomPtr self = (ISOPrimaryItemAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 2; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - ISOPrimaryItemAtomPtr self = (ISOPrimaryItemAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; + MP4Err err; + ISOPrimaryItemAtomPtr self = (ISOPrimaryItemAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; - GET16( item_ID ); + GET16(item_ID); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err ISOCreatePrimaryItemAtom( ISOPrimaryItemAtomPtr *outAtom ) +MP4Err ISOCreatePrimaryItemAtom(ISOPrimaryItemAtomPtr *outAtom) { - MP4Err err; - ISOPrimaryItemAtomPtr self; - - self = (ISOPrimaryItemAtomPtr) calloc( 1, sizeof(ISOPrimaryItemAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOPrimaryItemAtomType; - self->name = "primary item"; - self->flags = 0; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->item_ID = 0; - - *outAtom = self; + MP4Err err; + ISOPrimaryItemAtomPtr self; + + self = (ISOPrimaryItemAtomPtr)calloc(1, sizeof(ISOPrimaryItemAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOPrimaryItemAtomType; + self->name = "primary item"; + self->flags = 0; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->item_ID = 0; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c b/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c index bc83e4f..272472c 100644 --- a/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c +++ b/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c @@ -1,149 +1,137 @@ /* -* This software module was originally developed by InterDigital, Inc. -* in the course of development of MPEG-4. -* This software module is an implementation of a part of one or -* more MPEG-4 tools as specified by MPEG-4. -* ISO/IEC gives users of MPEG-4 free license to this -* software module or modifications thereof for use in hardware -* or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. -* Those intending to use this software module in hardware or software -* products are advised that its use may infringe existing patents. -* The original developer of this software module and his/her company, -* the subsequent editors and their companies, and ISO/IEC have no -* liability for use of this software module or modifications thereof -* in an implementation. -* -* Copyright is not released for non MPEG-4 conforming -* products. InterDigital, Inc. retains full right to use the code for its own -* purpose, assign or donate the code to a third party and to -* inhibit third parties from using the code for non -* MPEG-4 conforming products. -* -* This copyright notice must be included in all copies or -* derivative works. -*/ - + * This software module was originally developed by InterDigital, Inc. + * in the course of development of MPEG-4. + * This software module is an implementation of a part of one or + * more MPEG-4 tools as specified by MPEG-4. + * ISO/IEC gives users of MPEG-4 free license to this + * software module or modifications thereof for use in hardware + * or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. + * Those intending to use this software module in hardware or software + * products are advised that its use may infringe existing patents. + * The original developer of this software module and his/her company, + * the subsequent editors and their companies, and ISO/IEC have no + * liability for use of this software module or modifications thereof + * in an implementation. + * + * Copyright is not released for non MPEG-4 conforming + * products. InterDigital, Inc. retains full right to use the code for its own + * purpose, assign or donate the code to a third party and to + * inhibit third parties from using the code for non + * MPEG-4 conforming products. + * + * This copyright notice must be included in all copies or + * derivative works. + */ /** -* @file ProducerReferenceTimeAtom.c -* @author Ahmed Hamza -* @date April 19, 2018 -* @brief Implements functions for reading and writing ProducerReferenceTimeAtom instances. -*/ - + * @file ProducerReferenceTimeAtom.c + * @author Ahmed Hamza + * @date April 19, 2018 + * @brief Implements functions for reading and writing ProducerReferenceTimeAtom instances. + */ #include "MP4Atoms.h" #include #include - static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4ProducerReferenceTimeAtomPtr self; + MP4Err err; + MP4ProducerReferenceTimeAtomPtr self; - self = (MP4ProducerReferenceTimeAtomPtr)s; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + self = (MP4ProducerReferenceTimeAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - if (self->super) - self->super->destroy(s); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return; + return; } - - - -static MP4Err serialize(struct MP4Atom* s, char* buffer) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; + MP4Err err; - MP4ProducerReferenceTimeAtomPtr self = (MP4ProducerReferenceTimeAtomPtr)s; - err = MP4NoErr; + MP4ProducerReferenceTimeAtomPtr self = (MP4ProducerReferenceTimeAtomPtr)s; + err = MP4NoErr; - err = MP4SerializeCommonFullAtomFields((MP4FullAtom*)s, buffer); if (err) goto bail; /* Full Atom */ - buffer += self->bytesWritten; + err = MP4SerializeCommonFullAtomFields((MP4FullAtom *)s, buffer); + if(err) goto bail; /* Full Atom */ + buffer += self->bytesWritten; - PUT32(referenceTrackId); - PUT64(ntpTimestamp); - PUT32(mediaTime); + PUT32(referenceTrackId); + PUT64(ntpTimestamp); + PUT32(mediaTime); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err calculateSize(struct MP4Atom* s) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; + MP4Err err; - MP4ProducerReferenceTimeAtomPtr self = (MP4ProducerReferenceTimeAtomPtr)s; - err = MP4NoErr; + MP4ProducerReferenceTimeAtomPtr self = (MP4ProducerReferenceTimeAtomPtr)s; + err = MP4NoErr; - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if (err) goto bail; + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; - self->size += 4 + 8 + 4; + self->size += 4 + 8 + 4; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - - - static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; + MP4Err err; - MP4ProducerReferenceTimeAtomPtr self = (MP4ProducerReferenceTimeAtomPtr)s; + MP4ProducerReferenceTimeAtomPtr self = (MP4ProducerReferenceTimeAtomPtr)s; - err = MP4NoErr; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - err = self->super->createFromInputStream(s, proto, (char*)inputStream); + err = self->super->createFromInputStream(s, proto, (char *)inputStream); - GET32(referenceTrackId); - GET64(ntpTimestamp); - GET32(mediaTime); + GET32(referenceTrackId); + GET64(ntpTimestamp); + GET32(mediaTime); - assert(self->bytesRead == self->size); + assert(self->bytesRead == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - - MP4Err MP4CreateProducerReferenceTimeAtom(MP4ProducerReferenceTimeAtomPtr *outAtom) { - MP4Err err; - MP4ProducerReferenceTimeAtomPtr self; + MP4Err err; + MP4ProducerReferenceTimeAtomPtr self; - self = (MP4ProducerReferenceTimeAtomPtr)calloc(1, sizeof(MP4ProducerReferenceTimeAtom)); - TESTMALLOC(self); + self = (MP4ProducerReferenceTimeAtomPtr)calloc(1, sizeof(MP4ProducerReferenceTimeAtom)); + TESTMALLOC(self); - err = MP4CreateFullAtom((MP4AtomPtr)self); if (err) goto bail; + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; - self->type = MP4ProducerReferenceTimeAtomType; - self->name = "ProducerReferenceTimeBox"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; + self->type = MP4ProducerReferenceTimeAtomType; + self->name = "ProducerReferenceTimeBox"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; - *outAtom = self; + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } \ No newline at end of file diff --git a/IsoLib/libisomediafile/src/QTMovies.c b/IsoLib/libisomediafile/src/QTMovies.c index 72369be..764bab5 100644 --- a/IsoLib/libisomediafile/src/QTMovies.c +++ b/IsoLib/libisomediafile/src/QTMovies.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: QTMovies.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: QTMovies.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "ISOMovies.h" #include "MP4Atoms.h" @@ -42,116 +42,143 @@ derivative works. Copyright (c) 1999, 2000. #include #include -ISO_EXTERN ( ISOErr ) -QTNewMovie( ISOMovie *outMovie ) +ISO_EXTERN(ISOErr) +QTNewMovie(ISOMovie *outMovie) { - ISOErr MP4CreateMediaDataAtom( MP4MediaDataAtomPtr *outAtom ); - ISOErr MP4CreateMovieAtom( MP4MovieAtomPtr *outAtom ); - ISOErr MP4CreateMovieHeaderAtom( MP4MovieHeaderAtomPtr *outAtom ); - - u64 now; - ISOErr err; - MP4PrivateMovieRecordPtr movie; - MP4MovieAtomPtr moov; - MP4MovieHeaderAtomPtr mvhd; - MP4MediaDataAtomPtr mdat; - ISOFileTypeAtomPtr ftyp; - - movie = (MP4PrivateMovieRecordPtr) calloc( 1, sizeof(MP4PrivateMovieRecord) ); - if ( movie == NULL ) - { - err = MP4NoMemoryErr; - goto bail; - } - movie->referenceCount = 1; - movie->prepend_handle = NULL; - err = MP4GetCurrentTime( &now ); if (err) goto bail; - err = MP4CreateMovieAtom( (MP4MovieAtomPtr *) &movie->moovAtomPtr ); if (err) goto bail; - moov = (MP4MovieAtomPtr) movie->moovAtomPtr; - err = MP4CreateMovieHeaderAtom( &mvhd ); if (err) goto bail; - mvhd->nextTrackID = 1; - mvhd->creationTime = now; - mvhd->modificationTime = now; - err = moov->addAtom( moov, (MP4AtomPtr) mvhd ); if (err) goto bail; - moov->setTimeScale( moov, 600 ); - err = MP4CreateMediaDataAtom( &mdat ); - movie->mdat = (MP4AtomPtr) mdat; - { - MP4DataHandlerPtr dh; - - err = MP4CreateMdatDataHandler( mdat, &dh ); if (err) goto bail; - movie->inMemoryDataHandler = dh; - } - movie->fileType = ISOQuickTimeFileType; - - err = MJ2CreateFileTypeAtom( &ftyp ); if (err) goto bail; - err = ftyp->setBrand( ftyp, ISOQuickTimeBrand, 0 ); if (err) goto bail; - err = ftyp->addStandard( ftyp, ISOISOBrand ); if (err) goto bail; - movie->ftyp = (MP4AtomPtr) ftyp; - - *outMovie = (MP4Movie) movie; + ISOErr MP4CreateMediaDataAtom(MP4MediaDataAtomPtr * outAtom); + ISOErr MP4CreateMovieAtom(MP4MovieAtomPtr * outAtom); + ISOErr MP4CreateMovieHeaderAtom(MP4MovieHeaderAtomPtr * outAtom); + + u64 now; + ISOErr err; + MP4PrivateMovieRecordPtr movie; + MP4MovieAtomPtr moov; + MP4MovieHeaderAtomPtr mvhd; + MP4MediaDataAtomPtr mdat; + ISOFileTypeAtomPtr ftyp; + + movie = (MP4PrivateMovieRecordPtr)calloc(1, sizeof(MP4PrivateMovieRecord)); + if(movie == NULL) + { + err = MP4NoMemoryErr; + goto bail; + } + movie->referenceCount = 1; + movie->prepend_handle = NULL; + err = MP4GetCurrentTime(&now); + if(err) goto bail; + err = MP4CreateMovieAtom((MP4MovieAtomPtr *)&movie->moovAtomPtr); + if(err) goto bail; + moov = (MP4MovieAtomPtr)movie->moovAtomPtr; + err = MP4CreateMovieHeaderAtom(&mvhd); + if(err) goto bail; + mvhd->nextTrackID = 1; + mvhd->creationTime = now; + mvhd->modificationTime = now; + err = moov->addAtom(moov, (MP4AtomPtr)mvhd); + if(err) goto bail; + moov->setTimeScale(moov, 600); + err = MP4CreateMediaDataAtom(&mdat); + movie->mdat = (MP4AtomPtr)mdat; + { + MP4DataHandlerPtr dh; + + err = MP4CreateMdatDataHandler(mdat, &dh); + if(err) goto bail; + movie->inMemoryDataHandler = dh; + } + movie->fileType = ISOQuickTimeFileType; + + err = MJ2CreateFileTypeAtom(&ftyp); + if(err) goto bail; + err = ftyp->setBrand(ftyp, ISOQuickTimeBrand, 0); + if(err) goto bail; + err = ftyp->addStandard(ftyp, ISOISOBrand); + if(err) goto bail; + movie->ftyp = (MP4AtomPtr)ftyp; + + *outMovie = (MP4Movie)movie; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -ISO_EXTERN ( ISOErr ) -New3GPPMovie( ISOMovie *outMovie, u16 release ) +ISO_EXTERN(ISOErr) +New3GPPMovie(ISOMovie *outMovie, u16 release) { - ISOErr MP4CreateMediaDataAtom( MP4MediaDataAtomPtr *outAtom ); - ISOErr MP4CreateMovieAtom( MP4MovieAtomPtr *outAtom ); - ISOErr MP4CreateMovieHeaderAtom( MP4MovieHeaderAtomPtr *outAtom ); - - u64 now; - ISOErr err; - MP4PrivateMovieRecordPtr movie; - MP4MovieAtomPtr moov; - MP4MovieHeaderAtomPtr mvhd; - MP4MediaDataAtomPtr mdat; - ISOFileTypeAtomPtr ftyp; - - movie = (MP4PrivateMovieRecordPtr) calloc( 1, sizeof(MP4PrivateMovieRecord) ); - if ( movie == NULL ) - { - err = MP4NoMemoryErr; - goto bail; - } - movie->referenceCount = 1; - movie->prepend_handle = NULL; - err = MP4GetCurrentTime( &now ); if (err) goto bail; - err = MP4CreateMovieAtom( (MP4MovieAtomPtr *) &movie->moovAtomPtr ); if (err) goto bail; - moov = (MP4MovieAtomPtr) movie->moovAtomPtr; - err = MP4CreateMovieHeaderAtom( &mvhd ); if (err) goto bail; - mvhd->nextTrackID = 1; - mvhd->creationTime = now; - mvhd->modificationTime = now; - err = moov->addAtom( moov, (MP4AtomPtr) mvhd ); if (err) goto bail; - moov->setTimeScale( moov, 600 ); - err = MP4CreateMediaDataAtom( &mdat ); - movie->mdat = (MP4AtomPtr) mdat; - { - MP4DataHandlerPtr dh; - - err = MP4CreateMdatDataHandler( mdat, &dh ); if (err) goto bail; - movie->inMemoryDataHandler = dh; - } - movie->fileType = ISO3GPPFileType; - - err = MJ2CreateFileTypeAtom( &ftyp ); if (err) goto bail; - - switch (release) { - case 4: err = ftyp->setBrand( ftyp, ISO3GP4Brand, 0 ); if (err) goto bail; break; - case 5: err = ftyp->setBrand( ftyp, ISO3GP5Brand, 0 ); if (err) goto bail; break; - case 6: err = ftyp->setBrand( ftyp, ISO3GP6Brand, 0 ); if (err) goto bail; break; - default: BAILWITHERROR( ISONotImplementedErr); break; - } - err = ftyp->addStandard( ftyp, ISOISOBrand ); if (err) goto bail; - movie->ftyp = (MP4AtomPtr) ftyp; - - *outMovie = (MP4Movie) movie; + ISOErr MP4CreateMediaDataAtom(MP4MediaDataAtomPtr * outAtom); + ISOErr MP4CreateMovieAtom(MP4MovieAtomPtr * outAtom); + ISOErr MP4CreateMovieHeaderAtom(MP4MovieHeaderAtomPtr * outAtom); + + u64 now; + ISOErr err; + MP4PrivateMovieRecordPtr movie; + MP4MovieAtomPtr moov; + MP4MovieHeaderAtomPtr mvhd; + MP4MediaDataAtomPtr mdat; + ISOFileTypeAtomPtr ftyp; + + movie = (MP4PrivateMovieRecordPtr)calloc(1, sizeof(MP4PrivateMovieRecord)); + if(movie == NULL) + { + err = MP4NoMemoryErr; + goto bail; + } + movie->referenceCount = 1; + movie->prepend_handle = NULL; + err = MP4GetCurrentTime(&now); + if(err) goto bail; + err = MP4CreateMovieAtom((MP4MovieAtomPtr *)&movie->moovAtomPtr); + if(err) goto bail; + moov = (MP4MovieAtomPtr)movie->moovAtomPtr; + err = MP4CreateMovieHeaderAtom(&mvhd); + if(err) goto bail; + mvhd->nextTrackID = 1; + mvhd->creationTime = now; + mvhd->modificationTime = now; + err = moov->addAtom(moov, (MP4AtomPtr)mvhd); + if(err) goto bail; + moov->setTimeScale(moov, 600); + err = MP4CreateMediaDataAtom(&mdat); + movie->mdat = (MP4AtomPtr)mdat; + { + MP4DataHandlerPtr dh; + + err = MP4CreateMdatDataHandler(mdat, &dh); + if(err) goto bail; + movie->inMemoryDataHandler = dh; + } + movie->fileType = ISO3GPPFileType; + + err = MJ2CreateFileTypeAtom(&ftyp); + if(err) goto bail; + + switch(release) + { + case 4: + err = ftyp->setBrand(ftyp, ISO3GP4Brand, 0); + if(err) goto bail; + break; + case 5: + err = ftyp->setBrand(ftyp, ISO3GP5Brand, 0); + if(err) goto bail; + break; + case 6: + err = ftyp->setBrand(ftyp, ISO3GP6Brand, 0); + if(err) goto bail; + break; + default: + BAILWITHERROR(ISONotImplementedErr); + break; + } + err = ftyp->addStandard(ftyp, ISOISOBrand); + if(err) goto bail; + movie->ftyp = (MP4AtomPtr)ftyp; + + *outMovie = (MP4Movie)movie; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/RestrictedSchemeInfoAtom.c b/IsoLib/libisomediafile/src/RestrictedSchemeInfoAtom.c index c110f74..2c03c94 100644 --- a/IsoLib/libisomediafile/src/RestrictedSchemeInfoAtom.c +++ b/IsoLib/libisomediafile/src/RestrictedSchemeInfoAtom.c @@ -13,7 +13,7 @@ * liability for use of this software module or modifications thereof * in an implementation. * - * Copyright is not released for non MPEG-4 conforming + * Copyright is not released for non MPEG-4 conforming * products. InterDigital, Inc. retains full right to use the code for its own * purpose, assign or donate the code to a third party and to * inhibit third parties from using the code for non @@ -30,163 +30,153 @@ * @brief Implements functions for reading and writing RestrictedSchemeInfoAtom instances. */ - #include "MP4Atoms.h" #include #include - - static void destroy(MP4AtomPtr s) { - MP4Err err; - - MP4RestrictedSchemeInfoAtomPtr self = (MP4RestrictedSchemeInfoAtomPtr)s; - err = MP4NoErr; - - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); - - - DESTROY_ATOM_LIST_F(atomList); - - /* - if (self->MP4OriginalFormat) - { - self->MP4OriginalFormat->destroy(self->MP4OriginalFormat); - self->MP4OriginalFormat = NULL; - } - if (self->MP4SchemeType) - { - self->MP4SchemeType->destroy(self->MP4SchemeType); - self->MP4SchemeType = NULL; - } - if (self->MP4SchemeInfo) - { - self->MP4SchemeInfo->destroy(self->MP4SchemeInfo); - self->MP4SchemeInfo = NULL; - } - */ - - if (self->super) - self->super->destroy(s); + MP4Err err; + + MP4RestrictedSchemeInfoAtomPtr self = (MP4RestrictedSchemeInfoAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + DESTROY_ATOM_LIST_F(atomList); + + /* + if (self->MP4OriginalFormat) + { + self->MP4OriginalFormat->destroy(self->MP4OriginalFormat); + self->MP4OriginalFormat = NULL; + } + if (self->MP4SchemeType) + { + self->MP4SchemeType->destroy(self->MP4SchemeType); + self->MP4SchemeType = NULL; + } + if (self->MP4SchemeInfo) + { + self->MP4SchemeInfo->destroy(self->MP4SchemeInfo); + self->MP4SchemeInfo = NULL; + } + */ + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize(struct MP4Atom* s, char* buffer) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4RestrictedSchemeInfoAtomPtr self = (MP4RestrictedSchemeInfoAtomPtr)s; - err = MP4NoErr; + MP4Err err; + MP4RestrictedSchemeInfoAtomPtr self = (MP4RestrictedSchemeInfoAtomPtr)s; + err = MP4NoErr; - err = MP4SerializeCommonBaseAtomFields(s, buffer); if (err) goto bail; - buffer += self->bytesWritten; + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; - /* PUT32_V( 0 ); */ /* version/flags */ + /* PUT32_V( 0 ); */ /* version/flags */ - /* - SERIALIZE_ATOM(MP4OriginalFormat); - SERIALIZE_ATOM(MP4SchemeType); - SERIALIZE_ATOM(MP4SchemeInfo); - */ + /* + SERIALIZE_ATOM(MP4OriginalFormat); + SERIALIZE_ATOM(MP4SchemeType); + SERIALIZE_ATOM(MP4SchemeInfo); + */ - SERIALIZE_ATOM_LIST(atomList); + SERIALIZE_ATOM_LIST(atomList); - assert(self->bytesWritten == self->size); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize(struct MP4Atom* s) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4RestrictedSchemeInfoAtomPtr self = (MP4RestrictedSchemeInfoAtomPtr)s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize(s); if (err) goto bail; - self->size += 0; /* version/flags */ - - ADD_ATOM_LIST_SIZE(atomList); - -bail: - TEST_RETURN(err); + MP4Err err; + MP4RestrictedSchemeInfoAtomPtr self = (MP4RestrictedSchemeInfoAtomPtr)s; + err = MP4NoErr; - return err; -} + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 0; /* version/flags */ + + ADD_ATOM_LIST_SIZE(atomList); -#define ADDCASE( atomName ) \ - case atomName ## AtomType: \ - if (self->atomName) \ - BAILWITHERROR(MP4BadDataErr); \ - self->atomName = atom; \ - break +bail: + TEST_RETURN(err); + return err; +} +#define ADDCASE(atomName) \ + case atomName##AtomType: \ + if(self->atomName) BAILWITHERROR(MP4BadDataErr); \ + self->atomName = atom; \ + break static MP4Err addAtom(MP4RestrictedSchemeInfoAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - - err = MP4AddListEntry(atom, self->atomList); if (err) goto bail; - - switch (atom->type) - { - ADDCASE(MP4OriginalFormat); - ADDCASE(MP4SchemeType); - ADDCASE(MP4SchemeInfo); - } + MP4Err err; + err = MP4NoErr; + + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; + + switch(atom->type) + { + ADDCASE(MP4OriginalFormat); + ADDCASE(MP4SchemeType); + ADDCASE(MP4SchemeInfo); + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MP4RestrictedSchemeInfoAtom); - - - - + PARSE_ATOM_LIST(MP4RestrictedSchemeInfoAtom); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - - MP4Err MP4CreateRestrictedSchemeInfoAtom(MP4RestrictedSchemeInfoAtomPtr *outAtom) { - MP4Err err; - MP4RestrictedSchemeInfoAtomPtr self; + MP4Err err; + MP4RestrictedSchemeInfoAtomPtr self; - self = (MP4RestrictedSchemeInfoAtomPtr)calloc(1, sizeof(MP4RestrictedSchemeInfoAtom)); - TESTMALLOC(self); + self = (MP4RestrictedSchemeInfoAtomPtr)calloc(1, sizeof(MP4RestrictedSchemeInfoAtom)); + TESTMALLOC(self); - err = MP4CreateBaseAtom((MP4AtomPtr)self); if (err) goto bail; + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; - self->type = MP4RestrictedSchemeInfoAtomType; - self->name = "RestrictedSchemeInfoBox"; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addAtom = addAtom; + self->type = MP4RestrictedSchemeInfoAtomType; + self->name = "RestrictedSchemeInfoBox"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addAtom = addAtom; - err = MP4MakeLinkedList(&self->atomList); if (err) goto bail; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; - *outAtom = self; + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } \ No newline at end of file diff --git a/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c b/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c index 4248d6f..e633f9d 100644 --- a/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c +++ b/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c @@ -34,353 +34,398 @@ #include #include - static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4RestrictedVideoSampleEntryAtomPtr self; - err = MP4NoErr; - self = (MP4RestrictedVideoSampleEntryAtomPtr)s; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr) - - if (self->MP4RestrictedSchemeInfo) - { - self->MP4RestrictedSchemeInfo->destroy(self->MP4RestrictedSchemeInfo); - self->MP4RestrictedSchemeInfo = NULL; - } - DESTROY_ATOM_LIST_F(ExtensionAtomList) - - if (self->super) - self->super->destroy(s); + MP4Err err; + MP4RestrictedVideoSampleEntryAtomPtr self; + err = MP4NoErr; + self = (MP4RestrictedVideoSampleEntryAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->MP4RestrictedSchemeInfo) + { + self->MP4RestrictedSchemeInfo->destroy(self->MP4RestrictedSchemeInfo); + self->MP4RestrictedSchemeInfo = NULL; + } + DESTROY_ATOM_LIST_F(ExtensionAtomList) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize(struct MP4Atom* s, char* buffer) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields(s, buffer); if (err) goto bail; - buffer += self->bytesWritten; - - PUTBYTES(self->reserved1, 6); - PUT16(dataReferenceIndex); - PUTBYTES(self->reserved2, 16); - PUT16(width); - PUT16(height); - /* PUT32( reserved3 ); */ - PUT32(reserved4); - PUT32(reserved5); - PUT32(reserved6); - PUT16(reserved7); - PUT8(nameLength); - PUTBYTES(self->name31, 31); - PUT16(reserved8); - PUT16(reserved9); - - SERIALIZE_ATOM(MP4RestrictedSchemeInfo); - SERIALIZE_ATOM_LIST(ExtensionAtomList); - - assert(self->bytesWritten == self->size); + MP4Err err; + MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + PUTBYTES(self->reserved1, 6); + PUT16(dataReferenceIndex); + PUTBYTES(self->reserved2, 16); + PUT16(width); + PUT16(height); + /* PUT32( reserved3 ); */ + PUT32(reserved4); + PUT32(reserved5); + PUT32(reserved6); + PUT16(reserved7); + PUT8(nameLength); + PUTBYTES(self->name31, 31); + PUT16(reserved8); + PUT16(reserved9); + + SERIALIZE_ATOM(MP4RestrictedSchemeInfo); + SERIALIZE_ATOM_LIST(ExtensionAtomList); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize(struct MP4Atom* s) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize(s); if (err) goto bail; - self->size += (6 + 16 + 31 + (4 * 2) + (1 * 1) + (4 * 4)); /* TODO this probably includes restriction_type */ - ADD_ATOM_SIZE(MP4RestrictedSchemeInfo); - ADD_ATOM_LIST_SIZE(ExtensionAtomList); + MP4Err err; + MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += (6 + 16 + 31 + (4 * 2) + (1 * 1) + + (4 * 4)); /* TODO this probably includes restriction_type */ + ADD_ATOM_SIZE(MP4RestrictedSchemeInfo); + ADD_ATOM_LIST_SIZE(ExtensionAtomList); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static MP4Err addAtom(MP4RestrictedVideoSampleEntryAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - if (atom == NULL) - BAILWITHERROR(MP4BadParamErr); - if (atom->type == MP4RestrictedSchemeInfoAtomType) - self->MP4RestrictedSchemeInfo = atom; - else { err = MP4AddListEntry(atom, self->ExtensionAtomList); if (err) goto bail; } + MP4Err err; + err = MP4NoErr; + if(atom == NULL) BAILWITHERROR(MP4BadParamErr); + if(atom->type == MP4RestrictedSchemeInfoAtomType) self->MP4RestrictedSchemeInfo = atom; + else + { + err = MP4AddListEntry(atom, self->ExtensionAtomList); + if(err) goto bail; + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; - - err = MP4NoErr; - if (self == NULL) BAILWITHERROR(MP4BadParamErr) - err = self->super->createFromInputStream(s, proto, (char*)inputStream); if (err) goto bail; - - GETBYTES(6, reserved1); - GET16(dataReferenceIndex); - GETBYTES(16, reserved2); - GET16(width); - GET16(height); - /* GET32( reserved3 ); */ - GET32(reserved4); - GET32(reserved5); - GET32(reserved6); - GET16(reserved7); - GET8(nameLength); - GETBYTES(31, name31); - GET16(reserved8); - GET16(reserved9); - GETATOM(MP4RestrictedSchemeInfo); - GETATOM_LIST(ExtensionAtomList); - - if (self->bytesRead != self->size) - BAILWITHERROR(MP4BadDataErr); + MP4Err err; + MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GETBYTES(6, reserved1); + GET16(dataReferenceIndex); + GETBYTES(16, reserved2); + GET16(width); + GET16(height); + /* GET32( reserved3 ); */ + GET32(reserved4); + GET32(reserved5); + GET32(reserved6); + GET16(reserved7); + GET8(nameLength); + GETBYTES(31, name31); + GET16(reserved8); + GET16(reserved9); + GETATOM(MP4RestrictedSchemeInfo); + GETATOM_LIST(ExtensionAtomList); + + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - - -static MP4Err transform(struct MP4Atom *s, u32 sch_type, u32 sch_version, char* sch_url) +static MP4Err transform(struct MP4Atom *s, u32 sch_type, u32 sch_version, char *sch_url) { - MP4Err err; - - MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; - - MP4RestrictedSchemeInfoAtomPtr rinf; - MP4OriginalFormatAtomPtr frma; - MP4SchemeTypeAtomPtr schm; - MP4SchemeInfoAtomPtr schi; - char* sch_url_copy = NULL; - - err = MP4CreateOriginalFormatAtom(&frma); if (err) goto bail; - frma->original_format = self->type; - - err = MP4CreateSchemeInfoAtom(&schi); if (err) goto bail; - - err = MP4CreateSchemeTypeAtom(&schm); if (err) goto bail; - schm->scheme_type = sch_type; - schm->scheme_version = sch_version; - - if (sch_url) { - sch_url_copy = (char*)calloc(1, strlen(sch_url) + 1); - TESTMALLOC(sch_url_copy); - memcpy(sch_url_copy, sch_url, strlen(sch_url) + 1); - schm->scheme_url = sch_url_copy; sch_url_copy = NULL; - } - else schm->scheme_url = NULL; - - /* create 'rinf' atom */ - err = MP4CreateRestrictedSchemeInfoAtom(&rinf); if (err) goto bail; - - /* assign */ - rinf->addAtom(rinf, (MP4AtomPtr)frma); frma = NULL; - rinf->addAtom(rinf, (MP4AtomPtr)schm); schm = NULL; - rinf->addAtom(rinf, (MP4AtomPtr)schi); schi = NULL; - - self->type = self->restriction_type; - - /* set */ - self->addAtom(self, (MP4AtomPtr)rinf); + MP4Err err; + + MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; + + MP4RestrictedSchemeInfoAtomPtr rinf; + MP4OriginalFormatAtomPtr frma; + MP4SchemeTypeAtomPtr schm; + MP4SchemeInfoAtomPtr schi; + char *sch_url_copy = NULL; + + err = MP4CreateOriginalFormatAtom(&frma); + if(err) goto bail; + frma->original_format = self->type; + + err = MP4CreateSchemeInfoAtom(&schi); + if(err) goto bail; + + err = MP4CreateSchemeTypeAtom(&schm); + if(err) goto bail; + schm->scheme_type = sch_type; + schm->scheme_version = sch_version; + + if(sch_url) + { + sch_url_copy = (char *)calloc(1, strlen(sch_url) + 1); + TESTMALLOC(sch_url_copy); + memcpy(sch_url_copy, sch_url, strlen(sch_url) + 1); + schm->scheme_url = sch_url_copy; + sch_url_copy = NULL; + } + else + schm->scheme_url = NULL; + + /* create 'rinf' atom */ + err = MP4CreateRestrictedSchemeInfoAtom(&rinf); + if(err) goto bail; + + /* assign */ + rinf->addAtom(rinf, (MP4AtomPtr)frma); + frma = NULL; + rinf->addAtom(rinf, (MP4AtomPtr)schm); + schm = NULL; + rinf->addAtom(rinf, (MP4AtomPtr)schi); + schi = NULL; + + self->type = self->restriction_type; + + /* set */ + self->addAtom(self, (MP4AtomPtr)rinf); bail: - if (frma) frma->destroy((MP4AtomPtr)frma); - if (schm) schm->destroy((MP4AtomPtr)schm); - if (schi) schi->destroy((MP4AtomPtr)schi); - if (sch_url_copy) free(sch_url_copy); + if(frma) frma->destroy((MP4AtomPtr)frma); + if(schm) schm->destroy((MP4AtomPtr)schm); + if(schi) schi->destroy((MP4AtomPtr)schi); + if(sch_url_copy) free(sch_url_copy); - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static MP4Err untransform(struct MP4Atom *s) { - MP4Err err; + MP4Err err; - MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; - MP4OriginalFormatAtomPtr fmt; - MP4RestrictedSchemeInfoAtomPtr rinf; + MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; + MP4OriginalFormatAtomPtr fmt; + MP4RestrictedSchemeInfoAtomPtr rinf; - err = MP4NoErr; + err = MP4NoErr; - rinf = (MP4RestrictedSchemeInfoAtomPtr)self->MP4RestrictedSchemeInfo; - if (!rinf) { err = MP4BadParamErr; goto bail; } + rinf = (MP4RestrictedSchemeInfoAtomPtr)self->MP4RestrictedSchemeInfo; + if(!rinf) + { + err = MP4BadParamErr; + goto bail; + } - fmt = (MP4OriginalFormatAtomPtr)rinf->MP4OriginalFormat; - if (!fmt) { err = MP4BadDataErr; goto bail; } + fmt = (MP4OriginalFormatAtomPtr)rinf->MP4OriginalFormat; + if(!fmt) + { + err = MP4BadDataErr; + goto bail; + } - self->type = fmt->original_format; - self->MP4RestrictedSchemeInfo = NULL; + self->type = fmt->original_format; + self->MP4RestrictedSchemeInfo = NULL; - rinf->destroy((MP4AtomPtr)rinf); + rinf->destroy((MP4AtomPtr)rinf); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static MP4Err addSchemeInfoAtom(struct MP4Atom *s, struct MP4Atom *theAtom) { - MP4Err err; + MP4Err err; - MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; - MP4SchemeInfoAtomPtr schi; - MP4RestrictedSchemeInfoAtomPtr rinf; + MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; + MP4SchemeInfoAtomPtr schi; + MP4RestrictedSchemeInfoAtomPtr rinf; - rinf = (MP4RestrictedSchemeInfoAtomPtr)self->MP4RestrictedSchemeInfo; - if (!rinf) { err = MP4BadParamErr; goto bail; } + rinf = (MP4RestrictedSchemeInfoAtomPtr)self->MP4RestrictedSchemeInfo; + if(!rinf) + { + err = MP4BadParamErr; + goto bail; + } - schi = (MP4SchemeInfoAtomPtr)rinf->MP4SchemeInfo; - if (!schi) { err = MP4BadDataErr; goto bail; } + schi = (MP4SchemeInfoAtomPtr)rinf->MP4SchemeInfo; + if(!schi) + { + err = MP4BadDataErr; + goto bail; + } - err = schi->addAtom(schi, theAtom); if (err) goto bail; + err = schi->addAtom(schi, theAtom); + if(err) goto bail; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static MP4Err getSchemeInfoAtom(struct MP4Atom *s, u32 theType, struct MP4Atom **theAtom) { - MP4Err err; - - MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; - MP4SchemeInfoAtomPtr schi; - MP4RestrictedSchemeInfoAtomPtr rinf; - - err = MP4NoErr; - - rinf = (MP4RestrictedSchemeInfoAtomPtr)self->MP4RestrictedSchemeInfo; - if (!rinf) { err = MP4BadParamErr; goto bail; } - - schi = (MP4SchemeInfoAtomPtr)rinf->MP4SchemeInfo; - if (!schi) { err = MP4BadDataErr; goto bail; } - - err = MP4BadParamErr; - *theAtom = NULL; - - if (schi->atomList) - { - u32 count; - u32 i; - struct MP4Atom* desc; - err = MP4GetListEntryCount(schi->atomList, &count); if (err) goto bail; - for (i = 0; i < count; i++) - { - err = MP4GetListEntry(schi->atomList, i, (char **)&desc); if (err) goto bail; - if (desc && (desc->type == theType)) - { - *theAtom = desc; - break; - err = MP4NoErr; - } - } - } + MP4Err err; + + MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; + MP4SchemeInfoAtomPtr schi; + MP4RestrictedSchemeInfoAtomPtr rinf; + + err = MP4NoErr; + + rinf = (MP4RestrictedSchemeInfoAtomPtr)self->MP4RestrictedSchemeInfo; + if(!rinf) + { + err = MP4BadParamErr; + goto bail; + } + + schi = (MP4SchemeInfoAtomPtr)rinf->MP4SchemeInfo; + if(!schi) + { + err = MP4BadDataErr; + goto bail; + } + + err = MP4BadParamErr; + *theAtom = NULL; + + if(schi->atomList) + { + u32 count; + u32 i; + struct MP4Atom *desc; + err = MP4GetListEntryCount(schi->atomList, &count); + if(err) goto bail; + for(i = 0; i < count; i++) + { + err = MP4GetListEntry(schi->atomList, i, (char **)&desc); + if(err) goto bail; + if(desc && (desc->type == theType)) + { + *theAtom = desc; + break; + err = MP4NoErr; + } + } + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getScheme(struct MP4Atom *s, u32* sch_type, u32* sch_version, char** sch_url) +static MP4Err getScheme(struct MP4Atom *s, u32 *sch_type, u32 *sch_version, char **sch_url) { - MP4Err err; - - MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; - MP4SchemeTypeAtomPtr schm; - MP4RestrictedSchemeInfoAtomPtr rinf; - char* sch_url_copy; - - err = MP4NoErr; - - rinf = (MP4RestrictedSchemeInfoAtomPtr)self->MP4RestrictedSchemeInfo; - if (!rinf) { err = MP4BadParamErr; goto bail; } - - schm = (MP4SchemeTypeAtomPtr)rinf->MP4SchemeType; - if (!schm) { err = MP4BadDataErr; goto bail; } - - *sch_type = schm->scheme_type; - *sch_version = schm->scheme_version; - - if (sch_url) { - sch_url_copy = (char*)calloc(1, strlen(schm->scheme_url) + 1); - TESTMALLOC(sch_url_copy); - memcpy(sch_url_copy, schm->scheme_url, strlen(schm->scheme_url) + 1); - *sch_url = sch_url_copy; - } + MP4Err err; + + MP4RestrictedVideoSampleEntryAtomPtr self = (MP4RestrictedVideoSampleEntryAtomPtr)s; + MP4SchemeTypeAtomPtr schm; + MP4RestrictedSchemeInfoAtomPtr rinf; + char *sch_url_copy; + + err = MP4NoErr; + + rinf = (MP4RestrictedSchemeInfoAtomPtr)self->MP4RestrictedSchemeInfo; + if(!rinf) + { + err = MP4BadParamErr; + goto bail; + } + + schm = (MP4SchemeTypeAtomPtr)rinf->MP4SchemeType; + if(!schm) + { + err = MP4BadDataErr; + goto bail; + } + + *sch_type = schm->scheme_type; + *sch_version = schm->scheme_version; + + if(sch_url) + { + sch_url_copy = (char *)calloc(1, strlen(schm->scheme_url) + 1); + TESTMALLOC(sch_url_copy); + memcpy(sch_url_copy, schm->scheme_url, strlen(schm->scheme_url) + 1); + *sch_url = sch_url_copy; + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - - MP4Err MP4CreateRestrictedVideoSampleEntryAtom(MP4RestrictedVideoSampleEntryAtomPtr *outAtom) { - MP4Err err; - MP4RestrictedVideoSampleEntryAtomPtr self; - - self = (MP4RestrictedVideoSampleEntryAtomPtr)calloc(1, sizeof(MP4RestrictedVideoSampleEntryAtom)); - TESTMALLOC(self); - - err = MP4CreateBaseAtom((MP4AtomPtr)self); - if (err) goto bail; - - self->untransform = untransform; - self->addSchemeInfoAtom = addSchemeInfoAtom; - self->getSchemeInfoAtom = getSchemeInfoAtom; - self->getScheme = getScheme; - self->transform = transform; - self->addAtom = addAtom; - - err = MP4MakeLinkedList(&self->ExtensionAtomList); if (err) goto bail; - - self->type = MP4RestrictedVideoSampleEntryAtomType; - self->name = "Restricted Video Sample Entry"; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->restriction_type = MP4RestrictedVideoSampleEntryAtomType; - - self->width = 0x140; - self->height = 0xf0; - self->reserved4 = 0x00480000; - self->reserved5 = 0x00480000; - self->reserved7 = 1; - self->reserved8 = 0x18; - self->reserved9 = -1; - - *outAtom = self; + MP4Err err; + MP4RestrictedVideoSampleEntryAtomPtr self; + + self = (MP4RestrictedVideoSampleEntryAtomPtr)calloc(1, sizeof(MP4RestrictedVideoSampleEntryAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + + self->untransform = untransform; + self->addSchemeInfoAtom = addSchemeInfoAtom; + self->getSchemeInfoAtom = getSchemeInfoAtom; + self->getScheme = getScheme; + self->transform = transform; + self->addAtom = addAtom; + + err = MP4MakeLinkedList(&self->ExtensionAtomList); + if(err) goto bail; + + self->type = MP4RestrictedVideoSampleEntryAtomType; + self->name = "Restricted Video Sample Entry"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->restriction_type = MP4RestrictedVideoSampleEntryAtomType; + + self->width = 0x140; + self->height = 0xf0; + self->reserved4 = 0x00480000; + self->reserved5 = 0x00480000; + self->reserved7 = 1; + self->reserved8 = 0x18; + self->reserved9 = -1; + + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SLConfigDescriptor.c b/IsoLib/libisomediafile/src/SLConfigDescriptor.c index e13075a..cf9aa5d 100644 --- a/IsoLib/libisomediafile/src/SLConfigDescriptor.c +++ b/IsoLib/libisomediafile/src/SLConfigDescriptor.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,323 +15,324 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: SLConfigDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SLConfigDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" #include -static MP4Err calculateSize( struct MP4DescriptorRecord* s ) +static MP4Err calculateSize(struct MP4DescriptorRecord *s) { - MP4Err err; - MP4SLConfigDescriptorPtr self = (MP4SLConfigDescriptorPtr) s; - err = MP4NoErr; - if ( s == 0 ) - BAILWITHERROR( MP4BadParamErr ); - self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ - self->size += 1; /* predefined */ - if ( self->predefined == 0 ) - { - self->size += 15; - } - if ( self->durationFlag ) - self->size += 8; - if ( self->useTimestampsFlag == 0 ) - { - u32 tslen = self->timestampLength * 2; - u32 tsbytes = tslen / 8; - if ( tslen & 0x7F ) - tsbytes += 1; - self->size += tsbytes; - } + MP4Err err; + MP4SLConfigDescriptorPtr self = (MP4SLConfigDescriptorPtr)s; + err = MP4NoErr; + if(s == 0) BAILWITHERROR(MP4BadParamErr); + self->size = DESCRIPTOR_TAG_LEN_SIZE; /* tag + length word */ + self->size += 1; /* predefined */ + if(self->predefined == 0) + { + self->size += 15; + } + if(self->durationFlag) self->size += 8; + if(self->useTimestampsFlag == 0) + { + u32 tslen = self->timestampLength * 2; + u32 tsbytes = tslen / 8; + if(tslen & 0x7F) tsbytes += 1; + self->size += tsbytes; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -#define MAKEFLAG( member, bit ) \ - if ( self->member ) \ - flags |= (1 << (bit)) +#define MAKEFLAG(member, bit) \ + if(self->member) flags |= (1 << (bit)) -static MP4Err serialize( struct MP4DescriptorRecord* s, char* buffer ) +static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) { - u32 flags; - MP4Err err; - - MP4SLConfigDescriptorPtr self = (MP4SLConfigDescriptorPtr) s; - err = MP4NoErr; - err = MP4EncodeBaseDescriptor( s, buffer ); if (err) goto bail; - buffer += DESCRIPTOR_TAG_LEN_SIZE; - - PUT8( predefined ); - if ( self->predefined == 0 ) - { - u32 lengths; - flags = 0; - MAKEFLAG( useAccessUnitStartFlag, 7 ); - MAKEFLAG( useAccessUnitEndFlag, 6 ); - MAKEFLAG( useRandomAccessPointFlag, 5 ); - MAKEFLAG( useRandomAccessUnitsOnlyFlag, 4 ); - MAKEFLAG( usePaddingFlag, 3 ); - MAKEFLAG( useTimestampsFlag, 2 ); - MAKEFLAG( useIdleFlag, 1 ); - MAKEFLAG( durationFlag, 0 ); - PUT8_V( flags ); - PUT32( timestampResolution ); - PUT32( OCRResolution ); - PUT8( timestampLength ); - PUT8( OCRLength ); - PUT8( AULength ); - PUT8( instantBitrateLength ); - lengths = self->degradationPriorityLength << 12; - lengths |= self->AUSeqNumLength << 7; - lengths |= self->packetSeqNumLength << 2; - lengths |= 3; - PUT16_V( lengths ); - } - if ( self->durationFlag ) - { - PUT32( timeScale ); - PUT16( AUDuration ); - PUT16( CUDuration ); - } - if ( self->useTimestampsFlag == 0 ) - { - BAILWITHERROR( MP4NotImplementedErr ); - } + u32 flags; + MP4Err err; + + MP4SLConfigDescriptorPtr self = (MP4SLConfigDescriptorPtr)s; + err = MP4NoErr; + err = MP4EncodeBaseDescriptor(s, buffer); + if(err) goto bail; + buffer += DESCRIPTOR_TAG_LEN_SIZE; + + PUT8(predefined); + if(self->predefined == 0) + { + u32 lengths; + flags = 0; + MAKEFLAG(useAccessUnitStartFlag, 7); + MAKEFLAG(useAccessUnitEndFlag, 6); + MAKEFLAG(useRandomAccessPointFlag, 5); + MAKEFLAG(useRandomAccessUnitsOnlyFlag, 4); + MAKEFLAG(usePaddingFlag, 3); + MAKEFLAG(useTimestampsFlag, 2); + MAKEFLAG(useIdleFlag, 1); + MAKEFLAG(durationFlag, 0); + PUT8_V(flags); + PUT32(timestampResolution); + PUT32(OCRResolution); + PUT8(timestampLength); + PUT8(OCRLength); + PUT8(AULength); + PUT8(instantBitrateLength); + lengths = self->degradationPriorityLength << 12; + lengths |= self->AUSeqNumLength << 7; + lengths |= self->packetSeqNumLength << 2; + lengths |= 3; + PUT16_V(lengths); + } + if(self->durationFlag) + { + PUT32(timeScale); + PUT16(AUDuration); + PUT16(CUDuration); + } + if(self->useTimestampsFlag == 0) + { + BAILWITHERROR(MP4NotImplementedErr); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err handlePredefined( MP4SLConfigDescriptorPtr self ) +static MP4Err handlePredefined(MP4SLConfigDescriptorPtr self) { - MP4Err err; - - err = MP4NoErr; - - switch ( self->predefined ) - { - case SLConfigPredefinedMP4: - self->useTimestampsFlag = 1; - break; - - default: - BAILWITHERROR( MP4InvalidMediaErr ) - } + MP4Err err; + + err = MP4NoErr; + + switch(self->predefined) + { + case SLConfigPredefinedMP4: + self->useTimestampsFlag = 1; + break; + + default: + BAILWITHERROR(MP4InvalidMediaErr) + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -#define SETFLAG( member, bit ) \ - self->member = flags & (1 << (bit)) ? 1 : 0 +#define SETFLAG(member, bit) self->member = flags & (1 << (bit)) ? 1 : 0 -static MP4Err createFromInputStream( struct MP4DescriptorRecord* s, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 flags; - MP4SLConfigDescriptorPtr self = (MP4SLConfigDescriptorPtr) s; - err = MP4NoErr; - - GET8( predefined ); - if ( self->predefined ) - { - err = handlePredefined( self ); if (err) goto bail; - } - else - { - - u32 lengths; - - GET8_V_MSG( flags, NULL ); - SETFLAG( useAccessUnitStartFlag, 7 ); - SETFLAG( useAccessUnitEndFlag, 6 ); - SETFLAG( useRandomAccessPointFlag, 5 ); - SETFLAG( useRandomAccessUnitsOnlyFlag, 4 ); - SETFLAG( usePaddingFlag, 3 ); - SETFLAG( useTimestampsFlag, 2 ); - SETFLAG( useIdleFlag, 1 ); - SETFLAG( durationFlag, 0 ); - - DEBUG_SPRINTF( "useAccessUnitStartFlag = %d", self->useAccessUnitStartFlag ); - DEBUG_SPRINTF( "useAccessUnitEndFlag = %d", self->useAccessUnitEndFlag ); - DEBUG_SPRINTF( "useRandomAccessPointFlag = %d", self->useRandomAccessPointFlag ); - DEBUG_SPRINTF( "useRandomAccessUnitsOnlyFlag = %d", self->useRandomAccessUnitsOnlyFlag ); - DEBUG_SPRINTF( "usePaddingFlag = %d", self->usePaddingFlag ); - DEBUG_SPRINTF( "useTimestampsFlag = %d", self->useTimestampsFlag ); - DEBUG_SPRINTF( "useIdleFlag = %d", self->useIdleFlag ); - DEBUG_SPRINTF( "durationFlag = %d", self->durationFlag ); - - GET32( timestampResolution ); - GET32( OCRResolution ); - GET8( timestampLength ); - GET8( OCRLength ); - GET8( AULength ); - GET8( instantBitrateLength ); - GET16_V_MSG( lengths, NULL ); - self->degradationPriorityLength = lengths >> 12; - self->AUSeqNumLength = (lengths >> 7) & 0x1F; - self->packetSeqNumLength = (lengths >> 2) & 0x1F; - - DEBUG_SPRINTF( "degradationPriorityLength = %d", self->degradationPriorityLength ); - DEBUG_SPRINTF( "AUSeqNumLength = %d", self->AUSeqNumLength ); - DEBUG_SPRINTF( "packetSeqNumLength = %d", self->packetSeqNumLength ); - } - - if ( self->durationFlag ) - { - GET32( timeScale ); - GET16( AUDuration ); - GET16( CUDuration ); - } - if ( self->useTimestampsFlag == 0 ) - { - u32 timestampLength; - char timestamps[ 1024 ]; - timestampLength = 2 * self->timestampLength; - if ( timestampLength & 0x7 ) - timestampLength = 1 + timestampLength / 8; - else - timestampLength /= 8; - if ( timestampLength > 1024 ) - { - BAILWITHERROR( MP4NotImplementedErr ); - } - else - { - GETBYTES_V_MSG( timestampLength, timestamps, "timestamps+pad" ); - } - } - /* for compatibility with systems V1, where there is an extra 0x7F */ - if (self->bytesRead==(self->size - 1)) { u32 junk; GET8_V_MSG( junk, NULL ); } + MP4Err err; + u32 flags; + MP4SLConfigDescriptorPtr self = (MP4SLConfigDescriptorPtr)s; + err = MP4NoErr; + + GET8(predefined); + if(self->predefined) + { + err = handlePredefined(self); + if(err) goto bail; + } + else + { + + u32 lengths; + + GET8_V_MSG(flags, NULL); + SETFLAG(useAccessUnitStartFlag, 7); + SETFLAG(useAccessUnitEndFlag, 6); + SETFLAG(useRandomAccessPointFlag, 5); + SETFLAG(useRandomAccessUnitsOnlyFlag, 4); + SETFLAG(usePaddingFlag, 3); + SETFLAG(useTimestampsFlag, 2); + SETFLAG(useIdleFlag, 1); + SETFLAG(durationFlag, 0); + + DEBUG_SPRINTF("useAccessUnitStartFlag = %d", self->useAccessUnitStartFlag); + DEBUG_SPRINTF("useAccessUnitEndFlag = %d", self->useAccessUnitEndFlag); + DEBUG_SPRINTF("useRandomAccessPointFlag = %d", self->useRandomAccessPointFlag); + DEBUG_SPRINTF("useRandomAccessUnitsOnlyFlag = %d", self->useRandomAccessUnitsOnlyFlag); + DEBUG_SPRINTF("usePaddingFlag = %d", self->usePaddingFlag); + DEBUG_SPRINTF("useTimestampsFlag = %d", self->useTimestampsFlag); + DEBUG_SPRINTF("useIdleFlag = %d", self->useIdleFlag); + DEBUG_SPRINTF("durationFlag = %d", self->durationFlag); + + GET32(timestampResolution); + GET32(OCRResolution); + GET8(timestampLength); + GET8(OCRLength); + GET8(AULength); + GET8(instantBitrateLength); + GET16_V_MSG(lengths, NULL); + self->degradationPriorityLength = lengths >> 12; + self->AUSeqNumLength = (lengths >> 7) & 0x1F; + self->packetSeqNumLength = (lengths >> 2) & 0x1F; + + DEBUG_SPRINTF("degradationPriorityLength = %d", self->degradationPriorityLength); + DEBUG_SPRINTF("AUSeqNumLength = %d", self->AUSeqNumLength); + DEBUG_SPRINTF("packetSeqNumLength = %d", self->packetSeqNumLength); + } + + if(self->durationFlag) + { + GET32(timeScale); + GET16(AUDuration); + GET16(CUDuration); + } + if(self->useTimestampsFlag == 0) + { + u32 timestampLength; + char timestamps[1024]; + timestampLength = 2 * self->timestampLength; + if(timestampLength & 0x7) timestampLength = 1 + timestampLength / 8; + else + timestampLength /= 8; + if(timestampLength > 1024) + { + BAILWITHERROR(MP4NotImplementedErr); + } + else + { + GETBYTES_V_MSG(timestampLength, timestamps, "timestamps+pad"); + } + } + /* for compatibility with systems V1, where there is an extra 0x7F */ + if(self->bytesRead == (self->size - 1)) + { + u32 junk; + GET8_V_MSG(junk, NULL); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static void destroy( struct MP4DescriptorRecord* s ) + +static void destroy(struct MP4DescriptorRecord *s) { - MP4SLConfigDescriptorPtr self = (MP4SLConfigDescriptorPtr) s; - DESTROY_DESCRIPTOR_LIST( extensionDescriptors ) + MP4SLConfigDescriptorPtr self = (MP4SLConfigDescriptorPtr)s; + DESTROY_DESCRIPTOR_LIST(extensionDescriptors) - free( s ); + free(s); bail: - return; + return; } -MP4Err MP4CreateSLConfigDescriptor( u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc ) +MP4Err MP4CreateSLConfigDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) { - SETUP_BASE_DESCRIPTOR( MP4SLConfigDescriptor ) - *outDesc = (MP4DescriptorPtr) self; + SETUP_BASE_DESCRIPTOR(MP4SLConfigDescriptor) + *outDesc = (MP4DescriptorPtr)self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4_EXTERN ( MP4Err ) -MP4NewSLConfig( MP4SLConfigSettingsPtr settings, MP4SLConfig *outSLConfig ) +MP4_EXTERN(MP4Err) +MP4NewSLConfig(MP4SLConfigSettingsPtr settings, MP4SLConfig *outSLConfig) { - MP4Err err; - MP4DescriptorPtr desc; - if ( (settings == 0) || (outSLConfig == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = MP4CreateSLConfigDescriptor( MP4SLConfigDescriptorTag, 0, 0, &desc ); if (err) goto bail; - err = MP4SetSLConfigSettings( (MP4SLConfig) desc, settings ); if (err) goto bail; - *outSLConfig = (MP4SLConfig) desc; + MP4Err err; + MP4DescriptorPtr desc; + if((settings == 0) || (outSLConfig == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + err = MP4CreateSLConfigDescriptor(MP4SLConfigDescriptorTag, 0, 0, &desc); + if(err) goto bail; + err = MP4SetSLConfigSettings((MP4SLConfig)desc, settings); + if(err) goto bail; + *outSLConfig = (MP4SLConfig)desc; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) -MP4GetSLConfigSettings( MP4SLConfig config, MP4SLConfigSettingsPtr outSettings ) +MP4_EXTERN(MP4Err) +MP4GetSLConfigSettings(MP4SLConfig config, MP4SLConfigSettingsPtr outSettings) { - MP4Err err = MP4NoErr; - MP4SLConfigDescriptorPtr slconfig = (MP4SLConfigDescriptorPtr) config; - if ( (outSettings == 0) || (config == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - outSettings->predefined = slconfig->predefined; - outSettings->useAccessUnitStartFlag = slconfig->useAccessUnitStartFlag; - outSettings->useAccessUnitEndFlag = slconfig->useAccessUnitEndFlag; - outSettings->useRandomAccessPointFlag = slconfig->useRandomAccessPointFlag; - outSettings->useRandomAccessUnitsOnlyFlag = slconfig->useRandomAccessUnitsOnlyFlag; - outSettings->usePaddingFlag = slconfig->usePaddingFlag; - outSettings->useTimestampsFlag = slconfig->useTimestampsFlag; - outSettings->useIdleFlag = slconfig->useIdleFlag; - outSettings->durationFlag = slconfig->durationFlag; - outSettings->timestampResolution = slconfig->timestampResolution; - outSettings->OCRResolution = slconfig->OCRResolution; - outSettings->timestampLength = slconfig->timestampLength; - outSettings->OCRLength = slconfig->OCRLength; - outSettings->AULength = slconfig->AULength; - outSettings->instantBitrateLength = slconfig->instantBitrateLength; - outSettings->degradationPriorityLength = slconfig->degradationPriorityLength; - outSettings->AUSeqNumLength = slconfig->AUSeqNumLength; - outSettings->packetSeqNumLength = slconfig->packetSeqNumLength; - outSettings->timeScale = slconfig->timeScale; - outSettings->AUDuration = slconfig->AUDuration; - outSettings->CUDuration = slconfig->CUDuration; - outSettings->startDTS = slconfig->startDTS; - outSettings->startCTS = slconfig->startCTS; + MP4Err err = MP4NoErr; + MP4SLConfigDescriptorPtr slconfig = (MP4SLConfigDescriptorPtr)config; + if((outSettings == 0) || (config == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + outSettings->predefined = slconfig->predefined; + outSettings->useAccessUnitStartFlag = slconfig->useAccessUnitStartFlag; + outSettings->useAccessUnitEndFlag = slconfig->useAccessUnitEndFlag; + outSettings->useRandomAccessPointFlag = slconfig->useRandomAccessPointFlag; + outSettings->useRandomAccessUnitsOnlyFlag = slconfig->useRandomAccessUnitsOnlyFlag; + outSettings->usePaddingFlag = slconfig->usePaddingFlag; + outSettings->useTimestampsFlag = slconfig->useTimestampsFlag; + outSettings->useIdleFlag = slconfig->useIdleFlag; + outSettings->durationFlag = slconfig->durationFlag; + outSettings->timestampResolution = slconfig->timestampResolution; + outSettings->OCRResolution = slconfig->OCRResolution; + outSettings->timestampLength = slconfig->timestampLength; + outSettings->OCRLength = slconfig->OCRLength; + outSettings->AULength = slconfig->AULength; + outSettings->instantBitrateLength = slconfig->instantBitrateLength; + outSettings->degradationPriorityLength = slconfig->degradationPriorityLength; + outSettings->AUSeqNumLength = slconfig->AUSeqNumLength; + outSettings->packetSeqNumLength = slconfig->packetSeqNumLength; + outSettings->timeScale = slconfig->timeScale; + outSettings->AUDuration = slconfig->AUDuration; + outSettings->CUDuration = slconfig->CUDuration; + outSettings->startDTS = slconfig->startDTS; + outSettings->startCTS = slconfig->startCTS; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -MP4_EXTERN ( MP4Err ) -MP4SetSLConfigSettings( MP4SLConfig config, MP4SLConfigSettingsPtr settings ) +MP4_EXTERN(MP4Err) +MP4SetSLConfigSettings(MP4SLConfig config, MP4SLConfigSettingsPtr settings) { - MP4Err err = MP4NoErr; - MP4SLConfigDescriptorPtr slconfig = (MP4SLConfigDescriptorPtr) config; - if ( (settings == 0) || (config == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - slconfig->predefined = settings->predefined; - slconfig->useAccessUnitStartFlag = settings->useAccessUnitStartFlag; - slconfig->useAccessUnitEndFlag = settings->useAccessUnitEndFlag; - slconfig->useRandomAccessPointFlag = settings->useRandomAccessPointFlag; - slconfig->useRandomAccessUnitsOnlyFlag = settings->useRandomAccessUnitsOnlyFlag; - slconfig->usePaddingFlag = settings->usePaddingFlag; - slconfig->useTimestampsFlag = settings->useTimestampsFlag; - slconfig->useIdleFlag = settings->useIdleFlag; - slconfig->durationFlag = settings->durationFlag; - slconfig->timestampResolution = settings->timestampResolution; - slconfig->OCRResolution = settings->OCRResolution; - slconfig->timestampLength = settings->timestampLength; - slconfig->OCRLength = settings->OCRLength; - slconfig->AULength = settings->AULength; - slconfig->instantBitrateLength = settings->instantBitrateLength; - slconfig->degradationPriorityLength = settings->degradationPriorityLength; - slconfig->AUSeqNumLength = settings->AUSeqNumLength; - slconfig->packetSeqNumLength = settings->packetSeqNumLength; - slconfig->timeScale = settings->timeScale; - slconfig->AUDuration = settings->AUDuration; - slconfig->CUDuration = settings->CUDuration; - slconfig->startDTS = settings->startDTS; - slconfig->startCTS = settings->startCTS; + MP4Err err = MP4NoErr; + MP4SLConfigDescriptorPtr slconfig = (MP4SLConfigDescriptorPtr)config; + if((settings == 0) || (config == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + slconfig->predefined = settings->predefined; + slconfig->useAccessUnitStartFlag = settings->useAccessUnitStartFlag; + slconfig->useAccessUnitEndFlag = settings->useAccessUnitEndFlag; + slconfig->useRandomAccessPointFlag = settings->useRandomAccessPointFlag; + slconfig->useRandomAccessUnitsOnlyFlag = settings->useRandomAccessUnitsOnlyFlag; + slconfig->usePaddingFlag = settings->usePaddingFlag; + slconfig->useTimestampsFlag = settings->useTimestampsFlag; + slconfig->useIdleFlag = settings->useIdleFlag; + slconfig->durationFlag = settings->durationFlag; + slconfig->timestampResolution = settings->timestampResolution; + slconfig->OCRResolution = settings->OCRResolution; + slconfig->timestampLength = settings->timestampLength; + slconfig->OCRLength = settings->OCRLength; + slconfig->AULength = settings->AULength; + slconfig->instantBitrateLength = settings->instantBitrateLength; + slconfig->degradationPriorityLength = settings->degradationPriorityLength; + slconfig->AUSeqNumLength = settings->AUSeqNumLength; + slconfig->packetSeqNumLength = settings->packetSeqNumLength; + slconfig->timeScale = settings->timeScale; + slconfig->AUDuration = settings->AUDuration; + slconfig->CUDuration = settings->CUDuration; + slconfig->startDTS = settings->startDTS; + slconfig->startCTS = settings->startCTS; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } - diff --git a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c index 4d21b9a..f5fdeed 100644 --- a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c +++ b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c @@ -28,248 +28,248 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - u32 i; - MP4Err err; - MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - if (self->flags & 1) + u32 i; + MP4Err err; + MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + if(self->flags & 1) + { + PUT32(aux_info_type); + PUT32(aux_info_type_parameter); + } + + PUT32(entry_count); + + for(i = 0; i < self->entry_count; i++) + { + if(self->version == 0) { - PUT32(aux_info_type); - PUT32(aux_info_type_parameter); + u32 temp; + temp = self->offsets[i] + self->additionalOffset; + PUT32_V(temp); } - - PUT32(entry_count); - - for (i = 0; i < self->entry_count; i++) + else { - if (self->version == 0) - { - u32 temp; - temp = self->offsets[i] + self->additionalOffset; - PUT32_V(temp); - } - else - { - PUT64(offsets[i]); - } + PUT64(offsets[i]); } - - assert( self->bytesWritten == self->size ); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 0; - - if (self->flags & 1) - { - self->size += 8; - } - - self->size += 4; - - if (self->version == 0) - { - self->size += self->entry_count * 4; - } - else - { - self->size += self->entry_count * 8; - } + MP4Err err; + MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 0; + + if(self->flags & 1) + { + self->size += 8; + } + + self->size += 4; + + if(self->version == 0) + { + self->size += self->entry_count * 4; + } + else + { + self->size += self->entry_count * 8; + } bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - u32 i; - MP4Err err; - MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - if (self->flags & 1) + u32 i; + MP4Err err; + MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + if(self->flags & 1) + { + GET32(aux_info_type); + GET32(aux_info_type_parameter); + } + + GET32(entry_count); + + self->offsets = calloc(self->entry_count, sizeof(u64)); + for(i = 0; i < self->entry_count; i++) + { + if(self->version == 0) { - GET32(aux_info_type); - GET32(aux_info_type_parameter); + u32 temp; + GET32_V(temp); + self->offsets[i] = temp; } - - GET32(entry_count); - - self->offsets = calloc(self->entry_count, sizeof(u64)); - for (i = 0; i < self->entry_count; i++) + else { - if (self->version == 0) - { - u32 temp; - GET32_V(temp); - self->offsets[i] = temp; - } - else - { - GET64(offsets[i]); - } + GET64(offsets[i]); } - assert( self->bytesRead == self->size ); + } + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err addOffsets( MP4AtomPtr s, u32 entryCount, MP4Handle sizesH ) +static MP4Err addOffsets(MP4AtomPtr s, u32 entryCount, MP4Handle sizesH) { - u32 i; - u32 *sizes; - u32 sizeCount; - u32 onlySize; - MP4Err err; - MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr) s; - - err = MP4NoErr; - - - sizes = (u32*) *sizesH; - - err = MP4GetHandleSize( sizesH, &sizeCount ); if (err) goto bail; - sizeCount /= sizeof(u32); - if ( sizeCount == 1 ) - onlySize = *(u32*) *sizesH; - else if ( sizeCount != entryCount ) - BAILWITHERROR( MP4BadParamErr ); - - self->offsets = realloc(self->offsets, (self->entry_count + entryCount) * 8); - - for (i = 0; i < entryCount; i++) - { - self->offsets[self->entry_count + i] = self->totalOffset; - if ( sizeCount == 1 ) - self->totalOffset += onlySize; - else - self->totalOffset += sizes[i]; - } - - self->entry_count += entryCount; + u32 i; + u32 *sizes; + u32 sizeCount; + u32 onlySize; + MP4Err err; + MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)s; + + err = MP4NoErr; + + sizes = (u32 *)*sizesH; + + err = MP4GetHandleSize(sizesH, &sizeCount); + if(err) goto bail; + sizeCount /= sizeof(u32); + if(sizeCount == 1) onlySize = *(u32 *)*sizesH; + else if(sizeCount != entryCount) + BAILWITHERROR(MP4BadParamErr); + + self->offsets = realloc(self->offsets, (self->entry_count + entryCount) * 8); + + for(i = 0; i < entryCount; i++) + { + self->offsets[self->entry_count + i] = self->totalOffset; + if(sizeCount == 1) self->totalOffset += onlySize; + else + self->totalOffset += sizes[i]; + } + + self->entry_count += entryCount; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err mdatMoved (MP4AtomPtr s, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) +static MP4Err mdatMoved(MP4AtomPtr s, u64 mdatBase, u64 mdatEnd, s32 mdatOffset) { - MP4Err err; - u32 j; - MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr) s; - - err = MP4NoErr; + MP4Err err; + u32 j; + MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)s; - for (j = 0; j<= self->entry_count; j++) - { - if ((self->offsets[j] >= mdatBase) && (self->offsets[j] < mdatEnd)) - self->offsets[j] += mdatOffset; - } + err = MP4NoErr; + + for(j = 0; j <= self->entry_count; j++) + { + if((self->offsets[j] >= mdatBase) && (self->offsets[j] < mdatEnd)) + self->offsets[j] += mdatOffset; + } - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err mergeOffsets ( MP4AtomPtr s, MP4AtomPtr otherSaio, u64 baseOffset ) +MP4Err mergeOffsets(MP4AtomPtr s, MP4AtomPtr otherSaio, u64 baseOffset) { - u32 i; - MP4Err err; - MP4SampleAuxiliaryInformationOffsetsAtomPtr self; - MP4SampleAuxiliaryInformationOffsetsAtomPtr other; - - err = MP4NoErr; - - self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr) s; - other = (MP4SampleAuxiliaryInformationOffsetsAtomPtr) otherSaio; - - err = MP4NoErr; - - - self->offsets = (u64*)realloc(self->offsets, (self->entry_count + other->entry_count) * 8); - - for (i = 0; i < other->entry_count; i++) - { - self->offsets[self->entry_count + i] = baseOffset + other->offsets[i]; - } - - self->totalOffset = other->totalOffset; - self->entry_count += other->entry_count; + u32 i; + MP4Err err; + MP4SampleAuxiliaryInformationOffsetsAtomPtr self; + MP4SampleAuxiliaryInformationOffsetsAtomPtr other; + + err = MP4NoErr; + + self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)s; + other = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)otherSaio; + + err = MP4NoErr; + + self->offsets = (u64 *)realloc(self->offsets, (self->entry_count + other->entry_count) * 8); + + for(i = 0; i < other->entry_count; i++) + { + self->offsets[self->entry_count + i] = baseOffset + other->offsets[i]; + } + + self->totalOffset = other->totalOffset; + self->entry_count += other->entry_count; - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err MP4CreateSampleAuxiliaryInformationOffsetsAtom( MP4SampleAuxiliaryInformationOffsetsAtomPtr *outAtom ) +MP4Err +MP4CreateSampleAuxiliaryInformationOffsetsAtom(MP4SampleAuxiliaryInformationOffsetsAtomPtr *outAtom) { - MP4Err err; - MP4SampleAuxiliaryInformationOffsetsAtomPtr self; - - self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr) calloc( 1, sizeof(MP4SampleAuxiliaryInformationOffsetsAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4SampleAuxiliaryInformationOffsetsAtomType; - self->name = "sample auxiliary information offsets"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->mergeOffsets = mergeOffsets; - - self->flags = 0; - self->entry_count = 0; - self->additionalOffset = 0; - self->totalOffset = 0; - self->addOffsets = addOffsets; - self->offsets = NULL; - self->mdatMoved = mdatMoved; - - *outAtom = self; + MP4Err err; + MP4SampleAuxiliaryInformationOffsetsAtomPtr self; + + self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)calloc( + 1, sizeof(MP4SampleAuxiliaryInformationOffsetsAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SampleAuxiliaryInformationOffsetsAtomType; + self->name = "sample auxiliary information offsets"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->mergeOffsets = mergeOffsets; + + self->flags = 0; + self->entry_count = 0; + self->additionalOffset = 0; + self->totalOffset = 0; + self->addOffsets = addOffsets; + self->offsets = NULL; + self->mdatMoved = mdatMoved; + + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationSizesAtom.c b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationSizesAtom.c index 4250e09..ba5c50e 100644 --- a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationSizesAtom.c +++ b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationSizesAtom.c @@ -28,232 +28,234 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - u32 i; - MP4Err err; - MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - if (self->flags & 1) - { - PUT32(aux_info_type); - PUT32(aux_info_type_parameter); - } - - PUT8(default_sample_info_size); - PUT32(sample_count); - - if (self->default_sample_info_size == 0) + u32 i; + MP4Err err; + MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + if(self->flags & 1) + { + PUT32(aux_info_type); + PUT32(aux_info_type_parameter); + } + + PUT8(default_sample_info_size); + PUT32(sample_count); + + if(self->default_sample_info_size == 0) + { + for(i = 0; i < self->sample_count; i++) { - for (i = 0; i < self->sample_count; i++) - { - PUT8(sample_info_sizes[i]); - } + PUT8(sample_info_sizes[i]); } - - assert( self->bytesWritten == self->size ); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - - if (self->flags & 1) - { - self->size += 8; - } - - self->size += 5; - - if (self->default_sample_info_size == 0) - { - self->size += self->sample_count; - } + MP4Err err; + MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + if(self->flags & 1) + { + self->size += 8; + } + + self->size += 5; + + if(self->default_sample_info_size == 0) + { + self->size += self->sample_count; + } bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - u32 i; - MP4Err err; - MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - if (self->flags & 1) - { - GET32(aux_info_type); - GET32(aux_info_type_parameter); - } - - GET8(default_sample_info_size); - GET32(sample_count); - - if (self->default_sample_info_size == 0) + u32 i; + MP4Err err; + MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + if(self->flags & 1) + { + GET32(aux_info_type); + GET32(aux_info_type_parameter); + } + + GET8(default_sample_info_size); + GET32(sample_count); + + if(self->default_sample_info_size == 0) + { + self->sample_info_sizes = calloc(self->sample_count, sizeof(u8)); + for(i = 0; i < self->sample_count; i++) { - self->sample_info_sizes = calloc(self->sample_count, sizeof(u8)); - for (i = 0; i < self->sample_count; i++) - { - GET8(sample_info_sizes[i]); - } + GET8(sample_info_sizes[i]); } - - assert( self->bytesRead == self->size ); + } + + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err addSizes( MP4AtomPtr s, u32 sampleCount, MP4Handle sizesH ) +static MP4Err addSizes(MP4AtomPtr s, u32 sampleCount, MP4Handle sizesH) { - u32 i; - u32 *sizes; - u32 sizeCount; - u32 onlySize; - MP4Err err; - MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr) s; - - err = MP4NoErr; - - if (self->default_sample_info_size == 0) + u32 i; + u32 *sizes; + u32 sizeCount; + u32 onlySize; + MP4Err err; + MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr)s; + + err = MP4NoErr; + + if(self->default_sample_info_size == 0) + { + sizes = (u32 *)*sizesH; + + err = MP4GetHandleSize(sizesH, &sizeCount); + if(err) goto bail; + sizeCount /= sizeof(u32); + if(sizeCount == 1) onlySize = *(u32 *)*sizesH; + else if(sizeCount != sampleCount) + BAILWITHERROR(MP4BadParamErr); + + self->sample_info_sizes = realloc(self->sample_info_sizes, self->sample_count + sampleCount); + + for(i = 0; i < sampleCount; i++) { - sizes = (u32*) *sizesH; - - err = MP4GetHandleSize( sizesH, &sizeCount ); if (err) goto bail; - sizeCount /= sizeof(u32); - if ( sizeCount == 1 ) - onlySize = *(u32*) *sizesH; - else if ( sizeCount != sampleCount ) - BAILWITHERROR( MP4BadParamErr ); - - self->sample_info_sizes = realloc(self->sample_info_sizes, self->sample_count + sampleCount); - - for (i = 0; i < sampleCount; i++) - { - if ( sizeCount == 1 ) - self->sample_info_sizes[self->sample_count + i] = (u8) onlySize; - else - self->sample_info_sizes[self->sample_count + i] = (u8) sizes[i]; - } + if(sizeCount == 1) self->sample_info_sizes[self->sample_count + i] = (u8)onlySize; + else + self->sample_info_sizes[self->sample_count + i] = (u8)sizes[i]; } - - self->sample_count += sampleCount; + } + + self->sample_count += sampleCount; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err mergeSizes ( MP4AtomPtr s, MP4AtomPtr otherSaiz ) +MP4Err mergeSizes(MP4AtomPtr s, MP4AtomPtr otherSaiz) { - u32 i; - MP4Err err; - MP4SampleAuxiliaryInformationSizesAtomPtr self; - MP4SampleAuxiliaryInformationSizesAtomPtr other; - - err = MP4NoErr; - - self = (MP4SampleAuxiliaryInformationSizesAtomPtr) s; - other = (MP4SampleAuxiliaryInformationSizesAtomPtr) otherSaiz; - - if (self->default_sample_info_size != 0) + u32 i; + MP4Err err; + MP4SampleAuxiliaryInformationSizesAtomPtr self; + MP4SampleAuxiliaryInformationSizesAtomPtr other; + + err = MP4NoErr; + + self = (MP4SampleAuxiliaryInformationSizesAtomPtr)s; + other = (MP4SampleAuxiliaryInformationSizesAtomPtr)otherSaiz; + + if(self->default_sample_info_size != 0) + { + if(other->default_sample_info_size != 0) { - if (other->default_sample_info_size != 0) - { - if (self->default_sample_info_size == other->default_sample_info_size) - { - self->sample_count += other->sample_count; - goto bail; - } - } - - self->sample_info_sizes = realloc(self->sample_info_sizes, self->sample_count); - for (i = 0; i < self->sample_count; i++) - { - self->sample_info_sizes[i] = (u8) self->default_sample_info_size; - } - self->default_sample_info_size = 0; + if(self->default_sample_info_size == other->default_sample_info_size) + { + self->sample_count += other->sample_count; + goto bail; + } } - - self->sample_info_sizes = realloc(self->sample_info_sizes, self->sample_count + other->sample_count); - for (i = 0; i < other->sample_count; i++) - { - if (other->default_sample_info_size != 0) - self->sample_info_sizes[self->sample_count + i] = (u8) other->default_sample_info_size; - else - self->sample_info_sizes[self->sample_count + i] = other->sample_info_sizes[i]; + self->sample_info_sizes = realloc(self->sample_info_sizes, self->sample_count); + for(i = 0; i < self->sample_count; i++) + { + self->sample_info_sizes[i] = (u8)self->default_sample_info_size; } - self->sample_count += other->sample_count; + self->default_sample_info_size = 0; + } + + self->sample_info_sizes = + realloc(self->sample_info_sizes, self->sample_count + other->sample_count); + for(i = 0; i < other->sample_count; i++) + { + if(other->default_sample_info_size != 0) + self->sample_info_sizes[self->sample_count + i] = (u8)other->default_sample_info_size; + else + self->sample_info_sizes[self->sample_count + i] = other->sample_info_sizes[i]; + } + self->sample_count += other->sample_count; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err MP4CreateSampleAuxiliaryInformationSizesAtom( MP4SampleAuxiliaryInformationSizesAtomPtr *outAtom ) +MP4Err +MP4CreateSampleAuxiliaryInformationSizesAtom(MP4SampleAuxiliaryInformationSizesAtomPtr *outAtom) { - MP4Err err; - MP4SampleAuxiliaryInformationSizesAtomPtr self; - - self = (MP4SampleAuxiliaryInformationSizesAtomPtr) calloc( 1, sizeof(MP4SampleAuxiliaryInformationSizesAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4SampleAuxiliaryInformationSizesAtomType; - self->name = "sample auxiliary information sizes"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->mergeSizes = mergeSizes; - - self->flags = 0; - self->sample_count = 0; - - self->addSizes = addSizes; - - self->sample_info_sizes = NULL; - - *outAtom = self; + MP4Err err; + MP4SampleAuxiliaryInformationSizesAtomPtr self; + + self = (MP4SampleAuxiliaryInformationSizesAtomPtr)calloc( + 1, sizeof(MP4SampleAuxiliaryInformationSizesAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SampleAuxiliaryInformationSizesAtomType; + self->name = "sample auxiliary information sizes"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->mergeSizes = mergeSizes; + + self->flags = 0; + self->sample_count = 0; + + self->addSizes = addSizes; + + self->sample_info_sizes = NULL; + + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/SampleDependencyAtom.c b/IsoLib/libisomediafile/src/SampleDependencyAtom.c index d9bcdf8..40ef4fb 100644 --- a/IsoLib/libisomediafile/src/SampleDependencyAtom.c +++ b/IsoLib/libisomediafile/src/SampleDependencyAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -27,196 +27,212 @@ derivative works. Copyright (c) 1999. #define allocation_size 4096 -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SampleDependencyAtomPtr self; - err = MP4NoErr; - self = (MP4SampleDependencyAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->dependency != NULL ) - { - free( self->dependency ); - self->dependency = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4SampleDependencyAtomPtr self; + err = MP4NoErr; + self = (MP4SampleDependencyAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->dependency != NULL) + { + free(self->dependency); + self->dependency = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err ensureSize( struct MP4SampleDependencyAtom *self, u32 newSize ) +static MP4Err ensureSize(struct MP4SampleDependencyAtom *self, u32 newSize) { - MP4Err err; - - err = MP4NoErr; - - if (newSize > self->allocatedSize) { - self->allocatedSize += allocation_size; - if (newSize > self->allocatedSize) self->allocatedSize = newSize; - - if (self->dependency != NULL) - self->dependency = (u8*) realloc( self->dependency, self->allocatedSize ); - else - self->dependency = (u8*) calloc( self->allocatedSize, 1 ); - - TESTMALLOC( self->dependency ); - } + MP4Err err; + + err = MP4NoErr; + + if(newSize > self->allocatedSize) + { + self->allocatedSize += allocation_size; + if(newSize > self->allocatedSize) self->allocatedSize = newSize; + + if(self->dependency != NULL) + self->dependency = (u8 *)realloc(self->dependency, self->allocatedSize); + else + self->dependency = (u8 *)calloc(self->allocatedSize, 1); + + TESTMALLOC(self->dependency); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSamples( struct MP4SampleDependencyAtom *self, u32 count ) +static MP4Err addSamples(struct MP4SampleDependencyAtom *self, u32 count) { - MP4Err err; - u8 *p; - u32 j; - - err = MP4NoErr; - err = ensureSize( self, (self->sampleCount + count)*sizeof(u8) ); if (err) goto bail; - - p = &((self->dependency)[self->sampleCount]); - for (j=0; jsampleCount += count; + MP4Err err; + u8 *p; + u32 j; + + err = MP4NoErr; + err = ensureSize(self, (self->sampleCount + count) * sizeof(u8)); + if(err) goto bail; + + p = &((self->dependency)[self->sampleCount]); + for(j = 0; j < count; j++) + *p++ = 0; + self->sampleCount += count; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err setSampleDependency( struct MP4SampleDependencyAtom *self, s32 sample_index, - MP4Handle dependencies ) +static MP4Err setSampleDependency(struct MP4SampleDependencyAtom *self, s32 sample_index, + MP4Handle dependencies) { - MP4Err err; - u32 i; - u8* p; - u8* dependency; - u32 count; - - - err = MP4GetHandleSize( dependencies, &count ); if (err) goto bail; - dependency = (u8*) *dependencies; - - if (sample_index<0) { - p = &((self->dependency)[self->sampleCount + sample_index]); - if (count > ((u32) (- sample_index))) { err = MP4BadParamErr; goto bail; } - } - else { - p = &((self->dependency)[sample_index]); - if (count+sample_index > self->sampleCount) { err = MP4BadParamErr; goto bail; } - } - for (i=0; idependency)[self->sampleCount + sample_index]); + if(count > ((u32)(-sample_index))) + { + err = MP4BadParamErr; + goto bail; + } + } + else + { + p = &((self->dependency)[sample_index]); + if(count + sample_index > self->sampleCount) + { + err = MP4BadParamErr; + goto bail; + } + } + for(i = 0; i < count; i++) + *p++ = *dependency++; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getSampleDependency( struct MP4SampleDependencyAtom *self, u32 sampleNumber, - u8* dependency ) +static MP4Err getSampleDependency(struct MP4SampleDependencyAtom *self, u32 sampleNumber, + u8 *dependency) { - MP4Err err; - - err = MP4NoErr; - - if (sampleNumber<1) BAILWITHERROR( MP4BadParamErr ); - if (sampleNumber > self->sampleCount) - *dependency = 0; - else *dependency = (self->dependency)[sampleNumber - 1]; + MP4Err err; + + err = MP4NoErr; + + if(sampleNumber < 1) BAILWITHERROR(MP4BadParamErr); + if(sampleNumber > self->sampleCount) *dependency = 0; + else + *dependency = (self->dependency)[sampleNumber - 1]; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - - MP4SampleDependencyAtomPtr self = (MP4SampleDependencyAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( self->dependency, self->sampleCount ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + + MP4SampleDependencyAtomPtr self = (MP4SampleDependencyAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(self->dependency, self->sampleCount); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SampleDependencyAtomPtr self = (MP4SampleDependencyAtomPtr) s; - - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - - self->size += self->sampleCount; + MP4Err err; + MP4SampleDependencyAtomPtr self = (MP4SampleDependencyAtomPtr)s; + + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + self->size += self->sampleCount; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4SampleDependencyAtomPtr self = (MP4SampleDependencyAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - self->sampleCount = (self->size) - (self->bytesRead); - err = ensureSize( self, self->sampleCount ); if (err) goto bail; - - GETBYTES_V_MSG( self->sampleCount, (char*) (self->dependency), "dependency" ); - + MP4Err err; + MP4SampleDependencyAtomPtr self = (MP4SampleDependencyAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + self->sampleCount = (self->size) - (self->bytesRead); + err = ensureSize(self, self->sampleCount); + if(err) goto bail; + + GETBYTES_V_MSG(self->sampleCount, (char *)(self->dependency), "dependency"); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSampleDependencyAtom( MP4SampleDependencyAtomPtr *outAtom ) +MP4Err MP4CreateSampleDependencyAtom(MP4SampleDependencyAtomPtr *outAtom) { - MP4Err err; - MP4SampleDependencyAtomPtr self; - - self = (MP4SampleDependencyAtomPtr) calloc( 1, sizeof(MP4SampleDependencyAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4SampleDependencyAtomType; - self->name = "sample dependency"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->setSampleDependency = setSampleDependency; - self->addSamples = addSamples; - self->getSampleDependency = getSampleDependency; - self->dependency = NULL; - self->sampleCount = 0; - - *outAtom = self; + MP4Err err; + MP4SampleDependencyAtomPtr self; + + self = (MP4SampleDependencyAtomPtr)calloc(1, sizeof(MP4SampleDependencyAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SampleDependencyAtomType; + self->name = "sample dependency"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->setSampleDependency = setSampleDependency; + self->addSamples = addSamples; + self->getSampleDependency = getSampleDependency; + self->dependency = NULL; + self->sampleCount = 0; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SampleDescriptionAtom.c b/IsoLib/libisomediafile/src/SampleDescriptionAtom.c index fc5379d..7e00ce8 100644 --- a/IsoLib/libisomediafile/src/SampleDescriptionAtom.c +++ b/IsoLib/libisomediafile/src/SampleDescriptionAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SampleDescriptionAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SampleDescriptionAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,151 +29,158 @@ derivative works. Copyright (c) 1999. extern u32 MP4SampleEntryProtos[]; -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SampleDescriptionAtomPtr self; - u32 i; - - err = MP4NoErr; - self = (MP4SampleDescriptionAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4SampleDescriptionAtomPtr self; + u32 i; + + err = MP4NoErr; + self = (MP4SampleDescriptionAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -IMPLEMENT_NEW_ADDATOM( MP4SampleDescriptionAtom ) +IMPLEMENT_NEW_ADDATOM(MP4SampleDescriptionAtom) -static MP4Err addEntry( struct MP4SampleDescriptionAtom *self, MP4AtomPtr entry ) +static MP4Err addEntry(struct MP4SampleDescriptionAtom *self, MP4AtomPtr entry) { - MP4Err err; - - err = addAtom( self, entry ); if (err) goto bail; + MP4Err err; + + err = addAtom(self, entry); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 entryCount; - MP4SampleDescriptionAtomPtr self = (MP4SampleDescriptionAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - err = MP4GetListEntryCount( self->atomList, &entryCount ); if (err) goto bail; - PUT32_V( entryCount ); - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 entryCount; + MP4SampleDescriptionAtomPtr self = (MP4SampleDescriptionAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + err = MP4GetListEntryCount(self->atomList, &entryCount); + if(err) goto bail; + PUT32_V(entryCount); + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SampleDescriptionAtomPtr self = (MP4SampleDescriptionAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4; - ADD_ATOM_LIST_SIZE( atomList ); + MP4Err err; + MP4SampleDescriptionAtomPtr self = (MP4SampleDescriptionAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4; + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static u32 getEntryCount( struct MP4SampleDescriptionAtom *self ) +static u32 getEntryCount(struct MP4SampleDescriptionAtom *self) { - u32 entryCount = 0; - MP4GetListEntryCount( self->atomList, &entryCount ); - return entryCount; + u32 entryCount = 0; + MP4GetListEntryCount(self->atomList, &entryCount); + return entryCount; } -static MP4Err getEntry( struct MP4SampleDescriptionAtom *self, u32 entryNumber, struct GenericSampleEntryAtom **outEntry ) +static MP4Err getEntry(struct MP4SampleDescriptionAtom *self, u32 entryNumber, + struct GenericSampleEntryAtom **outEntry) { - MP4Err err; - u32 entryCount; - - err = MP4NoErr; - entryCount = getEntryCount( self ); - if ( (entryNumber == 0) || (entryNumber > entryCount) ) - BAILWITHERROR( MP4BadParamErr ) - err = MP4GetListEntry( self->atomList, entryNumber - 1, (char**) outEntry ); if (err) goto bail; + MP4Err err; + u32 entryCount; + + err = MP4NoErr; + entryCount = getEntryCount(self); + if((entryNumber == 0) || (entryNumber > entryCount)) BAILWITHERROR(MP4BadParamErr) + err = MP4GetListEntry(self->atomList, entryNumber - 1, (char **)outEntry); + if(err) goto bail; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err MP4ParseAtomUsingProtoList( MP4InputStreamPtr inputStream, u32* protoList, u32 defaultAtom, MP4AtomPtr *outAtom ); - MP4Err err; - u32 entryCount; - u32 i; - MP4SampleDescriptionAtomPtr self = (MP4SampleDescriptionAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32_V( entryCount ); - for ( i = 0; i < entryCount; i++ ) - { - MP4AtomPtr atom; + MP4Err MP4ParseAtomUsingProtoList(MP4InputStreamPtr inputStream, u32 * protoList, u32 defaultAtom, + MP4AtomPtr * outAtom); + MP4Err err; + u32 entryCount; + u32 i; + MP4SampleDescriptionAtomPtr self = (MP4SampleDescriptionAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32_V(entryCount); + for(i = 0; i < entryCount; i++) + { + MP4AtomPtr atom; #if 0 err = MP4ParseAtom( inputStream, &atom ); if (err) goto bail; #else - err = MP4ParseAtomUsingProtoList( inputStream, - MP4SampleEntryProtos, MP4GenericSampleEntryAtomType, &atom ); if (err) goto bail; + err = MP4ParseAtomUsingProtoList(inputStream, MP4SampleEntryProtos, + MP4GenericSampleEntryAtomType, &atom); + if(err) goto bail; #endif - self->bytesRead += atom->size; - err = addAtom( self, atom ); if (err) goto bail; - } - if ( self->bytesRead != self->size ) - BAILWITHERROR( MP4BadDataErr ) + self->bytesRead += atom->size; + err = addAtom(self, atom); + if(err) goto bail; + } + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSampleDescriptionAtom( MP4SampleDescriptionAtomPtr *outAtom ) +MP4Err MP4CreateSampleDescriptionAtom(MP4SampleDescriptionAtomPtr *outAtom) { - MP4Err err; - MP4SampleDescriptionAtomPtr self; - - self = (MP4SampleDescriptionAtomPtr) calloc( 1, sizeof(MP4SampleDescriptionAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->type = MP4SampleDescriptionAtomType; - self->name = "sample description"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addEntry = addEntry; - self->getEntryCount = getEntryCount; - self->getEntry = getEntry; - *outAtom = self; + MP4Err err; + MP4SampleDescriptionAtomPtr self; + + self = (MP4SampleDescriptionAtomPtr)calloc(1, sizeof(MP4SampleDescriptionAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->type = MP4SampleDescriptionAtomType; + self->name = "sample description"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addEntry = addEntry; + self->getEntryCount = getEntryCount; + self->getEntry = getEntry; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c index d689612..791c64a 100644 --- a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c +++ b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -25,218 +25,240 @@ derivative works. Copyright (c) 1999. #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 i; - MP4SampleGroupDescriptionAtomPtr self; - err = MP4NoErr; - self = (MP4SampleGroupDescriptionAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->groups != NULL ) - { - for (i=0; igroupCount; i++) - free( (self->groups)[i].groupDescription ); - - free( self->groups ); - self->groups = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + u32 i; + MP4SampleGroupDescriptionAtomPtr self; + err = MP4NoErr; + self = (MP4SampleGroupDescriptionAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->groups != NULL) + { + for(i = 0; i < self->groupCount; i++) + free((self->groups)[i].groupDescription); + + free(self->groups); + self->groups = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err addGroupDescription( struct MP4SampleGroupDescriptionAtom *self, MP4Handle theDescription, u32* index ) +static MP4Err addGroupDescription(struct MP4SampleGroupDescriptionAtom *self, + MP4Handle theDescription, u32 *index) { - MP4Err err; - sampleGroupEntry *p; - u32 theSize; - - if (self->groups != NULL) - self->groups = calloc( 1, sizeof(sampleGroupEntry) ); - else - self->groups = realloc( self->groups, (self->groupCount + 1)*sizeof(sampleGroupEntry) ); - TESTMALLOC( self->groups ); - p = &((self->groups)[self->groupCount]); - - err = MP4GetHandleSize( theDescription, &theSize ); if (err) goto bail; - - p->groupDescription = calloc( theSize, 1 ); - TESTMALLOC( p->groupDescription ); - memcpy( p->groupDescription, *theDescription, theSize ); - p->groupSize = theSize; - - self->groupCount += 1; - *index = self->groupCount; + MP4Err err; + sampleGroupEntry *p; + u32 theSize; + + if(self->groups != NULL) self->groups = calloc(1, sizeof(sampleGroupEntry)); + else + self->groups = realloc(self->groups, (self->groupCount + 1) * sizeof(sampleGroupEntry)); + TESTMALLOC(self->groups); + p = &((self->groups)[self->groupCount]); + + err = MP4GetHandleSize(theDescription, &theSize); + if(err) goto bail; + + p->groupDescription = calloc(theSize, 1); + TESTMALLOC(p->groupDescription); + memcpy(p->groupDescription, *theDescription, theSize); + p->groupSize = theSize; + + self->groupCount += 1; + *index = self->groupCount; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getGroupDescription( struct MP4SampleGroupDescriptionAtom *self, u32 index, MP4Handle theDescription ) +static MP4Err getGroupDescription(struct MP4SampleGroupDescriptionAtom *self, u32 index, + MP4Handle theDescription) { - MP4Err err; - sampleGroupEntry *p; - - if ((index < 1) || (index > self->groupCount)) BAILWITHERROR( MP4BadParamErr ); - - p = &((self->groups)[index - 1]); - - err = MP4SetHandleSize( theDescription, p->groupSize ); if (err) goto bail; - - memcpy( *theDescription, p->groupDescription, p->groupSize ); - + MP4Err err; + sampleGroupEntry *p; + + if((index < 1) || (index > self->groupCount)) BAILWITHERROR(MP4BadParamErr); + + p = &((self->groups)[index - 1]); + + err = MP4SetHandleSize(theDescription, p->groupSize); + if(err) goto bail; + + memcpy(*theDescription, p->groupDescription, p->groupSize); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - - MP4SampleGroupDescriptionAtomPtr self = (MP4SampleGroupDescriptionAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - PUT32( grouping_type ); - PUT32( default_length ); - PUT32( groupCount ); - - for (i=0; igroupCount; i++) { - if (self->default_length == 0) { PUT32_V( (self->groups)[i].groupSize ); } - else { assert( (self->groups)[i].groupSize == self->default_length ); } - - PUTBYTES( (self->groups)[i].groupDescription, (self->groups)[i].groupSize ); - } - - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + + MP4SampleGroupDescriptionAtomPtr self = (MP4SampleGroupDescriptionAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + PUT32(grouping_type); + PUT32(default_length); + PUT32(groupCount); + + for(i = 0; i < self->groupCount; i++) + { + if(self->default_length == 0) + { + PUT32_V((self->groups)[i].groupSize); + } + else + { + assert((self->groups)[i].groupSize == self->default_length); + } + + PUTBYTES((self->groups)[i].groupDescription, (self->groups)[i].groupSize); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SampleGroupDescriptionAtomPtr self = (MP4SampleGroupDescriptionAtomPtr) s; - u32 i; - - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - - assert( self->groupCount > 0); - - self->size += 12; - - self->default_length = (self->groups[0]).groupSize; - self->size += self->default_length; - - for (i=1; i<(self->groupCount); i++) { - if ((self->groups[i]).groupSize != self->default_length) { - self->default_length = 0; - } - self->size += (self->groups[i]).groupSize; - } - - if (self->default_length == 0) { - self->size += (self->groupCount) * 4; - } - + MP4Err err; + MP4SampleGroupDescriptionAtomPtr self = (MP4SampleGroupDescriptionAtomPtr)s; + u32 i; + + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + assert(self->groupCount > 0); + + self->size += 12; + + self->default_length = (self->groups[0]).groupSize; + self->size += self->default_length; + + for(i = 1; i < (self->groupCount); i++) + { + if((self->groups[i]).groupSize != self->default_length) + { + self->default_length = 0; + } + self->size += (self->groups[i]).groupSize; + } + + if(self->default_length == 0) + { + self->size += (self->groupCount) * 4; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i; - MP4SampleGroupDescriptionAtomPtr self = (MP4SampleGroupDescriptionAtomPtr) s; - char typeString[ 8 ]; - char msgString[ 80 ]; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( grouping_type ); - MP4TypeToString( self->grouping_type, typeString ); - sprintf( msgString, " grouping type is '%s'", typeString ); - inputStream->msg( inputStream, msgString ); - - if (self->version == 1) - { GET32( default_length ); } - else { err = MP4NotImplementedErr; goto bail; } - - GET32( groupCount ); - - self->groups = calloc( self->groupCount, sizeof( sampleGroupEntry ) ); - TESTMALLOC( self->groups ); - - for (i=0; igroupCount; i++) - { - u32 count; - if (self->default_length == 0) { - GET32_V_MSG( count, NULL ); - } - else count = self->default_length; - - sprintf( msgString, " entry %d, size %d", i+1, count ); - inputStream->msg( inputStream, msgString ); - - (self->groups)[i].groupDescription = malloc( count ); - TESTMALLOC( (self->groups)[i].groupDescription ); - (self->groups)[i].groupSize = count; - - GETBYTES_V( count, (self->groups)[i].groupDescription ); - } - + MP4Err err; + u32 i; + MP4SampleGroupDescriptionAtomPtr self = (MP4SampleGroupDescriptionAtomPtr)s; + char typeString[8]; + char msgString[80]; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(grouping_type); + MP4TypeToString(self->grouping_type, typeString); + sprintf(msgString, " grouping type is '%s'", typeString); + inputStream->msg(inputStream, msgString); + + if(self->version == 1) + { + GET32(default_length); + } + else + { + err = MP4NotImplementedErr; + goto bail; + } + + GET32(groupCount); + + self->groups = calloc(self->groupCount, sizeof(sampleGroupEntry)); + TESTMALLOC(self->groups); + + for(i = 0; i < self->groupCount; i++) + { + u32 count; + if(self->default_length == 0) + { + GET32_V_MSG(count, NULL); + } + else + count = self->default_length; + + sprintf(msgString, " entry %d, size %d", i + 1, count); + inputStream->msg(inputStream, msgString); + + (self->groups)[i].groupDescription = malloc(count); + TESTMALLOC((self->groups)[i].groupDescription); + (self->groups)[i].groupSize = count; + + GETBYTES_V(count, (self->groups)[i].groupDescription); + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSampleGroupDescriptionAtom( MP4SampleGroupDescriptionAtomPtr *outAtom ) +MP4Err MP4CreateSampleGroupDescriptionAtom(MP4SampleGroupDescriptionAtomPtr *outAtom) { - MP4Err err; - MP4SampleGroupDescriptionAtomPtr self; - - self = (MP4SampleGroupDescriptionAtomPtr) calloc( 1, sizeof(MP4SampleGroupDescriptionAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4SampleGroupDescriptionAtomType; - self->name = "sample group description"; - self->version = 1; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addGroupDescription = addGroupDescription; - self->getGroupDescription = getGroupDescription; - self->default_length = 0; - self->groupCount = 0; - self->groups = NULL; - - *outAtom = self; + MP4Err err; + MP4SampleGroupDescriptionAtomPtr self; + + self = (MP4SampleGroupDescriptionAtomPtr)calloc(1, sizeof(MP4SampleGroupDescriptionAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SampleGroupDescriptionAtomType; + self->name = "sample group description"; + self->version = 1; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addGroupDescription = addGroupDescription; + self->getGroupDescription = getGroupDescription; + self->default_length = 0; + self->groupCount = 0; + self->groups = NULL; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SampleSizeAtom.c b/IsoLib/libisomediafile/src/SampleSizeAtom.c index 952b3d6..89140a2 100644 --- a/IsoLib/libisomediafile/src/SampleSizeAtom.c +++ b/IsoLib/libisomediafile/src/SampleSizeAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SampleSizeAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SampleSizeAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -30,339 +30,363 @@ derivative works. Copyright (c) 1999. #define allocation_size 8192 -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SampleSizeAtomPtr self; - err = MP4NoErr; - self = (MP4SampleSizeAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->sizes ) - { - free( self->sizes ); - self->sizes = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4SampleSizeAtomPtr self; + err = MP4NoErr; + self = (MP4SampleSizeAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->sizes) + { + free(self->sizes); + self->sizes = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err addSamples( struct MP4SampleSizeAtom *self, u32 sampleCount, MP4Handle sizesH ) +static MP4Err addSamples(struct MP4SampleSizeAtom *self, u32 sampleCount, MP4Handle sizesH) { - MP4Err err; - u32 *sampleSizes; - u32 sizesCount; - u8 varyingsizes = 0; - u32 i; - - err = MP4NoErr; - sampleSizes = (u32 *) *sizesH; - err = MP4GetHandleSize( sizesH, &sizesCount ); if (err) goto bail; - sizesCount /= sizeof(u32); - for (i=1; isampleCount > 0) && (*sampleSizes != self->sampleSize)) ) - { - u32 newsize; - - newsize = (sampleCount + self->sampleCount + 1) * sizeof(u32); - - if ( (self->sizes == NULL) && self->sampleCount ) - { - u32 i; - self->allocatedSize = newsize; - if (self->allocatedSize < allocation_size) self->allocatedSize = allocation_size; - - self->sizes = (u32 *) calloc( self->allocatedSize, 1 ); - TESTMALLOC( self->sizes ); - for ( i = 0; i < self->sampleCount; i++ ) - self->sizes[ i ] = self->sampleSize; - } - - if (self->allocatedSize < newsize) { - while (self->allocatedSize < newsize) self->allocatedSize += allocation_size; - self->sizes = realloc( self->sizes, self->allocatedSize ); - TESTMALLOC( self->sizes ); - } - - if ( sizesCount > 1 ) - memcpy( self->sizes + self->sampleCount, sampleSizes, sizesCount * sizeof(u32) ); - else - { - u32 i; - u32 *p; - p = self->sizes + self->sampleCount; - for ( i = 0; i < sampleCount; i++ ) - *p++ = *sampleSizes; - } - self->sampleSize = 0; - } - else - { - self->sampleSize = *sampleSizes; - } - self->sampleCount += sampleCount; + MP4Err err; + u32 *sampleSizes; + u32 sizesCount; + u8 varyingsizes = 0; + u32 i; + + err = MP4NoErr; + sampleSizes = (u32 *)*sizesH; + err = MP4GetHandleSize(sizesH, &sizesCount); + if(err) goto bail; + sizesCount /= sizeof(u32); + for(i = 1; i < sizesCount; i++) + { + if(sampleSizes[i] != sampleSizes[0]) + { + varyingsizes = 1; + break; + } + } + if(varyingsizes || (*sampleSizes == 0) || + ((self->sampleCount > 0) && (*sampleSizes != self->sampleSize))) + { + u32 newsize; + + newsize = (sampleCount + self->sampleCount + 1) * sizeof(u32); + + if((self->sizes == NULL) && self->sampleCount) + { + u32 i; + self->allocatedSize = newsize; + if(self->allocatedSize < allocation_size) self->allocatedSize = allocation_size; + + self->sizes = (u32 *)calloc(self->allocatedSize, 1); + TESTMALLOC(self->sizes); + for(i = 0; i < self->sampleCount; i++) + self->sizes[i] = self->sampleSize; + } + + if(self->allocatedSize < newsize) + { + while(self->allocatedSize < newsize) + self->allocatedSize += allocation_size; + self->sizes = realloc(self->sizes, self->allocatedSize); + TESTMALLOC(self->sizes); + } + + if(sizesCount > 1) + memcpy(self->sizes + self->sampleCount, sampleSizes, sizesCount * sizeof(u32)); + else + { + u32 i; + u32 *p; + p = self->sizes + self->sampleCount; + for(i = 0; i < sampleCount; i++) + *p++ = *sampleSizes; + } + self->sampleSize = 0; + } + else + { + self->sampleSize = *sampleSizes; + } + self->sampleCount += sampleCount; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getSampleSize( MP4AtomPtr s, u32 sampleNumber, u32 *outSize ) +static MP4Err getSampleSize(MP4AtomPtr s, u32 sampleNumber, u32 *outSize) { - MP4Err err; - MP4SampleSizeAtomPtr self = (MP4SampleSizeAtomPtr) s; - - err = MP4NoErr; - if ( (self == NULL) || (outSize == NULL) || (sampleNumber > self->sampleCount) || (sampleNumber == 0) ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->sampleSize ) - { - *outSize = self->sampleSize; - } - else - { - *outSize = self->sizes[sampleNumber - 1]; - } + MP4Err err; + MP4SampleSizeAtomPtr self = (MP4SampleSizeAtomPtr)s; + + err = MP4NoErr; + if((self == NULL) || (outSize == NULL) || (sampleNumber > self->sampleCount) || + (sampleNumber == 0)) + BAILWITHERROR(MP4BadParamErr) + + if(self->sampleSize) + { + *outSize = self->sampleSize; + } + else + { + *outSize = self->sizes[sampleNumber - 1]; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getSampleSizeAndOffset( MP4AtomPtr s, u32 sampleNumber, u32 *outSize, u32 startingSampleNumber, u32 *outOffsetSize ) +static MP4Err getSampleSizeAndOffset(MP4AtomPtr s, u32 sampleNumber, u32 *outSize, + u32 startingSampleNumber, u32 *outOffsetSize) { - MP4Err err; - MP4SampleSizeAtomPtr self = (MP4SampleSizeAtomPtr) s; - - err = MP4NoErr; - if ( (self == NULL) || (outSize == NULL) || (sampleNumber > self->sampleCount) || (sampleNumber == 0) ) - BAILWITHERROR( MP4BadParamErr ) - if ( (startingSampleNumber == 0) || (startingSampleNumber > sampleNumber) || (outOffsetSize == NULL) ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->sampleSize ) - { - *outSize = self->sampleSize; - *outOffsetSize = (sampleNumber - startingSampleNumber) * self->sampleSize; - } - else - { - u32 i; - u32 offset; - offset = 0; - *outSize = self->sizes[sampleNumber - 1]; - for ( i = startingSampleNumber - 1; i < sampleNumber - 1; i++ ) - offset += self->sizes[ i ]; - *outOffsetSize = offset; - } + MP4Err err; + MP4SampleSizeAtomPtr self = (MP4SampleSizeAtomPtr)s; + + err = MP4NoErr; + if((self == NULL) || (outSize == NULL) || (sampleNumber > self->sampleCount) || + (sampleNumber == 0)) + BAILWITHERROR(MP4BadParamErr) + if((startingSampleNumber == 0) || (startingSampleNumber > sampleNumber) || + (outOffsetSize == NULL)) + BAILWITHERROR(MP4BadParamErr) + + if(self->sampleSize) + { + *outSize = self->sampleSize; + *outOffsetSize = (sampleNumber - startingSampleNumber) * self->sampleSize; + } + else + { + u32 i; + u32 offset; + offset = 0; + *outSize = self->sizes[sampleNumber - 1]; + for(i = startingSampleNumber - 1; i < sampleNumber - 1; i++) + offset += self->sizes[i]; + *outOffsetSize = offset; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err setfieldsize( MP4SampleSizeAtomPtr self, u32 fieldsize ) +static MP4Err setfieldsize(MP4SampleSizeAtomPtr self, u32 fieldsize) { - self->fieldsize = fieldsize; - /* 32-bit size, or a default size for all samples, give the old atom */ - - if ((self->fieldsize == 32) || ( self->sampleSize != 0 )) - self->type = MP4SampleSizeAtomType; - else - self->type = MP4CompactSampleSizeAtomType; - return MP4NoErr; + self->fieldsize = fieldsize; + /* 32-bit size, or a default size for all samples, give the old atom */ + + if((self->fieldsize == 32) || (self->sampleSize != 0)) self->type = MP4SampleSizeAtomType; + else + self->type = MP4CompactSampleSizeAtomType; + return MP4NoErr; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - u32 fieldsize; - MP4SampleSizeAtomPtr self = (MP4SampleSizeAtomPtr) s; - - err = MP4NoErr; - - setfieldsize(self, self->fieldsize); - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - if (self->type == MP4SampleSizeAtomType) + MP4Err err; + u32 i; + u32 fieldsize; + MP4SampleSizeAtomPtr self = (MP4SampleSizeAtomPtr)s; + + err = MP4NoErr; + + setfieldsize(self, self->fieldsize); + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + if(self->type == MP4SampleSizeAtomType) + { + PUT32(sampleSize); + PUT32(sampleCount); + if(self->sampleSize == 0) { - PUT32( sampleSize ); - PUT32( sampleCount ); - if ( self->sampleSize == 0 ) - { - for ( i = 0; i < self->sampleCount; i++ ) - { - PUT32_V( self->sizes[i] ); - } - } - } - else - { - fieldsize = self->fieldsize; - PUT32( fieldsize ); - PUT32( sampleCount ); - switch (self->fieldsize) { - case 4: - for (i=0; isampleCount; i = i+2) - { - u8 thesizes; - thesizes = (self->sizes[i] & 0xF) | ((self->sizes[i+1] & 0xF) << 4); - PUT8_V( thesizes ); - } - break; - case 8: - for ( i = 0; i < self->sampleCount; i++ ) - { - PUT8_V( self->sizes[i] ); - } - break; - case 16: - for ( i = 0; i < self->sampleCount; i++ ) - { - PUT16_V( self->sizes[i] ); - } - break; - } - } - assert( self->bytesWritten == self->size ); + for(i = 0; i < self->sampleCount; i++) + { + PUT32_V(self->sizes[i]); + } + } + } + else + { + fieldsize = self->fieldsize; + PUT32(fieldsize); + PUT32(sampleCount); + switch(self->fieldsize) + { + case 4: + for(i = 0; i < self->sampleCount; i = i + 2) + { + u8 thesizes; + thesizes = (self->sizes[i] & 0xF) | ((self->sizes[i + 1] & 0xF) << 4); + PUT8_V(thesizes); + } + break; + case 8: + for(i = 0; i < self->sampleCount; i++) + { + PUT8_V(self->sizes[i]); + } + break; + case 16: + for(i = 0; i < self->sampleCount; i++) + { + PUT16_V(self->sizes[i]); + } + break; + } + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SampleSizeAtomPtr self = (MP4SampleSizeAtomPtr) s; - err = MP4NoErr; - - setfieldsize(self, self->fieldsize); - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 8; - if ( self->sampleSize == 0 ) switch(self->fieldsize) { - case 4: self->size += ((self->sampleCount+1)/2); break; - case 8: self->size += ( self->sampleCount); break; - case 16: self->size += (2*self->sampleCount); break; - case 32: self->size += (4*self->sampleCount); break; - } - + MP4Err err; + MP4SampleSizeAtomPtr self = (MP4SampleSizeAtomPtr)s; + err = MP4NoErr; + + setfieldsize(self, self->fieldsize); + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 8; + if(self->sampleSize == 0) switch(self->fieldsize) + { + case 4: + self->size += ((self->sampleCount + 1) / 2); + break; + case 8: + self->size += (self->sampleCount); + break; + case 16: + self->size += (2 * self->sampleCount); + break; + case 32: + self->size += (4 * self->sampleCount); + break; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 entries; - u32* p; - MP4SampleSizeAtomPtr self = (MP4SampleSizeAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - if (self->type == MP4SampleSizeAtomType) - { - GET32( sampleSize ); - GET32( sampleCount ); - - if ( self->sampleSize == 0 ) - { - self->sizes = (u32 *) calloc( self->sampleCount + 1, sizeof(u32) ); - TESTMALLOC( self->sizes ) - self->allocatedSize = (self->sampleCount + 1) * sizeof(u32); - for ( entries = 0, p = self->sizes; entries < self->sampleCount; entries++, p++ ) - { - u32 size; - GET32_V( size ); - *p = size; - } - } - } - else - { - GET32( fieldsize ); - GET32( sampleCount ); - self->sizes = (u32 *) calloc( self->sampleCount + 1, sizeof(u32) ); - TESTMALLOC( self->sizes ) - self->allocatedSize = (self->sampleCount + 1) * sizeof(u32); - p = self->sizes; - - switch(self->fieldsize) { - case 4: - for ( entries = 0; entries < self->sampleCount; entries = entries + 2 ) - { - u32 size; - GET8_V_MSG( size, NULL ); - *p = size & 0xF; p++; size = size >> 4; - *p = size & 0xF; p++; - } - break; - case 8: - for ( entries = 0, p = self->sizes; entries < self->sampleCount; entries++, p++ ) - { - u32 size; - GET8_V( size ); - *p = size; - } - break; - case 16: - for ( entries = 0, p = self->sizes; entries < self->sampleCount; entries++, p++ ) - { - u32 size; - GET16_V( size ); - *p = size; - } - break; - } - } + MP4Err err; + u32 entries; + u32 *p; + MP4SampleSizeAtomPtr self = (MP4SampleSizeAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + if(self->type == MP4SampleSizeAtomType) + { + GET32(sampleSize); + GET32(sampleCount); + + if(self->sampleSize == 0) + { + self->sizes = (u32 *)calloc(self->sampleCount + 1, sizeof(u32)); + TESTMALLOC(self->sizes) + self->allocatedSize = (self->sampleCount + 1) * sizeof(u32); + for(entries = 0, p = self->sizes; entries < self->sampleCount; entries++, p++) + { + u32 size; + GET32_V(size); + *p = size; + } + } + } + else + { + GET32(fieldsize); + GET32(sampleCount); + self->sizes = (u32 *)calloc(self->sampleCount + 1, sizeof(u32)); + TESTMALLOC(self->sizes) + self->allocatedSize = (self->sampleCount + 1) * sizeof(u32); + p = self->sizes; + + switch(self->fieldsize) + { + case 4: + for(entries = 0; entries < self->sampleCount; entries = entries + 2) + { + u32 size; + GET8_V_MSG(size, NULL); + *p = size & 0xF; + p++; + size = size >> 4; + *p = size & 0xF; + p++; + } + break; + case 8: + for(entries = 0, p = self->sizes; entries < self->sampleCount; entries++, p++) + { + u32 size; + GET8_V(size); + *p = size; + } + break; + case 16: + for(entries = 0, p = self->sizes; entries < self->sampleCount; entries++, p++) + { + u32 size; + GET16_V(size); + *p = size; + } + break; + } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSampleSizeAtom( MP4SampleSizeAtomPtr *outAtom ) +MP4Err MP4CreateSampleSizeAtom(MP4SampleSizeAtomPtr *outAtom) { - MP4Err err; - MP4SampleSizeAtomPtr self; - - self = (MP4SampleSizeAtomPtr) calloc( 1, sizeof(MP4SampleSizeAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4SampleSizeAtomType; - self->name = "sample size"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->getSampleSize = getSampleSize; - self->getSampleSizeAndOffset = getSampleSizeAndOffset; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addSamples = addSamples; - self->setfieldsize = setfieldsize; - self->fieldsize = 32; - *outAtom = self; + MP4Err err; + MP4SampleSizeAtomPtr self; + + self = (MP4SampleSizeAtomPtr)calloc(1, sizeof(MP4SampleSizeAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SampleSizeAtomType; + self->name = "sample size"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->getSampleSize = getSampleSize; + self->getSampleSizeAndOffset = getSampleSizeAndOffset; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addSamples = addSamples; + self->setfieldsize = setfieldsize; + self->fieldsize = 32; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index 424ead5..a1df334 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,758 +15,852 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SampleTableAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SampleTableAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SampleTableAtomPtr self; - u32 i; - err = MP4NoErr; - self = (MP4SampleTableAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - err = MP4DeleteLinkedList( self->groupDescriptionList ); if (err) goto bail; - err = MP4DeleteLinkedList( self->sampletoGroupList ); if (err) goto bail; - err = MP4DeleteLinkedList( self->compactSampletoGroupList ); if (err) goto bail; - err = MP4DeleteLinkedList( self->SampleAuxiliaryInformationSizes ); if (err) goto bail; - err = MP4DeleteLinkedList( self->SampleAuxiliaryInformationOffsets ); if (err) goto bail; - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4SampleTableAtomPtr self; + u32 i; + err = MP4NoErr; + self = (MP4SampleTableAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + err = MP4DeleteLinkedList(self->groupDescriptionList); + if(err) goto bail; + err = MP4DeleteLinkedList(self->sampletoGroupList); + if(err) goto bail; + err = MP4DeleteLinkedList(self->compactSampletoGroupList); + if(err) goto bail; + err = MP4DeleteLinkedList(self->SampleAuxiliaryInformationSizes); + if(err) goto bail; + err = MP4DeleteLinkedList(self->SampleAuxiliaryInformationOffsets); + if(err) goto bail; + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -MP4Err MP4FindGroupAtom( MP4LinkedList theList, u32 type, MP4AtomPtr* theAtom ) +MP4Err MP4FindGroupAtom(MP4LinkedList theList, u32 type, MP4AtomPtr *theAtom) { - u32 count, i; - MP4Err err; - - *theAtom = NULL; - - err = MP4GetListEntryCount( theList, &count ); if (err) goto bail; - for ( i = 0; i < count; i++ ) - { - MP4AtomPtr desc; - err = MP4GetListEntry( theList, i, (char **) &desc ); if (err) goto bail; - if ( desc ) - { - if(desc->type == MP4CompactSampletoGroupAtomType) { - MP4CompactSampletoGroupAtomPtr grp = (MP4CompactSampletoGroupAtomPtr) desc; - if (grp->grouping_type == type) { - *theAtom = desc; - return err; - } - } - else { - MP4SampletoGroupAtomPtr grp = (MP4SampletoGroupAtomPtr) desc; - if (grp->grouping_type == type) { - *theAtom = desc; - return err; - } - } - } - } - + u32 count, i; + MP4Err err; + + *theAtom = NULL; + + err = MP4GetListEntryCount(theList, &count); + if(err) goto bail; + for(i = 0; i < count; i++) + { + MP4AtomPtr desc; + err = MP4GetListEntry(theList, i, (char **)&desc); + if(err) goto bail; + if(desc) + { + if(desc->type == MP4CompactSampletoGroupAtomType) + { + MP4CompactSampletoGroupAtomPtr grp = (MP4CompactSampletoGroupAtomPtr)desc; + if(grp->grouping_type == type) + { + *theAtom = desc; + return err; + } + } + else + { + MP4SampletoGroupAtomPtr grp = (MP4SampletoGroupAtomPtr)desc; + if(grp->grouping_type == type) + { + *theAtom = desc; + return err; + } + } + } + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -#define ADDCASE( atomName ) \ - case MP4 ## atomName ## AtomType: \ - if ( self->atomName ) \ - BAILWITHERROR( MP4BadDataErr ) \ - self->atomName = atom; \ - break +#define ADDCASE(atomName) \ + case MP4##atomName##AtomType: \ + if(self->atomName) BAILWITHERROR(MP4BadDataErr) \ + self->atomName = atom; \ + break -static MP4Err addAtom( MP4SampleTableAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4SampleTableAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; - switch( atom->type ) - { - ADDCASE( TimeToSample ); - ADDCASE( CompositionOffset ); - ADDCASE( CompositionToDecode ); - ADDCASE( SyncSample ); - ADDCASE( SampleDescription ); - - case MP4CompactSampleSizeAtomType: - - ADDCASE( SampleSize ); - ADDCASE( SampleToChunk ); - - case MP4ChunkLargeOffsetAtomType: - ADDCASE( ChunkOffset ); - - ADDCASE( ShadowSync ); - ADDCASE( DegradationPriority ); - ADDCASE( PaddingBits ); - - ADDCASE( SampleDependency ); - - case MP4SampleAuxiliaryInformationSizesAtomType: - err = MP4AddListEntry( (void*) atom, self->SampleAuxiliaryInformationSizes ); - break; - - case MP4SampleAuxiliaryInformationOffsetsAtomType: - err = MP4AddListEntry( (void*) atom, self->SampleAuxiliaryInformationOffsets ); - break; - - case MP4SampleGroupDescriptionAtomType: - err = MP4AddListEntry( (void*) atom, self->groupDescriptionList ); - break; - - case MP4SampletoGroupAtomType: - err = MP4AddListEntry( (void*) atom, self->sampletoGroupList ); - break; - - case MP4CompactSampletoGroupAtomType: - err = MP4AddListEntry( (void*) atom, self->compactSampletoGroupList); - break; - } + MP4Err err; + err = MP4NoErr; + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; + switch(atom->type) + { + ADDCASE(TimeToSample); + ADDCASE(CompositionOffset); + ADDCASE(CompositionToDecode); + ADDCASE(SyncSample); + ADDCASE(SampleDescription); + + case MP4CompactSampleSizeAtomType: + + ADDCASE(SampleSize); + ADDCASE(SampleToChunk); + + case MP4ChunkLargeOffsetAtomType: + ADDCASE(ChunkOffset); + + ADDCASE(ShadowSync); + ADDCASE(DegradationPriority); + ADDCASE(PaddingBits); + + ADDCASE(SampleDependency); + + case MP4SampleAuxiliaryInformationSizesAtomType: + err = MP4AddListEntry((void *)atom, self->SampleAuxiliaryInformationSizes); + break; + + case MP4SampleAuxiliaryInformationOffsetsAtomType: + err = MP4AddListEntry((void *)atom, self->SampleAuxiliaryInformationOffsets); + break; + + case MP4SampleGroupDescriptionAtomType: + err = MP4AddListEntry((void *)atom, self->groupDescriptionList); + break; + + case MP4SampletoGroupAtomType: + err = MP4AddListEntry((void *)atom, self->sampletoGroupList); + break; + + case MP4CompactSampletoGroupAtomType: + err = MP4AddListEntry((void *)atom, self->compactSampletoGroupList); + break; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err calculateDuration( struct MP4SampleTableAtom *self, u32 *outDuration ) +static MP4Err calculateDuration(struct MP4SampleTableAtom *self, u32 *outDuration) { - MP4Err err; - MP4TimeToSampleAtomPtr ctts; - - err = MP4NoErr; - if ( outDuration == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - ctts = (MP4TimeToSampleAtomPtr) self->TimeToSample; - if ( ctts == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - err = ctts->getTotalDuration( ctts, outDuration ); if (err) goto bail; + MP4Err err; + MP4TimeToSampleAtomPtr ctts; + + err = MP4NoErr; + if(outDuration == NULL) BAILWITHERROR(MP4BadParamErr) + + ctts = (MP4TimeToSampleAtomPtr)self->TimeToSample; + if(ctts == NULL) BAILWITHERROR(MP4InvalidMediaErr) + err = ctts->getTotalDuration(ctts, outDuration); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err setSampleEntry( struct MP4SampleTableAtom *self, MP4AtomPtr entry ) +static MP4Err setSampleEntry(struct MP4SampleTableAtom *self, MP4AtomPtr entry) { - MP4Err err; - MP4SampleDescriptionAtomPtr stsd; - - err = MP4NoErr; - if ( entry == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - stsd = (MP4SampleDescriptionAtomPtr) self->SampleDescription; - if ( stsd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - err = stsd->addEntry( stsd, entry ); if (err) goto bail; - self->currentSampleEntry = entry; - self->currentSampleEntryIndex = stsd->getEntryCount( stsd ); + MP4Err err; + MP4SampleDescriptionAtomPtr stsd; + + err = MP4NoErr; + if(entry == NULL) BAILWITHERROR(MP4BadParamErr) + + stsd = (MP4SampleDescriptionAtomPtr)self->SampleDescription; + if(stsd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + err = stsd->addEntry(stsd, entry); + if(err) goto bail; + self->currentSampleEntry = entry; + self->currentSampleEntryIndex = stsd->getEntryCount(stsd); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static u32 getCurrentSampleEntryIndex( struct MP4SampleTableAtom *self ) +static u32 getCurrentSampleEntryIndex(struct MP4SampleTableAtom *self) { - return self->currentSampleEntryIndex; + return self->currentSampleEntryIndex; } -static MP4Err setDefaultSampleEntry( struct MP4SampleTableAtom *self, u32 index ) +static MP4Err setDefaultSampleEntry(struct MP4SampleTableAtom *self, u32 index) { - MP4SampleDescriptionAtomPtr stsd; - MP4Err err; - - err = MP4NoErr; - - stsd = (MP4SampleDescriptionAtomPtr) self->SampleDescription; - if ( stsd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - err = stsd->getEntry( stsd, index, (GenericSampleEntryAtomPtr*) &(self->currentSampleEntry) ); - self->currentSampleEntryIndex = index; - + MP4SampleDescriptionAtomPtr stsd; + MP4Err err; + + err = MP4NoErr; + + stsd = (MP4SampleDescriptionAtomPtr)self->SampleDescription; + if(stsd == NULL) BAILWITHERROR(MP4InvalidMediaErr) + err = stsd->getEntry(stsd, index, (GenericSampleEntryAtomPtr *)&(self->currentSampleEntry)); + self->currentSampleEntryIndex = index; + bail: - return err; + return err; } -static MP4Err setfieldsize( struct MP4SampleTableAtom* self, u32 fieldsize ) +static MP4Err setfieldsize(struct MP4SampleTableAtom *self, u32 fieldsize) { - MP4Err err; - MP4SampleSizeAtomPtr stsz; - - err = MP4NoErr; - stsz = (MP4SampleSizeAtomPtr) self->SampleSize; - assert( stsz ); - assert( stsz->setfieldsize ); - err = stsz->setfieldsize( stsz, fieldsize ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4SampleSizeAtomPtr stsz; + + err = MP4NoErr; + stsz = (MP4SampleSizeAtomPtr)self->SampleSize; + assert(stsz); + assert(stsz->setfieldsize); + err = stsz->setfieldsize(stsz, fieldsize); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err getCurrentDataReferenceIndex( struct MP4SampleTableAtom *self, u32 *outDataReferenceIndex ) +static MP4Err getCurrentDataReferenceIndex(struct MP4SampleTableAtom *self, + u32 *outDataReferenceIndex) { - GenericSampleEntryAtomPtr entry; - MP4Err err; - - err = MP4NoErr; - entry = (GenericSampleEntryAtomPtr) self->currentSampleEntry; - if ( entry == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ) - *outDataReferenceIndex = entry->dataReferenceIndex; + GenericSampleEntryAtomPtr entry; + MP4Err err; + + err = MP4NoErr; + entry = (GenericSampleEntryAtomPtr)self->currentSampleEntry; + if(entry == NULL) BAILWITHERROR(MP4InvalidMediaErr) + *outDataReferenceIndex = entry->dataReferenceIndex; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err extendLastSampleDuration( struct MP4SampleTableAtom *self, u32 duration ) +static MP4Err extendLastSampleDuration(struct MP4SampleTableAtom *self, u32 duration) { - MP4Err err; - MP4TimeToSampleAtomPtr stts; - - err = MP4NoErr; - stts = (MP4TimeToSampleAtomPtr) self->TimeToSample; - - if ( stts == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - stts->extendLastSampleDuration( stts, duration ); - + MP4Err err; + MP4TimeToSampleAtomPtr stts; + + err = MP4NoErr; + stts = (MP4TimeToSampleAtomPtr)self->TimeToSample; + + if(stts == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + stts->extendLastSampleDuration(stts, duration); + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err addSamples( struct MP4SampleTableAtom *self, - u32 sampleCount, u64 sampleOffset, MP4Handle durationsH, - MP4Handle sizesH, MP4Handle compositionOffsetsH, - MP4Handle syncSamplesH, MP4Handle padsH ) +static MP4Err addSamples(struct MP4SampleTableAtom *self, u32 sampleCount, u64 sampleOffset, + MP4Handle durationsH, MP4Handle sizesH, MP4Handle compositionOffsetsH, + MP4Handle syncSamplesH, MP4Handle padsH) { - u32 beginningSampleNumber; - u32 sampleDescriptionIndex; - MP4SampleDescriptionAtomPtr stsd; - MP4TimeToSampleAtomPtr stts; - MP4SampleSizeAtomPtr stsz; - MP4SampleToChunkAtomPtr stsc; - MP4ChunkOffsetAtomPtr stco; - MP4CompositionOffsetAtomPtr ctts; - MP4SyncSampleAtomPtr stss; - MP4PaddingBitsAtomPtr padb; - MP4CompositionToDecodeAtomPtr cslg; - u32 groupCount; - u32 i; - MP4Err err; - - err = MP4NoErr; - stsd = (MP4SampleDescriptionAtomPtr) self->SampleDescription; - if ( stsd == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stts = (MP4TimeToSampleAtomPtr) self->TimeToSample; - if ( stts == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stsz = (MP4SampleSizeAtomPtr) self->SampleSize; - if ( stsz == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stsc = (MP4SampleToChunkAtomPtr) self->SampleToChunk; - if ( stsc == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - stco = (MP4ChunkOffsetAtomPtr) self->ChunkOffset; - if ( stco == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - ctts = NULL; - if ( compositionOffsetsH != NULL ) - { - if (self->CompositionOffset == NULL ) + u32 beginningSampleNumber; + u32 sampleDescriptionIndex; + MP4SampleDescriptionAtomPtr stsd; + MP4TimeToSampleAtomPtr stts; + MP4SampleSizeAtomPtr stsz; + MP4SampleToChunkAtomPtr stsc; + MP4ChunkOffsetAtomPtr stco; + MP4CompositionOffsetAtomPtr ctts; + MP4SyncSampleAtomPtr stss; + MP4PaddingBitsAtomPtr padb; + MP4CompositionToDecodeAtomPtr cslg; + u32 groupCount; + u32 i; + MP4Err err; + + err = MP4NoErr; + stsd = (MP4SampleDescriptionAtomPtr)self->SampleDescription; + if(stsd == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stts = (MP4TimeToSampleAtomPtr)self->TimeToSample; + if(stts == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stsz = (MP4SampleSizeAtomPtr)self->SampleSize; + if(stsz == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stsc = (MP4SampleToChunkAtomPtr)self->SampleToChunk; + if(stsc == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + stco = (MP4ChunkOffsetAtomPtr)self->ChunkOffset; + if(stco == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + ctts = NULL; + if(compositionOffsetsH != NULL) + { + if(self->CompositionOffset == NULL) + { + MP4Err MP4CreateCompositionOffsetAtom(MP4CompositionOffsetAtomPtr * outAtom); + err = MP4CreateCompositionOffsetAtom(&ctts); + if(err) goto bail; + if(self->useSignedCompositionTimeOffsets == 1) { - MP4Err MP4CreateCompositionOffsetAtom( MP4CompositionOffsetAtomPtr *outAtom ); - err = MP4CreateCompositionOffsetAtom( &ctts ); if (err) goto bail; - if (self->useSignedCompositionTimeOffsets == 1) - { - MP4Err MP4CreateCompositionToDecodeAtom( MP4CompositionToDecodeAtomPtr *outAtom ); - ctts->version = 1; - err = MP4CreateCompositionToDecodeAtom( &cslg ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) cslg ); if (err) goto bail; - - } - err = addAtom( self, (MP4AtomPtr) ctts ); if (err) goto bail; + MP4Err MP4CreateCompositionToDecodeAtom(MP4CompositionToDecodeAtomPtr * outAtom); + ctts->version = 1; + err = MP4CreateCompositionToDecodeAtom(&cslg); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)cslg); + if(err) goto bail; } - ctts = (MP4CompositionOffsetAtomPtr) self->CompositionOffset; - - } - stss = NULL; - if ( syncSamplesH != NULL ) - { - if (self->SyncSample == NULL ) + err = addAtom(self, (MP4AtomPtr)ctts); + if(err) goto bail; + } + ctts = (MP4CompositionOffsetAtomPtr)self->CompositionOffset; + } + stss = NULL; + if(syncSamplesH != NULL) + { + if(self->SyncSample == NULL) + { + /* + create a sync sample atom when we get the first + indication that all samples are not sync samples + */ + u32 samplesInHandle; + err = MP4GetHandleSize(syncSamplesH, &samplesInHandle); + if(err) goto bail; + samplesInHandle /= 4; + if(samplesInHandle != sampleCount) { - /* - create a sync sample atom when we get the first - indication that all samples are not sync samples - */ - u32 samplesInHandle; - err = MP4GetHandleSize( syncSamplesH, &samplesInHandle ); if (err) goto bail; - samplesInHandle /= 4; - if ( samplesInHandle != sampleCount ) - { - MP4Err MP4CreateSyncSampleAtom( MP4SyncSampleAtomPtr *outAtom ); - err = MP4CreateSyncSampleAtom( &stss ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) stss ); if (err) goto bail; - } + MP4Err MP4CreateSyncSampleAtom(MP4SyncSampleAtomPtr * outAtom); + err = MP4CreateSyncSampleAtom(&stss); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)stss); + if(err) goto bail; } - stss = (MP4SyncSampleAtomPtr) self->SyncSample; - } - beginningSampleNumber = stsz->sampleCount + 1; - err = stts->addSamples( stts, sampleCount, durationsH ); if (err) goto bail; - if ( ctts ) - { - err = ctts->addSamples( ctts, beginningSampleNumber, sampleCount, compositionOffsetsH ); if (err) goto bail; - if (self->useSignedCompositionTimeOffsets == 1) - { - cslg = (MP4CompositionToDecodeAtomPtr) self->CompositionToDecode; - cslg->updateFields( (MP4AtomPtr) cslg, sampleCount, durationsH, compositionOffsetsH); if (err) goto bail; - } - } - if ( stss ) - { - err = stss->addSamples( stss, beginningSampleNumber, sampleCount, syncSamplesH ); if (err) goto bail; - } - sampleDescriptionIndex = stsd->getEntryCount( stsd ); - if ( sampleDescriptionIndex == 0 ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - - padb = (MP4PaddingBitsAtomPtr) self->PaddingBits; - if (padsH != NULL) - { - if (padb == NULL) - { - MP4Err MP4CreatePaddingBitsAtom( MP4PaddingBitsAtomPtr *outAtom ); - err = MP4CreatePaddingBitsAtom( &padb ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) padb ); if (err) goto bail; - if (stsz->sampleCount > 0) { - err = padb->addSamplePads( padb, stsz->sampleCount, NULL ); if (err) goto bail; - } - } - err = padb->addSamplePads( padb, sampleCount, padsH ); if (err) goto bail; - } - else if (padb != NULL) - { - err = padb->addSamplePads( padb, sampleCount, NULL ); if (err) goto bail; - } - - err = stsz->addSamples( stsz, sampleCount, sizesH ); if (err) goto bail; - err = stco->addOffset( stco, sampleOffset ); if (err) goto bail; - err = stsc->setEntry( stsc, stco->getChunkCount( (MP4AtomPtr) stco ), - sampleCount, sampleDescriptionIndex ); if (err) goto bail; - - err = MP4GetListEntryCount( self->sampletoGroupList, &groupCount ); if (err) goto bail; - for ( i = 0; i < groupCount; i++ ) \ - { - MP4SampletoGroupAtomPtr desc; - err = MP4GetListEntry( self->sampletoGroupList, i, (char **) &desc ); if (err) goto bail; - if ( desc ) - { - err = desc->addSamples( desc, sampleCount ); if (err) goto bail; - } - } - err = MP4GetListEntryCount( self->compactSampletoGroupList, &groupCount ); if (err) goto bail; - for ( i = 0; i < groupCount; i++ ) \ - { - MP4CompactSampletoGroupAtomPtr desc; - err = MP4GetListEntry( self->compactSampletoGroupList, i, (char **) &desc ); if (err) goto bail; - if ( desc ) - { - err = desc->addSamples( desc, sampleCount ); if (err) goto bail; - } - } - - if (self->SampleDependency) { - MP4SampleDependencyAtomPtr sdtp; - sdtp = (MP4SampleDependencyAtomPtr) self->SampleDependency; - err = sdtp->addSamples( sdtp, sampleCount ); if (err) goto bail; - } - - bail: - TEST_RETURN( err ); - - return err; + } + stss = (MP4SyncSampleAtomPtr)self->SyncSample; + } + beginningSampleNumber = stsz->sampleCount + 1; + err = stts->addSamples(stts, sampleCount, durationsH); + if(err) goto bail; + if(ctts) + { + err = ctts->addSamples(ctts, beginningSampleNumber, sampleCount, compositionOffsetsH); + if(err) goto bail; + if(self->useSignedCompositionTimeOffsets == 1) + { + cslg = (MP4CompositionToDecodeAtomPtr)self->CompositionToDecode; + cslg->updateFields((MP4AtomPtr)cslg, sampleCount, durationsH, compositionOffsetsH); + if(err) goto bail; + } + } + if(stss) + { + err = stss->addSamples(stss, beginningSampleNumber, sampleCount, syncSamplesH); + if(err) goto bail; + } + sampleDescriptionIndex = stsd->getEntryCount(stsd); + if(sampleDescriptionIndex == 0) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + + padb = (MP4PaddingBitsAtomPtr)self->PaddingBits; + if(padsH != NULL) + { + if(padb == NULL) + { + MP4Err MP4CreatePaddingBitsAtom(MP4PaddingBitsAtomPtr * outAtom); + err = MP4CreatePaddingBitsAtom(&padb); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)padb); + if(err) goto bail; + if(stsz->sampleCount > 0) + { + err = padb->addSamplePads(padb, stsz->sampleCount, NULL); + if(err) goto bail; + } + } + err = padb->addSamplePads(padb, sampleCount, padsH); + if(err) goto bail; + } + else if(padb != NULL) + { + err = padb->addSamplePads(padb, sampleCount, NULL); + if(err) goto bail; + } + + err = stsz->addSamples(stsz, sampleCount, sizesH); + if(err) goto bail; + err = stco->addOffset(stco, sampleOffset); + if(err) goto bail; + err = stsc->setEntry(stsc, stco->getChunkCount((MP4AtomPtr)stco), sampleCount, + sampleDescriptionIndex); + if(err) goto bail; + + err = MP4GetListEntryCount(self->sampletoGroupList, &groupCount); + if(err) goto bail; + for(i = 0; i < groupCount; i++) + { + MP4SampletoGroupAtomPtr desc; + err = MP4GetListEntry(self->sampletoGroupList, i, (char **)&desc); + if(err) goto bail; + if(desc) + { + err = desc->addSamples(desc, sampleCount); + if(err) goto bail; + } + } + err = MP4GetListEntryCount(self->compactSampletoGroupList, &groupCount); + if(err) goto bail; + for(i = 0; i < groupCount; i++) + { + MP4CompactSampletoGroupAtomPtr desc; + err = MP4GetListEntry(self->compactSampletoGroupList, i, (char **)&desc); + if(err) goto bail; + if(desc) + { + err = desc->addSamples(desc, sampleCount); + if(err) goto bail; + } + } + + if(self->SampleDependency) + { + MP4SampleDependencyAtomPtr sdtp; + sdtp = (MP4SampleDependencyAtomPtr)self->SampleDependency; + err = sdtp->addSamples(sdtp, sampleCount); + if(err) goto bail; + } + +bail: + TEST_RETURN(err); + + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4SampleTableAtomPtr self = (MP4SampleTableAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( atomList ); - SERIALIZE_ATOM_LIST( SampleAuxiliaryInformationSizes ); - SERIALIZE_ATOM_LIST( SampleAuxiliaryInformationOffsets ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4SampleTableAtomPtr self = (MP4SampleTableAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(atomList); + SERIALIZE_ATOM_LIST(SampleAuxiliaryInformationSizes); + SERIALIZE_ATOM_LIST(SampleAuxiliaryInformationOffsets); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SampleTableAtomPtr self = (MP4SampleTableAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE( atomList ); - ADD_ATOM_LIST_SIZE( SampleAuxiliaryInformationSizes ); - ADD_ATOM_LIST_SIZE( SampleAuxiliaryInformationOffsets ); + MP4Err err; + MP4SampleTableAtomPtr self = (MP4SampleTableAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); + ADD_ATOM_LIST_SIZE(SampleAuxiliaryInformationSizes); + ADD_ATOM_LIST_SIZE(SampleAuxiliaryInformationOffsets); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err setupNew( struct MP4SampleTableAtom *self ) +static MP4Err setupNew(struct MP4SampleTableAtom *self) { - MP4Err MP4CreateTimeToSampleAtom( MP4TimeToSampleAtomPtr *outAtom ); - MP4Err MP4CreateSampleDescriptionAtom( MP4SampleDescriptionAtomPtr *outAtom ); - MP4Err MP4CreateSampleSizeAtom( MP4SampleSizeAtomPtr *outAtom ); - MP4Err MP4CreateSampleToChunkAtom( MP4SampleToChunkAtomPtr *outAtom ); - MP4Err MP4CreateChunkOffsetAtom( MP4ChunkOffsetAtomPtr *outAtom ); - - MP4Err err; - MP4TimeToSampleAtomPtr ctts; - MP4SampleDescriptionAtomPtr stsd; - MP4SampleSizeAtomPtr stsz; - MP4SampleToChunkAtomPtr stsc; - MP4ChunkOffsetAtomPtr stco; - - err = MP4NoErr; - - if (!(self->TimeToSample)) { - err = MP4CreateTimeToSampleAtom( &ctts ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) ctts ); if (err) goto bail; - } - if (!(self->SampleDescription)) { - err = MP4CreateSampleDescriptionAtom( &stsd ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) stsd ); if (err) goto bail; - } - if (!(self->SampleSize)) { - err = MP4CreateSampleSizeAtom( &stsz ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) stsz ); if (err) goto bail; - } - if (!(self->SampleToChunk)) { - err = MP4CreateSampleToChunkAtom( &stsc ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) stsc ); if (err) goto bail; - } - if (!(self->ChunkOffset)) { - err = MP4CreateChunkOffsetAtom( &stco ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) stco ); if (err) goto bail; - } - + MP4Err MP4CreateTimeToSampleAtom(MP4TimeToSampleAtomPtr * outAtom); + MP4Err MP4CreateSampleDescriptionAtom(MP4SampleDescriptionAtomPtr * outAtom); + MP4Err MP4CreateSampleSizeAtom(MP4SampleSizeAtomPtr * outAtom); + MP4Err MP4CreateSampleToChunkAtom(MP4SampleToChunkAtomPtr * outAtom); + MP4Err MP4CreateChunkOffsetAtom(MP4ChunkOffsetAtomPtr * outAtom); + + MP4Err err; + MP4TimeToSampleAtomPtr ctts; + MP4SampleDescriptionAtomPtr stsd; + MP4SampleSizeAtomPtr stsz; + MP4SampleToChunkAtomPtr stsc; + MP4ChunkOffsetAtomPtr stco; + + err = MP4NoErr; + + if(!(self->TimeToSample)) + { + err = MP4CreateTimeToSampleAtom(&ctts); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)ctts); + if(err) goto bail; + } + if(!(self->SampleDescription)) + { + err = MP4CreateSampleDescriptionAtom(&stsd); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)stsd); + if(err) goto bail; + } + if(!(self->SampleSize)) + { + err = MP4CreateSampleSizeAtom(&stsz); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)stsz); + if(err) goto bail; + } + if(!(self->SampleToChunk)) + { + err = MP4CreateSampleToChunkAtom(&stsc); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)stsc); + if(err) goto bail; + } + if(!(self->ChunkOffset)) + { + err = MP4CreateChunkOffsetAtom(&stco); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)stco); + if(err) goto bail; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addGroupDescription( struct MP4SampleTableAtom *self, u32 theType, MP4Handle theDescription, u32* index ) +static MP4Err addGroupDescription(struct MP4SampleTableAtom *self, u32 theType, + MP4Handle theDescription, u32 *index) { - MP4Err err; - MP4SampleGroupDescriptionAtomPtr theGroup; - - err = MP4FindGroupAtom( self->groupDescriptionList, theType, (MP4AtomPtr*) &theGroup ); - if (!theGroup) - { - err = MP4CreateSampleGroupDescriptionAtom( &theGroup ); if (err) goto bail; - theGroup->grouping_type = theType; - err = addAtom( self, (MP4AtomPtr) theGroup ); if (err) goto bail; - } - err = theGroup->addGroupDescription( theGroup, theDescription, index ); if (err) goto bail; - + MP4Err err; + MP4SampleGroupDescriptionAtomPtr theGroup; + + err = MP4FindGroupAtom(self->groupDescriptionList, theType, (MP4AtomPtr *)&theGroup); + if(!theGroup) + { + err = MP4CreateSampleGroupDescriptionAtom(&theGroup); + if(err) goto bail; + theGroup->grouping_type = theType; + err = addAtom(self, (MP4AtomPtr)theGroup); + if(err) goto bail; + } + err = theGroup->addGroupDescription(theGroup, theDescription, index); + if(err) goto bail; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getGroupDescription( struct MP4SampleTableAtom *self, u32 theType, u32 index, MP4Handle theDescription ) +static MP4Err getGroupDescription(struct MP4SampleTableAtom *self, u32 theType, u32 index, + MP4Handle theDescription) { - MP4Err err; - MP4SampleGroupDescriptionAtomPtr theGroup; - - err = MP4FindGroupAtom( self->groupDescriptionList, theType, (MP4AtomPtr*) &theGroup ); - if (!theGroup) BAILWITHERROR(MP4BadParamErr ); - err = theGroup->getGroupDescription( theGroup, index, theDescription ); if (err) goto bail; - + MP4Err err; + MP4SampleGroupDescriptionAtomPtr theGroup; + + err = MP4FindGroupAtom(self->groupDescriptionList, theType, (MP4AtomPtr *)&theGroup); + if(!theGroup) BAILWITHERROR(MP4BadParamErr); + err = theGroup->getGroupDescription(theGroup, index, theDescription); + if(err) goto bail; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err mapSamplestoGroup( struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples ) +static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, + s32 sample_index, u32 count, u32 enableCompactSamples) { - MP4Err err; - MP4SampletoGroupAtomPtr theGroup; - MP4SampleGroupDescriptionAtomPtr theDesc; - - err = MP4FindGroupAtom( self->groupDescriptionList, groupType, (MP4AtomPtr*) &theDesc ); - if (!theDesc) BAILWITHERROR( MP4BadParamErr ); - if (group_index > theDesc->groupCount) BAILWITHERROR( MP4BadParamErr ); - - if (enableCompactSamples) { - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - err = MP4FindGroupAtom( self->compactSampletoGroupList, groupType, (MP4AtomPtr*) &compactSampleGroup ); - if (!compactSampleGroup) { - MP4SampleSizeAtomPtr stsz; - stsz = (MP4SampleSizeAtomPtr) self->SampleSize; - if ( stsz == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - err = MP4CreateCompactSampletoGroupAtom( &compactSampleGroup ); if (err) goto bail; - compactSampleGroup->grouping_type = groupType; - compactSampleGroup->fragmentLocalIndexPresent = 0; - err = addAtom( self, (MP4AtomPtr) compactSampleGroup ); if (err) goto bail; - err = compactSampleGroup->addSamples( compactSampleGroup, stsz->sampleCount ); if (err) goto bail; - } - err = compactSampleGroup->mapSamplestoGroup( compactSampleGroup, group_index, sample_index, count ); if (err) goto bail; - } - else { - err = MP4FindGroupAtom( self->sampletoGroupList, groupType, (MP4AtomPtr*) &theGroup ); - if (!theGroup) { - MP4SampleSizeAtomPtr stsz; - - stsz = (MP4SampleSizeAtomPtr) self->SampleSize; - if ( stsz == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - err = MP4CreateSampletoGroupAtom( &theGroup ); if (err) goto bail; - theGroup->grouping_type = groupType; - err = addAtom( self, (MP4AtomPtr) theGroup ); if (err) goto bail; - err = theGroup->addSamples( theGroup, stsz->sampleCount ); if (err) goto bail; - } - err = theGroup->mapSamplestoGroup( theGroup, group_index, sample_index, count ); if (err) goto bail; - } - + MP4Err err; + MP4SampletoGroupAtomPtr theGroup; + MP4SampleGroupDescriptionAtomPtr theDesc; + + err = MP4FindGroupAtom(self->groupDescriptionList, groupType, (MP4AtomPtr *)&theDesc); + if(!theDesc) BAILWITHERROR(MP4BadParamErr); + if(group_index > theDesc->groupCount) BAILWITHERROR(MP4BadParamErr); + + if(enableCompactSamples) + { + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + err = MP4FindGroupAtom(self->compactSampletoGroupList, groupType, + (MP4AtomPtr *)&compactSampleGroup); + if(!compactSampleGroup) + { + MP4SampleSizeAtomPtr stsz; + stsz = (MP4SampleSizeAtomPtr)self->SampleSize; + if(stsz == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + err = MP4CreateCompactSampletoGroupAtom(&compactSampleGroup); + if(err) goto bail; + compactSampleGroup->grouping_type = groupType; + compactSampleGroup->fragmentLocalIndexPresent = 0; + err = addAtom(self, (MP4AtomPtr)compactSampleGroup); + if(err) goto bail; + err = compactSampleGroup->addSamples(compactSampleGroup, stsz->sampleCount); + if(err) goto bail; + } + err = + compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); + if(err) goto bail; + } + else + { + err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); + if(!theGroup) + { + MP4SampleSizeAtomPtr stsz; + + stsz = (MP4SampleSizeAtomPtr)self->SampleSize; + if(stsz == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + err = MP4CreateSampletoGroupAtom(&theGroup); + if(err) goto bail; + theGroup->grouping_type = groupType; + err = addAtom(self, (MP4AtomPtr)theGroup); + if(err) goto bail; + err = theGroup->addSamples(theGroup, stsz->sampleCount); + if(err) goto bail; + } + err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); + if(err) goto bail; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getSampleGroupMap( struct MP4SampleTableAtom *self, u32 groupType, u32 sample_number, u32* group_index ) +static MP4Err getSampleGroupMap(struct MP4SampleTableAtom *self, u32 groupType, u32 sample_number, + u32 *group_index) { - MP4Err err; - MP4SampletoGroupAtomPtr theGroup; - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - - err = MP4FindGroupAtom( self->sampletoGroupList, groupType, (MP4AtomPtr*) &theGroup ); - if (theGroup) { - err = theGroup->getSampleGroupMap( theGroup, sample_number, group_index ); if (err) goto bail; - return err; - } - - err = MP4FindGroupAtom( self->compactSampletoGroupList, groupType, (MP4AtomPtr*) &compactSampleGroup ); - if (compactSampleGroup) { - err = compactSampleGroup->getSampleGroupMap( compactSampleGroup, sample_number, group_index ); if (err) goto bail; - } - else { - err = MP4BadParamErr; - goto bail; - } - + MP4Err err; + MP4SampletoGroupAtomPtr theGroup; + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + + err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); + if(theGroup) + { + err = theGroup->getSampleGroupMap(theGroup, sample_number, group_index); + if(err) goto bail; + return err; + } + + err = MP4FindGroupAtom(self->compactSampletoGroupList, groupType, + (MP4AtomPtr *)&compactSampleGroup); + if(compactSampleGroup) + { + err = compactSampleGroup->getSampleGroupMap(compactSampleGroup, sample_number, group_index); + if(err) goto bail; + } + else + { + err = MP4BadParamErr; + goto bail; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err setSampleDependency( struct MP4SampleTableAtom *self, s32 sample_index, MP4Handle dependencies ) +static MP4Err setSampleDependency(struct MP4SampleTableAtom *self, s32 sample_index, + MP4Handle dependencies) { - MP4Err err; - MP4SampleDependencyAtomPtr sdtp; - - err = MP4NoErr; - sdtp = (MP4SampleDependencyAtomPtr) self->SampleDependency; - if (!sdtp) { - MP4Err MP4CreateSampleDependencyAtom( MP4SampleDependencyAtomPtr *outAtom ); - MP4SampleSizeAtomPtr stsz; - - stsz = (MP4SampleSizeAtomPtr) self->SampleSize; - if ( stsz == NULL ) - { - BAILWITHERROR( MP4InvalidMediaErr ); - } - err = MP4CreateSampleDependencyAtom( &sdtp ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) sdtp ); if (err) goto bail; - if (stsz->sampleCount > 0) { - err = sdtp->addSamples( sdtp, stsz->sampleCount ); if (err) goto bail; - } - } - assert( sdtp->setSampleDependency ); - err = sdtp->setSampleDependency( sdtp, sample_index, dependencies ); if (err) goto bail; - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4SampleDependencyAtomPtr sdtp; + + err = MP4NoErr; + sdtp = (MP4SampleDependencyAtomPtr)self->SampleDependency; + if(!sdtp) + { + MP4Err MP4CreateSampleDependencyAtom(MP4SampleDependencyAtomPtr * outAtom); + MP4SampleSizeAtomPtr stsz; + + stsz = (MP4SampleSizeAtomPtr)self->SampleSize; + if(stsz == NULL) + { + BAILWITHERROR(MP4InvalidMediaErr); + } + err = MP4CreateSampleDependencyAtom(&sdtp); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)sdtp); + if(err) goto bail; + if(stsz->sampleCount > 0) + { + err = sdtp->addSamples(sdtp, stsz->sampleCount); + if(err) goto bail; + } + } + assert(sdtp->setSampleDependency); + err = sdtp->setSampleDependency(sdtp, sample_index, dependencies); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err getSampleDependency( struct MP4SampleTableAtom *self, u32 sampleNumber, u8* dependency ) +static MP4Err getSampleDependency(struct MP4SampleTableAtom *self, u32 sampleNumber, u8 *dependency) { - MP4Err err; - MP4SampleDependencyAtomPtr sdtp; - - err = MP4NoErr; - sdtp = (MP4SampleDependencyAtomPtr) self->SampleDependency; - if (sdtp) { - assert( sdtp->getSampleDependency ); - err = sdtp->getSampleDependency( sdtp, sampleNumber, dependency ); if (err) goto bail; - } - else { - *dependency = 0; - } - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4SampleDependencyAtomPtr sdtp; + + err = MP4NoErr; + sdtp = (MP4SampleDependencyAtomPtr)self->SampleDependency; + if(sdtp) + { + assert(sdtp->getSampleDependency); + err = sdtp->getSampleDependency(sdtp, sampleNumber, dependency); + if(err) goto bail; + } + else + { + *dependency = 0; + } +bail: + TEST_RETURN(err); + + return err; } -MP4Err getSampleAuxiliaryInformation( struct MP4SampleTableAtom *self, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, - MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut) +MP4Err getSampleAuxiliaryInformation(struct MP4SampleTableAtom *self, + u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, + u32 aux_info_type_parameter, + MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, + MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut) { - MP4Err err; - u32 i; - err = MP4NoErr; - - *saizOut = NULL; - *saioOut = NULL; - - for (i = 0; i < self->SampleAuxiliaryInformationSizes->entryCount; i++) + MP4Err err; + u32 i; + err = MP4NoErr; + + *saizOut = NULL; + *saioOut = NULL; + + for(i = 0; i < self->SampleAuxiliaryInformationSizes->entryCount; i++) + { + MP4SampleAuxiliaryInformationSizesAtomPtr saizExisting; + MP4SampleAuxiliaryInformationOffsetsAtomPtr saioExisting; + err = MP4GetListEntry(self->SampleAuxiliaryInformationSizes, i, (char **)&saizExisting); + err = MP4GetListEntry(self->SampleAuxiliaryInformationOffsets, i, (char **)&saioExisting); + + if(((saizExisting->flags & 1) == isUsingAuxInfoPropertiesFlag) && + (saizExisting->aux_info_type == aux_info_type) && + (saizExisting->aux_info_type_parameter == aux_info_type_parameter)) { - MP4SampleAuxiliaryInformationSizesAtomPtr saizExisting; - MP4SampleAuxiliaryInformationOffsetsAtomPtr saioExisting; - err = MP4GetListEntry(self->SampleAuxiliaryInformationSizes, i, (char **) &saizExisting); - err = MP4GetListEntry(self->SampleAuxiliaryInformationOffsets, i, (char **) &saioExisting); - - if (((saizExisting->flags & 1) == isUsingAuxInfoPropertiesFlag) && - (saizExisting->aux_info_type == aux_info_type) && - (saizExisting->aux_info_type_parameter == aux_info_type_parameter)) - { - *saizOut = saizExisting; - } - - if (((saioExisting->flags & 1) == isUsingAuxInfoPropertiesFlag) && - (saioExisting->aux_info_type == aux_info_type) && - (saioExisting->aux_info_type_parameter == aux_info_type_parameter)) - { - *saioOut = saioExisting; - } + *saizOut = saizExisting; } - TEST_RETURN( err ); - - return err; + if(((saioExisting->flags & 1) == isUsingAuxInfoPropertiesFlag) && + (saioExisting->aux_info_type == aux_info_type) && + (saioExisting->aux_info_type_parameter == aux_info_type_parameter)) + { + *saioOut = saioExisting; + } + } + + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MP4SampleTableAtom) + PARSE_ATOM_LIST(MP4SampleTableAtom) - err = self->setupNew( (MP4SampleTableAtomPtr) s ); + err = self->setupNew((MP4SampleTableAtomPtr)s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSampleTableAtom( MP4SampleTableAtomPtr *outAtom ) +MP4Err MP4CreateSampleTableAtom(MP4SampleTableAtomPtr *outAtom) { - MP4Err err; - MP4SampleTableAtomPtr self; - - self = (MP4SampleTableAtomPtr) calloc( 1, sizeof(MP4SampleTableAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4SampleTableAtomType; - self->name = "sample table"; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->calculateDuration = calculateDuration; - self->setSampleEntry = setSampleEntry; - self->serialize = serialize; - self->getCurrentDataReferenceIndex = getCurrentDataReferenceIndex; - self->extendLastSampleDuration = extendLastSampleDuration; - self->addSamples = addSamples; - self->setupNew = setupNew; - self->setfieldsize = setfieldsize; - self->getCurrentSampleEntryIndex = getCurrentSampleEntryIndex; - self->setDefaultSampleEntry = setDefaultSampleEntry; - - self->addGroupDescription = addGroupDescription; - self->mapSamplestoGroup = mapSamplestoGroup; - self->getSampleGroupMap = getSampleGroupMap; - self->getGroupDescription = getGroupDescription; - - self->setSampleDependency = setSampleDependency; - self->getSampleDependency = getSampleDependency; - - err = MP4MakeLinkedList( &(self->groupDescriptionList) ); if (err) goto bail; - err = MP4MakeLinkedList( &(self->sampletoGroupList) ); if (err) goto bail; - err = MP4MakeLinkedList( &(self->compactSampletoGroupList) ); if (err) goto bail; - - self->useSignedCompositionTimeOffsets = 0; - self->getSampleAuxiliaryInformation = getSampleAuxiliaryInformation; - - err = MP4MakeLinkedList( &(self->SampleAuxiliaryInformationSizes) ); if (err) goto bail; - err = MP4MakeLinkedList( &(self->SampleAuxiliaryInformationOffsets) ); if (err) goto bail; - - *outAtom = self; + MP4Err err; + MP4SampleTableAtomPtr self; + + self = (MP4SampleTableAtomPtr)calloc(1, sizeof(MP4SampleTableAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SampleTableAtomType; + self->name = "sample table"; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->calculateDuration = calculateDuration; + self->setSampleEntry = setSampleEntry; + self->serialize = serialize; + self->getCurrentDataReferenceIndex = getCurrentDataReferenceIndex; + self->extendLastSampleDuration = extendLastSampleDuration; + self->addSamples = addSamples; + self->setupNew = setupNew; + self->setfieldsize = setfieldsize; + self->getCurrentSampleEntryIndex = getCurrentSampleEntryIndex; + self->setDefaultSampleEntry = setDefaultSampleEntry; + + self->addGroupDescription = addGroupDescription; + self->mapSamplestoGroup = mapSamplestoGroup; + self->getSampleGroupMap = getSampleGroupMap; + self->getGroupDescription = getGroupDescription; + + self->setSampleDependency = setSampleDependency; + self->getSampleDependency = getSampleDependency; + + err = MP4MakeLinkedList(&(self->groupDescriptionList)); + if(err) goto bail; + err = MP4MakeLinkedList(&(self->sampletoGroupList)); + if(err) goto bail; + err = MP4MakeLinkedList(&(self->compactSampletoGroupList)); + if(err) goto bail; + + self->useSignedCompositionTimeOffsets = 0; + self->getSampleAuxiliaryInformation = getSampleAuxiliaryInformation; + + err = MP4MakeLinkedList(&(self->SampleAuxiliaryInformationSizes)); + if(err) goto bail; + err = MP4MakeLinkedList(&(self->SampleAuxiliaryInformationOffsets)); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SampleToChunkAtom.c b/IsoLib/libisomediafile/src/SampleToChunkAtom.c index d3d12bb..9e159a5 100644 --- a/IsoLib/libisomediafile/src/SampleToChunkAtom.c +++ b/IsoLib/libisomediafile/src/SampleToChunkAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,337 +15,353 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SampleToChunkAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SampleToChunkAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static u32 getEntryCount( struct MP4SampleToChunkAtom *self ) +static u32 getEntryCount(struct MP4SampleToChunkAtom *self) { - u32 entryCount = 0; - MP4GetListEntryCount( self->entryList, &entryCount ); - return entryCount; + u32 entryCount = 0; + MP4GetListEntryCount(self->entryList, &entryCount); + return entryCount; } -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 entryCount; - MP4SampleToChunkAtomPtr self; - err = MP4NoErr; - self = (MP4SampleToChunkAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - entryCount = getEntryCount( self ); - if ( entryCount ) - { - u32 i; - for ( i = 0; i < entryCount; i++ ) - { - char *p; - err = MP4GetListEntry( self->entryList, i, &p ); if (err) goto bail; - if ( p ) - free( p ); - } - } - MP4DeleteLinkedList( self->entryList ); - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + u32 entryCount; + MP4SampleToChunkAtomPtr self; + err = MP4NoErr; + self = (MP4SampleToChunkAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + entryCount = getEntryCount(self); + if(entryCount) + { + u32 i; + for(i = 0; i < entryCount; i++) + { + char *p; + err = MP4GetListEntry(self->entryList, i, &p); + if(err) goto bail; + if(p) free(p); + } + } + MP4DeleteLinkedList(self->entryList); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } typedef struct { - u32 firstChunk; - u32 samplesPerChunk; - u32 sampleDescriptionIndex; + u32 firstChunk; + u32 samplesPerChunk; + u32 sampleDescriptionIndex; } stscEntry, *stscEntryPtr; - -static MP4Err setEntry( struct MP4SampleToChunkAtom *self, u32 firstChunkNumber, u32 sampleCount, u32 sampleDescriptionIndex ) +static MP4Err setEntry(struct MP4SampleToChunkAtom *self, u32 firstChunkNumber, u32 sampleCount, + u32 sampleDescriptionIndex) { - stscEntryPtr p; - stscEntryPtr last; - MP4Err err; - u32 entryCount; - u8 addnew; - - err = MP4NoErr; - - entryCount = getEntryCount( self ); - addnew = 1; - - if (entryCount > 0) - { - err = MP4GetListEntry( self->entryList, entryCount-1, (char**) &last ); if (err) goto bail; - if ((last->samplesPerChunk == sampleCount) && (last->sampleDescriptionIndex == sampleDescriptionIndex)) - addnew = 0; - } - - if (addnew) { - p = (stscEntryPtr) calloc( 1, sizeof(stscEntry) ); - TESTMALLOC( p ); - p->firstChunk = firstChunkNumber; - p->samplesPerChunk = sampleCount; - p->sampleDescriptionIndex = sampleDescriptionIndex; - err = MP4AddListEntry( p, self->entryList ); if (err) goto bail; - } + stscEntryPtr p; + stscEntryPtr last; + MP4Err err; + u32 entryCount; + u8 addnew; + + err = MP4NoErr; + + entryCount = getEntryCount(self); + addnew = 1; + + if(entryCount > 0) + { + err = MP4GetListEntry(self->entryList, entryCount - 1, (char **)&last); + if(err) goto bail; + if((last->samplesPerChunk == sampleCount) && + (last->sampleDescriptionIndex == sampleDescriptionIndex)) + addnew = 0; + } + + if(addnew) + { + p = (stscEntryPtr)calloc(1, sizeof(stscEntry)); + TESTMALLOC(p); + p->firstChunk = firstChunkNumber; + p->samplesPerChunk = sampleCount; + p->sampleDescriptionIndex = sampleDescriptionIndex; + err = MP4AddListEntry(p, self->entryList); + if(err) goto bail; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err mdatMoved( struct MP4SampleToChunkAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset, - struct MP4SampleDescriptionAtom *stsd, - struct MP4DataReferenceAtom *dref, struct MP4ChunkOffsetAtom *stco ) +static MP4Err mdatMoved(struct MP4SampleToChunkAtom *self, u64 mdatBase, u64 mdatEnd, + s32 mdatOffset, struct MP4SampleDescriptionAtom *stsd, + struct MP4DataReferenceAtom *dref, struct MP4ChunkOffsetAtom *stco) { - MP4Err err; - u32 i; - u32 entryCount; - u32 savedDescIndex; - u32 savedRefIndex; - u32 savedSelfContained; - u32 chunkCount; - - err = MP4NoErr; - savedDescIndex = 0; - savedRefIndex = 0; - savedSelfContained = 0; - entryCount = getEntryCount( self ); - /* if ( stco->offsets == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); */ - /* if ( entryCount != stco->entryCount ) - BAILWITHERROR( MP4InvalidMediaErr ); - */ - chunkCount = stco->entryCount; - for ( i = 0; i < entryCount; i++ ) - { - stscEntryPtr p; - u32 chunks; - - err = MP4GetListEntry( self->entryList, i, (char**) &p ); if (err) goto bail; - if ( p->sampleDescriptionIndex != savedDescIndex ) - { - GenericSampleEntryAtomPtr sampleEntry; - MP4DataEntryAtomPtr dataEntry; - /* get sample desc */ - savedDescIndex = p->sampleDescriptionIndex; - err = stsd->getEntry( stsd, p->sampleDescriptionIndex, &sampleEntry ); if (err) goto bail; - /* get data entry */ - savedRefIndex = sampleEntry->dataReferenceIndex; - err = dref->getEntry( dref, savedRefIndex, &dataEntry ); if (err) goto bail; - /* mdat? */ - savedSelfContained = (dataEntry->flags & 1); - } - if ( savedSelfContained ) - { - /* find the chunk numbers and add the offset */ - if (i == (entryCount - 1)) - chunks = chunkCount + 1 - p->firstChunk; - else { - stscEntryPtr q; - err = MP4GetListEntry( self->entryList, i+1, (char**) &q ); if (err) goto bail; - chunks = q->firstChunk - p->firstChunk; - } - /* this is wrong; the stco pointer may be a 64-bit offset co64 - for (j=p->firstChunk-1; j<(p->firstChunk+chunks-1); j++) { - if ((stco->offsets[j] >= mdatBase) && (stco->offsets[j] < mdatEnd)) - stco->offsets[j] += mdatOffset; - } - */ - err = stco->mdatMoved( stco, p->firstChunk, p->firstChunk+chunks-1, mdatBase, mdatEnd, mdatOffset ); - if (err) goto bail; - } - /* if (( savedSelfContained ) && (stco->offsets[i] >= mdatBase) && (stco->offsets[i] < mdatEnd)) - stco->offsets[i] += mdatOffset; */ - } + MP4Err err; + u32 i; + u32 entryCount; + u32 savedDescIndex; + u32 savedRefIndex; + u32 savedSelfContained; + u32 chunkCount; + + err = MP4NoErr; + savedDescIndex = 0; + savedRefIndex = 0; + savedSelfContained = 0; + entryCount = getEntryCount(self); + /* if ( stco->offsets == NULL ) + BAILWITHERROR( MP4InvalidMediaErr ); */ + /* if ( entryCount != stco->entryCount ) + BAILWITHERROR( MP4InvalidMediaErr ); + */ + chunkCount = stco->entryCount; + for(i = 0; i < entryCount; i++) + { + stscEntryPtr p; + u32 chunks; + + err = MP4GetListEntry(self->entryList, i, (char **)&p); + if(err) goto bail; + if(p->sampleDescriptionIndex != savedDescIndex) + { + GenericSampleEntryAtomPtr sampleEntry; + MP4DataEntryAtomPtr dataEntry; + /* get sample desc */ + savedDescIndex = p->sampleDescriptionIndex; + err = stsd->getEntry(stsd, p->sampleDescriptionIndex, &sampleEntry); + if(err) goto bail; + /* get data entry */ + savedRefIndex = sampleEntry->dataReferenceIndex; + err = dref->getEntry(dref, savedRefIndex, &dataEntry); + if(err) goto bail; + /* mdat? */ + savedSelfContained = (dataEntry->flags & 1); + } + if(savedSelfContained) + { + /* find the chunk numbers and add the offset */ + if(i == (entryCount - 1)) chunks = chunkCount + 1 - p->firstChunk; + else + { + stscEntryPtr q; + err = MP4GetListEntry(self->entryList, i + 1, (char **)&q); + if(err) goto bail; + chunks = q->firstChunk - p->firstChunk; + } + /* this is wrong; the stco pointer may be a 64-bit offset co64 + for (j=p->firstChunk-1; j<(p->firstChunk+chunks-1); j++) { + if ((stco->offsets[j] >= mdatBase) && (stco->offsets[j] < mdatEnd)) + stco->offsets[j] += mdatOffset; + } + */ + err = stco->mdatMoved(stco, p->firstChunk, p->firstChunk + chunks - 1, mdatBase, mdatEnd, + mdatOffset); + if(err) goto bail; + } + /* if (( savedSelfContained ) && (stco->offsets[i] >= mdatBase) && (stco->offsets[i] < mdatEnd)) + stco->offsets[i] += mdatOffset; */ + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } - -static MP4Err lookupSample( MP4AtomPtr s, u32 sampleNumber, - u32 *outChunkNumber, u32 *outSampleDescriptionIndex, - u32 *outFirstSampleNumberInChunk ) +static MP4Err lookupSample(MP4AtomPtr s, u32 sampleNumber, u32 *outChunkNumber, + u32 *outSampleDescriptionIndex, u32 *outFirstSampleNumberInChunk) { - MP4Err err; - u32 i; - u32 entryCount; - stscEntryPtr p; - u32 firstChunkInRun; - u32 firstSampleThisChunkRun; - - MP4SampleToChunkAtomPtr self = (MP4SampleToChunkAtomPtr) s; - if ( (self == NULL) || (sampleNumber == 0) || (outChunkNumber == NULL) ) - BAILWITHERROR( MP4BadParamErr ) - - err = MP4NoErr; - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - if ( self->foundEntryFirstSampleNumber && (self->foundEntryFirstSampleNumber < sampleNumber) ) - { - firstSampleThisChunkRun = self->foundEntryFirstSampleNumber; - i = self->foundEntryNumber; - } - else - { - firstSampleThisChunkRun = 1; - i = 0; - } - - *outChunkNumber = 0; - *outSampleDescriptionIndex = 0; - for ( ; i < entryCount; i++ ) - { - err = MP4GetListEntry( self->entryList, i, (char**) &p ); if (err) goto bail; - firstChunkInRun = p->firstChunk; - if ( i == entryCount - 1 ) - { - /* the last run -- calculate based on spc */ - u32 sampleOffsetInThisChunk; - sampleOffsetInThisChunk = (sampleNumber - firstSampleThisChunkRun); - *outChunkNumber = firstChunkInRun + (sampleOffsetInThisChunk / p->samplesPerChunk); - *outSampleDescriptionIndex = p->sampleDescriptionIndex; - *outFirstSampleNumberInChunk = ((*outChunkNumber - firstChunkInRun) * p->samplesPerChunk) + firstSampleThisChunkRun; - self->foundEntryNumber = i; - } - else - { - u32 nextChunk; - u32 samplesThisChunkRun; - stscEntryPtr nextEntryP; - err = MP4GetListEntry( self->entryList, i + 1, (char**) &nextEntryP ); if (err) goto bail; - nextChunk = nextEntryP->firstChunk; - samplesThisChunkRun = (nextChunk - firstChunkInRun) * p->samplesPerChunk; - if ( sampleNumber <= (firstSampleThisChunkRun + samplesThisChunkRun) ) - { - u32 sampleOffsetInThisChunk; - sampleOffsetInThisChunk = (sampleNumber - firstSampleThisChunkRun); - *outChunkNumber = firstChunkInRun + (sampleOffsetInThisChunk / p->samplesPerChunk); - *outSampleDescriptionIndex = p->sampleDescriptionIndex; - *outFirstSampleNumberInChunk = ((*outChunkNumber - firstChunkInRun) * p->samplesPerChunk) + firstSampleThisChunkRun; - self->foundEntryNumber = i; - break; - } - else - { - firstSampleThisChunkRun += samplesThisChunkRun; - } - } - } - self->foundEntryFirstSampleNumber = firstSampleThisChunkRun; + MP4Err err; + u32 i; + u32 entryCount; + stscEntryPtr p; + u32 firstChunkInRun; + u32 firstSampleThisChunkRun; + + MP4SampleToChunkAtomPtr self = (MP4SampleToChunkAtomPtr)s; + if((self == NULL) || (sampleNumber == 0) || (outChunkNumber == NULL)) + BAILWITHERROR(MP4BadParamErr) + + err = MP4NoErr; + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + if(self->foundEntryFirstSampleNumber && (self->foundEntryFirstSampleNumber < sampleNumber)) + { + firstSampleThisChunkRun = self->foundEntryFirstSampleNumber; + i = self->foundEntryNumber; + } + else + { + firstSampleThisChunkRun = 1; + i = 0; + } + + *outChunkNumber = 0; + *outSampleDescriptionIndex = 0; + for(; i < entryCount; i++) + { + err = MP4GetListEntry(self->entryList, i, (char **)&p); + if(err) goto bail; + firstChunkInRun = p->firstChunk; + if(i == entryCount - 1) + { + /* the last run -- calculate based on spc */ + u32 sampleOffsetInThisChunk; + sampleOffsetInThisChunk = (sampleNumber - firstSampleThisChunkRun); + *outChunkNumber = firstChunkInRun + (sampleOffsetInThisChunk / p->samplesPerChunk); + *outSampleDescriptionIndex = p->sampleDescriptionIndex; + *outFirstSampleNumberInChunk = + ((*outChunkNumber - firstChunkInRun) * p->samplesPerChunk) + firstSampleThisChunkRun; + self->foundEntryNumber = i; + } + else + { + u32 nextChunk; + u32 samplesThisChunkRun; + stscEntryPtr nextEntryP; + err = MP4GetListEntry(self->entryList, i + 1, (char **)&nextEntryP); + if(err) goto bail; + nextChunk = nextEntryP->firstChunk; + samplesThisChunkRun = (nextChunk - firstChunkInRun) * p->samplesPerChunk; + if(sampleNumber <= (firstSampleThisChunkRun + samplesThisChunkRun)) + { + u32 sampleOffsetInThisChunk; + sampleOffsetInThisChunk = (sampleNumber - firstSampleThisChunkRun); + *outChunkNumber = firstChunkInRun + (sampleOffsetInThisChunk / p->samplesPerChunk); + *outSampleDescriptionIndex = p->sampleDescriptionIndex; + *outFirstSampleNumberInChunk = + ((*outChunkNumber - firstChunkInRun) * p->samplesPerChunk) + firstSampleThisChunkRun; + self->foundEntryNumber = i; + break; + } + else + { + firstSampleThisChunkRun += samplesThisChunkRun; + } + } + } + self->foundEntryFirstSampleNumber = firstSampleThisChunkRun; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - u32 entryCount; - MP4SampleToChunkAtomPtr self = (MP4SampleToChunkAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - entryCount = getEntryCount( self ); - PUT32_V( entryCount ); - for ( i = 0; i < entryCount; i++ ) - { - stscEntryPtr p; - err = MP4GetListEntry( self->entryList, i, (char**) &p ); if (err) goto bail; - PUT32_V( p->firstChunk ); - PUT32_V( p->samplesPerChunk ); - PUT32_V( p->sampleDescriptionIndex ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + u32 entryCount; + MP4SampleToChunkAtomPtr self = (MP4SampleToChunkAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + entryCount = getEntryCount(self); + PUT32_V(entryCount); + for(i = 0; i < entryCount; i++) + { + stscEntryPtr p; + err = MP4GetListEntry(self->entryList, i, (char **)&p); + if(err) goto bail; + PUT32_V(p->firstChunk); + PUT32_V(p->samplesPerChunk); + PUT32_V(p->sampleDescriptionIndex); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SampleToChunkAtomPtr self = (MP4SampleToChunkAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4 + (12 * getEntryCount(self)); + MP4Err err; + MP4SampleToChunkAtomPtr self = (MP4SampleToChunkAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4 + (12 * getEntryCount(self)); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i; - u32 entryCount; - MP4SampleToChunkAtomPtr self = (MP4SampleToChunkAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32_V( entryCount ); - - for ( i = 0; i < entryCount; i++ ) - { - u32 firstChunk; - u32 samplesPerChunk; - u32 sampleDescriptionIndex; - - GET32_V( firstChunk ); - GET32_V( samplesPerChunk ); - GET32_V( sampleDescriptionIndex ); - err = setEntry( self, firstChunk, samplesPerChunk, sampleDescriptionIndex ); if (err) goto bail; - } + MP4Err err; + u32 i; + u32 entryCount; + MP4SampleToChunkAtomPtr self = (MP4SampleToChunkAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32_V(entryCount); + + for(i = 0; i < entryCount; i++) + { + u32 firstChunk; + u32 samplesPerChunk; + u32 sampleDescriptionIndex; + + GET32_V(firstChunk); + GET32_V(samplesPerChunk); + GET32_V(sampleDescriptionIndex); + err = setEntry(self, firstChunk, samplesPerChunk, sampleDescriptionIndex); + if(err) goto bail; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSampleToChunkAtom( MP4SampleToChunkAtomPtr *outAtom ) +MP4Err MP4CreateSampleToChunkAtom(MP4SampleToChunkAtomPtr *outAtom) { - MP4Err err; - MP4SampleToChunkAtomPtr self; - - self = (MP4SampleToChunkAtomPtr) calloc( 1, sizeof(MP4SampleToChunkAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - err = MP4MakeLinkedList( &self->entryList ); if (err) goto bail; - self->type = MP4SampleToChunkAtomType; - self->name = "sample to chunk"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->lookupSample = lookupSample; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->setEntry = setEntry; - self->getEntryCount = getEntryCount; - self->mdatMoved = mdatMoved; - *outAtom = self; + MP4Err err; + MP4SampleToChunkAtomPtr self; + + self = (MP4SampleToChunkAtomPtr)calloc(1, sizeof(MP4SampleToChunkAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + err = MP4MakeLinkedList(&self->entryList); + if(err) goto bail; + self->type = MP4SampleToChunkAtomType; + self->name = "sample to chunk"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->lookupSample = lookupSample; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->setEntry = setEntry; + self->getEntryCount = getEntryCount; + self->mdatMoved = mdatMoved; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SampleToGroupAtom.c b/IsoLib/libisomediafile/src/SampleToGroupAtom.c index 85b5c59..432f002 100644 --- a/IsoLib/libisomediafile/src/SampleToGroupAtom.c +++ b/IsoLib/libisomediafile/src/SampleToGroupAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -27,243 +27,266 @@ derivative works. Copyright (c) 1999. #define allocation_size 8192 -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SampletoGroupAtomPtr self; - err = MP4NoErr; - self = (MP4SampletoGroupAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->group_index != NULL ) - { - free( self->group_index ); - self->group_index = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4SampletoGroupAtomPtr self; + err = MP4NoErr; + self = (MP4SampletoGroupAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->group_index != NULL) + { + free(self->group_index); + self->group_index = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err ensureSize( struct MP4SampletoGroupAtom *self, u32 newSize ) +static MP4Err ensureSize(struct MP4SampletoGroupAtom *self, u32 newSize) { - MP4Err err; - - err = MP4NoErr; - - if (newSize > self->allocatedSize) { - self->allocatedSize += allocation_size; - if (newSize > self->allocatedSize) self->allocatedSize = newSize; - - if (self->group_index != NULL) - self->group_index = (u32*) realloc( self->group_index, self->allocatedSize ); - else - self->group_index = (u32*) calloc( self->allocatedSize, 1 ); - - TESTMALLOC( self->group_index ); - } + MP4Err err; + + err = MP4NoErr; + + if(newSize > self->allocatedSize) + { + self->allocatedSize += allocation_size; + if(newSize > self->allocatedSize) self->allocatedSize = newSize; + + if(self->group_index != NULL) + self->group_index = (u32 *)realloc(self->group_index, self->allocatedSize); + else + self->group_index = (u32 *)calloc(self->allocatedSize, 1); + + TESTMALLOC(self->group_index); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSamples( struct MP4SampletoGroupAtom *self, u32 count ) +static MP4Err addSamples(struct MP4SampletoGroupAtom *self, u32 count) { - MP4Err err; - u32 *p; - u32 j; - - err = MP4NoErr; - err = ensureSize( self, (self->sampleCount + count)*sizeof(u32) ); if (err) goto bail; - - p = &((self->group_index)[self->sampleCount]); - for (j=0; jsampleCount += count; + MP4Err err; + u32 *p; + u32 j; + + err = MP4NoErr; + err = ensureSize(self, (self->sampleCount + count) * sizeof(u32)); + if(err) goto bail; + + p = &((self->group_index)[self->sampleCount]); + for(j = 0; j < count; j++) + *p++ = 0; + self->sampleCount += count; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err mapSamplestoGroup( struct MP4SampletoGroupAtom *self, u32 group_index, s32 sample_index, u32 count ) +static MP4Err mapSamplestoGroup(struct MP4SampletoGroupAtom *self, u32 group_index, + s32 sample_index, u32 count) { - MP4Err err; - u32 i; - u32* p; - - err = MP4NoErr; - - if (sample_index<0) { - p = &((self->group_index)[self->sampleCount + sample_index]); - if (count > ((u32) (- sample_index))) { err = MP4BadParamErr; goto bail; } - } - else { - p = &((self->group_index)[sample_index]); - if (count+sample_index > self->sampleCount) { err = MP4BadParamErr; goto bail; } - } - for (i=0; igroup_index)[self->sampleCount + sample_index]); + if(count > ((u32)(-sample_index))) + { + err = MP4BadParamErr; + goto bail; + } + } + else + { + p = &((self->group_index)[sample_index]); + if(count + sample_index > self->sampleCount) + { + err = MP4BadParamErr; + goto bail; + } + } + for(i = 0; i < count; i++) + *p++ = group_index; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getSampleGroupMap( struct MP4SampletoGroupAtom *self, u32 sampleNumber, u32* groupIndex ) +static MP4Err getSampleGroupMap(struct MP4SampletoGroupAtom *self, u32 sampleNumber, + u32 *groupIndex) { - MP4Err err; - - err = MP4NoErr; - - if (sampleNumber<1) BAILWITHERROR( MP4BadParamErr ); - if (sampleNumber > self->sampleCount) - *groupIndex = 0; - else *groupIndex = (self->group_index)[sampleNumber - 1]; + MP4Err err; + + err = MP4NoErr; + + if(sampleNumber < 1) BAILWITHERROR(MP4BadParamErr); + if(sampleNumber > self->sampleCount) *groupIndex = 0; + else + *groupIndex = (self->group_index)[sampleNumber - 1]; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - u32 cur_index, cur_count, entryCount; - - MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( grouping_type ); - PUT32( entryCount ); - - cur_index = (self->group_index)[0]; - cur_count = 1; - entryCount = 0; - - for (i=1; isampleCount; i++) { - if ((self->group_index)[i-1] != (self->group_index)[i]) { - PUT32_V(cur_count); - PUT32_V(cur_index); - cur_count = 1; - cur_index = (self->group_index)[i]; - entryCount++; - } - else cur_count++; - } - PUT32_V(cur_count); - PUT32_V(cur_index); - entryCount++; - - assert( entryCount == self->entryCount ); - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + u32 cur_index, cur_count, entryCount; + + MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(grouping_type); + PUT32(entryCount); + + cur_index = (self->group_index)[0]; + cur_count = 1; + entryCount = 0; + + for(i = 1; i < self->sampleCount; i++) + { + if((self->group_index)[i - 1] != (self->group_index)[i]) + { + PUT32_V(cur_count); + PUT32_V(cur_index); + cur_count = 1; + cur_index = (self->group_index)[i]; + entryCount++; + } + else + cur_count++; + } + PUT32_V(cur_count); + PUT32_V(cur_index); + entryCount++; + + assert(entryCount == self->entryCount); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr) s; - u32 entryCount, i; - - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - - entryCount = 1; - - for (i=1; i<(self->sampleCount); i++) { - if ((self->group_index)[i-1] != (self->group_index)[i]) entryCount++; - } - self->size += (entryCount*8) + 8; - self->entryCount = entryCount; - + MP4Err err; + MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; + u32 entryCount, i; + + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + + entryCount = 1; + + for(i = 1; i < (self->sampleCount); i++) + { + if((self->group_index)[i - 1] != (self->group_index)[i]) entryCount++; + } + self->size += (entryCount * 8) + 8; + self->entryCount = entryCount; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i, j, size; - u32* p; - MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr) s; - char typeString[ 8 ]; - char msgString[ 80 ]; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( grouping_type ); - MP4TypeToString( self->grouping_type, typeString ); - sprintf( msgString, " grouping type is '%s'", typeString ); - inputStream->msg( inputStream, msgString ); - - GET32( entryCount ); - size = 0; - - for (i=0; ientryCount; i++) - { - u32 count, index; - GET32_V_MSG( count, NULL ); - GET32_V_MSG( index, NULL ); - sprintf( msgString, " entry %d, count %d index %d", i+1, count, index ); - inputStream->msg( inputStream, msgString ); - - err = ensureSize( self, (size + count)*sizeof(u32) ); if (err) goto bail; - - p = &((self->group_index)[size]); - for (j=0; jsampleCount = size; - + MP4Err err; + u32 i, j, size; + u32 *p; + MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; + char typeString[8]; + char msgString[80]; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(grouping_type); + MP4TypeToString(self->grouping_type, typeString); + sprintf(msgString, " grouping type is '%s'", typeString); + inputStream->msg(inputStream, msgString); + + GET32(entryCount); + size = 0; + + for(i = 0; i < self->entryCount; i++) + { + u32 count, index; + GET32_V_MSG(count, NULL); + GET32_V_MSG(index, NULL); + sprintf(msgString, " entry %d, count %d index %d", i + 1, count, index); + inputStream->msg(inputStream, msgString); + + err = ensureSize(self, (size + count) * sizeof(u32)); + if(err) goto bail; + + p = &((self->group_index)[size]); + for(j = 0; j < count; j++) + *p++ = index; + size += count; + } + self->sampleCount = size; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSampletoGroupAtom( MP4SampletoGroupAtomPtr *outAtom ) +MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom) { - MP4Err err; - MP4SampletoGroupAtomPtr self; - - self = (MP4SampletoGroupAtomPtr) calloc( 1, sizeof(MP4SampletoGroupAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4SampletoGroupAtomType; - self->name = "sample to group"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->mapSamplestoGroup = mapSamplestoGroup; - self->addSamples = addSamples; - self->getSampleGroupMap = getSampleGroupMap; - self->group_index = NULL; - self->sampleCount = 0; - - *outAtom = self; + MP4Err err; + MP4SampletoGroupAtomPtr self; + + self = (MP4SampletoGroupAtomPtr)calloc(1, sizeof(MP4SampletoGroupAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SampletoGroupAtomType; + self->name = "sample to group"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->mapSamplestoGroup = mapSamplestoGroup; + self->addSamples = addSamples; + self->getSampleGroupMap = getSampleGroupMap; + self->group_index = NULL; + self->sampleCount = 0; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SceneDescriptionMediaHeader.c b/IsoLib/libisomediafile/src/SceneDescriptionMediaHeader.c index ca11dcc..c0e337d 100644 --- a/IsoLib/libisomediafile/src/SceneDescriptionMediaHeader.c +++ b/IsoLib/libisomediafile/src/SceneDescriptionMediaHeader.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,95 +15,95 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SceneDescriptionMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SceneDescriptionMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4SceneDescriptionMediaHeaderAtomPtr self = (MP4SceneDescriptionMediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4SceneDescriptionMediaHeaderAtomPtr self = (MP4SceneDescriptionMediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - /*MP4SceneDescriptionMediaHeaderAtomPtr self = (MP4SceneDescriptionMediaHeaderAtomPtr) s;*/ - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; + MP4Err err; + /*MP4SceneDescriptionMediaHeaderAtomPtr self = (MP4SceneDescriptionMediaHeaderAtomPtr) s;*/ + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4SceneDescriptionMediaHeaderAtomPtr self = (MP4SceneDescriptionMediaHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; + MP4Err err; + MP4SceneDescriptionMediaHeaderAtomPtr self = (MP4SceneDescriptionMediaHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSceneDescriptionMediaHeaderAtom( MP4SceneDescriptionMediaHeaderAtomPtr *outAtom ) +MP4Err MP4CreateSceneDescriptionMediaHeaderAtom(MP4SceneDescriptionMediaHeaderAtomPtr *outAtom) { - MP4Err err; - MP4SceneDescriptionMediaHeaderAtomPtr self; - - self = (MP4SceneDescriptionMediaHeaderAtomPtr) calloc( 1, sizeof(MP4SceneDescriptionMediaHeaderAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4SceneDescriptionMediaHeaderAtomType; - self->name = "scene description media header"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4SceneDescriptionMediaHeaderAtomPtr self; + + self = + (MP4SceneDescriptionMediaHeaderAtomPtr)calloc(1, sizeof(MP4SceneDescriptionMediaHeaderAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SceneDescriptionMediaHeaderAtomType; + self->name = "scene description media header"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SchemeInfoAtom.c b/IsoLib/libisomediafile/src/SchemeInfoAtom.c index d1c5c26..5c0f344 100644 --- a/IsoLib/libisomediafile/src/SchemeInfoAtom.c +++ b/IsoLib/libisomediafile/src/SchemeInfoAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,96 +15,94 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4SchemeInfoAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MP4SchemeInfoAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" #include #include - - -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 i; - - MP4SchemeInfoAtomPtr self = (MP4SchemeInfoAtomPtr) s; - err = MP4NoErr; + MP4Err err; + u32 i; + + MP4SchemeInfoAtomPtr self = (MP4SchemeInfoAtomPtr)s; + err = MP4NoErr; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - DESTROY_ATOM_LIST + DESTROY_ATOM_LIST - if ( self->super ) - self->super->destroy( s ); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4SchemeInfoAtomPtr self = (MP4SchemeInfoAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( (MP4AtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - /* PUT32_V( 0 ); */ /* version/flags */ - - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4SchemeInfoAtomPtr self = (MP4SchemeInfoAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields((MP4AtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + /* PUT32_V( 0 ); */ /* version/flags */ + + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SchemeInfoAtomPtr self = (MP4SchemeInfoAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( (MP4AtomPtr) s ); if (err) goto bail; - - self->size+= 0; /* version/flags */ - - ADD_ATOM_LIST_SIZE( atomList ); + MP4Err err; + MP4SchemeInfoAtomPtr self = (MP4SchemeInfoAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)s); + if(err) goto bail; + + self->size += 0; /* version/flags */ + + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addAtom( MP4SchemeInfoAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4SchemeInfoAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; + MP4Err err; + err = MP4NoErr; + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - - PARSE_ATOM_LIST(MP4SchemeInfoAtom) - + + PARSE_ATOM_LIST(MP4SchemeInfoAtom) + #if 0 u32 junk; MP4Err err; \ @@ -128,44 +126,43 @@ static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStr } \ } \ if ( self->bytesRead != self->size ) \ - BAILWITHERROR( MP4BadDataErr ) \ - + BAILWITHERROR( MP4BadDataErr ) + #endif - assert( self->bytesRead == self->size ); + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSchemeInfoAtom( MP4SchemeInfoAtomPtr *outAtom ) +MP4Err MP4CreateSchemeInfoAtom(MP4SchemeInfoAtomPtr *outAtom) { - MP4Err err; - MP4SchemeInfoAtomPtr self; - - self = (MP4SchemeInfoAtomPtr) calloc( 1, sizeof(MP4SchemeInfoAtom) ); - TESTMALLOC( self ); + MP4Err err; + MP4SchemeInfoAtomPtr self; - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); if ( err ) goto bail; + self = (MP4SchemeInfoAtomPtr)calloc(1, sizeof(MP4SchemeInfoAtom)); + TESTMALLOC(self); - self->type = MP4SchemeInfoAtomType; - self->name = "SchemeInformationBox"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addAtom = addAtom; + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; - err = MP4MakeLinkedList(&self->atomList); if (err) goto bail; + self->type = MP4SchemeInfoAtomType; + self->name = "SchemeInformationBox"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addAtom = addAtom; - *outAtom = self; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - - - diff --git a/IsoLib/libisomediafile/src/SchemeTypeAtom.c b/IsoLib/libisomediafile/src/SchemeTypeAtom.c index f63106e..04240b5 100644 --- a/IsoLib/libisomediafile/src/SchemeTypeAtom.c +++ b/IsoLib/libisomediafile/src/SchemeTypeAtom.c @@ -23,7 +23,6 @@ * derivative works. */ - /** * @file SchemeTypeAtom.c * @author Ahmed Hamza @@ -31,141 +30,147 @@ * @brief Implements functions for reading and writing SchemeTypeAtom instances. */ - #include "MP4Atoms.h" #include #include - static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SchemeTypeAtomPtr self = (MP4SchemeTypeAtomPtr)s; - err = MP4NoErr; + MP4Err err; + MP4SchemeTypeAtomPtr self = (MP4SchemeTypeAtomPtr)s; + err = MP4NoErr; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - /* if there is a scheme_url field, free it */ - if (self->scheme_url) { - free(self->scheme_url); - self->scheme_url = NULL; - } + /* if there is a scheme_url field, free it */ + if(self->scheme_url) + { + free(self->scheme_url); + self->scheme_url = NULL; + } - if (self->super) - self->super->destroy(s); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize(struct MP4Atom* s, char* buffer) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4SchemeTypeAtomPtr self = (MP4SchemeTypeAtomPtr)s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); if (err) goto bail; - buffer += self->bytesWritten; - PUT32(scheme_type); - PUT32(scheme_version); - if ((self->flags & 1) == 1) - { - u32 len = strlen(self->scheme_url) + 1; - PUTBYTES(self->scheme_url, len); - } - - assert(self->bytesWritten == self->size); + MP4Err err; + MP4SchemeTypeAtomPtr self = (MP4SchemeTypeAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(scheme_type); + PUT32(scheme_version); + if((self->flags & 1) == 1) + { + u32 len = strlen(self->scheme_url) + 1; + PUTBYTES(self->scheme_url, len); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize(struct MP4Atom* s) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SchemeTypeAtomPtr self = (MP4SchemeTypeAtomPtr)s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if (err) goto bail; - self->size += 8; /* 4 bytes (scheme_type) + 4 bytes (scheme_version) */ - if ((self->scheme_url) && (strlen(self->scheme_url) > 0)) - { - self->flags = 1; - self->size += 1 + strlen(self->scheme_url); /* strlen ignores \0 */ - } - else self->flags = 0; + MP4Err err; + MP4SchemeTypeAtomPtr self = (MP4SchemeTypeAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 8; /* 4 bytes (scheme_type) + 4 bytes (scheme_version) */ + if((self->scheme_url) && (strlen(self->scheme_url) > 0)) + { + self->flags = 1; + self->size += 1 + strlen(self->scheme_url); /* strlen ignores \0 */ + } + else + self->flags = 0; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - char debugstr[256]; - MP4SchemeTypeAtomPtr self = (MP4SchemeTypeAtomPtr)s; - - err = MP4NoErr; - if (self == NULL) BAILWITHERROR(MP4BadParamErr) - err = self->super->createFromInputStream(s, proto, (char*)inputStream); if (err) goto bail; - GET32(scheme_type); - GET32(scheme_version); - bytesToRead = self->size - self->bytesRead; - if (bytesToRead < 0) - BAILWITHERROR(MP4BadDataErr) - if (bytesToRead > 0) - { - if ((self->flags & 1) != 1) { err = MP4BadDataErr; goto bail; } - self->scheme_url = (char*)calloc(1, bytesToRead); - if (self->scheme_url == NULL) - BAILWITHERROR(MP4NoMemoryErr) - GETBYTES(bytesToRead, scheme_url); - if (bytesToRead < 200) - { - sprintf(debugstr, "Scheme URL location is \"%s\"", self->scheme_url); - DEBUG_MSG(debugstr); - } - } - else - { - if ((self->flags & 1) != 0) { err = MP4BadDataErr; goto bail; } - } - - assert(self->bytesRead == self->size); + MP4Err err; + long bytesToRead; + char debugstr[256]; + MP4SchemeTypeAtomPtr self = (MP4SchemeTypeAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + GET32(scheme_type); + GET32(scheme_version); + bytesToRead = self->size - self->bytesRead; + if(bytesToRead < 0) BAILWITHERROR(MP4BadDataErr) + if(bytesToRead > 0) + { + if((self->flags & 1) != 1) + { + err = MP4BadDataErr; + goto bail; + } + self->scheme_url = (char *)calloc(1, bytesToRead); + if(self->scheme_url == NULL) BAILWITHERROR(MP4NoMemoryErr) + GETBYTES(bytesToRead, scheme_url); + if(bytesToRead < 200) + { + sprintf(debugstr, "Scheme URL location is \"%s\"", self->scheme_url); + DEBUG_MSG(debugstr); + } + } + else + { + if((self->flags & 1) != 0) + { + err = MP4BadDataErr; + goto bail; + } + } + + assert(self->bytesRead == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } MP4Err MP4CreateSchemeTypeAtom(MP4SchemeTypeAtomPtr *outAtom) { - MP4Err err; - MP4SchemeTypeAtomPtr self; - - self = (MP4SchemeTypeAtomPtr)calloc(1, sizeof(MP4SchemeTypeAtom)); - TESTMALLOC(self); - - err = MP4CreateFullAtom((MP4AtomPtr)self); - if (err) goto bail; - self->type = MP4SchemeTypeAtomType; - self->name = "SchemeTypeBox"; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4SchemeTypeAtomPtr self; + + self = (MP4SchemeTypeAtomPtr)calloc(1, sizeof(MP4SchemeTypeAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SchemeTypeAtomType; + self->name = "SchemeTypeBox"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - diff --git a/IsoLib/libisomediafile/src/SecurityInfoAtom.c b/IsoLib/libisomediafile/src/SecurityInfoAtom.c index 602f837..51b0d4f 100644 --- a/IsoLib/libisomediafile/src/SecurityInfoAtom.c +++ b/IsoLib/libisomediafile/src/SecurityInfoAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SecurityInfoAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: SecurityInfoAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -30,110 +30,109 @@ derivative works. Copyright (c) 1999. #ifdef ISMACrypt -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - - MP4SecurityInfoAtomPtr self = (MP4SecurityInfoAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->MP4OriginalFormat ) - { - self->MP4OriginalFormat->destroy( self->MP4OriginalFormat ); - self->MP4OriginalFormat = NULL; - } - if ( self->MP4SchemeType ) - { - self->MP4SchemeType->destroy( self->MP4SchemeType ); - self->MP4SchemeType = NULL; - } - if ( self->MP4SchemeInfo ) - { - self->MP4SchemeInfo->destroy( self->MP4SchemeInfo ); - self->MP4SchemeInfo = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + + MP4SecurityInfoAtomPtr self = (MP4SecurityInfoAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->MP4OriginalFormat) + { + self->MP4OriginalFormat->destroy(self->MP4OriginalFormat); + self->MP4OriginalFormat = NULL; + } + if(self->MP4SchemeType) + { + self->MP4SchemeType->destroy(self->MP4SchemeType); + self->MP4SchemeType = NULL; + } + if(self->MP4SchemeInfo) + { + self->MP4SchemeInfo->destroy(self->MP4SchemeInfo); + self->MP4SchemeInfo = NULL; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4SecurityInfoAtomPtr self = (MP4SecurityInfoAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - /* PUT32_V( 0 ); */ /* version/flags */ - - SERIALIZE_ATOM( MP4OriginalFormat ); - SERIALIZE_ATOM( MP4SchemeType ); - SERIALIZE_ATOM( MP4SchemeInfo ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4SecurityInfoAtomPtr self = (MP4SecurityInfoAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + /* PUT32_V( 0 ); */ /* version/flags */ + + SERIALIZE_ATOM(MP4OriginalFormat); + SERIALIZE_ATOM(MP4SchemeType); + SERIALIZE_ATOM(MP4SchemeInfo); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SecurityInfoAtomPtr self = (MP4SecurityInfoAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 0; /* version/flags */ - ADD_ATOM_SIZE( MP4OriginalFormat ); - ADD_ATOM_SIZE( MP4SchemeType ); - ADD_ATOM_SIZE( MP4SchemeInfo ); + MP4Err err; + MP4SecurityInfoAtomPtr self = (MP4SecurityInfoAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 0; /* version/flags */ + ADD_ATOM_SIZE(MP4OriginalFormat); + ADD_ATOM_SIZE(MP4SchemeType); + ADD_ATOM_SIZE(MP4SchemeInfo); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -#define ADDCASE( atomName ) \ - case atomName ## AtomType: \ - if ( self->atomName ) \ - BAILWITHERROR( MP4BadDataErr ) \ - self->atomName = atom; \ - break +#define ADDCASE(atomName) \ + case atomName##AtomType: \ + if(self->atomName) BAILWITHERROR(MP4BadDataErr) \ + self->atomName = atom; \ + break -static MP4Err addAtom( MP4SecurityInfoAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4SecurityInfoAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - switch( atom->type ) - { - ADDCASE( MP4OriginalFormat ); - ADDCASE( MP4SchemeType ); - ADDCASE( MP4SchemeInfo ); - /* todo: this default is wrong; we should be tolerant and accept unknown atoms */ - default: - err = MP4InvalidMediaErr; - goto bail; - break; - } + MP4Err err; + err = MP4NoErr; + switch(atom->type) + { + ADDCASE(MP4OriginalFormat); + ADDCASE(MP4SchemeType); + ADDCASE(MP4SchemeInfo); + /* todo: this default is wrong; we should be tolerant and accept unknown atoms */ + default: + err = MP4InvalidMediaErr; + goto bail; + break; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - - PARSE_ATOM_LIST(MP4SecurityInfoAtom) + + PARSE_ATOM_LIST(MP4SecurityInfoAtom) #if 0 MP4Err err; \ @@ -158,41 +157,39 @@ static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStr } \ } \ if ( self->bytesRead != self->size ) \ - BAILWITHERROR( MP4BadDataErr ) \ - + BAILWITHERROR( MP4BadDataErr ) + #endif - bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSecurityInfoAtom( MP4SecurityInfoAtomPtr *outAtom ) +MP4Err MP4CreateSecurityInfoAtom(MP4SecurityInfoAtomPtr *outAtom) { - MP4Err err; - MP4SecurityInfoAtomPtr self; - - self = (MP4SecurityInfoAtomPtr) calloc( 1, sizeof(MP4SecurityInfoAtom) ); - TESTMALLOC( self ); + MP4Err err; + MP4SecurityInfoAtomPtr self; + + self = (MP4SecurityInfoAtomPtr)calloc(1, sizeof(MP4SecurityInfoAtom)); + TESTMALLOC(self); - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4SecurityInfoAtomType; - self->name = "SecurityInfo"; + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SecurityInfoAtomType; + self->name = "SecurityInfo"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; - *outAtom = self; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } #endif - diff --git a/IsoLib/libisomediafile/src/SecuritySchemeAtom.c b/IsoLib/libisomediafile/src/SecuritySchemeAtom.c index 8b39d07..8e8c879 100644 --- a/IsoLib/libisomediafile/src/SecuritySchemeAtom.c +++ b/IsoLib/libisomediafile/src/SecuritySchemeAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SecuritySchemeAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: SecuritySchemeAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ /* @@ -33,133 +33,129 @@ derivative works. Copyright (c) 1999. static void destroy( MP4AtomPtr s ) { - MP4Err err; - MP4SecuritySchemeAtomPtr self = (MP4SecuritySchemeAtomPtr) s; + MP4Err err; + MP4SecuritySchemeAtomPtr self = (MP4SecuritySchemeAtomPtr) s; err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->scheme_url ) { - free( self->scheme_url ); - self->scheme_url = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + if ( self == NULL ) + BAILWITHERROR( MP4BadParamErr ) + + if ( self->scheme_url ) { + free( self->scheme_url ); + self->scheme_url = NULL; + } + + if ( self->super ) + self->super->destroy( s ); bail: - TEST_RETURN( err ); + TEST_RETURN( err ); - return; + return; } static MP4Err serialize( struct MP4Atom* s, char* buffer ) { - MP4Err err; - MP4SecuritySchemeAtomPtr self = (MP4SecuritySchemeAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; + MP4Err err; + MP4SecuritySchemeAtomPtr self = (MP4SecuritySchemeAtomPtr) s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; buffer += self->bytesWritten; - PUT32( scheme_type ); - PUT32( scheme_version ); + PUT32( scheme_type ); + PUT32( scheme_version ); if ( (self->flags & 1) == 1 ) - { - u32 len = strlen( self->scheme_url ) + 1; - PUTBYTES( self->scheme_url, len ); - } + { + u32 len = strlen( self->scheme_url ) + 1; + PUTBYTES( self->scheme_url, len ); + } - assert( self->bytesWritten == self->size ); + assert( self->bytesWritten == self->size ); bail: - TEST_RETURN( err ); + TEST_RETURN( err ); - return err; + return err; } static MP4Err calculateSize( struct MP4Atom* s ) { - MP4Err err; - MP4SecuritySchemeAtomPtr self = (MP4SecuritySchemeAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 8; - if (( self->scheme_url ) && (strlen( self->scheme_url ) > 0)) - { - self->flags = 1; - self->size += 1 + strlen( self->scheme_url ); - } - else self->flags = 0; + MP4Err err; + MP4SecuritySchemeAtomPtr self = (MP4SecuritySchemeAtomPtr) s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; + self->size += 8; + if (( self->scheme_url ) && (strlen( self->scheme_url ) > 0)) + { + self->flags = 1; + self->size += 1 + strlen( self->scheme_url ); + } + else self->flags = 0; bail: - TEST_RETURN( err ); + TEST_RETURN( err ); - return err; + return err; } static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) { - MP4Err err; - long bytesToRead; - char debugstr[ 256 ]; - MP4SecuritySchemeAtomPtr self = (MP4SecuritySchemeAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - GET32( scheme_type ); - GET32( scheme_version ); - bytesToRead = self->size - self->bytesRead; - if ( bytesToRead < 0 ) - BAILWITHERROR( MP4BadDataErr ) - if ( bytesToRead > 0 ) - { - if ((self->flags & 1) != 1) { err = MP4BadDataErr; goto bail; } - self->scheme_url = (char*) calloc( 1, bytesToRead ); - if ( self->scheme_url == NULL ) - BAILWITHERROR( MP4NoMemoryErr ) - GETBYTES( bytesToRead, scheme_url ); - if ( bytesToRead < 200 ) - { - sprintf( debugstr, "Scheme URL location is \"%s\"", self->scheme_url ); - DEBUG_MSG( debugstr ); - } - } - else - { - if ((self->flags & 1) != 0) { err = MP4BadDataErr; goto bail; } - } - - assert( self->bytesRead == self->size ); - + MP4Err err; + long bytesToRead; + char debugstr[ 256 ]; + MP4SecuritySchemeAtomPtr self = (MP4SecuritySchemeAtomPtr) s; + + err = MP4NoErr; + if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) + err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto +bail; GET32( scheme_type ); GET32( scheme_version ); bytesToRead = self->size - self->bytesRead; if +( bytesToRead < 0 ) BAILWITHERROR( MP4BadDataErr ) if ( bytesToRead > 0 ) + { + if ((self->flags & 1) != 1) { err = MP4BadDataErr; goto bail; } + self->scheme_url = (char*) calloc( 1, bytesToRead ); + if ( self->scheme_url == NULL ) + BAILWITHERROR( MP4NoMemoryErr ) + GETBYTES( bytesToRead, scheme_url ); + if ( bytesToRead < 200 ) + { + sprintf( debugstr, "Scheme URL location is \"%s\"", self->scheme_url ); + DEBUG_MSG( debugstr ); + } + } + else + { + if ((self->flags & 1) != 0) { err = MP4BadDataErr; goto bail; } + } + + assert( self->bytesRead == self->size ); + bail: - TEST_RETURN( err ); + TEST_RETURN( err ); - return err; + return err; } MP4Err MP4CreateSecuritySchemeAtom( MP4SecuritySchemeAtomPtr *outAtom ) { - MP4Err err; - MP4SecuritySchemeAtomPtr self; - - self = (MP4SecuritySchemeAtomPtr) calloc( 1, sizeof(MP4SecuritySchemeAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4SchemeTypeAtomType; - self->name = "SecurityScheme"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4SecuritySchemeAtomPtr self; + + self = (MP4SecuritySchemeAtomPtr) calloc( 1, sizeof(MP4SecuritySchemeAtom) ); + TESTMALLOC( self ); + + err = MP4CreateFullAtom( (MP4AtomPtr) self ); + if ( err ) goto bail; + self->type = MP4SchemeTypeAtomType; + self->name = "SecurityScheme"; + self->createFromInputStream = (cisfunc) createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN( err ); - return err; + return err; } #endif diff --git a/IsoLib/libisomediafile/src/SegmentIndexAtom.c b/IsoLib/libisomediafile/src/SegmentIndexAtom.c index 62a9281..93b5dcb 100644 --- a/IsoLib/libisomediafile/src/SegmentIndexAtom.c +++ b/IsoLib/libisomediafile/src/SegmentIndexAtom.c @@ -1,274 +1,269 @@ /* -*This software module was originally developed by InterDigital, Inc. -* in the course of development of MPEG-4. -* This software module is an implementation of a part of one or -* more MPEG-4 tools as specified by MPEG-4. -* ISO/IEC gives users of MPEG-4 free license to this -* software module or modifications thereof for use in hardware -* or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. -* Those intending to use this software module in hardware or software -* products are advised that its use may infringe existing patents. -* The original developer of this software module and his/her company, -* the subsequent editors and their companies, and ISO/IEC have no -* liability for use of this software module or modifications thereof -* in an implementation. -* -* Copyright is not released for non MPEG-4 conforming -* products. InterDigital, Inc. retains full right to use the code for its own -* purpose, assign or donate the code to a third party and to -* inhibit third parties from using the code for non -* MPEG-4 conforming products. -* -* This copyright notice must be included in all copies or -* derivative works. -*/ + *This software module was originally developed by InterDigital, Inc. + * in the course of development of MPEG-4. + * This software module is an implementation of a part of one or + * more MPEG-4 tools as specified by MPEG-4. + * ISO/IEC gives users of MPEG-4 free license to this + * software module or modifications thereof for use in hardware + * or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. + * Those intending to use this software module in hardware or software + * products are advised that its use may infringe existing patents. + * The original developer of this software module and his/her company, + * the subsequent editors and their companies, and ISO/IEC have no + * liability for use of this software module or modifications thereof + * in an implementation. + * + * Copyright is not released for non MPEG-4 conforming + * products. InterDigital, Inc. retains full right to use the code for its own + * purpose, assign or donate the code to a third party and to + * inhibit third parties from using the code for non + * MPEG-4 conforming products. + * + * This copyright notice must be included in all copies or + * derivative works. + */ /** -* @file SegmentIndexAtom.c -* @author Ahmed Hamza -* @date April 19, 2018 -* @brief Implements functions for reading and writing SegmentIndexAtom instances. -*/ - + * @file SegmentIndexAtom.c + * @author Ahmed Hamza + * @date April 19, 2018 + * @brief Implements functions for reading and writing SegmentIndexAtom instances. + */ #include "MP4Atoms.h" #include - static u32 getReferenceCount(struct MP4SegmentIndexAtom *self) { - u32 referenceCount = 0; - MP4GetListEntryCount(self->referencesList, &referenceCount); - return referenceCount; + u32 referenceCount = 0; + MP4GetListEntryCount(self->referencesList, &referenceCount); + return referenceCount; } -static MP4Err addReference(struct MP4SegmentIndexAtom *self, - u8 referenceType, u32 referencedSize, - u32 subsegmentDuration, - u8 startsWithSAP, u8 SAPType, u32 SAPDeltaTime) +static MP4Err addReference(struct MP4SegmentIndexAtom *self, u8 referenceType, u32 referencedSize, + u32 subsegmentDuration, u8 startsWithSAP, u8 SAPType, u32 SAPDeltaTime) { - MP4Err err; + MP4Err err; - SIDXReferencePtr p; - SIDXReferencePtr last; + SIDXReferencePtr p; + SIDXReferencePtr last; - u32 referenceCount; - u8 addnew; + u32 referenceCount; + u8 addnew; - err = MP4NoErr; + err = MP4NoErr; - referenceCount = getReferenceCount(self); - addnew = 1; + referenceCount = getReferenceCount(self); + addnew = 1; - if (referenceCount > 0) - { - /* get last refernece */ - err = MP4GetListEntry(self->referencesList, referenceCount - 1, (char**)&last); if (err) goto bail; - } + if(referenceCount > 0) + { + /* get last refernece */ + err = MP4GetListEntry(self->referencesList, referenceCount - 1, (char **)&last); + if(err) goto bail; + } - if (addnew) { + if(addnew) + { - p = (SIDXReferencePtr)calloc(1, sizeof(SIDXReference)); - TESTMALLOC(p); + p = (SIDXReferencePtr)calloc(1, sizeof(SIDXReference)); + TESTMALLOC(p); - p->referenceType = referenceType; - p->referencedSize = referencedSize; - p->subsegmentDuration = subsegmentDuration; - p->startsWithSAP = startsWithSAP; - p->SAPType = SAPType; - p->SAPDeltaTime = SAPDeltaTime; + p->referenceType = referenceType; + p->referencedSize = referencedSize; + p->subsegmentDuration = subsegmentDuration; + p->startsWithSAP = startsWithSAP; + p->SAPType = SAPType; + p->SAPDeltaTime = SAPDeltaTime; - /* add reference to linked list */ - err = MP4AddListEntry(p, self->referencesList); if (err) goto bail; - } + /* add reference to linked list */ + err = MP4AddListEntry(p, self->referencesList); + if(err) goto bail; + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 referenceCount; - MP4SegmentIndexAtomPtr self; + MP4Err err; + u32 referenceCount; + MP4SegmentIndexAtomPtr self; - self = (MP4SegmentIndexAtomPtr)s; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + self = (MP4SegmentIndexAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - referenceCount = getReferenceCount(self); + referenceCount = getReferenceCount(self); - if (referenceCount) + if(referenceCount) + { + u32 i; + for(i = 0; i < referenceCount; i++) { - u32 i; - for (i = 0; i < referenceCount; i++) - { - char *p; - err = MP4GetListEntry(self->referencesList, i, &p); if (err) goto bail; - if (p) { - free(p); - } - } + char *p; + err = MP4GetListEntry(self->referencesList, i, &p); + if(err) goto bail; + if(p) + { + free(p); + } } + } - MP4DeleteLinkedList(self->referencesList); + MP4DeleteLinkedList(self->referencesList); - if (self->super) - self->super->destroy(s); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return; + return; } - -static MP4Err serialize(struct MP4Atom* s, char* buffer) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - u32 tmp32; + MP4Err err; + u32 i; + u32 tmp32; - MP4SegmentIndexAtomPtr self = (MP4SegmentIndexAtomPtr)s; - err = MP4NoErr; + MP4SegmentIndexAtomPtr self = (MP4SegmentIndexAtomPtr)s; + err = MP4NoErr; - err = MP4SerializeCommonFullAtomFields((MP4FullAtom*)s, buffer); if (err) goto bail; /* Full Atom */ - buffer += self->bytesWritten; + err = MP4SerializeCommonFullAtomFields((MP4FullAtom *)s, buffer); + if(err) goto bail; /* Full Atom */ + buffer += self->bytesWritten; - PUT32(referenceId); - PUT32(timescale); + PUT32(referenceId); + PUT32(timescale); - PUT32(earliestPresentationTime); - PUT32(firstOffset); + PUT32(earliestPresentationTime); + PUT32(firstOffset); - PUT16(reserved1); - PUT16(referenceCount); + PUT16(reserved1); + PUT16(referenceCount); - for (i = 0; i < self->referenceCount; i++) { + for(i = 0; i < self->referenceCount; i++) + { - SIDXReferencePtr reference; - err = MP4GetListEntry(self->referencesList, i, (char**)&reference); - if (err) goto bail; + SIDXReferencePtr reference; + err = MP4GetListEntry(self->referencesList, i, (char **)&reference); + if(err) goto bail; - tmp32 = (reference->referenceType << 31) | (reference->referencedSize); - PUT32_V(tmp32); + tmp32 = (reference->referenceType << 31) | (reference->referencedSize); + PUT32_V(tmp32); - PUT32_V(reference->subsegmentDuration); + PUT32_V(reference->subsegmentDuration); - tmp32 = (reference->startsWithSAP << 31) | (reference->SAPType << 28) | reference->SAPDeltaTime; - PUT32_V(tmp32); - - } + tmp32 = (reference->startsWithSAP << 31) | (reference->SAPType << 28) | reference->SAPDeltaTime; + PUT32_V(tmp32); + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err calculateSize(struct MP4Atom* s) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SegmentIndexAtomPtr self = (MP4SegmentIndexAtomPtr)s; - err = MP4NoErr; + MP4Err err; + MP4SegmentIndexAtomPtr self = (MP4SegmentIndexAtomPtr)s; + err = MP4NoErr; - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if (err) goto bail; + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; - self->size += (4 * 2) + (4 * 2) + (2 * 2); - - self->size += (4 * self->referenceCount); + self->size += (4 * 2) + (4 * 2) + (2 * 2); + self->size += (4 * self->referenceCount); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - - static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i; - u32 tmp32; + MP4Err err; + u32 i; + u32 tmp32; - MP4SegmentIndexAtomPtr self = (MP4SegmentIndexAtomPtr)s; + MP4SegmentIndexAtomPtr self = (MP4SegmentIndexAtomPtr)s; - err = MP4NoErr; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - err = self->super->createFromInputStream(s, proto, (char*)inputStream); + err = self->super->createFromInputStream(s, proto, (char *)inputStream); - GET32(referenceId); - GET32(timescale); + GET32(referenceId); + GET32(timescale); - GET32(earliestPresentationTime); - GET32(firstOffset); + GET32(earliestPresentationTime); + GET32(firstOffset); - GET16(reserved1); - GET16(referenceCount); + GET16(reserved1); + GET16(referenceCount); - for (i = 0; i < self->referenceCount; i++) { - - u8 referenceType; - u32 referencedSize; - u32 subsegmentDuration; - u8 startsWithSAP; - u8 SAPType; - u32 SAPDeltaTime; + for(i = 0; i < self->referenceCount; i++) + { - GET32_V(tmp32); - referenceType = (tmp32 >> 31) & 0x01; - referencedSize = tmp32 & 0x7FFF; - GET32_V(subsegmentDuration); - GET32_V(tmp32); - startsWithSAP = (tmp32 >> 31) & 0x01; - SAPType = (tmp32 >> 28) & 0x07; - SAPDeltaTime = tmp32 & 0x0FFFFFFF; + u8 referenceType; + u32 referencedSize; + u32 subsegmentDuration; + u8 startsWithSAP; + u8 SAPType; + u32 SAPDeltaTime; - err = addReference(self, referenceType, referencedSize, subsegmentDuration, startsWithSAP, SAPType, SAPDeltaTime); - if (err) goto bail; - } + GET32_V(tmp32); + referenceType = (tmp32 >> 31) & 0x01; + referencedSize = tmp32 & 0x7FFF; + GET32_V(subsegmentDuration); + GET32_V(tmp32); + startsWithSAP = (tmp32 >> 31) & 0x01; + SAPType = (tmp32 >> 28) & 0x07; + SAPDeltaTime = tmp32 & 0x0FFFFFFF; - assert(self->bytesRead == self->size); + err = addReference(self, referenceType, referencedSize, subsegmentDuration, startsWithSAP, + SAPType, SAPDeltaTime); + if(err) goto bail; + } + + assert(self->bytesRead == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - - - - MP4Err MP4CreateSegmentIndexAtom(MP4SegmentIndexAtomPtr *outAtom) { - MP4Err err; - MP4SegmentIndexAtomPtr self; + MP4Err err; + MP4SegmentIndexAtomPtr self; - self = (MP4SegmentIndexAtomPtr)calloc(1, sizeof(MP4SegmentIndexAtom)); - TESTMALLOC(self); + self = (MP4SegmentIndexAtomPtr)calloc(1, sizeof(MP4SegmentIndexAtom)); + TESTMALLOC(self); - err = MP4CreateFullAtom((MP4AtomPtr)self); if (err) goto bail; + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; - err = MP4MakeLinkedList(&self->referencesList); if (err) goto bail; + err = MP4MakeLinkedList(&self->referencesList); + if(err) goto bail; - self->type = MP4SegmentIndexAtomType; - self->name = "SegmentIndexBox"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addReference = addReference; + self->type = MP4SegmentIndexAtomType; + self->name = "SegmentIndexBox"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addReference = addReference; - *outAtom = self; + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } \ No newline at end of file diff --git a/IsoLib/libisomediafile/src/SegmentTypeAtom.c b/IsoLib/libisomediafile/src/SegmentTypeAtom.c index 64eb40f..8d3f8e4 100644 --- a/IsoLib/libisomediafile/src/SegmentTypeAtom.c +++ b/IsoLib/libisomediafile/src/SegmentTypeAtom.c @@ -1,257 +1,261 @@ /* -* This software module was originally developed by InterDigital, Inc. -* in the course of development of MPEG-4. -* This software module is an implementation of a part of one or -* more MPEG-4 tools as specified by MPEG-4. -* ISO/IEC gives users of MPEG-4 free license to this -* software module or modifications thereof for use in hardware -* or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. -* Those intending to use this software module in hardware or software -* products are advised that its use may infringe existing patents. -* The original developer of this software module and his/her company, -* the subsequent editors and their companies, and ISO/IEC have no -* liability for use of this software module or modifications thereof -* in an implementation. -* -* Copyright is not released for non MPEG-4 conforming -* products. InterDigital, Inc. retains full right to use the code for its own -* purpose, assign or donate the code to a third party and to -* inhibit third parties from using the code for non -* MPEG-4 conforming products. -* -* This copyright notice must be included in all copies or -* derivative works. -*/ - + * This software module was originally developed by InterDigital, Inc. + * in the course of development of MPEG-4. + * This software module is an implementation of a part of one or + * more MPEG-4 tools as specified by MPEG-4. + * ISO/IEC gives users of MPEG-4 free license to this + * software module or modifications thereof for use in hardware + * or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. + * Those intending to use this software module in hardware or software + * products are advised that its use may infringe existing patents. + * The original developer of this software module and his/her company, + * the subsequent editors and their companies, and ISO/IEC have no + * liability for use of this software module or modifications thereof + * in an implementation. + * + * Copyright is not released for non MPEG-4 conforming + * products. InterDigital, Inc. retains full right to use the code for its own + * purpose, assign or donate the code to a third party and to + * inhibit third parties from using the code for non + * MPEG-4 conforming products. + * + * This copyright notice must be included in all copies or + * derivative works. + */ /** -* @file SegmentTypeAtom.c -* @author Ahmed Hamza -* @date April 19, 2018 -* @brief Implements functions for reading and writing SegmentTypeAtom instances. -*/ - + * @file SegmentTypeAtom.c + * @author Ahmed Hamza + * @date April 19, 2018 + * @brief Implements functions for reading and writing SegmentTypeAtom instances. + */ #include "MP4Atoms.h" #include #include - static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SegmentTypeAtomPtr self; + MP4Err err; + MP4SegmentTypeAtomPtr self; - err = MP4NoErr; - self = (MP4SegmentTypeAtomPtr)s; + err = MP4NoErr; + self = (MP4SegmentTypeAtomPtr)s; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - if (self->compatibilityList) - { - free(self->compatibilityList); - self->compatibilityList = NULL; - } + if(self->compatibilityList) + { + free(self->compatibilityList); + self->compatibilityList = NULL; + } - if (self->super) - self->super->destroy(s); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return; + return; } - - -static ISOErr serialize(struct MP4Atom* s, char* buffer) +static ISOErr serialize(struct MP4Atom *s, char *buffer) { - ISOErr err; - u32 i; - MP4SegmentTypeAtomPtr self = (MP4SegmentTypeAtomPtr)s; + ISOErr err; + u32 i; + MP4SegmentTypeAtomPtr self = (MP4SegmentTypeAtomPtr)s; - err = ISONoErr; + err = ISONoErr; - err = MP4SerializeCommonFullAtomFields((MP4FullAtom*)s, buffer); if (err) goto bail; /* Full Atom */ - buffer += self->bytesWritten; + err = MP4SerializeCommonFullAtomFields((MP4FullAtom *)s, buffer); + if(err) goto bail; /* Full Atom */ + buffer += self->bytesWritten; - PUT32(majorBrand); - PUT32(minorVersion); + PUT32(majorBrand); + PUT32(minorVersion); - for (i = 0; i < self->itemCount; i++) - { - PUT32_V((self->compatibilityList[i])); - } + for(i = 0; i < self->itemCount; i++) + { + PUT32_V((self->compatibilityList[i])); + } - assert(self->bytesWritten == self->size); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static ISOErr calculateSize(struct MP4Atom* s) +static ISOErr calculateSize(struct MP4Atom *s) { - ISOErr err; - MP4SegmentTypeAtomPtr self = (MP4SegmentTypeAtomPtr)s; - err = ISONoErr; - - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if (err) goto bail; /* Full Atom */ - self->size += 2 * sizeof(u32); /* brand and minorVersion */ - self->size += self->itemCount * sizeof(u32); /* compatibilityList */ + ISOErr err; + MP4SegmentTypeAtomPtr self = (MP4SegmentTypeAtomPtr)s; + err = ISONoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; /* Full Atom */ + self->size += 2 * sizeof(u32); /* brand and minorVersion */ + self->size += self->itemCount * sizeof(u32); /* compatibilityList */ bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static ISOErr getBrand(struct MP4SegmentTypeAtom *self, u32* standard, u32* minorversion) +static ISOErr getBrand(struct MP4SegmentTypeAtom *self, u32 *standard, u32 *minorversion) { - *standard = self->majorBrand; - *minorversion = self->minorVersion; + *standard = self->majorBrand; + *minorversion = self->minorVersion; - return MP4NoErr; + return MP4NoErr; } static u32 getStandard(struct MP4SegmentTypeAtom *self, u32 standard) { - u32 i; - u32 outval; + u32 i; + u32 outval; - outval = 0; + outval = 0; - for (i = 0; iitemCount; i++) { - if (self->compatibilityList[i] == standard) { - outval = standard; - break; - } + for(i = 0; i < self->itemCount; i++) + { + if(self->compatibilityList[i] == standard) + { + outval = standard; + break; } - return outval; + } + return outval; } /* add a segment type to the compatibility list */ static ISOErr addStandard(struct MP4SegmentTypeAtom *self, u32 standard) { - ISOErr err; - err = ISONoErr; - - if (!getStandard(self, standard)) { - self->itemCount++; - self->compatibilityList = (u32*)realloc(self->compatibilityList, self->itemCount * sizeof(u32)); - TESTMALLOC(self->compatibilityList); - self->compatibilityList[self->itemCount - 1] = (u32)standard; - } + ISOErr err; + err = ISONoErr; + + if(!getStandard(self, standard)) + { + self->itemCount++; + self->compatibilityList = + (u32 *)realloc(self->compatibilityList, self->itemCount * sizeof(u32)); + TESTMALLOC(self->compatibilityList); + self->compatibilityList[self->itemCount - 1] = (u32)standard; + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static ISOErr setBrand(struct MP4SegmentTypeAtom *self, u32 standard, u32 minorversion) { - u32 oldstandard; - MP4Err err; - oldstandard = self->majorBrand; - - self->majorBrand = standard; - self->minorVersion = minorversion; - - /* in the compatibility list are also the new major brand, and the old one, if any */ - if (oldstandard) { err = addStandard(self, oldstandard); if (err) return err; } - err = addStandard(self, standard); if (err) return err; - - return err; + u32 oldstandard; + MP4Err err; + oldstandard = self->majorBrand; + + self->majorBrand = standard; + self->minorVersion = minorversion; + + /* in the compatibility list are also the new major brand, and the old one, if any */ + if(oldstandard) + { + err = addStandard(self, oldstandard); + if(err) return err; + } + err = addStandard(self, standard); + if(err) return err; + + return err; } static ISOErr createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - ISOErr err; - u32 items = 0; - long bytesToRead; - char typeString[8]; - char msgString[80]; + ISOErr err; + u32 items = 0; + long bytesToRead; + char typeString[8]; + char msgString[80]; - MP4SegmentTypeAtomPtr self = (MP4SegmentTypeAtomPtr)s; + MP4SegmentTypeAtomPtr self = (MP4SegmentTypeAtomPtr)s; - err = ISONoErr; - if (self == NULL) - BAILWITHERROR(ISOBadParamErr); + err = ISONoErr; + if(self == NULL) BAILWITHERROR(ISOBadParamErr); - err = self->super->createFromInputStream(s, proto, (char*)inputStream); if (err) goto bail; + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; - GET32(majorBrand); - MP4TypeToString(self->majorBrand, typeString); - sprintf(msgString, " major brand is '%s'", typeString); - inputStream->msg(inputStream, msgString); + GET32(majorBrand); + MP4TypeToString(self->majorBrand, typeString); + sprintf(msgString, " major brand is '%s'", typeString); + inputStream->msg(inputStream, msgString); - GET32(minorVersion); + GET32(minorVersion); - bytesToRead = self->size - self->bytesRead; - if (bytesToRead < ((long) sizeof(u32))) /* there must be at least one item in the compatibility list */ - BAILWITHERROR(ISOBadDataErr); + bytesToRead = self->size - self->bytesRead; + if(bytesToRead < + ((long)sizeof(u32))) /* there must be at least one item in the compatibility list */ + BAILWITHERROR(ISOBadDataErr); - if (self->compatibilityList) - free(self->compatibilityList); + if(self->compatibilityList) free(self->compatibilityList); - self->compatibilityList = (u32 *)calloc(1, bytesToRead); - TESTMALLOC(self->compatibilityList); + self->compatibilityList = (u32 *)calloc(1, bytesToRead); + TESTMALLOC(self->compatibilityList); - while (bytesToRead > 0) - { - if (bytesToRead < ((long) sizeof(u32))) /* we need to read a full u32 */ - BAILWITHERROR(ISOBadDataErr); - - GET32(compatibilityList[items]); - MP4TypeToString(self->compatibilityList[items], typeString); - sprintf(msgString, " minor brand is '%s'", typeString); - inputStream->msg(inputStream, msgString); - items++; - bytesToRead = self->size - self->bytesRead; - } + while(bytesToRead > 0) + { + if(bytesToRead < ((long)sizeof(u32))) /* we need to read a full u32 */ + BAILWITHERROR(ISOBadDataErr); - self->itemCount = items; + GET32(compatibilityList[items]); + MP4TypeToString(self->compatibilityList[items], typeString); + sprintf(msgString, " minor brand is '%s'", typeString); + inputStream->msg(inputStream, msgString); + items++; + bytesToRead = self->size - self->bytesRead; + } + + self->itemCount = items; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } ISOErr MP4CreateSegmentTypeAtom(MP4SegmentTypeAtomPtr *outAtom) { - ISOErr err; - MP4SegmentTypeAtomPtr self; - - self = (MP4SegmentTypeAtomPtr)calloc(1, sizeof(MP4SegmentTypeAtom)); - TESTMALLOC(self); - - err = MP4CreateFullAtom((MP4AtomPtr)self); /* Full atom */ - if (err) goto bail; - - self->type = MP4SegmentTypeAtomType; - self->name = "SegmentTypeBox"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addStandard = addStandard; - self->setBrand = setBrand; - self->getBrand = getBrand; - self->getStandard = getStandard; - - self->majorBrand = 0; /* was ISOISOBrand */ - self->minorVersion = (u32)0; - - self->compatibilityList = (u32*)calloc(1, sizeof(u32)); - TESTMALLOC(self->compatibilityList); - - /* self->compatibilityList[0] = ISOISOBrand; */ - /* self->compatibilityList[1] = ISOISOBrand; */ - /* No, MPEG-21 and meta movies are not ISOM branded */ - self->itemCount = (u32)0; - - *outAtom = self; + ISOErr err; + MP4SegmentTypeAtomPtr self; + + self = (MP4SegmentTypeAtomPtr)calloc(1, sizeof(MP4SegmentTypeAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); /* Full atom */ + if(err) goto bail; + + self->type = MP4SegmentTypeAtomType; + self->name = "SegmentTypeBox"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addStandard = addStandard; + self->setBrand = setBrand; + self->getBrand = getBrand; + self->getStandard = getStandard; + + self->majorBrand = 0; /* was ISOISOBrand */ + self->minorVersion = (u32)0; + + self->compatibilityList = (u32 *)calloc(1, sizeof(u32)); + TESTMALLOC(self->compatibilityList); + + /* self->compatibilityList[0] = ISOISOBrand; */ + /* self->compatibilityList[1] = ISOISOBrand; */ + /* No, MPEG-21 and meta movies are not ISOM branded */ + self->itemCount = (u32)0; + + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/ShadowSyncAtom.c b/IsoLib/libisomediafile/src/ShadowSyncAtom.c index 57a33e8..fad23f7 100644 --- a/IsoLib/libisomediafile/src/ShadowSyncAtom.c +++ b/IsoLib/libisomediafile/src/ShadowSyncAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,133 +15,133 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ShadowSyncAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: ShadowSyncAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4ShadowSyncAtomPtr self; - err = MP4NoErr; - self = (MP4ShadowSyncAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->entries ) - { - free( self->entries ); - self->entries = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4ShadowSyncAtomPtr self; + err = MP4NoErr; + self = (MP4ShadowSyncAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->entries) + { + free(self->entries); + self->entries = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } typedef struct { - u32 shadowedSampleNumber; - s32 syncSampleNumber; + u32 shadowedSampleNumber; + s32 syncSampleNumber; } stshEntry, *stshEntryPtr; - -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - stshEntryPtr p; - MP4ShadowSyncAtomPtr self = (MP4ShadowSyncAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( entryCount ); - p = (stshEntryPtr) self->entries; - for ( i = 0; i < self->entryCount; i++, p++ ) - { - PUT32_V( p->shadowedSampleNumber ); - PUT32_V( p->syncSampleNumber ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + stshEntryPtr p; + MP4ShadowSyncAtomPtr self = (MP4ShadowSyncAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(entryCount); + p = (stshEntryPtr)self->entries; + for(i = 0; i < self->entryCount; i++, p++) + { + PUT32_V(p->shadowedSampleNumber); + PUT32_V(p->syncSampleNumber); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4ShadowSyncAtomPtr self = (MP4ShadowSyncAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4 + (8 * self->entryCount); + MP4Err err; + MP4ShadowSyncAtomPtr self = (MP4ShadowSyncAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4 + (8 * self->entryCount); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 entries; - stshEntryPtr p; - MP4ShadowSyncAtomPtr self = (MP4ShadowSyncAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( entryCount ); - self->entries = calloc( self->entryCount, sizeof(stshEntry) ); - TESTMALLOC( self->entries ) - p = (stshEntryPtr) self->entries; - for ( entries = 0; entries < self->entryCount; entries++, p++ ) - { - u32 shadowedSampleNumber; - s32 syncSampleNumber; - GET32_V( shadowedSampleNumber ); - GET32_V( syncSampleNumber ); - p->shadowedSampleNumber = shadowedSampleNumber; - p->syncSampleNumber = syncSampleNumber; - } + MP4Err err; + u32 entries; + stshEntryPtr p; + MP4ShadowSyncAtomPtr self = (MP4ShadowSyncAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(entryCount); + self->entries = calloc(self->entryCount, sizeof(stshEntry)); + TESTMALLOC(self->entries) + p = (stshEntryPtr)self->entries; + for(entries = 0; entries < self->entryCount; entries++, p++) + { + u32 shadowedSampleNumber; + s32 syncSampleNumber; + GET32_V(shadowedSampleNumber); + GET32_V(syncSampleNumber); + p->shadowedSampleNumber = shadowedSampleNumber; + p->syncSampleNumber = syncSampleNumber; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateShadowSyncAtom( MP4ShadowSyncAtomPtr *outAtom ) +MP4Err MP4CreateShadowSyncAtom(MP4ShadowSyncAtomPtr *outAtom) { - MP4Err err; - MP4ShadowSyncAtomPtr self; - - self = (MP4ShadowSyncAtomPtr) calloc( 1, sizeof(MP4ShadowSyncAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4ShadowSyncAtomType; - self->name = "shadow sync"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4ShadowSyncAtomPtr self; + + self = (MP4ShadowSyncAtomPtr)calloc(1, sizeof(MP4ShadowSyncAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4ShadowSyncAtomType; + self->name = "shadow sync"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SingleItemTypeReferenceAtom.c b/IsoLib/libisomediafile/src/SingleItemTypeReferenceAtom.c index 5e775e6..865faec 100644 --- a/IsoLib/libisomediafile/src/SingleItemTypeReferenceAtom.c +++ b/IsoLib/libisomediafile/src/SingleItemTypeReferenceAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 2014. @@ -25,165 +25,165 @@ derivative works. Copyright (c) 2014. #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISOSingleItemTypeReferenceAtomPtr self; - err = MP4NoErr; - self = (ISOSingleItemTypeReferenceAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ); - - if ( self->to_item_IDs ) - free (self->to_item_IDs); - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + ISOSingleItemTypeReferenceAtomPtr self; + err = MP4NoErr; + self = (ISOSingleItemTypeReferenceAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + if(self->to_item_IDs) free(self->to_item_IDs); + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - ISOSingleItemTypeReferenceAtomPtr self = (ISOSingleItemTypeReferenceAtomPtr) s; - u32 i; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - - if (self->isLarge == 0) + MP4Err err; + ISOSingleItemTypeReferenceAtomPtr self = (ISOSingleItemTypeReferenceAtomPtr)s; + u32 i; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + if(self->isLarge == 0) + { + PUT16(from_item_ID); + PUT16(reference_count); + } + else + { + PUT32(from_item_ID); + PUT16(reference_count); + } + + for(i = 0; i < self->reference_count; i++) + { + if(self->isLarge == 0) { - PUT16( from_item_ID ); - PUT16( reference_count ); + PUT16_V(self->to_item_IDs[i]); } else { - PUT32( from_item_ID ); - PUT16( reference_count ); - } - - for (i = 0; i < self->reference_count; i++) - { - if (self->isLarge == 0) - { - PUT16_V( self->to_item_IDs[i] ); - } - else - { - PUT32_V( self->to_item_IDs[i] ); - } + PUT32_V(self->to_item_IDs[i]); } - - assert( self->bytesWritten == self->size ); + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISOSingleItemTypeReferenceAtomPtr self = (ISOSingleItemTypeReferenceAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - - if (self->isLarge == 0) - { - self->size += 4; - self->size += 2 * self->reference_count; - } - else - { - self->size += 6; - self->size += 4 * self->reference_count; - } + MP4Err err; + ISOSingleItemTypeReferenceAtomPtr self = (ISOSingleItemTypeReferenceAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + + if(self->isLarge == 0) + { + self->size += 4; + self->size += 2 * self->reference_count; + } + else + { + self->size += 6; + self->size += 4 * self->reference_count; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i; - char typeString[8]; - char msgString[ 80 ]; - - void MP4TypeToString( u32 inType, char* ioStr ); - - ISOSingleItemTypeReferenceAtomPtr self = (ISOSingleItemTypeReferenceAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - - self->bytesRead = 0; - - GET32( size ); - GET32( type ); - MP4TypeToString( self->type, typeString ); - sprintf( msgString, "type is '%s'", typeString ); - inputStream->msg( inputStream, msgString ); - - if (self->isLarge == 0) + MP4Err err; + u32 i; + char typeString[8]; + char msgString[80]; + + void MP4TypeToString(u32 inType, char *ioStr); + + ISOSingleItemTypeReferenceAtomPtr self = (ISOSingleItemTypeReferenceAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + self->bytesRead = 0; + + GET32(size); + GET32(type); + MP4TypeToString(self->type, typeString); + sprintf(msgString, "type is '%s'", typeString); + inputStream->msg(inputStream, msgString); + + if(self->isLarge == 0) + { + GET16(from_item_ID); + GET16(reference_count); + self->to_item_IDs = calloc(self->reference_count, sizeof(u16)); + } + else + { + GET32(from_item_ID); + GET16(reference_count); + self->to_item_IDs = calloc(self->reference_count, sizeof(u32)); + } + + for(i = 0; i < self->reference_count; i++) + { + if(self->isLarge == 0) { - GET16( from_item_ID ); - GET16( reference_count ); - self->to_item_IDs = calloc(self->reference_count, sizeof(u16)); + GET16_V(self->to_item_IDs[i]); } else { - GET32( from_item_ID ); - GET16( reference_count ); - self->to_item_IDs = calloc(self->reference_count, sizeof(u32)); + GET32_V(self->to_item_IDs[i]); } - - for (i = 0; i < self->reference_count; i++) - { - if (self->isLarge == 0) - { - GET16_V( self->to_item_IDs[i] ); - } - else - { - GET32_V( self->to_item_IDs[i] ); - } - } - - assert( self->bytesRead == self->size ); + } + + assert(self->bytesRead == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err ISOCreateSingleItemTypeReferenceAtom( ISOSingleItemTypeReferenceAtomPtr *outAtom, u32 type, u8 isLarge ) +MP4Err ISOCreateSingleItemTypeReferenceAtom(ISOSingleItemTypeReferenceAtomPtr *outAtom, u32 type, + u8 isLarge) { - MP4Err err; - ISOSingleItemTypeReferenceAtomPtr self; - - self = (ISOSingleItemTypeReferenceAtomPtr) calloc( 1, sizeof(ISOSingleItemTypeReferenceAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = type; - self->name = "single item type reference"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->isLarge = isLarge; - - *outAtom = self; + MP4Err err; + ISOSingleItemTypeReferenceAtomPtr self; + + self = (ISOSingleItemTypeReferenceAtomPtr)calloc(1, sizeof(ISOSingleItemTypeReferenceAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = type; + self->name = "single item type reference"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->isLarge = isLarge; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SoundMediaHeaderAtom.c b/IsoLib/libisomediafile/src/SoundMediaHeaderAtom.c index 5eb326b..a78c024 100644 --- a/IsoLib/libisomediafile/src/SoundMediaHeaderAtom.c +++ b/IsoLib/libisomediafile/src/SoundMediaHeaderAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,101 +15,100 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SoundMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SoundMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } - -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4SoundMediaHeaderAtomPtr self = (MP4SoundMediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT16( balance ); - PUT16( reserved ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4SoundMediaHeaderAtomPtr self = (MP4SoundMediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT16(balance); + PUT16(reserved); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SoundMediaHeaderAtomPtr self = (MP4SoundMediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4; + MP4Err err; + MP4SoundMediaHeaderAtomPtr self = (MP4SoundMediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4SoundMediaHeaderAtomPtr self = (MP4SoundMediaHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET16( balance ); - GET16( reserved ); + MP4Err err; + MP4SoundMediaHeaderAtomPtr self = (MP4SoundMediaHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET16(balance); + GET16(reserved); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSoundMediaHeaderAtom( MP4SoundMediaHeaderAtomPtr *outAtom ) +MP4Err MP4CreateSoundMediaHeaderAtom(MP4SoundMediaHeaderAtomPtr *outAtom) { - MP4Err err; - MP4SoundMediaHeaderAtomPtr self; - - self = (MP4SoundMediaHeaderAtomPtr) calloc( 1, sizeof(MP4SoundMediaHeaderAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4SoundMediaHeaderAtomType; - self->name = "sound media header"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4SoundMediaHeaderAtomPtr self; + + self = (MP4SoundMediaHeaderAtomPtr)calloc(1, sizeof(MP4SoundMediaHeaderAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SoundMediaHeaderAtomType; + self->name = "sound media header"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/StereoVideoAtom.c b/IsoLib/libisomediafile/src/StereoVideoAtom.c index d92195a..ceec212 100644 --- a/IsoLib/libisomediafile/src/StereoVideoAtom.c +++ b/IsoLib/libisomediafile/src/StereoVideoAtom.c @@ -1,27 +1,27 @@ /* -*This software module was originally developed by InterDigital, Inc. -* in the course of development of MPEG-4. -* This software module is an implementation of a part of one or -* more MPEG-4 tools as specified by MPEG-4. -* ISO/IEC gives users of MPEG-4 free license to this -* software module or modifications thereof for use in hardware -* or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. -* Those intending to use this software module in hardware or software -* products are advised that its use may infringe existing patents. -* The original developer of this software module and his/her company, -* the subsequent editors and their companies, and ISO/IEC have no -* liability for use of this software module or modifications thereof -* in an implementation. -* -* Copyright is not released for non MPEG-4 conforming -* products. InterDigital, Inc. retains full right to use the code for its own -* purpose, assign or donate the code to a third party and to -* inhibit third parties from using the code for non -* MPEG-4 conforming products. -* -* This copyright notice must be included in all copies or -* derivative works. -*/ + *This software module was originally developed by InterDigital, Inc. + * in the course of development of MPEG-4. + * This software module is an implementation of a part of one or + * more MPEG-4 tools as specified by MPEG-4. + * ISO/IEC gives users of MPEG-4 free license to this + * software module or modifications thereof for use in hardware + * or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. + * Those intending to use this software module in hardware or software + * products are advised that its use may infringe existing patents. + * The original developer of this software module and his/her company, + * the subsequent editors and their companies, and ISO/IEC have no + * liability for use of this software module or modifications thereof + * in an implementation. + * + * Copyright is not released for non MPEG-4 conforming + * products. InterDigital, Inc. retains full right to use the code for its own + * purpose, assign or donate the code to a third party and to + * inhibit third parties from using the code for non + * MPEG-4 conforming products. + * + * This copyright notice must be included in all copies or + * derivative works. + */ /** * @file StereoVideoAtom.c @@ -30,162 +30,159 @@ * @brief Implements functions for reading and writing StereoVideoAtom instances. */ - #include "MP4Atoms.h" #include - static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4StereoVideoAtomPtr self; + MP4Err err; + MP4StereoVideoAtomPtr self; - self = (MP4StereoVideoAtomPtr)s; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); - - DESTROY_ATOM_LIST_F(atomList); + self = (MP4StereoVideoAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - if (self->super) - self->super->destroy(s); + DESTROY_ATOM_LIST_F(atomList); + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return; + return; } - static MP4Err addAtom(MP4StereoVideoAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; + MP4Err err; + err = MP4NoErr; - if (self == 0) - BAILWITHERROR(MP4BadParamErr); + if(self == 0) BAILWITHERROR(MP4BadParamErr); - err = MP4AddListEntry(atom, self->atomList); if (err) goto bail; + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize(struct MP4Atom* s, char* buffer) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 tmp32; - u8 tmp8; - u32 i; - MP4StereoVideoAtomPtr self = (MP4StereoVideoAtomPtr)s; - err = MP4NoErr; + MP4Err err; + u32 tmp32; + u8 tmp8; + u32 i; + MP4StereoVideoAtomPtr self = (MP4StereoVideoAtomPtr)s; + err = MP4NoErr; - if (self->size > 0) { + if(self->size > 0) + { - err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)self, buffer); if (err) goto bail; - buffer += self->bytesWritten; + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)self, buffer); + if(err) goto bail; + buffer += self->bytesWritten; - tmp32 = (self->reserved << 2) + self->single_view_allowed; - PUT32_V(tmp32); - PUT32(stereo_scheme); - PUT32(length); - - for (i = 0; i < self->length; i++) { - tmp8 = self->stereo_indication_type[i]; - PUT8_V(tmp8); - } + tmp32 = (self->reserved << 2) + self->single_view_allowed; + PUT32_V(tmp32); + PUT32(stereo_scheme); + PUT32(length); - SERIALIZE_ATOM_LIST(atomList); + for(i = 0; i < self->length; i++) + { + tmp8 = self->stereo_indication_type[i]; + PUT8_V(tmp8); + } - assert(self->bytesWritten == self->size); + SERIALIZE_ATOM_LIST(atomList); - } + assert(self->bytesWritten == self->size); + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err calculateSize(struct MP4Atom* s) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4StereoVideoAtomPtr self = (MP4StereoVideoAtomPtr)s; - err = MP4NoErr; + MP4Err err; + MP4StereoVideoAtomPtr self = (MP4StereoVideoAtomPtr)s; + err = MP4NoErr; - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if (err) goto bail; + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; - self->size += (3 * 4) + self->length; + self->size += (3 * 4) + self->length; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i; - u32 tmp32; - - MP4StereoVideoAtomPtr self = (MP4StereoVideoAtomPtr)s; - - err = MP4NoErr; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); - - err = self->super->createFromInputStream(s, proto, (char*)inputStream); - - GET32_V(tmp32); - self->reserved = (tmp32 >> 2) & 0x3FFF; - self->single_view_allowed = (u8)(tmp32 & 0x3); - GET32(stereo_scheme); - GET32(length); - self->stereo_indication_type = calloc(self->length, sizeof(u8)); - for (i = 0; i < self->length; i++) { - GET8_V(self->stereo_indication_type[i]); - } - - assert(self->bytesRead == self->size); + MP4Err err; + u32 i; + u32 tmp32; + + MP4StereoVideoAtomPtr self = (MP4StereoVideoAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + + GET32_V(tmp32); + self->reserved = (tmp32 >> 2) & 0x3FFF; + self->single_view_allowed = (u8)(tmp32 & 0x3); + GET32(stereo_scheme); + GET32(length); + self->stereo_indication_type = calloc(self->length, sizeof(u8)); + for(i = 0; i < self->length; i++) + { + GET8_V(self->stereo_indication_type[i]); + } + + assert(self->bytesRead == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - MP4Err MP4CreateStereoVideoAtom(MP4StereoVideoAtomPtr *outAtom) { - MP4Err err; - MP4StereoVideoAtomPtr self; - - self = (MP4StereoVideoAtomPtr)calloc(1, sizeof(MP4StereoVideoAtom)); - TESTMALLOC(self); - - err = MP4CreateFullAtom((MP4AtomPtr)self); if (err) goto bail; - - self->type = MP4StereoVideoAtomType; - self->name = "StereoVideoBox"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addAtom = addAtom; - - err = MP4MakeLinkedList(&self->atomList); if (err) goto bail; - - /* - self->stereo_indication_type = (u8*)calloc(1, sizeof(u8)); - TESTMALLOC(self->stereo_indication_type); - */ - - *outAtom = self; + MP4Err err; + MP4StereoVideoAtomPtr self; + + self = (MP4StereoVideoAtomPtr)calloc(1, sizeof(MP4StereoVideoAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + + self->type = MP4StereoVideoAtomType; + self->name = "StereoVideoBox"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addAtom = addAtom; + + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + + /* + self->stereo_indication_type = (u8*)calloc(1, sizeof(u8)); + TESTMALLOC(self->stereo_indication_type); + */ + + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/StereoVideoGroupAtom.c b/IsoLib/libisomediafile/src/StereoVideoGroupAtom.c index 9cf9c64..09275f2 100644 --- a/IsoLib/libisomediafile/src/StereoVideoGroupAtom.c +++ b/IsoLib/libisomediafile/src/StereoVideoGroupAtom.c @@ -1,151 +1,146 @@ /* -*This software module was originally developed by InterDigital, Inc. -* in the course of development of MPEG-4. -* This software module is an implementation of a part of one or -* more MPEG-4 tools as specified by MPEG-4. -* ISO/IEC gives users of MPEG-4 free license to this -* software module or modifications thereof for use in hardware -* or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. -* Those intending to use this software module in hardware or software -* products are advised that its use may infringe existing patents. -* The original developer of this software module and his/her company, -* the subsequent editors and their companies, and ISO/IEC have no -* liability for use of this software module or modifications thereof -* in an implementation. -* -* Copyright is not released for non MPEG-4 conforming -* products. InterDigital, Inc. retains full right to use the code for its own -* purpose, assign or donate the code to a third party and to -* inhibit third parties from using the code for non -* MPEG-4 conforming products. -* -* This copyright notice must be included in all copies or -* derivative works. -*/ + *This software module was originally developed by InterDigital, Inc. + * in the course of development of MPEG-4. + * This software module is an implementation of a part of one or + * more MPEG-4 tools as specified by MPEG-4. + * ISO/IEC gives users of MPEG-4 free license to this + * software module or modifications thereof for use in hardware + * or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. + * Those intending to use this software module in hardware or software + * products are advised that its use may infringe existing patents. + * The original developer of this software module and his/her company, + * the subsequent editors and their companies, and ISO/IEC have no + * liability for use of this software module or modifications thereof + * in an implementation. + * + * Copyright is not released for non MPEG-4 conforming + * products. InterDigital, Inc. retains full right to use the code for its own + * purpose, assign or donate the code to a third party and to + * inhibit third parties from using the code for non + * MPEG-4 conforming products. + * + * This copyright notice must be included in all copies or + * derivative works. + */ /** -* @file StereoVideoGroupAtom.c -* @author Ahmed Hamza -* @date January 19, 2018 -* @brief Implements functions for reading and writing StereoVideoAtom instances. -*/ - + * @file StereoVideoGroupAtom.c + * @author Ahmed Hamza + * @date January 19, 2018 + * @brief Implements functions for reading and writing StereoVideoAtom instances. + */ #include "MP4Atoms.h" #include static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4StereoVideoGroupAtomPtr self; + MP4Err err; + MP4StereoVideoGroupAtomPtr self; - self = (MP4StereoVideoGroupAtomPtr)s; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + self = (MP4StereoVideoGroupAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - if (self->super) - self->super->destroy(s); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return; + return; } - -static MP4Err serialize(struct MP4Atom* s, char* buffer) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 tmp32; + MP4Err err; + u32 tmp32; + + MP4StereoVideoGroupAtomPtr self = (MP4StereoVideoGroupAtomPtr)s; + err = MP4NoErr; + + if(self->size > 0) + { - MP4StereoVideoGroupAtomPtr self = (MP4StereoVideoGroupAtomPtr)s; - err = MP4NoErr; + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)self, buffer); + if(err) goto bail; + buffer += self->bytesWritten; - if (self->size > 0) { + PUT32(trackGroupID); - err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)self, buffer); if (err) goto bail; - buffer += self->bytesWritten; - - PUT32(trackGroupID); + tmp32 = self->leftViewFlag << 31; + PUT32_V(tmp32); - tmp32 = self->leftViewFlag << 31; - PUT32_V(tmp32); - - assert(self->bytesWritten == self->size); - } + assert(self->bytesWritten == self->size); + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err calculateSize(struct MP4Atom* s) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; + MP4Err err; - MP4StereoVideoGroupAtomPtr self = (MP4StereoVideoGroupAtomPtr)s; - err = MP4NoErr; + MP4StereoVideoGroupAtomPtr self = (MP4StereoVideoGroupAtomPtr)s; + err = MP4NoErr; - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if (err) goto bail; + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; - self->size += (2 * 4); + self->size += (2 * 4); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - - static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 tmp32; + MP4Err err; + u32 tmp32; - MP4StereoVideoGroupAtomPtr self = (MP4StereoVideoGroupAtomPtr)s; - err = MP4NoErr; + MP4StereoVideoGroupAtomPtr self = (MP4StereoVideoGroupAtomPtr)s; + err = MP4NoErr; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - err = self->super->createFromInputStream(s, proto, (char*)inputStream); + err = self->super->createFromInputStream(s, proto, (char *)inputStream); - GET32(trackGroupID); + GET32(trackGroupID); - GET32_V(tmp32); - self->leftViewFlag = (tmp32 >> 31) & 0x01; + GET32_V(tmp32); + self->leftViewFlag = (tmp32 >> 31) & 0x01; - assert(self->bytesRead == self->size); + assert(self->bytesRead == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - MP4Err MP4CreateStereoVideoGroupAtom(MP4StereoVideoGroupAtomPtr *outAtom) { - MP4Err err; - MP4StereoVideoGroupAtomPtr self; + MP4Err err; + MP4StereoVideoGroupAtomPtr self; - self = (MP4StereoVideoGroupAtomPtr)calloc(1, sizeof(MP4StereoVideoGroupAtom)); - TESTMALLOC(self); + self = (MP4StereoVideoGroupAtomPtr)calloc(1, sizeof(MP4StereoVideoGroupAtom)); + TESTMALLOC(self); - err = MP4CreateFullAtom((MP4AtomPtr)self); if (err) goto bail; + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; - self->type = MP4StereoVideoGroupAtomType; - self->name = "StereoVideoGroupBox"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; + self->type = MP4StereoVideoGroupAtomType; + self->name = "StereoVideoGroupBox"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; - *outAtom = self; + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SubSampleInformationAtom.c b/IsoLib/libisomediafile/src/SubSampleInformationAtom.c index 9bb63c3..e6c358b 100644 --- a/IsoLib/libisomediafile/src/SubSampleInformationAtom.c +++ b/IsoLib/libisomediafile/src/SubSampleInformationAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -25,227 +25,250 @@ derivative works. Copyright (c) 1999. #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 i; - MP4SubSampleInformationAtomPtr self; - err = MP4NoErr; - self = (MP4SubSampleInformationAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->entry_count ) - { - for (i = 0; i < self->entry_count; i++) - { - if (self->subsample_count[i]) - { - free(self->subsample_size[i]); self->subsample_size[i] = NULL; - free(self->subsample_priority[i]); self->subsample_priority[i] = NULL; - free(self->discardable[i]); self->discardable[i] = NULL; - free(self->reserved[i]); self->reserved[i] = NULL; - } - } - free(self->subsample_size); self->subsample_size = NULL; - free(self->subsample_priority); self->subsample_priority = NULL; - free(self->discardable); self->discardable = NULL; - free(self->reserved); self->reserved = NULL; - - free(self->subsample_count); self->subsample_count = NULL; - free(self->sample_delta); self->sample_delta = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + u32 i; + MP4SubSampleInformationAtomPtr self; + err = MP4NoErr; + self = (MP4SubSampleInformationAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->entry_count) + { + for(i = 0; i < self->entry_count; i++) + { + if(self->subsample_count[i]) + { + free(self->subsample_size[i]); + self->subsample_size[i] = NULL; + free(self->subsample_priority[i]); + self->subsample_priority[i] = NULL; + free(self->discardable[i]); + self->discardable[i] = NULL; + free(self->reserved[i]); + self->reserved[i] = NULL; + } + } + free(self->subsample_size); + self->subsample_size = NULL; + free(self->subsample_priority); + self->subsample_priority = NULL; + free(self->discardable); + self->discardable = NULL; + free(self->reserved); + self->reserved = NULL; + + free(self->subsample_count); + self->subsample_count = NULL; + free(self->sample_delta); + self->sample_delta = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i,j; - MP4SubSampleInformationAtomPtr self = (MP4SubSampleInformationAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( entry_count ); - for (i = 0; i < self->entry_count; i++) - { - PUT32( sample_delta[i] ); - PUT16( subsample_count[i] ); - for (j = 0; j < self->subsample_count[i]; j++) - { - if (self->version == 1) - { - PUT32(subsample_size[i][j]); - } - else - { - PUT16(subsample_size[i][j]); - } - PUT8(subsample_priority[i][j]); - PUT8(discardable[i][j]); - PUT32(reserved[i][j]); - } - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i, j; + MP4SubSampleInformationAtomPtr self = (MP4SubSampleInformationAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(entry_count); + for(i = 0; i < self->entry_count; i++) + { + PUT32(sample_delta[i]); + PUT16(subsample_count[i]); + for(j = 0; j < self->subsample_count[i]; j++) + { + if(self->version == 1) + { + PUT32(subsample_size[i][j]); + } + else + { + PUT16(subsample_size[i][j]); + } + PUT8(subsample_priority[i][j]); + PUT8(discardable[i][j]); + PUT32(reserved[i][j]); + } + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - u32 i; - MP4SubSampleInformationAtomPtr self = (MP4SubSampleInformationAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4 + (self->entry_count * 6); - for (i = 0; i < self->entry_count; i++) - { - self->size += self->subsample_count[i] * (self->version == 1 ? 10 : 8); - } + MP4Err err; + u32 i; + MP4SubSampleInformationAtomPtr self = (MP4SubSampleInformationAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4 + (self->entry_count * 6); + for(i = 0; i < self->entry_count; i++) + { + self->size += self->subsample_count[i] * (self->version == 1 ? 10 : 8); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addEntry(MP4AtomPtr s, u32 sample_delta, - u32 subsample_count, MP4Handle subsample_size_array, MP4Handle subsample_priority_array, - MP4Handle subsample_discardable_array) { - MP4Err err; - MP4SubSampleInformationAtomPtr self; - u32 i; - u32 current_entry; - - err = MP4NoErr; - if ((s == NULL)) - BAILWITHERROR(MP4BadParamErr); - self = (MP4SubSampleInformationAtomPtr)s; - current_entry = self->entry_count; - - /* re-allocate basic structures */ - self->sample_delta = (u32 *)realloc(self->sample_delta, (self->entry_count + 1)*sizeof(u32)); - TESTMALLOC(self->sample_delta); - self->subsample_count = (u32 *)realloc(self->subsample_count, (self->entry_count + 1)*sizeof(u32)); - TESTMALLOC(self->subsample_count); - - self->subsample_size = (u32 **)realloc(self->subsample_size, (self->entry_count + 1)*sizeof(u32*)); - TESTMALLOC(self->subsample_size); - self->subsample_size[current_entry] = (u32 *)calloc(subsample_count, sizeof(u32)); - TESTMALLOC(self->subsample_size[current_entry]); - - self->subsample_priority = (u32 **)realloc(self->subsample_priority, (self->entry_count + 1)*sizeof(u32*)); - TESTMALLOC(self->subsample_priority); - self->subsample_priority[current_entry] = (u32 *)calloc(subsample_count, sizeof(u32)); - TESTMALLOC(self->subsample_priority[current_entry]); - - self->discardable = (u32 **)realloc(self->discardable, (self->entry_count + 1)*sizeof(u32*)); - TESTMALLOC(self->discardable); - self->discardable[current_entry] = (u32 *)calloc(subsample_count, sizeof(u32)); - TESTMALLOC(self->discardable[current_entry]); - - self->reserved = (u32 **)realloc(self->reserved, (self->entry_count + 1)*sizeof(u32*)); - TESTMALLOC(self->reserved); - self->reserved[current_entry] = (u32 *)calloc(subsample_count, sizeof(u32)); - TESTMALLOC(self->reserved[current_entry]); - - - - self->sample_delta[current_entry] = sample_delta; - self->subsample_count[current_entry] = subsample_count; - for (i = 0; i < subsample_count; i++) { - self->subsample_size[current_entry][i] = ((u32*)*subsample_size_array)[i]; - self->subsample_priority[current_entry][i] = ((u32*)*subsample_priority_array)[i]; - self->discardable[current_entry][i] = ((u32*)*subsample_discardable_array)[i]; - self->reserved[current_entry][i] = 0; - } - - self->entry_count++; +static MP4Err addEntry(MP4AtomPtr s, u32 sample_delta, u32 subsample_count, + MP4Handle subsample_size_array, MP4Handle subsample_priority_array, + MP4Handle subsample_discardable_array) +{ + MP4Err err; + MP4SubSampleInformationAtomPtr self; + u32 i; + u32 current_entry; + + err = MP4NoErr; + if((s == NULL)) BAILWITHERROR(MP4BadParamErr); + self = (MP4SubSampleInformationAtomPtr)s; + current_entry = self->entry_count; + + /* re-allocate basic structures */ + self->sample_delta = (u32 *)realloc(self->sample_delta, (self->entry_count + 1) * sizeof(u32)); + TESTMALLOC(self->sample_delta); + self->subsample_count = + (u32 *)realloc(self->subsample_count, (self->entry_count + 1) * sizeof(u32)); + TESTMALLOC(self->subsample_count); + + self->subsample_size = + (u32 **)realloc(self->subsample_size, (self->entry_count + 1) * sizeof(u32 *)); + TESTMALLOC(self->subsample_size); + self->subsample_size[current_entry] = (u32 *)calloc(subsample_count, sizeof(u32)); + TESTMALLOC(self->subsample_size[current_entry]); + + self->subsample_priority = + (u32 **)realloc(self->subsample_priority, (self->entry_count + 1) * sizeof(u32 *)); + TESTMALLOC(self->subsample_priority); + self->subsample_priority[current_entry] = (u32 *)calloc(subsample_count, sizeof(u32)); + TESTMALLOC(self->subsample_priority[current_entry]); + + self->discardable = (u32 **)realloc(self->discardable, (self->entry_count + 1) * sizeof(u32 *)); + TESTMALLOC(self->discardable); + self->discardable[current_entry] = (u32 *)calloc(subsample_count, sizeof(u32)); + TESTMALLOC(self->discardable[current_entry]); + + self->reserved = (u32 **)realloc(self->reserved, (self->entry_count + 1) * sizeof(u32 *)); + TESTMALLOC(self->reserved); + self->reserved[current_entry] = (u32 *)calloc(subsample_count, sizeof(u32)); + TESTMALLOC(self->reserved[current_entry]); + + self->sample_delta[current_entry] = sample_delta; + self->subsample_count[current_entry] = subsample_count; + for(i = 0; i < subsample_count; i++) + { + self->subsample_size[current_entry][i] = ((u32 *)*subsample_size_array)[i]; + self->subsample_priority[current_entry][i] = ((u32 *)*subsample_priority_array)[i]; + self->discardable[current_entry][i] = ((u32 *)*subsample_discardable_array)[i]; + self->reserved[current_entry][i] = 0; + } + + self->entry_count++; bail: - TEST_RETURN(err); - return err; + TEST_RETURN(err); + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i,j; - MP4SubSampleInformationAtomPtr self = (MP4SubSampleInformationAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( entry_count ); - - self->sample_delta = (u32 *)calloc(self->entry_count, sizeof(u32)); TESTMALLOC(self->sample_delta); - self->subsample_count = (u32 *)calloc(self->entry_count, sizeof(u32)); TESTMALLOC(self->subsample_count); - - self->subsample_size = (u32 **)calloc(self->entry_count, sizeof(u32*)); TESTMALLOC(self->subsample_size); - self->subsample_priority = (u32 **)calloc(self->entry_count, sizeof(u32*)); TESTMALLOC(self->subsample_priority); - self->discardable = (u32 **)calloc(self->entry_count, sizeof(u32*)); TESTMALLOC(self->discardable); - self->reserved = (u32 **)calloc(self->entry_count, sizeof(u32*)); TESTMALLOC(self->reserved); - - - - for (i = 0; i < self->entry_count; i++) - { - GET32(sample_delta[i]); - GET16(subsample_count[i]); - self->subsample_size[i] = (u32 *)calloc(self->subsample_count[i], sizeof(u32)); TESTMALLOC(self->subsample_count[i]); - self->subsample_priority[i] = (u32 *)calloc(self->subsample_count[i], sizeof(u32)); TESTMALLOC(self->subsample_count[i]); - self->discardable[i] = (u32 *)calloc(self->subsample_count[i], sizeof(u32)); TESTMALLOC(self->subsample_count[i]); - self->reserved[i] = (u32 *)calloc(self->subsample_count[i], sizeof(u32)); TESTMALLOC(self->subsample_count[i]); - for (j = 0; j < self->subsample_count[i]; j++) - { - if (self->version == 1) - { - GET32(subsample_size[i][j]); - } - else - { - GET16(subsample_size[i][j]); - } - GET8(subsample_priority[i][j]); - GET8(discardable[i][j]); - GET32(reserved[i][j]); - } - } + MP4Err err; + u32 i, j; + MP4SubSampleInformationAtomPtr self = (MP4SubSampleInformationAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(entry_count); + + self->sample_delta = (u32 *)calloc(self->entry_count, sizeof(u32)); + TESTMALLOC(self->sample_delta); + self->subsample_count = (u32 *)calloc(self->entry_count, sizeof(u32)); + TESTMALLOC(self->subsample_count); + + self->subsample_size = (u32 **)calloc(self->entry_count, sizeof(u32 *)); + TESTMALLOC(self->subsample_size); + self->subsample_priority = (u32 **)calloc(self->entry_count, sizeof(u32 *)); + TESTMALLOC(self->subsample_priority); + self->discardable = (u32 **)calloc(self->entry_count, sizeof(u32 *)); + TESTMALLOC(self->discardable); + self->reserved = (u32 **)calloc(self->entry_count, sizeof(u32 *)); + TESTMALLOC(self->reserved); + + for(i = 0; i < self->entry_count; i++) + { + GET32(sample_delta[i]); + GET16(subsample_count[i]); + self->subsample_size[i] = (u32 *)calloc(self->subsample_count[i], sizeof(u32)); + TESTMALLOC(self->subsample_count[i]); + self->subsample_priority[i] = (u32 *)calloc(self->subsample_count[i], sizeof(u32)); + TESTMALLOC(self->subsample_count[i]); + self->discardable[i] = (u32 *)calloc(self->subsample_count[i], sizeof(u32)); + TESTMALLOC(self->subsample_count[i]); + self->reserved[i] = (u32 *)calloc(self->subsample_count[i], sizeof(u32)); + TESTMALLOC(self->subsample_count[i]); + for(j = 0; j < self->subsample_count[i]; j++) + { + if(self->version == 1) + { + GET32(subsample_size[i][j]); + } + else + { + GET16(subsample_size[i][j]); + } + GET8(subsample_priority[i][j]); + GET8(discardable[i][j]); + GET32(reserved[i][j]); + } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSubSampleInformationAtom( MP4SubSampleInformationAtomPtr *outAtom ) +MP4Err MP4CreateSubSampleInformationAtom(MP4SubSampleInformationAtomPtr *outAtom) { - MP4Err err; - MP4SubSampleInformationAtomPtr self; - - self = (MP4SubSampleInformationAtomPtr) calloc( 1, sizeof(MP4SubSampleInformationAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); if ( err ) goto bail; - self->type = MP4SubSampleInformationAtomType; - self->name = "sub-sample information"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addEntry = addEntry; - *outAtom = self; - self->entry_count = 0; + MP4Err err; + MP4SubSampleInformationAtomPtr self; + + self = (MP4SubSampleInformationAtomPtr)calloc(1, sizeof(MP4SubSampleInformationAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SubSampleInformationAtomType; + self->name = "sub-sample information"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addEntry = addEntry; + *outAtom = self; + self->entry_count = 0; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c b/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c index 68445c7..84f5bd0 100644 --- a/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c +++ b/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c @@ -1,298 +1,294 @@ /* -*This software module was originally developed by InterDigital, Inc. -* in the course of development of MPEG-4. -* This software module is an implementation of a part of one or -* more MPEG-4 tools as specified by MPEG-4. -* ISO/IEC gives users of MPEG-4 free license to this -* software module or modifications thereof for use in hardware -* or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. -* Those intending to use this software module in hardware or software -* products are advised that its use may infringe existing patents. -* The original developer of this software module and his/her company, -* the subsequent editors and their companies, and ISO/IEC have no -* liability for use of this software module or modifications thereof -* in an implementation. -* -* Copyright is not released for non MPEG-4 conforming -* products. InterDigital, Inc. retains full right to use the code for its own -* purpose, assign or donate the code to a third party and to -* inhibit third parties from using the code for non -* MPEG-4 conforming products. -* -* This copyright notice must be included in all copies or -* derivative works. -*/ + *This software module was originally developed by InterDigital, Inc. + * in the course of development of MPEG-4. + * This software module is an implementation of a part of one or + * more MPEG-4 tools as specified by MPEG-4. + * ISO/IEC gives users of MPEG-4 free license to this + * software module or modifications thereof for use in hardware + * or software products claiming conformance to MPEG-4 only for evaluation and testing purposes. + * Those intending to use this software module in hardware or software + * products are advised that its use may infringe existing patents. + * The original developer of this software module and his/her company, + * the subsequent editors and their companies, and ISO/IEC have no + * liability for use of this software module or modifications thereof + * in an implementation. + * + * Copyright is not released for non MPEG-4 conforming + * products. InterDigital, Inc. retains full right to use the code for its own + * purpose, assign or donate the code to a third party and to + * inhibit third parties from using the code for non + * MPEG-4 conforming products. + * + * This copyright notice must be included in all copies or + * derivative works. + */ /** -* @file SubsegmentIndexAtom.c -* @author Ahmed Hamza -* @date April 19, 2018 -* @brief Implements functions for reading and writing SubsegmentIndexAtom instances. -*/ - + * @file SubsegmentIndexAtom.c + * @author Ahmed Hamza + * @date April 19, 2018 + * @brief Implements functions for reading and writing SubsegmentIndexAtom instances. + */ #include "MP4Atoms.h" #include - - static u32 getSubsegmentCount(struct MP4SubsegmentIndexAtom *self) { - u32 subsegmentCount = 0; - MP4GetListEntryCount(self->subsegmentsList, &subsegmentCount); - return subsegmentCount; + u32 subsegmentCount = 0; + MP4GetListEntryCount(self->subsegmentsList, &subsegmentCount); + return subsegmentCount; } static MP4Err addSubsegment(struct MP4SubsegmentIndexAtom *self, struct Subsegment *ss) { - MP4Err err; - err = MP4NoErr; + MP4Err err; + err = MP4NoErr; - err = MP4AddListEntry(ss, self->subsegmentsList); - /* if (err) goto bail; */ + err = MP4AddListEntry(ss, self->subsegmentsList); + /* if (err) goto bail; */ bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static MP4Err addSubsegmentRange(struct Subsegment *self, u8 level, u32 rangeSize) { - MP4Err err; - SubsegmentRangePtr p; + MP4Err err; + SubsegmentRangePtr p; - err = MP4NoErr; + err = MP4NoErr; - p = (SubsegmentRangePtr)calloc(1, sizeof(SubsegmentRange)); - TESTMALLOC(p); + p = (SubsegmentRangePtr)calloc(1, sizeof(SubsegmentRange)); + TESTMALLOC(p); - p->level = level; - p->rangeSize = rangeSize; + p->level = level; + p->rangeSize = rangeSize; - /* add range to linked list */ - err = MP4AddListEntry(p, self->rangesList); if (err) goto bail; + /* add range to linked list */ + err = MP4AddListEntry(p, self->rangesList); + if(err) goto bail; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - - static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 subsegmentCount; - u32 rangeCount; - MP4SubsegmentIndexAtomPtr self; + MP4Err err; + u32 subsegmentCount; + u32 rangeCount; + MP4SubsegmentIndexAtomPtr self; - self = (MP4SubsegmentIndexAtomPtr)s; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + self = (MP4SubsegmentIndexAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - subsegmentCount = getSubsegmentCount(self); + subsegmentCount = getSubsegmentCount(self); - if (subsegmentCount) + if(subsegmentCount) + { + u32 i; + for(i = 0; i < subsegmentCount; i++) { - u32 i; - for (i = 0; i < subsegmentCount; i++) + SubsegmentPtr p; + err = MP4GetListEntry(self->subsegmentsList, i, (char **)&p); + if(err) goto bail; + if(p) + { + + rangeCount = p->rangeCount; + if(rangeCount) { - SubsegmentPtr p; - err = MP4GetListEntry(self->subsegmentsList, i, (char**)&p); if (err) goto bail; - if (p) { - - rangeCount = p->rangeCount; - if (rangeCount) { - u32 j; - for (j = 0; j < rangeCount; j++) { - - char *r; - err = MP4GetListEntry(p->rangesList, j, &r); if (err) goto bail; + u32 j; + for(j = 0; j < rangeCount; j++) + { - if (r) { - free(r); - } - } - } + char *r; + err = MP4GetListEntry(p->rangesList, j, &r); + if(err) goto bail; - MP4DeleteLinkedList(p->rangesList); - - free(p); + if(r) + { + free(r); } + } } + + MP4DeleteLinkedList(p->rangesList); + + free(p); + } } + } - MP4DeleteLinkedList(self->subsegmentsList); + MP4DeleteLinkedList(self->subsegmentsList); - if (self->super) - self->super->destroy(s); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return; + return; } - -static MP4Err serialize(struct MP4Atom* s, char* buffer) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i, j; - u32 tmp32; + MP4Err err; + u32 i, j; + u32 tmp32; - MP4SubsegmentIndexAtomPtr self = (MP4SubsegmentIndexAtomPtr)s; - err = MP4NoErr; + MP4SubsegmentIndexAtomPtr self = (MP4SubsegmentIndexAtomPtr)s; + err = MP4NoErr; - err = MP4SerializeCommonFullAtomFields((MP4FullAtom*)s, buffer); if (err) goto bail; /* Full Atom */ - buffer += self->bytesWritten; + err = MP4SerializeCommonFullAtomFields((MP4FullAtom *)s, buffer); + if(err) goto bail; /* Full Atom */ + buffer += self->bytesWritten; - PUT32(subsegmentCount); + PUT32(subsegmentCount); - for (i = 0; i < self->subsegmentCount; i++) { + for(i = 0; i < self->subsegmentCount; i++) + { - SubsegmentPtr ss; - err = MP4GetListEntry(self->subsegmentsList, i, (char**)&ss); - if (err) goto bail; + SubsegmentPtr ss; + err = MP4GetListEntry(self->subsegmentsList, i, (char **)&ss); + if(err) goto bail; - PUT32_V(ss->rangeCount); + PUT32_V(ss->rangeCount); - for (j = 0; j < ss->rangeCount; j++) { - - SubsegmentRangePtr ssRange; - err = MP4GetListEntry(ss->rangesList, i, (char**)&ssRange); - if (err) goto bail; + for(j = 0; j < ss->rangeCount; j++) + { - tmp32 = ssRange->level; - tmp32 = (tmp32 << 28) | ssRange->rangeSize; + SubsegmentRangePtr ssRange; + err = MP4GetListEntry(ss->rangesList, i, (char **)&ssRange); + if(err) goto bail; - PUT32_V(tmp32); + tmp32 = ssRange->level; + tmp32 = (tmp32 << 28) | ssRange->rangeSize; - } + PUT32_V(tmp32); } + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err calculateSize(struct MP4Atom* s) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - u32 i; - - MP4SubsegmentIndexAtomPtr self = (MP4SubsegmentIndexAtomPtr)s; - err = MP4NoErr; + MP4Err err; + u32 i; - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if (err) goto bail; + MP4SubsegmentIndexAtomPtr self = (MP4SubsegmentIndexAtomPtr)s; + err = MP4NoErr; - self->size += 4; + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; - for (i = 0; i < self->subsegmentCount; i++) { - - self->size += 4; + self->size += 4; - SubsegmentPtr ss; - err = MP4GetListEntry(self->subsegmentsList, i, (char**)&ss); - if (err) goto bail; + for(i = 0; i < self->subsegmentCount; i++) + { - self->size += ss->rangeCount * 4; + self->size += 4; - } + SubsegmentPtr ss; + err = MP4GetListEntry(self->subsegmentsList, i, (char **)&ss); + if(err) goto bail; + self->size += ss->rangeCount * 4; + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - - static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i, j; - u32 tmp32; - - MP4SubsegmentIndexAtomPtr self = (MP4SubsegmentIndexAtomPtr)s; + MP4Err err; + u32 i, j; + u32 tmp32; - err = MP4NoErr; - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); + MP4SubsegmentIndexAtomPtr self = (MP4SubsegmentIndexAtomPtr)s; - err = self->super->createFromInputStream(s, proto, (char*)inputStream); + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); - GET32(subsegmentCount); + err = self->super->createFromInputStream(s, proto, (char *)inputStream); - for (i = 0; i < self->subsegmentCount; i++) { - - SubsegmentPtr ss; - ss = (SubsegmentPtr)calloc(1, sizeof(Subsegment)); - TESTMALLOC(ss); + GET32(subsegmentCount); - err = MP4MakeLinkedList(&ss->rangesList); if (err) goto bail; - - GET32_V(ss->rangeCount); + for(i = 0; i < self->subsegmentCount; i++) + { - for (j = 0; j < ss->rangeCount; j++) { + SubsegmentPtr ss; + ss = (SubsegmentPtr)calloc(1, sizeof(Subsegment)); + TESTMALLOC(ss); - u8 level; - u32 rangeSize; + err = MP4MakeLinkedList(&ss->rangesList); + if(err) goto bail; - GET32_V(tmp32); - level = (tmp32 >> 24) & 0xFF; - rangeSize = tmp32 & 0x00FFFFFF; + GET32_V(ss->rangeCount); - err = addSubsegmentRange(ss, level, rangeSize); - if (err) goto bail; + for(j = 0; j < ss->rangeCount; j++) + { - } + u8 level; + u32 rangeSize; - err = addSubsegment(self, ss); - if (err) goto bail; + GET32_V(tmp32); + level = (tmp32 >> 24) & 0xFF; + rangeSize = tmp32 & 0x00FFFFFF; + err = addSubsegmentRange(ss, level, rangeSize); + if(err) goto bail; } - assert(self->bytesRead == self->size); + err = addSubsegment(self, ss); + if(err) goto bail; + } + + assert(self->bytesRead == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } - - - - MP4Err MP4CreateSubsegmentIndexAtom(MP4SubsegmentIndexAtomPtr *outAtom) { - MP4Err err; - MP4SubsegmentIndexAtomPtr self; + MP4Err err; + MP4SubsegmentIndexAtomPtr self; - self = (MP4SubsegmentIndexAtomPtr)calloc(1, sizeof(MP4SubsegmentIndexAtom)); - TESTMALLOC(self); + self = (MP4SubsegmentIndexAtomPtr)calloc(1, sizeof(MP4SubsegmentIndexAtom)); + TESTMALLOC(self); - err = MP4CreateFullAtom((MP4AtomPtr)self); if (err) goto bail; + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; - err = MP4MakeLinkedList(&self->subsegmentsList); if (err) goto bail; + err = MP4MakeLinkedList(&self->subsegmentsList); + if(err) goto bail; - self->type = MP4SubsegmentIndexAtomType; - self->name = "SubsegmentIndexBox"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addSubsegment = addSubsegment; - self->getSubsegmentCount = getSubsegmentCount; - self->addSubsegmentRange = addSubsegmentRange; + self->type = MP4SubsegmentIndexAtomType; + self->name = "SubsegmentIndexBox"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addSubsegment = addSubsegment; + self->getSubsegmentCount = getSubsegmentCount; + self->addSubsegmentRange = addSubsegmentRange; - *outAtom = self; + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } \ No newline at end of file diff --git a/IsoLib/libisomediafile/src/SyncSampleAtom.c b/IsoLib/libisomediafile/src/SyncSampleAtom.c index eed303c..b067516 100644 --- a/IsoLib/libisomediafile/src/SyncSampleAtom.c +++ b/IsoLib/libisomediafile/src/SyncSampleAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SyncSampleAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SyncSampleAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,231 +29,235 @@ derivative works. Copyright (c) 1999. #define allocation_size 1024 -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SyncSampleAtomPtr self; - err = MP4NoErr; - self = (MP4SyncSampleAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->sampleNumbers ) - { - free( self->sampleNumbers ); - self->sampleNumbers = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4SyncSampleAtomPtr self; + err = MP4NoErr; + self = (MP4SyncSampleAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->sampleNumbers) + { + free(self->sampleNumbers); + self->sampleNumbers = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err isSyncSample( MP4AtomPtr s, u32 sampleNumber, u32 *outSync ) +static MP4Err isSyncSample(MP4AtomPtr s, u32 sampleNumber, u32 *outSync) { - MP4Err err; - u32 i; - u32 *p; - MP4SyncSampleAtomPtr self = (MP4SyncSampleAtomPtr) s; - - err = MP4NoErr; - p = self->sampleNumbers; - if ( (self == NULL) || (outSync == NULL) || (sampleNumber == 0) ) + MP4Err err; + u32 i; + u32 *p; + MP4SyncSampleAtomPtr self = (MP4SyncSampleAtomPtr)s; + + err = MP4NoErr; + p = self->sampleNumbers; + if((self == NULL) || (outSync == NULL) || (sampleNumber == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + *outSync = 0; + for(i = 0; i < self->entryCount; i++, p++) + { + u32 syncSample; + syncSample = *p; + if(sampleNumber == syncSample) + { + *outSync = 1; + break; + } + else if(sampleNumber < syncSample) { - BAILWITHERROR( MP4BadParamErr ); + break; } - *outSync = 0; - for ( i = 0; i < self->entryCount; i++, p++ ) - { - u32 syncSample; - syncSample = *p; - if ( sampleNumber == syncSample ) - { - *outSync = 1; - break; - } - else if ( sampleNumber < syncSample ) - { - break; - } - } - + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSamples( struct MP4SyncSampleAtom *self, u32 beginningSampleNumber, - u32 sampleCount, MP4Handle syncSamplesH ) +static MP4Err addSamples(struct MP4SyncSampleAtom *self, u32 beginningSampleNumber, u32 sampleCount, + MP4Handle syncSamplesH) { - MP4Err err; - u32 newSampleCount, newSize; - u32 *src; - u32 *dst; - u32 i; - u32 handleSize; - u32 samplesInHandle; - u32 firstSyncSampleCount = 0; - - if ( (self == NULL) || (syncSamplesH == NULL) || (beginningSampleNumber == 0) ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = MP4GetHandleSize( syncSamplesH, &handleSize ); if (err) goto bail; - samplesInHandle = handleSize / sizeof(u32); + MP4Err err; + u32 newSampleCount, newSize; + u32 *src; + u32 *dst; + u32 i; + u32 handleSize; + u32 samplesInHandle; + u32 firstSyncSampleCount = 0; + if((self == NULL) || (syncSamplesH == NULL) || (beginningSampleNumber == 0)) + { + BAILWITHERROR(MP4BadParamErr); + } + err = MP4GetHandleSize(syncSamplesH, &handleSize); + if(err) goto bail; + samplesInHandle = handleSize / sizeof(u32); - if ( self->entryCount == 0 ) - { - /* - If this is an empty atom and we are now being called it - can mean: + if(self->entryCount == 0) + { + /* + If this is an empty atom and we are now being called it + can mean: - a) All samples were sync until this one, and we need to - make sync sample entries for them all right now, or + a) All samples were sync until this one, and we need to + make sync sample entries for them all right now, or - b) All samples were non-sync -- and we either got another - non-sync (which doesn't change our state) or we finally - got a sync sample and we can set an entry count containing - just this sample. - */ -/* GUIDO 25/07/00 Case a) applies independently of samplesInHandle */ -/* if ( (samplesInHandle == 0) && (self->nonSyncFlag == 0) ) */ - if ( self->nonSyncFlag == 0) - { - /* first non-sync -- set all prior to sync */ - firstSyncSampleCount = (beginningSampleNumber - 1); - newSampleCount = samplesInHandle + firstSyncSampleCount; - self->nonSyncFlag = 1; - } - else - { - self->nonSyncFlag = (samplesInHandle == 0); - newSampleCount = samplesInHandle; - } + b) All samples were non-sync -- and we either got another + non-sync (which doesn't change our state) or we finally + got a sync sample and we can set an entry count containing + just this sample. + */ + /* GUIDO 25/07/00 Case a) applies independently of samplesInHandle */ + /* if ( (samplesInHandle == 0) && (self->nonSyncFlag == 0) ) */ + if(self->nonSyncFlag == 0) + { + /* first non-sync -- set all prior to sync */ + firstSyncSampleCount = (beginningSampleNumber - 1); + newSampleCount = samplesInHandle + firstSyncSampleCount; + self->nonSyncFlag = 1; } else { - newSampleCount = samplesInHandle + self->entryCount; + self->nonSyncFlag = (samplesInHandle == 0); + newSampleCount = samplesInHandle; } - newSize = newSampleCount * sizeof(u32); - if (newSize > self->allocatedSize) { - self->allocatedSize += allocation_size; - if (self->allocatedSize < newSize) self->allocatedSize = newSize; - - if (self->sampleNumbers != NULL) - self->sampleNumbers = (u32*) realloc( self->sampleNumbers, self->allocatedSize ); - else - self->sampleNumbers = (u32*) calloc( self->allocatedSize, 1 ); - TESTMALLOC( self->sampleNumbers ); - } - src = (u32*) *syncSamplesH; - dst = &self->sampleNumbers[self->entryCount]; - for ( i = 0; i < firstSyncSampleCount; i++ ) + } + else + { + newSampleCount = samplesInHandle + self->entryCount; + } + newSize = newSampleCount * sizeof(u32); + if(newSize > self->allocatedSize) + { + self->allocatedSize += allocation_size; + if(self->allocatedSize < newSize) self->allocatedSize = newSize; + + if(self->sampleNumbers != NULL) + self->sampleNumbers = (u32 *)realloc(self->sampleNumbers, self->allocatedSize); + else + self->sampleNumbers = (u32 *)calloc(self->allocatedSize, 1); + TESTMALLOC(self->sampleNumbers); + } + src = (u32 *)*syncSamplesH; + dst = &self->sampleNumbers[self->entryCount]; + for(i = 0; i < firstSyncSampleCount; i++) + { + *dst++ = (i + 1); + } + for(i = 0; i < samplesInHandle; i++) + { + u32 sampleOffset; + sampleOffset = *src++; + if((sampleOffset == 0) || (sampleOffset > sampleCount)) { - *dst++ = (i + 1); + BAILWITHERROR(MP4BadParamErr); } - for ( i = 0; i < samplesInHandle; i++ ) - { - u32 sampleOffset; - sampleOffset = *src++; - if (( sampleOffset == 0 ) || (sampleOffset > sampleCount)) - { - BAILWITHERROR( MP4BadParamErr ); - } - *dst++ = beginningSampleNumber + (sampleOffset - 1); - } - self->entryCount = newSampleCount; + *dst++ = beginningSampleNumber + (sampleOffset - 1); + } + self->entryCount = newSampleCount; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - MP4SyncSampleAtomPtr self = (MP4SyncSampleAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( entryCount ); - for ( i = 0; i < self->entryCount; i++ ) - { - PUT32_V( self->sampleNumbers[i] ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + MP4SyncSampleAtomPtr self = (MP4SyncSampleAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(entryCount); + for(i = 0; i < self->entryCount; i++) + { + PUT32_V(self->sampleNumbers[i]); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4SyncSampleAtomPtr self = (MP4SyncSampleAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4 + (4 * self->entryCount); + MP4Err err; + MP4SyncSampleAtomPtr self = (MP4SyncSampleAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4 + (4 * self->entryCount); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 entries; - u32* p; - MP4SyncSampleAtomPtr self = (MP4SyncSampleAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; + MP4Err err; + u32 entries; + u32 *p; + MP4SyncSampleAtomPtr self = (MP4SyncSampleAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; - GET32( entryCount ); + GET32(entryCount); - self->sampleNumbers = (u32 *) calloc( self->entryCount + 1, sizeof(u32) ); - self->allocatedSize = (self->entryCount + 1) * sizeof(u32); - TESTMALLOC( self->sampleNumbers ) - for ( entries = 0, p = self->sampleNumbers; entries < self->entryCount; entries++, p++ ) - { - u32 sampleNumber; - GET32_V( sampleNumber ); - *p = sampleNumber; - } + self->sampleNumbers = (u32 *)calloc(self->entryCount + 1, sizeof(u32)); + self->allocatedSize = (self->entryCount + 1) * sizeof(u32); + TESTMALLOC(self->sampleNumbers) + for(entries = 0, p = self->sampleNumbers; entries < self->entryCount; entries++, p++) + { + u32 sampleNumber; + GET32_V(sampleNumber); + *p = sampleNumber; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateSyncSampleAtom( MP4SyncSampleAtomPtr *outAtom ) +MP4Err MP4CreateSyncSampleAtom(MP4SyncSampleAtomPtr *outAtom) { - MP4Err err; - MP4SyncSampleAtomPtr self; - - self = (MP4SyncSampleAtomPtr) calloc( 1, sizeof(MP4SyncSampleAtom) ); - TESTMALLOC( self ) + MP4Err err; + MP4SyncSampleAtomPtr self; + + self = (MP4SyncSampleAtomPtr)calloc(1, sizeof(MP4SyncSampleAtom)); + TESTMALLOC(self) - err = MP4CreateFullAtom( (MP4AtomPtr) self ); if ( err ) goto bail; - self->type = MP4SyncSampleAtomType; - self->name = "sync sample"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->isSyncSample = isSyncSample; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addSamples = addSamples; - *outAtom = self; + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4SyncSampleAtomType; + self->name = "sync sample"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->isSyncSample = isSyncSample; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addSamples = addSamples; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TextMetaSampleEntry.c b/IsoLib/libisomediafile/src/TextMetaSampleEntry.c index 5d92703..4d46561 100644 --- a/IsoLib/libisomediafile/src/TextMetaSampleEntry.c +++ b/IsoLib/libisomediafile/src/TextMetaSampleEntry.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,178 +15,198 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TextMetaSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TextMetaSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4TextMetaSampleEntryAtomPtr self; - err = MP4NoErr; - self = (MP4TextMetaSampleEntryAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST_F( ExtensionAtomList ) - - if ( self->content_encoding ) { - free( self->content_encoding ); - self->content_encoding = NULL; - } - if ( self->mime_format ) { - free( self->mime_format ); - self->mime_format = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4TextMetaSampleEntryAtomPtr self; + err = MP4NoErr; + self = (MP4TextMetaSampleEntryAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST_F(ExtensionAtomList) + + if(self->content_encoding) + { + free(self->content_encoding); + self->content_encoding = NULL; + } + if(self->mime_format) + { + free(self->mime_format); + self->mime_format = NULL; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4TextMetaSampleEntryAtomPtr self = (MP4TextMetaSampleEntryAtomPtr) s; - u8 x; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - - PUTBYTES( self->reserved, 6 ); - PUT16( dataReferenceIndex ); - - x = 0; - - if ( self->content_encoding ) - { - u32 len = strlen( self->content_encoding ) + 1; - PUTBYTES( self->content_encoding, len ); - } else { PUT8_V( x ); } - - if ( self->mime_format ) - { - u32 len = strlen( self->mime_format ) + 1; - PUTBYTES( self->mime_format, len ); - } else { PUT8_V( x ); } - - - SERIALIZE_ATOM_LIST( ExtensionAtomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4TextMetaSampleEntryAtomPtr self = (MP4TextMetaSampleEntryAtomPtr)s; + u8 x; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + + PUTBYTES(self->reserved, 6); + PUT16(dataReferenceIndex); + + x = 0; + + if(self->content_encoding) + { + u32 len = strlen(self->content_encoding) + 1; + PUTBYTES(self->content_encoding, len); + } + else + { + PUT8_V(x); + } + + if(self->mime_format) + { + u32 len = strlen(self->mime_format) + 1; + PUTBYTES(self->mime_format, len); + } + else + { + PUT8_V(x); + } + + SERIALIZE_ATOM_LIST(ExtensionAtomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4TextMetaSampleEntryAtomPtr self = (MP4TextMetaSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 8 + 2; /* the null terminators of the two strings */ - - if ( self->content_encoding ) - self->size += strlen( self->content_encoding ); - if ( self->mime_format ) - self->size += strlen( self->mime_format ); - - ADD_ATOM_LIST_SIZE( ExtensionAtomList ); + MP4Err err; + MP4TextMetaSampleEntryAtomPtr self = (MP4TextMetaSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 8 + 2; /* the null terminators of the two strings */ + + if(self->content_encoding) self->size += strlen(self->content_encoding); + if(self->mime_format) self->size += strlen(self->mime_format); + + ADD_ATOM_LIST_SIZE(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err readstring( char** b, MP4TextMetaSampleEntryAtomPtr self, MP4InputStreamPtr inputStream, char *fieldname ) + +static MP4Err readstring(char **b, MP4TextMetaSampleEntryAtomPtr self, + MP4InputStreamPtr inputStream, char *fieldname) { - u32 byte; - MP4Err err; - char temp[1024]; - char msgString[200]; - char* p; - - err = MP4NoErr; - p = &(temp[0]); - - for (;;) { - GET8_V_MSG( byte, NULL ); - *p++ = byte; - if (byte==0) break; - } - - *b = calloc( strlen(temp)+1, 1 ); - TESTMALLOC( *b ); - strcpy( *b, temp ); - sprintf( msgString, "%s = '%s'", fieldname, *b ); - inputStream->msg( inputStream, msgString ); + u32 byte; + MP4Err err; + char temp[1024]; + char msgString[200]; + char *p; + + err = MP4NoErr; + p = &(temp[0]); + + for(;;) + { + GET8_V_MSG(byte, NULL); + *p++ = byte; + if(byte == 0) break; + } + + *b = calloc(strlen(temp) + 1, 1); + TESTMALLOC(*b); + strcpy(*b, temp); + sprintf(msgString, "%s = '%s'", fieldname, *b); + inputStream->msg(inputStream, msgString); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4TextMetaSampleEntryAtomPtr self = (MP4TextMetaSampleEntryAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GETBYTES( 6, reserved ); - GET16( dataReferenceIndex ); - - if (self->size > self->bytesRead) - { err = readstring( &(self->content_encoding), self, inputStream, "content_encoding" ); if (err) goto bail; } - else self->content_encoding = NULL; - if (self->size > self->bytesRead) - { err = readstring( &(self->mime_format), self, inputStream, "mime_format" ); if (err) goto bail; } - else self->mime_format = NULL; - - GETATOM_LIST( ExtensionAtomList ); + MP4Err err; + MP4TextMetaSampleEntryAtomPtr self = (MP4TextMetaSampleEntryAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GETBYTES(6, reserved); + GET16(dataReferenceIndex); + + if(self->size > self->bytesRead) + { + err = readstring(&(self->content_encoding), self, inputStream, "content_encoding"); + if(err) goto bail; + } + else + self->content_encoding = NULL; + if(self->size > self->bytesRead) + { + err = readstring(&(self->mime_format), self, inputStream, "mime_format"); + if(err) goto bail; + } + else + self->mime_format = NULL; + + GETATOM_LIST(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateTextMetaSampleEntryAtom( MP4TextMetaSampleEntryAtomPtr *outAtom ) +MP4Err MP4CreateTextMetaSampleEntryAtom(MP4TextMetaSampleEntryAtomPtr *outAtom) { - MP4Err err; - MP4TextMetaSampleEntryAtomPtr self; - - self = (MP4TextMetaSampleEntryAtomPtr) calloc( 1, sizeof(MP4TextMetaSampleEntryAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4TextMetaSampleEntryAtomType; - self->name = "Text meta sample entry"; - err = MP4MakeLinkedList( &self->ExtensionAtomList ); if (err) goto bail; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4TextMetaSampleEntryAtomPtr self; + + self = (MP4TextMetaSampleEntryAtomPtr)calloc(1, sizeof(MP4TextMetaSampleEntryAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4TextMetaSampleEntryAtomType; + self->name = "Text meta sample entry"; + err = MP4MakeLinkedList(&self->ExtensionAtomList); + if(err) goto bail; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TimeToSampleAtom.c b/IsoLib/libisomediafile/src/TimeToSampleAtom.c index 650433e..df974ca 100644 --- a/IsoLib/libisomediafile/src/TimeToSampleAtom.c +++ b/IsoLib/libisomediafile/src/TimeToSampleAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TimeToSampleAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TimeToSampleAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,406 +29,424 @@ derivative works. Copyright (c) 1999. typedef struct { - u32 sampleCount; - u32 sampleDuration; /* also known as sampleDelta */ + u32 sampleCount; + u32 sampleDuration; /* also known as sampleDelta */ } sttsEntry, *sttsEntryPtr; -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4TimeToSampleAtomPtr self; - err = MP4NoErr; - self = (MP4TimeToSampleAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->entryList ) - { - u32 entryCount; - u32 i; - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - for ( i = 0; i < entryCount; i++ ) - { - sttsEntryPtr pe; - err = MP4GetListEntry( self->entryList, i, (char**) &pe ); if (err) goto bail; - free( pe ); - } - err = MP4DeleteLinkedList( self->entryList ); if (err) goto bail; - self->entryList = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4TimeToSampleAtomPtr self; + err = MP4NoErr; + self = (MP4TimeToSampleAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->entryList) + { + u32 entryCount; + u32 i; + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + for(i = 0; i < entryCount; i++) + { + sttsEntryPtr pe; + err = MP4GetListEntry(self->entryList, i, (char **)&pe); + if(err) goto bail; + free(pe); + } + err = MP4DeleteLinkedList(self->entryList); + if(err) goto bail; + self->entryList = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err getTotalDuration( struct MP4TimeToSampleAtom *self, u32 *outDuration ) +static MP4Err getTotalDuration(struct MP4TimeToSampleAtom *self, u32 *outDuration) { - MP4Err err; - u32 totalDuration; - u32 entryCount; - u32 i; - err = MP4NoErr; - - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - totalDuration = 0; - for ( i = 0; i < entryCount; i++ ) - { - sttsEntryPtr pe; - err = MP4GetListEntry( self->entryList, i, (char**) &pe ); if (err) goto bail; - totalDuration += (pe->sampleCount * pe->sampleDuration); - } - *outDuration = totalDuration; + MP4Err err; + u32 totalDuration; + u32 entryCount; + u32 i; + err = MP4NoErr; + + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + totalDuration = 0; + for(i = 0; i < entryCount; i++) + { + sttsEntryPtr pe; + err = MP4GetListEntry(self->entryList, i, (char **)&pe); + if(err) goto bail; + totalDuration += (pe->sampleCount * pe->sampleDuration); + } + *outDuration = totalDuration; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSample( struct MP4TimeToSampleAtom *self, u32 duration ) +static MP4Err addSample(struct MP4TimeToSampleAtom *self, u32 duration) { - MP4Err err; - sttsEntryPtr current; - - err = MP4NoErr; - current = (sttsEntryPtr) self->currentEntry; - if ( (current == NULL) || (current->sampleDuration != duration) ) - { - current = (sttsEntryPtr) calloc( 1, sizeof(sttsEntry) ); - TESTMALLOC( current ); - current->sampleCount = 1; - current->sampleDuration = duration; - err = MP4AddListEntry( current, self->entryList ); if (err) goto bail; - self->currentEntry = current; - } - else - { - current->sampleCount++; - } + MP4Err err; + sttsEntryPtr current; + + err = MP4NoErr; + current = (sttsEntryPtr)self->currentEntry; + if((current == NULL) || (current->sampleDuration != duration)) + { + current = (sttsEntryPtr)calloc(1, sizeof(sttsEntry)); + TESTMALLOC(current); + current->sampleCount = 1; + current->sampleDuration = duration; + err = MP4AddListEntry(current, self->entryList); + if(err) goto bail; + self->currentEntry = current; + } + else + { + current->sampleCount++; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSamples( struct MP4TimeToSampleAtom *self, u32 sampleCount, MP4Handle durationsH ) +static MP4Err addSamples(struct MP4TimeToSampleAtom *self, u32 sampleCount, MP4Handle durationsH) { - MP4Err err; - u32 hasDurations; - u32 *durations; - u32 i; - - err = MP4NoErr; - durations = (u32 *) *durationsH; - err = MP4GetHandleSize( durationsH, &hasDurations ); if (err) goto bail; - hasDurations = hasDurations > sizeof(u32) ? 1 : 0; - for ( i = 0; i < sampleCount; i++ ) - { - u32 duration; - duration = hasDurations ? durations[i] : *durations; - err = addSample( self, duration ); if (err) goto bail; - } - err = MP4NoErr; + MP4Err err; + u32 hasDurations; + u32 *durations; + u32 i; + + err = MP4NoErr; + durations = (u32 *)*durationsH; + err = MP4GetHandleSize(durationsH, &hasDurations); + if(err) goto bail; + hasDurations = hasDurations > sizeof(u32) ? 1 : 0; + for(i = 0; i < sampleCount; i++) + { + u32 duration; + duration = hasDurations ? durations[i] : *durations; + err = addSample(self, duration); + if(err) goto bail; + } + err = MP4NoErr; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err extendLastSampleDuration( struct MP4TimeToSampleAtom *self, u32 duration ) +static MP4Err extendLastSampleDuration(struct MP4TimeToSampleAtom *self, u32 duration) { - MP4Err err; - sttsEntryPtr current; - - err = MP4NoErr; - current = (sttsEntryPtr) self->currentEntry; - - if (current->sampleCount == 1) - { - current->sampleDuration += duration; - } - else - { - current->sampleCount--; - err = addSample(self, current->sampleDuration + duration); if (err) goto bail; - } - + MP4Err err; + sttsEntryPtr current; + + err = MP4NoErr; + current = (sttsEntryPtr)self->currentEntry; + + if(current->sampleCount == 1) + { + current->sampleDuration += duration; + } + else + { + current->sampleCount--; + err = addSample(self, current->sampleDuration + duration); + if(err) goto bail; + } + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err getTimeForSampleNumber( MP4AtomPtr s, u32 sampleNumber, u64 *outSampleCTS, s32 *outSampleDuration ) +static MP4Err getTimeForSampleNumber(MP4AtomPtr s, u32 sampleNumber, u64 *outSampleCTS, + s32 *outSampleDuration) { - MP4Err err; - u32 i; - sttsEntryPtr pe; - u64 entryTime; - u32 entrySampleNumber; - u64 sampleCTS; - s32 sampleDuration; - u32 entryCount; - - MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = MP4NoErr; - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - - if ( self->foundEntry && (self->foundEntrySampleNumber < sampleNumber) ) - { - entryTime = self->foundEntryTime; - entrySampleNumber = self->foundEntrySampleNumber; - i = self->foundEntryNumber; - } - else - { - entryTime = 0; - entrySampleNumber = 1; - i = 0; - } - sampleCTS = -1; - sampleDuration = 0; - - for ( ; i < entryCount; i++ ) - { - err = MP4GetListEntry( self->entryList, i, (char**) &pe ); if (err) goto bail; + MP4Err err; + u32 i; + sttsEntryPtr pe; + u64 entryTime; + u32 entrySampleNumber; + u64 sampleCTS; + s32 sampleDuration; + u32 entryCount; + + MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = MP4NoErr; + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + + if(self->foundEntry && (self->foundEntrySampleNumber < sampleNumber)) + { + entryTime = self->foundEntryTime; + entrySampleNumber = self->foundEntrySampleNumber; + i = self->foundEntryNumber; + } + else + { + entryTime = 0; + entrySampleNumber = 1; + i = 0; + } + sampleCTS = -1; + sampleDuration = 0; + + for(; i < entryCount; i++) + { + err = MP4GetListEntry(self->entryList, i, (char **)&pe); + if(err) goto bail; #if 0 if ( (entrySampleNumber + pe->sampleCount) >= sampleNumber ) #else - if ( (entrySampleNumber + pe->sampleCount) > sampleNumber ) + if((entrySampleNumber + pe->sampleCount) > sampleNumber) #endif - { - /* this is the desired entry */ - u64 sampleOffset; - sampleOffset = sampleNumber - entrySampleNumber; - sampleCTS = entryTime + ((sampleNumber - entrySampleNumber) * pe->sampleDuration); - sampleDuration = pe->sampleDuration; - break; - } - else - { - /* go to next entry */ - entrySampleNumber += pe->sampleCount; - entryTime += (pe->sampleCount * pe->sampleDuration); - } - } - if ( outSampleCTS ) - *outSampleCTS = sampleCTS; - if ( outSampleDuration ) - *outSampleDuration = sampleDuration; - self->foundEntry = pe; - self->foundEntryTime = entryTime; - self->foundEntrySampleNumber = entrySampleNumber; - self->foundEntryNumber = i; + { + /* this is the desired entry */ + u64 sampleOffset; + sampleOffset = sampleNumber - entrySampleNumber; + sampleCTS = entryTime + ((sampleNumber - entrySampleNumber) * pe->sampleDuration); + sampleDuration = pe->sampleDuration; + break; + } + else + { + /* go to next entry */ + entrySampleNumber += pe->sampleCount; + entryTime += (pe->sampleCount * pe->sampleDuration); + } + } + if(outSampleCTS) *outSampleCTS = sampleCTS; + if(outSampleDuration) *outSampleDuration = sampleDuration; + self->foundEntry = pe; + self->foundEntryTime = entryTime; + self->foundEntrySampleNumber = entrySampleNumber; + self->foundEntryNumber = i; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err findSamples( MP4AtomPtr s, u64 desiredTime, s64 *outPriorSample, s64 *outExactSample, s64 *outNextSample, - u32 *outSampleNumber, s32 *outSampleDuration ) +static MP4Err findSamples(MP4AtomPtr s, u64 desiredTime, s64 *outPriorSample, s64 *outExactSample, + s64 *outNextSample, u32 *outSampleNumber, s32 *outSampleDuration) { - MP4Err err; - u32 entryCount; - u32 i; - - sttsEntryPtr pe; - u64 entryTime; - u32 sampleNumber; - int foundSample; - - MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = MP4NoErr; - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - entryTime = 0; - *outPriorSample = -1; - *outExactSample = -1; - *outNextSample = -1; - *outSampleNumber = 0; - sampleNumber = 1; - foundSample = 0; - - for ( i = 0; i < entryCount; i++ ) - { - s64 entryDuration; - u64 finalTime; - err = MP4GetListEntry( self->entryList, i, (char**) &pe ); if (err) goto bail; - entryDuration = pe->sampleDuration * pe->sampleCount; - finalTime = entryTime + entryDuration; - - if ( entryTime == desiredTime ) - { - *outExactSample = entryTime; - *outSampleNumber = sampleNumber; - *outSampleDuration = pe->sampleDuration; - foundSample = 1; - if ( entryTime + pe->sampleDuration <= finalTime ) - { - *outNextSample = entryTime + pe->sampleDuration; - break; - } - } - else if ( entryTime < desiredTime ) - { - *outPriorSample = entryTime; - } - else if ( entryTime > desiredTime ) - { - *outNextSample = entryTime; - break; - } - if ( finalTime < desiredTime ) - { - *outPriorSample = finalTime; - } - else if ( finalTime == desiredTime ) - { - *outPriorSample = finalTime - pe->sampleDuration; - *outExactSample = finalTime; - *outSampleNumber = sampleNumber + pe->sampleCount; - *outSampleDuration = pe->sampleDuration; - foundSample = 1; - } - else if ( finalTime > desiredTime ) - { - u32 bestSample; - u64 nextTime; - s64 timeDifference; - - /* next line was: timeDifference = finalTime - desiredTime; corrected by Per Frojdh */ - timeDifference = desiredTime - entryTime; - - bestSample = (u32) (timeDifference / pe->sampleDuration); - if ( foundSample == 0 ) - { - *outSampleNumber = sampleNumber + bestSample; - *outSampleDuration = pe->sampleDuration; - *outPriorSample = entryTime + (bestSample * pe->sampleDuration); - foundSample = 1; - } - nextTime = entryTime + (bestSample * pe->sampleDuration) + pe->sampleDuration; - if ( nextTime <= finalTime ) - { - *outNextSample = nextTime; - break; - } - } - entryTime += entryDuration; - sampleNumber += pe->sampleCount; - } - + MP4Err err; + u32 entryCount; + u32 i; + + sttsEntryPtr pe; + u64 entryTime; + u32 sampleNumber; + int foundSample; + + MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = MP4NoErr; + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + entryTime = 0; + *outPriorSample = -1; + *outExactSample = -1; + *outNextSample = -1; + *outSampleNumber = 0; + sampleNumber = 1; + foundSample = 0; + + for(i = 0; i < entryCount; i++) + { + s64 entryDuration; + u64 finalTime; + err = MP4GetListEntry(self->entryList, i, (char **)&pe); + if(err) goto bail; + entryDuration = pe->sampleDuration * pe->sampleCount; + finalTime = entryTime + entryDuration; + + if(entryTime == desiredTime) + { + *outExactSample = entryTime; + *outSampleNumber = sampleNumber; + *outSampleDuration = pe->sampleDuration; + foundSample = 1; + if(entryTime + pe->sampleDuration <= finalTime) + { + *outNextSample = entryTime + pe->sampleDuration; + break; + } + } + else if(entryTime < desiredTime) + { + *outPriorSample = entryTime; + } + else if(entryTime > desiredTime) + { + *outNextSample = entryTime; + break; + } + if(finalTime < desiredTime) + { + *outPriorSample = finalTime; + } + else if(finalTime == desiredTime) + { + *outPriorSample = finalTime - pe->sampleDuration; + *outExactSample = finalTime; + *outSampleNumber = sampleNumber + pe->sampleCount; + *outSampleDuration = pe->sampleDuration; + foundSample = 1; + } + else if(finalTime > desiredTime) + { + u32 bestSample; + u64 nextTime; + s64 timeDifference; + + /* next line was: timeDifference = finalTime - desiredTime; corrected by Per Frojdh */ + timeDifference = desiredTime - entryTime; + + bestSample = (u32)(timeDifference / pe->sampleDuration); + if(foundSample == 0) + { + *outSampleNumber = sampleNumber + bestSample; + *outSampleDuration = pe->sampleDuration; + *outPriorSample = entryTime + (bestSample * pe->sampleDuration); + foundSample = 1; + } + nextTime = entryTime + (bestSample * pe->sampleDuration) + pe->sampleDuration; + if(nextTime <= finalTime) + { + *outNextSample = nextTime; + break; + } + } + entryTime += entryDuration; + sampleNumber += pe->sampleCount; + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - sttsEntryPtr pe; - u32 entryCount; - MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - PUT32_V( entryCount ); - - for ( i = 0; i < entryCount; i++ ) - { - err = MP4GetListEntry( self->entryList, i, (char**) &pe ); if (err) goto bail; - PUT32_V( pe->sampleCount ); - PUT32_V( pe->sampleDuration ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + sttsEntryPtr pe; + u32 entryCount; + MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + PUT32_V(entryCount); + + for(i = 0; i < entryCount; i++) + { + err = MP4GetListEntry(self->entryList, i, (char **)&pe); + if(err) goto bail; + PUT32_V(pe->sampleCount); + PUT32_V(pe->sampleDuration); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr) s; - u32 entryCount; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - err = MP4GetListEntryCount( self->entryList, &entryCount ); if (err) goto bail; - self->size += 4 + (8 * entryCount); + MP4Err err; + MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr)s; + u32 entryCount; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + err = MP4GetListEntryCount(self->entryList, &entryCount); + if(err) goto bail; + self->size += 4 + (8 * entryCount); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 i; - u32 entryCount; - MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32_V( entryCount ); - for ( i = 0; i < entryCount; i++ ) - { - u32 count; - s32 duration; - sttsEntryPtr pe; - pe = (sttsEntryPtr) calloc( 1, sizeof(sttsEntry) ); - TESTMALLOC( pe ); - - GET32_V( count ); - GET32_V( duration ); - pe->sampleCount = count; - pe->sampleDuration = duration; - err = MP4AddListEntry( pe, self->entryList ); if (err) goto bail; - self->currentEntry = pe; - } + MP4Err err; + u32 i; + u32 entryCount; + MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32_V(entryCount); + for(i = 0; i < entryCount; i++) + { + u32 count; + s32 duration; + sttsEntryPtr pe; + pe = (sttsEntryPtr)calloc(1, sizeof(sttsEntry)); + TESTMALLOC(pe); + + GET32_V(count); + GET32_V(duration); + pe->sampleCount = count; + pe->sampleDuration = duration; + err = MP4AddListEntry(pe, self->entryList); + if(err) goto bail; + self->currentEntry = pe; + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateTimeToSampleAtom( MP4TimeToSampleAtomPtr *outAtom ) +MP4Err MP4CreateTimeToSampleAtom(MP4TimeToSampleAtomPtr *outAtom) { - MP4Err err; - MP4TimeToSampleAtomPtr self; - - self = (MP4TimeToSampleAtomPtr) calloc( 1, sizeof(MP4TimeToSampleAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - - err = MP4MakeLinkedList( &self->entryList ); if (err) goto bail; - self->type = MP4TimeToSampleAtomType; - self->name = "time to sample"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->findSamples = findSamples; - self->getTimeForSampleNumber = getTimeForSampleNumber; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->getTotalDuration = getTotalDuration; - self->addSamples = addSamples; - self->extendLastSampleDuration = extendLastSampleDuration; - *outAtom = self; + MP4Err err; + MP4TimeToSampleAtomPtr self; + + self = (MP4TimeToSampleAtomPtr)calloc(1, sizeof(MP4TimeToSampleAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + + err = MP4MakeLinkedList(&self->entryList); + if(err) goto bail; + self->type = MP4TimeToSampleAtomType; + self->name = "time to sample"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->findSamples = findSamples; + self->getTimeForSampleNumber = getTimeForSampleNumber; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->getTotalDuration = getTotalDuration; + self->addSamples = addSamples; + self->extendLastSampleDuration = extendLastSampleDuration; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TrackAtom.c b/IsoLib/libisomediafile/src/TrackAtom.c index 34bd09a..bf40cf3 100644 --- a/IsoLib/libisomediafile/src/TrackAtom.c +++ b/IsoLib/libisomediafile/src/TrackAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,516 +15,506 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include #include -static MP4Err addAtom( MP4TrackAtomPtr self, MP4AtomPtr atom ); +static MP4Err addAtom(MP4TrackAtomPtr self, MP4AtomPtr atom); -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4TrackAtomPtr self; - u32 i; - err = MP4NoErr; - self = (MP4TrackAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); - bail: - TEST_RETURN( err ); - - return; + MP4Err err; + MP4TrackAtomPtr self; + u32 i; + err = MP4NoErr; + self = (MP4TrackAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); +bail: + TEST_RETURN(err); + + return; } -static MP4Err setMdat( struct MP4TrackAtom *self, MP4AtomPtr mdat ) +static MP4Err setMdat(struct MP4TrackAtom *self, MP4AtomPtr mdat) { - self->mdat = mdat; - return MP4NoErr; + self->mdat = mdat; + return MP4NoErr; } -static MP4Err setMoov( struct MP4TrackAtom *self, MP4PrivateMovieRecordPtr moov ) +static MP4Err setMoov(struct MP4TrackAtom *self, MP4PrivateMovieRecordPtr moov) { - self->moov = moov; - return MP4NoErr; + self->moov = moov; + return MP4NoErr; } -static MP4Err newMedia( struct MP4TrackAtom *self, MP4Media *outMedia, u32 mediaType, u32 timeScale, MP4Handle dataURL ) +static MP4Err newMedia(struct MP4TrackAtom *self, MP4Media *outMedia, u32 mediaType, u32 timeScale, + MP4Handle dataURL) { - MP4Err MP4CreateMediaAtom( MP4MediaAtomPtr *outAtom ); - - MP4Err err; - MP4Media media; - MP4MediaAtomPtr mdia; - - err = MP4NoErr; - err = MP4CreateMediaAtom( &mdia ); if (err) goto bail; - media = (MP4Media) mdia; - err = mdia->setupNew( mdia, (MP4AtomPtr) self, mediaType, timeScale, dataURL ); if (err) goto bail; - err = addAtom( self, (MP4AtomPtr) mdia ); if (err) goto bail; - *outMedia = media; - bail: - TEST_RETURN( err ); - - return err; + MP4Err MP4CreateMediaAtom(MP4MediaAtomPtr * outAtom); + + MP4Err err; + MP4Media media; + MP4MediaAtomPtr mdia; + + err = MP4NoErr; + err = MP4CreateMediaAtom(&mdia); + if(err) goto bail; + media = (MP4Media)mdia; + err = mdia->setupNew(mdia, (MP4AtomPtr)self, mediaType, timeScale, dataURL); + if(err) goto bail; + err = addAtom(self, (MP4AtomPtr)mdia); + if(err) goto bail; + *outMedia = media; +bail: + TEST_RETURN(err); + + return err; } -static MP4Err adjustedDuration( u32 mediaDuration, u32 mediaTimeScale, u32 movieTimeScale, u32 *outDuration ) +static MP4Err adjustedDuration(u32 mediaDuration, u32 mediaTimeScale, u32 movieTimeScale, + u32 *outDuration) { - MP4Err err; - - err = MP4NoErr; - - if ( mediaTimeScale == 0 ) - BAILWITHERROR( MP4BadParamErr ); - *outDuration = (u32) ((((u64) mediaDuration) * ((u64)movieTimeScale)) / ((u64)mediaTimeScale)); - bail: - TEST_RETURN( err ); - return err; + MP4Err err; + + err = MP4NoErr; + + if(mediaTimeScale == 0) BAILWITHERROR(MP4BadParamErr); + *outDuration = (u32)((((u64)mediaDuration) * ((u64)movieTimeScale)) / ((u64)mediaTimeScale)); +bail: + TEST_RETURN(err); + return err; } -static MP4Err mdatArrived( struct MP4TrackAtom* self, MP4AtomPtr mdat ) +static MP4Err mdatArrived(struct MP4TrackAtom *self, MP4AtomPtr mdat) { - MP4Err err; - MP4MediaAtomPtr mdia; - MP4MediaInformationAtomPtr minf; - ISOMetaAtomPtr meta; - ISOAdditionalMetaDataContainerAtomPtr meco; - - err = MP4NoErr; - - meta = (ISOMetaAtomPtr) self->meta; - if (meta) { - meta->setMdat( meta, (MP4AtomPtr) mdat ); - } - - meco = (ISOAdditionalMetaDataContainerAtomPtr) self->meco; - if (meco) { - meco->setMdat( meco, (MP4AtomPtr) mdat ); - } - - mdia = (MP4MediaAtomPtr) self->trackMedia; - if ( mdia == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - minf = (MP4MediaInformationAtomPtr) mdia->information; - if (minf == NULL) - BAILWITHERROR( MP4InvalidMediaErr ); - - err = minf->mdatArrived( minf, mdat ); if (err) goto bail; - bail: - TEST_RETURN( err ); - return err; + MP4Err err; + MP4MediaAtomPtr mdia; + MP4MediaInformationAtomPtr minf; + ISOMetaAtomPtr meta; + ISOAdditionalMetaDataContainerAtomPtr meco; + + err = MP4NoErr; + + meta = (ISOMetaAtomPtr)self->meta; + if(meta) + { + meta->setMdat(meta, (MP4AtomPtr)mdat); + } + + meco = (ISOAdditionalMetaDataContainerAtomPtr)self->meco; + if(meco) + { + meco->setMdat(meco, (MP4AtomPtr)mdat); + } + + mdia = (MP4MediaAtomPtr)self->trackMedia; + if(mdia == NULL) BAILWITHERROR(MP4InvalidMediaErr); + minf = (MP4MediaInformationAtomPtr)mdia->information; + if(minf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + err = minf->mdatArrived(minf, mdat); + if(err) goto bail; +bail: + TEST_RETURN(err); + return err; } -static MP4Err mdatMoved( struct MP4TrackAtom* self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) +static MP4Err mdatMoved(struct MP4TrackAtom *self, u64 mdatBase, u64 mdatEnd, s32 mdatOffset) { - MP4Err err; - MP4MediaAtomPtr mdia; - ISOMetaAtomPtr meta; - ISOAdditionalMetaDataContainerAtomPtr meco; - - err = MP4NoErr; - mdia = (MP4MediaAtomPtr) self->trackMedia; - if ( mdia == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - err = mdia->mdatMoved( mdia, mdatBase, mdatEnd, mdatOffset ); if (err) goto bail; - - meta = (ISOMetaAtomPtr) self->meta; - if (meta) { - err = meta->mdatMoved( meta, mdatBase, mdatEnd, mdatOffset ); if (err) goto bail; - } - - meco = (ISOAdditionalMetaDataContainerAtomPtr) self->meco; - if (meco) { - err = meco->mdatMoved( meco, mdatBase, mdatEnd, mdatOffset ); if (err) goto bail; - } - bail: - TEST_RETURN( err ); - return err; + MP4Err err; + MP4MediaAtomPtr mdia; + ISOMetaAtomPtr meta; + ISOAdditionalMetaDataContainerAtomPtr meco; + + err = MP4NoErr; + mdia = (MP4MediaAtomPtr)self->trackMedia; + if(mdia == NULL) BAILWITHERROR(MP4InvalidMediaErr); + err = mdia->mdatMoved(mdia, mdatBase, mdatEnd, mdatOffset); + if(err) goto bail; + + meta = (ISOMetaAtomPtr)self->meta; + if(meta) + { + err = meta->mdatMoved(meta, mdatBase, mdatEnd, mdatOffset); + if(err) goto bail; + } + + meco = (ISOAdditionalMetaDataContainerAtomPtr)self->meco; + if(meco) + { + err = meco->mdatMoved(meco, mdatBase, mdatEnd, mdatOffset); + if(err) goto bail; + } +bail: + TEST_RETURN(err); + return err; } - -static MP4Err calculateDuration( struct MP4TrackAtom *self, u32 movieTimeScale ) +static MP4Err calculateDuration(struct MP4TrackAtom *self, u32 movieTimeScale) { - MP4Err err; - MP4TrackHeaderAtomPtr tkhd; - MP4EditAtomPtr edts; - MP4MediaAtomPtr mdia; - MP4MediaHeaderAtomPtr mhdr; - u32 mediaDuration; - u32 mediaTimeScale; - u32 trackDuration; - - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - edts = (MP4EditAtomPtr) self->trackEditAtom; - err = MP4NoErr; - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - mdia = (MP4MediaAtomPtr) self->trackMedia; - if ( mdia == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - mhdr = (MP4MediaHeaderAtomPtr) mdia->mediaHeader; - mediaDuration = (u32) mhdr->duration; - mediaTimeScale = (u32) mhdr->timeScale; - - trackDuration = 0; - - if ( edts ) - { - err = edts->getEffectiveDuration( edts, &trackDuration ); if (err) goto bail; - } - - if (trackDuration == 0) /* either no edit list at all, or an edit list with no entries */ - { - err = adjustedDuration( mediaDuration, mediaTimeScale, movieTimeScale, &trackDuration ); if (err) goto bail; - } - tkhd->duration = trackDuration; - bail: - TEST_RETURN( err ); - return err; + MP4Err err; + MP4TrackHeaderAtomPtr tkhd; + MP4EditAtomPtr edts; + MP4MediaAtomPtr mdia; + MP4MediaHeaderAtomPtr mhdr; + u32 mediaDuration; + u32 mediaTimeScale; + u32 trackDuration; + + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + edts = (MP4EditAtomPtr)self->trackEditAtom; + err = MP4NoErr; + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + mdia = (MP4MediaAtomPtr)self->trackMedia; + if(mdia == NULL) BAILWITHERROR(MP4InvalidMediaErr); + mhdr = (MP4MediaHeaderAtomPtr)mdia->mediaHeader; + mediaDuration = (u32)mhdr->duration; + mediaTimeScale = (u32)mhdr->timeScale; + + trackDuration = 0; + + if(edts) + { + err = edts->getEffectiveDuration(edts, &trackDuration); + if(err) goto bail; + } + + if(trackDuration == 0) /* either no edit list at all, or an edit list with no entries */ + { + err = adjustedDuration(mediaDuration, mediaTimeScale, movieTimeScale, &trackDuration); + if(err) goto bail; + } + tkhd->duration = trackDuration; +bail: + TEST_RETURN(err); + return err; } -static MP4Err getDuration( struct MP4TrackAtom *self, u32 *outDuration ) +static MP4Err getDuration(struct MP4TrackAtom *self, u32 *outDuration) { - MP4Err err; - MP4TrackHeaderAtomPtr tkhd; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - - err = MP4NoErr; - if ( outDuration == NULL ) - BAILWITHERROR( MP4BadParamErr ); - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - *outDuration = (u32) tkhd->duration; + MP4Err err; + MP4TrackHeaderAtomPtr tkhd; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + + err = MP4NoErr; + if(outDuration == NULL) BAILWITHERROR(MP4BadParamErr); + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + *outDuration = (u32)tkhd->duration; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err setMatrix( struct MP4TrackAtom* self, u32 matrix[9] ) +static MP4Err setMatrix(struct MP4TrackAtom *self, u32 matrix[9]) { - MP4TrackHeaderAtomPtr tkhd; - MP4Err err; - err = MP4NoErr; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - memcpy( &(tkhd->qt_matrixA), matrix, sizeof(ISOMatrixRecord) ); + MP4TrackHeaderAtomPtr tkhd; + MP4Err err; + err = MP4NoErr; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + memcpy(&(tkhd->qt_matrixA), matrix, sizeof(ISOMatrixRecord)); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getMatrix( struct MP4TrackAtom* self, u32 outMatrix[9] ) +static MP4Err getMatrix(struct MP4TrackAtom *self, u32 outMatrix[9]) { - MP4TrackHeaderAtomPtr tkhd; - MP4Err err; - err = MP4NoErr; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - memcpy( outMatrix, &(tkhd->qt_matrixA), sizeof(ISOMatrixRecord) ); + MP4TrackHeaderAtomPtr tkhd; + MP4Err err; + err = MP4NoErr; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + memcpy(outMatrix, &(tkhd->qt_matrixA), sizeof(ISOMatrixRecord)); bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err setLayer( struct MP4TrackAtom* self, s16 layer ) +static MP4Err setLayer(struct MP4TrackAtom *self, s16 layer) { - MP4TrackHeaderAtomPtr tkhd; - MP4Err err; - err = MP4NoErr; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - tkhd->qt_layer = layer; + MP4TrackHeaderAtomPtr tkhd; + MP4Err err; + err = MP4NoErr; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + tkhd->qt_layer = layer; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getLayer( struct MP4TrackAtom* self, s16 *outLayer ) +static MP4Err getLayer(struct MP4TrackAtom *self, s16 *outLayer) { - MP4TrackHeaderAtomPtr tkhd; - MP4Err err; - err = MP4NoErr; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - *outLayer = (s16) tkhd->qt_layer; + MP4TrackHeaderAtomPtr tkhd; + MP4Err err; + err = MP4NoErr; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + *outLayer = (s16)tkhd->qt_layer; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err setDimensions( struct MP4TrackAtom* self, u32 width, u32 height ) +static MP4Err setDimensions(struct MP4TrackAtom *self, u32 width, u32 height) { - MP4TrackHeaderAtomPtr tkhd; - MP4Err err; - err = MP4NoErr; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - tkhd->qt_trackWidth = width << 16; - tkhd->qt_trackHeight = height << 16; + MP4TrackHeaderAtomPtr tkhd; + MP4Err err; + err = MP4NoErr; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + tkhd->qt_trackWidth = width << 16; + tkhd->qt_trackHeight = height << 16; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getDimensions( struct MP4TrackAtom* self, u32 *outWidth, u32 *outHeight ) +static MP4Err getDimensions(struct MP4TrackAtom *self, u32 *outWidth, u32 *outHeight) { - MP4TrackHeaderAtomPtr tkhd; - MP4Err err; - err = MP4NoErr; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - *outWidth = (u32) (tkhd->qt_trackWidth >> 16); - *outHeight = (u32) (tkhd->qt_trackHeight >> 16); + MP4TrackHeaderAtomPtr tkhd; + MP4Err err; + err = MP4NoErr; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + *outWidth = (u32)(tkhd->qt_trackWidth >> 16); + *outHeight = (u32)(tkhd->qt_trackHeight >> 16); bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err setVolume( struct MP4TrackAtom* self, s16 volume ) +static MP4Err setVolume(struct MP4TrackAtom *self, s16 volume) { - MP4TrackHeaderAtomPtr tkhd; - MP4Err err; - err = MP4NoErr; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - tkhd->qt_volume = volume; + MP4TrackHeaderAtomPtr tkhd; + MP4Err err; + err = MP4NoErr; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + tkhd->qt_volume = volume; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getVolume( struct MP4TrackAtom* self, s16 *outVolume ) +static MP4Err getVolume(struct MP4TrackAtom *self, s16 *outVolume) { - MP4TrackHeaderAtomPtr tkhd; - MP4Err err; - err = MP4NoErr; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - *outVolume = (s16) tkhd->qt_volume; + MP4TrackHeaderAtomPtr tkhd; + MP4Err err; + err = MP4NoErr; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + *outVolume = (s16)tkhd->qt_volume; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err setEnabled( struct MP4TrackAtom *self, u32 enabled ) +static MP4Err setEnabled(struct MP4TrackAtom *self, u32 enabled) { - MP4TrackHeaderAtomPtr tkhd; - MP4Err err; - - err = MP4NoErr; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - if ( tkhd == NULL ) - BAILWITHERROR( MP4InvalidMediaErr ); - - if ( enabled ) - tkhd->flags |= 1; - else - tkhd->flags &= ~1; - bail: - TEST_RETURN( err ); - return err; + MP4TrackHeaderAtomPtr tkhd; + MP4Err err; + + err = MP4NoErr; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + if(tkhd == NULL) BAILWITHERROR(MP4InvalidMediaErr); + + if(enabled) tkhd->flags |= 1; + else + tkhd->flags &= ~1; +bail: + TEST_RETURN(err); + return err; } -static MP4Err getEnabled( struct MP4TrackAtom *self, u32 *outEnabled ) +static MP4Err getEnabled(struct MP4TrackAtom *self, u32 *outEnabled) { - MP4TrackHeaderAtomPtr tkhd; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - *outEnabled = tkhd->flags & 1 ? 1 : 0; - return MP4NoErr; + MP4TrackHeaderAtomPtr tkhd; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + *outEnabled = tkhd->flags & 1 ? 1 : 0; + return MP4NoErr; } -static MP4Err settrackfragment (struct MP4TrackAtom *self, u32 trackID, MP4AtomPtr fragment ) +static MP4Err settrackfragment(struct MP4TrackAtom *self, u32 trackID, MP4AtomPtr fragment) { - MP4Err err; - MP4TrackHeaderAtomPtr tkhd; - - err = MP4NoErr; - tkhd = (MP4TrackHeaderAtomPtr) self->trackHeader; - - if (tkhd->trackID == trackID) - { - MP4MediaAtomPtr mdia; - mdia = (MP4MediaAtomPtr) self->trackMedia; - err = mdia->settrackfragment( mdia, fragment ); - } - - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4TrackHeaderAtomPtr tkhd; + + err = MP4NoErr; + tkhd = (MP4TrackHeaderAtomPtr)self->trackHeader; + + if(tkhd->trackID == trackID) + { + MP4MediaAtomPtr mdia; + mdia = (MP4MediaAtomPtr)self->trackMedia; + err = mdia->settrackfragment(mdia, fragment); + } + + TEST_RETURN(err); + + return err; } -static MP4Err addAtom( MP4TrackAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4TrackAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; - switch( atom->type ) - { - case MP4TrackHeaderAtomType: - if ( self->trackHeader ) - BAILWITHERROR( MP4BadDataErr ); - self->trackHeader = atom; - break; - - case MP4EditAtomType: - if ( self->trackEditAtom ) - BAILWITHERROR( MP4BadDataErr ); - self->trackEditAtom = atom; - break; - - case MP4UserDataAtomType: - if ( self->udta ) - BAILWITHERROR( MP4BadDataErr ); - self->udta = atom; - break; - - case MP4TrackReferenceAtomType: - if ( self->trackReferences ) - BAILWITHERROR( MP4BadDataErr ); - self->trackReferences = atom; - break; - - case MP4TrackGroupAtomType: - if (self->trackGroups) - BAILWITHERROR(MP4BadDataErr); - self->trackGroups = atom; - break; - - case MP4MediaAtomType: - if ( self->trackMedia ) - BAILWITHERROR( MP4BadDataErr ); - self->trackMedia = atom; - ((MP4MediaAtomPtr) atom)->mediaTrack = (MP4AtomPtr) self; - break; - - case ISOMetaAtomType: - if ( self->meta ) - BAILWITHERROR( MP4BadDataErr ) - self->meta = atom; - break; - - case ISOAdditionalMetaDataContainerAtomType: - if ( self->meco ) - BAILWITHERROR( MP4BadDataErr ) - self->meco = atom; - break; - } - - - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + err = MP4NoErr; + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; + switch(atom->type) + { + case MP4TrackHeaderAtomType: + if(self->trackHeader) BAILWITHERROR(MP4BadDataErr); + self->trackHeader = atom; + break; + + case MP4EditAtomType: + if(self->trackEditAtom) BAILWITHERROR(MP4BadDataErr); + self->trackEditAtom = atom; + break; + + case MP4UserDataAtomType: + if(self->udta) BAILWITHERROR(MP4BadDataErr); + self->udta = atom; + break; + + case MP4TrackReferenceAtomType: + if(self->trackReferences) BAILWITHERROR(MP4BadDataErr); + self->trackReferences = atom; + break; + + case MP4TrackGroupAtomType: + if(self->trackGroups) BAILWITHERROR(MP4BadDataErr); + self->trackGroups = atom; + break; + + case MP4MediaAtomType: + if(self->trackMedia) BAILWITHERROR(MP4BadDataErr); + self->trackMedia = atom; + ((MP4MediaAtomPtr)atom)->mediaTrack = (MP4AtomPtr)self; + break; + + case ISOMetaAtomType: + if(self->meta) BAILWITHERROR(MP4BadDataErr) + self->meta = atom; + break; + + case ISOAdditionalMetaDataContainerAtomType: + if(self->meco) BAILWITHERROR(MP4BadDataErr) + self->meco = atom; + break; + } + +bail: + TEST_RETURN(err); + + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4TrackAtomPtr self = (MP4TrackAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4TrackAtomPtr self = (MP4TrackAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); +bail: + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4TrackAtomPtr self = (MP4TrackAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE( atomList ); - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4TrackAtomPtr self = (MP4TrackAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); +bail: + TEST_RETURN(err); + + return err; } -static MP4Err trakAtomCreateFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, /*MP4InputStreamPtr*/ char* inputStream ) +static MP4Err trakAtomCreateFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, + /*MP4InputStreamPtr*/ char *inputStream) { - PARSE_ATOM_LIST(MP4TrackAtom) + PARSE_ATOM_LIST(MP4TrackAtom) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateTrackAtom( MP4TrackAtomPtr *outAtom ) +MP4Err MP4CreateTrackAtom(MP4TrackAtomPtr *outAtom) { - MP4Err err; - MP4TrackAtomPtr self; - - self = (MP4TrackAtomPtr) calloc( 1, sizeof(MP4TrackAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4TrackAtomType; - self->name = "track"; - self->createFromInputStream = trakAtomCreateFromInputStream; - self->destroy = destroy; - self->addAtom = addAtom; - self->setMoov = setMoov; - self->setMdat = setMdat; - self->newMedia = newMedia; - self->setEnabled = setEnabled; - self->getEnabled = getEnabled; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->calculateDuration = calculateDuration; - self->getDuration = getDuration; - self->setMatrix = setMatrix; - self->getMatrix = getMatrix; - self->setLayer = setLayer; - self->getLayer = getLayer; - self->setDimensions = setDimensions; - self->getDimensions = getDimensions; - self->setVolume = setVolume; - self->getVolume = getVolume; - self->mdatMoved = mdatMoved; - self->mdatArrived = mdatArrived; - self->settrackfragment = settrackfragment; - - self->meta = NULL; - self->meco = NULL; - - *outAtom = self; - + MP4Err err; + MP4TrackAtomPtr self; + + self = (MP4TrackAtomPtr)calloc(1, sizeof(MP4TrackAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4TrackAtomType; + self->name = "track"; + self->createFromInputStream = trakAtomCreateFromInputStream; + self->destroy = destroy; + self->addAtom = addAtom; + self->setMoov = setMoov; + self->setMdat = setMdat; + self->newMedia = newMedia; + self->setEnabled = setEnabled; + self->getEnabled = getEnabled; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->calculateDuration = calculateDuration; + self->getDuration = getDuration; + self->setMatrix = setMatrix; + self->getMatrix = getMatrix; + self->setLayer = setLayer; + self->getLayer = getLayer; + self->setDimensions = setDimensions; + self->getDimensions = getDimensions; + self->setVolume = setVolume; + self->getVolume = getVolume; + self->mdatMoved = mdatMoved; + self->mdatArrived = mdatArrived; + self->settrackfragment = settrackfragment; + + self->meta = NULL; + self->meco = NULL; + + *outAtom = self; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TrackExtendsAtom.c b/IsoLib/libisomediafile/src/TrackExtendsAtom.c index 34f09e9..6e30b58 100644 --- a/IsoLib/libisomediafile/src/TrackExtendsAtom.c +++ b/IsoLib/libisomediafile/src/TrackExtendsAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,112 +15,113 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackExtendsAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackExtendsAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4TrackExtendsAtomPtr self = (MP4TrackExtendsAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( trackID ); - PUT32( default_sample_description_index ); - PUT32( default_sample_duration ); - PUT32( default_sample_size ); - PUT32( default_sample_flags ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4TrackExtendsAtomPtr self = (MP4TrackExtendsAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(trackID); + PUT32(default_sample_description_index); + PUT32(default_sample_duration); + PUT32(default_sample_size); + PUT32(default_sample_flags); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4TrackExtendsAtomPtr self = (MP4TrackExtendsAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += (5*4); + MP4Err err; + MP4TrackExtendsAtomPtr self = (MP4TrackExtendsAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += (5 * 4); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4TrackExtendsAtomPtr self = (MP4TrackExtendsAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET32( trackID ); - GET32( default_sample_description_index ); - GET32( default_sample_duration ); - GET32( default_sample_size ); - GET32( default_sample_flags ); + MP4Err err; + MP4TrackExtendsAtomPtr self = (MP4TrackExtendsAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(trackID); + GET32(default_sample_description_index); + GET32(default_sample_duration); + GET32(default_sample_size); + GET32(default_sample_flags); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateTrackExtendsAtom( MP4TrackExtendsAtomPtr *outAtom ) +MP4Err MP4CreateTrackExtendsAtom(MP4TrackExtendsAtomPtr *outAtom) { - MP4Err err; - MP4TrackExtendsAtomPtr self; - - self = (MP4TrackExtendsAtomPtr) calloc( 1, sizeof(MP4TrackExtendsAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4TrackExtendsAtomType; - self->name = "track extends"; - self->flags = 0; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - self->isInitialMediaDecodeTimeAdded = 0; - self->baseMediaDecodeTime = 0; - - *outAtom = self; + MP4Err err; + MP4TrackExtendsAtomPtr self; + + self = (MP4TrackExtendsAtomPtr)calloc(1, sizeof(MP4TrackExtendsAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4TrackExtendsAtomType; + self->name = "track extends"; + self->flags = 0; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + self->isInitialMediaDecodeTimeAdded = 0; + self->baseMediaDecodeTime = 0; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TrackExtensionPropertiesAtom.c b/IsoLib/libisomediafile/src/TrackExtensionPropertiesAtom.c index c95d3a5..a57f460 100644 --- a/IsoLib/libisomediafile/src/TrackExtensionPropertiesAtom.c +++ b/IsoLib/libisomediafile/src/TrackExtensionPropertiesAtom.c @@ -28,136 +28,141 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4TrackExtensionPropertiesAtomPtr self = (MP4TrackExtensionPropertiesAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4TrackExtensionPropertiesAtomPtr self = (MP4TrackExtensionPropertiesAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } -static MP4Err getAtom( MP4TrackExtensionPropertiesAtomPtr self, u32 atomType, MP4AtomPtr *outAtom ) +static MP4Err getAtom(MP4TrackExtensionPropertiesAtomPtr self, u32 atomType, MP4AtomPtr *outAtom) { - u32 i; - MP4Err err; - u32 count; - err = MP4NoErr; - - MP4GetListEntryCount( self->atomList, &count ); - for( i = 0; i < count; i++ ) + u32 i; + MP4Err err; + u32 count; + err = MP4NoErr; + + MP4GetListEntryCount(self->atomList, &count); + for(i = 0; i < count; i++) + { + MP4AtomPtr atom; + + err = MP4GetListEntry(self->atomList, i, (char **)&atom); + if(err) goto bail; + + if(atom->type == atomType) { - MP4AtomPtr atom; - - err = MP4GetListEntry( self->atomList, i, (char **) &atom ); if (err) goto bail; - - if (atom->type == atomType) { - *outAtom = atom; - break; - } + *outAtom = atom; + break; } + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err addAtom( MP4TrackExtensionPropertiesAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4TrackExtensionPropertiesAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - err = MP4NoErr; - err = MP4AddListEntry( atom, self->atomList ); if (err) goto bail; + MP4Err err; + err = MP4NoErr; + err = MP4AddListEntry(atom, self->atomList); + if(err) goto bail; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4TrackExtensionPropertiesAtomPtr self = (MP4TrackExtensionPropertiesAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( track_id ); - SERIALIZE_ATOM_LIST( atomList ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4TrackExtensionPropertiesAtomPtr self = (MP4TrackExtensionPropertiesAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(track_id); + SERIALIZE_ATOM_LIST(atomList); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4TrackExtensionPropertiesAtomPtr self = (MP4TrackExtensionPropertiesAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4; - - ADD_ATOM_LIST_SIZE( atomList ); + MP4Err err; + MP4TrackExtensionPropertiesAtomPtr self = (MP4TrackExtensionPropertiesAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4; + + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4TrackExtensionPropertiesAtomPtr self = (MP4TrackExtensionPropertiesAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - GET32( track_id ); - GETATOM_LIST( atomList ); - - assert( self->bytesRead == self->size ); - + MP4Err err; + MP4TrackExtensionPropertiesAtomPtr self = (MP4TrackExtensionPropertiesAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + GET32(track_id); + GETATOM_LIST(atomList); + + assert(self->bytesRead == self->size); + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err MP4CreateTrackExtensionPropertiesAtom( MP4TrackExtensionPropertiesAtomPtr *outAtom ) +MP4Err MP4CreateTrackExtensionPropertiesAtom(MP4TrackExtensionPropertiesAtomPtr *outAtom) { - MP4Err err; - MP4TrackExtensionPropertiesAtomPtr self; - - self = (MP4TrackExtensionPropertiesAtomPtr) calloc( 1, sizeof(MP4TrackExtensionPropertiesAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4TrackExtensionPropertiesAtomType; - self->name = "track extension properties"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->track_id = 0; - self->addAtom = addAtom; - self->getAtom = getAtom; - - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - - *outAtom = self; + MP4Err err; + MP4TrackExtensionPropertiesAtomPtr self; + + self = (MP4TrackExtensionPropertiesAtomPtr)calloc(1, sizeof(MP4TrackExtensionPropertiesAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4TrackExtensionPropertiesAtomType; + self->name = "track extension properties"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->track_id = 0; + self->addAtom = addAtom; + self->getAtom = getAtom; + + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index 5dbc975..e35ab4c 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,357 +15,394 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackFragmentAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackFragmentAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include - -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4TrackFragmentAtomPtr self; + MP4Err err; + MP4TrackFragmentAtomPtr self; - self = (MP4TrackFragmentAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST_F( atomList ); - DESTROY_ATOM_LIST_F( groupList ); - DESTROY_ATOM_LIST_F( groupDescriptionList ); - DESTROY_ATOM_LIST_F( compactSampleGroupList ); - (self->tfhd)->destroy( (MP4AtomPtr) (self->tfhd) ); - (self->tfdt)->destroy( (MP4AtomPtr) (self->tfdt) ); + self = (MP4TrackFragmentAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST_F(atomList); + DESTROY_ATOM_LIST_F(groupList); + DESTROY_ATOM_LIST_F(groupDescriptionList); + DESTROY_ATOM_LIST_F(compactSampleGroupList); + (self->tfhd)->destroy((MP4AtomPtr)(self->tfhd)); + (self->tfdt)->destroy((MP4AtomPtr)(self->tfdt)); - if ( self->super ) - self->super->destroy( s ); + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err addAtom( MP4TrackFragmentAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4TrackFragmentAtomPtr self, MP4AtomPtr atom) { MP4Err err; err = MP4NoErr; - if ( self == 0 ) - BAILWITHERROR( MP4BadParamErr ); - switch (atom->type) + if(self == 0) BAILWITHERROR(MP4BadParamErr); + switch(atom->type) { - case MP4TrackFragmentHeaderAtomType: self->tfhd = atom; break; - case MP4TrackFragmentDecodeTimeAtomType: self->tfdt = atom; break; - case MP4SampleAuxiliaryInformationSizesAtomType: err = MP4AddListEntry( atom, self->saizList ); break; - case MP4SampleAuxiliaryInformationOffsetsAtomType: err = MP4AddListEntry( atom, self->saioList ); break; - case MP4TrackRunAtomType: err = MP4AddListEntry( atom, self->atomList ); break; - case MP4SampletoGroupAtomType: err = MP4AddListEntry( atom, self->groupList ); break; /* sbgp */ - case MP4SampleGroupDescriptionAtomType: err = MP4AddListEntry( atom, self->groupDescriptionList ); break; /* sgpd */ - case MP4CompactSampletoGroupAtomType: err = MP4AddListEntry( atom, self->compactSampleGroupList ); break; + case MP4TrackFragmentHeaderAtomType: + self->tfhd = atom; + break; + case MP4TrackFragmentDecodeTimeAtomType: + self->tfdt = atom; + break; + case MP4SampleAuxiliaryInformationSizesAtomType: + err = MP4AddListEntry(atom, self->saizList); + break; + case MP4SampleAuxiliaryInformationOffsetsAtomType: + err = MP4AddListEntry(atom, self->saioList); + break; + case MP4TrackRunAtomType: + err = MP4AddListEntry(atom, self->atomList); + break; + case MP4SampletoGroupAtomType: + err = MP4AddListEntry(atom, self->groupList); + break; /* sbgp */ + case MP4SampleGroupDescriptionAtomType: + err = MP4AddListEntry(atom, self->groupDescriptionList); + break; /* sgpd */ + case MP4CompactSampletoGroupAtomType: + err = MP4AddListEntry(atom, self->compactSampleGroupList); + break; /* default: BAILWITHERROR( MP4BadDataErr ) */ } bail: - TEST_RETURN( err ); + TEST_RETURN(err); return err; } -static MP4Err mdatMoved( struct MP4MediaInformationAtom* s, u64 mdatBase, u64 mdatEnd, s32 mdatOffset ) +static MP4Err mdatMoved(struct MP4MediaInformationAtom *s, u64 mdatBase, u64 mdatEnd, + s32 mdatOffset) { - MP4Err err; - MP4TrackFragmentAtomPtr self; - MP4TrackFragmentHeaderAtomPtr tfhd; - u64 mdatSize; - - self = (MP4TrackFragmentAtomPtr) s; - - err = MP4NoErr; - mdatSize = mdatEnd - mdatBase; /* not something we need to know, but it avoids an unused param warning */ - - tfhd = (MP4TrackFragmentHeaderAtomPtr) self->tfhd; - if (tfhd==NULL) BAILWITHERROR( MP4BadParamErr ) - - if (self->samples_use_mdat == 1) tfhd->base_data_offset = mdatOffset; - + MP4Err err; + MP4TrackFragmentAtomPtr self; + MP4TrackFragmentHeaderAtomPtr tfhd; + u64 mdatSize; + + self = (MP4TrackFragmentAtomPtr)s; + + err = MP4NoErr; + mdatSize = + mdatEnd - mdatBase; /* not something we need to know, but it avoids an unused param warning */ + + tfhd = (MP4TrackFragmentHeaderAtomPtr)self->tfhd; + if(tfhd == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->samples_use_mdat == 1) tfhd->base_data_offset = mdatOffset; + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err addSampleGroups( struct MP4TrackFragmentAtom *self, u32 sampleCount ) +static MP4Err addSampleGroups(struct MP4TrackFragmentAtom *self, u32 sampleCount) { - MP4Err err; - u32 groupListSize, i; - - err = MP4GetListEntryCount( self->groupList, &groupListSize ); if (err) goto bail; - for ( i = 0; i < groupListSize; i++ ) - { - MP4SampletoGroupAtomPtr theGroup; - err = MP4GetListEntry( self->groupList, i, (char **) &theGroup ); if (err) goto bail; - if ( theGroup ) { - err = theGroup->addSamples( theGroup, sampleCount ); - if (err) goto bail; - } - } - - err = MP4GetListEntryCount( self->compactSampleGroupList, &groupListSize ); if (err) goto bail; - for ( i = 0; i < groupListSize; i++ ) - { - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - err = MP4GetListEntry( self->compactSampleGroupList, i, (char **) &compactSampleGroup ); if (err) goto bail; - if ( compactSampleGroup ) { - err = compactSampleGroup->addSamples( compactSampleGroup, sampleCount ); - if (err) goto bail; - } - } - - + MP4Err err; + u32 groupListSize, i; + + err = MP4GetListEntryCount(self->groupList, &groupListSize); + if(err) goto bail; + for(i = 0; i < groupListSize; i++) + { + MP4SampletoGroupAtomPtr theGroup; + err = MP4GetListEntry(self->groupList, i, (char **)&theGroup); + if(err) goto bail; + if(theGroup) + { + err = theGroup->addSamples(theGroup, sampleCount); + if(err) goto bail; + } + } + + err = MP4GetListEntryCount(self->compactSampleGroupList, &groupListSize); + if(err) goto bail; + for(i = 0; i < groupListSize; i++) + { + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + err = MP4GetListEntry(self->compactSampleGroupList, i, (char **)&compactSampleGroup); + if(err) goto bail; + if(compactSampleGroup) + { + err = compactSampleGroup->addSamples(compactSampleGroup, sampleCount); + if(err) goto bail; + } + } + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err addSamples( struct MP4MediaInformationAtom *s, MP4Handle sampleH, - u32 sampleCount, MP4Handle durationsH, MP4Handle sizesH, - MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ) +static MP4Err addSamples(struct MP4MediaInformationAtom *s, MP4Handle sampleH, u32 sampleCount, + MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, + MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH) { - MP4Err MP4CreateTrackRunAtom( MP4TrackRunAtomPtr *outAtom ); - MP4Err err; - MP4MediaDataAtomPtr mdat; - MP4TrackRunAtomPtr trun; - MP4TrackRunEntryPtr entry; - u32 duration_count; - u32* durations; - u32 size_count; - u32* sizes; - u32 sync_count; - u32* syncs; - u32 i; - u32* decodes; - MP4TrackFragmentAtomPtr self; - MP4TrackExtendsAtomPtr trex; - - - self = (MP4TrackFragmentAtomPtr) s; - - trex = (MP4TrackExtendsAtomPtr) self->trex; - - if (sampleEntryH != NULL) BAILWITHERROR( MP4BadDataErr ) - - if ((self->samples_use_mdat == 0) || (self->samples_use_mdat == 1)) self->samples_use_mdat = 1; - else BAILWITHERROR( MP4BadDataErr ) - - mdat = self->mdat; - - err = MP4CreateTrackRunAtom( &trun ); if (err) goto bail; - trun->data_offset = (u32) mdat->dataSize; - trun->samplecount = sampleCount; - - mdat->addData( mdat, sampleH ); - - trun->entries = (MP4TrackRunEntryPtr) calloc( sampleCount, sizeof(MP4TrackRunEntry) ); - TESTMALLOC( trun->entries ) - - MP4GetHandleSize( durationsH, &duration_count ); duration_count /= 4; - - MP4GetHandleSize( sizesH, &size_count); size_count /= 4; - - durations = (u32 *) *durationsH; - sizes = (u32 *) *sizesH; - decodes = NULL; - if (decodingOffsetsH != NULL) decodes = (u32 *) *decodingOffsetsH; - - for (i=0, entry=trun->entries; isample_duration = ( (i>=duration_count) ? durations[0] : durations[i] ); - trex->baseMediaDecodeTime += entry->sample_duration; - - entry->sample_size = ( (i>=size_count) ? sizes[0] : sizes[i] ); - entry->sample_flags = - ( (padsH == NULL) ? 0 : (((u8*) padsH)[i])<<17 ) + - ( (syncSamplesH == NULL) ? 0 : fragment_difference_sample_flag ); - entry->sample_composition_time_offset = - ( (decodingOffsetsH == NULL) ? 0 : decodes[i] ); - } - - entry=trun->entries; - - if (syncSamplesH != NULL) { - MP4GetHandleSize( syncSamplesH, &sync_count); sync_count /= 4; - syncs = (u32*) *syncSamplesH; - for (i=0; iuseSignedCompositionTimeOffsets == 1) - trun->version = 1; - - err = MP4AddListEntry( trun, self->atomList ); if (err) goto bail; - - err = addSampleGroups( self, sampleCount ); if (err) goto bail; + MP4Err MP4CreateTrackRunAtom(MP4TrackRunAtomPtr * outAtom); + MP4Err err; + MP4MediaDataAtomPtr mdat; + MP4TrackRunAtomPtr trun; + MP4TrackRunEntryPtr entry; + u32 duration_count; + u32 *durations; + u32 size_count; + u32 *sizes; + u32 sync_count; + u32 *syncs; + u32 i; + u32 *decodes; + MP4TrackFragmentAtomPtr self; + MP4TrackExtendsAtomPtr trex; + + self = (MP4TrackFragmentAtomPtr)s; + + trex = (MP4TrackExtendsAtomPtr)self->trex; + + if(sampleEntryH != NULL) BAILWITHERROR(MP4BadDataErr) + + if((self->samples_use_mdat == 0) || (self->samples_use_mdat == 1)) self->samples_use_mdat = 1; + else + BAILWITHERROR(MP4BadDataErr) + + mdat = self->mdat; + + err = MP4CreateTrackRunAtom(&trun); + if(err) goto bail; + trun->data_offset = (u32)mdat->dataSize; + trun->samplecount = sampleCount; + + mdat->addData(mdat, sampleH); + + trun->entries = (MP4TrackRunEntryPtr)calloc(sampleCount, sizeof(MP4TrackRunEntry)); + TESTMALLOC(trun->entries) + + MP4GetHandleSize(durationsH, &duration_count); + duration_count /= 4; + + MP4GetHandleSize(sizesH, &size_count); + size_count /= 4; + + durations = (u32 *)*durationsH; + sizes = (u32 *)*sizesH; + decodes = NULL; + if(decodingOffsetsH != NULL) decodes = (u32 *)*decodingOffsetsH; + + for(i = 0, entry = trun->entries; i < sampleCount; i++, entry++) + { + entry->sample_duration = ((i >= duration_count) ? durations[0] : durations[i]); + trex->baseMediaDecodeTime += entry->sample_duration; + + entry->sample_size = ((i >= size_count) ? sizes[0] : sizes[i]); + entry->sample_flags = ((padsH == NULL) ? 0 : (((u8 *)padsH)[i]) << 17) + + ((syncSamplesH == NULL) ? 0 : fragment_difference_sample_flag); + entry->sample_composition_time_offset = ((decodingOffsetsH == NULL) ? 0 : decodes[i]); + } + + entry = trun->entries; + + if(syncSamplesH != NULL) + { + MP4GetHandleSize(syncSamplesH, &sync_count); + sync_count /= 4; + syncs = (u32 *)*syncSamplesH; + for(i = 0; i < sync_count; i++) + { + entry[syncs[i] - 1].sample_flags ^= fragment_difference_sample_flag; + } + } + + if(self->useSignedCompositionTimeOffsets == 1) trun->version = 1; + + err = MP4AddListEntry(trun, self->atomList); + if(err) goto bail; + + err = addSampleGroups(self, sampleCount); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addSampleReference( struct MP4MediaInformationAtom *s, u64 dataOffset, u32 sampleCount, - MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, - MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, MP4Handle padsH ) +static MP4Err addSampleReference(struct MP4MediaInformationAtom *s, u64 dataOffset, u32 sampleCount, + MP4Handle durationsH, MP4Handle sizesH, MP4Handle sampleEntryH, + MP4Handle decodingOffsetsH, MP4Handle syncSamplesH, + MP4Handle padsH) { - MP4Err MP4CreateTrackRunAtom( MP4TrackRunAtomPtr *outAtom ); - MP4Err err; - - MP4TrackRunAtomPtr trun; - MP4TrackRunEntryPtr entry; - u32 duration_count; - u32* durations; - u32 size_count; - u32* sizes; - u32 sync_count; - u32* syncs; - u32 i; - MP4TrackFragmentAtomPtr self; - MP4TrackFragmentHeaderAtomPtr tfhd; - MP4TrackExtendsAtomPtr trex; - - self = (MP4TrackFragmentAtomPtr) s; - - trex = (MP4TrackExtendsAtomPtr) self->trex; - - if (sampleEntryH != NULL) BAILWITHERROR( MP4BadDataErr ) - - if ((self->samples_use_mdat == 0) || (self->samples_use_mdat == 2)) self->samples_use_mdat = 2; - else BAILWITHERROR( MP4BadDataErr ) - - err = MP4CreateTrackRunAtom( &trun ); if (err) goto bail; - - tfhd = (MP4TrackFragmentHeaderAtomPtr) self->tfhd; - if (tfhd->base_data_offset == 0) tfhd->base_data_offset = dataOffset; - - trun->data_offset = (u32) (dataOffset - (tfhd->base_data_offset)); - trun->samplecount = sampleCount; - - trun->entries = (MP4TrackRunEntryPtr) calloc( sampleCount, sizeof(MP4TrackRunEntry) ); - TESTMALLOC( trun->entries ) - - MP4GetHandleSize( durationsH, &duration_count ); duration_count /= 4; - MP4GetHandleSize( sizesH, &size_count); size_count /= 4; - - durations = (u32 *) *durationsH; - sizes = (u32 *) *sizesH; - - for (i=0, entry=trun->entries; isample_duration = ( (i>=duration_count) ? durations[0] : durations[i] ); - trex->baseMediaDecodeTime += entry->sample_duration; - - entry->sample_size = ( (i>=size_count) ? sizes[0] : sizes[i] ); - entry->sample_flags = - ( (padsH == NULL) ? 0 : (((u8*) padsH)[i])<<13 ) + - ( (syncSamplesH == NULL) ? 0 : fragment_difference_sample_flag ); - entry->sample_composition_time_offset = - ( (decodingOffsetsH == NULL) ? 0 : ((u32*) decodingOffsetsH)[i] ); - } - - entry=trun->entries; - - if (syncSamplesH != NULL) { - MP4GetHandleSize( syncSamplesH, &sync_count); sync_count /= 4; - syncs = (u32*) *syncSamplesH; - for (i=0; iuseSignedCompositionTimeOffsets == 1) - trun->version = 1; - - err = MP4AddListEntry( trun, self->atomList ); if (err) goto bail; - - err = addSampleGroups( self, sampleCount ); if (err) goto bail; + MP4Err MP4CreateTrackRunAtom(MP4TrackRunAtomPtr * outAtom); + MP4Err err; + + MP4TrackRunAtomPtr trun; + MP4TrackRunEntryPtr entry; + u32 duration_count; + u32 *durations; + u32 size_count; + u32 *sizes; + u32 sync_count; + u32 *syncs; + u32 i; + MP4TrackFragmentAtomPtr self; + MP4TrackFragmentHeaderAtomPtr tfhd; + MP4TrackExtendsAtomPtr trex; + + self = (MP4TrackFragmentAtomPtr)s; + + trex = (MP4TrackExtendsAtomPtr)self->trex; + + if(sampleEntryH != NULL) BAILWITHERROR(MP4BadDataErr) + + if((self->samples_use_mdat == 0) || (self->samples_use_mdat == 2)) self->samples_use_mdat = 2; + else + BAILWITHERROR(MP4BadDataErr) + + err = MP4CreateTrackRunAtom(&trun); + if(err) goto bail; + + tfhd = (MP4TrackFragmentHeaderAtomPtr)self->tfhd; + if(tfhd->base_data_offset == 0) tfhd->base_data_offset = dataOffset; + + trun->data_offset = (u32)(dataOffset - (tfhd->base_data_offset)); + trun->samplecount = sampleCount; + + trun->entries = (MP4TrackRunEntryPtr)calloc(sampleCount, sizeof(MP4TrackRunEntry)); + TESTMALLOC(trun->entries) + + MP4GetHandleSize(durationsH, &duration_count); + duration_count /= 4; + MP4GetHandleSize(sizesH, &size_count); + size_count /= 4; + + durations = (u32 *)*durationsH; + sizes = (u32 *)*sizesH; + + for(i = 0, entry = trun->entries; i < sampleCount; i++, entry++) + { + entry->sample_duration = ((i >= duration_count) ? durations[0] : durations[i]); + trex->baseMediaDecodeTime += entry->sample_duration; + + entry->sample_size = ((i >= size_count) ? sizes[0] : sizes[i]); + entry->sample_flags = ((padsH == NULL) ? 0 : (((u8 *)padsH)[i]) << 13) + + ((syncSamplesH == NULL) ? 0 : fragment_difference_sample_flag); + entry->sample_composition_time_offset = + ((decodingOffsetsH == NULL) ? 0 : ((u32 *)decodingOffsetsH)[i]); + } + + entry = trun->entries; + + if(syncSamplesH != NULL) + { + MP4GetHandleSize(syncSamplesH, &sync_count); + sync_count /= 4; + syncs = (u32 *)*syncSamplesH; + for(i = 0; i < sync_count; i++) + { + entry[syncs[i - 1]].sample_flags ^= fragment_difference_sample_flag; + } + } + + if(self->useSignedCompositionTimeOffsets == 1) trun->version = 1; + + err = MP4AddListEntry(trun, self->atomList); + if(err) goto bail; + + err = addSampleGroups(self, sampleCount); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addGroupDescription( struct MP4Atom* s, u32 theType, MP4Handle theDescription, u32* index ) +static MP4Err addGroupDescription(struct MP4Atom *s, u32 theType, MP4Handle theDescription, + u32 *index) { MP4Err err; MP4SampleGroupDescriptionAtomPtr theGroup; - MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr) s; + MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr)s; - err = MP4FindGroupAtom( self->groupDescriptionList, theType, (MP4AtomPtr*) &theGroup ); - if (!theGroup) + err = MP4FindGroupAtom(self->groupDescriptionList, theType, (MP4AtomPtr *)&theGroup); + if(!theGroup) { - err = MP4CreateSampleGroupDescriptionAtom( &theGroup ); if (err) goto bail; + err = MP4CreateSampleGroupDescriptionAtom(&theGroup); + if(err) goto bail; theGroup->grouping_type = theType; - err = addAtom( self, (MP4AtomPtr) theGroup ); if (err) goto bail; + err = addAtom(self, (MP4AtomPtr)theGroup); + if(err) goto bail; } - err = theGroup->addGroupDescription( theGroup, theDescription, index ); if (err) goto bail; + err = theGroup->addGroupDescription(theGroup, theDescription, index); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); return err; } -static MP4Err getGroupDescription( struct MP4SampleTableAtom *self, u32 theType, u32 index, MP4Handle theDescription ) +static MP4Err getGroupDescription(struct MP4SampleTableAtom *self, u32 theType, u32 index, + MP4Handle theDescription) { MP4Err err; MP4SampleGroupDescriptionAtomPtr theGroup; - err = MP4FindGroupAtom( self->groupDescriptionList, theType, (MP4AtomPtr*) &theGroup ); - if (!theGroup) BAILWITHERROR(MP4BadParamErr ); - err = theGroup->getGroupDescription( theGroup, index, theDescription ); if (err) goto bail; + err = MP4FindGroupAtom(self->groupDescriptionList, theType, (MP4AtomPtr *)&theGroup); + if(!theGroup) BAILWITHERROR(MP4BadParamErr); + err = theGroup->getGroupDescription(theGroup, index, theDescription); + if(err) goto bail; bail: - TEST_RETURN( err ); + TEST_RETURN(err); return err; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { MP4Err err; - MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr) s; - err = MP4NoErr; + MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr)s; + err = MP4NoErr; - if ( self->size > 0 ) + if(self->size > 0) { - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM( tfhd ); - SERIALIZE_ATOM( tfdt ); - SERIALIZE_ATOM_LIST( saizList ); - SERIALIZE_ATOM_LIST( saioList ); - - SERIALIZE_ATOM_LIST( atomList ); - SERIALIZE_ATOM_LIST( groupDescriptionList ); - SERIALIZE_ATOM_LIST( groupList ); - SERIALIZE_ATOM_LIST( compactSampleGroupList ); - assert( self->bytesWritten == self->size ); + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM(tfhd); + SERIALIZE_ATOM(tfdt); + SERIALIZE_ATOM_LIST(saizList); + SERIALIZE_ATOM_LIST(saioList); + + SERIALIZE_ATOM_LIST(atomList); + SERIALIZE_ATOM_LIST(groupDescriptionList); + SERIALIZE_ATOM_LIST(groupList); + SERIALIZE_ATOM_LIST(compactSampleGroupList); + assert(self->bytesWritten == self->size); } bail: - TEST_RETURN( err ); + TEST_RETURN(err); return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { MP4Err err; - MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr) s; + MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr)s; MP4TrackFragmentHeaderAtomPtr tfhd; MP4TrackFragmentDecodeTimeAtomPtr tfdt; @@ -375,556 +412,652 @@ static MP4Err calculateSize( struct MP4Atom* s ) err = MP4NoErr; - tfhd = (MP4TrackFragmentHeaderAtomPtr) self->tfhd; - tfdt = (MP4TrackFragmentDecodeTimeAtomPtr) self->tfdt; + tfhd = (MP4TrackFragmentHeaderAtomPtr)self->tfhd; + tfdt = (MP4TrackFragmentDecodeTimeAtomPtr)self->tfdt; tfhd->default_sample_duration = 0; tfhd->default_sample_flags = 0; tfhd->default_sample_size = 0; - tfhd_flags = tfhd_base_data_offset_present; + tfhd_flags = tfhd_base_data_offset_present; - if ( self->atomList ) + if(self->atomList) { - err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; + err = MP4GetListEntryCount(self->atomList, &atomListSize); + if(err) goto bail; } - else atomListSize = 0; + else + atomListSize = 0; - if (atomListSize > 0) + if(atomListSize > 0) { MP4TrackRunAtomPtr a; - + /* first, calculate what defaults are suitable in this track fragment header */ - for ( i = 0; i < atomListSize; i++ ) + for(i = 0; i < atomListSize; i++) { - err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; - if ( a ) a->calculateDefaults( a, tfhd, 2 ); + err = MP4GetListEntry(self->atomList, i, (char **)&a); + if(err) goto bail; + if(a) a->calculateDefaults(a, tfhd, 2); /* first iteration gets the second flag value as the first can be special-cased */ } - + /* then come back round and pick up the flags if not already set from second position */ - if (tfhd->default_sample_flags == 0) + if(tfhd->default_sample_flags == 0) { - for ( i = 0; i < atomListSize; i++ ) + for(i = 0; i < atomListSize; i++) { - err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; - if ( a ) a->calculateDefaults( a, tfhd, 1 ); + err = MP4GetListEntry(self->atomList, i, (char **)&a); + if(err) goto bail; + if(a) a->calculateDefaults(a, tfhd, 1); /* pick up flags from the first position */ } } - + /* then see how they compare with the trex defaults */ - if (self->default_sample_description_index != tfhd->sample_description_index) + if(self->default_sample_description_index != tfhd->sample_description_index) tfhd_flags |= tfhd_sample_description_index_present; - if (self->default_sample_duration != tfhd->default_sample_duration) + if(self->default_sample_duration != tfhd->default_sample_duration) tfhd_flags |= tfhd_default_sample_duration_present; - if (self->default_sample_size != tfhd->default_sample_size) + if(self->default_sample_size != tfhd->default_sample_size) tfhd_flags |= tfhd_default_sample_size_present; - if (self->default_sample_flags != tfhd->default_sample_flags) + if(self->default_sample_flags != tfhd->default_sample_flags) tfhd_flags |= tfhd_default_sample_flags_present; /* finally, tell each run to set its flags based on what we calculated */ - for ( i = 0; i < atomListSize; i++ ) + for(i = 0; i < atomListSize; i++) { - err = MP4GetListEntry( self->atomList, i, (char **) &a ); if (err) goto bail; - if ( a ) a->setFlags( a, tfhd ); + err = MP4GetListEntry(self->atomList, i, (char **)&a); + if(err) goto bail; + if(a) a->setFlags(a, tfhd); } tfhd->flags = tfhd_flags; - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_SIZE( tfhd ); - ADD_ATOM_SIZE( tfdt ); - ADD_ATOM_LIST_SIZE( saizList ); - ADD_ATOM_LIST_SIZE( saioList ); - ADD_ATOM_LIST_SIZE( atomList ); - ADD_ATOM_LIST_SIZE( groupDescriptionList ); - ADD_ATOM_LIST_SIZE( groupList ); - ADD_ATOM_LIST_SIZE( compactSampleGroupList ); + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_SIZE(tfhd); + ADD_ATOM_SIZE(tfdt); + ADD_ATOM_LIST_SIZE(saizList); + ADD_ATOM_LIST_SIZE(saioList); + ADD_ATOM_LIST_SIZE(atomList); + ADD_ATOM_LIST_SIZE(groupDescriptionList); + ADD_ATOM_LIST_SIZE(groupList); + ADD_ATOM_LIST_SIZE(compactSampleGroupList); } - else self->size = 0; + else + self->size = 0; bail: - TEST_RETURN( err ); + TEST_RETURN(err); return err; } -static MP4Err mergeRuns( MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia ) +static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) { - MP4Err err; - MP4TrackFragmentHeaderAtomPtr tfhd; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - u32 i, total_samples; - - err = MP4NoErr; - total_samples = 0; - - tfhd = (MP4TrackFragmentHeaderAtomPtr) self->tfhd; - minf = (MP4MediaInformationAtomPtr) mdia->information; - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - - if ( self->atomList ) - { - u32 atomListSize; - err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; - for ( i = 0; i < atomListSize; i++ ) - { - MP4TrackRunAtomPtr trun; - err = MP4GetListEntry( self->atomList, i, (char **) &trun ); if (err) goto bail; - if ( trun ) { - u32 count; - MP4Handle durationsH; - MP4Handle sizesH; - MP4Handle decodingOffsetsH; - MP4Handle syncSamplesH; - MP4Handle padsH; - MP4Handle depsH; - u32* durations; - u32* sizes; - u32* decodingOffsets; - u32* syncSamples; - u8* pads; - u8* deps; - u32 havepads, havedeps; - u32 synccount; - u32 all_sync; - MP4TrackRunEntryPtr entry; - u32 flags; - u32 j; - - havedeps = 0; havepads = 0; synccount = 0; all_sync = 1; - - count=(trun->samplecount)*sizeof(u32); - err = MP4NewHandle( count, &durationsH); if (err) goto bail; - err = MP4NewHandle( count, &sizesH); if (err) goto bail; - err = MP4NewHandle( count, &decodingOffsetsH); if (err) goto bail; - err = MP4NewHandle( count, &syncSamplesH); if (err) goto bail; - count /= sizeof(u32); - total_samples += count; - - err = MP4NewHandle( count, &padsH); if (err) goto bail; - err = MP4NewHandle( count, &depsH); if (err) goto bail; - - flags = trun->flags; entry = trun->entries; - if ((flags & trun_first_sample_flags_present) != 0) - entry->sample_flags = trun->first_sample_flags; - - durations = (u32*) *durationsH; sizes = (u32*) *sizesH; - decodingOffsets = (u32*) *decodingOffsetsH; - syncSamples = (u32*) *syncSamplesH; pads = (u8*) *padsH; deps = (u8*) *depsH; - - for (j=0; jsample_duration : tfhd->default_sample_duration); - *sizes = ((flags & trun_sample_size_present) != 0 ? entry->sample_size : tfhd->default_sample_size); - *decodingOffsets = entry->sample_composition_time_offset; - if ((j==0) && ((flags & trun_first_sample_flags_present) != 0)) - entry->sample_flags = trun->first_sample_flags; - else if ((flags & trun_sample_flags_present) == 0) - entry->sample_flags = tfhd->default_sample_flags; - - *pads = (entry->sample_flags >> 17) & 7; /* used to be > 13, and should be a right-shift 17 anded with 7 */ - if (*pads != 0) havepads = 1; - *deps = (entry->sample_flags >> 20) & 0x3F; - if (*deps != 0) havedeps = 1; - - if ((entry->sample_flags & fragment_difference_sample_flag) == 0) - syncSamples[ synccount++ ] = j+1; - else all_sync = 0; - } - MP4SetHandleSize( syncSamplesH, synccount*sizeof(u32) ); - - stbl->setDefaultSampleEntry( stbl, tfhd->sample_description_index ); - - err = mdia->addSampleReference( mdia, - tfhd->base_data_offset + trun->data_offset, - count, durationsH, sizesH, NULL, - ((flags & trun_sample_composition_times_present) != 0 ? decodingOffsetsH : NULL), - (all_sync == 0 ? syncSamplesH : NULL), - (havepads!=0 ? padsH : NULL) ); - if (err) goto bail; - - if (havedeps) { - err = mdia->setSampleDependency( mdia, -count, depsH ); if (err) goto bail; - } - - err = MP4DisposeHandle( durationsH); if (err) goto bail; - err = MP4DisposeHandle( sizesH); if (err) goto bail; - err = MP4DisposeHandle( decodingOffsetsH); if (err) goto bail; - err = MP4DisposeHandle( syncSamplesH); if (err) goto bail; - err = MP4DisposeHandle( padsH); if (err) goto bail; - err = MP4DisposeHandle( depsH); if (err) goto bail; - } - } - } - - if (self->groupList) { - u32 groupListSize; - err = ISOSetSamplestoGroupType( (MP4Media) mdia, 0 ); if (err) goto bail; - err = MP4GetListEntryCount( self->groupList, &groupListSize ); if (err) goto bail; - for ( i = 0; i < groupListSize; i++ ) - { - MP4SampletoGroupAtomPtr theGroup; - err = MP4GetListEntry( self->groupList, i, (char **) &theGroup ); if (err) goto bail; - if ( theGroup ) { - u32 j; - for (j=0; jsampleCount; j++) { - s32 position; - position = j - total_samples; - err = mdia->mapSamplestoGroup( mdia, theGroup->grouping_type, (theGroup->group_index)[j], position, 1 ); - if (err) goto bail; - } - } - } - } - - if (self->compactSampleGroupList) { - u32 groupListSize; - err = ISOSetSamplestoGroupType( (MP4Media) mdia, 1 ); if (err) goto bail; - err = MP4GetListEntryCount( self->compactSampleGroupList, &groupListSize ); if (err) goto bail; - for ( i = 0; i < groupListSize; i++ ) - { - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - err = MP4GetListEntry( self->compactSampleGroupList, i, (char **) &compactSampleGroup ); if (err) goto bail; - if ( compactSampleGroup ) { - u32 j; - for (j=0; jsampleCount; j++) { - s32 position; - position = j - total_samples; - err = mdia->mapSamplestoGroup( mdia, compactSampleGroup->grouping_type, (compactSampleGroup->group_index)[j], position, 1 ); - if (err) goto bail; - } - } - } - } + MP4Err err; + MP4TrackFragmentHeaderAtomPtr tfhd; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + u32 i, total_samples; + + err = MP4NoErr; + total_samples = 0; + + tfhd = (MP4TrackFragmentHeaderAtomPtr)self->tfhd; + minf = (MP4MediaInformationAtomPtr)mdia->information; + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + + if(self->atomList) + { + u32 atomListSize; + err = MP4GetListEntryCount(self->atomList, &atomListSize); + if(err) goto bail; + for(i = 0; i < atomListSize; i++) + { + MP4TrackRunAtomPtr trun; + err = MP4GetListEntry(self->atomList, i, (char **)&trun); + if(err) goto bail; + if(trun) + { + u32 count; + MP4Handle durationsH; + MP4Handle sizesH; + MP4Handle decodingOffsetsH; + MP4Handle syncSamplesH; + MP4Handle padsH; + MP4Handle depsH; + u32 *durations; + u32 *sizes; + u32 *decodingOffsets; + u32 *syncSamples; + u8 *pads; + u8 *deps; + u32 havepads, havedeps; + u32 synccount; + u32 all_sync; + MP4TrackRunEntryPtr entry; + u32 flags; + u32 j; + + havedeps = 0; + havepads = 0; + synccount = 0; + all_sync = 1; + + count = (trun->samplecount) * sizeof(u32); + err = MP4NewHandle(count, &durationsH); + if(err) goto bail; + err = MP4NewHandle(count, &sizesH); + if(err) goto bail; + err = MP4NewHandle(count, &decodingOffsetsH); + if(err) goto bail; + err = MP4NewHandle(count, &syncSamplesH); + if(err) goto bail; + count /= sizeof(u32); + total_samples += count; + + err = MP4NewHandle(count, &padsH); + if(err) goto bail; + err = MP4NewHandle(count, &depsH); + if(err) goto bail; + + flags = trun->flags; + entry = trun->entries; + if((flags & trun_first_sample_flags_present) != 0) + entry->sample_flags = trun->first_sample_flags; + + durations = (u32 *)*durationsH; + sizes = (u32 *)*sizesH; + decodingOffsets = (u32 *)*decodingOffsetsH; + syncSamples = (u32 *)*syncSamplesH; + pads = (u8 *)*padsH; + deps = (u8 *)*depsH; + + for(j = 0; j < count; j++, entry++, durations++, sizes++, decodingOffsets++, pads++, deps++) + { + *durations = + ((flags & trun_sample_duration_present) != 0 ? entry->sample_duration + : tfhd->default_sample_duration); + *sizes = ((flags & trun_sample_size_present) != 0 ? entry->sample_size + : tfhd->default_sample_size); + *decodingOffsets = entry->sample_composition_time_offset; + if((j == 0) && ((flags & trun_first_sample_flags_present) != 0)) + entry->sample_flags = trun->first_sample_flags; + else if((flags & trun_sample_flags_present) == 0) + entry->sample_flags = tfhd->default_sample_flags; + + *pads = (entry->sample_flags >> 17) & + 7; /* used to be > 13, and should be a right-shift 17 anded with 7 */ + if(*pads != 0) havepads = 1; + *deps = (entry->sample_flags >> 20) & 0x3F; + if(*deps != 0) havedeps = 1; + + if((entry->sample_flags & fragment_difference_sample_flag) == 0) + syncSamples[synccount++] = j + 1; + else + all_sync = 0; + } + MP4SetHandleSize(syncSamplesH, synccount * sizeof(u32)); + + stbl->setDefaultSampleEntry(stbl, tfhd->sample_description_index); + + err = mdia->addSampleReference( + mdia, tfhd->base_data_offset + trun->data_offset, count, durationsH, sizesH, NULL, + ((flags & trun_sample_composition_times_present) != 0 ? decodingOffsetsH : NULL), + (all_sync == 0 ? syncSamplesH : NULL), (havepads != 0 ? padsH : NULL)); + if(err) goto bail; + + if(havedeps) + { + err = mdia->setSampleDependency(mdia, -count, depsH); + if(err) goto bail; + } + + err = MP4DisposeHandle(durationsH); + if(err) goto bail; + err = MP4DisposeHandle(sizesH); + if(err) goto bail; + err = MP4DisposeHandle(decodingOffsetsH); + if(err) goto bail; + err = MP4DisposeHandle(syncSamplesH); + if(err) goto bail; + err = MP4DisposeHandle(padsH); + if(err) goto bail; + err = MP4DisposeHandle(depsH); + if(err) goto bail; + } + } + } + + if(self->groupList) + { + u32 groupListSize; + err = ISOSetSamplestoGroupType((MP4Media)mdia, 0); + if(err) goto bail; + err = MP4GetListEntryCount(self->groupList, &groupListSize); + if(err) goto bail; + for(i = 0; i < groupListSize; i++) + { + MP4SampletoGroupAtomPtr theGroup; + err = MP4GetListEntry(self->groupList, i, (char **)&theGroup); + if(err) goto bail; + if(theGroup) + { + u32 j; + for(j = 0; j < theGroup->sampleCount; j++) + { + s32 position; + position = j - total_samples; + err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, (theGroup->group_index)[j], + position, 1); + if(err) goto bail; + } + } + } + } + + if(self->compactSampleGroupList) + { + u32 groupListSize; + err = ISOSetSamplestoGroupType((MP4Media)mdia, 1); + if(err) goto bail; + err = MP4GetListEntryCount(self->compactSampleGroupList, &groupListSize); + if(err) goto bail; + for(i = 0; i < groupListSize; i++) + { + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + err = MP4GetListEntry(self->compactSampleGroupList, i, (char **)&compactSampleGroup); + if(err) goto bail; + if(compactSampleGroup) + { + u32 j; + for(j = 0; j < compactSampleGroup->sampleCount; j++) + { + s32 position; + position = j - total_samples; + err = mdia->mapSamplestoGroup(mdia, compactSampleGroup->grouping_type, + (compactSampleGroup->group_index)[j], position, 1); + if(err) goto bail; + } + } + } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err mergeSampleAuxiliaryInformation( struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia ) +MP4Err mergeSampleAuxiliaryInformation(struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia) { - u32 i; - MP4Err err; - MP4TrackFragmentHeaderAtomPtr tfhd; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; - - err = MP4NoErr; - - tfhd = (MP4TrackFragmentHeaderAtomPtr) self->tfhd; - minf = (MP4MediaInformationAtomPtr) mdia->information; - stbl = (MP4SampleTableAtomPtr) minf->sampleTable; - - for (i = 0; i < self->saizList->entryCount; i++) - { - MP4SampleAuxiliaryInformationSizesAtomPtr saizOfTraf; - MP4SampleAuxiliaryInformationOffsetsAtomPtr saioOfTraf; - MP4SampleAuxiliaryInformationSizesAtomPtr saizOfStbl; - MP4SampleAuxiliaryInformationOffsetsAtomPtr saioOfStbl; - err = MP4GetListEntry(self->saizList, i, (char **) &saizOfTraf); - err = MP4GetListEntry(self->saioList, i, (char **) &saioOfTraf); - - err = stbl->getSampleAuxiliaryInformation(stbl, (saizOfTraf->flags & 1), saizOfTraf->aux_info_type, saizOfTraf->aux_info_type_parameter, - &saizOfStbl, &saioOfStbl); if (err) goto bail; - - err = saizOfStbl->mergeSizes((MP4AtomPtr) saizOfStbl, (MP4AtomPtr) saizOfTraf); if (err) goto bail; - err = saioOfStbl->mergeOffsets((MP4AtomPtr) saioOfStbl, (MP4AtomPtr) saioOfTraf, tfhd->base_data_offset ); if (err) goto bail; - } - - + u32 i; + MP4Err err; + MP4TrackFragmentHeaderAtomPtr tfhd; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + tfhd = (MP4TrackFragmentHeaderAtomPtr)self->tfhd; + minf = (MP4MediaInformationAtomPtr)mdia->information; + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + + for(i = 0; i < self->saizList->entryCount; i++) + { + MP4SampleAuxiliaryInformationSizesAtomPtr saizOfTraf; + MP4SampleAuxiliaryInformationOffsetsAtomPtr saioOfTraf; + MP4SampleAuxiliaryInformationSizesAtomPtr saizOfStbl; + MP4SampleAuxiliaryInformationOffsetsAtomPtr saioOfStbl; + err = MP4GetListEntry(self->saizList, i, (char **)&saizOfTraf); + err = MP4GetListEntry(self->saioList, i, (char **)&saioOfTraf); + + err = stbl->getSampleAuxiliaryInformation( + stbl, (saizOfTraf->flags & 1), saizOfTraf->aux_info_type, + saizOfTraf->aux_info_type_parameter, &saizOfStbl, &saioOfStbl); + if(err) goto bail; + + err = saizOfStbl->mergeSizes((MP4AtomPtr)saizOfStbl, (MP4AtomPtr)saizOfTraf); + if(err) goto bail; + err = saioOfStbl->mergeOffsets((MP4AtomPtr)saioOfStbl, (MP4AtomPtr)saioOfTraf, + tfhd->base_data_offset); + if(err) goto bail; + } + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err getSampleAuxiliaryInfoFromTrackFragment (struct MP4TrackFragmentAtom *self, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, - MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut) +MP4Err getSampleAuxiliaryInfoFromTrackFragment(struct MP4TrackFragmentAtom *self, + u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, + u32 aux_info_type_parameter, + MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, + MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut) { - MP4Err err; - u32 i; - err = MP4NoErr; - - *saizOut = NULL; - *saioOut = NULL; - - for (i = 0; i < self->saizList->entryCount; i++) + MP4Err err; + u32 i; + err = MP4NoErr; + + *saizOut = NULL; + *saioOut = NULL; + + for(i = 0; i < self->saizList->entryCount; i++) + { + MP4SampleAuxiliaryInformationSizesAtomPtr saizExisting; + MP4SampleAuxiliaryInformationOffsetsAtomPtr saioExisting; + err = MP4GetListEntry(self->saizList, i, (char **)&saizExisting); + err = MP4GetListEntry(self->saioList, i, (char **)&saioExisting); + + if(((saizExisting->flags & 1) == isUsingAuxInfoPropertiesFlag) && + (saizExisting->aux_info_type == aux_info_type) && + (saizExisting->aux_info_type_parameter == aux_info_type_parameter)) + { + *saizOut = saizExisting; + } + + if(((saioExisting->flags & 1) == isUsingAuxInfoPropertiesFlag) && + (saioExisting->aux_info_type == aux_info_type) && + (saioExisting->aux_info_type_parameter == aux_info_type_parameter)) + { + *saioOut = saioExisting; + } + } + + TEST_RETURN(err); + + return err; +} +static MP4Err calculateDataEnd(MP4TrackFragmentAtomPtr self, u32 *outEnd) +{ + MP4Err err; + MP4TrackFragmentHeaderAtomPtr tfhd; + u32 i; + u32 totalsize, data_begin, data_end; + + totalsize = 0; + + err = MP4NoErr; + + tfhd = (MP4TrackFragmentHeaderAtomPtr)self->tfhd; + + data_end = tfhd->base_data_offset; + + if(self->atomList) + { + u32 atomListSize; + err = MP4GetListEntryCount(self->atomList, &atomListSize); + if(err) goto bail; + for(i = 0; i < atomListSize; i++) { - MP4SampleAuxiliaryInformationSizesAtomPtr saizExisting; - MP4SampleAuxiliaryInformationOffsetsAtomPtr saioExisting; - err = MP4GetListEntry(self->saizList, i, (char **) &saizExisting); - err = MP4GetListEntry(self->saioList, i, (char **) &saioExisting); - - if (((saizExisting->flags & 1) == isUsingAuxInfoPropertiesFlag) && - (saizExisting->aux_info_type == aux_info_type) && - (saizExisting->aux_info_type_parameter == aux_info_type_parameter)) + MP4TrackRunAtomPtr trun; + err = MP4GetListEntry(self->atomList, i, (char **)&trun); + if(err) goto bail; + if(trun) + { + u32 count; + u32 j; + MP4TrackRunEntryPtr entry; + + if(trun->flags & trun_data_offset_present) + data_begin = tfhd->base_data_offset + trun->data_offset; + else + data_begin = data_end; + + count = trun->samplecount; + entry = trun->entries; + + if(trun->flags & trun_sample_size_present) { - *saizOut = saizExisting; + for(j = 0; j < count; j++, entry++) + totalsize += entry->sample_size; } - - if (((saioExisting->flags & 1) == isUsingAuxInfoPropertiesFlag) && - (saioExisting->aux_info_type == aux_info_type) && - (saioExisting->aux_info_type_parameter == aux_info_type_parameter)) + else { - *saioOut = saioExisting; + totalsize += (tfhd->default_sample_size) * count; } + + data_end = data_begin + totalsize; + } } + } + *outEnd = data_end; - TEST_RETURN( err ); - - return err; -} -static MP4Err calculateDataEnd( MP4TrackFragmentAtomPtr self, u32* outEnd ) -{ - MP4Err err; - MP4TrackFragmentHeaderAtomPtr tfhd; - u32 i; - u32 totalsize, data_begin, data_end; - - totalsize = 0; - - err = MP4NoErr; - - tfhd = (MP4TrackFragmentHeaderAtomPtr) self->tfhd; - - data_end = tfhd->base_data_offset; - - if ( self->atomList ) - { - u32 atomListSize; - err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; - for ( i = 0; i < atomListSize; i++ ) - { - MP4TrackRunAtomPtr trun; - err = MP4GetListEntry( self->atomList, i, (char **) &trun ); if (err) goto bail; - if ( trun ) { - u32 count; - u32 j; - MP4TrackRunEntryPtr entry; - - if (trun->flags & trun_data_offset_present) - data_begin = tfhd->base_data_offset + trun->data_offset; - else data_begin = data_end; - - count=trun->samplecount; - entry = trun->entries; - - if (trun->flags & trun_sample_size_present) - { - for (j=0; jsample_size; - } - else - { - totalsize += (tfhd->default_sample_size)*count; - } - - data_end = data_begin + totalsize; - } - } - } - *outEnd = data_end; - bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 compactSamples ) +static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType, u32 group_index, + s32 sample_index, u32 count, u32 compactSamples) { - MP4Err err; - MP4SampletoGroupAtomPtr theGroup; - MP4TrackFragmentAtomPtr self; - u32 fragment_sample_count, atomListSize, i; - - self = (MP4TrackFragmentAtomPtr) s; - - if (compactSamples) { - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - err = MP4FindGroupAtom( self->compactSampleGroupList, groupType, (MP4AtomPtr*) &compactSampleGroup ); - if (!compactSampleGroup) { - err = MP4CreateCompactSampletoGroupAtom( &compactSampleGroup ); if (err) goto bail; - compactSampleGroup->fragmentLocalIndexPresent = 1; - compactSampleGroup->grouping_type = groupType; - err = addAtom( self, (MP4AtomPtr) compactSampleGroup ); if (err) goto bail; - - fragment_sample_count = 0; - err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; - for ( i = 0; i < atomListSize; i++ ) - { - MP4TrackRunAtomPtr trun; - err = MP4GetListEntry( self->atomList, i, (char **) &trun ); if (err) goto bail; - if ( trun ) fragment_sample_count += trun->samplecount; - } - - if (fragment_sample_count > 0) { - err = compactSampleGroup->addSamples( compactSampleGroup, fragment_sample_count ); - } - } - err = compactSampleGroup->mapSamplestoGroup( compactSampleGroup, group_index, sample_index, count ); if (err) goto bail; - } - else { - err = MP4FindGroupAtom( self->groupList, groupType, (MP4AtomPtr*) &theGroup ); - if (!theGroup) { - err = MP4CreateSampletoGroupAtom( &theGroup ); if (err) goto bail; - theGroup->grouping_type = groupType; - err = addAtom( self, (MP4AtomPtr) theGroup ); if (err) goto bail; - - fragment_sample_count = 0; - err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; - for ( i = 0; i < atomListSize; i++ ) - { - MP4TrackRunAtomPtr trun; - err = MP4GetListEntry( self->atomList, i, (char **) &trun ); if (err) goto bail; - if ( trun ) fragment_sample_count += trun->samplecount; - } - - if (fragment_sample_count > 0) { - err = theGroup->addSamples( theGroup, fragment_sample_count ); - } - } - err = theGroup->mapSamplestoGroup( theGroup, group_index, sample_index, count ); if (err) goto bail; - } - + MP4Err err; + MP4SampletoGroupAtomPtr theGroup; + MP4TrackFragmentAtomPtr self; + u32 fragment_sample_count, atomListSize, i; + + self = (MP4TrackFragmentAtomPtr)s; + + if(compactSamples) + { + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + err = MP4FindGroupAtom(self->compactSampleGroupList, groupType, + (MP4AtomPtr *)&compactSampleGroup); + if(!compactSampleGroup) + { + err = MP4CreateCompactSampletoGroupAtom(&compactSampleGroup); + if(err) goto bail; + compactSampleGroup->fragmentLocalIndexPresent = 1; + compactSampleGroup->grouping_type = groupType; + err = addAtom(self, (MP4AtomPtr)compactSampleGroup); + if(err) goto bail; + + fragment_sample_count = 0; + err = MP4GetListEntryCount(self->atomList, &atomListSize); + if(err) goto bail; + for(i = 0; i < atomListSize; i++) + { + MP4TrackRunAtomPtr trun; + err = MP4GetListEntry(self->atomList, i, (char **)&trun); + if(err) goto bail; + if(trun) fragment_sample_count += trun->samplecount; + } + + if(fragment_sample_count > 0) + { + err = compactSampleGroup->addSamples(compactSampleGroup, fragment_sample_count); + } + } + err = + compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); + if(err) goto bail; + } + else + { + err = MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&theGroup); + if(!theGroup) + { + err = MP4CreateSampletoGroupAtom(&theGroup); + if(err) goto bail; + theGroup->grouping_type = groupType; + err = addAtom(self, (MP4AtomPtr)theGroup); + if(err) goto bail; + + fragment_sample_count = 0; + err = MP4GetListEntryCount(self->atomList, &atomListSize); + if(err) goto bail; + for(i = 0; i < atomListSize; i++) + { + MP4TrackRunAtomPtr trun; + err = MP4GetListEntry(self->atomList, i, (char **)&trun); + if(err) goto bail; + if(trun) fragment_sample_count += trun->samplecount; + } + + if(fragment_sample_count > 0) + { + err = theGroup->addSamples(theGroup, fragment_sample_count); + } + } + err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); + if(err) goto bail; + } + bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getSampleGroupMap( struct MP4Atom* s, u32 groupType, u32 sample_number, u32* group_index ) +static MP4Err getSampleGroupMap(struct MP4Atom *s, u32 groupType, u32 sample_number, + u32 *group_index) { MP4Err err; MP4SampletoGroupAtomPtr theGroup; MP4CompactSampletoGroupAtomPtr compactSampleGroup; - MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr) s; + MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr)s; - err = MP4FindGroupAtom( self->groupList, groupType, (MP4AtomPtr*) &theGroup ); - if (theGroup) + err = MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&theGroup); + if(theGroup) { - err = theGroup->getSampleGroupMap( theGroup, sample_number, group_index ); if (err) goto bail; + err = theGroup->getSampleGroupMap(theGroup, sample_number, group_index); + if(err) goto bail; return err; } - err = MP4FindGroupAtom( self->compactSampleGroupList, groupType, (MP4AtomPtr*) &compactSampleGroup ); - if (compactSampleGroup) + err = + MP4FindGroupAtom(self->compactSampleGroupList, groupType, (MP4AtomPtr *)&compactSampleGroup); + if(compactSampleGroup) { - err = compactSampleGroup->getSampleGroupMap( compactSampleGroup, sample_number, group_index ); if (err) goto bail; + err = compactSampleGroup->getSampleGroupMap(compactSampleGroup, sample_number, group_index); + if(err) goto bail; } - else + else { err = MP4BadParamErr; goto bail; } bail: - TEST_RETURN( err ); + TEST_RETURN(err); return err; } -static MP4Err setSampleDependency( struct MP4MediaInformationAtom *s, s32 sample_index, MP4Handle dependencies ) +static MP4Err setSampleDependency(struct MP4MediaInformationAtom *s, s32 sample_index, + MP4Handle dependencies) { - MP4Err err; - MP4TrackFragmentAtomPtr self; - u32 fragment_sample_count, atomListSize, i, j, count, dep_pos; - s32 fragment_pos; - u8* dependency; - - self = (MP4TrackFragmentAtomPtr) s; - - err = MP4NoErr; - - fragment_sample_count = 0; - err = MP4GetListEntryCount( self->atomList, &atomListSize ); if (err) goto bail; - for ( i = 0; i < atomListSize; i++ ) - { - MP4TrackRunAtomPtr trun; - err = MP4GetListEntry( self->atomList, i, (char **) &trun ); if (err) goto bail; - if ( trun ) fragment_sample_count += trun->samplecount; - } - - if (sample_index < 0) sample_index = fragment_sample_count + sample_index; - - err = MP4GetHandleSize( dependencies, &count ); if (err) goto bail; - if ((sample_index + count) > fragment_sample_count) BAILWITHERROR( MP4BadParamErr ); - - fragment_pos = - sample_index; /* starts negative, and hits zero on the first one to do */ - dep_pos = 0; - dependency = (u8*) *dependencies; - - for ( i = 0; (i < atomListSize) && (dep_pos < count); i++ ) - { - MP4TrackRunAtomPtr trun; - err = MP4GetListEntry( self->atomList, i, (char **) &trun ); if (err) goto bail; - if ( trun ) { - for (j=0; (jsamplecount) && (dep_pos < count); j++, fragment_pos++) { - if ((fragment_pos >= 0) && (dep_pos < count)) { - (trun->entries)[j].sample_flags = - ((trun->entries)[j].sample_flags & ~(0xFF << 20)) | - (dependency[dep_pos++] << 20); - } - } - } - } - - bail: - TEST_RETURN( err ); - - return err; + MP4Err err; + MP4TrackFragmentAtomPtr self; + u32 fragment_sample_count, atomListSize, i, j, count, dep_pos; + s32 fragment_pos; + u8 *dependency; + + self = (MP4TrackFragmentAtomPtr)s; + + err = MP4NoErr; + + fragment_sample_count = 0; + err = MP4GetListEntryCount(self->atomList, &atomListSize); + if(err) goto bail; + for(i = 0; i < atomListSize; i++) + { + MP4TrackRunAtomPtr trun; + err = MP4GetListEntry(self->atomList, i, (char **)&trun); + if(err) goto bail; + if(trun) fragment_sample_count += trun->samplecount; + } + + if(sample_index < 0) sample_index = fragment_sample_count + sample_index; + + err = MP4GetHandleSize(dependencies, &count); + if(err) goto bail; + if((sample_index + count) > fragment_sample_count) BAILWITHERROR(MP4BadParamErr); + + fragment_pos = -sample_index; /* starts negative, and hits zero on the first one to do */ + dep_pos = 0; + dependency = (u8 *)*dependencies; + + for(i = 0; (i < atomListSize) && (dep_pos < count); i++) + { + MP4TrackRunAtomPtr trun; + err = MP4GetListEntry(self->atomList, i, (char **)&trun); + if(err) goto bail; + if(trun) + { + for(j = 0; (j < trun->samplecount) && (dep_pos < count); j++, fragment_pos++) + { + if((fragment_pos >= 0) && (dep_pos < count)) + { + (trun->entries)[j].sample_flags = + ((trun->entries)[j].sample_flags & ~(0xFF << 20)) | (dependency[dep_pos++] << 20); + } + } + } + } + +bail: + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - PARSE_ATOM_LIST(MP4TrackFragmentAtom) + PARSE_ATOM_LIST(MP4TrackFragmentAtom) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateTrackFragmentAtom( MP4TrackFragmentAtomPtr *outAtom ) +MP4Err MP4CreateTrackFragmentAtom(MP4TrackFragmentAtomPtr *outAtom) { MP4Err err; MP4TrackFragmentAtomPtr self; - self = (MP4TrackFragmentAtomPtr) calloc( 1, sizeof(MP4TrackFragmentAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4TrackFragmentAtomType; - self->name = "track fragment"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->groupList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->groupDescriptionList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->compactSampleGroupList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->mdatMoved = mdatMoved; - self->addSamples = addSamples; - self->addSampleReference = addSampleReference; - self->mergeRuns = mergeRuns; - self->calculateDataEnd = calculateDataEnd; + self = (MP4TrackFragmentAtomPtr)calloc(1, sizeof(MP4TrackFragmentAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4TrackFragmentAtomType; + self->name = "track fragment"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + err = MP4MakeLinkedList(&self->groupList); + if(err) goto bail; + err = MP4MakeLinkedList(&self->groupDescriptionList); + if(err) goto bail; + err = MP4MakeLinkedList(&self->compactSampleGroupList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->mdatMoved = mdatMoved; + self->addSamples = addSamples; + self->addSampleReference = addSampleReference; + self->mergeRuns = mergeRuns; + self->calculateDataEnd = calculateDataEnd; self->addGroupDescription = addGroupDescription; self->mapSamplestoGroup = mapSamplestoGroup; self->getSampleGroupMap = getSampleGroupMap; self->getGroupDescription = getGroupDescription; - self->setSampleDependency = setSampleDependency; + self->setSampleDependency = setSampleDependency; - self->useSignedCompositionTimeOffsets = 0; - self->mergeSampleAuxiliaryInformation = mergeSampleAuxiliaryInformation; + self->useSignedCompositionTimeOffsets = 0; + self->mergeSampleAuxiliaryInformation = mergeSampleAuxiliaryInformation; self->getSampleAuxiliaryInfoFromTrackFragment = getSampleAuxiliaryInfoFromTrackFragment; - err = MP4MakeLinkedList( &self->saizList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->saioList ); if (err) goto bail; + err = MP4MakeLinkedList(&self->saizList); + if(err) goto bail; + err = MP4MakeLinkedList(&self->saioList); + if(err) goto bail; *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); return err; } diff --git a/IsoLib/libisomediafile/src/TrackFragmentDecodeTimeAtom.c b/IsoLib/libisomediafile/src/TrackFragmentDecodeTimeAtom.c index ffbe721..8391bcf 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentDecodeTimeAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentDecodeTimeAtom.c @@ -28,91 +28,92 @@ #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4TrackFragmentDecodeTimeAtomPtr self = (MP4TrackFragmentDecodeTimeAtomPtr) s; - err = MP4NoErr; - - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4TrackFragmentDecodeTimeAtomPtr self = (MP4TrackFragmentDecodeTimeAtomPtr)s; + err = MP4NoErr; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); - - return; + TEST_RETURN(err); + + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4TrackFragmentDecodeTimeAtomPtr self = (MP4TrackFragmentDecodeTimeAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( baseMediaDecodeTime ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4TrackFragmentDecodeTimeAtomPtr self = (MP4TrackFragmentDecodeTimeAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(baseMediaDecodeTime); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4TrackFragmentDecodeTimeAtomPtr self = (MP4TrackFragmentDecodeTimeAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4; + MP4Err err; + MP4TrackFragmentDecodeTimeAtomPtr self = (MP4TrackFragmentDecodeTimeAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4TrackFragmentDecodeTimeAtomPtr self = (MP4TrackFragmentDecodeTimeAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - GET32( baseMediaDecodeTime ); - assert( self->bytesRead == self->size ); - + MP4Err err; + MP4TrackFragmentDecodeTimeAtomPtr self = (MP4TrackFragmentDecodeTimeAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + GET32(baseMediaDecodeTime); + assert(self->bytesRead == self->size); + bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } -MP4Err MP4CreateTrackFragmentDecodeTimeAtom( MP4TrackFragmentDecodeTimeAtomPtr *outAtom ) +MP4Err MP4CreateTrackFragmentDecodeTimeAtom(MP4TrackFragmentDecodeTimeAtomPtr *outAtom) { - MP4Err err; - MP4TrackFragmentDecodeTimeAtomPtr self; - - self = (MP4TrackFragmentDecodeTimeAtomPtr) calloc( 1, sizeof(MP4TrackFragmentDecodeTimeAtom) ); - TESTMALLOC( self ); - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4TrackFragmentDecodeTimeAtomType; - self->name = "track fragment decode time"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4TrackFragmentDecodeTimeAtomPtr self; + + self = (MP4TrackFragmentDecodeTimeAtomPtr)calloc(1, sizeof(MP4TrackFragmentDecodeTimeAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4TrackFragmentDecodeTimeAtomType; + self->name = "track fragment decode time"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); - - return err; + TEST_RETURN(err); + + return err; } diff --git a/IsoLib/libisomediafile/src/TrackFragmentHeaderAtom.c b/IsoLib/libisomediafile/src/TrackFragmentHeaderAtom.c index 0d42bc1..3ac7c17 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentHeaderAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentHeaderAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,129 +15,155 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackFragmentHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackFragmentHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 flags; - MP4TrackFragmentHeaderAtomPtr self = (MP4TrackFragmentHeaderAtomPtr) s; - err = MP4NoErr; - - flags = self->flags; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( trackID ); - if (flags & tfhd_base_data_offset_present) - { PUT64( base_data_offset ); }; - if (flags & tfhd_sample_description_index_present) - { PUT32( sample_description_index ); }; - if (flags & tfhd_default_sample_duration_present) - { PUT32( default_sample_duration ); }; - if (flags & tfhd_default_sample_size_present) - { PUT32( default_sample_size ); }; - if (flags & tfhd_default_sample_flags_present) - { PUT32( default_sample_flags ); }; - - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 flags; + MP4TrackFragmentHeaderAtomPtr self = (MP4TrackFragmentHeaderAtomPtr)s; + err = MP4NoErr; + + flags = self->flags; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(trackID); + if(flags & tfhd_base_data_offset_present) + { + PUT64(base_data_offset); + }; + if(flags & tfhd_sample_description_index_present) + { + PUT32(sample_description_index); + }; + if(flags & tfhd_default_sample_duration_present) + { + PUT32(default_sample_duration); + }; + if(flags & tfhd_default_sample_size_present) + { + PUT32(default_sample_size); + }; + if(flags & tfhd_default_sample_flags_present) + { + PUT32(default_sample_flags); + }; + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - u32 flags; - MP4TrackFragmentHeaderAtomPtr self = (MP4TrackFragmentHeaderAtomPtr) s; - err = MP4NoErr; - - flags = self->flags; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4; - if (flags & tfhd_base_data_offset_present) self->size += 8; - if (flags & tfhd_sample_description_index_present) self->size += 4; - if (flags & tfhd_default_sample_duration_present) self->size += 4; - if (flags & tfhd_default_sample_size_present) self->size += 4; - if (flags & tfhd_default_sample_flags_present) self->size += 4; - + MP4Err err; + u32 flags; + MP4TrackFragmentHeaderAtomPtr self = (MP4TrackFragmentHeaderAtomPtr)s; + err = MP4NoErr; + + flags = self->flags; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4; + if(flags & tfhd_base_data_offset_present) self->size += 8; + if(flags & tfhd_sample_description_index_present) self->size += 4; + if(flags & tfhd_default_sample_duration_present) self->size += 4; + if(flags & tfhd_default_sample_size_present) self->size += 4; + if(flags & tfhd_default_sample_flags_present) self->size += 4; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 flags; - MP4TrackFragmentHeaderAtomPtr self = (MP4TrackFragmentHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - flags = self->flags; - GET32( trackID ); - - if (flags & tfhd_base_data_offset_present) { GET64( base_data_offset ); }; - if (flags & tfhd_sample_description_index_present) { GET32( sample_description_index ); }; - if (flags & tfhd_default_sample_duration_present) { GET32( default_sample_duration ); }; - if (flags & tfhd_default_sample_size_present) { GET32( default_sample_size ); }; - if (flags & tfhd_default_sample_flags_present) { GET32( default_sample_flags ); }; + MP4Err err; + u32 flags; + MP4TrackFragmentHeaderAtomPtr self = (MP4TrackFragmentHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + flags = self->flags; + GET32(trackID); + + if(flags & tfhd_base_data_offset_present) + { + GET64(base_data_offset); + }; + if(flags & tfhd_sample_description_index_present) + { + GET32(sample_description_index); + }; + if(flags & tfhd_default_sample_duration_present) + { + GET32(default_sample_duration); + }; + if(flags & tfhd_default_sample_size_present) + { + GET32(default_sample_size); + }; + if(flags & tfhd_default_sample_flags_present) + { + GET32(default_sample_flags); + }; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateTrackFragmentHeaderAtom( MP4TrackFragmentHeaderAtomPtr *outAtom ) +MP4Err MP4CreateTrackFragmentHeaderAtom(MP4TrackFragmentHeaderAtomPtr *outAtom) { - MP4Err err; - MP4TrackFragmentHeaderAtomPtr self; - - self = (MP4TrackFragmentHeaderAtomPtr) calloc( 1, sizeof(MP4TrackFragmentHeaderAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4TrackFragmentHeaderAtomType; - self->name = "track fragment header"; - self->flags = 0; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4TrackFragmentHeaderAtomPtr self; + + self = (MP4TrackFragmentHeaderAtomPtr)calloc(1, sizeof(MP4TrackFragmentHeaderAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4TrackFragmentHeaderAtomType; + self->name = "track fragment header"; + self->flags = 0; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TrackFragmentRunAtom.c b/IsoLib/libisomediafile/src/TrackFragmentRunAtom.c index 68d1a18..d2b1b36 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentRunAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentRunAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,233 +15,279 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackFragmentRunAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackFragmentRunAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4TrackRunAtomPtr self; - - self = (MP4TrackRunAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - if ( self->entries ) - { - free( self->entries ); - self->entries = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4TrackRunAtomPtr self; + + self = (MP4TrackRunAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->entries) + { + free(self->entries); + self->entries = NULL; + } + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static void calculateDefaults (struct MP4TrackRunAtom *self, MP4TrackFragmentHeaderAtomPtr tfhd, u32 flags_index ) +static void calculateDefaults(struct MP4TrackRunAtom *self, MP4TrackFragmentHeaderAtomPtr tfhd, + u32 flags_index) { - MP4Err err; - MP4TrackRunEntryPtr entry; - err = MP4NoErr; - - if (self->samplecount == 0) goto bail; - - entry=self->entries; - - if (tfhd->default_sample_duration == 0) - tfhd->default_sample_duration = entry->sample_duration; - if (tfhd->default_sample_size == 0) - tfhd->default_sample_size = entry->sample_size; - if ((tfhd->default_sample_flags == 0) && (self->samplecount >= flags_index)) - tfhd->default_sample_flags = entry[flags_index-1].sample_flags; + MP4Err err; + MP4TrackRunEntryPtr entry; + err = MP4NoErr; -bail: - TEST_RETURN( err ); + if(self->samplecount == 0) goto bail; + + entry = self->entries; + + if(tfhd->default_sample_duration == 0) tfhd->default_sample_duration = entry->sample_duration; + if(tfhd->default_sample_size == 0) tfhd->default_sample_size = entry->sample_size; + if((tfhd->default_sample_flags == 0) && (self->samplecount >= flags_index)) + tfhd->default_sample_flags = entry[flags_index - 1].sample_flags; - return; +bail: + TEST_RETURN(err); + return; } -static void setFlags (struct MP4TrackRunAtom *self, MP4TrackFragmentHeaderAtomPtr tfhd ) +static void setFlags(struct MP4TrackRunAtom *self, MP4TrackFragmentHeaderAtomPtr tfhd) { - u32 flags; - MP4Err err; - u32 i; - MP4TrackRunEntryPtr entry; - - err = MP4NoErr; - flags = 0; - - if (self->data_offset != 0) flags |= trun_data_offset_present; - - entry = self->entries; - self->first_sample_flags = entry->sample_flags; - - if (entry->sample_flags != tfhd->default_sample_flags) - flags |= trun_first_sample_flags_present; - - for (i=0, entry=self->entries; isamplecount; i++, entry++ ) { - if (entry->sample_duration != tfhd->default_sample_duration) - flags |= trun_sample_duration_present; - if (entry->sample_size != tfhd->default_sample_size) - flags |= trun_sample_size_present; - if ((i>0) && (entry->sample_flags != tfhd->default_sample_flags)) - flags = (flags & ~trun_first_sample_flags_present) | trun_sample_flags_present; - if (entry->sample_composition_time_offset != 0) - flags |= trun_sample_composition_times_present; - - if ((flags & trun_all_sample_flags) == trun_all_sample_flags) break; - } - self->flags = flags; - - return; + u32 flags; + MP4Err err; + u32 i; + MP4TrackRunEntryPtr entry; + + err = MP4NoErr; + flags = 0; + + if(self->data_offset != 0) flags |= trun_data_offset_present; + + entry = self->entries; + self->first_sample_flags = entry->sample_flags; + if(entry->sample_flags != tfhd->default_sample_flags) flags |= trun_first_sample_flags_present; + + for(i = 0, entry = self->entries; i < self->samplecount; i++, entry++) + { + if(entry->sample_duration != tfhd->default_sample_duration) + flags |= trun_sample_duration_present; + if(entry->sample_size != tfhd->default_sample_size) flags |= trun_sample_size_present; + if((i > 0) && (entry->sample_flags != tfhd->default_sample_flags)) + flags = (flags & ~trun_first_sample_flags_present) | trun_sample_flags_present; + if(entry->sample_composition_time_offset != 0) flags |= trun_sample_composition_times_present; + + if((flags & trun_all_sample_flags) == trun_all_sample_flags) break; + } + self->flags = flags; + + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 flags; - u32 i; - MP4TrackRunEntryPtr entry; - MP4TrackRunAtomPtr self = (MP4TrackRunAtomPtr) s; - err = MP4NoErr; - - flags = self->flags; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT32( samplecount ); - - if (flags & trun_data_offset_present) { PUT32( data_offset ); }; - if (flags & trun_first_sample_flags_present) { PUT32( first_sample_flags ); }; - for (i=0, entry = self->entries; isamplecount; i++, entry++) { - if (flags & trun_sample_duration_present) { PUT32_V( entry->sample_duration ); }; - if (flags & trun_sample_size_present) { PUT32_V( entry->sample_size ); }; - if (flags & trun_sample_flags_present) { PUT32_V( entry->sample_flags ); }; - if (flags & trun_sample_composition_times_present) { PUT32_V( entry->sample_composition_time_offset ); }; - } + MP4Err err; + u32 flags; + u32 i; + MP4TrackRunEntryPtr entry; + MP4TrackRunAtomPtr self = (MP4TrackRunAtomPtr)s; + err = MP4NoErr; + + flags = self->flags; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(samplecount); + + if(flags & trun_data_offset_present) + { + PUT32(data_offset); + }; + if(flags & trun_first_sample_flags_present) + { + PUT32(first_sample_flags); + }; + for(i = 0, entry = self->entries; i < self->samplecount; i++, entry++) + { + if(flags & trun_sample_duration_present) + { + PUT32_V(entry->sample_duration); + }; + if(flags & trun_sample_size_present) + { + PUT32_V(entry->sample_size); + }; + if(flags & trun_sample_flags_present) + { + PUT32_V(entry->sample_flags); + }; + if(flags & trun_sample_composition_times_present) + { + PUT32_V(entry->sample_composition_time_offset); + }; + } - assert( self->bytesWritten == self->size ); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - u32 flags; - u32 entry_size; - MP4TrackRunAtomPtr self = (MP4TrackRunAtomPtr) s; - err = MP4NoErr; - - flags = self->flags; - entry_size = 0; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 4; - - if (flags & trun_data_offset_present) self->size += 4; - if (flags & trun_first_sample_flags_present) self->size += 4; - if (flags & trun_sample_duration_present) entry_size += 4; - if (flags & trun_sample_size_present) entry_size += 4; - if (flags & trun_sample_flags_present) entry_size += 4; - if (flags & trun_sample_composition_times_present) entry_size += 4; - self->size += entry_size * self->samplecount; - + MP4Err err; + u32 flags; + u32 entry_size; + MP4TrackRunAtomPtr self = (MP4TrackRunAtomPtr)s; + err = MP4NoErr; + + flags = self->flags; + entry_size = 0; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 4; + + if(flags & trun_data_offset_present) self->size += 4; + if(flags & trun_first_sample_flags_present) self->size += 4; + if(flags & trun_sample_duration_present) entry_size += 4; + if(flags & trun_sample_size_present) entry_size += 4; + if(flags & trun_sample_flags_present) entry_size += 4; + if(flags & trun_sample_composition_times_present) entry_size += 4; + self->size += entry_size * self->samplecount; + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -int bitcount(int v) { - unsigned int c; /* c accumulates the total bits set in v */ - for (c = 0; v; c++) - { - v &= v - 1; /* clear the least significant bit set */ - } - return c; +int bitcount(int v) +{ + unsigned int c; /* c accumulates the total bits set in v */ + for(c = 0; v; c++) + { + v &= v - 1; /* clear the least significant bit set */ + } + return c; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - u32 flags; - u32 i; - MP4TrackRunEntryPtr entry; - MP4TrackRunAtomPtr self = (MP4TrackRunAtomPtr) s; - u32 field_count, record_count, r, junk; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - flags = self->flags; - GET32( samplecount ); - - self->entries = (MP4TrackRunEntry*) calloc( self->samplecount, sizeof( MP4TrackRunEntry )); - - field_count = bitcount(flags & 0xFF); - record_count = bitcount(flags & 0xFF00); - - if (flags & trun_data_offset_present) { GET32( data_offset ); field_count--; }; - if (flags & trun_first_sample_flags_present) { GET32( first_sample_flags ); field_count--; }; - while (field_count > 0) { GET32_V(junk); field_count--; } - - for (i=0, entry = self->entries; isamplecount; i++, entry++) { - r = record_count; - if (flags & trun_sample_duration_present) - { GET32_V_MSG(( entry->sample_duration ), "duration"); r--; }; - if (flags & trun_sample_size_present) - { GET32_V_MSG(( entry->sample_size ), "size"); r--; }; - if (flags & trun_sample_flags_present) - { GET32_V_MSG(( entry->sample_flags ), "flags"); r--; }; - if (flags & trun_sample_composition_times_present) - { GET32_V_MSG(( entry->sample_composition_time_offset ), "comp offset"); r--; }; - while (r > 0) { GET32_V(junk); r--; } + MP4Err err; + u32 flags; + u32 i; + MP4TrackRunEntryPtr entry; + MP4TrackRunAtomPtr self = (MP4TrackRunAtomPtr)s; + u32 field_count, record_count, r, junk; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + flags = self->flags; + GET32(samplecount); + + self->entries = (MP4TrackRunEntry *)calloc(self->samplecount, sizeof(MP4TrackRunEntry)); + + field_count = bitcount(flags & 0xFF); + record_count = bitcount(flags & 0xFF00); + + if(flags & trun_data_offset_present) + { + GET32(data_offset); + field_count--; + }; + if(flags & trun_first_sample_flags_present) + { + GET32(first_sample_flags); + field_count--; + }; + while(field_count > 0) + { + GET32_V(junk); + field_count--; + } + + for(i = 0, entry = self->entries; i < self->samplecount; i++, entry++) + { + r = record_count; + if(flags & trun_sample_duration_present) + { + GET32_V_MSG((entry->sample_duration), "duration"); + r--; + }; + if(flags & trun_sample_size_present) + { + GET32_V_MSG((entry->sample_size), "size"); + r--; + }; + if(flags & trun_sample_flags_present) + { + GET32_V_MSG((entry->sample_flags), "flags"); + r--; + }; + if(flags & trun_sample_composition_times_present) + { + GET32_V_MSG((entry->sample_composition_time_offset), "comp offset"); + r--; + }; + while(r > 0) + { + GET32_V(junk); + r--; } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateTrackRunAtom( MP4TrackRunAtomPtr *outAtom ) +MP4Err MP4CreateTrackRunAtom(MP4TrackRunAtomPtr *outAtom) { - MP4Err err; - MP4TrackRunAtomPtr self; - - self = (MP4TrackRunAtomPtr) calloc( 1, sizeof(MP4TrackRunAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4TrackRunAtomType; - self->name = "track fragment run"; - self->flags = 0; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - self->setFlags = setFlags; - self->calculateDefaults = calculateDefaults; - *outAtom = self; + MP4Err err; + MP4TrackRunAtomPtr self; + + self = (MP4TrackRunAtomPtr)calloc(1, sizeof(MP4TrackRunAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4TrackRunAtomType; + self->name = "track fragment run"; + self->flags = 0; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + self->setFlags = setFlags; + self->calculateDefaults = calculateDefaults; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TrackGroupAtom.c b/IsoLib/libisomediafile/src/TrackGroupAtom.c index 7e723c7..e5fc1aa 100644 --- a/IsoLib/libisomediafile/src/TrackGroupAtom.c +++ b/IsoLib/libisomediafile/src/TrackGroupAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -26,150 +26,150 @@ derivative works. Copyright (c) 1999. #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 i; - MP4TrackGroupAtomPtr self; - err = MP4NoErr; - self = (MP4TrackGroupAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + u32 i; + MP4TrackGroupAtomPtr self; + err = MP4NoErr; + self = (MP4TrackGroupAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4TrackGroupAtomPtr self = (MP4TrackGroupAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4TrackGroupAtomPtr self = (MP4TrackGroupAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4TrackGroupAtomPtr self = (MP4TrackGroupAtomPtr ) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE( atomList ); + MP4Err err; + MP4TrackGroupAtomPtr self = (MP4TrackGroupAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err findAtomOfType( struct MP4TrackGroupAtom *self, u32 atomType, MP4AtomPtr *outAtom ) +static MP4Err findAtomOfType(struct MP4TrackGroupAtom *self, u32 atomType, MP4AtomPtr *outAtom) { - MP4Err err; - u32 entryCount; - u32 i; - MP4AtomPtr foundAtom; - - err = MP4NoErr; - foundAtom = NULL; - err = MP4GetListEntryCount( self->atomList, &entryCount ); if (err) goto bail; - for ( i = 0; i < entryCount; i++ ) - { - MP4AtomPtr anAtom; - err = MP4GetListEntry( self->atomList, i, (char**) &anAtom ); if (err) goto bail; - if ( anAtom->type == atomType ) - { - foundAtom = anAtom; - break; - } - } - *outAtom = foundAtom; + MP4Err err; + u32 entryCount; + u32 i; + MP4AtomPtr foundAtom; + + err = MP4NoErr; + foundAtom = NULL; + err = MP4GetListEntryCount(self->atomList, &entryCount); + if(err) goto bail; + for(i = 0; i < entryCount; i++) + { + MP4AtomPtr anAtom; + err = MP4GetListEntry(self->atomList, i, (char **)&anAtom); + if(err) goto bail; + if(anAtom->type == atomType) + { + foundAtom = anAtom; + break; + } + } + *outAtom = foundAtom; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } - -static MP4Err addAtom( MP4TrackGroupAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4TrackGroupAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - if ( self == 0 ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4AddListEntry( atom, self->atomList ); + MP4Err err; + if(self == 0) BAILWITHERROR(MP4BadParamErr); + err = MP4AddListEntry(atom, self->atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - /* PARSE_ATOM_LIST(MP4TrackGroupAtom) */ - /* we need to have an empty proto list and a default type here, alas */ - u32 NoProtos[] = { 0 }; - MP4Err err; - MP4TrackGroupAtomPtr self = (MP4TrackGroupAtomPtr) s; - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - while ( self->bytesRead < self->size ) - { - MP4AtomPtr atom; - err = MP4ParseAtomUsingProtoList( (MP4InputStreamPtr) inputStream, - NoProtos, MP4_FOUR_CHAR_CODE('m', 's', 'r', 'c'), - &atom); - if (err) goto bail; - self->bytesRead += atom->size; - if ( ((atom->type)== MP4FreeSpaceAtomType) || ((atom->type)== MP4SkipAtomType)) - atom->destroy( atom ); - else { - err = addAtom( self, atom ); - if (err) goto bail; - } - } - if ( self->bytesRead != self->size ) - BAILWITHERROR( MP4BadDataErr ) + /* PARSE_ATOM_LIST(MP4TrackGroupAtom) */ + /* we need to have an empty proto list and a default type here, alas */ + u32 NoProtos[] = {0}; + MP4Err err; + MP4TrackGroupAtomPtr self = (MP4TrackGroupAtomPtr)s; + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + while(self->bytesRead < self->size) + { + MP4AtomPtr atom; + err = MP4ParseAtomUsingProtoList((MP4InputStreamPtr)inputStream, NoProtos, + MP4_FOUR_CHAR_CODE('m', 's', 'r', 'c'), &atom); + if(err) goto bail; + self->bytesRead += atom->size; + if(((atom->type) == MP4FreeSpaceAtomType) || ((atom->type) == MP4SkipAtomType)) + atom->destroy(atom); + else + { + err = addAtom(self, atom); + if(err) goto bail; + } + } + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateTrackGroupAtom( MP4TrackGroupAtomPtr *outAtom ) +MP4Err MP4CreateTrackGroupAtom(MP4TrackGroupAtomPtr *outAtom) { - MP4Err err; - MP4TrackGroupAtomPtr self; - self = (MP4TrackGroupAtomPtr) calloc( 1, sizeof(MP4TrackGroupAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); if ( err ) goto bail; - self->type = MP4TrackGroupAtomType; - self->name = "track group"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->findAtomOfType = findAtomOfType; - self->addAtom = addAtom; - *outAtom = self; + MP4Err err; + MP4TrackGroupAtomPtr self; + self = (MP4TrackGroupAtomPtr)calloc(1, sizeof(MP4TrackGroupAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4TrackGroupAtomType; + self->name = "track group"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->findAtomOfType = findAtomOfType; + self->addAtom = addAtom; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TrackGroupTypeAtom.c b/IsoLib/libisomediafile/src/TrackGroupTypeAtom.c index e174e15..226fad3 100644 --- a/IsoLib/libisomediafile/src/TrackGroupTypeAtom.c +++ b/IsoLib/libisomediafile/src/TrackGroupTypeAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -26,94 +26,95 @@ derivative works. Copyright (c) 1999. #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4TrackGroupTypeAtomPtr self; - self = (MP4TrackGroupTypeAtomPtr) s; - if ( self->super ) - self->super->destroy( s ); + MP4TrackGroupTypeAtomPtr self; + self = (MP4TrackGroupTypeAtomPtr)s; + if(self->super) self->super->destroy(s); } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4TrackGroupTypeAtomPtr self = (MP4TrackGroupTypeAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); if (err) goto bail; - buffer += self->bytesWritten; - PUT32(track_group_id); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4TrackGroupTypeAtomPtr self = (MP4TrackGroupTypeAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT32(track_group_id); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4TrackGroupTypeAtomPtr self = (MP4TrackGroupTypeAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if (err) goto bail; - self->size += (sizeof(u32)); + MP4Err err; + MP4TrackGroupTypeAtomPtr self = (MP4TrackGroupTypeAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += (sizeof(u32)); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - MP4TrackGroupTypeAtomPtr self = (MP4TrackGroupTypeAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); + MP4Err err; + long bytesToRead; + MP4TrackGroupTypeAtomPtr self = (MP4TrackGroupTypeAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); - bytesToRead = s->size - s->bytesRead; - GET32(track_group_id); + bytesToRead = s->size - s->bytesRead; + GET32(track_group_id); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } static MP4Err setGroupID(struct MP4TrackGroupTypeAtom *self, u32 track_group_id) { - MP4Err err; - err = MP4NoErr; + MP4Err err; + err = MP4NoErr; - self->track_group_id = track_group_id; + self->track_group_id = track_group_id; - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -MP4Err MP4CreateTrackGroupTypeAtom( u32 atomType, MP4TrackGroupTypeAtomPtr *outAtom ) +MP4Err MP4CreateTrackGroupTypeAtom(u32 atomType, MP4TrackGroupTypeAtomPtr *outAtom) { - MP4Err err; - MP4TrackGroupTypeAtomPtr self; - - self = (MP4TrackGroupTypeAtomPtr) calloc( 1, sizeof(MP4TrackGroupTypeAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = atomType; - self->name = "track group type"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->setGroupID = setGroupID; - *outAtom = self; + MP4Err err; + MP4TrackGroupTypeAtomPtr self; + + self = (MP4TrackGroupTypeAtomPtr)calloc(1, sizeof(MP4TrackGroupTypeAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = atomType; + self->name = "track group type"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->setGroupID = setGroupID; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TrackHeaderAtom.c b/IsoLib/libisomediafile/src/TrackHeaderAtom.c index 4a0a7f7..8afda1d 100644 --- a/IsoLib/libisomediafile/src/TrackHeaderAtom.c +++ b/IsoLib/libisomediafile/src/TrackHeaderAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,177 +15,178 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4TrackHeaderAtomPtr self = (MP4TrackHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - if ( self->version == 1 ) - { - PUT64( creationTime ); - PUT64( modificationTime ); - PUT32( trackID ); - PUT32( qt_reserved1 ); - PUT64( duration ); - } - else - { - PUT32( creationTime ); - PUT32( modificationTime ); - PUT32( trackID ); - PUT32( qt_reserved1 ); - PUT32( duration ); - } - PUTBYTES(self->qt_reserved2, 8 ); - PUT16( qt_layer ); - PUT16( qt_alternateGroup ); - PUT16( qt_volume ); - PUT16( qt_reserved3 ); - PUT32( qt_matrixA ); - PUT32( qt_matrixB ); - PUT32( qt_matrixU ); - PUT32( qt_matrixC ); - PUT32( qt_matrixD ); - PUT32( qt_matrixV ); - PUT32( qt_matrixX ); - PUT32( qt_matrixY ); - PUT32( qt_matrixW ); - PUT32( qt_trackWidth ); - PUT32( qt_trackHeight ); - - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4TrackHeaderAtomPtr self = (MP4TrackHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + if(self->version == 1) + { + PUT64(creationTime); + PUT64(modificationTime); + PUT32(trackID); + PUT32(qt_reserved1); + PUT64(duration); + } + else + { + PUT32(creationTime); + PUT32(modificationTime); + PUT32(trackID); + PUT32(qt_reserved1); + PUT32(duration); + } + PUTBYTES(self->qt_reserved2, 8); + PUT16(qt_layer); + PUT16(qt_alternateGroup); + PUT16(qt_volume); + PUT16(qt_reserved3); + PUT32(qt_matrixA); + PUT32(qt_matrixB); + PUT32(qt_matrixU); + PUT32(qt_matrixC); + PUT32(qt_matrixD); + PUT32(qt_matrixV); + PUT32(qt_matrixX); + PUT32(qt_matrixY); + PUT32(qt_matrixW); + PUT32(qt_trackWidth); + PUT32(qt_trackHeight); + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4TrackHeaderAtomPtr self = (MP4TrackHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += (8 + (4*2)+(11*4)); - self->size += self->version == 1 ? (3*8)+(2*4) : (5*4); + MP4Err err; + MP4TrackHeaderAtomPtr self = (MP4TrackHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += (8 + (4 * 2) + (11 * 4)); + self->size += self->version == 1 ? (3 * 8) + (2 * 4) : (5 * 4); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4TrackHeaderAtomPtr self = (MP4TrackHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - if ( self->version == 1 ) - { - GET64_MSG( creationTime, NULL ); - /* DEBUG_SPRINTF( "creationTime = %llu", self->creationTime ); */ - /* commented out to avoid compiler warnings on the %ll (not an ansi modifier) dws */ - - GET64_MSG( modificationTime, NULL ); - /* DEBUG_SPRINTF( "modificationTime = %llu", self->modificationTime ); */ - - GET32( trackID ); - GET32( qt_reserved1 ); - GET64_MSG( duration, NULL ); - /* DEBUG_SPRINTF( "duration = %llu", self->duration ); */ - } - else - { - u32 val; - GET32_V_MSG( val, "creationTime" ); - self->creationTime = val; - GET32_V_MSG( val, "modificationTime" ); - self->modificationTime = val; - - GET32( trackID ); - GET32( qt_reserved1 ); - GET32_V_MSG( val, "duration" ); - self->duration = val; - } - GETBYTES( 8, qt_reserved2 ); - GET16( qt_layer ); - GET16( qt_alternateGroup ); - GET16( qt_volume ); - GET16( qt_reserved3 ); - GET32( qt_matrixA ); - GET32( qt_matrixB ); - GET32( qt_matrixU ); - GET32( qt_matrixC ); - GET32( qt_matrixD ); - GET32( qt_matrixV ); - GET32( qt_matrixX ); - GET32( qt_matrixY ); - GET32( qt_matrixW ); - GET32( qt_trackWidth ); - GET32( qt_trackHeight ); + MP4Err err; + MP4TrackHeaderAtomPtr self = (MP4TrackHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + if(self->version == 1) + { + GET64_MSG(creationTime, NULL); + /* DEBUG_SPRINTF( "creationTime = %llu", self->creationTime ); */ + /* commented out to avoid compiler warnings on the %ll (not an ansi modifier) dws */ + + GET64_MSG(modificationTime, NULL); + /* DEBUG_SPRINTF( "modificationTime = %llu", self->modificationTime ); */ + + GET32(trackID); + GET32(qt_reserved1); + GET64_MSG(duration, NULL); + /* DEBUG_SPRINTF( "duration = %llu", self->duration ); */ + } + else + { + u32 val; + GET32_V_MSG(val, "creationTime"); + self->creationTime = val; + GET32_V_MSG(val, "modificationTime"); + self->modificationTime = val; + + GET32(trackID); + GET32(qt_reserved1); + GET32_V_MSG(val, "duration"); + self->duration = val; + } + GETBYTES(8, qt_reserved2); + GET16(qt_layer); + GET16(qt_alternateGroup); + GET16(qt_volume); + GET16(qt_reserved3); + GET32(qt_matrixA); + GET32(qt_matrixB); + GET32(qt_matrixU); + GET32(qt_matrixC); + GET32(qt_matrixD); + GET32(qt_matrixV); + GET32(qt_matrixX); + GET32(qt_matrixY); + GET32(qt_matrixW); + GET32(qt_trackWidth); + GET32(qt_trackHeight); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateTrackHeaderAtom( MP4TrackHeaderAtomPtr *outAtom ) +MP4Err MP4CreateTrackHeaderAtom(MP4TrackHeaderAtomPtr *outAtom) { - MP4Err err; - MP4TrackHeaderAtomPtr self; - - self = (MP4TrackHeaderAtomPtr) calloc( 1, sizeof(MP4TrackHeaderAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4TrackHeaderAtomType; - self->name = "track header"; - self->flags = 7; /* track is enabled,in movie, in preview, by default */ - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->qt_matrixA = (1<<16); - self->qt_matrixD = (1<<16); - self->qt_matrixW = (1<<30); - *outAtom = self; + MP4Err err; + MP4TrackHeaderAtomPtr self; + + self = (MP4TrackHeaderAtomPtr)calloc(1, sizeof(MP4TrackHeaderAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4TrackHeaderAtomType; + self->name = "track header"; + self->flags = 7; /* track is enabled,in movie, in preview, by default */ + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->qt_matrixA = (1 << 16); + self->qt_matrixD = (1 << 16); + self->qt_matrixW = (1 << 30); + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TrackReferenceAtom.c b/IsoLib/libisomediafile/src/TrackReferenceAtom.c index 4adbae1..3d06df1 100644 --- a/IsoLib/libisomediafile/src/TrackReferenceAtom.c +++ b/IsoLib/libisomediafile/src/TrackReferenceAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,161 +15,162 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackReferenceAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackReferenceAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - u32 i; - MP4TrackReferenceAtomPtr self; - err = MP4NoErr; - self = (MP4TrackReferenceAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + u32 i; + MP4TrackReferenceAtomPtr self; + err = MP4NoErr; + self = (MP4TrackReferenceAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4TrackReferenceAtomPtr self = (MP4TrackReferenceAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - SERIALIZE_ATOM_LIST( atomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4TrackReferenceAtomPtr self = (MP4TrackReferenceAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + SERIALIZE_ATOM_LIST(atomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4TrackReferenceAtomPtr self = (MP4TrackReferenceAtomPtr ) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - ADD_ATOM_LIST_SIZE( atomList ); + MP4Err err; + MP4TrackReferenceAtomPtr self = (MP4TrackReferenceAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + ADD_ATOM_LIST_SIZE(atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err findAtomOfType( struct MP4TrackReferenceAtom *self, u32 atomType, MP4AtomPtr *outAtom ) +static MP4Err findAtomOfType(struct MP4TrackReferenceAtom *self, u32 atomType, MP4AtomPtr *outAtom) { - MP4Err err; - u32 entryCount; - u32 i; - MP4AtomPtr foundAtom; - - err = MP4NoErr; - foundAtom = NULL; - err = MP4GetListEntryCount( self->atomList, &entryCount ); if (err) goto bail; - for ( i = 0; i < entryCount; i++ ) - { - MP4AtomPtr anAtom; - err = MP4GetListEntry( self->atomList, i, (char**) &anAtom ); if (err) goto bail; - if ( anAtom->type == atomType ) - { - foundAtom = anAtom; - break; - } - } - *outAtom = foundAtom; + MP4Err err; + u32 entryCount; + u32 i; + MP4AtomPtr foundAtom; + + err = MP4NoErr; + foundAtom = NULL; + err = MP4GetListEntryCount(self->atomList, &entryCount); + if(err) goto bail; + for(i = 0; i < entryCount; i++) + { + MP4AtomPtr anAtom; + err = MP4GetListEntry(self->atomList, i, (char **)&anAtom); + if(err) goto bail; + if(anAtom->type == atomType) + { + foundAtom = anAtom; + break; + } + } + *outAtom = foundAtom; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } - -static MP4Err addAtom( MP4TrackReferenceAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4TrackReferenceAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - if ( self == 0 ) - BAILWITHERROR( MP4BadParamErr ); - err = MP4AddListEntry( atom, self->atomList ); + MP4Err err; + if(self == 0) BAILWITHERROR(MP4BadParamErr); + err = MP4AddListEntry(atom, self->atomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - - -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - /* PARSE_ATOM_LIST(MP4TrackReferenceAtom) */ - /* we need to have an empty proto list and a default type here, alas */ - u32 NoProtos[] = { 0 }; - MP4Err err; - MP4TrackReferenceAtomPtr self = (MP4TrackReferenceAtomPtr) s; - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - while ( self->bytesRead < self->size ) - { - MP4AtomPtr atom; - err = MP4ParseAtomUsingProtoList( (MP4InputStreamPtr) inputStream, - NoProtos, MP4StreamDependenceAtomType, &atom ); - if (err) goto bail; - self->bytesRead += atom->size; - if ( ((atom->type)== MP4FreeSpaceAtomType) || ((atom->type)== MP4SkipAtomType)) - atom->destroy( atom ); - else { - err = addAtom( self, atom ); - if (err) goto bail; - } - } - if ( self->bytesRead != self->size ) - BAILWITHERROR( MP4BadDataErr ) + /* PARSE_ATOM_LIST(MP4TrackReferenceAtom) */ + /* we need to have an empty proto list and a default type here, alas */ + u32 NoProtos[] = {0}; + MP4Err err; + MP4TrackReferenceAtomPtr self = (MP4TrackReferenceAtomPtr)s; + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + while(self->bytesRead < self->size) + { + MP4AtomPtr atom; + err = MP4ParseAtomUsingProtoList((MP4InputStreamPtr)inputStream, NoProtos, + MP4StreamDependenceAtomType, &atom); + if(err) goto bail; + self->bytesRead += atom->size; + if(((atom->type) == MP4FreeSpaceAtomType) || ((atom->type) == MP4SkipAtomType)) + atom->destroy(atom); + else + { + err = addAtom(self, atom); + if(err) goto bail; + } + } + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateTrackReferenceAtom( MP4TrackReferenceAtomPtr *outAtom ) +MP4Err MP4CreateTrackReferenceAtom(MP4TrackReferenceAtomPtr *outAtom) { - MP4Err err; - MP4TrackReferenceAtomPtr self; - self = (MP4TrackReferenceAtomPtr) calloc( 1, sizeof(MP4TrackReferenceAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); if ( err ) goto bail; - self->type = MP4TrackReferenceAtomType; - self->name = "track reference"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - err = MP4MakeLinkedList( &self->atomList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->findAtomOfType = findAtomOfType; - self->addAtom = addAtom; - *outAtom = self; + MP4Err err; + MP4TrackReferenceAtomPtr self; + self = (MP4TrackReferenceAtomPtr)calloc(1, sizeof(MP4TrackReferenceAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4TrackReferenceAtomType; + self->name = "track reference"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + err = MP4MakeLinkedList(&self->atomList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->findAtomOfType = findAtomOfType; + self->addAtom = addAtom; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TrackReferenceTypeAtom.c b/IsoLib/libisomediafile/src/TrackReferenceTypeAtom.c index 278d153..bed3931 100644 --- a/IsoLib/libisomediafile/src/TrackReferenceTypeAtom.c +++ b/IsoLib/libisomediafile/src/TrackReferenceTypeAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,140 +15,141 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackReferenceTypeAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackReferenceTypeAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4TrackReferenceTypeAtomPtr self; - self = (MP4TrackReferenceTypeAtomPtr) s; - if ( self->trackIDs ) - { - free( self->trackIDs ); - self->trackIDs = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4TrackReferenceTypeAtomPtr self; + self = (MP4TrackReferenceTypeAtomPtr)s; + if(self->trackIDs) + { + free(self->trackIDs); + self->trackIDs = NULL; + } + if(self->super) self->super->destroy(s); } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 i; - MP4TrackReferenceTypeAtomPtr self = (MP4TrackReferenceTypeAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - for ( i = 0; i < self->trackIDCount; i++ ) - { - PUT32( trackIDs[i] ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 i; + MP4TrackReferenceTypeAtomPtr self = (MP4TrackReferenceTypeAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + for(i = 0; i < self->trackIDCount; i++) + { + PUT32(trackIDs[i]); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4TrackReferenceTypeAtomPtr self = (MP4TrackReferenceTypeAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += (self->trackIDCount * sizeof(u32)); + MP4Err err; + MP4TrackReferenceTypeAtomPtr self = (MP4TrackReferenceTypeAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += (self->trackIDCount * sizeof(u32)); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - u32 i; - MP4TrackReferenceTypeAtomPtr self = (MP4TrackReferenceTypeAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); - - bytesToRead = s->size - s->bytesRead; - self->trackIDCount = bytesToRead / sizeof(u32); - self->trackIDs = (u32*) calloc( 1, bytesToRead ); - TESTMALLOC( self->trackIDs ) - - for ( i = 0; i < self->trackIDCount; i++ ) - { - GET32( trackIDs[i] ); - } + MP4Err err; + long bytesToRead; + u32 i; + MP4TrackReferenceTypeAtomPtr self = (MP4TrackReferenceTypeAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + + bytesToRead = s->size - s->bytesRead; + self->trackIDCount = bytesToRead / sizeof(u32); + self->trackIDs = (u32 *)calloc(1, bytesToRead); + TESTMALLOC(self->trackIDs) + + for(i = 0; i < self->trackIDCount; i++) + { + GET32(trackIDs[i]); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - if ( err && self->trackIDs ) - { - free( self->trackIDs ); - } - return err; + if(err && self->trackIDs) + { + free(self->trackIDs); + } + return err; } -static MP4Err addTrackID( struct MP4TrackReferenceTypeAtom *self, u32 trackID ) +static MP4Err addTrackID(struct MP4TrackReferenceTypeAtom *self, u32 trackID) { - MP4Err err; - u32 i; - err = MP4NoErr; - if ( trackID == 0 ) - BAILWITHERROR( MP4BadParamErr ); - - /* JLF 12 / 00: don't add a dep if already here !! */ - for (i = 0; i < self->trackIDCount; i++) { - if (self->trackIDs[i] == trackID) return err; - } - - if (self->trackIDs != NULL) - self->trackIDs = (u32*) realloc( self->trackIDs, (self->trackIDCount+1)*sizeof(u32) ); - else - self->trackIDs = (u32*) calloc( self->trackIDCount+1, sizeof(u32) ); - TESTMALLOC( self->trackIDs ); - self->trackIDs[ self->trackIDCount++ ] = trackID; + MP4Err err; + u32 i; + err = MP4NoErr; + if(trackID == 0) BAILWITHERROR(MP4BadParamErr); + + /* JLF 12 / 00: don't add a dep if already here !! */ + for(i = 0; i < self->trackIDCount; i++) + { + if(self->trackIDs[i] == trackID) return err; + } + + if(self->trackIDs != NULL) + self->trackIDs = (u32 *)realloc(self->trackIDs, (self->trackIDCount + 1) * sizeof(u32)); + else + self->trackIDs = (u32 *)calloc(self->trackIDCount + 1, sizeof(u32)); + TESTMALLOC(self->trackIDs); + self->trackIDs[self->trackIDCount++] = trackID; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -MP4Err MP4CreateTrackReferenceTypeAtom( u32 atomType, MP4TrackReferenceTypeAtomPtr *outAtom ) +MP4Err MP4CreateTrackReferenceTypeAtom(u32 atomType, MP4TrackReferenceTypeAtomPtr *outAtom) { - MP4Err err; - MP4TrackReferenceTypeAtomPtr self; - - self = (MP4TrackReferenceTypeAtomPtr) calloc( 1, sizeof(MP4TrackReferenceTypeAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = atomType; - self->name = "track reference type"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addTrackID = addTrackID; - *outAtom = self; + MP4Err err; + MP4TrackReferenceTypeAtomPtr self; + + self = (MP4TrackReferenceTypeAtomPtr)calloc(1, sizeof(MP4TrackReferenceTypeAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = atomType; + self->name = "track reference type"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addTrackID = addTrackID; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/TrackTypeAtom.c b/IsoLib/libisomediafile/src/TrackTypeAtom.c index 1c7ee15..eb1c84d 100644 --- a/IsoLib/libisomediafile/src/TrackTypeAtom.c +++ b/IsoLib/libisomediafile/src/TrackTypeAtom.c @@ -1,4 +1,4 @@ -/* +/* * This software module was originally developed by InterDigital, Inc. * in the course of development of MPEG-4. * This software module is an implementation of a part of one or @@ -18,240 +18,244 @@ * purpose, assign or donate the code to a third party and to * inhibit third parties from using the code for non * MPEG-4 conforming products. - * + * * This copyright notice must be included in all copies or - * derivative works. + * derivative works. */ - /** * @file TrackTypeAtom.c * @author Ahmed Hamza - * @date + * @date * @brief Implements functions for reading and writing TrackTypeAtom instances. */ - #include "MP4Atoms.h" #include #include - static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4TrackTypeAtomPtr self; - - err = MP4NoErr; - self = (MP4TrackTypeAtomPtr)s; - - if (self == NULL) - BAILWITHERROR(MP4BadParamErr); - - if (self->compatibilityList) - { - free(self->compatibilityList); - self->compatibilityList = NULL; - } - - if (self->super) - self->super->destroy(s); -bail: - TEST_RETURN(err); + MP4Err err; + MP4TrackTypeAtomPtr self; - return; -} + err = MP4NoErr; + self = (MP4TrackTypeAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr); + if(self->compatibilityList) + { + free(self->compatibilityList); + self->compatibilityList = NULL; + } -static ISOErr serialize(struct MP4Atom* s, char* buffer) + if(self->super) self->super->destroy(s); +bail: + TEST_RETURN(err); + + return; +} + +static ISOErr serialize(struct MP4Atom *s, char *buffer) { - ISOErr err; - u32 i; - MP4TrackTypeAtomPtr self = (MP4TrackTypeAtomPtr)s; + ISOErr err; + u32 i; + MP4TrackTypeAtomPtr self = (MP4TrackTypeAtomPtr)s; - err = ISONoErr; + err = ISONoErr; - err = MP4SerializeCommonFullAtomFields((MP4FullAtom*)s, buffer); if (err) goto bail; /* Full Atom */ - buffer += self->bytesWritten; + err = MP4SerializeCommonFullAtomFields((MP4FullAtom *)s, buffer); + if(err) goto bail; /* Full Atom */ + buffer += self->bytesWritten; - PUT32(majorBrand); - PUT32(minorVersion); + PUT32(majorBrand); + PUT32(minorVersion); - for (i = 0; i < self->itemCount; i++) - { - PUT32_V((self->compatibilityList[i])); - } + for(i = 0; i < self->itemCount; i++) + { + PUT32_V((self->compatibilityList[i])); + } - assert(self->bytesWritten == self->size); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static ISOErr calculateSize(struct MP4Atom* s) +static ISOErr calculateSize(struct MP4Atom *s) { - ISOErr err; - MP4TrackTypeAtomPtr self = (MP4TrackTypeAtomPtr)s; - err = ISONoErr; - - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if (err) goto bail; /* Full Atom */ - self->size += 2 * sizeof(u32); /* brand and minorVersion */ - self->size += self->itemCount * sizeof(u32); /* compatibilityList */ + ISOErr err; + MP4TrackTypeAtomPtr self = (MP4TrackTypeAtomPtr)s; + err = ISONoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; /* Full Atom */ + self->size += 2 * sizeof(u32); /* brand and minorVersion */ + self->size += self->itemCount * sizeof(u32); /* compatibilityList */ bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } -static ISOErr getBrand(struct MP4TrackTypeAtom *self, u32* standard, u32* minorversion) +static ISOErr getBrand(struct MP4TrackTypeAtom *self, u32 *standard, u32 *minorversion) { - *standard = self->majorBrand; - *minorversion = self->minorVersion; + *standard = self->majorBrand; + *minorversion = self->minorVersion; - return MP4NoErr; + return MP4NoErr; } static u32 getStandard(struct MP4TrackTypeAtom *self, u32 standard) { - u32 i; - u32 outval; - - outval = 0; - - for (i = 0; iitemCount; i++) { - if (self->compatibilityList[i] == standard) { - outval = standard; - break; - } - } - return outval; + u32 i; + u32 outval; + + outval = 0; + + for(i = 0; i < self->itemCount; i++) + { + if(self->compatibilityList[i] == standard) + { + outval = standard; + break; + } + } + return outval; } /* add a track type to the compatibility list */ static ISOErr addStandard(struct MP4TrackTypeAtom *self, u32 standard) { - ISOErr err; - err = ISONoErr; - - if (!getStandard(self, standard)) { - self->itemCount++; - self->compatibilityList = (u32*)realloc(self->compatibilityList, self->itemCount * sizeof(u32)); - TESTMALLOC(self->compatibilityList); - self->compatibilityList[self->itemCount - 1] = (u32)standard; - } + ISOErr err; + err = ISONoErr; + + if(!getStandard(self, standard)) + { + self->itemCount++; + self->compatibilityList = + (u32 *)realloc(self->compatibilityList, self->itemCount * sizeof(u32)); + TESTMALLOC(self->compatibilityList); + self->compatibilityList[self->itemCount - 1] = (u32)standard; + } bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } static ISOErr setBrand(struct MP4TrackTypeAtom *self, u32 standard, u32 minorversion) { - u32 oldstandard; - MP4Err err; - oldstandard = self->majorBrand; - - self->majorBrand = standard; - self->minorVersion = minorversion; - - /* in the compatibility list are also the new major brand, and the old one, if any */ - if (oldstandard) { err = addStandard(self, oldstandard); if (err) return err; } - err = addStandard(self, standard); if (err) return err; - - return err; + u32 oldstandard; + MP4Err err; + oldstandard = self->majorBrand; + + self->majorBrand = standard; + self->minorVersion = minorversion; + + /* in the compatibility list are also the new major brand, and the old one, if any */ + if(oldstandard) + { + err = addStandard(self, oldstandard); + if(err) return err; + } + err = addStandard(self, standard); + if(err) return err; + + return err; } static ISOErr createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - ISOErr err; - u32 items = 0; - long bytesToRead; - char typeString[8]; - char msgString[80]; - - MP4TrackTypeAtomPtr self = (MP4TrackTypeAtomPtr)s; - - err = ISONoErr; - if (self == NULL) - BAILWITHERROR(ISOBadParamErr); - - err = self->super->createFromInputStream(s, proto, (char*)inputStream); if (err) goto bail; - - GET32(majorBrand); - MP4TypeToString(self->majorBrand, typeString); - sprintf(msgString, " major brand is '%s'", typeString); - inputStream->msg(inputStream, msgString); - - GET32(minorVersion); - - bytesToRead = self->size - self->bytesRead; - if (bytesToRead < ((long) sizeof(u32))) /* there must be at least one item in the compatibility list */ - BAILWITHERROR(ISOBadDataErr); - - if (self->compatibilityList) - free(self->compatibilityList); - - self->compatibilityList = (u32 *)calloc(1, bytesToRead); - TESTMALLOC(self->compatibilityList); - - while (bytesToRead > 0) - { - if (bytesToRead < ((long) sizeof(u32))) /* we need to read a full u32 */ - BAILWITHERROR(ISOBadDataErr); - - GET32(compatibilityList[items]); - MP4TypeToString(self->compatibilityList[items], typeString); - sprintf(msgString, " minor brand is '%s'", typeString); - inputStream->msg(inputStream, msgString); - items++; - bytesToRead = self->size - self->bytesRead; - } - - self->itemCount = items; + ISOErr err; + u32 items = 0; + long bytesToRead; + char typeString[8]; + char msgString[80]; + + MP4TrackTypeAtomPtr self = (MP4TrackTypeAtomPtr)s; + + err = ISONoErr; + if(self == NULL) BAILWITHERROR(ISOBadParamErr); + + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET32(majorBrand); + MP4TypeToString(self->majorBrand, typeString); + sprintf(msgString, " major brand is '%s'", typeString); + inputStream->msg(inputStream, msgString); + + GET32(minorVersion); + + bytesToRead = self->size - self->bytesRead; + if(bytesToRead < + ((long)sizeof(u32))) /* there must be at least one item in the compatibility list */ + BAILWITHERROR(ISOBadDataErr); + + if(self->compatibilityList) free(self->compatibilityList); + + self->compatibilityList = (u32 *)calloc(1, bytesToRead); + TESTMALLOC(self->compatibilityList); + + while(bytesToRead > 0) + { + if(bytesToRead < ((long)sizeof(u32))) /* we need to read a full u32 */ + BAILWITHERROR(ISOBadDataErr); + + GET32(compatibilityList[items]); + MP4TypeToString(self->compatibilityList[items], typeString); + sprintf(msgString, " minor brand is '%s'", typeString); + inputStream->msg(inputStream, msgString); + items++; + bytesToRead = self->size - self->bytesRead; + } + + self->itemCount = items; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } ISOErr MP4CreateTrackTypeAtom(MP4TrackTypeAtomPtr *outAtom) { - ISOErr err; - MP4TrackTypeAtomPtr self; - - self = (MP4TrackTypeAtomPtr)calloc(1, sizeof(MP4TrackTypeAtom)); - TESTMALLOC(self); - - err = MP4CreateFullAtom((MP4AtomPtr)self); /* Full atom */ - if (err) goto bail; - - self->type = MP4TrackTypeAtomType; - self->name = "TrackTypeBox"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addStandard = addStandard; - self->setBrand = setBrand; - self->getBrand = getBrand; - self->getStandard = getStandard; - - self->majorBrand = 0; /* was ISOISOBrand */ - self->minorVersion = (u32)0; - - self->compatibilityList = (u32*)calloc(1, sizeof(u32)); - TESTMALLOC(self->compatibilityList); - - /* self->compatibilityList[0] = ISOISOBrand; */ - /* self->compatibilityList[1] = ISOISOBrand; */ - /* No, MPEG-21 and meta movies are not ISOM branded */ - self->itemCount = (u32)0; - - *outAtom = self; + ISOErr err; + MP4TrackTypeAtomPtr self; + + self = (MP4TrackTypeAtomPtr)calloc(1, sizeof(MP4TrackTypeAtom)); + TESTMALLOC(self); + + err = MP4CreateFullAtom((MP4AtomPtr)self); /* Full atom */ + if(err) goto bail; + + self->type = MP4TrackTypeAtomType; + self->name = "TrackTypeBox"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addStandard = addStandard; + self->setBrand = setBrand; + self->getBrand = getBrand; + self->getStandard = getStandard; + + self->majorBrand = 0; /* was ISOISOBrand */ + self->minorVersion = (u32)0; + + self->compatibilityList = (u32 *)calloc(1, sizeof(u32)); + TESTMALLOC(self->compatibilityList); + + /* self->compatibilityList[0] = ISOISOBrand; */ + /* self->compatibilityList[1] = ISOISOBrand; */ + /* No, MPEG-21 and meta movies are not ISOM branded */ + self->itemCount = (u32)0; + + *outAtom = self; bail: - TEST_RETURN(err); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/UnknownAtom.c b/IsoLib/libisomediafile/src/UnknownAtom.c index 0c84be7..9931106 100644 --- a/IsoLib/libisomediafile/src/UnknownAtom.c +++ b/IsoLib/libisomediafile/src/UnknownAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,113 +15,115 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: UnknownAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: UnknownAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4UnknownAtomPtr self; - self = (MP4UnknownAtomPtr) s; - if ( self->data ) - { - free( self->data ); - self->data = NULL; - } - if ( self->super ) - self->super->destroy( s ); + MP4UnknownAtomPtr self; + self = (MP4UnknownAtomPtr)s; + if(self->data) + { + free(self->data); + self->data = NULL; + } + if(self->super) self->super->destroy(s); } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4UnknownAtomPtr self = (MP4UnknownAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - if (self->type==MP4ExtendedAtomType) { - PUTBYTES( self->uuid, 16 ); - } - PUTBYTES( self->data, self->dataSize ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4UnknownAtomPtr self = (MP4UnknownAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + if(self->type == MP4ExtendedAtomType) + { + PUTBYTES(self->uuid, 16); + } + PUTBYTES(self->data, self->dataSize); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4UnknownAtomPtr self = (MP4UnknownAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - if (self->type==MP4ExtendedAtomType) self->size += 16; - - self->size += self->dataSize; + MP4Err err; + MP4UnknownAtomPtr self = (MP4UnknownAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + if(self->type == MP4ExtendedAtomType) self->size += 16; + + self->size += self->dataSize; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err unknownAtomCreateFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err unknownAtomCreateFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, + MP4InputStreamPtr inputStream) { - MP4Err err; - long bytesToRead; - MP4UnknownAtomPtr self = (MP4UnknownAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); - - bytesToRead = s->size - s->bytesRead; - self->data = (char*) calloc( 1, bytesToRead ); - TESTMALLOC( self->data ) - GETBYTES_MSG( bytesToRead, data, "unknown atom data" ); - self->dataSize = bytesToRead; + MP4Err err; + long bytesToRead; + MP4UnknownAtomPtr self = (MP4UnknownAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + + bytesToRead = s->size - s->bytesRead; + self->data = (char *)calloc(1, bytesToRead); + TESTMALLOC(self->data) + GETBYTES_MSG(bytesToRead, data, "unknown atom data"); + self->dataSize = bytesToRead; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - if ( err && self->data ) - { - free( self->data ); - } - return err; + if(err && self->data) + { + free(self->data); + } + return err; } -MP4Err MP4CreateUnknownAtom( MP4UnknownAtomPtr *outAtom ) +MP4Err MP4CreateUnknownAtom(MP4UnknownAtomPtr *outAtom) { - MP4Err err; - MP4UnknownAtomPtr self; - - self = (MP4UnknownAtomPtr) calloc( 1, sizeof(MP4UnknownAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - - self->name = "unknown atom"; - self->destroy = destroy; - self->createFromInputStream = (cisfunc) unknownAtomCreateFromInputStream; - self->data = NULL; - self->calculateSize = calculateSize; - self->serialize = serialize; - *outAtom = self; + MP4Err err; + MP4UnknownAtomPtr self; + + self = (MP4UnknownAtomPtr)calloc(1, sizeof(MP4UnknownAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + + self->name = "unknown atom"; + self->destroy = destroy; + self->createFromInputStream = (cisfunc)unknownAtomCreateFromInputStream; + self->data = NULL; + self->calculateSize = calculateSize; + self->serialize = serialize; + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/UserDataAtom.c b/IsoLib/libisomediafile/src/UserDataAtom.c index c430b96..018fbc0 100644 --- a/IsoLib/libisomediafile/src/UserDataAtom.c +++ b/IsoLib/libisomediafile/src/UserDataAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,352 +15,395 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: UserDataAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: UserDataAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include #include - typedef struct UserDataMapRecord { - u32 atomType; - MP4LinkedList atomList; + u32 atomType; + MP4LinkedList atomList; } UserDataMapRecord, *UserDataMapRecordPtr; -static MP4Err getEntryCount( struct MP4UserDataAtom *self, u32 userDataType, u32 *outCount ); -static MP4Err getIndType( struct MP4UserDataAtom *self, u32 typeIndex, u32 *outType ); -static MP4Err getItem( struct MP4UserDataAtom *self, MP4Handle userDataH, u32 userDataType, u32 itemIndex ); -static MP4Err getTypeCount( struct MP4UserDataAtom *self, u32 *outCount ); +static MP4Err getEntryCount(struct MP4UserDataAtom *self, u32 userDataType, u32 *outCount); +static MP4Err getIndType(struct MP4UserDataAtom *self, u32 typeIndex, u32 *outType); +static MP4Err getItem(struct MP4UserDataAtom *self, MP4Handle userDataH, u32 userDataType, + u32 itemIndex); +static MP4Err getTypeCount(struct MP4UserDataAtom *self, u32 *outCount); -static MP4Err findEntryForAtomType( MP4UserDataAtomPtr self, u32 atomType, UserDataMapRecordPtr *outRecord ); +static MP4Err findEntryForAtomType(MP4UserDataAtomPtr self, u32 atomType, + UserDataMapRecordPtr *outRecord); -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4UserDataAtomPtr self; - u32 i; - u32 recordCount; - u32 recordIndex; - err = MP4NoErr; - self = (MP4UserDataAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = MP4GetListEntryCount( self->recordList, &recordCount ); if (err) goto bail; - for ( recordIndex = 0; recordIndex < recordCount; recordIndex++ ) - { - UserDataMapRecordPtr p; - err = MP4GetListEntry( self->recordList, recordIndex, (char **) &p ); if (err) goto bail; - DESTROY_ATOM_LIST_V( p->atomList ); - free( p ); - } - err = MP4DeleteLinkedList( self->recordList ); if (err) goto bail; - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4UserDataAtomPtr self; + u32 i; + u32 recordCount; + u32 recordIndex; + err = MP4NoErr; + self = (MP4UserDataAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = MP4GetListEntryCount(self->recordList, &recordCount); + if(err) goto bail; + for(recordIndex = 0; recordIndex < recordCount; recordIndex++) + { + UserDataMapRecordPtr p; + err = MP4GetListEntry(self->recordList, recordIndex, (char **)&p); + if(err) goto bail; + DESTROY_ATOM_LIST_V(p->atomList); + free(p); + } + err = MP4DeleteLinkedList(self->recordList); + if(err) goto bail; + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err addUserData(struct MP4UserDataAtom *self, MP4Handle userDataH, u32 userDataType, u32 *outIndex ) +static MP4Err addUserData(struct MP4UserDataAtom *self, MP4Handle userDataH, u32 userDataType, + u32 *outIndex) { - MP4Err MP4CreateUnknownAtom( MP4UnknownAtomPtr *outAtom ); - - MP4Err err; - UserDataMapRecordPtr rec; - MP4UnknownAtomPtr atom; - - err = MP4CreateUnknownAtom( &atom ); if (err) goto bail; - atom->type = userDataType; - err = MP4GetHandleSize( userDataH, &atom->dataSize ); if (err) goto bail; - if ( atom->dataSize > 0 ) - { - atom->data = (char*) malloc( atom->dataSize ); - TESTMALLOC( atom->data ) - memcpy( atom->data, *userDataH, atom->dataSize ); - } - err = findEntryForAtomType( self, userDataType, &rec ); if (err) goto bail; - if ( rec == NULL ) - { - rec = (UserDataMapRecordPtr) calloc( 1, sizeof(struct UserDataMapRecord) ); - TESTMALLOC( rec ) - rec->atomType = atom->type; - err = MP4MakeLinkedList( &rec->atomList ); if (err) goto bail; - err = MP4AddListEntry( rec, self->recordList ); if (err) goto bail; - } - err = MP4AddListEntry( atom, rec->atomList ); if (err) goto bail; - if ( outIndex != NULL ) - { - err = MP4GetListEntryCount( rec->atomList, outIndex ); if (err) goto bail; - } + MP4Err MP4CreateUnknownAtom(MP4UnknownAtomPtr * outAtom); + + MP4Err err; + UserDataMapRecordPtr rec; + MP4UnknownAtomPtr atom; + + err = MP4CreateUnknownAtom(&atom); + if(err) goto bail; + atom->type = userDataType; + err = MP4GetHandleSize(userDataH, &atom->dataSize); + if(err) goto bail; + if(atom->dataSize > 0) + { + atom->data = (char *)malloc(atom->dataSize); + TESTMALLOC(atom->data) + memcpy(atom->data, *userDataH, atom->dataSize); + } + err = findEntryForAtomType(self, userDataType, &rec); + if(err) goto bail; + if(rec == NULL) + { + rec = (UserDataMapRecordPtr)calloc(1, sizeof(struct UserDataMapRecord)); + TESTMALLOC(rec) + rec->atomType = atom->type; + err = MP4MakeLinkedList(&rec->atomList); + if(err) goto bail; + err = MP4AddListEntry(rec, self->recordList); + if(err) goto bail; + } + err = MP4AddListEntry(atom, rec->atomList); + if(err) goto bail; + if(outIndex != NULL) + { + err = MP4GetListEntryCount(rec->atomList, outIndex); + if(err) goto bail; + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err findEntryForAtomType( MP4UserDataAtomPtr self, u32 atomType, UserDataMapRecordPtr *outRecord ) +static MP4Err findEntryForAtomType(MP4UserDataAtomPtr self, u32 atomType, + UserDataMapRecordPtr *outRecord) { - MP4Err err; - u32 i; - u32 count; - *outRecord = 0; - err = MP4GetListEntryCount( self->recordList, &count ); if (err) goto bail; - for ( i = 0; i < count; i++ ) - { - UserDataMapRecordPtr p; - err = MP4GetListEntry( self->recordList, i, (char **) &p ); if (err) goto bail; - if ( (p != 0) && (p->atomType == atomType) ) - { - *outRecord = p; - break; - } - } + MP4Err err; + u32 i; + u32 count; + *outRecord = 0; + err = MP4GetListEntryCount(self->recordList, &count); + if(err) goto bail; + for(i = 0; i < count; i++) + { + UserDataMapRecordPtr p; + err = MP4GetListEntry(self->recordList, i, (char **)&p); + if(err) goto bail; + if((p != 0) && (p->atomType == atomType)) + { + *outRecord = p; + break; + } + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getTypeCount( struct MP4UserDataAtom *self, u32 *outCount ) +static MP4Err getTypeCount(struct MP4UserDataAtom *self, u32 *outCount) { - MP4Err err; + MP4Err err; - err = MP4GetListEntryCount( self->recordList, outCount ); if (err) goto bail; + err = MP4GetListEntryCount(self->recordList, outCount); + if(err) goto bail; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getEntryCount( struct MP4UserDataAtom *self, u32 userDataType, u32 *outCount ) +static MP4Err getEntryCount(struct MP4UserDataAtom *self, u32 userDataType, u32 *outCount) { - MP4Err err; - u32 i; - u32 count; - *outCount = 0; - err = MP4GetListEntryCount( self->recordList, &count ); if (err) goto bail; - for ( i = 0; i < count; i++ ) - { - UserDataMapRecordPtr p; - err = MP4GetListEntry( self->recordList, i, (char **) &p ); if (err) goto bail; - if ( (p != 0) && (p->atomType == userDataType) && (p->atomList != 0) ) - { - err = MP4GetListEntryCount( p->atomList, outCount ); if (err) goto bail; - break; - } - } + MP4Err err; + u32 i; + u32 count; + *outCount = 0; + err = MP4GetListEntryCount(self->recordList, &count); + if(err) goto bail; + for(i = 0; i < count; i++) + { + UserDataMapRecordPtr p; + err = MP4GetListEntry(self->recordList, i, (char **)&p); + if(err) goto bail; + if((p != 0) && (p->atomType == userDataType) && (p->atomList != 0)) + { + err = MP4GetListEntryCount(p->atomList, outCount); + if(err) goto bail; + break; + } + } bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getIndType( struct MP4UserDataAtom *self, u32 typeIndex, u32 *outType ) +static MP4Err getIndType(struct MP4UserDataAtom *self, u32 typeIndex, u32 *outType) { - MP4Err err; - u32 count; - UserDataMapRecordPtr p; - *outType = 0; - err = MP4GetListEntryCount( self->recordList, &count ); if (err) goto bail; - if ( typeIndex > count ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = MP4GetListEntry( self->recordList, typeIndex - 1, (char **) &p ); if (err) goto bail; - *outType = p->atomType; + MP4Err err; + u32 count; + UserDataMapRecordPtr p; + *outType = 0; + err = MP4GetListEntryCount(self->recordList, &count); + if(err) goto bail; + if(typeIndex > count) + { + BAILWITHERROR(MP4BadParamErr); + } + err = MP4GetListEntry(self->recordList, typeIndex - 1, (char **)&p); + if(err) goto bail; + *outType = p->atomType; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getItem( struct MP4UserDataAtom *self, MP4Handle userDataH, u32 userDataType, u32 itemIndex ) +static MP4Err getItem(struct MP4UserDataAtom *self, MP4Handle userDataH, u32 userDataType, + u32 itemIndex) { - MP4Err err; - UserDataMapRecordPtr rec; - MP4UnknownAtomPtr atom; - - err = findEntryForAtomType( self, userDataType, &rec ); if (err) goto bail; - if ( rec == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = MP4GetListEntry( rec->atomList, itemIndex - 1, (char **) &atom ); if (err) goto bail; - err = atom->calculateSize( (MP4AtomPtr) atom ); if (err) goto bail; - err = MP4SetHandleSize( userDataH, atom->dataSize ); if (err) goto bail; - memcpy( *userDataH, atom->data, atom->dataSize ); + MP4Err err; + UserDataMapRecordPtr rec; + MP4UnknownAtomPtr atom; + + err = findEntryForAtomType(self, userDataType, &rec); + if(err) goto bail; + if(rec == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + err = MP4GetListEntry(rec->atomList, itemIndex - 1, (char **)&atom); + if(err) goto bail; + err = atom->calculateSize((MP4AtomPtr)atom); + if(err) goto bail; + err = MP4SetHandleSize(userDataH, atom->dataSize); + if(err) goto bail; + memcpy(*userDataH, atom->data, atom->dataSize); bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err getAtom( struct MP4UserDataAtom *self, MP4AtomPtr *outatom, u32 userDataType, u32 itemIndex ) +static MP4Err getAtom(struct MP4UserDataAtom *self, MP4AtomPtr *outatom, u32 userDataType, + u32 itemIndex) { - MP4Err err; - UserDataMapRecordPtr rec; - MP4UnknownAtomPtr atom; - - err = findEntryForAtomType( self, userDataType, &rec ); if (err) goto bail; - if ( rec == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = MP4GetListEntry( rec->atomList, itemIndex - 1, (char **) &atom ); if (err) goto bail; - - *outatom = (MP4AtomPtr) atom; + MP4Err err; + UserDataMapRecordPtr rec; + MP4UnknownAtomPtr atom; + + err = findEntryForAtomType(self, userDataType, &rec); + if(err) goto bail; + if(rec == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + err = MP4GetListEntry(rec->atomList, itemIndex - 1, (char **)&atom); + if(err) goto bail; + + *outatom = (MP4AtomPtr)atom; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err deleteItem( struct MP4UserDataAtom *self, u32 userDataType, u32 itemIndex ) +static MP4Err deleteItem(struct MP4UserDataAtom *self, u32 userDataType, u32 itemIndex) { - MP4Err err; - UserDataMapRecordPtr rec; - - err = findEntryForAtomType( self, userDataType, &rec ); if (err) goto bail; - if ( rec == 0 ) - { - BAILWITHERROR( MP4BadParamErr ); - } - err = MP4DeleteListEntry( rec->atomList, itemIndex - 1); if (err) goto bail; + MP4Err err; + UserDataMapRecordPtr rec; + + err = findEntryForAtomType(self, userDataType, &rec); + if(err) goto bail; + if(rec == 0) + { + BAILWITHERROR(MP4BadParamErr); + } + err = MP4DeleteListEntry(rec->atomList, itemIndex - 1); + if(err) goto bail; bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } -static MP4Err addAtom( MP4UserDataAtomPtr self, MP4AtomPtr atom ) +static MP4Err addAtom(MP4UserDataAtomPtr self, MP4AtomPtr atom) { - MP4Err err; - UserDataMapRecordPtr rec; - err = findEntryForAtomType( self, atom->type, &rec ); if (err) goto bail; - if ( rec == 0 ) - { - rec = (UserDataMapRecordPtr) calloc( 1, sizeof(struct UserDataMapRecord) ); - TESTMALLOC( rec ) - rec->atomType = atom->type; - err = MP4MakeLinkedList( &rec->atomList ); if (err) goto bail; - err = MP4AddListEntry( rec, self->recordList ); if (err) goto bail; - } - err = MP4AddListEntry( atom, rec->atomList ); + MP4Err err; + UserDataMapRecordPtr rec; + err = findEntryForAtomType(self, atom->type, &rec); + if(err) goto bail; + if(rec == 0) + { + rec = (UserDataMapRecordPtr)calloc(1, sizeof(struct UserDataMapRecord)); + TESTMALLOC(rec) + rec->atomType = atom->type; + err = MP4MakeLinkedList(&rec->atomList); + if(err) goto bail; + err = MP4AddListEntry(rec, self->recordList); + if(err) goto bail; + } + err = MP4AddListEntry(atom, rec->atomList); bail: - TEST_RETURN( err ); - return err; + TEST_RETURN(err); + return err; } - -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 recordCount; - u32 recordIndex; - MP4UserDataAtomPtr self = (MP4UserDataAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - err = MP4GetListEntryCount( self->recordList, &recordCount ); if (err) goto bail; - for ( recordIndex = 0; recordIndex < recordCount; recordIndex++ ) - { - UserDataMapRecordPtr p; - err = MP4GetListEntry( self->recordList, recordIndex, (char **) &p ); if (err) goto bail; - SERIALIZE_ATOM_LIST_V( p->atomList ); - } - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 recordCount; + u32 recordIndex; + MP4UserDataAtomPtr self = (MP4UserDataAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + err = MP4GetListEntryCount(self->recordList, &recordCount); + if(err) goto bail; + for(recordIndex = 0; recordIndex < recordCount; recordIndex++) + { + UserDataMapRecordPtr p; + err = MP4GetListEntry(self->recordList, recordIndex, (char **)&p); + if(err) goto bail; + SERIALIZE_ATOM_LIST_V(p->atomList); + } + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - u32 recordCount; - u32 recordIndex; - MP4UserDataAtomPtr self = (MP4UserDataAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - err = MP4GetListEntryCount( self->recordList, &recordCount ); if (err) goto bail; - for ( recordIndex = 0; recordIndex < recordCount; recordIndex++ ) - { - UserDataMapRecordPtr p; - err = MP4GetListEntry( self->recordList, recordIndex, (char **) &p ); if (err) goto bail; - ADD_ATOM_LIST_SIZE_V( p->atomList ); - } + MP4Err err; + u32 recordCount; + u32 recordIndex; + MP4UserDataAtomPtr self = (MP4UserDataAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + err = MP4GetListEntryCount(self->recordList, &recordCount); + if(err) goto bail; + for(recordIndex = 0; recordIndex < recordCount; recordIndex++) + { + UserDataMapRecordPtr p; + err = MP4GetListEntry(self->recordList, recordIndex, (char **)&p); + if(err) goto bail; + ADD_ATOM_LIST_SIZE_V(p->atomList); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - /* PARSE_ATOM_LIST(MP4UserDataAtom) */ - - MP4Err err; - u32 junk; - - MP4UserDataAtomPtr self = (MP4UserDataAtomPtr) s; - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - while ( self->bytesRead < (self->size-4) ) - { - MP4AtomPtr atom; - err = MP4ParseAtom( (MP4InputStreamPtr) inputStream, &atom ); - if (err) goto bail; - self->bytesRead += atom->size; - if ( ((atom->type)== MP4FreeSpaceAtomType) || ((atom->type)== MP4SkipAtomType)) - atom->destroy( atom ); - else { - err = addAtom( self, atom ); - if (err) goto bail; - } - } - if ((self->size - self->bytesRead) == 4) { GET32_V( junk ); } - - if ( self->bytesRead != self->size ) - BAILWITHERROR( MP4BadDataErr ) + /* PARSE_ATOM_LIST(MP4UserDataAtom) */ + + MP4Err err; + u32 junk; + + MP4UserDataAtomPtr self = (MP4UserDataAtomPtr)s; + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + while(self->bytesRead < (self->size - 4)) + { + MP4AtomPtr atom; + err = MP4ParseAtom((MP4InputStreamPtr)inputStream, &atom); + if(err) goto bail; + self->bytesRead += atom->size; + if(((atom->type) == MP4FreeSpaceAtomType) || ((atom->type) == MP4SkipAtomType)) + atom->destroy(atom); + else + { + err = addAtom(self, atom); + if(err) goto bail; + } + } + if((self->size - self->bytesRead) == 4) + { + GET32_V(junk); + } + + if(self->bytesRead != self->size) BAILWITHERROR(MP4BadDataErr) bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateUserDataAtom( MP4UserDataAtomPtr *outAtom ) +MP4Err MP4CreateUserDataAtom(MP4UserDataAtomPtr *outAtom) { - MP4Err err; - MP4UserDataAtomPtr self; - - self = (MP4UserDataAtomPtr) calloc( 1, sizeof(MP4UserDataAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4UserDataAtomType; - self->name = "user data"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - err = MP4MakeLinkedList( &self->recordList ); if (err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addUserData = addUserData; - self->getEntryCount = getEntryCount; - self->getIndType = getIndType; - self->getItem = getItem; - self->deleteItem = deleteItem; - self->getTypeCount = getTypeCount; - self->getAtom = getAtom; - - *outAtom = self; + MP4Err err; + MP4UserDataAtomPtr self; + + self = (MP4UserDataAtomPtr)calloc(1, sizeof(MP4UserDataAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4UserDataAtomType; + self->name = "user data"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + err = MP4MakeLinkedList(&self->recordList); + if(err) goto bail; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addUserData = addUserData; + self->getEntryCount = getEntryCount; + self->getIndType = getIndType; + self->getItem = getItem; + self->deleteItem = deleteItem; + self->getTypeCount = getTypeCount; + self->getAtom = getAtom; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/VCConfigAtom.c b/IsoLib/libisomediafile/src/VCConfigAtom.c index b06f070..34d3430 100644 --- a/IsoLib/libisomediafile/src/VCConfigAtom.c +++ b/IsoLib/libisomediafile/src/VCConfigAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: VCConfigAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: VCConfigAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -29,336 +29,411 @@ derivative works. Copyright (c) 1999. #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - ISOVCConfigAtomPtr self; - err = MP4NoErr; - self = (ISOVCConfigAtomPtr) s; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( self->spsList ) - { - err = MP4DeleteLinkedList( self->spsList ); if (err) goto bail; - self->spsList = NULL; - } - if ( self->ppsList ) - { - err = MP4DeleteLinkedList( self->ppsList ); if (err) goto bail; - self->ppsList = NULL; - } - if ( self->spsextList ) - { - err = MP4DeleteLinkedList( self->spsextList ); if (err) goto bail; - self->spsextList = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + ISOVCConfigAtomPtr self; + err = MP4NoErr; + self = (ISOVCConfigAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self->spsList) + { + err = MP4DeleteLinkedList(self->spsList); + if(err) goto bail; + self->spsList = NULL; + } + if(self->ppsList) + { + err = MP4DeleteLinkedList(self->ppsList); + if(err) goto bail; + self->ppsList = NULL; + } + if(self->spsextList) + { + err = MP4DeleteLinkedList(self->spsextList); + if(err) goto bail; + self->spsextList = NULL; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - u32 x, i; - ISOVCConfigAtomPtr self = (ISOVCConfigAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( (MP4AtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - x = 1; - PUT8_V( x ); - /* config_version */ - PUT8( profile ); - PUT8( profile_compatibility); - PUT8( level ); - x = (self->complete_rep ? 0x80 : 0) | 0x7C | ((self->length_size - 1) & 3); - PUT8_V( x ); - - if (self->spsList) { - u32 count; - err = MP4GetListEntryCount( self->spsList, &count ); if (err) goto bail; - if (count>>5) BAILWITHERROR( MP4BadParamErr ); - x = 0xE0 | (count & 0x1F); - PUT8_V( x ); - - for (i=0; ispsList, i, (char **) &b ); if (err) goto bail; - err = MP4GetHandleSize( b, &the_size ); if (err) goto bail; - PUT16_V( the_size ); - PUTBYTES( *b, the_size ); - } - } else { x = 0xE0; PUT8_V( x ); } - - if (self->ppsList) { - u32 count; - err = MP4GetListEntryCount( self->ppsList, &count ); if (err) goto bail; - PUT8_V( count ); - - for (i=0; ippsList, i, (char **) &b ); if (err) goto bail; - err = MP4GetHandleSize( b, &the_size ); if (err) goto bail; - PUT16_V( the_size ); - PUTBYTES( *b, the_size ); - } - } else { x = 0; PUT8_V( x ); } - - if( self->profile == 100 || self->profile == 110 || - self->profile == 122 || self->profile == 144 ) - { - x = 0xFC | ((self->chroma_format) & 3); PUT8_V( x ); - x = 0xF8 | ((self->bit_depth_luma_minus8) & 7); PUT8_V( x ); - x = 0xF8 | ((self->bit_depth_chroma_minus8) & 7); PUT8_V( x ); - - if (self->spsextList) { - u32 count; - err = MP4GetListEntryCount( self->spsextList, &count ); if (err) goto bail; - PUT8_V( count ); - - for (i=0; ispsextList, i, (char **) &b ); if (err) goto bail; - err = MP4GetHandleSize( b, &the_size ); if (err) goto bail; - PUT16_V( the_size ); - PUTBYTES( *b, the_size ); - } - } else { x = 0; PUT8_V( x ); } - } - - assert( self->bytesWritten == self->size ); + MP4Err err; + u32 x, i; + ISOVCConfigAtomPtr self = (ISOVCConfigAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields((MP4AtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + x = 1; + PUT8_V(x); + /* config_version */ + PUT8(profile); + PUT8(profile_compatibility); + PUT8(level); + x = (self->complete_rep ? 0x80 : 0) | 0x7C | ((self->length_size - 1) & 3); + PUT8_V(x); + + if(self->spsList) + { + u32 count; + err = MP4GetListEntryCount(self->spsList, &count); + if(err) goto bail; + if(count >> 5) BAILWITHERROR(MP4BadParamErr); + x = 0xE0 | (count & 0x1F); + PUT8_V(x); + + for(i = 0; i < count; i++) + { + MP4Handle b; + u32 the_size; + err = MP4GetListEntry(self->spsList, i, (char **)&b); + if(err) goto bail; + err = MP4GetHandleSize(b, &the_size); + if(err) goto bail; + PUT16_V(the_size); + PUTBYTES(*b, the_size); + } + } + else + { + x = 0xE0; + PUT8_V(x); + } + + if(self->ppsList) + { + u32 count; + err = MP4GetListEntryCount(self->ppsList, &count); + if(err) goto bail; + PUT8_V(count); + + for(i = 0; i < count; i++) + { + MP4Handle b; + u32 the_size; + err = MP4GetListEntry(self->ppsList, i, (char **)&b); + if(err) goto bail; + err = MP4GetHandleSize(b, &the_size); + if(err) goto bail; + PUT16_V(the_size); + PUTBYTES(*b, the_size); + } + } + else + { + x = 0; + PUT8_V(x); + } + + if(self->profile == 100 || self->profile == 110 || self->profile == 122 || self->profile == 144) + { + x = 0xFC | ((self->chroma_format) & 3); + PUT8_V(x); + x = 0xF8 | ((self->bit_depth_luma_minus8) & 7); + PUT8_V(x); + x = 0xF8 | ((self->bit_depth_chroma_minus8) & 7); + PUT8_V(x); + + if(self->spsextList) + { + u32 count; + err = MP4GetListEntryCount(self->spsextList, &count); + if(err) goto bail; + PUT8_V(count); + + for(i = 0; i < count; i++) + { + MP4Handle b; + u32 the_size; + err = MP4GetListEntry(self->spsextList, i, (char **)&b); + if(err) goto bail; + err = MP4GetHandleSize(b, &the_size); + if(err) goto bail; + PUT16_V(the_size); + PUTBYTES(*b, the_size); + } + } + else + { + x = 0; + PUT8_V(x); + } + } + + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - ISOVCConfigAtomPtr self = (ISOVCConfigAtomPtr) s; - u32 i; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( (MP4AtomPtr) s ); if (err) goto bail; - self->size += 7; - - if (self->spsList) { - u32 count; - err = MP4GetListEntryCount( self->spsList, &count ); if (err) goto bail; - if (count>>5) BAILWITHERROR( MP4BadParamErr ); - - for (i=0; ispsList, i, (char **) &b ); if (err) goto bail; - err = MP4GetHandleSize( b, &the_size ); if (err) goto bail; - self->size += 2 + the_size; - } - } - if (self->ppsList) { - u32 count; - err = MP4GetListEntryCount( self->ppsList, &count ); if (err) goto bail; - if (count>>5) BAILWITHERROR( MP4BadParamErr ); - - for (i=0; ippsList, i, (char **) &b ); if (err) goto bail; - err = MP4GetHandleSize( b, &the_size ); if (err) goto bail; - self->size += 2 + the_size; - } - } - - if( self->profile == 100 || self->profile == 110 || - self->profile == 122 || self->profile == 144 ) - { - self->size += 4; - - if (self->spsextList) { - u32 count; - err = MP4GetListEntryCount( self->spsextList, &count ); if (err) goto bail; - - for (i=0; ispsextList, i, (char **) &b ); if (err) goto bail; - err = MP4GetHandleSize( b, &the_size ); if (err) goto bail; - self->size += 2 + the_size; - } - } - } + MP4Err err; + ISOVCConfigAtomPtr self = (ISOVCConfigAtomPtr)s; + u32 i; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)s); + if(err) goto bail; + self->size += 7; + + if(self->spsList) + { + u32 count; + err = MP4GetListEntryCount(self->spsList, &count); + if(err) goto bail; + if(count >> 5) BAILWITHERROR(MP4BadParamErr); + + for(i = 0; i < count; i++) + { + MP4Handle b; + u32 the_size; + err = MP4GetListEntry(self->spsList, i, (char **)&b); + if(err) goto bail; + err = MP4GetHandleSize(b, &the_size); + if(err) goto bail; + self->size += 2 + the_size; + } + } + if(self->ppsList) + { + u32 count; + err = MP4GetListEntryCount(self->ppsList, &count); + if(err) goto bail; + if(count >> 5) BAILWITHERROR(MP4BadParamErr); + + for(i = 0; i < count; i++) + { + MP4Handle b; + u32 the_size; + err = MP4GetListEntry(self->ppsList, i, (char **)&b); + if(err) goto bail; + err = MP4GetHandleSize(b, &the_size); + if(err) goto bail; + self->size += 2 + the_size; + } + } + + if(self->profile == 100 || self->profile == 110 || self->profile == 122 || self->profile == 144) + { + self->size += 4; + + if(self->spsextList) + { + u32 count; + err = MP4GetListEntryCount(self->spsextList, &count); + if(err) goto bail; + + for(i = 0; i < count; i++) + { + MP4Handle b; + u32 the_size; + err = MP4GetListEntry(self->spsextList, i, (char **)&b); + if(err) goto bail; + err = MP4GetHandleSize(b, &the_size); + if(err) goto bail; + self->size += 2 + the_size; + } + } + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - ISOVCConfigAtomPtr self = (ISOVCConfigAtomPtr) s; - u32 x, count, i; - - err = MP4NoErr; - if ( self == NULL ) - BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GET8_V( x ); /* config_version */ - if (x!=1) BAILWITHERROR( MP4BadDataErr ); - - GET8( profile ); - GET8( profile_compatibility); - GET8( level ); - GET8_V( x ); - self->complete_rep = (x & 0x80 ? 1 : 0); - self->length_size = (x & 3) + 1; - - GET8_V( count ); count = count & 0x1F; - for (i=0; ispsList ); if (err) goto bail; - } - GET8_V( count ); - for (i=0; ippsList ); if (err) goto bail; - } - - if( self->profile == 100 || self->profile == 110 || - self->profile == 122 || self->profile == 144 ) - { - GET8_V( x ); self->chroma_format = x & 3; - GET8_V( x ); self->bit_depth_luma_minus8 = x & 7; - GET8_V( x ); self->bit_depth_chroma_minus8 = x & 7; - - GET8_V( count ); - for (i=0; ispsextList ); if (err) goto bail; - } - - } - + MP4Err err; + ISOVCConfigAtomPtr self = (ISOVCConfigAtomPtr)s; + u32 x, count, i; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GET8_V(x); /* config_version */ + if(x != 1) BAILWITHERROR(MP4BadDataErr); + + GET8(profile); + GET8(profile_compatibility); + GET8(level); + GET8_V(x); + self->complete_rep = (x & 0x80 ? 1 : 0); + self->length_size = (x & 3) + 1; + + GET8_V(count); + count = count & 0x1F; + for(i = 0; i < count; i++) + { + MP4Handle b; + u32 the_size; + GET16_V(the_size); + err = MP4NewHandle(the_size, &b); + if(err) goto bail; + + GETBYTES_V_MSG(the_size, *b, "sps"); + err = MP4AddListEntry((void *)b, self->spsList); + if(err) goto bail; + } + GET8_V(count); + for(i = 0; i < count; i++) + { + MP4Handle b; + u32 the_size; + GET16_V(the_size); + err = MP4NewHandle(the_size, &b); + if(err) goto bail; + + GETBYTES_V_MSG(the_size, *b, "pps"); + err = MP4AddListEntry((void *)b, self->ppsList); + if(err) goto bail; + } + + if(self->profile == 100 || self->profile == 110 || self->profile == 122 || self->profile == 144) + { + GET8_V(x); + self->chroma_format = x & 3; + GET8_V(x); + self->bit_depth_luma_minus8 = x & 7; + GET8_V(x); + self->bit_depth_chroma_minus8 = x & 7; + + GET8_V(count); + for(i = 0; i < count; i++) + { + MP4Handle b; + u32 the_size; + GET16_V(the_size); + err = MP4NewHandle(the_size, &b); + if(err) goto bail; + + GETBYTES_V_MSG(the_size, *b, "spsext"); + err = MP4AddListEntry((void *)b, self->spsextList); + if(err) goto bail; + } + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err addParameterSet( struct ISOVCConfigAtom *self, MP4Handle ps, u32 where ) +static MP4Err addParameterSet(struct ISOVCConfigAtom *self, MP4Handle ps, u32 where) { - MP4Err err; - MP4Handle b; - u32 the_size; - - err = MP4NoErr; - err = MP4GetHandleSize( ps, &the_size ); if (err) goto bail; - err = MP4NewHandle( the_size, &b ); if (err) goto bail; - memcpy( *b, *ps, the_size ); - - switch (where & 3) { - case AVCsps: - err = MP4AddListEntry( (void*) b, self->spsList ); if (err) goto bail; - break; - case AVCpps: - err = MP4AddListEntry( (void*) b, self->ppsList ); if (err) goto bail; - break; - case AVCspsext: - err = MP4AddListEntry( (void*) b, self->spsextList ); if (err) goto bail; - break; - default: - BAILWITHERROR( MP4BadParamErr ); - } - + MP4Err err; + MP4Handle b; + u32 the_size; + + err = MP4NoErr; + err = MP4GetHandleSize(ps, &the_size); + if(err) goto bail; + err = MP4NewHandle(the_size, &b); + if(err) goto bail; + memcpy(*b, *ps, the_size); + + switch(where & 3) + { + case AVCsps: + err = MP4AddListEntry((void *)b, self->spsList); + if(err) goto bail; + break; + case AVCpps: + err = MP4AddListEntry((void *)b, self->ppsList); + if(err) goto bail; + break; + case AVCspsext: + err = MP4AddListEntry((void *)b, self->spsextList); + if(err) goto bail; + break; + default: + BAILWITHERROR(MP4BadParamErr); + } + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err getParameterSet( struct ISOVCConfigAtom *self, MP4Handle ps, u32 where, u32 index ) +static MP4Err getParameterSet(struct ISOVCConfigAtom *self, MP4Handle ps, u32 where, u32 index) { - MP4Err err; - MP4Handle b; - u32 the_size; - - err = MP4NoErr; - - switch (where & 3) { - case AVCsps: - err = MP4GetListEntry( self->spsList, index-1, (char**) &b ); if (err) goto bail; - break; - case AVCpps: - err = MP4GetListEntry( self->ppsList, index-1, (char**) &b ); if (err) goto bail; - break; - case AVCspsext: - err = MP4GetListEntry( self->spsextList, index-1, (char**) &b ); if (err) goto bail; - break; - default: - BAILWITHERROR( MP4BadParamErr ); - } - err = MP4GetHandleSize( b, &the_size ); if (err) goto bail; - err = MP4SetHandleSize( ps, the_size ); if (err) goto bail; - memcpy( *ps, *b, the_size ); - + MP4Err err; + MP4Handle b; + u32 the_size; + + err = MP4NoErr; + + switch(where & 3) + { + case AVCsps: + err = MP4GetListEntry(self->spsList, index - 1, (char **)&b); + if(err) goto bail; + break; + case AVCpps: + err = MP4GetListEntry(self->ppsList, index - 1, (char **)&b); + if(err) goto bail; + break; + case AVCspsext: + err = MP4GetListEntry(self->spsextList, index - 1, (char **)&b); + if(err) goto bail; + break; + default: + BAILWITHERROR(MP4BadParamErr); + } + err = MP4GetHandleSize(b, &the_size); + if(err) goto bail; + err = MP4SetHandleSize(ps, the_size); + if(err) goto bail; + memcpy(*ps, *b, the_size); + bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateVCConfigAtom( ISOVCConfigAtomPtr *outAtom ) +MP4Err MP4CreateVCConfigAtom(ISOVCConfigAtomPtr *outAtom) { - MP4Err err; - ISOVCConfigAtomPtr self; - - self = (ISOVCConfigAtomPtr) calloc( 1, sizeof(ISOVCConfigAtom) ); - TESTMALLOC( self ); - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = ISOVCConfigAtomType; - self->name = "VCConfig"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->complete_rep = 1; - self->addParameterSet = addParameterSet; - self->getParameterSet = getParameterSet; - err = MP4MakeLinkedList( &self->spsList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->ppsList ); if (err) goto bail; - err = MP4MakeLinkedList( &self->spsextList ); if (err) goto bail; - - *outAtom = self; + MP4Err err; + ISOVCConfigAtomPtr self; + + self = (ISOVCConfigAtomPtr)calloc(1, sizeof(ISOVCConfigAtom)); + TESTMALLOC(self); + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = ISOVCConfigAtomType; + self->name = "VCConfig"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->complete_rep = 1; + self->addParameterSet = addParameterSet; + self->getParameterSet = getParameterSet; + err = MP4MakeLinkedList(&self->spsList); + if(err) goto bail; + err = MP4MakeLinkedList(&self->ppsList); + if(err) goto bail; + err = MP4MakeLinkedList(&self->spsextList); + if(err) goto bail; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/VideoMediaHeaderAtom.c b/IsoLib/libisomediafile/src/VideoMediaHeaderAtom.c index 312ee2c..707ef71 100644 --- a/IsoLib/libisomediafile/src/VideoMediaHeaderAtom.c +++ b/IsoLib/libisomediafile/src/VideoMediaHeaderAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,107 +15,109 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: VideoMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: VideoMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if ( s == NULL ) - BAILWITHERROR( MP4BadParamErr ) - if ( s->super ) - s->super->destroy( s ); + MP4Err err; + err = MP4NoErr; + if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s->super) s->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4VideoMediaHeaderAtomPtr self = (MP4VideoMediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonFullAtomFields( (MP4FullAtomPtr) s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUT16( graphicsMode ); - PUT16( opColorRed ); - PUT16( opColorGreen ); - PUT16( opColorBlue ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4VideoMediaHeaderAtomPtr self = (MP4VideoMediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUT16(graphicsMode); + PUT16(opColorRed); + PUT16(opColorGreen); + PUT16(opColorBlue); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4VideoMediaHeaderAtomPtr self = (MP4VideoMediaHeaderAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateFullAtomFieldSize( (MP4FullAtomPtr) s ); if (err) goto bail; - self->size += 8; + MP4Err err; + MP4VideoMediaHeaderAtomPtr self = (MP4VideoMediaHeaderAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); + if(err) goto bail; + self->size += 8; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4VideoMediaHeaderAtomPtr self = (MP4VideoMediaHeaderAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - if ( self->size - self->bytesRead == 8 ) { - GET16( graphicsMode ); - GET16( opColorRed ); - GET16( opColorGreen ); - GET16( opColorBlue ); - } + MP4Err err; + MP4VideoMediaHeaderAtomPtr self = (MP4VideoMediaHeaderAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + if(self->size - self->bytesRead == 8) + { + GET16(graphicsMode); + GET16(opColorRed); + GET16(opColorGreen); + GET16(opColorBlue); + } bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateVideoMediaHeaderAtom( MP4VideoMediaHeaderAtomPtr *outAtom ) +MP4Err MP4CreateVideoMediaHeaderAtom(MP4VideoMediaHeaderAtomPtr *outAtom) { - MP4Err err; - MP4VideoMediaHeaderAtomPtr self; - - self = (MP4VideoMediaHeaderAtomPtr) calloc( 1, sizeof(MP4VideoMediaHeaderAtom) ); - TESTMALLOC( self ) - - err = MP4CreateFullAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4VideoMediaHeaderAtomType; - self->name = "video media header"; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - self->flags = 1; - - *outAtom = self; + MP4Err err; + MP4VideoMediaHeaderAtomPtr self; + + self = (MP4VideoMediaHeaderAtomPtr)calloc(1, sizeof(MP4VideoMediaHeaderAtom)); + TESTMALLOC(self) + + err = MP4CreateFullAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4VideoMediaHeaderAtomType; + self->name = "video media header"; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + self->flags = 1; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/VisualSampleEntryAtom.c b/IsoLib/libisomediafile/src/VisualSampleEntryAtom.c index 5108ffc..a7c567c 100644 --- a/IsoLib/libisomediafile/src/VisualSampleEntryAtom.c +++ b/IsoLib/libisomediafile/src/VisualSampleEntryAtom.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,139 +15,143 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: VisualSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: VisualSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4VisualSampleEntryAtomPtr self; - err = MP4NoErr; - self = (MP4VisualSampleEntryAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST_F( ExtensionAtomList ) - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4VisualSampleEntryAtomPtr self; + err = MP4NoErr; + self = (MP4VisualSampleEntryAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST_F(ExtensionAtomList) + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4VisualSampleEntryAtomPtr self = (MP4VisualSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( self->reserved, 6 ); - PUT16( dataReferenceIndex ); - PUTBYTES( self->reserved2, 16 ); - PUT16( width ); - PUT16( height ); - /* PUT32( reserved3 ); */ - PUT32( reserved4 ); - PUT32( reserved5 ); - PUT32( reserved6 ); - PUT16( reserved7 ); - PUT8( nameLength ); - PUTBYTES(self->name31, 31 ); - PUT16( reserved8 ); - PUT16( reserved9 ); - SERIALIZE_ATOM_LIST( ExtensionAtomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4VisualSampleEntryAtomPtr self = (MP4VisualSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(self->reserved, 6); + PUT16(dataReferenceIndex); + PUTBYTES(self->reserved2, 16); + PUT16(width); + PUT16(height); + /* PUT32( reserved3 ); */ + PUT32(reserved4); + PUT32(reserved5); + PUT32(reserved6); + PUT16(reserved7); + PUT8(nameLength); + PUTBYTES(self->name31, 31); + PUT16(reserved8); + PUT16(reserved9); + SERIALIZE_ATOM_LIST(ExtensionAtomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4VisualSampleEntryAtomPtr self = (MP4VisualSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += (6 + 16 + 31 + (4*2)+(1*1)+(4*4)); - ADD_ATOM_LIST_SIZE( ExtensionAtomList ); + MP4Err err; + MP4VisualSampleEntryAtomPtr self = (MP4VisualSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += (6 + 16 + 31 + (4 * 2) + (1 * 1) + (4 * 4)); + ADD_ATOM_LIST_SIZE(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4VisualSampleEntryAtomPtr self = (MP4VisualSampleEntryAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GETBYTES( 6, reserved ); - GET16( dataReferenceIndex ); - GETBYTES( 16, reserved2 ); - GET16( width ); - GET16( height ); - /* GET32( reserved3 ); */ - GET32( reserved4 ); - GET32( reserved5 ); - GET32( reserved6 ); - GET16( reserved7 ); - GET8( nameLength ); - GETBYTES( 31, name31 ); - GET16( reserved8 ); - GET16( reserved9 ); - GETATOM_LIST( ExtensionAtomList ); + MP4Err err; + MP4VisualSampleEntryAtomPtr self = (MP4VisualSampleEntryAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GETBYTES(6, reserved); + GET16(dataReferenceIndex); + GETBYTES(16, reserved2); + GET16(width); + GET16(height); + /* GET32( reserved3 ); */ + GET32(reserved4); + GET32(reserved5); + GET32(reserved6); + GET16(reserved7); + GET8(nameLength); + GETBYTES(31, name31); + GET16(reserved8); + GET16(reserved9); + GETATOM_LIST(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateVisualSampleEntryAtom( MP4VisualSampleEntryAtomPtr *outAtom ) +MP4Err MP4CreateVisualSampleEntryAtom(MP4VisualSampleEntryAtomPtr *outAtom) { - MP4Err err; - MP4VisualSampleEntryAtomPtr self; - - self = (MP4VisualSampleEntryAtomPtr) calloc( 1, sizeof(MP4VisualSampleEntryAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4VisualSampleEntryAtomType; - self->name = "visual sample entry"; - err = MP4MakeLinkedList( &self->ExtensionAtomList ); if (err) goto bail; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - self->width = 0x140; - self->height = 0xf0; - self->reserved4 = 0x00480000; self->reserved5 = 0x00480000; - self->reserved7 = 1; - self->reserved8 = 0x18; - self->reserved9 = -1; - - *outAtom = self; + MP4Err err; + MP4VisualSampleEntryAtomPtr self; + + self = (MP4VisualSampleEntryAtomPtr)calloc(1, sizeof(MP4VisualSampleEntryAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4VisualSampleEntryAtomType; + self->name = "visual sample entry"; + err = MP4MakeLinkedList(&self->ExtensionAtomList); + if(err) goto bail; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + self->width = 0x140; + self->height = 0xf0; + self->reserved4 = 0x00480000; + self->reserved5 = 0x00480000; + self->reserved7 = 1; + self->reserved8 = 0x18; + self->reserved9 = -1; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c b/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c index d3b91a9..353b9f5 100644 --- a/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c +++ b/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,192 +15,220 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: XMLMetaSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: XMLMetaSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" #include #include -static void destroy( MP4AtomPtr s ) +static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4XMLMetaSampleEntryAtomPtr self; - err = MP4NoErr; - self = (MP4XMLMetaSampleEntryAtomPtr) s; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - DESTROY_ATOM_LIST_F( ExtensionAtomList ) - - if ( self->content_encoding ) { - free( self->content_encoding ); - self->content_encoding = NULL; - } - if ( self->xml_namespace ) { - free( self->xml_namespace ); - self->xml_namespace = NULL; - } - if ( self->schema_location ) { - free( self->schema_location ); - self->schema_location = NULL; - } - - if ( self->super ) - self->super->destroy( s ); + MP4Err err; + MP4XMLMetaSampleEntryAtomPtr self; + err = MP4NoErr; + self = (MP4XMLMetaSampleEntryAtomPtr)s; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + DESTROY_ATOM_LIST_F(ExtensionAtomList) + + if(self->content_encoding) + { + free(self->content_encoding); + self->content_encoding = NULL; + } + if(self->xml_namespace) + { + free(self->xml_namespace); + self->xml_namespace = NULL; + } + if(self->schema_location) + { + free(self->schema_location); + self->schema_location = NULL; + } + + if(self->super) self->super->destroy(s); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return; + return; } -static MP4Err serialize( struct MP4Atom* s, char* buffer ) +static MP4Err serialize(struct MP4Atom *s, char *buffer) { - MP4Err err; - MP4XMLMetaSampleEntryAtomPtr self = (MP4XMLMetaSampleEntryAtomPtr) s; - u8 x; - err = MP4NoErr; - - err = MP4SerializeCommonBaseAtomFields( s, buffer ); if (err) goto bail; - buffer += self->bytesWritten; - PUTBYTES( self->reserved, 6 ); - PUT16( dataReferenceIndex ); - - x = 0; - - if ( self->content_encoding ) - { - u32 len = strlen( self->content_encoding ) + 1; - PUTBYTES( self->content_encoding, len ); - } else { PUT8_V( x ); } - - if ( self->xml_namespace ) - { - u32 len = strlen( self->xml_namespace ) + 1; - PUTBYTES( self->xml_namespace, len ); - } else { PUT8_V( x ); } - - if ( self->schema_location ) - { - u32 len = strlen( self->schema_location ) + 1; - PUTBYTES( self->schema_location, len ); - } else { PUT8_V( x ); } - - - SERIALIZE_ATOM_LIST( ExtensionAtomList ); - assert( self->bytesWritten == self->size ); + MP4Err err; + MP4XMLMetaSampleEntryAtomPtr self = (MP4XMLMetaSampleEntryAtomPtr)s; + u8 x; + err = MP4NoErr; + + err = MP4SerializeCommonBaseAtomFields(s, buffer); + if(err) goto bail; + buffer += self->bytesWritten; + PUTBYTES(self->reserved, 6); + PUT16(dataReferenceIndex); + + x = 0; + + if(self->content_encoding) + { + u32 len = strlen(self->content_encoding) + 1; + PUTBYTES(self->content_encoding, len); + } + else + { + PUT8_V(x); + } + + if(self->xml_namespace) + { + u32 len = strlen(self->xml_namespace) + 1; + PUTBYTES(self->xml_namespace, len); + } + else + { + PUT8_V(x); + } + + if(self->schema_location) + { + u32 len = strlen(self->schema_location) + 1; + PUTBYTES(self->schema_location, len); + } + else + { + PUT8_V(x); + } + + SERIALIZE_ATOM_LIST(ExtensionAtomList); + assert(self->bytesWritten == self->size); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err calculateSize( struct MP4Atom* s ) +static MP4Err calculateSize(struct MP4Atom *s) { - MP4Err err; - MP4XMLMetaSampleEntryAtomPtr self = (MP4XMLMetaSampleEntryAtomPtr) s; - err = MP4NoErr; - - err = MP4CalculateBaseAtomFieldSize( s ); if (err) goto bail; - self->size += 8 + 3; /* the null terminators of the three strings */ - - if ( self->content_encoding ) - self->size += strlen( self->content_encoding ); - if ( self->xml_namespace ) - self->size += strlen( self->xml_namespace ); - if ( self->schema_location ) - self->size += strlen( self->schema_location ); - - ADD_ATOM_LIST_SIZE( ExtensionAtomList ); + MP4Err err; + MP4XMLMetaSampleEntryAtomPtr self = (MP4XMLMetaSampleEntryAtomPtr)s; + err = MP4NoErr; + + err = MP4CalculateBaseAtomFieldSize(s); + if(err) goto bail; + self->size += 8 + 3; /* the null terminators of the three strings */ + + if(self->content_encoding) self->size += strlen(self->content_encoding); + if(self->xml_namespace) self->size += strlen(self->xml_namespace); + if(self->schema_location) self->size += strlen(self->schema_location); + + ADD_ATOM_LIST_SIZE(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } - -static MP4Err readstring( char** b, MP4XMLMetaSampleEntryAtomPtr self, MP4InputStreamPtr inputStream, char *fieldname ) + +static MP4Err readstring(char **b, MP4XMLMetaSampleEntryAtomPtr self, MP4InputStreamPtr inputStream, + char *fieldname) { - u32 byte; - MP4Err err; - char temp[1024]; - char msgString[200]; - char* p; - - err = MP4NoErr; - p = &(temp[0]); - - for (;;) { - GET8_V_MSG( byte, NULL ); - *p++ = byte; - if (byte==0) break; - } - - *b = calloc( strlen(temp)+1, 1 ); - TESTMALLOC( *b ); - strcpy( *b, temp ); - sprintf( msgString, "%s = '%s'", fieldname, *b ); - inputStream->msg( inputStream, msgString ); + u32 byte; + MP4Err err; + char temp[1024]; + char msgString[200]; + char *p; + + err = MP4NoErr; + p = &(temp[0]); + + for(;;) + { + GET8_V_MSG(byte, NULL); + *p++ = byte; + if(byte == 0) break; + } + + *b = calloc(strlen(temp) + 1, 1); + TESTMALLOC(*b); + strcpy(*b, temp); + sprintf(msgString, "%s = '%s'", fieldname, *b); + inputStream->msg(inputStream, msgString); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -static MP4Err createFromInputStream( MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream ) +static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - MP4Err err; - MP4XMLMetaSampleEntryAtomPtr self = (MP4XMLMetaSampleEntryAtomPtr) s; - - err = MP4NoErr; - if ( self == NULL ) BAILWITHERROR( MP4BadParamErr ) - err = self->super->createFromInputStream( s, proto, (char*) inputStream ); if ( err ) goto bail; - - GETBYTES( 6, reserved ); - GET16( dataReferenceIndex ); - - if (self->size > self->bytesRead) - { err = readstring( &(self->content_encoding), self, inputStream, "content_encoding" ); if (err) goto bail; } - else self->content_encoding = NULL; - if (self->size > self->bytesRead) - { err = readstring( &(self->xml_namespace), self, inputStream, "xml_namespace" ); if (err) goto bail; } - else self->xml_namespace = NULL; - if (self->size > self->bytesRead) - { err = readstring( &(self->schema_location), self, inputStream, "schema_location" ); if (err) goto bail; } - else self->xml_namespace = NULL; - - GETATOM_LIST( ExtensionAtomList ); + MP4Err err; + MP4XMLMetaSampleEntryAtomPtr self = (MP4XMLMetaSampleEntryAtomPtr)s; + + err = MP4NoErr; + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + if(err) goto bail; + + GETBYTES(6, reserved); + GET16(dataReferenceIndex); + + if(self->size > self->bytesRead) + { + err = readstring(&(self->content_encoding), self, inputStream, "content_encoding"); + if(err) goto bail; + } + else + self->content_encoding = NULL; + if(self->size > self->bytesRead) + { + err = readstring(&(self->xml_namespace), self, inputStream, "xml_namespace"); + if(err) goto bail; + } + else + self->xml_namespace = NULL; + if(self->size > self->bytesRead) + { + err = readstring(&(self->schema_location), self, inputStream, "schema_location"); + if(err) goto bail; + } + else + self->xml_namespace = NULL; + + GETATOM_LIST(ExtensionAtomList); bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } -MP4Err MP4CreateXMLMetaSampleEntryAtom( MP4XMLMetaSampleEntryAtomPtr *outAtom ) +MP4Err MP4CreateXMLMetaSampleEntryAtom(MP4XMLMetaSampleEntryAtomPtr *outAtom) { - MP4Err err; - MP4XMLMetaSampleEntryAtomPtr self; - - self = (MP4XMLMetaSampleEntryAtomPtr) calloc( 1, sizeof(MP4XMLMetaSampleEntryAtom) ); - TESTMALLOC( self ) - - err = MP4CreateBaseAtom( (MP4AtomPtr) self ); - if ( err ) goto bail; - self->type = MP4XMLMetaSampleEntryAtomType; - self->name = "XML meta sample entry"; - err = MP4MakeLinkedList( &self->ExtensionAtomList ); if (err) goto bail; - self->createFromInputStream = (cisfunc) createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - - *outAtom = self; + MP4Err err; + MP4XMLMetaSampleEntryAtomPtr self; + + self = (MP4XMLMetaSampleEntryAtomPtr)calloc(1, sizeof(MP4XMLMetaSampleEntryAtom)); + TESTMALLOC(self) + + err = MP4CreateBaseAtom((MP4AtomPtr)self); + if(err) goto bail; + self->type = MP4XMLMetaSampleEntryAtomType; + self->name = "XML meta sample entry"; + err = MP4MakeLinkedList(&self->ExtensionAtomList); + if(err) goto bail; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + + *outAtom = self; bail: - TEST_RETURN( err ); + TEST_RETURN(err); - return err; + return err; } diff --git a/IsoLib/libisomediafile/w32/MP4OSMacros.h b/IsoLib/libisomediafile/w32/MP4OSMacros.h index 8226940..2a0e69d 100644 --- a/IsoLib/libisomediafile/w32/MP4OSMacros.h +++ b/IsoLib/libisomediafile/w32/MP4OSMacros.h @@ -1,9 +1,9 @@ /* - This header file may be freely copied and distributed. + This header file may be freely copied and distributed. */ /* - Windows OS Macros for the ISO file format library + Windows OS Macros for the ISO file format library */ #ifndef INCLUDED_MP4OSMACROS_H @@ -23,7 +23,7 @@ #define MP4_EXTERN(v) extern v #else #ifdef ISOMP4DLLAPI -#define MP4_EXTERN(v) extern __declspec( dllexport ) v __cdecl +#define MP4_EXTERN(v) extern __declspec(dllexport) v __cdecl #else #define MP4_EXTERN(v) extern v __cdecl #endif @@ -43,7 +43,7 @@ typedef int s32; typedef short s16; typedef char s8; -#define MP4_FOUR_CHAR_CODE( a, b, c, d ) (((a)<<24)|((b)<<16)|((c)<<8)|(d)) +#define MP4_FOUR_CHAR_CODE(a, b, c, d) (((a) << 24) | ((b) << 16) | ((c) << 8) | (d)) #if defined(_MSC_VER) #define strcasecmp _stricmp #else diff --git a/IsoLib/libisomediafile/w32/W32FileMappingObject.c b/IsoLib/libisomediafile/w32/W32FileMappingObject.c index b0bbec2..46e207c 100644 --- a/IsoLib/libisomediafile/w32/W32FileMappingObject.c +++ b/IsoLib/libisomediafile/w32/W32FileMappingObject.c @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,169 +15,160 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: W32FileMappingObject.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: W32FileMappingObject.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "W32FileMappingObject.h" #include #include -static MP4Err doClose( struct FileMappingObjectRecord *s ); -static MP4Err doOpen( struct FileMappingObjectRecord *s, const char *filename ); -static MP4Err isYourFile( struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile ); +static MP4Err doClose(struct FileMappingObjectRecord *s); +static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *filename); +static MP4Err isYourFile(struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile); -static MP4Err destroy( struct FileMappingObjectRecord *s ) +static MP4Err destroy(struct FileMappingObjectRecord *s) { - MP4Err err; - Win32FileMappingObject self = (Win32FileMappingObject) s; - - err = MP4NoErr; - if ( self->data ) - err = doClose( s ); if (err) goto bail; - if ( self->parent ) - { - free( self->parent ); - } - - free( s ); + MP4Err err; + Win32FileMappingObject self = (Win32FileMappingObject)s; + + err = MP4NoErr; + if(self->data) err = doClose(s); + if(err) goto bail; + if(self->parent) + { + free(self->parent); + } + + free(s); bail: - return err; + return err; } -static MP4Err doOpen( struct FileMappingObjectRecord *s, const char *filename ) +static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *filename) { - MP4Err err; - Win32FileMappingObject self = (Win32FileMappingObject) s; - HANDLE fileHandle; - HANDLE fileMappingHandle; - /*DWORD fileSizeHigh; */ - DWORD fileSizeLow; - char *separator; - - err = MP4NoErr; - if ( self->data ) - doClose( s ); - self->fileName = _strdup( filename ); - TESTMALLOC( self->fileName ); - - fileHandle = CreateFile( filename, GENERIC_READ, FILE_SHARE_READ, NULL, - OPEN_EXISTING, - (FILE_ATTRIBUTE_READONLY | FILE_FLAG_SEQUENTIAL_SCAN), - NULL ); - if ( fileHandle == INVALID_HANDLE_VALUE ) - BAILWITHERROR( MP4FileNotFoundErr ) - fileSizeLow = GetFileSize( fileHandle, NULL ); - if ( fileSizeLow == 0xFFFFFFFF ) - BAILWITHERROR( MP4IOErr ) - self->size = fileSizeLow; - self->size64 = fileSizeLow; - fileMappingHandle = CreateFileMapping( fileHandle, NULL, PAGE_READONLY, 0, 0, NULL ); - if ( fileMappingHandle == NULL ) - BAILWITHERROR( MP4IOErr ) - - self->data = MapViewOfFile( fileMappingHandle, FILE_MAP_READ, 0, 0, 0 ); - if ( self->data == NULL ) - BAILWITHERROR( MP4IOErr ) - - CloseHandle( fileHandle ); - CloseHandle( fileMappingHandle ); - /* make parent */ - if ( (separator = strrchr(filename, '\\')) || (separator = strrchr(filename, '/')) ) - { - int len = separator - filename; - if ( self->parent ) - { - free( self->parent ); - } - - self->parent = (char *) calloc( 1, len + 2 ); - TESTMALLOC( self->parent ); - strncpy( self->parent, filename, len + 1 ); - /* strcat( self->parent, "/" ); */ - } + MP4Err err; + Win32FileMappingObject self = (Win32FileMappingObject)s; + HANDLE fileHandle; + HANDLE fileMappingHandle; + /*DWORD fileSizeHigh; */ + DWORD fileSizeLow; + char *separator; + + err = MP4NoErr; + if(self->data) doClose(s); + self->fileName = _strdup(filename); + TESTMALLOC(self->fileName); + + fileHandle = CreateFile(filename, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, + (FILE_ATTRIBUTE_READONLY | FILE_FLAG_SEQUENTIAL_SCAN), NULL); + if(fileHandle == INVALID_HANDLE_VALUE) BAILWITHERROR(MP4FileNotFoundErr) + fileSizeLow = GetFileSize(fileHandle, NULL); + if(fileSizeLow == 0xFFFFFFFF) BAILWITHERROR(MP4IOErr) + self->size = fileSizeLow; + self->size64 = fileSizeLow; + fileMappingHandle = CreateFileMapping(fileHandle, NULL, PAGE_READONLY, 0, 0, NULL); + if(fileMappingHandle == NULL) BAILWITHERROR(MP4IOErr) + + self->data = MapViewOfFile(fileMappingHandle, FILE_MAP_READ, 0, 0, 0); + if(self->data == NULL) BAILWITHERROR(MP4IOErr) + + CloseHandle(fileHandle); + CloseHandle(fileMappingHandle); + /* make parent */ + if((separator = strrchr(filename, '\\')) || (separator = strrchr(filename, '/'))) + { + int len = separator - filename; + if(self->parent) + { + free(self->parent); + } + + self->parent = (char *)calloc(1, len + 2); + TESTMALLOC(self->parent); + strncpy(self->parent, filename, len + 1); + /* strcat( self->parent, "/" ); */ + } bail: - return err; + return err; } -static MP4Err doClose( struct FileMappingObjectRecord *s ) +static MP4Err doClose(struct FileMappingObjectRecord *s) { - BOOL val; - MP4Err err; - Win32FileMappingObject self = (Win32FileMappingObject) s; - - err = MP4NoErr; - val = UnmapViewOfFile( self->data ); - if ( val==0 ) - err = MP4IOErr; - self->data = NULL; - if ( self->fileName ) - free( self->fileName ); - self->fileName = NULL; - if ( self->parent ) - { - free( self->parent ); - } - self->parent = NULL; - - return err; + BOOL val; + MP4Err err; + Win32FileMappingObject self = (Win32FileMappingObject)s; + + err = MP4NoErr; + val = UnmapViewOfFile(self->data); + if(val == 0) err = MP4IOErr; + self->data = NULL; + if(self->fileName) free(self->fileName); + self->fileName = NULL; + if(self->parent) + { + free(self->parent); + } + self->parent = NULL; + + return err; } -static MP4Err isYourFile( struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile ) +static MP4Err isYourFile(struct FileMappingObjectRecord *s, const char *filename, u32 *outSameFile) { - MP4Err err; - Win32FileMappingObject self = (Win32FileMappingObject) s; - int result; - err = MP4NoErr; - - result = _stricmp( self->fileName, filename ); - *outSameFile = result ? 0 : 1; - return err; -} + MP4Err err; + Win32FileMappingObject self = (Win32FileMappingObject)s; + int result; + err = MP4NoErr; + result = _stricmp(self->fileName, filename); + *outSameFile = result ? 0 : 1; + return err; +} -MP4Err MP4CreateWin32FileMappingObject( char *filename, FileMappingObject *outObject ) +MP4Err MP4CreateWin32FileMappingObject(char *filename, FileMappingObject *outObject) { - MP4Err err; - Win32FileMappingObject self; - - err = MP4NoErr; - self = (Win32FileMappingObject) calloc( 1, sizeof(Win32FileMappingObjectRecord) ); - TESTMALLOC( self ); - self->destroy = destroy; - self->open = doOpen; - self->close = doClose; - self->isYourFile = isYourFile; - err = doOpen( (FileMappingObject) self, filename ); if (err) goto bail; - *outObject = (FileMappingObject) self; + MP4Err err; + Win32FileMappingObject self; + + err = MP4NoErr; + self = (Win32FileMappingObject)calloc(1, sizeof(Win32FileMappingObjectRecord)); + TESTMALLOC(self); + self->destroy = destroy; + self->open = doOpen; + self->close = doClose; + self->isYourFile = isYourFile; + err = doOpen((FileMappingObject)self, filename); + if(err) goto bail; + *outObject = (FileMappingObject)self; bail: - return err; + return err; } -MP4Err MP4CreateFileMappingObject( char *urlString, FileMappingObject *outObject ) +MP4Err MP4CreateFileMappingObject(char *urlString, FileMappingObject *outObject) { - char *pathname = urlString; - if ( (strncmp(urlString, "file://", 7) == 0) || (strncmp(urlString, "file|//", 7) == 0) ) - { - pathname += 7; - } - return MP4CreateWin32FileMappingObject( pathname, outObject ); + char *pathname = urlString; + if((strncmp(urlString, "file://", 7) == 0) || (strncmp(urlString, "file|//", 7) == 0)) + { + pathname += 7; + } + return MP4CreateWin32FileMappingObject(pathname, outObject); } -MP4Err MP4AssertFileExists( char *pathName ) +MP4Err MP4AssertFileExists(char *pathName) { - MP4Err err; - struct stat buf; + MP4Err err; + struct stat buf; - err = stat( pathName, &buf ); - if ( err ) - { - BAILWITHERROR( MP4FileNotFoundErr ); - } + err = stat(pathName, &buf); + if(err) + { + BAILWITHERROR(MP4FileNotFoundErr); + } bail: - return err; + return err; } diff --git a/IsoLib/libisomediafile/w32/W32FileMappingObject.h b/IsoLib/libisomediafile/w32/W32FileMappingObject.h index 0933931..a0ab211 100644 --- a/IsoLib/libisomediafile/w32/W32FileMappingObject.h +++ b/IsoLib/libisomediafile/w32/W32FileMappingObject.h @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,13 +15,13 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: W32FileMappingObject.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: W32FileMappingObject.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #ifndef INCLUDED_W32FILEMAPPING_OBJECT_H #define INCLUDED_W32FILEMAPPING_OBJECT_H @@ -30,11 +30,11 @@ derivative works. Copyright (c) 1999. typedef struct Win32FileMappingObjectRecord { - COMMON_FILEMAPPING_OBJECT_FIELDS - char *fileName; - u32 size; + COMMON_FILEMAPPING_OBJECT_FIELDS + char *fileName; + u32 size; } Win32FileMappingObjectRecord, *Win32FileMappingObject; -MP4Err MP4CreateWin32FileMappingObject( char *filename, FileMappingObject *outObject ); +MP4Err MP4CreateWin32FileMappingObject(char *filename, FileMappingObject *outObject); #endif From 3130e33880afb380bc01671514312c115b2f3405 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Wed, 4 Nov 2020 23:16:03 +0100 Subject: [PATCH 13/55] get samplegroup sample numbers --- IsoLib/libisomediafile/src/ISOMovies.h | 1 + IsoLib/libisomediafile/src/MP4Atoms.h | 8 +++ IsoLib/libisomediafile/src/MP4Media.c | 22 ++++++++ IsoLib/libisomediafile/src/MP4Movies.h | 7 +++ IsoLib/libisomediafile/src/MediaAtom.c | 46 +++++++++++----- .../src/MediaInformationAtom.c | 53 +++++++++++++------ .../libisomediafile/src/MovieFragmentAtom.c | 20 +++++++ IsoLib/libisomediafile/src/SampleTableAtom.c | 51 ++++++++++++++++-- 8 files changed, 175 insertions(+), 33 deletions(-) diff --git a/IsoLib/libisomediafile/src/ISOMovies.h b/IsoLib/libisomediafile/src/ISOMovies.h index 63baa5f..8e95c50 100644 --- a/IsoLib/libisomediafile/src/ISOMovies.h +++ b/IsoLib/libisomediafile/src/ISOMovies.h @@ -184,6 +184,7 @@ extern "C" #define ISOGetTrackOffset MP4GetTrackOffset #define ISOGetTrackReference MP4GetTrackReference #define ISOGetTrackReferenceCount MP4GetTrackReferenceCount +#define ISOGetTrackGroup MP4GetTrackGroup #define ISOInsertMediaIntoTrack MP4InsertMediaIntoTrack #define ISONewMovieTrack MP4NewMovieTrack #define ISONewMovieTrackWithID MP4NewMovieTrackWithID diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index 765f556..01164dd 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -450,6 +450,8 @@ typedef struct MP4MediaAtom s32 sample_index, u32 count); MP4Err (*getSampleGroupMap)(struct MP4MediaAtom *self, u32 groupType, u32 sample_number, u32 *group_index); + MP4Err (*getSampleGroupSampleNumbers)(struct MP4MediaAtom *self, u32 groupType, + u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt); MP4Err (*getGroupDescription)(struct MP4MediaAtom *self, u32 groupType, u32 index, MP4Handle description); @@ -534,6 +536,8 @@ typedef struct MP4MediaInformationAtom MP4Handle description, u32 *index); MP4Err (*getSampleGroupMap)(struct MP4MediaInformationAtom *self, u32 groupType, u32 sample_number, u32 *group_index); + MP4Err (*getSampleGroupSampleNumbers)(struct MP4MediaInformationAtom *self, u32 groupType, + u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt); MP4Err (*getGroupDescription)(struct MP4MediaInformationAtom *self, u32 groupType, u32 index, MP4Handle description); MP4Err (*getSampleDependency)(struct MP4MediaInformationAtom *self, u32 sampleNumber, @@ -709,6 +713,8 @@ typedef struct MP4SampleTableAtom s32 sample_index, u32 count, u32 enableCompactSamples); MP4Err (*getSampleGroupMap)(struct MP4SampleTableAtom *self, u32 groupType, u32 sample_number, u32 *group_index); + MP4Err (*getSampleGroupSampleNumbers)(struct MP4SampleTableAtom *self, u32 groupType, + u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt); MP4Err (*getGroupDescription)(struct MP4SampleTableAtom *self, u32 theType, u32 index, MP4Handle theDescription); @@ -1335,6 +1341,8 @@ typedef struct MP4TrackFragmentAtom MP4Handle description, u32 *index); MP4Err (*getSampleGroupMap)(struct MP4TrackFragmentAtom *self, u32 groupType, u32 sample_number, u32 *group_index); + MP4Err (*getSampleGroupSampleNumbers)(struct MP4TrackFragmentAtom *self, u32 groupType, + u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt); MP4Err (*getGroupDescription)(struct MP4TrackFragmentAtom *self, u32 theType, u32 index, MP4Handle theDescription); u32 default_sample_description_index; /* all copied from the matching trex */ diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index 70a912d..38e3ada 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -261,6 +261,28 @@ ISOGetSampletoGroupMap(MP4Media media, u32 groupType, u32 sample_number, u32 *gr return err; } +MP4_EXTERN(MP4Err) +ISOGetSampleGroupSampleNumbers(MP4Media media, u32 groupType, u32 groupIndex, + u32 **outSampleNumbers, u32 *outSampleCnt) +{ + MP4Err err; + MP4MediaAtomPtr mdia; + + err = MP4NoErr; + if(media == NULL) + { + BAILWITHERROR(MP4BadParamErr); + } + mdia = (MP4MediaAtomPtr)media; + err = mdia->getSampleGroupSampleNumbers(mdia, groupType, groupIndex, outSampleNumbers, + outSampleCnt); + +bail: + TEST_RETURN(err); + + return err; +} + MP4_EXTERN(MP4Err) ISOSetSampleDependency(MP4Media media, s32 sample_index, MP4Handle dependencies) { diff --git a/IsoLib/libisomediafile/src/MP4Movies.h b/IsoLib/libisomediafile/src/MP4Movies.h index d81e85b..ddb2bbe 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.h +++ b/IsoLib/libisomediafile/src/MP4Movies.h @@ -327,6 +327,9 @@ extern "C" MP4_EXTERN(MP4Err) MP4GetTrackReferenceCount(MP4Track theTrack, u32 referenceType, u32 *outReferenceCount); + MP4_EXTERN(MP4Err) + MP4GetTrackGroup(MP4Track theTrack, u32 groupType, u32 *outGroupId); + MP4_EXTERN(MP4Err) MP4GetTrackUserData(MP4Track theTrack, MP4UserData *outUserData); @@ -398,6 +401,10 @@ extern "C" MP4_EXTERN(MP4Err) ISOGetSampletoGroupMap(MP4Media media, u32 groupType, u32 sample_number, u32 *group_index); + MP4_EXTERN(MP4Err) + ISOGetSampleGroupSampleNumbers(MP4Media media, u32 groupType, u32 group_index, + u32 **outSampleNubers, u32 *outSampleCnt); + MP4_EXTERN(MP4Err) ISOSetSampleDependency(MP4Media media, s32 sample_index, MP4Handle dependencies); diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index 8dcaa5b..b877a01 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -387,6 +387,25 @@ static MP4Err getSampleGroupMap(struct MP4MediaAtom *self, u32 groupType, u32 sa return err; } +static MP4Err getSampleGroupSampleNumbers(struct MP4MediaAtom *self, u32 groupType, u32 groupIndex, + u32 **outSampleNumbers, u32 *outSampleCnt) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + err = MP4NoErr; + + minf = (MP4MediaInformationAtomPtr)self->information; + assert(minf); + assert(minf->getSampleGroupSampleNumbers); + err = minf->getSampleGroupSampleNumbers(minf, groupType, groupIndex, outSampleNumbers, + outSampleCnt); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err setSampleDependency(struct MP4MediaAtom *self, s32 sample_index, MP4Handle dependencies) { @@ -509,19 +528,20 @@ MP4Err MP4CreateMediaAtom(MP4MediaAtomPtr *outAtom) self->destroy = destroy; err = MP4MakeLinkedList(&self->atomList); if(err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addSamples = addSamples; - self->calculateDuration = calculateDuration; - self->setfieldsize = setfieldsize; - self->setupNew = setupNew; - self->mdatMoved = mdatMoved; - self->addSampleReference = addSampleReference; - self->settrackfragment = settrackfragment; - self->addGroupDescription = addGroupDescription; - self->mapSamplestoGroup = mapSamplestoGroup; - self->getSampleGroupMap = getSampleGroupMap; - self->getGroupDescription = getGroupDescription; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addSamples = addSamples; + self->calculateDuration = calculateDuration; + self->setfieldsize = setfieldsize; + self->setupNew = setupNew; + self->mdatMoved = mdatMoved; + self->addSampleReference = addSampleReference; + self->settrackfragment = settrackfragment; + self->addGroupDescription = addGroupDescription; + self->mapSamplestoGroup = mapSamplestoGroup; + self->getSampleGroupMap = getSampleGroupMap; + self->getSampleGroupSampleNumbers = getSampleGroupSampleNumbers; + self->getGroupDescription = getGroupDescription; self->setSampleDependency = setSampleDependency; self->getSampleDependency = getSampleDependency; diff --git a/IsoLib/libisomediafile/src/MediaInformationAtom.c b/IsoLib/libisomediafile/src/MediaInformationAtom.c index 3c4d3d1..4d75009 100644 --- a/IsoLib/libisomediafile/src/MediaInformationAtom.c +++ b/IsoLib/libisomediafile/src/MediaInformationAtom.c @@ -602,6 +602,26 @@ static MP4Err getSampleGroupMap(struct MP4MediaInformationAtom *self, u32 groupT return err; } +static MP4Err getSampleGroupSampleNumbers(struct MP4MediaInformationAtom *self, u32 groupType, + u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt) +{ + MP4Err err; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + assert(stbl); + assert(stbl->getSampleGroupSampleNumbers); + err = stbl->getSampleGroupSampleNumbers(stbl, groupType, groupIndex, outSampleNumbers, + outSampleCnt); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err setSampleDependency(struct MP4MediaInformationAtom *self, s32 sample_index, MP4Handle dependencies) { @@ -758,22 +778,23 @@ MP4Err MP4CreateMediaInformationAtom(MP4MediaInformationAtomPtr *outAtom) self->getMediaDuration = getMediaDuration; err = MP4MakeLinkedList(&self->atomList); if(err) goto bail; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addSamples = addSamples; - self->setfieldsize = setfieldsize; - self->mdatMoved = mdatMoved; - self->mdatArrived = mdatArrived; - self->addSampleReference = addSampleReference; - self->testDataEntry = testDataEntry; - self->addGroupDescription = addGroupDescription; - self->mapSamplestoGroup = mapSamplestoGroup; - self->getSampleGroupMap = getSampleGroupMap; - self->getGroupDescription = getGroupDescription; - self->getSampleDependency = getSampleDependency; - self->setSampleDependency = setSampleDependency; - self->extendLastSampleDuration = extendLastSampleDuration; - self->setSampleEntry = setSampleEntry; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addSamples = addSamples; + self->setfieldsize = setfieldsize; + self->mdatMoved = mdatMoved; + self->mdatArrived = mdatArrived; + self->addSampleReference = addSampleReference; + self->testDataEntry = testDataEntry; + self->addGroupDescription = addGroupDescription; + self->mapSamplestoGroup = mapSamplestoGroup; + self->getSampleGroupMap = getSampleGroupMap; + self->getSampleGroupSampleNumbers = getSampleGroupSampleNumbers; + self->getGroupDescription = getGroupDescription; + self->getSampleDependency = getSampleDependency; + self->setSampleDependency = setSampleDependency; + self->extendLastSampleDuration = extendLastSampleDuration; + self->setSampleEntry = setSampleEntry; *outAtom = self; bail: diff --git a/IsoLib/libisomediafile/src/MovieFragmentAtom.c b/IsoLib/libisomediafile/src/MovieFragmentAtom.c index 5268390..7c40c19 100644 --- a/IsoLib/libisomediafile/src/MovieFragmentAtom.c +++ b/IsoLib/libisomediafile/src/MovieFragmentAtom.c @@ -95,6 +95,11 @@ static MP4Err mergeFragments(struct MP4MovieFragmentAtom *self, MP4MovieAtomPtr MP4Track trak; u64 mediaDuration, initialMediaDuration; u32 tfhd_flags; + u32 groupDescriptionCount; + ISOHandle desc; + u32 n; + u32 descIdx; + MP4SampleGroupDescriptionAtomPtr theGroup; err = MP4GetListEntry(self->atomList, i, (char **)&traf); if(err) goto bail; @@ -132,6 +137,21 @@ static MP4Err mergeFragments(struct MP4MovieFragmentAtom *self, MP4MovieAtomPtr err = MP4GetMediaTrack((MP4Media)mdia, &trak); if(err) goto bail; + /* sample group descriptions */ + ISONewHandle(0, &desc); + MP4GetListEntryCount(traf->groupDescriptionList, &groupDescriptionCount); + for(n = 0; n < groupDescriptionCount; n++) + { + MP4GetListEntry(traf->groupDescriptionList, n, (char **)&theGroup); + + /* check if we already have this group in moov */ + err = mdia->getGroupDescription(mdia, theGroup->grouping_type, 1, desc); + if(err != MP4NoErr) + { + mdia->addGroupDescription(mdia, theGroup->grouping_type, desc, &descIdx); + } + } + err = MP4GetMediaDuration((MP4Media)mdia, &initialMediaDuration); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index a1df334..8a5c2fb 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -696,6 +696,48 @@ static MP4Err getSampleGroupMap(struct MP4SampleTableAtom *self, u32 groupType, return err; } +static MP4Err getSampleGroupSampleNumbers(struct MP4SampleTableAtom *self, u32 groupType, + u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt) +{ + MP4Err err; + + u32 i; + u32 cur_index, cur_count; + *outSampleCnt = 0; + TESTMALLOC(*outSampleNumbers); + + MP4SampletoGroupAtomPtr theGroup; + err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); + if(theGroup) + { + *outSampleNumbers = (u32 *)malloc((theGroup->sampleCount) * sizeof(u32)); + cur_index = (theGroup->group_index)[0]; + cur_count = 1; + for(i = 1; i < theGroup->sampleCount; i++) + { + if((theGroup->group_index)[i - 1] == (theGroup->group_index)[i]) cur_count++; + else + { + if(cur_index == groupIndex) + { + (*outSampleNumbers)[(*outSampleCnt)++] = i; + } + cur_count = 1; + cur_index = (theGroup->group_index)[i]; + } + } + if(cur_index == groupIndex) + { + (*outSampleNumbers)[(*outSampleCnt)++] = i+1; + } + } + +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err setSampleDependency(struct MP4SampleTableAtom *self, s32 sample_index, MP4Handle dependencies) { @@ -835,10 +877,11 @@ MP4Err MP4CreateSampleTableAtom(MP4SampleTableAtomPtr *outAtom) self->getCurrentSampleEntryIndex = getCurrentSampleEntryIndex; self->setDefaultSampleEntry = setDefaultSampleEntry; - self->addGroupDescription = addGroupDescription; - self->mapSamplestoGroup = mapSamplestoGroup; - self->getSampleGroupMap = getSampleGroupMap; - self->getGroupDescription = getGroupDescription; + self->addGroupDescription = addGroupDescription; + self->mapSamplestoGroup = mapSamplestoGroup; + self->getSampleGroupMap = getSampleGroupMap; + self->getSampleGroupSampleNumbers = getSampleGroupSampleNumbers; + self->getGroupDescription = getGroupDescription; self->setSampleDependency = setSampleDependency; self->getSampleDependency = getSampleDependency; From 49e1c06d2788b650b8f1807e711195a15cc6c424 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Thu, 5 Nov 2020 14:54:39 +0100 Subject: [PATCH 14/55] add more tests (Metadata, libmd5 for sample verification) implement getSamplenumbers API add a temporary playgournd project (this will move to a separate test after finishing the implementation) fix wanrings on macOS --- CMakeLists.txt | 4 +- IsoLib/libisomediafile/src/ISOMeta.c | 14 +- .../src/ISOSampleDescriptions.c | 2 +- .../libisomediafile/src/ItemPropertiesAtom.c | 4 +- IsoLib/libisomediafile/src/MP4Atoms.h | 6 +- IsoLib/libisomediafile/src/MP4Media.c | 8 +- IsoLib/libisomediafile/src/MP4MovieFile.c | 2 +- IsoLib/libisomediafile/src/MP4TrackReader.c | 2 +- IsoLib/libisomediafile/src/MetaAtom.c | 2 +- IsoLib/libisomediafile/src/MovieTracks.c | 18 +- .../src/SubSampleInformationAtom.c | 4 +- .../libisomediafile/src/TrackFragmentAtom.c | 8 +- IsoLib/playground/CMakeLists.txt | 19 + IsoLib/playground/main.cpp | 362 ++++++++++++++++++ test/CMakeLists.txt | 4 + test/libmd5/MD5.h | 79 ++++ test/libmd5/libmd5.cpp | 261 +++++++++++++ test/libmd5/libmd5.h | 61 +++ test/test_01_simple.cpp | 271 ++++++------- test/test_fragment_creation.cpp | 355 ++++++++++------- test/test_metadata.cpp | 88 +++++ 21 files changed, 1257 insertions(+), 317 deletions(-) create mode 100644 IsoLib/playground/CMakeLists.txt create mode 100644 IsoLib/playground/main.cpp create mode 100644 test/libmd5/MD5.h create mode 100644 test/libmd5/libmd5.cpp create mode 100644 test/libmd5/libmd5.h create mode 100644 test/test_metadata.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index dea5ecd..5503d15 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -37,4 +37,6 @@ add_subdirectory(IsoLib/hevc_extractors) add_subdirectory(IsoLib/ipmp_example) add_subdirectory(IsoLib/isoiff_tool) add_subdirectory(IsoLib/pcm_audio_example) -add_subdirectory(test) \ No newline at end of file +add_subdirectory(test) + +add_subdirectory(IsoLib/playground) diff --git a/IsoLib/libisomediafile/src/ISOMeta.c b/IsoLib/libisomediafile/src/ISOMeta.c index e94e91c..16cb297 100644 --- a/IsoLib/libisomediafile/src/ISOMeta.c +++ b/IsoLib/libisomediafile/src/ISOMeta.c @@ -113,11 +113,11 @@ ISO_EXTERN(ISOErr) ISONewMovieMeta(ISOMovie theMovie, u32 metaType, ISOMeta *out err = newMeta(&myMeta, metaType); if(err) goto bail; - if(moov->meta != NULL) + if(movieAtom->meta != NULL) { - if(moov->meta->type == metaType) BAILWITHERROR(MP4BadParamErr); + if(movieAtom->meta->type == metaType) BAILWITHERROR(MP4BadParamErr); - if(moov->meco == NULL) + if(movieAtom->meco == NULL) { MP4AtomPtr tempMeco; err = ISOCreateAdditionalMetaDataContainerAtom( @@ -128,7 +128,7 @@ ISO_EXTERN(ISOErr) ISONewMovieMeta(ISOMovie theMovie, u32 metaType, ISOMeta *out myMeta->relatedMeco = (MP4AtomPtr)mecoPtr; } - mecoPtr = (ISOAdditionalMetaDataContainerAtomPtr)moov->meco; + mecoPtr = (ISOAdditionalMetaDataContainerAtomPtr)movieAtom->meco; err = mecoPtr->addMeta(mecoPtr, (MP4AtomPtr)myMeta); if(err) goto bail; } @@ -194,6 +194,7 @@ ISO_EXTERN(ISOErr) ISONewTrackMeta(ISOTrack theTrack, u32 metaType, ISOMeta *out return err; } +/* Deprecated */ ISO_EXTERN(ISOErr) ISOAddMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 relation_type) { MP4Err err; @@ -233,6 +234,7 @@ ISO_EXTERN(ISOErr) ISOAddMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta return err; } +/* Deprecated */ ISO_EXTERN(ISOErr) ISOGetMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 *relation_type) { MP4Err err; @@ -1926,7 +1928,7 @@ ISOAddMetaItemProperty(ISOMetaItem item, MP4GenericAtom *itemProperty, u8 essent if(myMeta->iprp == NULL) { - err = MP4CreateItemPropertiesAtom(&myMeta->iprp); + err = MP4CreateItemPropertiesAtom( (MP4ItemPropertiesAtomPtr*) &myMeta->iprp); if(err) goto bail; err = MP4AddListEntry(myMeta->iprp, myMeta->atomList); if(err) goto bail; @@ -1967,7 +1969,7 @@ ISOGetProperitesOfMetaItem(ISOMetaItem item, MP4GenericAtom **properties, u32 *p if(myMeta->iprp == NULL) { - err = MP4CreateItemPropertiesAtom(&myMeta->iprp); + err = MP4CreateItemPropertiesAtom( (MP4ItemPropertiesAtomPtr*) &myMeta->iprp); if(err) goto bail; err = MP4AddListEntry(myMeta->iprp, myMeta->atomList); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c index 2f3c1af..50f7535 100644 --- a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c +++ b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c @@ -1422,7 +1422,7 @@ ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 height = read_golomb_uev(bb, &err); if(err) goto bail; ((MP4VisualSampleEntryAtomPtr)entry)->height = height; - ((MP4TrackAtomPtr)theTrack)->setDimensions(theTrack, width, height); + ((MP4TrackAtomPtr)theTrack)->setDimensions((MP4TrackAtomPtr)theTrack, width, height); /* conformance_window_flag */ x = GetBits(bb, 1, &err); diff --git a/IsoLib/libisomediafile/src/ItemPropertiesAtom.c b/IsoLib/libisomediafile/src/ItemPropertiesAtom.c index 3e8055b..238a407 100644 --- a/IsoLib/libisomediafile/src/ItemPropertiesAtom.c +++ b/IsoLib/libisomediafile/src/ItemPropertiesAtom.c @@ -53,11 +53,11 @@ static MP4Err addAtom(MP4ItemPropertiesAtomPtr self, MP4AtomPtr atom) switch(atom->type) { case MP4ItemPropertyContainerAtomType: - self->ipco = atom; + self->ipco = (MP4ItemPropertyContainerAtomPtr)atom; break; case MP4ItemPropertyAssociationAtomType: - self->ipma = atom; + self->ipma = (MP4ItemPropertyAssociationAtomPtr)atom; break; } diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index 01164dd..63f8960 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -128,8 +128,8 @@ enum ISOItemProtectionAtomType = MP4_FOUR_CHAR_CODE('i', 'p', 'r', 'o'), ISOItemInfoAtomType = MP4_FOUR_CHAR_CODE('i', 'i', 'n', 'f'), ISOItemInfoEntryAtomType = MP4_FOUR_CHAR_CODE('i', 'n', 'f', 'e'), - ISOAdditionalMetaDataContainerAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 'c', 'o'), - ISOMetaboxRelationAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 'r', 'e'), + ISOAdditionalMetaDataContainerAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 'c', 'o'), /* Deprecated */ + ISOMetaboxRelationAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 'r', 'e'), /* Deprecated */ ISOItemDataAtomType = MP4_FOUR_CHAR_CODE('i', 'd', 'a', 't'), ISOItemReferenceAtomType = MP4_FOUR_CHAR_CODE('i', 'r', 'e', 'f'), ISOVCConfigAtomType = MP4_FOUR_CHAR_CODE('a', 'v', 'c', 'C'), @@ -228,7 +228,7 @@ typedef struct MP4PrivateMovieRecord MP4AtomPtr jp2h; /* for JPEG-2000, the JP2 header atom */ MP4AtomPtr sgnt; /* for JPEG-2000, the signature atom */ MP4AtomPtr meta; /* file-level meta-data */ - MP4AtomPtr meco; /* file-level additional meta-data container */ + MP4AtomPtr meco; /* Deprecated file-level additional meta-data container */ void *inMemoryDataHandler; MP4Handle prepend_handle; diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index 38e3ada..1dbadef 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -1078,7 +1078,7 @@ MP4_EXTERN(MP4Err) MP4CheckMediaDataReferences(MP4Media theMedia) u32 dataEntryIndex; err = MP4NoErr; - if((theMedia == NULL)) + if(theMedia == NULL) { BAILWITHERROR(MP4BadParamErr); } @@ -1122,7 +1122,7 @@ MP4AddMediaDataReference(MP4Media theMedia, u32 *outReferenceIndex, MP4Handle ur MP4DataReferenceAtomPtr dref; err = MP4NoErr; - if((theMedia == NULL)) + if(theMedia == NULL) { BAILWITHERROR(MP4BadParamErr); } @@ -1989,7 +1989,7 @@ MP4MediaTimeToSampleNum(MP4Media theMedia, u64 mediaTime, u32 *outSampleNum, u64 s32 sampleDuration; err = MP4NoErr; - if((theMedia == NULL)) + if(theMedia == NULL) { BAILWITHERROR(MP4BadParamErr); } @@ -2133,7 +2133,7 @@ MP4CheckMediaDataRef(MP4Media theMedia, u32 dataEntryIndex) MP4DataReferenceAtomPtr dref; err = MP4NoErr; - if((theMedia == NULL)) BAILWITHERROR(MP4BadParamErr); + if(theMedia == NULL) BAILWITHERROR(MP4BadParamErr); minf = (MP4MediaInformationAtomPtr)((MP4MediaAtomPtr)theMedia)->information; if(minf == NULL) BAILWITHERROR(MP4InvalidMediaErr); dinf = (MP4DataInformationAtomPtr)minf->dataInformation; diff --git a/IsoLib/libisomediafile/src/MP4MovieFile.c b/IsoLib/libisomediafile/src/MP4MovieFile.c index 39b5ef6..61894e0 100644 --- a/IsoLib/libisomediafile/src/MP4MovieFile.c +++ b/IsoLib/libisomediafile/src/MP4MovieFile.c @@ -48,7 +48,7 @@ static MP4Err LocalPutMovieIntoHandle(MP4Movie theMovie, MP4Handle movieH, u32 i MP4AtomPtr headatom; err = MP4NoErr; - if((theMovie == NULL)) BAILWITHERROR(MP4BadParamErr); + if(theMovie == NULL) BAILWITHERROR(MP4BadParamErr); /* if movieH is NULL, then we append the movie into the prepend_handle */ movie = (MP4PrivateMovieRecordPtr)theMovie; diff --git a/IsoLib/libisomediafile/src/MP4TrackReader.c b/IsoLib/libisomediafile/src/MP4TrackReader.c index 3f6cbf4..cb426b3 100644 --- a/IsoLib/libisomediafile/src/MP4TrackReader.c +++ b/IsoLib/libisomediafile/src/MP4TrackReader.c @@ -107,7 +107,7 @@ MP4TrackReaderGetCurrentSampleDescriptionIndex(MP4TrackReader theReader, u32 *in MP4TrackReaderPtr reader; err = MP4NoErr; - if((theReader == 0)) BAILWITHERROR(MP4BadParamErr) + if(theReader == 0) BAILWITHERROR(MP4BadParamErr) reader = (MP4TrackReaderPtr)theReader; *index = reader->sampleDescIndex; bail: diff --git a/IsoLib/libisomediafile/src/MetaAtom.c b/IsoLib/libisomediafile/src/MetaAtom.c index 7591fc6..8683dde 100644 --- a/IsoLib/libisomediafile/src/MetaAtom.c +++ b/IsoLib/libisomediafile/src/MetaAtom.c @@ -257,7 +257,7 @@ static MP4Err getData(ISOMetaAtomPtr self, u32 box_type, MP4Handle data, u8 is_f u32 i, count; err = MP4NoErr; - if((self == NULL)) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) BAILWITHERROR(MP4BadParamErr) if(self->atomList) { diff --git a/IsoLib/libisomediafile/src/MovieTracks.c b/IsoLib/libisomediafile/src/MovieTracks.c index 963401d..5a42168 100644 --- a/IsoLib/libisomediafile/src/MovieTracks.c +++ b/IsoLib/libisomediafile/src/MovieTracks.c @@ -146,7 +146,7 @@ MP4_EXTERN(MP4Err) MP4AddSubSampleInformationToTrack(MP4Track theTrack, MP4Gener err = MP4NoErr; - if((theTrack == NULL)) BAILWITHERROR(MP4BadParamErr); + if(theTrack == NULL) BAILWITHERROR(MP4BadParamErr); trak = (MP4TrackAtomPtr)theTrack; mdia = (MP4MediaAtomPtr)trak->trackMedia; @@ -190,7 +190,7 @@ MP4_EXTERN(MP4Err) MP4SetSubSampleInformationFlags(MP4GenericAtom subsample, u32 MP4SubSampleInformationAtomPtr subs; err = MP4NoErr; - if((subsample == NULL)) BAILWITHERROR(MP4BadParamErr); + if(subsample == NULL) BAILWITHERROR(MP4BadParamErr); subs = (MP4SubSampleInformationAtomPtr)subsample; subs->flags = flags; @@ -215,7 +215,7 @@ MP4GetSubSampleInformationEntryFromTrack(MP4Track theTrack, u32 *flags, u32 *ent MP4SampleTableAtomPtr stbl = NULL; err = MP4NoErr; - if((theTrack == NULL)) BAILWITHERROR(MP4BadParamErr); + if(theTrack == NULL) BAILWITHERROR(MP4BadParamErr); trak = (MP4TrackAtomPtr)theTrack; mdia = (MP4MediaAtomPtr)trak->trackMedia; @@ -310,10 +310,10 @@ MP4AddSubSampleInformationEntry(MP4GenericAtom subsample, u32 sample_delta, u32 MP4SubSampleInformationAtomPtr subs; err = MP4NoErr; - if((subsample == NULL)) BAILWITHERROR(MP4BadParamErr); + if(subsample == NULL) BAILWITHERROR(MP4BadParamErr); subs = (MP4SubSampleInformationAtomPtr)subsample; - err = subs->addEntry((MP4AtomPtr)subs, sample_delta, subsample_count, subsample_size_array, + err = subs->addEntry(subs, sample_delta, subsample_count, subsample_size_array, subsample_priority_array, subsample_discardable_array); bail: @@ -329,7 +329,7 @@ MP4_EXTERN(MP4Err) MP4AddTrackGroup(MP4Track theTrack, u32 groupID, u32 dependen MP4TrackGroupTypeAtomPtr msrc; err = MP4NoErr; - if((theTrack == NULL)) BAILWITHERROR(MP4BadParamErr); + if(theTrack == NULL) BAILWITHERROR(MP4BadParamErr); trak = (MP4TrackAtomPtr)theTrack; trgr = (MP4TrackGroupAtomPtr)trak->trackGroups; if(trgr == NULL) @@ -644,7 +644,7 @@ MP4_EXTERN(MP4Err) MP4GetTrackGroup(MP4Track theTrack, u32 groupType, u32 *outGr if(trgr == NULL) BAILWITHERROR(MP4BadParamErr); err = trgr->findAtomOfType(trgr, groupType, (MP4AtomPtr *)&msrc); if(err) goto bail; - if((msrc == NULL)) BAILWITHERROR(MP4BadParamErr); + if(msrc == NULL) BAILWITHERROR(MP4BadParamErr); *outGroupId = msrc->track_group_id; bail: @@ -893,7 +893,7 @@ MP4_EXTERN(MP4Err) MP4SetTrackOffset(MP4Track track, u32 movieOffsetTime) u64 trackDuration; err = MP4NoErr; - if((track == 0)) BAILWITHERROR(MP4BadParamErr); + if(track == 0) BAILWITHERROR(MP4BadParamErr); err = MP4GetTrackDuration(track, &trackDuration); if(err) goto bail; @@ -979,7 +979,7 @@ MP4_EXTERN(MP4Err) MP4TrackTimeToMediaTime(MP4Track theTrack, u64 inTrackTime, s err = MP4GetMediaTimeScale(theMedia, &mediaTimeScale); if(err) goto bail; - if((movieTimeScale == 0)) BAILWITHERROR(MP4InvalidMediaErr) + if(movieTimeScale == 0) BAILWITHERROR(MP4InvalidMediaErr) trak = (MP4TrackAtomPtr)theTrack; edts = (MP4EditAtomPtr)trak->trackEditAtom; diff --git a/IsoLib/libisomediafile/src/SubSampleInformationAtom.c b/IsoLib/libisomediafile/src/SubSampleInformationAtom.c index e6c358b..f6f080f 100644 --- a/IsoLib/libisomediafile/src/SubSampleInformationAtom.c +++ b/IsoLib/libisomediafile/src/SubSampleInformationAtom.c @@ -127,7 +127,7 @@ static MP4Err calculateSize(struct MP4Atom *s) return err; } -static MP4Err addEntry(MP4AtomPtr s, u32 sample_delta, u32 subsample_count, +static MP4Err addEntry(MP4SubSampleInformationAtom *s, u32 sample_delta, u32 subsample_count, MP4Handle subsample_size_array, MP4Handle subsample_priority_array, MP4Handle subsample_discardable_array) { @@ -137,7 +137,7 @@ static MP4Err addEntry(MP4AtomPtr s, u32 sample_delta, u32 subsample_count, u32 current_entry; err = MP4NoErr; - if((s == NULL)) BAILWITHERROR(MP4BadParamErr); + if(s == NULL) BAILWITHERROR(MP4BadParamErr); self = (MP4SubSampleInformationAtomPtr)s; current_entry = self->entry_count; diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index e35ab4c..0f7dcf4 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -331,12 +331,11 @@ static MP4Err addSampleReference(struct MP4MediaInformationAtom *s, u64 dataOffs return err; } -static MP4Err addGroupDescription(struct MP4Atom *s, u32 theType, MP4Handle theDescription, +static MP4Err addGroupDescription(MP4TrackFragmentAtomPtr self, u32 theType, MP4Handle theDescription, u32 *index) { MP4Err err; MP4SampleGroupDescriptionAtomPtr theGroup; - MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr)s; err = MP4FindGroupAtom(self->groupDescriptionList, theType, (MP4AtomPtr *)&theGroup); if(!theGroup) @@ -355,7 +354,7 @@ static MP4Err addGroupDescription(struct MP4Atom *s, u32 theType, MP4Handle theD return err; } -static MP4Err getGroupDescription(struct MP4SampleTableAtom *self, u32 theType, u32 index, +static MP4Err getGroupDescription(MP4TrackFragmentAtomPtr self, u32 theType, u32 index, MP4Handle theDescription) { MP4Err err; @@ -909,13 +908,12 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType return err; } -static MP4Err getSampleGroupMap(struct MP4Atom *s, u32 groupType, u32 sample_number, +static MP4Err getSampleGroupMap(MP4TrackFragmentAtomPtr self, u32 groupType, u32 sample_number, u32 *group_index) { MP4Err err; MP4SampletoGroupAtomPtr theGroup; MP4CompactSampletoGroupAtomPtr compactSampleGroup; - MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr)s; err = MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&theGroup); if(theGroup) diff --git a/IsoLib/playground/CMakeLists.txt b/IsoLib/playground/CMakeLists.txt new file mode 100644 index 0000000..bd572a5 --- /dev/null +++ b/IsoLib/playground/CMakeLists.txt @@ -0,0 +1,19 @@ +cmake_minimum_required(VERSION 3.9.2) + +project(playground) + +include_directories(../libisomediafile/src) +include_directories( + # Linux + $<$:${CMAKE_CURRENT_LIST_DIR}/../libisomediafile/linux> + + # Windows + $<$:${CMAKE_CURRENT_LIST_DIR}/../libisomediafile/w32> + + # Mac + $<$:${CMAKE_CURRENT_LIST_DIR}/../libisomediafile/macosx> +) + +add_executable(playground main.cpp) + +target_link_libraries(playground LINK_PUBLIC libisomediafile) diff --git a/IsoLib/playground/main.cpp b/IsoLib/playground/main.cpp new file mode 100644 index 0000000..37e7baf --- /dev/null +++ b/IsoLib/playground/main.cpp @@ -0,0 +1,362 @@ +/** + * @file main.cpp + * @author Dimitri Podborski + * @brief Writes a HEVC mp4 file with sample groups accoring to colour pattern + * @version 0.1 + * @date 2020-10-26 + * + * @copyright Copyright (c) 2020 + * + */ +#include +#include +#include +#include +#include + +extern "C" { +MP4_EXTERN(MP4Err) +ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 length_size, + MP4Handle first_sps, MP4Handle first_pps, + MP4Handle first_spsext); +} + +u8 VPS[] = {0x40, 0x01, 0x0C, 0x01, 0xFF, 0xFF, 0x04, 0x08, + 0x00, 0x00, 0x03, 0x00, 0x9F, 0xA8, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x1E, 0xBA, 0x02, 0x40}; + +u8 SPS[] = {0x42, 0x01, 0x01, 0x04, 0x08, 0x00, 0x00, 0x03, + 0x00, 0x9F, 0xA8, 0x00, 0x00, 0x03, 0x00, 0x00, + 0x1E, 0xA0, 0x20, 0x83, 0x16, 0x5B, 0xAB, 0x93, + 0x2B, 0x9A, 0x02, 0x00, 0x00, 0x03, 0x00, 0x02, + 0x00, 0x00, 0x03, 0x00, 0x32, 0x10}; + +u8 PPS[] = {0x44, 0x01, 0xC1, 0x73, 0xC0, 0x89}; + +u8 auRed[] = {0x00, 0x00, 0x00, 0x16, 0x28, 0x01, 0xAF, 0x78, 0xF7, 0x04, + 0x03, 0xFF, 0xDB, 0xA3, 0xFF, 0xED, 0x27, 0xD2, 0xF6, + 0xC3, 0x94, 0x40, 0x83, 0xC0, 0x00, 0x78}; + +u8 auBlue[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, + 0x3F, 0x9C, 0x43, 0xFF, 0xFA, 0x87, 0x32, 0xAF, + 0xFC, 0x5D, 0xFF, 0xFF, 0xAE, 0x1D, 0xB9, 0xA2, + 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; + +u8 auGreen[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, + 0x3F, 0x9C, 0x43, 0xFF, 0xF5, 0x9F, 0x1F, 0xFF, + 0xD8, 0x3B, 0xFF, 0xFD, 0xF0, 0xF5, 0xB9, 0xA2, + 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; + +u8 auYellow[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xA0, + 0x3F, 0x9C, 0x43, 0x3C, 0xFA, 0x51, 0x1D, 0xFF, + 0xFC, 0x5D, 0xFE, 0xCB, 0xAE, 0x1D, 0xB9, 0xA2, + 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; + + +u8 auWhite[] = { + 0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, 0xE7, 0x9F, 0x6C, 0x07, 0x79, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87 +}; + +u8 auBlack[] = { + 0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, 0xFF, 0xFF, 0x72, 0xCA, 0x19, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87 +}; + +const u32 TIMESCALE = 30000; +const u32 FPS = 30; + +const u32 FOURCC_RED = MP4_FOUR_CHAR_CODE('r', 'e', 'd', ' '); +const u32 FOURCC_BLU = MP4_FOUR_CHAR_CODE('b', 'l', 'u', 'e'); +const u32 FOURCC_GRN = MP4_FOUR_CHAR_CODE('g', 'r', 'e', 'n'); +const u32 FOURCC_YLW = MP4_FOUR_CHAR_CODE('y', 'e', 'l', 'w'); + +ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, ISOHandle sampleEntryH = 0) { + ISOErr err; + u32 sampleCount = 0; + ISOHandle sampleDataH, durationsH, sizesH; + err = ISONewHandle(sizeof(u32), &durationsH); if(err) return err; + + *((u32*)*durationsH) = TIMESCALE/FPS; + + std::vector bufferData; + std::vector bufferSizes; + for(std::string::const_iterator it=strPattern.cbegin(); it != strPattern.cend(); ++it) { + switch (*it) + { + case 'r': + bufferData.insert(bufferData.end(), auRed, auRed + sizeof(auRed)); + bufferSizes.push_back(sizeof(auRed)); + break; + case 'b': + bufferData.insert(bufferData.end(), auBlue, auBlue + sizeof(auBlue)); + bufferSizes.push_back(sizeof(auBlue)); + break; + case 'g': + bufferData.insert(bufferData.end(), auGreen, auGreen + sizeof(auGreen)); + bufferSizes.push_back(sizeof(auGreen)); + break; + case 'y': + bufferData.insert(bufferData.end(), auYellow, auYellow + sizeof(auYellow)); + bufferSizes.push_back(sizeof(auYellow)); + break; + case 'w': + bufferData.insert(bufferData.end(), auWhite, auWhite + sizeof(auWhite)); + bufferSizes.push_back(sizeof(auWhite)); + break; + case 'k': + bufferData.insert(bufferData.end(), auBlack, auBlack + sizeof(auBlack)); + bufferSizes.push_back(sizeof(auBlack)); + break; + default: + std::cerr << "UNKNOWN char in pattern string: " << *it << std::endl; + break; + } + } + + // repeat pattern + std::vector bufferDataPattern = bufferData; + std::vector bufferSizesPattern = bufferSizes; + std::string fullPattern = strPattern; + for(u32 n = 1; n:${CMAKE_CURRENT_LIST_DIR}/../IsoLib/libisomediafile/macosx> ) +file(GLOB LIBMD5_FILES "libmd5/*.cpp" ) + include_directories(${CMAKE_CURRENT_BINARY_DIR}) add_executable( @@ -27,6 +29,8 @@ add_executable( test_main.cpp test_01_simple.cpp test_fragment_creation.cpp + test_metadata.cpp + ${LIBMD5_FILES} ) target_link_libraries(unit_tests LINK_PUBLIC libisomediafile) \ No newline at end of file diff --git a/test/libmd5/MD5.h b/test/libmd5/MD5.h new file mode 100644 index 0000000..75e655e --- /dev/null +++ b/test/libmd5/MD5.h @@ -0,0 +1,79 @@ +/* The copyright in this software is being made available under the BSD + * License, included below. This software may be subject to other third party + * and contributor rights, including patent rights, and no such rights are + * granted under this license. + * + * Copyright (c) 2010-2018, ITU/ISO/IEC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of the ITU/ISO/IEC nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ +#pragma once +#include "libmd5.h" +#include + +//! \ingroup libMD5 +//! \{ + +static const uint32_t MD5_DIGEST_STRING_LENGTH=16; + +namespace libmd5 { + +class MD5 +{ +public: + /** + * initialize digest state + */ + MD5() + { + MD5Init(&m_state); + } + + /** + * compute digest over buf of length len. + * multiple calls may extend the digest over more data. + */ + void update(unsigned char *buf, unsigned len) + { + MD5Update(&m_state, buf, len); + } + + /** + * flush any outstanding MD5 data, write the digest into digest. + */ + void finalize(unsigned char digest[MD5_DIGEST_STRING_LENGTH]) + { + MD5Final(digest, &m_state); + } + +private: + context_md5_t m_state; +}; + + +//! \} + +} // namespace diff --git a/test/libmd5/libmd5.cpp b/test/libmd5/libmd5.cpp new file mode 100644 index 0000000..701a44b --- /dev/null +++ b/test/libmd5/libmd5.cpp @@ -0,0 +1,261 @@ +/* + * This code implements the MD5 message-digest algorithm. The algorithm was + * written by Ron Rivest. This code was written by Colin Plumb in 1993, our + * understanding is that no copyright is claimed and that this code is in the + * public domain. + * + * Equivalent code is available from RSA Data Security, Inc. + * This code has been tested against that, and is functionally equivalent, + * + * To compute the message digest of a chunk of bytes, declare an MD5Context + * structure, pass it to MD5Init, call MD5Update as needed on buffers full of + * bytes, and then call MD5Final, which will fill a supplied 16-byte array with + * the digest. + */ + +#include +#include +#include "libmd5.h" + + +namespace libmd5{ + +//! \ingroup libMD5 +//! \{ + +static void MD5Transform(uint32_t buf[4], uint32_t const in[16]); + +#ifndef __BIG_ENDIAN__ +# define byteReverse(buf, len) /* Nothing */ +#else +void byteReverse(uint32_t *buf, unsigned len); +/* + * Note: this code is harmless on little-endian machines. + */ +void byteReverse(uint32_t *buf, unsigned len) +{ + uint32_t t; + do { + char* bytes = (char *) buf; + t = ((unsigned) bytes[3] << 8 | bytes[2]) << 16 | + ((unsigned) bytes[1] << 8 | bytes[0]); + *buf = t; + buf++; + } while (--len); +} +#endif + +/* + * Start MD5 accumulation. Set bit count to 0 and buffer to mysterious + * initialization constants. + */ +void MD5Init(context_md5_t *ctx) +{ + ctx->buf[0] = 0x67452301; + ctx->buf[1] = 0xefcdab89; + ctx->buf[2] = 0x98badcfe; + ctx->buf[3] = 0x10325476; + + ctx->bits[0] = 0; + ctx->bits[1] = 0; +} + +/* + * Update context to reflect the concatenation of another buffer full + * of bytes. + */ +void MD5Update(context_md5_t *ctx, unsigned char *buf, unsigned len) +{ + uint32_t t; + + /* Update bitcount */ + + t = ctx->bits[0]; + if ((ctx->bits[0] = t + ((uint32_t) len << 3)) < t) + ctx->bits[1]++; /* Carry from low to high */ + ctx->bits[1] += len >> 29; + + t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */ + + /* Handle any leading odd-sized chunks */ + + if (t) { + unsigned char *p = ctx->in.b8 + t; + + t = 64 - t; + if (len < t) { + memcpy(p, buf, len); + return; + } + memcpy(p, buf, t); + byteReverse(ctx->in.b32, 16); + MD5Transform(ctx->buf, ctx->in.b32); + buf += t; + len -= t; + } + /* Process data in 64-byte chunks */ + + while (len >= 64) { + memcpy(ctx->in.b8, buf, 64); + byteReverse(ctx->in.b32, 16); + MD5Transform(ctx->buf, ctx->in.b32); + buf += 64; + len -= 64; + } + + /* Handle any remaining bytes of data. */ + + memcpy(ctx->in.b8, buf, len); +} + +/* + * Final wrapup - pad to 64-byte boundary with the bit pattern + * 1 0* (64-bit count of bits processed, MSB-first) + */ +void MD5Final(unsigned char digest[16], context_md5_t *ctx) +{ + unsigned count; + unsigned char *p; + + /* Compute number of bytes mod 64 */ + count = (ctx->bits[0] >> 3) & 0x3F; + + /* Set the first char of padding to 0x80. This is safe since there is + always at least one byte free */ + p = ctx->in.b8 + count; + *p++ = 0x80; + + /* Bytes of padding needed to make 64 bytes */ + count = 64 - 1 - count; + + /* Pad out to 56 mod 64 */ + if (count < 8) { + /* Two lots of padding: Pad the first block to 64 bytes */ + memset(p, 0, count); + byteReverse(ctx->in.b32, 16); + MD5Transform(ctx->buf, ctx->in.b32); + + /* Now fill the next block with 56 bytes */ + memset(ctx->in.b8, 0, 56); + } else { + /* Pad block to 56 bytes */ + memset(p, 0, count - 8); + } + byteReverse(ctx->in.b32, 14); + + /* Append length in bits and transform */ + ctx->in.b32[14] = ctx->bits[0]; + ctx->in.b32[15] = ctx->bits[1]; + + MD5Transform(ctx->buf, ctx->in.b32); + byteReverse((uint32_t *) ctx->buf, 4); + memcpy(digest, ctx->buf, 16); + + memset(ctx, 0, sizeof(* ctx)); /* In case it's sensitive */ + /* The original version of this code omitted the asterisk. In + effect, only the first part of ctx was wiped with zeros, not + the whole thing. Bug found by Derek Jones. Original line: */ + // memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */ +} + +/* The four core functions - F1 is optimized somewhat */ + +/* #define F1(x, y, z) (x & y | ~x & z) */ +#define F1(x, y, z) (z ^ (x & (y ^ z))) +#define F2(x, y, z) F1(z, x, y) +#define F3(x, y, z) (x ^ y ^ z) +#define F4(x, y, z) (y ^ (x | ~z)) + +/* This is the central step in the MD5 algorithm. */ +#define MD5STEP(f, w, x, y, z, data, s) \ + ( w += f(x, y, z) + data, w = w<>(32-s), w += x ) + +/* + * The core of the MD5 algorithm, this alters an existing MD5 hash to + * reflect the addition of 16 longwords of new data. MD5Update blocks + * the data and converts bytes into longwords for this routine. + */ +static void MD5Transform(uint32_t buf[4], uint32_t const in[16]) +{ + uint32_t a, b, c, d; + + a = buf[0]; + b = buf[1]; + c = buf[2]; + d = buf[3]; + + MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7); + MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12); + MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17); + MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22); + MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7); + MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12); + MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17); + MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22); + MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7); + MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12); + MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17); + MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22); + MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7); + MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12); + MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17); + MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22); + + MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5); + MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9); + MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14); + MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20); + MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5); + MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9); + MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14); + MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20); + MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5); + MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9); + MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14); + MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20); + MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5); + MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9); + MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14); + MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20); + + MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4); + MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11); + MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16); + MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23); + MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4); + MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11); + MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16); + MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23); + MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4); + MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11); + MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16); + MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23); + MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4); + MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11); + MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16); + MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23); + + MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6); + MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10); + MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15); + MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21); + MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6); + MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10); + MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15); + MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21); + MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6); + MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10); + MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15); + MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21); + MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6); + MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10); + MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15); + MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21); + + buf[0] += a; + buf[1] += b; + buf[2] += c; + buf[3] += d; +} + +} // namespace diff --git a/test/libmd5/libmd5.h b/test/libmd5/libmd5.h new file mode 100644 index 0000000..6966ef7 --- /dev/null +++ b/test/libmd5/libmd5.h @@ -0,0 +1,61 @@ +/* The copyright in this software is being made available under the BSD + * License, included below. This software may be subject to other third party + * and contributor rights, including patent rights, and no such rights are + * granted under this license. + * + * Copyright (c) 2010-2018, ITU/ISO/IEC + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * * Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * * Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * * Neither the name of the ITU/ISO/IEC nor the names of its contributors may + * be used to endorse or promote products derived from this software without + * specific prior written permission. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS + * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF + * THE POSSIBILITY OF SUCH DAMAGE. + */ +#pragma once +#include + + +namespace libmd5 { +//! \ingroup libMD5 +//! \{ + +typedef struct _context_md5_t { + uint32_t buf[4]; + uint32_t bits[2]; + union { + unsigned char b8[64]; + uint32_t b32[16]; + } in; +} context_md5_t; + +//#ifdef __cplusplus +//extern "C" { +//#endif +void MD5Init(context_md5_t *ctx); +void MD5Update(context_md5_t *ctx, unsigned char *buf, unsigned len); +void MD5Final(unsigned char digest[16], context_md5_t *ctx); +//#ifdef __cplusplus +//} +//#endif + +//! \} +} // namespace diff --git a/test/test_01_simple.cpp b/test/test_01_simple.cpp index 8c832ce..1f58dab 100644 --- a/test/test_01_simple.cpp +++ b/test/test_01_simple.cpp @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -28,50 +28,51 @@ derivative works. Copyright (c) 1999. #include const std::string strDataPath = TESTDATA_PATH; -const std::string strTestFile = strDataPath + + "/isobmff/01_simple.mp4"; +const std::string strTestFile = strDataPath + +"/isobmff/01_simple.mp4"; // isobmff stuff -ISOMovie cMovieBox; +ISOMovie cMovieBox; - -TEST_CASE( "Check isobmff/01_simple.mp4" ) { +TEST_CASE("Check isobmff/01_simple.mp4") +{ ISOErr err; err = ISOOpenMovieFile(&cMovieBox, strTestFile.c_str(), MP4OpenMovieNormal); - REQUIRE( err == MP4NoErr ); + REQUIRE(err == MP4NoErr); ISOTrack audioTrack, videoTrack; - SECTION( "Check Movie" ) { + SECTION("Check Movie") + { u32 brand, minorversion; - err = ISOGetMovieBrand( cMovieBox, &brand, &minorversion ); - CHECK( err == MP4NoErr ); - CHECK( brand == MP4_FOUR_CHAR_CODE('m', 'p', '4', '2') ); - CHECK( minorversion == 1 ); + err = ISOGetMovieBrand(cMovieBox, &brand, &minorversion); + CHECK(err == MP4NoErr); + CHECK(brand == MP4_FOUR_CHAR_CODE('m', 'p', '4', '2')); + CHECK(minorversion == 1); u32 outTimeScale; - err = ISOGetMovieTimeScale( cMovieBox, &outTimeScale ); - CHECK( err == MP4NoErr ); - CHECK( outTimeScale == 600 ); + err = ISOGetMovieTimeScale(cMovieBox, &outTimeScale); + CHECK(err == MP4NoErr); + CHECK(outTimeScale == 600); ISOTrack audioTrack; - err = ISOGetMovieTrack( cMovieBox, 101, &audioTrack); - CHECK( err == MP4NoErr ); - CHECK( audioTrack != 0 ); - err = ISOGetMovieTrack( cMovieBox, 301, &audioTrack); // non existing track - CHECK( err == MP4BadParamErr ); + err = ISOGetMovieTrack(cMovieBox, 101, &audioTrack); + CHECK(err == MP4NoErr); + CHECK(audioTrack != 0); + err = ISOGetMovieTrack(cMovieBox, 301, &audioTrack); // non existing track + CHECK(err == MP4BadParamErr); ISOHandle h; err = ISONewHandle(0, &h); - CHECK( err == MP4NoErr ); // TODO: move this to utility testing suite - err = MP4GetMovieInitialObjectDescriptor( cMovieBox, h ); - CHECK( err == MP4NoErr ); + CHECK(err == MP4NoErr); // TODO: move this to utility testing suite + err = MP4GetMovieInitialObjectDescriptor(cMovieBox, h); + CHECK(err == MP4NoErr); ISODisposeHandle(h); - CHECK( err == MP4NoErr ); // TODO: move this to utility testing suite + CHECK(err == MP4NoErr); // TODO: move this to utility testing suite u8 outFlag; - err = MP4GetMovieIODInlineProfileFlag ( cMovieBox, &outFlag ); - CHECK( err == MP4NoErr ); + err = MP4GetMovieIODInlineProfileFlag(cMovieBox, &outFlag); + CHECK(err == MP4NoErr); // TODO: check the value of outFlag u8 outOD; @@ -79,13 +80,9 @@ TEST_CASE( "Check isobmff/01_simple.mp4" ) { u8 outAudio; u8 outVisual; u8 outGraphics; - err = MP4GetMovieProfilesAndLevels( cMovieBox, - &outOD, - &outScene, - &outAudio, - &outVisual, - &outGraphics ); - CHECK( err == MP4NoErr ); + err = MP4GetMovieProfilesAndLevels(cMovieBox, &outOD, &outScene, &outAudio, &outVisual, + &outGraphics); + CHECK(err == MP4NoErr); // TODO: profiles and levels of Object Descriptor // WARN((u32)outOD); // WARN((u32)outScene); @@ -95,138 +92,142 @@ TEST_CASE( "Check isobmff/01_simple.mp4" ) { u64 outDuration; err = ISOGetMovieDuration(cMovieBox, &outDuration); - CHECK( err == MP4NoErr ); - CHECK( outDuration == 6074 ); + CHECK(err == MP4NoErr); + CHECK(outDuration == 6074); } - SECTION( "Check Tracks" ) { + SECTION("Check Tracks") + { // ISOGetMovieIndTrack ISOTrack track1, track2, track3, track4; - err = ISOGetMovieIndTrack( cMovieBox, 0, &audioTrack ); - REQUIRE( err != MP4NoErr ); - err = ISOGetMovieIndTrack( cMovieBox, 1, &track1 ); - CHECK( err == MP4NoErr ); - err = ISOGetMovieIndTrack( cMovieBox, 2, &track2 ); - CHECK( err == MP4NoErr ); - err = ISOGetMovieIndTrack( cMovieBox, 3, &track3 ); - CHECK( err == MP4NoErr ); - err = ISOGetMovieIndTrack( cMovieBox, 4, &track4 ); - CHECK( err == MP4NoErr ); - err = ISOGetMovieIndTrack( cMovieBox, 5, &track4 ); - CHECK( err != MP4NoErr ); + err = ISOGetMovieIndTrack(cMovieBox, 0, &audioTrack); + REQUIRE(err != MP4NoErr); + err = ISOGetMovieIndTrack(cMovieBox, 1, &track1); + CHECK(err == MP4NoErr); + err = ISOGetMovieIndTrack(cMovieBox, 2, &track2); + CHECK(err == MP4NoErr); + err = ISOGetMovieIndTrack(cMovieBox, 3, &track3); + CHECK(err == MP4NoErr); + err = ISOGetMovieIndTrack(cMovieBox, 4, &track4); + CHECK(err == MP4NoErr); + err = ISOGetMovieIndTrack(cMovieBox, 5, &track4); + CHECK(err != MP4NoErr); // ISOGetMovieTrackCount uint32_t uiTrackCnt = 0; - err = ISOGetMovieTrackCount(cMovieBox, &uiTrackCnt); - CHECK( err == MP4NoErr ); - CHECK( uiTrackCnt == 4 ); + err = ISOGetMovieTrackCount(cMovieBox, &uiTrackCnt); + CHECK(err == MP4NoErr); + CHECK(uiTrackCnt == 4); // ISOGetTrackEnabled u32 outEnabled; - ISOGetMovieTrack( cMovieBox, 101, &audioTrack); - err = ISOGetTrackEnabled( audioTrack, &outEnabled ); - CHECK( err == MP4NoErr ); - CHECK( outEnabled == 1 ); - + ISOGetMovieTrack(cMovieBox, 101, &audioTrack); + err = ISOGetTrackEnabled(audioTrack, &outEnabled); + CHECK(err == MP4NoErr); + CHECK(outEnabled == 1); + // ISOGetTrackEditlistEntryCount no elst in 01_simple.mp4 u32 outEditListCnt; - err = ISOGetTrackEditlistEntryCount( audioTrack, &outEditListCnt ); - CHECK( err == MP4NotFoundErr ); + err = ISOGetTrackEditlistEntryCount(audioTrack, &outEditListCnt); + CHECK(err == MP4NotFoundErr); // ISOGetTrackEditlist n/a for 01_simple.mp4 // ISOGetTrackID u32 outTrackID; - err = ISOGetTrackID( audioTrack, &outTrackID ); - CHECK( err == MP4NoErr ); - CHECK( outTrackID == 101 ); + err = ISOGetTrackID(audioTrack, &outTrackID); + CHECK(err == MP4NoErr); + CHECK(outTrackID == 101); // ISOGetTrackMedia ISOMedia outMedia; - err = ISOGetTrackMedia( audioTrack, &outMedia ); - CHECK( err == MP4NoErr ); + err = ISOGetTrackMedia(audioTrack, &outMedia); + CHECK(err == MP4NoErr); // ISOGetTrackMovie ISOMovie outMovie; - err = ISOGetTrackMovie( audioTrack, &outMovie ); - CHECK( err == MP4NoErr ); + err = ISOGetTrackMovie(audioTrack, &outMovie); + CHECK(err == MP4NoErr); // ISOGetTrackOffset u32 outMovieOffsetTime; - err = ISOGetTrackOffset( audioTrack, &outMovieOffsetTime ); - CHECK( err == MP4NoErr ); - CHECK( outMovieOffsetTime == 0 ); + err = ISOGetTrackOffset(audioTrack, &outMovieOffsetTime); + CHECK(err == MP4NoErr); + CHECK(outMovieOffsetTime == 0); // ISOGetTrackReference ISOTrack outReferencedTrack; - err = ISOGetTrackReference( audioTrack, MP4_FOUR_CHAR_CODE('s','y','n','c'), 1, &outReferencedTrack ); - CHECK( err == MP4NoErr ); - ISOGetTrackID( outReferencedTrack, &outTrackID ); - CHECK( outTrackID == 201 ); + err = ISOGetTrackReference(audioTrack, MP4_FOUR_CHAR_CODE('s', 'y', 'n', 'c'), 1, + &outReferencedTrack); + CHECK(err == MP4NoErr); + ISOGetTrackID(outReferencedTrack, &outTrackID); + CHECK(outTrackID == 201); // ISOGetTrackReferenceCount u32 outReferenceIndex; - err = ISOGetTrackReferenceCount(audioTrack, MP4_FOUR_CHAR_CODE('s','y','n','c'), &outReferenceIndex ); - CHECK( err == MP4NoErr ); - CHECK( outReferenceIndex == 1 ); + err = ISOGetTrackReferenceCount(audioTrack, MP4_FOUR_CHAR_CODE('s', 'y', 'n', 'c'), + &outReferenceIndex); + CHECK(err == MP4NoErr); + CHECK(outReferenceIndex == 1); // MJ2GetTrackMatrix u32 outMatrix[9]; - err = MJ2GetTrackMatrix( audioTrack, outMatrix ); - CHECK( err == MP4NoErr ); + err = MJ2GetTrackMatrix(audioTrack, outMatrix); + CHECK(err == MP4NoErr); // 65536,0,0,0,65536,0,0,0,1073741824 - CHECK( outMatrix[0] == 65536 ); - CHECK( outMatrix[1] == 0 ); - CHECK( outMatrix[2] == 0 ); - CHECK( outMatrix[3] == 0 ); - CHECK( outMatrix[4] == 65536 ); - CHECK( outMatrix[5] == 0 ); - CHECK( outMatrix[6] == 0 ); - CHECK( outMatrix[7] == 0 ); - CHECK( outMatrix[8] == 1073741824 ); + CHECK(outMatrix[0] == 65536); + CHECK(outMatrix[1] == 0); + CHECK(outMatrix[2] == 0); + CHECK(outMatrix[3] == 0); + CHECK(outMatrix[4] == 65536); + CHECK(outMatrix[5] == 0); + CHECK(outMatrix[6] == 0); + CHECK(outMatrix[7] == 0); + CHECK(outMatrix[8] == 1073741824); // MJ2GetTrackLayer s16 outLayer; - err = MJ2GetTrackLayer( audioTrack, &outLayer ); - CHECK( err == MP4NoErr ); - CHECK( outLayer == 0 ); + err = MJ2GetTrackLayer(audioTrack, &outLayer); + CHECK(err == MP4NoErr); + CHECK(outLayer == 0); // MJ2GetTrackDimensions u32 outWidth, outHeight; - ISOGetMovieTrack( cMovieBox, 201, &videoTrack); - err = MJ2GetTrackDimensions( videoTrack, &outWidth, &outHeight ); - CHECK( err == MP4NoErr ); - CHECK( outWidth == 120 ); - CHECK( outHeight == 96 ); + ISOGetMovieTrack(cMovieBox, 201, &videoTrack); + err = MJ2GetTrackDimensions(videoTrack, &outWidth, &outHeight); + CHECK(err == MP4NoErr); + CHECK(outWidth == 120); + CHECK(outHeight == 96); // MJ2GetTrackVolume s16 outVolume; - err = MJ2GetTrackVolume( audioTrack, &outVolume ); - CHECK( err == MP4NoErr ); - CHECK( outVolume == 256 ); + err = MJ2GetTrackVolume(audioTrack, &outVolume); + CHECK(err == MP4NoErr); + CHECK(outVolume == 256); // ISOGetTrackDuration u64 outDuration; - err = ISOGetTrackDuration( audioTrack, &outDuration ); - CHECK( err == MP4NoErr ); - CHECK( outDuration == 6074 ); + err = ISOGetTrackDuration(audioTrack, &outDuration); + CHECK(err == MP4NoErr); + CHECK(outDuration == 6074); } - SECTION( "Check Media" ) { + SECTION("Check Media") + { ISOMedia audioMedia, videoMedia; - ISOGetMovieTrack( cMovieBox, 101, &audioTrack); - ISOGetMovieTrack( cMovieBox, 201, &videoTrack); + ISOGetMovieTrack(cMovieBox, 101, &audioTrack); + ISOGetMovieTrack(cMovieBox, 201, &videoTrack); - err = ISOGetTrackMedia( audioTrack, &audioMedia ); - REQUIRE( err == MP4NoErr ); - err = ISOGetTrackMedia( videoTrack, &videoMedia ); - REQUIRE( err == MP4NoErr ); + err = ISOGetTrackMedia(audioTrack, &audioMedia); + REQUIRE(err == MP4NoErr); + err = ISOGetTrackMedia(videoTrack, &videoMedia); + REQUIRE(err == MP4NoErr); // MP4GetMediaDataRefCount u32 outCount; - err = MP4GetMediaDataRefCount( audioMedia, &outCount ); - CHECK( err == MP4NoErr ); - CHECK( outCount == 1 ); + err = MP4GetMediaDataRefCount(audioMedia, &outCount); + CHECK(err == MP4NoErr); + CHECK(outCount == 1); // ISOGetIndMediaSample: read second sample of the audio track ISOHandle outSample; @@ -237,14 +238,15 @@ TEST_CASE( "Check isobmff/01_simple.mp4" ) { u32 outSampleFlags; u32 outSampleDescIndex; ISONewHandle(0, &outSample); - err = ISOGetIndMediaSample(audioMedia, 2, outSample, &outSize, &outDecodingTime, &outCTSOffset, &outDuration, &outSampleFlags, &outSampleDescIndex ); - CHECK( err == MP4NoErr ); - CHECK( outSize == 141 ); - CHECK( outDecodingTime == 1024 ); - CHECK( outCTSOffset == 0 ); - CHECK( outDuration == 1024 ); - CHECK( outSampleFlags == 0 ); - CHECK( outSampleDescIndex == 1 ); + err = ISOGetIndMediaSample(audioMedia, 2, outSample, &outSize, &outDecodingTime, &outCTSOffset, + &outDuration, &outSampleFlags, &outSampleDescIndex); + CHECK(err == MP4NoErr); + CHECK(outSize == 141); + CHECK(outDecodingTime == 1024); + CHECK(outCTSOffset == 0); + CHECK(outDuration == 1024); + CHECK(outSampleFlags == 0); + CHECK(outSampleDescIndex == 1); // TODO: implement MP4GetIndMediaSampleReference // TODO: implement ISOGetIndMediaSampleWithPad @@ -258,23 +260,25 @@ TEST_CASE( "Check isobmff/01_simple.mp4" ) { u64 outCompositionTime = 0; ISOHandle outSampleDescription; ISONewHandle(0, &outSampleDescription); - outDecodingTime = 0; - outDuration = 0; + outDecodingTime = 0; + outDuration = 0; outSampleDescIndex = 0; - err = ISOGetMediaSample(audioMedia, outSample, &outSize, 3000, &outDecodingTime, &outCompositionTime, &outDuration, outSampleDescription, &outSampleDescIndex, &outSampleFlags); - CHECK( err == MP4NoErr ); - CHECK( outDecodingTime == 2048 ); - CHECK( outCompositionTime == 2048 ); - CHECK( outDuration == 1024 ); - CHECK( outSampleDescIndex == 1 ); - CHECK( outSampleFlags == 0 ); + err = ISOGetMediaSample(audioMedia, outSample, &outSize, 3000, &outDecodingTime, + &outCompositionTime, &outDuration, outSampleDescription, + &outSampleDescIndex, &outSampleFlags); + CHECK(err == MP4NoErr); + CHECK(outDecodingTime == 2048); + CHECK(outCompositionTime == 2048); + CHECK(outDuration == 1024); + CHECK(outSampleDescIndex == 1); + CHECK(outSampleFlags == 0); // TODO: implement ISOGetMediaSampleWithPad - + // ISOGetMediaSampleCount err = ISOGetMediaSampleCount(audioMedia, &outCount); - CHECK( err == MP4NoErr ); - CHECK( outCount == 218 ); + CHECK(err == MP4NoErr); + CHECK(outCount == 218); // TODO: implement ISOGetMediaTimeScale // TODO: implement ISOGetMediaTrack @@ -287,5 +291,4 @@ TEST_CASE( "Check isobmff/01_simple.mp4" ) { // TODO: implement ISOGetGroupDescription // TODO: implement ISOGetSampleDependency } - } diff --git a/test/test_fragment_creation.cpp b/test/test_fragment_creation.cpp index 2a03e9b..2b45a53 100644 --- a/test/test_fragment_creation.cpp +++ b/test/test_fragment_creation.cpp @@ -1,10 +1,10 @@ /* This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. +in the course of development of MPEG-4. +This software module is an implementation of a part of one or +more MPEG-4 tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware +software module or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. Those intending to use this software module in hardware or software products are advised that its use may infringe existing patents. @@ -15,7 +15,7 @@ in an implementation. Copyright is not released for non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its own purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non +inhibit third parties from using the code for non MPEG-4 conforming products. This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. @@ -23,27 +23,70 @@ derivative works. Copyright (c) 1999. #include #include +#include +#include +#include +#include "libmd5/MD5.h" + +// TODO: move code from playground to this test after finishing all features + +extern "C" { +MP4_EXTERN(MP4Err) +ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 length_size, + MP4Handle first_sps, MP4Handle first_pps, + MP4Handle first_spsext); +} + +// TODO: after reading the sample data check the md5 to ensure that samples are correct +libmd5::MD5 g_md5; + /* AAC encoding of a 234.375 Hz stereo tone */ -u8 aacDecoderSpecificInfo[] = { -0x11, 0x80, 0x08, 0xc4, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, -0x00, 0x00 -}; -u8 aacAccessUnit[] = { -0x21, 0x09, 0x49, 0x00, 0x00, 0x00, 0x00, 0x29, 0xc0, 0x56, -0x10, 0xf8, 0xc3, 0x8e, 0x9f, 0x84, 0x3b, 0xe0, 0x7c, 0xc3, -0x80, 0x00, 0x00, 0x00, 0x00 -}; -u32 frameCount = 1; -u32 samplesizefieldsize = 32; -u32 samplesperchunk = 24; +u8 aacDecoderSpecificInfo[] = {0x11, 0x80, 0x08, 0xc4, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x00, 0x00}; +u8 aacAccessUnit[] = {0x21, 0x09, 0x49, 0x00, 0x00, 0x00, 0x00, 0x29, 0xc0, 0x56, 0x10, 0xf8, 0xc3, + 0x8e, 0x9f, 0x84, 0x3b, 0xe0, 0x7c, 0xc3, 0x80, 0x00, 0x00, 0x00, 0x00}; + +u8 VPS[] = {0x40, 0x01, 0x0C, 0x01, 0xFF, 0xFF, 0x04, 0x08, 0x00, 0x00, 0x03, 0x00, + 0x9F, 0xA8, 0x00, 0x00, 0x03, 0x00, 0x00, 0x1E, 0xBA, 0x02, 0x40}; + +u8 SPS[] = {0x42, 0x01, 0x01, 0x04, 0x08, 0x00, 0x00, 0x03, 0x00, 0x9F, 0xA8, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x1E, 0xA0, 0x20, 0x83, 0x16, 0x5B, 0xAB, 0x93, 0x2B, 0x9A, + 0x02, 0x00, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x32, 0x10}; + +u8 PPS[] = {0x44, 0x01, 0xC1, 0x73, 0xC0, 0x89}; + +u8 auRed[] = {0x00, 0x00, 0x00, 0x16, 0x28, 0x01, 0xAF, 0x78, 0xF7, 0x04, 0x03, 0xFF, 0xDB, + 0xA3, 0xFF, 0xED, 0x27, 0xD2, 0xF6, 0xC3, 0x94, 0x40, 0x83, 0xC0, 0x00, 0x78}; + +u8 auBlue[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3F, + 0x9C, 0x43, 0xFF, 0xFA, 0x87, 0x32, 0xAF, 0xFC, 0x5D, 0xFF, + 0xFF, 0xAE, 0x1D, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; +u8 auGreen[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3F, + 0x9C, 0x43, 0xFF, 0xF5, 0x9F, 0x1F, 0xFF, 0xD8, 0x3B, 0xFF, + 0xFD, 0xF0, 0xF5, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; -MP4Err addMySamples( MP4Track theTrack, MP4Media theMedia, u32 do_init ); -MP4Err getDecoderSpecificInfo( MP4Handle sampleH ); -MP4Err getNextAudioFrame( MP4Handle sampleH ); +u8 auYellow[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xA0, 0x3F, + 0x9C, 0x43, 0x3C, 0xFA, 0x51, 0x1D, 0xFF, 0xFC, 0x5D, 0xFE, + 0xCB, 0xAE, 0x1D, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; -TEST_CASE( "Fragment creation" ) +u8 auWhite[] = {0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, + 0xE7, 0x9F, 0x6C, 0x07, 0x79, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87}; + +u8 auBlack[] = {0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, + 0xFF, 0xFF, 0x72, 0xCA, 0x19, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87}; + +u32 frameCount = 1; +u32 samplesizefieldsize = 32; +u32 samplesperchunk = 24; + +MP4Err addMySamples(MP4Track theTrack, MP4Media theMedia, u32 do_init); +MP4Err getDecoderSpecificInfo(MP4Handle sampleH); +MP4Err getNextAudioFrame(MP4Handle sampleH); + +TEST_CASE("Fragment creation") { MP4Err err; MP4Movie moov; @@ -62,75 +105,73 @@ TEST_CASE( "Fragment creation" ) u32 frameCounter; MP4NewHandle(1, &rap_desc); /* Allocate one byte for rap */ - err = MP4NoErr; + err = MP4NoErr; initialObjectDescriptorID = 1; - OD_profileAndLevel = 0xff; /* none required */ - scene_profileAndLevel = 0xff; /* none required */ - audio_profileAndLevel = 0x01; /* main profile L1 */ - visual_profileAndLevel = 0xff; /* none required */ - graphics_profileAndLevel = 0xff; /* none required */ - timeScale = 48000; /* sampling frequency */ - err = MP4NewMovie( &moov, - initialObjectDescriptorID, - OD_profileAndLevel, - scene_profileAndLevel, - audio_profileAndLevel, - visual_profileAndLevel, - graphics_profileAndLevel ); - CHECK( err == MP4NoErr ); - - err = ISOSetMovieTimeScale( moov, 48000 ); - CHECK( err == MP4NoErr ); - - err = MP4NewMovieTrack( moov, MP4NewTrackIsAudio, &trak ); - CHECK( err == MP4NoErr ); - - if (initialObjectDescriptorID != 0) { - err = MP4AddTrackToMovieIOD( trak ); - CHECK( err == MP4NoErr ); + OD_profileAndLevel = 0xff; /* none required */ + scene_profileAndLevel = 0xff; /* none required */ + audio_profileAndLevel = 0x01; /* main profile L1 */ + visual_profileAndLevel = 0xff; /* none required */ + graphics_profileAndLevel = 0xff; /* none required */ + timeScale = 48000; /* sampling frequency */ + err = MP4NewMovie(&moov, initialObjectDescriptorID, OD_profileAndLevel, scene_profileAndLevel, + audio_profileAndLevel, visual_profileAndLevel, graphics_profileAndLevel); + CHECK(err == MP4NoErr); + + err = ISOSetMovieTimeScale(moov, 48000); + CHECK(err == MP4NoErr); + + err = MP4NewMovieTrack(moov, MP4NewTrackIsAudio, &trak); + CHECK(err == MP4NoErr); + + if(initialObjectDescriptorID != 0) + { + err = MP4AddTrackToMovieIOD(trak); + CHECK(err == MP4NoErr); } - - err = MP4NewTrackMedia( trak, &media, MP4AudioHandlerType, timeScale, NULL ); - CHECK( err == MP4NoErr ); - err = ISOSetSampleSizeField ( media, samplesizefieldsize ); - CHECK( err == MP4NoErr ); - err = MP4BeginMediaEdits( media ); - CHECK( err == MP4NoErr ); - - err = ISOSetTrackFragmentDefaults( trak, 1024, sizeof(aacAccessUnit), 1, 0 ); - CHECK( err == MP4NoErr ); - - err = addMySamples( trak, media, 1 ); - - err = MP4EndMediaEdits( media ); - CHECK( err == MP4NoErr ); - - err = MP4GetMediaDuration( media, &mediaDuration ); - CHECK( err == MP4NoErr ); - - err = MP4InsertMediaIntoTrack( trak, 0, 0, mediaDuration, 1 ); - CHECK( err == MP4NoErr ); - - err = ISOStartMovieFragment( moov ); - CHECK( err == MP4NoErr ); + + err = MP4NewTrackMedia(trak, &media, MP4AudioHandlerType, timeScale, NULL); + CHECK(err == MP4NoErr); + err = ISOSetSampleSizeField(media, samplesizefieldsize); + CHECK(err == MP4NoErr); + err = MP4BeginMediaEdits(media); + CHECK(err == MP4NoErr); + + err = ISOSetTrackFragmentDefaults(trak, 1024, sizeof(aacAccessUnit), 1, 0); + CHECK(err == MP4NoErr); + + err = addMySamples(trak, media, 1); + + err = MP4EndMediaEdits(media); + CHECK(err == MP4NoErr); + + err = MP4GetMediaDuration(media, &mediaDuration); + CHECK(err == MP4NoErr); + + err = MP4InsertMediaIntoTrack(trak, 0, 0, mediaDuration, 1); + CHECK(err == MP4NoErr); + + err = ISOStartMovieFragment(moov); + CHECK(err == MP4NoErr); frameCount = 1; - err = addMySamples( trak, media, 0 ); - CHECK( err == MP4NoErr ); + err = addMySamples(trak, media, 0); + CHECK(err == MP4NoErr); ISOAddGroupDescription(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc, &rap_desc_index); - for (frameCounter = 1; frameCounter < samplesperchunk; frameCounter++) { + for(frameCounter = 1; frameCounter < samplesperchunk; frameCounter++) + { /* Mark RAP frames (CRA/BLA/IDR/IRAP) to the group */ - if (frameCounter % 4 == 0) { - ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc_index, frameCounter-1, 1); + if(frameCounter % 4 == 0) + { + ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc_index, + frameCounter - 1, 1); } } - err = MP4WriteMovieToFile( moov, "test_fragments.mp4" ); - CHECK( err == MP4NoErr ); + err = MP4WriteMovieToFile(moov, "test_fragments.mp4"); + CHECK(err == MP4NoErr); } - -MP4Err addMySamples( MP4Track trak, MP4Media media, u32 do_init ) +MP4Err addMySamples(MP4Track trak, MP4Media media, u32 do_init) { MP4Err err; MP4Handle sampleEntryH; @@ -143,118 +184,138 @@ MP4Err addMySamples( MP4Track trak, MP4Media media, u32 do_init ) u32 decoderBufferSize; u32 maxBitrate; u32 avgBitrate; - u32 done = 0; + u32 done = 0; u32 fileoffset = 0; u32 i; MP4Handle pad_bits, depsH; - + err = MP4NoErr; - if (do_init) + if(do_init) { - err = MP4SetMediaLanguage( media, "und" ); if (err) goto bail; - - objectTypeIndication = 0x40; /* mpeg-4 audio */ - streamType = 0x05; /* audio stream */ - decoderBufferSize = 2*6144; /* stereo */ - maxBitrate = 128000; - avgBitrate = 128000; - err = MP4NewHandle( 0, &decoderSpecificInfoH ); if (err) goto bail; - err = getDecoderSpecificInfo( decoderSpecificInfoH ); if (err) goto bail; - - err = MP4NewHandle( 0, &sampleEntryH ); if (err) goto bail; - err = MP4NewSampleDescription( trak, sampleEntryH, - 1, - objectTypeIndication, - streamType, - decoderBufferSize, - maxBitrate, - avgBitrate, - decoderSpecificInfoH ); if (err) goto bail; - } else sampleEntryH = NULL; - - err = MP4NewHandle( samplesperchunk * sizeof(u32), &sampleDurationH ); if (err) goto bail; - err = MP4NewHandle( 0, &sampleDataH ); if (err) goto bail; - err = MP4NewHandle( samplesperchunk * sizeof(u32), &sampleSizeH ); if (err) goto bail; - err = MP4NewHandle( 1, &pad_bits ); if (err) goto bail; - err = MP4NewHandle( samplesperchunk, &depsH ); if (err) goto bail; - *(( u8* )(*pad_bits)) = 0; - for (i=0; i 0) { + if(frames > 0) + { err = MP4SetHandleOffset(sampleDataH, 0); - err = MP4AddMediaSamples( media, sampleDataH, frames, sampleDurationH, - sampleSizeH, sampleEntryH, NULL, NULL ); if (err) goto bail; - - if ( sampleEntryH ) + err = MP4AddMediaSamples(media, sampleDataH, frames, sampleDurationH, sampleSizeH, + sampleEntryH, NULL, NULL); + if(err) goto bail; + + if(sampleEntryH) { - err = MP4DisposeHandle( sampleEntryH ); if (err) goto bail; + err = MP4DisposeHandle(sampleEntryH); + if(err) goto bail; sampleEntryH = NULL; } - } + } } bail: return err; } -MP4Err getDecoderSpecificInfo( MP4Handle decoderSpecificInfoH ) +MP4Err getDecoderSpecificInfo(MP4Handle decoderSpecificInfoH) { MP4Err err; u8 *p; u32 i, frameLength; - + err = MP4NoErr; - if ((frameLength = sizeof(aacDecoderSpecificInfo)) >= 128) { - err = MP4BadParamErr; goto bail; + if((frameLength = sizeof(aacDecoderSpecificInfo)) >= 128) + { + err = MP4BadParamErr; + goto bail; } - err = MP4SetHandleSize( decoderSpecificInfoH, frameLength+2 ); if (err) goto bail; - p = (u8*) *decoderSpecificInfoH; - *p++ = 0x05; /* DecSpecificInfoTag, 14496-1, Sec 8.2.2.2, Table 1*/ + err = MP4SetHandleSize(decoderSpecificInfoH, frameLength + 2); + if(err) goto bail; + p = (u8 *)*decoderSpecificInfoH; + *p++ = 0x05; /* DecSpecificInfoTag, 14496-1, Sec 8.2.2.2, Table 1*/ *p++ = frameLength; /* sizeOfInstance, 14496-1, Sec 12.3.3 */ - for (i=0; i 48 ) /* one second of sine wave signal */ + if(frameCount++ > 48) /* one second of sine wave signal */ return MP4EOF; frameLength = sizeof(aacAccessUnit); - err = MP4SetHandleSize( sampleH, frameLength ); if (err) goto bail; - p = (u8*) *sampleH; - for (i=0; i +#include +#include + +TEST_CASE("Check Metadata functions") +{ + SECTION("Check Properties") + { + ISOErr err; + ISOMovie moov; + ISOTrack trak; + ISOMedia media; + ISOMeta metaFile, metaMovie, metaTrack; + + MP4NewMovie(&moov, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff); + ISONewMovieTrack(moov, MP4NewTrackIsVisual, &trak); + MP4AddTrackToMovieIOD(trak); + ISONewTrackMedia(trak, &media, ISOVisualHandlerType, 90000, NULL); + + err = ISONewFileMeta( moov, 123, &metaFile); + CHECK(err == ISONoErr); + + err = ISONewMovieMeta( moov, 456, &metaMovie); + CHECK(err == ISONoErr); + + err = ISONewTrackMeta( trak, 789, &metaTrack); + CHECK(err == ISONoErr); + + u16 outRefIdx; + ISOHandle urlHandle, urnHandle; + ISONewHandle(0, &urlHandle); + ISONewHandle(0, &urnHandle); + err = ISOAddMetaDataReference(metaFile, &outRefIdx, urlHandle, urnHandle); + CHECK(err == ISONoErr); + CHECK(outRefIdx == 1); + + ISOMetaItem outItem; + err = ISOAddMetaItem(metaFile, &outItem, 0, 0); + CHECK(err == ISONoErr); + + // MP4GenericAtom foo; + MP4TrackAtomPtr trackPtr = (MP4TrackAtomPtr)trak; + MP4MediaAtomPtr mediaPtr = (MP4MediaAtom*)trackPtr->trackMedia; + + // put tkhd and mdhd as properties in the media item + err = ISOAddMetaItemProperty(outItem, (MP4GenericAtom *)trackPtr->trackHeader, 0); + CHECK(err == ISONoErr); + err = ISOAddMetaItemProperty(outItem, (MP4GenericAtom *)mediaPtr->mediaHeader, 0); + CHECK(err == ISONoErr); + + MP4GenericAtom *properties; + u32 propertiesFound; + err = ISOGetProperitesOfMetaItem(outItem, &properties, &propertiesFound); + CHECK(err == ISONoErr); + REQUIRE(2 == propertiesFound); + + MP4TrackAtomPtr prop1 = (MP4TrackAtomPtr)properties[0]; + MP4MediaAtomPtr prop2 = (MP4MediaAtomPtr)properties[1]; + CHECK(MP4_FOUR_CHAR_CODE('t', 'k', 'h', 'd') == prop1->type); + CHECK(MP4_FOUR_CHAR_CODE('m', 'd', 'h', 'd') == prop2->type); + + err = MP4WriteMovieToFile(moov, "temp.mp4"); + CHECK(err==ISONoErr); + } +} \ No newline at end of file From 5ca6d948a136dca5d097e14753d4e75633b9ed35 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Thu, 5 Nov 2020 17:46:04 +0100 Subject: [PATCH 15/55] sample2group mode2 in fragments stores both s2g variants. call a finalize function at the end to select the correct type. Another one will be removed. --- IsoLib/libisomediafile/src/SampleTableAtom.c | 19 ++- .../libisomediafile/src/TrackFragmentAtom.c | 145 +++++++++++++++++- IsoLib/playground/main.cpp | 11 +- 3 files changed, 164 insertions(+), 11 deletions(-) diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index 8a5c2fb..5ce0b14 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -606,7 +606,7 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, if(!theDesc) BAILWITHERROR(MP4BadParamErr); if(group_index > theDesc->groupCount) BAILWITHERROR(MP4BadParamErr); - if(enableCompactSamples) + if(enableCompactSamples==1) { MP4CompactSampletoGroupAtomPtr compactSampleGroup; err = MP4FindGroupAtom(self->compactSampletoGroupList, groupType, @@ -632,7 +632,7 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); if(err) goto bail; } - else + else if(enableCompactSamples==0) { err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); if(!theGroup) @@ -647,14 +647,27 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, err = MP4CreateSampletoGroupAtom(&theGroup); if(err) goto bail; theGroup->grouping_type = groupType; - err = addAtom(self, (MP4AtomPtr)theGroup); + // err = addAtom(self, (MP4AtomPtr)theGroup); if(err) goto bail; err = theGroup->addSamples(theGroup, stsz->sampleCount); if(err) goto bail; } err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); + err = addAtom(self, (MP4AtomPtr)theGroup); if(err) goto bail; } + else + { + /* automatic mode, use both normal and compressed and see what has the smaller size when done */ + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + MP4SampletoGroupAtomPtr normalSampleGroup; + + err = MP4FindGroupAtom(self->compactSampletoGroupList, groupType, (MP4AtomPtr*)&compactSampleGroup); + err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&normalSampleGroup); + + /* TODO: implement me*/ + normalSampleGroup->size; + } bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index 0f7dcf4..886a336 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -828,17 +828,92 @@ static MP4Err calculateDataEnd(MP4TrackFragmentAtomPtr self, u32 *outEnd) return err; } +static MP4Err finalizeSampleToGroup(MP4TrackFragmentAtomPtr self, u32 mode) { + u32 count1, count2; + s32 i, j; + MP4Err err; + + MP4SampletoGroupAtomPtr normalSampleGroup; + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + + err = MP4GetListEntryCount(self->groupList, &count1); + if(err) goto bail; + + for(i = 0; i < count1; i++) + { + MP4AtomPtr desc1, desc2; + err = MP4GetListEntry(self->groupList, i, (char **)&desc1); + if(err) goto bail; + + err = MP4GetListEntryCount(self->compactSampleGroupList, &count2); + if(err) goto bail; + for(j = 0; j < count2; j++) + { + err = MP4GetListEntry(self->compactSampleGroupList, j, (char **)&desc2); + if(err) goto bail; + + if(desc1 && desc2) + { + MP4SampletoGroupAtomPtr grp1 = (MP4SampletoGroupAtomPtr)desc1; + MP4CompactSampletoGroupAtomPtr grp2 = (MP4CompactSampletoGroupAtomPtr)desc2; + if(grp1->grouping_type == grp2->grouping_type) + { + switch (mode) + { + case 0: + /* we want to keep normal only */ + MP4DeleteListEntry(self->compactSampleGroupList, j); + j--; + count2--; + break; + case 1: + /* we want to keep compressed only */ + MP4DeleteListEntry(self->groupList, i); + i--; + count1--; + break; + default: + /* decide based on atom size */ + grp1->calculateSize((MP4AtomPtr)grp1); + grp2->calculateSize((MP4AtomPtr)grp2); + + if(grp1->size < grp2->size) + { + /* normal is smaller */ + MP4DeleteListEntry(self->compactSampleGroupList, j); + j--; + count2--; + } + else + { + /* compressed is smaller */ + MP4DeleteListEntry(self->groupList, i); + i--; + count1--; + } + break; + } + } + } + } + } + +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 compactSamples) { MP4Err err; - MP4SampletoGroupAtomPtr theGroup; MP4TrackFragmentAtomPtr self; u32 fragment_sample_count, atomListSize, i; self = (MP4TrackFragmentAtomPtr)s; - if(compactSamples) + if(compactSamples==1) { MP4CompactSampletoGroupAtomPtr compactSampleGroup; err = MP4FindGroupAtom(self->compactSampleGroupList, groupType, @@ -872,8 +947,9 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); if(err) goto bail; } - else + else if(compactSamples==0) { + MP4SampletoGroupAtomPtr theGroup; err = MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&theGroup); if(!theGroup) { @@ -902,6 +978,69 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); if(err) goto bail; } + else + { + /* automatic mode, use both normal and compressed and see what has the smaller size when done */ + MP4SampletoGroupAtomPtr normalSampleGroup; + MP4CompactSampletoGroupAtomPtr compactSampleGroup; + + MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&normalSampleGroup); + MP4FindGroupAtom(self->compactSampleGroupList, groupType, (MP4AtomPtr *)&compactSampleGroup); + + if(!normalSampleGroup) + { + err = MP4CreateSampletoGroupAtom(&normalSampleGroup); + if(err) goto bail; + normalSampleGroup->grouping_type = groupType; + err = addAtom(self, (MP4AtomPtr)normalSampleGroup); + if(err) goto bail; + + fragment_sample_count = 0; + err = MP4GetListEntryCount(self->atomList, &atomListSize); + if(err) goto bail; + for(i = 0; i < atomListSize; i++) + { + MP4TrackRunAtomPtr trun; + err = MP4GetListEntry(self->atomList, i, (char **)&trun); + if(err) goto bail; + if(trun) fragment_sample_count += trun->samplecount; + } + + if(fragment_sample_count > 0) + { + err = normalSampleGroup->addSamples(normalSampleGroup, fragment_sample_count); + } + } + + if(!compactSampleGroup) + { + err = MP4CreateCompactSampletoGroupAtom(&compactSampleGroup); + if(err) goto bail; + compactSampleGroup->fragmentLocalIndexPresent = 1; + compactSampleGroup->grouping_type = groupType; + err = addAtom(self, (MP4AtomPtr)compactSampleGroup); + if(err) goto bail; + + fragment_sample_count = 0; + err = MP4GetListEntryCount(self->atomList, &atomListSize); + if(err) goto bail; + for(i = 0; i < atomListSize; i++) + { + MP4TrackRunAtomPtr trun; + err = MP4GetListEntry(self->atomList, i, (char **)&trun); + if(err) goto bail; + if(trun) fragment_sample_count += trun->samplecount; + } + + if(fragment_sample_count > 0) + { + err = compactSampleGroup->addSamples(compactSampleGroup, fragment_sample_count); + } + } + err = normalSampleGroup->mapSamplestoGroup(normalSampleGroup, group_index, sample_index, count); + err = compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); + + } bail: TEST_RETURN(err); diff --git a/IsoLib/playground/main.cpp b/IsoLib/playground/main.cpp index 37e7baf..7a03b28 100644 --- a/IsoLib/playground/main.cpp +++ b/IsoLib/playground/main.cpp @@ -237,6 +237,7 @@ ISOErr addGroups(MP4Media media, std::string strPattern, u32 repeatPattern = 1) } } } + return err; } ISOErr createFile(std::string strFilename) { @@ -281,22 +282,22 @@ ISOErr createFile(std::string strFilename) { err = addSamples(media, "r", 0, sampleEntryH); if(err) return err; err = MP4EndMediaEdits(media); - // fragment 1 - ISOSetSamplestoGroupType(media, 0); + std::cout << "fragment 1" << std::endl; + ISOSetSamplestoGroupType(media,0); err = ISOStartMovieFragment( moov ); if(err) return err; err = addSamples(media, "rb", 3); if(err) return err; - // fragment 2 (compressed sample group) + std::cout << "fragment 2 (compressed sample group)" << std::endl; ISOSetSamplestoGroupType(media, 1); err = ISOStartMovieFragment( moov ); if(err) return err; err = addSamples(media, "gry", 2); if(err) return err; - // framgment 3 + std::cout << "fragment 3" << std::endl; ISOSetSamplestoGroupType(media, 0); err = ISOStartMovieFragment( moov ); if(err) return err; err = addSamples(media, "bgy", 2); if(err) return err; - // framgment 4 + std::cout << "fragment 4" << std::endl; err = ISOStartMovieFragment( moov ); if(err) return err; err = addSamples(media, "wk", 3); if(err) return err; From d5a65f7e926c4f0cde129969d4421578c2494254 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Mon, 9 Nov 2020 18:59:41 +0100 Subject: [PATCH 16/55] wip --- IsoLib/libisomediafile/src/MP4Atoms.h | 2 +- .../libisomediafile/src/MovieFragmentAtom.c | 3 ++- IsoLib/libisomediafile/src/SampleTableAtom.c | 19 +++++-------------- IsoLib/playground/main.cpp | 4 +++- 4 files changed, 11 insertions(+), 17 deletions(-) diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index 63f8960..ae71408 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -1357,7 +1357,7 @@ typedef struct MP4TrackFragmentAtom MP4LinkedList atomList; /* track runs */ MP4LinkedList groupDescriptionList; /* sample group description list */ MP4LinkedList groupList; /* sample to group maps */ - MP4LinkedList compactSampleGroupList; /* compact sample to group maps */ + MP4LinkedList compactSampleGroupList; /* TODO: consider using just one. compact sample to group maps */ MP4LinkedList saizList; MP4LinkedList saioList; } MP4TrackFragmentAtom, *MP4TrackFragmentAtomPtr; diff --git a/IsoLib/libisomediafile/src/MovieFragmentAtom.c b/IsoLib/libisomediafile/src/MovieFragmentAtom.c index 7c40c19..99e30e1 100644 --- a/IsoLib/libisomediafile/src/MovieFragmentAtom.c +++ b/IsoLib/libisomediafile/src/MovieFragmentAtom.c @@ -148,7 +148,8 @@ static MP4Err mergeFragments(struct MP4MovieFragmentAtom *self, MP4MovieAtomPtr err = mdia->getGroupDescription(mdia, theGroup->grouping_type, 1, desc); if(err != MP4NoErr) { - mdia->addGroupDescription(mdia, theGroup->grouping_type, desc, &descIdx); + mdia->addGroupDescription(mdia, theGroup->grouping_type, desc, &descIdx); /* TODO: map to correct indexes fomr memory */ + /* check the description as well, not only the type */ } } diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index 5ce0b14..16eab4e 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -606,10 +606,13 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, if(!theDesc) BAILWITHERROR(MP4BadParamErr); if(group_index > theDesc->groupCount) BAILWITHERROR(MP4BadParamErr); + // if self->gourp==0 && self->compactGroup==0 + // create one depending on the type + if(enableCompactSamples==1) { MP4CompactSampletoGroupAtomPtr compactSampleGroup; - err = MP4FindGroupAtom(self->compactSampletoGroupList, groupType, + err = MP4FindGroupAtom(self->compactSampletoGroupList, groupType, /* TODO: flip it over */ (MP4AtomPtr *)&compactSampleGroup); if(!compactSampleGroup) { @@ -632,7 +635,7 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); if(err) goto bail; } - else if(enableCompactSamples==0) + else { err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); if(!theGroup) @@ -656,18 +659,6 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, err = addAtom(self, (MP4AtomPtr)theGroup); if(err) goto bail; } - else - { - /* automatic mode, use both normal and compressed and see what has the smaller size when done */ - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - MP4SampletoGroupAtomPtr normalSampleGroup; - - err = MP4FindGroupAtom(self->compactSampletoGroupList, groupType, (MP4AtomPtr*)&compactSampleGroup); - err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&normalSampleGroup); - - /* TODO: implement me*/ - normalSampleGroup->size; - } bail: TEST_RETURN(err); diff --git a/IsoLib/playground/main.cpp b/IsoLib/playground/main.cpp index 7a03b28..1ef2e6c 100644 --- a/IsoLib/playground/main.cpp +++ b/IsoLib/playground/main.cpp @@ -179,6 +179,8 @@ ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, } } + // TODO: group color with different descriptions + err = ISODisposeHandle(sampleDataH); if(err) return err; err = ISODisposeHandle(durationsH); if(err) return err; err = ISODisposeHandle(sizesH); if(err) return err; @@ -358,6 +360,6 @@ int main() { } // ISOGetSampleGroupSamples() - // err = MP4WriteMovieToFile(moov, strFileDefrag.c_str()); + err = MP4WriteMovieToFile(moov, strFileDefrag.c_str()); return err; } From 2dd1b6e8f0cd6316e58cb21b53c2f1285980e338 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Tue, 10 Nov 2020 14:54:33 +0100 Subject: [PATCH 17/55] BugFix: allow multiple sample group description entries of the same type --- IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c index 791c64a..e02066c 100644 --- a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c +++ b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c @@ -55,7 +55,7 @@ static MP4Err addGroupDescription(struct MP4SampleGroupDescriptionAtom *self, sampleGroupEntry *p; u32 theSize; - if(self->groups != NULL) self->groups = calloc(1, sizeof(sampleGroupEntry)); + if(self->groups == NULL) self->groups = calloc(1, sizeof(sampleGroupEntry)); else self->groups = realloc(self->groups, (self->groupCount + 1) * sizeof(sampleGroupEntry)); TESTMALLOC(self->groups); From c44188de1de193aff807d533d2573bc7ae763042 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Tue, 10 Nov 2020 19:49:49 +0100 Subject: [PATCH 18/55] make sure that we can not add a groupdescription to traf if the same type already exists in stbl --- IsoLib/libisomediafile/src/MediaAtom.c | 25 +++++++++++++++++++++---- 1 file changed, 21 insertions(+), 4 deletions(-) diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index b877a01..4ff92c7 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -318,14 +318,31 @@ static MP4Err addGroupDescription(struct MP4MediaAtom *self, u32 groupType, MP4H u32 *index) { MP4Err err; - MP4MediaInformationAtomPtr minf; + MP4MediaInformationAtomPtr minf, true_minf; + MP4SampleTableAtomPtr stbl; + MP4SampleGroupDescriptionAtomPtr group_descr_in_stbl; err = MP4NoErr; minf = (MP4MediaInformationAtomPtr)self->information; /* this can be 'traf' if fragmented */ assert(minf); - assert(minf->addGroupDescription); - err = minf->addGroupDescription(minf, groupType, description, index); - if(err) goto bail; + true_minf = (self->true_minf == NULL) ? minf : (MP4MediaInformationAtomPtr)self->true_minf; + assert(true_minf); + stbl = (MP4SampleTableAtomPtr)true_minf->sampleTable; + assert(stbl); + err = MP4FindGroupAtom(stbl->groupDescriptionList, groupType, (MP4AtomPtr *)&group_descr_in_stbl); + + if(err==MP4NoErr && group_descr_in_stbl != NULL && minf != true_minf) + { + /* same group is already in stbl and its already serialized */ + BAILWITHERROR(MP4InvalidMediaErr); + } + else + { + /* new group type, we can add it to traf or stbl */ + assert(minf->addGroupDescription); + err = minf->addGroupDescription(minf, groupType, description, index); + if(err) goto bail; + } bail: TEST_RETURN(err); From fd3251c5b8b2f3cd70310405946fe620f9499148 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Wed, 11 Nov 2020 17:37:05 +0100 Subject: [PATCH 19/55] BugFix: merge sampleGroupDescription tables for fragmented files based on the group type and description entry --- IsoLib/libisomediafile/src/MP4Atoms.h | 4 ++ .../libisomediafile/src/MovieFragmentAtom.c | 21 +++---- .../src/SampleGroupDescriptionAtom.c | 31 +++++++++ IsoLib/libisomediafile/src/SampleTableAtom.c | 63 ++++++++++++++++++- 4 files changed, 106 insertions(+), 13 deletions(-) diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index ae71408..ce89e3d 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -728,6 +728,9 @@ typedef struct MP4SampleTableAtom MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut); + + MP4Err (*mergeSampleGroupDescriptions)(struct MP4SampleTableAtom *self, MP4AtomPtr otherSampleGroupDescr); + MP4AtomPtr TimeToSample; MP4AtomPtr CompositionOffset; MP4AtomPtr CompositionToDecode; @@ -1705,6 +1708,7 @@ typedef struct MP4SampleGroupDescriptionAtom MP4Handle theDescription, u32 *index); MP4Err (*getGroupDescription)(struct MP4SampleGroupDescriptionAtom *self, u32 index, MP4Handle theDescription); + MP4Err (*findGroupDescriptionIdx)(struct MP4SampleGroupDescriptionAtom *self, MP4Handle searchH, u32 *index); } MP4SampleGroupDescriptionAtom, *MP4SampleGroupDescriptionAtomPtr; diff --git a/IsoLib/libisomediafile/src/MovieFragmentAtom.c b/IsoLib/libisomediafile/src/MovieFragmentAtom.c index 99e30e1..716dc12 100644 --- a/IsoLib/libisomediafile/src/MovieFragmentAtom.c +++ b/IsoLib/libisomediafile/src/MovieFragmentAtom.c @@ -99,7 +99,9 @@ static MP4Err mergeFragments(struct MP4MovieFragmentAtom *self, MP4MovieAtomPtr ISOHandle desc; u32 n; u32 descIdx; - MP4SampleGroupDescriptionAtomPtr theGroup; + MP4SampleGroupDescriptionAtomPtr groupDescriptionTraf, groupDescriptionStbl; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; err = MP4GetListEntry(self->atomList, i, (char **)&traf); if(err) goto bail; @@ -137,20 +139,17 @@ static MP4Err mergeFragments(struct MP4MovieFragmentAtom *self, MP4MovieAtomPtr err = MP4GetMediaTrack((MP4Media)mdia, &trak); if(err) goto bail; - /* sample group descriptions */ + /* merge sample group descriptions */ + minf = (MP4MediaInformationAtomPtr)mdia->information; + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + ISONewHandle(0, &desc); MP4GetListEntryCount(traf->groupDescriptionList, &groupDescriptionCount); for(n = 0; n < groupDescriptionCount; n++) { - MP4GetListEntry(traf->groupDescriptionList, n, (char **)&theGroup); - - /* check if we already have this group in moov */ - err = mdia->getGroupDescription(mdia, theGroup->grouping_type, 1, desc); - if(err != MP4NoErr) - { - mdia->addGroupDescription(mdia, theGroup->grouping_type, desc, &descIdx); /* TODO: map to correct indexes fomr memory */ - /* check the description as well, not only the type */ - } + MP4GetListEntry(traf->groupDescriptionList, n, (char **)&groupDescriptionTraf); + assert(groupDescriptionTraf != NULL); + err = stbl->mergeSampleGroupDescriptions(stbl, (MP4AtomPtr)groupDescriptionTraf); } err = MP4GetMediaDuration((MP4Media)mdia, &initialMediaDuration); diff --git a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c index e02066c..f2c0cdb 100644 --- a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c +++ b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c @@ -99,6 +99,36 @@ static MP4Err getGroupDescription(struct MP4SampleGroupDescriptionAtom *self, u3 return err; } +static MP4Err findGroupDescriptionIdx(struct MP4SampleGroupDescriptionAtom *self, MP4Handle searchH, u32 *index) +{ + MP4Err err; + u32 size, i, temp; + sampleGroupEntry *p; + + err = MP4GetHandleSize(searchH, &size); if(err) goto bail; + if(index==NULL || self == NULL || size == 0) BAILWITHERROR(MP4BadParamErr); + + err = MP4NotFoundErr; + for(i=0; igroupCount; ++i) + { + p = &((self->groups)[i]); + if(p->groupSize != size) continue; + + temp = memcmp(p->groupDescription, *searchH, size); + if(temp==0) + { + *index = i+1; + err = MP4NoErr; + break; + } + } + +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err serialize(struct MP4Atom *s, char *buffer) { MP4Err err; @@ -252,6 +282,7 @@ MP4Err MP4CreateSampleGroupDescriptionAtom(MP4SampleGroupDescriptionAtomPtr *out self->serialize = serialize; self->addGroupDescription = addGroupDescription; self->getGroupDescription = getGroupDescription; + self->findGroupDescriptionIdx = findGroupDescriptionIdx; self->default_length = 0; self->groupCount = 0; self->groups = NULL; diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index 16eab4e..70f0591 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -595,6 +595,64 @@ static MP4Err getGroupDescription(struct MP4SampleTableAtom *self, u32 theType, return err; } +static MP4Err mergeSampleGroupDescriptions(struct MP4SampleTableAtom *self, MP4AtomPtr otherSampleGroupDescr) +{ + MP4Err err, errTemp; + MP4SampleGroupDescriptionAtomPtr stblGroup; + MP4SampleGroupDescriptionAtomPtr other; + u32 idx, dummy; + MP4Handle descrH; + + if(otherSampleGroupDescr==NULL) BAILWITHERROR(MP4BadParamErr); + + err = errTemp = MP4NoErr; + other = (MP4SampleGroupDescriptionAtomPtr)otherSampleGroupDescr; + idx = 1; + + err = MP4FindGroupAtom(self->groupDescriptionList, other->grouping_type, (MP4AtomPtr *)&stblGroup); + + if(err == MP4NoErr && stblGroup != NULL) + { + /* group description of the same type is already present in stbl, add only entries which are not yet present */ + while(errTemp==MP4NoErr) + { + MP4NewHandle(0, &descrH); + errTemp = other->getGroupDescription(other, idx++, descrH); + if(errTemp == MP4NoErr) + { + err = stblGroup->findGroupDescriptionIdx(stblGroup, descrH, &dummy); + if(err == MP4NotFoundErr) err = addGroupDescription(self, other->grouping_type, descrH, &dummy); + } + MP4DisposeHandle(descrH); + } + } + else + { + /* no such group description, iterate over all entries and add them */ + while(errTemp==MP4NoErr) + { + MP4NewHandle(0, &descrH); + errTemp = other->getGroupDescription(other, idx++, descrH); + if(errTemp == MP4NoErr) err = addGroupDescription(self, other->grouping_type, descrH, &dummy); + MP4DisposeHandle(descrH); + } + + /* check if we already have this group in moov */ + // err = mdia->getGroupDescription(mdia, groupDescriptionTraf->grouping_type, 1, desc); + // if(err != MP4NoErr) + // { + // mdia->addGroupDescription(mdia, groupDescriptionTraf->grouping_type, desc, &descIdx); /* TODO: map to correct indexes from memory */ + // /* check the description as well, not only the type */ + // } + } + + +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 enableCompactSamples) { @@ -650,13 +708,12 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, err = MP4CreateSampletoGroupAtom(&theGroup); if(err) goto bail; theGroup->grouping_type = groupType; - // err = addAtom(self, (MP4AtomPtr)theGroup); + err = addAtom(self, (MP4AtomPtr)theGroup); if(err) goto bail; err = theGroup->addSamples(theGroup, stsz->sampleCount); if(err) goto bail; } err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); - err = addAtom(self, (MP4AtomPtr)theGroup); if(err) goto bail; } @@ -890,6 +947,8 @@ MP4Err MP4CreateSampleTableAtom(MP4SampleTableAtomPtr *outAtom) self->setSampleDependency = setSampleDependency; self->getSampleDependency = getSampleDependency; + self->mergeSampleGroupDescriptions = mergeSampleGroupDescriptions; + err = MP4MakeLinkedList(&(self->groupDescriptionList)); if(err) goto bail; err = MP4MakeLinkedList(&(self->sampletoGroupList)); From b0db3f68b484b63647a756de141f06348e83e72f Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Fri, 13 Nov 2020 14:17:49 +0100 Subject: [PATCH 20/55] make sure not to add multiple entries to sgpd with the same payload and type. allow adding sgpd in fragments even if the same type is already in stbl --- IsoLib/libisomediafile/src/MediaAtom.c | 25 +-- .../src/SampleGroupDescriptionAtom.c | 6 +- IsoLib/playground/main.cpp | 144 +++++++++--------- 3 files changed, 80 insertions(+), 95 deletions(-) diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index 4ff92c7..9d33ab6 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -319,30 +319,15 @@ static MP4Err addGroupDescription(struct MP4MediaAtom *self, u32 groupType, MP4H { MP4Err err; MP4MediaInformationAtomPtr minf, true_minf; - MP4SampleTableAtomPtr stbl; - MP4SampleGroupDescriptionAtomPtr group_descr_in_stbl; err = MP4NoErr; minf = (MP4MediaInformationAtomPtr)self->information; /* this can be 'traf' if fragmented */ assert(minf); - true_minf = (self->true_minf == NULL) ? minf : (MP4MediaInformationAtomPtr)self->true_minf; - assert(true_minf); - stbl = (MP4SampleTableAtomPtr)true_minf->sampleTable; - assert(stbl); - err = MP4FindGroupAtom(stbl->groupDescriptionList, groupType, (MP4AtomPtr *)&group_descr_in_stbl); - - if(err==MP4NoErr && group_descr_in_stbl != NULL && minf != true_minf) - { - /* same group is already in stbl and its already serialized */ - BAILWITHERROR(MP4InvalidMediaErr); - } - else - { - /* new group type, we can add it to traf or stbl */ - assert(minf->addGroupDescription); - err = minf->addGroupDescription(minf, groupType, description, index); - if(err) goto bail; - } + assert(minf->addGroupDescription); + + err = minf->addGroupDescription(minf, groupType, description, index); + if(err) goto bail; + bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c index f2c0cdb..bcd76fc 100644 --- a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c +++ b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c @@ -53,7 +53,11 @@ static MP4Err addGroupDescription(struct MP4SampleGroupDescriptionAtom *self, { MP4Err err; sampleGroupEntry *p; - u32 theSize; + u32 theSize, foundIdx; + + /* make sure we don't add duplicate descriptions */ + err = self->findGroupDescriptionIdx(self, theDescription, &foundIdx); + if(err != MP4NotFoundErr) BAILWITHERROR(MP4BadParamErr); if(self->groups == NULL) self->groups = calloc(1, sizeof(sampleGroupEntry)); else diff --git a/IsoLib/playground/main.cpp b/IsoLib/playground/main.cpp index 1ef2e6c..099e9b7 100644 --- a/IsoLib/playground/main.cpp +++ b/IsoLib/playground/main.cpp @@ -70,6 +70,14 @@ const u32 FOURCC_BLU = MP4_FOUR_CHAR_CODE('b', 'l', 'u', 'e'); const u32 FOURCC_GRN = MP4_FOUR_CHAR_CODE('g', 'r', 'e', 'n'); const u32 FOURCC_YLW = MP4_FOUR_CHAR_CODE('y', 'e', 'l', 'w'); +const u32 FOURCC_COLOR = MP4_FOUR_CHAR_CODE('c', 'o', 'l', 'r'); +const u32 FOURCC_TEST = MP4_FOUR_CHAR_CODE('t', 'e', 's', 't'); + +u32 groupIdRed = 0; +u32 groupIdBlue = 0; +u32 groupIdGreen = 0; +u32 groupIdYellow = 0; + ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, ISOHandle sampleEntryH = 0) { ISOErr err; u32 sampleCount = 0; @@ -133,62 +141,38 @@ ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, err = ISOAddMediaSamples(media, sampleDataH, bufferSizesPattern.size()*repeatPattern, durationsH, sizesH, sampleEntryH, 0, 0); if(err) return err; - // add sample groups - std::cout << "fullPattern = " << fullPattern << std::endl; - if(repeatPattern>0) { - size_t nr = std::count(fullPattern.begin(), fullPattern.end(), 'r'); - size_t nb = std::count(fullPattern.begin(), fullPattern.end(), 'b'); - size_t ng = std::count(fullPattern.begin(), fullPattern.end(), 'g'); - size_t ny = std::count(fullPattern.begin(), fullPattern.end(), 'y'); - std::cout << "r = " << nr << std::endl; - std::cout << "b = " << nb << std::endl; - std::cout << "g = " << ng << std::endl; - std::cout << "y = " << ny << std::endl; - - u32 descrIdxR, descrIdxB, descrIdxG, descrIdxY; - ISOHandle descrR; - ISONewHandle(0, &descrR); - if(nr) err = ISOAddGroupDescription(media, FOURCC_RED, descrR, &descrIdxR); if(err) return err; - if(nb) err = ISOAddGroupDescription(media, FOURCC_BLU, descrR, &descrIdxB); if(err) return err; - if(ng) err = ISOAddGroupDescription(media, FOURCC_GRN, descrR, &descrIdxG); if(err) return err; - if(ny) err = ISOAddGroupDescription(media, FOURCC_YLW, descrR, &descrIdxY); if(err) return err; - - for(u32 n=0; nmapSamplestoGroup); err = minf->mapSamplestoGroup(minf, groupType, group_index, sample_index, count, - self->enableCompactSamples); + self->sampleToGroupType); if(err) goto bail; bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/MediaInformationAtom.c b/IsoLib/libisomediafile/src/MediaInformationAtom.c index 4d75009..f9aeb3a 100644 --- a/IsoLib/libisomediafile/src/MediaInformationAtom.c +++ b/IsoLib/libisomediafile/src/MediaInformationAtom.c @@ -564,7 +564,7 @@ static MP4Err getGroupDescription(struct MP4MediaInformationAtom *self, u32 grou static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, - u32 enableCompactSamples) + u32 sampleToGroupType) { MP4Err err; MP4SampleTableAtomPtr stbl; @@ -575,7 +575,7 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *self, u32 groupT assert(stbl); assert(stbl->mapSamplestoGroup); err = stbl->mapSamplestoGroup(stbl, groupType, group_index, sample_index, count, - enableCompactSamples); + sampleToGroupType); if(err) goto bail; bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index 70f0591..4bbfab0 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -41,8 +41,6 @@ static void destroy(MP4AtomPtr s) if(err) goto bail; err = MP4DeleteLinkedList(self->sampletoGroupList); if(err) goto bail; - err = MP4DeleteLinkedList(self->compactSampletoGroupList); - if(err) goto bail; err = MP4DeleteLinkedList(self->SampleAuxiliaryInformationSizes); if(err) goto bail; err = MP4DeleteLinkedList(self->SampleAuxiliaryInformationOffsets); @@ -71,23 +69,11 @@ MP4Err MP4FindGroupAtom(MP4LinkedList theList, u32 type, MP4AtomPtr *theAtom) if(err) goto bail; if(desc) { - if(desc->type == MP4CompactSampletoGroupAtomType) - { - MP4CompactSampletoGroupAtomPtr grp = (MP4CompactSampletoGroupAtomPtr)desc; - if(grp->grouping_type == type) - { - *theAtom = desc; - return err; - } - } - else + MP4SampletoGroupAtomPtr grp = (MP4SampletoGroupAtomPtr)desc; + if(grp->grouping_type == type) { - MP4SampletoGroupAtomPtr grp = (MP4SampletoGroupAtomPtr)desc; - if(grp->grouping_type == type) - { - *theAtom = desc; - return err; - } + *theAtom = desc; + return err; } } } @@ -145,11 +131,8 @@ static MP4Err addAtom(MP4SampleTableAtomPtr self, MP4AtomPtr atom) break; case MP4SampletoGroupAtomType: - err = MP4AddListEntry((void *)atom, self->sampletoGroupList); - break; - case MP4CompactSampletoGroupAtomType: - err = MP4AddListEntry((void *)atom, self->compactSampletoGroupList); + err = MP4AddListEntry((void *)atom, self->sampletoGroupList); break; } bail: @@ -431,20 +414,7 @@ static MP4Err addSamples(struct MP4SampleTableAtom *self, u32 sampleCount, u64 s if(err) goto bail; } } - err = MP4GetListEntryCount(self->compactSampletoGroupList, &groupCount); - if(err) goto bail; - for(i = 0; i < groupCount; i++) - { - MP4CompactSampletoGroupAtomPtr desc; - err = MP4GetListEntry(self->compactSampletoGroupList, i, (char **)&desc); - if(err) goto bail; - if(desc) - { - err = desc->addSamples(desc, sampleCount); - if(err) goto bail; - } - } - + if(self->SampleDependency) { MP4SampleDependencyAtomPtr sdtp; @@ -654,7 +624,7 @@ static MP4Err mergeSampleGroupDescriptions(struct MP4SampleTableAtom *self, MP4A } static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, - s32 sample_index, u32 count, u32 enableCompactSamples) + s32 sample_index, u32 count, u32 sampleToGroupType) { MP4Err err; MP4SampletoGroupAtomPtr theGroup; @@ -664,59 +634,81 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, if(!theDesc) BAILWITHERROR(MP4BadParamErr); if(group_index > theDesc->groupCount) BAILWITHERROR(MP4BadParamErr); - // if self->gourp==0 && self->compactGroup==0 - // create one depending on the type - - if(enableCompactSamples==1) + + /* create one if the box doesn't extist */ + err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); + if(!theGroup) { - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - err = MP4FindGroupAtom(self->compactSampletoGroupList, groupType, /* TODO: flip it over */ - (MP4AtomPtr *)&compactSampleGroup); - if(!compactSampleGroup) + MP4SampleSizeAtomPtr stsz; + + stsz = (MP4SampleSizeAtomPtr)self->SampleSize; + if(stsz == NULL) { - MP4SampleSizeAtomPtr stsz; - stsz = (MP4SampleSizeAtomPtr)self->SampleSize; - if(stsz == NULL) - { - BAILWITHERROR(MP4InvalidMediaErr); - } - err = MP4CreateCompactSampletoGroupAtom(&compactSampleGroup); - if(err) goto bail; - compactSampleGroup->grouping_type = groupType; - compactSampleGroup->fragmentLocalIndexPresent = 0; - err = addAtom(self, (MP4AtomPtr)compactSampleGroup); - if(err) goto bail; - err = compactSampleGroup->addSamples(compactSampleGroup, stsz->sampleCount); - if(err) goto bail; + BAILWITHERROR(MP4InvalidMediaErr); } - err = - compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); + err = MP4CreateSampletoGroupAtom(&theGroup, sampleToGroupType); if(err) goto bail; - } - else - { - err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); - if(!theGroup) - { - MP4SampleSizeAtomPtr stsz; - - stsz = (MP4SampleSizeAtomPtr)self->SampleSize; - if(stsz == NULL) - { - BAILWITHERROR(MP4InvalidMediaErr); - } - err = MP4CreateSampletoGroupAtom(&theGroup); - if(err) goto bail; - theGroup->grouping_type = groupType; - err = addAtom(self, (MP4AtomPtr)theGroup); - if(err) goto bail; - err = theGroup->addSamples(theGroup, stsz->sampleCount); - if(err) goto bail; - } - err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); + theGroup->grouping_type = groupType; + theGroup->fragmentLocalIndexPresent = 0; + err = addAtom(self, (MP4AtomPtr)theGroup); + if(err) goto bail; + err = theGroup->addSamples(theGroup, stsz->sampleCount); if(err) goto bail; } + err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); + if(err) goto bail; + + // if(sampleToGroupType==1) + // { + // MP4CompactSampletoGroupAtomPtr compactSampleGroup; + // err = MP4FindGroupAtom(self->compactSampletoGroupList, groupType, /* TODO: flip it over */ + // (MP4AtomPtr *)&compactSampleGroup); + // if(!compactSampleGroup) + // { + // MP4SampleSizeAtomPtr stsz; + // stsz = (MP4SampleSizeAtomPtr)self->SampleSize; + // if(stsz == NULL) + // { + // BAILWITHERROR(MP4InvalidMediaErr); + // } + // err = MP4CreateCompactSampletoGroupAtom(&compactSampleGroup); + // if(err) goto bail; + // compactSampleGroup->grouping_type = groupType; + // compactSampleGroup->fragmentLocalIndexPresent = 0; + // err = addAtom(self, (MP4AtomPtr)compactSampleGroup); + // if(err) goto bail; + // err = compactSampleGroup->addSamples(compactSampleGroup, stsz->sampleCount); + // if(err) goto bail; + // } + // err = + // compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); + // if(err) goto bail; + // } + // else + // { + // err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); + // if(!theGroup) + // { + // MP4SampleSizeAtomPtr stsz; + + // stsz = (MP4SampleSizeAtomPtr)self->SampleSize; + // if(stsz == NULL) + // { + // BAILWITHERROR(MP4InvalidMediaErr); + // } + // err = MP4CreateSampletoGroupAtom(&theGroup); + // if(err) goto bail; + // theGroup->grouping_type = groupType; + // err = addAtom(self, (MP4AtomPtr)theGroup); + // if(err) goto bail; + // err = theGroup->addSamples(theGroup, stsz->sampleCount); + // if(err) goto bail; + // } + // err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); + // if(err) goto bail; + // } + bail: TEST_RETURN(err); @@ -728,28 +720,14 @@ static MP4Err getSampleGroupMap(struct MP4SampleTableAtom *self, u32 groupType, { MP4Err err; MP4SampletoGroupAtomPtr theGroup; - MP4CompactSampletoGroupAtomPtr compactSampleGroup; err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); if(theGroup) { err = theGroup->getSampleGroupMap(theGroup, sample_number, group_index); if(err) goto bail; - return err; - } - - err = MP4FindGroupAtom(self->compactSampletoGroupList, groupType, - (MP4AtomPtr *)&compactSampleGroup); - if(compactSampleGroup) - { - err = compactSampleGroup->getSampleGroupMap(compactSampleGroup, sample_number, group_index); - if(err) goto bail; - } - else - { - err = MP4BadParamErr; - goto bail; } + else BAILWITHERROR(MP4BadParamErr); bail: TEST_RETURN(err); @@ -953,8 +931,6 @@ MP4Err MP4CreateSampleTableAtom(MP4SampleTableAtomPtr *outAtom) if(err) goto bail; err = MP4MakeLinkedList(&(self->sampletoGroupList)); if(err) goto bail; - err = MP4MakeLinkedList(&(self->compactSampletoGroupList)); - if(err) goto bail; self->useSignedCompositionTimeOffsets = 0; self->getSampleAuxiliaryInformation = getSampleAuxiliaryInformation; diff --git a/IsoLib/libisomediafile/src/SampleToGroupAtom.c b/IsoLib/libisomediafile/src/SampleToGroupAtom.c index 432f002..18b15e2 100644 --- a/IsoLib/libisomediafile/src/SampleToGroupAtom.c +++ b/IsoLib/libisomediafile/src/SampleToGroupAtom.c @@ -27,6 +27,398 @@ derivative works. Copyright (c) 1999. #define allocation_size 8192 +enum +{ + kMaxPatternLength = 32, + kUpperNibblePresent = 0x8000 +}; + +/* PatternTracker is maintained as an array for each sample input. +patternStart at index k, represents the start index of the pattern which helped yield the most +efficient way to encode samples from [0, k] inclusive with patternLength, repeated sampleCount times +cumulativeMemoryCost at index k, represents the memory cost associated with most efficient way to +encode samples from [0, k] inclusive. Default considers each sample as a distinct non-pattern +prevEfficientIndex at index k, represents the end of the most efficient previous pattern/ +non-pattern before k which helped yield the cumulativeMemoryCost at index k. nextEfficientIndex is +populated after back-tracking prevEfficientIndex to easily create compact sample groups +*/ +typedef struct +{ + u32 patternStart; + u32 patternLength; + u32 sampleCount; + s32 cumulativeMemoryCost; + s32 prevEfficientIndex; + s32 nextEfficientIndex; +} PatternTracker; + +/* +Compacting Algorithm: +1. Run through sample group set: i=[0,n] + a. Expand the input samples + b. Initialize memory costs in tracker assuming each sample is a distinct non-pattern C[i] = +(i*indexFieldSize) +2. Run through sample group set: i=[0,n] + a. Update memory cost considering sample i is a distinct non-pattern C[i] = min(C[i] , +C[i-1]+ indexFieldSize) b. For pattern lengths, p=[1, 32] i. Consider patterns ending at i, from +[start=i-p, i] in the Search buffer. ii. Extend right end from [i+1, n] in the look ahead buffer + 1. As long as the pattern repeats, keep extending right end and +update memory cost C[end] = min(C[end] , C[start-1] + p*indexFieldSize + 2. If C[end] got modified, a more efficient pattern was found, +maintain previousEfficientIndex = start-1 for backtracking. +3. Tracker[n-1] represents most efficienct way to encode samples [0,n]. Run through tracker +backwards from last sample: i[n-1, 0]. a. Use previousEfficientIndex to populate nextEfficientIndex +to easily create compact sample groups b. Patterns with (pattern length == sample count == 1), are +combined and considered as non-pattern + +Algorithm can further be optimized by making memory cost consider patternLength and sampleCount +field sizes +*/ + +typedef struct +{ + u32 *groupIndex; + u32 sampleCount; + PatternTracker *patternTracker; + u8 groupIndexFieldSize; +} SampleGroupInfo; + +u8 GetFieldSize(u32 value, u8 localFragmentUsed) +{ + if(localFragmentUsed) + { + if(value < 8) + { + return 4; + } + else if(value < 128) + { + return 8; + } + else if(value < 32768) + { + return 16; + } + else + { + return 32; + } + } + else + { + if(value < 16) + { + return 4; + } + else if(value < 256) + { + return 8; + } + else if(value < 65536) + { + return 16; + } + else + { + return 32; + } + } +} + +u8 SetFieldSize(u32 fieldSize) +{ + assert(fieldSize == 4 || fieldSize == 8 || fieldSize == 16 || fieldSize == 32); + switch(fieldSize) + { + case 4: + return 0; + break; + case 8: + return 1; + break; + case 16: + return 2; + break; + case 32: + return 3; + break; + }; + return 0; +} + +void AppendDescriptionIndexToCompactGroup(CompressedGroupInfo *compressedGroup, u32 descIndex, + u32 groupIndex) +{ + assert(descIndex < compressedGroup->totalIndexDescriptionCount); + compressedGroup->indexDescriptionArray[descIndex] = groupIndex; +} + +void AppendNewPatternEntry(CompressedGroupInfo *compressedGroup, u32 index, u32 patternLength, + u32 sampleCount) +{ + assert(patternLength != 0); + assert(sampleCount != 0); + assert(index < compressedGroup->patternCount); + /*printf("\n New pattern: length %d sampleCount %d", patternLength, sampleCount); */ + + compressedGroup->patternEntries[index].patternLength = patternLength; + compressedGroup->patternEntries[index].sampleCount = sampleCount; + compressedGroup->totalSampleCount += sampleCount; +} + +void SetMemoryCostForPattern(SampleGroupInfo *sampleGroup, u32 patternLength, + u32 startPatternSampleIndex, u32 endPatternSampleIndex) +{ + u32 sampleCount = endPatternSampleIndex - startPatternSampleIndex + 1; + + assert(startPatternSampleIndex + patternLength <= endPatternSampleIndex); + + s32 memoryCost = + startPatternSampleIndex <= 0 + ? sampleGroup->patternTracker[0].cumulativeMemoryCost + : sampleGroup->patternTracker[startPatternSampleIndex - 1].cumulativeMemoryCost; + memoryCost += (patternLength * sampleGroup->groupIndexFieldSize); + + if(memoryCost < sampleGroup->patternTracker[endPatternSampleIndex].cumulativeMemoryCost) + { + PatternTracker patTrack; + patTrack.patternStart = startPatternSampleIndex; + patTrack.patternLength = patternLength; + patTrack.sampleCount = sampleCount; + patTrack.cumulativeMemoryCost = memoryCost; + patTrack.prevEfficientIndex = startPatternSampleIndex - 1; + + sampleGroup->patternTracker[endPatternSampleIndex] = patTrack; + /*printf("\n Pattern run of pattern length %d, sample count %d, starting @ %3d with memoryCost + * %d and prevMostEffIndex %d", patternLength, sampleCount, startPatternSampleIndex, + * patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex); */ + } +} + +void SetMemoryCostForNonPattern(SampleGroupInfo *sampleGroup, s32 sampleIndex) +{ + s32 memoryCost = + (sampleIndex < 1 ? sampleGroup->patternTracker[0].cumulativeMemoryCost + : sampleGroup->patternTracker[sampleIndex - 1].cumulativeMemoryCost) + + sampleGroup->groupIndexFieldSize; + + if(memoryCost < sampleGroup->patternTracker[sampleIndex].cumulativeMemoryCost) + { + PatternTracker patTrack; + patTrack.patternStart = sampleIndex; + patTrack.patternLength = 1; + patTrack.sampleCount = 1; + patTrack.cumulativeMemoryCost = memoryCost; + patTrack.prevEfficientIndex = sampleIndex - 1; + + sampleGroup->patternTracker[sampleIndex] = patTrack; + /*printf("\n Writing non-pattern with memoryCost %d and prevMostEffIndex %d ", + * patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex);*/ + } +} + +void CombineNonPatterns(SampleGroupInfo *sampleGroup, CompressedGroupInfo *compressedGroup) +{ + s32 prevIndex = sampleGroup->sampleCount - 1; + s32 nextIndex = sampleGroup->sampleCount; + PatternTracker *patternTracker = sampleGroup->patternTracker; + + /* Post-process output pattern tracker. Get Pattern Count, Populate the nextIndex to navigate + * easily*/ + while(prevIndex >= 0 && prevIndex < sampleGroup->sampleCount) + { + u32 consecutiveNonPatterns = 0; + s32 i = prevIndex; + while(i >= 0 && i < sampleGroup->sampleCount && (patternTracker[i].patternLength == 1) && + (patternTracker[i].sampleCount == 1)) + { + consecutiveNonPatterns++; + i = patternTracker[i].prevEfficientIndex; + } + if(consecutiveNonPatterns) + { + patternTracker[prevIndex].patternLength = consecutiveNonPatterns; + patternTracker[prevIndex].sampleCount = consecutiveNonPatterns; + patternTracker[prevIndex].patternStart -= (consecutiveNonPatterns - 1); + compressedGroup->totalIndexDescriptionCount += consecutiveNonPatterns; + patternTracker[prevIndex].prevEfficientIndex = i; + } + else + { + compressedGroup->totalIndexDescriptionCount += patternTracker[prevIndex].patternLength; + } + + patternTracker[prevIndex].nextEfficientIndex = nextIndex; + nextIndex = prevIndex; + prevIndex = patternTracker[prevIndex].prevEfficientIndex; + + compressedGroup->patternCount++; + } + compressedGroup->efficientStartIndex = nextIndex; +} + +void FindPatternsStartingAtIndex(SampleGroupInfo *sampleGroup, u32 sampleIndex) +{ + u32 p; + assert(sampleIndex < sampleGroup->sampleCount); + + /* Update memoryCost in case current sample is considered as a non-pattern*/ + SetMemoryCostForNonPattern(sampleGroup, sampleIndex); + + for(p = 1; p <= kMaxPatternLength; p++) + { + if(sampleIndex < p) break; + + if(sampleGroup->groupIndex[sampleIndex] == sampleGroup->groupIndex[sampleIndex - p]) + { + u32 startPatternSampleIndex = sampleIndex - p; + u32 i = sampleIndex; + while(i < sampleGroup->sampleCount && + sampleGroup->groupIndex[i] == sampleGroup->groupIndex[i - p]) + { + SetMemoryCostForPattern(sampleGroup, p, startPatternSampleIndex, i); + i++; + } + + /* Pattern ended at i - 1. + printf("\n %3d: pattern run ended", i-1); + break; */ + } + } +} + +void InitializeSampleGroupInput(MP4SampletoGroupAtomPtr self, SampleGroupInfo *sampleGroup) +{ + u32 i; + sampleGroup->groupIndex = self->group_index; + sampleGroup->sampleCount = self->sampleCount; + sampleGroup->groupIndexFieldSize = self->compressedGroup.indexFieldSize; + sampleGroup->patternTracker = + (PatternTracker *)malloc(sizeof(PatternTracker) * self->sampleCount); + + memset(sampleGroup->patternTracker, 0, sizeof(PatternTracker) * self->sampleCount); + + /* Expand sample group indices, get maximum field size to represent each group index*/ + u32 startValue = self->group_index[0]; + + for(i = 1; i < self->sampleCount; i++) + { + if(self->group_index[i - 1] == self->group_index[i]) + { + self->group_index[i - 1] = startValue; + } + else + { + startValue = self->group_index[i]; + } + } + self->group_index[self->sampleCount - 1] = startValue; + + /* Initialize efficiencies assuming each input sample is a distinct non-pattern*/ + PatternTracker patternTrackerEntry; + patternTrackerEntry.patternLength = patternTrackerEntry.sampleCount = 1; + + for(i = 0; i < self->sampleCount; i++) + { + patternTrackerEntry.patternStart = i; + patternTrackerEntry.prevEfficientIndex = i - 1; + patternTrackerEntry.cumulativeMemoryCost = (i + 1) * sampleGroup->groupIndexFieldSize; + sampleGroup->patternTracker[i] = patternTrackerEntry; + } +} + +void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) +{ + u32 j; + u32 patternIndex; + if(self->compressedGroup.isSampleGroupCompressed) return; + + SampleGroupInfo sampleGroup; + InitializeSampleGroupInput(self, &sampleGroup); + + CompressedGroupInfo *compressedGroup = &self->compressedGroup; + compressedGroup->patternLengthFieldSize = 4; + compressedGroup->sampleCountFieldSize = 4; + compressedGroup->indexFieldSize = sampleGroup.groupIndexFieldSize; + + /* Repeatedly process, find and update efficiencies at each sample index*/ + for(j = 0; j < self->sampleCount; j++) + { + FindPatternsStartingAtIndex(&sampleGroup, j); + } + + CombineNonPatterns(&sampleGroup, compressedGroup); + + if(compressedGroup->patternEntries == NULL) + { + compressedGroup->patternEntries = (MP4CompactSampleToGroupPatternEntryPtr)malloc( + sizeof(MP4CompactSampleToGroupPatternEntry) * compressedGroup->patternCount); + } + if(compressedGroup->indexDescriptionArray == NULL) + { + compressedGroup->indexDescriptionArray = + (u32 *)malloc(sizeof(u32) * compressedGroup->totalIndexDescriptionCount); + } + + /*printf("\n The pattern tracker details are"); + for(int i = 0; i < self->sampleCount; i++) + { + printf("\n Index %d Start: %d PL: %d SC: %d Eff: %d PrevIndex: %d NextIndex: %d ", i, + patternTracker[i].start, patternTracker[i].patternLength, patternTracker[i].sampleCount, + patternTracker[i].cumulativeMemoryCost, patternTracker[i].prevEfficientIndex, + patternTracker[i].nextEfficientIndex); + }*/ + + PatternTracker *patternTracker = sampleGroup.patternTracker; + u32 descIndex = 0; + u32 nextIndex = compressedGroup->efficientStartIndex; + for(patternIndex = 0; patternIndex < compressedGroup->patternCount; patternIndex++) + { + u32 patternLength = patternTracker[nextIndex].patternLength; + u8 fieldSize = GetFieldSize(patternLength, 0); + if(fieldSize > compressedGroup->patternLengthFieldSize) + compressedGroup->patternLengthFieldSize = fieldSize; + + u32 sampleCount = patternTracker[nextIndex].sampleCount; + fieldSize = GetFieldSize(sampleCount, 0); + if(fieldSize > compressedGroup->sampleCountFieldSize) + compressedGroup->sampleCountFieldSize = fieldSize; + + AppendNewPatternEntry(compressedGroup, patternIndex, patternLength, sampleCount); + + assert(patternTracker[nextIndex].patternStart >= 0 && + patternTracker[nextIndex].patternStart < self->sampleCount); + assert(patternTracker[nextIndex].patternStart + patternLength - 1 < self->sampleCount); + + for(j = 0; j < patternLength; j++) + { + u32 groupIndex = sampleGroup.groupIndex[patternTracker[nextIndex].patternStart + j]; + if(self->fragmentLocalIndexPresent) + { + groupIndex = groupIndex | (1 << (self->compressedGroup.indexFieldSize - 1)); + } + AppendDescriptionIndexToCompactGroup(compressedGroup, descIndex, groupIndex); + descIndex++; + } + nextIndex = patternTracker[nextIndex].nextEfficientIndex; + } + + /* In case only patternLength or sampleCount field size is 4, ensure pattern entry is always byte + * aligned*/ + if((compressedGroup->patternLengthFieldSize + compressedGroup->sampleCountFieldSize) % 8) + { + if(compressedGroup->patternLengthFieldSize == 4) compressedGroup->patternLengthFieldSize = 8; + else + compressedGroup->sampleCountFieldSize = 8; + } + + assert(descIndex == compressedGroup->totalIndexDescriptionCount); + self->compressedGroup.isSampleGroupCompressed = 1; + + free(sampleGroup.patternTracker); + sampleGroup.patternTracker = NULL; +} + static void destroy(MP4AtomPtr s) { MP4Err err; @@ -39,6 +431,19 @@ static void destroy(MP4AtomPtr s) free(self->group_index); self->group_index = NULL; } + + if(self->compressedGroup.patternEntries != NULL) + { + free(self->compressedGroup.patternEntries); + self->compressedGroup.patternEntries = NULL; + } + + if(self->compressedGroup.indexDescriptionArray != NULL) + { + free(self->compressedGroup.indexDescriptionArray); + self->compressedGroup.indexDescriptionArray = NULL; + } + if(self->super) self->super->destroy(s); bail: TEST_RETURN(err); @@ -122,6 +527,11 @@ static MP4Err mapSamplestoGroup(struct MP4SampletoGroupAtom *self, u32 group_ind for(i = 0; i < count; i++) *p++ = group_index; + if(GetFieldSize(group_index, self->fragmentLocalIndexPresent) > + self->compressedGroup.indexFieldSize) + self->compressedGroup.indexFieldSize = + GetFieldSize(group_index, self->fragmentLocalIndexPresent); + bail: TEST_RETURN(err); @@ -146,6 +556,93 @@ static MP4Err getSampleGroupMap(struct MP4SampletoGroupAtom *self, u32 sampleNum return err; } +static MP4Err GetData(MP4AtomPtr s, MP4InputStreamPtr inputStream, u8 fieldSize, u32 *upperNibble, + u32 *outValue) +{ + MP4Err err = MP4NoErr; + MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; + + if(fieldSize != 4 && fieldSize != 8 && fieldSize != 16 && fieldSize != 32) + BAILWITHERROR(MP4BadParamErr) + + u32 readData = 0; + switch(fieldSize) + { + case 4: + if(*upperNibble & kUpperNibblePresent) + { + *outValue = *upperNibble & 0xF; + *upperNibble = 0; + } + else + { + GET8_V_MSG(readData, NULL); + *upperNibble = (readData & 0xF) | kUpperNibblePresent; + *outValue = readData >> 4; + } + break; + case 8: + GET8_V_MSG(readData, NULL); + *outValue = readData; + break; + case 16: + GET16_V_MSG(readData, NULL); + *outValue = readData; + break; + case 32: + GET32_V_MSG(readData, NULL); + *outValue = readData; + break; + } +bail: + TEST_RETURN(err); + + return err; +} + +static MP4Err PackData(MP4SampletoGroupAtomPtr self, char **bufferPtr, u8 fieldSize, + u8 nonByteBoundary, u32 value) +{ + MP4Err err = MP4NoErr; + u32 previousByte; + char *buffer = *bufferPtr; + if(fieldSize != 4 && fieldSize != 8 && fieldSize != 16 && fieldSize != 32) + BAILWITHERROR(MP4BadParamErr) + + switch(fieldSize) + { + case 4: + /* Read the previous byte and append the new nibble to it*/ + if(nonByteBoundary) + { + buffer = buffer - 1; + self->bytesWritten -= 1; + previousByte = *(u8 *)buffer; + value = previousByte | (value & 0xF); + } + else + { + value = value << 4; + } + PUT8_V(value); + break; + case 8: + PUT8_V(value); + break; + case 16: + PUT16_V(value); + break; + case 32: + PUT32_V(value); + break; + } + *bufferPtr = buffer; +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err serialize(struct MP4Atom *s, char *buffer) { MP4Err err; @@ -155,34 +652,82 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; err = MP4NoErr; + if(self->type == MP4CompactSampletoGroupAtomType) + { + self->flags = SetFieldSize(self->compressedGroup.indexFieldSize) | + (SetFieldSize(self->compressedGroup.sampleCountFieldSize) << 2) | + (SetFieldSize(self->compressedGroup.patternLengthFieldSize) << 4) | + (self->fragmentLocalIndexPresent ? 0x80 : 0); + } + err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); if(err) goto bail; buffer += self->bytesWritten; + PUT32(grouping_type); + /* Grouping type parameter is disabled. If enabled, will need to pack an additional byte to + * represent it*/ PUT32(entryCount); - cur_index = (self->group_index)[0]; - cur_count = 1; - entryCount = 0; + if(self->type == MP4SampletoGroupAtomType) + { + cur_index = (self->group_index)[0]; + cur_count = 1; + entryCount = 0; - for(i = 1; i < self->sampleCount; i++) + for(i = 1; i < self->sampleCount; i++) + { + if((self->group_index)[i - 1] != (self->group_index)[i]) + { + PUT32_V(cur_count); + PUT32_V(cur_index); + cur_count = 1; + cur_index = (self->group_index)[i]; + entryCount++; + } + else + cur_count++; + } + PUT32_V(cur_count); + PUT32_V(cur_index); + entryCount++; + + assert(entryCount == self->entryCount); + } + else { - if((self->group_index)[i - 1] != (self->group_index)[i]) + printf(" \n Field sizes of pattern is %d , sampleCount is %d , indexDescription is %d ", + self->compressedGroup.patternLengthFieldSize, self->compressedGroup.sampleCountFieldSize, + self->compressedGroup.indexFieldSize); + + printf("\n Pattern count %d covering %d total samples ", self->compressedGroup.patternCount, + self->compressedGroup.totalSampleCount); + + for(i = 0; i < self->compressedGroup.patternCount; i++) { - PUT32_V(cur_count); - PUT32_V(cur_index); - cur_count = 1; - cur_index = (self->group_index)[i]; - entryCount++; + printf("\n Pattern length %d for %d samples ", + self->compressedGroup.patternEntries[i].patternLength, + self->compressedGroup.patternEntries[i].sampleCount); + + /* Pattern entry is ensured to start at a byte boundary*/ + PackData(self, &buffer, self->compressedGroup.patternLengthFieldSize, 0, + self->compressedGroup.patternEntries[i].patternLength); + + PackData(self, &buffer, self->compressedGroup.sampleCountFieldSize, + (self->compressedGroup.patternLengthFieldSize == 4), + self->compressedGroup.patternEntries[i].sampleCount); + } + + /* Index descriptor array is ensured to start at a byte boundary*/ + printf("\n Index Descriptors array is: "); + for(i = 0; i < self->compressedGroup.totalIndexDescriptionCount; i++) + { + printf(" %d ", self->compressedGroup.indexDescriptionArray[i]); + PackData(self, &buffer, self->compressedGroup.indexFieldSize, (i & 1), + self->compressedGroup.indexDescriptionArray[i]); } - else - cur_count++; } - PUT32_V(cur_count); - PUT32_V(cur_index); - entryCount++; - assert(entryCount == self->entryCount); assert(self->bytesWritten == self->size); bail: TEST_RETURN(err); @@ -201,14 +746,33 @@ static MP4Err calculateSize(struct MP4Atom *s) err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if(err) goto bail; - entryCount = 1; - - for(i = 1; i < (self->sampleCount); i++) + if(self->type == MP4SampletoGroupAtomType) + { + entryCount = 1; + for(i = 1; i < (self->sampleCount); i++) + { + if((self->group_index)[i - 1] != (self->group_index)[i]) entryCount++; + } + self->size += (entryCount * 8) + 8; + self->entryCount = entryCount; + } + else { - if((self->group_index)[i - 1] != (self->group_index)[i]) entryCount++; + CreateCompactSampleGroups(self); + + /* If grouping type parameter is enabled in flags, will need to add an additional byte*/ + self->size += 8; + + u32 sizeInBits = + (self->compressedGroup.patternCount * + (self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); + sizeInBits += + (self->compressedGroup.totalIndexDescriptionCount * self->compressedGroup.indexFieldSize); + self->size = self->size + (sizeInBits + 4) / 8; + + self->entryCount = self->compressedGroup.patternCount; } - self->size += (entryCount * 8) + 8; - self->entryCount = entryCount; + bail: TEST_RETURN(err); @@ -219,42 +783,140 @@ static MP4Err calculateSize(struct MP4Atom *s) static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { MP4Err err; - u32 i, j, size; + u32 i, j, size, flags; u32 *p; MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; char typeString[8]; char msgString[80]; + u8 indexFieldSize, countFieldSize, patternFieldSize; + char groupingTypeParamPresent; err = MP4NoErr; if(self == NULL) BAILWITHERROR(MP4BadParamErr) err = self->super->createFromInputStream(s, proto, (char *)inputStream); if(err) goto bail; + flags = self->flags; - GET32(grouping_type); - MP4TypeToString(self->grouping_type, typeString); - sprintf(msgString, " grouping type is '%s'", typeString); - inputStream->msg(inputStream, msgString); + if(self->type == MP4SampletoGroupAtomType) + { + self->sampleToGroupType = 0; + GET32(grouping_type); + MP4TypeToString(self->grouping_type, typeString); + sprintf(msgString, " grouping type is '%s'", typeString); + inputStream->msg(inputStream, msgString); - GET32(entryCount); - size = 0; + GET32(entryCount); + size = 0; - for(i = 0; i < self->entryCount; i++) + for(i = 0; i < self->entryCount; i++) + { + u32 count, index; + GET32_V_MSG(count, NULL); + GET32_V_MSG(index, NULL); + sprintf(msgString, " entry %d, count %d index %d", i + 1, count, index); + inputStream->msg(inputStream, msgString); + + err = ensureSize(self, (size + count) * sizeof(u32)); + if(err) goto bail; + + p = &((self->group_index)[size]); + for(j = 0; j < count; j++) + *p++ = index; + size += count; + } + self->sampleCount = size; + } + else { - u32 count, index; - GET32_V_MSG(count, NULL); - GET32_V_MSG(index, NULL); - sprintf(msgString, " entry %d, count %d index %d", i + 1, count, index); + self->sampleToGroupType = 1; + indexFieldSize = 4 << ((flags & 0x3) >> 0); + if(indexFieldSize != 4 && indexFieldSize != 8 && indexFieldSize != 16 && indexFieldSize != 32) + BAILWITHERROR(MP4BadParamErr) + + countFieldSize = 4 << ((flags & 0xC) >> 2); + if(countFieldSize != 4 && countFieldSize != 8 && countFieldSize != 16 && countFieldSize != 32) + BAILWITHERROR(MP4BadParamErr) + + patternFieldSize = 4 << ((flags & 0x30) >> 4); + if(patternFieldSize != 4 && patternFieldSize != 8 && patternFieldSize != 16 && + patternFieldSize != 32) + BAILWITHERROR(MP4BadParamErr) + + /* Ensure each pattern entry is always byte-aligned*/ + if((patternFieldSize + countFieldSize) % 8) BAILWITHERROR(MP4BadParamErr) + + self->fragmentLocalIndexPresent = (flags & 0x80); + groupingTypeParamPresent = (flags & 0x40); + + sprintf(msgString, "field size for index %d , sample count %d pattern length %d ", indexFieldSize, + countFieldSize, patternFieldSize); inputStream->msg(inputStream, msgString); - err = ensureSize(self, (size + count) * sizeof(u32)); + GET32(grouping_type); + MP4TypeToString(self->grouping_type, typeString); + sprintf(msgString, "grouping type is '%s'", typeString); + inputStream->msg(inputStream, msgString); + + if(groupingTypeParamPresent) + { + GET32(groupingTypeParameter); + } + + GET32(entryCount); + + MP4CompactSampleToGroupPatternEntryPtr patternEntries = + malloc(self->entryCount * sizeof(MP4CompactSampleToGroupPatternEntry)); + TESTMALLOC(patternEntries); + u32 upperNibble = 0; + + for(i = 0; i < self->entryCount; i++) + { + u32 sampleCount, patternLength; + + GetData(s, inputStream, patternFieldSize, &upperNibble, &patternLength); + patternEntries[i].patternLength = patternLength; + + GetData(s, inputStream, countFieldSize, &upperNibble, &sampleCount); + patternEntries[i].sampleCount = sampleCount; + self->sampleCount += sampleCount; + + sprintf(msgString, "pattern entry %d: pattern length->%d sample count->%d ", i + 1, + patternLength, sampleCount); + inputStream->msg(inputStream, msgString); + } + + err = ensureSize(self, self->sampleCount * sizeof(u32)); if(err) goto bail; + p = &((self->group_index)[0]); + + sprintf(msgString, "Index description values are:"); + inputStream->msg(inputStream, msgString); + for(i = 0; i < self->entryCount; i++) + { + u32 *patternStart = p; + u32 mask = + self->fragmentLocalIndexPresent ? 0xFFFFFFFF >> (32 - indexFieldSize + 1) : 0xFFFFFFFF; + for(j = 0; j < patternEntries[i].sampleCount; j++) + { + if(j < patternEntries[i].patternLength) + { + u32 indexValue; + GetData(s, inputStream, indexFieldSize, &upperNibble, &indexValue); + indexValue = indexValue & mask; + *p++ = indexValue; + sprintf(msgString + (i * 2), "%d ", indexValue); + } + else + { + *p++ = *(patternStart + (j % patternEntries[i].patternLength)); + } + } + } + inputStream->msg(inputStream, msgString); - p = &((self->group_index)[size]); - for(j = 0; j < count; j++) - *p++ = index; - size += count; + free(patternEntries); + patternEntries = NULL; } - self->sampleCount = size; bail: TEST_RETURN(err); @@ -262,7 +924,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre return err; } -MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom) +MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, u32 sampleToGroupType) { MP4Err err; MP4SampletoGroupAtomPtr self; @@ -272,17 +934,29 @@ MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom) err = MP4CreateFullAtom((MP4AtomPtr)self); if(err) goto bail; - self->type = MP4SampletoGroupAtomType; - self->name = "sample to group"; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->mapSamplestoGroup = mapSamplestoGroup; - self->addSamples = addSamples; - self->getSampleGroupMap = getSampleGroupMap; - self->group_index = NULL; - self->sampleCount = 0; + self->sampleToGroupType = sampleToGroupType; + if(self->sampleToGroupType == 0) + { + self->type = MP4SampletoGroupAtomType; + self->name = "sample to group"; + } + else //if(self->sampleToGroupType == 1) + { + self->type = MP4CompactSampletoGroupAtomType; + self->name = "compact sample to group"; + } + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->mapSamplestoGroup = mapSamplestoGroup; + self->addSamples = addSamples; + self->getSampleGroupMap = getSampleGroupMap; + self->group_index = NULL; + self->sampleCount = 0; + self->flags = 0; + self->fragmentLocalIndexPresent = 0; + memset(&self->compressedGroup, 0, sizeof(CompressedGroupInfo)); *outAtom = self; bail: diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index 886a336..eedf2fe 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -37,7 +37,6 @@ static void destroy(MP4AtomPtr s) DESTROY_ATOM_LIST_F(atomList); DESTROY_ATOM_LIST_F(groupList); DESTROY_ATOM_LIST_F(groupDescriptionList); - DESTROY_ATOM_LIST_F(compactSampleGroupList); (self->tfhd)->destroy((MP4AtomPtr)(self->tfhd)); (self->tfdt)->destroy((MP4AtomPtr)(self->tfdt)); @@ -72,16 +71,14 @@ static MP4Err addAtom(MP4TrackFragmentAtomPtr self, MP4AtomPtr atom) case MP4TrackRunAtomType: err = MP4AddListEntry(atom, self->atomList); break; - case MP4SampletoGroupAtomType: + case MP4SampletoGroupAtomType: /* sbgp */ + case MP4CompactSampletoGroupAtomType: /* csgp */ err = MP4AddListEntry(atom, self->groupList); - break; /* sbgp */ - case MP4SampleGroupDescriptionAtomType: + break; + case MP4SampleGroupDescriptionAtomType: /* sgpd */ err = MP4AddListEntry(atom, self->groupDescriptionList); - break; /* sgpd */ - case MP4CompactSampletoGroupAtomType: - err = MP4AddListEntry(atom, self->compactSampleGroupList); break; - /* default: BAILWITHERROR( MP4BadDataErr ) */ + /* default: BAILWITHERROR( MP4BadDataErr ) */ } bail: TEST_RETURN(err); @@ -131,19 +128,19 @@ static MP4Err addSampleGroups(struct MP4TrackFragmentAtom *self, u32 sampleCount } } - err = MP4GetListEntryCount(self->compactSampleGroupList, &groupListSize); - if(err) goto bail; - for(i = 0; i < groupListSize; i++) - { - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - err = MP4GetListEntry(self->compactSampleGroupList, i, (char **)&compactSampleGroup); - if(err) goto bail; - if(compactSampleGroup) - { - err = compactSampleGroup->addSamples(compactSampleGroup, sampleCount); - if(err) goto bail; - } - } + // err = MP4GetListEntryCount(self->compactSampleGroupList, &groupListSize); + // if(err) goto bail; + // for(i = 0; i < groupListSize; i++) + // { + // MP4CompactSampletoGroupAtomPtr compactSampleGroup; + // err = MP4GetListEntry(self->compactSampleGroupList, i, (char **)&compactSampleGroup); + // if(err) goto bail; + // if(compactSampleGroup) + // { + // err = compactSampleGroup->addSamples(compactSampleGroup, sampleCount); + // if(err) goto bail; + // } + // } bail: TEST_RETURN(err); @@ -389,7 +386,6 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) SERIALIZE_ATOM_LIST(atomList); SERIALIZE_ATOM_LIST(groupDescriptionList); SERIALIZE_ATOM_LIST(groupList); - SERIALIZE_ATOM_LIST(compactSampleGroupList); assert(self->bytesWritten == self->size); } @@ -480,7 +476,6 @@ static MP4Err calculateSize(struct MP4Atom *s) ADD_ATOM_LIST_SIZE(atomList); ADD_ATOM_LIST_SIZE(groupDescriptionList); ADD_ATOM_LIST_SIZE(groupList); - ADD_ATOM_LIST_SIZE(compactSampleGroupList); } else self->size = 0; @@ -654,32 +649,32 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) } } - if(self->compactSampleGroupList) - { - u32 groupListSize; - err = ISOSetSamplestoGroupType((MP4Media)mdia, 1); - if(err) goto bail; - err = MP4GetListEntryCount(self->compactSampleGroupList, &groupListSize); - if(err) goto bail; - for(i = 0; i < groupListSize; i++) - { - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - err = MP4GetListEntry(self->compactSampleGroupList, i, (char **)&compactSampleGroup); - if(err) goto bail; - if(compactSampleGroup) - { - u32 j; - for(j = 0; j < compactSampleGroup->sampleCount; j++) - { - s32 position; - position = j - total_samples; - err = mdia->mapSamplestoGroup(mdia, compactSampleGroup->grouping_type, - (compactSampleGroup->group_index)[j], position, 1); - if(err) goto bail; - } - } - } - } + // if(self->compactSampleGroupList) + // { + // u32 groupListSize; + // err = ISOSetSamplestoGroupType((MP4Media)mdia, 1); + // if(err) goto bail; + // err = MP4GetListEntryCount(self->compactSampleGroupList, &groupListSize); + // if(err) goto bail; + // for(i = 0; i < groupListSize; i++) + // { + // MP4CompactSampletoGroupAtomPtr compactSampleGroup; + // err = MP4GetListEntry(self->compactSampleGroupList, i, (char **)&compactSampleGroup); + // if(err) goto bail; + // if(compactSampleGroup) + // { + // u32 j; + // for(j = 0; j < compactSampleGroup->sampleCount; j++) + // { + // s32 position; + // position = j - total_samples; + // err = mdia->mapSamplestoGroup(mdia, compactSampleGroup->grouping_type, + // (compactSampleGroup->group_index)[j], position, 1); + // if(err) goto bail; + // } + // } + // } + // } bail: TEST_RETURN(err); @@ -828,220 +823,188 @@ static MP4Err calculateDataEnd(MP4TrackFragmentAtomPtr self, u32 *outEnd) return err; } -static MP4Err finalizeSampleToGroup(MP4TrackFragmentAtomPtr self, u32 mode) { - u32 count1, count2; - s32 i, j; - MP4Err err; - - MP4SampletoGroupAtomPtr normalSampleGroup; - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - - err = MP4GetListEntryCount(self->groupList, &count1); - if(err) goto bail; - - for(i = 0; i < count1; i++) - { - MP4AtomPtr desc1, desc2; - err = MP4GetListEntry(self->groupList, i, (char **)&desc1); - if(err) goto bail; - - err = MP4GetListEntryCount(self->compactSampleGroupList, &count2); - if(err) goto bail; - for(j = 0; j < count2; j++) - { - err = MP4GetListEntry(self->compactSampleGroupList, j, (char **)&desc2); - if(err) goto bail; - - if(desc1 && desc2) - { - MP4SampletoGroupAtomPtr grp1 = (MP4SampletoGroupAtomPtr)desc1; - MP4CompactSampletoGroupAtomPtr grp2 = (MP4CompactSampletoGroupAtomPtr)desc2; - if(grp1->grouping_type == grp2->grouping_type) - { - switch (mode) - { - case 0: - /* we want to keep normal only */ - MP4DeleteListEntry(self->compactSampleGroupList, j); - j--; - count2--; - break; - case 1: - /* we want to keep compressed only */ - MP4DeleteListEntry(self->groupList, i); - i--; - count1--; - break; - default: - /* decide based on atom size */ - grp1->calculateSize((MP4AtomPtr)grp1); - grp2->calculateSize((MP4AtomPtr)grp2); - - if(grp1->size < grp2->size) - { - /* normal is smaller */ - MP4DeleteListEntry(self->compactSampleGroupList, j); - j--; - count2--; - } - else - { - /* compressed is smaller */ - MP4DeleteListEntry(self->groupList, i); - i--; - count1--; - } - break; - } - } - } - } - } - -bail: - TEST_RETURN(err); - - return err; -} +// static MP4Err finalizeSampleToGroup(MP4TrackFragmentAtomPtr self, u32 mode) { +// u32 count1, count2; +// s32 i, j; +// MP4Err err; + +// MP4SampletoGroupAtomPtr normalSampleGroup; +// MP4CompactSampletoGroupAtomPtr compactSampleGroup; + +// err = MP4GetListEntryCount(self->groupList, &count1); +// if(err) goto bail; + +// for(i = 0; i < count1; i++) +// { +// MP4AtomPtr desc1, desc2; +// err = MP4GetListEntry(self->groupList, i, (char **)&desc1); +// if(err) goto bail; + +// err = MP4GetListEntryCount(self->compactSampleGroupList, &count2); +// if(err) goto bail; +// for(j = 0; j < count2; j++) +// { +// err = MP4GetListEntry(self->compactSampleGroupList, j, (char **)&desc2); +// if(err) goto bail; + +// if(desc1 && desc2) +// { +// MP4SampletoGroupAtomPtr grp1 = (MP4SampletoGroupAtomPtr)desc1; +// MP4CompactSampletoGroupAtomPtr grp2 = (MP4CompactSampletoGroupAtomPtr)desc2; +// if(grp1->grouping_type == grp2->grouping_type) +// { +// switch (mode) +// { +// case 0: +// /* we want to keep normal only */ +// MP4DeleteListEntry(self->compactSampleGroupList, j); +// j--; +// count2--; +// break; +// case 1: +// /* we want to keep compressed only */ +// MP4DeleteListEntry(self->groupList, i); +// i--; +// count1--; +// break; +// default: +// /* decide based on atom size */ +// grp1->calculateSize((MP4AtomPtr)grp1); +// grp2->calculateSize((MP4AtomPtr)grp2); + +// if(grp1->size < grp2->size) +// { +// /* normal is smaller */ +// MP4DeleteListEntry(self->compactSampleGroupList, j); +// j--; +// count2--; +// } +// else +// { +// /* compressed is smaller */ +// MP4DeleteListEntry(self->groupList, i); +// i--; +// count1--; +// } +// break; +// } +// } +// } +// } +// } + +// bail: +// TEST_RETURN(err); + +// return err; +// } static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType, u32 group_index, - s32 sample_index, u32 count, u32 compactSamples) + s32 sample_index, u32 count, u32 sampleToGroupType) { MP4Err err; MP4TrackFragmentAtomPtr self; u32 fragment_sample_count, atomListSize, i; + MP4SampletoGroupAtomPtr theGroup; self = (MP4TrackFragmentAtomPtr)s; - if(compactSamples==1) + err = MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&theGroup); + if(!theGroup) { - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - err = MP4FindGroupAtom(self->compactSampleGroupList, groupType, - (MP4AtomPtr *)&compactSampleGroup); - if(!compactSampleGroup) - { - err = MP4CreateCompactSampletoGroupAtom(&compactSampleGroup); - if(err) goto bail; - compactSampleGroup->fragmentLocalIndexPresent = 1; - compactSampleGroup->grouping_type = groupType; - err = addAtom(self, (MP4AtomPtr)compactSampleGroup); - if(err) goto bail; - - fragment_sample_count = 0; - err = MP4GetListEntryCount(self->atomList, &atomListSize); - if(err) goto bail; - for(i = 0; i < atomListSize; i++) - { - MP4TrackRunAtomPtr trun; - err = MP4GetListEntry(self->atomList, i, (char **)&trun); - if(err) goto bail; - if(trun) fragment_sample_count += trun->samplecount; - } - - if(fragment_sample_count > 0) - { - err = compactSampleGroup->addSamples(compactSampleGroup, fragment_sample_count); - } - } - err = - compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); + err = MP4CreateSampletoGroupAtom(&theGroup, sampleToGroupType); if(err) goto bail; - } - else if(compactSamples==0) - { - MP4SampletoGroupAtomPtr theGroup; - err = MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&theGroup); - if(!theGroup) - { - err = MP4CreateSampletoGroupAtom(&theGroup); - if(err) goto bail; - theGroup->grouping_type = groupType; - err = addAtom(self, (MP4AtomPtr)theGroup); - if(err) goto bail; - - fragment_sample_count = 0; - err = MP4GetListEntryCount(self->atomList, &atomListSize); - if(err) goto bail; - for(i = 0; i < atomListSize; i++) - { - MP4TrackRunAtomPtr trun; - err = MP4GetListEntry(self->atomList, i, (char **)&trun); - if(err) goto bail; - if(trun) fragment_sample_count += trun->samplecount; - } - - if(fragment_sample_count > 0) - { - err = theGroup->addSamples(theGroup, fragment_sample_count); - } - } - err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); + theGroup->fragmentLocalIndexPresent = 1; + theGroup->grouping_type = groupType; + err = addAtom(self, (MP4AtomPtr)theGroup); if(err) goto bail; - } - else - { - /* automatic mode, use both normal and compressed and see what has the smaller size when done */ - MP4SampletoGroupAtomPtr normalSampleGroup; - MP4CompactSampletoGroupAtomPtr compactSampleGroup; - - MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&normalSampleGroup); - MP4FindGroupAtom(self->compactSampleGroupList, groupType, (MP4AtomPtr *)&compactSampleGroup); - if(!normalSampleGroup) + fragment_sample_count = 0; + err = MP4GetListEntryCount(self->atomList, &atomListSize); + if(err) goto bail; + for(i = 0; i < atomListSize; i++) { - err = MP4CreateSampletoGroupAtom(&normalSampleGroup); - if(err) goto bail; - normalSampleGroup->grouping_type = groupType; - err = addAtom(self, (MP4AtomPtr)normalSampleGroup); - if(err) goto bail; - - fragment_sample_count = 0; - err = MP4GetListEntryCount(self->atomList, &atomListSize); + MP4TrackRunAtomPtr trun; + err = MP4GetListEntry(self->atomList, i, (char **)&trun); if(err) goto bail; - for(i = 0; i < atomListSize; i++) - { - MP4TrackRunAtomPtr trun; - err = MP4GetListEntry(self->atomList, i, (char **)&trun); - if(err) goto bail; - if(trun) fragment_sample_count += trun->samplecount; - } - - if(fragment_sample_count > 0) - { - err = normalSampleGroup->addSamples(normalSampleGroup, fragment_sample_count); - } + if(trun) fragment_sample_count += trun->samplecount; } - if(!compactSampleGroup) + if(fragment_sample_count > 0) { - err = MP4CreateCompactSampletoGroupAtom(&compactSampleGroup); - if(err) goto bail; - compactSampleGroup->fragmentLocalIndexPresent = 1; - compactSampleGroup->grouping_type = groupType; - err = addAtom(self, (MP4AtomPtr)compactSampleGroup); - if(err) goto bail; - - fragment_sample_count = 0; - err = MP4GetListEntryCount(self->atomList, &atomListSize); - if(err) goto bail; - for(i = 0; i < atomListSize; i++) - { - MP4TrackRunAtomPtr trun; - err = MP4GetListEntry(self->atomList, i, (char **)&trun); - if(err) goto bail; - if(trun) fragment_sample_count += trun->samplecount; - } - - if(fragment_sample_count > 0) - { - err = compactSampleGroup->addSamples(compactSampleGroup, fragment_sample_count); - } + err = theGroup->addSamples(theGroup, fragment_sample_count); } - err = normalSampleGroup->mapSamplestoGroup(normalSampleGroup, group_index, sample_index, count); - err = compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); - } + err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); + if(err) goto bail; + + // if(compactSamples==1) + // { + // MP4CompactSampletoGroupAtomPtr compactSampleGroup; + // err = MP4FindGroupAtom(self->compactSampleGroupList, groupType, + // (MP4AtomPtr *)&compactSampleGroup); + // if(!compactSampleGroup) + // { + // err = MP4CreateCompactSampletoGroupAtom(&compactSampleGroup); + // if(err) goto bail; + // compactSampleGroup->fragmentLocalIndexPresent = 1; + // compactSampleGroup->grouping_type = groupType; + // err = addAtom(self, (MP4AtomPtr)compactSampleGroup); + // if(err) goto bail; + + // fragment_sample_count = 0; + // err = MP4GetListEntryCount(self->atomList, &atomListSize); + // if(err) goto bail; + // for(i = 0; i < atomListSize; i++) + // { + // MP4TrackRunAtomPtr trun; + // err = MP4GetListEntry(self->atomList, i, (char **)&trun); + // if(err) goto bail; + // if(trun) fragment_sample_count += trun->samplecount; + // } + + // if(fragment_sample_count > 0) + // { + // err = compactSampleGroup->addSamples(compactSampleGroup, fragment_sample_count); + // } + // } + // err = + // compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); + // if(err) goto bail; + // } + // else + // { + // MP4SampletoGroupAtomPtr theGroup; + // err = MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&theGroup); + // if(!theGroup) + // { + // err = MP4CreateSampletoGroupAtom(&theGroup); + // if(err) goto bail; + // theGroup->grouping_type = groupType; + // err = addAtom(self, (MP4AtomPtr)theGroup); + // if(err) goto bail; + + // fragment_sample_count = 0; + // err = MP4GetListEntryCount(self->atomList, &atomListSize); + // if(err) goto bail; + // for(i = 0; i < atomListSize; i++) + // { + // MP4TrackRunAtomPtr trun; + // err = MP4GetListEntry(self->atomList, i, (char **)&trun); + // if(err) goto bail; + // if(trun) fragment_sample_count += trun->samplecount; + // } + + // if(fragment_sample_count > 0) + // { + // err = theGroup->addSamples(theGroup, fragment_sample_count); + // } + // } + // err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); + // if(err) goto bail; + // } + bail: TEST_RETURN(err); return err; @@ -1052,28 +1015,14 @@ static MP4Err getSampleGroupMap(MP4TrackFragmentAtomPtr self, u32 groupType, u32 { MP4Err err; MP4SampletoGroupAtomPtr theGroup; - MP4CompactSampletoGroupAtomPtr compactSampleGroup; err = MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&theGroup); if(theGroup) { err = theGroup->getSampleGroupMap(theGroup, sample_number, group_index); if(err) goto bail; - return err; - } - - err = - MP4FindGroupAtom(self->compactSampleGroupList, groupType, (MP4AtomPtr *)&compactSampleGroup); - if(compactSampleGroup) - { - err = compactSampleGroup->getSampleGroupMap(compactSampleGroup, sample_number, group_index); - if(err) goto bail; - } - else - { - err = MP4BadParamErr; - goto bail; } + else BAILWITHERROR(MP4BadParamErr); bail: TEST_RETURN(err); @@ -1167,8 +1116,6 @@ MP4Err MP4CreateTrackFragmentAtom(MP4TrackFragmentAtomPtr *outAtom) if(err) goto bail; err = MP4MakeLinkedList(&self->groupDescriptionList); if(err) goto bail; - err = MP4MakeLinkedList(&self->compactSampleGroupList); - if(err) goto bail; self->calculateSize = calculateSize; self->serialize = serialize; self->mdatMoved = mdatMoved; From cce1862816049c04d4430e11cdb200802e49fe99 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Mon, 16 Nov 2020 15:47:09 +0100 Subject: [PATCH 22/55] clean up --- IsoLib/libisomediafile/src/MP4Atoms.h | 1 - IsoLib/libisomediafile/src/SampleTableAtom.c | 59 ------ .../libisomediafile/src/TrackFragmentAtom.c | 185 +----------------- 3 files changed, 1 insertion(+), 244 deletions(-) diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index a7893df..6695686 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -2124,7 +2124,6 @@ MP4Err MP4CreateEncBaseAtom(MP4EncBaseSampleEntryAtomPtr outAtom); #endif MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, u32 sampleToGroupType); // sampleToGroupType_t -// MP4Err MP4CreateCompactSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom); MP4Err MP4CreateSampleGroupDescriptionAtom(MP4SampleGroupDescriptionAtomPtr *outAtom); MP4Err MP4CreateSampleDependencyAtom(MP4SampleDependencyAtomPtr *outAtom); diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index 4bbfab0..f00b0b3 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -606,17 +606,8 @@ static MP4Err mergeSampleGroupDescriptions(struct MP4SampleTableAtom *self, MP4A if(errTemp == MP4NoErr) err = addGroupDescription(self, other->grouping_type, descrH, &dummy); MP4DisposeHandle(descrH); } - - /* check if we already have this group in moov */ - // err = mdia->getGroupDescription(mdia, groupDescriptionTraf->grouping_type, 1, desc); - // if(err != MP4NoErr) - // { - // mdia->addGroupDescription(mdia, groupDescriptionTraf->grouping_type, desc, &descIdx); /* TODO: map to correct indexes from memory */ - // /* check the description as well, not only the type */ - // } } - bail: TEST_RETURN(err); @@ -658,56 +649,6 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); if(err) goto bail; - - // if(sampleToGroupType==1) - // { - // MP4CompactSampletoGroupAtomPtr compactSampleGroup; - // err = MP4FindGroupAtom(self->compactSampletoGroupList, groupType, /* TODO: flip it over */ - // (MP4AtomPtr *)&compactSampleGroup); - // if(!compactSampleGroup) - // { - // MP4SampleSizeAtomPtr stsz; - // stsz = (MP4SampleSizeAtomPtr)self->SampleSize; - // if(stsz == NULL) - // { - // BAILWITHERROR(MP4InvalidMediaErr); - // } - // err = MP4CreateCompactSampletoGroupAtom(&compactSampleGroup); - // if(err) goto bail; - // compactSampleGroup->grouping_type = groupType; - // compactSampleGroup->fragmentLocalIndexPresent = 0; - // err = addAtom(self, (MP4AtomPtr)compactSampleGroup); - // if(err) goto bail; - // err = compactSampleGroup->addSamples(compactSampleGroup, stsz->sampleCount); - // if(err) goto bail; - // } - // err = - // compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); - // if(err) goto bail; - // } - // else - // { - // err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); - // if(!theGroup) - // { - // MP4SampleSizeAtomPtr stsz; - - // stsz = (MP4SampleSizeAtomPtr)self->SampleSize; - // if(stsz == NULL) - // { - // BAILWITHERROR(MP4InvalidMediaErr); - // } - // err = MP4CreateSampletoGroupAtom(&theGroup); - // if(err) goto bail; - // theGroup->grouping_type = groupType; - // err = addAtom(self, (MP4AtomPtr)theGroup); - // if(err) goto bail; - // err = theGroup->addSamples(theGroup, stsz->sampleCount); - // if(err) goto bail; - // } - // err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); - // if(err) goto bail; - // } bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index eedf2fe..08b987c 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -128,20 +128,6 @@ static MP4Err addSampleGroups(struct MP4TrackFragmentAtom *self, u32 sampleCount } } - // err = MP4GetListEntryCount(self->compactSampleGroupList, &groupListSize); - // if(err) goto bail; - // for(i = 0; i < groupListSize; i++) - // { - // MP4CompactSampletoGroupAtomPtr compactSampleGroup; - // err = MP4GetListEntry(self->compactSampleGroupList, i, (char **)&compactSampleGroup); - // if(err) goto bail; - // if(compactSampleGroup) - // { - // err = compactSampleGroup->addSamples(compactSampleGroup, sampleCount); - // if(err) goto bail; - // } - // } - bail: TEST_RETURN(err); return err; @@ -649,33 +635,6 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) } } - // if(self->compactSampleGroupList) - // { - // u32 groupListSize; - // err = ISOSetSamplestoGroupType((MP4Media)mdia, 1); - // if(err) goto bail; - // err = MP4GetListEntryCount(self->compactSampleGroupList, &groupListSize); - // if(err) goto bail; - // for(i = 0; i < groupListSize; i++) - // { - // MP4CompactSampletoGroupAtomPtr compactSampleGroup; - // err = MP4GetListEntry(self->compactSampleGroupList, i, (char **)&compactSampleGroup); - // if(err) goto bail; - // if(compactSampleGroup) - // { - // u32 j; - // for(j = 0; j < compactSampleGroup->sampleCount; j++) - // { - // s32 position; - // position = j - total_samples; - // err = mdia->mapSamplestoGroup(mdia, compactSampleGroup->grouping_type, - // (compactSampleGroup->group_index)[j], position, 1); - // if(err) goto bail; - // } - // } - // } - // } - bail: TEST_RETURN(err); @@ -823,82 +782,6 @@ static MP4Err calculateDataEnd(MP4TrackFragmentAtomPtr self, u32 *outEnd) return err; } -// static MP4Err finalizeSampleToGroup(MP4TrackFragmentAtomPtr self, u32 mode) { -// u32 count1, count2; -// s32 i, j; -// MP4Err err; - -// MP4SampletoGroupAtomPtr normalSampleGroup; -// MP4CompactSampletoGroupAtomPtr compactSampleGroup; - -// err = MP4GetListEntryCount(self->groupList, &count1); -// if(err) goto bail; - -// for(i = 0; i < count1; i++) -// { -// MP4AtomPtr desc1, desc2; -// err = MP4GetListEntry(self->groupList, i, (char **)&desc1); -// if(err) goto bail; - -// err = MP4GetListEntryCount(self->compactSampleGroupList, &count2); -// if(err) goto bail; -// for(j = 0; j < count2; j++) -// { -// err = MP4GetListEntry(self->compactSampleGroupList, j, (char **)&desc2); -// if(err) goto bail; - -// if(desc1 && desc2) -// { -// MP4SampletoGroupAtomPtr grp1 = (MP4SampletoGroupAtomPtr)desc1; -// MP4CompactSampletoGroupAtomPtr grp2 = (MP4CompactSampletoGroupAtomPtr)desc2; -// if(grp1->grouping_type == grp2->grouping_type) -// { -// switch (mode) -// { -// case 0: -// /* we want to keep normal only */ -// MP4DeleteListEntry(self->compactSampleGroupList, j); -// j--; -// count2--; -// break; -// case 1: -// /* we want to keep compressed only */ -// MP4DeleteListEntry(self->groupList, i); -// i--; -// count1--; -// break; -// default: -// /* decide based on atom size */ -// grp1->calculateSize((MP4AtomPtr)grp1); -// grp2->calculateSize((MP4AtomPtr)grp2); - -// if(grp1->size < grp2->size) -// { -// /* normal is smaller */ -// MP4DeleteListEntry(self->compactSampleGroupList, j); -// j--; -// count2--; -// } -// else -// { -// /* compressed is smaller */ -// MP4DeleteListEntry(self->groupList, i); -// i--; -// count1--; -// } -// break; -// } -// } -// } -// } -// } - -// bail: -// TEST_RETURN(err); - -// return err; -// } - static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType, u32 group_index, s32 sample_index, u32 count, u32 sampleToGroupType) { @@ -937,73 +820,7 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType } err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); - if(err) goto bail; - - // if(compactSamples==1) - // { - // MP4CompactSampletoGroupAtomPtr compactSampleGroup; - // err = MP4FindGroupAtom(self->compactSampleGroupList, groupType, - // (MP4AtomPtr *)&compactSampleGroup); - // if(!compactSampleGroup) - // { - // err = MP4CreateCompactSampletoGroupAtom(&compactSampleGroup); - // if(err) goto bail; - // compactSampleGroup->fragmentLocalIndexPresent = 1; - // compactSampleGroup->grouping_type = groupType; - // err = addAtom(self, (MP4AtomPtr)compactSampleGroup); - // if(err) goto bail; - - // fragment_sample_count = 0; - // err = MP4GetListEntryCount(self->atomList, &atomListSize); - // if(err) goto bail; - // for(i = 0; i < atomListSize; i++) - // { - // MP4TrackRunAtomPtr trun; - // err = MP4GetListEntry(self->atomList, i, (char **)&trun); - // if(err) goto bail; - // if(trun) fragment_sample_count += trun->samplecount; - // } - - // if(fragment_sample_count > 0) - // { - // err = compactSampleGroup->addSamples(compactSampleGroup, fragment_sample_count); - // } - // } - // err = - // compactSampleGroup->mapSamplestoGroup(compactSampleGroup, group_index, sample_index, count); - // if(err) goto bail; - // } - // else - // { - // MP4SampletoGroupAtomPtr theGroup; - // err = MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&theGroup); - // if(!theGroup) - // { - // err = MP4CreateSampletoGroupAtom(&theGroup); - // if(err) goto bail; - // theGroup->grouping_type = groupType; - // err = addAtom(self, (MP4AtomPtr)theGroup); - // if(err) goto bail; - - // fragment_sample_count = 0; - // err = MP4GetListEntryCount(self->atomList, &atomListSize); - // if(err) goto bail; - // for(i = 0; i < atomListSize; i++) - // { - // MP4TrackRunAtomPtr trun; - // err = MP4GetListEntry(self->atomList, i, (char **)&trun); - // if(err) goto bail; - // if(trun) fragment_sample_count += trun->samplecount; - // } - - // if(fragment_sample_count > 0) - // { - // err = theGroup->addSamples(theGroup, fragment_sample_count); - // } - // } - // err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); - // if(err) goto bail; - // } + if(err) goto bail; bail: TEST_RETURN(err); From 4a190f023e94091bc73f2e5021cc2bac2944ea8e Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Mon, 16 Nov 2020 16:08:16 +0100 Subject: [PATCH 23/55] use sampleToGroupType_t. Delete csgp as it is now a part of sbgp structure --- .../src/CompactSampleToGroupAtom.c | 875 ------------------ IsoLib/libisomediafile/src/MP4Atoms.h | 18 +- IsoLib/libisomediafile/src/MP4Media.c | 2 +- IsoLib/libisomediafile/src/MP4Movies.h | 159 ++-- .../src/MediaInformationAtom.c | 2 +- IsoLib/libisomediafile/src/SampleTableAtom.c | 2 +- .../libisomediafile/src/SampleToGroupAtom.c | 2 +- .../libisomediafile/src/TrackFragmentAtom.c | 2 +- IsoLib/playground/main.cpp | 6 +- 9 files changed, 96 insertions(+), 972 deletions(-) delete mode 100644 IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c diff --git a/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c b/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c deleted file mode 100644 index 100422f..0000000 --- a/IsoLib/libisomediafile/src/CompactSampleToGroupAtom.c +++ /dev/null @@ -1,875 +0,0 @@ -/* -This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. -ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware -or software products claiming conformance to MPEG-4. -Those intending to use this software module in hardware or software -products are advised that its use may infringe existing patents. -The original developer of this software module and his/her company, -the subsequent editors and their companies, and ISO/IEC have no -liability for use of this software module or modifications thereof -in an implementation. -Copyright is not released for non MPEG-4 conforming -products. Apple Computer, Inc. retains full right to use the code for its own -purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non -MPEG-4 conforming products. -This copyright notice must be included in all copies or -derivative works. Copyright (c) 1999. -*/ - -#include "MP4Atoms.h" -#include -#include - -#define allocation_size 8192 - -enum -{ - kMaxPatternLength = 32, - kUpperNibblePresent = 0x8000 -}; - -/* PatternTracker is maintained as an array for each sample input. -patternStart at index k, represents the start index of the pattern which helped yield the most -efficient way to encode samples from [0, k] inclusive with patternLength, repeated sampleCount times -cumulativeMemoryCost at index k, represents the memory cost associated with most efficient way to -encode samples from [0, k] inclusive. Default considers each sample as a distinct non-pattern -prevEfficientIndex at index k, represents the end of the most efficient previous pattern/ -non-pattern before k which helped yield the cumulativeMemoryCost at index k. nextEfficientIndex is -populated after back-tracking prevEfficientIndex to easily create compact sample groups -*/ -typedef struct -{ - u32 patternStart; - u32 patternLength; - u32 sampleCount; - s32 cumulativeMemoryCost; - s32 prevEfficientIndex; - s32 nextEfficientIndex; -} PatternTracker; - -/* -Compacting Algorithm: -1. Run through sample group set: i=[0,n] - a. Expand the input samples - b. Initialize memory costs in tracker assuming each sample is a distinct non-pattern C[i] = -(i*indexFieldSize) -2. Run through sample group set: i=[0,n] - a. Update memory cost considering sample i is a distinct non-pattern C[i] = min(C[i] , -C[i-1]+ indexFieldSize) b. For pattern lengths, p=[1, 32] i. Consider patterns ending at i, from -[start=i-p, i] in the Search buffer. ii. Extend right end from [i+1, n] in the look ahead buffer - 1. As long as the pattern repeats, keep extending right end and -update memory cost C[end] = min(C[end] , C[start-1] + p*indexFieldSize - 2. If C[end] got modified, a more efficient pattern was found, -maintain previousEfficientIndex = start-1 for backtracking. -3. Tracker[n-1] represents most efficienct way to encode samples [0,n]. Run through tracker -backwards from last sample: i[n-1, 0]. a. Use previousEfficientIndex to populate nextEfficientIndex -to easily create compact sample groups b. Patterns with (pattern length == sample count == 1), are -combined and considered as non-pattern - -Algorithm can further be optimized by making memory cost consider patternLength and sampleCount -field sizes -*/ - -typedef struct -{ - u32 *groupIndex; - u32 sampleCount; - PatternTracker *patternTracker; - u8 groupIndexFieldSize; -} SampleGroupInfo; - -u8 GetFieldSize(u32 value, u8 localFragmentUsed) -{ - if(localFragmentUsed) - { - if(value < 8) - { - return 4; - } - else if(value < 128) - { - return 8; - } - else if(value < 32768) - { - return 16; - } - else - { - return 32; - } - } - else - { - if(value < 16) - { - return 4; - } - else if(value < 256) - { - return 8; - } - else if(value < 65536) - { - return 16; - } - else - { - return 32; - } - } -} - -u8 SetFieldSize(u32 fieldSize) -{ - assert(fieldSize == 4 || fieldSize == 8 || fieldSize == 16 || fieldSize == 32); - switch(fieldSize) - { - case 4: - return 0; - break; - case 8: - return 1; - break; - case 16: - return 2; - break; - case 32: - return 3; - break; - }; - return 0; -} - -void AppendDescriptionIndexToCompactGroup(CompressedGroupInfo *compressedGroup, u32 descIndex, - u32 groupIndex) -{ - assert(descIndex < compressedGroup->totalIndexDescriptionCount); - compressedGroup->indexDescriptionArray[descIndex] = groupIndex; -} - -void AppendNewPatternEntry(CompressedGroupInfo *compressedGroup, u32 index, u32 patternLength, - u32 sampleCount) -{ - assert(patternLength != 0); - assert(sampleCount != 0); - assert(index < compressedGroup->patternCount); - /*printf("\n New pattern: length %d sampleCount %d", patternLength, sampleCount); */ - - compressedGroup->patternEntries[index].patternLength = patternLength; - compressedGroup->patternEntries[index].sampleCount = sampleCount; - compressedGroup->totalSampleCount += sampleCount; -} - -void SetMemoryCostForPattern(SampleGroupInfo *sampleGroup, u32 patternLength, - u32 startPatternSampleIndex, u32 endPatternSampleIndex) -{ - u32 sampleCount = endPatternSampleIndex - startPatternSampleIndex + 1; - - assert(startPatternSampleIndex + patternLength <= endPatternSampleIndex); - - s32 memoryCost = - startPatternSampleIndex <= 0 - ? sampleGroup->patternTracker[0].cumulativeMemoryCost - : sampleGroup->patternTracker[startPatternSampleIndex - 1].cumulativeMemoryCost; - memoryCost += (patternLength * sampleGroup->groupIndexFieldSize); - - if(memoryCost < sampleGroup->patternTracker[endPatternSampleIndex].cumulativeMemoryCost) - { - PatternTracker patTrack; - patTrack.patternStart = startPatternSampleIndex; - patTrack.patternLength = patternLength; - patTrack.sampleCount = sampleCount; - patTrack.cumulativeMemoryCost = memoryCost; - patTrack.prevEfficientIndex = startPatternSampleIndex - 1; - - sampleGroup->patternTracker[endPatternSampleIndex] = patTrack; - /*printf("\n Pattern run of pattern length %d, sample count %d, starting @ %3d with memoryCost - * %d and prevMostEffIndex %d", patternLength, sampleCount, startPatternSampleIndex, - * patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex); */ - } -} - -void SetMemoryCostForNonPattern(SampleGroupInfo *sampleGroup, s32 sampleIndex) -{ - s32 memoryCost = - (sampleIndex < 1 ? sampleGroup->patternTracker[0].cumulativeMemoryCost - : sampleGroup->patternTracker[sampleIndex - 1].cumulativeMemoryCost) + - sampleGroup->groupIndexFieldSize; - - if(memoryCost < sampleGroup->patternTracker[sampleIndex].cumulativeMemoryCost) - { - PatternTracker patTrack; - patTrack.patternStart = sampleIndex; - patTrack.patternLength = 1; - patTrack.sampleCount = 1; - patTrack.cumulativeMemoryCost = memoryCost; - patTrack.prevEfficientIndex = sampleIndex - 1; - - sampleGroup->patternTracker[sampleIndex] = patTrack; - /*printf("\n Writing non-pattern with memoryCost %d and prevMostEffIndex %d ", - * patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex);*/ - } -} - -void CombineNonPatterns(SampleGroupInfo *sampleGroup, CompressedGroupInfo *compressedGroup) -{ - s32 prevIndex = sampleGroup->sampleCount - 1; - s32 nextIndex = sampleGroup->sampleCount; - PatternTracker *patternTracker = sampleGroup->patternTracker; - - /* Post-process output pattern tracker. Get Pattern Count, Populate the nextIndex to navigate - * easily*/ - while(prevIndex >= 0 && prevIndex < sampleGroup->sampleCount) - { - u32 consecutiveNonPatterns = 0; - s32 i = prevIndex; - while(i >= 0 && i < sampleGroup->sampleCount && (patternTracker[i].patternLength == 1) && - (patternTracker[i].sampleCount == 1)) - { - consecutiveNonPatterns++; - i = patternTracker[i].prevEfficientIndex; - } - if(consecutiveNonPatterns) - { - patternTracker[prevIndex].patternLength = consecutiveNonPatterns; - patternTracker[prevIndex].sampleCount = consecutiveNonPatterns; - patternTracker[prevIndex].patternStart -= (consecutiveNonPatterns - 1); - compressedGroup->totalIndexDescriptionCount += consecutiveNonPatterns; - patternTracker[prevIndex].prevEfficientIndex = i; - } - else - { - compressedGroup->totalIndexDescriptionCount += patternTracker[prevIndex].patternLength; - } - - patternTracker[prevIndex].nextEfficientIndex = nextIndex; - nextIndex = prevIndex; - prevIndex = patternTracker[prevIndex].prevEfficientIndex; - - compressedGroup->patternCount++; - } - compressedGroup->efficientStartIndex = nextIndex; -} - -void FindPatternsStartingAtIndex(SampleGroupInfo *sampleGroup, u32 sampleIndex) -{ - u32 p; - assert(sampleIndex < sampleGroup->sampleCount); - - /* Update memoryCost in case current sample is considered as a non-pattern*/ - SetMemoryCostForNonPattern(sampleGroup, sampleIndex); - - for(p = 1; p <= kMaxPatternLength; p++) - { - if(sampleIndex < p) break; - - if(sampleGroup->groupIndex[sampleIndex] == sampleGroup->groupIndex[sampleIndex - p]) - { - u32 startPatternSampleIndex = sampleIndex - p; - u32 i = sampleIndex; - while(i < sampleGroup->sampleCount && - sampleGroup->groupIndex[i] == sampleGroup->groupIndex[i - p]) - { - SetMemoryCostForPattern(sampleGroup, p, startPatternSampleIndex, i); - i++; - } - - /* Pattern ended at i - 1. - printf("\n %3d: pattern run ended", i-1); - break; */ - } - } -} - -void InitializeSampleGroupInput(MP4CompactSampletoGroupAtomPtr self, SampleGroupInfo *sampleGroup) -{ - u32 i; - sampleGroup->groupIndex = self->group_index; - sampleGroup->sampleCount = self->sampleCount; - sampleGroup->groupIndexFieldSize = self->compressedGroup.indexFieldSize; - sampleGroup->patternTracker = - (PatternTracker *)malloc(sizeof(PatternTracker) * self->sampleCount); - - memset(sampleGroup->patternTracker, 0, sizeof(PatternTracker) * self->sampleCount); - - /* Expand sample group indices, get maximum field size to represent each group index*/ - u32 startValue = self->group_index[0]; - - for(i = 1; i < self->sampleCount; i++) - { - if(self->group_index[i - 1] == self->group_index[i]) - { - self->group_index[i - 1] = startValue; - } - else - { - startValue = self->group_index[i]; - } - } - self->group_index[self->sampleCount - 1] = startValue; - - /* Initialize efficiencies assuming each input sample is a distinct non-pattern*/ - PatternTracker patternTrackerEntry; - patternTrackerEntry.patternLength = patternTrackerEntry.sampleCount = 1; - - for(i = 0; i < self->sampleCount; i++) - { - patternTrackerEntry.patternStart = i; - patternTrackerEntry.prevEfficientIndex = i - 1; - patternTrackerEntry.cumulativeMemoryCost = (i + 1) * sampleGroup->groupIndexFieldSize; - sampleGroup->patternTracker[i] = patternTrackerEntry; - } -} - -void CreateCompactSampleGroups(MP4CompactSampletoGroupAtomPtr self) -{ - u32 j; - u32 patternIndex; - if(self->compressedGroup.isSampleGroupCompressed) return; - - SampleGroupInfo sampleGroup; - InitializeSampleGroupInput(self, &sampleGroup); - - CompressedGroupInfo *compressedGroup = &self->compressedGroup; - compressedGroup->patternLengthFieldSize = 4; - compressedGroup->sampleCountFieldSize = 4; - compressedGroup->indexFieldSize = sampleGroup.groupIndexFieldSize; - - /* Repeatedly process, find and update efficiencies at each sample index*/ - for(j = 0; j < self->sampleCount; j++) - { - FindPatternsStartingAtIndex(&sampleGroup, j); - } - - CombineNonPatterns(&sampleGroup, compressedGroup); - - if(compressedGroup->patternEntries == NULL) - { - compressedGroup->patternEntries = (MP4CompactSampleToGroupPatternEntryPtr)malloc( - sizeof(MP4CompactSampleToGroupPatternEntry) * compressedGroup->patternCount); - } - if(compressedGroup->indexDescriptionArray == NULL) - { - compressedGroup->indexDescriptionArray = - (u32 *)malloc(sizeof(u32) * compressedGroup->totalIndexDescriptionCount); - } - - /*printf("\n The pattern tracker details are"); - for(int i = 0; i < self->sampleCount; i++) - { - printf("\n Index %d Start: %d PL: %d SC: %d Eff: %d PrevIndex: %d NextIndex: %d ", i, - patternTracker[i].start, patternTracker[i].patternLength, patternTracker[i].sampleCount, - patternTracker[i].cumulativeMemoryCost, patternTracker[i].prevEfficientIndex, - patternTracker[i].nextEfficientIndex); - }*/ - - PatternTracker *patternTracker = sampleGroup.patternTracker; - u32 descIndex = 0; - u32 nextIndex = compressedGroup->efficientStartIndex; - for(patternIndex = 0; patternIndex < compressedGroup->patternCount; patternIndex++) - { - u32 patternLength = patternTracker[nextIndex].patternLength; - u8 fieldSize = GetFieldSize(patternLength, 0); - if(fieldSize > compressedGroup->patternLengthFieldSize) - compressedGroup->patternLengthFieldSize = fieldSize; - - u32 sampleCount = patternTracker[nextIndex].sampleCount; - fieldSize = GetFieldSize(sampleCount, 0); - if(fieldSize > compressedGroup->sampleCountFieldSize) - compressedGroup->sampleCountFieldSize = fieldSize; - - AppendNewPatternEntry(compressedGroup, patternIndex, patternLength, sampleCount); - - assert(patternTracker[nextIndex].patternStart >= 0 && - patternTracker[nextIndex].patternStart < self->sampleCount); - assert(patternTracker[nextIndex].patternStart + patternLength - 1 < self->sampleCount); - - for(j = 0; j < patternLength; j++) - { - u32 groupIndex = sampleGroup.groupIndex[patternTracker[nextIndex].patternStart + j]; - if(self->fragmentLocalIndexPresent) - { - groupIndex = groupIndex | (1 << (self->compressedGroup.indexFieldSize - 1)); - } - AppendDescriptionIndexToCompactGroup(compressedGroup, descIndex, groupIndex); - descIndex++; - } - nextIndex = patternTracker[nextIndex].nextEfficientIndex; - } - - /* In case only patternLength or sampleCount field size is 4, ensure pattern entry is always byte - * aligned*/ - if((compressedGroup->patternLengthFieldSize + compressedGroup->sampleCountFieldSize) % 8) - { - if(compressedGroup->patternLengthFieldSize == 4) compressedGroup->patternLengthFieldSize = 8; - else - compressedGroup->sampleCountFieldSize = 8; - } - - assert(descIndex == compressedGroup->totalIndexDescriptionCount); - self->compressedGroup.isSampleGroupCompressed = 1; - - free(sampleGroup.patternTracker); - sampleGroup.patternTracker = NULL; -} - -static void destroy(MP4AtomPtr s) -{ - MP4Err err; - MP4CompactSampletoGroupAtomPtr self; - err = MP4NoErr; - self = (MP4CompactSampletoGroupAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - if(self->group_index != NULL) - { - free(self->group_index); - self->group_index = NULL; - } - - if(self->compressedGroup.patternEntries != NULL) - { - free(self->compressedGroup.patternEntries); - self->compressedGroup.patternEntries = NULL; - } - - if(self->compressedGroup.indexDescriptionArray != NULL) - { - free(self->compressedGroup.indexDescriptionArray); - self->compressedGroup.indexDescriptionArray = NULL; - } - if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; -} - -static MP4Err ensureSize(struct MP4CompactSampletoGroupAtom *self, u32 newSize) -{ - MP4Err err; - - err = MP4NoErr; - - if(newSize > self->allocatedSize) - { - self->allocatedSize += allocation_size; - if(newSize > self->allocatedSize) self->allocatedSize = newSize; - - if(self->group_index != NULL) - self->group_index = (u32 *)realloc(self->group_index, self->allocatedSize); - else - self->group_index = (u32 *)calloc(self->allocatedSize, 1); - - TESTMALLOC(self->group_index); - } - -bail: - TEST_RETURN(err); - - return err; -} - -static MP4Err addSamples(struct MP4CompactSampletoGroupAtom *self, u32 count) -{ - MP4Err err; - u32 *p; - u32 j; - - err = MP4NoErr; - err = ensureSize(self, (self->sampleCount + count) * sizeof(u32)); - if(err) goto bail; - - p = &((self->group_index)[self->sampleCount]); - for(j = 0; j < count; j++) - *p++ = 0; - self->sampleCount += count; - -bail: - TEST_RETURN(err); - - return err; -} - -static MP4Err mapSamplestoGroup(struct MP4CompactSampletoGroupAtom *self, u32 group_index, - s32 sample_index, u32 count) -{ - MP4Err err; - u32 i; - u32 *p; - - err = MP4NoErr; - - if(sample_index < 0) - { - p = &((self->group_index)[self->sampleCount + sample_index]); - if(count > ((u32)(-sample_index))) - { - err = MP4BadParamErr; - goto bail; - } - } - else - { - p = &((self->group_index)[sample_index]); - if(count + sample_index > self->sampleCount) - { - err = MP4BadParamErr; - goto bail; - } - } - for(i = 0; i < count; i++) - *p++ = group_index; - - if(GetFieldSize(group_index, self->fragmentLocalIndexPresent) > - self->compressedGroup.indexFieldSize) - self->compressedGroup.indexFieldSize = - GetFieldSize(group_index, self->fragmentLocalIndexPresent); - -bail: - TEST_RETURN(err); - - return err; -} - -static MP4Err getSampleGroupMap(struct MP4CompactSampletoGroupAtom *self, u32 sampleNumber, - u32 *groupIndex) -{ - MP4Err err; - - err = MP4NoErr; - - if(sampleNumber < 1) BAILWITHERROR(MP4BadParamErr); - if(sampleNumber > self->sampleCount) *groupIndex = 0; - else - *groupIndex = (self->group_index)[sampleNumber - 1]; - -bail: - TEST_RETURN(err); - - return err; -} - -static MP4Err GetData(MP4AtomPtr s, MP4InputStreamPtr inputStream, u8 fieldSize, u32 *upperNibble, - u32 *outValue) -{ - MP4Err err = MP4NoErr; - MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr)s; - - if(fieldSize != 4 && fieldSize != 8 && fieldSize != 16 && fieldSize != 32) - BAILWITHERROR(MP4BadParamErr) - - u32 readData = 0; - switch(fieldSize) - { - case 4: - if(*upperNibble & kUpperNibblePresent) - { - *outValue = *upperNibble & 0xF; - *upperNibble = 0; - } - else - { - GET8_V_MSG(readData, NULL); - *upperNibble = (readData & 0xF) | kUpperNibblePresent; - *outValue = readData >> 4; - } - break; - case 8: - GET8_V_MSG(readData, NULL); - *outValue = readData; - break; - case 16: - GET16_V_MSG(readData, NULL); - *outValue = readData; - break; - case 32: - GET32_V_MSG(readData, NULL); - *outValue = readData; - break; - } -bail: - TEST_RETURN(err); - - return err; -} - -static MP4Err PackData(MP4CompactSampletoGroupAtomPtr self, char **bufferPtr, u8 fieldSize, - u8 nonByteBoundary, u32 value) -{ - MP4Err err = MP4NoErr; - u32 previousByte; - char *buffer = *bufferPtr; - if(fieldSize != 4 && fieldSize != 8 && fieldSize != 16 && fieldSize != 32) - BAILWITHERROR(MP4BadParamErr) - - switch(fieldSize) - { - case 4: - /* Read the previous byte and append the new nibble to it*/ - if(nonByteBoundary) - { - buffer = buffer - 1; - self->bytesWritten -= 1; - previousByte = *(u8 *)buffer; - value = previousByte | (value & 0xF); - } - else - { - value = value << 4; - } - PUT8_V(value); - break; - case 8: - PUT8_V(value); - break; - case 16: - PUT16_V(value); - break; - case 32: - PUT32_V(value); - break; - } - *bufferPtr = buffer; -bail: - TEST_RETURN(err); - - return err; -} - -static MP4Err serialize(struct MP4Atom *s, char *buffer) -{ - MP4Err err = MP4NoErr; - u32 i; - - MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr)s; - - self->flags = SetFieldSize(self->compressedGroup.indexFieldSize) | - (SetFieldSize(self->compressedGroup.sampleCountFieldSize) << 2) | - (SetFieldSize(self->compressedGroup.patternLengthFieldSize) << 4) | - (self->fragmentLocalIndexPresent ? 0x80 : 0); - - err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); - if(err) goto bail; - buffer += self->bytesWritten; - - PUT32(grouping_type); - /* Grouping type parameter is disabled. If enabled, will need to pack an additional byte to - * represent it*/ - PUT32(entryCount); - - printf(" \n Field sizes of pattern is %d , sampleCount is %d , indexDescription is %d ", - self->compressedGroup.patternLengthFieldSize, self->compressedGroup.sampleCountFieldSize, - self->compressedGroup.indexFieldSize); - - printf("\n Pattern count %d covering %d total samples ", self->compressedGroup.patternCount, - self->compressedGroup.totalSampleCount); - - for(i = 0; i < self->compressedGroup.patternCount; i++) - { - printf("\n Pattern length %d for %d samples ", - self->compressedGroup.patternEntries[i].patternLength, - self->compressedGroup.patternEntries[i].sampleCount); - - /* Pattern entry is ensured to start at a byte boundary*/ - PackData(self, &buffer, self->compressedGroup.patternLengthFieldSize, 0, - self->compressedGroup.patternEntries[i].patternLength); - - PackData(self, &buffer, self->compressedGroup.sampleCountFieldSize, - (self->compressedGroup.patternLengthFieldSize == 4), - self->compressedGroup.patternEntries[i].sampleCount); - } - - /* Index descriptor array is ensured to start at a byte boundary*/ - printf("\n Index Descriptors array is: "); - for(i = 0; i < self->compressedGroup.totalIndexDescriptionCount; i++) - { - printf(" %d ", self->compressedGroup.indexDescriptionArray[i]); - PackData(self, &buffer, self->compressedGroup.indexFieldSize, (i & 1), - self->compressedGroup.indexDescriptionArray[i]); - } - - assert(self->bytesWritten == self->size); - -bail: - TEST_RETURN(err); - - return err; -} - -static MP4Err calculateSize(struct MP4Atom *s) -{ - MP4Err err = MP4NoErr; - MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr)s; - - err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); - if(err) goto bail; - - CreateCompactSampleGroups(self); - - /* If grouping type parameter is enabled in flags, will need to add an additional byte*/ - self->size += 8; - - u32 sizeInBits = - (self->compressedGroup.patternCount * - (self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); - sizeInBits += - (self->compressedGroup.totalIndexDescriptionCount * self->compressedGroup.indexFieldSize); - self->size = self->size + (sizeInBits + 4) / 8; - - self->entryCount = self->compressedGroup.patternCount; - -bail: - TEST_RETURN(err); - - return err; -} - -static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) -{ - MP4Err err; - u32 i, j; - u32 *p; - u32 flags; - MP4CompactSampletoGroupAtomPtr self = (MP4CompactSampletoGroupAtomPtr)s; - char typeString[8]; - char msgString[80]; - u8 indexFieldSize, countFieldSize, patternFieldSize; - char groupingTypeParamPresent; - - err = MP4NoErr; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - err = self->super->createFromInputStream(s, proto, (char *)inputStream); - if(err) goto bail; - flags = self->flags; - - indexFieldSize = 4 << ((flags & 0x3) >> 0); - if(indexFieldSize != 4 && indexFieldSize != 8 && indexFieldSize != 16 && indexFieldSize != 32) - BAILWITHERROR(MP4BadParamErr) - - countFieldSize = 4 << ((flags & 0xC) >> 2); - if(countFieldSize != 4 && countFieldSize != 8 && countFieldSize != 16 && countFieldSize != 32) - BAILWITHERROR(MP4BadParamErr) - - patternFieldSize = 4 << ((flags & 0x30) >> 4); - if(patternFieldSize != 4 && patternFieldSize != 8 && patternFieldSize != 16 && - patternFieldSize != 32) - BAILWITHERROR(MP4BadParamErr) - - /* Ensure each pattern entry is always byte-aligned*/ - if((patternFieldSize + countFieldSize) % 8) BAILWITHERROR(MP4BadParamErr) - - self->fragmentLocalIndexPresent = (flags & 0x80); - groupingTypeParamPresent = (flags & 0x40); - - sprintf(msgString, "field size for index %d , sample count %d pattern length %d ", indexFieldSize, - countFieldSize, patternFieldSize); - inputStream->msg(inputStream, msgString); - - GET32(grouping_type); - MP4TypeToString(self->grouping_type, typeString); - sprintf(msgString, "grouping type is '%s'", typeString); - inputStream->msg(inputStream, msgString); - - if(groupingTypeParamPresent) - { - GET32(groupingTypeParameter); - } - - GET32(entryCount); - - MP4CompactSampleToGroupPatternEntryPtr patternEntries = - malloc(self->entryCount * sizeof(MP4CompactSampleToGroupPatternEntry)); - TESTMALLOC(patternEntries); - u32 upperNibble = 0; - - for(i = 0; i < self->entryCount; i++) - { - u32 sampleCount, patternLength; - - GetData(s, inputStream, patternFieldSize, &upperNibble, &patternLength); - patternEntries[i].patternLength = patternLength; - - GetData(s, inputStream, countFieldSize, &upperNibble, &sampleCount); - patternEntries[i].sampleCount = sampleCount; - self->sampleCount += sampleCount; - - sprintf(msgString, "pattern entry %d: pattern length->%d sample count->%d ", i + 1, - patternLength, sampleCount); - inputStream->msg(inputStream, msgString); - } - - err = ensureSize(self, self->sampleCount * sizeof(u32)); - if(err) goto bail; - p = &((self->group_index)[0]); - - sprintf(msgString, "Index description values are:"); - inputStream->msg(inputStream, msgString); - for(i = 0; i < self->entryCount; i++) - { - u32 *patternStart = p; - u32 mask = - self->fragmentLocalIndexPresent ? 0xFFFFFFFF >> (32 - indexFieldSize + 1) : 0xFFFFFFFF; - for(j = 0; j < patternEntries[i].sampleCount; j++) - { - if(j < patternEntries[i].patternLength) - { - u32 indexValue; - GetData(s, inputStream, indexFieldSize, &upperNibble, &indexValue); - indexValue = indexValue & mask; - *p++ = indexValue; - sprintf(msgString + (i * 2), "%d ", indexValue); - } - else - { - *p++ = *(patternStart + (j % patternEntries[i].patternLength)); - } - } - } - inputStream->msg(inputStream, msgString); - - free(patternEntries); - patternEntries = NULL; - -bail: - TEST_RETURN(err); - - return err; -} - -MP4Err MP4CreateCompactSampletoGroupAtom(MP4CompactSampletoGroupAtomPtr *outAtom) -{ - MP4Err err; - MP4CompactSampletoGroupAtomPtr self; - - self = (MP4CompactSampletoGroupAtomPtr)calloc(1, sizeof(MP4CompactSampletoGroupAtom)); - TESTMALLOC(self) - - err = MP4CreateFullAtom((MP4AtomPtr)self); - if(err) goto bail; - self->type = MP4CompactSampletoGroupAtomType; - self->name = "compact sample to group"; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->mapSamplestoGroup = mapSamplestoGroup; - self->addSamples = addSamples; - self->getSampleGroupMap = getSampleGroupMap; - self->group_index = NULL; - self->flags = 0; - self->sampleCount = 0; - self->fragmentLocalIndexPresent = 0; - memset(&self->compressedGroup, 0, sizeof(CompressedGroupInfo)); - - *outAtom = self; -bail: - TEST_RETURN(err); - - return err; -} diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index 6695686..37bf455 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -429,14 +429,6 @@ typedef struct MP4TrackGroupAtom MP4LinkedList atomList; } MP4TrackGroupAtom, *MP4TrackGroupAtomPtr; -// TODO: use this enum instead of u32 -typedef enum sampleToGroupType_t -{ - SAMPLE_GROUP_NORMAL = 0, - SAMPLE_GROUP_COMPRESSED, - SAMPLE_GROUP_AUTO -} sampleToGroupType_t; - typedef struct MP4MediaAtom { MP4_BASE_ATOM @@ -478,7 +470,7 @@ typedef struct MP4MediaAtom MP4AtomPtr extendedLanguageTag; MP4LinkedList atomList; MP4AtomPtr true_minf; - u32 sampleToGroupType; + sampleToGroupType_t sampleToGroupType; } MP4MediaAtom, *MP4MediaAtomPtr; typedef struct MP4MediaHeaderAtom @@ -524,7 +516,7 @@ typedef struct MP4ExtendedLanguageTag s32 mdatOffset); \ MP4Err (*mapSamplestoGroup)(struct MP4MediaInformationAtom * self, u32 groupType, \ u32 group_index, s32 sample_index, u32 count, \ - u32 sampleToGroupType); \ + sampleToGroupType_t sampleToGroupType); \ MP4Err (*setSampleDependency)(struct MP4MediaInformationAtom * self, s32 sample_index, \ MP4Handle dependencies); @@ -718,7 +710,7 @@ typedef struct MP4SampleTableAtom MP4Err (*addGroupDescription)(struct MP4SampleTableAtom *self, u32 theType, MP4Handle theDescription, u32 *index); MP4Err (*mapSamplestoGroup)(struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, - s32 sample_index, u32 count, u32 sampleToGroupType); + s32 sample_index, u32 count, sampleToGroupType_t sampleToGroupType); MP4Err (*getSampleGroupMap)(struct MP4SampleTableAtom *self, u32 groupType, u32 sample_number, u32 *group_index); MP4Err (*getSampleGroupSampleNumbers)(struct MP4SampleTableAtom *self, u32 groupType, @@ -1749,7 +1741,7 @@ typedef struct MP4SampletoGroupAtom u32 entryCount; u32 allocatedSize; - u32 sampleToGroupType; /* 0 - normal; 1 - compact; 2 - auto */ + sampleToGroupType_t sampleToGroupType; /* these are required for CompactSampletoGroup */ u32 groupingTypeParameter; @@ -2123,7 +2115,7 @@ MP4Err MP4CreateEncVisualSampleEntryAtom(MP4EncVisualSampleEntryAtomPtr *outAtom MP4Err MP4CreateEncBaseAtom(MP4EncBaseSampleEntryAtomPtr outAtom); #endif -MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, u32 sampleToGroupType); // sampleToGroupType_t +MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, sampleToGroupType_t sampleToGroupType); MP4Err MP4CreateSampleGroupDescriptionAtom(MP4SampleGroupDescriptionAtomPtr *outAtom); MP4Err MP4CreateSampleDependencyAtom(MP4SampleDependencyAtomPtr *outAtom); diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index e7a8afe..2a0665c 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -202,7 +202,7 @@ ISOGetGroupDescription(MP4Media media, u32 groupType, u32 index, MP4Handle descr } MP4_EXTERN(MP4Err) -ISOSetSamplestoGroupType(MP4Media media, u32 sampleToGroupType) +ISOSetSamplestoGroupType(MP4Media media, sampleToGroupType_t sampleToGroupType) { MP4Err err; MP4MediaAtomPtr mdia; diff --git a/IsoLib/libisomediafile/src/MP4Movies.h b/IsoLib/libisomediafile/src/MP4Movies.h index 93701cc..d1d43a0 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.h +++ b/IsoLib/libisomediafile/src/MP4Movies.h @@ -15,89 +15,96 @@ extern "C" #define ISMACrypt - typedef int MP4Err; +typedef int MP4Err; - enum - { - /* JLF 12/00 : support for OD, returned by MP4GetInline... and MP4GetProfiles... */ - MP4HasRootOD = 2, - MP4EOF = 1, - MP4NoErr = 0, - MP4FileNotFoundErr = -1, - MP4BadParamErr = -2, - MP4NoMemoryErr = -3, - MP4IOErr = -4, - MP4NoLargeAtomSupportErr = -5, - MP4BadDataErr = -6, - MP4VersionNotSupportedErr = -7, - MP4InvalidMediaErr = -8, - MP4InternalErr = -9, - MP4NotFoundErr = -10, - MP4DataEntryTypeNotSupportedErr = -100, - MP4NoQTAtomErr = -500, - MP4NotImplementedErr = -1000 - }; - - enum - { - MP4OpenMovieNormal = 0, - MP4OpenMovieDebug = (1 << 0), - MP4OpenMovieInPlace = (1 << 1) - - }; - - enum - { - MP4NewTrackIsVisual = (1 << 1), - MP4NewTrackIsAudio = (1 << 2), - MP4NewTrackIsMetadata = (1 << 3), - MP4NewTrackIsPrivate = (1 << 8) - }; +enum +{ + /* JLF 12/00 : support for OD, returned by MP4GetInline... and MP4GetProfiles... */ + MP4HasRootOD = 2, + MP4EOF = 1, + MP4NoErr = 0, + MP4FileNotFoundErr = -1, + MP4BadParamErr = -2, + MP4NoMemoryErr = -3, + MP4IOErr = -4, + MP4NoLargeAtomSupportErr = -5, + MP4BadDataErr = -6, + MP4VersionNotSupportedErr = -7, + MP4InvalidMediaErr = -8, + MP4InternalErr = -9, + MP4NotFoundErr = -10, + MP4DataEntryTypeNotSupportedErr = -100, + MP4NoQTAtomErr = -500, + MP4NotImplementedErr = -1000 +}; + +enum +{ + MP4OpenMovieNormal = 0, + MP4OpenMovieDebug = (1 << 0), + MP4OpenMovieInPlace = (1 << 1) - enum - { - MP4ObjectDescriptorHandlerType = MP4_FOUR_CHAR_CODE('o', 'd', 's', 'm'), - MP4ClockReferenceHandlerType = MP4_FOUR_CHAR_CODE('c', 'r', 's', 'm'), - MP4SceneDescriptionHandlerType = MP4_FOUR_CHAR_CODE('s', 'd', 's', 'm'), - MP4VisualHandlerType = MP4_FOUR_CHAR_CODE('v', 'i', 'd', 'e'), - MP4AudioHandlerType = MP4_FOUR_CHAR_CODE('s', 'o', 'u', 'n'), - MP4MPEG7HandlerType = MP4_FOUR_CHAR_CODE('m', '7', 's', 'm'), - MP4OCIHandlerType = MP4_FOUR_CHAR_CODE('o', 'c', 's', 'm'), - MP4IPMPHandlerType = MP4_FOUR_CHAR_CODE('i', 'p', 's', 'm'), - MP4MPEGJHandlerType = MP4_FOUR_CHAR_CODE('m', 'j', 's', 'm'), - MP4HintHandlerType = MP4_FOUR_CHAR_CODE('h', 'i', 'n', 't'), - MP4TextHandlerType = MP4_FOUR_CHAR_CODE('t', 'e', 'x', 't'), - MP7TextHandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '7', 't'), - MP7BinaryHandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '7', 'b'), - MP21HandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '2', '1'), - MP4NullHandlerType = MP4_FOUR_CHAR_CODE('n', 'u', 'l', 'l'), - MP4MetaHandlerType = MP4_FOUR_CHAR_CODE('m', 'e', 't', 'a'), - - ISOXMLAtomType = MP4_FOUR_CHAR_CODE('x', 'm', 'l', ' '), - ISOBinaryXMLAtomType = MP4_FOUR_CHAR_CODE('b', 'x', 'm', 'l') +}; - }; +enum +{ + MP4NewTrackIsVisual = (1 << 1), + MP4NewTrackIsAudio = (1 << 2), + MP4NewTrackIsMetadata = (1 << 3), + MP4NewTrackIsPrivate = (1 << 8) +}; - enum - { - MP4IPMP_NoControlPoint = 0x00, - MP4IPMP_DB_Decoder_ControlPoint = 0x01, - MP4IPMP_Decoder_CB_ControlPoint = 0x02, - MP4IPMP_CB_Compositor_ControlPoint = 0x03, - MP4IPMP_BIFSTree_ControlPoint = 0x04 - }; +enum +{ + MP4ObjectDescriptorHandlerType = MP4_FOUR_CHAR_CODE('o', 'd', 's', 'm'), + MP4ClockReferenceHandlerType = MP4_FOUR_CHAR_CODE('c', 'r', 's', 'm'), + MP4SceneDescriptionHandlerType = MP4_FOUR_CHAR_CODE('s', 'd', 's', 'm'), + MP4VisualHandlerType = MP4_FOUR_CHAR_CODE('v', 'i', 'd', 'e'), + MP4AudioHandlerType = MP4_FOUR_CHAR_CODE('s', 'o', 'u', 'n'), + MP4MPEG7HandlerType = MP4_FOUR_CHAR_CODE('m', '7', 's', 'm'), + MP4OCIHandlerType = MP4_FOUR_CHAR_CODE('o', 'c', 's', 'm'), + MP4IPMPHandlerType = MP4_FOUR_CHAR_CODE('i', 'p', 's', 'm'), + MP4MPEGJHandlerType = MP4_FOUR_CHAR_CODE('m', 'j', 's', 'm'), + MP4HintHandlerType = MP4_FOUR_CHAR_CODE('h', 'i', 'n', 't'), + MP4TextHandlerType = MP4_FOUR_CHAR_CODE('t', 'e', 'x', 't'), + MP7TextHandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '7', 't'), + MP7BinaryHandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '7', 'b'), + MP21HandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '2', '1'), + MP4NullHandlerType = MP4_FOUR_CHAR_CODE('n', 'u', 'l', 'l'), + MP4MetaHandlerType = MP4_FOUR_CHAR_CODE('m', 'e', 't', 'a'), + + ISOXMLAtomType = MP4_FOUR_CHAR_CODE('x', 'm', 'l', ' '), + ISOBinaryXMLAtomType = MP4_FOUR_CHAR_CODE('b', 'x', 'm', 'l') + +}; + +enum +{ + MP4IPMP_NoControlPoint = 0x00, + MP4IPMP_DB_Decoder_ControlPoint = 0x01, + MP4IPMP_Decoder_CB_ControlPoint = 0x02, + MP4IPMP_CB_Compositor_ControlPoint = 0x03, + MP4IPMP_BIFSTree_ControlPoint = 0x04 +}; + +enum +{ + does_depend_on = 0x10, + does_not_depend_on = 0x20, - enum - { - does_depend_on = 0x10, - does_not_depend_on = 0x20, + is_depended_on = 0x4, + is_not_depended_on = 0x8, - is_depended_on = 0x4, - is_not_depended_on = 0x8, + has_redundancy = 1, + has_no_redundancy = 2 +}; - has_redundancy = 1, - has_no_redundancy = 2 - }; +typedef enum sampleToGroupType_t +{ + SAMPLE_GROUP_NORMAL = 0, + SAMPLE_GROUP_COMPRESSED, + SAMPLE_GROUP_AUTO +} sampleToGroupType_t; #define GETMOOV(arg) \ MP4PrivateMovieRecordPtr moov; \ diff --git a/IsoLib/libisomediafile/src/MediaInformationAtom.c b/IsoLib/libisomediafile/src/MediaInformationAtom.c index f9aeb3a..9d79aec 100644 --- a/IsoLib/libisomediafile/src/MediaInformationAtom.c +++ b/IsoLib/libisomediafile/src/MediaInformationAtom.c @@ -564,7 +564,7 @@ static MP4Err getGroupDescription(struct MP4MediaInformationAtom *self, u32 grou static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, - u32 sampleToGroupType) + sampleToGroupType_t sampleToGroupType) { MP4Err err; MP4SampleTableAtomPtr stbl; diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index f00b0b3..862a5cc 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -615,7 +615,7 @@ static MP4Err mergeSampleGroupDescriptions(struct MP4SampleTableAtom *self, MP4A } static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, - s32 sample_index, u32 count, u32 sampleToGroupType) + s32 sample_index, u32 count, sampleToGroupType_t sampleToGroupType) { MP4Err err; MP4SampletoGroupAtomPtr theGroup; diff --git a/IsoLib/libisomediafile/src/SampleToGroupAtom.c b/IsoLib/libisomediafile/src/SampleToGroupAtom.c index 18b15e2..4ccbea3 100644 --- a/IsoLib/libisomediafile/src/SampleToGroupAtom.c +++ b/IsoLib/libisomediafile/src/SampleToGroupAtom.c @@ -924,7 +924,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre return err; } -MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, u32 sampleToGroupType) +MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, sampleToGroupType_t sampleToGroupType) { MP4Err err; MP4SampletoGroupAtomPtr self; diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index 08b987c..2835bf7 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -783,7 +783,7 @@ static MP4Err calculateDataEnd(MP4TrackFragmentAtomPtr self, u32 *outEnd) } static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType, u32 group_index, - s32 sample_index, u32 count, u32 sampleToGroupType) + s32 sample_index, u32 count, sampleToGroupType_t sampleToGroupType) { MP4Err err; MP4TrackFragmentAtomPtr self; diff --git a/IsoLib/playground/main.cpp b/IsoLib/playground/main.cpp index 099e9b7..9fac4ce 100644 --- a/IsoLib/playground/main.cpp +++ b/IsoLib/playground/main.cpp @@ -267,7 +267,7 @@ ISOErr createFile(std::string strFilename) { err = MP4EndMediaEdits(media); std::cout << "fragment 1" << std::endl; - ISOSetSamplestoGroupType(media,0); + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); err = ISOStartMovieFragment( moov ); if(err) return err; err = addSamples(media, "rb", 3); if(err) return err; err = addGroupDescription(media, FOURCC_COLOR, "This must pass even if in stbl", temp); if(err) return err; @@ -278,7 +278,7 @@ ISOErr createFile(std::string strFilename) { err = mapSamplesToGroups(media, "rb", 3); if(err) return err; std::cout << "fragment 2 (compressed sample group)" << std::endl; - ISOSetSamplestoGroupType(media, 1); + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_COMPRESSED); err = ISOStartMovieFragment( moov ); if(err) return err; err = addSamples(media, "gry", 2); if(err) return err; err = addGroupDescription(media, FOURCC_TEST, "Same as in previous fragment but different entry", groupIdBlue); if(err) return err; @@ -286,7 +286,7 @@ ISOErr createFile(std::string strFilename) { err = mapSamplesToGroups(media, "gry", 2); if(err) return err; std::cout << "fragment 3" << std::endl; - ISOSetSamplestoGroupType(media, 0); + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); err = ISOStartMovieFragment( moov ); if(err) return err; err = addSamples(media, "bgy", 2); if(err) return err; err = mapSamplesToGroups(media, "bgy", 2); if(err) return err; From 426bf758ec6395df8c1f0a77e4e47697d766701b Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Mon, 16 Nov 2020 16:44:29 +0100 Subject: [PATCH 24/55] BugFix: last sample number index --- IsoLib/libisomediafile/src/SampleTableAtom.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index 862a5cc..e5d3fe0 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -708,7 +708,7 @@ static MP4Err getSampleGroupSampleNumbers(struct MP4SampleTableAtom *self, u32 g } if(cur_index == groupIndex) { - (*outSampleNumbers)[(*outSampleCnt)++] = i+1; + (*outSampleNumbers)[(*outSampleCnt)++] = i; } } From f9ce355f9a5bcc5b441bc4de7c934d357aa6214d Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Mon, 16 Nov 2020 22:30:10 +0100 Subject: [PATCH 25/55] implement changeSamplestoGroupType and automatic mode for sampleToGroups --- IsoLib/libisomediafile/src/MP4Atoms.c | 2 +- IsoLib/libisomediafile/src/MP4Atoms.h | 9 +- IsoLib/libisomediafile/src/MP4Media.c | 3 + IsoLib/libisomediafile/src/MP4Movies.h | 6 +- IsoLib/libisomediafile/src/MediaAtom.c | 18 +++ .../src/MediaInformationAtom.c | 19 +++ IsoLib/libisomediafile/src/SampleTableAtom.c | 27 ++++ .../libisomediafile/src/SampleToGroupAtom.c | 128 ++++++++++++++---- .../libisomediafile/src/TrackFragmentAtom.c | 56 ++++++-- IsoLib/playground/main.cpp | 58 ++++++-- 10 files changed, 269 insertions(+), 57 deletions(-) diff --git a/IsoLib/libisomediafile/src/MP4Atoms.c b/IsoLib/libisomediafile/src/MP4Atoms.c index 2c201ab..996c6f2 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.c +++ b/IsoLib/libisomediafile/src/MP4Atoms.c @@ -558,7 +558,7 @@ MP4Err MP4CreateAtom(u32 atomType, MP4AtomPtr *outAtom) case MP4SampletoGroupAtomType: case MP4CompactSampletoGroupAtomType: - err = MP4CreateSampletoGroupAtom((MP4SampletoGroupAtomPtr *)&newAtom, 0); + err = MP4CreateSampletoGroupAtom((MP4SampletoGroupAtomPtr *)&newAtom, SAMPLE_GROUP_COMPACT); break; case ISOMetaAtomType: diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index 37bf455..0d06ae5 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -446,6 +446,7 @@ typedef struct MP4MediaAtom MP4Err (*settrackfragment)(struct MP4MediaAtom *self, MP4AtomPtr fragment); MP4Err (*addGroupDescription)(struct MP4MediaAtom *self, u32 groupType, MP4Handle description, u32 *index); + MP4Err (*changeSamplestoGroupType)(struct MP4MediaAtom *self, sampleToGroupType_t sampleToGroupType); MP4Err (*mapSamplestoGroup)(struct MP4MediaAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count); MP4Err (*getSampleGroupMap)(struct MP4MediaAtom *self, u32 groupType, u32 sample_number, @@ -518,7 +519,9 @@ typedef struct MP4ExtendedLanguageTag u32 group_index, s32 sample_index, u32 count, \ sampleToGroupType_t sampleToGroupType); \ MP4Err (*setSampleDependency)(struct MP4MediaInformationAtom * self, s32 sample_index, \ - MP4Handle dependencies); + MP4Handle dependencies); \ + MP4Err (*changeSamplestoGroupType)(struct MP4MediaInformationAtom * self, \ + sampleToGroupType_t sampleToGroupType); typedef struct MP4MediaInformationAtom { @@ -709,6 +712,7 @@ typedef struct MP4SampleTableAtom MP4Err (*setDefaultSampleEntry)(struct MP4SampleTableAtom *self, u32 index); MP4Err (*addGroupDescription)(struct MP4SampleTableAtom *self, u32 theType, MP4Handle theDescription, u32 *index); + MP4Err (*changeSamplestoGroupType)(struct MP4SampleTableAtom *self, sampleToGroupType_t sampleToGroupType); MP4Err (*mapSamplestoGroup)(struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, sampleToGroupType_t sampleToGroupType); MP4Err (*getSampleGroupMap)(struct MP4SampleTableAtom *self, u32 groupType, u32 sample_number, @@ -1358,7 +1362,7 @@ typedef struct MP4TrackFragmentAtom MP4LinkedList atomList; /* track runs */ MP4LinkedList groupDescriptionList; /* sample group description list */ - MP4LinkedList groupList; /* sample to group maps */ + MP4LinkedList sampletoGroupList; /* sample to group maps */ MP4LinkedList saizList; MP4LinkedList saioList; } MP4TrackFragmentAtom, *MP4TrackFragmentAtomPtr; @@ -1752,6 +1756,7 @@ typedef struct MP4SampletoGroupAtom MP4Err (*addSamples)(struct MP4SampletoGroupAtom *self, u32 count); MP4Err (*mapSamplestoGroup)(struct MP4SampletoGroupAtom *self, u32 group_index, s32 sample_index, u32 count); + MP4Err (*changeSamplestoGroupType)(struct MP4SampletoGroupAtom *self, sampleToGroupType_t sampleToGroupType); MP4Err (*getSampleGroupMap)(struct MP4SampletoGroupAtom *self, u32 sampleNumber, u32 *groupIndex); } MP4SampletoGroupAtom, *MP4SampletoGroupAtomPtr; diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index 2a0665c..b3b1a33 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -215,6 +215,9 @@ ISOSetSamplestoGroupType(MP4Media media, sampleToGroupType_t sampleToGroupType) mdia = (MP4MediaAtomPtr)media; mdia->sampleToGroupType = sampleToGroupType; + err = mdia->changeSamplestoGroupType(mdia, sampleToGroupType); + if(err) goto bail; + bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/MP4Movies.h b/IsoLib/libisomediafile/src/MP4Movies.h index d1d43a0..aed06ab 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.h +++ b/IsoLib/libisomediafile/src/MP4Movies.h @@ -101,9 +101,9 @@ enum typedef enum sampleToGroupType_t { - SAMPLE_GROUP_NORMAL = 0, - SAMPLE_GROUP_COMPRESSED, - SAMPLE_GROUP_AUTO + SAMPLE_GROUP_NORMAL = 0, /* sbgp */ + SAMPLE_GROUP_COMPACT, /* csgp */ + SAMPLE_GROUP_AUTO /* automatically decide based on atom size */ } sampleToGroupType_t; #define GETMOOV(arg) \ diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index 8f5a62c..48656f3 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -352,6 +352,23 @@ static MP4Err getGroupDescription(struct MP4MediaAtom *self, u32 groupType, u32 return err; } +static MP4Err changeSamplestoGroupType(struct MP4MediaAtom *self, sampleToGroupType_t sampleToGroupType) +{ + MP4Err err; + MP4MediaInformationAtomPtr minf; + + err = MP4NoErr; + minf = (MP4MediaInformationAtomPtr)self->information; /* this can be 'traf' if fragmented */ + assert(minf); + assert(minf->changeSamplestoGroupType); + err = minf->changeSamplestoGroupType(minf, sampleToGroupType); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err mapSamplestoGroup(struct MP4MediaAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count) { @@ -540,6 +557,7 @@ MP4Err MP4CreateMediaAtom(MP4MediaAtomPtr *outAtom) self->addSampleReference = addSampleReference; self->settrackfragment = settrackfragment; self->addGroupDescription = addGroupDescription; + self->changeSamplestoGroupType = changeSamplestoGroupType; self->mapSamplestoGroup = mapSamplestoGroup; self->getSampleGroupMap = getSampleGroupMap; self->getSampleGroupSampleNumbers = getSampleGroupSampleNumbers; diff --git a/IsoLib/libisomediafile/src/MediaInformationAtom.c b/IsoLib/libisomediafile/src/MediaInformationAtom.c index 9d79aec..ed26395 100644 --- a/IsoLib/libisomediafile/src/MediaInformationAtom.c +++ b/IsoLib/libisomediafile/src/MediaInformationAtom.c @@ -562,6 +562,24 @@ static MP4Err getGroupDescription(struct MP4MediaInformationAtom *self, u32 grou return err; } +static MP4Err changeSamplestoGroupType(struct MP4MediaInformationAtom *self, sampleToGroupType_t sampleToGroupType) +{ + MP4Err err; + MP4SampleTableAtomPtr stbl; + + err = MP4NoErr; + + stbl = (MP4SampleTableAtomPtr)self->sampleTable; + assert(stbl); + assert(stbl->changeSamplestoGroupType); + err = stbl->changeSamplestoGroupType(stbl, sampleToGroupType); + if(err) goto bail; +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, sampleToGroupType_t sampleToGroupType) @@ -787,6 +805,7 @@ MP4Err MP4CreateMediaInformationAtom(MP4MediaInformationAtomPtr *outAtom) self->addSampleReference = addSampleReference; self->testDataEntry = testDataEntry; self->addGroupDescription = addGroupDescription; + self->changeSamplestoGroupType = changeSamplestoGroupType; self->mapSamplestoGroup = mapSamplestoGroup; self->getSampleGroupMap = getSampleGroupMap; self->getSampleGroupSampleNumbers = getSampleGroupSampleNumbers; diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index e5d3fe0..32b6e28 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -614,6 +614,32 @@ static MP4Err mergeSampleGroupDescriptions(struct MP4SampleTableAtom *self, MP4A return err; } +static MP4Err changeSamplestoGroupType(struct MP4SampleTableAtom *self, sampleToGroupType_t sampleToGroupType) +{ + MP4Err err; + u32 i, count; + + err = MP4GetListEntryCount(self->sampletoGroupList, &count); + if(err) goto bail; + + for(i = 0; i < count; i++) + { + MP4AtomPtr desc; + err = MP4GetListEntry(self->sampletoGroupList, i, (char **)&desc); + if(err) goto bail; + if(desc) + { + MP4SampletoGroupAtomPtr grp = (MP4SampletoGroupAtomPtr)desc; + grp->changeSamplestoGroupType(grp, sampleToGroupType); + } + } + +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, sampleToGroupType_t sampleToGroupType) { @@ -858,6 +884,7 @@ MP4Err MP4CreateSampleTableAtom(MP4SampleTableAtomPtr *outAtom) self->setDefaultSampleEntry = setDefaultSampleEntry; self->addGroupDescription = addGroupDescription; + self->changeSamplestoGroupType = changeSamplestoGroupType; self->mapSamplestoGroup = mapSamplestoGroup; self->getSampleGroupMap = getSampleGroupMap; self->getSampleGroupSampleNumbers = getSampleGroupSampleNumbers; diff --git a/IsoLib/libisomediafile/src/SampleToGroupAtom.c b/IsoLib/libisomediafile/src/SampleToGroupAtom.c index 4ccbea3..42ccb95 100644 --- a/IsoLib/libisomediafile/src/SampleToGroupAtom.c +++ b/IsoLib/libisomediafile/src/SampleToGroupAtom.c @@ -538,6 +538,39 @@ static MP4Err mapSamplestoGroup(struct MP4SampletoGroupAtom *self, u32 group_ind return err; } +static MP4Err changeSamplestoGroupType(struct MP4SampletoGroupAtom *self, sampleToGroupType_t sampleToGroupType) +{ + MP4Err err; + + if(self == NULL) BAILWITHERROR(MP4BadParamErr) + + self->sampleToGroupType = sampleToGroupType; + switch (self->sampleToGroupType) + { + case SAMPLE_GROUP_NORMAL: + self->type = MP4SampletoGroupAtomType; + self->name = "sample to group"; + break; + case SAMPLE_GROUP_COMPACT: + self->type = MP4CompactSampletoGroupAtomType; + self->name = "compact sample to group"; + break; + case SAMPLE_GROUP_AUTO: + self->type = 0; + self->name = "auto sample to group"; + break; + default: + self->type = MP4SampletoGroupAtomType; + self->name = "(default) sample to group"; + break; + } + +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err getSampleGroupMap(struct MP4SampletoGroupAtom *self, u32 sampleNumber, u32 *groupIndex) { @@ -646,8 +679,7 @@ static MP4Err PackData(MP4SampletoGroupAtomPtr self, char **bufferPtr, u8 fieldS static MP4Err serialize(struct MP4Atom *s, char *buffer) { MP4Err err; - u32 i; - u32 cur_index, cur_count, entryCount; + u32 i, cur_index, cur_count, entryCount; MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; err = MP4NoErr; @@ -739,41 +771,77 @@ static MP4Err calculateSize(struct MP4Atom *s) { MP4Err err; MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; - u32 entryCount, i; + u32 entryCount, i, normalSize, compactSize; err = MP4NoErr; err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if(err) goto bail; - if(self->type == MP4SampletoGroupAtomType) + if(self->sampleToGroupType != SAMPLE_GROUP_AUTO) { - entryCount = 1; - for(i = 1; i < (self->sampleCount); i++) + if(self->type == MP4SampletoGroupAtomType) { - if((self->group_index)[i - 1] != (self->group_index)[i]) entryCount++; + entryCount = 1; + for(i = 1; i < (self->sampleCount); i++) + { + if((self->group_index)[i - 1] != (self->group_index)[i]) entryCount++; + } + self->size += (entryCount * 8) + 8; + self->entryCount = entryCount; + } + else if(self->type == MP4CompactSampletoGroupAtomType) + { + CreateCompactSampleGroups(self); + + /* If grouping type parameter is enabled in flags, will need to add an additional byte*/ + self->size += 8; + + u32 sizeInBits = + (self->compressedGroup.patternCount * + (self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); + sizeInBits += + (self->compressedGroup.totalIndexDescriptionCount * self->compressedGroup.indexFieldSize); + self->size = self->size + (sizeInBits + 4) / 8; + + self->entryCount = self->compressedGroup.patternCount; } - self->size += (entryCount * 8) + 8; - self->entryCount = entryCount; } else { + normalSize = compactSize = self->size; + /* normal */ + entryCount = 1; + for(i = 1; i < (self->sampleCount); i++) + { + if((self->group_index)[i - 1] != (self->group_index)[i]) entryCount++; + } + normalSize += (entryCount * 8) + 8; + /* compact */ CreateCompactSampleGroups(self); - - /* If grouping type parameter is enabled in flags, will need to add an additional byte*/ - self->size += 8; - + compactSize += 8; u32 sizeInBits = (self->compressedGroup.patternCount * (self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); sizeInBits += (self->compressedGroup.totalIndexDescriptionCount * self->compressedGroup.indexFieldSize); - self->size = self->size + (sizeInBits + 4) / 8; + compactSize += (sizeInBits + 4) / 8; - self->entryCount = self->compressedGroup.patternCount; + /* pick compact only if the size is smaller */ + if(normalSize<=compactSize) + { + self->changeSamplestoGroupType(self, SAMPLE_GROUP_NORMAL); + self->size = normalSize; + self->entryCount = entryCount; + } + else + { + self->changeSamplestoGroupType(self, SAMPLE_GROUP_COMPACT); + self->size = compactSize; + self->entryCount = self->compressedGroup.patternCount; + } } - bail: TEST_RETURN(err); @@ -934,16 +1002,25 @@ MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, sampleToGrou err = MP4CreateFullAtom((MP4AtomPtr)self); if(err) goto bail; - self->sampleToGroupType = sampleToGroupType; - if(self->sampleToGroupType == 0) + self->sampleToGroupType = sampleToGroupType; + switch (self->sampleToGroupType) { - self->type = MP4SampletoGroupAtomType; - self->name = "sample to group"; - } - else //if(self->sampleToGroupType == 1) - { - self->type = MP4CompactSampletoGroupAtomType; - self->name = "compact sample to group"; + case SAMPLE_GROUP_NORMAL: + self->type = MP4SampletoGroupAtomType; + self->name = "sample to group"; + break; + case SAMPLE_GROUP_COMPACT: + self->type = MP4CompactSampletoGroupAtomType; + self->name = "compact sample to group"; + break; + case SAMPLE_GROUP_AUTO: + self->type = 0; + self->name = "auto sample to group"; + break; + default: + self->type = MP4SampletoGroupAtomType; + self->name = "(default) sample to group"; + break; } self->createFromInputStream = (cisfunc)createFromInputStream; self->destroy = destroy; @@ -951,6 +1028,7 @@ MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, sampleToGrou self->serialize = serialize; self->mapSamplestoGroup = mapSamplestoGroup; self->addSamples = addSamples; + self->changeSamplestoGroupType = changeSamplestoGroupType; self->getSampleGroupMap = getSampleGroupMap; self->group_index = NULL; self->sampleCount = 0; diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index 2835bf7..e84fabf 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -35,7 +35,7 @@ static void destroy(MP4AtomPtr s) self = (MP4TrackFragmentAtomPtr)s; if(self == NULL) BAILWITHERROR(MP4BadParamErr) DESTROY_ATOM_LIST_F(atomList); - DESTROY_ATOM_LIST_F(groupList); + DESTROY_ATOM_LIST_F(sampletoGroupList); DESTROY_ATOM_LIST_F(groupDescriptionList); (self->tfhd)->destroy((MP4AtomPtr)(self->tfhd)); (self->tfdt)->destroy((MP4AtomPtr)(self->tfdt)); @@ -73,7 +73,7 @@ static MP4Err addAtom(MP4TrackFragmentAtomPtr self, MP4AtomPtr atom) break; case MP4SampletoGroupAtomType: /* sbgp */ case MP4CompactSampletoGroupAtomType: /* csgp */ - err = MP4AddListEntry(atom, self->groupList); + err = MP4AddListEntry(atom, self->sampletoGroupList); break; case MP4SampleGroupDescriptionAtomType: /* sgpd */ err = MP4AddListEntry(atom, self->groupDescriptionList); @@ -114,12 +114,12 @@ static MP4Err addSampleGroups(struct MP4TrackFragmentAtom *self, u32 sampleCount MP4Err err; u32 groupListSize, i; - err = MP4GetListEntryCount(self->groupList, &groupListSize); + err = MP4GetListEntryCount(self->sampletoGroupList, &groupListSize); if(err) goto bail; for(i = 0; i < groupListSize; i++) { MP4SampletoGroupAtomPtr theGroup; - err = MP4GetListEntry(self->groupList, i, (char **)&theGroup); + err = MP4GetListEntry(self->sampletoGroupList, i, (char **)&theGroup); if(err) goto bail; if(theGroup) { @@ -371,7 +371,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) SERIALIZE_ATOM_LIST(atomList); SERIALIZE_ATOM_LIST(groupDescriptionList); - SERIALIZE_ATOM_LIST(groupList); + SERIALIZE_ATOM_LIST(sampletoGroupList); assert(self->bytesWritten == self->size); } @@ -461,7 +461,7 @@ static MP4Err calculateSize(struct MP4Atom *s) ADD_ATOM_LIST_SIZE(saioList); ADD_ATOM_LIST_SIZE(atomList); ADD_ATOM_LIST_SIZE(groupDescriptionList); - ADD_ATOM_LIST_SIZE(groupList); + ADD_ATOM_LIST_SIZE(sampletoGroupList); } else self->size = 0; @@ -608,17 +608,17 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) } } - if(self->groupList) + if(self->sampletoGroupList) { u32 groupListSize; err = ISOSetSamplestoGroupType((MP4Media)mdia, 0); if(err) goto bail; - err = MP4GetListEntryCount(self->groupList, &groupListSize); + err = MP4GetListEntryCount(self->sampletoGroupList, &groupListSize); if(err) goto bail; for(i = 0; i < groupListSize; i++) { MP4SampletoGroupAtomPtr theGroup; - err = MP4GetListEntry(self->groupList, i, (char **)&theGroup); + err = MP4GetListEntry(self->sampletoGroupList, i, (char **)&theGroup); if(err) goto bail; if(theGroup) { @@ -782,6 +782,37 @@ static MP4Err calculateDataEnd(MP4TrackFragmentAtomPtr self, u32 *outEnd) return err; } +static MP4Err changeSamplestoGroupType(struct MP4MediaInformationAtom *s, sampleToGroupType_t sampleToGroupType) +{ + MP4Err err; + u32 i, count; + MP4TrackFragmentAtomPtr self; + + if(s == NULL) BAILWITHERROR(MP4BadParamErr); + + self = (MP4TrackFragmentAtomPtr)s; + + err = MP4GetListEntryCount(self->sampletoGroupList, &count); + if(err) goto bail; + + for(i = 0; i < count; i++) + { + MP4AtomPtr desc; + err = MP4GetListEntry(self->sampletoGroupList, i, (char **)&desc); + if(err) goto bail; + if(desc) + { + MP4SampletoGroupAtomPtr grp = (MP4SampletoGroupAtomPtr)desc; + grp->changeSamplestoGroupType(grp, sampleToGroupType); + } + } + +bail: + TEST_RETURN(err); + + return err; +} + static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType, u32 group_index, s32 sample_index, u32 count, sampleToGroupType_t sampleToGroupType) { @@ -792,7 +823,7 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType self = (MP4TrackFragmentAtomPtr)s; - err = MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&theGroup); + err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); if(!theGroup) { err = MP4CreateSampletoGroupAtom(&theGroup, sampleToGroupType); @@ -833,7 +864,7 @@ static MP4Err getSampleGroupMap(MP4TrackFragmentAtomPtr self, u32 groupType, u32 MP4Err err; MP4SampletoGroupAtomPtr theGroup; - err = MP4FindGroupAtom(self->groupList, groupType, (MP4AtomPtr *)&theGroup); + err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); if(theGroup) { err = theGroup->getSampleGroupMap(theGroup, sample_number, group_index); @@ -929,7 +960,7 @@ MP4Err MP4CreateTrackFragmentAtom(MP4TrackFragmentAtomPtr *outAtom) self->destroy = destroy; err = MP4MakeLinkedList(&self->atomList); if(err) goto bail; - err = MP4MakeLinkedList(&self->groupList); + err = MP4MakeLinkedList(&self->sampletoGroupList); if(err) goto bail; err = MP4MakeLinkedList(&self->groupDescriptionList); if(err) goto bail; @@ -942,6 +973,7 @@ MP4Err MP4CreateTrackFragmentAtom(MP4TrackFragmentAtomPtr *outAtom) self->calculateDataEnd = calculateDataEnd; self->addGroupDescription = addGroupDescription; + self->changeSamplestoGroupType = changeSamplestoGroupType; self->mapSamplestoGroup = mapSamplestoGroup; self->getSampleGroupMap = getSampleGroupMap; self->getGroupDescription = getGroupDescription; diff --git a/IsoLib/playground/main.cpp b/IsoLib/playground/main.cpp index 9fac4ce..dfb31b4 100644 --- a/IsoLib/playground/main.cpp +++ b/IsoLib/playground/main.cpp @@ -65,18 +65,15 @@ u8 auBlack[] = { const u32 TIMESCALE = 30000; const u32 FPS = 30; -const u32 FOURCC_RED = MP4_FOUR_CHAR_CODE('r', 'e', 'd', ' '); -const u32 FOURCC_BLU = MP4_FOUR_CHAR_CODE('b', 'l', 'u', 'e'); -const u32 FOURCC_GRN = MP4_FOUR_CHAR_CODE('g', 'r', 'e', 'n'); -const u32 FOURCC_YLW = MP4_FOUR_CHAR_CODE('y', 'e', 'l', 'w'); - const u32 FOURCC_COLOR = MP4_FOUR_CHAR_CODE('c', 'o', 'l', 'r'); const u32 FOURCC_TEST = MP4_FOUR_CHAR_CODE('t', 'e', 's', 't'); +const u32 FOURCC_BLACK = MP4_FOUR_CHAR_CODE('b', 'l', 'c', 'k'); u32 groupIdRed = 0; u32 groupIdBlue = 0; u32 groupIdGreen = 0; u32 groupIdYellow = 0; +u32 groupIdBlack = 0; ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, ISOHandle sampleEntryH = 0) { ISOErr err; @@ -278,7 +275,7 @@ ISOErr createFile(std::string strFilename) { err = mapSamplesToGroups(media, "rb", 3); if(err) return err; std::cout << "fragment 2 (compressed sample group)" << std::endl; - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_COMPRESSED); + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_COMPACT); err = ISOStartMovieFragment( moov ); if(err) return err; err = addSamples(media, "gry", 2); if(err) return err; err = addGroupDescription(media, FOURCC_TEST, "Same as in previous fragment but different entry", groupIdBlue); if(err) return err; @@ -291,9 +288,13 @@ ISOErr createFile(std::string strFilename) { err = addSamples(media, "bgy", 2); if(err) return err; err = mapSamplesToGroups(media, "bgy", 2); if(err) return err; - // std::cout << "fragment 4" << std::endl; - // err = ISOStartMovieFragment( moov ); if(err) return err; - // err = addSamples(media, "wk", 3); if(err) return err; + std::cout << "fragment 4" << std::endl; + err = ISOStartMovieFragment( moov ); if(err) return err; + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_AUTO); // FIXME: no sampleToGroupBox in the last fragment + // ISOSetSamplestoGroupType(media, SAMPLE_GROUP_COMPACT); + err = addSamples(media, "wwwk", 1); if(err) return err; + err = addGroupDescription(media, FOURCC_BLACK, "Single black frame", groupIdBlack); if(err) return err; + ISOMapSamplestoGroup(media, FOURCC_BLACK, groupIdBlack, 3, 1); // err = mapSamplesToGroups(media, "wk", 3); if(err) return err; err = MP4WriteMovieToFile(moov, strFilename.c_str()); @@ -303,7 +304,7 @@ ISOErr createFile(std::string strFilename) { int main() { ISOErr err; std::string strFileFrag = "hevc_fragments.mp4"; - std::string strFileDefrag = "hevc_defrag.mp4"; + std::string strFileDefragBase = "hevc_defrag_"; err = createFile(strFileFrag); if(err) { @@ -319,7 +320,8 @@ int main() { u32 trackCount = 0; err = MP4GetMovieTrackCount(moov, &trackCount); - for (u32 trackNumber = 1; trackNumber <= trackCount; ++trackNumber) { + for (u32 trackNumber = 1; trackNumber <= trackCount; ++trackNumber) + { err = ISOGetMovieIndTrack(moov, trackNumber, &trak); err = ISOGetTrackMedia(trak, &media); u32 sampleCnt = 0; @@ -351,11 +353,39 @@ int main() { for(u32 i=0; i Date: Tue, 17 Nov 2020 20:13:45 +0100 Subject: [PATCH 26/55] fix several issues, add missing prototypes, make gcc happy (no warnings) --- .../linux/SimpleFileMappingObject.c | 2 - .../macosx/SimpleFileMappingObject.c | 2 - .../libisomediafile/src/AMRSpecificInfoAtom.c | 10 +-- .../src/AMRWPSpecificInfoAtom.c | 10 +-- IsoLib/libisomediafile/src/BitRateAtom.c | 10 +-- .../libisomediafile/src/ChannelLayoutAtom.c | 13 +-- IsoLib/libisomediafile/src/ChunkOffsetAtom.c | 10 +-- .../src/ClockReferenceMediaHeader.c | 10 +-- .../src/CompatibleSchemeTypeAtom.c | 8 +- .../src/CompositionToDecodeAtom.c | 15 ++-- IsoLib/libisomediafile/src/CopyrightAtom.c | 10 +-- IsoLib/libisomediafile/src/DataEntryURLAtom.c | 11 +-- IsoLib/libisomediafile/src/DataEntryURNAtom.c | 10 +-- .../src/DegradationPriorityAtom.c | 10 +-- .../src/DownMixInstructionsAtom.c | 14 +--- IsoLib/libisomediafile/src/ESDAtom.c | 11 +-- IsoLib/libisomediafile/src/EditAtom.c | 2 +- IsoLib/libisomediafile/src/EditListAtom.c | 5 +- .../libisomediafile/src/ExtendedLanguageTag.c | 10 +-- IsoLib/libisomediafile/src/HEVCConfigAtom.c | 2 +- IsoLib/libisomediafile/src/HandlerAtom.c | 10 +-- .../libisomediafile/src/HintMediaHeaderAtom.c | 10 +-- IsoLib/libisomediafile/src/ISMAKMSAtom.c | 10 +-- IsoLib/libisomediafile/src/ISMASaltAtom.c | 12 +-- .../src/ISMASampleFormatAtom.c | 12 +-- IsoLib/libisomediafile/src/ISMASecurity.c | 3 +- IsoLib/libisomediafile/src/ISOMeta.c | 6 ++ IsoLib/libisomediafile/src/ISOMovies.h | 22 ++++- .../src/ISOSampleDescriptions.c | 6 +- .../libisomediafile/src/ItemInfoEntryAtom.c | 4 +- .../libisomediafile/src/ItemPropertiesAtom.c | 14 +--- .../src/ItemPropertyAssociationAtom.c | 4 +- .../src/ItemPropertyContainerAtom.c | 14 +--- IsoLib/libisomediafile/src/LoudnessAtom.c | 5 +- .../src/MJ2BitsPerComponentAtom.c | 12 +-- .../src/MJ2ColorSpecificationAtom.c | 12 +-- IsoLib/libisomediafile/src/MJ2FileTypeAtom.c | 11 +-- .../libisomediafile/src/MJ2ImageHeaderAtom.c | 11 +-- IsoLib/libisomediafile/src/MJ2SignatureAtom.c | 12 +-- IsoLib/libisomediafile/src/MP4Atoms.c | 4 +- IsoLib/libisomediafile/src/MP4Atoms.h | 2 +- .../src/MP4IPMPDescriptorPointer.c | 6 +- IsoLib/libisomediafile/src/MP4IPMPToolList.c | 4 +- .../libisomediafile/src/MP4IPMPXDefaultData.c | 8 +- IsoLib/libisomediafile/src/MP4Media.c | 6 +- .../src/MP4MemoryInputStream.c | 3 +- IsoLib/libisomediafile/src/MP4MovieFile.c | 4 +- IsoLib/libisomediafile/src/MP4Movies.c | 10 +-- IsoLib/libisomediafile/src/MP4Movies.h | 20 ++++- .../libisomediafile/src/MPEGMediaHeaderAtom.c | 10 +-- IsoLib/libisomediafile/src/MdatDataHandler.c | 12 +-- IsoLib/libisomediafile/src/MediaAtom.c | 4 +- IsoLib/libisomediafile/src/MediaDataAtom.c | 4 +- IsoLib/libisomediafile/src/MediaHeaderAtom.c | 10 +-- .../libisomediafile/src/MetaboxRelationAtom.c | 14 +--- IsoLib/libisomediafile/src/MovieAtom.c | 12 ++- IsoLib/libisomediafile/src/MovieExtendsAtom.c | 5 +- .../libisomediafile/src/MovieFragmentAtom.c | 5 +- .../src/MovieFragmentHeaderAtom.c | 10 +-- IsoLib/libisomediafile/src/MovieHeaderAtom.c | 10 +-- IsoLib/libisomediafile/src/MovieTracks.c | 2 +- .../src/ObjectDescriptorAtom.c | 10 +-- .../src/ObjectDescriptorMediaHeader.c | 10 +-- .../libisomediafile/src/OriginalFormatAtom.c | 12 +-- IsoLib/libisomediafile/src/PCMConfigAtom.c | 10 +-- IsoLib/libisomediafile/src/PaddingBitsAtom.c | 10 +-- IsoLib/libisomediafile/src/PrimaryItemAtom.c | 10 +-- .../src/ProducerReferenceTimeAtom.c | 10 +-- .../SampleAuxiliaryInformationOffsetsAtom.c | 17 ++-- .../src/SampleAuxiliaryInformationSizesAtom.c | 19 ++--- .../src/SampleDependencyAtom.c | 8 +- .../src/SampleGroupDescriptionAtom.c | 8 +- IsoLib/libisomediafile/src/SampleSizeAtom.c | 12 +-- IsoLib/libisomediafile/src/SampleTableAtom.c | 10 +-- .../libisomediafile/src/SampleToGroupAtom.c | 84 +++++++++---------- .../src/SceneDescriptionMediaHeader.c | 10 +-- IsoLib/libisomediafile/src/SchemeTypeAtom.c | 12 +-- IsoLib/libisomediafile/src/SecurityInfoAtom.c | 13 +-- .../libisomediafile/src/SecuritySchemeAtom.c | 4 +- IsoLib/libisomediafile/src/SegmentTypeAtom.c | 15 +--- IsoLib/libisomediafile/src/ShadowSyncAtom.c | 10 +-- .../src/SingleItemTypeReferenceAtom.c | 12 +-- .../src/SoundMediaHeaderAtom.c | 10 +-- .../src/StereoVideoGroupAtom.c | 13 +-- .../src/SubSampleInformationAtom.c | 8 +- .../libisomediafile/src/SubsegmentIndexAtom.c | 6 +- IsoLib/libisomediafile/src/SyncSampleAtom.c | 10 +-- IsoLib/libisomediafile/src/TimeToSampleAtom.c | 4 +- IsoLib/libisomediafile/src/TrackExtendsAtom.c | 10 +-- .../src/TrackExtensionPropertiesAtom.c | 14 +--- .../libisomediafile/src/TrackFragmentAtom.c | 14 ++-- .../src/TrackFragmentDecodeTimeAtom.c | 14 +--- .../src/TrackFragmentHeaderAtom.c | 10 +-- .../src/TrackFragmentRunAtom.c | 28 ++----- .../libisomediafile/src/TrackGroupTypeAtom.c | 2 - IsoLib/libisomediafile/src/TrackHeaderAtom.c | 10 +-- IsoLib/libisomediafile/src/TrackTypeAtom.c | 15 +--- .../src/VideoMediaHeaderAtom.c | 10 +-- 98 files changed, 280 insertions(+), 734 deletions(-) diff --git a/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c b/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c index 1e75ed9..d1aa904 100644 --- a/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c +++ b/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c @@ -54,7 +54,6 @@ static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *pathname) { MP4Err err; struct stat info; - long count; char *separator; SimpleFileMappingObject self = (SimpleFileMappingObject)s; @@ -71,7 +70,6 @@ static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *pathname) self->size = info.st_size; self->data = (char *)malloc(self->size); if(self->data == NULL) BAILWITHERROR(MP4IOErr); - count = self->size; if(read(self->fd, self->data, self->size) != ((s32)self->size)) { BAILWITHERROR(MP4IOErr); diff --git a/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c b/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c index af6d9e3..5bd8150 100644 --- a/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c +++ b/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c @@ -62,7 +62,6 @@ static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *pathname) { MP4Err err; struct stat info; - long count; char *separator; SimpleFileMappingObject self = (SimpleFileMappingObject)s; @@ -97,7 +96,6 @@ static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *pathname) self->size64 = info.st_size; self->data = (char *)malloc(self->size64); if(self->data == NULL) BAILWITHERROR(MP4IOErr); - count = self->size64; if(read(self->fd, self->data, self->size64) != ((s32)self->size64)) { BAILWITHERROR(MP4IOErr); diff --git a/IsoLib/libisomediafile/src/AMRSpecificInfoAtom.c b/IsoLib/libisomediafile/src/AMRSpecificInfoAtom.c index 5f05167..f235007 100644 --- a/IsoLib/libisomediafile/src/AMRSpecificInfoAtom.c +++ b/IsoLib/libisomediafile/src/AMRSpecificInfoAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) Apple Computer and Telefonaktiebolaget LM Ericsson 2001 */ /* - $Id: AMRSpecificInfoAtom.c,v 1.2 2001/10/25 15:53:24 erapefh Exp $ + $Id: AMRSpecificInfoAtom.c,v 1.2 2001/10/25 15:53:24 erapefh Exp $ */ #include "MP4Atoms.h" @@ -29,16 +29,10 @@ derivative works. Copyright (c) Apple Computer and Telefonaktiebolaget LM Ericss static void destroy(MP4AtomPtr s) { - MP4Err err; MP4AMRSpecificInfoAtomPtr self; - err = MP4NoErr; self = (MP4AMRSpecificInfoAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/AMRWPSpecificInfoAtom.c b/IsoLib/libisomediafile/src/AMRWPSpecificInfoAtom.c index fbe52af..7a43b53 100644 --- a/IsoLib/libisomediafile/src/AMRWPSpecificInfoAtom.c +++ b/IsoLib/libisomediafile/src/AMRWPSpecificInfoAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) Apple Computer and Telefonaktiebolaget LM Ericsson 2001 */ /* - $Id: AMRWPSpecificInfoAtom.c,v 1.1 2004/10/26 15:01:47 eanital Exp $ + $Id: AMRWPSpecificInfoAtom.c,v 1.1 2004/10/26 15:01:47 eanital Exp $ */ #include "MP4Atoms.h" @@ -29,16 +29,10 @@ derivative works. Copyright (c) Apple Computer and Telefonaktiebolaget LM Ericss static void destroy(MP4AtomPtr s) { - MP4Err err; MP4AMRWPSpecificInfoAtomPtr self; - err = MP4NoErr; self = (MP4AMRWPSpecificInfoAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/BitRateAtom.c b/IsoLib/libisomediafile/src/BitRateAtom.c index 572e0bd..c8a4803 100644 --- a/IsoLib/libisomediafile/src/BitRateAtom.c +++ b/IsoLib/libisomediafile/src/BitRateAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) Apple Computer and Telefonaktiebolaget LM Ericsson 2001 */ /* - $Id: BitRateAtom.c,v 1.1 2004/09/15 17:00:48 erapefh Exp $ + $Id: BitRateAtom.c,v 1.1 2004/09/15 17:00:48 erapefh Exp $ */ #include "MP4Atoms.h" @@ -29,16 +29,10 @@ derivative works. Copyright (c) Apple Computer and Telefonaktiebolaget LM Ericss static void destroy(MP4AtomPtr s) { - MP4Err err; MP4BitRateAtomPtr self; - err = MP4NoErr; self = (MP4BitRateAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/ChannelLayoutAtom.c b/IsoLib/libisomediafile/src/ChannelLayoutAtom.c index 8a93c6a..7e97503 100644 --- a/IsoLib/libisomediafile/src/ChannelLayoutAtom.c +++ b/IsoLib/libisomediafile/src/ChannelLayoutAtom.c @@ -21,8 +21,8 @@ derivative works. Copyright (c) 2014. */ /* - $Id: ChannelLayoutAtom.c,v 1.1.1.1 2014/09/18 08:10:00 armin Exp $ - */ + $Id: ChannelLayoutAtom.c,v 1.1.1.1 2014/09/18 08:10:00 armin Exp $ +*/ #include "MP4Atoms.h" #include @@ -34,11 +34,9 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4ChannelLayoutAtomPtr self = (MP4ChannelLayoutAtomPtr)s; - err = MP4NoErr; - if(self == NULL) BAILWITHERROR(MP4BadParamErr); + if(self == NULL) return; if(self->definedLayouts != NULL) { @@ -52,11 +50,6 @@ static void destroy(MP4AtomPtr s) MP4DeleteLinkedList(self->definedLayouts); } if(self->super) self->super->destroy(s); - -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/ChunkOffsetAtom.c b/IsoLib/libisomediafile/src/ChunkOffsetAtom.c index 645c928..b23d690 100644 --- a/IsoLib/libisomediafile/src/ChunkOffsetAtom.c +++ b/IsoLib/libisomediafile/src/ChunkOffsetAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ChunkOffsetAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ChunkOffsetAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -31,21 +31,15 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4ChunkOffsetAtomPtr self; - err = MP4NoErr; self = (MP4ChunkOffsetAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->offsets) { free(self->offsets); self->offsets = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/ClockReferenceMediaHeader.c b/IsoLib/libisomediafile/src/ClockReferenceMediaHeader.c index bb30776..0cf0904 100644 --- a/IsoLib/libisomediafile/src/ClockReferenceMediaHeader.c +++ b/IsoLib/libisomediafile/src/ClockReferenceMediaHeader.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ClockReferenceMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ClockReferenceMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -29,14 +29,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c b/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c index da32037..368657a 100644 --- a/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c +++ b/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c @@ -36,11 +36,9 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4CompatibleSchemeTypeAtomPtr self = (MP4CompatibleSchemeTypeAtomPtr)s; - err = MP4NoErr; - if(self == NULL) BAILWITHERROR(MP4BadParamErr); + if(self == NULL) return; /* if there is a scheme_url field, free it */ if(self->scheme_url) @@ -50,10 +48,6 @@ static void destroy(MP4AtomPtr s) } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/CompositionToDecodeAtom.c b/IsoLib/libisomediafile/src/CompositionToDecodeAtom.c index 456f994..c613bb0 100644 --- a/IsoLib/libisomediafile/src/CompositionToDecodeAtom.c +++ b/IsoLib/libisomediafile/src/CompositionToDecodeAtom.c @@ -21,8 +21,8 @@ derivative works. Copyright (c) 2014. */ /* - $Id: CompositionToDecodeAtom.c,v 1.1.1.1 2014/10/21 08:10:00 armin Exp $ - */ + $Id: CompositionToDecodeAtom.c,v 1.1.1.1 2014/10/21 08:10:00 armin Exp $ +*/ #include "MP4Atoms.h" #include @@ -31,17 +31,10 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) @@ -82,6 +75,8 @@ static MP4Err updateFields(struct MP4Atom *s, u32 sampleCount, MP4Handle duratio MP4CompositionToDecodeAtomPtr self = (MP4CompositionToDecodeAtomPtr)s; err = MP4NoErr; + onlyDuration = 0; + onlyOffset = 0; offsets = (s32 *)*compositionOffsetsH; durations = (s32 *)*durationsH; diff --git a/IsoLib/libisomediafile/src/CopyrightAtom.c b/IsoLib/libisomediafile/src/CopyrightAtom.c index 3a7986c..8181658 100644 --- a/IsoLib/libisomediafile/src/CopyrightAtom.c +++ b/IsoLib/libisomediafile/src/CopyrightAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: CopyrightAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: CopyrightAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -30,21 +30,15 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4CopyrightAtomPtr self = (MP4CopyrightAtomPtr)s; - err = MP4NoErr; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->notice) { free(self->notice); self->notice = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/DataEntryURLAtom.c b/IsoLib/libisomediafile/src/DataEntryURLAtom.c index e842b34..adaff31 100644 --- a/IsoLib/libisomediafile/src/DataEntryURLAtom.c +++ b/IsoLib/libisomediafile/src/DataEntryURLAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: DataEntryURLAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: DataEntryURLAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -31,21 +31,14 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4DataEntryURLAtomPtr self = (MP4DataEntryURLAtomPtr)s; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(self->location) { free(self->location); self->location = NULL; } - if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err getOffset(struct MP4DataEntryAtom *self, u64 *outOffset) diff --git a/IsoLib/libisomediafile/src/DataEntryURNAtom.c b/IsoLib/libisomediafile/src/DataEntryURNAtom.c index b0f2ee7..f43b2e3 100644 --- a/IsoLib/libisomediafile/src/DataEntryURNAtom.c +++ b/IsoLib/libisomediafile/src/DataEntryURNAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: DataEntryURNAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: DataEntryURNAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -30,10 +30,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4DataEntryURNAtomPtr self = (MP4DataEntryURNAtomPtr)s; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(self->nameURN) { @@ -42,10 +40,6 @@ static void destroy(MP4AtomPtr s) } if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err getOffset(struct MP4DataEntryAtom *self, u64 *outOffset) diff --git a/IsoLib/libisomediafile/src/DegradationPriorityAtom.c b/IsoLib/libisomediafile/src/DegradationPriorityAtom.c index d4caba3..b202555 100644 --- a/IsoLib/libisomediafile/src/DegradationPriorityAtom.c +++ b/IsoLib/libisomediafile/src/DegradationPriorityAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: DegradationPriorityAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: DegradationPriorityAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -29,11 +29,9 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4DegradationPriorityAtomPtr self; - err = MP4NoErr; self = (MP4DegradationPriorityAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->priorities) { free(self->priorities); @@ -41,10 +39,6 @@ static void destroy(MP4AtomPtr s) } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c b/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c index d2e0caf..2a67e03 100644 --- a/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c +++ b/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c @@ -21,8 +21,8 @@ derivative works. Copyright (c) 2014. */ /* - $Id: DownMixInstructionsAtom.c,v 1.1.1.1 2014/09/18 08:10:00 armin Exp $ - */ + $Id: DownMixInstructionsAtom.c,v 1.1.1.1 2014/09/18 08:10:00 armin Exp $ +*/ #include "MP4Atoms.h" #include @@ -30,19 +30,11 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4DownMixInstructionsAtomPtr self = (MP4DownMixInstructionsAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr); + if(self == NULL) return; if(self->bs_downmix_coefficients) free(self->bs_downmix_coefficients); - if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/ESDAtom.c b/IsoLib/libisomediafile/src/ESDAtom.c index b7b8c51..d99cb55 100644 --- a/IsoLib/libisomediafile/src/ESDAtom.c +++ b/IsoLib/libisomediafile/src/ESDAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ESDAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ESDAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -30,22 +30,15 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4ESDAtomPtr self; - err = MP4NoErr; self = (MP4ESDAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->descriptor) { self->descriptor->destroy(self->descriptor); self->descriptor = NULL; } - if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/EditAtom.c b/IsoLib/libisomediafile/src/EditAtom.c index b006d59..08e141d 100644 --- a/IsoLib/libisomediafile/src/EditAtom.c +++ b/IsoLib/libisomediafile/src/EditAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: EditAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: EditAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" diff --git a/IsoLib/libisomediafile/src/EditListAtom.c b/IsoLib/libisomediafile/src/EditListAtom.c index 3410059..cb67cce 100644 --- a/IsoLib/libisomediafile/src/EditListAtom.c +++ b/IsoLib/libisomediafile/src/EditListAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: EditListAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: EditListAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -75,11 +75,8 @@ static MP4Err getTrackOffset(struct MP4EditListAtom *self, u32 *outTrackStartTim { MP4Err err; u32 entryCount; - edtsEntryPtr p; err = MP4NoErr; - p = NULL; - err = MP4GetListEntryCount(self->entryList, &entryCount); if(entryCount == 0) { diff --git a/IsoLib/libisomediafile/src/ExtendedLanguageTag.c b/IsoLib/libisomediafile/src/ExtendedLanguageTag.c index 7ee0423..75b4159 100644 --- a/IsoLib/libisomediafile/src/ExtendedLanguageTag.c +++ b/IsoLib/libisomediafile/src/ExtendedLanguageTag.c @@ -20,6 +20,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 2014. */ + #include "MP4Atoms.h" #include @@ -27,23 +28,16 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4ExtendedLanguageTagAtomPtr self; - err = MP4NoErr; self = (MP4ExtendedLanguageTagAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->extended_language) { free(self->extended_language); self->extended_language = NULL; } - if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/HEVCConfigAtom.c b/IsoLib/libisomediafile/src/HEVCConfigAtom.c index b0d5024..0363e1b 100644 --- a/IsoLib/libisomediafile/src/HEVCConfigAtom.c +++ b/IsoLib/libisomediafile/src/HEVCConfigAtom.c @@ -105,7 +105,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) /* constantFrameRate (2) + numTemporalLayers (3) + temporalIdNested (1) + lengthSizeMinusOne (2) */ x = /*(1<<6) |*/ (1 << 3) | (self->sps_temporal_id_nesting_flag << 2) | - self->lengthSizeMinusOne + 3; + (self->lengthSizeMinusOne + 3); PUT8_V(x); PUT8(numOfArrays); diff --git a/IsoLib/libisomediafile/src/HandlerAtom.c b/IsoLib/libisomediafile/src/HandlerAtom.c index 01fa990..e0c3ff8 100644 --- a/IsoLib/libisomediafile/src/HandlerAtom.c +++ b/IsoLib/libisomediafile/src/HandlerAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: HandlerAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: HandlerAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -31,20 +31,14 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4HandlerAtomPtr self = (MP4HandlerAtomPtr)s; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(self->nameUTF8) { free(self->nameUTF8); self->nameUTF8 = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/HintMediaHeaderAtom.c b/IsoLib/libisomediafile/src/HintMediaHeaderAtom.c index a8aaf88..a45dc37 100644 --- a/IsoLib/libisomediafile/src/HintMediaHeaderAtom.c +++ b/IsoLib/libisomediafile/src/HintMediaHeaderAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: HintMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: HintMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -29,14 +29,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/ISMAKMSAtom.c b/IsoLib/libisomediafile/src/ISMAKMSAtom.c index 6af41bf..f52693b 100644 --- a/IsoLib/libisomediafile/src/ISMAKMSAtom.c +++ b/IsoLib/libisomediafile/src/ISMAKMSAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ISMAKMSAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ISMAKMSAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -32,21 +32,15 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; ISMAKMSAtomPtr self = (ISMAKMSAtomPtr)s; - err = MP4NoErr; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->kms_url) { free(self->kms_url); self->kms_url = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/ISMASaltAtom.c b/IsoLib/libisomediafile/src/ISMASaltAtom.c index b3f0eb3..5a14cac 100644 --- a/IsoLib/libisomediafile/src/ISMASaltAtom.c +++ b/IsoLib/libisomediafile/src/ISMASaltAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ISMASaltAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ISMASaltAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -32,17 +32,9 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; ISMASaltAtomPtr self = (ISMASaltAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/ISMASampleFormatAtom.c b/IsoLib/libisomediafile/src/ISMASampleFormatAtom.c index a791354..0c3511d 100644 --- a/IsoLib/libisomediafile/src/ISMASampleFormatAtom.c +++ b/IsoLib/libisomediafile/src/ISMASampleFormatAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ISMASampleFormatAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ISMASampleFormatAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -32,17 +32,9 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; ISMASampleFormatAtomPtr self = (ISMASampleFormatAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/ISMASecurity.c b/IsoLib/libisomediafile/src/ISMASecurity.c index e7f2da9..8ecff7a 100644 --- a/IsoLib/libisomediafile/src/ISMASecurity.c +++ b/IsoLib/libisomediafile/src/ISMASecurity.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: ISMASecurity.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: ISMASecurity.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" @@ -65,6 +65,7 @@ ISMATransformSampleEntrySalt(u32 newTrackFlags, MP4Handle insampleEntryH, u8 sel kms = NULL; fmt = NULL; slt = NULL; + is = NULL; if(newTrackFlags & ISONewTrackIsVisual) atomType = MP4EncVisualSampleEntryAtomType; else if(newTrackFlags & ISONewTrackIsAudio) diff --git a/IsoLib/libisomediafile/src/ISOMeta.c b/IsoLib/libisomediafile/src/ISOMeta.c index 16cb297..522ab80 100644 --- a/IsoLib/libisomediafile/src/ISOMeta.c +++ b/IsoLib/libisomediafile/src/ISOMeta.c @@ -113,6 +113,8 @@ ISO_EXTERN(ISOErr) ISONewMovieMeta(ISOMovie theMovie, u32 metaType, ISOMeta *out err = newMeta(&myMeta, metaType); if(err) goto bail; + mecoPtr = NULL; + if(movieAtom->meta != NULL) { if(movieAtom->meta->type == metaType) BAILWITHERROR(MP4BadParamErr); @@ -159,6 +161,8 @@ ISO_EXTERN(ISOErr) ISONewTrackMeta(ISOTrack theTrack, u32 metaType, ISOMeta *out if(err) goto bail; trak = (MP4TrackAtomPtr)theTrack; + mecoPtr = NULL; + if(trak->meta != NULL) { if(trak->meta->type == metaType) BAILWITHERROR(MP4BadParamErr); @@ -1476,6 +1480,8 @@ ISO_EXTERN(ISOErr) ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_of ISOItemDataAtomPtr idat; err = MP4NoErr; + dhlr = NULL; + idat = NULL; myItem = (MetaItemLocationPtr)item; if(myItem == NULL) BAILWITHERROR(MP4BadParamErr) diff --git a/IsoLib/libisomediafile/src/ISOMovies.h b/IsoLib/libisomediafile/src/ISOMovies.h index 8e95c50..9f64a37 100644 --- a/IsoLib/libisomediafile/src/ISOMovies.h +++ b/IsoLib/libisomediafile/src/ISOMovies.h @@ -174,6 +174,11 @@ extern "C" #define ISOPutMovieIntoHandle MP4PutMovieIntoHandle #define ISOSetMovieTimeScale MP4SetMovieTimeScale #define ISOAddTrackReference MP4AddTrackReference +#define ISOAddSubSampleInformationToTrack MP4AddSubSampleInformationToTrack +#define ISOSetSubSampleInformationFlags MP4SetSubSampleInformationFlags +#define ISOGetSubSampleInformationEntryFromTrack MP4GetSubSampleInformationEntryFromTrack +#define ISOAddSubSampleInformationEntry MP4AddSubSampleInformationEntry +#define ISOAddTrackGroup MP4AddTrackGroup #define ISOAddTrackReferenceWithID MP4AddTrackReferenceWithID #define ISOGetMovieIndTrack MP4GetMovieIndTrack #define ISOGetMovieTrackCount MP4GetMovieTrackCount @@ -335,7 +340,7 @@ extern "C" ISO_EXTERN(ISOErr) ISOGetMovieBrand(ISOMovie theMovie, u32 *brand, u32 *minorversion); - ISO_EXTERN(u32) + ISO_EXTERN(ISOErr) ISOIsMovieCompatibleBrand(ISOMovie theMovie, u32 brand); /* AVC Sample descriptions */ @@ -353,6 +358,18 @@ extern "C" ISO_EXTERN(ISOErr) ISOGetVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index); + ISO_EXTERN(ISOErr) + ISOGetHEVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index); + ISO_EXTERN(ISOErr) + ISOGetRESVSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index); + ISO_EXTERN(ISOErr) + ISOGetRESVLengthSizeMinusOne(MP4Handle sampleEntryH, u32 *out); + ISO_EXTERN(ISOErr) + ISOGetRESVOriginalFormat(MP4Handle sampleEntryH, u32 *outOrigFmt); + ISO_EXTERN(ISOErr) + ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, + u32 length_size, MP4Handle first_sps, MP4Handle first_pps, + MP4Handle first_vps); /* 3GPP media */ MP4_EXTERN(MP4Err) ISOAddBitrateToSampleDescription(MP4Handle sampleEntryH, u8 is_3GPP, u32 buffersizeDB, @@ -411,7 +428,8 @@ extern "C" ISO_EXTERN(ISOErr) ISOGetItemReferences(ISOMetaItem item, u32 reference_type, u16 *reference_count, MP4Handle to_item_IDs); - + ISO_EXTERN(ISOErr) + ISOGetItemReference(ISOMetaItem item, u32 reference_type, u16 reference_index, ISOMetaItem *outItem); ISO_EXTERN(ISOErr) ISOAddPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom); ISO_EXTERN(ISOErr) diff --git a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c index 50f7535..a5a0105 100644 --- a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c +++ b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c @@ -27,7 +27,7 @@ */ /* - $Id: MP4Media.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4Media.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" @@ -567,14 +567,12 @@ ISONewXMLMetaDataSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptio { MP4Err err; MP4XMLMetaSampleEntryAtomPtr entry; - MP4TrackAtomPtr trak; if((theTrack == NULL) || (sampleDescriptionH == NULL)) { BAILWITHERROR(MP4BadParamErr); } - trak = (MP4TrackAtomPtr)theTrack; err = MP4CreateXMLMetaSampleEntryAtom((MP4XMLMetaSampleEntryAtomPtr *)&entry); if(err) goto bail; @@ -623,14 +621,12 @@ ISONewTextMetaDataSampleDescription(MP4Track theTrack, MP4Handle sampleDescripti { MP4Err err; MP4TextMetaSampleEntryAtomPtr entry; - MP4TrackAtomPtr trak; if((theTrack == NULL) || (sampleDescriptionH == NULL)) { BAILWITHERROR(MP4BadParamErr); } - trak = (MP4TrackAtomPtr)theTrack; err = MP4CreateTextMetaSampleEntryAtom((MP4TextMetaSampleEntryAtomPtr *)&entry); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c b/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c index 391e4d6..85ffa38 100644 --- a/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c +++ b/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ItemInfoEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ItemInfoEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -143,7 +143,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->version == 1) { - if(self->extension_type != 0) PUT32(extension_type); + if(self->extension_type != 0) { PUT32(extension_type); } if(self->item_info_extension != NULL) { diff --git a/IsoLib/libisomediafile/src/ItemPropertiesAtom.c b/IsoLib/libisomediafile/src/ItemPropertiesAtom.c index 238a407..339ba67 100644 --- a/IsoLib/libisomediafile/src/ItemPropertiesAtom.c +++ b/IsoLib/libisomediafile/src/ItemPropertiesAtom.c @@ -21,8 +21,8 @@ derivative works. Copyright (c) 1999. */ /* - $Id: ItemPropertiesAtom.c,v 1.1.1.1 2016/09/14 armin Exp $ - */ + $Id: ItemPropertiesAtom.c,v 1.1.1.1 2016/09/14 armin Exp $ +*/ #include "MP4Atoms.h" #include @@ -30,17 +30,9 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4ItemPropertiesAtomPtr self = (MP4ItemPropertiesAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err addAtom(MP4ItemPropertiesAtomPtr self, MP4AtomPtr atom) diff --git a/IsoLib/libisomediafile/src/ItemPropertyAssociationAtom.c b/IsoLib/libisomediafile/src/ItemPropertyAssociationAtom.c index 64430cc..15e5d5a 100644 --- a/IsoLib/libisomediafile/src/ItemPropertyAssociationAtom.c +++ b/IsoLib/libisomediafile/src/ItemPropertyAssociationAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* -$Id: ItemPropertyContainerAtom.c,v 1.1.1.1 2016/09/14 armin Exp $ + $Id: ItemPropertyContainerAtom.c,v 1.1.1.1 2016/09/14 armin Exp $ */ #include "MP4Atoms.h" @@ -228,7 +228,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre if(self->flags & 1) { GET16_V(propertyIndex->property_index); - propertyIndex->essential = propertyIndex->property_index & (1 << 15); + propertyIndex->essential = (u8)(propertyIndex->property_index & (1 << 15)); if(propertyIndex->essential == 1) { propertyIndex->property_index &= ~(1 << 15); diff --git a/IsoLib/libisomediafile/src/ItemPropertyContainerAtom.c b/IsoLib/libisomediafile/src/ItemPropertyContainerAtom.c index 1e3f19f..faa62e1 100644 --- a/IsoLib/libisomediafile/src/ItemPropertyContainerAtom.c +++ b/IsoLib/libisomediafile/src/ItemPropertyContainerAtom.c @@ -21,8 +21,8 @@ derivative works. Copyright (c) 1999. */ /* - $Id: ItemPropertyContainerAtom.c,v 1.1.1.1 2016/09/14 armin Exp $ - */ + $Id: ItemPropertyContainerAtom.c,v 1.1.1.1 2016/09/14 armin Exp $ +*/ #include "MP4Atoms.h" #include @@ -30,17 +30,9 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4ItemPropertyContainerAtomPtr self = (MP4ItemPropertyContainerAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err addAtom(MP4ItemPropertyContainerAtomPtr self, MP4AtomPtr atom) diff --git a/IsoLib/libisomediafile/src/LoudnessAtom.c b/IsoLib/libisomediafile/src/LoudnessAtom.c index 553281f..38d3cdd 100644 --- a/IsoLib/libisomediafile/src/LoudnessAtom.c +++ b/IsoLib/libisomediafile/src/LoudnessAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 2014. */ /* - $Id: LoudnessAtom.c,v 1.1.1.1 2014/09/19 armin Exp $ + $Id: LoudnessAtom.c,v 1.1.1.1 2014/09/19 armin Exp $ */ #include "MP4Atoms.h" @@ -127,7 +127,6 @@ static MP4Err getDataSize(struct MP4Atom *s, u32 *dataSizeOut) static MP4Err calculateSize(struct MP4Atom *s) { MP4Err err; - u32 baseAtomFieldSize; MP4LoudnessAtomPtr self; self = (MP4LoudnessAtomPtr)s; @@ -135,8 +134,6 @@ static MP4Err calculateSize(struct MP4Atom *s) err = MP4CalculateBaseAtomFieldSize((MP4AtomPtr)s); if(err) goto bail; - baseAtomFieldSize = self->size; - ADD_ATOM_LIST_SIZE(trackLoudnessInfoList); ADD_ATOM_LIST_SIZE(albumLoudnessInfoList); diff --git a/IsoLib/libisomediafile/src/MJ2BitsPerComponentAtom.c b/IsoLib/libisomediafile/src/MJ2BitsPerComponentAtom.c index e8972ff..48704c4 100644 --- a/IsoLib/libisomediafile/src/MJ2BitsPerComponentAtom.c +++ b/IsoLib/libisomediafile/src/MJ2BitsPerComponentAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2BitsPerComponentAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2BitsPerComponentAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MJ2Atoms.h" @@ -30,22 +30,14 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - ISOErr err = ISONoErr; MJ2BitsPerComponentAtomPtr self = (MJ2BitsPerComponentAtomPtr)s; - - if(self == NULL) BAILWITHERROR(ISOBadParamErr) - + if(self == NULL) return; if(self->bitsPerComponent) { free(self->bitsPerComponent); self->bitsPerComponent = NULL; } - if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static ISOErr serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/MJ2ColorSpecificationAtom.c b/IsoLib/libisomediafile/src/MJ2ColorSpecificationAtom.c index df932bc..ceef7e5 100644 --- a/IsoLib/libisomediafile/src/MJ2ColorSpecificationAtom.c +++ b/IsoLib/libisomediafile/src/MJ2ColorSpecificationAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2ColorSpecificationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2ColorSpecificationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MJ2Atoms.h" @@ -30,22 +30,14 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - ISOErr err = ISONoErr; MJ2ColorSpecificationAtomPtr self = (MJ2ColorSpecificationAtomPtr)s; - - if(self == NULL) BAILWITHERROR(ISOBadParamErr) - + if(self == NULL) return; if(self->profile) { free(self->profile); self->profile = NULL; } - if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static ISOErr serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/MJ2FileTypeAtom.c b/IsoLib/libisomediafile/src/MJ2FileTypeAtom.c index 7cd7bfe..45caca0 100644 --- a/IsoLib/libisomediafile/src/MJ2FileTypeAtom.c +++ b/IsoLib/libisomediafile/src/MJ2FileTypeAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2FileTypeAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2FileTypeAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MJ2Atoms.h" @@ -30,22 +30,15 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - ISOErr err = ISONoErr; ISOFileTypeAtomPtr self = (ISOFileTypeAtomPtr)s; - if(self == NULL) BAILWITHERROR(ISOBadParamErr) - + if(self == NULL) return; if(self->compatibilityList) { free(self->compatibilityList); self->compatibilityList = NULL; } if(self->super) self->super->destroy(s); - -bail: - TEST_RETURN(err); - - return; } static ISOErr serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/MJ2ImageHeaderAtom.c b/IsoLib/libisomediafile/src/MJ2ImageHeaderAtom.c index e0d0ff8..2ef7c7f 100644 --- a/IsoLib/libisomediafile/src/MJ2ImageHeaderAtom.c +++ b/IsoLib/libisomediafile/src/MJ2ImageHeaderAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2ImageHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2ImageHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MJ2Atoms.h" @@ -30,16 +30,9 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - ISOErr err = ISONoErr; MJ2ImageHeaderAtomPtr self = (MJ2ImageHeaderAtomPtr)s; - - if(self == NULL) BAILWITHERROR(ISOBadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static ISOErr serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/MJ2SignatureAtom.c b/IsoLib/libisomediafile/src/MJ2SignatureAtom.c index 5fd57f3..4b3a51c 100644 --- a/IsoLib/libisomediafile/src/MJ2SignatureAtom.c +++ b/IsoLib/libisomediafile/src/MJ2SignatureAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MJ2SignatureAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MJ2SignatureAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MJ2Atoms.h" @@ -30,17 +30,9 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - ISOErr err = ISONoErr; MJ2JPEG2000SignatureAtomPtr self = (MJ2JPEG2000SignatureAtomPtr)s; - - if(self == NULL) BAILWITHERROR(ISOBadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); - -bail: - TEST_RETURN(err); - - return; } static ISOErr serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/MP4Atoms.c b/IsoLib/libisomediafile/src/MP4Atoms.c index 996c6f2..95d0488 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.c +++ b/IsoLib/libisomediafile/src/MP4Atoms.c @@ -26,7 +26,7 @@ * All rights reserved. */ /* - $Id: MP4Atoms.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MP4Atoms.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -558,7 +558,7 @@ MP4Err MP4CreateAtom(u32 atomType, MP4AtomPtr *outAtom) case MP4SampletoGroupAtomType: case MP4CompactSampletoGroupAtomType: - err = MP4CreateSampletoGroupAtom((MP4SampletoGroupAtomPtr *)&newAtom, SAMPLE_GROUP_COMPACT); + err = MP4CreateSampletoGroupAtom((MP4SampletoGroupAtomPtr *)&newAtom, SAMPLE_GROUP_NORMAL); break; case ISOMetaAtomType: diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index 0d06ae5..d077c11 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -1734,7 +1734,7 @@ typedef struct MP4CompactSampleToGroupPatternEntryPtr patternEntries; u32 *indexDescriptionArray; -} CompressedGroupInfo; +} CompressedGroupInfo, *CompressedGroupInfoPtr; typedef struct MP4SampletoGroupAtom { diff --git a/IsoLib/libisomediafile/src/MP4IPMPDescriptorPointer.c b/IsoLib/libisomediafile/src/MP4IPMPDescriptorPointer.c index 0a081e1..3b769d8 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPDescriptorPointer.c +++ b/IsoLib/libisomediafile/src/MP4IPMPDescriptorPointer.c @@ -85,12 +85,8 @@ static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStrea static void destroy(struct MP4DescriptorRecord *s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr); + if(s == NULL) return; free(s); -bail: - return; } MP4Err MP4CreateIPMPDescriptorPointer(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) diff --git a/IsoLib/libisomediafile/src/MP4IPMPToolList.c b/IsoLib/libisomediafile/src/MP4IPMPToolList.c index 92c5979..6b8d336 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPToolList.c +++ b/IsoLib/libisomediafile/src/MP4IPMPToolList.c @@ -110,12 +110,10 @@ static MP4Err createFromInputStream(struct MP4DescriptorRecord *s, MP4InputStrea static void destroy(struct MP4DescriptorRecord *s) { - MP4Err err; MP4IPMPToolListDescriptorPtr self = (MP4IPMPToolListDescriptorPtr)s; - if(s == NULL) BAILWITHERROR(MP4BadParamErr); + if(s == NULL) return; DESTROY_DESCRIPTOR_LIST(ipmpTools) - free(s); bail: diff --git a/IsoLib/libisomediafile/src/MP4IPMPXDefaultData.c b/IsoLib/libisomediafile/src/MP4IPMPXDefaultData.c index e48271d..1fd8203 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPXDefaultData.c +++ b/IsoLib/libisomediafile/src/MP4IPMPXDefaultData.c @@ -75,20 +75,14 @@ static MP4Err createFromInputStream(struct MP4IPMPXDataRecord *s, MP4InputStream static void destroy(struct MP4IPMPXDataRecord *s) { - MP4Err err; - MP4IPMPXDefaultDataPtr self = (MP4IPMPXDefaultDataPtr)s; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr); + if(s == NULL) return; if(self->data) { free(self->data); self->data = NULL; } free(s); - -bail: - return; } MP4Err MP4CreateIPMPXDefaultData(u32 tag, u32 size, u32 bytesRead, MP4IPMPXDataPtr *outData) diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index b3b1a33..2291b5f 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: MP4Media.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4Media.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" @@ -1355,7 +1355,6 @@ MP4GetMediaNextInterestingTime(MP4Media theMedia, MP4MediaInformationAtomPtr minf; MP4SampleTableAtomPtr stbl; MP4TimeToSampleAtomPtr stts; - MP4SyncSampleAtomPtr stss; s64 priorSample; s64 exactSample; s64 nextSample; @@ -1382,7 +1381,6 @@ MP4GetMediaNextInterestingTime(MP4Media theMedia, { BAILWITHERROR(MP4InvalidMediaErr); } - stss = (MP4SyncSampleAtomPtr)stbl->SyncSample; err = stts->findSamples(stbl->TimeToSample, searchFromTime, &priorSample, &exactSample, &nextSample, &sampleNumber, &sampleDuration); if(err) goto bail; @@ -1429,7 +1427,6 @@ MP4Err MP4GetMediaSampleDescIndex(MP4Media theMedia, u64 desiredTime, MP4MediaInformationAtomPtr minf; MP4SampleTableAtomPtr stbl; MP4TimeToSampleAtomPtr stts; - MP4SyncSampleAtomPtr stss; MP4SampleSizeAtomPtr stsz; MP4SampleToChunkAtomPtr stsc; @@ -1462,7 +1459,6 @@ MP4Err MP4GetMediaSampleDescIndex(MP4Media theMedia, u64 desiredTime, { BAILWITHERROR(MP4InvalidMediaErr); } - stss = (MP4SyncSampleAtomPtr)stbl->SyncSample; stsz = (MP4SampleSizeAtomPtr)stbl->SampleSize; if(stsz == NULL) { diff --git a/IsoLib/libisomediafile/src/MP4MemoryInputStream.c b/IsoLib/libisomediafile/src/MP4MemoryInputStream.c index 2982d5c..d345df1 100644 --- a/IsoLib/libisomediafile/src/MP4MemoryInputStream.c +++ b/IsoLib/libisomediafile/src/MP4MemoryInputStream.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4MemoryInputStream.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4MemoryInputStream.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4InputStream.h" #include "MP4Impl.h" @@ -75,6 +75,7 @@ static MP4Err read8(struct MP4InputStreamRecord *s, u32 *outVal, char *msg) u8 val; MP4MemoryInputStreamPtr self = (MP4MemoryInputStreamPtr)s; err = MP4NoErr; + val = 0; if((s == 0) || (outVal == 0)) BAILWITHERROR(MP4BadParamErr); err = readData(s, 1, (char *)&val, NULL); *outVal = val; diff --git a/IsoLib/libisomediafile/src/MP4MovieFile.c b/IsoLib/libisomediafile/src/MP4MovieFile.c index 61894e0..edb7e7c 100644 --- a/IsoLib/libisomediafile/src/MP4MovieFile.c +++ b/IsoLib/libisomediafile/src/MP4MovieFile.c @@ -428,7 +428,6 @@ ISOAddDelayToTrackFragmentDecodeTime(MP4Movie theMovie, u32 delay) MP4Err err; MP4PrivateMovieRecordPtr movie; MP4MovieFragmentAtomPtr moof; - MP4AtomPtr moofEntry; MP4TrackFragmentAtomPtr traf; MP4TrackExtendsAtomPtr trex; MP4TrackFragmentDecodeTimeAtomPtr tfdt; @@ -442,7 +441,8 @@ ISOAddDelayToTrackFragmentDecodeTime(MP4Movie theMovie, u32 delay) for(i = 0; i < moof->atomList->entryCount; i++) { - MP4GetListEntry(moof->atomList, i, (char **)moofEntry); + MP4AtomPtr moofEntry; + MP4GetListEntry(moof->atomList, i, (char **)&moofEntry); if(moofEntry->type == MP4TrackFragmentAtomType) { traf = (MP4TrackFragmentAtomPtr)moofEntry; diff --git a/IsoLib/libisomediafile/src/MP4Movies.c b/IsoLib/libisomediafile/src/MP4Movies.c index d87f63a..e93b4eb 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.c +++ b/IsoLib/libisomediafile/src/MP4Movies.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: MP4Movies.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4Movies.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" @@ -968,7 +968,7 @@ ISOGetMovieBrand(ISOMovie theMovie, u32 *brand, u32 *minorversion) return err; } -ISO_EXTERN(u32) +ISO_EXTERN(MP4Err) ISOIsMovieCompatibleBrand(ISOMovie theMovie, u32 brand) { ISOFileTypeAtomPtr ftyp; @@ -977,11 +977,11 @@ ISOIsMovieCompatibleBrand(ISOMovie theMovie, u32 brand) GETMOOV(theMovie); ftyp = (ISOFileTypeAtomPtr)moov->ftyp; if(ftyp) outval = ftyp->getStandard(ftyp, brand); - else - BAILWITHERROR(MP4NoQTAtomErr) + else BAILWITHERROR(MP4NoQTAtomErr) + if(outval != brand) err = MP4NotFoundErr; bail: TEST_RETURN(err); - return outval; + return err; } MP4_EXTERN(MP4Err) diff --git a/IsoLib/libisomediafile/src/MP4Movies.h b/IsoLib/libisomediafile/src/MP4Movies.h index aed06ab..6bbade3 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.h +++ b/IsoLib/libisomediafile/src/MP4Movies.h @@ -294,7 +294,25 @@ typedef enum sampleToGroupType_t MP4_EXTERN(MP4Err) MP4AddTrackReferenceWithID(MP4Track theTrack, u32 dependsOnID, u32 dependencyType, u32 *outReferenceIndex); - + MP4_EXTERN(MP4Err) + MP4AddSubSampleInformationToTrack(MP4Track theTrack, MP4GenericAtom *subs); + MP4_EXTERN(MP4Err) + MP4SetSubSampleInformationFlags(MP4GenericAtom subsample, u32 flags); + MP4_EXTERN(MP4Err) + MP4GetSubSampleInformationEntryFromTrack(MP4Track theTrack, u32 *flags, + u32 *entry_count, + u32 **sample_delta, u32 **subsample_count, + u32 ***subsample_size_array, + u32 ***subsample_priority_array, + u32 ***subsample_discardable_array); + MP4_EXTERN(MP4Err) + MP4AddSubSampleInformationEntry(MP4GenericAtom subsample, u32 sample_delta, + u32 subsample_count, + MP4Handle subsample_size_array, + MP4Handle subsample_priority_array, + MP4Handle subsample_discardable_array); + MP4_EXTERN(MP4Err) + MP4AddTrackGroup(MP4Track theTrack, u32 groupID, u32 dependencyType); MP4_EXTERN(MP4Err) MP4AddTrackToMovieIOD(MP4Track theTrack); diff --git a/IsoLib/libisomediafile/src/MPEGMediaHeaderAtom.c b/IsoLib/libisomediafile/src/MPEGMediaHeaderAtom.c index 7c29c19..050b368 100644 --- a/IsoLib/libisomediafile/src/MPEGMediaHeaderAtom.c +++ b/IsoLib/libisomediafile/src/MPEGMediaHeaderAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MPEGMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MPEGMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,14 +29,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/MdatDataHandler.c b/IsoLib/libisomediafile/src/MdatDataHandler.c index f6f25b4..57a0e1b 100644 --- a/IsoLib/libisomediafile/src/MdatDataHandler.c +++ b/IsoLib/libisomediafile/src/MdatDataHandler.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MdatDataHandler.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MdatDataHandler.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Movies.h" #include "MP4Impl.h" @@ -33,15 +33,9 @@ derivative works. Copyright (c) 1999. static MP4Err doOpen(struct MP4DataHandler *s, struct MP4InputStreamRecord *inputStream, MP4DataEntryAtomPtr dataEntry) { - u64 b; - MP4DataEntryAtomPtr d; - - b = inputStream->available; - d = dataEntry; - - if(s == NULL) return MP4BadParamErr; + if(s == NULL || inputStream == NULL || dataEntry == NULL) return MP4BadParamErr; else - return MP4NoErr; + return MP4NotImplementedErr; } static MP4Err doClose(struct MP4DataHandler *s) diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index 48656f3..6a31c9a 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MediaAtom.c,v 1.2 2002/10/01 12:49:19 julien Exp $ + $Id: MediaAtom.c,v 1.2 2002/10/01 12:49:19 julien Exp $ */ #include "MP4Atoms.h" @@ -318,7 +318,7 @@ static MP4Err addGroupDescription(struct MP4MediaAtom *self, u32 groupType, MP4H u32 *index) { MP4Err err; - MP4MediaInformationAtomPtr minf, true_minf; + MP4MediaInformationAtomPtr minf; err = MP4NoErr; minf = (MP4MediaInformationAtomPtr)self->information; /* this can be 'traf' if fragmented */ diff --git a/IsoLib/libisomediafile/src/MediaDataAtom.c b/IsoLib/libisomediafile/src/MediaDataAtom.c index 9b9139f..d3ee572 100644 --- a/IsoLib/libisomediafile/src/MediaDataAtom.c +++ b/IsoLib/libisomediafile/src/MediaDataAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MediaDataAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MediaDataAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -99,7 +99,7 @@ static MP4Err writeToFile(struct MP4MediaDataAtom *self, FILE *fd) if(written != (self->dataSize - FORCE_OFFSET)) BAILWITHERROR(MP4IOErr) #else written = fwrite(self->data, 1, (size_t)self->dataSize, fd); - if(written != self->dataSize) BAILWITHERROR(MP4IOErr) + if(written != (size_t)self->dataSize) BAILWITHERROR(MP4IOErr) #endif self->bytesWritten += written; /* this is not reliable because bytesWritten is only a 32 and we may have written more */ diff --git a/IsoLib/libisomediafile/src/MediaHeaderAtom.c b/IsoLib/libisomediafile/src/MediaHeaderAtom.c index 7c7c2a6..6804962 100644 --- a/IsoLib/libisomediafile/src/MediaHeaderAtom.c +++ b/IsoLib/libisomediafile/src/MediaHeaderAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -29,14 +29,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/MetaboxRelationAtom.c b/IsoLib/libisomediafile/src/MetaboxRelationAtom.c index 6e335b7..39465a2 100644 --- a/IsoLib/libisomediafile/src/MetaboxRelationAtom.c +++ b/IsoLib/libisomediafile/src/MetaboxRelationAtom.c @@ -21,8 +21,8 @@ derivative works. Copyright (c) 2014. */ /* - $Id: MetaboxRelationAtom.c,v 1.1.1.1 2014/11/07 08:10:00 armin Exp $ - */ + $Id: MetaboxRelationAtom.c,v 1.1.1.1 2014/11/07 08:10:00 armin Exp $ +*/ #include "MP4Atoms.h" #include @@ -30,17 +30,9 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; ISOMetaboxRelationAtomPtr self = (ISOMetaboxRelationAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/MovieAtom.c b/IsoLib/libisomediafile/src/MovieAtom.c index 96b9d05..a2661ff 100644 --- a/IsoLib/libisomediafile/src/MovieAtom.c +++ b/IsoLib/libisomediafile/src/MovieAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -372,7 +372,6 @@ static u32 getTrackCount(MP4MovieAtomPtr self) static MP4Err setupTracks(MP4MovieAtomPtr self, MP4PrivateMovieRecordPtr moov) { - u32 trackIdx; u32 i; MP4Err err; u32 trackCount; @@ -380,7 +379,7 @@ static MP4Err setupTracks(MP4MovieAtomPtr self, MP4PrivateMovieRecordPtr moov) self->moov = moov; trackCount = getTrackCount(self); - for(i = 0, trackIdx = 0; i < trackCount; i++) + for(i = 0; i < trackCount; i++) { MP4TrackAtomPtr atom; err = MP4GetListEntry(self->trackList, i, (char **)&atom); @@ -424,7 +423,6 @@ static MP4Err getTrackExtendsAtom(struct MP4MovieAtom *self, u32 trackID, MP4Ato static MP4Err getTrackMedia(struct MP4MovieAtom *self, u32 trackID, MP4AtomPtr *outTrack) { - u32 trackIdx; u32 i; MP4Err err; u32 trackCount; @@ -433,7 +431,7 @@ static MP4Err getTrackMedia(struct MP4MovieAtom *self, u32 trackID, MP4AtomPtr * if((trackID == 0) || (outTrack == NULL)) BAILWITHERROR(MP4BadParamErr) MP4GetListEntryCount(self->trackList, &trackCount); - for(i = 0, trackIdx = 0; i < trackCount; i++) + for(i = 0; i < trackCount; i++) { MP4TrackAtomPtr trak; @@ -463,6 +461,7 @@ static MP4Err getSampleDescriptionIndex(struct MP4MovieAtom *self, u32 trackID, MP4Err err; err = MP4NoErr; + mdia = NULL; err = getTrackMedia(self, trackID, (MP4AtomPtr *)&mdia); if(err) goto bail; @@ -477,14 +476,13 @@ static MP4Err getSampleDescriptionIndex(struct MP4MovieAtom *self, u32 trackID, static MP4Err settrackfragment(struct MP4MovieAtom *self, u32 trackID, MP4AtomPtr fragment) { - u32 trackIdx; u32 i; MP4Err err; u32 trackCount; err = MP4NoErr; trackCount = getTrackCount(self); - for(i = 0, trackIdx = 0; i < trackCount; i++) + for(i = 0; i < trackCount; i++) { MP4TrackAtomPtr atom; err = MP4GetListEntry(self->trackList, i, (char **)&atom); diff --git a/IsoLib/libisomediafile/src/MovieExtendsAtom.c b/IsoLib/libisomediafile/src/MovieExtendsAtom.c index a8b5ce9..c06599d 100644 --- a/IsoLib/libisomediafile/src/MovieExtendsAtom.c +++ b/IsoLib/libisomediafile/src/MovieExtendsAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieExtendsAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieExtendsAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -162,14 +162,13 @@ static MP4Err setCompositionToDecodeProperties(struct MP4MovieExtendsAtom *self, static MP4Err maketrackfragments(struct MP4MovieExtendsAtom *self, MP4MovieFragmentAtomPtr moof, MP4MovieAtomPtr moov, MP4MediaDataAtomPtr mdat) { - u32 trackIdx; u32 i; MP4Err err; u32 trackCount; err = MP4NoErr; MP4GetListEntryCount(self->trackExtendsList, &trackCount); - for(i = 0, trackIdx = 0; i < trackCount; i++) + for(i = 0; i < trackCount; i++) { MP4TrackExtendsAtomPtr trex; MP4TrackFragmentAtomPtr traf; diff --git a/IsoLib/libisomediafile/src/MovieFragmentAtom.c b/IsoLib/libisomediafile/src/MovieFragmentAtom.c index 716dc12..7faa049 100644 --- a/IsoLib/libisomediafile/src/MovieFragmentAtom.c +++ b/IsoLib/libisomediafile/src/MovieFragmentAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieFragmentAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieFragmentAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -98,8 +98,7 @@ static MP4Err mergeFragments(struct MP4MovieFragmentAtom *self, MP4MovieAtomPtr u32 groupDescriptionCount; ISOHandle desc; u32 n; - u32 descIdx; - MP4SampleGroupDescriptionAtomPtr groupDescriptionTraf, groupDescriptionStbl; + MP4SampleGroupDescriptionAtomPtr groupDescriptionTraf; MP4MediaInformationAtomPtr minf; MP4SampleTableAtomPtr stbl; diff --git a/IsoLib/libisomediafile/src/MovieFragmentHeaderAtom.c b/IsoLib/libisomediafile/src/MovieFragmentHeaderAtom.c index d94e025..e06b6ba 100644 --- a/IsoLib/libisomediafile/src/MovieFragmentHeaderAtom.c +++ b/IsoLib/libisomediafile/src/MovieFragmentHeaderAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieFragmentHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieFragmentHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -29,14 +29,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/MovieHeaderAtom.c b/IsoLib/libisomediafile/src/MovieHeaderAtom.c index 22e2166..f67945f 100644 --- a/IsoLib/libisomediafile/src/MovieHeaderAtom.c +++ b/IsoLib/libisomediafile/src/MovieHeaderAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -30,14 +30,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/MovieTracks.c b/IsoLib/libisomediafile/src/MovieTracks.c index 5a42168..82a5305 100644 --- a/IsoLib/libisomediafile/src/MovieTracks.c +++ b/IsoLib/libisomediafile/src/MovieTracks.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MovieTracks.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: MovieTracks.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Movies.h" diff --git a/IsoLib/libisomediafile/src/ObjectDescriptorAtom.c b/IsoLib/libisomediafile/src/ObjectDescriptorAtom.c index 5f8846b..ee9d97d 100644 --- a/IsoLib/libisomediafile/src/ObjectDescriptorAtom.c +++ b/IsoLib/libisomediafile/src/ObjectDescriptorAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ObjectDescriptorAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: ObjectDescriptorAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -30,20 +30,14 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4ObjectDescriptorAtomPtr self = (MP4ObjectDescriptorAtomPtr)s; - err = MP4NoErr; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->descriptor) { self->descriptor->destroy(self->descriptor); self->descriptor = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err setDescriptor(struct MP4Atom *s, struct MP4DescriptorRecord *desc) diff --git a/IsoLib/libisomediafile/src/ObjectDescriptorMediaHeader.c b/IsoLib/libisomediafile/src/ObjectDescriptorMediaHeader.c index 7c5a47b..4c9de66 100644 --- a/IsoLib/libisomediafile/src/ObjectDescriptorMediaHeader.c +++ b/IsoLib/libisomediafile/src/ObjectDescriptorMediaHeader.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ObjectDescriptorMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: ObjectDescriptorMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,14 +29,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/OriginalFormatAtom.c b/IsoLib/libisomediafile/src/OriginalFormatAtom.c index 27214d4..924977f 100644 --- a/IsoLib/libisomediafile/src/OriginalFormatAtom.c +++ b/IsoLib/libisomediafile/src/OriginalFormatAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: OriginalFormatAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: OriginalFormatAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -32,17 +32,9 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4OriginalFormatAtomPtr self = (MP4OriginalFormatAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/PCMConfigAtom.c b/IsoLib/libisomediafile/src/PCMConfigAtom.c index cdc6bf3..69cf5e9 100644 --- a/IsoLib/libisomediafile/src/PCMConfigAtom.c +++ b/IsoLib/libisomediafile/src/PCMConfigAtom.c @@ -27,17 +27,9 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4PCMConfigAtomPtr self = (MP4PCMConfigAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/PaddingBitsAtom.c b/IsoLib/libisomediafile/src/PaddingBitsAtom.c index 77d0360..427fb49 100644 --- a/IsoLib/libisomediafile/src/PaddingBitsAtom.c +++ b/IsoLib/libisomediafile/src/PaddingBitsAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: PaddingBitsAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: PaddingBitsAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -30,21 +30,15 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4PaddingBitsAtomPtr self; - err = MP4NoErr; self = (MP4PaddingBitsAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->pads) { free(self->pads); self->pads = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err addSamplePads(struct MP4PaddingBitsAtom *self, u32 sampleCount, MP4Handle padsH) diff --git a/IsoLib/libisomediafile/src/PrimaryItemAtom.c b/IsoLib/libisomediafile/src/PrimaryItemAtom.c index f332920..c07e363 100644 --- a/IsoLib/libisomediafile/src/PrimaryItemAtom.c +++ b/IsoLib/libisomediafile/src/PrimaryItemAtom.c @@ -21,21 +21,15 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: PrimaryItemAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: PrimaryItemAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c b/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c index 272472c..bcd989d 100644 --- a/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c +++ b/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c @@ -36,18 +36,10 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4ProducerReferenceTimeAtomPtr self; - self = (MP4ProducerReferenceTimeAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr); - + if(self == NULL) return; if(self->super) self->super->destroy(s); - -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c index f5fdeed..82257a2 100644 --- a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c +++ b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c @@ -21,8 +21,8 @@ derivative works. Copyright (c) 1999. */ /* - $Id: SampleAuxiliaryInformationOffsetsAtom.c,v 1.1.1.1 2014/08/08 08:10:00 armin Exp $ - */ + $Id: SampleAuxiliaryInformationOffsetsAtom.c,v 1.1.1.1 2014/08/08 08:10:00 armin Exp $ +*/ #include "MP4Atoms.h" #include @@ -30,17 +30,9 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) @@ -164,6 +156,7 @@ static MP4Err addOffsets(MP4AtomPtr s, u32 entryCount, MP4Handle sizesH) MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)s; err = MP4NoErr; + onlySize = 0; sizes = (u32 *)*sizesH; @@ -210,7 +203,7 @@ static MP4Err mdatMoved(MP4AtomPtr s, u64 mdatBase, u64 mdatEnd, s32 mdatOffset) return err; } -MP4Err mergeOffsets(MP4AtomPtr s, MP4AtomPtr otherSaio, u64 baseOffset) +static MP4Err mergeOffsets(MP4AtomPtr s, MP4AtomPtr otherSaio, u64 baseOffset) { u32 i; MP4Err err; diff --git a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationSizesAtom.c b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationSizesAtom.c index ba5c50e..ba85636 100644 --- a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationSizesAtom.c +++ b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationSizesAtom.c @@ -21,8 +21,8 @@ derivative works. Copyright (c) 1999. */ /* - $Id: SampleAuxiliaryInformationSizesAtom.c,v 1.1.1.1 2014/08/08 08:10:00 armin Exp $ - */ + $Id: SampleAuxiliaryInformationSizesAtom.c,v 1.1.1.1 2014/08/08 08:10:00 armin Exp $ +*/ #include "MP4Atoms.h" #include @@ -30,17 +30,9 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) @@ -149,7 +141,8 @@ static MP4Err addSizes(MP4AtomPtr s, u32 sampleCount, MP4Handle sizesH) MP4Err err; MP4SampleAuxiliaryInformationSizesAtomPtr self = (MP4SampleAuxiliaryInformationSizesAtomPtr)s; - err = MP4NoErr; + err = MP4NoErr; + onlySize = 0; if(self->default_sample_info_size == 0) { @@ -179,7 +172,7 @@ static MP4Err addSizes(MP4AtomPtr s, u32 sampleCount, MP4Handle sizesH) return err; } -MP4Err mergeSizes(MP4AtomPtr s, MP4AtomPtr otherSaiz) +static MP4Err mergeSizes(MP4AtomPtr s, MP4AtomPtr otherSaiz) { u32 i; MP4Err err; diff --git a/IsoLib/libisomediafile/src/SampleDependencyAtom.c b/IsoLib/libisomediafile/src/SampleDependencyAtom.c index 40ef4fb..2ab3070 100644 --- a/IsoLib/libisomediafile/src/SampleDependencyAtom.c +++ b/IsoLib/libisomediafile/src/SampleDependencyAtom.c @@ -29,21 +29,15 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4SampleDependencyAtomPtr self; - err = MP4NoErr; self = (MP4SampleDependencyAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->dependency != NULL) { free(self->dependency); self->dependency = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err ensureSize(struct MP4SampleDependencyAtom *self, u32 newSize) diff --git a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c index bcd76fc..11cfb4d 100644 --- a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c +++ b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c @@ -27,12 +27,10 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; u32 i; MP4SampleGroupDescriptionAtomPtr self; - err = MP4NoErr; self = (MP4SampleGroupDescriptionAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->groups != NULL) { for(i = 0; i < self->groupCount; i++) @@ -42,10 +40,6 @@ static void destroy(MP4AtomPtr s) self->groups = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err addGroupDescription(struct MP4SampleGroupDescriptionAtom *self, diff --git a/IsoLib/libisomediafile/src/SampleSizeAtom.c b/IsoLib/libisomediafile/src/SampleSizeAtom.c index 89140a2..23a4050 100644 --- a/IsoLib/libisomediafile/src/SampleSizeAtom.c +++ b/IsoLib/libisomediafile/src/SampleSizeAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SampleSizeAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SampleSizeAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -32,21 +32,15 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4SampleSizeAtomPtr self; - err = MP4NoErr; self = (MP4SampleSizeAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->sizes) { free(self->sizes); self->sizes = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err addSamples(struct MP4SampleSizeAtom *self, u32 sampleCount, MP4Handle sizesH) @@ -194,7 +188,6 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) { MP4Err err; u32 i; - u32 fieldsize; MP4SampleSizeAtomPtr self = (MP4SampleSizeAtomPtr)s; err = MP4NoErr; @@ -219,7 +212,6 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) } else { - fieldsize = self->fieldsize; PUT32(fieldsize); PUT32(sampleCount); switch(self->fieldsize) diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index 32b6e28..ec6c184 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SampleTableAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SampleTableAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -706,13 +706,11 @@ static MP4Err getSampleGroupSampleNumbers(struct MP4SampleTableAtom *self, u32 g u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt) { MP4Err err; - - u32 i; - u32 cur_index, cur_count; + MP4SampletoGroupAtomPtr theGroup; + u32 i, cur_index, cur_count; *outSampleCnt = 0; TESTMALLOC(*outSampleNumbers); - MP4SampletoGroupAtomPtr theGroup; err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); if(theGroup) { @@ -804,7 +802,7 @@ static MP4Err getSampleDependency(struct MP4SampleTableAtom *self, u32 sampleNum return err; } -MP4Err getSampleAuxiliaryInformation(struct MP4SampleTableAtom *self, +static MP4Err getSampleAuxiliaryInformation(struct MP4SampleTableAtom *self, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, diff --git a/IsoLib/libisomediafile/src/SampleToGroupAtom.c b/IsoLib/libisomediafile/src/SampleToGroupAtom.c index 42ccb95..085f1c4 100644 --- a/IsoLib/libisomediafile/src/SampleToGroupAtom.c +++ b/IsoLib/libisomediafile/src/SampleToGroupAtom.c @@ -50,7 +50,7 @@ typedef struct s32 cumulativeMemoryCost; s32 prevEfficientIndex; s32 nextEfficientIndex; -} PatternTracker; +} PatternTracker, *PatternTrackerPtr; /* Compacting Algorithm: @@ -83,7 +83,7 @@ typedef struct u8 groupIndexFieldSize; } SampleGroupInfo; -u8 GetFieldSize(u32 value, u8 localFragmentUsed) +static u8 GetFieldSize(u32 value, u8 localFragmentUsed) { if(localFragmentUsed) { @@ -125,7 +125,7 @@ u8 GetFieldSize(u32 value, u8 localFragmentUsed) } } -u8 SetFieldSize(u32 fieldSize) +static u8 SetFieldSize(u32 fieldSize) { assert(fieldSize == 4 || fieldSize == 8 || fieldSize == 16 || fieldSize == 32); switch(fieldSize) @@ -146,14 +146,14 @@ u8 SetFieldSize(u32 fieldSize) return 0; } -void AppendDescriptionIndexToCompactGroup(CompressedGroupInfo *compressedGroup, u32 descIndex, +static void AppendDescriptionIndexToCompactGroup(CompressedGroupInfo *compressedGroup, u32 descIndex, u32 groupIndex) { assert(descIndex < compressedGroup->totalIndexDescriptionCount); compressedGroup->indexDescriptionArray[descIndex] = groupIndex; } -void AppendNewPatternEntry(CompressedGroupInfo *compressedGroup, u32 index, u32 patternLength, +static void AppendNewPatternEntry(CompressedGroupInfo *compressedGroup, u32 index, u32 patternLength, u32 sampleCount) { assert(patternLength != 0); @@ -166,17 +166,15 @@ void AppendNewPatternEntry(CompressedGroupInfo *compressedGroup, u32 index, u32 compressedGroup->totalSampleCount += sampleCount; } -void SetMemoryCostForPattern(SampleGroupInfo *sampleGroup, u32 patternLength, +static void SetMemoryCostForPattern(SampleGroupInfo *sampleGroup, u32 patternLength, u32 startPatternSampleIndex, u32 endPatternSampleIndex) { + s32 memoryCost; u32 sampleCount = endPatternSampleIndex - startPatternSampleIndex + 1; assert(startPatternSampleIndex + patternLength <= endPatternSampleIndex); - s32 memoryCost = - startPatternSampleIndex <= 0 - ? sampleGroup->patternTracker[0].cumulativeMemoryCost - : sampleGroup->patternTracker[startPatternSampleIndex - 1].cumulativeMemoryCost; + memoryCost = startPatternSampleIndex <= 0 ? sampleGroup->patternTracker[0].cumulativeMemoryCost : sampleGroup->patternTracker[startPatternSampleIndex - 1].cumulativeMemoryCost; memoryCost += (patternLength * sampleGroup->groupIndexFieldSize); if(memoryCost < sampleGroup->patternTracker[endPatternSampleIndex].cumulativeMemoryCost) @@ -195,7 +193,7 @@ void SetMemoryCostForPattern(SampleGroupInfo *sampleGroup, u32 patternLength, } } -void SetMemoryCostForNonPattern(SampleGroupInfo *sampleGroup, s32 sampleIndex) +static void SetMemoryCostForNonPattern(SampleGroupInfo *sampleGroup, s32 sampleIndex) { s32 memoryCost = (sampleIndex < 1 ? sampleGroup->patternTracker[0].cumulativeMemoryCost @@ -217,7 +215,7 @@ void SetMemoryCostForNonPattern(SampleGroupInfo *sampleGroup, s32 sampleIndex) } } -void CombineNonPatterns(SampleGroupInfo *sampleGroup, CompressedGroupInfo *compressedGroup) +static void CombineNonPatterns(SampleGroupInfo *sampleGroup, CompressedGroupInfo *compressedGroup) { s32 prevIndex = sampleGroup->sampleCount - 1; s32 nextIndex = sampleGroup->sampleCount; @@ -225,11 +223,11 @@ void CombineNonPatterns(SampleGroupInfo *sampleGroup, CompressedGroupInfo *compr /* Post-process output pattern tracker. Get Pattern Count, Populate the nextIndex to navigate * easily*/ - while(prevIndex >= 0 && prevIndex < sampleGroup->sampleCount) + while(prevIndex >= 0 && prevIndex < (s32)sampleGroup->sampleCount) { u32 consecutiveNonPatterns = 0; s32 i = prevIndex; - while(i >= 0 && i < sampleGroup->sampleCount && (patternTracker[i].patternLength == 1) && + while(i >= 0 && i < (s32)sampleGroup->sampleCount && (patternTracker[i].patternLength == 1) && (patternTracker[i].sampleCount == 1)) { consecutiveNonPatterns++; @@ -257,7 +255,7 @@ void CombineNonPatterns(SampleGroupInfo *sampleGroup, CompressedGroupInfo *compr compressedGroup->efficientStartIndex = nextIndex; } -void FindPatternsStartingAtIndex(SampleGroupInfo *sampleGroup, u32 sampleIndex) +static void FindPatternsStartingAtIndex(SampleGroupInfo *sampleGroup, u32 sampleIndex) { u32 p; assert(sampleIndex < sampleGroup->sampleCount); @@ -287,9 +285,10 @@ void FindPatternsStartingAtIndex(SampleGroupInfo *sampleGroup, u32 sampleIndex) } } -void InitializeSampleGroupInput(MP4SampletoGroupAtomPtr self, SampleGroupInfo *sampleGroup) +static void InitializeSampleGroupInput(MP4SampletoGroupAtomPtr self, SampleGroupInfo *sampleGroup) { - u32 i; + u32 i, startValue; + PatternTracker patternTrackerEntry; sampleGroup->groupIndex = self->group_index; sampleGroup->sampleCount = self->sampleCount; sampleGroup->groupIndexFieldSize = self->compressedGroup.indexFieldSize; @@ -299,7 +298,7 @@ void InitializeSampleGroupInput(MP4SampletoGroupAtomPtr self, SampleGroupInfo *s memset(sampleGroup->patternTracker, 0, sizeof(PatternTracker) * self->sampleCount); /* Expand sample group indices, get maximum field size to represent each group index*/ - u32 startValue = self->group_index[0]; + startValue = self->group_index[0]; for(i = 1; i < self->sampleCount; i++) { @@ -315,7 +314,6 @@ void InitializeSampleGroupInput(MP4SampletoGroupAtomPtr self, SampleGroupInfo *s self->group_index[self->sampleCount - 1] = startValue; /* Initialize efficiencies assuming each input sample is a distinct non-pattern*/ - PatternTracker patternTrackerEntry; patternTrackerEntry.patternLength = patternTrackerEntry.sampleCount = 1; for(i = 0; i < self->sampleCount; i++) @@ -327,16 +325,17 @@ void InitializeSampleGroupInput(MP4SampletoGroupAtomPtr self, SampleGroupInfo *s } } -void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) +static void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) { - u32 j; - u32 patternIndex; + u32 j, patternIndex, descIndex, nextIndex, sampleCount; + SampleGroupInfo sampleGroup; + CompressedGroupInfoPtr compressedGroup; + PatternTrackerPtr patternTracker; if(self->compressedGroup.isSampleGroupCompressed) return; - SampleGroupInfo sampleGroup; InitializeSampleGroupInput(self, &sampleGroup); - CompressedGroupInfo *compressedGroup = &self->compressedGroup; + compressedGroup = &self->compressedGroup; compressedGroup->patternLengthFieldSize = 4; compressedGroup->sampleCountFieldSize = 4; compressedGroup->indexFieldSize = sampleGroup.groupIndexFieldSize; @@ -369,9 +368,9 @@ void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) patternTracker[i].nextEfficientIndex); }*/ - PatternTracker *patternTracker = sampleGroup.patternTracker; - u32 descIndex = 0; - u32 nextIndex = compressedGroup->efficientStartIndex; + patternTracker = sampleGroup.patternTracker; + descIndex = 0; + nextIndex = compressedGroup->efficientStartIndex; for(patternIndex = 0; patternIndex < compressedGroup->patternCount; patternIndex++) { u32 patternLength = patternTracker[nextIndex].patternLength; @@ -379,15 +378,14 @@ void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) if(fieldSize > compressedGroup->patternLengthFieldSize) compressedGroup->patternLengthFieldSize = fieldSize; - u32 sampleCount = patternTracker[nextIndex].sampleCount; - fieldSize = GetFieldSize(sampleCount, 0); + sampleCount = patternTracker[nextIndex].sampleCount; + fieldSize = GetFieldSize(sampleCount, 0); if(fieldSize > compressedGroup->sampleCountFieldSize) compressedGroup->sampleCountFieldSize = fieldSize; AppendNewPatternEntry(compressedGroup, patternIndex, patternLength, sampleCount); - assert(patternTracker[nextIndex].patternStart >= 0 && - patternTracker[nextIndex].patternStart < self->sampleCount); + assert(patternTracker[nextIndex].patternStart < self->sampleCount); assert(patternTracker[nextIndex].patternStart + patternLength - 1 < self->sampleCount); for(j = 0; j < patternLength; j++) @@ -421,11 +419,9 @@ void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) static void destroy(MP4AtomPtr s) { - MP4Err err; MP4SampletoGroupAtomPtr self; - err = MP4NoErr; self = (MP4SampletoGroupAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->group_index != NULL) { free(self->group_index); @@ -445,10 +441,6 @@ static void destroy(MP4AtomPtr s) } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err ensureSize(struct MP4SampletoGroupAtom *self, u32 newSize) @@ -594,11 +586,11 @@ static MP4Err GetData(MP4AtomPtr s, MP4InputStreamPtr inputStream, u8 fieldSize, { MP4Err err = MP4NoErr; MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; + u32 readData = 0; if(fieldSize != 4 && fieldSize != 8 && fieldSize != 16 && fieldSize != 32) BAILWITHERROR(MP4BadParamErr) - u32 readData = 0; switch(fieldSize) { case 4: @@ -771,7 +763,7 @@ static MP4Err calculateSize(struct MP4Atom *s) { MP4Err err; MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; - u32 entryCount, i, normalSize, compactSize; + u32 entryCount, i, normalSize, compactSize, sizeInBits; err = MP4NoErr; @@ -797,7 +789,7 @@ static MP4Err calculateSize(struct MP4Atom *s) /* If grouping type parameter is enabled in flags, will need to add an additional byte*/ self->size += 8; - u32 sizeInBits = + sizeInBits = (self->compressedGroup.patternCount * (self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); sizeInBits += @@ -820,7 +812,7 @@ static MP4Err calculateSize(struct MP4Atom *s) /* compact */ CreateCompactSampleGroups(self); compactSize += 8; - u32 sizeInBits = + sizeInBits = (self->compressedGroup.patternCount * (self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); sizeInBits += @@ -851,8 +843,9 @@ static MP4Err calculateSize(struct MP4Atom *s) static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { MP4Err err; - u32 i, j, size, flags; + u32 i, j, size, flags, upperNibble; u32 *p; + MP4CompactSampleToGroupPatternEntryPtr patternEntries; MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; char typeString[8]; char msgString[80]; @@ -932,10 +925,9 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre GET32(entryCount); - MP4CompactSampleToGroupPatternEntryPtr patternEntries = - malloc(self->entryCount * sizeof(MP4CompactSampleToGroupPatternEntry)); + patternEntries = malloc(self->entryCount * sizeof(MP4CompactSampleToGroupPatternEntry)); TESTMALLOC(patternEntries); - u32 upperNibble = 0; + upperNibble = 0; for(i = 0; i < self->entryCount; i++) { diff --git a/IsoLib/libisomediafile/src/SceneDescriptionMediaHeader.c b/IsoLib/libisomediafile/src/SceneDescriptionMediaHeader.c index c0e337d..83f70b5 100644 --- a/IsoLib/libisomediafile/src/SceneDescriptionMediaHeader.c +++ b/IsoLib/libisomediafile/src/SceneDescriptionMediaHeader.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SceneDescriptionMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SceneDescriptionMediaHeader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,14 +29,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/SchemeTypeAtom.c b/IsoLib/libisomediafile/src/SchemeTypeAtom.c index 04240b5..e79f984 100644 --- a/IsoLib/libisomediafile/src/SchemeTypeAtom.c +++ b/IsoLib/libisomediafile/src/SchemeTypeAtom.c @@ -36,24 +36,14 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4SchemeTypeAtomPtr self = (MP4SchemeTypeAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr); - - /* if there is a scheme_url field, free it */ + if(self == NULL) return; if(self->scheme_url) { free(self->scheme_url); self->scheme_url = NULL; } - if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/SecurityInfoAtom.c b/IsoLib/libisomediafile/src/SecurityInfoAtom.c index 51b0d4f..ec86765 100644 --- a/IsoLib/libisomediafile/src/SecurityInfoAtom.c +++ b/IsoLib/libisomediafile/src/SecurityInfoAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SecurityInfoAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: SecurityInfoAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -32,12 +32,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SecurityInfoAtomPtr self = (MP4SecurityInfoAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->MP4OriginalFormat) { self->MP4OriginalFormat->destroy(self->MP4OriginalFormat); @@ -53,12 +49,7 @@ static void destroy(MP4AtomPtr s) self->MP4SchemeInfo->destroy(self->MP4SchemeInfo); self->MP4SchemeInfo = NULL; } - if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/SecuritySchemeAtom.c b/IsoLib/libisomediafile/src/SecuritySchemeAtom.c index 8e8c879..2fecd66 100644 --- a/IsoLib/libisomediafile/src/SecuritySchemeAtom.c +++ b/IsoLib/libisomediafile/src/SecuritySchemeAtom.c @@ -159,4 +159,6 @@ MP4Err MP4CreateSecuritySchemeAtom( MP4SecuritySchemeAtomPtr *outAtom ) } #endif -*/ \ No newline at end of file +*/ + +typedef int suppress_iso_compiler_warning_empty_translation; \ No newline at end of file diff --git a/IsoLib/libisomediafile/src/SegmentTypeAtom.c b/IsoLib/libisomediafile/src/SegmentTypeAtom.c index 8d3f8e4..1211a2e 100644 --- a/IsoLib/libisomediafile/src/SegmentTypeAtom.c +++ b/IsoLib/libisomediafile/src/SegmentTypeAtom.c @@ -36,25 +36,14 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4SegmentTypeAtomPtr self; - - err = MP4NoErr; - self = (MP4SegmentTypeAtomPtr)s; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr); - + MP4SegmentTypeAtomPtr self = (MP4SegmentTypeAtomPtr)s; + if(self == NULL) return; if(self->compatibilityList) { free(self->compatibilityList); self->compatibilityList = NULL; } - if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static ISOErr serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/ShadowSyncAtom.c b/IsoLib/libisomediafile/src/ShadowSyncAtom.c index fad23f7..7660204 100644 --- a/IsoLib/libisomediafile/src/ShadowSyncAtom.c +++ b/IsoLib/libisomediafile/src/ShadowSyncAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ShadowSyncAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: ShadowSyncAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,21 +29,15 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4ShadowSyncAtomPtr self; - err = MP4NoErr; self = (MP4ShadowSyncAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->entries) { free(self->entries); self->entries = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } typedef struct diff --git a/IsoLib/libisomediafile/src/SingleItemTypeReferenceAtom.c b/IsoLib/libisomediafile/src/SingleItemTypeReferenceAtom.c index 865faec..ca7f86b 100644 --- a/IsoLib/libisomediafile/src/SingleItemTypeReferenceAtom.c +++ b/IsoLib/libisomediafile/src/SingleItemTypeReferenceAtom.c @@ -27,19 +27,11 @@ derivative works. Copyright (c) 2014. static void destroy(MP4AtomPtr s) { - MP4Err err; ISOSingleItemTypeReferenceAtomPtr self; - err = MP4NoErr; self = (ISOSingleItemTypeReferenceAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr); - + if(self == NULL) return; if(self->to_item_IDs) free(self->to_item_IDs); - if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) @@ -122,6 +114,8 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre err = MP4NoErr; if(self == NULL) BAILWITHERROR(MP4BadParamErr) + err = self->super->createFromInputStream(s, proto, (char *)inputStream); + self->bytesRead = 0; GET32(size); diff --git a/IsoLib/libisomediafile/src/SoundMediaHeaderAtom.c b/IsoLib/libisomediafile/src/SoundMediaHeaderAtom.c index a78c024..34135a9 100644 --- a/IsoLib/libisomediafile/src/SoundMediaHeaderAtom.c +++ b/IsoLib/libisomediafile/src/SoundMediaHeaderAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SoundMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SoundMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,14 +29,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/StereoVideoGroupAtom.c b/IsoLib/libisomediafile/src/StereoVideoGroupAtom.c index 09275f2..0e89e3f 100644 --- a/IsoLib/libisomediafile/src/StereoVideoGroupAtom.c +++ b/IsoLib/libisomediafile/src/StereoVideoGroupAtom.c @@ -35,18 +35,9 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4StereoVideoGroupAtomPtr self; - - self = (MP4StereoVideoGroupAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr); - + MP4StereoVideoGroupAtomPtr self = (MP4StereoVideoGroupAtomPtr)s; + if(self == NULL) return; if(self->super) self->super->destroy(s); - -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/SubSampleInformationAtom.c b/IsoLib/libisomediafile/src/SubSampleInformationAtom.c index f6f080f..26f365a 100644 --- a/IsoLib/libisomediafile/src/SubSampleInformationAtom.c +++ b/IsoLib/libisomediafile/src/SubSampleInformationAtom.c @@ -27,12 +27,10 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; u32 i; MP4SubSampleInformationAtomPtr self; - err = MP4NoErr; self = (MP4SubSampleInformationAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->entry_count) { for(i = 0; i < self->entry_count; i++) @@ -64,10 +62,6 @@ static void destroy(MP4AtomPtr s) self->sample_delta = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c b/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c index 84f5bd0..4b1a76d 100644 --- a/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c +++ b/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c @@ -46,7 +46,7 @@ static MP4Err addSubsegment(struct MP4SubsegmentIndexAtom *self, struct Subsegme err = MP4NoErr; err = MP4AddListEntry(ss, self->subsegmentsList); - /* if (err) goto bail; */ + if (err) goto bail; bail: TEST_RETURN(err); @@ -194,10 +194,8 @@ static MP4Err calculateSize(struct MP4Atom *s) for(i = 0; i < self->subsegmentCount; i++) { - - self->size += 4; - SubsegmentPtr ss; + self->size += 4; err = MP4GetListEntry(self->subsegmentsList, i, (char **)&ss); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/SyncSampleAtom.c b/IsoLib/libisomediafile/src/SyncSampleAtom.c index b067516..3954de0 100644 --- a/IsoLib/libisomediafile/src/SyncSampleAtom.c +++ b/IsoLib/libisomediafile/src/SyncSampleAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: SyncSampleAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: SyncSampleAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -31,21 +31,15 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; MP4SyncSampleAtomPtr self; - err = MP4NoErr; self = (MP4SyncSampleAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + if(self == NULL) return; if(self->sampleNumbers) { free(self->sampleNumbers); self->sampleNumbers = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err isSyncSample(MP4AtomPtr s, u32 sampleNumber, u32 *outSync) diff --git a/IsoLib/libisomediafile/src/TimeToSampleAtom.c b/IsoLib/libisomediafile/src/TimeToSampleAtom.c index df974ca..3965d45 100644 --- a/IsoLib/libisomediafile/src/TimeToSampleAtom.c +++ b/IsoLib/libisomediafile/src/TimeToSampleAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TimeToSampleAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TimeToSampleAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -211,8 +211,6 @@ static MP4Err getTimeForSampleNumber(MP4AtomPtr s, u32 sampleNumber, u64 *outSam #endif { /* this is the desired entry */ - u64 sampleOffset; - sampleOffset = sampleNumber - entrySampleNumber; sampleCTS = entryTime + ((sampleNumber - entrySampleNumber) * pe->sampleDuration); sampleDuration = pe->sampleDuration; break; diff --git a/IsoLib/libisomediafile/src/TrackExtendsAtom.c b/IsoLib/libisomediafile/src/TrackExtendsAtom.c index 6e30b58..8815b68 100644 --- a/IsoLib/libisomediafile/src/TrackExtendsAtom.c +++ b/IsoLib/libisomediafile/src/TrackExtendsAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackExtendsAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackExtendsAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,14 +29,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/TrackExtensionPropertiesAtom.c b/IsoLib/libisomediafile/src/TrackExtensionPropertiesAtom.c index a57f460..80cbef4 100644 --- a/IsoLib/libisomediafile/src/TrackExtensionPropertiesAtom.c +++ b/IsoLib/libisomediafile/src/TrackExtensionPropertiesAtom.c @@ -21,8 +21,8 @@ derivative works. Copyright (c) 2014. */ /* - $Id: TrackExtensionPropertiesAtom.c,v 1.1.1.1 2014/10/22 08:10:00 armin Exp $ - */ + $Id: TrackExtensionPropertiesAtom.c,v 1.1.1.1 2014/10/22 08:10:00 armin Exp $ +*/ #include "MP4Atoms.h" #include @@ -30,17 +30,9 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4TrackExtensionPropertiesAtomPtr self = (MP4TrackExtensionPropertiesAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err getAtom(MP4TrackExtensionPropertiesAtomPtr self, u32 atomType, MP4AtomPtr *outAtom) diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index e84fabf..28a867d 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -91,13 +91,12 @@ static MP4Err mdatMoved(struct MP4MediaInformationAtom *s, u64 mdatBase, u64 mda MP4Err err; MP4TrackFragmentAtomPtr self; MP4TrackFragmentHeaderAtomPtr tfhd; - u64 mdatSize; self = (MP4TrackFragmentAtomPtr)s; err = MP4NoErr; - mdatSize = - mdatEnd - mdatBase; /* not something we need to know, but it avoids an unused param warning */ + (void)mdatBase; + (void)mdatEnd; tfhd = (MP4TrackFragmentHeaderAtomPtr)self->tfhd; if(tfhd == NULL) BAILWITHERROR(MP4BadParamErr) @@ -385,16 +384,13 @@ static MP4Err calculateSize(struct MP4Atom *s) MP4Err err; MP4TrackFragmentAtomPtr self = (MP4TrackFragmentAtomPtr)s; MP4TrackFragmentHeaderAtomPtr tfhd; - MP4TrackFragmentDecodeTimeAtomPtr tfdt; u32 tfhd_flags; u32 i; u32 atomListSize; - err = MP4NoErr; - + err = MP4NoErr; tfhd = (MP4TrackFragmentHeaderAtomPtr)self->tfhd; - tfdt = (MP4TrackFragmentDecodeTimeAtomPtr)self->tfdt; tfhd->default_sample_duration = 0; tfhd->default_sample_flags = 0; @@ -641,7 +637,7 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) return err; } -MP4Err mergeSampleAuxiliaryInformation(struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia) +static MP4Err mergeSampleAuxiliaryInformation(struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia) { u32 i; MP4Err err; @@ -682,7 +678,7 @@ MP4Err mergeSampleAuxiliaryInformation(struct MP4TrackFragmentAtom *self, MP4Med return err; } -MP4Err getSampleAuxiliaryInfoFromTrackFragment(struct MP4TrackFragmentAtom *self, +static MP4Err getSampleAuxiliaryInfoFromTrackFragment(struct MP4TrackFragmentAtom *self, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, u32 aux_info_type_parameter, MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, diff --git a/IsoLib/libisomediafile/src/TrackFragmentDecodeTimeAtom.c b/IsoLib/libisomediafile/src/TrackFragmentDecodeTimeAtom.c index 8391bcf..d278e5d 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentDecodeTimeAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentDecodeTimeAtom.c @@ -21,8 +21,8 @@ derivative works. Copyright (c) 1999. */ /* - $Id: TrackFragmentDecodeTimeAtom.c,v 1.1.1.1 2014/08/08 08:10:00 armin Exp $ - */ + $Id: TrackFragmentDecodeTimeAtom.c,v 1.1.1.1 2014/08/08 08:10:00 armin Exp $ +*/ #include "MP4Atoms.h" #include @@ -30,17 +30,9 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; MP4TrackFragmentDecodeTimeAtomPtr self = (MP4TrackFragmentDecodeTimeAtomPtr)s; - err = MP4NoErr; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr) - + if(self == NULL) return; if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/TrackFragmentHeaderAtom.c b/IsoLib/libisomediafile/src/TrackFragmentHeaderAtom.c index 3ac7c17..91b181c 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentHeaderAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentHeaderAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackFragmentHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackFragmentHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,14 +29,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/TrackFragmentRunAtom.c b/IsoLib/libisomediafile/src/TrackFragmentRunAtom.c index d2b1b36..5cda94c 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentRunAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentRunAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackFragmentRunAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackFragmentRunAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,31 +29,22 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4TrackRunAtomPtr self; - - self = (MP4TrackRunAtomPtr)s; - if(self == NULL) BAILWITHERROR(MP4BadParamErr) + MP4TrackRunAtomPtr self = (MP4TrackRunAtomPtr)s; + if(self == NULL) return; if(self->entries) { free(self->entries); self->entries = NULL; } if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static void calculateDefaults(struct MP4TrackRunAtom *self, MP4TrackFragmentHeaderAtomPtr tfhd, u32 flags_index) { - MP4Err err; MP4TrackRunEntryPtr entry; - err = MP4NoErr; - if(self->samplecount == 0) goto bail; + if(self->samplecount == 0) return; entry = self->entries; @@ -61,21 +52,14 @@ static void calculateDefaults(struct MP4TrackRunAtom *self, MP4TrackFragmentHead if(tfhd->default_sample_size == 0) tfhd->default_sample_size = entry->sample_size; if((tfhd->default_sample_flags == 0) && (self->samplecount >= flags_index)) tfhd->default_sample_flags = entry[flags_index - 1].sample_flags; - -bail: - TEST_RETURN(err); - - return; } static void setFlags(struct MP4TrackRunAtom *self, MP4TrackFragmentHeaderAtomPtr tfhd) { u32 flags; - MP4Err err; u32 i; MP4TrackRunEntryPtr entry; - err = MP4NoErr; flags = 0; if(self->data_offset != 0) flags |= trun_data_offset_present; @@ -97,8 +81,6 @@ static void setFlags(struct MP4TrackRunAtom *self, MP4TrackFragmentHeaderAtomPtr if((flags & trun_all_sample_flags) == trun_all_sample_flags) break; } self->flags = flags; - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) @@ -181,7 +163,7 @@ static MP4Err calculateSize(struct MP4Atom *s) return err; } -int bitcount(int v) +static int bitcount(int v) { unsigned int c; /* c accumulates the total bits set in v */ for(c = 0; v; c++) diff --git a/IsoLib/libisomediafile/src/TrackGroupTypeAtom.c b/IsoLib/libisomediafile/src/TrackGroupTypeAtom.c index 226fad3..286ab8b 100644 --- a/IsoLib/libisomediafile/src/TrackGroupTypeAtom.c +++ b/IsoLib/libisomediafile/src/TrackGroupTypeAtom.c @@ -68,14 +68,12 @@ static MP4Err calculateSize(struct MP4Atom *s) static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { MP4Err err; - long bytesToRead; MP4TrackGroupTypeAtomPtr self = (MP4TrackGroupTypeAtomPtr)s; err = MP4NoErr; if(self == NULL) BAILWITHERROR(MP4BadParamErr) err = self->super->createFromInputStream(s, proto, (char *)inputStream); - bytesToRead = s->size - s->bytesRead; GET32(track_group_id); bail: diff --git a/IsoLib/libisomediafile/src/TrackHeaderAtom.c b/IsoLib/libisomediafile/src/TrackHeaderAtom.c index 8afda1d..0a46668 100644 --- a/IsoLib/libisomediafile/src/TrackHeaderAtom.c +++ b/IsoLib/libisomediafile/src/TrackHeaderAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -30,14 +30,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/TrackTypeAtom.c b/IsoLib/libisomediafile/src/TrackTypeAtom.c index eb1c84d..76da488 100644 --- a/IsoLib/libisomediafile/src/TrackTypeAtom.c +++ b/IsoLib/libisomediafile/src/TrackTypeAtom.c @@ -36,25 +36,14 @@ static void destroy(MP4AtomPtr s) { - MP4Err err; - MP4TrackTypeAtomPtr self; - - err = MP4NoErr; - self = (MP4TrackTypeAtomPtr)s; - - if(self == NULL) BAILWITHERROR(MP4BadParamErr); - + MP4TrackTypeAtomPtr self = (MP4TrackTypeAtomPtr)s; + if(self == NULL) return; if(self->compatibilityList) { free(self->compatibilityList); self->compatibilityList = NULL; } - if(self->super) self->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static ISOErr serialize(struct MP4Atom *s, char *buffer) diff --git a/IsoLib/libisomediafile/src/VideoMediaHeaderAtom.c b/IsoLib/libisomediafile/src/VideoMediaHeaderAtom.c index 707ef71..5ecbbc4 100644 --- a/IsoLib/libisomediafile/src/VideoMediaHeaderAtom.c +++ b/IsoLib/libisomediafile/src/VideoMediaHeaderAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: VideoMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: VideoMediaHeaderAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -29,14 +29,8 @@ derivative works. Copyright (c) 1999. static void destroy(MP4AtomPtr s) { - MP4Err err; - err = MP4NoErr; - if(s == NULL) BAILWITHERROR(MP4BadParamErr) + if(s == NULL) return; if(s->super) s->super->destroy(s); -bail: - TEST_RETURN(err); - - return; } static MP4Err serialize(struct MP4Atom *s, char *buffer) From 23516d8f22fe67c3d9a361eb48c5fbb45af11128 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Tue, 17 Nov 2020 21:17:09 +0100 Subject: [PATCH 27/55] clang-format modified files --- IsoLib/libisomediafile/src/ISOMeta.c | 4 +- IsoLib/libisomediafile/src/ISOMovies.h | 9 +- .../src/ISOSampleDescriptions.c | 4 +- .../libisomediafile/src/ItemInfoEntryAtom.c | 5 +- IsoLib/libisomediafile/src/MP4Atoms.c | 4 +- IsoLib/libisomediafile/src/MP4Atoms.h | 41 +- IsoLib/libisomediafile/src/MP4Media.c | 2 +- IsoLib/libisomediafile/src/MP4Movies.c | 3 +- IsoLib/libisomediafile/src/MP4Movies.h | 186 +++++----- IsoLib/libisomediafile/src/MediaAtom.c | 7 +- .../src/MediaInformationAtom.c | 7 +- IsoLib/libisomediafile/src/MovieAtom.c | 2 +- .../SampleAuxiliaryInformationOffsetsAtom.c | 2 +- .../src/SampleGroupDescriptionAtom.c | 42 ++- IsoLib/libisomediafile/src/SampleTableAtom.c | 49 +-- .../libisomediafile/src/SampleToGroupAtom.c | 78 ++-- .../libisomediafile/src/SubsegmentIndexAtom.c | 2 +- .../libisomediafile/src/TrackFragmentAtom.c | 38 +- IsoLib/playground/main.cpp | 350 ++++++++++-------- 19 files changed, 456 insertions(+), 379 deletions(-) diff --git a/IsoLib/libisomediafile/src/ISOMeta.c b/IsoLib/libisomediafile/src/ISOMeta.c index 522ab80..135976e 100644 --- a/IsoLib/libisomediafile/src/ISOMeta.c +++ b/IsoLib/libisomediafile/src/ISOMeta.c @@ -1934,7 +1934,7 @@ ISOAddMetaItemProperty(ISOMetaItem item, MP4GenericAtom *itemProperty, u8 essent if(myMeta->iprp == NULL) { - err = MP4CreateItemPropertiesAtom( (MP4ItemPropertiesAtomPtr*) &myMeta->iprp); + err = MP4CreateItemPropertiesAtom((MP4ItemPropertiesAtomPtr *)&myMeta->iprp); if(err) goto bail; err = MP4AddListEntry(myMeta->iprp, myMeta->atomList); if(err) goto bail; @@ -1975,7 +1975,7 @@ ISOGetProperitesOfMetaItem(ISOMetaItem item, MP4GenericAtom **properties, u32 *p if(myMeta->iprp == NULL) { - err = MP4CreateItemPropertiesAtom( (MP4ItemPropertiesAtomPtr*) &myMeta->iprp); + err = MP4CreateItemPropertiesAtom((MP4ItemPropertiesAtomPtr *)&myMeta->iprp); if(err) goto bail; err = MP4AddListEntry(myMeta->iprp, myMeta->atomList); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/ISOMovies.h b/IsoLib/libisomediafile/src/ISOMovies.h index 9f64a37..98a7aee 100644 --- a/IsoLib/libisomediafile/src/ISOMovies.h +++ b/IsoLib/libisomediafile/src/ISOMovies.h @@ -367,9 +367,9 @@ extern "C" ISO_EXTERN(ISOErr) ISOGetRESVOriginalFormat(MP4Handle sampleEntryH, u32 *outOrigFmt); ISO_EXTERN(ISOErr) - ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 dataReferenceIndex, - u32 length_size, MP4Handle first_sps, MP4Handle first_pps, - MP4Handle first_vps); + ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps, + MP4Handle first_pps, MP4Handle first_vps); /* 3GPP media */ MP4_EXTERN(MP4Err) ISOAddBitrateToSampleDescription(MP4Handle sampleEntryH, u8 is_3GPP, u32 buffersizeDB, @@ -429,7 +429,8 @@ extern "C" ISOGetItemReferences(ISOMetaItem item, u32 reference_type, u16 *reference_count, MP4Handle to_item_IDs); ISO_EXTERN(ISOErr) - ISOGetItemReference(ISOMetaItem item, u32 reference_type, u16 reference_index, ISOMetaItem *outItem); + ISOGetItemReference(ISOMetaItem item, u32 reference_type, u16 reference_index, + ISOMetaItem *outItem); ISO_EXTERN(ISOErr) ISOAddPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom); ISO_EXTERN(ISOErr) diff --git a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c index a5a0105..cca773d 100644 --- a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c +++ b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c @@ -573,7 +573,7 @@ ISONewXMLMetaDataSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptio BAILWITHERROR(MP4BadParamErr); } - err = MP4CreateXMLMetaSampleEntryAtom((MP4XMLMetaSampleEntryAtomPtr *)&entry); + err = MP4CreateXMLMetaSampleEntryAtom((MP4XMLMetaSampleEntryAtomPtr *)&entry); if(err) goto bail; entry->dataReferenceIndex = dataReferenceIndex; @@ -627,7 +627,7 @@ ISONewTextMetaDataSampleDescription(MP4Track theTrack, MP4Handle sampleDescripti BAILWITHERROR(MP4BadParamErr); } - err = MP4CreateTextMetaSampleEntryAtom((MP4TextMetaSampleEntryAtomPtr *)&entry); + err = MP4CreateTextMetaSampleEntryAtom((MP4TextMetaSampleEntryAtomPtr *)&entry); if(err) goto bail; entry->dataReferenceIndex = dataReferenceIndex; diff --git a/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c b/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c index 85ffa38..9597de1 100644 --- a/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c +++ b/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c @@ -143,7 +143,10 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->version == 1) { - if(self->extension_type != 0) { PUT32(extension_type); } + if(self->extension_type != 0) + { + PUT32(extension_type); + } if(self->item_info_extension != NULL) { diff --git a/IsoLib/libisomediafile/src/MP4Atoms.c b/IsoLib/libisomediafile/src/MP4Atoms.c index 95d0488..0c0959d 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.c +++ b/IsoLib/libisomediafile/src/MP4Atoms.c @@ -585,12 +585,12 @@ MP4Err MP4CreateAtom(u32 atomType, MP4AtomPtr *outAtom) err = ISOCreateItemInfoEntryAtom((ISOItemInfoEntryAtomPtr *)&newAtom); break; - case ISOAdditionalMetaDataContainerAtomType: + case ISOAdditionalMetaDataContainerAtomType: /* Deprecated */ err = ISOCreateAdditionalMetaDataContainerAtom((ISOAdditionalMetaDataContainerAtomPtr *)&newAtom); break; - case ISOMetaboxRelationAtomType: + case ISOMetaboxRelationAtomType: /* Deprecated */ err = ISOCreateMetaboxRelationAtom((ISOMetaboxRelationAtomPtr *)&newAtom); break; diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index d077c11..ed886b1 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -26,7 +26,7 @@ * All rights reserved. */ /* - $Id: MP4Atoms.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4Atoms.h,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #ifndef INCLUDED_MP4ATOMS_H @@ -128,8 +128,8 @@ enum ISOItemProtectionAtomType = MP4_FOUR_CHAR_CODE('i', 'p', 'r', 'o'), ISOItemInfoAtomType = MP4_FOUR_CHAR_CODE('i', 'i', 'n', 'f'), ISOItemInfoEntryAtomType = MP4_FOUR_CHAR_CODE('i', 'n', 'f', 'e'), - ISOAdditionalMetaDataContainerAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 'c', 'o'), /* Deprecated */ - ISOMetaboxRelationAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 'r', 'e'), /* Deprecated */ + ISOAdditionalMetaDataContainerAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 'c', 'o'), + ISOMetaboxRelationAtomType = MP4_FOUR_CHAR_CODE('m', 'e', 'r', 'e'), ISOItemDataAtomType = MP4_FOUR_CHAR_CODE('i', 'd', 'a', 't'), ISOItemReferenceAtomType = MP4_FOUR_CHAR_CODE('i', 'r', 'e', 'f'), ISOVCConfigAtomType = MP4_FOUR_CHAR_CODE('a', 'v', 'c', 'C'), @@ -446,13 +446,14 @@ typedef struct MP4MediaAtom MP4Err (*settrackfragment)(struct MP4MediaAtom *self, MP4AtomPtr fragment); MP4Err (*addGroupDescription)(struct MP4MediaAtom *self, u32 groupType, MP4Handle description, u32 *index); - MP4Err (*changeSamplestoGroupType)(struct MP4MediaAtom *self, sampleToGroupType_t sampleToGroupType); + MP4Err (*changeSamplestoGroupType)(struct MP4MediaAtom *self, + sampleToGroupType_t sampleToGroupType); MP4Err (*mapSamplestoGroup)(struct MP4MediaAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count); MP4Err (*getSampleGroupMap)(struct MP4MediaAtom *self, u32 groupType, u32 sample_number, u32 *group_index); - MP4Err (*getSampleGroupSampleNumbers)(struct MP4MediaAtom *self, u32 groupType, - u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt); + MP4Err (*getSampleGroupSampleNumbers)(struct MP4MediaAtom *self, u32 groupType, u32 groupIndex, + u32 **outSampleNumbers, u32 *outSampleCnt); MP4Err (*getGroupDescription)(struct MP4MediaAtom *self, u32 groupType, u32 index, MP4Handle description); @@ -540,7 +541,7 @@ typedef struct MP4MediaInformationAtom MP4Err (*getSampleGroupMap)(struct MP4MediaInformationAtom *self, u32 groupType, u32 sample_number, u32 *group_index); MP4Err (*getSampleGroupSampleNumbers)(struct MP4MediaInformationAtom *self, u32 groupType, - u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt); + u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt); MP4Err (*getGroupDescription)(struct MP4MediaInformationAtom *self, u32 groupType, u32 index, MP4Handle description); MP4Err (*getSampleDependency)(struct MP4MediaInformationAtom *self, u32 sampleNumber, @@ -712,13 +713,14 @@ typedef struct MP4SampleTableAtom MP4Err (*setDefaultSampleEntry)(struct MP4SampleTableAtom *self, u32 index); MP4Err (*addGroupDescription)(struct MP4SampleTableAtom *self, u32 theType, MP4Handle theDescription, u32 *index); - MP4Err (*changeSamplestoGroupType)(struct MP4SampleTableAtom *self, sampleToGroupType_t sampleToGroupType); + MP4Err (*changeSamplestoGroupType)(struct MP4SampleTableAtom *self, + sampleToGroupType_t sampleToGroupType); MP4Err (*mapSamplestoGroup)(struct MP4SampleTableAtom *self, u32 groupType, u32 group_index, s32 sample_index, u32 count, sampleToGroupType_t sampleToGroupType); MP4Err (*getSampleGroupMap)(struct MP4SampleTableAtom *self, u32 groupType, u32 sample_number, u32 *group_index); MP4Err (*getSampleGroupSampleNumbers)(struct MP4SampleTableAtom *self, u32 groupType, - u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt); + u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt); MP4Err (*getGroupDescription)(struct MP4SampleTableAtom *self, u32 theType, u32 index, MP4Handle theDescription); @@ -732,8 +734,8 @@ typedef struct MP4SampleTableAtom MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut); - - MP4Err (*mergeSampleGroupDescriptions)(struct MP4SampleTableAtom *self, MP4AtomPtr otherSampleGroupDescr); + MP4Err (*mergeSampleGroupDescriptions)(struct MP4SampleTableAtom *self, + MP4AtomPtr otherSampleGroupDescr); MP4AtomPtr TimeToSample; MP4AtomPtr CompositionOffset; @@ -1348,7 +1350,7 @@ typedef struct MP4TrackFragmentAtom MP4Err (*getSampleGroupMap)(struct MP4TrackFragmentAtom *self, u32 groupType, u32 sample_number, u32 *group_index); MP4Err (*getSampleGroupSampleNumbers)(struct MP4TrackFragmentAtom *self, u32 groupType, - u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt); + u32 groupIndex, u32 **outSampleNumbers, u32 *outSampleCnt); MP4Err (*getGroupDescription)(struct MP4TrackFragmentAtom *self, u32 theType, u32 index, MP4Handle theDescription); u32 default_sample_description_index; /* all copied from the matching trex */ @@ -1360,9 +1362,9 @@ typedef struct MP4TrackFragmentAtom u32 samples_use_mdat; /* 0 -- not yet decided, 1=yes, 2=no */ u8 useSignedCompositionTimeOffsets; - MP4LinkedList atomList; /* track runs */ - MP4LinkedList groupDescriptionList; /* sample group description list */ - MP4LinkedList sampletoGroupList; /* sample to group maps */ + MP4LinkedList atomList; /* track runs */ + MP4LinkedList groupDescriptionList; /* sample group description list */ + MP4LinkedList sampletoGroupList; /* sample to group maps */ MP4LinkedList saizList; MP4LinkedList saioList; } MP4TrackFragmentAtom, *MP4TrackFragmentAtomPtr; @@ -1710,7 +1712,8 @@ typedef struct MP4SampleGroupDescriptionAtom MP4Handle theDescription, u32 *index); MP4Err (*getGroupDescription)(struct MP4SampleGroupDescriptionAtom *self, u32 index, MP4Handle theDescription); - MP4Err (*findGroupDescriptionIdx)(struct MP4SampleGroupDescriptionAtom *self, MP4Handle searchH, u32 *index); + MP4Err (*findGroupDescriptionIdx)(struct MP4SampleGroupDescriptionAtom *self, MP4Handle searchH, + u32 *index); } MP4SampleGroupDescriptionAtom, *MP4SampleGroupDescriptionAtomPtr; @@ -1756,7 +1759,8 @@ typedef struct MP4SampletoGroupAtom MP4Err (*addSamples)(struct MP4SampletoGroupAtom *self, u32 count); MP4Err (*mapSamplestoGroup)(struct MP4SampletoGroupAtom *self, u32 group_index, s32 sample_index, u32 count); - MP4Err (*changeSamplestoGroupType)(struct MP4SampletoGroupAtom *self, sampleToGroupType_t sampleToGroupType); + MP4Err (*changeSamplestoGroupType)(struct MP4SampletoGroupAtom *self, + sampleToGroupType_t sampleToGroupType); MP4Err (*getSampleGroupMap)(struct MP4SampletoGroupAtom *self, u32 sampleNumber, u32 *groupIndex); } MP4SampletoGroupAtom, *MP4SampletoGroupAtomPtr; @@ -2120,7 +2124,8 @@ MP4Err MP4CreateEncVisualSampleEntryAtom(MP4EncVisualSampleEntryAtomPtr *outAtom MP4Err MP4CreateEncBaseAtom(MP4EncBaseSampleEntryAtomPtr outAtom); #endif -MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, sampleToGroupType_t sampleToGroupType); +MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, + sampleToGroupType_t sampleToGroupType); MP4Err MP4CreateSampleGroupDescriptionAtom(MP4SampleGroupDescriptionAtomPtr *outAtom); MP4Err MP4CreateSampleDependencyAtom(MP4SampleDependencyAtomPtr *outAtom); diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index 2291b5f..be27e9a 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -1381,7 +1381,7 @@ MP4GetMediaNextInterestingTime(MP4Media theMedia, { BAILWITHERROR(MP4InvalidMediaErr); } - err = stts->findSamples(stbl->TimeToSample, searchFromTime, &priorSample, &exactSample, + err = stts->findSamples(stbl->TimeToSample, searchFromTime, &priorSample, &exactSample, &nextSample, &sampleNumber, &sampleDuration); if(err) goto bail; if(outInterestingTime) diff --git a/IsoLib/libisomediafile/src/MP4Movies.c b/IsoLib/libisomediafile/src/MP4Movies.c index e93b4eb..e6c3a6b 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.c +++ b/IsoLib/libisomediafile/src/MP4Movies.c @@ -977,7 +977,8 @@ ISOIsMovieCompatibleBrand(ISOMovie theMovie, u32 brand) GETMOOV(theMovie); ftyp = (ISOFileTypeAtomPtr)moov->ftyp; if(ftyp) outval = ftyp->getStandard(ftyp, brand); - else BAILWITHERROR(MP4NoQTAtomErr) + else + BAILWITHERROR(MP4NoQTAtomErr) if(outval != brand) err = MP4NotFoundErr; bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/MP4Movies.h b/IsoLib/libisomediafile/src/MP4Movies.h index 6bbade3..d661274 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.h +++ b/IsoLib/libisomediafile/src/MP4Movies.h @@ -15,96 +15,96 @@ extern "C" #define ISMACrypt -typedef int MP4Err; + typedef int MP4Err; -enum -{ - /* JLF 12/00 : support for OD, returned by MP4GetInline... and MP4GetProfiles... */ - MP4HasRootOD = 2, - MP4EOF = 1, - MP4NoErr = 0, - MP4FileNotFoundErr = -1, - MP4BadParamErr = -2, - MP4NoMemoryErr = -3, - MP4IOErr = -4, - MP4NoLargeAtomSupportErr = -5, - MP4BadDataErr = -6, - MP4VersionNotSupportedErr = -7, - MP4InvalidMediaErr = -8, - MP4InternalErr = -9, - MP4NotFoundErr = -10, - MP4DataEntryTypeNotSupportedErr = -100, - MP4NoQTAtomErr = -500, - MP4NotImplementedErr = -1000 -}; - -enum -{ - MP4OpenMovieNormal = 0, - MP4OpenMovieDebug = (1 << 0), - MP4OpenMovieInPlace = (1 << 1) + enum + { + /* JLF 12/00 : support for OD, returned by MP4GetInline... and MP4GetProfiles... */ + MP4HasRootOD = 2, + MP4EOF = 1, + MP4NoErr = 0, + MP4FileNotFoundErr = -1, + MP4BadParamErr = -2, + MP4NoMemoryErr = -3, + MP4IOErr = -4, + MP4NoLargeAtomSupportErr = -5, + MP4BadDataErr = -6, + MP4VersionNotSupportedErr = -7, + MP4InvalidMediaErr = -8, + MP4InternalErr = -9, + MP4NotFoundErr = -10, + MP4DataEntryTypeNotSupportedErr = -100, + MP4NoQTAtomErr = -500, + MP4NotImplementedErr = -1000 + }; -}; + enum + { + MP4OpenMovieNormal = 0, + MP4OpenMovieDebug = (1 << 0), + MP4OpenMovieInPlace = (1 << 1) -enum -{ - MP4NewTrackIsVisual = (1 << 1), - MP4NewTrackIsAudio = (1 << 2), - MP4NewTrackIsMetadata = (1 << 3), - MP4NewTrackIsPrivate = (1 << 8) -}; + }; -enum -{ - MP4ObjectDescriptorHandlerType = MP4_FOUR_CHAR_CODE('o', 'd', 's', 'm'), - MP4ClockReferenceHandlerType = MP4_FOUR_CHAR_CODE('c', 'r', 's', 'm'), - MP4SceneDescriptionHandlerType = MP4_FOUR_CHAR_CODE('s', 'd', 's', 'm'), - MP4VisualHandlerType = MP4_FOUR_CHAR_CODE('v', 'i', 'd', 'e'), - MP4AudioHandlerType = MP4_FOUR_CHAR_CODE('s', 'o', 'u', 'n'), - MP4MPEG7HandlerType = MP4_FOUR_CHAR_CODE('m', '7', 's', 'm'), - MP4OCIHandlerType = MP4_FOUR_CHAR_CODE('o', 'c', 's', 'm'), - MP4IPMPHandlerType = MP4_FOUR_CHAR_CODE('i', 'p', 's', 'm'), - MP4MPEGJHandlerType = MP4_FOUR_CHAR_CODE('m', 'j', 's', 'm'), - MP4HintHandlerType = MP4_FOUR_CHAR_CODE('h', 'i', 'n', 't'), - MP4TextHandlerType = MP4_FOUR_CHAR_CODE('t', 'e', 'x', 't'), - MP7TextHandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '7', 't'), - MP7BinaryHandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '7', 'b'), - MP21HandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '2', '1'), - MP4NullHandlerType = MP4_FOUR_CHAR_CODE('n', 'u', 'l', 'l'), - MP4MetaHandlerType = MP4_FOUR_CHAR_CODE('m', 'e', 't', 'a'), - - ISOXMLAtomType = MP4_FOUR_CHAR_CODE('x', 'm', 'l', ' '), - ISOBinaryXMLAtomType = MP4_FOUR_CHAR_CODE('b', 'x', 'm', 'l') - -}; - -enum -{ - MP4IPMP_NoControlPoint = 0x00, - MP4IPMP_DB_Decoder_ControlPoint = 0x01, - MP4IPMP_Decoder_CB_ControlPoint = 0x02, - MP4IPMP_CB_Compositor_ControlPoint = 0x03, - MP4IPMP_BIFSTree_ControlPoint = 0x04 -}; - -enum -{ - does_depend_on = 0x10, - does_not_depend_on = 0x20, + enum + { + MP4NewTrackIsVisual = (1 << 1), + MP4NewTrackIsAudio = (1 << 2), + MP4NewTrackIsMetadata = (1 << 3), + MP4NewTrackIsPrivate = (1 << 8) + }; + + enum + { + MP4ObjectDescriptorHandlerType = MP4_FOUR_CHAR_CODE('o', 'd', 's', 'm'), + MP4ClockReferenceHandlerType = MP4_FOUR_CHAR_CODE('c', 'r', 's', 'm'), + MP4SceneDescriptionHandlerType = MP4_FOUR_CHAR_CODE('s', 'd', 's', 'm'), + MP4VisualHandlerType = MP4_FOUR_CHAR_CODE('v', 'i', 'd', 'e'), + MP4AudioHandlerType = MP4_FOUR_CHAR_CODE('s', 'o', 'u', 'n'), + MP4MPEG7HandlerType = MP4_FOUR_CHAR_CODE('m', '7', 's', 'm'), + MP4OCIHandlerType = MP4_FOUR_CHAR_CODE('o', 'c', 's', 'm'), + MP4IPMPHandlerType = MP4_FOUR_CHAR_CODE('i', 'p', 's', 'm'), + MP4MPEGJHandlerType = MP4_FOUR_CHAR_CODE('m', 'j', 's', 'm'), + MP4HintHandlerType = MP4_FOUR_CHAR_CODE('h', 'i', 'n', 't'), + MP4TextHandlerType = MP4_FOUR_CHAR_CODE('t', 'e', 'x', 't'), + MP7TextHandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '7', 't'), + MP7BinaryHandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '7', 'b'), + MP21HandlerType = MP4_FOUR_CHAR_CODE('m', 'p', '2', '1'), + MP4NullHandlerType = MP4_FOUR_CHAR_CODE('n', 'u', 'l', 'l'), + MP4MetaHandlerType = MP4_FOUR_CHAR_CODE('m', 'e', 't', 'a'), + + ISOXMLAtomType = MP4_FOUR_CHAR_CODE('x', 'm', 'l', ' '), + ISOBinaryXMLAtomType = MP4_FOUR_CHAR_CODE('b', 'x', 'm', 'l') - is_depended_on = 0x4, - is_not_depended_on = 0x8, + }; - has_redundancy = 1, - has_no_redundancy = 2 -}; + enum + { + MP4IPMP_NoControlPoint = 0x00, + MP4IPMP_DB_Decoder_ControlPoint = 0x01, + MP4IPMP_Decoder_CB_ControlPoint = 0x02, + MP4IPMP_CB_Compositor_ControlPoint = 0x03, + MP4IPMP_BIFSTree_ControlPoint = 0x04 + }; -typedef enum sampleToGroupType_t -{ - SAMPLE_GROUP_NORMAL = 0, /* sbgp */ - SAMPLE_GROUP_COMPACT, /* csgp */ - SAMPLE_GROUP_AUTO /* automatically decide based on atom size */ -} sampleToGroupType_t; + enum + { + does_depend_on = 0x10, + does_not_depend_on = 0x20, + + is_depended_on = 0x4, + is_not_depended_on = 0x8, + + has_redundancy = 1, + has_no_redundancy = 2 + }; + + typedef enum sampleToGroupType_t + { + SAMPLE_GROUP_NORMAL = 0, /* sbgp */ + SAMPLE_GROUP_COMPACT, /* csgp */ + SAMPLE_GROUP_AUTO /* automatically decide based on atom size */ + } sampleToGroupType_t; #define GETMOOV(arg) \ MP4PrivateMovieRecordPtr moov; \ @@ -296,22 +296,20 @@ typedef enum sampleToGroupType_t u32 *outReferenceIndex); MP4_EXTERN(MP4Err) MP4AddSubSampleInformationToTrack(MP4Track theTrack, MP4GenericAtom *subs); - MP4_EXTERN(MP4Err) + MP4_EXTERN(MP4Err) MP4SetSubSampleInformationFlags(MP4GenericAtom subsample, u32 flags); MP4_EXTERN(MP4Err) - MP4GetSubSampleInformationEntryFromTrack(MP4Track theTrack, u32 *flags, - u32 *entry_count, - u32 **sample_delta, u32 **subsample_count, - u32 ***subsample_size_array, - u32 ***subsample_priority_array, - u32 ***subsample_discardable_array); + MP4GetSubSampleInformationEntryFromTrack(MP4Track theTrack, u32 *flags, u32 *entry_count, + u32 **sample_delta, u32 **subsample_count, + u32 ***subsample_size_array, + u32 ***subsample_priority_array, + u32 ***subsample_discardable_array); MP4_EXTERN(MP4Err) - MP4AddSubSampleInformationEntry(MP4GenericAtom subsample, u32 sample_delta, - u32 subsample_count, - MP4Handle subsample_size_array, + MP4AddSubSampleInformationEntry(MP4GenericAtom subsample, u32 sample_delta, u32 subsample_count, + MP4Handle subsample_size_array, MP4Handle subsample_priority_array, MP4Handle subsample_discardable_array); - MP4_EXTERN(MP4Err) + MP4_EXTERN(MP4Err) MP4AddTrackGroup(MP4Track theTrack, u32 groupID, u32 dependencyType); MP4_EXTERN(MP4Err) MP4AddTrackToMovieIOD(MP4Track theTrack); diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index 6a31c9a..1d095cc 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -324,10 +324,10 @@ static MP4Err addGroupDescription(struct MP4MediaAtom *self, u32 groupType, MP4H minf = (MP4MediaInformationAtomPtr)self->information; /* this can be 'traf' if fragmented */ assert(minf); assert(minf->addGroupDescription); - + err = minf->addGroupDescription(minf, groupType, description, index); if(err) goto bail; - + bail: TEST_RETURN(err); @@ -352,7 +352,8 @@ static MP4Err getGroupDescription(struct MP4MediaAtom *self, u32 groupType, u32 return err; } -static MP4Err changeSamplestoGroupType(struct MP4MediaAtom *self, sampleToGroupType_t sampleToGroupType) +static MP4Err changeSamplestoGroupType(struct MP4MediaAtom *self, + sampleToGroupType_t sampleToGroupType) { MP4Err err; MP4MediaInformationAtomPtr minf; diff --git a/IsoLib/libisomediafile/src/MediaInformationAtom.c b/IsoLib/libisomediafile/src/MediaInformationAtom.c index ed26395..0cc0895 100644 --- a/IsoLib/libisomediafile/src/MediaInformationAtom.c +++ b/IsoLib/libisomediafile/src/MediaInformationAtom.c @@ -562,7 +562,8 @@ static MP4Err getGroupDescription(struct MP4MediaInformationAtom *self, u32 grou return err; } -static MP4Err changeSamplestoGroupType(struct MP4MediaInformationAtom *self, sampleToGroupType_t sampleToGroupType) +static MP4Err changeSamplestoGroupType(struct MP4MediaInformationAtom *self, + sampleToGroupType_t sampleToGroupType) { MP4Err err; MP4SampleTableAtomPtr stbl; @@ -592,8 +593,8 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *self, u32 groupT stbl = (MP4SampleTableAtomPtr)self->sampleTable; assert(stbl); assert(stbl->mapSamplestoGroup); - err = stbl->mapSamplestoGroup(stbl, groupType, group_index, sample_index, count, - sampleToGroupType); + err = + stbl->mapSamplestoGroup(stbl, groupType, group_index, sample_index, count, sampleToGroupType); if(err) goto bail; bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/MovieAtom.c b/IsoLib/libisomediafile/src/MovieAtom.c index a2661ff..316bcfe 100644 --- a/IsoLib/libisomediafile/src/MovieAtom.c +++ b/IsoLib/libisomediafile/src/MovieAtom.c @@ -460,7 +460,7 @@ static MP4Err getSampleDescriptionIndex(struct MP4MovieAtom *self, u32 trackID, MP4SampleTableAtomPtr stbl; MP4Err err; - err = MP4NoErr; + err = MP4NoErr; mdia = NULL; err = getTrackMedia(self, trackID, (MP4AtomPtr *)&mdia); diff --git a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c index 82257a2..4556420 100644 --- a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c +++ b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c @@ -155,7 +155,7 @@ static MP4Err addOffsets(MP4AtomPtr s, u32 entryCount, MP4Handle sizesH) MP4Err err; MP4SampleAuxiliaryInformationOffsetsAtomPtr self = (MP4SampleAuxiliaryInformationOffsetsAtomPtr)s; - err = MP4NoErr; + err = MP4NoErr; onlySize = 0; sizes = (u32 *)*sizesH; diff --git a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c index 11cfb4d..5c67cdd 100644 --- a/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c +++ b/IsoLib/libisomediafile/src/SampleGroupDescriptionAtom.c @@ -97,26 +97,28 @@ static MP4Err getGroupDescription(struct MP4SampleGroupDescriptionAtom *self, u3 return err; } -static MP4Err findGroupDescriptionIdx(struct MP4SampleGroupDescriptionAtom *self, MP4Handle searchH, u32 *index) +static MP4Err findGroupDescriptionIdx(struct MP4SampleGroupDescriptionAtom *self, MP4Handle searchH, + u32 *index) { MP4Err err; u32 size, i, temp; sampleGroupEntry *p; - err = MP4GetHandleSize(searchH, &size); if(err) goto bail; - if(index==NULL || self == NULL || size == 0) BAILWITHERROR(MP4BadParamErr); + err = MP4GetHandleSize(searchH, &size); + if(err) goto bail; + if(index == NULL || self == NULL || size == 0) BAILWITHERROR(MP4BadParamErr); err = MP4NotFoundErr; - for(i=0; igroupCount; ++i) + for(i = 0; i < self->groupCount; ++i) { p = &((self->groups)[i]); if(p->groupSize != size) continue; - + temp = memcmp(p->groupDescription, *searchH, size); - if(temp==0) + if(temp == 0) { - *index = i+1; - err = MP4NoErr; + *index = i + 1; + err = MP4NoErr; break; } } @@ -271,19 +273,19 @@ MP4Err MP4CreateSampleGroupDescriptionAtom(MP4SampleGroupDescriptionAtomPtr *out err = MP4CreateFullAtom((MP4AtomPtr)self); if(err) goto bail; - self->type = MP4SampleGroupDescriptionAtomType; - self->name = "sample group description"; - self->version = 1; - self->createFromInputStream = (cisfunc)createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->addGroupDescription = addGroupDescription; - self->getGroupDescription = getGroupDescription; + self->type = MP4SampleGroupDescriptionAtomType; + self->name = "sample group description"; + self->version = 1; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->addGroupDescription = addGroupDescription; + self->getGroupDescription = getGroupDescription; self->findGroupDescriptionIdx = findGroupDescriptionIdx; - self->default_length = 0; - self->groupCount = 0; - self->groups = NULL; + self->default_length = 0; + self->groupCount = 0; + self->groups = NULL; *outAtom = self; bail: diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index ec6c184..56d2858 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -414,7 +414,7 @@ static MP4Err addSamples(struct MP4SampleTableAtom *self, u32 sampleCount, u64 s if(err) goto bail; } } - + if(self->SampleDependency) { MP4SampleDependencyAtomPtr sdtp; @@ -565,7 +565,8 @@ static MP4Err getGroupDescription(struct MP4SampleTableAtom *self, u32 theType, return err; } -static MP4Err mergeSampleGroupDescriptions(struct MP4SampleTableAtom *self, MP4AtomPtr otherSampleGroupDescr) +static MP4Err mergeSampleGroupDescriptions(struct MP4SampleTableAtom *self, + MP4AtomPtr otherSampleGroupDescr) { MP4Err err, errTemp; MP4SampleGroupDescriptionAtomPtr stblGroup; @@ -573,25 +574,28 @@ static MP4Err mergeSampleGroupDescriptions(struct MP4SampleTableAtom *self, MP4A u32 idx, dummy; MP4Handle descrH; - if(otherSampleGroupDescr==NULL) BAILWITHERROR(MP4BadParamErr); + if(otherSampleGroupDescr == NULL) BAILWITHERROR(MP4BadParamErr); err = errTemp = MP4NoErr; - other = (MP4SampleGroupDescriptionAtomPtr)otherSampleGroupDescr; - idx = 1; + other = (MP4SampleGroupDescriptionAtomPtr)otherSampleGroupDescr; + idx = 1; - err = MP4FindGroupAtom(self->groupDescriptionList, other->grouping_type, (MP4AtomPtr *)&stblGroup); + err = + MP4FindGroupAtom(self->groupDescriptionList, other->grouping_type, (MP4AtomPtr *)&stblGroup); - if(err == MP4NoErr && stblGroup != NULL) + if(err == MP4NoErr && stblGroup != NULL) { - /* group description of the same type is already present in stbl, add only entries which are not yet present */ - while(errTemp==MP4NoErr) + /* group description of the same type is already present in stbl, add only entries which are not + * yet present */ + while(errTemp == MP4NoErr) { MP4NewHandle(0, &descrH); errTemp = other->getGroupDescription(other, idx++, descrH); - if(errTemp == MP4NoErr) + if(errTemp == MP4NoErr) { err = stblGroup->findGroupDescriptionIdx(stblGroup, descrH, &dummy); - if(err == MP4NotFoundErr) err = addGroupDescription(self, other->grouping_type, descrH, &dummy); + if(err == MP4NotFoundErr) + err = addGroupDescription(self, other->grouping_type, descrH, &dummy); } MP4DisposeHandle(descrH); } @@ -599,7 +603,7 @@ static MP4Err mergeSampleGroupDescriptions(struct MP4SampleTableAtom *self, MP4A else { /* no such group description, iterate over all entries and add them */ - while(errTemp==MP4NoErr) + while(errTemp == MP4NoErr) { MP4NewHandle(0, &descrH); errTemp = other->getGroupDescription(other, idx++, descrH); @@ -614,14 +618,15 @@ static MP4Err mergeSampleGroupDescriptions(struct MP4SampleTableAtom *self, MP4A return err; } -static MP4Err changeSamplestoGroupType(struct MP4SampleTableAtom *self, sampleToGroupType_t sampleToGroupType) +static MP4Err changeSamplestoGroupType(struct MP4SampleTableAtom *self, + sampleToGroupType_t sampleToGroupType) { MP4Err err; u32 i, count; err = MP4GetListEntryCount(self->sampletoGroupList, &count); if(err) goto bail; - + for(i = 0; i < count; i++) { MP4AtomPtr desc; @@ -651,7 +656,6 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, if(!theDesc) BAILWITHERROR(MP4BadParamErr); if(group_index > theDesc->groupCount) BAILWITHERROR(MP4BadParamErr); - /* create one if the box doesn't extist */ err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); if(!theGroup) @@ -665,9 +669,9 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, } err = MP4CreateSampletoGroupAtom(&theGroup, sampleToGroupType); if(err) goto bail; - theGroup->grouping_type = groupType; + theGroup->grouping_type = groupType; theGroup->fragmentLocalIndexPresent = 0; - err = addAtom(self, (MP4AtomPtr)theGroup); + err = addAtom(self, (MP4AtomPtr)theGroup); if(err) goto bail; err = theGroup->addSamples(theGroup, stsz->sampleCount); if(err) goto bail; @@ -694,7 +698,8 @@ static MP4Err getSampleGroupMap(struct MP4SampleTableAtom *self, u32 groupType, err = theGroup->getSampleGroupMap(theGroup, sample_number, group_index); if(err) goto bail; } - else BAILWITHERROR(MP4BadParamErr); + else + BAILWITHERROR(MP4BadParamErr); bail: TEST_RETURN(err); @@ -803,10 +808,10 @@ static MP4Err getSampleDependency(struct MP4SampleTableAtom *self, u32 sampleNum } static MP4Err getSampleAuxiliaryInformation(struct MP4SampleTableAtom *self, - u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, - u32 aux_info_type_parameter, - MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, - MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut) + u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, + u32 aux_info_type_parameter, + MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, + MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut) { MP4Err err; u32 i; diff --git a/IsoLib/libisomediafile/src/SampleToGroupAtom.c b/IsoLib/libisomediafile/src/SampleToGroupAtom.c index 085f1c4..8c7fd9c 100644 --- a/IsoLib/libisomediafile/src/SampleToGroupAtom.c +++ b/IsoLib/libisomediafile/src/SampleToGroupAtom.c @@ -146,15 +146,15 @@ static u8 SetFieldSize(u32 fieldSize) return 0; } -static void AppendDescriptionIndexToCompactGroup(CompressedGroupInfo *compressedGroup, u32 descIndex, - u32 groupIndex) +static void AppendDescriptionIndexToCompactGroup(CompressedGroupInfo *compressedGroup, + u32 descIndex, u32 groupIndex) { assert(descIndex < compressedGroup->totalIndexDescriptionCount); compressedGroup->indexDescriptionArray[descIndex] = groupIndex; } -static void AppendNewPatternEntry(CompressedGroupInfo *compressedGroup, u32 index, u32 patternLength, - u32 sampleCount) +static void AppendNewPatternEntry(CompressedGroupInfo *compressedGroup, u32 index, + u32 patternLength, u32 sampleCount) { assert(patternLength != 0); assert(sampleCount != 0); @@ -167,14 +167,16 @@ static void AppendNewPatternEntry(CompressedGroupInfo *compressedGroup, u32 inde } static void SetMemoryCostForPattern(SampleGroupInfo *sampleGroup, u32 patternLength, - u32 startPatternSampleIndex, u32 endPatternSampleIndex) + u32 startPatternSampleIndex, u32 endPatternSampleIndex) { s32 memoryCost; u32 sampleCount = endPatternSampleIndex - startPatternSampleIndex + 1; assert(startPatternSampleIndex + patternLength <= endPatternSampleIndex); - memoryCost = startPatternSampleIndex <= 0 ? sampleGroup->patternTracker[0].cumulativeMemoryCost : sampleGroup->patternTracker[startPatternSampleIndex - 1].cumulativeMemoryCost; + memoryCost = startPatternSampleIndex <= 0 + ? sampleGroup->patternTracker[0].cumulativeMemoryCost + : sampleGroup->patternTracker[startPatternSampleIndex - 1].cumulativeMemoryCost; memoryCost += (patternLength * sampleGroup->groupIndexFieldSize); if(memoryCost < sampleGroup->patternTracker[endPatternSampleIndex].cumulativeMemoryCost) @@ -368,9 +370,9 @@ static void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) patternTracker[i].nextEfficientIndex); }*/ - patternTracker = sampleGroup.patternTracker; - descIndex = 0; - nextIndex = compressedGroup->efficientStartIndex; + patternTracker = sampleGroup.patternTracker; + descIndex = 0; + nextIndex = compressedGroup->efficientStartIndex; for(patternIndex = 0; patternIndex < compressedGroup->patternCount; patternIndex++) { u32 patternLength = patternTracker[nextIndex].patternLength; @@ -530,14 +532,15 @@ static MP4Err mapSamplestoGroup(struct MP4SampletoGroupAtom *self, u32 group_ind return err; } -static MP4Err changeSamplestoGroupType(struct MP4SampletoGroupAtom *self, sampleToGroupType_t sampleToGroupType) +static MP4Err changeSamplestoGroupType(struct MP4SampletoGroupAtom *self, + sampleToGroupType_t sampleToGroupType) { MP4Err err; if(self == NULL) BAILWITHERROR(MP4BadParamErr) self->sampleToGroupType = sampleToGroupType; - switch (self->sampleToGroupType) + switch(self->sampleToGroupType) { case SAMPLE_GROUP_NORMAL: self->type = MP4SampletoGroupAtomType; @@ -679,9 +682,9 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->type == MP4CompactSampletoGroupAtomType) { self->flags = SetFieldSize(self->compressedGroup.indexFieldSize) | - (SetFieldSize(self->compressedGroup.sampleCountFieldSize) << 2) | - (SetFieldSize(self->compressedGroup.patternLengthFieldSize) << 4) | - (self->fragmentLocalIndexPresent ? 0x80 : 0); + (SetFieldSize(self->compressedGroup.sampleCountFieldSize) << 2) | + (SetFieldSize(self->compressedGroup.patternLengthFieldSize) << 4) | + (self->fragmentLocalIndexPresent ? 0x80 : 0); } err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); @@ -721,25 +724,25 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) else { printf(" \n Field sizes of pattern is %d , sampleCount is %d , indexDescription is %d ", - self->compressedGroup.patternLengthFieldSize, self->compressedGroup.sampleCountFieldSize, - self->compressedGroup.indexFieldSize); + self->compressedGroup.patternLengthFieldSize, self->compressedGroup.sampleCountFieldSize, + self->compressedGroup.indexFieldSize); printf("\n Pattern count %d covering %d total samples ", self->compressedGroup.patternCount, - self->compressedGroup.totalSampleCount); + self->compressedGroup.totalSampleCount); for(i = 0; i < self->compressedGroup.patternCount; i++) { printf("\n Pattern length %d for %d samples ", - self->compressedGroup.patternEntries[i].patternLength, - self->compressedGroup.patternEntries[i].sampleCount); + self->compressedGroup.patternEntries[i].patternLength, + self->compressedGroup.patternEntries[i].sampleCount); /* Pattern entry is ensured to start at a byte boundary*/ PackData(self, &buffer, self->compressedGroup.patternLengthFieldSize, 0, - self->compressedGroup.patternEntries[i].patternLength); + self->compressedGroup.patternEntries[i].patternLength); PackData(self, &buffer, self->compressedGroup.sampleCountFieldSize, - (self->compressedGroup.patternLengthFieldSize == 4), - self->compressedGroup.patternEntries[i].sampleCount); + (self->compressedGroup.patternLengthFieldSize == 4), + self->compressedGroup.patternEntries[i].sampleCount); } /* Index descriptor array is ensured to start at a byte boundary*/ @@ -748,7 +751,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) { printf(" %d ", self->compressedGroup.indexDescriptionArray[i]); PackData(self, &buffer, self->compressedGroup.indexFieldSize, (i & 1), - self->compressedGroup.indexDescriptionArray[i]); + self->compressedGroup.indexDescriptionArray[i]); } } @@ -790,8 +793,8 @@ static MP4Err calculateSize(struct MP4Atom *s) self->size += 8; sizeInBits = - (self->compressedGroup.patternCount * - (self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); + (self->compressedGroup.patternCount * (self->compressedGroup.patternLengthFieldSize + + self->compressedGroup.sampleCountFieldSize)); sizeInBits += (self->compressedGroup.totalIndexDescriptionCount * self->compressedGroup.indexFieldSize); self->size = self->size + (sizeInBits + 4) / 8; @@ -813,27 +816,27 @@ static MP4Err calculateSize(struct MP4Atom *s) CreateCompactSampleGroups(self); compactSize += 8; sizeInBits = - (self->compressedGroup.patternCount * - (self->compressedGroup.patternLengthFieldSize + self->compressedGroup.sampleCountFieldSize)); + (self->compressedGroup.patternCount * (self->compressedGroup.patternLengthFieldSize + + self->compressedGroup.sampleCountFieldSize)); sizeInBits += (self->compressedGroup.totalIndexDescriptionCount * self->compressedGroup.indexFieldSize); compactSize += (sizeInBits + 4) / 8; /* pick compact only if the size is smaller */ - if(normalSize<=compactSize) + if(normalSize <= compactSize) { self->changeSamplestoGroupType(self, SAMPLE_GROUP_NORMAL); - self->size = normalSize; + self->size = normalSize; self->entryCount = entryCount; } else { self->changeSamplestoGroupType(self, SAMPLE_GROUP_COMPACT); - self->size = compactSize; + self->size = compactSize; self->entryCount = self->compressedGroup.patternCount; } } - + bail: TEST_RETURN(err); @@ -890,7 +893,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre else { self->sampleToGroupType = 1; - indexFieldSize = 4 << ((flags & 0x3) >> 0); + indexFieldSize = 4 << ((flags & 0x3) >> 0); if(indexFieldSize != 4 && indexFieldSize != 8 && indexFieldSize != 16 && indexFieldSize != 32) BAILWITHERROR(MP4BadParamErr) @@ -900,7 +903,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre patternFieldSize = 4 << ((flags & 0x30) >> 4); if(patternFieldSize != 4 && patternFieldSize != 8 && patternFieldSize != 16 && - patternFieldSize != 32) + patternFieldSize != 32) BAILWITHERROR(MP4BadParamErr) /* Ensure each pattern entry is always byte-aligned*/ @@ -909,8 +912,8 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre self->fragmentLocalIndexPresent = (flags & 0x80); groupingTypeParamPresent = (flags & 0x40); - sprintf(msgString, "field size for index %d , sample count %d pattern length %d ", indexFieldSize, - countFieldSize, patternFieldSize); + sprintf(msgString, "field size for index %d , sample count %d pattern length %d ", + indexFieldSize, countFieldSize, patternFieldSize); inputStream->msg(inputStream, msgString); GET32(grouping_type); @@ -984,7 +987,8 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre return err; } -MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, sampleToGroupType_t sampleToGroupType) +MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, + sampleToGroupType_t sampleToGroupType) { MP4Err err; MP4SampletoGroupAtomPtr self; @@ -995,7 +999,7 @@ MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, sampleToGrou err = MP4CreateFullAtom((MP4AtomPtr)self); if(err) goto bail; self->sampleToGroupType = sampleToGroupType; - switch (self->sampleToGroupType) + switch(self->sampleToGroupType) { case SAMPLE_GROUP_NORMAL: self->type = MP4SampletoGroupAtomType; diff --git a/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c b/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c index 4b1a76d..bc6cd7d 100644 --- a/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c +++ b/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c @@ -46,7 +46,7 @@ static MP4Err addSubsegment(struct MP4SubsegmentIndexAtom *self, struct Subsegme err = MP4NoErr; err = MP4AddListEntry(ss, self->subsegmentsList); - if (err) goto bail; + if(err) goto bail; bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index 28a867d..3527712 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -71,10 +71,10 @@ static MP4Err addAtom(MP4TrackFragmentAtomPtr self, MP4AtomPtr atom) case MP4TrackRunAtomType: err = MP4AddListEntry(atom, self->atomList); break; - case MP4SampletoGroupAtomType: /* sbgp */ + case MP4SampletoGroupAtomType: /* sbgp */ case MP4CompactSampletoGroupAtomType: /* csgp */ err = MP4AddListEntry(atom, self->sampletoGroupList); - break; + break; case MP4SampleGroupDescriptionAtomType: /* sgpd */ err = MP4AddListEntry(atom, self->groupDescriptionList); break; @@ -313,8 +313,8 @@ static MP4Err addSampleReference(struct MP4MediaInformationAtom *s, u64 dataOffs return err; } -static MP4Err addGroupDescription(MP4TrackFragmentAtomPtr self, u32 theType, MP4Handle theDescription, - u32 *index) +static MP4Err addGroupDescription(MP4TrackFragmentAtomPtr self, u32 theType, + MP4Handle theDescription, u32 *index) { MP4Err err; MP4SampleGroupDescriptionAtomPtr theGroup; @@ -637,7 +637,8 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) return err; } -static MP4Err mergeSampleAuxiliaryInformation(struct MP4TrackFragmentAtom *self, MP4MediaAtomPtr mdia) +static MP4Err mergeSampleAuxiliaryInformation(struct MP4TrackFragmentAtom *self, + MP4MediaAtomPtr mdia) { u32 i; MP4Err err; @@ -678,11 +679,10 @@ static MP4Err mergeSampleAuxiliaryInformation(struct MP4TrackFragmentAtom *self, return err; } -static MP4Err getSampleAuxiliaryInfoFromTrackFragment(struct MP4TrackFragmentAtom *self, - u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, - u32 aux_info_type_parameter, - MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, - MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut) +static MP4Err getSampleAuxiliaryInfoFromTrackFragment( + struct MP4TrackFragmentAtom *self, u8 isUsingAuxInfoPropertiesFlag, u32 aux_info_type, + u32 aux_info_type_parameter, MP4SampleAuxiliaryInformationSizesAtomPtr *saizOut, + MP4SampleAuxiliaryInformationOffsetsAtomPtr *saioOut) { MP4Err err; u32 i; @@ -778,7 +778,8 @@ static MP4Err calculateDataEnd(MP4TrackFragmentAtomPtr self, u32 *outEnd) return err; } -static MP4Err changeSamplestoGroupType(struct MP4MediaInformationAtom *s, sampleToGroupType_t sampleToGroupType) +static MP4Err changeSamplestoGroupType(struct MP4MediaInformationAtom *s, + sampleToGroupType_t sampleToGroupType) { MP4Err err; u32 i, count; @@ -787,7 +788,7 @@ static MP4Err changeSamplestoGroupType(struct MP4MediaInformationAtom *s, sample if(s == NULL) BAILWITHERROR(MP4BadParamErr); self = (MP4TrackFragmentAtomPtr)s; - + err = MP4GetListEntryCount(self->sampletoGroupList, &count); if(err) goto bail; @@ -847,7 +848,7 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType } err = theGroup->mapSamplestoGroup(theGroup, group_index, sample_index, count); - if(err) goto bail; + if(err) goto bail; bail: TEST_RETURN(err); @@ -866,7 +867,8 @@ static MP4Err getSampleGroupMap(MP4TrackFragmentAtomPtr self, u32 groupType, u32 err = theGroup->getSampleGroupMap(theGroup, sample_number, group_index); if(err) goto bail; } - else BAILWITHERROR(MP4BadParamErr); + else + BAILWITHERROR(MP4BadParamErr); bail: TEST_RETURN(err); @@ -968,11 +970,11 @@ MP4Err MP4CreateTrackFragmentAtom(MP4TrackFragmentAtomPtr *outAtom) self->mergeRuns = mergeRuns; self->calculateDataEnd = calculateDataEnd; - self->addGroupDescription = addGroupDescription; + self->addGroupDescription = addGroupDescription; self->changeSamplestoGroupType = changeSamplestoGroupType; - self->mapSamplestoGroup = mapSamplestoGroup; - self->getSampleGroupMap = getSampleGroupMap; - self->getGroupDescription = getGroupDescription; + self->mapSamplestoGroup = mapSamplestoGroup; + self->getSampleGroupMap = getSampleGroupMap; + self->getGroupDescription = getGroupDescription; self->setSampleDependency = setSampleDependency; diff --git a/IsoLib/playground/main.cpp b/IsoLib/playground/main.cpp index dfb31b4..0f09811 100644 --- a/IsoLib/playground/main.cpp +++ b/IsoLib/playground/main.cpp @@ -4,89 +4,84 @@ * @brief Writes a HEVC mp4 file with sample groups accoring to colour pattern * @version 0.1 * @date 2020-10-26 - * + * * @copyright Copyright (c) 2020 - * + * */ #include #include #include #include #include +#include -extern "C" { -MP4_EXTERN(MP4Err) -ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, u32 length_size, - MP4Handle first_sps, MP4Handle first_pps, - MP4Handle first_spsext); +extern "C" +{ + MP4_EXTERN(MP4Err) + ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps, + MP4Handle first_pps, MP4Handle first_spsext); } -u8 VPS[] = {0x40, 0x01, 0x0C, 0x01, 0xFF, 0xFF, 0x04, 0x08, - 0x00, 0x00, 0x03, 0x00, 0x9F, 0xA8, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x1E, 0xBA, 0x02, 0x40}; +u8 VPS[] = {0x40, 0x01, 0x0C, 0x01, 0xFF, 0xFF, 0x04, 0x08, 0x00, 0x00, 0x03, 0x00, + 0x9F, 0xA8, 0x00, 0x00, 0x03, 0x00, 0x00, 0x1E, 0xBA, 0x02, 0x40}; -u8 SPS[] = {0x42, 0x01, 0x01, 0x04, 0x08, 0x00, 0x00, 0x03, - 0x00, 0x9F, 0xA8, 0x00, 0x00, 0x03, 0x00, 0x00, - 0x1E, 0xA0, 0x20, 0x83, 0x16, 0x5B, 0xAB, 0x93, - 0x2B, 0x9A, 0x02, 0x00, 0x00, 0x03, 0x00, 0x02, - 0x00, 0x00, 0x03, 0x00, 0x32, 0x10}; +u8 SPS[] = {0x42, 0x01, 0x01, 0x04, 0x08, 0x00, 0x00, 0x03, 0x00, 0x9F, 0xA8, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x1E, 0xA0, 0x20, 0x83, 0x16, 0x5B, 0xAB, 0x93, 0x2B, 0x9A, + 0x02, 0x00, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x32, 0x10}; u8 PPS[] = {0x44, 0x01, 0xC1, 0x73, 0xC0, 0x89}; -u8 auRed[] = {0x00, 0x00, 0x00, 0x16, 0x28, 0x01, 0xAF, 0x78, 0xF7, 0x04, - 0x03, 0xFF, 0xDB, 0xA3, 0xFF, 0xED, 0x27, 0xD2, 0xF6, - 0xC3, 0x94, 0x40, 0x83, 0xC0, 0x00, 0x78}; - -u8 auBlue[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, - 0x3F, 0x9C, 0x43, 0xFF, 0xFA, 0x87, 0x32, 0xAF, - 0xFC, 0x5D, 0xFF, 0xFF, 0xAE, 0x1D, 0xB9, 0xA2, - 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; +u8 auRed[] = {0x00, 0x00, 0x00, 0x16, 0x28, 0x01, 0xAF, 0x78, 0xF7, 0x04, 0x03, 0xFF, 0xDB, + 0xA3, 0xFF, 0xED, 0x27, 0xD2, 0xF6, 0xC3, 0x94, 0x40, 0x83, 0xC0, 0x00, 0x78}; -u8 auGreen[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, - 0x3F, 0x9C, 0x43, 0xFF, 0xF5, 0x9F, 0x1F, 0xFF, - 0xD8, 0x3B, 0xFF, 0xFD, 0xF0, 0xF5, 0xB9, 0xA2, - 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; +u8 auBlue[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3F, + 0x9C, 0x43, 0xFF, 0xFA, 0x87, 0x32, 0xAF, 0xFC, 0x5D, 0xFF, + 0xFF, 0xAE, 0x1D, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; -u8 auYellow[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xA0, - 0x3F, 0x9C, 0x43, 0x3C, 0xFA, 0x51, 0x1D, 0xFF, - 0xFC, 0x5D, 0xFE, 0xCB, 0xAE, 0x1D, 0xB9, 0xA2, - 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; +u8 auGreen[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3F, + 0x9C, 0x43, 0xFF, 0xF5, 0x9F, 0x1F, 0xFF, 0xD8, 0x3B, 0xFF, + 0xFD, 0xF0, 0xF5, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; +u8 auYellow[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xA0, 0x3F, + 0x9C, 0x43, 0x3C, 0xFA, 0x51, 0x1D, 0xFF, 0xFC, 0x5D, 0xFE, + 0xCB, 0xAE, 0x1D, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; -u8 auWhite[] = { - 0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, 0xE7, 0x9F, 0x6C, 0x07, 0x79, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87 -}; +u8 auWhite[] = {0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, + 0xE7, 0x9F, 0x6C, 0x07, 0x79, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87}; -u8 auBlack[] = { - 0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, 0xFF, 0xFF, 0x72, 0xCA, 0x19, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87 -}; +u8 auBlack[] = {0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, + 0xFF, 0xFF, 0x72, 0xCA, 0x19, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87}; const u32 TIMESCALE = 30000; -const u32 FPS = 30; +const u32 FPS = 30; const u32 FOURCC_COLOR = MP4_FOUR_CHAR_CODE('c', 'o', 'l', 'r'); const u32 FOURCC_TEST = MP4_FOUR_CHAR_CODE('t', 'e', 's', 't'); const u32 FOURCC_BLACK = MP4_FOUR_CHAR_CODE('b', 'l', 'c', 'k'); -u32 groupIdRed = 0; -u32 groupIdBlue = 0; -u32 groupIdGreen = 0; +u32 groupIdRed = 0; +u32 groupIdBlue = 0; +u32 groupIdGreen = 0; u32 groupIdYellow = 0; -u32 groupIdBlack = 0; +u32 groupIdBlack = 0; -ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, ISOHandle sampleEntryH = 0) { +ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, + ISOHandle sampleEntryH = 0) +{ ISOErr err; u32 sampleCount = 0; ISOHandle sampleDataH, durationsH, sizesH; - err = ISONewHandle(sizeof(u32), &durationsH); if(err) return err; + err = ISONewHandle(sizeof(u32), &durationsH); + if(err) return err; - *((u32*)*durationsH) = TIMESCALE/FPS; + *((u32 *)*durationsH) = TIMESCALE / FPS; std::vector bufferData; std::vector bufferSizes; - for(std::string::const_iterator it=strPattern.cbegin(); it != strPattern.cend(); ++it) { - switch (*it) + for(std::string::const_iterator it = strPattern.cbegin(); it != strPattern.cend(); ++it) + { + switch(*it) { case 'r': bufferData.insert(bufferData.end(), auRed, auRed + sizeof(auRed)); @@ -119,28 +114,37 @@ ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, } // repeat pattern - std::vector bufferDataPattern = bufferData; + std::vector bufferDataPattern = bufferData; std::vector bufferSizesPattern = bufferSizes; - std::string fullPattern = strPattern; - for(u32 n = 1; n Date: Wed, 18 Nov 2020 02:43:16 +0100 Subject: [PATCH 28/55] fix even more issues treat warnings as errors in libisomedia, increase the level of warnings, few bugfixes --- IsoLib/libisomediafile/CMakeLists.txt | 8 +++++ .../macosx/SimpleFileMappingObject.c | 6 ++-- .../src/CompatibleSchemeTypeAtom.c | 4 +-- IsoLib/libisomediafile/src/CopyrightAtom.c | 4 +-- IsoLib/libisomediafile/src/DataEntryURLAtom.c | 10 +++---- IsoLib/libisomediafile/src/DataEntryURNAtom.c | 14 ++++----- .../src/EncAudioSampleEntryAtom.c | 6 ++-- .../libisomediafile/src/ExtendedLanguageTag.c | 4 +-- .../src/FileMappingDataHandler.c | 6 ++-- IsoLib/libisomediafile/src/HandlerAtom.c | 2 +- IsoLib/libisomediafile/src/ISMAKMSAtom.c | 4 +-- IsoLib/libisomediafile/src/ISMASecurity.c | 2 ++ IsoLib/libisomediafile/src/ISOMeta.c | 23 +++++++------- .../src/ISOSampleDescriptions.c | 23 +++++++++----- .../libisomediafile/src/ItemInfoEntryAtom.c | 30 +++++++++---------- IsoLib/libisomediafile/src/MP4Atoms.c | 2 +- IsoLib/libisomediafile/src/MP4Media.c | 1 + IsoLib/libisomediafile/src/MP4Movies.c | 6 ++-- IsoLib/libisomediafile/src/MP4SLPacket.c | 3 +- IsoLib/libisomediafile/src/MediaAtom.c | 3 ++ IsoLib/libisomediafile/src/MediaDataAtom.c | 6 ++-- IsoLib/libisomediafile/src/MovieExtendsAtom.c | 2 +- .../libisomediafile/src/MovieFragmentAtom.c | 2 +- .../src/ProducerReferenceTimeAtom.c | 2 +- .../src/RestrictedSchemeInfoAtom.c | 2 +- .../src/RestrictedVideoSampleEntry.c | 6 ++-- .../SampleAuxiliaryInformationOffsetsAtom.c | 2 +- .../libisomediafile/src/SampleToGroupAtom.c | 2 +- IsoLib/libisomediafile/src/SchemeTypeAtom.c | 4 +-- .../libisomediafile/src/SecuritySchemeAtom.c | 2 +- IsoLib/libisomediafile/src/SegmentIndexAtom.c | 2 +- .../libisomediafile/src/SubsegmentIndexAtom.c | 2 +- .../libisomediafile/src/TextMetaSampleEntry.c | 10 +++---- .../libisomediafile/src/TrackFragmentAtom.c | 6 ++-- .../libisomediafile/src/XMLMetaSampleEntry.c | 12 ++++---- .../w32/W32FileMappingObject.c | 2 +- 36 files changed, 125 insertions(+), 100 deletions(-) diff --git a/IsoLib/libisomediafile/CMakeLists.txt b/IsoLib/libisomediafile/CMakeLists.txt index 0d96517..7c20ecc 100644 --- a/IsoLib/libisomediafile/CMakeLists.txt +++ b/IsoLib/libisomediafile/CMakeLists.txt @@ -6,6 +6,14 @@ cmake_minimum_required (VERSION 3.9.2) project(libisomediafile) #--------------------------------------------------------------------------------------------------- +if (MSVC) + # warning level 4 and all warnings as errors + add_compile_options(/W4 /WX) +else() + # lots of warnings and all warnings as errors + add_compile_options(-Wall -Wextra -pedantic -Werror) +endif() + add_library( ${PROJECT_NAME} diff --git a/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c b/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c index 5bd8150..5a760fc 100644 --- a/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c +++ b/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c @@ -84,7 +84,7 @@ static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *pathname) self->data = mmap(0, self->window_size, PROT_READ, MAP_FILE + MAP_PRIVATE, self->fd, self->window); - if(!(self->data) || (self->data < 0)) + if(!(self->data) || (self->data == MAP_FAILED)) { /* printf("Error was %d %s\n",errno,strerror( errno )); */ BAILWITHERROR(MP4IOErr); } @@ -173,7 +173,7 @@ static MP4Err copyData(struct FileMappingObjectRecord *s, u64 offset, char *dst, } #ifdef DO_MAP - if(self->window != (offset & WINDOW_BITS)) + if(self->window != (u64)(offset & WINDOW_BITS)) { err = munmap(self->data, self->window_size); if(err) @@ -188,7 +188,7 @@ static MP4Err copyData(struct FileMappingObjectRecord *s, u64 offset, char *dst, self->data = mmap(0, self->window_size, PROT_READ, MAP_FILE + MAP_PRIVATE, self->fd, self->window); - if(!(self->data) || (self->data < 0)) + if(!(self->data) || (self->data == MAP_FAILED)) { BAILWITHERROR(MP4IOErr); } diff --git a/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c b/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c index 368657a..2a7208d 100644 --- a/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c +++ b/IsoLib/libisomediafile/src/CompatibleSchemeTypeAtom.c @@ -64,7 +64,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) PUT32(scheme_version); if((self->flags & 1) == 1) { - u32 len = strlen(self->scheme_url) + 1; + u32 len = (u32)strlen(self->scheme_url) + 1; PUTBYTES(self->scheme_url, len); } @@ -87,7 +87,7 @@ static MP4Err calculateSize(struct MP4Atom *s) if((self->scheme_url) && (strlen(self->scheme_url) > 0)) { self->flags = 1; - self->size += 1 + strlen(self->scheme_url); /* strlen ignores \0 */ + self->size += (u32)strlen(self->scheme_url) + 1; /* strlen ignores \0 */ } else self->flags = 0; diff --git a/IsoLib/libisomediafile/src/CopyrightAtom.c b/IsoLib/libisomediafile/src/CopyrightAtom.c index 8181658..e0cc360 100644 --- a/IsoLib/libisomediafile/src/CopyrightAtom.c +++ b/IsoLib/libisomediafile/src/CopyrightAtom.c @@ -52,7 +52,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(err) goto bail; buffer += self->bytesWritten; PUT16(packedLanguageCode); - len = strlen(self->notice) + 1; + len = (u32)strlen(self->notice) + 1; PUTBYTES(self->notice, len); assert(self->bytesWritten == self->size); bail: @@ -69,7 +69,7 @@ static MP4Err calculateSize(struct MP4Atom *s) err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if(err) goto bail; - self->size += 3 + strlen(self->notice); + self->size += 3 + (u32)strlen(self->notice); bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/DataEntryURLAtom.c b/IsoLib/libisomediafile/src/DataEntryURLAtom.c index adaff31..b3ded20 100644 --- a/IsoLib/libisomediafile/src/DataEntryURLAtom.c +++ b/IsoLib/libisomediafile/src/DataEntryURLAtom.c @@ -64,9 +64,9 @@ static MP4Err addSampleReference(struct MP4DataEntryAtom *self, u64 dataOffset, { MP4Err err; - err = MP4NoErr; - dataOffset = dataOffset; - sizesH = sizesH; + err = MP4NoErr; + (void)dataOffset; + (void)sizesH; if(self->mdat) BAILWITHERROR(MP4BadParamErr) bail: TEST_RETURN(err); @@ -112,7 +112,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) { if(self->location) { - u32 len = strlen(self->location) + 1; + u32 len = (u32)strlen(self->location) + 1; PUTBYTES(self->location, len); } } @@ -133,7 +133,7 @@ static MP4Err calculateSize(struct MP4Atom *s) if(err) goto bail; if((self->flags & 1) == 0) { - if(self->location) self->size += 1 + strlen(self->location); + if(self->location) self->size += 1 + (u32)strlen(self->location); } bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/DataEntryURNAtom.c b/IsoLib/libisomediafile/src/DataEntryURNAtom.c index f43b2e3..2467790 100644 --- a/IsoLib/libisomediafile/src/DataEntryURNAtom.c +++ b/IsoLib/libisomediafile/src/DataEntryURNAtom.c @@ -65,9 +65,9 @@ static MP4Err addSampleReference(struct MP4DataEntryAtom *self, u64 dataOffset, { MP4Err err; - err = MP4NoErr; - dataOffset = dataOffset; - sizesH = sizesH; + err = MP4NoErr; + (void)dataOffset; + (void)sizesH; if(self->mdat) BAILWITHERROR(MP4BadParamErr); bail: TEST_RETURN(err); @@ -113,11 +113,11 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) { if(self->location) { - u32 len = strlen(self->location) + 1; + u32 len = (u32)strlen(self->location) + 1; PUTBYTES(self->location, len); if(self->name) { - len = strlen(self->name) + 1; + len = (u32)strlen(self->name) + 1; PUTBYTES(self->name, len); } } @@ -139,8 +139,8 @@ static MP4Err calculateSize(struct MP4Atom *s) if(err) goto bail; if((self->flags & 1) == 0) { - if(self->location) self->size += 1 + strlen(self->location); - if(self->name) self->size += 1 + strlen(self->name); + if(self->location) self->size += 1 + (u32)strlen(self->location); + if(self->name) self->size += 1 + (u32)strlen(self->name); } bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c b/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c index a49b85b..fe2b385 100644 --- a/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c +++ b/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: EncAudioSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: EncAudioSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -156,8 +156,8 @@ static MP4Err transform(struct MP4Atom *s, u32 sch_type, u32 sch_version, char * MP4EncBaseSampleEntryAtomPtr self = (MP4EncBaseSampleEntryAtomPtr)s; MP4OriginalFormatAtomPtr fmt; MP4SecurityInfoAtomPtr sinf; - MP4SchemeTypeAtomPtr schm; - MP4SchemeInfoAtomPtr schi; + MP4SchemeTypeAtomPtr schm = NULL; + MP4SchemeInfoAtomPtr schi = NULL; char *sch_url_copy = NULL; err = MP4CreateOriginalFormatAtom(&fmt); diff --git a/IsoLib/libisomediafile/src/ExtendedLanguageTag.c b/IsoLib/libisomediafile/src/ExtendedLanguageTag.c index 75b4159..c6b7c4b 100644 --- a/IsoLib/libisomediafile/src/ExtendedLanguageTag.c +++ b/IsoLib/libisomediafile/src/ExtendedLanguageTag.c @@ -49,7 +49,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); if(err) goto bail; buffer += self->bytesWritten; - PUTBYTES(self->extended_language, strlen(self->extended_language) * sizeof(char) + 1); + PUTBYTES(self->extended_language, (u32)strlen(self->extended_language) * sizeof(char) + 1); assert(self->bytesWritten == self->size); bail: TEST_RETURN(err); @@ -66,7 +66,7 @@ static MP4Err calculateSize(struct MP4Atom *s) err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if(err) goto bail; - self->size += strlen(self->extended_language) * sizeof(char) + 1; + self->size += (u32)strlen(self->extended_language) * sizeof(char) + 1; bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/FileMappingDataHandler.c b/IsoLib/libisomediafile/src/FileMappingDataHandler.c index 461a285..dd48182 100644 --- a/IsoLib/libisomediafile/src/FileMappingDataHandler.c +++ b/IsoLib/libisomediafile/src/FileMappingDataHandler.c @@ -47,7 +47,7 @@ static MP4Err createCanonicalPathName(struct MP4InputStreamRecord *inputStream, if((strncmp(fname, "file://", 7) == 0) || (strncmp(fname, "file|//", 7) == 0)) { /* absolute URL */ - err = MP4SetHandleSize(outPathNameH, strlen(fname + 6)); + err = MP4SetHandleSize(outPathNameH, (u32)strlen(fname + 6)); if(err) goto bail; strcpy(*outPathNameH, fname + 7); } @@ -62,7 +62,7 @@ static MP4Err createCanonicalPathName(struct MP4InputStreamRecord *inputStream, if(parent) { /* prepend parent path */ - err = MP4SetHandleSize(outPathNameH, (strlen(parent) + strlen(fname) + 1)); + err = MP4SetHandleSize(outPathNameH, (u32)(strlen(parent) + strlen(fname) + 1)); if(err) goto bail; strcpy(*outPathNameH, parent); /* parent includes platform-specific path separator */ strcat(*outPathNameH, fname); @@ -70,7 +70,7 @@ static MP4Err createCanonicalPathName(struct MP4InputStreamRecord *inputStream, else { /* bare: open relative to cwd */ - err = MP4SetHandleSize(outPathNameH, (strlen(fname) + 1)); + err = MP4SetHandleSize(outPathNameH, (u32)(strlen(fname) + 1)); if(err) goto bail; strcat(*outPathNameH, fname); } diff --git a/IsoLib/libisomediafile/src/HandlerAtom.c b/IsoLib/libisomediafile/src/HandlerAtom.c index e0c3ff8..a857898 100644 --- a/IsoLib/libisomediafile/src/HandlerAtom.c +++ b/IsoLib/libisomediafile/src/HandlerAtom.c @@ -105,7 +105,7 @@ static MP4Err setName(struct MP4Atom *s, char *name, u32 is_qt) oldname = self->nameUTF8; - self->nameLength = strlen(name); + self->nameLength = (u32)strlen(name); self->nameUTF8 = (char *)calloc(1, self->nameLength + 1); TESTMALLOC(self->nameUTF8) memcpy(self->nameUTF8, name, self->nameLength + 1); diff --git a/IsoLib/libisomediafile/src/ISMAKMSAtom.c b/IsoLib/libisomediafile/src/ISMAKMSAtom.c index f52693b..7161e83 100644 --- a/IsoLib/libisomediafile/src/ISMAKMSAtom.c +++ b/IsoLib/libisomediafile/src/ISMAKMSAtom.c @@ -56,7 +56,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->kms_url) { - len = strlen(self->kms_url) + 1; + len = (u32)strlen(self->kms_url) + 1; PUTBYTES(self->kms_url, len); } else @@ -78,7 +78,7 @@ static MP4Err calculateSize(struct MP4Atom *s) err = MP4CalculateFullAtomFieldSize((MP4FullAtomPtr)s); if(err) goto bail; - self->size += 1 + (self->kms_url ? strlen(self->kms_url) : 0); + self->size += 1 + (self->kms_url ? (u32)strlen(self->kms_url) : 0); bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/ISMASecurity.c b/IsoLib/libisomediafile/src/ISMASecurity.c index 8ecff7a..f9c17ef 100644 --- a/IsoLib/libisomediafile/src/ISMASecurity.c +++ b/IsoLib/libisomediafile/src/ISMASecurity.c @@ -173,6 +173,8 @@ ISMAUnTransformSampleEntrySalt(MP4Handle insampleEntryH, u8 *selective_encryptio u32 sch_type, sch_version; err = MP4NoErr; + entry = NULL; + is = NULL; err = MP4GetHandleSize(insampleEntryH, &size); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/ISOMeta.c b/IsoLib/libisomediafile/src/ISOMeta.c index 135976e..e8b19dd 100644 --- a/IsoLib/libisomediafile/src/ISOMeta.c +++ b/IsoLib/libisomediafile/src/ISOMeta.c @@ -1016,7 +1016,7 @@ ISOSetItemInfo(ISOMetaItem item, u16 protection_index, char *name, char *content if(name) { - sz = strlen(name); + sz = (u32)strlen(name); infe->item_name = (char *)calloc(1, sz + 1); memcpy(infe->item_name, name, sz); (infe->item_name)[sz] = '\0'; @@ -1029,7 +1029,7 @@ ISOSetItemInfo(ISOMetaItem item, u16 protection_index, char *name, char *content if(content_encoding) { - sz = strlen(content_encoding); + sz = (u32)strlen(content_encoding); infe->content_encoding = (char *)calloc(1, sz); memcpy(infe->content_encoding, content_encoding, sz); } @@ -1041,7 +1041,7 @@ ISOSetItemInfo(ISOMetaItem item, u16 protection_index, char *name, char *content if(content_type) { - sz = strlen(content_type); + sz = (u32)strlen(content_type); infe->content_type = (char *)calloc(1, sz); memcpy(infe->content_type, content_type, sz); } @@ -1152,7 +1152,7 @@ ISO_EXTERN(ISOErr) ISOSetItemInfoItemType(ISOMetaItem item, u32 item_type, char if(item_uri_type) { - u32 sz = strlen(item_uri_type); + u32 sz = (u32)strlen(item_uri_type); infe->item_uri_type = (char *)calloc(1, sz); memcpy(infe->item_uri_type, item_uri_type, sz); } @@ -1193,7 +1193,7 @@ ISO_EXTERN(ISOErr) ISOGetItemInfoItemType(ISOMetaItem item, u32 *item_type, char if(infe->item_uri_type) { - u32 sz = strlen(infe->item_uri_type); + u32 sz = (u32)strlen(infe->item_uri_type); *item_uri_type = (char *)calloc(1, sz); memcpy(*item_uri_type, infe->item_uri_type, sz); } @@ -1557,7 +1557,7 @@ ISO_EXTERN(ISOErr) ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_of else if(myItem->construction_method == 2) { u64 k; - err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), b->extent_index, + err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), (u16)b->extent_index, &referenceItem); if(err) goto bail; err = MP4NewHandle(0, &referenceItemData); @@ -1586,7 +1586,7 @@ ISO_EXTERN(ISOErr) ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_of } else if(myItem->construction_method == 1) { - err = idat->getData((MP4AtomPtr)idat, (*data) + datasize, b->extent_offset, length); + err = idat->getData((MP4AtomPtr)idat, (*data) + datasize, (u32)b->extent_offset, length); if(err) goto bail; } else if(myItem->construction_method == 2) @@ -1594,7 +1594,7 @@ ISO_EXTERN(ISOErr) ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_of u64 k; u32 referenceDataLength; - err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), b->extent_index, + err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), (u16)b->extent_index, &referenceItem); if(err) goto bail; err = MP4NewHandle(0, &referenceItemData); @@ -1656,7 +1656,7 @@ ISOGetItemInfo(ISOMetaItem item, u16 *protection_index, char *name, char *conten u32 sz; if(name && infe->item_name) { - sz = strlen(infe->item_name); + sz = (u32)strlen(infe->item_name); memcpy(name, infe->item_name, sz + 1); } else if(name) @@ -1664,7 +1664,7 @@ ISOGetItemInfo(ISOMetaItem item, u16 *protection_index, char *name, char *conten if(content_encoding && infe->content_encoding) { - sz = strlen(infe->content_encoding); + sz = (u32)strlen(infe->content_encoding); memcpy(content_encoding, infe->content_encoding, sz + 1); } else if(content_encoding) @@ -1672,7 +1672,7 @@ ISOGetItemInfo(ISOMetaItem item, u16 *protection_index, char *name, char *conten if(content_type && infe->content_type) { - sz = strlen(infe->content_type); + sz = (u32)strlen(infe->content_type); memcpy(content_type, infe->content_type, sz + 1); } else if(content_type) @@ -1746,6 +1746,7 @@ ISONewMetaProtection(ISOMeta meta, u32 sch_type, u32 sch_version, char *sch_url, u32 j; char *sch_url_copy = NULL; + schm = NULL; err = MP4NoErr; myMeta = (ISOMetaAtomPtr)meta; diff --git a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c index cca773d..1bbc5c7 100644 --- a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c +++ b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c @@ -150,6 +150,9 @@ MP4NewSampleDescriptionWithOCRAssociation(MP4Track theTrack, MP4Handle sampleDes MP4TrackAtomPtr trak; u32 outReferenceIndex; + entry = NULL; + esdAtom = NULL; + if((theTrack == NULL) || (sampleDescriptionH == NULL)) { BAILWITHERROR(MP4BadParamErr); @@ -436,8 +439,8 @@ ISONewGeneralSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, MP4Err MP4CreateAudioSampleEntryAtom(MP4AudioSampleEntryAtomPtr * outAtom); MP4Err err; - GenericSampleEntryAtomPtr entry; - MP4TrackAtomPtr trak; + GenericSampleEntryAtomPtr entry = NULL; + MP4TrackAtomPtr trak = NULL; if((theTrack == NULL) || (sampleDescriptionH == NULL)) { @@ -566,7 +569,7 @@ ISONewXMLMetaDataSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptio char *xml_namespace, char *schema_location) { MP4Err err; - MP4XMLMetaSampleEntryAtomPtr entry; + MP4XMLMetaSampleEntryAtomPtr entry = NULL; if((theTrack == NULL) || (sampleDescriptionH == NULL)) { @@ -620,7 +623,7 @@ ISONewTextMetaDataSampleDescription(MP4Track theTrack, MP4Handle sampleDescripti char *mime_format) { MP4Err err; - MP4TextMetaSampleEntryAtomPtr entry; + MP4TextMetaSampleEntryAtomPtr entry = NULL; if((theTrack == NULL) || (sampleDescriptionH == NULL)) { @@ -665,9 +668,9 @@ ISONewH263SampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 u32 vendor, u8 decoder_version, u8 H263_level, u8 H263_profile) { MP4Err err; - GenericSampleEntryAtomPtr entry; - MP4H263SpecificInfoAtomPtr H263SpecificInfoAtom; - MP4TrackAtomPtr trak; + GenericSampleEntryAtomPtr entry = NULL; + MP4H263SpecificInfoAtomPtr H263SpecificInfoAtom = NULL; + MP4TrackAtomPtr trak = NULL; if((theTrack == NULL) || (sampleDescriptionH == NULL)) { @@ -715,6 +718,8 @@ ISONewAMRSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 MP4Media media; u32 timeScale; + entry = NULL; + if((theTrack == NULL) || (sampleDescriptionH == NULL)) { BAILWITHERROR(MP4BadParamErr); @@ -767,6 +772,8 @@ ISONewAMRWPSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, MP4Media media; u32 timeScale; + entry = NULL; + if((theTrack == NULL) || (sampleDescriptionH == NULL)) { BAILWITHERROR(MP4BadParamErr); @@ -975,6 +982,8 @@ ISONewAVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 u32 the_size, y; u8 x; + entry = NULL; + if((theTrack == NULL) || (sampleDescriptionH == NULL)) { BAILWITHERROR(MP4BadParamErr); diff --git a/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c b/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c index 9597de1..1a71ba8 100644 --- a/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c +++ b/IsoLib/libisomediafile/src/ItemInfoEntryAtom.c @@ -98,7 +98,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->item_name) { - u32 len = strlen(self->item_name) + 1; + u32 len = (u32)strlen(self->item_name) + 1; PUTBYTES(self->item_name, len); } else @@ -110,7 +110,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) { if(self->content_type) { - u32 len = strlen(self->content_type) + 1; + u32 len = (u32)strlen(self->content_type) + 1; PUTBYTES(self->content_type, len); } else @@ -120,7 +120,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->content_encoding) { - u32 len = strlen(self->content_encoding) + 1; + u32 len = (u32)strlen(self->content_encoding) + 1; PUTBYTES(self->content_encoding, len); } else @@ -132,7 +132,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) { if(self->item_uri_type) { - u32 len = strlen(self->item_uri_type) + 1; + u32 len = (u32)strlen(self->item_uri_type) + 1; PUTBYTES(self->item_uri_type, len); } else @@ -178,9 +178,9 @@ static MP4Err calculateSize(struct MP4Atom *s) if((self->version == 0) || (self->version == 1)) { self->size += 7; /* includes the null terminators of the three strings */ - if(self->item_name) self->size += strlen(self->item_name); - if(self->content_type) self->size += strlen(self->content_type); - if(self->content_encoding) self->size += strlen(self->content_encoding); + if(self->item_name) self->size += (u32)strlen(self->item_name); + if(self->content_type) self->size += (u32)strlen(self->content_type); + if(self->content_encoding) self->size += (u32)strlen(self->content_encoding); } if(self->version == 1) @@ -203,18 +203,18 @@ static MP4Err calculateSize(struct MP4Atom *s) self->size += 4; self->size += 7; - if(self->item_name) self->size += strlen(self->item_name); + if(self->item_name) self->size += (u32)strlen(self->item_name); if(self->item_type == MP4_FOUR_CHAR_CODE('m', 'i', 'm', 'e')) { self->size += 2; - if(self->content_type) self->size += strlen(self->content_type); - if(self->content_encoding) self->size += strlen(self->content_encoding); + if(self->content_type) self->size += (u32)strlen(self->content_type); + if(self->content_encoding) self->size += (u32)strlen(self->content_encoding); } else if(self->item_type == MP4_FOUR_CHAR_CODE('u', 'r', 'i', ' ')) { self->size += 1; - if(self->item_uri_type) self->size += strlen(self->item_uri_type); + if(self->item_uri_type) self->size += (u32)strlen(self->item_uri_type); } } @@ -274,7 +274,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre if(bytesToRead > 0) { - i = strlen(str); + i = (u32)strlen(str); bytesToRead -= i + 1; self->item_name = calloc(i + 1, 1); strcpy(self->item_name, str); @@ -289,7 +289,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre { if(bytesToRead > 0) { - i = strlen(str); + i = (u32)strlen(str); bytesToRead -= i + 1; self->content_type = calloc(i + 1, 1); strcpy(self->content_type, str); @@ -302,7 +302,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre if(bytesToRead > 0) { - i = strlen(str); + i = (u32)strlen(str); bytesToRead -= i + 1; self->content_encoding = calloc(i + 1, 1); strcpy(self->content_encoding, str); @@ -317,7 +317,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre { if(bytesToRead > 0) { - i = strlen(str); + i = (u32)strlen(str); bytesToRead -= i + 1; self->item_uri_type = calloc(i + 1, 1); strcpy(self->item_uri_type, str); diff --git a/IsoLib/libisomediafile/src/MP4Atoms.c b/IsoLib/libisomediafile/src/MP4Atoms.c index 0c0959d..5708f0e 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.c +++ b/IsoLib/libisomediafile/src/MP4Atoms.c @@ -61,7 +61,7 @@ static void baseAtomDestroy(MP4AtomPtr self) static MP4Err baseAtomCreateFromInputStream(MP4AtomPtr self, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { - inputStream = inputStream; + (void)inputStream; self->type = proto->type; memcpy(self->uuid, proto->uuid, 16); self->size = proto->size; diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index be27e9a..008ea43 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -2230,6 +2230,7 @@ MP4AddSampleAuxiliaryInformation(MP4Media theMedia, u8 isUsingAuxInfoPropertiesF minf = NULL; stbl = NULL; traf = NULL; + saiz = NULL; if(sampleCount == 0) goto bail; diff --git a/IsoLib/libisomediafile/src/MP4Movies.c b/IsoLib/libisomediafile/src/MP4Movies.c index e6c3a6b..e1d1ba2 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.c +++ b/IsoLib/libisomediafile/src/MP4Movies.c @@ -1220,7 +1220,7 @@ MP4Err MP4GetCurrentTime(u64 *outTime) { time_t t; t = time(NULL); - calctime = t + MAC_EPOCH; + calctime = (unsigned long)(t + MAC_EPOCH); } #endif ret = calctime; @@ -1340,7 +1340,7 @@ MP4NewMovieExt(MP4Movie *outMovie, u32 initialODID, u8 OD_profileAndLevel, u8 sc od->objectDescriptorID = initialODID; if(strlen(url)) { - od->URLStringLength = strlen(url); + od->URLStringLength = (u32)strlen(url); od->URLString = (char *)malloc(sizeof(char) * od->URLStringLength); strcpy(od->URLString, url); } @@ -1363,7 +1363,7 @@ MP4NewMovieExt(MP4Movie *outMovie, u32 initialODID, u8 OD_profileAndLevel, u8 sc iod->graphics_profileAndLevel = graphics_profileAndLevel; if(strlen(url)) { - iod->URLStringLength = strlen(url); + iod->URLStringLength = (u32)strlen(url); iod->URLString = (char *)malloc(sizeof(char) * iod->URLStringLength); strcpy(iod->URLString, url); } diff --git a/IsoLib/libisomediafile/src/MP4SLPacket.c b/IsoLib/libisomediafile/src/MP4SLPacket.c index 0c6c1fa..75ab5e3 100644 --- a/IsoLib/libisomediafile/src/MP4SLPacket.c +++ b/IsoLib/libisomediafile/src/MP4SLPacket.c @@ -53,6 +53,7 @@ MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackRefere u32 i; u32 j; + is = NULL; err = MP4NoErr; err = MP4GetHandleSize(sampleH, &unitSize); if(err) goto bail; @@ -315,7 +316,7 @@ MP4Err rewriteIPMPDescriptorPointers(MP4DescriptorPtr desc, MP4TrackReferenceTyp MP4IPMPDescriptorPointerPtr ipmpDescPtr; err = MP4GetListEntry(ipmpDescPointersList, k, (char **)&ipmpDescPtr); if(err) goto bail; - if((ipmpDescPtr->ipmpEsId != 0) || (ipmpDescPtr->ipmpEsId != 0xFFFF)) + if((ipmpDescPtr->ipmpEsId != 0) && (ipmpDescPtr->ipmpEsId != 0xFFFF)) { /* rewrite the good ID */ ipmpDescPtr->ipmpEsId = mpod->trackIDs[ipmpDescPtr->ipmpEsId - 1]; diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index 1d095cc..8b3d67c 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -608,6 +608,9 @@ MP4Err MP4ParseODFrame(struct MP4MediaAtom *self, MP4Handle sampleH, MP4Handle s MP4Err MP4ParseCommand(MP4InputStreamPtr inputStream, MP4DescriptorPtr * outDesc); MP4Err MP4CreateES_ID_RefDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); + descList = NULL; + is = NULL; + err = MP4GetHandleSize(sampleH, &frameSize); if(err) goto bail; err = MP4CreateMemoryInputStream(*sampleH, frameSize, &is); diff --git a/IsoLib/libisomediafile/src/MediaDataAtom.c b/IsoLib/libisomediafile/src/MediaDataAtom.c index d3ee572..433ac54 100644 --- a/IsoLib/libisomediafile/src/MediaDataAtom.c +++ b/IsoLib/libisomediafile/src/MediaDataAtom.c @@ -101,7 +101,7 @@ static MP4Err writeToFile(struct MP4MediaDataAtom *self, FILE *fd) written = fwrite(self->data, 1, (size_t)self->dataSize, fd); if(written != (size_t)self->dataSize) BAILWITHERROR(MP4IOErr) #endif - self->bytesWritten += written; + self->bytesWritten += (u32)written; /* this is not reliable because bytesWritten is only a 32 and we may have written more */ } bail: @@ -158,7 +158,7 @@ static MP4Err addData(struct MP4MediaDataAtom *self, MP4Handle dataH) if(newSize > self->allocatedSize) { self->allocatedSize += allocation_size; - if(newSize > self->allocatedSize) self->allocatedSize = newSize; + if(newSize > self->allocatedSize) self->allocatedSize = (u32)newSize; if(self->data != NULL) self->data = (char *)realloc(self->data, self->allocatedSize); else @@ -198,7 +198,7 @@ static MP4Err addMdat(struct MP4MediaDataAtom *self, struct MP4MediaDataAtom *ot if(newSize > self->allocatedSize) { self->allocatedSize += allocation_size; - if(newSize > self->allocatedSize) self->allocatedSize = newSize; + if(newSize > self->allocatedSize) self->allocatedSize = (u32)newSize; if(self->data != NULL) self->data = (char *)realloc(self->data, self->allocatedSize); else diff --git a/IsoLib/libisomediafile/src/MovieExtendsAtom.c b/IsoLib/libisomediafile/src/MovieExtendsAtom.c index c06599d..8d477e7 100644 --- a/IsoLib/libisomediafile/src/MovieExtendsAtom.c +++ b/IsoLib/libisomediafile/src/MovieExtendsAtom.c @@ -208,7 +208,7 @@ static MP4Err maketrackfragments(struct MP4MovieExtendsAtom *self, MP4MovieFragm err = MP4GetMediaDuration((MP4Media)mdia, &initialMediaDuration); if(err) goto bail; - trex->baseMediaDecodeTime = initialMediaDuration; + trex->baseMediaDecodeTime = (u32)initialMediaDuration; trex->isInitialMediaDecodeTimeAdded = 1; } diff --git a/IsoLib/libisomediafile/src/MovieFragmentAtom.c b/IsoLib/libisomediafile/src/MovieFragmentAtom.c index 7faa049..b8eea6e 100644 --- a/IsoLib/libisomediafile/src/MovieFragmentAtom.c +++ b/IsoLib/libisomediafile/src/MovieFragmentAtom.c @@ -163,7 +163,7 @@ static MP4Err mergeFragments(struct MP4MovieFragmentAtom *self, MP4MovieAtomPtr if(tfdt->baseMediaDecodeTime > initialMediaDuration) err = - mdia->extendLastSampleDuration(mdia, tfdt->baseMediaDecodeTime - initialMediaDuration); + mdia->extendLastSampleDuration(mdia, tfdt->baseMediaDecodeTime - (u32)initialMediaDuration); if(err) goto bail; } diff --git a/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c b/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c index bcd989d..fa26588 100644 --- a/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c +++ b/IsoLib/libisomediafile/src/ProducerReferenceTimeAtom.c @@ -126,4 +126,4 @@ MP4Err MP4CreateProducerReferenceTimeAtom(MP4ProducerReferenceTimeAtomPtr *outAt TEST_RETURN(err); return err; -} \ No newline at end of file +} diff --git a/IsoLib/libisomediafile/src/RestrictedSchemeInfoAtom.c b/IsoLib/libisomediafile/src/RestrictedSchemeInfoAtom.c index 2c03c94..bd95085 100644 --- a/IsoLib/libisomediafile/src/RestrictedSchemeInfoAtom.c +++ b/IsoLib/libisomediafile/src/RestrictedSchemeInfoAtom.c @@ -179,4 +179,4 @@ MP4Err MP4CreateRestrictedSchemeInfoAtom(MP4RestrictedSchemeInfoAtomPtr *outAtom TEST_RETURN(err); return err; -} \ No newline at end of file +} diff --git a/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c b/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c index e633f9d..5a31e05 100644 --- a/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c +++ b/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c @@ -170,9 +170,9 @@ static MP4Err transform(struct MP4Atom *s, u32 sch_type, u32 sch_version, char * MP4RestrictedSchemeInfoAtomPtr rinf; MP4OriginalFormatAtomPtr frma; - MP4SchemeTypeAtomPtr schm; - MP4SchemeInfoAtomPtr schi; - char *sch_url_copy = NULL; + MP4SchemeTypeAtomPtr schm = NULL; + MP4SchemeInfoAtomPtr schi = NULL; + char *sch_url_copy = NULL; err = MP4CreateOriginalFormatAtom(&frma); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c index 4556420..6a3563b 100644 --- a/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c +++ b/IsoLib/libisomediafile/src/SampleAuxiliaryInformationOffsetsAtom.c @@ -59,7 +59,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->version == 0) { u32 temp; - temp = self->offsets[i] + self->additionalOffset; + temp = (u32)(self->offsets[i] + self->additionalOffset); PUT32_V(temp); } else diff --git a/IsoLib/libisomediafile/src/SampleToGroupAtom.c b/IsoLib/libisomediafile/src/SampleToGroupAtom.c index 8c7fd9c..42cab6c 100644 --- a/IsoLib/libisomediafile/src/SampleToGroupAtom.c +++ b/IsoLib/libisomediafile/src/SampleToGroupAtom.c @@ -535,7 +535,7 @@ static MP4Err mapSamplestoGroup(struct MP4SampletoGroupAtom *self, u32 group_ind static MP4Err changeSamplestoGroupType(struct MP4SampletoGroupAtom *self, sampleToGroupType_t sampleToGroupType) { - MP4Err err; + MP4Err err = MP4NoErr; if(self == NULL) BAILWITHERROR(MP4BadParamErr) diff --git a/IsoLib/libisomediafile/src/SchemeTypeAtom.c b/IsoLib/libisomediafile/src/SchemeTypeAtom.c index e79f984..5119206 100644 --- a/IsoLib/libisomediafile/src/SchemeTypeAtom.c +++ b/IsoLib/libisomediafile/src/SchemeTypeAtom.c @@ -59,7 +59,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) PUT32(scheme_version); if((self->flags & 1) == 1) { - u32 len = strlen(self->scheme_url) + 1; + u32 len = (u32)strlen(self->scheme_url) + 1; PUTBYTES(self->scheme_url, len); } @@ -82,7 +82,7 @@ static MP4Err calculateSize(struct MP4Atom *s) if((self->scheme_url) && (strlen(self->scheme_url) > 0)) { self->flags = 1; - self->size += 1 + strlen(self->scheme_url); /* strlen ignores \0 */ + self->size += 1 + (u32)strlen(self->scheme_url); /* strlen ignores \0 */ } else self->flags = 0; diff --git a/IsoLib/libisomediafile/src/SecuritySchemeAtom.c b/IsoLib/libisomediafile/src/SecuritySchemeAtom.c index 2fecd66..7f5e8a1 100644 --- a/IsoLib/libisomediafile/src/SecuritySchemeAtom.c +++ b/IsoLib/libisomediafile/src/SecuritySchemeAtom.c @@ -161,4 +161,4 @@ MP4Err MP4CreateSecuritySchemeAtom( MP4SecuritySchemeAtomPtr *outAtom ) #endif */ -typedef int suppress_iso_compiler_warning_empty_translation; \ No newline at end of file +typedef int suppress_iso_compiler_warning_empty_translation; diff --git a/IsoLib/libisomediafile/src/SegmentIndexAtom.c b/IsoLib/libisomediafile/src/SegmentIndexAtom.c index 93b5dcb..0e1f5c1 100644 --- a/IsoLib/libisomediafile/src/SegmentIndexAtom.c +++ b/IsoLib/libisomediafile/src/SegmentIndexAtom.c @@ -266,4 +266,4 @@ MP4Err MP4CreateSegmentIndexAtom(MP4SegmentIndexAtomPtr *outAtom) TEST_RETURN(err); return err; -} \ No newline at end of file +} diff --git a/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c b/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c index bc6cd7d..519b5f7 100644 --- a/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c +++ b/IsoLib/libisomediafile/src/SubsegmentIndexAtom.c @@ -289,4 +289,4 @@ MP4Err MP4CreateSubsegmentIndexAtom(MP4SubsegmentIndexAtomPtr *outAtom) TEST_RETURN(err); return err; -} \ No newline at end of file +} diff --git a/IsoLib/libisomediafile/src/TextMetaSampleEntry.c b/IsoLib/libisomediafile/src/TextMetaSampleEntry.c index 4d46561..7c95af5 100644 --- a/IsoLib/libisomediafile/src/TextMetaSampleEntry.c +++ b/IsoLib/libisomediafile/src/TextMetaSampleEntry.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TextMetaSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TextMetaSampleEntryAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -73,7 +73,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->content_encoding) { - u32 len = strlen(self->content_encoding) + 1; + u32 len = (u32)strlen(self->content_encoding) + 1; PUTBYTES(self->content_encoding, len); } else @@ -83,7 +83,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->mime_format) { - u32 len = strlen(self->mime_format) + 1; + u32 len = (u32)strlen(self->mime_format) + 1; PUTBYTES(self->mime_format, len); } else @@ -109,8 +109,8 @@ static MP4Err calculateSize(struct MP4Atom *s) if(err) goto bail; self->size += 8 + 2; /* the null terminators of the two strings */ - if(self->content_encoding) self->size += strlen(self->content_encoding); - if(self->mime_format) self->size += strlen(self->mime_format); + if(self->content_encoding) self->size += (u32)strlen(self->content_encoding); + if(self->mime_format) self->size += (u32)strlen(self->mime_format); ADD_ATOM_LIST_SIZE(ExtensionAtomList); bail: diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index 3527712..a8d7a9f 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -584,7 +584,7 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) if(havedeps) { - err = mdia->setSampleDependency(mdia, -count, depsH); + err = mdia->setSampleDependency(mdia, (s32)count*(-1), depsH); if(err) goto bail; } @@ -730,7 +730,7 @@ static MP4Err calculateDataEnd(MP4TrackFragmentAtomPtr self, u32 *outEnd) tfhd = (MP4TrackFragmentHeaderAtomPtr)self->tfhd; - data_end = tfhd->base_data_offset; + data_end = (u32)tfhd->base_data_offset; if(self->atomList) { @@ -749,7 +749,7 @@ static MP4Err calculateDataEnd(MP4TrackFragmentAtomPtr self, u32 *outEnd) MP4TrackRunEntryPtr entry; if(trun->flags & trun_data_offset_present) - data_begin = tfhd->base_data_offset + trun->data_offset; + data_begin = (u32)(tfhd->base_data_offset + trun->data_offset); else data_begin = data_end; diff --git a/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c b/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c index 353b9f5..34278ab 100644 --- a/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c +++ b/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c @@ -77,7 +77,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->content_encoding) { - u32 len = strlen(self->content_encoding) + 1; + u32 len = (u32)strlen(self->content_encoding) + 1; PUTBYTES(self->content_encoding, len); } else @@ -87,7 +87,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->xml_namespace) { - u32 len = strlen(self->xml_namespace) + 1; + u32 len = (u32)strlen(self->xml_namespace) + 1; PUTBYTES(self->xml_namespace, len); } else @@ -97,7 +97,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->schema_location) { - u32 len = strlen(self->schema_location) + 1; + u32 len = (u32)strlen(self->schema_location) + 1; PUTBYTES(self->schema_location, len); } else @@ -123,9 +123,9 @@ static MP4Err calculateSize(struct MP4Atom *s) if(err) goto bail; self->size += 8 + 3; /* the null terminators of the three strings */ - if(self->content_encoding) self->size += strlen(self->content_encoding); - if(self->xml_namespace) self->size += strlen(self->xml_namespace); - if(self->schema_location) self->size += strlen(self->schema_location); + if(self->content_encoding) self->size += (u32)strlen(self->content_encoding); + if(self->xml_namespace) self->size += (u32)strlen(self->xml_namespace); + if(self->schema_location) self->size += (u32)strlen(self->schema_location); ADD_ATOM_LIST_SIZE(ExtensionAtomList); bail: diff --git a/IsoLib/libisomediafile/w32/W32FileMappingObject.c b/IsoLib/libisomediafile/w32/W32FileMappingObject.c index 46e207c..2ec140c 100644 --- a/IsoLib/libisomediafile/w32/W32FileMappingObject.c +++ b/IsoLib/libisomediafile/w32/W32FileMappingObject.c @@ -82,7 +82,7 @@ static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *filename) /* make parent */ if((separator = strrchr(filename, '\\')) || (separator = strrchr(filename, '/'))) { - int len = separator - filename; + int len = (int)(separator - filename); if(self->parent) { free(self->parent); From d841eb0e885e20ff74d3470f9b5f420458382a7b Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Wed, 18 Nov 2020 04:09:04 +0100 Subject: [PATCH 29/55] potential bugfix --- IsoLib/libisomediafile/src/SampleTableAtom.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index 56d2858..b355f25 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -714,14 +714,14 @@ static MP4Err getSampleGroupSampleNumbers(struct MP4SampleTableAtom *self, u32 g MP4SampletoGroupAtomPtr theGroup; u32 i, cur_index, cur_count; *outSampleCnt = 0; - TESTMALLOC(*outSampleNumbers); err = MP4FindGroupAtom(self->sampletoGroupList, groupType, (MP4AtomPtr *)&theGroup); if(theGroup) { *outSampleNumbers = (u32 *)malloc((theGroup->sampleCount) * sizeof(u32)); - cur_index = (theGroup->group_index)[0]; - cur_count = 1; + TESTMALLOC(*outSampleNumbers); + cur_index = (theGroup->group_index)[0]; + cur_count = 1; for(i = 1; i < theGroup->sampleCount; i++) { if((theGroup->group_index)[i - 1] == (theGroup->group_index)[i]) cur_count++; From 0c2ac3cbd0269e7b05e6ef2e5013a69c6084243e Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Wed, 18 Nov 2020 17:32:57 +0100 Subject: [PATCH 30/55] wip: fix warning level 4 on windows --- .../libisomediafile/src/ChannelLayoutAtom.c | 2 +- .../src/DegradationPriorityAtom.c | 4 +- .../src/DownMixInstructionsAtom.c | 6 +- IsoLib/libisomediafile/src/ESUpdateCommand.c | 12 ++-- .../src/EncAudioSampleEntryAtom.c | 2 +- IsoLib/libisomediafile/src/ISMASecurity.c | 6 +- IsoLib/libisomediafile/src/ISOMeta.c | 19 +++--- .../src/ISOSampleDescriptions.c | 16 ++--- IsoLib/libisomediafile/src/ItemInfoAtom.c | 12 ++-- IsoLib/libisomediafile/src/ItemLocationAtom.c | 36 +++++------ .../libisomediafile/src/ItemPropertiesAtom.c | 2 +- .../libisomediafile/src/ItemProtectionAtom.c | 8 +-- .../libisomediafile/src/ItemReferenceAtom.c | 2 +- IsoLib/libisomediafile/src/LoudnessBaseAtom.c | 18 +++--- IsoLib/libisomediafile/src/MP4Atoms.c | 2 +- .../src/MP4DecoderConfigDescriptor.c | 4 +- IsoLib/libisomediafile/src/MP4ESDescriptor.c | 4 +- .../src/MP4InitialObjectDescriptor.c | 17 +++++- IsoLib/libisomediafile/src/MediaAtom.c | 47 ++++++++++++-- IsoLib/libisomediafile/src/MovieExtendsAtom.c | 15 +++-- IsoLib/libisomediafile/src/MovieTracks.c | 61 ++++++++++--------- 21 files changed, 175 insertions(+), 120 deletions(-) diff --git a/IsoLib/libisomediafile/src/ChannelLayoutAtom.c b/IsoLib/libisomediafile/src/ChannelLayoutAtom.c index 7e97503..6f66eec 100644 --- a/IsoLib/libisomediafile/src/ChannelLayoutAtom.c +++ b/IsoLib/libisomediafile/src/ChannelLayoutAtom.c @@ -262,7 +262,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre else { /* version > 0 */ GET8_V(tmp8); - self->stream_structure = tmp8 >> 4; + self->stream_structure = (u8)(tmp8 >> 4); self->formatOrdering = tmp8 & 0xF; GET8(baseChannelCount); if(self->stream_structure & STREAM_STRUCTURE_CHANNELS) diff --git a/IsoLib/libisomediafile/src/DegradationPriorityAtom.c b/IsoLib/libisomediafile/src/DegradationPriorityAtom.c index b202555..6bbaccc 100644 --- a/IsoLib/libisomediafile/src/DegradationPriorityAtom.c +++ b/IsoLib/libisomediafile/src/DegradationPriorityAtom.c @@ -1,4 +1,4 @@ -/* + /* This software module was originally developed by Apple Computer, Inc. in the course of development of MPEG-4. This software module is an implementation of a part of one or @@ -98,7 +98,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre { u32 priority; GET16_V(priority); - *p = priority; + *p = (u16)priority; } bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c b/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c index 2a67e03..a7825b1 100644 --- a/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c +++ b/IsoLib/libisomediafile/src/DownMixInstructionsAtom.c @@ -126,17 +126,17 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre count = 0; GET8(targetLayout); GET8_V(tmp8); - self->reserved = tmp8 >> 7; + self->reserved = (u8)(tmp8 >> 7); self->targetChannelCount = tmp8 & 0x7F; GET8_V(tmp8); - self->in_stream = tmp8 >> 7; + self->in_stream = (u8)(tmp8 >> 7); self->downmix_ID = tmp8 & 0x7F; while(self->bytesRead < self->size) { self->bs_downmix_coefficients = realloc(self->bs_downmix_coefficients, count + 2); GET8_V(tmp8); - self->bs_downmix_coefficients[count] = tmp8 >> 4; + self->bs_downmix_coefficients[count] = (u8)(tmp8 >> 4); self->bs_downmix_coefficients[count + 1] = tmp8 & 0x0F; count += 2; } diff --git a/IsoLib/libisomediafile/src/ESUpdateCommand.c b/IsoLib/libisomediafile/src/ESUpdateCommand.c index 8bb5b4f..6344d19 100644 --- a/IsoLib/libisomediafile/src/ESUpdateCommand.c +++ b/IsoLib/libisomediafile/src/ESUpdateCommand.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ESUpdateCommand.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ESUpdateCommand.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" @@ -149,14 +149,14 @@ static void destroy(struct MP4DescriptorRecord *s) static MP4Err removeESDS(struct MP4DescriptorRecord *s) { - MP4Err err; + MP4Err errBase; MP4ESDescriptorUpdatePtr self = (MP4ESDescriptorUpdatePtr)s; - err = MP4NoErr; + errBase = MP4NoErr; DESTROY_DESCRIPTOR_LIST(ESDescriptors); - err = MP4MakeLinkedList(&self->ESDescriptors); - if(err) goto bail; + errBase = MP4MakeLinkedList(&self->ESDescriptors); + if(errBase) goto bail; bail: - return err; + return errBase; } MP4Err MP4CreateESDescriptorUpdate(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr *outDesc) diff --git a/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c b/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c index fe2b385..9e661a7 100644 --- a/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c +++ b/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c @@ -313,8 +313,8 @@ static MP4Err getSchemeInfoAtom(struct MP4Atom *s, u32 theType, struct MP4Atom * if(desc && (desc->type == theType)) { *theAtom = desc; - break; err = MP4NoErr; + break; } } } diff --git a/IsoLib/libisomediafile/src/ISMASecurity.c b/IsoLib/libisomediafile/src/ISMASecurity.c index f9c17ef..bd8ebbf 100644 --- a/IsoLib/libisomediafile/src/ISMASecurity.c +++ b/IsoLib/libisomediafile/src/ISMASecurity.c @@ -222,9 +222,9 @@ ISMAUnTransformSampleEntrySalt(MP4Handle insampleEntryH, u8 *selective_encryptio err = entry->getSchemeInfoAtom((MP4AtomPtr)entry, ISMASampleFormatAtomType, (MP4AtomPtr *)&fmt); if(err) goto bail; - *selective_encryption = fmt->selective_encryption; - *key_indicator_length = fmt->key_indicator_len; - *IV_length = fmt->IV_len; + *selective_encryption = (u8)fmt->selective_encryption; + *key_indicator_length = (u8)fmt->key_indicator_len; + *IV_length = (u8)fmt->IV_len; err = entry->untransform((MP4AtomPtr)entry); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/ISOMeta.c b/IsoLib/libisomediafile/src/ISOMeta.c index e8b19dd..1021f43 100644 --- a/IsoLib/libisomediafile/src/ISOMeta.c +++ b/IsoLib/libisomediafile/src/ISOMeta.c @@ -21,8 +21,9 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: MP4Movies.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4Movies.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ + #include "MP4Movies.h" #include "MP4Atoms.h" #include "FileMappingObject.h" @@ -347,7 +348,7 @@ ISOAddMetaDataReference(ISOMeta meta, u16 *out_ref, ISOHandle urlHandle, ISOHand err = dref->addDataEntry(dref, (MP4AtomPtr)urn); if(err) goto bail; } - *out_ref = dref->getEntryCount(dref); + *out_ref = (u16)dref->getEntryCount(dref); bail: TEST_RETURN(err); @@ -757,7 +758,7 @@ ISOGetItemReference(ISOMetaItem item, u32 reference_type, u16 reference_index, I referencedItemID = toItemIDsArray[reference_index - 1]; - err = ISOFindItemByID((ISOMeta)myMeta, outItem, referencedItemID); + err = ISOFindItemByID((ISOMeta)myMeta, outItem, (u16)referencedItemID); if(err) goto bail; bail: @@ -856,7 +857,7 @@ ISOAddItemReferences(ISOMetaItem item, u32 reference_type, u16 reference_count, irefPtr = (ISOItemReferenceAtomPtr)myMeta->iref; - err = ISOCreateSingleItemTypeReferenceAtom(&singleIrefPtr, reference_type, irefPtr->version); + err = ISOCreateSingleItemTypeReferenceAtom(&singleIrefPtr, reference_type, (u8)irefPtr->version); if(err) goto bail; singleIrefPtr->from_item_ID = myItem->item_ID; @@ -954,7 +955,7 @@ ISO_EXTERN(ISOErr) ISOGetPrimaryItemID(ISOMeta meta, u16 *ID) pitm = (ISOPrimaryItemAtomPtr)myMeta->pitm; if(pitm) { - *ID = pitm->item_ID; + *ID = (u16)pitm->item_ID; } else BAILWITHERROR(MP4NotFoundErr); @@ -1534,8 +1535,8 @@ ISO_EXTERN(ISOErr) ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_of MetaExtentLocationPtr b; ISOMetaItem referenceItem; MP4Handle referenceItemData; - u32 length; - u64 fileSize; + u32 length = 0; + u64 fileSize = 0; err = MP4GetListEntry(myItem->extentList, j, (char **)&b); if(err) goto bail; @@ -1678,7 +1679,7 @@ ISOGetItemInfo(ISOMetaItem item, u16 *protection_index, char *name, char *conten else if(content_type) name[0] = 0; - if(protection_index) *protection_index = infe->protection_index; + if(protection_index) *protection_index = (u16)infe->protection_index; err = MP4NoErr; goto bail; } @@ -1787,7 +1788,7 @@ ISONewMetaProtection(ISOMeta meta, u32 sch_type, u32 sch_version, char *sch_url, } err = MP4GetListEntryCount(ipro->atomList, &j); if(err) goto bail; - *protection_index = j + 1; + *protection_index = (u16)(j + 1); err = ipro->addAtom(ipro, (MP4AtomPtr)sinf); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c index 1bbc5c7..a5e8e39 100644 --- a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c +++ b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c @@ -406,8 +406,8 @@ ISOGetSampleDescriptionDimensions(MP4Handle sampleEntryH, u16 *width, u16 *heigh err = sampleEntryHToAtomPtr(sampleEntryH, (MP4AtomPtr *)&entry, MP4VisualSampleEntryAtomType); if(err) goto bail; - *width = entry->width; - *height = entry->height; + *width = (u16)entry->width; + *height = (u16)entry->height; bail: if(entry) entry->destroy((MP4AtomPtr)entry); @@ -1374,15 +1374,15 @@ ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 /* sub_layer_profile_present_flag[i] + sub_layer_level_present_flag[i] */ for(i = 0; i < sps_max_sub_layers - 1; i++) { - sub_layer_profile_present_flag[i] = GetBits(bb, 1, &err); + sub_layer_profile_present_flag[i] = (u8)GetBits(bb, 1, &err); if(err) goto bail; - sub_layer_level_present_flag[i] = GetBits(bb, 1, &err); + sub_layer_level_present_flag[i] = (u8)GetBits(bb, 1, &err); if(err) goto bail; } /* reserved_zero_2bits[ i ] */ if(sps_max_sub_layers > 1) { - x = GetBits(bb, 16 - (sps_max_sub_layers - 1) * 2, &err); + x = (u8)GetBits(bb, 16 - (sps_max_sub_layers - 1) * 2, &err); if(err) goto bail; } @@ -1415,7 +1415,7 @@ ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 if(y == 3) { /* separate_colour_plane_flag */ - x = GetBits(bb, 1, &err); + x = (u8)GetBits(bb, 1, &err); if(err) goto bail; } /* pic_width_in_luma_samples */ @@ -1430,14 +1430,14 @@ ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 ((MP4TrackAtomPtr)theTrack)->setDimensions((MP4TrackAtomPtr)theTrack, width, height); /* conformance_window_flag */ - x = GetBits(bb, 1, &err); + x = (u8)GetBits(bb, 1, &err); if(err) goto bail; if(x) { /* conf_win_[left|right|top|bottom]_offset */ for(i = 0; i < 4; i++) { - x = read_golomb_uev(bb, &err); + x = (u8)read_golomb_uev(bb, &err); if(err) goto bail; } } diff --git a/IsoLib/libisomediafile/src/ItemInfoAtom.c b/IsoLib/libisomediafile/src/ItemInfoAtom.c index 7a06664..453f776 100644 --- a/IsoLib/libisomediafile/src/ItemInfoAtom.c +++ b/IsoLib/libisomediafile/src/ItemInfoAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ItemInfoAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ItemInfoAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -61,6 +61,8 @@ static MP4Err getEntry(ISOItemInfoAtomPtr self, u32 itemID, ISOItemInfoEntryAtom MP4Err err; u32 i; + err = MP4NoErr; + for(i = 0; i < self->atomList->entryCount; i++) { ISOItemInfoEntryAtomPtr entry; @@ -81,23 +83,23 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) { MP4Err err; ISOItemInfoAtomPtr self = (ISOItemInfoAtomPtr)s; - u32 count; + u32 countBase; err = MP4NoErr; err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); if(err) goto bail; buffer += self->bytesWritten; - err = MP4GetListEntryCount(self->atomList, &count); + err = MP4GetListEntryCount(self->atomList, &countBase); if(err) goto bail; if(self->version == 0) { - PUT16_V(count); + PUT16_V(countBase); } else { - PUT32_V(count); + PUT32_V(countBase); } SERIALIZE_ATOM_LIST(atomList); /* should be sorted by item_id! */ diff --git a/IsoLib/libisomediafile/src/ItemLocationAtom.c b/IsoLib/libisomediafile/src/ItemLocationAtom.c index 30e0422..35bbc59 100644 --- a/IsoLib/libisomediafile/src/ItemLocationAtom.c +++ b/IsoLib/libisomediafile/src/ItemLocationAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ItemLocationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ItemLocationAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -124,9 +124,9 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) } else if(self->base_offset_size == 4) { - u32 x; - x = (u32)a->base_offset; - PUT32_V(x); + u32 x1; + x1 = (u32)a->base_offset; + PUT32_V(x1); } list2Size = 0; @@ -151,9 +151,9 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) } else if(self->index_size == 4) { - u32 x; - x = (u32)b->extent_index; - PUT32_V(x); + u32 x2; + x2 = (u32)b->extent_index; + PUT32_V(x2); } } @@ -163,9 +163,9 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) } else if(self->offset_size == 4) { - u32 x; - x = (u32)b->extent_offset; - PUT32_V(x); + u32 x3; + x3 = (u32)b->extent_offset; + PUT32_V(x3); } if(self->length_size == 8) @@ -174,9 +174,9 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) } else if(self->length_size == 4) { - u32 x; - x = (u32)b->extent_length; - PUT32_V(x); + u32 x4; + x4 = (u32)b->extent_length; + PUT32_V(x4); } } } @@ -366,10 +366,10 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre if(err) goto bail; GET8_V(x); - self->offset_size = (x >> 4); + self->offset_size = (u8)(x >> 4); self->length_size = (x & 0xF); GET8_V_MSG(x, "base offset size"); - self->base_offset_size = (x >> 4); + self->base_offset_size = (u8)(x >> 4); self->index_size = (x & 0xF); GET16_V(item_count); @@ -387,16 +387,16 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre if(err) goto bail; GET16_V_MSG(tmp, "item_ID"); - a->item_ID = tmp; + a->item_ID = (u16)tmp; if(self->version == 1) { GET16_V_MSG(tmp, "construction_method"); - a->construction_method = tmp; + a->construction_method = (u8)tmp; } GET16_V_MSG(tmp, "dref_index"); - a->dref_index = tmp; + a->dref_index = (u16)tmp; switch(self->base_offset_size) { case 8: diff --git a/IsoLib/libisomediafile/src/ItemPropertiesAtom.c b/IsoLib/libisomediafile/src/ItemPropertiesAtom.c index 339ba67..8514be1 100644 --- a/IsoLib/libisomediafile/src/ItemPropertiesAtom.c +++ b/IsoLib/libisomediafile/src/ItemPropertiesAtom.c @@ -119,7 +119,7 @@ static MP4Err addItemProperty(struct MP4ItemPropertiesAtom *self, MP4AtomPtr ite 1, sizeof(MP4ItemPropertyAssociationEntryPropertyIndex)); TESTMALLOC(propertyIndex); propertyIndex->essential = essential; - propertyIndex->property_index = property_index + 1; + propertyIndex->property_index = (u16)(property_index + 1); err = MP4AddListEntry(propertyIndex, targetEntry->propertyIndexes); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/ItemProtectionAtom.c b/IsoLib/libisomediafile/src/ItemProtectionAtom.c index 0d920a5..4475884 100644 --- a/IsoLib/libisomediafile/src/ItemProtectionAtom.c +++ b/IsoLib/libisomediafile/src/ItemProtectionAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: ItemProtectionAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ + $Id: ItemProtectionAtom.c,v 1.1.1.1 2002/09/20 08:53:34 julien Exp $ */ #include "MP4Atoms.h" @@ -60,7 +60,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) { MP4Err err; ISOItemProtectionAtomPtr self = (ISOItemProtectionAtomPtr)s; - u32 count; + u32 countBase; err = MP4NoErr; @@ -68,9 +68,9 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(err) goto bail; buffer += self->bytesWritten; - err = MP4GetListEntryCount(self->atomList, &count); + err = MP4GetListEntryCount(self->atomList, &countBase); if(err) goto bail; - PUT16_V(count); + PUT16_V(countBase); SERIALIZE_ATOM_LIST(atomList); assert(self->bytesWritten == self->size); diff --git a/IsoLib/libisomediafile/src/ItemReferenceAtom.c b/IsoLib/libisomediafile/src/ItemReferenceAtom.c index 00d0e01..29455eb 100644 --- a/IsoLib/libisomediafile/src/ItemReferenceAtom.c +++ b/IsoLib/libisomediafile/src/ItemReferenceAtom.c @@ -90,7 +90,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre while(self->bytesRead < self->size) { ISOSingleItemTypeReferenceAtomPtr atm; - err = ISOCreateSingleItemTypeReferenceAtom(&atm, 0, self->version); + err = ISOCreateSingleItemTypeReferenceAtom(&atm, 0, (u8)self->version); if(err) goto bail; err = atm->createFromInputStream((MP4AtomPtr)atm, NULL, (char *)inputStream); diff --git a/IsoLib/libisomediafile/src/LoudnessBaseAtom.c b/IsoLib/libisomediafile/src/LoudnessBaseAtom.c index e6b15a6..ac47d12 100644 --- a/IsoLib/libisomediafile/src/LoudnessBaseAtom.c +++ b/IsoLib/libisomediafile/src/LoudnessBaseAtom.c @@ -21,8 +21,8 @@ derivative works. Copyright (c) 2014. */ /* - $Id: LoudnessBaseAtom.c,v 1.1.1.1 2014/09/19 08:10:00 armin Exp $ - */ + $Id: LoudnessBaseAtom.c,v 1.1.1.1 2014/09/19 08:10:00 armin Exp $ +*/ #include "MP4Atoms.h" #include @@ -130,30 +130,30 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre if(err) goto bail; GET8_V(tmp8); - self->reserved = tmp8 >> 5; + self->reserved = (u8)(tmp8 >> 5); tmpVar = (tmp8 & 0x1F) << 2; GET8_V(tmp8); - tmpVar += tmp8 >> 6; + tmpVar += (u8)(tmp8 >> 6); self->downmix_ID = tmpVar; self->DRC_set_ID = tmp8 & 0x3F; GET8_V(tmp8); - self->bs_sample_peak_level = tmp8; + self->bs_sample_peak_level = (s16)tmp8; GET8_V(tmp8); - self->bs_sample_peak_level = (self->bs_sample_peak_level << 4) + (tmp8 >> 4); + self->bs_sample_peak_level = (s16)((self->bs_sample_peak_level << 4) + (tmp8 >> 4)); self->bs_sample_peak_level = self->bs_sample_peak_level << 4; self->bs_sample_peak_level = self->bs_sample_peak_level >> 4; /* get sign right */ self->bs_true_peak_level = tmp8 & 0x0F; GET8_V(tmp8); - self->bs_true_peak_level = (self->bs_true_peak_level << 8) + tmp8; + self->bs_true_peak_level = (s16)((self->bs_true_peak_level << 8) + tmp8); self->bs_true_peak_level = self->bs_true_peak_level << 4; self->bs_true_peak_level = self->bs_true_peak_level >> 4; /* get sign right */ GET8_V(tmp8); - self->measurement_system_for_TP = tmp8 >> 4; + self->measurement_system_for_TP = (u8)(tmp8 >> 4); self->reliability_for_TP = tmp8 & 0x0F; GET8(measurement_count); @@ -167,7 +167,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre GET8_V(measurement->method_definition); GET8_V(measurement->method_value); GET8_V(tmp8); - measurement->measurement_system = tmp8 >> 4; + measurement->measurement_system = (u8)(tmp8 >> 4); measurement->reliability = tmp8 & 0x0F; MP4AddListEntry(measurement, self->measurements); } diff --git a/IsoLib/libisomediafile/src/MP4Atoms.c b/IsoLib/libisomediafile/src/MP4Atoms.c index 5708f0e..0c41fb0 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.c +++ b/IsoLib/libisomediafile/src/MP4Atoms.c @@ -652,7 +652,7 @@ void MP4TypeToString(u32 inType, char *ioStr) for(i = 0; i < 4; i++, ioStr++) { ch = inType >> (8 * (3 - i)) & 0xff; - if(isprint(ch)) *ioStr = ch; + if(isprint(ch)) *ioStr = (char)ch; else *ioStr = '.'; } diff --git a/IsoLib/libisomediafile/src/MP4DecoderConfigDescriptor.c b/IsoLib/libisomediafile/src/MP4DecoderConfigDescriptor.c index 0457543..a6161da 100644 --- a/IsoLib/libisomediafile/src/MP4DecoderConfigDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4DecoderConfigDescriptor.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: + $Id: */ #include "MP4Descriptors.h" #include "MP4Movies.h" @@ -52,7 +52,7 @@ static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) buffer += DESCRIPTOR_TAG_LEN_SIZE; PUT8(objectTypeIndication); - val = self->streamType << 2; + val = (u8)(self->streamType << 2); if(self->upstream) val |= (1 << 1); val |= 1; PUT8_V(val); diff --git a/IsoLib/libisomediafile/src/MP4ESDescriptor.c b/IsoLib/libisomediafile/src/MP4ESDescriptor.c index cdf8b0e..aafbdc5 100644 --- a/IsoLib/libisomediafile/src/MP4ESDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4ESDescriptor.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999, 2000. */ /* - $Id: MP4ESDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4ESDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" @@ -128,7 +128,7 @@ static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) buffer += DESCRIPTOR_TAG_LEN_SIZE; PUT16(ESID); - val = self->streamPriority; + val = (u8)self->streamPriority; if(self->OCRESID) val |= (1 << 5); if(self->URLStringLength) val |= (1 << 6); if(self->dependsOnES) val |= (1 << 7); diff --git a/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c b/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c index 90aed79..fa63ccf 100644 --- a/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4InitialObjectDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4InitialObjectDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" @@ -97,7 +97,7 @@ static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) if(err) goto bail; buffer += DESCRIPTOR_TAG_LEN_SIZE; - val = self->objectDescriptorID << 6; + val = (u16)(self->objectDescriptorID << 6); if(self->URLStringLength) val |= (1 << 5); if(self->inlineProfileFlag) val |= (1 << 4); val |= 0xf; @@ -228,7 +228,18 @@ static MP4Err removeESDS(struct MP4DescriptorRecord *s) MP4Err err; MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr)s; err = MP4NoErr; - DESTROY_DESCRIPTOR_LIST(ESDescriptors); + if(self->ESDescriptors) + { + u32 listSize, i; + err = MP4GetListEntryCount(self->ESDescriptors, &listSize); if(err) goto bail; + for(i = 0; i < listSize; i++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(self->ESDescriptors, i, (char **)&a); if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(self->ESDescriptors); if(err) goto bail; + } err = MP4MakeLinkedList(&self->ESDescriptors); if(err) goto bail; bail: diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index 8b3d67c..d22f289 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -656,7 +656,6 @@ MP4Err MP4ParseODFrame(struct MP4MediaAtom *self, MP4Handle sampleH, MP4Handle s while(is->available > 0) { - MP4DescriptorPtr desc; MP4ObjectDescriptorUpdatePtr odUpdate; MP4ESDescriptorUpdatePtr esUpdate; @@ -721,7 +720,20 @@ MP4Err MP4ParseODFrame(struct MP4MediaAtom *self, MP4Handle sampleH, MP4Handle s /* Remove the ESDescriptor List from each OD present in the ObjectDescriptor !! */ if(od->ESDescriptors) { - DESTROY_DESCRIPTOR_LIST_V(od->ESDescriptors); + u32 listSize; + u32 i1; + err = MP4GetListEntryCount(od->ESDescriptors, &listSize); + if(err) goto bail; + for(i1 = 0; i1 < listSize; i1++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(od->ESDescriptors, i1, (char **)&a); + if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(od->ESDescriptors); + if(err) goto bail; + od->ESDescriptors = NULL; } } @@ -762,7 +774,19 @@ MP4Err MP4ParseODFrame(struct MP4MediaAtom *self, MP4Handle sampleH, MP4Handle s /* Remove the ESDescriptors from the ES Listr present in this update!! */ if(esUpdate->ESDescriptors) { - DESTROY_DESCRIPTOR_LIST_V(esUpdate->ESDescriptors); + u32 listSize; + u32 i1; + err = MP4GetListEntryCount(esUpdate->ESDescriptors, &listSize); + if(err) goto bail; + for(i1 = 0; i1 < listSize; i1++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(esUpdate->ESDescriptors, i1, (char **)&a); + if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(esUpdate->ESDescriptors); if(err) goto bail; + esUpdate->ESDescriptors = NULL; } @@ -802,7 +826,18 @@ MP4Err MP4ParseODFrame(struct MP4MediaAtom *self, MP4Handle sampleH, MP4Handle s if(is) is->destroy(is); if(descList) { - DESTROY_DESCRIPTOR_LIST_V(descList); + u32 listSize; + u32 i1; + err = MP4GetListEntryCount(descList, &listSize); + if(err) goto bail; + for(i1 = 0; i1 < listSize; i1++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(descList, i1, (char **)&a); + if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(descList); if(err) goto bail; } TEST_RETURN(err); return err; @@ -812,7 +847,7 @@ MP4Err storeIPMPDescriptorPointers(MP4DescriptorPtr desc, MP4TrackReferenceTypeA { u32 k; u32 ipmpDescPointersCount; - u32 err; + MP4Err err; MP4LinkedList ipmpDescPointersList; err = MP4NoErr; @@ -843,7 +878,7 @@ MP4Err storeIPMPDescriptorPointers(MP4DescriptorPtr desc, MP4TrackReferenceTypeA err = mpod->addTrackID(mpod, ipmpDescPtr->ipmpEsId); if(err) goto bail; /* change the id */ - ipmpDescPtr->ipmpEsId = mpod->trackIDCount; + ipmpDescPtr->ipmpEsId = (u16)mpod->trackIDCount; } } diff --git a/IsoLib/libisomediafile/src/MovieExtendsAtom.c b/IsoLib/libisomediafile/src/MovieExtendsAtom.c index 8d477e7..c8d2041 100644 --- a/IsoLib/libisomediafile/src/MovieExtendsAtom.c +++ b/IsoLib/libisomediafile/src/MovieExtendsAtom.c @@ -121,6 +121,7 @@ static MP4Err setCompositionToDecodeProperties(struct MP4MovieExtendsAtom *self, err = MP4NoErr; createCslg = 0; + cslg = NULL; trep = NULL; self->getTrackExtensionPropertiesAtom(self, trackID, (MP4AtomPtr *)&trep); @@ -148,11 +149,15 @@ static MP4Err setCompositionToDecodeProperties(struct MP4MovieExtendsAtom *self, trep->addAtom(trep, (MP4AtomPtr)cslg); } - cslg->compositionToDTSShift = compositionToDTSShift; - cslg->leastDecodeToDisplayDelta = leastDecodeToDisplayDelta; - cslg->greatestDecodeToDisplayDelta = greatestDecodeToDisplayDelta; - cslg->compositionStartTime = compositionStartTime; - cslg->compositionEndTime = compositionEndTime; + if(cslg) + { + cslg->compositionToDTSShift = compositionToDTSShift; + cslg->leastDecodeToDisplayDelta = leastDecodeToDisplayDelta; + cslg->greatestDecodeToDisplayDelta = greatestDecodeToDisplayDelta; + cslg->compositionStartTime = compositionStartTime; + cslg->compositionEndTime = compositionEndTime; + } + bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/MovieTracks.c b/IsoLib/libisomediafile/src/MovieTracks.c index 82a5305..df12cb5 100644 --- a/IsoLib/libisomediafile/src/MovieTracks.c +++ b/IsoLib/libisomediafile/src/MovieTracks.c @@ -31,6 +31,8 @@ derivative works. Copyright (c) 1999. #include #include +MP4Err MP4MovieAddTrackES_IDToIOD(MP4Movie theMovie, MP4Track theTrack); + MP4_EXTERN(MP4Err) MP4GetTrackID(MP4Track theTrack, u32 *outTrackID) { MP4Err err; @@ -358,7 +360,6 @@ MP4_EXTERN(MP4Err) MP4AddTrackGroup(MP4Track theTrack, u32 groupID, u32 dependen MP4_EXTERN(MP4Err) MP4AddTrackToMovieIOD(MP4Track theTrack) { - MP4Err MP4MovieAddTrackES_IDToIOD(MP4Movie theMovie, MP4Track theTrack); MP4Movie itsMovie; MP4Err err; if(theTrack == 0) BAILWITHERROR(MP4BadParamErr); @@ -1036,6 +1037,8 @@ ISOSetTrackFragmentDefaults(MP4Track theTrack, u32 duration, u32 size, u32 is_sy MP4TrackHeaderAtomPtr tkhd; /* MP4SampleTableAtomPtr stbl; */ MP4MovieExtendsAtomPtr mvex; + MP4MovieAtomPtr movieAtom; + MP4PrivateMovieRecordPtr moov; err = MP4NoErr; trak = (MP4TrackAtomPtr)theTrack; @@ -1043,42 +1046,40 @@ ISOSetTrackFragmentDefaults(MP4Track theTrack, u32 duration, u32 size, u32 is_sy if(err) goto bail; /* This function needs a re-write to be more object-oriented...*/ - + if(theMovie == NULL) BAILWITHERROR(MP4BadParamErr) + moov = (MP4PrivateMovieRecordPtr)theMovie; + movieAtom = (MP4MovieAtomPtr)moov->moovAtomPtr; + if(movieAtom->mvex == NULL) { - GETMOVIEATOM(theMovie); - if(movieAtom->mvex == NULL) - { - err = MP4CreateMovieExtendsAtom(&mvex); - if(err) goto bail; - err = movieAtom->addAtom(movieAtom, (MP4AtomPtr)mvex); - if(err) goto bail; - } - else - mvex = (MP4MovieExtendsAtomPtr)(movieAtom->mvex); - - err = MP4CreateTrackExtendsAtom(&trex); + err = MP4CreateMovieExtendsAtom(&mvex); + if(err) goto bail; + err = movieAtom->addAtom(movieAtom, (MP4AtomPtr)mvex); if(err) goto bail; - tkhd = (MP4TrackHeaderAtomPtr)trak->trackHeader; + } + else + mvex = (MP4MovieExtendsAtomPtr)(movieAtom->mvex); - trex->trackID = tkhd->trackID; - trex->default_sample_duration = duration; - trex->default_sample_size = size; - trex->default_sample_flags = - ((pad & 7) << 17) | (is_sync ? 0 : fragment_difference_sample_flag); + err = MP4CreateTrackExtendsAtom(&trex); + if(err) goto bail; + tkhd = (MP4TrackHeaderAtomPtr)trak->trackHeader; - /* stbl = ((MP4SampleTableAtomPtr) - ((MP4MediaInformationAtomPtr) - ((MP4MediaAtomPtr) - (trak->trackMedia))->information)->sampleTable); + trex->trackID = tkhd->trackID; + trex->default_sample_duration = duration; + trex->default_sample_size = size; + trex->default_sample_flags = + ((pad & 7) << 17) | (is_sync ? 0 : fragment_difference_sample_flag); - trex->default_sample_description_index = stbl->getCurrentSampleEntryIndex( stbl ); */ + /* stbl = ((MP4SampleTableAtomPtr) + ((MP4MediaInformationAtomPtr) + ((MP4MediaAtomPtr) + (trak->trackMedia))->information)->sampleTable); - err = mvex->addAtom(mvex, (MP4AtomPtr)trex); - if(err) goto bail; - } -bail: - TEST_RETURN(err); + trex->default_sample_description_index = stbl->getCurrentSampleEntryIndex( stbl ); */ + err = mvex->addAtom(mvex, (MP4AtomPtr)trex); + if(err) goto bail; + +bail: return err; } From a6d69dd27a86eff018aa51c0c8dc6bdf621a4257 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Wed, 18 Nov 2020 22:51:13 +0100 Subject: [PATCH 31/55] merge local sample groups in fragments --- IsoLib/libisomediafile/src/MP4Media.c | 2 + IsoLib/libisomediafile/src/MP4Movies.h | 2 +- IsoLib/libisomediafile/src/MediaAtom.c | 6 ++ .../libisomediafile/src/TrackFragmentAtom.c | 35 +++++++- IsoLib/playground/main.cpp | 82 +++++++------------ 5 files changed, 69 insertions(+), 58 deletions(-) diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index 008ea43..0a1e12c 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -175,6 +175,8 @@ ISOAddGroupDescription(MP4Media media, u32 groupType, MP4Handle description, u32 mdia = (MP4MediaAtomPtr)media; err = mdia->addGroupDescription(mdia, groupType, description, index); + if(!err) printf("Add group description: index = %u\n", *index); + bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/MP4Movies.h b/IsoLib/libisomediafile/src/MP4Movies.h index d661274..82ad3f0 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.h +++ b/IsoLib/libisomediafile/src/MP4Movies.h @@ -416,7 +416,7 @@ extern "C" ISOGetGroupDescription(MP4Media media, u32 groupType, u32 index, MP4Handle description); MP4_EXTERN(MP4Err) - ISOSetSamplestoGroupType(MP4Media media, u32 sampleToGroupType); + ISOSetSamplestoGroupType(MP4Media media, sampleToGroupType_t sampleToGroupType); MP4_EXTERN(MP4Err) ISOMapSamplestoGroup(MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count); diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index d22f289..914a561 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -328,6 +328,11 @@ static MP4Err addGroupDescription(struct MP4MediaAtom *self, u32 groupType, MP4H err = minf->addGroupDescription(minf, groupType, description, index); if(err) goto bail; + if(minf->type == MP4TrackFragmentAtomType) + { + *index += 0x10000; + } + bail: TEST_RETURN(err); @@ -364,6 +369,7 @@ static MP4Err changeSamplestoGroupType(struct MP4MediaAtom *self, assert(minf->changeSamplestoGroupType); err = minf->changeSamplestoGroupType(minf, sampleToGroupType); if(err) goto bail; + self->sampleToGroupType = sampleToGroupType; bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index a8d7a9f..c694f7d 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -607,7 +607,7 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) if(self->sampletoGroupList) { u32 groupListSize; - err = ISOSetSamplestoGroupType((MP4Media)mdia, 0); + err = ISOSetSamplestoGroupType((MP4Media)mdia, SAMPLE_GROUP_NORMAL); if(err) goto bail; err = MP4GetListEntryCount(self->sampletoGroupList, &groupListSize); if(err) goto bail; @@ -622,10 +622,37 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) for(j = 0; j < theGroup->sampleCount; j++) { s32 position; + u32 index, localIndex, correctIndex; position = j - total_samples; - err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, (theGroup->group_index)[j], - position, 1); - if(err) goto bail; + index = (theGroup->group_index)[j]; + if(index<=0x10000) + { + err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, index, position, 1); + if(err) goto bail; + } + else + { + MP4Handle descriptionPayload; + MP4SampleGroupDescriptionAtomPtr stblGroup; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + localIndex = index - 0x10000; + + err = ISONewHandle(1, &descriptionPayload); if (err) goto bail; + + /* 1. get handler from the local group description using localIndex */ + err = self->getGroupDescription(self, theGroup->grouping_type, localIndex, descriptionPayload); + + /* 2. find the same handler with the same type in stbl */ + minf = (MP4MediaInformationAtomPtr)mdia->information; + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + err = MP4FindGroupAtom(stbl->groupDescriptionList, theGroup->grouping_type, (MP4AtomPtr *)&stblGroup); + err = stblGroup->findGroupDescriptionIdx(stblGroup, descriptionPayload, &correctIndex); + + err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, correctIndex, position, 1); + // if(err) goto bail; + err = ISODisposeHandle(descriptionPayload); + } } } } diff --git a/IsoLib/playground/main.cpp b/IsoLib/playground/main.cpp index 0f09811..0cbed3e 100644 --- a/IsoLib/playground/main.cpp +++ b/IsoLib/playground/main.cpp @@ -161,20 +161,6 @@ ISOErr addGroupDescription(MP4Media media, u32 fcc, std::string strDescription, return err; } -ISOErr addGroupDescriptions(MP4Media media) -{ - ISOErr err = ISONoErr; - err = addGroupDescription(media, FOURCC_COLOR, "Red frames", groupIdRed); - if(err) return err; - err = addGroupDescription(media, FOURCC_COLOR, "Blue frames", groupIdBlue); - if(err) return err; - err = addGroupDescription(media, FOURCC_COLOR, "Green frames", groupIdGreen); - if(err) return err; - err = addGroupDescription(media, FOURCC_COLOR, "Yellow frames", groupIdYellow); - if(err) return err; - return err; -} - ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 repeatPattern = 1) { ISOErr err = ISONoErr; @@ -188,18 +174,8 @@ ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 repeatPatt std::cout << "fullPattern = " << fullPattern << std::endl; if(repeatPattern > 0) { - size_t nr = std::count(fullPattern.begin(), fullPattern.end(), 'r'); - size_t nb = std::count(fullPattern.begin(), fullPattern.end(), 'b'); - size_t ng = std::count(fullPattern.begin(), fullPattern.end(), 'g'); - size_t ny = std::count(fullPattern.begin(), fullPattern.end(), 'y'); - std::cout << "r = " << nr << std::endl; - std::cout << "b = " << nb << std::endl; - std::cout << "g = " << ng << std::endl; - std::cout << "y = " << ny << std::endl; - for(u32 n = 0; n < fullPattern.size(); ++n) { - std::cout << fullPattern[n] << " "; switch(fullPattern[n]) { case 'r': @@ -273,32 +249,31 @@ ISOErr createFile(std::string strFilename) err = ISOSetTrackFragmentDefaults(trak, TIMESCALE / FPS, sizeof(auBlue), 1, 0); - err = addGroupDescriptions(media); - if(err) return err; + // red and blue are in stbl + err = addGroupDescription(media, FOURCC_COLOR, "Red frames", groupIdRed); if(err) return err; + err = addGroupDescription(media, FOURCC_COLOR, "Blue frames", groupIdBlue); if(err) return err; + u32 temp = 0; - err = addGroupDescription(media, FOURCC_COLOR, "Yellow frames", temp); + err = addGroupDescription(media, FOURCC_COLOR, "Red frames", temp); if(err == MP4NoErr) - return -5; // this must fail because "Yellow frames" payload is already added with the same type + return -5; // this must fail because "Red frames" payload is already added with the same type // just add sample entry, call addSamples with sample count = 0 err = addSamples(media, "r", 0, sampleEntryH); if(err) return err; err = MP4EndMediaEdits(media); - std::cout << "fragment 1" << std::endl; - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); + std::cout << "\nfragment 1" << std::endl; err = ISOStartMovieFragment(moov); + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); if(err) return err; err = addSamples(media, "rb", 3); if(err) return err; - err = addGroupDescription(media, FOURCC_COLOR, "This must pass even if in stbl", temp); - if(err) return err; err = addGroupDescription(media, FOURCC_TEST, "This must pass", temp); if(err) return err; - err = addGroupDescription(media, FOURCC_COLOR, "Yellow frames", temp); - if(err) - return err; // this must pass even if the same type and payload is in stbl (but it shall not be - // in defragmented file) + err = addGroupDescription(media, FOURCC_COLOR, "Red frames", temp); + if(err) return err; // this must pass even if the same type and payload is in stbl + // (but it shall not be in defragmented file) err = addGroupDescription(media, FOURCC_TEST, "Test", temp); if(err) return err; err = addGroupDescription(media, FOURCC_TEST, "Test", temp); @@ -306,41 +281,40 @@ ISOErr createFile(std::string strFilename) err = mapSamplesToGroups(media, "rb", 3); if(err) return err; - std::cout << "fragment 2 (compressed sample group)" << std::endl; - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_COMPACT); + std::cout << "\nfragment 2 (compressed sample group)" << std::endl; err = ISOStartMovieFragment(moov); - if(err) return err; + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); + // local green and yellow groups + err = addGroupDescription(media, FOURCC_COLOR, "Green frames", groupIdGreen); if(err) return err; + err = addGroupDescription(media, FOURCC_COLOR, "Yellow frames", groupIdYellow); if(err) return err; err = addSamples(media, "gry", 2); if(err) return err; err = addGroupDescription(media, FOURCC_TEST, "Same as in previous fragment but different entry", - groupIdBlue); + temp); if(err) return err; - err = addGroupDescription(media, FOURCC_TEST, "This must pass", groupIdBlue); + err = addGroupDescription(media, FOURCC_TEST, "This must pass", temp); if(err) return err; err = mapSamplesToGroups(media, "gry", 2); if(err) return err; - std::cout << "fragment 3" << std::endl; - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); + std::cout << "\nfragment 3" << std::endl; err = ISOStartMovieFragment(moov); - if(err) return err; + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); + // local green and yellow groups + err = addGroupDescription(media, FOURCC_COLOR, "Green frames", groupIdGreen); if(err) return err; + err = addGroupDescription(media, FOURCC_COLOR, "Yellow frames", groupIdYellow); if(err) return err; err = addSamples(media, "bgy", 2); if(err) return err; err = mapSamplesToGroups(media, "bgy", 2); if(err) return err; - std::cout << "fragment 4" << std::endl; + std::cout << "\nfragment 4" << std::endl; err = ISOStartMovieFragment(moov); if(err) return err; - ISOSetSamplestoGroupType(media, - SAMPLE_GROUP_AUTO); // FIXME: no sampleToGroupBox in the last fragment - // ISOSetSamplestoGroupType(media, SAMPLE_GROUP_COMPACT); - err = addSamples(media, "wwwk", 1); - if(err) return err; - err = addGroupDescription(media, FOURCC_BLACK, "Single black frame", groupIdBlack); + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); + err = addSamples(media, "wk", 3); if(err) return err; - ISOMapSamplestoGroup(media, FOURCC_BLACK, groupIdBlack, 3, 1); - // err = mapSamplesToGroups(media, "wk", 3); if(err) return err; + err = MP4WriteMovieToFile(moov, strFilename.c_str()); return err; @@ -373,6 +347,8 @@ int main() err = ISOGetTrackMedia(trak, &media); u32 sampleCnt = 0; u32 *sampleNumbers; + groupIdGreen = 3; // TODO: get these IDs using the API + groupIdYellow = 4; err = ISOGetSampleGroupSampleNumbers(media, FOURCC_COLOR, groupIdRed, &sampleNumbers, &sampleCnt); From 760ebfcb3e529cb449f2e739116b2ce0809ac0f9 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Thu, 19 Nov 2020 17:18:23 +0100 Subject: [PATCH 32/55] cleanup --- IsoLib/libisomediafile/src/MP4Impl.h | 8 ++++- .../libisomediafile/src/TrackFragmentAtom.c | 34 ++++++++++++------- 2 files changed, 28 insertions(+), 14 deletions(-) diff --git a/IsoLib/libisomediafile/src/MP4Impl.h b/IsoLib/libisomediafile/src/MP4Impl.h index 8209041..dadcaba 100644 --- a/IsoLib/libisomediafile/src/MP4Impl.h +++ b/IsoLib/libisomediafile/src/MP4Impl.h @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4Impl.h,v 1.3 2002/10/01 12:49:19 julien Exp $ + $Id: MP4Impl.h,v 1.3 2002/10/01 12:49:19 julien Exp $ */ #ifndef INCLUDED_MP4IMPL_H #define INCLUDED_MP4IMPL_H @@ -48,6 +48,12 @@ derivative works. Copyright (c) 1999. goto bail; \ } +#define BAILWITHFREEHANDLE(v) \ + { \ + ISODisposeHandle(v); \ + goto bail; \ + } + #define TEST_ATOM_TYPE(atomName) \ if(self->type != atomName##Type) \ { \ diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index c694f7d..f74c1a6 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -622,36 +622,44 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) for(j = 0; j < theGroup->sampleCount; j++) { s32 position; - u32 index, localIndex, correctIndex; + u32 group_description_index; position = j - total_samples; - index = (theGroup->group_index)[j]; - if(index<=0x10000) + group_description_index = (theGroup->group_index)[j]; + if(group_description_index <= 0x10000) { - err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, index, position, 1); + /* mapping to global indexes */ + err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, group_description_index, position, 1); if(err) goto bail; } else { - MP4Handle descriptionPayload; + /* mapping local indexes to corrected global indexes */ + MP4Handle descriptionEntry; MP4SampleGroupDescriptionAtomPtr stblGroup; MP4MediaInformationAtomPtr minf; MP4SampleTableAtomPtr stbl; - localIndex = index - 0x10000; + u32 local_description_index, correct_description_index; - err = ISONewHandle(1, &descriptionPayload); if (err) goto bail; + local_description_index = group_description_index - 0x10000; + correct_description_index = 0; + + err = ISONewHandle(1, &descriptionEntry); if (err) goto bail; /* 1. get handler from the local group description using localIndex */ - err = self->getGroupDescription(self, theGroup->grouping_type, localIndex, descriptionPayload); + err = self->getGroupDescription(self, theGroup->grouping_type, local_description_index, descriptionEntry); + if(err) BAILWITHFREEHANDLE(descriptionEntry); /* 2. find the same handler with the same type in stbl */ minf = (MP4MediaInformationAtomPtr)mdia->information; stbl = (MP4SampleTableAtomPtr)minf->sampleTable; - err = MP4FindGroupAtom(stbl->groupDescriptionList, theGroup->grouping_type, (MP4AtomPtr *)&stblGroup); - err = stblGroup->findGroupDescriptionIdx(stblGroup, descriptionPayload, &correctIndex); + err = MP4FindGroupAtom(stbl->groupDescriptionList, theGroup->grouping_type, (MP4AtomPtr *)&stblGroup); + if(err) BAILWITHFREEHANDLE(descriptionEntry); + err = stblGroup->findGroupDescriptionIdx(stblGroup, descriptionEntry, &correct_description_index); + if(err) BAILWITHFREEHANDLE(descriptionEntry); - err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, correctIndex, position, 1); - // if(err) goto bail; - err = ISODisposeHandle(descriptionPayload); + err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, correct_description_index, position, 1); + ISODisposeHandle(descriptionEntry); + if(err) goto bail; } } } From 9eb5fcb4db1c9b0b31aac5dd08aa07f9a8a48493 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Thu, 19 Nov 2020 19:03:38 +0100 Subject: [PATCH 33/55] deal with remaining level 4 warnings --- .../linux/SimpleFileMappingObject.c | 2 +- .../macosx/SimpleFileMappingObject.c | 2 +- IsoLib/libisomediafile/src/MP4IPMPXData.c | 2 +- IsoLib/libisomediafile/src/MP4Media.c | 2 +- IsoLib/libisomediafile/src/MP4MovieFile.c | 4 +- IsoLib/libisomediafile/src/MP4Movies.c | 19 +----- .../libisomediafile/src/MP4ObjectDescriptor.c | 19 +++++- .../src/MP4OrdinaryTrackReader.c | 10 ++- IsoLib/libisomediafile/src/MP4SLPacket.c | 62 ++++++++++++++++--- IsoLib/libisomediafile/src/PCMConfigAtom.c | 4 +- IsoLib/libisomediafile/src/PaddingBitsAtom.c | 1 + .../src/RestrictedVideoSampleEntry.c | 2 +- IsoLib/libisomediafile/src/SampleSizeAtom.c | 10 +-- IsoLib/libisomediafile/src/StereoVideoAtom.c | 6 +- .../libisomediafile/src/TextMetaSampleEntry.c | 2 +- IsoLib/libisomediafile/src/TimeToSampleAtom.c | 1 + .../libisomediafile/src/TrackFragmentAtom.c | 20 +++--- .../libisomediafile/src/XMLMetaSampleEntry.c | 2 +- .../w32/W32FileMappingObject.c | 4 +- 19 files changed, 106 insertions(+), 68 deletions(-) diff --git a/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c b/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c index d1aa904..50d110a 100644 --- a/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c +++ b/IsoLib/libisomediafile/linux/SimpleFileMappingObject.c @@ -75,7 +75,7 @@ static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *pathname) BAILWITHERROR(MP4IOErr); } /* make parent */ - if((separator = strrchr(pathname, '\\')) || (separator = strrchr(pathname, '/'))) + if((separator = strrchr(pathname, '\\')) != 0 || (separator = strrchr(pathname, '/')) != 0) { int len = separator - pathname; self->parent = (char *)calloc(1, len + 2); diff --git a/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c b/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c index 5a760fc..e4cd0a9 100644 --- a/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c +++ b/IsoLib/libisomediafile/macosx/SimpleFileMappingObject.c @@ -102,7 +102,7 @@ static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *pathname) } #endif /* make parent */ - if((separator = strrchr(pathname, '\\')) || (separator = strrchr(pathname, '/'))) + if((separator = strrchr(pathname, '\\')) != 0 || (separator = strrchr(pathname, '/')) != 0) { int len = separator - pathname; self->parent = (char *)calloc(1, len + 2); diff --git a/IsoLib/libisomediafile/src/MP4IPMPXData.c b/IsoLib/libisomediafile/src/MP4IPMPXData.c index ddb6e1b..415375a 100644 --- a/IsoLib/libisomediafile/src/MP4IPMPXData.c +++ b/IsoLib/libisomediafile/src/MP4IPMPXData.c @@ -70,7 +70,7 @@ MP4Err MP4ParseIPMPXData(MP4InputStreamPtr inputStream, MP4IPMPXDataPtr *outData /* read the version */ err = inputStream->read8(inputStream, &version, NULL); if(err) goto bail; - data->version = version; + data->version = (u8)version; data->bytesRead++; if(data->version != 0x01) /* only version 1 is currently supported */ BAILWITHERROR(MP4BadDataErr) diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index 0a1e12c..2c86eba 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -2344,7 +2344,7 @@ MP4GetSampleAuxiliaryInformation(MP4Media theMedia, u32 *outCount, err = MP4GetListEntry(stbl->SampleAuxiliaryInformationSizes, i, (char **)&saiz); if(err) goto bail; - flags[i] = saiz->flags; + flags[i] = (u8)saiz->flags; types[i] = saiz->aux_info_type; parameters[i] = saiz->aux_info_type_parameter; } diff --git a/IsoLib/libisomediafile/src/MP4MovieFile.c b/IsoLib/libisomediafile/src/MP4MovieFile.c index edb7e7c..8062dc7 100644 --- a/IsoLib/libisomediafile/src/MP4MovieFile.c +++ b/IsoLib/libisomediafile/src/MP4MovieFile.c @@ -28,10 +28,10 @@ derivative works. Copyright (c) 1999. #include "MJ2Atoms.h" #include +MP4Err MP4MovieCreateDescriptors(MP4Movie theMovie); + static MP4Err LocalPutMovieIntoHandle(MP4Movie theMovie, MP4Handle movieH, u32 include_mdat) { - MP4Err MP4MovieCreateDescriptors(MP4Movie theMovie); - MP4Err err; MP4PrivateMovieRecordPtr movie; MP4MovieAtomPtr moov; diff --git a/IsoLib/libisomediafile/src/MP4Movies.c b/IsoLib/libisomediafile/src/MP4Movies.c index e1d1ba2..0ac52b7 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.c +++ b/IsoLib/libisomediafile/src/MP4Movies.c @@ -48,12 +48,13 @@ MP4Err MP4MovieCreateDescriptors(MP4Movie theMovie); MP4Err MP4MovieAddTrackES_IDToIOD(MP4Movie theMovie, MP4Track theTrack); MP4Err MP4GetMovieObjectDescriptorUsingSLConfig(MP4Movie theMovie, MP4SLConfig slconfig, MP4Handle outDescriptorH); +MP4Err MP4GetMediaSampleDescIndex(MP4Media theMedia, u64 desiredTime, u32 * outSampleDescriptionIndex); +MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr * outESD, u32 * outDataReferenceIndex); MP4_EXTERN(MP4Err) MergeMovieFragments(MP4PrivateMovieRecordPtr movie); MP4_EXTERN(MP4Err) MergeMovieData(MP4PrivateMovieRecordPtr movie); -MP4_EXTERN(MP4Err) -MP4DisposeMovie(MP4Movie theMovie) +MP4_EXTERN(MP4Err) MP4DisposeMovie(MP4Movie theMovie) { GETMOOV(theMovie); @@ -480,13 +481,6 @@ MP4_EXTERN(MP4Err) MP4AddAtomToMovie(MP4Movie theMovie, MP4GenericAtom the_atom) MP4Err makeESD(MP4Movie theMovie, u32 trackNumber, u64 cts, MP4SLConfig inSLConfig, MP4DescriptorPtr *outDesc) { - MP4Err MP4GetMediaSampleDescIndex(MP4Media theMedia, u64 desiredTime, - u32 * outSampleDescriptionIndex); - MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr * outESD, - u32 * outDataReferenceIndex); - MP4Err MP4CreateSLConfigDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); - MP4Err MP4CreateES_Descriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); - MP4Err err; MP4ES_DescriptorPtr esd; MP4ES_DescriptorPtr esdInFile; @@ -710,11 +704,8 @@ MP4_EXTERN(MP4Err) MP4GetMovieInitialObjectDescriptorUsingSLConfig(MP4Movie theMovie, MP4SLConfig slconfig, MP4Handle outDescriptorH) { - MP4Err MP4CreateSLConfigDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr * outESD, u32 * outDataReferenceIndex); - MP4Err MP4GetMovieObjectDescriptorUsingSLConfig(MP4Movie theMovie, MP4SLConfig slconfig, - MP4Handle outDescriptorH); MP4InitialObjectDescriptorPtr iodDesc; MP4LinkedList incDescriptors; @@ -1408,10 +1399,6 @@ MP4NewMovieExt(MP4Movie *outMovie, u32 initialODID, u8 OD_profileAndLevel, u8 sc MP4Err MP4GetMovieObjectDescriptorUsingSLConfig(MP4Movie theMovie, MP4SLConfig slconfig, MP4Handle outDescriptorH) { - MP4Err MP4CreateSLConfigDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); - MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr * outESD, - u32 * outDataReferenceIndex); - MP4ObjectDescriptorPtr odDesc; MP4LinkedList incDescriptors; GETIODATOM(theMovie); diff --git a/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c b/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c index aa7c18a..0f330fc 100644 --- a/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4ObjectDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4ObjectDescriptor.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Descriptors.h" #include "MP4Movies.h" @@ -99,7 +99,7 @@ static MP4Err serialize(struct MP4DescriptorRecord *s, char *buffer) if(err) goto bail; buffer += DESCRIPTOR_TAG_LEN_SIZE; - val = self->objectDescriptorID << 6; + val = (u16)(self->objectDescriptorID << 6); if(self->URLStringLength) val |= (1 << 5); val |= 0x1f; PUT16_V(val); @@ -218,7 +218,20 @@ static MP4Err removeESDS(struct MP4DescriptorRecord *s) MP4Err err; MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr)s; err = MP4NoErr; - DESTROY_DESCRIPTOR_LIST(ESDescriptors); + if(self->ESDescriptors) + { + u32 listSize; + u32 i; + err = MP4GetListEntryCount(self->ESDescriptors, &listSize); + if(err) goto bail; + for(i = 0; i < listSize; i++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(self->ESDescriptors, i, (char **)&a); if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(self->ESDescriptors); if(err) goto bail; + } err = MP4MakeLinkedList(&self->ESDescriptors); if(err) goto bail; bail: diff --git a/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c b/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c index a349c96..c22119d 100644 --- a/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c +++ b/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4OrdinaryTrackReader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: MP4OrdinaryTrackReader.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Movies.h" #include "MP4TrackReader.h" @@ -30,6 +30,9 @@ derivative works. Copyright (c) 1999. #include #include +MP4Err MP4GetTrackReferenceType(MP4Track track, u32 atomType, MP4TrackReferenceTypeAtomPtr * outAtom); +MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackReferenceTypeAtomPtr mpod, MP4SLConfig slconfig); + static void put32(u32 val, char *buf) { buf[3] = val & 0xFF; @@ -133,11 +136,6 @@ static MP4Err getNextAccessUnit(struct MP4TrackReaderStruct *self, MP4Handle out if(self->isODTrack) { - MP4Err MP4GetTrackReferenceType(MP4Track track, u32 atomType, - MP4TrackReferenceTypeAtomPtr * outAtom); - MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, - MP4TrackReferenceTypeAtomPtr mpod, MP4SLConfig slconfig); - MP4TrackReferenceTypeAtomPtr mpod; err = MP4GetTrackReferenceType(self->track, MP4ODTrackReferenceAtomType, &mpod); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/MP4SLPacket.c b/IsoLib/libisomediafile/src/MP4SLPacket.c index 75ab5e3..1cd9663 100644 --- a/IsoLib/libisomediafile/src/MP4SLPacket.c +++ b/IsoLib/libisomediafile/src/MP4SLPacket.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: MP4SLPacket.c,v 1.2 2002/10/01 12:49:19 julien Exp $ + $Id: MP4SLPacket.c,v 1.2 2002/10/01 12:49:19 julien Exp $ */ #include "MP4Movies.h" #include "MP4Atoms.h" @@ -32,16 +32,13 @@ derivative works. Copyright (c) 1999. MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackReferenceTypeAtomPtr mpod, MP4SLConfig slconfig); - MP4Err rewriteIPMPDescriptorPointers(MP4DescriptorPtr desc, MP4TrackReferenceTypeAtomPtr mpod); +MP4Err makeESD(MP4Movie theMovie, u32 trackNumber, u64 cts, MP4SLConfig slconfig, + MP4DescriptorPtr *outDesc); MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackReferenceTypeAtomPtr mpod, MP4SLConfig slconfig) { - MP4Err makeESD(MP4Movie theMovie, u32 trackNumber, u64 cts, MP4SLConfig slconfig, - MP4DescriptorPtr * outDesc); - MP4Err MP4ParseCommand(MP4InputStreamPtr inputStream, MP4DescriptorPtr * outDesc); - MP4Err err; u32 unitSize; MP4InputStreamPtr is; @@ -113,7 +110,22 @@ MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackRefere if(err) goto bail; } /* --awm to avoid putting the ES_ID_Ref descriptors in the output */ - DESTROY_DESCRIPTOR_LIST_V(od->ES_ID_RefDescriptors); + if(od->ES_ID_RefDescriptors) + { + u32 listSize; + u32 i1; + err = MP4GetListEntryCount(od->ES_ID_RefDescriptors, &listSize); + if(err) goto bail; + for(i1 = 0; i1 < listSize; i1++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(od->ES_ID_RefDescriptors, i1, (char **)&a); + if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(od->ES_ID_RefDescriptors); + if(err) goto bail; + } od->ES_ID_RefDescriptors = NULL; } break; @@ -140,7 +152,22 @@ MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackRefere if(err) goto bail; } /* --awm to avoid putting the ES_ID_Ref descriptors in the output */ - DESTROY_DESCRIPTOR_LIST_V(esUpdate->ES_ID_RefDescriptors); + if(esUpdate->ES_ID_RefDescriptors) + { + u32 listSize; + u32 i2; + err = MP4GetListEntryCount(esUpdate->ES_ID_RefDescriptors, &listSize); + if(err) goto bail; + for(i2 = 0; i2 < listSize; i2++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(esUpdate->ES_ID_RefDescriptors, i2, (char **)&a); + if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(esUpdate->ES_ID_RefDescriptors); + if(err) goto bail; + } esUpdate->ES_ID_RefDescriptors = NULL; break; @@ -170,7 +197,22 @@ MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackRefere /* MP4DeleteLinkedList( descList ); */ /* Just deleting the list still leaves the allocated descriptors hanging around -- dws */ - DESTROY_DESCRIPTOR_LIST_V(descList); + if(descList) + { + u32 listSize; + u32 i3; + err = MP4GetListEntryCount(descList, &listSize); + if(err) goto bail; + for(i3 = 0; i3 < listSize; i3++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(descList, i3, (char **)&a); + if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(descList); + if(err) goto bail; + } bail: if(is) { @@ -319,7 +361,7 @@ MP4Err rewriteIPMPDescriptorPointers(MP4DescriptorPtr desc, MP4TrackReferenceTyp if((ipmpDescPtr->ipmpEsId != 0) && (ipmpDescPtr->ipmpEsId != 0xFFFF)) { /* rewrite the good ID */ - ipmpDescPtr->ipmpEsId = mpod->trackIDs[ipmpDescPtr->ipmpEsId - 1]; + ipmpDescPtr->ipmpEsId = (u16)mpod->trackIDs[ipmpDescPtr->ipmpEsId - 1]; } } diff --git a/IsoLib/libisomediafile/src/PCMConfigAtom.c b/IsoLib/libisomediafile/src/PCMConfigAtom.c index 69cf5e9..57da78a 100644 --- a/IsoLib/libisomediafile/src/PCMConfigAtom.c +++ b/IsoLib/libisomediafile/src/PCMConfigAtom.c @@ -84,9 +84,9 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre if(err) goto bail; GET8_V(tmp8); - self->format_flags = tmp8; + self->format_flags = (u8)tmp8; GET8_V(tmp8); - self->PCM_sample_size = tmp8; + self->PCM_sample_size = (u8)tmp8; assert(self->bytesRead == self->size); bail: diff --git a/IsoLib/libisomediafile/src/PaddingBitsAtom.c b/IsoLib/libisomediafile/src/PaddingBitsAtom.c index 427fb49..8528dc1 100644 --- a/IsoLib/libisomediafile/src/PaddingBitsAtom.c +++ b/IsoLib/libisomediafile/src/PaddingBitsAtom.c @@ -55,6 +55,7 @@ static MP4Err addSamplePads(struct MP4PaddingBitsAtom *self, u32 sampleCount, MP dodefault = 1; defaultpad = 0; + padsCount = 0; PaddingBits = NULL; if(padsH != NULL) diff --git a/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c b/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c index 5a31e05..99d3325 100644 --- a/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c +++ b/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c @@ -332,8 +332,8 @@ static MP4Err getSchemeInfoAtom(struct MP4Atom *s, u32 theType, struct MP4Atom * if(desc && (desc->type == theType)) { *theAtom = desc; - break; err = MP4NoErr; + break; } } } diff --git a/IsoLib/libisomediafile/src/SampleSizeAtom.c b/IsoLib/libisomediafile/src/SampleSizeAtom.c index 23a4050..a6a770d 100644 --- a/IsoLib/libisomediafile/src/SampleSizeAtom.c +++ b/IsoLib/libisomediafile/src/SampleSizeAtom.c @@ -73,14 +73,14 @@ static MP4Err addSamples(struct MP4SampleSizeAtom *self, u32 sampleCount, MP4Han if((self->sizes == NULL) && self->sampleCount) { - u32 i; + u32 i1; self->allocatedSize = newsize; if(self->allocatedSize < allocation_size) self->allocatedSize = allocation_size; self->sizes = (u32 *)calloc(self->allocatedSize, 1); TESTMALLOC(self->sizes); - for(i = 0; i < self->sampleCount; i++) - self->sizes[i] = self->sampleSize; + for(i1 = 0; i1 < self->sampleCount; i1++) + self->sizes[i1] = self->sampleSize; } if(self->allocatedSize < newsize) @@ -95,10 +95,10 @@ static MP4Err addSamples(struct MP4SampleSizeAtom *self, u32 sampleCount, MP4Han memcpy(self->sizes + self->sampleCount, sampleSizes, sizesCount * sizeof(u32)); else { - u32 i; + u32 i2; u32 *p; p = self->sizes + self->sampleCount; - for(i = 0; i < sampleCount; i++) + for(i2 = 0; i2 < sampleCount; i2++) *p++ = *sampleSizes; } self->sampleSize = 0; diff --git a/IsoLib/libisomediafile/src/StereoVideoAtom.c b/IsoLib/libisomediafile/src/StereoVideoAtom.c index ceec212..a51fde8 100644 --- a/IsoLib/libisomediafile/src/StereoVideoAtom.c +++ b/IsoLib/libisomediafile/src/StereoVideoAtom.c @@ -72,7 +72,7 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) MP4Err err; u32 tmp32; u8 tmp8; - u32 i; + u32 n; MP4StereoVideoAtomPtr self = (MP4StereoVideoAtomPtr)s; err = MP4NoErr; @@ -88,9 +88,9 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) PUT32(stereo_scheme); PUT32(length); - for(i = 0; i < self->length; i++) + for(n = 0; n < self->length; n++) { - tmp8 = self->stereo_indication_type[i]; + tmp8 = self->stereo_indication_type[n]; PUT8_V(tmp8); } diff --git a/IsoLib/libisomediafile/src/TextMetaSampleEntry.c b/IsoLib/libisomediafile/src/TextMetaSampleEntry.c index 7c95af5..e0be906 100644 --- a/IsoLib/libisomediafile/src/TextMetaSampleEntry.c +++ b/IsoLib/libisomediafile/src/TextMetaSampleEntry.c @@ -134,7 +134,7 @@ static MP4Err readstring(char **b, MP4TextMetaSampleEntryAtomPtr self, for(;;) { GET8_V_MSG(byte, NULL); - *p++ = byte; + *p++ = (char)byte; if(byte == 0) break; } diff --git a/IsoLib/libisomediafile/src/TimeToSampleAtom.c b/IsoLib/libisomediafile/src/TimeToSampleAtom.c index 3965d45..0614f27 100644 --- a/IsoLib/libisomediafile/src/TimeToSampleAtom.c +++ b/IsoLib/libisomediafile/src/TimeToSampleAtom.c @@ -182,6 +182,7 @@ static MP4Err getTimeForSampleNumber(MP4AtomPtr s, u32 sampleNumber, u64 *outSam MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr)s; if(self == NULL) BAILWITHERROR(MP4BadParamErr) err = MP4NoErr; + pe = NULL; err = MP4GetListEntryCount(self->entryList, &entryCount); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index f74c1a6..fbe1d2d 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: TrackFragmentAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: TrackFragmentAtom.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "MP4Atoms.h" @@ -386,7 +386,7 @@ static MP4Err calculateSize(struct MP4Atom *s) MP4TrackFragmentHeaderAtomPtr tfhd; u32 tfhd_flags; - u32 i; + u32 n; u32 atomListSize; err = MP4NoErr; @@ -410,9 +410,9 @@ static MP4Err calculateSize(struct MP4Atom *s) MP4TrackRunAtomPtr a; /* first, calculate what defaults are suitable in this track fragment header */ - for(i = 0; i < atomListSize; i++) + for(n = 0; n < atomListSize; n++) { - err = MP4GetListEntry(self->atomList, i, (char **)&a); + err = MP4GetListEntry(self->atomList, n, (char **)&a); if(err) goto bail; if(a) a->calculateDefaults(a, tfhd, 2); /* first iteration gets the second flag value as the first can be special-cased */ @@ -421,9 +421,9 @@ static MP4Err calculateSize(struct MP4Atom *s) /* then come back round and pick up the flags if not already set from second position */ if(tfhd->default_sample_flags == 0) { - for(i = 0; i < atomListSize; i++) + for(n = 0; n < atomListSize; n++) { - err = MP4GetListEntry(self->atomList, i, (char **)&a); + err = MP4GetListEntry(self->atomList, n, (char **)&a); if(err) goto bail; if(a) a->calculateDefaults(a, tfhd, 1); /* pick up flags from the first position */ @@ -441,9 +441,9 @@ static MP4Err calculateSize(struct MP4Atom *s) tfhd_flags |= tfhd_default_sample_flags_present; /* finally, tell each run to set its flags based on what we calculated */ - for(i = 0; i < atomListSize; i++) + for(n = 0; n < atomListSize; n++) { - err = MP4GetListEntry(self->atomList, i, (char **)&a); + err = MP4GetListEntry(self->atomList, n, (char **)&a); if(err) goto bail; if(a) a->setFlags(a, tfhd); } @@ -636,8 +636,6 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) /* mapping local indexes to corrected global indexes */ MP4Handle descriptionEntry; MP4SampleGroupDescriptionAtomPtr stblGroup; - MP4MediaInformationAtomPtr minf; - MP4SampleTableAtomPtr stbl; u32 local_description_index, correct_description_index; local_description_index = group_description_index - 0x10000; @@ -650,8 +648,6 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) if(err) BAILWITHFREEHANDLE(descriptionEntry); /* 2. find the same handler with the same type in stbl */ - minf = (MP4MediaInformationAtomPtr)mdia->information; - stbl = (MP4SampleTableAtomPtr)minf->sampleTable; err = MP4FindGroupAtom(stbl->groupDescriptionList, theGroup->grouping_type, (MP4AtomPtr *)&stblGroup); if(err) BAILWITHFREEHANDLE(descriptionEntry); err = stblGroup->findGroupDescriptionIdx(stblGroup, descriptionEntry, &correct_description_index); diff --git a/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c b/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c index 34278ab..64ffc2a 100644 --- a/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c +++ b/IsoLib/libisomediafile/src/XMLMetaSampleEntry.c @@ -149,7 +149,7 @@ static MP4Err readstring(char **b, MP4XMLMetaSampleEntryAtomPtr self, MP4InputSt for(;;) { GET8_V_MSG(byte, NULL); - *p++ = byte; + *p++ = (char)byte; if(byte == 0) break; } diff --git a/IsoLib/libisomediafile/w32/W32FileMappingObject.c b/IsoLib/libisomediafile/w32/W32FileMappingObject.c index 2ec140c..52a894f 100644 --- a/IsoLib/libisomediafile/w32/W32FileMappingObject.c +++ b/IsoLib/libisomediafile/w32/W32FileMappingObject.c @@ -21,7 +21,7 @@ This copyright notice must be included in all copies or derivative works. Copyright (c) 1999. */ /* - $Id: W32FileMappingObject.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ + $Id: W32FileMappingObject.c,v 1.1.1.1 2002/09/20 08:53:35 julien Exp $ */ #include "W32FileMappingObject.h" #include @@ -80,7 +80,7 @@ static MP4Err doOpen(struct FileMappingObjectRecord *s, const char *filename) CloseHandle(fileHandle); CloseHandle(fileMappingHandle); /* make parent */ - if((separator = strrchr(filename, '\\')) || (separator = strrchr(filename, '/'))) + if((separator = strrchr(filename, '\\')) != 0 || (separator = strrchr(filename, '/')) != 0) { int len = (int)(separator - filename); if(self->parent) From 7a1e8cef5c07856d350ad8678027e40592646b7e Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Thu, 19 Nov 2020 19:23:05 +0100 Subject: [PATCH 34/55] clang-format modified files --- .../src/DegradationPriorityAtom.c | 2 +- .../src/EncAudioSampleEntryAtom.c | 4 +- IsoLib/libisomediafile/src/ISMASecurity.c | 4 +- IsoLib/libisomediafile/src/ISOMeta.c | 8 +- .../src/ISOSampleDescriptions.c | 8 +- IsoLib/libisomediafile/src/MP4Atoms.c | 2 +- IsoLib/libisomediafile/src/MP4Impl.h | 8 +- .../src/MP4InitialObjectDescriptor.c | 25 +++--- IsoLib/libisomediafile/src/MP4Media.c | 3 +- IsoLib/libisomediafile/src/MP4Movies.c | 6 +- .../libisomediafile/src/MP4ObjectDescriptor.c | 26 +++--- .../src/MP4OrdinaryTrackReader.c | 6 +- IsoLib/libisomediafile/src/MediaAtom.c | 82 ++++++++++--------- IsoLib/libisomediafile/src/MovieExtendsAtom.c | 2 +- .../libisomediafile/src/MovieFragmentAtom.c | 4 +- IsoLib/libisomediafile/src/MovieTracks.c | 13 ++- .../src/RestrictedVideoSampleEntry.c | 2 +- IsoLib/libisomediafile/src/TimeToSampleAtom.c | 2 +- .../libisomediafile/src/TrackFragmentAtom.c | 24 ++++-- 19 files changed, 123 insertions(+), 108 deletions(-) diff --git a/IsoLib/libisomediafile/src/DegradationPriorityAtom.c b/IsoLib/libisomediafile/src/DegradationPriorityAtom.c index 6bbaccc..15c1e34 100644 --- a/IsoLib/libisomediafile/src/DegradationPriorityAtom.c +++ b/IsoLib/libisomediafile/src/DegradationPriorityAtom.c @@ -1,4 +1,4 @@ - /* +/* This software module was originally developed by Apple Computer, Inc. in the course of development of MPEG-4. This software module is an implementation of a part of one or diff --git a/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c b/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c index 9e661a7..8de1787 100644 --- a/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c +++ b/IsoLib/libisomediafile/src/EncAudioSampleEntryAtom.c @@ -158,7 +158,7 @@ static MP4Err transform(struct MP4Atom *s, u32 sch_type, u32 sch_version, char * MP4SecurityInfoAtomPtr sinf; MP4SchemeTypeAtomPtr schm = NULL; MP4SchemeInfoAtomPtr schi = NULL; - char *sch_url_copy = NULL; + char *sch_url_copy = NULL; err = MP4CreateOriginalFormatAtom(&fmt); if(err) goto bail; @@ -313,7 +313,7 @@ static MP4Err getSchemeInfoAtom(struct MP4Atom *s, u32 theType, struct MP4Atom * if(desc && (desc->type == theType)) { *theAtom = desc; - err = MP4NoErr; + err = MP4NoErr; break; } } diff --git a/IsoLib/libisomediafile/src/ISMASecurity.c b/IsoLib/libisomediafile/src/ISMASecurity.c index bd8ebbf..fc18b12 100644 --- a/IsoLib/libisomediafile/src/ISMASecurity.c +++ b/IsoLib/libisomediafile/src/ISMASecurity.c @@ -172,9 +172,9 @@ ISMAUnTransformSampleEntrySalt(MP4Handle insampleEntryH, u8 *selective_encryptio char *kms_url_copy; u32 sch_type, sch_version; - err = MP4NoErr; + err = MP4NoErr; entry = NULL; - is = NULL; + is = NULL; err = MP4GetHandleSize(insampleEntryH, &size); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/ISOMeta.c b/IsoLib/libisomediafile/src/ISOMeta.c index 1021f43..a441c1b 100644 --- a/IsoLib/libisomediafile/src/ISOMeta.c +++ b/IsoLib/libisomediafile/src/ISOMeta.c @@ -1558,8 +1558,8 @@ ISO_EXTERN(ISOErr) ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_of else if(myItem->construction_method == 2) { u64 k; - err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), (u16)b->extent_index, - &referenceItem); + err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), + (u16)b->extent_index, &referenceItem); if(err) goto bail; err = MP4NewHandle(0, &referenceItemData); if(err) goto bail; @@ -1595,8 +1595,8 @@ ISO_EXTERN(ISOErr) ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_of u64 k; u32 referenceDataLength; - err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), (u16)b->extent_index, - &referenceItem); + err = ISOGetItemReference(item, MP4_FOUR_CHAR_CODE('i', 'l', 'o', 'c'), + (u16)b->extent_index, &referenceItem); if(err) goto bail; err = MP4NewHandle(0, &referenceItemData); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c index a5e8e39..dbaf239 100644 --- a/IsoLib/libisomediafile/src/ISOSampleDescriptions.c +++ b/IsoLib/libisomediafile/src/ISOSampleDescriptions.c @@ -150,7 +150,7 @@ MP4NewSampleDescriptionWithOCRAssociation(MP4Track theTrack, MP4Handle sampleDes MP4TrackAtomPtr trak; u32 outReferenceIndex; - entry = NULL; + entry = NULL; esdAtom = NULL; if((theTrack == NULL) || (sampleDescriptionH == NULL)) @@ -440,7 +440,7 @@ ISONewGeneralSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, MP4Err err; GenericSampleEntryAtomPtr entry = NULL; - MP4TrackAtomPtr trak = NULL; + MP4TrackAtomPtr trak = NULL; if((theTrack == NULL) || (sampleDescriptionH == NULL)) { @@ -668,9 +668,9 @@ ISONewH263SampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, u32 u32 vendor, u8 decoder_version, u8 H263_level, u8 H263_profile) { MP4Err err; - GenericSampleEntryAtomPtr entry = NULL; + GenericSampleEntryAtomPtr entry = NULL; MP4H263SpecificInfoAtomPtr H263SpecificInfoAtom = NULL; - MP4TrackAtomPtr trak = NULL; + MP4TrackAtomPtr trak = NULL; if((theTrack == NULL) || (sampleDescriptionH == NULL)) { diff --git a/IsoLib/libisomediafile/src/MP4Atoms.c b/IsoLib/libisomediafile/src/MP4Atoms.c index 0c41fb0..e3d8c83 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.c +++ b/IsoLib/libisomediafile/src/MP4Atoms.c @@ -62,7 +62,7 @@ static MP4Err baseAtomCreateFromInputStream(MP4AtomPtr self, MP4AtomPtr proto, MP4InputStreamPtr inputStream) { (void)inputStream; - self->type = proto->type; + self->type = proto->type; memcpy(self->uuid, proto->uuid, 16); self->size = proto->size; self->size64 = proto->size64; diff --git a/IsoLib/libisomediafile/src/MP4Impl.h b/IsoLib/libisomediafile/src/MP4Impl.h index dadcaba..87f9849 100644 --- a/IsoLib/libisomediafile/src/MP4Impl.h +++ b/IsoLib/libisomediafile/src/MP4Impl.h @@ -48,10 +48,10 @@ derivative works. Copyright (c) 1999. goto bail; \ } -#define BAILWITHFREEHANDLE(v) \ - { \ - ISODisposeHandle(v); \ - goto bail; \ +#define BAILWITHFREEHANDLE(v) \ + { \ + ISODisposeHandle(v); \ + goto bail; \ } #define TEST_ATOM_TYPE(atomName) \ diff --git a/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c b/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c index fa63ccf..e19e872 100644 --- a/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4InitialObjectDescriptor.c @@ -228,17 +228,20 @@ static MP4Err removeESDS(struct MP4DescriptorRecord *s) MP4Err err; MP4InitialObjectDescriptorPtr self = (MP4InitialObjectDescriptorPtr)s; err = MP4NoErr; - if(self->ESDescriptors) - { - u32 listSize, i; - err = MP4GetListEntryCount(self->ESDescriptors, &listSize); if(err) goto bail; - for(i = 0; i < listSize; i++) - { - MP4DescriptorPtr a; - err = MP4GetListEntry(self->ESDescriptors, i, (char **)&a); if(err) goto bail; - if(a) a->destroy(a); - } - err = MP4DeleteLinkedList(self->ESDescriptors); if(err) goto bail; + if(self->ESDescriptors) + { + u32 listSize, i; + err = MP4GetListEntryCount(self->ESDescriptors, &listSize); + if(err) goto bail; + for(i = 0; i < listSize; i++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(self->ESDescriptors, i, (char **)&a); + if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(self->ESDescriptors); + if(err) goto bail; } err = MP4MakeLinkedList(&self->ESDescriptors); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index 2c86eba..4a0e8ec 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -175,8 +175,6 @@ ISOAddGroupDescription(MP4Media media, u32 groupType, MP4Handle description, u32 mdia = (MP4MediaAtomPtr)media; err = mdia->addGroupDescription(mdia, groupType, description, index); - if(!err) printf("Add group description: index = %u\n", *index); - bail: TEST_RETURN(err); @@ -2233,6 +2231,7 @@ MP4AddSampleAuxiliaryInformation(MP4Media theMedia, u8 isUsingAuxInfoPropertiesF stbl = NULL; traf = NULL; saiz = NULL; + saio = NULL; if(sampleCount == 0) goto bail; diff --git a/IsoLib/libisomediafile/src/MP4Movies.c b/IsoLib/libisomediafile/src/MP4Movies.c index 0ac52b7..67d9a21 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.c +++ b/IsoLib/libisomediafile/src/MP4Movies.c @@ -48,8 +48,10 @@ MP4Err MP4MovieCreateDescriptors(MP4Movie theMovie); MP4Err MP4MovieAddTrackES_IDToIOD(MP4Movie theMovie, MP4Track theTrack); MP4Err MP4GetMovieObjectDescriptorUsingSLConfig(MP4Movie theMovie, MP4SLConfig slconfig, MP4Handle outDescriptorH); -MP4Err MP4GetMediaSampleDescIndex(MP4Media theMedia, u64 desiredTime, u32 * outSampleDescriptionIndex); -MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr * outESD, u32 * outDataReferenceIndex); +MP4Err MP4GetMediaSampleDescIndex(MP4Media theMedia, u64 desiredTime, + u32 *outSampleDescriptionIndex); +MP4Err MP4GetMediaESD(MP4Media theMedia, u32 index, MP4ES_DescriptorPtr *outESD, + u32 *outDataReferenceIndex); MP4_EXTERN(MP4Err) MergeMovieFragments(MP4PrivateMovieRecordPtr movie); MP4_EXTERN(MP4Err) MergeMovieData(MP4PrivateMovieRecordPtr movie); diff --git a/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c b/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c index 0f330fc..95ff5b3 100644 --- a/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c +++ b/IsoLib/libisomediafile/src/MP4ObjectDescriptor.c @@ -218,19 +218,21 @@ static MP4Err removeESDS(struct MP4DescriptorRecord *s) MP4Err err; MP4ObjectDescriptorPtr self = (MP4ObjectDescriptorPtr)s; err = MP4NoErr; - if(self->ESDescriptors) - { - u32 listSize; - u32 i; - err = MP4GetListEntryCount(self->ESDescriptors, &listSize); - if(err) goto bail; - for(i = 0; i < listSize; i++) - { - MP4DescriptorPtr a; - err = MP4GetListEntry(self->ESDescriptors, i, (char **)&a); if(err) goto bail; + if(self->ESDescriptors) + { + u32 listSize; + u32 i; + err = MP4GetListEntryCount(self->ESDescriptors, &listSize); + if(err) goto bail; + for(i = 0; i < listSize; i++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(self->ESDescriptors, i, (char **)&a); + if(err) goto bail; if(a) a->destroy(a); - } - err = MP4DeleteLinkedList(self->ESDescriptors); if(err) goto bail; + } + err = MP4DeleteLinkedList(self->ESDescriptors); + if(err) goto bail; } err = MP4MakeLinkedList(&self->ESDescriptors); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c b/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c index c22119d..32c6d24 100644 --- a/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c +++ b/IsoLib/libisomediafile/src/MP4OrdinaryTrackReader.c @@ -30,8 +30,10 @@ derivative works. Copyright (c) 1999. #include #include -MP4Err MP4GetTrackReferenceType(MP4Track track, u32 atomType, MP4TrackReferenceTypeAtomPtr * outAtom); -MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackReferenceTypeAtomPtr mpod, MP4SLConfig slconfig); +MP4Err MP4GetTrackReferenceType(MP4Track track, u32 atomType, + MP4TrackReferenceTypeAtomPtr *outAtom); +MP4Err rewriteODFrame(MP4Track track, MP4Handle sampleH, u64 cts, MP4TrackReferenceTypeAtomPtr mpod, + MP4SLConfig slconfig); static void put32(u32 val, char *buf) { diff --git a/IsoLib/libisomediafile/src/MediaAtom.c b/IsoLib/libisomediafile/src/MediaAtom.c index 914a561..5b52bfc 100644 --- a/IsoLib/libisomediafile/src/MediaAtom.c +++ b/IsoLib/libisomediafile/src/MediaAtom.c @@ -615,7 +615,7 @@ MP4Err MP4ParseODFrame(struct MP4MediaAtom *self, MP4Handle sampleH, MP4Handle s MP4Err MP4CreateES_ID_RefDescriptor(u32 tag, u32 size, u32 bytesRead, MP4DescriptorPtr * outDesc); descList = NULL; - is = NULL; + is = NULL; err = MP4GetHandleSize(sampleH, &frameSize); if(err) goto bail; @@ -726,20 +726,20 @@ MP4Err MP4ParseODFrame(struct MP4MediaAtom *self, MP4Handle sampleH, MP4Handle s /* Remove the ESDescriptor List from each OD present in the ObjectDescriptor !! */ if(od->ESDescriptors) { - u32 listSize; - u32 i1; - err = MP4GetListEntryCount(od->ESDescriptors, &listSize); - if(err) goto bail; - for(i1 = 0; i1 < listSize; i1++) - { - MP4DescriptorPtr a; - err = MP4GetListEntry(od->ESDescriptors, i1, (char **)&a); - if(err) goto bail; - if(a) a->destroy(a); - } - err = MP4DeleteLinkedList(od->ESDescriptors); - if(err) goto bail; - + u32 listSize; + u32 i1; + err = MP4GetListEntryCount(od->ESDescriptors, &listSize); + if(err) goto bail; + for(i1 = 0; i1 < listSize; i1++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(od->ESDescriptors, i1, (char **)&a); + if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(od->ESDescriptors); + if(err) goto bail; + od->ESDescriptors = NULL; } } @@ -780,19 +780,20 @@ MP4Err MP4ParseODFrame(struct MP4MediaAtom *self, MP4Handle sampleH, MP4Handle s /* Remove the ESDescriptors from the ES Listr present in this update!! */ if(esUpdate->ESDescriptors) { - u32 listSize; - u32 i1; - err = MP4GetListEntryCount(esUpdate->ESDescriptors, &listSize); - if(err) goto bail; - for(i1 = 0; i1 < listSize; i1++) - { - MP4DescriptorPtr a; - err = MP4GetListEntry(esUpdate->ESDescriptors, i1, (char **)&a); - if(err) goto bail; - if(a) a->destroy(a); - } - err = MP4DeleteLinkedList(esUpdate->ESDescriptors); if(err) goto bail; - + u32 listSize; + u32 i1; + err = MP4GetListEntryCount(esUpdate->ESDescriptors, &listSize); + if(err) goto bail; + for(i1 = 0; i1 < listSize; i1++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(esUpdate->ESDescriptors, i1, (char **)&a); + if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(esUpdate->ESDescriptors); + if(err) goto bail; + esUpdate->ESDescriptors = NULL; } @@ -832,18 +833,19 @@ MP4Err MP4ParseODFrame(struct MP4MediaAtom *self, MP4Handle sampleH, MP4Handle s if(is) is->destroy(is); if(descList) { - u32 listSize; - u32 i1; - err = MP4GetListEntryCount(descList, &listSize); - if(err) goto bail; - for(i1 = 0; i1 < listSize; i1++) - { - MP4DescriptorPtr a; - err = MP4GetListEntry(descList, i1, (char **)&a); - if(err) goto bail; - if(a) a->destroy(a); - } - err = MP4DeleteLinkedList(descList); if(err) goto bail; + u32 listSize; + u32 i1; + err = MP4GetListEntryCount(descList, &listSize); + if(err) goto bail; + for(i1 = 0; i1 < listSize; i1++) + { + MP4DescriptorPtr a; + err = MP4GetListEntry(descList, i1, (char **)&a); + if(err) goto bail; + if(a) a->destroy(a); + } + err = MP4DeleteLinkedList(descList); + if(err) goto bail; } TEST_RETURN(err); return err; diff --git a/IsoLib/libisomediafile/src/MovieExtendsAtom.c b/IsoLib/libisomediafile/src/MovieExtendsAtom.c index c8d2041..da0ff50 100644 --- a/IsoLib/libisomediafile/src/MovieExtendsAtom.c +++ b/IsoLib/libisomediafile/src/MovieExtendsAtom.c @@ -157,7 +157,7 @@ static MP4Err setCompositionToDecodeProperties(struct MP4MovieExtendsAtom *self, cslg->compositionStartTime = compositionStartTime; cslg->compositionEndTime = compositionEndTime; } - + bail: TEST_RETURN(err); diff --git a/IsoLib/libisomediafile/src/MovieFragmentAtom.c b/IsoLib/libisomediafile/src/MovieFragmentAtom.c index b8eea6e..aa3a1d7 100644 --- a/IsoLib/libisomediafile/src/MovieFragmentAtom.c +++ b/IsoLib/libisomediafile/src/MovieFragmentAtom.c @@ -162,8 +162,8 @@ static MP4Err mergeFragments(struct MP4MovieFragmentAtom *self, MP4MovieAtomPtr if(tfdt->baseMediaDecodeTime < initialMediaDuration) BAILWITHERROR(MP4InvalidMediaErr); if(tfdt->baseMediaDecodeTime > initialMediaDuration) - err = - mdia->extendLastSampleDuration(mdia, tfdt->baseMediaDecodeTime - (u32)initialMediaDuration); + err = mdia->extendLastSampleDuration(mdia, + tfdt->baseMediaDecodeTime - (u32)initialMediaDuration); if(err) goto bail; } diff --git a/IsoLib/libisomediafile/src/MovieTracks.c b/IsoLib/libisomediafile/src/MovieTracks.c index df12cb5..89058f9 100644 --- a/IsoLib/libisomediafile/src/MovieTracks.c +++ b/IsoLib/libisomediafile/src/MovieTracks.c @@ -1037,8 +1037,8 @@ ISOSetTrackFragmentDefaults(MP4Track theTrack, u32 duration, u32 size, u32 is_sy MP4TrackHeaderAtomPtr tkhd; /* MP4SampleTableAtomPtr stbl; */ MP4MovieExtendsAtomPtr mvex; - MP4MovieAtomPtr movieAtom; - MP4PrivateMovieRecordPtr moov; + MP4MovieAtomPtr movieAtom; + MP4PrivateMovieRecordPtr moov; err = MP4NoErr; trak = (MP4TrackAtomPtr)theTrack; @@ -1046,8 +1046,8 @@ ISOSetTrackFragmentDefaults(MP4Track theTrack, u32 duration, u32 size, u32 is_sy if(err) goto bail; /* This function needs a re-write to be more object-oriented...*/ - if(theMovie == NULL) BAILWITHERROR(MP4BadParamErr) - moov = (MP4PrivateMovieRecordPtr)theMovie; + if(theMovie == NULL) BAILWITHERROR(MP4BadParamErr) + moov = (MP4PrivateMovieRecordPtr)theMovie; movieAtom = (MP4MovieAtomPtr)moov->moovAtomPtr; if(movieAtom->mvex == NULL) { @@ -1066,8 +1066,7 @@ ISOSetTrackFragmentDefaults(MP4Track theTrack, u32 duration, u32 size, u32 is_sy trex->trackID = tkhd->trackID; trex->default_sample_duration = duration; trex->default_sample_size = size; - trex->default_sample_flags = - ((pad & 7) << 17) | (is_sync ? 0 : fragment_difference_sample_flag); + trex->default_sample_flags = ((pad & 7) << 17) | (is_sync ? 0 : fragment_difference_sample_flag); /* stbl = ((MP4SampleTableAtomPtr) ((MP4MediaInformationAtomPtr) @@ -1078,7 +1077,7 @@ ISOSetTrackFragmentDefaults(MP4Track theTrack, u32 duration, u32 size, u32 is_sy err = mvex->addAtom(mvex, (MP4AtomPtr)trex); if(err) goto bail; - + bail: return err; } diff --git a/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c b/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c index 99d3325..19f13a9 100644 --- a/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c +++ b/IsoLib/libisomediafile/src/RestrictedVideoSampleEntry.c @@ -332,7 +332,7 @@ static MP4Err getSchemeInfoAtom(struct MP4Atom *s, u32 theType, struct MP4Atom * if(desc && (desc->type == theType)) { *theAtom = desc; - err = MP4NoErr; + err = MP4NoErr; break; } } diff --git a/IsoLib/libisomediafile/src/TimeToSampleAtom.c b/IsoLib/libisomediafile/src/TimeToSampleAtom.c index 0614f27..2d68ac4 100644 --- a/IsoLib/libisomediafile/src/TimeToSampleAtom.c +++ b/IsoLib/libisomediafile/src/TimeToSampleAtom.c @@ -182,7 +182,7 @@ static MP4Err getTimeForSampleNumber(MP4AtomPtr s, u32 sampleNumber, u64 *outSam MP4TimeToSampleAtomPtr self = (MP4TimeToSampleAtomPtr)s; if(self == NULL) BAILWITHERROR(MP4BadParamErr) err = MP4NoErr; - pe = NULL; + pe = NULL; err = MP4GetListEntryCount(self->entryList, &entryCount); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index fbe1d2d..b2fd080 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -584,7 +584,7 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) if(havedeps) { - err = mdia->setSampleDependency(mdia, (s32)count*(-1), depsH); + err = mdia->setSampleDependency(mdia, (s32)count * (-1), depsH); if(err) goto bail; } @@ -623,12 +623,13 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) { s32 position; u32 group_description_index; - position = j - total_samples; + position = j - total_samples; group_description_index = (theGroup->group_index)[j]; if(group_description_index <= 0x10000) { /* mapping to global indexes */ - err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, group_description_index, position, 1); + err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, group_description_index, + position, 1); if(err) goto bail; } else @@ -641,19 +642,24 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) local_description_index = group_description_index - 0x10000; correct_description_index = 0; - err = ISONewHandle(1, &descriptionEntry); if (err) goto bail; + err = ISONewHandle(1, &descriptionEntry); + if(err) goto bail; - /* 1. get handler from the local group description using localIndex */ - err = self->getGroupDescription(self, theGroup->grouping_type, local_description_index, descriptionEntry); + /* 1. get handler from the local group description using localIndex */ + err = self->getGroupDescription(self, theGroup->grouping_type, local_description_index, + descriptionEntry); if(err) BAILWITHFREEHANDLE(descriptionEntry); /* 2. find the same handler with the same type in stbl */ - err = MP4FindGroupAtom(stbl->groupDescriptionList, theGroup->grouping_type, (MP4AtomPtr *)&stblGroup); + err = MP4FindGroupAtom(stbl->groupDescriptionList, theGroup->grouping_type, + (MP4AtomPtr *)&stblGroup); if(err) BAILWITHFREEHANDLE(descriptionEntry); - err = stblGroup->findGroupDescriptionIdx(stblGroup, descriptionEntry, &correct_description_index); + err = stblGroup->findGroupDescriptionIdx(stblGroup, descriptionEntry, + &correct_description_index); if(err) BAILWITHFREEHANDLE(descriptionEntry); - err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, correct_description_index, position, 1); + err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, correct_description_index, + position, 1); ISODisposeHandle(descriptionEntry); if(err) goto bail; } From 64440c31e1b724340819c2bc7a11b8a458554bb3 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Fri, 20 Nov 2020 02:09:55 +0100 Subject: [PATCH 35/55] an example on how documentation should be done it would be nice to move all the existing documentation to this doxygen style. --- IsoLib/libisomediafile/src/MP4Handle.c | 122 ++++++++++++++++--------- 1 file changed, 80 insertions(+), 42 deletions(-) diff --git a/IsoLib/libisomediafile/src/MP4Handle.c b/IsoLib/libisomediafile/src/MP4Handle.c index 3f7149a..5573f10 100644 --- a/IsoLib/libisomediafile/src/MP4Handle.c +++ b/IsoLib/libisomediafile/src/MP4Handle.c @@ -1,28 +1,25 @@ -/* -This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. -ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware -or software products claiming conformance to MPEG-4. -Those intending to use this software module in hardware or software -products are advised that its use may infringe existing patents. -The original developer of this software module and his/her company, -the subsequent editors and their companies, and ISO/IEC have no -liability for use of this software module or modifications thereof -in an implementation. -Copyright is not released for non MPEG-4 conforming -products. Apple Computer, Inc. retains full right to use the code for its own -purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non -MPEG-4 conforming products. -This copyright notice must be included in all copies or -derivative works. Copyright (c) 1999. -*/ -/* - $Id: MP4Handle.c,v 1.4 2002/10/08 10:11:54 fred Exp $ -*/ +/** + * @file MP4Handle.c + * @author fred Exp + * @brief Utility functions + * @version 0.4 + * @date 2020-11-20 + * + * @copyright This software module was originally developed by Apple Computer, Inc. in the course of + * development of MPEG-4. This software module is an implementation of a part of one or more MPEG-4 + * tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this software module + * or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. + * Those intending to use this software module in hardware or software products are advised that its + * use may infringe existing patents. The original developer of this software module and his/her + * company, the subsequent editors and their companies, and ISO/IEC have no liability for use of + * this software module or modifications thereof in an implementation. Copyright is not released for + * non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its + * own purpose, assign or donate the code to a third party and to inhibit third parties from using + * the code for non MPEG-4 conforming products. This copyright notice must be included in all copies + * or derivative works. Copyright (c) 2020. + * + */ + #include "MP4Movies.h" #include #include @@ -37,16 +34,22 @@ typedef struct u32 offset; } handleStruct, *actualHandle; -/* The handle offset makes the handle point to an offset into the datablock. - Setting the offset thus 'reserves space' at the front of the block, and - reduces its effective size. The handle size is thus set and reported without - the offset. - */ +/* The handle offset makes the handle point to an offset into the datablock. Setting the offset thus + * 'reserves space' at the front of the block, and reduces its effective size. The handle size is + * thus set and reported without the offset. */ #define HANDLE_SIGNATURE 0x1234 -MP4_EXTERN(MP4Err) -MP4NewHandle(u32 handleSize, MP4Handle *outHandle) +/** + * @brief Creates a new handle, and allocates handleSize bytes for it. It is OK to call this with a + * size of zero. This is commonly done when the handle will be used as a parameter to a function + * that will size it appropriately. + * + * @param handleSize number of bytes to allocate + * @param outHandle output handle + * @return MP4Err error code + */ +MP4_EXTERN(MP4Err) MP4NewHandle(u32 handleSize, MP4Handle *outHandle) { MP4Err err; MP4Handle ret; @@ -83,8 +86,14 @@ MP4NewHandle(u32 handleSize, MP4Handle *outHandle) return err; } -MP4_EXTERN(MP4Err) -MP4GetHandleSize(MP4Handle theHandle, u32 *outSize) +/** + * @brief Use this to determine the present logical size (in bytes) of a handle. + * + * @param theHandle input handle + * @param outSize output size in bytes + * @return MP4Err error code + */ +MP4_EXTERN(MP4Err) MP4GetHandleSize(MP4Handle theHandle, u32 *outSize) { MP4Err err; actualHandle h = (actualHandle)theHandle; @@ -101,8 +110,17 @@ MP4GetHandleSize(MP4Handle theHandle, u32 *outSize) return err; } -MP4_EXTERN(MP4Err) -MP4SetHandleSize(MP4Handle theHandle, u32 requestedSize) +/** + * @brief Sets the logical size of the handle to requestedSize bytes. If this is larger than the + * number of bytes allocated for this handle, the handle will be grown accordingly. If the new size + * is smaller than the allocated size the memory is not freed. The only way to free this memory is + * to dispose of the handle. + * + * @param theHandle input handle + * @param requestedSize new size in bytes + * @return MP4Err error code + */ +MP4_EXTERN(MP4Err) MP4SetHandleSize(MP4Handle theHandle, u32 requestedSize) { MP4Err err; actualHandle h = (actualHandle)theHandle; @@ -135,8 +153,16 @@ MP4SetHandleSize(MP4Handle theHandle, u32 requestedSize) return err; } -MP4_EXTERN(MP4Err) -MP4SetHandleOffset(MP4Handle theHandle, u32 offset) +/** + * @brief Sets the handle so that subsequent de-references of it refer to the data starting at the + * given byte offset. This can be used to cause data to be read from or written to locations after + * the beginning, leaving room (for example) for an encryption header. + * + * @param theHandle input handle + * @param offset byte offset + * @return MP4Err error code + */ +MP4_EXTERN(MP4Err) MP4SetHandleOffset(MP4Handle theHandle, u32 offset) { MP4Err err; actualHandle h = (actualHandle)theHandle; @@ -169,8 +195,13 @@ MP4SetHandleOffset(MP4Handle theHandle, u32 offset) return err; } -MP4_EXTERN(MP4Err) -MP4DisposeHandle(MP4Handle theHandle) +/** + * @brief Frees the memory that was allocated for a handle. + * + * @param theHandle input handle to kill + * @return MP4Err error code + */ +MP4_EXTERN(MP4Err) MP4DisposeHandle(MP4Handle theHandle) { MP4Err err; actualHandle h = (actualHandle)theHandle; @@ -184,8 +215,15 @@ MP4DisposeHandle(MP4Handle theHandle) return err; } -MP4_EXTERN(MP4Err) -MP4HandleCat(MP4Handle theDstHandle, MP4Handle theSrcHandle) +/** + * @brief Appends the data contained in theSrcHandle to data contained in theDstHandle by + * reallocating, if necessary, the number of bytes allocated for theDstHandle. + * + * @param theDstHandle destination handle + * @param theSrcHandle source handle + * @return MP4Err error code + */ +MP4_EXTERN(MP4Err) MP4HandleCat(MP4Handle theDstHandle, MP4Handle theSrcHandle) { MP4Err err; u32 requestedSize, offset; From e1ac4390880b9bc29629b7c4ad4e96d01f89c763 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Fri, 20 Nov 2020 20:07:23 +0100 Subject: [PATCH 36/55] Finish sample-group test and other stuff - Implement sample group testing - Implement getDescriptionEntryCount to provide the API to iterate over all entries - Clean up debugging output - Move doxygen documentation to the header of the API --- IsoLib/libisomediafile/src/MP4Handle.c | 51 +- IsoLib/libisomediafile/src/MP4Media.c | 40 ++ IsoLib/libisomediafile/src/MP4Movies.h | 131 ++++- .../libisomediafile/src/SampleToGroupAtom.c | 56 +- IsoLib/playground/main.cpp | 351 ++++++----- test/CMakeLists.txt | 2 +- test/test_data.h | 56 ++ test/test_fragment_creation.cpp | 322 ---------- test/test_sample_groups.cpp | 550 ++++++++++++++++++ 9 files changed, 980 insertions(+), 579 deletions(-) create mode 100644 test/test_data.h delete mode 100644 test/test_fragment_creation.cpp create mode 100644 test/test_sample_groups.cpp diff --git a/IsoLib/libisomediafile/src/MP4Handle.c b/IsoLib/libisomediafile/src/MP4Handle.c index 5573f10..930e44a 100644 --- a/IsoLib/libisomediafile/src/MP4Handle.c +++ b/IsoLib/libisomediafile/src/MP4Handle.c @@ -1,7 +1,7 @@ /** * @file MP4Handle.c * @author fred Exp - * @brief Utility functions + * @brief Implementation of utility functions * @version 0.4 * @date 2020-11-20 * @@ -40,15 +40,6 @@ typedef struct #define HANDLE_SIGNATURE 0x1234 -/** - * @brief Creates a new handle, and allocates handleSize bytes for it. It is OK to call this with a - * size of zero. This is commonly done when the handle will be used as a parameter to a function - * that will size it appropriately. - * - * @param handleSize number of bytes to allocate - * @param outHandle output handle - * @return MP4Err error code - */ MP4_EXTERN(MP4Err) MP4NewHandle(u32 handleSize, MP4Handle *outHandle) { MP4Err err; @@ -86,13 +77,6 @@ MP4_EXTERN(MP4Err) MP4NewHandle(u32 handleSize, MP4Handle *outHandle) return err; } -/** - * @brief Use this to determine the present logical size (in bytes) of a handle. - * - * @param theHandle input handle - * @param outSize output size in bytes - * @return MP4Err error code - */ MP4_EXTERN(MP4Err) MP4GetHandleSize(MP4Handle theHandle, u32 *outSize) { MP4Err err; @@ -110,16 +94,6 @@ MP4_EXTERN(MP4Err) MP4GetHandleSize(MP4Handle theHandle, u32 *outSize) return err; } -/** - * @brief Sets the logical size of the handle to requestedSize bytes. If this is larger than the - * number of bytes allocated for this handle, the handle will be grown accordingly. If the new size - * is smaller than the allocated size the memory is not freed. The only way to free this memory is - * to dispose of the handle. - * - * @param theHandle input handle - * @param requestedSize new size in bytes - * @return MP4Err error code - */ MP4_EXTERN(MP4Err) MP4SetHandleSize(MP4Handle theHandle, u32 requestedSize) { MP4Err err; @@ -153,15 +127,6 @@ MP4_EXTERN(MP4Err) MP4SetHandleSize(MP4Handle theHandle, u32 requestedSize) return err; } -/** - * @brief Sets the handle so that subsequent de-references of it refer to the data starting at the - * given byte offset. This can be used to cause data to be read from or written to locations after - * the beginning, leaving room (for example) for an encryption header. - * - * @param theHandle input handle - * @param offset byte offset - * @return MP4Err error code - */ MP4_EXTERN(MP4Err) MP4SetHandleOffset(MP4Handle theHandle, u32 offset) { MP4Err err; @@ -195,12 +160,6 @@ MP4_EXTERN(MP4Err) MP4SetHandleOffset(MP4Handle theHandle, u32 offset) return err; } -/** - * @brief Frees the memory that was allocated for a handle. - * - * @param theHandle input handle to kill - * @return MP4Err error code - */ MP4_EXTERN(MP4Err) MP4DisposeHandle(MP4Handle theHandle) { MP4Err err; @@ -215,14 +174,6 @@ MP4_EXTERN(MP4Err) MP4DisposeHandle(MP4Handle theHandle) return err; } -/** - * @brief Appends the data contained in theSrcHandle to data contained in theDstHandle by - * reallocating, if necessary, the number of bytes allocated for theDstHandle. - * - * @param theDstHandle destination handle - * @param theSrcHandle source handle - * @return MP4Err error code - */ MP4_EXTERN(MP4Err) MP4HandleCat(MP4Handle theDstHandle, MP4Handle theSrcHandle) { MP4Err err; diff --git a/IsoLib/libisomediafile/src/MP4Media.c b/IsoLib/libisomediafile/src/MP4Media.c index 4a0e8ec..3acab32 100644 --- a/IsoLib/libisomediafile/src/MP4Media.c +++ b/IsoLib/libisomediafile/src/MP4Media.c @@ -201,6 +201,46 @@ ISOGetGroupDescription(MP4Media media, u32 groupType, u32 index, MP4Handle descr return err; } +MP4_EXTERN(MP4Err) +ISOGetGroupDescriptionEntryCount(MP4Media media, u32 groupType, u32 *outEntryCount) +{ + MP4Err err; + MP4MediaAtomPtr mdia; + MP4MediaInformationAtomPtr minf; + MP4SampleTableAtomPtr stbl; + MP4TrackFragmentAtomPtr traf; + MP4SampleGroupDescriptionAtomPtr theGroup; + + err = MP4NoErr; + mdia = (MP4MediaAtomPtr)media; + if(mdia == NULL) BAILWITHERROR(MP4BadParamErr); + + if(mdia->information->type == MP4MediaInformationAtomType) + { + minf = (MP4MediaInformationAtomPtr)mdia->information; + if(minf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + stbl = (MP4SampleTableAtomPtr)minf->sampleTable; + if(stbl == NULL) BAILWITHERROR(MP4BadParamErr); + MP4FindGroupAtom(stbl->groupDescriptionList, groupType, (MP4AtomPtr *)&theGroup); + if(!theGroup) BAILWITHERROR(MP4NotFoundErr); + *outEntryCount = theGroup->groupCount; + } + else if(mdia->information->type == MP4TrackFragmentAtomType) + { + traf = (MP4TrackFragmentAtomPtr)mdia->information; + if(traf == NULL) BAILWITHERROR(MP4InvalidMediaErr); + MP4FindGroupAtom(traf->groupDescriptionList, groupType, (MP4AtomPtr *)&theGroup); + if(!theGroup) BAILWITHERROR(MP4NotFoundErr); + *outEntryCount = theGroup->groupCount; + } + else BAILWITHERROR(MP4InvalidMediaErr); + +bail: + TEST_RETURN(err); + + return err; +} + MP4_EXTERN(MP4Err) ISOSetSamplestoGroupType(MP4Media media, sampleToGroupType_t sampleToGroupType) { diff --git a/IsoLib/libisomediafile/src/MP4Movies.h b/IsoLib/libisomediafile/src/MP4Movies.h index 82ad3f0..08be223 100644 --- a/IsoLib/libisomediafile/src/MP4Movies.h +++ b/IsoLib/libisomediafile/src/MP4Movies.h @@ -1,7 +1,11 @@ -/* - This header file may be freely copied and distributed. - -*/ +/** + * @file MP4Movies.h + * @brief API + * @version 0.1 + * + * @copyright This header file may be freely copied and distributed. + * + */ #ifndef INCLUDED_MP4MOVIE_H #define INCLUDED_MP4MOVIE_H @@ -101,9 +105,9 @@ extern "C" typedef enum sampleToGroupType_t { - SAMPLE_GROUP_NORMAL = 0, /* sbgp */ - SAMPLE_GROUP_COMPACT, /* csgp */ - SAMPLE_GROUP_AUTO /* automatically decide based on atom size */ + SAMPLE_GROUP_NORMAL = 0, /**< sbgp */ + SAMPLE_GROUP_COMPACT, /**< csgp */ + SAMPLE_GROUP_AUTO /**< automatically decide based on atom size */ } sampleToGroupType_t; #define GETMOOV(arg) \ @@ -185,23 +189,66 @@ extern "C" typedef char **MP4Handle; - MP4_EXTERN(MP4Err) - MP4NewHandle(u32 handleSize, MP4Handle *outHandle); - - MP4_EXTERN(MP4Err) - MP4SetHandleSize(MP4Handle h, u32 handleSize); - - MP4_EXTERN(MP4Err) - MP4DisposeHandle(MP4Handle h); - - MP4_EXTERN(MP4Err) - MP4GetHandleSize(MP4Handle h, u32 *outHandleSize); - - MP4_EXTERN(MP4Err) - MP4HandleCat(MP4Handle theDstHandle, MP4Handle theSrcHandle); /* FB_RESO 09/02 */ - - MP4_EXTERN(MP4Err) - MP4SetHandleOffset(MP4Handle theHandle, u32 offset); + /** + * @brief Creates a new handle, and allocates handleSize bytes for it. It is OK to call this with a + * size of zero. This is commonly done when the handle will be used as a parameter to a function + * that will size it appropriately. + * + * @param handleSize number of bytes to allocate + * @param outHandle output handle + * @return MP4Err error code + */ + MP4_EXTERN(MP4Err) MP4NewHandle(u32 handleSize, MP4Handle *outHandle); + + /** + * @brief Sets the logical size of the handle to requestedSize bytes. If this is larger than the + * number of bytes allocated for this handle, the handle will be grown accordingly. If the new size + * is smaller than the allocated size the memory is not freed. The only way to free this memory is + * to dispose of the handle. + * + * @param theHandle input handle + * @param requestedSize new size in bytes + * @return MP4Err error code + */ + MP4_EXTERN(MP4Err) MP4SetHandleSize(MP4Handle theHandle, u32 handleSize); + + /** + * @brief Frees the memory that was allocated for a handle. + * + * @param theHandle input handle to kill + * @return MP4Err error code + */ + MP4_EXTERN(MP4Err) MP4DisposeHandle(MP4Handle theHandle); + + /** + * @brief Use this to determine the present logical size (in bytes) of a handle. + * + * @param theHandle input handle + * @param outSize output size in bytes + * @return MP4Err error code + */ + MP4_EXTERN(MP4Err) MP4GetHandleSize(MP4Handle theHandle, u32 *outSize); + + /** + * @brief Appends the data contained in theSrcHandle to data contained in theDstHandle by + * reallocating, if necessary, the number of bytes allocated for theDstHandle. + * + * @param theDstHandle destination handle + * @param theSrcHandle source handle + * @return MP4Err error code + */ + MP4_EXTERN(MP4Err) MP4HandleCat(MP4Handle theDstHandle, MP4Handle theSrcHandle); /* FB_RESO 09/02 */ + + /** + * @brief Sets the handle so that subsequent de-references of it refer to the data starting at the + * given byte offset. This can be used to cause data to be read from or written to locations after + * the beginning, leaving room (for example) for an encryption header. + * + * @param theHandle input handle + * @param offset byte offset + * @return MP4Err error code + */ + MP4_EXTERN(MP4Err) MP4SetHandleOffset(MP4Handle theHandle, u32 offset); /* Movie related */ @@ -412,11 +459,37 @@ extern "C" MP4_EXTERN(MP4Err) ISOAddGroupDescription(MP4Media media, u32 groupType, MP4Handle description, u32 *index); - MP4_EXTERN(MP4Err) - ISOGetGroupDescription(MP4Media media, u32 groupType, u32 index, MP4Handle description); - - MP4_EXTERN(MP4Err) - ISOSetSamplestoGroupType(MP4Media media, sampleToGroupType_t sampleToGroupType); + /** + * @brief Returns in the handle ‘description’ the group description associated with the given group index of the given group type. + * + * @param media media object where to look for the specific group description + * @param groupType grouping_type + * @param index index starting with 1 + * @param description output handle holding the SampleGroupDescriptionEntry + * @return MP4Err error code + */ + MP4_EXTERN(MP4Err) ISOGetGroupDescription(MP4Media media, u32 groupType, u32 index, MP4Handle description); + + /** + * @brief Returns the entry_count of the desired SampleGroupDescriptionBox 'sgpd' of the given type + * + * @param media media object where to look for the specific group description + * @param groupType grouping_type of 'sgpd' + * @param outEntryCount entry_count output + * @return MP4Err error code + */ + MP4_EXTERN(MP4Err) ISOGetGroupDescriptionEntryCount(MP4Media media, u32 groupType, u32 *outEntryCount); + + /** + * @brief Set the SampleToGroup mapping type: normal 'sbgp' (default), compact 'csgp', or decide which one to use automatically. + * + * @note Calling this function will also change the mapping type in the current movie or fragment. + * + * @param media media object + * @param sampleToGroupType choose between SAMPLE_GROUP_NORMAL, SAMPLE_GROUP_COMPACT or SAMPLE_GROUP_AUTO + * @return MP4Err error code + */ + MP4_EXTERN(MP4Err) ISOSetSamplestoGroupType(MP4Media media, sampleToGroupType_t sampleToGroupType); MP4_EXTERN(MP4Err) ISOMapSamplestoGroup(MP4Media media, u32 groupType, u32 group_index, s32 sample_index, u32 count); diff --git a/IsoLib/libisomediafile/src/SampleToGroupAtom.c b/IsoLib/libisomediafile/src/SampleToGroupAtom.c index 42cab6c..37dde6e 100644 --- a/IsoLib/libisomediafile/src/SampleToGroupAtom.c +++ b/IsoLib/libisomediafile/src/SampleToGroupAtom.c @@ -159,8 +159,6 @@ static void AppendNewPatternEntry(CompressedGroupInfo *compressedGroup, u32 inde assert(patternLength != 0); assert(sampleCount != 0); assert(index < compressedGroup->patternCount); - /*printf("\n New pattern: length %d sampleCount %d", patternLength, sampleCount); */ - compressedGroup->patternEntries[index].patternLength = patternLength; compressedGroup->patternEntries[index].sampleCount = sampleCount; compressedGroup->totalSampleCount += sampleCount; @@ -182,16 +180,12 @@ static void SetMemoryCostForPattern(SampleGroupInfo *sampleGroup, u32 patternLen if(memoryCost < sampleGroup->patternTracker[endPatternSampleIndex].cumulativeMemoryCost) { PatternTracker patTrack; - patTrack.patternStart = startPatternSampleIndex; - patTrack.patternLength = patternLength; - patTrack.sampleCount = sampleCount; - patTrack.cumulativeMemoryCost = memoryCost; - patTrack.prevEfficientIndex = startPatternSampleIndex - 1; - + patTrack.patternStart = startPatternSampleIndex; + patTrack.patternLength = patternLength; + patTrack.sampleCount = sampleCount; + patTrack.cumulativeMemoryCost = memoryCost; + patTrack.prevEfficientIndex = startPatternSampleIndex - 1; sampleGroup->patternTracker[endPatternSampleIndex] = patTrack; - /*printf("\n Pattern run of pattern length %d, sample count %d, starting @ %3d with memoryCost - * %d and prevMostEffIndex %d", patternLength, sampleCount, startPatternSampleIndex, - * patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex); */ } } @@ -205,15 +199,12 @@ static void SetMemoryCostForNonPattern(SampleGroupInfo *sampleGroup, s32 sampleI if(memoryCost < sampleGroup->patternTracker[sampleIndex].cumulativeMemoryCost) { PatternTracker patTrack; - patTrack.patternStart = sampleIndex; - patTrack.patternLength = 1; - patTrack.sampleCount = 1; - patTrack.cumulativeMemoryCost = memoryCost; - patTrack.prevEfficientIndex = sampleIndex - 1; - + patTrack.patternStart = sampleIndex; + patTrack.patternLength = 1; + patTrack.sampleCount = 1; + patTrack.cumulativeMemoryCost = memoryCost; + patTrack.prevEfficientIndex = sampleIndex - 1; sampleGroup->patternTracker[sampleIndex] = patTrack; - /*printf("\n Writing non-pattern with memoryCost %d and prevMostEffIndex %d ", - * patTrack.cumulativeMemoryCost, patTrack.prevEfficientIndex);*/ } } @@ -279,10 +270,6 @@ static void FindPatternsStartingAtIndex(SampleGroupInfo *sampleGroup, u32 sample SetMemoryCostForPattern(sampleGroup, p, startPatternSampleIndex, i); i++; } - - /* Pattern ended at i - 1. - printf("\n %3d: pattern run ended", i-1); - break; */ } } } @@ -361,15 +348,6 @@ static void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) (u32 *)malloc(sizeof(u32) * compressedGroup->totalIndexDescriptionCount); } - /*printf("\n The pattern tracker details are"); - for(int i = 0; i < self->sampleCount; i++) - { - printf("\n Index %d Start: %d PL: %d SC: %d Eff: %d PrevIndex: %d NextIndex: %d ", i, - patternTracker[i].start, patternTracker[i].patternLength, patternTracker[i].sampleCount, - patternTracker[i].cumulativeMemoryCost, patternTracker[i].prevEfficientIndex, - patternTracker[i].nextEfficientIndex); - }*/ - patternTracker = sampleGroup.patternTracker; descIndex = 0; nextIndex = compressedGroup->efficientStartIndex; @@ -723,19 +701,9 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) } else { - printf(" \n Field sizes of pattern is %d , sampleCount is %d , indexDescription is %d ", - self->compressedGroup.patternLengthFieldSize, self->compressedGroup.sampleCountFieldSize, - self->compressedGroup.indexFieldSize); - - printf("\n Pattern count %d covering %d total samples ", self->compressedGroup.patternCount, - self->compressedGroup.totalSampleCount); - + /* compact sample groups */ for(i = 0; i < self->compressedGroup.patternCount; i++) { - printf("\n Pattern length %d for %d samples ", - self->compressedGroup.patternEntries[i].patternLength, - self->compressedGroup.patternEntries[i].sampleCount); - /* Pattern entry is ensured to start at a byte boundary*/ PackData(self, &buffer, self->compressedGroup.patternLengthFieldSize, 0, self->compressedGroup.patternEntries[i].patternLength); @@ -746,10 +714,8 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) } /* Index descriptor array is ensured to start at a byte boundary*/ - printf("\n Index Descriptors array is: "); for(i = 0; i < self->compressedGroup.totalIndexDescriptionCount; i++) { - printf(" %d ", self->compressedGroup.indexDescriptionArray[i]); PackData(self, &buffer, self->compressedGroup.indexFieldSize, (i & 1), self->compressedGroup.indexDescriptionArray[i]); } diff --git a/IsoLib/playground/main.cpp b/IsoLib/playground/main.cpp index 0cbed3e..7ce72ff 100644 --- a/IsoLib/playground/main.cpp +++ b/IsoLib/playground/main.cpp @@ -58,13 +58,6 @@ const u32 FPS = 30; const u32 FOURCC_COLOR = MP4_FOUR_CHAR_CODE('c', 'o', 'l', 'r'); const u32 FOURCC_TEST = MP4_FOUR_CHAR_CODE('t', 'e', 's', 't'); -const u32 FOURCC_BLACK = MP4_FOUR_CHAR_CODE('b', 'l', 'c', 'k'); - -u32 groupIdRed = 0; -u32 groupIdBlue = 0; -u32 groupIdGreen = 0; -u32 groupIdYellow = 0; -u32 groupIdBlack = 0; ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, ISOHandle sampleEntryH = 0) @@ -108,7 +101,6 @@ ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, bufferSizes.push_back(sizeof(auBlack)); break; default: - std::cerr << "UNKNOWN char in pattern string: " << *it << std::endl; break; } } @@ -161,7 +153,7 @@ ISOErr addGroupDescription(MP4Media media, u32 fcc, std::string strDescription, return err; } -ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 repeatPattern = 1) +ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 idRed, u32 idBlue, u32 idGreen, u32 idYellow, u32 repeatPattern = 1) { ISOErr err = ISONoErr; std::string fullPattern = strPattern; @@ -170,8 +162,7 @@ ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 repeatPatt fullPattern += strPattern; } - // add sample groups - std::cout << "fullPattern = " << fullPattern << std::endl; + // map samples to groups if(repeatPattern > 0) { for(u32 n = 0; n < fullPattern.size(); ++n) @@ -179,26 +170,22 @@ ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 repeatPatt switch(fullPattern[n]) { case 'r': - ISOMapSamplestoGroup(media, FOURCC_COLOR, groupIdRed, n, 1); - std::cout << "RED map sample_index=" << n << " to group_index=" << groupIdRed << std::endl; + err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idRed, n, 1); + if(err) return err; break; case 'b': - ISOMapSamplestoGroup(media, FOURCC_COLOR, groupIdBlue, n, 1); - std::cout << "BLUE map sample_index=" << n << " to group_index=" << groupIdBlue - << std::endl; + err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idBlue, n, 1); + if(err) return err; break; case 'g': - ISOMapSamplestoGroup(media, FOURCC_COLOR, groupIdGreen, n, 1); - std::cout << "GREEN map sample_index=" << n << " to group_index=" << groupIdGreen - << std::endl; + err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idGreen, n, 1); + if(err) return err; break; case 'y': - ISOMapSamplestoGroup(media, FOURCC_COLOR, groupIdYellow, n, 1); - std::cout << "YELLOW map sample_index=" << n << " to group_index=" << groupIdYellow - << std::endl; + err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idYellow, n, 1); + if(err) return err; break; default: - std::cout << "SKIP (" << fullPattern[n] << ") sample_index=" << n << std::endl; break; } } @@ -206,42 +193,57 @@ ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 repeatPatt return err; } -ISOErr createFile(std::string strFilename) +/** + * @brief Create a Fragmented File with different sample groups for testing + * + * Moovie: Global group description for COLOR RED and BLUE in stbl + * + * Fragment 1: local group description COLOR RED (not used) + * local group description TEST with 2 entries + * Fragment 2: local group description COLOR GREEN and YELLOW (both used in COMPACT sampleToGroupBox) + * local group description TEST with 2 entries (one of these entries is the same as in Fragment 1) + * Fragment 3: no group description + * Fragment 4: local group descrition COLOR GREEN and YELLOW (both used in NORMAL sampleToGroupBox) + * Fragment 5: no group description + * + * Samples: red (r), blue(b), green (g), yellow (y), white (w), black (k) + * | frag. 1 | frag. 2 | frag. 3 | frag. 4 | + * |r|b|r|b|r|b|g|r|y|g|r|y|b|g|y|b|g|y|w|k|w|k|w|k| + * + * @param strFilename output filename + * @return ISOErr error code + */ +ISOErr createFragmentedFile(std::string strFilename) { - std::cout << "create file..." << std::endl; ISOErr err; ISOMovie moov; ISOMedia media; ISOTrack trak; + u32 colorEntryCount = 0; + u32 groupIdRed = 0; + u32 groupIdBlue = 0; + u32 groupIdGreen = 0; + u32 groupIdYellow = 0; + ISOHandle spsHandle, ppsHandle, vpsHandle, sampleEntryH; - err = ISONewHandle(sizeof(SPS), &spsHandle); + err = MP4NewHandle(sizeof(SPS), &spsHandle); std::memcpy((*spsHandle), SPS, sizeof(SPS)); - err = ISONewHandle(sizeof(PPS), &ppsHandle); + err = MP4NewHandle(sizeof(PPS), &ppsHandle); std::memcpy((*ppsHandle), PPS, sizeof(PPS)); - err = ISONewHandle(sizeof(VPS), &vpsHandle); + err = MP4NewHandle(sizeof(VPS), &vpsHandle); std::memcpy((*vpsHandle), VPS, sizeof(VPS)); - err = ISONewHandle(0, &sampleEntryH); - - u32 initialODID = 1; - u8 OD_profileAndLevel = 0xff; // none required - u8 scene_profileAndLevel = 0xff; // none required - u8 audio_profileAndLevel = 0xff; // none required - u8 visual_profileAndLevel = 0xff; // none required - u8 graphics_profileAndLevel = 0xff; // none required - - err = MP4NewMovie(&moov, OD_profileAndLevel, OD_profileAndLevel, scene_profileAndLevel, - audio_profileAndLevel, visual_profileAndLevel, graphics_profileAndLevel); - if(err) return -1; + err = MP4NewHandle(0, &sampleEntryH); - ISOSetMovieBrand(moov, MP4_FOUR_CHAR_CODE('i', 's', 'o', '6'), 0); + err = MP4NewMovie(&moov, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff); + if(err) return err; err = ISONewMovieTrack(moov, MP4NewTrackIsVisual, &trak); - if(err) return -2; + if(err) return err; err = MP4AddTrackToMovieIOD(trak); - if(err) return -3; + if(err) return err; err = ISONewTrackMedia(trak, &media, ISOVisualHandlerType, TIMESCALE, NULL); - if(err) return -4; + if(err) return err; err = ISOBeginMediaEdits(media); err = ISONewHEVCSampleDescription(trak, sampleEntryH, 1, 1, spsHandle, ppsHandle, vpsHandle); @@ -249,9 +251,16 @@ ISOErr createFile(std::string strFilename) err = ISOSetTrackFragmentDefaults(trak, TIMESCALE / FPS, sizeof(auBlue), 1, 0); + err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); + if(err == MP4NoErr) return -1; + if(colorEntryCount != 0) return -1; // red and blue are in stbl err = addGroupDescription(media, FOURCC_COLOR, "Red frames", groupIdRed); if(err) return err; err = addGroupDescription(media, FOURCC_COLOR, "Blue frames", groupIdBlue); if(err) return err; + + err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); + if(err) return err; + if(colorEntryCount != 2) return -1; u32 temp = 0; err = addGroupDescription(media, FOURCC_COLOR, "Red frames", temp); @@ -263,13 +272,17 @@ ISOErr createFile(std::string strFilename) if(err) return err; err = MP4EndMediaEdits(media); - std::cout << "\nfragment 1" << std::endl; + // Fragment 1 err = ISOStartMovieFragment(moov); ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); if(err) return err; err = addSamples(media, "rb", 3); if(err) return err; - err = addGroupDescription(media, FOURCC_TEST, "This must pass", temp); + colorEntryCount = 0; + err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); + if(err == MP4NoErr) return -1; // there sould be no entries in this fragment yet + if(colorEntryCount != 0) return -1; + err = addGroupDescription(media, FOURCC_TEST, "Duplicate test", temp); if(err) return err; err = addGroupDescription(media, FOURCC_COLOR, "Red frames", temp); if(err) return err; // this must pass even if the same type and payload is in stbl @@ -278,26 +291,37 @@ ISOErr createFile(std::string strFilename) if(err) return err; err = addGroupDescription(media, FOURCC_TEST, "Test", temp); if(!err) return -5; // this must fail because same type and payload already added - err = mapSamplesToGroups(media, "rb", 3); + err = mapSamplesToGroups(media, "rb", groupIdRed, groupIdBlue, groupIdGreen, groupIdYellow, 3); if(err) return err; - std::cout << "\nfragment 2 (compressed sample group)" << std::endl; + err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); + if(err) return err; // there should be now exactly one entry + if(colorEntryCount != 1) return -1; + + // Fragment 2 err = ISOStartMovieFragment(moov); - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_COMPACT); // local green and yellow groups err = addGroupDescription(media, FOURCC_COLOR, "Green frames", groupIdGreen); if(err) return err; err = addGroupDescription(media, FOURCC_COLOR, "Yellow frames", groupIdYellow); if(err) return err; err = addSamples(media, "gry", 2); if(err) return err; - err = addGroupDescription(media, FOURCC_TEST, "Same as in previous fragment but different entry", + err = addGroupDescription(media, FOURCC_TEST, "Unique entry", temp); if(err) return err; - err = addGroupDescription(media, FOURCC_TEST, "This must pass", temp); + err = addGroupDescription(media, FOURCC_TEST, "Duplicate test", temp); + if(err) return err; + err = mapSamplesToGroups(media, "gry", groupIdRed, groupIdBlue, groupIdGreen, groupIdYellow, 2); if(err) return err; - err = mapSamplesToGroups(media, "gry", 2); + + // Fragment 3 + err = ISOStartMovieFragment(moov); + if(err) return err; + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); + err = addSamples(media, "wk", 3); if(err) return err; - std::cout << "\nfragment 3" << std::endl; + // Fragment 4 err = ISOStartMovieFragment(moov); ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); // local green and yellow groups @@ -305,117 +329,180 @@ ISOErr createFile(std::string strFilename) err = addGroupDescription(media, FOURCC_COLOR, "Yellow frames", groupIdYellow); if(err) return err; err = addSamples(media, "bgy", 2); if(err) return err; - err = mapSamplesToGroups(media, "bgy", 2); + err = mapSamplesToGroups(media, "bgy", groupIdRed, groupIdBlue, groupIdGreen, groupIdYellow, 2); if(err) return err; - std::cout << "\nfragment 4" << std::endl; + // Fragment 5 err = ISOStartMovieFragment(moov); if(err) return err; ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); err = addSamples(media, "wk", 3); if(err) return err; - err = MP4WriteMovieToFile(moov, strFilename.c_str()); return err; } -int main() +/** + * @brief Create different flavors of defragmented files from the fragmented file + * + * @param inputFrag Input fragmented file + * @param outputDefragNorm Defragmented file with NORMAL SampleToGroupBox + * @param outputDefragComp Defragmented file with COMPACT SampleToGroupBox + * @param outputDefragAuto Defragmented file with AUTO SampleToGroupBox (smaller size is used automatically) + * @return ISOErr + */ +ISOErr defragmentFile(std::string inputFrag, std::string outputDefragNorm, std::string outputDefragComp, std::string outputDefragAuto) { ISOErr err; - std::string strFileFrag = "hevc_fragments.mp4"; - std::string strFileDefragBase = "hevc_defrag_"; - - err = createFile(strFileFrag); - if(err) - { - std::cerr << "could not create the file" << std::endl; - return err; - } - - std::cout << "\n\nParse file..." << std::endl; ISOMovie moov; ISOTrack trak; ISOMedia media; - err = ISOOpenMovieFile(&moov, strFileFrag.c_str(), MP4OpenMovieNormal); // MP4OpenMovieDebug + err = ISOOpenMovieFile(&moov, inputFrag.c_str(), MP4OpenMovieNormal); + if(err) return err; - u32 trackCount = 0; - err = MP4GetMovieTrackCount(moov, &trackCount); - for(u32 trackNumber = 1; trackNumber <= trackCount; ++trackNumber) - { - err = ISOGetMovieIndTrack(moov, trackNumber, &trak); - err = ISOGetTrackMedia(trak, &media); - u32 sampleCnt = 0; - u32 *sampleNumbers; - groupIdGreen = 3; // TODO: get these IDs using the API - groupIdYellow = 4; - err = - ISOGetSampleGroupSampleNumbers(media, FOURCC_COLOR, groupIdRed, &sampleNumbers, &sampleCnt); - - std::cout << "RED sampleCnt=" << sampleCnt << std::endl; - for(u32 i = 0; i < sampleCnt; ++i) - { - std::cout << "sample " << sampleNumbers[i] << std::endl; - } + err = ISOGetMovieIndTrack(moov, 1, &trak); + if(err) return err; + err = ISOGetTrackMedia(trak, &media); + if(err) return err; - err = ISOGetSampleGroupSampleNumbers(media, FOURCC_COLOR, groupIdBlue, &sampleNumbers, - &sampleCnt); + // write file with compact sample groups + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_COMPACT); + err = MP4WriteMovieToFile(moov, outputDefragComp.c_str()); + if(err) return err; - std::cout << "BLUE sampleCnt=" << sampleCnt << std::endl; - for(u32 i = 0; i < sampleCnt; ++i) - { - std::cout << "sample " << sampleNumbers[i] << std::endl; - } + // write file with normal sample groups + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); + err = MP4WriteMovieToFile(moov, outputDefragNorm.c_str()); + if(err) return err; - err = ISOGetSampleGroupSampleNumbers(media, FOURCC_COLOR, groupIdGreen, &sampleNumbers, - &sampleCnt); + // write file with auto sample groups + ISOSetSamplestoGroupType(media, SAMPLE_GROUP_AUTO); + err = MP4WriteMovieToFile(moov, outputDefragAuto.c_str()); + return err; +} - std::cout << "GREEN sampleCnt=" << sampleCnt << std::endl; - for(u32 i = 0; i < sampleCnt; ++i) - { - std::cout << "sample " << sampleNumbers[i] << std::endl; - } +ISOErr checkSample(MP4Media media, u32 sampleNr, u8 *comparePtr, u32 compareSize) +{ + ISOErr err; + MP4Handle sampleH; + u32 outSize, outSampleFlags, outSampleDescIndex; + u64 outDTS, outDuration; + s32 outCTSOffset; - err = ISOGetSampleGroupSampleNumbers(media, FOURCC_COLOR, groupIdYellow, &sampleNumbers, - &sampleCnt); + MP4NewHandle(0, &sampleH); + err = MP4GetIndMediaSample(media, sampleNr, sampleH, &outSize, &outDTS, &outCTSOffset, &outDuration, &outSampleFlags, &outSampleDescIndex); + if(err) return err; - std::cout << "YELLOW sampleCnt=" << sampleCnt << std::endl; - for(u32 i = 0; i < sampleCnt; ++i) - { - std::cout << "sample " << sampleNumbers[i] << std::endl; - } - } - // ISOGetSampleGroupSamples() + u32 handleSize; + MP4GetHandleSize(sampleH, &handleSize); + if(handleSize != outSize) return -1; + if(outSize != compareSize) return -1; - // write file with compact sample groups - for(u32 trackNumber = 1; trackNumber <= trackCount; ++trackNumber) + int compareVal = std::memcmp(comparePtr, *sampleH, compareSize); + if(compareVal != 0) return -1; + + MP4DisposeHandle(sampleH); + return err; +} + +ISOErr checkSamples(std::string strFile) +{ + ISOErr err; + ISOMovie moov; + ISOTrack trak; + ISOMedia media; + err = ISOOpenMovieFile(&moov, strFile.c_str(), MP4OpenMovieNormal); + + err = ISOGetMovieIndTrack(moov, 1, &trak); + err = ISOGetTrackMedia(trak, &media); + u32 sampleCnt = 0; + u32 colorEntryCount = 0; + u32 *sampleNumbers; + u32 groupIdRed = 0; + u32 groupIdBlue = 0; + u32 groupIdGreen = 0; + u32 groupIdYellow = 0; + + // parse the entries of the COLOR type and get the indexes + err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); + if(err) return err; + if(colorEntryCount != 4) return -1; + for(u32 n=0; n + +namespace HEVC +{ + u8 VPS[] = {0x40, 0x01, 0x0C, 0x01, 0xFF, 0xFF, 0x04, 0x08, 0x00, 0x00, 0x03, 0x00, + 0x9F, 0xA8, 0x00, 0x00, 0x03, 0x00, 0x00, 0x1E, 0xBA, 0x02, 0x40}; + + u8 SPS[] = {0x42, 0x01, 0x01, 0x04, 0x08, 0x00, 0x00, 0x03, 0x00, 0x9F, 0xA8, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x1E, 0xA0, 0x20, 0x83, 0x16, 0x5B, 0xAB, 0x93, 0x2B, 0x9A, + 0x02, 0x00, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x32, 0x10}; + + u8 PPS[] = {0x44, 0x01, 0xC1, 0x73, 0xC0, 0x89}; + + u8 auRed[] = {0x00, 0x00, 0x00, 0x16, 0x28, 0x01, 0xAF, 0x78, 0xF7, 0x04, 0x03, 0xFF, 0xDB, + 0xA3, 0xFF, 0xED, 0x27, 0xD2, 0xF6, 0xC3, 0x94, 0x40, 0x83, 0xC0, 0x00, 0x78}; + + u8 auBlue[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3F, + 0x9C, 0x43, 0xFF, 0xFA, 0x87, 0x32, 0xAF, 0xFC, 0x5D, 0xFF, + 0xFF, 0xAE, 0x1D, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; + + u8 auGreen[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3F, + 0x9C, 0x43, 0xFF, 0xF5, 0x9F, 0x1F, 0xFF, 0xD8, 0x3B, 0xFF, + 0xFD, 0xF0, 0xF5, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; + + u8 auYellow[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xA0, 0x3F, + 0x9C, 0x43, 0x3C, 0xFA, 0x51, 0x1D, 0xFF, 0xFC, 0x5D, 0xFE, + 0xCB, 0xAE, 0x1D, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; + + u8 auWhite[] = {0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, + 0xE7, 0x9F, 0x6C, 0x07, 0x79, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87}; + + u8 auBlack[] = {0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, + 0xFF, 0xFF, 0x72, 0xCA, 0x19, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87}; +} // namespace HEVC diff --git a/test/test_fragment_creation.cpp b/test/test_fragment_creation.cpp deleted file mode 100644 index 2b45a53..0000000 --- a/test/test_fragment_creation.cpp +++ /dev/null @@ -1,322 +0,0 @@ -/* -This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. -ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware -or software products claiming conformance to MPEG-4. -Those intending to use this software module in hardware or software -products are advised that its use may infringe existing patents. -The original developer of this software module and his/her company, -the subsequent editors and their companies, and ISO/IEC have no -liability for use of this software module or modifications thereof -in an implementation. -Copyright is not released for non MPEG-4 conforming -products. Apple Computer, Inc. retains full right to use the code for its own -purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non -MPEG-4 conforming products. -This copyright notice must be included in all copies or -derivative works. Copyright (c) 1999. -*/ - -#include -#include -#include -#include -#include -#include "libmd5/MD5.h" - -// TODO: move code from playground to this test after finishing all features - -extern "C" { -MP4_EXTERN(MP4Err) -ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, u32 length_size, - MP4Handle first_sps, MP4Handle first_pps, - MP4Handle first_spsext); -} - -// TODO: after reading the sample data check the md5 to ensure that samples are correct -libmd5::MD5 g_md5; - - -/* AAC encoding of a 234.375 Hz stereo tone */ -u8 aacDecoderSpecificInfo[] = {0x11, 0x80, 0x08, 0xc4, 0x00, 0x00, - 0x20, 0x00, 0x00, 0x00, 0x00, 0x00}; -u8 aacAccessUnit[] = {0x21, 0x09, 0x49, 0x00, 0x00, 0x00, 0x00, 0x29, 0xc0, 0x56, 0x10, 0xf8, 0xc3, - 0x8e, 0x9f, 0x84, 0x3b, 0xe0, 0x7c, 0xc3, 0x80, 0x00, 0x00, 0x00, 0x00}; - -u8 VPS[] = {0x40, 0x01, 0x0C, 0x01, 0xFF, 0xFF, 0x04, 0x08, 0x00, 0x00, 0x03, 0x00, - 0x9F, 0xA8, 0x00, 0x00, 0x03, 0x00, 0x00, 0x1E, 0xBA, 0x02, 0x40}; - -u8 SPS[] = {0x42, 0x01, 0x01, 0x04, 0x08, 0x00, 0x00, 0x03, 0x00, 0x9F, 0xA8, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x1E, 0xA0, 0x20, 0x83, 0x16, 0x5B, 0xAB, 0x93, 0x2B, 0x9A, - 0x02, 0x00, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x32, 0x10}; - -u8 PPS[] = {0x44, 0x01, 0xC1, 0x73, 0xC0, 0x89}; - -u8 auRed[] = {0x00, 0x00, 0x00, 0x16, 0x28, 0x01, 0xAF, 0x78, 0xF7, 0x04, 0x03, 0xFF, 0xDB, - 0xA3, 0xFF, 0xED, 0x27, 0xD2, 0xF6, 0xC3, 0x94, 0x40, 0x83, 0xC0, 0x00, 0x78}; - -u8 auBlue[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3F, - 0x9C, 0x43, 0xFF, 0xFA, 0x87, 0x32, 0xAF, 0xFC, 0x5D, 0xFF, - 0xFF, 0xAE, 0x1D, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; - -u8 auGreen[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3F, - 0x9C, 0x43, 0xFF, 0xF5, 0x9F, 0x1F, 0xFF, 0xD8, 0x3B, 0xFF, - 0xFD, 0xF0, 0xF5, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; - -u8 auYellow[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xA0, 0x3F, - 0x9C, 0x43, 0x3C, 0xFA, 0x51, 0x1D, 0xFF, 0xFC, 0x5D, 0xFE, - 0xCB, 0xAE, 0x1D, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; - -u8 auWhite[] = {0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, - 0xE7, 0x9F, 0x6C, 0x07, 0x79, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87}; - -u8 auBlack[] = {0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, - 0xFF, 0xFF, 0x72, 0xCA, 0x19, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87}; - -u32 frameCount = 1; -u32 samplesizefieldsize = 32; -u32 samplesperchunk = 24; - -MP4Err addMySamples(MP4Track theTrack, MP4Media theMedia, u32 do_init); -MP4Err getDecoderSpecificInfo(MP4Handle sampleH); -MP4Err getNextAudioFrame(MP4Handle sampleH); - -TEST_CASE("Fragment creation") -{ - MP4Err err; - MP4Movie moov; - MP4Track trak; - MP4Media media; - u8 OD_profileAndLevel; - u8 scene_profileAndLevel; - u8 audio_profileAndLevel; - u8 visual_profileAndLevel; - u8 graphics_profileAndLevel; - u32 initialObjectDescriptorID; - u32 timeScale; - u64 mediaDuration; - MP4Handle rap_desc; - u32 rap_desc_index; - u32 frameCounter; - - MP4NewHandle(1, &rap_desc); /* Allocate one byte for rap */ - err = MP4NoErr; - initialObjectDescriptorID = 1; - OD_profileAndLevel = 0xff; /* none required */ - scene_profileAndLevel = 0xff; /* none required */ - audio_profileAndLevel = 0x01; /* main profile L1 */ - visual_profileAndLevel = 0xff; /* none required */ - graphics_profileAndLevel = 0xff; /* none required */ - timeScale = 48000; /* sampling frequency */ - err = MP4NewMovie(&moov, initialObjectDescriptorID, OD_profileAndLevel, scene_profileAndLevel, - audio_profileAndLevel, visual_profileAndLevel, graphics_profileAndLevel); - CHECK(err == MP4NoErr); - - err = ISOSetMovieTimeScale(moov, 48000); - CHECK(err == MP4NoErr); - - err = MP4NewMovieTrack(moov, MP4NewTrackIsAudio, &trak); - CHECK(err == MP4NoErr); - - if(initialObjectDescriptorID != 0) - { - err = MP4AddTrackToMovieIOD(trak); - CHECK(err == MP4NoErr); - } - - err = MP4NewTrackMedia(trak, &media, MP4AudioHandlerType, timeScale, NULL); - CHECK(err == MP4NoErr); - err = ISOSetSampleSizeField(media, samplesizefieldsize); - CHECK(err == MP4NoErr); - err = MP4BeginMediaEdits(media); - CHECK(err == MP4NoErr); - - err = ISOSetTrackFragmentDefaults(trak, 1024, sizeof(aacAccessUnit), 1, 0); - CHECK(err == MP4NoErr); - - err = addMySamples(trak, media, 1); - - err = MP4EndMediaEdits(media); - CHECK(err == MP4NoErr); - - err = MP4GetMediaDuration(media, &mediaDuration); - CHECK(err == MP4NoErr); - - err = MP4InsertMediaIntoTrack(trak, 0, 0, mediaDuration, 1); - CHECK(err == MP4NoErr); - - err = ISOStartMovieFragment(moov); - CHECK(err == MP4NoErr); - frameCount = 1; - err = addMySamples(trak, media, 0); - CHECK(err == MP4NoErr); - - ISOAddGroupDescription(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc, &rap_desc_index); - for(frameCounter = 1; frameCounter < samplesperchunk; frameCounter++) - { - /* Mark RAP frames (CRA/BLA/IDR/IRAP) to the group */ - if(frameCounter % 4 == 0) - { - ISOMapSamplestoGroup(media, MP4_FOUR_CHAR_CODE('r', 'a', 'p', ' '), rap_desc_index, - frameCounter - 1, 1); - } - } - - err = MP4WriteMovieToFile(moov, "test_fragments.mp4"); - CHECK(err == MP4NoErr); -} - -MP4Err addMySamples(MP4Track trak, MP4Media media, u32 do_init) -{ - MP4Err err; - MP4Handle sampleEntryH; - MP4Handle sampleDataH; - MP4Handle sampleDurationH; - MP4Handle sampleSizeH; - MP4Handle decoderSpecificInfoH; - u32 objectTypeIndication; - u32 streamType; - u32 decoderBufferSize; - u32 maxBitrate; - u32 avgBitrate; - u32 done = 0; - u32 fileoffset = 0; - u32 i; - MP4Handle pad_bits, depsH; - - err = MP4NoErr; - if(do_init) - { - err = MP4SetMediaLanguage(media, (char*)"und"); - if(err) goto bail; - - objectTypeIndication = 0x40; /* mpeg-4 audio */ - streamType = 0x05; /* audio stream */ - decoderBufferSize = 2 * 6144; /* stereo */ - maxBitrate = 128000; - avgBitrate = 128000; - err = MP4NewHandle(0, &decoderSpecificInfoH); - if(err) goto bail; - err = getDecoderSpecificInfo(decoderSpecificInfoH); - if(err) goto bail; - - err = MP4NewHandle(0, &sampleEntryH); - if(err) goto bail; - err = MP4NewSampleDescription(trak, sampleEntryH, 1, objectTypeIndication, streamType, - decoderBufferSize, maxBitrate, avgBitrate, decoderSpecificInfoH); - if(err) goto bail; - } - else - sampleEntryH = NULL; - - err = MP4NewHandle(samplesperchunk * sizeof(u32), &sampleDurationH); - if(err) goto bail; - err = MP4NewHandle(0, &sampleDataH); - if(err) goto bail; - err = MP4NewHandle(samplesperchunk * sizeof(u32), &sampleSizeH); - if(err) goto bail; - err = MP4NewHandle(1, &pad_bits); - if(err) goto bail; - err = MP4NewHandle(samplesperchunk, &depsH); - if(err) goto bail; - *((u8 *)(*pad_bits)) = 0; - for(i = 0; i < samplesperchunk; i++) - ((u8 *)*depsH)[i] = does_not_depend_on | is_not_depended_on | has_no_redundancy; - - while(!done) - { - u32 frames, sizesofar, i, chunksize, samplesize; - - frames = 0; - err = MP4SetHandleOffset(sampleDataH, 0); - chunksize = 0; - - for(i = 0; i < samplesperchunk; i++) - { - err = getNextAudioFrame(sampleDataH); - if(err) - { - if(err == MP4EOF) - { - err = 0; - done = 1; - break; - } - } - else - { - frames++; - err = MP4GetHandleSize(sampleDataH, &samplesize); - if(err) goto bail; - chunksize += samplesize; - err = MP4SetHandleOffset(sampleDataH, chunksize); - if(err) goto bail; - ((u32 *)*sampleDurationH)[i] = 1024; /* AAC block length */ - ((u32 *)*sampleSizeH)[i] = samplesize; - } - } - if(frames > 0) - { - err = MP4SetHandleOffset(sampleDataH, 0); - err = MP4AddMediaSamples(media, sampleDataH, frames, sampleDurationH, sampleSizeH, - sampleEntryH, NULL, NULL); - if(err) goto bail; - - if(sampleEntryH) - { - err = MP4DisposeHandle(sampleEntryH); - if(err) goto bail; - sampleEntryH = NULL; - } - } - } -bail: - return err; -} - -MP4Err getDecoderSpecificInfo(MP4Handle decoderSpecificInfoH) -{ - MP4Err err; - u8 *p; - u32 i, frameLength; - - err = MP4NoErr; - if((frameLength = sizeof(aacDecoderSpecificInfo)) >= 128) - { - err = MP4BadParamErr; - goto bail; - } - err = MP4SetHandleSize(decoderSpecificInfoH, frameLength + 2); - if(err) goto bail; - p = (u8 *)*decoderSpecificInfoH; - *p++ = 0x05; /* DecSpecificInfoTag, 14496-1, Sec 8.2.2.2, Table 1*/ - *p++ = frameLength; /* sizeOfInstance, 14496-1, Sec 12.3.3 */ - for(i = 0; i < frameLength; i++) - *p++ = aacDecoderSpecificInfo[i]; -bail: - return err; -} - -MP4Err getNextAudioFrame(MP4Handle sampleH) -{ - MP4Err err; - u8 *p; - u32 i, frameLength; - - err = MP4NoErr; - if(frameCount++ > 48) /* one second of sine wave signal */ - return MP4EOF; - frameLength = sizeof(aacAccessUnit); - err = MP4SetHandleSize(sampleH, frameLength); - if(err) goto bail; - p = (u8 *)*sampleH; - for(i = 0; i < frameLength; i++) - *p++ = aacAccessUnit[i]; -bail: - return err; -} \ No newline at end of file diff --git a/test/test_sample_groups.cpp b/test/test_sample_groups.cpp new file mode 100644 index 0000000..dec9dba --- /dev/null +++ b/test/test_sample_groups.cpp @@ -0,0 +1,550 @@ +/** + * @file test_sample_groups.cpp + * @author Dimitri Podborski + * @brief Perform checks on sample groups, in movie and movie fragments, defragmentation, changning + * the sample group mapping types etc. + * @version 0.1 + * @date 2020-11-20 + * + * @copyright This software module was originally developed by Apple Computer, Inc. in the course of + * development of MPEG-4. This software module is an implementation of a part of one or more MPEG-4 + * tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this software module + * or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. + * Those intending to use this software module in hardware or software products are advised that its + * use may infringe existing patents. The original developer of this software module and his/her + * company, the subsequent editors and their companies, and ISO/IEC have no liability for use of + * this software module or modifications thereof in an implementation. Copyright is not released for + * non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its + * own purpose, assign or donate the code to a third party and to inhibit third parties from using + * the code for non MPEG-4 conforming products. This copyright notice must be included in all copies + * or derivative works. Copyright (c) 1999. + * + */ + +#include +#include +#include +#include +#include +#include "test_data.h" + +extern "C" +{ + MP4_EXTERN(MP4Err) + ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps, + MP4Handle first_pps, MP4Handle first_spsext); +} + +const u32 TIMESCALE = 30000; +const u32 FPS = 30; + +const u32 FOURCC_COLOR = MP4_FOUR_CHAR_CODE('c', 'o', 'l', 'r'); +const u32 FOURCC_TEST = MP4_FOUR_CHAR_CODE('t', 'e', 's', 't'); + +/** + * @brief Helper function to add group description with the payload of a given string + * + * @param media media to add the description to + * @param fcc grouping_type + * @param strDescription Playload string + * @param [out] idx Index of the group entry + * @return ISOErr error code + */ +ISOErr addGroupDescription(MP4Media media, u32 fcc, std::string strDescription, u32 &idx) +{ + ISOErr err; + ISOHandle descrH; + ISONewHandle(strDescription.length() * sizeof(char), &descrH); + std::memcpy(*descrH, strDescription.data(), strDescription.length() * sizeof(char)); + + err = ISOAddGroupDescription(media, fcc, descrH, &idx); + + ISODisposeHandle(descrH); + return err; +} + +/** + * @brief Helper function to add samples given the color pattern + * + * @param media media to add the sample to + * @param strPattern color pattern of samples (r,b,g,y,w,k) + * @param repeatPattern number of times to repeat the pattern. No samples are added if this is 0 + * @param sampleEntryH sample entry handle (for the first call) + * @return ISOErr error code + */ +ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, ISOHandle sampleEntryH = 0) +{ + ISOErr err; + u32 sampleCount = 0; + ISOHandle sampleDataH, durationsH, sizesH; + err = ISONewHandle(sizeof(u32), &durationsH); + CHECK(err == ISONoErr); + + *((u32 *)*durationsH) = TIMESCALE / FPS; + + std::vector bufferData; + std::vector bufferSizes; + for(std::string::const_iterator it = strPattern.cbegin(); it != strPattern.cend(); ++it) + { + switch(*it) + { + case 'r': + bufferData.insert(bufferData.end(), HEVC::auRed, HEVC::auRed + sizeof(HEVC::auRed)); + bufferSizes.push_back(sizeof(HEVC::auRed)); + break; + case 'b': + bufferData.insert(bufferData.end(), HEVC::auBlue, HEVC::auBlue + sizeof(HEVC::auBlue)); + bufferSizes.push_back(sizeof(HEVC::auBlue)); + break; + case 'g': + bufferData.insert(bufferData.end(), HEVC::auGreen, HEVC::auGreen + sizeof(HEVC::auGreen)); + bufferSizes.push_back(sizeof(HEVC::auGreen)); + break; + case 'y': + bufferData.insert(bufferData.end(), HEVC::auYellow, HEVC::auYellow + sizeof(HEVC::auYellow)); + bufferSizes.push_back(sizeof(HEVC::auYellow)); + break; + case 'w': + bufferData.insert(bufferData.end(), HEVC::auWhite, HEVC::auWhite + sizeof(HEVC::auWhite)); + bufferSizes.push_back(sizeof(HEVC::auWhite)); + break; + case 'k': + bufferData.insert(bufferData.end(), HEVC::auBlack, HEVC::auBlack + sizeof(HEVC::auBlack)); + bufferSizes.push_back(sizeof(HEVC::auBlack)); + break; + default: + break; + } + } + + // repeat pattern + std::vector bufferDataPattern = bufferData; + std::vector bufferSizesPattern = bufferSizes; + std::string fullPattern = strPattern; + for(u32 n = 1; n < repeatPattern; ++n) + { + bufferData.insert(bufferData.end(), bufferDataPattern.begin(), bufferDataPattern.end()); + bufferSizes.insert(bufferSizes.end(), bufferSizesPattern.begin(), bufferSizesPattern.end()); + fullPattern += strPattern; + } + + // create handles and copy data + err = ISONewHandle(bufferData.size() * sizeof(u8), &sampleDataH); + CHECK(err == ISONoErr); + std::memcpy((*sampleDataH), bufferData.data(), bufferData.size() * sizeof(u8)); + err = ISONewHandle(sizeof(u32) * bufferSizes.size(), &sizesH); + CHECK(err == ISONoErr); + for(u32 n = 0; n < bufferSizes.size(); n++) + { + ((u32 *)*sizesH)[n] = bufferSizes[n]; + } + + err = ISOAddMediaSamples(media, sampleDataH, bufferSizesPattern.size() * repeatPattern, + durationsH, sizesH, sampleEntryH, 0, 0); + CHECK(err == ISONoErr); + + err = ISODisposeHandle(sampleDataH); + CHECK(err == ISONoErr); + err = ISODisposeHandle(durationsH); + CHECK(err == ISONoErr); + err = ISODisposeHandle(sizesH); + CHECK(err == ISONoErr); + return err; +} + +/** + * @brief Helper function to map samples to groups based on pattern + * + * @param media media to map sample in + * @param strPattern color pattern same as used in addSamples + * @param idRed The index of the Red entry in the COLOR group + * @param idBlue The index of the Blue entry in the COLOR group + * @param idGreen The index of the Green entry in the COLOR group + * @param idYellow The index of the Yellow entry in the COLOR group + * @param repeatPattern number of times to repeat the pattern. No samples are mapped if this is 0 + * @return ISOErr error code + */ +ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 idRed, u32 idBlue, u32 idGreen, u32 idYellow, u32 repeatPattern = 1) +{ + ISOErr err = ISONoErr; + std::string fullPattern = strPattern; + for(u32 n = 1; n < repeatPattern; ++n) + { + fullPattern += strPattern; + } + + // map samples to groups + if(repeatPattern > 0) + { + for(u32 n = 0; n < fullPattern.size(); ++n) + { + switch(fullPattern[n]) + { + case 'r': + err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idRed, n, 1); + CHECK(err == ISONoErr); + break; + case 'b': + err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idBlue, n, 1); + CHECK(err == ISONoErr); + break; + case 'g': + err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idGreen, n, 1); + CHECK(err == ISONoErr); + break; + case 'y': + err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idYellow, n, 1); + CHECK(err == ISONoErr); + break; + default: + break; + } + } + } + return err; +} + +/** + * @brief Helper function to check a single sample payload + * + * @param media media to take a sample from + * @param sampleNr sample number in that media + * @param comparePtr pointer to data to compare out payload to + * @param compareSize size of the compare data + * @return ISOErr error code + */ +ISOErr checkSample(MP4Media media, u32 sampleNr, u8 *comparePtr, u32 compareSize) +{ + ISOErr err; + MP4Handle sampleH; + u32 outSize, outSampleFlags, outSampleDescIndex; + u64 outDTS, outDuration; + s32 outCTSOffset; + + MP4NewHandle(0, &sampleH); + err = MP4GetIndMediaSample(media, sampleNr, sampleH, &outSize, &outDTS, &outCTSOffset, &outDuration, &outSampleFlags, &outSampleDescIndex); + CHECK(err == ISONoErr); + + u32 handleSize; + MP4GetHandleSize(sampleH, &handleSize); + if(handleSize != outSize) return -1; + if(outSize != compareSize) return -1; + + int compareVal = std::memcmp(comparePtr, *sampleH, compareSize); + if(compareVal != 0) return -1; + + MP4DisposeHandle(sampleH); + return err; +} + +/** + * @brief Helper function to check all samples in the given file + * + * @param strFile input file to check + * @return ISOErr error code + */ +ISOErr checkSamples(std::string strFile) +{ + ISOErr err; + ISOMovie moov; + ISOTrack trak; + ISOMedia media; + err = ISOOpenMovieFile(&moov, strFile.c_str(), MP4OpenMovieNormal); + + err = ISOGetMovieIndTrack(moov, 1, &trak); + err = ISOGetTrackMedia(trak, &media); + u32 sampleCnt = 0; + u32 colorEntryCount = 0; + u32 *sampleNumbers; + u32 groupIdRed = 0; + u32 groupIdBlue = 0; + u32 groupIdGreen = 0; + u32 groupIdYellow = 0; + + // parse the entries of the COLOR type and get the indexes + err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); + CHECK(err == ISONoErr); + if(colorEntryCount != 4) return -1; + for(u32 n=0; n Date: Fri, 20 Nov 2020 20:23:43 +0100 Subject: [PATCH 37/55] cleanup --- CMakeLists.txt | 2 - IsoLib/playground/CMakeLists.txt | 19 -- IsoLib/playground/main.cpp | 508 ------------------------------- test/test_01_simple.cpp | 43 ++- test/test_metadata.cpp | 43 ++- 5 files changed, 42 insertions(+), 573 deletions(-) delete mode 100644 IsoLib/playground/CMakeLists.txt delete mode 100644 IsoLib/playground/main.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 5503d15..a5fbacd 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -38,5 +38,3 @@ add_subdirectory(IsoLib/ipmp_example) add_subdirectory(IsoLib/isoiff_tool) add_subdirectory(IsoLib/pcm_audio_example) add_subdirectory(test) - -add_subdirectory(IsoLib/playground) diff --git a/IsoLib/playground/CMakeLists.txt b/IsoLib/playground/CMakeLists.txt deleted file mode 100644 index bd572a5..0000000 --- a/IsoLib/playground/CMakeLists.txt +++ /dev/null @@ -1,19 +0,0 @@ -cmake_minimum_required(VERSION 3.9.2) - -project(playground) - -include_directories(../libisomediafile/src) -include_directories( - # Linux - $<$:${CMAKE_CURRENT_LIST_DIR}/../libisomediafile/linux> - - # Windows - $<$:${CMAKE_CURRENT_LIST_DIR}/../libisomediafile/w32> - - # Mac - $<$:${CMAKE_CURRENT_LIST_DIR}/../libisomediafile/macosx> -) - -add_executable(playground main.cpp) - -target_link_libraries(playground LINK_PUBLIC libisomediafile) diff --git a/IsoLib/playground/main.cpp b/IsoLib/playground/main.cpp deleted file mode 100644 index 7ce72ff..0000000 --- a/IsoLib/playground/main.cpp +++ /dev/null @@ -1,508 +0,0 @@ -/** - * @file main.cpp - * @author Dimitri Podborski - * @brief Writes a HEVC mp4 file with sample groups accoring to colour pattern - * @version 0.1 - * @date 2020-10-26 - * - * @copyright Copyright (c) 2020 - * - */ -#include -#include -#include -#include -#include -#include - -extern "C" -{ - MP4_EXTERN(MP4Err) - ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps, - MP4Handle first_pps, MP4Handle first_spsext); -} - -u8 VPS[] = {0x40, 0x01, 0x0C, 0x01, 0xFF, 0xFF, 0x04, 0x08, 0x00, 0x00, 0x03, 0x00, - 0x9F, 0xA8, 0x00, 0x00, 0x03, 0x00, 0x00, 0x1E, 0xBA, 0x02, 0x40}; - -u8 SPS[] = {0x42, 0x01, 0x01, 0x04, 0x08, 0x00, 0x00, 0x03, 0x00, 0x9F, 0xA8, 0x00, 0x00, - 0x03, 0x00, 0x00, 0x1E, 0xA0, 0x20, 0x83, 0x16, 0x5B, 0xAB, 0x93, 0x2B, 0x9A, - 0x02, 0x00, 0x00, 0x03, 0x00, 0x02, 0x00, 0x00, 0x03, 0x00, 0x32, 0x10}; - -u8 PPS[] = {0x44, 0x01, 0xC1, 0x73, 0xC0, 0x89}; - -u8 auRed[] = {0x00, 0x00, 0x00, 0x16, 0x28, 0x01, 0xAF, 0x78, 0xF7, 0x04, 0x03, 0xFF, 0xDB, - 0xA3, 0xFF, 0xED, 0x27, 0xD2, 0xF6, 0xC3, 0x94, 0x40, 0x83, 0xC0, 0x00, 0x78}; - -u8 auBlue[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3F, - 0x9C, 0x43, 0xFF, 0xFA, 0x87, 0x32, 0xAF, 0xFC, 0x5D, 0xFF, - 0xFF, 0xAE, 0x1D, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; - -u8 auGreen[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3F, - 0x9C, 0x43, 0xFF, 0xF5, 0x9F, 0x1F, 0xFF, 0xD8, 0x3B, 0xFF, - 0xFD, 0xF0, 0xF5, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; - -u8 auYellow[] = {0x00, 0x00, 0x00, 0x1A, 0x28, 0x01, 0xAF, 0x0A, 0xA0, 0x3F, - 0x9C, 0x43, 0x3C, 0xFA, 0x51, 0x1D, 0xFF, 0xFC, 0x5D, 0xFE, - 0xCB, 0xAE, 0x1D, 0xB9, 0xA2, 0xB4, 0xBC, 0x6D, 0x84, 0x5F}; - -u8 auWhite[] = {0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, - 0xE7, 0x9F, 0x6C, 0x07, 0x79, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87}; - -u8 auBlack[] = {0x00, 0x00, 0x00, 0x13, 0x28, 0x01, 0xAF, 0x0A, 0xE0, 0x3C, 0x64, 0x00, - 0xFF, 0xFF, 0x72, 0xCA, 0x19, 0x0D, 0x1B, 0xFD, 0x7D, 0x7C, 0x87}; - -const u32 TIMESCALE = 30000; -const u32 FPS = 30; - -const u32 FOURCC_COLOR = MP4_FOUR_CHAR_CODE('c', 'o', 'l', 'r'); -const u32 FOURCC_TEST = MP4_FOUR_CHAR_CODE('t', 'e', 's', 't'); - -ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, - ISOHandle sampleEntryH = 0) -{ - ISOErr err; - u32 sampleCount = 0; - ISOHandle sampleDataH, durationsH, sizesH; - err = ISONewHandle(sizeof(u32), &durationsH); - if(err) return err; - - *((u32 *)*durationsH) = TIMESCALE / FPS; - - std::vector bufferData; - std::vector bufferSizes; - for(std::string::const_iterator it = strPattern.cbegin(); it != strPattern.cend(); ++it) - { - switch(*it) - { - case 'r': - bufferData.insert(bufferData.end(), auRed, auRed + sizeof(auRed)); - bufferSizes.push_back(sizeof(auRed)); - break; - case 'b': - bufferData.insert(bufferData.end(), auBlue, auBlue + sizeof(auBlue)); - bufferSizes.push_back(sizeof(auBlue)); - break; - case 'g': - bufferData.insert(bufferData.end(), auGreen, auGreen + sizeof(auGreen)); - bufferSizes.push_back(sizeof(auGreen)); - break; - case 'y': - bufferData.insert(bufferData.end(), auYellow, auYellow + sizeof(auYellow)); - bufferSizes.push_back(sizeof(auYellow)); - break; - case 'w': - bufferData.insert(bufferData.end(), auWhite, auWhite + sizeof(auWhite)); - bufferSizes.push_back(sizeof(auWhite)); - break; - case 'k': - bufferData.insert(bufferData.end(), auBlack, auBlack + sizeof(auBlack)); - bufferSizes.push_back(sizeof(auBlack)); - break; - default: - break; - } - } - - // repeat pattern - std::vector bufferDataPattern = bufferData; - std::vector bufferSizesPattern = bufferSizes; - std::string fullPattern = strPattern; - for(u32 n = 1; n < repeatPattern; ++n) - { - bufferData.insert(bufferData.end(), bufferDataPattern.begin(), bufferDataPattern.end()); - bufferSizes.insert(bufferSizes.end(), bufferSizesPattern.begin(), bufferSizesPattern.end()); - fullPattern += strPattern; - } - - // create handles and copy data - err = ISONewHandle(bufferData.size() * sizeof(u8), &sampleDataH); - if(err) return err; - std::memcpy((*sampleDataH), bufferData.data(), bufferData.size() * sizeof(u8)); - err = ISONewHandle(sizeof(u32) * bufferSizes.size(), &sizesH); - if(err) return err; - for(u32 n = 0; n < bufferSizes.size(); n++) - { - ((u32 *)*sizesH)[n] = bufferSizes[n]; - } - - err = ISOAddMediaSamples(media, sampleDataH, bufferSizesPattern.size() * repeatPattern, - durationsH, sizesH, sampleEntryH, 0, 0); - if(err) return err; - - err = ISODisposeHandle(sampleDataH); - if(err) return err; - err = ISODisposeHandle(durationsH); - if(err) return err; - err = ISODisposeHandle(sizesH); - if(err) return err; - return err; -} - -ISOErr addGroupDescription(MP4Media media, u32 fcc, std::string strDescription, u32 &idx) -{ - ISOErr err; - ISOHandle descrH; - ISONewHandle(strDescription.length() * sizeof(char), &descrH); - std::memcpy(*descrH, strDescription.data(), strDescription.length() * sizeof(char)); - - err = ISOAddGroupDescription(media, fcc, descrH, &idx); - - ISODisposeHandle(descrH); - return err; -} - -ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 idRed, u32 idBlue, u32 idGreen, u32 idYellow, u32 repeatPattern = 1) -{ - ISOErr err = ISONoErr; - std::string fullPattern = strPattern; - for(u32 n = 1; n < repeatPattern; ++n) - { - fullPattern += strPattern; - } - - // map samples to groups - if(repeatPattern > 0) - { - for(u32 n = 0; n < fullPattern.size(); ++n) - { - switch(fullPattern[n]) - { - case 'r': - err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idRed, n, 1); - if(err) return err; - break; - case 'b': - err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idBlue, n, 1); - if(err) return err; - break; - case 'g': - err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idGreen, n, 1); - if(err) return err; - break; - case 'y': - err = ISOMapSamplestoGroup(media, FOURCC_COLOR, idYellow, n, 1); - if(err) return err; - break; - default: - break; - } - } - } - return err; -} - -/** - * @brief Create a Fragmented File with different sample groups for testing - * - * Moovie: Global group description for COLOR RED and BLUE in stbl - * - * Fragment 1: local group description COLOR RED (not used) - * local group description TEST with 2 entries - * Fragment 2: local group description COLOR GREEN and YELLOW (both used in COMPACT sampleToGroupBox) - * local group description TEST with 2 entries (one of these entries is the same as in Fragment 1) - * Fragment 3: no group description - * Fragment 4: local group descrition COLOR GREEN and YELLOW (both used in NORMAL sampleToGroupBox) - * Fragment 5: no group description - * - * Samples: red (r), blue(b), green (g), yellow (y), white (w), black (k) - * | frag. 1 | frag. 2 | frag. 3 | frag. 4 | - * |r|b|r|b|r|b|g|r|y|g|r|y|b|g|y|b|g|y|w|k|w|k|w|k| - * - * @param strFilename output filename - * @return ISOErr error code - */ -ISOErr createFragmentedFile(std::string strFilename) -{ - ISOErr err; - ISOMovie moov; - ISOMedia media; - ISOTrack trak; - - u32 colorEntryCount = 0; - u32 groupIdRed = 0; - u32 groupIdBlue = 0; - u32 groupIdGreen = 0; - u32 groupIdYellow = 0; - - ISOHandle spsHandle, ppsHandle, vpsHandle, sampleEntryH; - err = MP4NewHandle(sizeof(SPS), &spsHandle); - std::memcpy((*spsHandle), SPS, sizeof(SPS)); - err = MP4NewHandle(sizeof(PPS), &ppsHandle); - std::memcpy((*ppsHandle), PPS, sizeof(PPS)); - err = MP4NewHandle(sizeof(VPS), &vpsHandle); - std::memcpy((*vpsHandle), VPS, sizeof(VPS)); - err = MP4NewHandle(0, &sampleEntryH); - - err = MP4NewMovie(&moov, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff); - if(err) return err; - - err = ISONewMovieTrack(moov, MP4NewTrackIsVisual, &trak); - if(err) return err; - err = MP4AddTrackToMovieIOD(trak); - if(err) return err; - err = ISONewTrackMedia(trak, &media, ISOVisualHandlerType, TIMESCALE, NULL); - if(err) return err; - - err = ISOBeginMediaEdits(media); - err = ISONewHEVCSampleDescription(trak, sampleEntryH, 1, 1, spsHandle, ppsHandle, vpsHandle); - if(err) return -4; - - err = ISOSetTrackFragmentDefaults(trak, TIMESCALE / FPS, sizeof(auBlue), 1, 0); - - err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); - if(err == MP4NoErr) return -1; - if(colorEntryCount != 0) return -1; - // red and blue are in stbl - err = addGroupDescription(media, FOURCC_COLOR, "Red frames", groupIdRed); if(err) return err; - err = addGroupDescription(media, FOURCC_COLOR, "Blue frames", groupIdBlue); if(err) return err; - - err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); - if(err) return err; - if(colorEntryCount != 2) return -1; - - u32 temp = 0; - err = addGroupDescription(media, FOURCC_COLOR, "Red frames", temp); - if(err == MP4NoErr) - return -5; // this must fail because "Red frames" payload is already added with the same type - - // just add sample entry, call addSamples with sample count = 0 - err = addSamples(media, "r", 0, sampleEntryH); - if(err) return err; - err = MP4EndMediaEdits(media); - - // Fragment 1 - err = ISOStartMovieFragment(moov); - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); - if(err) return err; - err = addSamples(media, "rb", 3); - if(err) return err; - colorEntryCount = 0; - err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); - if(err == MP4NoErr) return -1; // there sould be no entries in this fragment yet - if(colorEntryCount != 0) return -1; - err = addGroupDescription(media, FOURCC_TEST, "Duplicate test", temp); - if(err) return err; - err = addGroupDescription(media, FOURCC_COLOR, "Red frames", temp); - if(err) return err; // this must pass even if the same type and payload is in stbl - // (but it shall not be in defragmented file) - err = addGroupDescription(media, FOURCC_TEST, "Test", temp); - if(err) return err; - err = addGroupDescription(media, FOURCC_TEST, "Test", temp); - if(!err) return -5; // this must fail because same type and payload already added - err = mapSamplesToGroups(media, "rb", groupIdRed, groupIdBlue, groupIdGreen, groupIdYellow, 3); - if(err) return err; - - err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); - if(err) return err; // there should be now exactly one entry - if(colorEntryCount != 1) return -1; - - // Fragment 2 - err = ISOStartMovieFragment(moov); - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_COMPACT); - // local green and yellow groups - err = addGroupDescription(media, FOURCC_COLOR, "Green frames", groupIdGreen); if(err) return err; - err = addGroupDescription(media, FOURCC_COLOR, "Yellow frames", groupIdYellow); if(err) return err; - err = addSamples(media, "gry", 2); - if(err) return err; - err = addGroupDescription(media, FOURCC_TEST, "Unique entry", - temp); - if(err) return err; - err = addGroupDescription(media, FOURCC_TEST, "Duplicate test", temp); - if(err) return err; - err = mapSamplesToGroups(media, "gry", groupIdRed, groupIdBlue, groupIdGreen, groupIdYellow, 2); - if(err) return err; - - // Fragment 3 - err = ISOStartMovieFragment(moov); - if(err) return err; - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); - err = addSamples(media, "wk", 3); - if(err) return err; - - // Fragment 4 - err = ISOStartMovieFragment(moov); - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); - // local green and yellow groups - err = addGroupDescription(media, FOURCC_COLOR, "Green frames", groupIdGreen); if(err) return err; - err = addGroupDescription(media, FOURCC_COLOR, "Yellow frames", groupIdYellow); if(err) return err; - err = addSamples(media, "bgy", 2); - if(err) return err; - err = mapSamplesToGroups(media, "bgy", groupIdRed, groupIdBlue, groupIdGreen, groupIdYellow, 2); - if(err) return err; - - // Fragment 5 - err = ISOStartMovieFragment(moov); - if(err) return err; - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); - err = addSamples(media, "wk", 3); - if(err) return err; - - err = MP4WriteMovieToFile(moov, strFilename.c_str()); - return err; -} - -/** - * @brief Create different flavors of defragmented files from the fragmented file - * - * @param inputFrag Input fragmented file - * @param outputDefragNorm Defragmented file with NORMAL SampleToGroupBox - * @param outputDefragComp Defragmented file with COMPACT SampleToGroupBox - * @param outputDefragAuto Defragmented file with AUTO SampleToGroupBox (smaller size is used automatically) - * @return ISOErr - */ -ISOErr defragmentFile(std::string inputFrag, std::string outputDefragNorm, std::string outputDefragComp, std::string outputDefragAuto) -{ - ISOErr err; - ISOMovie moov; - ISOTrack trak; - ISOMedia media; - err = ISOOpenMovieFile(&moov, inputFrag.c_str(), MP4OpenMovieNormal); - if(err) return err; - - err = ISOGetMovieIndTrack(moov, 1, &trak); - if(err) return err; - err = ISOGetTrackMedia(trak, &media); - if(err) return err; - - // write file with compact sample groups - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_COMPACT); - err = MP4WriteMovieToFile(moov, outputDefragComp.c_str()); - if(err) return err; - - // write file with normal sample groups - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_NORMAL); - err = MP4WriteMovieToFile(moov, outputDefragNorm.c_str()); - if(err) return err; - - // write file with auto sample groups - ISOSetSamplestoGroupType(media, SAMPLE_GROUP_AUTO); - err = MP4WriteMovieToFile(moov, outputDefragAuto.c_str()); - return err; -} - -ISOErr checkSample(MP4Media media, u32 sampleNr, u8 *comparePtr, u32 compareSize) -{ - ISOErr err; - MP4Handle sampleH; - u32 outSize, outSampleFlags, outSampleDescIndex; - u64 outDTS, outDuration; - s32 outCTSOffset; - - MP4NewHandle(0, &sampleH); - err = MP4GetIndMediaSample(media, sampleNr, sampleH, &outSize, &outDTS, &outCTSOffset, &outDuration, &outSampleFlags, &outSampleDescIndex); - if(err) return err; - - u32 handleSize; - MP4GetHandleSize(sampleH, &handleSize); - if(handleSize != outSize) return -1; - if(outSize != compareSize) return -1; - - int compareVal = std::memcmp(comparePtr, *sampleH, compareSize); - if(compareVal != 0) return -1; - - MP4DisposeHandle(sampleH); - return err; -} - -ISOErr checkSamples(std::string strFile) -{ - ISOErr err; - ISOMovie moov; - ISOTrack trak; - ISOMedia media; - err = ISOOpenMovieFile(&moov, strFile.c_str(), MP4OpenMovieNormal); - - err = ISOGetMovieIndTrack(moov, 1, &trak); - err = ISOGetTrackMedia(trak, &media); - u32 sampleCnt = 0; - u32 colorEntryCount = 0; - u32 *sampleNumbers; - u32 groupIdRed = 0; - u32 groupIdBlue = 0; - u32 groupIdGreen = 0; - u32 groupIdYellow = 0; - - // parse the entries of the COLOR type and get the indexes - err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); - if(err) return err; - if(colorEntryCount != 4) return -1; - for(u32 n=0; n #include diff --git a/test/test_metadata.cpp b/test/test_metadata.cpp index 46da542..55e2c21 100644 --- a/test/test_metadata.cpp +++ b/test/test_metadata.cpp @@ -1,25 +1,24 @@ -/* -This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. -ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware -or software products claiming conformance to MPEG-4. -Those intending to use this software module in hardware or software -products are advised that its use may infringe existing patents. -The original developer of this software module and his/her company, -the subsequent editors and their companies, and ISO/IEC have no -liability for use of this software module or modifications thereof -in an implementation. -Copyright is not released for non MPEG-4 conforming -products. Apple Computer, Inc. retains full right to use the code for its own -purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non -MPEG-4 conforming products. -This copyright notice must be included in all copies or -derivative works. Copyright (c) 1999. -*/ +/** + * @file test_metadata.cpp + * @author Dimitri Podborski + * @brief Metadata testing + * @version 0.1 + * @date 2020-11-20 + * + * @copyright This software module was originally developed by Apple Computer, Inc. in the course of + * development of MPEG-4. This software module is an implementation of a part of one or more MPEG-4 + * tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this software module + * or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. + * Those intending to use this software module in hardware or software products are advised that its + * use may infringe existing patents. The original developer of this software module and his/her + * company, the subsequent editors and their companies, and ISO/IEC have no liability for use of + * this software module or modifications thereof in an implementation. Copyright is not released for + * non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its + * own purpose, assign or donate the code to a third party and to inhibit third parties from using + * the code for non MPEG-4 conforming products. This copyright notice must be included in all copies + * or derivative works. Copyright (c) 1999. + * + */ #include #include From 23d5da207d2f44f08187b9622eca636fb6e43ea7 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Fri, 20 Nov 2020 20:32:29 +0100 Subject: [PATCH 38/55] add header for memcmp and memcpy --- test/test_sample_groups.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/test/test_sample_groups.cpp b/test/test_sample_groups.cpp index dec9dba..b1b4d3a 100644 --- a/test/test_sample_groups.cpp +++ b/test/test_sample_groups.cpp @@ -26,6 +26,7 @@ #include #include #include +#include #include "test_data.h" extern "C" From ead7ab2f2a1c6bcc58daf1c4cbe76e0ebc7d31b9 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Mon, 30 Nov 2020 22:53:09 +0100 Subject: [PATCH 39/55] BugFix: local group description idex 0x10000 When inside a fragment the group_description_index is 0x10000 treat it as 0 (it should not be mapped) --- IsoLib/libisomediafile/src/TrackFragmentAtom.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index b2fd080..f6dd91b 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -625,14 +625,14 @@ static MP4Err mergeRuns(MP4TrackFragmentAtomPtr self, MP4MediaAtomPtr mdia) u32 group_description_index; position = j - total_samples; group_description_index = (theGroup->group_index)[j]; - if(group_description_index <= 0x10000) + if(group_description_index < 0x10000) { /* mapping to global indexes */ err = mdia->mapSamplestoGroup(mdia, theGroup->grouping_type, group_description_index, position, 1); if(err) goto bail; } - else + else if(group_description_index != 0x10000) { /* mapping local indexes to corrected global indexes */ MP4Handle descriptionEntry; From 737b7791834d3488232dac8cf778075a01217564 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Tue, 1 Dec 2020 13:25:33 +0100 Subject: [PATCH 40/55] Extend testcase, map single sample with index!=0 --- test/test_sample_groups.cpp | 166 +++++++++++++++++++++++------------- 1 file changed, 106 insertions(+), 60 deletions(-) diff --git a/test/test_sample_groups.cpp b/test/test_sample_groups.cpp index b1b4d3a..c5134eb 100644 --- a/test/test_sample_groups.cpp +++ b/test/test_sample_groups.cpp @@ -42,10 +42,11 @@ const u32 FPS = 30; const u32 FOURCC_COLOR = MP4_FOUR_CHAR_CODE('c', 'o', 'l', 'r'); const u32 FOURCC_TEST = MP4_FOUR_CHAR_CODE('t', 'e', 's', 't'); +const u32 FOURCC_BLACK = MP4_FOUR_CHAR_CODE('b', 'l', 'c', 'k'); /** * @brief Helper function to add group description with the payload of a given string - * + * * @param media media to add the description to * @param fcc grouping_type * @param strDescription Playload string @@ -67,14 +68,15 @@ ISOErr addGroupDescription(MP4Media media, u32 fcc, std::string strDescription, /** * @brief Helper function to add samples given the color pattern - * + * * @param media media to add the sample to * @param strPattern color pattern of samples (r,b,g,y,w,k) * @param repeatPattern number of times to repeat the pattern. No samples are added if this is 0 * @param sampleEntryH sample entry handle (for the first call) * @return ISOErr error code */ -ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, ISOHandle sampleEntryH = 0) +ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, + ISOHandle sampleEntryH = 0) { ISOErr err; u32 sampleCount = 0; @@ -156,7 +158,7 @@ ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, /** * @brief Helper function to map samples to groups based on pattern - * + * * @param media media to map sample in * @param strPattern color pattern same as used in addSamples * @param idRed The index of the Red entry in the COLOR group @@ -166,7 +168,8 @@ ISOErr addSamples(MP4Media media, std::string strPattern, u32 repeatPattern = 1, * @param repeatPattern number of times to repeat the pattern. No samples are mapped if this is 0 * @return ISOErr error code */ -ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 idRed, u32 idBlue, u32 idGreen, u32 idYellow, u32 repeatPattern = 1) +ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 idRed, u32 idBlue, + u32 idGreen, u32 idYellow, u32 repeatPattern = 1) { ISOErr err = ISONoErr; std::string fullPattern = strPattern; @@ -208,7 +211,7 @@ ISOErr mapSamplesToGroups(MP4Media media, std::string strPattern, u32 idRed, u32 /** * @brief Helper function to check a single sample payload - * + * * @param media media to take a sample from * @param sampleNr sample number in that media * @param comparePtr pointer to data to compare out payload to @@ -224,7 +227,8 @@ ISOErr checkSample(MP4Media media, u32 sampleNr, u8 *comparePtr, u32 compareSize s32 outCTSOffset; MP4NewHandle(0, &sampleH); - err = MP4GetIndMediaSample(media, sampleNr, sampleH, &outSize, &outDTS, &outCTSOffset, &outDuration, &outSampleFlags, &outSampleDescIndex); + err = MP4GetIndMediaSample(media, sampleNr, sampleH, &outSize, &outDTS, &outCTSOffset, + &outDuration, &outSampleFlags, &outSampleDescIndex); CHECK(err == ISONoErr); u32 handleSize; @@ -241,7 +245,7 @@ ISOErr checkSample(MP4Media media, u32 sampleNr, u8 *comparePtr, u32 compareSize /** * @brief Helper function to check all samples in the given file - * + * * @param strFile input file to check * @return ISOErr error code */ @@ -253,81 +257,109 @@ ISOErr checkSamples(std::string strFile) ISOMedia media; err = ISOOpenMovieFile(&moov, strFile.c_str(), MP4OpenMovieNormal); - err = ISOGetMovieIndTrack(moov, 1, &trak); - err = ISOGetTrackMedia(trak, &media); - u32 sampleCnt = 0; + err = ISOGetMovieIndTrack(moov, 1, &trak); + err = ISOGetTrackMedia(trak, &media); + u32 sampleCnt = 0; u32 colorEntryCount = 0; + u32 blackEntryCount = 0; u32 *sampleNumbers; - u32 groupIdRed = 0; - u32 groupIdBlue = 0; - u32 groupIdGreen = 0; + u32 groupIdRed = 0; + u32 groupIdBlue = 0; + u32 groupIdGreen = 0; u32 groupIdYellow = 0; + u32 groupIdBlack = 0; - // parse the entries of the COLOR type and get the indexes + // parse the entries of the COLOR type and get the indexes err = ISOGetGroupDescriptionEntryCount(media, FOURCC_COLOR, &colorEntryCount); CHECK(err == ISONoErr); - if(colorEntryCount != 4) return -1; - for(u32 n=0; n Date: Tue, 1 Dec 2020 13:28:41 +0100 Subject: [PATCH 41/55] ignore doc/ --- .gitignore | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitignore b/.gitignore index b63b544..6440a57 100644 --- a/.gitignore +++ b/.gitignore @@ -9,6 +9,7 @@ bld/ [Bb]in/ [Oo]bj/ [Ll]og/ +doc/ *.o *.d From a21a341fb9819c01af9d7d5e1cf14f455d355679 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Wed, 9 Dec 2020 13:22:22 +0100 Subject: [PATCH 42/55] BugFix: tfdt is not mandatory in TrackFragmentBox --- IsoLib/libisomediafile/src/TrackFragmentAtom.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index f6dd91b..4149257 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -38,7 +38,7 @@ static void destroy(MP4AtomPtr s) DESTROY_ATOM_LIST_F(sampletoGroupList); DESTROY_ATOM_LIST_F(groupDescriptionList); (self->tfhd)->destroy((MP4AtomPtr)(self->tfhd)); - (self->tfdt)->destroy((MP4AtomPtr)(self->tfdt)); + if(self->tfdt) (self->tfdt)->destroy((MP4AtomPtr)(self->tfdt)); if(self->super) self->super->destroy(s); From 9ca7ef8f95879de551a98aa928a83c3605334333 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Thu, 10 Dec 2020 21:34:24 +0100 Subject: [PATCH 43/55] BugFix: local compact groups in fragments in case of local compact sample groups in fragments the group indexes are stored without adding 0x10000 but with the MSB flag which indicates if this group index is local or not. --- IsoLib/libisomediafile/src/MP4Atoms.h | 11 +- IsoLib/libisomediafile/src/SampleTableAtom.c | 6 +- .../libisomediafile/src/SampleToGroupAtom.c | 246 ++++++++++-------- .../libisomediafile/src/TrackFragmentAtom.c | 6 +- 4 files changed, 146 insertions(+), 123 deletions(-) diff --git a/IsoLib/libisomediafile/src/MP4Atoms.h b/IsoLib/libisomediafile/src/MP4Atoms.h index ed886b1..64bdb98 100644 --- a/IsoLib/libisomediafile/src/MP4Atoms.h +++ b/IsoLib/libisomediafile/src/MP4Atoms.h @@ -1729,10 +1729,13 @@ typedef struct u32 totalSampleCount; u32 totalIndexDescriptionCount; u32 efficientStartIndex; - u8 patternLengthFieldSize; - u8 sampleCountFieldSize; - u8 indexFieldSize; u8 isSampleGroupCompressed; + /* flags */ + u8 index_msb_indicates_fragment_local_description; + u8 grouping_type_parameter_present; + u8 pattern_size_code; + u8 count_size_code; + u8 index_size_code; MP4CompactSampleToGroupPatternEntryPtr patternEntries; u32 *indexDescriptionArray; @@ -1747,12 +1750,12 @@ typedef struct MP4SampletoGroupAtom u32 sampleCount; u32 entryCount; u32 allocatedSize; + u8 groupIsInFragment; /**< If set to 1 this group is located in traf, else it is in stbl */ sampleToGroupType_t sampleToGroupType; /* these are required for CompactSampletoGroup */ u32 groupingTypeParameter; - u8 fragmentLocalIndexPresent; u32 mapSampleToGroupIndex; CompressedGroupInfo compressedGroup; diff --git a/IsoLib/libisomediafile/src/SampleTableAtom.c b/IsoLib/libisomediafile/src/SampleTableAtom.c index b355f25..1490af9 100644 --- a/IsoLib/libisomediafile/src/SampleTableAtom.c +++ b/IsoLib/libisomediafile/src/SampleTableAtom.c @@ -669,9 +669,9 @@ static MP4Err mapSamplestoGroup(struct MP4SampleTableAtom *self, u32 groupType, } err = MP4CreateSampletoGroupAtom(&theGroup, sampleToGroupType); if(err) goto bail; - theGroup->grouping_type = groupType; - theGroup->fragmentLocalIndexPresent = 0; - err = addAtom(self, (MP4AtomPtr)theGroup); + theGroup->grouping_type = groupType; + theGroup->groupIsInFragment = 0; + err = addAtom(self, (MP4AtomPtr)theGroup); if(err) goto bail; err = theGroup->addSamples(theGroup, stsz->sampleCount); if(err) goto bail; diff --git a/IsoLib/libisomediafile/src/SampleToGroupAtom.c b/IsoLib/libisomediafile/src/SampleToGroupAtom.c index 37dde6e..c1b6614 100644 --- a/IsoLib/libisomediafile/src/SampleToGroupAtom.c +++ b/IsoLib/libisomediafile/src/SampleToGroupAtom.c @@ -1,25 +1,47 @@ -/* -This software module was originally developed by Apple Computer, Inc. -in the course of development of MPEG-4. -This software module is an implementation of a part of one or -more MPEG-4 tools as specified by MPEG-4. -ISO/IEC gives users of MPEG-4 free license to this -software module or modifications thereof for use in hardware -or software products claiming conformance to MPEG-4. -Those intending to use this software module in hardware or software -products are advised that its use may infringe existing patents. -The original developer of this software module and his/her company, -the subsequent editors and their companies, and ISO/IEC have no -liability for use of this software module or modifications thereof -in an implementation. -Copyright is not released for non MPEG-4 conforming -products. Apple Computer, Inc. retains full right to use the code for its own -purpose, assign or donate the code to a third party and to -inhibit third parties from using the code for non -MPEG-4 conforming products. -This copyright notice must be included in all copies or -derivative works. Copyright (c) 1999. -*/ +/** + * @file SampleToGroupAtom.c + * @version 0.1 + * @brief Implements Sample to group box 'sbgp' and Compact sample to group box 'csgp' + * + * Compacting Algorithm: + * 1. Run through sample group set: i=[0,n] + * a. Expand the input samples + * b. Initialize memory costs in tracker assuming each sample is a distinct non-pattern + * C[i] = (i*index_size_code) + * 2. Run through sample group set: i=[0,n] + * a. Update memory cost considering sample i is a distinct non-pattern + * C[i] = min(C[i], C[i-1]+index_size_code) + * b. For pattern lengths, p=[1, 32] + * i. Consider patterns ending at i, from [start=i-p, i] in the Search buffer. + * ii. Extend right end from [i+1, n] in the look ahead buffer + * 1. As long as the pattern repeats, keep extending right end and update memory cost + * C[end] = min(C[end] , C[start-1] + p*index_size_code + * 2. If C[end] got modified, a more efficient pattern was found, maintain + * previousEfficientIndex = start-1 for backtracking. + * 3. Tracker[n-1] represents most efficienct way to encode samples [0,n]. Run through tracker + * backwards from last sample: i[n-1, 0]. + * a. Use previousEfficientIndex to populate nextEfficientIndex to easily create compact sample + * groups + * b. Patterns with (pattern length == sample count == 1), are combined and considered as + * non-pattern + * + * @note Algorithm can further be optimized by making memory cost consider patternLength and + * sampleCount field sizes + * + * @copyright This software module was originally developed by Apple Computer, Inc. in the course of + * development of MPEG-4. This software module is an implementation of a part of one or more MPEG-4 + * tools as specified by MPEG-4. ISO/IEC gives users of MPEG-4 free license to this software module + * or modifications thereof for use in hardware or software products claiming conformance to MPEG-4. + * Those intending to use this software module in hardware or software products are advised that its + * use may infringe existing patents. The original developer of this software module and his/her + * company, the subsequent editors and their companies, and ISO/IEC have no liability for use of + * this software module or modifications thereof in an implementation. Copyright is not released for + * non MPEG-4 conforming products. Apple Computer, Inc. retains full right to use the code for its + * own purpose, assign or donate the code to a third party and to inhibit third parties from using + * the code for non MPEG-4 conforming products. This copyright notice must be included in all copies + * or derivative works. Copyright (c) 1999. + * + */ #include "MP4Atoms.h" #include @@ -33,15 +55,19 @@ enum kUpperNibblePresent = 0x8000 }; -/* PatternTracker is maintained as an array for each sample input. -patternStart at index k, represents the start index of the pattern which helped yield the most -efficient way to encode samples from [0, k] inclusive with patternLength, repeated sampleCount times -cumulativeMemoryCost at index k, represents the memory cost associated with most efficient way to -encode samples from [0, k] inclusive. Default considers each sample as a distinct non-pattern -prevEfficientIndex at index k, represents the end of the most efficient previous pattern/ -non-pattern before k which helped yield the cumulativeMemoryCost at index k. nextEfficientIndex is -populated after back-tracking prevEfficientIndex to easily create compact sample groups -*/ +/** + * @brief PatternTracker is maintained as an array for each sample input. + * + * patternStart at index k, represents the start index of the pattern which helped yield the most + * efficient way to encode samples from [0, k] inclusive with patternLength, repeated sampleCount + * times cumulativeMemoryCost at index k, represents the memory cost associated with most efficient + * way to encode samples from [0, k] inclusive. Default considers each sample as a distinct + * non-pattern prevEfficientIndex at index k, represents the end of the most efficient previous + * pattern/ non-pattern before k which helped yield the cumulativeMemoryCost at index k. + * nextEfficientIndex is populated after back-tracking prevEfficientIndex to easily create compact + * sample groups + * + */ typedef struct { u32 patternStart; @@ -52,29 +78,6 @@ typedef struct s32 nextEfficientIndex; } PatternTracker, *PatternTrackerPtr; -/* -Compacting Algorithm: -1. Run through sample group set: i=[0,n] - a. Expand the input samples - b. Initialize memory costs in tracker assuming each sample is a distinct non-pattern C[i] = -(i*indexFieldSize) -2. Run through sample group set: i=[0,n] - a. Update memory cost considering sample i is a distinct non-pattern C[i] = min(C[i] , -C[i-1]+ indexFieldSize) b. For pattern lengths, p=[1, 32] i. Consider patterns ending at i, from -[start=i-p, i] in the Search buffer. ii. Extend right end from [i+1, n] in the look ahead buffer - 1. As long as the pattern repeats, keep extending right end and -update memory cost C[end] = min(C[end] , C[start-1] + p*indexFieldSize - 2. If C[end] got modified, a more efficient pattern was found, -maintain previousEfficientIndex = start-1 for backtracking. -3. Tracker[n-1] represents most efficienct way to encode samples [0,n]. Run through tracker -backwards from last sample: i[n-1, 0]. a. Use previousEfficientIndex to populate nextEfficientIndex -to easily create compact sample groups b. Patterns with (pattern length == sample count == 1), are -combined and considered as non-pattern - -Algorithm can further be optimized by making memory cost consider patternLength and sampleCount -field sizes -*/ - typedef struct { u32 *groupIndex; @@ -280,7 +283,7 @@ static void InitializeSampleGroupInput(MP4SampletoGroupAtomPtr self, SampleGroup PatternTracker patternTrackerEntry; sampleGroup->groupIndex = self->group_index; sampleGroup->sampleCount = self->sampleCount; - sampleGroup->groupIndexFieldSize = self->compressedGroup.indexFieldSize; + sampleGroup->groupIndexFieldSize = self->compressedGroup.index_size_code; sampleGroup->patternTracker = (PatternTracker *)malloc(sizeof(PatternTracker) * self->sampleCount); @@ -324,10 +327,10 @@ static void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) InitializeSampleGroupInput(self, &sampleGroup); - compressedGroup = &self->compressedGroup; - compressedGroup->patternLengthFieldSize = 4; - compressedGroup->sampleCountFieldSize = 4; - compressedGroup->indexFieldSize = sampleGroup.groupIndexFieldSize; + compressedGroup = &self->compressedGroup; + compressedGroup->pattern_size_code = 4; + compressedGroup->count_size_code = 4; + compressedGroup->index_size_code = sampleGroup.groupIndexFieldSize; /* Repeatedly process, find and update efficiencies at each sample index*/ for(j = 0; j < self->sampleCount; j++) @@ -355,13 +358,12 @@ static void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) { u32 patternLength = patternTracker[nextIndex].patternLength; u8 fieldSize = GetFieldSize(patternLength, 0); - if(fieldSize > compressedGroup->patternLengthFieldSize) - compressedGroup->patternLengthFieldSize = fieldSize; + if(fieldSize > compressedGroup->pattern_size_code) + compressedGroup->pattern_size_code = fieldSize; sampleCount = patternTracker[nextIndex].sampleCount; fieldSize = GetFieldSize(sampleCount, 0); - if(fieldSize > compressedGroup->sampleCountFieldSize) - compressedGroup->sampleCountFieldSize = fieldSize; + if(fieldSize > compressedGroup->count_size_code) compressedGroup->count_size_code = fieldSize; AppendNewPatternEntry(compressedGroup, patternIndex, patternLength, sampleCount); @@ -371,9 +373,13 @@ static void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) for(j = 0; j < patternLength; j++) { u32 groupIndex = sampleGroup.groupIndex[patternTracker[nextIndex].patternStart + j]; - if(self->fragmentLocalIndexPresent) + if(self->groupIsInFragment && groupIndex >= 0x10000) { - groupIndex = groupIndex | (1 << (self->compressedGroup.indexFieldSize - 1)); + groupIndex -= 0x10000; + if(self->compressedGroup.index_msb_indicates_fragment_local_description) + { + groupIndex = groupIndex | (1 << (self->compressedGroup.index_size_code - 1)); + } } AppendDescriptionIndexToCompactGroup(compressedGroup, descIndex, groupIndex); descIndex++; @@ -383,11 +389,11 @@ static void CreateCompactSampleGroups(MP4SampletoGroupAtomPtr self) /* In case only patternLength or sampleCount field size is 4, ensure pattern entry is always byte * aligned*/ - if((compressedGroup->patternLengthFieldSize + compressedGroup->sampleCountFieldSize) % 8) + if((compressedGroup->pattern_size_code + compressedGroup->count_size_code) % 8) { - if(compressedGroup->patternLengthFieldSize == 4) compressedGroup->patternLengthFieldSize = 8; + if(compressedGroup->pattern_size_code == 4) compressedGroup->pattern_size_code = 8; else - compressedGroup->sampleCountFieldSize = 8; + compressedGroup->count_size_code = 8; } assert(descIndex == compressedGroup->totalIndexDescriptionCount); @@ -475,6 +481,7 @@ static MP4Err mapSamplestoGroup(struct MP4SampletoGroupAtom *self, u32 group_ind MP4Err err; u32 i; u32 *p; + u8 size_code; err = MP4NoErr; @@ -499,10 +506,14 @@ static MP4Err mapSamplestoGroup(struct MP4SampletoGroupAtom *self, u32 group_ind for(i = 0; i < count; i++) *p++ = group_index; - if(GetFieldSize(group_index, self->fragmentLocalIndexPresent) > - self->compressedGroup.indexFieldSize) - self->compressedGroup.indexFieldSize = - GetFieldSize(group_index, self->fragmentLocalIndexPresent); + if(self->groupIsInFragment && group_index >= 0x10000) + self->compressedGroup.index_msb_indicates_fragment_local_description = 1; + size_code = GetFieldSize(group_index, + self->compressedGroup.index_msb_indicates_fragment_local_description); + if(size_code > self->compressedGroup.index_size_code) + { + self->compressedGroup.index_size_code = size_code; + } bail: TEST_RETURN(err); @@ -659,10 +670,12 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) if(self->type == MP4CompactSampletoGroupAtomType) { - self->flags = SetFieldSize(self->compressedGroup.indexFieldSize) | - (SetFieldSize(self->compressedGroup.sampleCountFieldSize) << 2) | - (SetFieldSize(self->compressedGroup.patternLengthFieldSize) << 4) | - (self->fragmentLocalIndexPresent ? 0x80 : 0); + self->flags = + SetFieldSize(self->compressedGroup.index_size_code) | + (SetFieldSize(self->compressedGroup.count_size_code) << 2) | + (SetFieldSize(self->compressedGroup.pattern_size_code) << 4) | + (self->compressedGroup.index_msb_indicates_fragment_local_description ? 0x80 : 0) | + (self->compressedGroup.grouping_type_parameter_present ? 0x40 : 0); } err = MP4SerializeCommonFullAtomFields((MP4FullAtomPtr)s, buffer); @@ -705,18 +718,18 @@ static MP4Err serialize(struct MP4Atom *s, char *buffer) for(i = 0; i < self->compressedGroup.patternCount; i++) { /* Pattern entry is ensured to start at a byte boundary*/ - PackData(self, &buffer, self->compressedGroup.patternLengthFieldSize, 0, + PackData(self, &buffer, self->compressedGroup.pattern_size_code, 0, self->compressedGroup.patternEntries[i].patternLength); - PackData(self, &buffer, self->compressedGroup.sampleCountFieldSize, - (self->compressedGroup.patternLengthFieldSize == 4), + PackData(self, &buffer, self->compressedGroup.count_size_code, + (self->compressedGroup.pattern_size_code == 4), self->compressedGroup.patternEntries[i].sampleCount); } /* Index descriptor array is ensured to start at a byte boundary*/ for(i = 0; i < self->compressedGroup.totalIndexDescriptionCount; i++) { - PackData(self, &buffer, self->compressedGroup.indexFieldSize, (i & 1), + PackData(self, &buffer, self->compressedGroup.index_size_code, (i & 1), self->compressedGroup.indexDescriptionArray[i]); } } @@ -758,11 +771,10 @@ static MP4Err calculateSize(struct MP4Atom *s) /* If grouping type parameter is enabled in flags, will need to add an additional byte*/ self->size += 8; - sizeInBits = - (self->compressedGroup.patternCount * (self->compressedGroup.patternLengthFieldSize + - self->compressedGroup.sampleCountFieldSize)); - sizeInBits += - (self->compressedGroup.totalIndexDescriptionCount * self->compressedGroup.indexFieldSize); + sizeInBits = (self->compressedGroup.patternCount * (self->compressedGroup.pattern_size_code + + self->compressedGroup.count_size_code)); + sizeInBits += (self->compressedGroup.totalIndexDescriptionCount * + self->compressedGroup.index_size_code); self->size = self->size + (sizeInBits + 4) / 8; self->entryCount = self->compressedGroup.patternCount; @@ -781,11 +793,10 @@ static MP4Err calculateSize(struct MP4Atom *s) /* compact */ CreateCompactSampleGroups(self); compactSize += 8; - sizeInBits = - (self->compressedGroup.patternCount * (self->compressedGroup.patternLengthFieldSize + - self->compressedGroup.sampleCountFieldSize)); + sizeInBits = (self->compressedGroup.patternCount * (self->compressedGroup.pattern_size_code + + self->compressedGroup.count_size_code)); sizeInBits += - (self->compressedGroup.totalIndexDescriptionCount * self->compressedGroup.indexFieldSize); + (self->compressedGroup.totalIndexDescriptionCount * self->compressedGroup.index_size_code); compactSize += (sizeInBits + 4) / 8; /* pick compact only if the size is smaller */ @@ -818,8 +829,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre MP4SampletoGroupAtomPtr self = (MP4SampletoGroupAtomPtr)s; char typeString[8]; char msgString[80]; - u8 indexFieldSize, countFieldSize, patternFieldSize; - char groupingTypeParamPresent; + u8 index_size_code, countFieldSize, patternFieldSize; err = MP4NoErr; if(self == NULL) BAILWITHERROR(MP4BadParamErr) @@ -858,9 +868,11 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre } else { + /* compact sample to group */ self->sampleToGroupType = 1; - indexFieldSize = 4 << ((flags & 0x3) >> 0); - if(indexFieldSize != 4 && indexFieldSize != 8 && indexFieldSize != 16 && indexFieldSize != 32) + index_size_code = 4 << ((flags & 0x3) >> 0); + if(index_size_code != 4 && index_size_code != 8 && index_size_code != 16 && + index_size_code != 32) BAILWITHERROR(MP4BadParamErr) countFieldSize = 4 << ((flags & 0xC) >> 2); @@ -875,11 +887,11 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre /* Ensure each pattern entry is always byte-aligned*/ if((patternFieldSize + countFieldSize) % 8) BAILWITHERROR(MP4BadParamErr) - self->fragmentLocalIndexPresent = (flags & 0x80); - groupingTypeParamPresent = (flags & 0x40); + self->compressedGroup.index_msb_indicates_fragment_local_description = (flags & 0x80); + self->compressedGroup.grouping_type_parameter_present = (flags & 0x40); sprintf(msgString, "field size for index %d , sample count %d pattern length %d ", - indexFieldSize, countFieldSize, patternFieldSize); + index_size_code, countFieldSize, patternFieldSize); inputStream->msg(inputStream, msgString); GET32(grouping_type); @@ -887,7 +899,7 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre sprintf(msgString, "grouping type is '%s'", typeString); inputStream->msg(inputStream, msgString); - if(groupingTypeParamPresent) + if(self->compressedGroup.grouping_type_parameter_present) { GET32(groupingTypeParameter); } @@ -923,16 +935,24 @@ static MP4Err createFromInputStream(MP4AtomPtr s, MP4AtomPtr proto, MP4InputStre for(i = 0; i < self->entryCount; i++) { u32 *patternStart = p; - u32 mask = - self->fragmentLocalIndexPresent ? 0xFFFFFFFF >> (32 - indexFieldSize + 1) : 0xFFFFFFFF; + u32 mask = self->compressedGroup.index_msb_indicates_fragment_local_description + ? 0xFFFFFFFF >> (32 - index_size_code + 1) + : 0xFFFFFFFF; for(j = 0; j < patternEntries[i].sampleCount; j++) { if(j < patternEntries[i].patternLength) { u32 indexValue; - GetData(s, inputStream, indexFieldSize, &upperNibble, &indexValue); + u32 isLocal; + GetData(s, inputStream, index_size_code, &upperNibble, &indexValue); + isLocal = indexValue & ~mask; indexValue = indexValue & mask; - *p++ = indexValue; + if(isLocal) + { + /* local index found, correct it by adding 0x10000 */ + indexValue += 0x10000; + } + *p++ = indexValue; sprintf(msgString + (i * 2), "%d ", indexValue); } else @@ -984,18 +1004,18 @@ MP4Err MP4CreateSampletoGroupAtom(MP4SampletoGroupAtomPtr *outAtom, self->name = "(default) sample to group"; break; } - self->createFromInputStream = (cisfunc)createFromInputStream; - self->destroy = destroy; - self->calculateSize = calculateSize; - self->serialize = serialize; - self->mapSamplestoGroup = mapSamplestoGroup; - self->addSamples = addSamples; - self->changeSamplestoGroupType = changeSamplestoGroupType; - self->getSampleGroupMap = getSampleGroupMap; - self->group_index = NULL; - self->sampleCount = 0; - self->flags = 0; - self->fragmentLocalIndexPresent = 0; + self->createFromInputStream = (cisfunc)createFromInputStream; + self->destroy = destroy; + self->calculateSize = calculateSize; + self->serialize = serialize; + self->mapSamplestoGroup = mapSamplestoGroup; + self->addSamples = addSamples; + self->changeSamplestoGroupType = changeSamplestoGroupType; + self->getSampleGroupMap = getSampleGroupMap; + self->group_index = NULL; + self->sampleCount = 0; + self->flags = 0; + self->groupIsInFragment = 0; memset(&self->compressedGroup, 0, sizeof(CompressedGroupInfo)); *outAtom = self; diff --git a/IsoLib/libisomediafile/src/TrackFragmentAtom.c b/IsoLib/libisomediafile/src/TrackFragmentAtom.c index 4149257..154946b 100644 --- a/IsoLib/libisomediafile/src/TrackFragmentAtom.c +++ b/IsoLib/libisomediafile/src/TrackFragmentAtom.c @@ -862,9 +862,9 @@ static MP4Err mapSamplestoGroup(struct MP4MediaInformationAtom *s, u32 groupType { err = MP4CreateSampletoGroupAtom(&theGroup, sampleToGroupType); if(err) goto bail; - theGroup->fragmentLocalIndexPresent = 1; - theGroup->grouping_type = groupType; - err = addAtom(self, (MP4AtomPtr)theGroup); + theGroup->groupIsInFragment = 1; + theGroup->grouping_type = groupType; + err = addAtom(self, (MP4AtomPtr)theGroup); if(err) goto bail; fragment_sample_count = 0; From 2c37c02d306977492ca1f3f3653a7ac1c6024000 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Fri, 11 Dec 2020 17:16:52 +0100 Subject: [PATCH 44/55] wip: doxygen-style comments for API --- IsoLib/libisomediafile/src/ISOMovies.h | 838 ++++++++++++++----------- 1 file changed, 485 insertions(+), 353 deletions(-) diff --git a/IsoLib/libisomediafile/src/ISOMovies.h b/IsoLib/libisomediafile/src/ISOMovies.h index 98a7aee..541e5c2 100644 --- a/IsoLib/libisomediafile/src/ISOMovies.h +++ b/IsoLib/libisomediafile/src/ISOMovies.h @@ -1,8 +1,11 @@ -/* - ISOMovies.h: A wrapper for the code defined in the MPEG-4 library. - - This header file may be freely copied and distributed. -*/ +/** + * @file ISOMovies.h + * @brief A wrapper for the code defined in the MPEG-4 library. + * @version 0.1 + * + * @copyright This header file may be freely copied and distributed. + * + */ #ifndef INCLUDED_ISOMOVIE_H #define INCLUDED_ISOMOVIE_H @@ -57,113 +60,134 @@ extern "C" #define ISOOpenMovieDebug MP4OpenMovieDebug #define ISOOpenMovieInPlace MP4OpenMovieInPlace - /* constants for the graphics modes (e.g. for MJ2SetMediaGraphicsMode) */ - enum - { - ISOGraphicsModeSrcCopy = 0x00000000, - ISOGraphicsModeTransparent = 0x00000024, - ISOGraphicsModeAlpha = 0x00000100, - ISOGraphicsModeWhiteAlpha = 0x00000101, - ISOGraphicsModeBlackAlpha = 0x00000102 - }; - - /* These data types are specific to JPEG-2; however, they have "ISO" names. */ - struct ISOMatrixRecord - { - u32 data[9]; - }; - typedef struct ISOMatrixRecord ISOMatrixRecord; - typedef ISOMatrixRecord *ISOMatrix; - - struct ISORGBColor - { - u16 red; - u16 green; - u16 blue; - }; - typedef struct ISORGBColor ISORGBColor; - typedef ISORGBColor *ISORGBColorPtr; - - /* constants for the fileType field of the MP4PrivateMovieRecord structure */ - enum - { - ISOUnknownFileType = (u32)0, - ISOMPEG4FileType = (u32)1, - ISOStillJPEG2000FileType = (u32)2, - ISOMotionJPEG2000FileType = (u32)3, - ISOQuickTimeFileType = (u32)4, - ISO3GPPFileType = (u32)5, - ISOMPEG21FileType = (u32)6 - }; - - /* constants for the qt_componentType field of the MP4HandlerAtom structure */ - enum - { - ISOMediaHandlerType = MP4_FOUR_CHAR_CODE('m', 'h', 'l', 'r'), - ISODataHandlerType = MP4_FOUR_CHAR_CODE('d', 'h', 'l', 'r') - }; - - /* Brands */ - - enum - { - JP2JPEG2000Brand = MP4_FOUR_CHAR_CODE('j', 'p', '2', ' '), /* brand for JPEG-2000 */ - MJ2JPEG2000Brand = MP4_FOUR_CHAR_CODE('m', 'j', 'p', '2'), /* brand for Motion JPEG-2000 */ - ISOQuickTimeBrand = MP4_FOUR_CHAR_CODE('q', 't', ' ', ' '), /* brand for QuickTime */ - ISOMpeg4V1Brand = MP4_FOUR_CHAR_CODE('m', 'p', '4', '1'), /* brand for MPEG-4 version 1 */ - ISOMpeg4V2Brand = MP4_FOUR_CHAR_CODE('m', 'p', '4', '2'), /* brand for MPEG-4 version 2 */ - ISOISOBrand = MP4_FOUR_CHAR_CODE('i', 's', 'o', 'm'), /* conforming brand for all files */ - ISOISO2Brand = MP4_FOUR_CHAR_CODE('i', 's', 'o', '2'), /* conforming brand for all files */ - ISO3GP4Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '4'), /* 3GPP Release 4 */ - ISO3GP5Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '5'), /* 3GPP Release 5 */ - ISO3GP6Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '6'), /* 3GPP Release 6 */ - ISOMPEG21Brand = MP4_FOUR_CHAR_CODE('m', 'p', '2', '1'), /* MPEG-21 */ - ISOUnknownBrand = MP4_FOUR_CHAR_CODE(' ', ' ', ' ', ' '), /* default 'brand' */ - - /* DASH-related brands (ISO/IEC 23009-1) */ - ISO_DASH_Brand = MP4_FOUR_CHAR_CODE('d', 'a', 's', 'h'), - ISO_DASH_DSMS_Brand = - MP4_FOUR_CHAR_CODE('d', 's', 'm', 's'), /* self-initializing media segment */ - ISO_DASH_MSDH_Brand = MP4_FOUR_CHAR_CODE('m', 's', 'd', 'h'), /* general format media segment */ - ISO_DASH_MSIX_Brand = MP4_FOUR_CHAR_CODE('m', 's', 'd', 'h'), /* indexed media segment */ - ISO_DASH_RISX_Brand = MP4_FOUR_CHAR_CODE( - 'r', 'i', 's', 'x'), /* representation index segment for MPEG-2 TS media segments */ - ISO_DASH_LMSG_Brand = - MP4_FOUR_CHAR_CODE('l', 'm', 's', 'g'), /* last media segment indicator (ISO BMFF) */ - ISO_DASH_SISX_Brand = - MP4_FOUR_CHAR_CODE('s', 'i', 's', 'x'), /* single index segment (MPEG-2 TS) */ - ISO_DASH_SSSS_Brand = - MP4_FOUR_CHAR_CODE('s', 's', 's', 's') /* subsegment index segment (MPEG-2 TS) */ - }; - - /* AVC/SVC PS places */ - - enum - { - AVCsps = 1, - AVCpps = 2, - AVCspsext = 3, - - SVCsps = 0x11, - SVCpps = 0x12, - SVCspsext = 0x13 - }; - - /* Meta-data records */ - - struct ISOMetaRecord - { - void *data; - }; - typedef struct ISOMetaRecord ISOMetaRecord; - typedef ISOMetaRecord *ISOMeta; - - struct ISOMetaItemRecord - { - void *data; - }; - typedef struct ISOMetaItemRecord ISOMetaItemRecord; - typedef ISOMetaItemRecord *ISOMetaItem; +/** + * @brief constants for the graphics modes (e.g. for MJ2SetMediaGraphicsMode) + * + */ +enum +{ + ISOGraphicsModeSrcCopy = 0x00000000, + ISOGraphicsModeTransparent = 0x00000024, + ISOGraphicsModeAlpha = 0x00000100, + ISOGraphicsModeWhiteAlpha = 0x00000101, + ISOGraphicsModeBlackAlpha = 0x00000102 +}; + +/** + * @brief These data types are specific to JPEG-2; however, they have "ISO" names. + * + */ +struct ISOMatrixRecord +{ + u32 data[9]; +}; +typedef struct ISOMatrixRecord ISOMatrixRecord; +typedef ISOMatrixRecord *ISOMatrix; + +/** + * @brief RGB color type + * + */ +struct ISORGBColor +{ + u16 red; + u16 green; + u16 blue; +}; +typedef struct ISORGBColor ISORGBColor; +typedef ISORGBColor *ISORGBColorPtr; + +/** + * @brief constants for the fileType field of the MP4PrivateMovieRecord structure + * + */ +enum +{ + ISOUnknownFileType = (u32)0, + ISOMPEG4FileType = (u32)1, + ISOStillJPEG2000FileType = (u32)2, + ISOMotionJPEG2000FileType = (u32)3, + ISOQuickTimeFileType = (u32)4, + ISO3GPPFileType = (u32)5, + ISOMPEG21FileType = (u32)6 +}; + +/** + * @brief constants for the qt_componentType field of the MP4HandlerAtom structure + * + */ +enum +{ + ISOMediaHandlerType = MP4_FOUR_CHAR_CODE('m', 'h', 'l', 'r'), + ISODataHandlerType = MP4_FOUR_CHAR_CODE('d', 'h', 'l', 'r') +}; + +/** + * @brief Brands + * + */ +enum +{ + JP2JPEG2000Brand = MP4_FOUR_CHAR_CODE('j', 'p', '2', ' '), /**< brand for JPEG-2000 */ + MJ2JPEG2000Brand = MP4_FOUR_CHAR_CODE('m', 'j', 'p', '2'), /**< brand for Motion JPEG-2000 */ + ISOQuickTimeBrand = MP4_FOUR_CHAR_CODE('q', 't', ' ', ' '), /**< brand for QuickTime */ + ISOMpeg4V1Brand = MP4_FOUR_CHAR_CODE('m', 'p', '4', '1'), /**< brand for MPEG-4 version 1 */ + ISOMpeg4V2Brand = MP4_FOUR_CHAR_CODE('m', 'p', '4', '2'), /**< brand for MPEG-4 version 2 */ + ISOISOBrand = MP4_FOUR_CHAR_CODE('i', 's', 'o', 'm'), /**< conforming brand for all files */ + ISOISO2Brand = MP4_FOUR_CHAR_CODE('i', 's', 'o', '2'), /**< conforming brand for all files */ + ISO3GP4Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '4'), /**< 3GPP Release 4 */ + ISO3GP5Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '5'), /**< 3GPP Release 5 */ + ISO3GP6Brand = MP4_FOUR_CHAR_CODE('3', 'g', 'p', '6'), /**< 3GPP Release 6 */ + ISOMPEG21Brand = MP4_FOUR_CHAR_CODE('m', 'p', '2', '1'), /**< MPEG-21 */ + ISOUnknownBrand = MP4_FOUR_CHAR_CODE(' ', ' ', ' ', ' '), /**< default 'brand' */ + + /* DASH-related brands (ISO/IEC 23009-1) */ + ISO_DASH_Brand = MP4_FOUR_CHAR_CODE('d', 'a', 's', 'h'), + ISO_DASH_DSMS_Brand = MP4_FOUR_CHAR_CODE('d', 's', 'm', 's'), /**< self-initializing media seg. */ + ISO_DASH_MSDH_Brand = MP4_FOUR_CHAR_CODE('m', 's', 'd', 'h'), /**< general format media segment */ + ISO_DASH_MSIX_Brand = MP4_FOUR_CHAR_CODE('m', 's', 'd', 'h'), /**< indexed media segment */ + ISO_DASH_RISX_Brand = MP4_FOUR_CHAR_CODE('r', 'i', 's', 'x'), /**< representation index segment */ + ISO_DASH_LMSG_Brand = MP4_FOUR_CHAR_CODE('l', 'm', 's', 'g'), /**< last media segment indicator */ + ISO_DASH_SISX_Brand = MP4_FOUR_CHAR_CODE('s', 'i', 's', 'x'), /**< single index segment */ + ISO_DASH_SSSS_Brand = MP4_FOUR_CHAR_CODE('s', 's', 's', 's') /**< subsegment index segment */ +}; + +/** + * @brief AVC/SVC Parameter Set places + * + */ +enum +{ + AVCsps = 1, + AVCpps = 2, + AVCspsext = 3, + + SVCsps = 0x11, + SVCpps = 0x12, + SVCspsext = 0x13 +}; + +/** + * @brief Meta-data records + * + */ +struct ISOMetaRecord +{ + void *data; +}; +typedef struct ISOMetaRecord ISOMetaRecord; +typedef ISOMetaRecord *ISOMeta; + +/** + * @brief Meta-item records + * + */ +struct ISOMetaItemRecord +{ + void *data; +}; +typedef struct ISOMetaItemRecord ISOMetaItemRecord; +typedef ISOMetaItemRecord *ISOMetaItem; /* These functions are general movie-handling functions and are common to both MPEG-4 and JPEG-2; ideally the "ISO" names should be used. */ @@ -261,249 +285,357 @@ extern "C" #define MJ2TrackReaderGetNextSample MP4TrackReaderGetNextAccessUnit - /* These functions are specific to Motion JPEG-2; they have only the "MJ2" names. */ - ISO_EXTERN(ISOErr) - MJ2SetMovieMatrix(ISOMovie theMovie, u32 matrix[9]); - - ISO_EXTERN(ISOErr) - MJ2GetMovieMatrix(ISOMovie theMovie, u32 outMatrix[9]); - - ISO_EXTERN(ISOErr) - MJ2SetMoviePreferredRate(ISOMovie theMovie, u32 rate); - - ISO_EXTERN(ISOErr) - MJ2GetMoviePreferredRate(ISOMovie theMovie, u32 *outRate); - - ISO_EXTERN(ISOErr) - MJ2SetMoviePreferredVolume(ISOMovie theMovie, s16 volume); - - ISO_EXTERN(ISOErr) - MJ2GetMoviePreferredVolume(ISOMovie theMovie, s16 *outVolume); - - ISO_EXTERN(ISOErr) - MJ2SetTrackMatrix(ISOTrack theTrack, u32 matrix[9]); - - ISO_EXTERN(ISOErr) - MJ2GetTrackMatrix(ISOTrack theTrack, u32 outMatrix[9]); - - ISO_EXTERN(ISOErr) - MJ2SetTrackLayer(ISOTrack theTrack, s16 layer); - - ISO_EXTERN(ISOErr) - MJ2GetTrackLayer(ISOTrack theTrack, s16 *outLayer); - - ISO_EXTERN(ISOErr) - MJ2SetTrackDimensions(ISOTrack theTrack, u32 width, u32 height); - - ISO_EXTERN(ISOErr) - MJ2GetTrackDimensions(ISOTrack theTrack, u32 *outWidth, u32 *outHeight); - - ISO_EXTERN(ISOErr) - MJ2SetTrackVolume(ISOTrack theTrack, s16 volume); - - ISO_EXTERN(ISOErr) - MJ2GetTrackVolume(ISOTrack theTrack, s16 *outVolume); - - ISO_EXTERN(ISOErr) - MJ2SetMediaGraphicsMode(ISOMedia theMedia, u32 mode, const ISORGBColor *opColor); - - ISO_EXTERN(ISOErr) - MJ2GetMediaGraphicsMode(ISOMedia theMedia, u32 *outMode, ISORGBColor *outOpColor); - - ISO_EXTERN(ISOErr) - MJ2SetMediaSoundBalance(ISOMedia theMedia, s16 balance); - - ISO_EXTERN(ISOErr) - MJ2GetMediaSoundBalance(ISOMedia theMedia, s16 *outBalance); - - ISO_EXTERN(ISOErr) - MJ2NewMovie(ISOMovie *outMovie); +/*************************************************************************************************** + * These functions are specific to Motion JPEG-2; they have only the "MJ2" names. + **************************************************************************************************/ + +/** + * @brief This sets the matrix of the overall movie. + * + * The default matrix is the unity matrix, if none has been set. + * + */ +ISO_EXTERN(ISOErr) MJ2SetMovieMatrix(ISOMovie theMovie, u32 matrix[9]); +/** + * @brief This returns the overall transformation matrix for the movie. + * + */ +ISO_EXTERN(ISOErr) MJ2GetMovieMatrix(ISOMovie theMovie, u32 outMatrix[9]); +/** + * @brief This sets the rate of the movie (the normal and default rate is 1.0). + * + * The rate is represented as a 16.16 fixed-point number. + * + */ +ISO_EXTERN(ISOErr) MJ2SetMoviePreferredRate(ISOMovie theMovie, u32 rate); +/** + * @brief This returns the currently set movie preferred rate. + * + */ +ISO_EXTERN(ISOErr) MJ2GetMoviePreferredRate(ISOMovie theMovie, u32 *outRate); +/** + * @brief This sets the normal volume of the movie. + * + * The normal, default, value is 1.0. The volume is expressed as an 8.8 fixed-point number. + * + */ +ISO_EXTERN(ISOErr) MJ2SetMoviePreferredVolume(ISOMovie theMovie, s16 volume); +/** + * @brief This returns the movie volume setting. + * + */ +ISO_EXTERN(ISOErr) MJ2GetMoviePreferredVolume(ISOMovie theMovie, s16 *outVolume); +/** + * @brief This sets the overall transformation matrix for the movie as a whole. + * + * The matrix allows for 2D transformations; see the MJ2 specification for the details of how it + * is applied. The default matrix is the unitary transform. + * + */ +ISO_EXTERN(ISOErr) MJ2SetTrackMatrix(ISOTrack theTrack, u32 matrix[9]); +/** + * @brief This returns the current matrix. + * + */ +ISO_EXTERN(ISOErr) MJ2GetTrackMatrix(ISOTrack theTrack, u32 outMatrix[9]); +/** + * @brief This sets the ordering of the visual tracks. + * + * It should be set if there is more than one visual track. Smaller numbers are closer to the + * front. + * + */ +ISO_EXTERN(ISOErr) MJ2SetTrackLayer(ISOTrack theTrack, s16 layer); +/** + * @brief This returns the currently set track layer. + * + */ +ISO_EXTERN(ISOErr) MJ2GetTrackLayer(ISOTrack theTrack, s16 *outLayer); +/** + * @brief This sets the width and height of a track. + * + * Note that this may be different from the width and height of the media; scaling may occur. + * All MJ2 visual tracks should have this set explicitly. + * + */ +ISO_EXTERN(ISOErr) MJ2SetTrackDimensions(ISOTrack theTrack, u32 width, u32 height); +/** + * @brief This returns the currently set dimensions. + * + */ +ISO_EXTERN(ISOErr) MJ2GetTrackDimensions(ISOTrack theTrack, u32 *outWidth, u32 *outHeight); +/** + * @brief This sets the normal volume of the track. + * + * The normal, default, value is 1.0. The volume is expressed as an 8.8 fixed-point number. + * Different audio tracks may have different volume settings; they are mixed for playback. + * + */ +ISO_EXTERN(ISOErr) MJ2SetTrackVolume(ISOTrack theTrack, s16 volume); +/** + * @brief Returns the currently set track volume. + * + */ +ISO_EXTERN(ISOErr) MJ2GetTrackVolume(ISOTrack theTrack, s16 *outVolume); +/** + * @brief Sets the graphics mode for this track. + * + * The mode should be chosen from the following list. The default mode is ISOGraphicsModeSrcCopy. + * + * ISOGraphicsModeSrcCopy: This video image will be copied over the top of the layers below it. + * This is the default value, and should be used for the backmost track. + * + * ISOGraphicsModeTransparent: The color ISORGBColor in this video image will be treated as + * transparent, allowing layers behind to be seen. + * + * ISOGraphicsModeAlpha: This video image includes an alpha plane to define its transparency. + * + * ISOGraphicsModeWhiteAlpha: This video image includes an alpha plane, which has been + * premultiplied with white, to define its transparency. + * + * ISOGraphicsModeBlackAlpha: This video image includes an alpha plane, which has been + * premultiplied with black, to define its transparency. + * + */ +ISO_EXTERN(ISOErr) MJ2SetMediaGraphicsMode(ISOMedia theMedia, u32 mode, const ISORGBColor *opColor); +/** + * @brief Returns the currently set graphics mode. + * + */ +ISO_EXTERN(ISOErr) MJ2GetMediaGraphicsMode(ISOMedia theMedia, u32 *outMode, + ISORGBColor *outOpColor); +/** + * @brief Sets the left-right balance of an audio track (normally a mono track). + * + * Balance values are represented as 16-bit, fixed-point numbers that range from -1.0 to +1.0. The + * high-order 8 bits contain the integer portion of the value; the low-order 8 bits contain the + * fractional part. Negative values weight the balance toward the left speaker; positive values + * emphasize the right channel. Setting the balance to 0 (the default) corresponds to a neutral + * setting. + * + */ +ISO_EXTERN(ISOErr) MJ2SetMediaSoundBalance(ISOMedia theMedia, s16 balance); +/** + * @brief Returns the currently set balance value. + * + */ +ISO_EXTERN(ISOErr) MJ2GetMediaSoundBalance(ISOMedia theMedia, s16 *outBalance); +/** + * @brief Creates a new empty Motion JPEG 2000 Movie in memory. + * + */ +ISO_EXTERN(ISOErr) MJ2NewMovie(ISOMovie *outMovie); + +/*************************************************************************************************** + * These functions are specific to 3GPP; they have only the "3GPP" names. + **************************************************************************************************/ + +/** + * @brief Creates a new empty 3GPP Movie in memory, and sets the brand to the indicated release + * (4, 5 or 6). + * + */ +ISO_EXTERN(ISOErr) New3GPPMovie(ISOMovie *outMovie, u16 release); + +/*************************************************************************************************** + * These functions are specific to QuickTime; they have only the "QT" names. + **************************************************************************************************/ + +/** + * @brief Creaets a new empty QT Movie in memory. + * + */ +ISO_EXTERN(ISOErr) QTNewMovie(ISOMovie *outMovie); + +/*************************************************************************************************** + * These functions are general. + **************************************************************************************************/ + +/** + * @brief Writes the in-memory Movie to a file. The file given by filename is created, written, + * and closed. + * + */ +ISO_EXTERN(ISOErr) ISOWriteMovieToFile(ISOMovie theMovie, const char *filename); +/** + * @brief Sets the Movie’s major brand. + * + * Also inserts the major brand into the compatible brands list. This function is not normally + * needed; the brand is set by the appropriate movie-creation function. + * + */ +ISO_EXTERN(ISOErr) ISOSetMovieBrand(ISOMovie theMovie, u32 brand, u32 minorversion); +/** + * @brief Adds a minor brand into the compatible brands list of the Movie. + * + * The following brands have defined constants in the headers, though of course you may use + * MP4_FOUR_CHAR_CODE also. + * + * JP2JPEG2000Brand: brand for JPEG-2000 + * MJ2JPEG2000Brand: brand for Motion JPEG-2000 + * ISOQuickTimeBrand: brand for QuickTime + * ISOMpeg4V1Brand: brand for MPEG-4 version 1 + * ISOMpeg4V2Brand: brand for MPEG-4 version 2 + * ISOISOBrand: conforming brand for all files + * ISOISO2Brand: conforming brand for all files + * ISO3GP4Brand: 3GPP Release 4 + * ISO3GP5Brand: 3GPP Release 5 + * ISO3GP6Brand: 3GPP Release 6 + * ISOMPEG21Brand: MPEG-21 + * + */ +ISO_EXTERN(ISOErr) ISOSetMovieCompatibleBrand(ISOMovie theMovie, u32 brand); +/** + * @brief Returns the Movie’s major brand and minor version. + * + */ +ISO_EXTERN(ISOErr) ISOGetMovieBrand(ISOMovie theMovie, u32 *brand, u32 *minorversion); +/** + * @brief If the brand is a compatible brand of the movie, this returns the compatible brand, + * otherwise it returns 0. + * + */ +ISO_EXTERN(ISOErr) ISOIsMovieCompatibleBrand(ISOMovie theMovie, u32 brand); + +/*************************************************************************************************** + * AVC Sample descriptions + **************************************************************************************************/ + +ISO_EXTERN(ISOErr) ISONewAVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 length_size, + MP4Handle first_sps, MP4Handle first_pps, + MP4Handle first_spsext); + +ISO_EXTERN(ISOErr) ISOAddVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where); + +ISO_EXTERN(ISOErr) ISOGetAVCSampleDescription(MP4Handle sampleEntryH, u32 *dataReferenceIndex, + u32 *length_size, u32 *sps_count, u32 *pss_count, + u32 *spsext_count); + +ISO_EXTERN(ISOErr) ISOGetVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, + u32 index); +ISO_EXTERN(ISOErr) ISOGetHEVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, + u32 index); +ISO_EXTERN(ISOErr) ISOGetRESVSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, + u32 index); +ISO_EXTERN(ISOErr) ISOGetRESVLengthSizeMinusOne(MP4Handle sampleEntryH, u32 *out); +ISO_EXTERN(ISOErr) ISOGetRESVOriginalFormat(MP4Handle sampleEntryH, u32 *outOrigFmt); +ISO_EXTERN(ISOErr) ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 length_size, + MP4Handle first_sps, MP4Handle first_pps, + MP4Handle first_vps); + +/*************************************************************************************************** + * 3GPP media + **************************************************************************************************/ +MP4_EXTERN(MP4Err) ISOAddBitrateToSampleDescription(MP4Handle sampleEntryH, u8 is_3GPP, + u32 buffersizeDB, u32 maxBitrate, + u32 avgBitrate); + +MP4_EXTERN(MP4Err) ISONewH263SampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 vendor, + u8 decoder_version, u8 H263_level, u8 H263_profile); + +MP4_EXTERN(MP4Err) ISONewAMRSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u8 is_WB, u32 vendor, + u8 decoder_version, u16 mode_set, + u8 mode_change_period, u8 frames_per_sample); + +MP4_EXTERN(MP4Err) ISONewAMRWPSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, + u32 dataReferenceIndex, u32 vendor, + u8 decoder_version); + +/*************************************************************************************************** + * Meta Data + **************************************************************************************************/ + +ISO_EXTERN(ISOErr) ISONewFileMeta(ISOMovie theMovie, u32 metaType, ISOMeta *meta); +ISO_EXTERN(ISOErr) ISONewMovieMeta(ISOMovie theMovie, u32 metaType, ISOMeta *meta); +ISO_EXTERN(ISOErr) ISONewTrackMeta(ISOTrack theTrack, u32 metaType, ISOMeta *meta); + +ISO_EXTERN(ISOErr) ISOAddMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 relation_type); +ISO_EXTERN(ISOErr) ISOGetMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, + u8 *relation_type); + +ISO_EXTERN(ISOErr) ISOAddMetaDataReference(ISOMeta meta, u16 *out_ref, ISOHandle urlHandle, + ISOHandle urnHandle); + +ISO_EXTERN(ISOErr) ISOAddMetaItem(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, + u16 data_ref_index); +ISO_EXTERN(ISOErr) ISOAddMetaItemWithID(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, + u16 data_ref_index, u16 item_ID); + +ISO_EXTERN(ISOErr) ISOAddItemExtent(ISOMetaItem item, MP4Handle data); +ISO_EXTERN(ISOErr) ISOAddItemExtentReference(ISOMetaItem item, u64 offset, u64 length); +ISO_EXTERN(ISOErr) ISOAddItemExtentUsingItemData(ISOMetaItem item, MP4Handle data); +ISO_EXTERN(ISOErr) ISOAddItemExtentItem(ISOMetaItem item, ISOMetaItem extent_item, u32 offset, + u32 length); + +ISO_EXTERN(ISOErr) ISOAddItemReference(ISOMetaItem item, u32 reference_type, u32 to_item_ID, + u32 *outIndex); +ISO_EXTERN(ISOErr) ISOAddItemReferences(ISOMetaItem item, u32 reference_type, u16 reference_count, + MP4Handle to_item_IDs); +ISO_EXTERN(ISOErr) ISOGetItemReferences(ISOMetaItem item, u32 reference_type, u16 *reference_count, + MP4Handle to_item_IDs); +ISO_EXTERN(ISOErr) ISOGetItemReference(ISOMetaItem item, u32 reference_type, u16 reference_index, + ISOMetaItem *outItem); +ISO_EXTERN(ISOErr) ISOAddPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom); +ISO_EXTERN(ISOErr) ISOGetPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom); +ISO_EXTERN(ISOErr) ISOGetPrimaryItemData(ISOMeta meta, u32 box_type, MP4Handle data, + u8 is_full_atom); + +ISO_EXTERN(ISOErr) ISOSetPrimaryItem(ISOMeta meta, ISOMetaItem item); +ISO_EXTERN(ISOErr) ISOGetPrimaryItemID(ISOMeta meta, u16 *ID); + +ISO_EXTERN(ISOErr) ISOGetItemID(ISOMetaItem item, u16 *ID); + +ISO_EXTERN(ISOErr) ISOSetItemInfo(ISOMetaItem item, u16 protection_index, char *name, + char *content_type, char *content_encoding); + +ISO_EXTERN(ISOErr) ISOSetItemInfoExtension(ISOMetaItem item, MP4Handle extension, + u32 extension_type); +ISO_EXTERN(ISOErr) ISOGetItemInfoExtension(ISOMetaItem item, MP4Handle extension, + u32 *extension_type); + +ISO_EXTERN(ISOErr) ISOSetItemInfoItemType(ISOMetaItem item, u32 item_type, char *item_uri_type); +ISO_EXTERN(ISOErr) ISOGetItemInfoItemType(ISOMetaItem item, u32 *item_type, char **item_uri_type); + +ISO_EXTERN(ISOErr) ISOGetFileMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, + u32 *outMetaType); +ISO_EXTERN(ISOErr) ISOGetMovieMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, + u32 *outMetaType); +ISO_EXTERN(ISOErr) ISOGetTrackMeta(ISOTrack theTrack, ISOMeta *meta, u32 inMetaType, + u32 *outMetaType); + +ISO_EXTERN(ISOErr) ISOGetAllItemsWithType(ISOMeta meta, u32 type, ISOMetaItem **items, + u32 *numberOfItemsFound); +ISO_EXTERN(ISOErr) ISOFindItemByName(ISOMeta meta, ISOMetaItem *item, char *name, u8 exact_case); +ISO_EXTERN(ISOErr) ISOFindItemByID(ISOMeta meta, ISOMetaItem *item, u16 ID); + +ISO_EXTERN(ISOErr) ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_offset); + +ISO_EXTERN(ISOErr) ISOGetItemInfo(ISOMetaItem item, u16 *protection_index, char *name, + char *content_type, char *content_encoding); + +ISO_EXTERN(MP4Err) ISOCheckMetaDataReferences(ISOMeta meta); + +ISO_EXTERN(MP4Err) ISONewMetaProtection(ISOMeta meta, u32 sch_type, u32 sch_version, char *sch_url, + u16 *protection_index); + +ISO_EXTERN(MP4Err) ISOAddMetaProtectionInfo(ISOMeta meta, u16 protection_index, + MP4GenericAtom schi_atom); + +ISO_EXTERN(MP4Err) ISOGetMetaProtection(ISOMeta meta, u16 protection_index, u32 *sch_type, + u32 *sch_version, char *sch_url); + +ISO_EXTERN(MP4Err) ISOGetMetaProtectionInfo(ISOMeta meta, u16 protection_index, u32 atom_type, + MP4GenericAtom *schi_atom); - /* These functions are specific to 3GPP; they have only the "3GPP" names. */ - ISO_EXTERN(ISOErr) - New3GPPMovie(ISOMovie *outMovie, u16 release); +ISO_EXTERN(MP4Err) ISOAddMetaItemProperty(ISOMetaItem item, MP4GenericAtom *itemProperty, + u8 essential); - /* These functions are specific to QuickTime; they have only the "QT" names. */ - ISO_EXTERN(ISOErr) - QTNewMovie(ISOMovie *outMovie); - - /* These functions are general. */ - ISO_EXTERN(ISOErr) - ISOWriteMovieToFile(ISOMovie theMovie, const char *filename); - - ISO_EXTERN(ISOErr) - ISOSetMovieBrand(ISOMovie theMovie, u32 brand, u32 minorversion); - - ISO_EXTERN(ISOErr) - ISOSetMovieCompatibleBrand(ISOMovie theMovie, u32 brand); - - ISO_EXTERN(ISOErr) - ISOGetMovieBrand(ISOMovie theMovie, u32 *brand, u32 *minorversion); - - ISO_EXTERN(ISOErr) - ISOIsMovieCompatibleBrand(ISOMovie theMovie, u32 brand); - - /* AVC Sample descriptions */ - - ISO_EXTERN(ISOErr) - ISONewAVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps, - MP4Handle first_pps, MP4Handle first_spsext); - - ISO_EXTERN(ISOErr) ISOAddVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where); - - ISO_EXTERN(ISOErr) - ISOGetAVCSampleDescription(MP4Handle sampleEntryH, u32 *dataReferenceIndex, u32 *length_size, - u32 *sps_count, u32 *pss_count, u32 *spsext_count); - - ISO_EXTERN(ISOErr) - ISOGetVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index); - ISO_EXTERN(ISOErr) - ISOGetHEVCSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index); - ISO_EXTERN(ISOErr) - ISOGetRESVSampleDescriptionPS(MP4Handle sampleEntryH, MP4Handle ps, u32 where, u32 index); - ISO_EXTERN(ISOErr) - ISOGetRESVLengthSizeMinusOne(MP4Handle sampleEntryH, u32 *out); - ISO_EXTERN(ISOErr) - ISOGetRESVOriginalFormat(MP4Handle sampleEntryH, u32 *outOrigFmt); - ISO_EXTERN(ISOErr) - ISONewHEVCSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, u32 length_size, MP4Handle first_sps, - MP4Handle first_pps, MP4Handle first_vps); - /* 3GPP media */ - MP4_EXTERN(MP4Err) - ISOAddBitrateToSampleDescription(MP4Handle sampleEntryH, u8 is_3GPP, u32 buffersizeDB, - u32 maxBitrate, u32 avgBitrate); - - MP4_EXTERN(MP4Err) - ISONewH263SampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, u32 vendor, u8 decoder_version, u8 H263_level, - u8 H263_profile); - - MP4_EXTERN(MP4Err) - ISONewAMRSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, u8 is_WB, u32 vendor, u8 decoder_version, - u16 mode_set, u8 mode_change_period, u8 frames_per_sample); - - MP4_EXTERN(MP4Err) - ISONewAMRWPSampleDescription(MP4Track theTrack, MP4Handle sampleDescriptionH, - u32 dataReferenceIndex, u32 vendor, u8 decoder_version); - /* Meta Data */ - - ISO_EXTERN(ISOErr) - ISONewFileMeta(ISOMovie theMovie, u32 metaType, ISOMeta *meta); - ISO_EXTERN(ISOErr) - ISONewMovieMeta(ISOMovie theMovie, u32 metaType, ISOMeta *meta); - ISO_EXTERN(ISOErr) - ISONewTrackMeta(ISOTrack theTrack, u32 metaType, ISOMeta *meta); - - ISO_EXTERN(ISOErr) - ISOAddMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 relation_type); - ISO_EXTERN(ISOErr) - ISOGetMetaBoxRelation(ISOMeta first_meta, ISOMeta second_meta, u8 *relation_type); - - ISO_EXTERN(ISOErr) - ISOAddMetaDataReference(ISOMeta meta, u16 *out_ref, ISOHandle urlHandle, ISOHandle urnHandle); - - ISO_EXTERN(ISOErr) - ISOAddMetaItem(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, u16 data_ref_index); - ISO_EXTERN(ISOErr) - ISOAddMetaItemWithID(ISOMeta meta, ISOMetaItem *outItem, u64 base_offset, u16 data_ref_index, - u16 item_ID); - - ISO_EXTERN(ISOErr) - ISOAddItemExtent(ISOMetaItem item, MP4Handle data); - ISO_EXTERN(ISOErr) - ISOAddItemExtentReference(ISOMetaItem item, u64 offset, u64 length); - ISO_EXTERN(ISOErr) - ISOAddItemExtentUsingItemData(ISOMetaItem item, MP4Handle data); - ISO_EXTERN(ISOErr) - ISOAddItemExtentItem(ISOMetaItem item, ISOMetaItem extent_item, u32 offset, u32 length); - - ISO_EXTERN(ISOErr) - ISOAddItemReference(ISOMetaItem item, u32 reference_type, u32 to_item_ID, u32 *outIndex); - ISO_EXTERN(ISOErr) - ISOAddItemReferences(ISOMetaItem item, u32 reference_type, u16 reference_count, - MP4Handle to_item_IDs); - ISO_EXTERN(ISOErr) - ISOGetItemReferences(ISOMetaItem item, u32 reference_type, u16 *reference_count, - MP4Handle to_item_IDs); - ISO_EXTERN(ISOErr) - ISOGetItemReference(ISOMetaItem item, u32 reference_type, u16 reference_index, - ISOMetaItem *outItem); - ISO_EXTERN(ISOErr) - ISOAddPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom); - ISO_EXTERN(ISOErr) - ISOGetPrimaryData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom); - ISO_EXTERN(ISOErr) - ISOGetPrimaryItemData(ISOMeta meta, u32 box_type, MP4Handle data, u8 is_full_atom); - - ISO_EXTERN(ISOErr) - ISOSetPrimaryItem(ISOMeta meta, ISOMetaItem item); - ISO_EXTERN(ISOErr) - ISOGetPrimaryItemID(ISOMeta meta, u16 *ID); - - ISO_EXTERN(ISOErr) - ISOGetItemID(ISOMetaItem item, u16 *ID); - - ISO_EXTERN(ISOErr) - ISOSetItemInfo(ISOMetaItem item, u16 protection_index, char *name, char *content_type, - char *content_encoding); - - ISO_EXTERN(ISOErr) - ISOSetItemInfoExtension(ISOMetaItem item, MP4Handle extension, u32 extension_type); - ISO_EXTERN(ISOErr) - ISOGetItemInfoExtension(ISOMetaItem item, MP4Handle extension, u32 *extension_type); - - ISO_EXTERN(ISOErr) - ISOSetItemInfoItemType(ISOMetaItem item, u32 item_type, char *item_uri_type); - ISO_EXTERN(ISOErr) - ISOGetItemInfoItemType(ISOMetaItem item, u32 *item_type, char **item_uri_type); - - ISO_EXTERN(ISOErr) - ISOGetFileMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, u32 *outMetaType); - ISO_EXTERN(ISOErr) - ISOGetMovieMeta(ISOMovie theMovie, ISOMeta *meta, u32 inMetaType, u32 *outMetaType); - ISO_EXTERN(ISOErr) - ISOGetTrackMeta(ISOTrack theTrack, ISOMeta *meta, u32 inMetaType, u32 *outMetaType); - - ISO_EXTERN(ISOErr) - ISOGetAllItemsWithType(ISOMeta meta, u32 type, ISOMetaItem **items, u32 *numberOfItemsFound); - ISO_EXTERN(ISOErr) - ISOFindItemByName(ISOMeta meta, ISOMetaItem *item, char *name, u8 exact_case); - ISO_EXTERN(ISOErr) - ISOFindItemByID(ISOMeta meta, ISOMetaItem *item, u16 ID); - - ISO_EXTERN(ISOErr) - ISOGetItemData(ISOMetaItem item, MP4Handle data, u64 *base_offset); - - ISO_EXTERN(ISOErr) - ISOGetItemInfo(ISOMetaItem item, u16 *protection_index, char *name, char *content_type, - char *content_encoding); - - ISO_EXTERN(MP4Err) - ISOCheckMetaDataReferences(ISOMeta meta); - - ISO_EXTERN(MP4Err) - ISONewMetaProtection(ISOMeta meta, u32 sch_type, u32 sch_version, char *sch_url, - u16 *protection_index); - - ISO_EXTERN(MP4Err) - ISOAddMetaProtectionInfo(ISOMeta meta, u16 protection_index, MP4GenericAtom schi_atom); - - ISO_EXTERN(MP4Err) - ISOGetMetaProtection(ISOMeta meta, u16 protection_index, u32 *sch_type, u32 *sch_version, - char *sch_url); - - ISO_EXTERN(MP4Err) - ISOGetMetaProtectionInfo(ISOMeta meta, u16 protection_index, u32 atom_type, - MP4GenericAtom *schi_atom); - - ISO_EXTERN(MP4Err) - ISOAddMetaItemProperty(ISOMetaItem item, MP4GenericAtom *itemProperty, u8 essential); - - ISO_EXTERN(MP4Err) - ISOGetProperitesOfMetaItem(ISOMetaItem item, MP4GenericAtom **properties, u32 *propertiesFound); +ISO_EXTERN(MP4Err) ISOGetProperitesOfMetaItem(ISOMetaItem item, MP4GenericAtom **properties, + u32 *propertiesFound); #ifdef PRAGMA_EXPORT #pragma export on From da1e33044b51e2a92f8ee1e9d4e2056917508060 Mon Sep 17 00:00:00 2001 From: Dimitri Podborski Date: Tue, 29 Dec 2020 18:14:39 +0100 Subject: [PATCH 45/55] doxygen-style comments for the entire API adding the Doxyfile which can be used to generate doxygen documentation. --- Doxyfile | 2553 +++++++++++++++++++ IsoLib/libisomediafile/macosx/MP4OSMacros.h | 50 +- IsoLib/libisomediafile/src/HEVCConfigAtom.c | 43 +- IsoLib/libisomediafile/src/ISOMovies.h | 535 +++- IsoLib/libisomediafile/src/MP4Atoms.c | 48 +- IsoLib/libisomediafile/src/MP4Atoms.h | 48 +- IsoLib/libisomediafile/src/MP4Movies.h | 2477 +++++++++++++----- IsoLib/libisomediafile/src/VCConfigAtom.c | 46 +- 8 files changed, 5023 insertions(+), 777 deletions(-) create mode 100644 Doxyfile diff --git a/Doxyfile b/Doxyfile new file mode 100644 index 0000000..97c9283 --- /dev/null +++ b/Doxyfile @@ -0,0 +1,2553 @@ +# Doxyfile 1.8.18 + +# This file describes the settings to be used by the documentation system +# doxygen (www.doxygen.org) for a project. +# +# All text after a double hash (##) is considered a comment and is placed in +# front of the TAG it is preceding. +# +# All text after a single hash (#) is considered a comment and will be ignored. +# The format is: +# TAG = value [value, ...] +# For lists, items can also be appended using: +# TAG += value [value, ...] +# Values that contain spaces should be placed between quotes (\" \"). + +#--------------------------------------------------------------------------- +# Project related configuration options +#--------------------------------------------------------------------------- + +# This tag specifies the encoding used for all characters in the configuration +# file that follow. The default is UTF-8 which is also the encoding used for all +# text before the first occurrence of this tag. Doxygen uses libiconv (or the +# iconv built into libc) for the transcoding. See +# https://www.gnu.org/software/libiconv/ for the list of possible encodings. +# The default value is: UTF-8. + +DOXYFILE_ENCODING = UTF-8 + +# The PROJECT_NAME tag is a single word (or a sequence of words surrounded by +# double-quotes, unless you are using Doxywizard) that should identify the +# project for which the documentation is generated. This name is used in the +# title of most generated pages and in a few other places. +# The default value is: My Project. + +PROJECT_NAME = "ISOBMFF" + +# The PROJECT_NUMBER tag can be used to enter a project or revision number. This +# could be handy for archiving the generated documentation or if some version +# control system is used. + +PROJECT_NUMBER = + +# Using the PROJECT_BRIEF tag one can provide an optional one line description +# for a project that appears at the top of each page and should give viewer a +# quick idea about the purpose of the project. Keep the description short. + +PROJECT_BRIEF = "ISO Base Media File Format Reference Software Documentation" + +# With the PROJECT_LOGO tag one can specify a logo or an icon that is included +# in the documentation. The maximum height of the logo should not exceed 55 +# pixels and the maximum width should not exceed 200 pixels. Doxygen will copy +# the logo to the output directory. + +PROJECT_LOGO = + +# The OUTPUT_DIRECTORY tag is used to specify the (relative or absolute) path +# into which the generated documentation will be written. If a relative path is +# entered, it will be relative to the location where doxygen was started. If +# left blank the current directory will be used. + +OUTPUT_DIRECTORY = doc + +# If the CREATE_SUBDIRS tag is set to YES then doxygen will create 4096 sub- +# directories (in 2 levels) under the output directory of each output format and +# will distribute the generated files over these directories. Enabling this +# option can be useful when feeding doxygen a huge amount of source files, where +# putting all generated files in the same directory would otherwise causes +# performance problems for the file system. +# The default value is: NO. + +CREATE_SUBDIRS = NO + +# If the ALLOW_UNICODE_NAMES tag is set to YES, doxygen will allow non-ASCII +# characters to appear in the names of generated files. If set to NO, non-ASCII +# characters will be escaped, for example _xE3_x81_x84 will be used for Unicode +# U+3044. +# The default value is: NO. + +ALLOW_UNICODE_NAMES = NO + +# The OUTPUT_LANGUAGE tag is used to specify the language in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all constant output in the proper language. +# Possible values are: Afrikaans, Arabic, Armenian, Brazilian, Catalan, Chinese, +# Chinese-Traditional, Croatian, Czech, Danish, Dutch, English (United States), +# Esperanto, Farsi (Persian), Finnish, French, German, Greek, Hungarian, +# Indonesian, Italian, Japanese, Japanese-en (Japanese with English messages), +# Korean, Korean-en (Korean with English messages), Latvian, Lithuanian, +# Macedonian, Norwegian, Persian (Farsi), Polish, Portuguese, Romanian, Russian, +# Serbian, Serbian-Cyrillic, Slovak, Slovene, Spanish, Swedish, Turkish, +# Ukrainian and Vietnamese. +# The default value is: English. + +OUTPUT_LANGUAGE = English + +# The OUTPUT_TEXT_DIRECTION tag is used to specify the direction in which all +# documentation generated by doxygen is written. Doxygen will use this +# information to generate all generated output in the proper direction. +# Possible values are: None, LTR, RTL and Context. +# The default value is: None. + +OUTPUT_TEXT_DIRECTION = None + +# If the BRIEF_MEMBER_DESC tag is set to YES, doxygen will include brief member +# descriptions after the members that are listed in the file and class +# documentation (similar to Javadoc). Set to NO to disable this. +# The default value is: YES. + +BRIEF_MEMBER_DESC = YES + +# If the REPEAT_BRIEF tag is set to YES, doxygen will prepend the brief +# description of a member or function before the detailed description +# +# Note: If both HIDE_UNDOC_MEMBERS and BRIEF_MEMBER_DESC are set to NO, the +# brief descriptions will be completely suppressed. +# The default value is: YES. + +REPEAT_BRIEF = YES + +# This tag implements a quasi-intelligent brief description abbreviator that is +# used to form the text in various listings. Each string in this list, if found +# as the leading text of the brief description, will be stripped from the text +# and the result, after processing the whole list, is used as the annotated +# text. Otherwise, the brief description is used as-is. If left blank, the +# following values are used ($name is automatically replaced with the name of +# the entity):The $name class, The $name widget, The $name file, is, provides, +# specifies, contains, represents, a, an and the. + +ABBREVIATE_BRIEF = "The $name class" \ + "The $name widget" \ + "The $name file" \ + is \ + provides \ + specifies \ + contains \ + represents \ + a \ + an \ + the + +# If the ALWAYS_DETAILED_SEC and REPEAT_BRIEF tags are both set to YES then +# doxygen will generate a detailed section even if there is only a brief +# description. +# The default value is: NO. + +ALWAYS_DETAILED_SEC = NO + +# If the INLINE_INHERITED_MEMB tag is set to YES, doxygen will show all +# inherited members of a class in the documentation of that class as if those +# members were ordinary class members. Constructors, destructors and assignment +# operators of the base classes will not be shown. +# The default value is: NO. + +INLINE_INHERITED_MEMB = NO + +# If the FULL_PATH_NAMES tag is set to YES, doxygen will prepend the full path +# before files name in the file list and in the header files. If set to NO the +# shortest path that makes the file name unique will be used +# The default value is: YES. + +FULL_PATH_NAMES = YES + +# The STRIP_FROM_PATH tag can be used to strip a user-defined part of the path. +# Stripping is only done if one of the specified strings matches the left-hand +# part of the path. The tag can be used to show relative paths in the file list. +# If left blank the directory from which doxygen is run is used as the path to +# strip. +# +# Note that you can specify absolute paths here, but also relative paths, which +# will be relative from the directory where doxygen is started. +# This tag requires that the tag FULL_PATH_NAMES is set to YES. + +STRIP_FROM_PATH = + +# The STRIP_FROM_INC_PATH tag can be used to strip a user-defined part of the +# path mentioned in the documentation of a class, which tells the reader which +# header file to include in order to use a class. If left blank only the name of +# the header file containing the class definition is used. Otherwise one should +# specify the list of include paths that are normally passed to the compiler +# using the -I flag. + +STRIP_FROM_INC_PATH = + +# If the SHORT_NAMES tag is set to YES, doxygen will generate much shorter (but +# less readable) file names. This can be useful is your file systems doesn't +# support long names like on DOS, Mac, or CD-ROM. +# The default value is: NO. + +SHORT_NAMES = NO + +# If the JAVADOC_AUTOBRIEF tag is set to YES then doxygen will interpret the +# first line (until the first dot) of a Javadoc-style comment as the brief +# description. If set to NO, the Javadoc-style will behave just like regular Qt- +# style comments (thus requiring an explicit @brief command for a brief +# description.) +# The default value is: NO. + +JAVADOC_AUTOBRIEF = YES + +# If the JAVADOC_BANNER tag is set to YES then doxygen will interpret a line +# such as +# /*************** +# as being the beginning of a Javadoc-style comment "banner". If set to NO, the +# Javadoc-style will behave just like regular comments and it will not be +# interpreted by doxygen. +# The default value is: NO. + +JAVADOC_BANNER = NO + +# If the QT_AUTOBRIEF tag is set to YES then doxygen will interpret the first +# line (until the first dot) of a Qt-style comment as the brief description. If +# set to NO, the Qt-style will behave just like regular Qt-style comments (thus +# requiring an explicit \brief command for a brief description.) +# The default value is: NO. + +QT_AUTOBRIEF = NO + +# The MULTILINE_CPP_IS_BRIEF tag can be set to YES to make doxygen treat a +# multi-line C++ special comment block (i.e. a block of //! or /// comments) as +# a brief description. This used to be the default behavior. The new default is +# to treat a multi-line C++ comment block as a detailed description. Set this +# tag to YES if you prefer the old behavior instead. +# +# Note that setting this tag to YES also means that rational rose comments are +# not recognized any more. +# The default value is: NO. + +MULTILINE_CPP_IS_BRIEF = NO + +# If the INHERIT_DOCS tag is set to YES then an undocumented member inherits the +# documentation from any documented member that it re-implements. +# The default value is: YES. + +INHERIT_DOCS = YES + +# If the SEPARATE_MEMBER_PAGES tag is set to YES then doxygen will produce a new +# page for each member. If set to NO, the documentation of a member will be part +# of the file/class/namespace that contains it. +# The default value is: NO. + +SEPARATE_MEMBER_PAGES = NO + +# The TAB_SIZE tag can be used to set the number of spaces in a tab. Doxygen +# uses this value to replace tabs by spaces in code fragments. +# Minimum value: 1, maximum value: 16, default value: 4. + +TAB_SIZE = 4 + +# This tag can be used to specify a number of aliases that act as commands in +# the documentation. An alias has the form: +# name=value +# For example adding +# "sideeffect=@par Side Effects:\n" +# will allow you to put the command \sideeffect (or @sideeffect) in the +# documentation, which will result in a user-defined paragraph with heading +# "Side Effects:". You can put \n's in the value part of an alias to insert +# newlines (in the resulting output). You can put ^^ in the value part of an +# alias to insert a newline as if a physical newline was in the original file. +# When you need a literal { or } or , in the value part of an alias you have to +# escape them by means of a backslash (\), this can lead to conflicts with the +# commands \{ and \} for these it is advised to use the version @{ and @} or use +# a double escape (\\{ and \\}) + +ALIASES = + +# Set the OPTIMIZE_OUTPUT_FOR_C tag to YES if your project consists of C sources +# only. Doxygen will then generate output that is more tailored for C. For +# instance, some of the names that are used will be different. The list of all +# members will be omitted, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_FOR_C = NO + +# Set the OPTIMIZE_OUTPUT_JAVA tag to YES if your project consists of Java or +# Python sources only. Doxygen will then generate output that is more tailored +# for that language. For instance, namespaces will be presented as packages, +# qualified scopes will look different, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_JAVA = NO + +# Set the OPTIMIZE_FOR_FORTRAN tag to YES if your project consists of Fortran +# sources. Doxygen will then generate output that is tailored for Fortran. +# The default value is: NO. + +OPTIMIZE_FOR_FORTRAN = NO + +# Set the OPTIMIZE_OUTPUT_VHDL tag to YES if your project consists of VHDL +# sources. Doxygen will then generate output that is tailored for VHDL. +# The default value is: NO. + +OPTIMIZE_OUTPUT_VHDL = NO + +# Set the OPTIMIZE_OUTPUT_SLICE tag to YES if your project consists of Slice +# sources only. Doxygen will then generate output that is more tailored for that +# language. For instance, namespaces will be presented as modules, types will be +# separated into more groups, etc. +# The default value is: NO. + +OPTIMIZE_OUTPUT_SLICE = NO + +# Doxygen selects the parser to use depending on the extension of the files it +# parses. With this tag you can assign which parser to use for a given +# extension. Doxygen has a built-in mapping, but you can override or extend it +# using this tag. The format is ext=language, where ext is a file extension, and +# language is one of the parsers supported by doxygen: IDL, Java, JavaScript, +# Csharp (C#), C, C++, D, PHP, md (Markdown), Objective-C, Python, Slice, VHDL, +# Fortran (fixed format Fortran: FortranFixed, free formatted Fortran: +# FortranFree, unknown formatted Fortran: Fortran. In the later case the parser +# tries to guess whether the code is fixed or free formatted code, this is the +# default for Fortran type files). For instance to make doxygen treat .inc files +# as Fortran files (default is PHP), and .f files as C (default is Fortran), +# use: inc=Fortran f=C. +# +# Note: For files without extension you can use no_extension as a placeholder. +# +# Note that for custom extensions you also need to set FILE_PATTERNS otherwise +# the files are not read by doxygen. + +EXTENSION_MAPPING = + +# If the MARKDOWN_SUPPORT tag is enabled then doxygen pre-processes all comments +# according to the Markdown format, which allows for more readable +# documentation. See https://daringfireball.net/projects/markdown/ for details. +# The output of markdown processing is further processed by doxygen, so you can +# mix doxygen, HTML, and XML commands with Markdown formatting. Disable only in +# case of backward compatibilities issues. +# The default value is: YES. + +MARKDOWN_SUPPORT = YES + +# When the TOC_INCLUDE_HEADINGS tag is set to a non-zero value, all headings up +# to that level are automatically included in the table of contents, even if +# they do not have an id attribute. +# Note: This feature currently applies only to Markdown headings. +# Minimum value: 0, maximum value: 99, default value: 5. +# This tag requires that the tag MARKDOWN_SUPPORT is set to YES. + +TOC_INCLUDE_HEADINGS = 5 + +# When enabled doxygen tries to link words that correspond to documented +# classes, or namespaces to their corresponding documentation. Such a link can +# be prevented in individual cases by putting a % sign in front of the word or +# globally by setting AUTOLINK_SUPPORT to NO. +# The default value is: YES. + +AUTOLINK_SUPPORT = YES + +# If you use STL classes (i.e. std::string, std::vector, etc.) but do not want +# to include (a tag file for) the STL sources as input, then you should set this +# tag to YES in order to let doxygen match functions declarations and +# definitions whose arguments contain STL classes (e.g. func(std::string); +# versus func(std::string) {}). This also make the inheritance and collaboration +# diagrams that involve STL classes more complete and accurate. +# The default value is: NO. + +BUILTIN_STL_SUPPORT = NO + +# If you use Microsoft's C++/CLI language, you should set this option to YES to +# enable parsing support. +# The default value is: NO. + +CPP_CLI_SUPPORT = NO + +# Set the SIP_SUPPORT tag to YES if your project consists of sip (see: +# https://www.riverbankcomputing.com/software/sip/intro) sources only. Doxygen +# will parse them like normal C++ but will assume all classes use public instead +# of private inheritance when no explicit protection keyword is present. +# The default value is: NO. + +SIP_SUPPORT = NO + +# For Microsoft's IDL there are propget and propput attributes to indicate +# getter and setter methods for a property. Setting this option to YES will make +# doxygen to replace the get and set methods by a property in the documentation. +# This will only work if the methods are indeed getting or setting a simple +# type. If this is not the case, or you want to show the methods anyway, you +# should set this option to NO. +# The default value is: YES. + +IDL_PROPERTY_SUPPORT = YES + +# If member grouping is used in the documentation and the DISTRIBUTE_GROUP_DOC +# tag is set to YES then doxygen will reuse the documentation of the first +# member in the group (if any) for the other members of the group. By default +# all members of a group must be documented explicitly. +# The default value is: NO. + +DISTRIBUTE_GROUP_DOC = NO + +# If one adds a struct or class to a group and this option is enabled, then also +# any nested class or struct is added to the same group. By default this option +# is disabled and one has to add nested compounds explicitly via \ingroup. +# The default value is: NO. + +GROUP_NESTED_COMPOUNDS = NO + +# Set the SUBGROUPING tag to YES to allow class member groups of the same type +# (for instance a group of public functions) to be put as a subgroup of that +# type (e.g. under the Public Functions section). Set it to NO to prevent +# subgrouping. Alternatively, this can be done per class using the +# \nosubgrouping command. +# The default value is: YES. + +SUBGROUPING = YES + +# When the INLINE_GROUPED_CLASSES tag is set to YES, classes, structs and unions +# are shown inside the group in which they are included (e.g. using \ingroup) +# instead of on a separate page (for HTML and Man pages) or section (for LaTeX +# and RTF). +# +# Note that this feature does not work in combination with +# SEPARATE_MEMBER_PAGES. +# The default value is: NO. + +INLINE_GROUPED_CLASSES = NO + +# When the INLINE_SIMPLE_STRUCTS tag is set to YES, structs, classes, and unions +# with only public data fields or simple typedef fields will be shown inline in +# the documentation of the scope in which they are defined (i.e. file, +# namespace, or group documentation), provided this scope is documented. If set +# to NO, structs, classes, and unions are shown on a separate page (for HTML and +# Man pages) or section (for LaTeX and RTF). +# The default value is: NO. + +INLINE_SIMPLE_STRUCTS = NO + +# When TYPEDEF_HIDES_STRUCT tag is enabled, a typedef of a struct, union, or +# enum is documented as struct, union, or enum with the name of the typedef. So +# typedef struct TypeS {} TypeT, will appear in the documentation as a struct +# with name TypeT. When disabled the typedef will appear as a member of a file, +# namespace, or class. And the struct will be named TypeS. This can typically be +# useful for C code in case the coding convention dictates that all compound +# types are typedef'ed and only the typedef is referenced, never the tag name. +# The default value is: NO. + +TYPEDEF_HIDES_STRUCT = NO + +# The size of the symbol lookup cache can be set using LOOKUP_CACHE_SIZE. This +# cache is used to resolve symbols given their name and scope. Since this can be +# an expensive process and often the same symbol appears multiple times in the +# code, doxygen keeps a cache of pre-resolved symbols. If the cache is too small +# doxygen will become slower. If the cache is too large, memory is wasted. The +# cache size is given by this formula: 2^(16+LOOKUP_CACHE_SIZE). The valid range +# is 0..9, the default is 0, corresponding to a cache size of 2^16=65536 +# symbols. At the end of a run doxygen will report the cache usage and suggest +# the optimal cache size from a speed point of view. +# Minimum value: 0, maximum value: 9, default value: 0. + +LOOKUP_CACHE_SIZE = 0 + +#--------------------------------------------------------------------------- +# Build related configuration options +#--------------------------------------------------------------------------- + +# If the EXTRACT_ALL tag is set to YES, doxygen will assume all entities in +# documentation are documented, even if no documentation was available. Private +# class members and static file members will be hidden unless the +# EXTRACT_PRIVATE respectively EXTRACT_STATIC tags are set to YES. +# Note: This will also disable the warnings about undocumented members that are +# normally produced when WARNINGS is set to YES. +# The default value is: NO. + +EXTRACT_ALL = NO + +# If the EXTRACT_PRIVATE tag is set to YES, all private members of a class will +# be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIVATE = NO + +# If the EXTRACT_PRIV_VIRTUAL tag is set to YES, documented private virtual +# methods of a class will be included in the documentation. +# The default value is: NO. + +EXTRACT_PRIV_VIRTUAL = NO + +# If the EXTRACT_PACKAGE tag is set to YES, all members with package or internal +# scope will be included in the documentation. +# The default value is: NO. + +EXTRACT_PACKAGE = NO + +# If the EXTRACT_STATIC tag is set to YES, all static members of a file will be +# included in the documentation. +# The default value is: NO. + +EXTRACT_STATIC = NO + +# If the EXTRACT_LOCAL_CLASSES tag is set to YES, classes (and structs) defined +# locally in source files will be included in the documentation. If set to NO, +# only classes defined in header files are included. Does not have any effect +# for Java sources. +# The default value is: YES. + +EXTRACT_LOCAL_CLASSES = YES + +# This flag is only useful for Objective-C code. If set to YES, local methods, +# which are defined in the implementation section but not in the interface are +# included in the documentation. If set to NO, only methods in the interface are +# included. +# The default value is: NO. + +EXTRACT_LOCAL_METHODS = NO + +# If this flag is set to YES, the members of anonymous namespaces will be +# extracted and appear in the documentation as a namespace called +# 'anonymous_namespace{file}', where file will be replaced with the base name of +# the file that contains the anonymous namespace. By default anonymous namespace +# are hidden. +# The default value is: NO. + +EXTRACT_ANON_NSPACES = NO + +# If the HIDE_UNDOC_MEMBERS tag is set to YES, doxygen will hide all +# undocumented members inside documented classes or files. If set to NO these +# members will be included in the various overviews, but no documentation +# section is generated. This option has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_MEMBERS = NO + +# If the HIDE_UNDOC_CLASSES tag is set to YES, doxygen will hide all +# undocumented classes that are normally visible in the class hierarchy. If set +# to NO, these classes will be included in the various overviews. This option +# has no effect if EXTRACT_ALL is enabled. +# The default value is: NO. + +HIDE_UNDOC_CLASSES = NO + +# If the HIDE_FRIEND_COMPOUNDS tag is set to YES, doxygen will hide all friend +# declarations. If set to NO, these declarations will be included in the +# documentation. +# The default value is: NO. + +HIDE_FRIEND_COMPOUNDS = NO + +# If the HIDE_IN_BODY_DOCS tag is set to YES, doxygen will hide any +# documentation blocks found inside the body of a function. If set to NO, these +# blocks will be appended to the function's detailed documentation block. +# The default value is: NO. + +HIDE_IN_BODY_DOCS = NO + +# The INTERNAL_DOCS tag determines if documentation that is typed after a +# \internal command is included. If the tag is set to NO then the documentation +# will be excluded. Set it to YES to include the internal documentation. +# The default value is: NO. + +INTERNAL_DOCS = NO + +# If the CASE_SENSE_NAMES tag is set to NO then doxygen will only generate file +# names in lower-case letters. If set to YES, upper-case letters are also +# allowed. This is useful if you have classes or files whose names only differ +# in case and if your file system supports case sensitive file names. Windows +# (including Cygwin) ands Mac users are advised to set this option to NO. +# The default value is: system dependent. + +CASE_SENSE_NAMES = NO + +# If the HIDE_SCOPE_NAMES tag is set to NO then doxygen will show members with +# their full class and namespace scopes in the documentation. If set to YES, the +# scope will be hidden. +# The default value is: NO. + +HIDE_SCOPE_NAMES = NO + +# If the HIDE_COMPOUND_REFERENCE tag is set to NO (default) then doxygen will +# append additional text to a page's title, such as Class Reference. If set to +# YES the compound reference will be hidden. +# The default value is: NO. + +HIDE_COMPOUND_REFERENCE= NO + +# If the SHOW_INCLUDE_FILES tag is set to YES then doxygen will put a list of +# the files that are included by a file in the documentation of that file. +# The default value is: YES. + +SHOW_INCLUDE_FILES = YES + +# If the SHOW_GROUPED_MEMB_INC tag is set to YES then Doxygen will add for each +# grouped member an include statement to the documentation, telling the reader +# which file to include in order to use the member. +# The default value is: NO. + +SHOW_GROUPED_MEMB_INC = NO + +# If the FORCE_LOCAL_INCLUDES tag is set to YES then doxygen will list include +# files with double quotes in the documentation rather than with sharp brackets. +# The default value is: NO. + +FORCE_LOCAL_INCLUDES = NO + +# If the INLINE_INFO tag is set to YES then a tag [inline] is inserted in the +# documentation for inline members. +# The default value is: YES. + +INLINE_INFO = YES + +# If the SORT_MEMBER_DOCS tag is set to YES then doxygen will sort the +# (detailed) documentation of file and class members alphabetically by member +# name. If set to NO, the members will appear in declaration order. +# The default value is: YES. + +SORT_MEMBER_DOCS = YES + +# If the SORT_BRIEF_DOCS tag is set to YES then doxygen will sort the brief +# descriptions of file, namespace and class members alphabetically by member +# name. If set to NO, the members will appear in declaration order. Note that +# this will also influence the order of the classes in the class list. +# The default value is: NO. + +SORT_BRIEF_DOCS = NO + +# If the SORT_MEMBERS_CTORS_1ST tag is set to YES then doxygen will sort the +# (brief and detailed) documentation of class members so that constructors and +# destructors are listed first. If set to NO the constructors will appear in the +# respective orders defined by SORT_BRIEF_DOCS and SORT_MEMBER_DOCS. +# Note: If SORT_BRIEF_DOCS is set to NO this option is ignored for sorting brief +# member documentation. +# Note: If SORT_MEMBER_DOCS is set to NO this option is ignored for sorting +# detailed member documentation. +# The default value is: NO. + +SORT_MEMBERS_CTORS_1ST = NO + +# If the SORT_GROUP_NAMES tag is set to YES then doxygen will sort the hierarchy +# of group names into alphabetical order. If set to NO the group names will +# appear in their defined order. +# The default value is: NO. + +SORT_GROUP_NAMES = NO + +# If the SORT_BY_SCOPE_NAME tag is set to YES, the class list will be sorted by +# fully-qualified names, including namespaces. If set to NO, the class list will +# be sorted only by class name, not including the namespace part. +# Note: This option is not very useful if HIDE_SCOPE_NAMES is set to YES. +# Note: This option applies only to the class list, not to the alphabetical +# list. +# The default value is: NO. + +SORT_BY_SCOPE_NAME = NO + +# If the STRICT_PROTO_MATCHING option is enabled and doxygen fails to do proper +# type resolution of all parameters of a function it will reject a match between +# the prototype and the implementation of a member function even if there is +# only one candidate or it is obvious which candidate to choose by doing a +# simple string match. By disabling STRICT_PROTO_MATCHING doxygen will still +# accept a match between prototype and implementation in such cases. +# The default value is: NO. + +STRICT_PROTO_MATCHING = NO + +# The GENERATE_TODOLIST tag can be used to enable (YES) or disable (NO) the todo +# list. This list is created by putting \todo commands in the documentation. +# The default value is: YES. + +GENERATE_TODOLIST = YES + +# The GENERATE_TESTLIST tag can be used to enable (YES) or disable (NO) the test +# list. This list is created by putting \test commands in the documentation. +# The default value is: YES. + +GENERATE_TESTLIST = YES + +# The GENERATE_BUGLIST tag can be used to enable (YES) or disable (NO) the bug +# list. This list is created by putting \bug commands in the documentation. +# The default value is: YES. + +GENERATE_BUGLIST = YES + +# The GENERATE_DEPRECATEDLIST tag can be used to enable (YES) or disable (NO) +# the deprecated list. This list is created by putting \deprecated commands in +# the documentation. +# The default value is: YES. + +GENERATE_DEPRECATEDLIST= YES + +# The ENABLED_SECTIONS tag can be used to enable conditional documentation +# sections, marked by \if ... \endif and \cond +# ... \endcond blocks. + +ENABLED_SECTIONS = + +# The MAX_INITIALIZER_LINES tag determines the maximum number of lines that the +# initial value of a variable or macro / define can have for it to appear in the +# documentation. If the initializer consists of more lines than specified here +# it will be hidden. Use a value of 0 to hide initializers completely. The +# appearance of the value of individual variables and macros / defines can be +# controlled using \showinitializer or \hideinitializer command in the +# documentation regardless of this setting. +# Minimum value: 0, maximum value: 10000, default value: 30. + +MAX_INITIALIZER_LINES = 30 + +# Set the SHOW_USED_FILES tag to NO to disable the list of files generated at +# the bottom of the documentation of classes and structs. If set to YES, the +# list will mention the files that were used to generate the documentation. +# The default value is: YES. + +SHOW_USED_FILES = NO + +# Set the SHOW_FILES tag to NO to disable the generation of the Files page. This +# will remove the Files entry from the Quick Index and from the Folder Tree View +# (if specified). +# The default value is: YES. + +SHOW_FILES = YES + +# Set the SHOW_NAMESPACES tag to NO to disable the generation of the Namespaces +# page. This will remove the Namespaces entry from the Quick Index and from the +# Folder Tree View (if specified). +# The default value is: YES. + +SHOW_NAMESPACES = YES + +# The FILE_VERSION_FILTER tag can be used to specify a program or script that +# doxygen should invoke to get the current version for each file (typically from +# the version control system). Doxygen will invoke the program by executing (via +# popen()) the command command input-file, where command is the value of the +# FILE_VERSION_FILTER tag, and input-file is the name of an input file provided +# by doxygen. Whatever the program writes to standard output is used as the file +# version. For an example see the documentation. + +FILE_VERSION_FILTER = + +# The LAYOUT_FILE tag can be used to specify a layout file which will be parsed +# by doxygen. The layout file controls the global structure of the generated +# output files in an output format independent way. To create the layout file +# that represents doxygen's defaults, run doxygen with the -l option. You can +# optionally specify a file name after the option, if omitted DoxygenLayout.xml +# will be used as the name of the layout file. +# +# Note that if you run doxygen from a directory containing a file called +# DoxygenLayout.xml, doxygen will parse it automatically even if the LAYOUT_FILE +# tag is left empty. + +LAYOUT_FILE = + +# The CITE_BIB_FILES tag can be used to specify one or more bib files containing +# the reference definitions. This must be a list of .bib files. The .bib +# extension is automatically appended if omitted. This requires the bibtex tool +# to be installed. See also https://en.wikipedia.org/wiki/BibTeX for more info. +# For LaTeX the style of the bibliography can be controlled using +# LATEX_BIB_STYLE. To use this feature you need bibtex and perl available in the +# search path. See also \cite for info how to create references. + +CITE_BIB_FILES = + +#--------------------------------------------------------------------------- +# Configuration options related to warning and progress messages +#--------------------------------------------------------------------------- + +# The QUIET tag can be used to turn on/off the messages that are generated to +# standard output by doxygen. If QUIET is set to YES this implies that the +# messages are off. +# The default value is: NO. + +QUIET = NO + +# The WARNINGS tag can be used to turn on/off the warning messages that are +# generated to standard error (stderr) by doxygen. If WARNINGS is set to YES +# this implies that the warnings are on. +# +# Tip: Turn warnings on while writing the documentation. +# The default value is: YES. + +WARNINGS = YES + +# If the WARN_IF_UNDOCUMENTED tag is set to YES then doxygen will generate +# warnings for undocumented members. If EXTRACT_ALL is set to YES then this flag +# will automatically be disabled. +# The default value is: YES. + +WARN_IF_UNDOCUMENTED = YES + +# If the WARN_IF_DOC_ERROR tag is set to YES, doxygen will generate warnings for +# potential errors in the documentation, such as not documenting some parameters +# in a documented function, or documenting parameters that don't exist or using +# markup commands wrongly. +# The default value is: YES. + +WARN_IF_DOC_ERROR = YES + +# This WARN_NO_PARAMDOC option can be enabled to get warnings for functions that +# are documented, but have no documentation for their parameters or return +# value. If set to NO, doxygen will only warn about wrong or incomplete +# parameter documentation, but not about the absence of documentation. If +# EXTRACT_ALL is set to YES then this flag will automatically be disabled. +# The default value is: NO. + +WARN_NO_PARAMDOC = NO + +# If the WARN_AS_ERROR tag is set to YES then doxygen will immediately stop when +# a warning is encountered. +# The default value is: NO. + +WARN_AS_ERROR = NO + +# The WARN_FORMAT tag determines the format of the warning messages that doxygen +# can produce. The string should contain the $file, $line, and $text tags, which +# will be replaced by the file and line number from which the warning originated +# and the warning text. Optionally the format may contain $version, which will +# be replaced by the version of the file (if it could be obtained via +# FILE_VERSION_FILTER) +# The default value is: $file:$line: $text. + +WARN_FORMAT = "$file:$line: $text" + +# The WARN_LOGFILE tag can be used to specify a file to which warning and error +# messages should be written. If left blank the output is written to standard +# error (stderr). + +WARN_LOGFILE = + +#--------------------------------------------------------------------------- +# Configuration options related to the input files +#--------------------------------------------------------------------------- + +# The INPUT tag is used to specify the files and/or directories that contain +# documented source files. You may enter file names like myfile.cpp or +# directories like /usr/src/myproject. Separate the files or directories with +# spaces. See also FILE_PATTERNS and EXTENSION_MAPPING +# Note: If this tag is empty the current directory is searched. + +INPUT = IsoLib/libisomediafile/src/ISOMovies.h IsoLib/libisomediafile/src/MP4Movies.h IsoLib/libisomediafile/macosx/MP4OSMacros.h + +# This tag can be used to specify the character encoding of the source files +# that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses +# libiconv (or the iconv built into libc) for the transcoding. See the libiconv +# documentation (see: https://www.gnu.org/software/libiconv/) for the list of +# possible encodings. +# The default value is: UTF-8. + +INPUT_ENCODING = UTF-8 + +# If the value of the INPUT tag contains directories, you can use the +# FILE_PATTERNS tag to specify one or more wildcard patterns (like *.cpp and +# *.h) to filter out the source-files in the directories. +# +# Note that for custom extensions or not directly supported extensions you also +# need to set EXTENSION_MAPPING for the extension otherwise the files are not +# read by doxygen. +# +# If left blank the following patterns are tested:*.c, *.cc, *.cxx, *.cpp, +# *.c++, *.java, *.ii, *.ixx, *.ipp, *.i++, *.inl, *.idl, *.ddl, *.odl, *.h, +# *.hh, *.hxx, *.hpp, *.h++, *.cs, *.d, *.php, *.php4, *.php5, *.phtml, *.inc, +# *.m, *.markdown, *.md, *.mm, *.dox (to be provided as doxygen C comment), +# *.doc (to be provided as doxygen C comment), *.txt (to be provided as doxygen +# C comment), *.py, *.pyw, *.f90, *.f95, *.f03, *.f08, *.f18, *.f, *.for, *.vhd, +# *.vhdl, *.ucf, *.qsf and *.ice. + +FILE_PATTERNS = *.c \ + *.cc \ + *.cxx \ + *.cpp \ + *.c++ \ + *.java \ + *.ii \ + *.ixx \ + *.ipp \ + *.i++ \ + *.inl \ + *.idl \ + *.ddl \ + *.odl \ + *.h \ + *.hh \ + *.hxx \ + *.hpp \ + *.h++ \ + *.cs \ + *.d \ + *.php \ + *.php4 \ + *.php5 \ + *.phtml \ + *.inc \ + *.m \ + *.markdown \ + *.md \ + *.mm \ + *.dox \ + *.doc \ + *.txt \ + *.py \ + *.pyw \ + *.f90 \ + *.f95 \ + *.f03 \ + *.f08 \ + *.f18 \ + *.f \ + *.for \ + *.vhd \ + *.vhdl \ + *.ucf \ + *.qsf \ + *.ice + +# The RECURSIVE tag can be used to specify whether or not subdirectories should +# be searched for input files as well. +# The default value is: NO. + +RECURSIVE = YES + +# The EXCLUDE tag can be used to specify files and/or directories that should be +# excluded from the INPUT source files. This way you can easily exclude a +# subdirectory from a directory tree whose root is specified with the INPUT tag. +# +# Note that relative paths are relative to the directory from which doxygen is +# run. + +EXCLUDE = + +# The EXCLUDE_SYMLINKS tag can be used to select whether or not files or +# directories that are symbolic links (a Unix file system feature) are excluded +# from the input. +# The default value is: NO. + +EXCLUDE_SYMLINKS = NO + +# If the value of the INPUT tag contains directories, you can use the +# EXCLUDE_PATTERNS tag to specify one or more wildcard patterns to exclude +# certain files from those directories. +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories for example use the pattern */test/* + +EXCLUDE_PATTERNS = + +# The EXCLUDE_SYMBOLS tag can be used to specify one or more symbol names +# (namespaces, classes, functions, etc.) that should be excluded from the +# output. The symbol name can be a fully qualified name, a word, or if the +# wildcard * is used, a substring. Examples: ANamespace, AClass, +# AClass::ANamespace, ANamespace::*Test +# +# Note that the wildcards are matched against the file with absolute path, so to +# exclude all test directories use the pattern */test/* + +EXCLUDE_SYMBOLS = + +# The EXAMPLE_PATH tag can be used to specify one or more files or directories +# that contain example code fragments that are included (see the \include +# command). + +EXAMPLE_PATH = + +# If the value of the EXAMPLE_PATH tag contains directories, you can use the +# EXAMPLE_PATTERNS tag to specify one or more wildcard pattern (like *.cpp and +# *.h) to filter out the source-files in the directories. If left blank all +# files are included. + +EXAMPLE_PATTERNS = * + +# If the EXAMPLE_RECURSIVE tag is set to YES then subdirectories will be +# searched for input files to be used with the \include or \dontinclude commands +# irrespective of the value of the RECURSIVE tag. +# The default value is: NO. + +EXAMPLE_RECURSIVE = NO + +# The IMAGE_PATH tag can be used to specify one or more files or directories +# that contain images that are to be included in the documentation (see the +# \image command). + +IMAGE_PATH = + +# The INPUT_FILTER tag can be used to specify a program that doxygen should +# invoke to filter for each input file. Doxygen will invoke the filter program +# by executing (via popen()) the command: +# +# +# +# where is the value of the INPUT_FILTER tag, and is the +# name of an input file. Doxygen will then use the output that the filter +# program writes to standard output. If FILTER_PATTERNS is specified, this tag +# will be ignored. +# +# Note that the filter must not add or remove lines; it is applied before the +# code is scanned, but not when the output code is generated. If lines are added +# or removed, the anchors will not be placed correctly. +# +# Note that for custom extensions or not directly supported extensions you also +# need to set EXTENSION_MAPPING for the extension otherwise the files are not +# properly processed by doxygen. + +INPUT_FILTER = + +# The FILTER_PATTERNS tag can be used to specify filters on a per file pattern +# basis. Doxygen will compare the file name with each pattern and apply the +# filter if there is a match. The filters are a list of the form: pattern=filter +# (like *.cpp=my_cpp_filter). See INPUT_FILTER for further information on how +# filters are used. If the FILTER_PATTERNS tag is empty or if none of the +# patterns match the file name, INPUT_FILTER is applied. +# +# Note that for custom extensions or not directly supported extensions you also +# need to set EXTENSION_MAPPING for the extension otherwise the files are not +# properly processed by doxygen. + +FILTER_PATTERNS = + +# If the FILTER_SOURCE_FILES tag is set to YES, the input filter (if set using +# INPUT_FILTER) will also be used to filter the input files that are used for +# producing the source files to browse (i.e. when SOURCE_BROWSER is set to YES). +# The default value is: NO. + +FILTER_SOURCE_FILES = NO + +# The FILTER_SOURCE_PATTERNS tag can be used to specify source filters per file +# pattern. A pattern will override the setting for FILTER_PATTERN (if any) and +# it is also possible to disable source filtering for a specific pattern using +# *.ext= (so without naming a filter). +# This tag requires that the tag FILTER_SOURCE_FILES is set to YES. + +FILTER_SOURCE_PATTERNS = + +# If the USE_MDFILE_AS_MAINPAGE tag refers to the name of a markdown file that +# is part of the input, its contents will be placed on the main page +# (index.html). This can be useful if you have a project on for instance GitHub +# and want to reuse the introduction page also for the doxygen output. + +USE_MDFILE_AS_MAINPAGE = + +#--------------------------------------------------------------------------- +# Configuration options related to source browsing +#--------------------------------------------------------------------------- + +# If the SOURCE_BROWSER tag is set to YES then a list of source files will be +# generated. Documented entities will be cross-referenced with these sources. +# +# Note: To get rid of all source code in the generated output, make sure that +# also VERBATIM_HEADERS is set to NO. +# The default value is: NO. + +SOURCE_BROWSER = NO + +# Setting the INLINE_SOURCES tag to YES will include the body of functions, +# classes and enums directly into the documentation. +# The default value is: NO. + +INLINE_SOURCES = NO + +# Setting the STRIP_CODE_COMMENTS tag to YES will instruct doxygen to hide any +# special comment blocks from generated source code fragments. Normal C, C++ and +# Fortran comments will always remain visible. +# The default value is: YES. + +STRIP_CODE_COMMENTS = YES + +# If the REFERENCED_BY_RELATION tag is set to YES then for each documented +# entity all documented functions referencing it will be listed. +# The default value is: NO. + +REFERENCED_BY_RELATION = NO + +# If the REFERENCES_RELATION tag is set to YES then for each documented function +# all documented entities called/used by that function will be listed. +# The default value is: NO. + +REFERENCES_RELATION = NO + +# If the REFERENCES_LINK_SOURCE tag is set to YES and SOURCE_BROWSER tag is set +# to YES then the hyperlinks from functions in REFERENCES_RELATION and +# REFERENCED_BY_RELATION lists will link to the source code. Otherwise they will +# link to the documentation. +# The default value is: YES. + +REFERENCES_LINK_SOURCE = YES + +# If SOURCE_TOOLTIPS is enabled (the default) then hovering a hyperlink in the +# source code will show a tooltip with additional information such as prototype, +# brief description and links to the definition and documentation. Since this +# will make the HTML file larger and loading of large files a bit slower, you +# can opt to disable this feature. +# The default value is: YES. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +SOURCE_TOOLTIPS = YES + +# If the USE_HTAGS tag is set to YES then the references to source code will +# point to the HTML generated by the htags(1) tool instead of doxygen built-in +# source browser. The htags tool is part of GNU's global source tagging system +# (see https://www.gnu.org/software/global/global.html). You will need version +# 4.8.6 or higher. +# +# To use it do the following: +# - Install the latest version of global +# - Enable SOURCE_BROWSER and USE_HTAGS in the configuration file +# - Make sure the INPUT points to the root of the source tree +# - Run doxygen as normal +# +# Doxygen will invoke htags (and that will in turn invoke gtags), so these +# tools must be available from the command line (i.e. in the search path). +# +# The result: instead of the source browser generated by doxygen, the links to +# source code will now point to the output of htags. +# The default value is: NO. +# This tag requires that the tag SOURCE_BROWSER is set to YES. + +USE_HTAGS = NO + +# If the VERBATIM_HEADERS tag is set the YES then doxygen will generate a +# verbatim copy of the header file for each class for which an include is +# specified. Set to NO to disable this. +# See also: Section \class. +# The default value is: YES. + +VERBATIM_HEADERS = YES + +#--------------------------------------------------------------------------- +# Configuration options related to the alphabetical class index +#--------------------------------------------------------------------------- + +# If the ALPHABETICAL_INDEX tag is set to YES, an alphabetical index of all +# compounds will be generated. Enable this if the project contains a lot of +# classes, structs, unions or interfaces. +# The default value is: YES. + +ALPHABETICAL_INDEX = YES + +# The COLS_IN_ALPHA_INDEX tag can be used to specify the number of columns in +# which the alphabetical index list will be split. +# Minimum value: 1, maximum value: 20, default value: 5. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +COLS_IN_ALPHA_INDEX = 5 + +# In case all classes in a project start with a common prefix, all classes will +# be put under the same header in the alphabetical index. The IGNORE_PREFIX tag +# can be used to specify a prefix (or a list of prefixes) that should be ignored +# while generating the index headers. +# This tag requires that the tag ALPHABETICAL_INDEX is set to YES. + +IGNORE_PREFIX = + +#--------------------------------------------------------------------------- +# Configuration options related to the HTML output +#--------------------------------------------------------------------------- + +# If the GENERATE_HTML tag is set to YES, doxygen will generate HTML output +# The default value is: YES. + +GENERATE_HTML = YES + +# The HTML_OUTPUT tag is used to specify where the HTML docs will be put. If a +# relative path is entered the value of OUTPUT_DIRECTORY will be put in front of +# it. +# The default directory is: html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_OUTPUT = html + +# The HTML_FILE_EXTENSION tag can be used to specify the file extension for each +# generated HTML page (for example: .htm, .php, .asp). +# The default value is: .html. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FILE_EXTENSION = .html + +# The HTML_HEADER tag can be used to specify a user-defined HTML header file for +# each generated HTML page. If the tag is left blank doxygen will generate a +# standard header. +# +# To get valid HTML the header file that includes any scripts and style sheets +# that doxygen needs, which is dependent on the configuration options used (e.g. +# the setting GENERATE_TREEVIEW). It is highly recommended to start with a +# default header using +# doxygen -w html new_header.html new_footer.html new_stylesheet.css +# YourConfigFile +# and then modify the file new_header.html. See also section "Doxygen usage" +# for information on how to generate the default header that doxygen normally +# uses. +# Note: The header is subject to change so you typically have to regenerate the +# default header when upgrading to a newer version of doxygen. For a description +# of the possible markers and block names see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_HEADER = + +# The HTML_FOOTER tag can be used to specify a user-defined HTML footer for each +# generated HTML page. If the tag is left blank doxygen will generate a standard +# footer. See HTML_HEADER for more information on how to generate a default +# footer and what special commands can be used inside the footer. See also +# section "Doxygen usage" for information on how to generate the default footer +# that doxygen normally uses. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FOOTER = + +# The HTML_STYLESHEET tag can be used to specify a user-defined cascading style +# sheet that is used by each HTML page. It can be used to fine-tune the look of +# the HTML output. If left blank doxygen will generate a default style sheet. +# See also section "Doxygen usage" for information on how to generate the style +# sheet that doxygen normally uses. +# Note: It is recommended to use HTML_EXTRA_STYLESHEET instead of this tag, as +# it is more robust and this tag (HTML_STYLESHEET) will in the future become +# obsolete. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_STYLESHEET = + +# The HTML_EXTRA_STYLESHEET tag can be used to specify additional user-defined +# cascading style sheets that are included after the standard style sheets +# created by doxygen. Using this option one can overrule certain style aspects. +# This is preferred over using HTML_STYLESHEET since it does not replace the +# standard style sheet and is therefore more robust against future updates. +# Doxygen will copy the style sheet files to the output directory. +# Note: The order of the extra style sheet files is of importance (e.g. the last +# style sheet in the list overrules the setting of the previous ones in the +# list). For an example see the documentation. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_STYLESHEET = + +# The HTML_EXTRA_FILES tag can be used to specify one or more extra images or +# other source files which should be copied to the HTML output directory. Note +# that these files will be copied to the base HTML output directory. Use the +# $relpath^ marker in the HTML_HEADER and/or HTML_FOOTER files to load these +# files. In the HTML_STYLESHEET file, use the file name only. Also note that the +# files will be copied as-is; there are no commands or markers available. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_EXTRA_FILES = + +# The HTML_COLORSTYLE_HUE tag controls the color of the HTML output. Doxygen +# will adjust the colors in the style sheet and background images according to +# this color. Hue is specified as an angle on a colorwheel, see +# https://en.wikipedia.org/wiki/Hue for more information. For instance the value +# 0 represents red, 60 is yellow, 120 is green, 180 is cyan, 240 is blue, 300 +# purple, and 360 is red again. +# Minimum value: 0, maximum value: 359, default value: 220. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_HUE = 220 + +# The HTML_COLORSTYLE_SAT tag controls the purity (or saturation) of the colors +# in the HTML output. For a value of 0 the output will use grayscales only. A +# value of 255 will produce the most vivid colors. +# Minimum value: 0, maximum value: 255, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_SAT = 100 + +# The HTML_COLORSTYLE_GAMMA tag controls the gamma correction applied to the +# luminance component of the colors in the HTML output. Values below 100 +# gradually make the output lighter, whereas values above 100 make the output +# darker. The value divided by 100 is the actual gamma applied, so 80 represents +# a gamma of 0.8, The value 220 represents a gamma of 2.2, and 100 does not +# change the gamma. +# Minimum value: 40, maximum value: 240, default value: 80. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_COLORSTYLE_GAMMA = 80 + +# If the HTML_TIMESTAMP tag is set to YES then the footer of each generated HTML +# page will contain the date and time when the page was generated. Setting this +# to YES can help to show when doxygen was last run and thus if the +# documentation is up to date. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_TIMESTAMP = NO + +# If the HTML_DYNAMIC_MENUS tag is set to YES then the generated HTML +# documentation will contain a main index with vertical navigation menus that +# are dynamically created via JavaScript. If disabled, the navigation index will +# consists of multiple levels of tabs that are statically embedded in every HTML +# page. Disable this option to support browsers that do not have JavaScript, +# like the Qt help browser. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_MENUS = YES + +# If the HTML_DYNAMIC_SECTIONS tag is set to YES then the generated HTML +# documentation will contain sections that can be hidden and shown after the +# page has loaded. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_DYNAMIC_SECTIONS = NO + +# With HTML_INDEX_NUM_ENTRIES one can control the preferred number of entries +# shown in the various tree structured indices initially; the user can expand +# and collapse entries dynamically later on. Doxygen will expand the tree to +# such a level that at most the specified number of entries are visible (unless +# a fully collapsed tree already exceeds this amount). So setting the number of +# entries 1 will produce a full collapsed tree by default. 0 is a special value +# representing an infinite number of entries and will result in a full expanded +# tree by default. +# Minimum value: 0, maximum value: 9999, default value: 100. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_INDEX_NUM_ENTRIES = 100 + +# If the GENERATE_DOCSET tag is set to YES, additional index files will be +# generated that can be used as input for Apple's Xcode 3 integrated development +# environment (see: https://developer.apple.com/xcode/), introduced with OSX +# 10.5 (Leopard). To create a documentation set, doxygen will generate a +# Makefile in the HTML output directory. Running make will produce the docset in +# that directory and running make install will install the docset in +# ~/Library/Developer/Shared/Documentation/DocSets so that Xcode will find it at +# startup. See https://developer.apple.com/library/archive/featuredarticles/Doxy +# genXcode/_index.html for more information. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_DOCSET = NO + +# This tag determines the name of the docset feed. A documentation feed provides +# an umbrella under which multiple documentation sets from a single provider +# (such as a company or product suite) can be grouped. +# The default value is: Doxygen generated docs. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_FEEDNAME = "Doxygen generated docs" + +# This tag specifies a string that should uniquely identify the documentation +# set bundle. This should be a reverse domain-name style string, e.g. +# com.mycompany.MyDocSet. Doxygen will append .docset to the name. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_BUNDLE_ID = org.doxygen.Project + +# The DOCSET_PUBLISHER_ID tag specifies a string that should uniquely identify +# the documentation publisher. This should be a reverse domain-name style +# string, e.g. com.mycompany.MyDocSet.documentation. +# The default value is: org.doxygen.Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_ID = org.doxygen.Publisher + +# The DOCSET_PUBLISHER_NAME tag identifies the documentation publisher. +# The default value is: Publisher. +# This tag requires that the tag GENERATE_DOCSET is set to YES. + +DOCSET_PUBLISHER_NAME = Publisher + +# If the GENERATE_HTMLHELP tag is set to YES then doxygen generates three +# additional HTML index files: index.hhp, index.hhc, and index.hhk. The +# index.hhp is a project file that can be read by Microsoft's HTML Help Workshop +# (see: https://www.microsoft.com/en-us/download/details.aspx?id=21138) on +# Windows. +# +# The HTML Help Workshop contains a compiler that can convert all HTML output +# generated by doxygen into a single compiled HTML file (.chm). Compiled HTML +# files are now used as the Windows 98 help format, and will replace the old +# Windows help format (.hlp) on all Windows platforms in the future. Compressed +# HTML files also contain an index, a table of contents, and you can search for +# words in the documentation. The HTML workshop also contains a viewer for +# compressed HTML files. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_HTMLHELP = NO + +# The CHM_FILE tag can be used to specify the file name of the resulting .chm +# file. You can add a path in front of the file if the result should not be +# written to the html output directory. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_FILE = + +# The HHC_LOCATION tag can be used to specify the location (absolute path +# including file name) of the HTML help compiler (hhc.exe). If non-empty, +# doxygen will try to run the HTML help compiler on the generated index.hhp. +# The file has to be specified with full path. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +HHC_LOCATION = + +# The GENERATE_CHI flag controls if a separate .chi index file is generated +# (YES) or that it should be included in the master .chm file (NO). +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +GENERATE_CHI = NO + +# The CHM_INDEX_ENCODING is used to encode HtmlHelp index (hhk), content (hhc) +# and project file content. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +CHM_INDEX_ENCODING = + +# The BINARY_TOC flag controls whether a binary table of contents is generated +# (YES) or a normal table of contents (NO) in the .chm file. Furthermore it +# enables the Previous and Next buttons. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +BINARY_TOC = NO + +# The TOC_EXPAND flag can be set to YES to add extra items for group members to +# the table of contents of the HTML help documentation and to the tree view. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTMLHELP is set to YES. + +TOC_EXPAND = NO + +# If the GENERATE_QHP tag is set to YES and both QHP_NAMESPACE and +# QHP_VIRTUAL_FOLDER are set, an additional index file will be generated that +# can be used as input for Qt's qhelpgenerator to generate a Qt Compressed Help +# (.qch) of the generated HTML documentation. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_QHP = NO + +# If the QHG_LOCATION tag is specified, the QCH_FILE tag can be used to specify +# the file name of the resulting .qch file. The path specified is relative to +# the HTML output folder. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QCH_FILE = + +# The QHP_NAMESPACE tag specifies the namespace to use when generating Qt Help +# Project output. For more information please see Qt Help Project / Namespace +# (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#namespace). +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_NAMESPACE = org.doxygen.Project + +# The QHP_VIRTUAL_FOLDER tag specifies the namespace to use when generating Qt +# Help Project output. For more information please see Qt Help Project / Virtual +# Folders (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#virtual- +# folders). +# The default value is: doc. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_VIRTUAL_FOLDER = doc + +# If the QHP_CUST_FILTER_NAME tag is set, it specifies the name of a custom +# filter to add. For more information please see Qt Help Project / Custom +# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_NAME = + +# The QHP_CUST_FILTER_ATTRS tag specifies the list of the attributes of the +# custom filter to add. For more information please see Qt Help Project / Custom +# Filters (see: https://doc.qt.io/archives/qt-4.8/qthelpproject.html#custom- +# filters). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_CUST_FILTER_ATTRS = + +# The QHP_SECT_FILTER_ATTRS tag specifies the list of the attributes this +# project's filter section matches. Qt Help Project / Filter Attributes (see: +# https://doc.qt.io/archives/qt-4.8/qthelpproject.html#filter-attributes). +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHP_SECT_FILTER_ATTRS = + +# The QHG_LOCATION tag can be used to specify the location of Qt's +# qhelpgenerator. If non-empty doxygen will try to run qhelpgenerator on the +# generated .qhp file. +# This tag requires that the tag GENERATE_QHP is set to YES. + +QHG_LOCATION = + +# If the GENERATE_ECLIPSEHELP tag is set to YES, additional index files will be +# generated, together with the HTML files, they form an Eclipse help plugin. To +# install this plugin and make it available under the help contents menu in +# Eclipse, the contents of the directory containing the HTML and XML files needs +# to be copied into the plugins directory of eclipse. The name of the directory +# within the plugins directory should be the same as the ECLIPSE_DOC_ID value. +# After copying Eclipse needs to be restarted before the help appears. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_ECLIPSEHELP = NO + +# A unique identifier for the Eclipse help plugin. When installing the plugin +# the directory name containing the HTML and XML files should also have this +# name. Each documentation set should have its own identifier. +# The default value is: org.doxygen.Project. +# This tag requires that the tag GENERATE_ECLIPSEHELP is set to YES. + +ECLIPSE_DOC_ID = org.doxygen.Project + +# If you want full control over the layout of the generated HTML pages it might +# be necessary to disable the index and replace it with your own. The +# DISABLE_INDEX tag can be used to turn on/off the condensed index (tabs) at top +# of each HTML page. A value of NO enables the index and the value YES disables +# it. Since the tabs in the index contain the same information as the navigation +# tree, you can set this option to YES if you also set GENERATE_TREEVIEW to YES. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +DISABLE_INDEX = YES + +# The GENERATE_TREEVIEW tag is used to specify whether a tree-like index +# structure should be generated to display hierarchical information. If the tag +# value is set to YES, a side panel will be generated containing a tree-like +# index structure (just like the one that is generated for HTML Help). For this +# to work a browser that supports JavaScript, DHTML, CSS and frames is required +# (i.e. any modern browser). Windows users are probably better off using the +# HTML help feature. Via custom style sheets (see HTML_EXTRA_STYLESHEET) one can +# further fine-tune the look of the index. As an example, the default style +# sheet generated by doxygen has an example that shows how to put an image at +# the root of the tree instead of the PROJECT_NAME. Since the tree basically has +# the same information as the tab index, you could consider setting +# DISABLE_INDEX to YES when enabling this option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +GENERATE_TREEVIEW = YES + +# The ENUM_VALUES_PER_LINE tag can be used to set the number of enum values that +# doxygen will group on one line in the generated HTML documentation. +# +# Note that a value of 0 will completely suppress the enum values from appearing +# in the overview section. +# Minimum value: 0, maximum value: 20, default value: 4. +# This tag requires that the tag GENERATE_HTML is set to YES. + +ENUM_VALUES_PER_LINE = 4 + +# If the treeview is enabled (see GENERATE_TREEVIEW) then this tag can be used +# to set the initial width (in pixels) of the frame in which the tree is shown. +# Minimum value: 0, maximum value: 1500, default value: 250. +# This tag requires that the tag GENERATE_HTML is set to YES. + +TREEVIEW_WIDTH = 250 + +# If the EXT_LINKS_IN_WINDOW option is set to YES, doxygen will open links to +# external symbols imported via tag files in a separate window. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +EXT_LINKS_IN_WINDOW = NO + +# If the HTML_FORMULA_FORMAT option is set to svg, doxygen will use the pdf2svg +# tool (see https://github.com/dawbarton/pdf2svg) or inkscape (see +# https://inkscape.org) to generate formulas as SVG images instead of PNGs for +# the HTML output. These images will generally look nicer at scaled resolutions. +# Possible values are: png The default and svg Looks nicer but requires the +# pdf2svg tool. +# The default value is: png. +# This tag requires that the tag GENERATE_HTML is set to YES. + +HTML_FORMULA_FORMAT = png + +# Use this tag to change the font size of LaTeX formulas included as images in +# the HTML documentation. When you change the font size after a successful +# doxygen run you need to manually remove any form_*.png images from the HTML +# output directory to force them to be regenerated. +# Minimum value: 8, maximum value: 50, default value: 10. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_FONTSIZE = 10 + +# Use the FORMULA_TRANSPARENT tag to determine whether or not the images +# generated for formulas are transparent PNGs. Transparent PNGs are not +# supported properly for IE 6.0, but are supported on all modern browsers. +# +# Note that when changing this option you need to delete any form_*.png files in +# the HTML output directory before the changes have effect. +# The default value is: YES. +# This tag requires that the tag GENERATE_HTML is set to YES. + +FORMULA_TRANSPARENT = YES + +# The FORMULA_MACROFILE can contain LaTeX \newcommand and \renewcommand commands +# to create new LaTeX commands to be used in formulas as building blocks. See +# the section "Including formulas" for details. + +FORMULA_MACROFILE = + +# Enable the USE_MATHJAX option to render LaTeX formulas using MathJax (see +# https://www.mathjax.org) which uses client side JavaScript for the rendering +# instead of using pre-rendered bitmaps. Use this if you do not have LaTeX +# installed or if you want to formulas look prettier in the HTML output. When +# enabled you may also need to install MathJax separately and configure the path +# to it using the MATHJAX_RELPATH option. +# The default value is: NO. +# This tag requires that the tag GENERATE_HTML is set to YES. + +USE_MATHJAX = NO + +# When MathJax is enabled you can set the default output format to be used for +# the MathJax output. See the MathJax site (see: +# http://docs.mathjax.org/en/latest/output.html) for more details. +# Possible values are: HTML-CSS (which is slower, but has the best +# compatibility), NativeMML (i.e. MathML) and SVG. +# The default value is: HTML-CSS. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_FORMAT = HTML-CSS + +# When MathJax is enabled you need to specify the location relative to the HTML +# output directory using the MATHJAX_RELPATH option. The destination directory +# should contain the MathJax.js script. For instance, if the mathjax directory +# is located at the same level as the HTML output directory, then +# MATHJAX_RELPATH should be ../mathjax. The default value points to the MathJax +# Content Delivery Network so you can quickly see the result without installing +# MathJax. However, it is strongly recommended to install a local copy of +# MathJax from https://www.mathjax.org before deployment. +# The default value is: https://cdn.jsdelivr.net/npm/mathjax@2. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_RELPATH = https://cdn.jsdelivr.net/npm/mathjax@2 + +# The MATHJAX_EXTENSIONS tag can be used to specify one or more MathJax +# extension names that should be enabled during MathJax rendering. For example +# MATHJAX_EXTENSIONS = TeX/AMSmath TeX/AMSsymbols +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_EXTENSIONS = + +# The MATHJAX_CODEFILE tag can be used to specify a file with javascript pieces +# of code that will be used on startup of the MathJax code. See the MathJax site +# (see: http://docs.mathjax.org/en/latest/output.html) for more details. For an +# example see the documentation. +# This tag requires that the tag USE_MATHJAX is set to YES. + +MATHJAX_CODEFILE = + +# When the SEARCHENGINE tag is enabled doxygen will generate a search box for +# the HTML output. The underlying search engine uses javascript and DHTML and +# should work on any modern browser. Note that when using HTML help +# (GENERATE_HTMLHELP), Qt help (GENERATE_QHP), or docsets (GENERATE_DOCSET) +# there is already a search function so this one should typically be disabled. +# For large projects the javascript based search engine can be slow, then +# enabling SERVER_BASED_SEARCH may provide a better solution. It is possible to +# search using the keyboard; to jump to the search box use + S +# (what the is depends on the OS and browser, but it is typically +# , /