static Bool uir_process(GF_TermExt *termext, u32 action, void *param)
{
const char *opt, *uifile;
GF_UIRecord *uir = termext->udta;
switch (action) {
case GF_TERM_EXT_START:
uir->term = (GF_Terminal *) param;
opt = gf_modules_get_option((GF_BaseInterface*)termext, "UIRecord", "Mode");
if (!opt) return 0;
uifile = gf_modules_get_option((GF_BaseInterface*)termext, "UIRecord", "File");
if (!opt) return 0;
if (!strcmp(opt, "Play")) {
uir->uif = gf_f64_open(uifile, "rb");
if (!uir->uif) return 0;
uir->bs = gf_bs_from_file(uir->uif, GF_BITSTREAM_READ);
termext->caps |= GF_TERM_EXTENSION_NOT_THREADED;
uir->evt_filter.on_event = uir_on_event_play;
uir->evt_filter.udta = uir;
gf_term_add_event_filter(uir->term, &uir->evt_filter);
uir_load_event(uir);
} else if (!strcmp(opt, "Record")) {
uir->uif = fopen(uifile, "wb");
if (!uir->uif) return 0;
uir->bs = gf_bs_from_file(uir->uif, GF_BITSTREAM_WRITE);
uir->evt_filter.on_event = uir_on_event_record;
uir->evt_filter.udta = uir;
gf_term_add_event_filter(uir->term, &uir->evt_filter);
} else {
return 0;
}
return 1;
case GF_TERM_EXT_STOP:
if (uir->uif) fclose(uir->uif);
if (uir->bs) gf_bs_del(uir->bs);
gf_term_remove_event_filter(uir->term, &uir->evt_filter);
uir->term = NULL;
/*auto-disable the plugin by default*/
gf_modules_set_option((GF_BaseInterface*)termext, "UIRecord", "Mode", "Disable");
break;
case GF_TERM_EXT_PROCESS:
/*flush all events until current time if reached*/
while (uir->evt_loaded && uir->ck && (uir->next_time <= gf_clock_time(uir->ck) )) {
uir->term->compositor->video_out->on_event(uir->term->compositor->video_out->evt_cbk_hdl, &uir->next_event);
uir_load_event(uir);
}
break;
}
return 0;
}
static Bool AC3_ConfigureFromFile(AC3Reader *read)
{
Bool sync;
GF_BitStream *bs;
GF_AC3Header hdr;
memset(&hdr, 0, sizeof(GF_AC3Header));
if (!read->stream) return 0;
bs = gf_bs_from_file(read->stream, GF_BITSTREAM_READ);
sync = gf_ac3_parser_bs(bs, &hdr, GF_TRUE);
if (!sync) {
gf_bs_del(bs);
return GF_FALSE;
}
read->nb_ch = hdr.channels;
read->sample_rate = hdr.sample_rate;
read->duration = 0;
if (!read->is_remote) {
read->duration = 1536;
gf_bs_skip_bytes(bs, hdr.framesize);
while (gf_ac3_parser_bs(bs, &hdr, GF_FALSE)) {
read->duration += 1536;
gf_bs_skip_bytes(bs, hdr.framesize);
}
}
gf_bs_del(bs);
gf_f64_seek(read->stream, 0, SEEK_SET);
return 1;
}
static Bool AAC_ConfigureFromFile(AACReader *read)
{
Bool sync;
GF_BitStream *bs;
ADTSHeader hdr;
if (!read->stream) return 0;
bs = gf_bs_from_file(read->stream, GF_BITSTREAM_READ);
sync = ADTS_SyncFrame(bs, !read->is_remote, &hdr);
if (!sync) {
gf_bs_del(bs);
return 0;
}
read->nb_ch = hdr.nb_ch;
read->prof = hdr.profile;
read->sr_idx = hdr.sr_idx;
read->oti = hdr.is_mp2 ? read->prof+0x66 : 0x40;
read->sample_rate = GF_M4ASampleRates[read->sr_idx];
read->duration = 0;
if (!read->is_remote) {
read->duration = 1024;
gf_bs_skip_bytes(bs, hdr.frame_size);
while (ADTS_SyncFrame(bs, !read->is_remote, &hdr)) {
read->duration += 1024;
gf_bs_skip_bytes(bs, hdr.frame_size);
}
}
gf_bs_del(bs);
fseek(read->stream, 0, SEEK_SET);
return 1;
}
GF_DataMap *gf_isom_fdm_new_temp(const char *sPath)
{
GF_FileDataMap *tmp = (GF_FileDataMap *) gf_malloc(sizeof(GF_FileDataMap));
if (!tmp) return NULL;
memset(tmp, 0, sizeof(GF_FileDataMap));
tmp->type = GF_ISOM_DATA_FILE;
tmp->mode = GF_ISOM_DATA_MAP_WRITE;
if (!sPath) {
tmp->stream = gf_temp_file_new();
} else {
char szPath[GF_MAX_PATH];
if ((sPath[strlen(sPath)-1] != '\\') && (sPath[strlen(sPath)-1] != '/')) {
sprintf(szPath, "%s%c%p_isotmp", sPath, GF_PATH_SEPARATOR, (void*) tmp);
} else {
sprintf(szPath, "%s%p_isotmp", sPath, (void*) tmp);
}
tmp->stream = gf_f64_open(szPath, "w+b");
tmp->temp_file = gf_strdup(szPath);
}
if (!tmp->stream) {
if (tmp->temp_file) gf_free(tmp->temp_file);
gf_free(tmp);
return NULL;
}
tmp->bs = gf_bs_from_file(tmp->stream, GF_BITSTREAM_WRITE);
if (!tmp->bs) {
fclose(tmp->stream);
gf_free(tmp);
return NULL;
}
return (GF_DataMap *)tmp;
}
GF_Err WriteToFile(GF_ISOFile *movie)
{
FILE *stream;
GF_BitStream *bs;
MovieWriter mw;
GF_Err e = GF_OK;
if (!movie) return GF_BAD_PARAM;
if (movie->openMode == GF_ISOM_OPEN_READ) return GF_BAD_PARAM;
e = gf_isom_insert_copyright(movie);
if (e) return e;
memset(&mw, 0, sizeof(mw));
mw.movie = movie;
//capture mode: we don't need a new bitstream
if (movie->openMode == GF_ISOM_OPEN_WRITE) {
e = WriteFlat(&mw, 0, movie->editFileMap->bs);
} else {
//OK, we need a new bitstream
stream = gf_f64_open(movie->finalName, "w+b");
if (!stream) return GF_IO_ERR;
bs = gf_bs_from_file(stream, GF_BITSTREAM_WRITE);
if (!bs) {
fclose(stream);
return GF_OUT_OF_MEM;
}
switch (movie->storageMode) {
case GF_ISOM_STORE_TIGHT:
case GF_ISOM_STORE_INTERLEAVED:
e = WriteInterleaved(&mw, bs, 0);
break;
case GF_ISOM_STORE_DRIFT_INTERLEAVED:
e = WriteInterleaved(&mw, bs, 1);
break;
case GF_ISOM_STORE_STREAMABLE:
e = WriteFlat(&mw, 1, bs);
break;
default:
e = WriteFlat(&mw, 0, bs);
break;
}
gf_bs_del(bs);
fclose(stream);
}
if (mw.buffer) gf_free(mw.buffer);
if (mw.nb_done<mw.total_samples) {
gf_set_progress("ISO File Writing", mw.total_samples, mw.total_samples);
}
return e;
}
GF_DataMap *gf_isom_fdm_new(const char *sPath, u8 mode)
{
u8 bs_mode;
GF_FileDataMap *tmp = (GF_FileDataMap *) gf_malloc(sizeof(GF_FileDataMap));
if (!tmp) return NULL;
memset(tmp, 0, sizeof(GF_FileDataMap));
tmp->type = GF_ISOM_DATA_FILE;
tmp->mode = mode;
#ifndef GPAC_DISABLE_ISOM_WRITE
//open a temp file
if (!strcmp(sPath, "mp4_tmp_edit")) {
//create a temp file (that only occurs in EDIT/WRITE mode)
tmp->stream = gf_temp_file_new();
bs_mode = GF_BITSTREAM_READ;
}
#endif
switch (mode) {
case GF_ISOM_DATA_MAP_READ:
if (!tmp->stream) tmp->stream = gf_f64_open(sPath, "rb");
bs_mode = GF_BITSTREAM_READ;
break;
///we open the file in READ/WRITE mode, in case
case GF_ISOM_DATA_MAP_WRITE:
if (!tmp->stream) tmp->stream = gf_f64_open(sPath, "w+b");
if (!tmp->stream) tmp->stream = gf_f64_open(sPath, "wb");
bs_mode = GF_BITSTREAM_WRITE;
break;
///we open the file in CAT mode, in case
case GF_ISOM_DATA_MAP_CAT:
if (!tmp->stream) tmp->stream = gf_f64_open(sPath, "a+b");
if (tmp->stream) gf_f64_seek(tmp->stream, 0, SEEK_END);
bs_mode = GF_BITSTREAM_WRITE;
break;
default:
gf_free(tmp);
return NULL;
}
if (!tmp->stream) {
gf_free(tmp);
return NULL;
}
tmp->bs = gf_bs_from_file(tmp->stream, bs_mode);
if (!tmp->bs) {
fclose(tmp->stream);
gf_free(tmp);
return NULL;
}
return (GF_DataMap *)tmp;
}
void main(int argc, char **argv)
{
FILE *in;
GF_BitStream *bs;
/* generation d'un TS aléatoire */
/*
if ((in=gf_fopen(argv[1], "wb")) == NULL) {
printf( "Impossible d'ouvrir %s en lecture.\n", argv[1]);
}
{
char buffer[188];
u32 j, i, nb_packets = 300;
for (i = 0; i < nb_packets; i++) {
buffer[0] = 0x47;
for (j = 1; j <188; j++) {
buffer[j] = rand();//j;
}
gf_fwrite(buffer, 1, 188, in);
}
}
gf_fclose(in);
if ((in=gf_fopen(argv[1], "rb")) == NULL) {
printf( "Impossible d'ouvrir %s en lecture.\n", argv[1]);
}
bs = gf_bs_from_file(in, GF_BITSTREAM_READ);
if (bs == NULL) return;
RS_Interleaver(bs, argv[2]);
gf_fclose(in);
gf_bs_del(bs);
*/
if ((in=gf_fopen(argv[1], "rb")) == NULL) {
printf( "Impossible d'ouvrir %s en lecture.\n", argv[1]);
}
bs = gf_bs_from_file(in, GF_BITSTREAM_READ);
if (bs == NULL) return;
RS_Deinterleaver(bs, argv[2]);
gf_fclose(in);
gf_bs_del(bs);
}
GF_ESD *IMG_GetESD(IMGLoader *read)
{
GF_ESD *esd = gf_odf_desc_esd_new(0);
esd->slConfig->timestampResolution = 1000;
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->ESID = 1;
if (read->img_type == IMG_BMP)
esd->decoderConfig->objectTypeIndication = GPAC_BMP_OTI;
else {
u8 OTI=0;
GF_BitStream *bs = gf_bs_from_file(read->stream, GF_BITSTREAM_READ);
#ifndef GPAC_DISABLE_AV_PARSERS
u32 mtype, w, h;
gf_img_parse(bs, &OTI, &mtype, &w, &h, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
#endif
gf_bs_del(bs);
if (!OTI) {
GF_LOG(GF_LOG_WARNING, GF_LOG_CODEC, ("[IMG_IN] Unable to guess format image - assigning from extension\n"));
if (read->img_type==IMG_JPEG) OTI = GPAC_OTI_IMAGE_JPEG;
else if (read->img_type==IMG_PNG) OTI = GPAC_OTI_IMAGE_PNG;
}
esd->decoderConfig->objectTypeIndication = OTI;
if (read->img_type == IMG_PNGD) {
GF_Descriptor *d = gf_odf_desc_new(GF_ODF_AUX_VIDEO_DATA);
((GF_AuxVideoDescriptor*)d)->aux_video_type = 1;
gf_list_add(esd->extensionDescriptors, d);
}
else if (read->img_type == IMG_PNGDS) {
GF_Descriptor *d = gf_odf_desc_new(GF_ODF_AUX_VIDEO_DATA);
((GF_AuxVideoDescriptor*)d)->aux_video_type = 2;
gf_list_add(esd->extensionDescriptors, d);
}
else if (read->img_type == IMG_PNGS) {
GF_Descriptor *d = gf_odf_desc_new(GF_ODF_AUX_VIDEO_DATA);
((GF_AuxVideoDescriptor*)d)->aux_video_type = 3;
gf_list_add(esd->extensionDescriptors, d);
}
}
return esd;
}
static void SAF_CheckFile(SAFIn *read)
{
u32 nb_streams, i, cts, au_size, au_type, stream_id, ts_res;
GF_BitStream *bs;
StreamInfo si[1024];
gf_f64_seek(read->stream, 0, SEEK_SET);
bs = gf_bs_from_file(read->stream, GF_BITSTREAM_READ);
nb_streams=0;
while (gf_bs_available(bs)) {
gf_bs_read_u16(bs);
gf_bs_read_int(bs, 2);
cts = gf_bs_read_int(bs, 30);
au_size = gf_bs_read_int(bs, 16);
au_type = gf_bs_read_int(bs, 4);
stream_id = gf_bs_read_int(bs, 12);
au_size-=2;
ts_res = 0;
for (i=0; i<nb_streams; i++) {
if (si[i].stream_id==stream_id) ts_res = si[i].ts_res;
}
if (!ts_res) {
if ((au_type==1) || (au_type==2) || (au_type==7)) {
gf_bs_read_u16(bs);
ts_res = gf_bs_read_u24(bs);
au_size -= 5;
si[nb_streams].stream_id = stream_id;
si[nb_streams].ts_res = ts_res;
nb_streams++;
}
}
if (ts_res && (au_type==4)) {
Double ts = cts;
ts /= ts_res;
if (ts>read->duration) read->duration = ts;
}
gf_bs_skip_bytes(bs, au_size);
}
gf_bs_del(bs);
gf_f64_seek(read->stream, 0, SEEK_SET);
}
static GF_Err AC3_ChannelGetSLP(GF_InputService *plug, LPNETCHANNEL channel, char **out_data_ptr, u32 *out_data_size, GF_SLHeader *out_sl_hdr, Bool *sl_compressed, GF_Err *out_reception_status, Bool *is_new_data)
{
u64 pos, start_from;
Bool sync;
GF_BitStream *bs;
GF_AC3Header hdr;
AC3Reader *read = plug->priv;
*out_reception_status = GF_OK;
*sl_compressed = 0;
*is_new_data = 0;
memset(&hdr, 0, sizeof(GF_AC3Header));
memset(&read->sl_hdr, 0, sizeof(GF_SLHeader));
read->sl_hdr.randomAccessPointFlag = 1;
read->sl_hdr.compositionTimeStampFlag = 1;
if (read->ch != channel) return GF_STREAM_NOT_FOUND;
/*fetching es data*/
if (read->done) {
*out_reception_status = GF_EOS;
return GF_OK;
}
if (!read->data) {
if (!read->stream) {
*out_data_ptr = NULL;
*out_data_size = 0;
return GF_OK;
}
bs = gf_bs_from_file(read->stream, GF_BITSTREAM_READ);
*is_new_data = 1;
fetch_next:
pos = gf_f64_tell(read->stream);
sync = gf_ac3_parser_bs(bs, &hdr, GF_FALSE);
if (!sync) {
gf_bs_del(bs);
if (!read->dnload) {
*out_reception_status = GF_EOS;
read->done = 1;
} else {
gf_f64_seek(read->stream, pos, SEEK_SET);
*out_reception_status = GF_OK;
}
return GF_OK;
}
if (!hdr.framesize) {
gf_bs_del(bs);
*out_reception_status = GF_EOS;
read->done = 1;
return GF_OK;
}
read->data_size = hdr.framesize;
read->nb_samp = 1536;
/*we're seeking*/
if (read->start_range && read->duration) {
start_from = (u32) (read->start_range * read->sample_rate);
if (read->current_time + read->nb_samp < start_from) {
read->current_time += read->nb_samp;
goto fetch_next;
} else {
read->start_range = 0;
}
}
read->sl_hdr.compositionTimeStamp = read->current_time;
read->data = gf_malloc(sizeof(char) * (read->data_size+read->pad_bytes));
gf_bs_read_data(bs, (char *) read->data, read->data_size);
if (read->pad_bytes) memset(read->data + read->data_size, 0, sizeof(char) * read->pad_bytes);
gf_bs_del(bs);
}
*out_sl_hdr = read->sl_hdr;
*out_data_ptr =(char *) read->data;
*out_data_size = read->data_size;
return GF_OK;
}
GF_EXPORT
GF_Err gf_isom_extract_meta_item_extended(GF_ISOFile *file, Bool root_meta, u32 track_num, u32 item_id, const char *dump_file_name, char **out_data, u32 *out_size, const char **out_mime )
{
GF_BitStream *item_bs;
char szPath[1024];
GF_ItemExtentEntry *extent_entry;
FILE *resource = NULL;
u32 i, count;
GF_ItemLocationEntry *location_entry;
u32 item_num;
char *item_name = NULL;
GF_MetaBox *meta = gf_isom_get_meta(file, root_meta, track_num);
if (!meta || !meta->item_infos || !meta->item_locations) return GF_BAD_PARAM;
if (out_mime) *out_mime = NULL;
item_num = gf_isom_get_meta_item_by_id(file, root_meta, track_num, item_id);
if (item_num) {
GF_ItemInfoEntryBox *item_entry = (GF_ItemInfoEntryBox *)gf_list_get(meta->item_infos->item_infos, item_num-1);
item_name = item_entry->item_name;
if (out_mime) *out_mime = item_entry->content_type;
}
location_entry = NULL;
count = gf_list_count(meta->item_locations->location_entries);
for (i=0; i<count; i++) {
location_entry = (GF_ItemLocationEntry *)gf_list_get(meta->item_locations->location_entries, i);
if (location_entry->item_ID == item_id) break;
location_entry = NULL;
}
if (!location_entry) return GF_BAD_PARAM;
/*FIXME*/
if (location_entry->data_reference_index) {
char *item_url = NULL, *item_urn = NULL;
GF_Box *a = (GF_Box *)gf_list_get(meta->file_locations->dref->other_boxes, location_entry->data_reference_index-1);
if (a->type==GF_ISOM_BOX_TYPE_URL) {
item_url = ((GF_DataEntryURLBox*)a)->location;
} else if (a->type==GF_ISOM_BOX_TYPE_URN) {
item_url = ((GF_DataEntryURNBox*)a)->location;
item_urn = ((GF_DataEntryURNBox*)a)->nameURN;
}
GF_LOG(GF_LOG_INFO, GF_LOG_CONTAINER, ("[IsoMedia] Item already outside the ISO file at URL: %s, URN: %s\n", (item_url?item_url:"N/A"), (item_urn?item_urn:"N/A") ));
return GF_OK;
}
/*don't extract self-reference item*/
count = gf_list_count(location_entry->extent_entries);
if (!location_entry->base_offset && (count==1)) {
extent_entry = (GF_ItemExtentEntry *)gf_list_get(location_entry->extent_entries, 0);
if (!extent_entry->extent_length
#ifndef GPAC_DISABLE_ISOM_WRITE
&& !extent_entry->original_extent_offset
#endif
) return GF_BAD_PARAM;
}
item_bs = NULL;
if (out_data) {
item_bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
} else if (dump_file_name) {
strcpy(szPath, dump_file_name);
resource = gf_fopen(szPath, "wb");
item_bs = gf_bs_from_file(resource, GF_BITSTREAM_WRITE);
} else {
if (item_name) strcpy(szPath, item_name);
else sprintf(szPath, "item_id%02d", item_id);
resource = gf_fopen(szPath, "wb");
item_bs = gf_bs_from_file(resource, GF_BITSTREAM_WRITE);
}
for (i=0; i<count; i++) {
char buf_cache[4096];
u64 remain;
GF_ItemExtentEntry *extent_entry = (GF_ItemExtentEntry *)gf_list_get(location_entry->extent_entries, i);
gf_bs_seek(file->movieFileMap->bs, location_entry->base_offset + extent_entry->extent_offset);
remain = extent_entry->extent_length;
while (remain) {
u32 cache_size = (remain>4096) ? 4096 : (u32) remain;
gf_bs_read_data(file->movieFileMap->bs, buf_cache, cache_size);
gf_bs_write_data(item_bs, buf_cache, cache_size);
remain -= cache_size;
}
}
if (out_data) {
gf_bs_get_content(item_bs, out_data, out_size);
}
if (resource) {
gf_fclose(resource);
}
gf_bs_del(item_bs);
return GF_OK;
}
GF_DataMap *gf_isom_fdm_new(const char *sPath, u8 mode)
{
u8 bs_mode;
GF_FileDataMap *tmp = (GF_FileDataMap *) gf_malloc(sizeof(GF_FileDataMap));
if (!tmp) return NULL;
memset(tmp, 0, sizeof(GF_FileDataMap));
tmp->type = GF_ISOM_DATA_FILE;
tmp->mode = mode;
#ifndef GPAC_DISABLE_ISOM_WRITE
//open a temp file
if (!strcmp(sPath, "mp4_tmp_edit")) {
//create a temp file (that only occurs in EDIT/WRITE mode)
tmp->stream = gf_temp_file_new();
bs_mode = GF_BITSTREAM_READ;
}
#endif
if (!strncmp(sPath, "gmem://", 7)) {
u32 size;
void *mem_address;
if (sscanf(sPath, "gmem://%d@%p", &size, &mem_address) != 2)
return NULL;
tmp->bs = gf_bs_new((const char *)mem_address, size, GF_BITSTREAM_READ);
if (!tmp->bs) {
gf_free(tmp);
return NULL;
}
return (GF_DataMap *)tmp;
}
switch (mode) {
case GF_ISOM_DATA_MAP_READ:
if (!tmp->stream) tmp->stream = gf_f64_open(sPath, "rb");
bs_mode = GF_BITSTREAM_READ;
break;
///we open the file in READ/WRITE mode, in case
case GF_ISOM_DATA_MAP_WRITE:
if (!strcmp(sPath, "std")) {
tmp->stream = stdout;
tmp->is_stdout = 1;
}
if (!tmp->stream) tmp->stream = gf_f64_open(sPath, "w+b");
if (!tmp->stream) tmp->stream = gf_f64_open(sPath, "wb");
bs_mode = GF_BITSTREAM_WRITE;
break;
///we open the file in CAT mode, in case
case GF_ISOM_DATA_MAP_CAT:
if (!strcmp(sPath, "std")) {
tmp->stream = stdout;
tmp->is_stdout = 1;
}
if (!tmp->stream) tmp->stream = gf_f64_open(sPath, "a+b");
if (tmp->stream) gf_f64_seek(tmp->stream, 0, SEEK_END);
bs_mode = GF_BITSTREAM_WRITE;
break;
default:
gf_free(tmp);
return NULL;
}
if (!tmp->stream) {
gf_free(tmp);
return NULL;
}
tmp->bs = gf_bs_from_file(tmp->stream, bs_mode);
if (!tmp->bs) {
fclose(tmp->stream);
gf_free(tmp);
return NULL;
}
if (default_write_buffering_size) {
gf_bs_set_output_buffering(tmp->bs, default_write_buffering_size);
}
return (GF_DataMap *)tmp;
}
