/*---------------------------------------------------------------------- | AP4_IsmaTrackEncrypter::ProcessTrack +---------------------------------------------------------------------*/ AP4_Result AP4_IsmaTrackEncrypter::ProcessTrack() { // sinf container AP4_ContainerAtom* sinf = new AP4_ContainerAtom(AP4_ATOM_TYPE_SINF); // original format AP4_FrmaAtom* frma = new AP4_FrmaAtom(m_SampleEntry->GetType()); // scheme AP4_SchmAtom* schm = new AP4_SchmAtom(AP4_ISMACRYP_SCHEME_TYPE_IAEC, 1); // scheme info AP4_ContainerAtom* schi = new AP4_ContainerAtom(AP4_ATOM_TYPE_SCHI); AP4_IkmsAtom* ikms = new AP4_IkmsAtom(m_KmsUri.c_str()); AP4_IsfmAtom* isfm = new AP4_IsfmAtom(false, 0, 4); // populate the schi container schi->AddChild(ikms); schi->AddChild(isfm); // populate the sinf container sinf->AddChild(frma); sinf->AddChild(schm); sinf->AddChild(schi); // add the sinf atom to the sample description m_SampleEntry->AddChild(sinf); // change the atom type of the sample description m_SampleEntry->SetType(m_Format); return AP4_SUCCESS; }
/*---------------------------------------------------------------------- | AP4_HintTrack::SetSdpText +---------------------------------------------------------------------*/ void AP4_HintTrack::SetSdpText(const char* text) { // build an sdp atom AP4_SdpAtom* sdp = DNew AP4_SdpAtom(text); // build the hnti AP4_ContainerAtom* hnti = DNew AP4_ContainerAtom(AP4_ATOM_TYPE_HNTI); hnti->AddChild(sdp); // check if there's already a user data atom AP4_ContainerAtom* udta = dynamic_cast<AP4_ContainerAtom*>(m_TrakAtom->FindChild("udta")); if (udta == NULL) { // otherwise create it udta = DNew AP4_ContainerAtom(AP4_ATOM_TYPE_UDTA); m_TrakAtom->AddChild(udta); } udta->AddChild(hnti); }
/*---------------------------------------------------------------------- | AP4_OmaDcfTrackEncrypter::ProcessTrack +---------------------------------------------------------------------*/ AP4_Result AP4_OmaDcfTrackEncrypter::ProcessTrack() { // original format AP4_FrmaAtom* frma = new AP4_FrmaAtom(m_SampleEntry->GetType()); // scheme info AP4_OdafAtom* odaf = new AP4_OdafAtom(true, 0, AP4_CIPHER_BLOCK_SIZE); AP4_OhdrAtom* ohdr = new AP4_OhdrAtom(m_CipherMode, m_CipherPadding, 0, m_ContentId.GetChars(), m_RightsIssuerUrl.GetChars(), m_TextualHeaders.GetData(), m_TextualHeaders.GetDataSize()); AP4_SchmAtom* schm = new AP4_SchmAtom(AP4_PROTECTION_SCHEME_TYPE_OMA, AP4_PROTECTION_SCHEME_VERSION_OMA_20); // populate the odkm container AP4_ContainerAtom* odkm = new AP4_ContainerAtom(AP4_ATOM_TYPE_ODKM, (AP4_UI32)0, (AP4_UI32)0); odkm->AddChild(odaf); odkm->AddChild(ohdr); // populate the schi container AP4_ContainerAtom* schi = new AP4_ContainerAtom(AP4_ATOM_TYPE_SCHI); schi->AddChild(odkm); // populate the sinf container AP4_ContainerAtom* sinf = new AP4_ContainerAtom(AP4_ATOM_TYPE_SINF); sinf->AddChild(frma); sinf->AddChild(schm); sinf->AddChild(schi); // add the sinf atom to the sample description m_SampleEntry->AddChild(sinf); // change the atom type of the sample description m_SampleEntry->SetType(m_Format); return AP4_SUCCESS; }
/*---------------------------------------------------------------------- | AP4_CompactingProcessor::TrackHandler::ProcessTrack +---------------------------------------------------------------------*/ AP4_Result AP4_CompactingProcessor::TrackHandler::ProcessTrack() { // find the stsz atom AP4_ContainerAtom* stbl = AP4_DYNAMIC_CAST(AP4_ContainerAtom, m_TrakAtom->FindChild("mdia/minf/stbl")); if (stbl == NULL) return AP4_SUCCESS; AP4_StszAtom* stsz = AP4_DYNAMIC_CAST(AP4_StszAtom, stbl->GetChild(AP4_ATOM_TYPE_STSZ)); if (stsz == NULL) return AP4_SUCCESS; // check if we can reduce the size of stsz by changing it to stz2 AP4_UI32 max_size = 0; for (unsigned int i=1; i<=stsz->GetSampleCount(); i++) { AP4_Size sample_size; stsz->GetSampleSize(i, sample_size); if (sample_size > max_size) { max_size = sample_size; } } AP4_UI08 field_size = 0; if (max_size <= 0xFF) { field_size = 1; } else if (max_size <= 0xFFFF) { field_size = 2; } if (m_Outer.m_Verbose) printf("Track %d: ", m_TrakAtom->GetId()); if (field_size == 0) { if (m_Outer.m_Verbose) { printf("no stz2 reduction possible\n"); } return AP4_SUCCESS; } else { if (m_Outer.m_Verbose) { unsigned int reduction = (4-field_size)*stsz->GetSampleCount(); printf("stz2 reduction = %d bytes\n", reduction); m_Outer.m_SizeReduction += reduction; } } // detach the original stsz atom so we can destroy it later m_StszAtom = stsz; stsz->Detach(); // create an stz2 atom and populate its entries AP4_Stz2Atom* stz2 = new AP4_Stz2Atom(field_size); for (unsigned int i=1; i<=m_StszAtom->GetSampleCount(); i++) { AP4_Size sample_size; m_StszAtom->GetSampleSize(i, sample_size); stz2->AddEntry(sample_size); } stbl->AddChild(stz2); return AP4_SUCCESS; }
/*---------------------------------------------------------------------- | Fragment +---------------------------------------------------------------------*/ static void Fragment(AP4_File& input_file, AP4_ByteStream& output_stream, AP4_Array<TrackCursor*>& cursors, unsigned int fragment_duration, AP4_UI32 timescale, AP4_UI32 track_id, bool create_segment_index) { AP4_List<FragmentInfo> fragments; TrackCursor* index_cursor = NULL; AP4_Result result; AP4_Movie* input_movie = input_file.GetMovie(); if (input_movie == NULL) { fprintf(stderr, "ERROR: no moov found in the input file\n"); return; } // create the output file object AP4_Movie* output_movie = new AP4_Movie(1000); // create an mvex container AP4_ContainerAtom* mvex = new AP4_ContainerAtom(AP4_ATOM_TYPE_MVEX); AP4_MehdAtom* mehd = new AP4_MehdAtom(0); mvex->AddChild(mehd); // add an output track for each track in the input file for (unsigned int i=0; i<cursors.ItemCount(); i++) { AP4_Track* track = cursors[i]->m_Track; // skip non matching tracks if we have a selector if (track_id && track->GetId() != track_id) { continue; } result = cursors[i]->Init(); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to init sample cursor (%d), skipping track %d\n", result, track->GetId()); return; } // create a sample table (with no samples) to hold the sample description AP4_SyntheticSampleTable* sample_table = new AP4_SyntheticSampleTable(); for (unsigned int j=0; j<track->GetSampleDescriptionCount(); j++) { AP4_SampleDescription* sample_description = track->GetSampleDescription(j); sample_table->AddSampleDescription(sample_description, false); } // create the track AP4_Track* output_track = new AP4_Track(sample_table, track->GetId(), timescale?timescale:1000, AP4_ConvertTime(track->GetDuration(), input_movie->GetTimeScale(), timescale?timescale:1000), timescale?timescale:track->GetMediaTimeScale(), 0,//track->GetMediaDuration(), track); output_movie->AddTrack(output_track); // add a trex entry to the mvex container AP4_TrexAtom* trex = new AP4_TrexAtom(track->GetId(), 1, 0, 0, 0); mvex->AddChild(trex); } // select the anchor cursor TrackCursor* anchor_cursor = NULL; for (unsigned int i=0; i<cursors.ItemCount(); i++) { if (cursors[i]->m_Track->GetId() == track_id) { anchor_cursor = cursors[i]; } } if (anchor_cursor == NULL) { for (unsigned int i=0; i<cursors.ItemCount(); i++) { // use this as the anchor track if it is the first video track if (cursors[i]->m_Track->GetType() == AP4_Track::TYPE_VIDEO) { anchor_cursor = cursors[i]; break; } } } if (anchor_cursor == NULL) { // no video track to anchor with, pick the first audio track for (unsigned int i=0; i<cursors.ItemCount(); i++) { if (cursors[i]->m_Track->GetType() == AP4_Track::TYPE_AUDIO) { anchor_cursor = cursors[i]; break; } } // no audio track to anchor with, pick the first subtitles track for (unsigned int i=0; i<cursors.ItemCount(); i++) { if (cursors[i]->m_Track->GetType() == AP4_Track::TYPE_SUBTITLES) { anchor_cursor = cursors[i]; break; } } } if (anchor_cursor == NULL) { // this shoudl never happen fprintf(stderr, "ERROR: no anchor track\n"); return; } if (create_segment_index) { index_cursor = anchor_cursor; } if (Options.debug) { printf("Using track ID %d as anchor\n", anchor_cursor->m_Track->GetId()); } // update the mehd duration mehd->SetDuration(output_movie->GetDuration()); // add the mvex container to the moov container output_movie->GetMoovAtom()->AddChild(mvex); // compute all the fragments unsigned int sequence_number = 1; for(;;) { TrackCursor* cursor = NULL; // pick the first track with a fragment index lower than the anchor's for (unsigned int i=0; i<cursors.ItemCount(); i++) { if (track_id && cursors[i]->m_Track->GetId() != track_id) continue; if (cursors[i]->m_Eos) continue; if (cursors[i]->m_FragmentIndex < anchor_cursor->m_FragmentIndex) { cursor = cursors[i]; break; } } // check if we found a non-anchor cursor to use if (cursor == NULL) { // the anchor should be used in this round, check if we can use it if (anchor_cursor->m_Eos) { // the anchor is done, pick a new anchor unless we need to trim anchor_cursor = NULL; if (!Options.trim) { for (unsigned int i=0; i<cursors.ItemCount(); i++) { if (track_id && cursors[i]->m_Track->GetId() != track_id) continue; if (cursors[i]->m_Eos) continue; if (anchor_cursor == NULL || cursors[i]->m_Track->GetType() == AP4_Track::TYPE_VIDEO || cursors[i]->m_Track->GetType() == AP4_Track::TYPE_AUDIO) { anchor_cursor = cursors[i]; if (Options.debug) { printf("+++ New anchor: Track ID %d\n", anchor_cursor->m_Track->GetId()); } } } } } cursor = anchor_cursor; } if (cursor == NULL) break; // all done // decide how many samples go into this fragment AP4_UI64 target_dts; if (cursor == anchor_cursor) { // compute the current dts in milliseconds AP4_UI64 anchor_dts_ms = AP4_ConvertTime(cursor->m_Sample.GetDts(), cursor->m_Track->GetMediaTimeScale(), 1000); // round to the nearest multiple of fragment_duration AP4_UI64 anchor_position = (anchor_dts_ms + (fragment_duration/2))/fragment_duration; // pick the next fragment_duration multiple at our target target_dts = AP4_ConvertTime(fragment_duration*(anchor_position+1), 1000, cursor->m_Track->GetMediaTimeScale()); } else { target_dts = AP4_ConvertTime(anchor_cursor->m_Sample.GetDts(), anchor_cursor->m_Track->GetMediaTimeScale(), cursor->m_Track->GetMediaTimeScale()); if (target_dts <= cursor->m_Sample.GetDts()) { // we must be at the end, past the last anchor sample, just use the target duration target_dts = AP4_ConvertTime(fragment_duration*(cursor->m_FragmentIndex+1), 1000, cursor->m_Track->GetMediaTimeScale()); if (target_dts <= cursor->m_Sample.GetDts()) { // we're still behind, there may have been an alignment/rounding error, just advance by one segment duration target_dts = cursor->m_Sample.GetDts()+AP4_ConvertTime(fragment_duration, 1000, cursor->m_Track->GetMediaTimeScale()); } } } unsigned int end_sample_index = cursor->m_Samples->GetSampleCount(); AP4_UI64 smallest_diff = (AP4_UI64)(0xFFFFFFFFFFFFFFFFULL); AP4_Sample sample; for (unsigned int i=cursor->m_SampleIndex+1; i<=cursor->m_Samples->GetSampleCount(); i++) { AP4_UI64 dts; if (i < cursor->m_Samples->GetSampleCount()) { result = cursor->m_Samples->GetSample(i, sample); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to get sample %d (%d)\n", i, result); return; } if (!sample.IsSync()) continue; // only look for sync samples dts = sample.GetDts(); } else { result = cursor->m_Samples->GetSample(i-1, sample); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to get sample %d (%d)\n", i-1, result); return; } dts = sample.GetDts()+sample.GetDuration(); } AP4_SI64 diff = dts-target_dts; AP4_UI64 abs_diff = diff<0?-diff:diff; if (abs_diff < smallest_diff) { // this sample is the closest to the target so far end_sample_index = i; smallest_diff = abs_diff; } if (diff >= 0) { // this sample is past the target, it is not going to get any better, stop looking break; } } if (cursor->m_Eos) continue; if (Options.debug) { if (cursor == anchor_cursor) { printf("===="); } else { printf("----"); } printf(" Track ID %d - dts=%lld, target=%lld, start=%d, end=%d/%d\n", cursor->m_Track->GetId(), cursor->m_Sample.GetDts(), target_dts, cursor->m_SampleIndex, end_sample_index, cursor->m_Track->GetSampleCount()); } // emit a fragment for the selected track if (Options.verbosity > 1) { printf("fragment: track ID %d ", cursor->m_Track->GetId()); } // decide which sample description index to use // (this is not very sophisticated, we only look at the sample description // index of the first sample in the group, which may not be correct. This // should be fixed later) unsigned int sample_desc_index = cursor->m_Sample.GetDescriptionIndex(); unsigned int tfhd_flags = AP4_TFHD_FLAG_DEFAULT_BASE_IS_MOOF; if (sample_desc_index > 0) { tfhd_flags |= AP4_TFHD_FLAG_SAMPLE_DESCRIPTION_INDEX_PRESENT; } if (cursor->m_Track->GetType() == AP4_Track::TYPE_VIDEO) { tfhd_flags |= AP4_TFHD_FLAG_DEFAULT_SAMPLE_FLAGS_PRESENT; } // setup the moof structure AP4_ContainerAtom* moof = new AP4_ContainerAtom(AP4_ATOM_TYPE_MOOF); AP4_MfhdAtom* mfhd = new AP4_MfhdAtom(sequence_number++); moof->AddChild(mfhd); AP4_ContainerAtom* traf = new AP4_ContainerAtom(AP4_ATOM_TYPE_TRAF); AP4_TfhdAtom* tfhd = new AP4_TfhdAtom(tfhd_flags, cursor->m_Track->GetId(), 0, sample_desc_index+1, 0, 0, 0); if (tfhd_flags & AP4_TFHD_FLAG_DEFAULT_SAMPLE_FLAGS_PRESENT) { tfhd->SetDefaultSampleFlags(0x1010000); // sample_is_non_sync_sample=1, sample_depends_on=1 (not I frame) } traf->AddChild(tfhd); if (!Options.no_tfdt) { AP4_TfdtAtom* tfdt = new AP4_TfdtAtom(1, cursor->m_Timestamp); traf->AddChild(tfdt); } AP4_UI32 trun_flags = AP4_TRUN_FLAG_DATA_OFFSET_PRESENT | AP4_TRUN_FLAG_SAMPLE_DURATION_PRESENT | AP4_TRUN_FLAG_SAMPLE_SIZE_PRESENT; AP4_UI32 first_sample_flags = 0; if (cursor->m_Track->GetType() == AP4_Track::TYPE_VIDEO) { trun_flags |= AP4_TRUN_FLAG_FIRST_SAMPLE_FLAGS_PRESENT; first_sample_flags = 0x2000000; // sample_depends_on=2 (I frame) } AP4_TrunAtom* trun = new AP4_TrunAtom(trun_flags, 0, first_sample_flags); traf->AddChild(trun); moof->AddChild(traf); // create a new FragmentInfo object to store the fragment details FragmentInfo* fragment = new FragmentInfo(cursor->m_Samples, cursor->m_Tfra, cursor->m_Timestamp, moof); fragments.Add(fragment); // add samples to the fragment unsigned int sample_count = 0; AP4_Array<AP4_TrunAtom::Entry> trun_entries; fragment->m_MdatSize = AP4_ATOM_HEADER_SIZE; for (;;) { // if we have one non-zero CTS delta, we'll need to express it if (cursor->m_Sample.GetCtsDelta()) { trun->SetFlags(trun->GetFlags() | AP4_TRUN_FLAG_SAMPLE_COMPOSITION_TIME_OFFSET_PRESENT); } // add one sample trun_entries.SetItemCount(sample_count+1); AP4_TrunAtom::Entry& trun_entry = trun_entries[sample_count]; trun_entry.sample_duration = timescale? (AP4_UI32)AP4_ConvertTime(cursor->m_Sample.GetDuration(), cursor->m_Track->GetMediaTimeScale(), timescale): cursor->m_Sample.GetDuration(); trun_entry.sample_size = cursor->m_Sample.GetSize(); trun_entry.sample_composition_time_offset = timescale? (AP4_UI32)AP4_ConvertTime(cursor->m_Sample.GetCtsDelta(), cursor->m_Track->GetMediaTimeScale(), timescale): cursor->m_Sample.GetCtsDelta(); fragment->m_SampleIndexes.SetItemCount(sample_count+1); fragment->m_SampleIndexes[sample_count] = cursor->m_SampleIndex; fragment->m_MdatSize += trun_entry.sample_size; fragment->m_Duration += trun_entry.sample_duration; // next sample cursor->m_Timestamp += trun_entry.sample_duration; result = cursor->SetSampleIndex(cursor->m_SampleIndex+1); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to get sample %d (%d)\n", cursor->m_SampleIndex+1, result); return; } sample_count++; if (cursor->m_Eos) { if (Options.debug) { printf("[Track ID %d has reached the end]\n", cursor->m_Track->GetId()); } break; } if (cursor->m_SampleIndex >= end_sample_index) { break; // done with this fragment } } if (Options.verbosity > 1) { printf(" %d samples\n", sample_count); } // update moof and children trun->SetEntries(trun_entries); trun->SetDataOffset((AP4_UI32)moof->GetSize()+AP4_ATOM_HEADER_SIZE); // advance the cursor's fragment index ++cursor->m_FragmentIndex; } // write the ftyp atom AP4_FtypAtom* ftyp = input_file.GetFileType(); if (ftyp) { // keep the existing brand and compatible brands AP4_Array<AP4_UI32> compatible_brands; compatible_brands.EnsureCapacity(ftyp->GetCompatibleBrands().ItemCount()+1); for (unsigned int i=0; i<ftyp->GetCompatibleBrands().ItemCount(); i++) { compatible_brands.Append(ftyp->GetCompatibleBrands()[i]); } // add the compatible brand if it is not already there if (!ftyp->HasCompatibleBrand(AP4_FILE_BRAND_ISO5)) { compatible_brands.Append(AP4_FILE_BRAND_ISO5); } // create a replacement AP4_FtypAtom* new_ftyp = new AP4_FtypAtom(ftyp->GetMajorBrand(), ftyp->GetMinorVersion(), &compatible_brands[0], compatible_brands.ItemCount()); ftyp = new_ftyp; } else { AP4_UI32 compat = AP4_FILE_BRAND_ISO5; ftyp = new AP4_FtypAtom(AP4_FTYP_BRAND_MP42, 0, &compat, 1); } ftyp->Write(output_stream); delete ftyp; // write the moov atom output_movie->GetMoovAtom()->Write(output_stream); // write the (not-yet fully computed) index if needed AP4_SidxAtom* sidx = NULL; AP4_Position sidx_position = 0; output_stream.Tell(sidx_position); if (create_segment_index) { sidx = new AP4_SidxAtom(index_cursor->m_Track->GetId(), index_cursor->m_Track->GetMediaTimeScale(), 0, 0); // reserve space for the entries now, but they will be computed and updated later sidx->SetReferenceCount(fragments.ItemCount()); sidx->Write(output_stream); } // write all fragments for (AP4_List<FragmentInfo>::Item* item = fragments.FirstItem(); item; item = item->GetNext()) { FragmentInfo* fragment = item->GetData(); // remember the time and position of this fragment output_stream.Tell(fragment->m_MoofPosition); fragment->m_Tfra->AddEntry(fragment->m_Timestamp, fragment->m_MoofPosition); // write the moof fragment->m_Moof->Write(output_stream); // write mdat output_stream.WriteUI32(fragment->m_MdatSize); output_stream.WriteUI32(AP4_ATOM_TYPE_MDAT); AP4_DataBuffer sample_data; AP4_Sample sample; for (unsigned int i=0; i<fragment->m_SampleIndexes.ItemCount(); i++) { // get the sample result = fragment->m_Samples->GetSample(fragment->m_SampleIndexes[i], sample); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to get sample %d (%d)\n", fragment->m_SampleIndexes[i], result); return; } // read the sample data result = sample.ReadData(sample_data); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to read sample data for sample %d (%d)\n", fragment->m_SampleIndexes[i], result); return; } // write the sample data result = output_stream.Write(sample_data.GetData(), sample_data.GetDataSize()); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to write sample data (%d)\n", result); return; } } } // update the index and re-write it if needed if (create_segment_index) { unsigned int segment_index = 0; AP4_SidxAtom::Reference reference; for (AP4_List<FragmentInfo>::Item* item = fragments.FirstItem(); item; item = item->GetNext()) { FragmentInfo* fragment = item->GetData(); reference.m_ReferencedSize = (AP4_UI32)(fragment->m_Moof->GetSize()+fragment->m_MdatSize); reference.m_SubsegmentDuration = fragment->m_Duration; reference.m_StartsWithSap = true; sidx->SetReference(segment_index++, reference); } AP4_Position here = 0; output_stream.Tell(here); output_stream.Seek(sidx_position); sidx->Write(output_stream); output_stream.Seek(here); delete sidx; } // create an mfra container and write out the index AP4_ContainerAtom mfra(AP4_ATOM_TYPE_MFRA); for (unsigned int i=0; i<cursors.ItemCount(); i++) { if (track_id && cursors[i]->m_Track->GetId() != track_id) { continue; } mfra.AddChild(cursors[i]->m_Tfra); cursors[i]->m_Tfra = NULL; } AP4_MfroAtom* mfro = new AP4_MfroAtom((AP4_UI32)mfra.GetSize()+16); mfra.AddChild(mfro); result = mfra.Write(output_stream); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to write 'mfra' (%d)\n", result); return; } // cleanup fragments.DeleteReferences(); for (unsigned int i=0; i<cursors.ItemCount(); i++) { delete cursors[i]; } for (AP4_List<FragmentInfo>::Item* item = fragments.FirstItem(); item; item = item->GetNext()) { FragmentInfo* fragment = item->GetData(); delete fragment->m_Moof; } delete output_movie; }
/*---------------------------------------------------------------------- | main +---------------------------------------------------------------------*/ int main(int argc, char** argv) { if (argc == 1) PrintUsageAndExit(); // parse options AP4_UI08 encryption_method = 0; bool encryption_method_is_set = false; AP4_UI08 padding_scheme = 0; const char* input_filename = NULL; const char* output_filename = NULL; bool show_progress = false; bool key_is_set = false; unsigned char key[16]; unsigned char iv[16]; AP4_BlockCipher::CipherMode cipher_mode = AP4_BlockCipher::CBC; const char* content_type = ""; const char* content_id = ""; const char* rights_issuer_url = ""; AP4_LargeSize plaintext_length = 0; AP4_DataBuffer textual_headers_buffer; AP4_TrackPropertyMap textual_headers; AP4_SetMemory(key, 0, sizeof(key)); AP4_SetMemory(iv, 0, sizeof(iv)); // parse the command line arguments char* arg; while ((arg = *++argv)) { if (!strcmp(arg, "--method")) { arg = *++argv; if (!strcmp(arg, "CBC")) { encryption_method = AP4_OMA_DCF_ENCRYPTION_METHOD_AES_CBC; encryption_method_is_set = true; padding_scheme = AP4_OMA_DCF_PADDING_SCHEME_RFC_2630; cipher_mode = AP4_BlockCipher::CBC; } else if (!strcmp(arg, "CTR")) { encryption_method = AP4_OMA_DCF_ENCRYPTION_METHOD_AES_CTR; encryption_method_is_set = true; padding_scheme = AP4_OMA_DCF_PADDING_SCHEME_NONE; cipher_mode = AP4_BlockCipher::CTR; } else if (!strcmp(arg, "NULL")) { encryption_method = AP4_OMA_DCF_ENCRYPTION_METHOD_NULL; encryption_method_is_set = true; padding_scheme = AP4_OMA_DCF_PADDING_SCHEME_NONE; } else { fprintf(stderr, "ERROR: invalid value for --method argument\n"); return 1; } } else if (!strcmp(arg, "--show-progress")) { show_progress = true; } else if (!strcmp(arg, "--content-type")) { content_type = *++argv; if (content_type == NULL) { fprintf(stderr, "ERROR: missing argument for --content-type option\n"); return 1; } } else if (!strcmp(arg, "--content-id")) { content_id = *++argv; if (content_type == NULL) { fprintf(stderr, "ERROR: missing argument for --content-id option\n"); return 1; } } else if (!strcmp(arg, "--rights-issuer")) { rights_issuer_url = *++argv; if (rights_issuer_url == NULL) { fprintf(stderr, "ERROR: missing argument for --rights-issuer option\n"); return 1; } } else if (!strcmp(arg, "--key")) { if (!encryption_method_is_set) { fprintf(stderr, "ERROR: --method argument must appear before --key\n"); return 1; } else if (encryption_method_is_set == AP4_OMA_DCF_ENCRYPTION_METHOD_NULL) { fprintf(stderr, "ERROR: --key cannot be used with --method NULL\n"); return 1; } arg = *++argv; if (arg == NULL) { fprintf(stderr, "ERROR: missing argument for --key option\n"); return 1; } char* key_ascii = NULL; char* iv_ascii = NULL; if (AP4_FAILED(AP4_SplitArgs(arg, key_ascii, iv_ascii))) { fprintf(stderr, "ERROR: invalid argument for --key option\n"); return 1; } if (AP4_ParseHex(key_ascii, key, 16)) { fprintf(stderr, "ERROR: invalid hex format for key\n"); } if (AP4_ParseHex(iv_ascii, iv, 16)) { fprintf(stderr, "ERROR: invalid hex format for iv\n"); return 1; } // check that the key is not already there if (key_is_set) { fprintf(stderr, "ERROR: key already set\n"); return 1; } key_is_set = true; } else if (!strcmp(arg, "--textual-header")) { char* name = NULL; char* value = NULL; arg = *++argv; if (arg == NULL) { fprintf(stderr, "ERROR: missing argument for --textual-header option\n"); return 1; } if (AP4_FAILED(AP4_SplitArgs(arg, name, value))) { fprintf(stderr, "ERROR: invalid argument for --textual-header option\n"); return 1; } // check that the property is not already set if (textual_headers.GetProperty(0, name)) { fprintf(stderr, "ERROR: textual header %s already set\n", name); return 1; } // set the property in the map textual_headers.SetProperty(0, name, value); } else if (input_filename == NULL) { input_filename = arg; } else if (output_filename == NULL) { output_filename = arg; } else { fprintf(stderr, "ERROR: unexpected argument (%s)\n", arg); return 1; } } // check the arguments if (!encryption_method_is_set) { fprintf(stderr, "ERROR: missing --method argument\n"); return 1; } if (!key_is_set) { fprintf(stderr, "ERROR: encryption key not specified\n"); return 1; } if (input_filename == NULL) { fprintf(stderr, "ERROR: missing input filename\n"); return 1; } if (output_filename == NULL) { fprintf(stderr, "ERROR: missing output filename\n"); return 1; } (void)show_progress; // avoid warnings // convert to a textual headers buffer textual_headers.GetTextualHeaders(0, textual_headers_buffer); // create the input stream AP4_Result result; AP4_ByteStream* input = NULL; result = AP4_FileByteStream::Create(input_filename, AP4_FileByteStream::STREAM_MODE_READ, input); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: cannot open input file (%s) %d\n", input_filename, result); return 1; } // get the size of the input result = input->GetSize(plaintext_length); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: cannot get the size of the input\n"); return 1; } // create an encrypting stream for the input AP4_ByteStream* encrypted_stream; if (encryption_method == AP4_OMA_DCF_ENCRYPTION_METHOD_NULL) { encrypted_stream = input; } else { result = AP4_EncryptingStream::Create(cipher_mode, *input, iv, 16, key, 16, true, &AP4_DefaultBlockCipherFactory::Instance, encrypted_stream); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to create cipher (%d)\n", result); return 1; } } // create the output stream AP4_ByteStream* output = NULL; result = AP4_FileByteStream::Create(output_filename, AP4_FileByteStream::STREAM_MODE_WRITE, output); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: cannot open output file (%s) %d\n", output_filename, result); return 1; } // create the file AP4_File file; // set the brand AP4_UI32 compatible_brands[1] = {AP4_OMA_DCF_BRAND_ODCF}; file.SetFileType(AP4_OMA_DCF_BRAND_ODCF, 2, compatible_brands, 1); // create the odrm atom (force a 64-bit size) AP4_ContainerAtom* odrm = new AP4_ContainerAtom(AP4_ATOM_TYPE_ODRM, AP4_FULL_ATOM_HEADER_SIZE_64, true, 0, 0); // create the ohdr atom AP4_OhdrAtom* ohdr = new AP4_OhdrAtom(encryption_method, padding_scheme, plaintext_length, content_id, rights_issuer_url, textual_headers_buffer.GetData(), textual_headers_buffer.GetDataSize()); // create the odhe atom (the ownership is transfered) AP4_OdheAtom* odhe = new AP4_OdheAtom(content_type, ohdr); odrm->AddChild(odhe); // create the odda atom AP4_OddaAtom* odda = new AP4_OddaAtom(*encrypted_stream); odrm->AddChild(odda); // add the odrm atom to the file (the owndership is transfered) file.GetTopLevelAtoms().Add(odrm); // write the file to the output AP4_FileWriter::Write(file, *output); // cleanup input->Release(); output->Release(); return 0; }
/*---------------------------------------------------------------------- | AP4_MarlinIpmpEncryptingProcessor::Initialize +---------------------------------------------------------------------*/ AP4_Result AP4_MarlinIpmpEncryptingProcessor::Initialize( AP4_AtomParent& top_level, AP4_ByteStream& /*stream*/, AP4_Processor::ProgressListener* /*listener = NULL*/) { // get the moov atom AP4_MoovAtom* moov = AP4_DYNAMIC_CAST(AP4_MoovAtom, top_level.GetChild(AP4_ATOM_TYPE_MOOV)); if (moov == NULL) return AP4_ERROR_INVALID_FORMAT; // deal with the file type AP4_FtypAtom* ftyp = AP4_DYNAMIC_CAST(AP4_FtypAtom, top_level.GetChild(AP4_ATOM_TYPE_FTYP)); if (ftyp) { // remove the atom, it will be replaced with a new one top_level.RemoveChild(ftyp); // keep the existing brand and compatible brands AP4_Array<AP4_UI32> compatible_brands; compatible_brands.EnsureCapacity(ftyp->GetCompatibleBrands().ItemCount()+1); for (unsigned int i=0; i<ftyp->GetCompatibleBrands().ItemCount(); i++) { compatible_brands.Append(ftyp->GetCompatibleBrands()[i]); } // add the MGSV compatible brand if it is not already there if (!ftyp->HasCompatibleBrand(AP4_MARLIN_BRAND_MGSV)) { compatible_brands.Append(AP4_MARLIN_BRAND_MGSV); } // create a replacement for the major brand AP4_FtypAtom* new_ftyp = new AP4_FtypAtom(AP4_MARLIN_BRAND_MGSV, 0x13c078c, //AP4_MARLIN_BRAND_MGSV_MAJOR_VERSION, &compatible_brands[0], compatible_brands.ItemCount()); delete ftyp; ftyp = new_ftyp; } else { AP4_UI32 isom = AP4_FTYP_BRAND_ISOM; ftyp = new AP4_FtypAtom(AP4_MARLIN_BRAND_MGSV, 0, &isom, 1); } // insert the ftyp atom as the first child top_level.AddChild(ftyp, 0); // create and 'mpod' track reference atom AP4_TrefTypeAtom* mpod = new AP4_TrefTypeAtom(AP4_ATOM_TYPE_MPOD); // look for an available track ID, starting at 1 unsigned int od_track_id = 0; unsigned int od_track_position = 0; AP4_List<AP4_TrakAtom>::Item* trak_item = moov->GetTrakAtoms().FirstItem(); while (trak_item) { AP4_TrakAtom* trak = trak_item->GetData(); if (trak) { od_track_position++; if (trak->GetId() >= od_track_id) { od_track_id = trak->GetId()+1; } // if the track is encrypted, reference it in the mpod if (m_KeyMap.GetKey(trak->GetId())) { mpod->AddTrackId(trak->GetId()); } //m_SinfEntries.Add(new SinfEntry(trak->GetId(), NULL)); } trak_item = trak_item->GetNext(); } // check that there was at least one track in the file if (od_track_id == 0) return AP4_ERROR_INVALID_FORMAT; // create an initial object descriptor AP4_InitialObjectDescriptor* iod = // FIXME: get real values from the property map new AP4_InitialObjectDescriptor(AP4_DESCRIPTOR_TAG_MP4_IOD, 1022, // object descriptor id false, 0xFE, // OD profile level (0xFE = No OD profile specified) 0xFF, // scene profile level 0xFE, // audio profile level 0xFE, // visual profile level 0xFF); // graphics profile // create an ES_ID_Inc subdescriptor and add it to the initial object descriptor AP4_EsIdIncDescriptor* es_id_inc = new AP4_EsIdIncDescriptor(od_track_id); iod->AddSubDescriptor(es_id_inc); // create an iods atom to hold the initial object descriptor AP4_IodsAtom* iods = new AP4_IodsAtom(iod); // add the iods atom to the moov atom (try to put it just after mvhd) int iods_position = 0; int item_position = 0; for (AP4_List<AP4_Atom>::Item* item = moov->GetChildren().FirstItem(); item; ++item) { ++item_position; if (item->GetData()->GetType() == AP4_ATOM_TYPE_MVHD) { iods_position = item_position; break; } } AP4_Result result = moov->AddChild(iods, iods_position); if (AP4_FAILED(result)) { delete iods; return result; } // create a sample table for the OD track AP4_SyntheticSampleTable* od_sample_table = new AP4_SyntheticSampleTable(); // create the sample description for the OD track AP4_MpegSystemSampleDescription* od_sample_description; od_sample_description = new AP4_MpegSystemSampleDescription(AP4_STREAM_TYPE_OD, AP4_OTI_MPEG4_SYSTEM, NULL, 32768, // buffer size 1024, // max bitrate 512); // avg bitrate od_sample_table->AddSampleDescription(od_sample_description, true); // create the OD descriptor update AP4_DescriptorUpdateCommand od_update(AP4_COMMAND_TAG_OBJECT_DESCRIPTOR_UPDATE); for (unsigned int i=0; i<mpod->GetTrackIds().ItemCount(); i++) { AP4_ObjectDescriptor* od = new AP4_ObjectDescriptor(AP4_DESCRIPTOR_TAG_MP4_OD, 256+i); // descriptor id = 256+i od->AddSubDescriptor(new AP4_EsIdRefDescriptor(i+1)); // index into mpod (1-based) od->AddSubDescriptor(new AP4_IpmpDescriptorPointer(i+1)); // descriptor id = i+1 od_update.AddDescriptor(od); } // create the IPMP descriptor update AP4_DescriptorUpdateCommand ipmp_update(AP4_COMMAND_TAG_IPMP_DESCRIPTOR_UPDATE); for (unsigned int i=0; i<mpod->GetTrackIds().ItemCount(); i++) { // create the ipmp descriptor AP4_IpmpDescriptor* ipmp_descriptor = new AP4_IpmpDescriptor(i+1, AP4_MARLIN_IPMPS_TYPE_MGSV); // create the sinf container AP4_ContainerAtom* sinf = new AP4_ContainerAtom(AP4_ATOM_TYPE_SINF); // add the scheme type atom sinf->AddChild(new AP4_SchmAtom(AP4_PROTECTION_SCHEME_TYPE_MARLIN_ACBC, 0x0100, NULL, true)); // setup the scheme info atom const char* content_id = m_PropertyMap.GetProperty(mpod->GetTrackIds()[i], "ContentId"); if (content_id) { AP4_ContainerAtom* schi = new AP4_ContainerAtom(AP4_ATOM_TYPE_SCHI); schi->AddChild(new AP4_NullTerminatedStringAtom(AP4_ATOM_TYPE_8ID_, content_id)); sinf->AddChild(schi); } // serialize the sinf atom to a buffer and set it as the ipmp data AP4_MemoryByteStream* sinf_data = new AP4_MemoryByteStream((AP4_Size)sinf->GetSize()); sinf->Write(*sinf_data); ipmp_descriptor->SetData(sinf_data->GetData(), sinf_data->GetDataSize()); sinf_data->Release(); ipmp_update.AddDescriptor(ipmp_descriptor); } // add the sample with the descriptors and updates AP4_MemoryByteStream* sample_data = new AP4_MemoryByteStream(); od_update.Write(*sample_data); ipmp_update.Write(*sample_data); od_sample_table->AddSample(*sample_data, 0, sample_data->GetDataSize(), 0, 0, 0, 0, true); // create the OD track AP4_TrakAtom* od_track = new AP4_TrakAtom(od_sample_table, AP4_HANDLER_TYPE_ODSM, "Bento4 Marlin OD Handler", od_track_id, 0, 0, 1, 1000, 1, 0, "und", 0, 0); // add an entry in the processor's stream table to indicate that the // media data for the OD track is not in the file stream, but in our // memory stream. m_ExternalTrackData.Add(new ExternalTrackData(od_track_id, sample_data)); sample_data->Release(); // add a tref track reference atom AP4_ContainerAtom* tref = new AP4_ContainerAtom(AP4_ATOM_TYPE_TREF); tref->AddChild(mpod); od_track->AddChild(tref, 1); // add after 'tkhd' // add the track to the moov atoms (just after the last track) moov->AddChild(od_track, od_track_position); return AP4_SUCCESS; }
/*---------------------------------------------------------------------- | AP4_MarlinIpmpEncryptingProcessor::Initialize +---------------------------------------------------------------------*/ AP4_Result AP4_MarlinIpmpEncryptingProcessor::Initialize( AP4_AtomParent& top_level, AP4_ByteStream& /*stream*/, AP4_Processor::ProgressListener* /*listener = NULL*/) { // get the moov atom AP4_MoovAtom* moov = AP4_DYNAMIC_CAST(AP4_MoovAtom, top_level.GetChild(AP4_ATOM_TYPE_MOOV)); if (moov == NULL) return AP4_ERROR_INVALID_FORMAT; // deal with the file type AP4_FtypAtom* ftyp = AP4_DYNAMIC_CAST(AP4_FtypAtom, top_level.GetChild(AP4_ATOM_TYPE_FTYP)); if (ftyp) { // remove the atom, it will be replaced with a new one top_level.RemoveChild(ftyp); // keep the existing brand and compatible brands AP4_Array<AP4_UI32> compatible_brands; compatible_brands.EnsureCapacity(ftyp->GetCompatibleBrands().ItemCount()+1); for (unsigned int i=0; i<ftyp->GetCompatibleBrands().ItemCount(); i++) { compatible_brands.Append(ftyp->GetCompatibleBrands()[i]); } // add the MGSV compatible brand if it is not already there if (!ftyp->HasCompatibleBrand(AP4_MARLIN_BRAND_MGSV)) { compatible_brands.Append(AP4_MARLIN_BRAND_MGSV); } // create a replacement for the major brand AP4_FtypAtom* new_ftyp = new AP4_FtypAtom(AP4_MARLIN_BRAND_MGSV, 0x13c078c, //AP4_MARLIN_BRAND_MGSV_MAJOR_VERSION, &compatible_brands[0], compatible_brands.ItemCount()); delete ftyp; ftyp = new_ftyp; } else { AP4_UI32 isom = AP4_FTYP_BRAND_ISOM; ftyp = new AP4_FtypAtom(AP4_MARLIN_BRAND_MGSV, 0, &isom, 1); } // insert the ftyp atom as the first child top_level.AddChild(ftyp, 0); // create and 'mpod' track reference atom AP4_TrefTypeAtom* mpod = new AP4_TrefTypeAtom(AP4_ATOM_TYPE_MPOD); // look for an available track ID, starting at 1 unsigned int od_track_id = 0; unsigned int od_track_position = 0; for (AP4_List<AP4_TrakAtom>::Item* trak_item = moov->GetTrakAtoms().FirstItem(); trak_item; trak_item = trak_item->GetNext()) { AP4_TrakAtom* trak = trak_item->GetData(); if (trak) { od_track_position++; if (trak->GetId() >= od_track_id) { od_track_id = trak->GetId()+1; } // if the track is encrypted, reference it in the mpod if (m_KeyMap.GetKey(trak->GetId())) { mpod->AddTrackId(trak->GetId()); } //m_SinfEntries.Add(new SinfEntry(trak->GetId(), NULL)); } } // check that there was at least one track in the file if (od_track_id == 0) return AP4_ERROR_INVALID_FORMAT; // create an initial object descriptor AP4_InitialObjectDescriptor* iod = // FIXME: get real values from the property map new AP4_InitialObjectDescriptor(AP4_DESCRIPTOR_TAG_MP4_IOD, 1022, // object descriptor id false, 0xFE, // OD profile level (0xFE = No OD profile specified) 0xFF, // scene profile level 0xFE, // audio profile level 0xFE, // visual profile level 0xFF); // graphics profile // create an ES_ID_Inc subdescriptor and add it to the initial object descriptor AP4_EsIdIncDescriptor* es_id_inc = new AP4_EsIdIncDescriptor(od_track_id); iod->AddSubDescriptor(es_id_inc); // create an iods atom to hold the initial object descriptor AP4_IodsAtom* iods = new AP4_IodsAtom(iod); // add the iods atom to the moov atom (try to put it just after mvhd) int iods_position = 0; int item_position = 0; for (AP4_List<AP4_Atom>::Item* moov_item = moov->GetChildren().FirstItem(); moov_item; moov_item = moov_item->GetNext()) { ++item_position; if (moov_item->GetData()->GetType() == AP4_ATOM_TYPE_MVHD) { iods_position = item_position; break; } } AP4_Result result = moov->AddChild(iods, iods_position); if (AP4_FAILED(result)) { delete iods; return result; } // create a sample table for the OD track AP4_SyntheticSampleTable* od_sample_table = new AP4_SyntheticSampleTable(); // create the sample description for the OD track AP4_MpegSystemSampleDescription* od_sample_description; od_sample_description = new AP4_MpegSystemSampleDescription(AP4_STREAM_TYPE_OD, AP4_OTI_MPEG4_SYSTEM, NULL, 32768, // buffer size 1024, // max bitrate 512); // avg bitrate od_sample_table->AddSampleDescription(od_sample_description, true); // create the OD descriptor update AP4_DescriptorUpdateCommand od_update(AP4_COMMAND_TAG_OBJECT_DESCRIPTOR_UPDATE); for (unsigned int i=0; i<mpod->GetTrackIds().ItemCount(); i++) { AP4_ObjectDescriptor* od = new AP4_ObjectDescriptor(AP4_DESCRIPTOR_TAG_MP4_OD, 256+i); // descriptor id = 256+i od->AddSubDescriptor(new AP4_EsIdRefDescriptor(i+1)); // index into mpod (1-based) od->AddSubDescriptor(new AP4_IpmpDescriptorPointer(i+1)); // descriptor id = i+1 od_update.AddDescriptor(od); } // create the IPMP descriptor update AP4_DescriptorUpdateCommand ipmp_update(AP4_COMMAND_TAG_IPMP_DESCRIPTOR_UPDATE); for (unsigned int i=0; i<mpod->GetTrackIds().ItemCount(); i++) { // create the ipmp descriptor AP4_IpmpDescriptor* ipmp_descriptor = new AP4_IpmpDescriptor(i+1, AP4_MARLIN_IPMPS_TYPE_MGSV); // create the sinf container AP4_ContainerAtom* sinf = new AP4_ContainerAtom(AP4_ATOM_TYPE_SINF); // add the scheme type atom sinf->AddChild(new AP4_SchmAtom(m_UseGroupKey? AP4_PROTECTION_SCHEME_TYPE_MARLIN_ACGK: AP4_PROTECTION_SCHEME_TYPE_MARLIN_ACBC, 0x0100, NULL, true)); // create the 'schi' container AP4_ContainerAtom* schi = new AP4_ContainerAtom(AP4_ATOM_TYPE_SCHI); // add the content ID const char* content_id = m_PropertyMap.GetProperty(mpod->GetTrackIds()[i], "ContentId"); if (content_id) { // add the content ID (8id_) schi->AddChild(new AP4_NullTerminatedStringAtom(AP4_ATOM_TYPE_8ID_, content_id)); } // find what the track type is (necessary for the next step) and the key const AP4_DataBuffer* key = NULL; AP4_Track::Type track_type = AP4_Track::TYPE_UNKNOWN; for (AP4_List<AP4_TrakAtom>::Item* trak_item = moov->GetTrakAtoms().FirstItem(); trak_item; trak_item = trak_item->GetNext()) { AP4_TrakAtom* trak = trak_item->GetData(); if (trak->GetId() == mpod->GetTrackIds()[i]) { // find the handler type AP4_Atom* sub = trak->FindChild("mdia/hdlr"); if (sub) { AP4_HdlrAtom* hdlr = AP4_DYNAMIC_CAST(AP4_HdlrAtom, sub); if (hdlr) { AP4_UI32 type = hdlr->GetHandlerType(); if (type == AP4_HANDLER_TYPE_SOUN) { track_type = AP4_Track::TYPE_AUDIO; } else if (type == AP4_HANDLER_TYPE_VIDE) { track_type = AP4_Track::TYPE_VIDEO; } } } // find the key key = m_KeyMap.GetKey(trak->GetId()); break; } } // group key if (m_UseGroupKey && key) { // find the group key const AP4_DataBuffer* group_key = m_KeyMap.GetKey(0); if (group_key) { AP4_DataBuffer wrapped_key; result = AP4_AesKeyWrap(group_key->GetData(), key->GetData(), key->GetDataSize(), wrapped_key); if (AP4_FAILED(result)) return result; AP4_UnknownAtom* gkey = new AP4_UnknownAtom(AP4_ATOM_TYPE_GKEY, wrapped_key.GetData(), wrapped_key.GetDataSize()); schi->AddChild(gkey); } } // create and add the security attributes (satr) if (track_type != AP4_Track::TYPE_UNKNOWN && key != NULL && key != NULL) { AP4_ContainerAtom* satr = new AP4_ContainerAtom(AP4_ATOM_TYPE_SATR); switch (track_type) { case AP4_Track::TYPE_AUDIO: satr->AddChild(new AP4_NullTerminatedStringAtom(AP4_ATOM_TYPE_STYP, AP4_MARLIN_IPMP_STYP_AUDIO)); break; case AP4_Track::TYPE_VIDEO: satr->AddChild(new AP4_NullTerminatedStringAtom(AP4_ATOM_TYPE_STYP, AP4_MARLIN_IPMP_STYP_VIDEO)); break; default: break; } // add the signed attributes, if any const char* signed_attributes = m_PropertyMap.GetProperty(mpod->GetTrackIds()[i], "SignedAttributes"); if (signed_attributes) { // decode the hex-encoded data unsigned int size = (unsigned int)AP4_StringLength(signed_attributes)/2; AP4_DataBuffer attributes_atoms; attributes_atoms.SetDataSize(size); if (AP4_SUCCEEDED(AP4_ParseHex(signed_attributes, attributes_atoms.UseData(), size))) { // parse all the atoms encoded in the data and add them to the 'schi' container AP4_MemoryByteStream* mbs = new AP4_MemoryByteStream(attributes_atoms.GetData(), attributes_atoms.GetDataSize()); do { AP4_Atom* atom = NULL; result = AP4_DefaultAtomFactory::Instance.CreateAtomFromStream(*mbs, atom); if (AP4_SUCCEEDED(result) && atom) { satr->AddChild(atom); } } while (AP4_SUCCEEDED(result)); mbs->Release(); } } // compute the hmac AP4_MemoryByteStream* mbs = new AP4_MemoryByteStream(); satr->Write(*mbs); AP4_Hmac* digester = NULL; AP4_Hmac::Create(AP4_Hmac::SHA256, key->GetData(), key->GetDataSize(), digester); digester->Update(mbs->GetData(), mbs->GetDataSize()); AP4_DataBuffer hmac_value; digester->Final(hmac_value); AP4_Atom* hmac = new AP4_UnknownAtom(AP4_ATOM_TYPE_HMAC, hmac_value.GetData(), hmac_value.GetDataSize()); schi->AddChild(satr); schi->AddChild(hmac); mbs->Release(); } sinf->AddChild(schi); // serialize the sinf atom to a buffer and set it as the ipmp data AP4_MemoryByteStream* sinf_data = new AP4_MemoryByteStream((AP4_Size)sinf->GetSize()); sinf->Write(*sinf_data); ipmp_descriptor->SetData(sinf_data->GetData(), sinf_data->GetDataSize()); sinf_data->Release(); ipmp_update.AddDescriptor(ipmp_descriptor); } // add the sample with the descriptors and updates AP4_MemoryByteStream* sample_data = new AP4_MemoryByteStream(); od_update.Write(*sample_data); ipmp_update.Write(*sample_data); od_sample_table->AddSample(*sample_data, 0, sample_data->GetDataSize(), 0, 0, 0, 0, true); // create the OD track AP4_TrakAtom* od_track = new AP4_TrakAtom(od_sample_table, AP4_HANDLER_TYPE_ODSM, "Bento4 Marlin OD Handler", od_track_id, 0, 0, 1, 1000, 1, 0, "und", 0, 0); // add an entry in the processor's stream table to indicate that the // media data for the OD track is not in the file stream, but in our // memory stream. m_ExternalTrackData.Add(new ExternalTrackData(od_track_id, sample_data)); sample_data->Release(); // add a tref track reference atom AP4_ContainerAtom* tref = new AP4_ContainerAtom(AP4_ATOM_TYPE_TREF); tref->AddChild(mpod); od_track->AddChild(tref, 1); // add after 'tkhd' // add the track to the moov atoms (just after the last track) moov->AddChild(od_track, od_track_position); return AP4_SUCCESS; }
/*---------------------------------------------------------------------- | AP4_TrakAtom::AP4_TrakAtom +---------------------------------------------------------------------*/ AP4_TrakAtom::AP4_TrakAtom(AP4_SampleTable* sample_table, AP4_Atom::Type hdlr_type, const char* hdlr_name, AP4_UI32 track_id, AP4_UI32 creation_time, AP4_UI32 modification_time, AP4_UI64 track_duration, AP4_UI32 media_time_scale, AP4_UI64 media_duration, AP4_UI16 volume, const char* language, AP4_UI32 width, AP4_UI32 height) : AP4_ContainerAtom(AP4_ATOM_TYPE_TRAK) { AP4_Result result; // create a tkhd atom m_TkhdAtom = new AP4_TkhdAtom(creation_time, modification_time, track_id, track_duration, volume, width, height); // create an edts // create a mdia atom AP4_ContainerAtom* mdia = new AP4_ContainerAtom(AP4_ATOM_TYPE_MDIA); // create a hdlr atom for the mdia atom AP4_HdlrAtom* hdlr = new AP4_HdlrAtom(hdlr_type, hdlr_name); // create a minf atom AP4_ContainerAtom* minf = new AP4_ContainerAtom(AP4_ATOM_TYPE_MINF); // create a media header atom for minf (vmhd, smhd, hmhd or nmhd) AP4_Atom* minf_header; // create a media header atom for minf in case of container type header (gmhd) AP4_ContainerAtom* minf_header2 = NULL; switch (hdlr_type) { case AP4_HANDLER_TYPE_VIDE: minf_header = new AP4_VmhdAtom(0, 0, 0, 0); break; case AP4_HANDLER_TYPE_SOUN: minf_header = new AP4_SmhdAtom(0); break; case AP4_HANDLER_TYPE_QTCHAP: // Generate needed child atoms AP4_GminAtom* gmin; AP4_GmhdTextAtom* gmhdtext; AP4_HdlrAtom* alis_hdlr; // build the Generic Media Header minf_header2 = new AP4_ContainerAtom(AP4_ATOM_TYPE_GMHD); // Generic Media Information a child of gmhd gmin = new AP4_GminAtom(64,32768,32768,32768,0); minf_header2->AddChild(gmin); // Special Text Description atom is a child of gmhd atom gmhdtext = new AP4_GmhdTextAtom(); minf_header2->AddChild(gmhdtext); // build the secondary Data Handler alis_hdlr = new AP4_HdlrAtom(AP4_HANDLER_TYPE_ALIS, "Bento4 Alis Handler",AP4_HANDLER_CLASS_DHLR, AP4_HANDLER_VENDOR_ID_APPL); minf->AddChild(alis_hdlr); // replace the main handler with a text Media Handler hdlr = new AP4_HdlrAtom(AP4_HANDLER_TYPE_TEXT, "Bento4 Text Handler", AP4_HANDLER_CLASS_MHLR, AP4_HANDLER_VENDOR_ID_APP2); // Chapter tracks should be disabled, they aren't played, only referenced m_TkhdAtom->SetEnabled(0); break; default: minf_header = new AP4_NmhdAtom(); break; } // create a dinf atom for minf AP4_ContainerAtom* dinf = new AP4_ContainerAtom(AP4_ATOM_TYPE_DINF); // create a url atom as a ref for dref AP4_Atom* url; // Chapter tracks use an alis reference atom if (hdlr_type == AP4_HANDLER_TYPE_QTCHAP){ url = new AP4_AlisAtom(); } else { url = new AP4_UrlAtom(); }// local ref // create a dref atom for dinf AP4_DrefAtom* dref = new AP4_DrefAtom(&url, 1); // create a stbl atom for minf AP4_ContainerAtom* stbl; result = sample_table->GenerateStblAtom(stbl); if (AP4_FAILED(result)) stbl = NULL; // populate the dinf atom dinf->AddChild(dref); // populate the minf atom // use the minf_header2 if it's been assigned if (minf_header2 != NULL) { minf->AddChild(minf_header2,0); } else { minf->AddChild(minf_header); } minf->AddChild(dinf); if (stbl) minf->AddChild(stbl); // create a mdhd atom for the mdia atom m_MdhdAtom = new AP4_MdhdAtom(creation_time, modification_time, media_time_scale, media_duration, language); // populate the mdia atom mdia->AddChild(m_MdhdAtom); mdia->AddChild(hdlr); mdia->AddChild(minf); // attach the children AddChild(m_TkhdAtom); AddChild(mdia); }
/*---------------------------------------------------------------------- | AP4_Processor::MuxStream +---------------------------------------------------------------------*/ AP4_Result AP4_Processor::MuxStream( AP4_Array<AP4_ByteStream *> &input, AP4_ByteStream& output, AP4_UI08 partitions, AP4_AtomFactory& atom_factory) { AP4_Result result; AP4_UI64 stream_offset = 0; if (partitions & 1) { // read all atoms. // keep all atoms except [mdat] // keep a ref to [moov] // put [moof] atoms in a separate list AP4_AtomParent top_level; AP4_Array<AP4_MoovAtom*> moov; AP4_Size track_count(0); for(AP4_Size streamid(0); streamid < input.ItemCount(); ++streamid) { for (AP4_Atom* atom = NULL; AP4_SUCCEEDED(atom_factory.CreateAtomFromStream(*input[streamid], atom)); input[streamid]->Tell(stream_offset)) { if (atom->GetType() == AP4_ATOM_TYPE_MFRA) { delete atom; continue; } else if (atom->GetType() == AP4_ATOM_TYPE_SIDX) { delete atom; continue; } else if (atom->GetType() == AP4_ATOM_TYPE_SSIX) { delete atom; continue; } if (streamid == 0) top_level.AddChild(atom); else if (atom->GetType() != AP4_ATOM_TYPE_MOOV) delete atom; if (atom->GetType() == AP4_ATOM_TYPE_MOOV) { moov.Append(AP4_DYNAMIC_CAST(AP4_MoovAtom,atom)); break; } } if (moov.ItemCount() == streamid) return AP4_ERROR_INVALID_FORMAT; while (AP4_SUCCEEDED(moov[streamid]->DeleteChild(AP4_ATOM_TYPE_PSSH, 0))); // Remove tracks we cannot handle for (AP4_List<AP4_TrakAtom>::Item *item(moov[streamid]->GetTrakAtoms().FirstItem()); item;) if (!item->GetData()->FindChild("mdia/minf/stbl")) moov[streamid]->GetTrakAtoms().Remove(item); else item = item->GetNext(); track_count += moov[streamid]->GetTrakAtoms().ItemCount(); } // initialize the processor if (AP4_FAILED(result = Initialize(top_level, *input[0]))) return result; // process the tracks if we have a moov atom m_TrackData.SetItemCount(track_count); m_StreamData.SetItemCount(input.ItemCount()); //NormalizeTREX(mvex, 0, m_TrackCounts[0], m_TrackCounts[1]); AP4_Cardinal internal_index(0); AP4_ContainerAtom *mvex_base(0); AP4_List<AP4_TrakAtom>::Item *item = NULL; for (AP4_Size streamid(0); streamid < input.ItemCount(); ++streamid) { m_StreamData[streamid].trackStart = internal_index; m_StreamData[streamid].stream = input[streamid]; if (streamid) moov[0]->AddTrakAtoms(moov[streamid]->GetTrakAtoms(), item); else item = moov[streamid]->GetTrakAtoms().FirstItem(); for (; item; item = item->GetNext()) { PERTRACK &track_data(m_TrackData[internal_index]); track_data.original_id = item->GetData()->GetId(); item->GetData()->SetId(track_data.new_id = internal_index + 1); if (AP4_MdhdAtom* mdhd = AP4_DYNAMIC_CAST(AP4_MdhdAtom, item->GetData()->FindChild("mdia/mdhd"))) track_data.timescale = mdhd->GetTimeScale(); else track_data.timescale = 1; AP4_ContainerAtom *mvex = AP4_DYNAMIC_CAST(AP4_ContainerAtom, moov[streamid]->GetChild(AP4_ATOM_TYPE_MVEX, 0)); if (!mvex) return AP4_ERROR_INVALID_FORMAT; if (!item->GetData()->GetDuration()) { AP4_MehdAtom *mehd(AP4_DYNAMIC_CAST(AP4_MehdAtom, mvex->GetChild(AP4_ATOM_TYPE_MEHD, 0))); item->GetData()->SetDuration(mehd? mehd->GetDuration():0); } AP4_TrexAtom *trex(NULL); unsigned int index(0); for (; !trex && (trex = AP4_DYNAMIC_CAST(AP4_TrexAtom, mvex->GetChild(AP4_ATOM_TYPE_TREX, index++)));) if(trex->GetTrackId() != track_data.original_id) trex = NULL; if (!trex) return AP4_ERROR_INVALID_FORMAT; if (mvex_base) { trex = AP4_DYNAMIC_CAST(AP4_TrexAtom, trex->Clone()); mvex_base->AddChild(trex); } else mvex_base = mvex; trex->SetTrackId(track_data.new_id); track_data.track_handler = CreateTrackHandler(item->GetData(), trex); track_data.track_handler->ProcessTrack(); track_data.streamId = streamid; ++m_StreamData[streamid].trackCount; ++internal_index; } } // We don't need the other moovs anymore..... moov.SetItemCount(1); AP4_MvhdAtom *mvhd(AP4_DYNAMIC_CAST(AP4_MvhdAtom, moov[0]->GetChild(AP4_ATOM_TYPE_MVHD, 0))); if (!mvhd->GetDuration()) { AP4_MehdAtom *mehd(AP4_DYNAMIC_CAST(AP4_MehdAtom, mvex_base->GetChild(AP4_ATOM_TYPE_MEHD, 0))); mvhd->SetDuration(mehd ? mehd->GetDuration() : 0); } // finalize the processor Finalize(top_level); // calculate the size of all atoms combined AP4_UI64 atoms_size = 0; top_level.GetChildren().Apply(AP4_AtomSizeAdder(atoms_size)); // write all atoms top_level.GetChildren().Apply(AP4_AtomListWriter(output)); m_MoovAtom = moov[0]; m_MoovAtom->Detach(); } if (partitions & 2) { // process the fragments, if any result = AP4_SUCCESS; AP4_Array<AP4_UI64> moof_positions, mdat_positions; moof_positions.SetItemCount(input.ItemCount()); mdat_positions.SetItemCount(input.ItemCount()); for (;;) { AP4_ContainerAtom *moof = NULL; AP4_UI32 track_index(0); #if 0 for (AP4_Cardinal streamid(0); streamid < input.ItemCount(); ++streamid) { AP4_Atom* atom = NULL; if (AP4_SUCCEEDED(input[streamid]->Tell(stream_offset)) && AP4_SUCCEEDED(atom_factory.CreateAtomFromStream(*input[streamid], atom))) { if (atom->GetType() != AP4_ATOM_TYPE_MOOF) return AP4_ERROR_INVALID_FORMAT; moof_positions[streamid] = stream_offset; mdat_positions[streamid] = stream_offset + atom->GetSize() + +AP4_ATOM_HEADER_SIZE; if (moof) { int index(0); for (; AP4_Atom* child = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom)->GetChild(AP4_ATOM_TYPE_TRAF, index++);) moof->AddChild(child->Clone()); delete atom; } else moof = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom); NormalizeTRAF(AP4_DYNAMIC_CAST(AP4_ContainerAtom, moof), m_StreamData[streamid].trackStart, m_StreamData[streamid].trackStart + m_StreamData[streamid].trackCount, track_index); } else delete atom; } #else double mindts(9999999999.0); AP4_Cardinal nextStream(~0); for (AP4_Cardinal track(0); track < m_TrackData.ItemCount(); ++track) if ((double)m_TrackData[track].dts / m_TrackData[track].timescale < mindts) { mindts = (double)m_TrackData[track].dts / m_TrackData[track].timescale; nextStream = m_TrackData[track].streamId; } AP4_Atom* atom = NULL; if (AP4_SUCCEEDED(result = input[nextStream]->Tell(stream_offset)) && AP4_SUCCEEDED(result = atom_factory.CreateAtomFromStream(*input[nextStream], atom))) { if (atom->GetType() != AP4_ATOM_TYPE_MOOF) return AP4_ERROR_INVALID_FORMAT; } else if (atom) return result; moof_positions[nextStream] = stream_offset; mdat_positions[nextStream] = stream_offset + atom->GetSize() + +AP4_ATOM_HEADER_SIZE; moof = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom); NormalizeTRAF(AP4_DYNAMIC_CAST(AP4_ContainerAtom, moof), m_StreamData[nextStream].trackStart, m_StreamData[nextStream].trackStart + m_StreamData[nextStream].trackCount, track_index); #endif if (!moof) break; if (AP4_FAILED(result = ProcessFragment(moof, NULL, 0, output, moof_positions, mdat_positions))) return result; delete moof; moof = NULL; } // cleanup m_TrackData.Clear(); m_StreamData.Clear(); } return AP4_SUCCESS; }
/*---------------------------------------------------------------------- | AP4_TrakAtom::AP4_TrakAtom +---------------------------------------------------------------------*/ AP4_TrakAtom::AP4_TrakAtom(AP4_SampleTable* sample_table, AP4_Atom::Type hdlr_type, const char* hdlr_name, AP4_UI32 track_id, AP4_UI32 creation_time, AP4_UI32 modification_time, AP4_UI64 track_duration, AP4_UI32 media_time_scale, AP4_UI64 media_duration, AP4_UI16 volume, const char* language, AP4_UI32 width, AP4_UI32 height) : AP4_ContainerAtom(AP4_ATOM_TYPE_TRAK) { AP4_Result result; // create a tkhd atom m_TkhdAtom = new AP4_TkhdAtom(creation_time, modification_time, track_id, track_duration, volume, width, height); // create an edts // create a mdia atom AP4_ContainerAtom* mdia = new AP4_ContainerAtom(AP4_ATOM_TYPE_MDIA); // create a hdlr atom for the mdia atom AP4_HdlrAtom* hdlr = new AP4_HdlrAtom(hdlr_type, hdlr_name); // create a minf atom AP4_ContainerAtom* minf = new AP4_ContainerAtom(AP4_ATOM_TYPE_MINF); // create a media header atom for minf (vmhd, smhd, hmhd or nmhd) AP4_Atom* minf_header; switch (hdlr_type) { case AP4_HANDLER_TYPE_VIDE: minf_header = new AP4_VmhdAtom(0, 0, 0, 0); break; case AP4_HANDLER_TYPE_SOUN: minf_header = new AP4_SmhdAtom(0); break; default: minf_header = new AP4_NmhdAtom(); break; } // create a dinf atom for minf AP4_ContainerAtom* dinf = new AP4_ContainerAtom(AP4_ATOM_TYPE_DINF); // create a url atom as a ref for dref AP4_Atom* url = new AP4_UrlAtom(); // local ref // create a dref atom for dinf AP4_DrefAtom* dref = new AP4_DrefAtom(&url, 1); // create a stbl atom for minf AP4_ContainerAtom* stbl; result = sample_table->GenerateStblAtom(stbl); if (AP4_FAILED(result)) stbl = NULL; // populate the dinf atom dinf->AddChild(dref); // populate the minf atom minf->AddChild(minf_header); minf->AddChild(dinf); if (stbl) minf->AddChild(stbl); // create a mdhd atom for the mdia atom m_MdhdAtom = new AP4_MdhdAtom(creation_time, modification_time, media_time_scale, media_duration, language); // populate the mdia atom mdia->AddChild(m_MdhdAtom); mdia->AddChild(hdlr); mdia->AddChild(minf); // attach the children AddChild(m_TkhdAtom); AddChild(mdia); }
/*---------------------------------------------------------------------- | Fragment +---------------------------------------------------------------------*/ static void Fragment(AP4_File& input_file, AP4_ByteStream& output_stream, unsigned int fragment_duration, AP4_UI32 timescale) { AP4_Result result; AP4_Movie* input_movie = input_file.GetMovie(); if (input_movie == NULL) { fprintf(stderr, "ERROR: no moov found in the input file\n"); return; } // create the output file object AP4_Movie* output_movie = new AP4_Movie(1000); // create an mvex container AP4_ContainerAtom* mvex = new AP4_ContainerAtom(AP4_ATOM_TYPE_MVEX); AP4_MehdAtom* mehd = new AP4_MehdAtom(0); mvex->AddChild(mehd); // create a cusor list to keep track of the tracks we will read from AP4_Array<TrackCursor*> cursors; // add an output track for each track in the input file for (AP4_List<AP4_Track>::Item* track_item = input_movie->GetTracks().FirstItem(); track_item; track_item = track_item->GetNext()) { AP4_Track* track = track_item->GetData(); TrackCursor* cursor = new TrackCursor(); cursor->m_TrackId = track->GetId(); cursor->m_Tfra->SetTrackId(track->GetId()); cursors.Append(cursor); // create a sample table (with no samples) to hold the sample description AP4_SyntheticSampleTable* sample_table = new AP4_SyntheticSampleTable(); for (unsigned int i=0; i<track->GetSampleDescriptionCount(); i++) { AP4_SampleDescription* sample_description = track->GetSampleDescription(i); sample_table->AddSampleDescription(sample_description, false); } // create the track AP4_Track* output_track = new AP4_Track(track->GetType(), sample_table, cursor->m_TrackId, timescale?timescale:1000, AP4_ConvertTime(track->GetDuration(), input_movie->GetTimeScale(), timescale?timescale:1000), timescale?timescale:track->GetMediaTimeScale(), 0,//track->GetMediaDuration(), track->GetTrackLanguage(), track->GetWidth(), track->GetHeight()); output_movie->AddTrack(output_track); result = cursor->SetTrack(track); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to read sample (%d)\n", result); return; } // add a trex entry to the mvex container AP4_TrexAtom* trex = new AP4_TrexAtom(cursor->m_TrackId, 1, 0, 0, 0); mvex->AddChild(trex); } if (cursors.ItemCount() == 0) { fprintf(stderr, "ERROR: no track found\n"); return; } for (unsigned int i=0; i<cursors.ItemCount(); i++) { if (cursors[i]->m_Track->GetType() == AP4_Track::TYPE_VIDEO) { cursors[i]->m_TargetDuration = AP4_ConvertTime(fragment_duration>AP4_FRAGMENTER_FRAGMENT_DURATION_TOLERANCE ? fragment_duration-AP4_FRAGMENTER_FRAGMENT_DURATION_TOLERANCE : 0, 1000, cursors[i]->m_Track->GetMediaTimeScale()); } else { cursors[i]->m_TargetDuration = AP4_ConvertTime(fragment_duration, 1000, cursors[i]->m_Track->GetMediaTimeScale()); } } // update the mehd duration mehd->SetDuration(output_movie->GetDuration()); // the mvex container to the moov container output_movie->GetMoovAtom()->AddChild(mvex); // write the ftyp atom AP4_FtypAtom* ftyp = input_file.GetFileType(); if (ftyp) { ftyp->Write(output_stream); } // write the moov atom output_movie->GetMoovAtom()->Write(output_stream); // write all the fragments unsigned int sequence_number = 1; for(;;) { // select the next track to read from TrackCursor* cursor = NULL; AP4_UI64 min_dts = (AP4_UI64)(-1); for (unsigned int i=0; i<cursors.ItemCount(); i++) { if (cursors[i]->m_Eos) continue; AP4_UI64 dts = AP4_ConvertTime(cursors[i]->m_Sample.GetDts(), cursors[i]->m_Track->GetMediaTimeScale(), AP4_FRAGMENTER_BASE_TIMESCALE); if (dts < min_dts) { min_dts = dts; cursor = cursors[i]; } } if (cursor == NULL) break; // all done // compute the target end for the segment cursor->m_EndDts = cursor->m_Sample.GetDts()+cursor->m_TargetDuration; // emit a fragment for the selected track if (Options.verbosity > 0) { printf("fragment: track ID %d ", cursor->m_Track->GetId()); } // remember the time and position of this fragment AP4_Position moof_offset = 0; output_stream.Tell(moof_offset); cursor->m_Tfra->AddEntry(cursor->m_Timestamp, moof_offset); // decide which sample description index to use // (this is not very sophisticated, we only look at the sample description // index of the first sample in the group, which may not be correct. This // should be fixed later) unsigned int sample_desc_index = cursor->m_Sample.GetDescriptionIndex(); unsigned int tfhd_flags = AP4_TFHD_FLAG_DEFAULT_BASE_IS_MOOF; if (sample_desc_index > 0) { tfhd_flags |= AP4_TFHD_FLAG_SAMPLE_DESCRIPTION_INDEX_PRESENT; } if (cursor->m_Track->GetType() == AP4_Track::TYPE_VIDEO) { tfhd_flags |= AP4_TFHD_FLAG_DEFAULT_SAMPLE_FLAGS_PRESENT; } // setup the moof structure AP4_ContainerAtom* moof = new AP4_ContainerAtom(AP4_ATOM_TYPE_MOOF); AP4_MfhdAtom* mfhd = new AP4_MfhdAtom(sequence_number++); moof->AddChild(mfhd); AP4_ContainerAtom* traf = new AP4_ContainerAtom(AP4_ATOM_TYPE_TRAF); AP4_TfhdAtom* tfhd = new AP4_TfhdAtom(tfhd_flags, cursor->m_TrackId, 0, sample_desc_index+1, 0, 0, 0); if (tfhd_flags & AP4_TFHD_FLAG_DEFAULT_SAMPLE_FLAGS_PRESENT) { tfhd->SetDefaultSampleFlags(0x1010000); // sample_is_non_sync_sample=1, sample_depends_on=1 (not I frame) } traf->AddChild(tfhd); AP4_TfdtAtom* tfdt = new AP4_TfdtAtom(1, cursor->m_Timestamp); traf->AddChild(tfdt); AP4_UI32 trun_flags = AP4_TRUN_FLAG_DATA_OFFSET_PRESENT | AP4_TRUN_FLAG_SAMPLE_DURATION_PRESENT | AP4_TRUN_FLAG_SAMPLE_SIZE_PRESENT; AP4_UI32 first_sample_flags = 0; if (cursor->m_Track->GetType() == AP4_Track::TYPE_VIDEO) { trun_flags |= AP4_TRUN_FLAG_FIRST_SAMPLE_FLAGS_PRESENT; first_sample_flags = 0x2000000; // sample_depends_on=2 (I frame) } AP4_TrunAtom* trun = new AP4_TrunAtom(trun_flags, 0, first_sample_flags); traf->AddChild(trun); moof->AddChild(traf); // decide which samples go in this fragment AP4_Array<AP4_UI32> sample_indexes; unsigned int sample_count = 0; AP4_Array<AP4_TrunAtom::Entry> trun_entries; AP4_UI32 mdat_size = AP4_ATOM_HEADER_SIZE; for (;;) { // if we have one non-zero CTS delta, we'll need to express it if (cursor->m_Sample.GetCtsDelta()) { trun->SetFlags(trun->GetFlags() | AP4_TRUN_FLAG_SAMPLE_COMPOSITION_TIME_OFFSET_PRESENT); } // add one sample trun_entries.SetItemCount(sample_count+1); AP4_TrunAtom::Entry& trun_entry = trun_entries[sample_count]; trun_entry.sample_duration = timescale? (AP4_UI32)AP4_ConvertTime(cursor->m_Sample.GetDuration(), cursor->m_Track->GetMediaTimeScale(), timescale): cursor->m_Sample.GetDuration(); trun_entry.sample_size = cursor->m_Sample.GetSize(); trun_entry.sample_composition_time_offset = timescale? (AP4_UI32)AP4_ConvertTime(cursor->m_Sample.GetCtsDelta(), cursor->m_Track->GetMediaTimeScale(), timescale): cursor->m_Sample.GetCtsDelta(); sample_indexes.SetItemCount(sample_count+1); sample_indexes[sample_count] = cursor->m_SampleIndex; mdat_size += trun_entry.sample_size; // next sample cursor->m_Timestamp += trun_entry.sample_duration; cursor->m_SampleIndex++; sample_count++; if (cursor->m_SampleIndex >= cursor->m_Track->GetSampleCount()) { cursor->m_Eos = true; AP4_UI64 end_dts = cursor->m_Sample.GetDts()+cursor->m_Sample.GetDuration(); cursor->m_Sample.Reset(); cursor->m_Sample.SetDts(end_dts); break; } result = cursor->m_Track->GetSample(cursor->m_SampleIndex, cursor->m_Sample); if (AP4_FAILED(result)) { cursor->m_Eos = true; AP4_UI64 end_dts = cursor->m_Sample.GetDts()+cursor->m_Sample.GetDuration(); cursor->m_Sample.Reset(); cursor->m_Sample.SetDts(end_dts); break; } if (cursor->m_Sample.IsSync()) { if (cursor->m_Sample.GetDts() >= cursor->m_EndDts) { break; // done with this segment } } } if (Options.verbosity) { printf(" %d samples\n", sample_count); } // update moof and children trun->SetEntries(trun_entries); trun->SetDataOffset((AP4_UI32)moof->GetSize()+AP4_ATOM_HEADER_SIZE); // write moof moof->Write(output_stream); // write mdat output_stream.WriteUI32(mdat_size); output_stream.WriteUI32(AP4_ATOM_TYPE_MDAT); AP4_Sample sample; AP4_DataBuffer sample_data; for (unsigned int i=0; i<sample_indexes.ItemCount(); i++) { result = cursor->m_Track->ReadSample(sample_indexes[i], sample, sample_data); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to read sample %d (%d)\n", sample_indexes[i], result); return; } result = output_stream.Write(sample_data.GetData(), sample_data.GetDataSize()); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to write sample data (%d)\n", result); return; } } // cleanup delete moof; } // create an mfra container and write out the index AP4_ContainerAtom mfra(AP4_ATOM_TYPE_MFRA); for (unsigned int i=0; i<cursors.ItemCount(); i++) { mfra.AddChild(cursors[i]->m_Tfra); cursors[i]->m_Tfra = NULL; } AP4_MfroAtom* mfro = new AP4_MfroAtom((AP4_UI32)mfra.GetSize()+16); mfra.AddChild(mfro); result = mfra.Write(output_stream); if (AP4_FAILED(result)) { fprintf(stderr, "ERROR: failed to write 'mfra' (%d)\n", result); return; } // cleanup for (unsigned int i=0; i<cursors.ItemCount(); i++) { delete cursors[i]; } delete output_movie; }