/*----------------------------------------------------------------------
| 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_Processor::Process
+---------------------------------------------------------------------*/
AP4_Result
AP4_Processor::Process(AP4_ByteStream& input,
AP4_ByteStream& output,
AP4_ByteStream* fragments,
ProgressListener* listener,
AP4_AtomFactory& atom_factory)
{
// 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_MoovAtom* moov = NULL;
AP4_ContainerAtom* mfra = NULL;
AP4_SidxAtom* sidx = NULL;
AP4_List<AP4_AtomLocator> frags;
AP4_UI64 stream_offset = 0;
bool in_fragments = false;
unsigned int sidx_count = 0;
for (AP4_Atom* atom = NULL;
AP4_SUCCEEDED(atom_factory.CreateAtomFromStream(input, atom));
input.Tell(stream_offset)) {
if (atom->GetType() == AP4_ATOM_TYPE_MDAT) {
delete atom;
continue;
} else if (atom->GetType() == AP4_ATOM_TYPE_MOOV) {
moov = AP4_DYNAMIC_CAST(AP4_MoovAtom, atom);
if (fragments) break;
} else if (atom->GetType() == AP4_ATOM_TYPE_MFRA) {
mfra = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom);
continue;
} else if (atom->GetType() == AP4_ATOM_TYPE_SIDX) {
// don't keep the index, it is likely to be invalidated, we will recompute it later
++sidx_count;
if (sidx == NULL) {
sidx = AP4_DYNAMIC_CAST(AP4_SidxAtom, atom);
} else {
delete atom;
continue;
}
} else if (atom->GetType() == AP4_ATOM_TYPE_SSIX) {
// don't keep the index, it is likely to be invalidated
delete atom;
continue;
} else if (!fragments && (in_fragments || atom->GetType() == AP4_ATOM_TYPE_MOOF)) {
in_fragments = true;
frags.Add(new AP4_AtomLocator(atom, stream_offset));
break;
}
top_level.AddChild(atom);
}
// check that we have at most one sidx (we can't deal with multi-sidx streams here
if (sidx_count > 1) {
top_level.RemoveChild(sidx);
delete sidx;
sidx = NULL;
}
// if we have a fragments stream, get the fragment locators from there
if (fragments) {
stream_offset = 0;
for (AP4_Atom* atom = NULL;
AP4_SUCCEEDED(atom_factory.CreateAtomFromStream(*fragments, atom));
fragments->Tell(stream_offset)) {
if (atom->GetType() == AP4_ATOM_TYPE_MDAT) {
delete atom;
continue;
}
frags.Add(new AP4_AtomLocator(atom, stream_offset));
}
}
// initialize the processor
AP4_Result result = Initialize(top_level, input);
if (AP4_FAILED(result)) return result;
// process the tracks if we have a moov atom
AP4_Array<AP4_SampleLocator> locators;
AP4_Cardinal track_count = 0;
AP4_List<AP4_TrakAtom>* trak_atoms = NULL;
AP4_LargeSize mdat_payload_size = 0;
AP4_SampleCursor* cursors = NULL;
if (moov) {
// build an array of track sample locators
trak_atoms = &moov->GetTrakAtoms();
track_count = trak_atoms->ItemCount();
cursors = new AP4_SampleCursor[track_count];
m_TrackData.SetItemCount(track_count);
m_StreamData.SetItemCount(1);
m_StreamData[0].stream = &input;
unsigned int index = 0;
for (AP4_List<AP4_TrakAtom>::Item* item = trak_atoms->FirstItem(); item; item=item->GetNext()) {
AP4_TrakAtom* trak = item->GetData();
// find the stsd atom
AP4_ContainerAtom* stbl = AP4_DYNAMIC_CAST(AP4_ContainerAtom, trak->FindChild("mdia/minf/stbl"));
if (stbl == NULL) continue;
// see if there's an external data source for this track
AP4_ByteStream* trak_data_stream = &input;
for (AP4_List<ExternalTrackData>::Item* ditem = m_ExternalTrackData.FirstItem(); ditem; ditem=ditem->GetNext()) {
ExternalTrackData* tdata = ditem->GetData();
if (tdata->m_TrackId == trak->GetId()) {
trak_data_stream = tdata->m_MediaData;
break;
}
}
AP4_ContainerAtom *mvex = AP4_DYNAMIC_CAST(AP4_ContainerAtom, moov->GetChild(AP4_ATOM_TYPE_MVEX));
AP4_TrexAtom* trex = NULL;
if (mvex) {
for (AP4_List<AP4_Atom>::Item* item = mvex->GetChildren().FirstItem(); item; item = item->GetNext()) {
AP4_Atom* atom = item->GetData();
if (atom->GetType() == AP4_ATOM_TYPE_TREX) {
trex = AP4_DYNAMIC_CAST(AP4_TrexAtom, atom);
if (trex && trex->GetTrackId() == trak->GetId())
break;
trex = NULL;
}
}
}
// create the track handler
m_TrackData[index].track_handler = CreateTrackHandler(trak, trex);
m_TrackData[index].new_id = trak->GetId();
cursors[index].m_Locator.m_TrakIndex = index;
cursors[index].m_Locator.m_SampleTable = new AP4_AtomSampleTable(stbl, *trak_data_stream);
cursors[index].m_Locator.m_SampleIndex = 0;
cursors[index].m_Locator.m_ChunkIndex = 0;
if (cursors[index].m_Locator.m_SampleTable->GetSampleCount()) {
cursors[index].m_Locator.m_SampleTable->GetSample(0, cursors[index].m_Locator.m_Sample);
} else {
cursors[index].m_EndReached = true;
}
index++;
}
// figure out the layout of the chunks
for (;;) {
// see which is the next sample to write
AP4_UI64 min_offset = (AP4_UI64)(-1);
int cursor = -1;
for (unsigned int i=0; i<track_count; i++) {
if (!cursors[i].m_EndReached &&
cursors[i].m_Locator.m_Sample.GetOffset() <= min_offset) {
min_offset = cursors[i].m_Locator.m_Sample.GetOffset();
cursor = i;
}
}
// stop if all cursors are exhausted
if (cursor == -1) break;
// append this locator to the layout list
AP4_SampleLocator& locator = cursors[cursor].m_Locator;
locators.Append(locator);
// move the cursor to the next sample
locator.m_SampleIndex++;
if (locator.m_SampleIndex == locator.m_SampleTable->GetSampleCount()) {
// mark this track as completed
cursors[cursor].m_EndReached = true;
} else {
// get the next sample info
locator.m_SampleTable->GetSample(locator.m_SampleIndex, locator.m_Sample);
AP4_Ordinal skip, sdesc;
locator.m_SampleTable->GetChunkForSample(locator.m_SampleIndex,
locator.m_ChunkIndex,
skip, sdesc);
}
}
// update the stbl atoms and compute the mdat size
int current_track = -1;
int current_chunk = -1;
AP4_Position current_chunk_offset = 0;
AP4_Size current_chunk_size = 0;
for (AP4_Ordinal i=0; i<locators.ItemCount(); i++) {
AP4_SampleLocator& locator = locators[i];
if ((int)locator.m_TrakIndex != current_track ||
(int)locator.m_ChunkIndex != current_chunk) {
// start a new chunk for this track
current_chunk_offset += current_chunk_size;
current_chunk_size = 0;
current_track = locator.m_TrakIndex;
current_chunk = locator.m_ChunkIndex;
locator.m_SampleTable->SetChunkOffset(locator.m_ChunkIndex, current_chunk_offset);
}
AP4_Size sample_size;
TrackHandler* handler = m_TrackData[locator.m_TrakIndex].track_handler;
if (handler) {
sample_size = handler->GetProcessedSampleSize(locator.m_Sample);
locator.m_SampleTable->SetSampleSize(locator.m_SampleIndex, sample_size);
} else {
sample_size = locator.m_Sample.GetSize();
}
current_chunk_size += sample_size;
mdat_payload_size += sample_size;
}
// process the tracks (ex: sample descriptions processing)
for (AP4_Ordinal i=0; i<track_count; i++) {
TrackHandler* handler = m_TrackData[i].track_handler;
if (handler)
handler->ProcessTrack();
}
}
// finalize the processor
Finalize(top_level);
if (!fragments) {
// calculate the size of all atoms combined
AP4_UI64 atoms_size = 0;
top_level.GetChildren().Apply(AP4_AtomSizeAdder(atoms_size));
// see if we need a 64-bit or 32-bit mdat
AP4_Size mdat_header_size = AP4_ATOM_HEADER_SIZE;
if (mdat_payload_size+mdat_header_size > 0xFFFFFFFF) {
// we need a 64-bit size
mdat_header_size += 8;
}
// adjust the chunk offsets
for (AP4_Ordinal i=0; i<track_count; i++) {
AP4_TrakAtom* trak;
trak_atoms->Get(i, trak);
trak->AdjustChunkOffsets(atoms_size+mdat_header_size);
}
// write all atoms
top_level.GetChildren().Apply(AP4_AtomListWriter(output));
// write mdat header
if (mdat_payload_size) {
if (mdat_header_size == AP4_ATOM_HEADER_SIZE) {
// 32-bit size
output.WriteUI32((AP4_UI32)(mdat_header_size+mdat_payload_size));
output.WriteUI32(AP4_ATOM_TYPE_MDAT);
} else {
// 64-bit size
output.WriteUI32(1);
output.WriteUI32(AP4_ATOM_TYPE_MDAT);
output.WriteUI64(mdat_header_size+mdat_payload_size);
}
}
}
// write the samples
if (moov) {
if (!fragments) {
#if defined(AP4_DEBUG)
AP4_Position before;
output.Tell(before);
#endif
AP4_Sample sample;
AP4_DataBuffer data_in;
AP4_DataBuffer data_out;
for (unsigned int i=0; i<locators.ItemCount(); i++) {
AP4_SampleLocator& locator = locators[i];
locator.m_Sample.ReadData(data_in);
TrackHandler* handler = m_TrackData[locator.m_TrakIndex].track_handler;
if (handler) {
result = handler->ProcessSample(data_in, data_out);
if (AP4_FAILED(result)) return result;
output.Write(data_out.GetData(), data_out.GetDataSize());
} else {
output.Write(data_in.GetData(), data_in.GetDataSize());
}
// notify the progress listener
if (listener) {
listener->OnProgress(i+1, locators.ItemCount());
}
}
#if defined(AP4_DEBUG)
AP4_Position after;
output.Tell(after);
AP4_ASSERT(after-before == mdat_payload_size);
#endif
}
else
m_StreamData[0].stream = fragments;
// find the position of the sidx atom
AP4_Position sidx_position = 0;
if (sidx) {
for (AP4_List<AP4_Atom>::Item* item = top_level.GetChildren().FirstItem();
item;
item = item->GetNext()) {
AP4_Atom* atom = item->GetData();
if (atom->GetType() == AP4_ATOM_TYPE_SIDX) {
break;
}
sidx_position += atom->GetSize();
}
}
// process the fragments, if any
AP4_Array<AP4_Position> moof_offsets, mdat_offsets;
moof_offsets.SetItemCount(1);
mdat_offsets.SetItemCount(1);
while (frags.ItemCount() > 0)
{
for (AP4_List<AP4_AtomLocator>::Item *locator(frags.FirstItem()); locator; locator = locator->GetNext())
{
AP4_ContainerAtom *moof(AP4_DYNAMIC_CAST(AP4_ContainerAtom, locator->GetData()->m_Atom));
moof_offsets[0] = locator->GetData()->m_Offset;
mdat_offsets[0] = moof_offsets[0] + moof->GetSize() + AP4_ATOM_HEADER_SIZE;
result = ProcessFragment(moof, sidx, sidx_position, output, moof_offsets, mdat_offsets);
if (AP4_FAILED(result))
return result;
}
frags.DeleteReferences();
AP4_Atom* atom = NULL;
input.Tell(stream_offset);
if (AP4_SUCCEEDED(atom_factory.CreateAtomFromStream(input, atom)))
{
if (atom->GetType() == AP4_ATOM_TYPE_MOOF)
frags.Add(new AP4_AtomLocator(atom, stream_offset));
else
delete atom;
}
}
// update the mfra if we have one
if (mfra) {
for (AP4_List<AP4_Atom>::Item* mfra_item = mfra->GetChildren().FirstItem(); mfra_item; mfra_item = mfra_item->GetNext())
{
if (mfra_item->GetData()->GetType() != AP4_ATOM_TYPE_TFRA)
continue;
AP4_TfraAtom* tfra = AP4_DYNAMIC_CAST(AP4_TfraAtom, mfra_item->GetData());
if (tfra == NULL)
continue;
AP4_Array<AP4_TfraAtom::Entry>& entries = tfra->GetEntries();
AP4_Cardinal entry_count = entries.ItemCount();
for (unsigned int i = 0; i<entry_count; i++) {
entries[i].m_MoofOffset = FindFragmentMapEntry(entries[i].m_MoofOffset);
}
}
}
// update and re-write the sidx if we have one
if (sidx && sidx_position) {
AP4_Position where = 0;
output.Tell(where);
output.Seek(sidx_position);
result = sidx->Write(output);
if (AP4_FAILED(result)) return result;
output.Seek(where);
}
if (!fragments) {
// write the mfra atom at the end if we have one
if (mfra) {
mfra->Write(output);
}
}
// cleanup
for (AP4_Ordinal i=0; i<track_count; i++)
delete cursors[i].m_Locator.m_SampleTable;
m_TrackData.Clear();
delete[] cursors;
}
// cleanup
frags.DeleteReferences();
delete mfra;
return AP4_SUCCESS;
}
/*----------------------------------------------------------------------
| 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;
}
/*----------------------------------------------------------------------
| AP4_Processor::ProcessFragments
+---------------------------------------------------------------------*/
AP4_Result
AP4_Processor::ProcessFragments(AP4_MoovAtom* moov,
AP4_List<AP4_MoofLocator>& moofs,
AP4_ContainerAtom* mfra,
AP4_ByteStream& input,
AP4_ByteStream& output)
{
// FIXME: this only works for non-changing moofs
for (AP4_List<AP4_MoofLocator>::Item* item = moofs.FirstItem();
item;
item = item->GetNext()) {
AP4_MoofLocator* locator = item->GetData();
AP4_ContainerAtom* moof = locator->m_Moof;
AP4_UI64 moof_offset = locator->m_Offset;
AP4_UI64 mdat_payload_offset = moof_offset+moof->GetSize()+8;
AP4_MovieFragment* fragment = new AP4_MovieFragment(moof);
AP4_Sample sample;
AP4_DataBuffer sample_data_in;
AP4_DataBuffer sample_data_out;
AP4_Result result;
// process all the traf atoms
AP4_Array<AP4_Processor::FragmentHandler*> handlers;
for (;AP4_Atom* atom = moof->GetChild(AP4_ATOM_TYPE_TRAF, handlers.ItemCount());) {
AP4_ContainerAtom* traf = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom);
AP4_Processor::FragmentHandler* handler = CreateFragmentHandler(traf);
if (handler) result = handler->ProcessFragment();
handlers.Append(handler);
}
// write the moof
AP4_UI64 moof_out_start = 0;
output.Tell(moof_out_start);
bool moof_has_changed = false;
moof->Write(output);
// process all track runs
for (unsigned int i=0; i<handlers.ItemCount(); i++) {
AP4_FragmentSampleTable* sample_table = NULL;
AP4_Processor::FragmentHandler* handler = handlers[i];
// get the track ID
AP4_ContainerAtom* traf = AP4_DYNAMIC_CAST(AP4_ContainerAtom, moof->GetChild(AP4_ATOM_TYPE_TRAF, i));
AP4_TfhdAtom* tfhd = AP4_DYNAMIC_CAST(AP4_TfhdAtom, traf->GetChild(AP4_ATOM_TYPE_TFHD, i));
// create a sample table object so we can read the sample data
result = fragment->CreateSampleTable(moov, tfhd->GetTrackId(), &input, moof_offset, mdat_payload_offset, sample_table);
if (AP4_FAILED(result)) return result;
// compute the mdat size
AP4_UI64 mdat_size = 0;
for (unsigned int j=0; j<sample_table->GetSampleCount(); j++) {
result = sample_table->GetSample(j, sample);
if (AP4_FAILED(result)) return result;
mdat_size += sample.GetSize();
}
// write an mdat header
if (mdat_size > 0xFFFFFFFF-8) {
// we don't support large mdat fragments
return AP4_ERROR_OUT_OF_RANGE;
}
if (mdat_size) {
output.WriteUI32((AP4_UI32)(8+mdat_size));
output.WriteUI32(AP4_ATOM_TYPE_MDAT);
}
#if defined(AP4_DEBUG)
AP4_Position before;
output.Tell(before);
#endif
// write the mdat
for (unsigned int j=0; j<sample_table->GetSampleCount(); j++) {
result = sample_table->GetSample(j, sample);
if (AP4_FAILED(result)) return result;
sample.ReadData(sample_data_in);
// process the sample data
if (handler) {
result = handler->ProcessSample(sample_data_in, sample_data_out);
if (AP4_FAILED(result)) return result;
// write the sample data
result = output.Write(sample_data_out.GetData(), sample_data_out.GetDataSize());
if (AP4_FAILED(result)) return result;
// give the handler a chance to update the atoms
result = handler->FinishFragment();
if (AP4_SUCCEEDED(result)) moof_has_changed = true;
} else {
// write the sample data (unmodified)
result = output.Write(sample_data_in.GetData(), sample_data_in.GetDataSize());
if (AP4_FAILED(result)) return result;
}
}
#if defined(AP4_DEBUG)
AP4_Position after;
output.Tell(after);
AP4_ASSERT(after-before == mdat_size);
#endif
delete sample_table;
}
// update the moof if needed
AP4_UI64 mdat_out_end = 0;
output.Tell(mdat_out_end);
if (moof_has_changed) {
output.Seek(moof_out_start);
moof->Write(output);
output.Seek(mdat_out_end);
}
// update the mfra if we have one
if (mfra) {
for (AP4_List<AP4_Atom>::Item* mfra_item = mfra->GetChildren().FirstItem();
mfra_item;
mfra_item = mfra_item->GetNext()) {
if (mfra_item->GetData()->GetType() != AP4_ATOM_TYPE_TFRA) continue;
AP4_TfraAtom* tfra = AP4_DYNAMIC_CAST(AP4_TfraAtom, mfra_item->GetData());
if (tfra == NULL) continue;
AP4_Array<AP4_TfraAtom::Entry>& entries = tfra->GetEntries();
AP4_Cardinal entry_count = entries.ItemCount();
for (unsigned int i=0; i<entry_count; i++) {
if (entries[i].m_MoofOffset == locator->m_Offset) {
entries[i].m_MoofOffset = moof_out_start;
}
}
}
}
delete fragment;
}
return AP4_SUCCESS;
}
/*----------------------------------------------------------------------
| AP4_Processor::Process
+---------------------------------------------------------------------*/
AP4_Result
AP4_Processor::Process(AP4_ByteStream& input,
AP4_ByteStream& output,
ProgressListener* listener,
AP4_AtomFactory& atom_factory)
{
// 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_MoovAtom* moov = NULL;
AP4_ContainerAtom* mfra = NULL;
AP4_List<AP4_MoofLocator> moofs;
AP4_UI64 stream_offset = 0;
for (AP4_Atom* atom = NULL;
AP4_SUCCEEDED(atom_factory.CreateAtomFromStream(input, atom));
input.Tell(stream_offset)) {
if (atom->GetType() == AP4_ATOM_TYPE_MDAT) {
continue;
} else if (atom->GetType() == AP4_ATOM_TYPE_MOOV) {
moov = AP4_DYNAMIC_CAST(AP4_MoovAtom, atom);
} else if (atom->GetType() == AP4_ATOM_TYPE_MOOF) {
AP4_ContainerAtom* moof = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom);
if (moof) {
moofs.Add(new AP4_MoofLocator(moof, stream_offset));
}
continue;
} else if (atom->GetType() == AP4_ATOM_TYPE_MFRA) {
mfra = AP4_DYNAMIC_CAST(AP4_ContainerAtom, atom);
continue;
}
top_level.AddChild(atom);
}
// initialize the processor
AP4_Result result = Initialize(top_level, input);
if (AP4_FAILED(result)) return result;
// process the tracks if we have a moov atom
AP4_Array<AP4_SampleLocator> locators;
AP4_Cardinal track_count = 0;
AP4_List<AP4_TrakAtom>* trak_atoms = NULL;
AP4_LargeSize mdat_payload_size = 0;
TrackHandler** handlers = NULL;
AP4_SampleCursor* cursors = NULL;
if (moov) {
// build an array of track sample locators
trak_atoms = &moov->GetTrakAtoms();
track_count = trak_atoms->ItemCount();
cursors = new AP4_SampleCursor[track_count];
handlers = new TrackHandler*[track_count];
for (AP4_Ordinal i=0; i<track_count; i++) {
handlers[i] = NULL;
}
unsigned int index = 0;
for (AP4_List<AP4_TrakAtom>::Item* item = trak_atoms->FirstItem(); item; item=item->GetNext()) {
AP4_TrakAtom* trak = item->GetData();
// find the stsd atom
AP4_ContainerAtom* stbl = AP4_DYNAMIC_CAST(AP4_ContainerAtom, trak->FindChild("mdia/minf/stbl"));
if (stbl == NULL) continue;
// see if there's an external data source for this track
AP4_ByteStream* trak_data_stream = &input;
for (AP4_List<ExternalTrackData>::Item* ditem = m_ExternalTrackData.FirstItem(); ditem; ditem=ditem->GetNext()) {
ExternalTrackData* tdata = ditem->GetData();
if (tdata->m_TrackId == trak->GetId()) {
trak_data_stream = tdata->m_MediaData;
break;
}
}
// create the track handler
handlers[index] = CreateTrackHandler(trak);
cursors[index].m_Locator.m_TrakIndex = index;
cursors[index].m_Locator.m_SampleTable = new AP4_AtomSampleTable(stbl, *trak_data_stream);
cursors[index].m_Locator.m_SampleIndex = 0;
cursors[index].m_Locator.m_ChunkIndex = 0;
if (cursors[index].m_Locator.m_SampleTable->GetSampleCount()) {
cursors[index].m_Locator.m_SampleTable->GetSample(0, cursors[index].m_Locator.m_Sample);
} else {
cursors[index].m_EndReached = true;
}
index++;
}
// figure out the layout of the chunks
for (;;) {
// see which is the next sample to write
AP4_UI64 min_offset = (AP4_UI64)(-1);
int cursor = -1;
for (unsigned int i=0; i<track_count; i++) {
if (!cursors[i].m_EndReached &&
cursors[i].m_Locator.m_Sample.GetOffset() <= min_offset) {
min_offset = cursors[i].m_Locator.m_Sample.GetOffset();
cursor = i;
}
}
// stop if all cursors are exhausted
if (cursor == -1) break;
// append this locator to the layout list
AP4_SampleLocator& locator = cursors[cursor].m_Locator;
locators.Append(locator);
// move the cursor to the next sample
locator.m_SampleIndex++;
if (locator.m_SampleIndex == locator.m_SampleTable->GetSampleCount()) {
// mark this track as completed
cursors[cursor].m_EndReached = true;
} else {
// get the next sample info
locator.m_SampleTable->GetSample(locator.m_SampleIndex, locator.m_Sample);
AP4_Ordinal skip, sdesc;
locator.m_SampleTable->GetChunkForSample(locator.m_SampleIndex,
locator.m_ChunkIndex,
skip, sdesc);
}
}
// update the stbl atoms and compute the mdat size
int current_track = -1;
int current_chunk = -1;
AP4_Position current_chunk_offset = 0;
AP4_Size current_chunk_size = 0;
for (AP4_Ordinal i=0; i<locators.ItemCount(); i++) {
AP4_SampleLocator& locator = locators[i];
if ((int)locator.m_TrakIndex != current_track ||
(int)locator.m_ChunkIndex != current_chunk) {
// start a new chunk for this track
current_chunk_offset += current_chunk_size;
current_chunk_size = 0;
current_track = locator.m_TrakIndex;
current_chunk = locator.m_ChunkIndex;
locator.m_SampleTable->SetChunkOffset(locator.m_ChunkIndex, current_chunk_offset);
}
AP4_Size sample_size;
TrackHandler* handler = handlers[locator.m_TrakIndex];
if (handler) {
sample_size = handler->GetProcessedSampleSize(locator.m_Sample);
locator.m_SampleTable->SetSampleSize(locator.m_SampleIndex, sample_size);
} else {
sample_size = locator.m_Sample.GetSize();
}
current_chunk_size += sample_size;
mdat_payload_size += sample_size;
}
// process the tracks (ex: sample descriptions processing)
for (AP4_Ordinal i=0; i<track_count; i++) {
TrackHandler* handler = handlers[i];
if (handler) handler->ProcessTrack();
}
}
// 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));
// see if we need a 64-bit or 32-bit mdat
AP4_Size mdat_header_size = AP4_ATOM_HEADER_SIZE;
if (mdat_payload_size+mdat_header_size > 0xFFFFFFFF) {
// we need a 64-bit size
mdat_header_size += 8;
}
// adjust the chunk offsets
for (AP4_Ordinal i=0; i<track_count; i++) {
AP4_TrakAtom* trak;
trak_atoms->Get(i, trak);
trak->AdjustChunkOffsets(atoms_size+mdat_header_size);
}
// write all atoms
top_level.GetChildren().Apply(AP4_AtomListWriter(output));
// write mdat header
if (mdat_payload_size) {
if (mdat_header_size == AP4_ATOM_HEADER_SIZE) {
// 32-bit size
output.WriteUI32((AP4_UI32)(mdat_header_size+mdat_payload_size));
output.WriteUI32(AP4_ATOM_TYPE_MDAT);
} else {
// 64-bit size
output.WriteUI32(1);
output.WriteUI32(AP4_ATOM_TYPE_MDAT);
output.WriteUI64(mdat_header_size+mdat_payload_size);
}
}
#if defined(AP4_DEBUG)
AP4_Position before;
output.Tell(before);
#endif
// write the samples
if (moov) {
AP4_Sample sample;
AP4_DataBuffer data_in;
AP4_DataBuffer data_out;
for (unsigned int i=0; i<locators.ItemCount(); i++) {
AP4_SampleLocator& locator = locators[i];
locator.m_Sample.ReadData(data_in);
TrackHandler* handler = handlers[locator.m_TrakIndex];
if (handler) {
result = handler->ProcessSample(data_in, data_out);
if (AP4_FAILED(result)) return result;
output.Write(data_out.GetData(), data_out.GetDataSize());
} else {
output.Write(data_in.GetData(), data_in.GetDataSize());
}
// notify the progress listener
if (listener) {
listener->OnProgress(i+1, locators.ItemCount());
}
}
// cleanup
for (AP4_Ordinal i=0; i<track_count; i++) {
delete cursors[i].m_Locator.m_SampleTable;
delete handlers[i];
}
delete[] cursors;
delete[] handlers;
}
#if defined(AP4_DEBUG)
AP4_Position after;
output.Tell(after);
AP4_ASSERT(after-before == mdat_payload_size);
#endif
// process the fragments, if any
result = ProcessFragments(moov, moofs, mfra, input, output);
if (AP4_FAILED(result)) return result;
// write the mfra atom at the end if we have one
if (mfra) {
mfra->Write(output);
}
// cleanup
moofs.DeleteReferences();
delete mfra;
return AP4_SUCCESS;
}
