GF_Err gf_isom_hevc_config_new(GF_ISOFile *the_file, u32 trackNumber, GF_HEVCConfig *cfg, char *URLname, char *URNname, u32 *outDescriptionIndex)
{
GF_TrackBox *trak;
GF_Err e;
u32 dataRefIndex;
GF_MPEGVisualSampleEntryBox *entry;
e = CanAccessMovie(the_file, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(the_file, trackNumber);
if (!trak || !trak->Media || !cfg) return GF_BAD_PARAM;
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
//create a new entry
entry = (GF_MPEGVisualSampleEntryBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_HVC1);
if (!entry) return GF_OUT_OF_MEM;
entry->hevc_config = (GF_HEVCConfigurationBox*)gf_isom_box_new(GF_ISOM_BOX_TYPE_HVCC);
entry->hevc_config->config = HEVC_DuplicateConfig(cfg);
entry->dataReferenceIndex = dataRefIndex;
e = gf_list_add(trak->Media->information->sampleTable->SampleDescription->other_boxes, entry);
*outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->other_boxes);
HEVC_RewriteESDescriptor(entry);
return e;
}
GF_Err gf_isom_new_webvtt_description(GF_ISOFile *movie, u32 trackNumber, GF_TextSampleDescriptor *desc, char *URLname, char *URNname, u32 *outDescriptionIndex)
{
GF_TrackBox *trak;
GF_Err e;
u32 dataRefIndex;
GF_WebVTTSampleEntryBox *wvtt;
e = CanAccessMovie(movie, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(movie, trackNumber);
if (!trak || !trak->Media) return GF_BAD_PARAM;
switch (trak->Media->handler->handlerType) {
case GF_ISOM_MEDIA_TEXT:
break;
default:
return GF_BAD_PARAM;
}
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
wvtt = (GF_WebVTTSampleEntryBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_WVTT);
wvtt->dataReferenceIndex = dataRefIndex;
gf_list_add(trak->Media->information->sampleTable->SampleDescription->other_boxes, wvtt);
if (outDescriptionIndex) *outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->other_boxes);
return e;
}
GF_Err gf_isom_new_text_description(GF_ISOFile *movie, u32 trackNumber, GF_TextSampleDescriptor *desc, char *URLname, char *URNname, u32 *outDescriptionIndex)
{
GF_TrackBox *trak;
GF_Err e;
u32 dataRefIndex, i;
GF_Tx3gSampleEntryBox *txt;
e = CanAccessMovie(movie, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(movie, trackNumber);
if (!trak || !trak->Media || !desc->font_count) return GF_BAD_PARAM;
switch (trak->Media->handler->handlerType) {
case GF_ISOM_MEDIA_TEXT:
case GF_ISOM_MEDIA_SUBT:
break;
default:
return GF_BAD_PARAM;
}
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
if (!movie->keep_utc)
trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
txt = (GF_Tx3gSampleEntryBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_TX3G);
txt->dataReferenceIndex = dataRefIndex;
gf_list_add(trak->Media->information->sampleTable->SampleDescription->other_boxes, txt);
if (outDescriptionIndex) *outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->other_boxes);
txt->back_color = desc->back_color;
txt->default_box = desc->default_pos;
txt->default_style = desc->default_style;
txt->displayFlags = desc->displayFlags;
txt->vertical_justification = desc->vert_justif;
txt->horizontal_justification = desc->horiz_justif;
txt->font_table = (GF_FontTableBox *)gf_isom_box_new(GF_ISOM_BOX_TYPE_FTAB);
txt->font_table->entry_count = desc->font_count;
txt->font_table->fonts = (GF_FontRecord *) gf_malloc(sizeof(GF_FontRecord) * desc->font_count);
for (i=0; i<desc->font_count; i++) {
txt->font_table->fonts[i].fontID = desc->fonts[i].fontID;
if (desc->fonts[i].fontName) txt->font_table->fonts[i].fontName = gf_strdup(desc->fonts[i].fontName);
}
return e;
}
GF_Err gf_isom_new_xml_subtitle_description(GF_ISOFile *movie, u32 trackNumber,
const char *xmlnamespace, const char *xml_schema_loc, const char *mimes,
u32 *outDescriptionIndex)
{
GF_TrackBox *trak;
GF_Err e;
u32 dataRefIndex;
GF_MetaDataSampleEntryBox *stpp;
char *URLname = NULL;
char *URNname = NULL;
e = CanAccessMovie(movie, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(movie, trackNumber);
if (!trak || !trak->Media) return GF_BAD_PARAM;
switch (trak->Media->handler->handlerType) {
case GF_ISOM_MEDIA_MPEG_SUBT:
case GF_ISOM_MEDIA_META:
case GF_ISOM_MEDIA_TEXT:
break;
default:
return GF_BAD_PARAM;
}
if (!xmlnamespace) {
GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("XML (Subtitle, Metadata or Text) SampleEntry: namespace is mandatory. Abort.\n"));
return GF_BAD_PARAM;
}
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
if (!movie->keep_utc)
trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
stpp = (GF_MetaDataSampleEntryBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_STPP);
stpp->dataReferenceIndex = dataRefIndex;
gf_list_add(trak->Media->information->sampleTable->SampleDescription->other_boxes, stpp);
if (outDescriptionIndex) *outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->other_boxes);
stpp->xml_namespace = gf_strdup(xmlnamespace);
if (xml_schema_loc) stpp->xml_schema_loc = gf_strdup(xml_schema_loc); //optional
if (mimes) stpp->mime_type = gf_strdup(mimes); //optional
return e;
}
GF_Err gf_isom_new_xml_metadata_description(GF_ISOFile *movie, u32 trackNumber,
const char *_namespace, const char *schema_loc, const char *content_encoding,
u32 *outDescriptionIndex)
{
GF_TrackBox *trak;
GF_Err e;
u32 dataRefIndex;
GF_MetaDataSampleEntryBox *metad;
char *URLname = NULL;
char *URNname = NULL;
e = CanAccessMovie(movie, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(movie, trackNumber);
if (!trak || !trak->Media || !_namespace)
return GF_BAD_PARAM;
switch (trak->Media->handler->handlerType) {
case GF_ISOM_MEDIA_MPEG_SUBT:
case GF_ISOM_MEDIA_META:
case GF_ISOM_MEDIA_TEXT:
break;
default:
return GF_BAD_PARAM;
}
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
if (!movie->keep_utc)
trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
metad = (GF_MetaDataSampleEntryBox*) gf_isom_box_new(GF_ISOM_BOX_TYPE_METX);
if (!metad) return GF_OUT_OF_MEM;
metad->dataReferenceIndex = dataRefIndex;
metad->xml_namespace = gf_strdup(_namespace);
if (content_encoding) metad->content_encoding = gf_strdup(content_encoding);
if (schema_loc) metad->xml_schema_loc = gf_strdup(schema_loc);
e = gf_list_add(trak->Media->information->sampleTable->SampleDescription->other_boxes, metad);
if (outDescriptionIndex) *outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->other_boxes);
return e;
}
//to use with internally supported protocols
GF_Err gf_isom_new_hint_description(GF_ISOFile *the_file, u32 trackNumber, s32 HintTrackVersion, s32 LastCompatibleVersion, u8 Rely, u32 *HintDescriptionIndex)
{
GF_Err e;
u32 drefIndex;
GF_TrackBox *trak;
GF_HintSampleEntryBox *hdesc;
GF_RelyHintBox *relyA;
e = CanAccessMovie(the_file, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(the_file, trackNumber);
*HintDescriptionIndex = 0;
if (!trak || !IsHintTrack(trak)) return GF_BAD_PARAM;
//OK, create a new HintSampleDesc
hdesc = (GF_HintSampleEntryBox *) gf_isom_box_new(GetHintFormat(trak));
if (HintTrackVersion > 0) hdesc->HintTrackVersion = HintTrackVersion;
if (LastCompatibleVersion > 0) hdesc->LastCompatibleVersion = LastCompatibleVersion;
//create a data reference - WE ONLY DEAL WITH SELF-CONTAINED HINT TRACKS
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, NULL, NULL, &drefIndex);
if (e) return e;
hdesc->dataReferenceIndex = drefIndex;
//add the entry to our table...
e = stsd_AddBox(trak->Media->information->sampleTable->SampleDescription, (GF_Box *) hdesc);
if (e) return e;
*HintDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->boxList);
//RTP needs a default timeScale... use the media one.
if (CheckHintFormat(trak, GF_ISOM_HINT_RTP)) {
e = gf_isom_rtp_set_timescale(the_file, trackNumber, *HintDescriptionIndex, trak->Media->mediaHeader->timeScale);
if (e) return e;
}
if (!Rely) return GF_OK;
//we need a rely box (common to all protocols)
relyA = (GF_RelyHintBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_RELY);
if (Rely == 1) {
relyA->prefered = 1;
} else {
relyA->required = 1;
}
return gf_list_add(hdesc->HintDataTable, relyA);
}
GF_Err gf_isom_new_generic_subtitle_description(GF_ISOFile *movie,
u32 trackNumber,
char *content_encoding,
char *xml_schema_loc,
char *mime_type_or_namespace,
Bool is_xml,
char *URLname,
char *URNname,
u32 *outDescriptionIndex)
{
GF_TrackBox *trak;
GF_Err e;
u32 dataRefIndex;
GF_MetaDataSampleEntryBox *metasd;
e = CanAccessMovie(movie, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(movie, trackNumber);
if (!trak || !trak->Media) return GF_BAD_PARAM;
switch (trak->Media->handler->handlerType) {
case GF_ISOM_MEDIA_SUBM:
break;
default:
return GF_BAD_PARAM;
}
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
metasd = (GF_MetaDataSampleEntryBox *) gf_isom_box_new((is_xml ? GF_ISOM_BOX_TYPE_METX : GF_ISOM_BOX_TYPE_METT));
metasd->dataReferenceIndex = dataRefIndex;
gf_list_add(trak->Media->information->sampleTable->SampleDescription->other_boxes, metasd);
if (outDescriptionIndex) *outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->other_boxes);
metasd->content_encoding = gf_strdup(content_encoding);
metasd->xml_schema_loc = gf_strdup(xml_schema_loc);
metasd->mime_type_or_namespace = gf_strdup(mime_type_or_namespace);
return e;
}
GF_Err gf_isom_new_dims_description(GF_ISOFile *movie, u32 trackNumber, GF_DIMSDescription *desc, char *URLname, char *URNname, u32 *outDescriptionIndex)
{
GF_TrackBox *trak;
GF_Err e;
u32 dataRefIndex;
GF_DIMSSampleEntryBox *dims;
e = CanAccessMovie(movie, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(movie, trackNumber);
if (!trak || !trak->Media) return GF_BAD_PARAM;
if (trak->Media->handler->handlerType != GF_ISOM_MEDIA_SCENE) return GF_BAD_PARAM;
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
if (!movie->keep_utc)
trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
dims = (GF_DIMSSampleEntryBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_DIMS);
dims->dataReferenceIndex = dataRefIndex;
gf_list_add(trak->Media->information->sampleTable->SampleDescription->other_boxes, dims);
if (outDescriptionIndex) *outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->other_boxes);
dims->config = (GF_DIMSSceneConfigBox*) gf_isom_box_new(GF_ISOM_BOX_TYPE_DIMC);
dims->config->profile = desc->profile;
dims->config->level = desc->level;
dims->config->pathComponents = desc->pathComponents;
dims->config->fullRequestHost = desc->fullRequestHost;
dims->config->containsRedundant = desc->containsRedundant;
if (!dims->config->containsRedundant) dims->config->containsRedundant = 1;
dims->config->streamType = desc->streamType;
dims->config->textEncoding = gf_strdup(desc->textEncoding ? desc->textEncoding : "");
dims->config->contentEncoding = gf_strdup(desc->contentEncoding ? desc->contentEncoding : "");
if (desc->content_script_types) {
dims->scripts = (GF_DIMSScriptTypesBox*) gf_isom_box_new(GF_ISOM_BOX_TYPE_DIST);
dims->scripts->content_script_types = gf_strdup(desc->content_script_types);
}
return e;
}
M4Err M4_AMR_NewStreamConfig(M4File *the_file, u32 trackNumber, LPAMRCONFIGURATION param, char *URLname, char *URNname, u32 *outDescriptionIndex)
{
TrackAtom *trak;
M4Err e;
u32 dataRefIndex;
TrackReferenceTypeAtom *dpnd;
TrackReferenceAtom *tref;
AMRSampleEntryAtom *entry;
e = CanAccessMovie((M4Movie *)the_file, M4_OPEN_WRITE);
if (e) return e;
trak = GetTrackFromFile(the_file, trackNumber);
if (!trak || !trak->Media || !param) return M4BadParam;
dpnd = NULL;
tref = NULL;
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
trak->Media->mediaHeader->modificationTime = GetMP4Time();
//create a new entry
entry = (AMRSampleEntryAtom *) CreateAtom(param->WideBandAMR ? WB_AMRSampleEntryAtomType : AMRSampleEntryAtomType);
if (!entry) return M4OutOfMem;
entry->amr_info = (AMRConfigAtom *) CreateAtom(AMRConfigAtomType);
if (!entry->amr_info) {
DelAtom((Atom *) entry);
return M4OutOfMem;
}
entry->samplerate_hi = trak->Media->mediaHeader->timeScale;
entry->dataReferenceIndex = dataRefIndex;
entry->amr_info->decoder_version = param->decoder_version;
entry->amr_info->vendor = param->vendor;
entry->amr_info->frames_per_sample = param->frames_per_sample;
entry->amr_info->mode_change_period = param->mode_change_period;
entry->amr_info->mode_set = param->mode_set;
e = ChainAddEntry(trak->Media->information->sampleTable->SampleDescription->atomList, entry);
*outDescriptionIndex = ChainGetCount(trak->Media->information->sampleTable->SampleDescription->atomList);
return e;
}
//to use with internally supported protocols
M4Err M4H_NewHintDescription(M4File *the_file, u32 trackNumber, s32 HintTrackVersion, s32 LastCompatibleVersion, u8 Rely, u32 *HintDescriptionIndex)
{
M4Err e;
u32 drefIndex;
TrackAtom *trak;
HintSampleEntryAtom *hdesc;
RelyHintEntry *relyA;
M4Err stsd_AddAtom(SampleDescriptionAtom *ptr, Atom *a);
trak = GetTrackFromFile(the_file, trackNumber);
*HintDescriptionIndex = 0;
if (!trak || !IsHintTrack(trak)) return M4BadParam;
//OK, create a new HintSampleDesc
hdesc = (HintSampleEntryAtom *) CreateAtom(GetHintFormat(trak));
if (HintTrackVersion > 0) hdesc->HintTrackVersion = HintTrackVersion;
if (LastCompatibleVersion > 0) hdesc->LastCompatibleVersion = LastCompatibleVersion;
//create a data reference - WE ONLY DEAL WITH SELF-CONTAINED HINT TRACKS
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, NULL, NULL, &drefIndex);
if (e) return e;
hdesc->dataReferenceIndex = drefIndex;
//add the entry to our table...
e = stsd_AddAtom(trak->Media->information->sampleTable->SampleDescription, (Atom *) hdesc);
if (e) return e;
*HintDescriptionIndex = ChainGetCount(trak->Media->information->sampleTable->SampleDescription->atomList);
//RTP needs a default timeScale... use the media one.
if (CheckHintFormat(trak, M4_Hint_RTP)) {
e = M4H_RTP_SetTimeScale(the_file, trackNumber, *HintDescriptionIndex, trak->Media->mediaHeader->timeScale);
if (e) return e;
}
if (!Rely) return M4OK;
//we need a rely atom (common to all protocols)
relyA = (RelyHintEntry *) CreateAtom(relyHintEntryType);
if (Rely == 1) {
relyA->prefered = 1;
} else {
relyA->required = 1;
}
return ChainAddEntry(hdesc->HintDataTable, relyA);
}
GF_EXPORT
GF_Err gf_isom_ac3_config_new(GF_ISOFile *the_file, u32 trackNumber, GF_AC3Config *cfg, char *URLname, char *URNname, u32 *outDescriptionIndex)
{
GF_TrackBox *trak;
GF_Err e;
u32 dataRefIndex;
GF_AC3SampleEntryBox *entry;
e = CanAccessMovie(the_file, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(the_file, trackNumber);
if (!trak || !trak->Media || !cfg) return GF_BAD_PARAM;
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
if (!the_file->keep_utc)
trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
if (cfg->is_ec3) {
entry = (GF_AC3SampleEntryBox *)gf_isom_box_new(GF_ISOM_BOX_TYPE_EC3);
if (!entry) return GF_OUT_OF_MEM;
entry->info = (GF_AC3ConfigBox *)gf_isom_box_new(GF_ISOM_BOX_TYPE_DEC3);
}
else {
entry = (GF_AC3SampleEntryBox *)gf_isom_box_new(GF_ISOM_BOX_TYPE_AC3);
if (!entry) return GF_OUT_OF_MEM;
entry->info = (GF_AC3ConfigBox *)gf_isom_box_new(GF_ISOM_BOX_TYPE_DAC3);
}
if (!entry->info) {
gf_isom_box_del((GF_Box *)entry);
return GF_OUT_OF_MEM;
}
memcpy(&entry->info->cfg, cfg, sizeof(GF_AC3Config));
entry->samplerate_hi = trak->Media->mediaHeader->timeScale;
entry->dataReferenceIndex = dataRefIndex;
e = gf_list_add(trak->Media->information->sampleTable->SampleDescription->other_boxes, entry);
*outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->other_boxes);
return e;
}
M4Err M4_H263_NewStreamConfig(M4File *the_file, u32 trackNumber, LPH263CONFIGURATION param, char *URLname, char *URNname, u32 *outDescriptionIndex)
{
TrackAtom *trak;
M4Err e;
u32 dataRefIndex;
TrackReferenceTypeAtom *dpnd;
TrackReferenceAtom *tref;
H263SampleEntryAtom *entry;
e = CanAccessMovie((M4Movie *)the_file, M4_OPEN_WRITE);
if (e) return e;
trak = GetTrackFromFile(the_file, trackNumber);
if (!trak || !trak->Media || !param) return M4BadParam;
dpnd = NULL;
tref = NULL;
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
trak->Media->mediaHeader->modificationTime = GetMP4Time();
//create a new entry
entry = (H263SampleEntryAtom *) CreateAtom(H263SampleEntryAtomType);
if (!entry) return M4OutOfMem;
entry->h263_config = (H263ConfigAtom *) CreateAtom(H263ConfigAtomType);
if (!entry->h263_config) {
DelAtom((Atom *) entry);
return M4OutOfMem;
}
entry->dataReferenceIndex = dataRefIndex;
entry->h263_config->decoder_version = param->decoder_version;
entry->h263_config->vendor = param->vendor;
entry->h263_config->Level = param->Level;
entry->h263_config->Profile = param->Profile;
e = ChainAddEntry(trak->Media->information->sampleTable->SampleDescription->atomList, entry);
*outDescriptionIndex = ChainGetCount(trak->Media->information->sampleTable->SampleDescription->atomList);
return e;
}
GF_Err gf_isom_add_meta_item_extended(GF_ISOFile *file, Bool root_meta, u32 track_num, Bool self_reference, char *resource_path,
const char *item_name, u32 item_id, const char *mime_type, const char *content_encoding,
GF_ImageItemProperties *image_props,
const char *URL, const char *URN,
char *data, u32 data_len)
{
GF_Err e;
GF_ItemLocationEntry *location_entry;
GF_ItemInfoEntryBox *infe;
GF_MetaBox *meta;
u32 lastItemID = 0;
if (!self_reference && !item_name && !resource_path) return GF_BAD_PARAM;
e = CanAccessMovie(file, GF_ISOM_OPEN_WRITE);
if (e) return e;
meta = gf_isom_get_meta(file, root_meta, track_num);
if (!meta) {
GF_LOG(GF_LOG_ERROR, GF_LOG_CONTAINER, ("Trying to add item, but missing meta box"));
return GF_BAD_PARAM;
}
e = FlushCaptureMode(file);
if (e) return e;
/*check file exists */
if (!URN && !URL && !self_reference && !data) {
FILE *src = gf_fopen(resource_path, "rb");
if (!src) return GF_URL_ERROR;
gf_fclose(src);
}
if (meta->item_infos) {
u32 i;
u32 item_count = gf_list_count(meta->item_infos->item_infos);
for (i = 0; i < item_count; i++) {
GF_ItemInfoEntryBox *e= (GF_ItemInfoEntryBox *)gf_list_get(meta->item_infos->item_infos, i);
if (e->item_ID > lastItemID) lastItemID = e->item_ID;
if (item_id == e->item_ID) {
GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("[IsoMedia] Item with id %d already exists, ignoring\n", item_id));
item_id = 0;
}
}
}
infe = (GF_ItemInfoEntryBox *)infe_New();
if (item_id) {
infe->item_ID = item_id;
} else {
infe->item_ID = ++lastItemID;
}
/*get relative name*/
if (item_name) {
infe->item_name = gf_strdup(item_name);
} else if (resource_path) {
if (strrchr(resource_path, GF_PATH_SEPARATOR)) {
infe->item_name = gf_strdup(strrchr(resource_path, GF_PATH_SEPARATOR) + 1);
} else {
infe->item_name = gf_strdup(resource_path);
}
}
if (mime_type) {
infe->content_type = gf_strdup(mime_type);
} else {
infe->content_type = gf_strdup("application/octet-stream");
}
if (content_encoding) infe->content_encoding = gf_strdup(content_encoding);
/*Creation of the ItemLocation */
location_entry = (GF_ItemLocationEntry*)gf_malloc(sizeof(GF_ItemLocationEntry));
if (!location_entry) {
gf_isom_box_del((GF_Box *)infe);
return GF_OUT_OF_MEM;
}
memset(location_entry, 0, sizeof(GF_ItemLocationEntry));
location_entry->extent_entries = gf_list_new();
/*Creates an mdat if it does not exist*/
if (!file->mdat) {
file->mdat = (GF_MediaDataBox *)mdat_New();
gf_list_add(file->TopBoxes, file->mdat);
}
/*Creation an ItemLocation Box if it does not exist*/
if (!meta->item_locations) meta->item_locations = (GF_ItemLocationBox *)iloc_New();
gf_list_add(meta->item_locations->location_entries, location_entry);
location_entry->item_ID = infe->item_ID;
if (!meta->item_infos) meta->item_infos = (GF_ItemInfoBox *) iinf_New();
e = gf_list_add(meta->item_infos->item_infos, infe);
if (e) return e;
if (image_props) {
meta_process_image_properties(meta, infe->item_ID, image_props);
}
/*0: the current file*/
location_entry->data_reference_index = 0;
if (self_reference) {
GF_ItemExtentEntry *entry;
GF_SAFEALLOC(entry, GF_ItemExtentEntry);
gf_list_add(location_entry->extent_entries, entry);
if (!infe->item_name) infe->item_name = gf_strdup("");
return GF_OK;
}
/*file not copied, just referenced*/
if (URL || URN) {
u32 dataRefIndex;
if (!meta->file_locations) meta->file_locations = (GF_DataInformationBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_DINF);
if (!meta->file_locations->dref) meta->file_locations->dref = (GF_DataReferenceBox *) gf_isom_box_new(GF_ISOM_BOX_TYPE_DREF);
e = Media_FindDataRef(meta->file_locations->dref, (char *) URL, (char *) URN, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(meta->file_locations->dref, (char *) URL, (char *) URN, &dataRefIndex);
if (e) return e;
}
location_entry->data_reference_index = dataRefIndex;
}
/*capture mode, write to disk*/
if ((file->openMode == GF_ISOM_OPEN_WRITE) && !location_entry->data_reference_index) {
FILE *src;
GF_ItemExtentEntry *entry;
GF_SAFEALLOC(entry, GF_ItemExtentEntry);
location_entry->base_offset = gf_bs_get_position(file->editFileMap->bs);
/*update base offset size*/
if (location_entry->base_offset>0xFFFFFFFF) meta->item_locations->base_offset_size = 8;
else if (location_entry->base_offset && !meta->item_locations->base_offset_size) meta->item_locations->base_offset_size = 4;
entry->extent_length = 0;
entry->extent_offset = 0;
gf_list_add(location_entry->extent_entries, entry);
if (data) {
gf_bs_write_data(file->editFileMap->bs, data, data_len);
/*update length size*/
if (entry->extent_length>0xFFFFFFFF) meta->item_locations->length_size = 8;
else if (entry->extent_length && !meta->item_locations->length_size) meta->item_locations->length_size = 4;
} else if (resource_path) {
src = gf_fopen(resource_path, "rb");
if (src) {
char cache_data[4096];
u64 remain;
gf_fseek(src, 0, SEEK_END);
entry->extent_length = gf_ftell(src);
gf_fseek(src, 0, SEEK_SET);
remain = entry->extent_length;
while (remain) {
u32 size_cache = (remain>4096) ? 4096 : (u32) remain;
size_t read = fread(cache_data, 1, size_cache, src);
if (read==(size_t)-1) break;
gf_bs_write_data(file->editFileMap->bs, cache_data, (u32) read);
remain -= (u32) read;
}
gf_fclose(src);
/*update length size*/
if (entry->extent_length>0xFFFFFFFF) meta->item_locations->length_size = 8;
else if (entry->extent_length && !meta->item_locations->length_size) meta->item_locations->length_size = 4;
}
}
}
/*store full path for info*/
else if (!location_entry->data_reference_index) {
if (data) {
infe->full_path = (char *)gf_malloc(sizeof(char) * data_len);
memcpy(infe->full_path, data, sizeof(char) * data_len);
infe->data_len = data_len;
} else {
infe->full_path = gf_strdup(resource_path);
infe->data_len = 0;
}
}
return GF_OK;
}
GF_EXPORT
GF_Err gf_isom_3gp_config_new(GF_ISOFile *the_file, u32 trackNumber, GF_3GPConfig *cfg, char *URLname, char *URNname, u32 *outDescriptionIndex)
{
GF_TrackBox *trak;
GF_Err e;
u32 dataRefIndex;
u32 cfg_type;
e = CanAccessMovie(the_file, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(the_file, trackNumber);
if (!trak || !trak->Media || !cfg) return GF_BAD_PARAM;
switch (cfg->type) {
case GF_ISOM_SUBTYPE_3GP_AMR:
case GF_ISOM_SUBTYPE_3GP_AMR_WB:
if (trak->Media->handler->handlerType!=GF_ISOM_MEDIA_AUDIO) return GF_BAD_PARAM;
cfg_type = GF_ISOM_BOX_TYPE_DAMR;
break;
case GF_ISOM_SUBTYPE_3GP_EVRC:
if (trak->Media->handler->handlerType!=GF_ISOM_MEDIA_AUDIO) return GF_BAD_PARAM;
cfg_type = GF_ISOM_BOX_TYPE_DEVC;
break;
case GF_ISOM_SUBTYPE_3GP_QCELP:
if (trak->Media->handler->handlerType!=GF_ISOM_MEDIA_AUDIO) return GF_BAD_PARAM;
cfg_type = GF_ISOM_BOX_TYPE_DQCP;
break;
case GF_ISOM_SUBTYPE_3GP_SMV:
if (trak->Media->handler->handlerType!=GF_ISOM_MEDIA_AUDIO) return GF_BAD_PARAM;
cfg_type = GF_ISOM_BOX_TYPE_DSMV;
break;
case GF_ISOM_SUBTYPE_3GP_H263:
if (trak->Media->handler->handlerType!=GF_ISOM_MEDIA_VISUAL) return GF_BAD_PARAM;
cfg_type = GF_ISOM_BOX_TYPE_D263;
break;
case 0: return GF_BAD_PARAM;
default:
return GF_NOT_SUPPORTED;
}
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
switch (cfg->type) {
case GF_ISOM_SUBTYPE_3GP_AMR:
case GF_ISOM_SUBTYPE_3GP_AMR_WB:
case GF_ISOM_SUBTYPE_3GP_EVRC:
case GF_ISOM_SUBTYPE_3GP_QCELP:
case GF_ISOM_SUBTYPE_3GP_SMV:
{
GF_3GPPAudioSampleEntryBox *entry = (GF_3GPPAudioSampleEntryBox *) gf_isom_box_new(cfg->type);
if (!entry) return GF_OUT_OF_MEM;
entry->info = (GF_3GPPConfigBox *) gf_isom_box_new(cfg_type);
if (!entry->info) {
gf_isom_box_del((GF_Box *) entry);
return GF_OUT_OF_MEM;
}
memcpy(&entry->info->cfg, cfg, sizeof(GF_3GPConfig));
entry->samplerate_hi = trak->Media->mediaHeader->timeScale;
entry->dataReferenceIndex = dataRefIndex;
e = gf_list_add(trak->Media->information->sampleTable->SampleDescription->other_boxes, entry);
*outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->other_boxes);
}
break;
case GF_ISOM_SUBTYPE_3GP_H263:
{
GF_3GPPVisualSampleEntryBox *entry = (GF_3GPPVisualSampleEntryBox *) gf_isom_box_new(cfg->type);
if (!entry) return GF_OUT_OF_MEM;
entry->info = (GF_3GPPConfigBox *) gf_isom_box_new(cfg_type);
if (!entry->info) {
gf_isom_box_del((GF_Box *) entry);
return GF_OUT_OF_MEM;
}
memcpy(&entry->info->cfg, cfg, sizeof(GF_3GPConfig));
entry->dataReferenceIndex = dataRefIndex;
e = gf_list_add(trak->Media->information->sampleTable->SampleDescription->other_boxes, entry);
*outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->other_boxes);
}
break;
}
return e;
}
GF_Err gf_isom_new_stxt_description(GF_ISOFile *movie, u32 trackNumber, u32 type,
const char *mime, const char *encoding, const char * config,
u32 *outDescriptionIndex)
{
GF_TrackBox *trak;
GF_Err e;
u32 dataRefIndex;
GF_MetaDataSampleEntryBox *sample_entry;
char *URLname = NULL;
char *URNname = NULL;
e = CanAccessMovie(movie, GF_ISOM_OPEN_WRITE);
if (e) return e;
trak = gf_isom_get_track_from_file(movie, trackNumber);
if (!trak || !trak->Media) return GF_BAD_PARAM;
switch (trak->Media->handler->handlerType) {
case GF_ISOM_MEDIA_MPEG_SUBT:
case GF_ISOM_MEDIA_META:
case GF_ISOM_MEDIA_SCENE:
case GF_ISOM_MEDIA_TEXT:
case GF_ISOM_MEDIA_SUBT:
break;
default:
return GF_BAD_PARAM;
}
switch (type) {
case GF_ISOM_SUBTYPE_SBTT:
case GF_ISOM_SUBTYPE_STXT:
case GF_ISOM_SUBTYPE_METT:
break;
default:
GF_LOG(GF_LOG_ERROR, GF_LOG_PARSER, ("SampleEntry shall be either Metadata, Subtitle or SimpleText. Abort.\n"));
return GF_BAD_PARAM;
}
if (!mime) {
GF_LOG(GF_LOG_WARNING, GF_LOG_PARSER, ("Text (Metadata, Subtitle or SimpleText) SampleEntry: mime is mandatory. Using text/plain.\n"));
mime = "text/plain";
}
//get or create the data ref
e = Media_FindDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
if (!dataRefIndex) {
e = Media_CreateDataRef(trak->Media->information->dataInformation->dref, URLname, URNname, &dataRefIndex);
if (e) return e;
}
if (!movie->keep_utc)
trak->Media->mediaHeader->modificationTime = gf_isom_get_mp4time();
sample_entry = (GF_MetaDataSampleEntryBox *) gf_isom_box_new(type);
sample_entry->dataReferenceIndex = dataRefIndex;
gf_list_add(trak->Media->information->sampleTable->SampleDescription->other_boxes, sample_entry);
if (outDescriptionIndex) *outDescriptionIndex = gf_list_count(trak->Media->information->sampleTable->SampleDescription->other_boxes);
sample_entry->mime_type = gf_strdup(mime);
if (encoding) sample_entry->content_encoding = gf_strdup(encoding);
if (config) {
sample_entry->config = (GF_TextConfigBox*) gf_isom_box_new(GF_ISOM_BOX_TYPE_TXTC);
sample_entry->config->config = gf_strdup(config);
}
return e;
}
