static u32 get_track_id(GF_ISOFile *mov, u32 media_type, u32 idx)
{
u32 i, count, cur;
cur=0;
count = gf_isom_get_track_count(mov);
for (i=0; i<count; i++) {
if (gf_isom_get_media_type(mov, i+1) != media_type) continue;
if (!idx) return gf_isom_get_track_id(mov, i+1);
cur++;
if (cur==idx) return gf_isom_get_track_id(mov, i+1);
}
return 0;
}
/*switch channel quality. Return next channel or current channel if error*/
static
u32 gf_channel_switch_quality(ISOMChannel *ch, GF_ISOFile *the_file, Bool switch_up)
{
u32 i, count, next_track, trackID, cur_track;
s32 ref_count;
cur_track = ch->next_track ? ch->next_track : ch->track;
count = gf_isom_get_track_count(the_file);
trackID = gf_isom_get_track_id(the_file, cur_track);
next_track = 0;
if (switch_up)
{
for (i = 0; i < count; i++)
{
ref_count = gf_isom_get_reference_count(the_file, i+1, GF_ISOM_REF_SCAL);
if (ref_count < 0)
return cur_track; //error
else if (ref_count == 0)
continue;
/*next track is the one that has the last reference of type GF_ISOM_REF_SCAL refers to this current track*/
else if ((u32)ref_count == gf_isom_has_track_reference(the_file, i+1, GF_ISOM_REF_SCAL, trackID))
{
next_track = i+1;
break;
}
}
/*this is the highest quality*/
if (!next_track)
return cur_track;
}
else
{
if (cur_track == ch->base_track)
return cur_track;
ref_count = gf_isom_get_reference_count(the_file, cur_track, GF_ISOM_REF_SCAL);
if (ref_count < 0)
return cur_track;
gf_isom_get_reference(the_file, cur_track, GF_ISOM_REF_SCAL, ref_count, &next_track);
if (!next_track)
return cur_track;
}
/*in scalable mode add SPS/PPS in-band*/
gf_isom_set_nalu_extract_mode(the_file, next_track, ch->nalu_extract_mode);
return next_track;
}
void MP4T_DumpSDP(GF_ISOFile *file, const char *name)
{
const char *sdp;
u32 size, i;
FILE *f;
f = gf_f64_open(name, "wt");
//get the movie SDP
gf_isom_sdp_get(file, &sdp, &size);
fwrite(sdp, size, 1, f);
fprintf(f, "\r\n");
//then tracks
for (i=0; i<gf_isom_get_track_count(file); i++) {
if (gf_isom_get_media_type(file, i+1) != GF_ISOM_MEDIA_HINT) continue;
gf_isom_sdp_track_get(file, i+1, &sdp, &size);
fwrite(sdp, size, 1, f);
}
fclose(f);
}
void gf_media_format_ttxt_sdp(GP_RTPPacketizer *builder, char *payload_name, char *sdpLine, GF_ISOFile *file, u32 track)
{
char buffer[2000];
u32 w, h, i, m_w, m_h;
s32 tx, ty;
s16 l;
sprintf(sdpLine, "a=fmtp:%d sver=60; ", builder->PayloadType);
gf_isom_get_track_layout_info(file, track, &w, &h, &tx, &ty, &l);
sprintf(buffer, "width=%d; height=%d; tx=%d; ty=%d; layer=%d; ", w, h, tx, ty, l);
strcat(sdpLine, buffer);
m_w = w;
m_h = h;
for (i=0; i<gf_isom_get_track_count(file); i++) {
switch (gf_isom_get_media_type(file, i+1)) {
case GF_ISOM_MEDIA_SCENE:
case GF_ISOM_MEDIA_VISUAL:
gf_isom_get_track_layout_info(file, i+1, &w, &h, &tx, &ty, &l);
if (w>m_w) m_w = w;
if (h>m_h) m_h = h;
break;
default:
break;
}
}
sprintf(buffer, "max-w=%d; max-h=%d", m_w, m_h);
strcat(sdpLine, buffer);
strcat(sdpLine, "; tx3g=");
for (i=0; i<gf_isom_get_sample_description_count(file, track); i++) {
char *tx3g;
u32 tx3g_len, len;
gf_isom_text_get_encoded_tx3g(file, track, i+1, GF_RTP_TX3G_SIDX_OFFSET, &tx3g, &tx3g_len);
len = gf_base64_encode(tx3g, tx3g_len, buffer, 2000);
gf_free(tx3g);
buffer[len] = 0;
if (i) strcat(sdpLine, ", ");
strcat(sdpLine, buffer);
}
}
/*import cubic QTVR to mp4*/
GF_Err gf_sm_load_init_qt(GF_SceneLoader *load)
{
u32 i, di, w, h, tk, nb_samp;
Bool has_qtvr;
GF_ISOSample *samp;
GF_ISOFile *src;
GF_StreamContext *st;
GF_AUContext *au;
GF_Command *com;
M_Background *back;
M_NavigationInfo *ni;
M_Group *gr;
GF_ODUpdate *odU;
GF_SceneGraph *sg;
GF_ObjectDescriptor *od;
GF_ESD *esd;
if (!load->ctx) return GF_NOT_SUPPORTED;
src = gf_isom_open(load->fileName, GF_ISOM_OPEN_READ, NULL);
if (!src) return gf_qt_report(load, GF_URL_ERROR, "Opening file %s failed", load->fileName);
w = h = tk = 0;
nb_samp = 0;
has_qtvr = 0;
for (i=0; i<gf_isom_get_track_count(src); i++) {
switch (gf_isom_get_media_type(src, i+1)) {
case GF_ISOM_MEDIA_VISUAL:
if (gf_isom_get_media_subtype(src, i+1, 1) == GF_4CC('j', 'p', 'e', 'g')) {
GF_GenericSampleDescription *udesc = gf_isom_get_generic_sample_description(src, i+1, 1);
if ((udesc->width>w) || (udesc->height>h)) {
w = udesc->width;
h = udesc->height;
tk = i+1;
nb_samp = gf_isom_get_sample_count(src, i+1);
}
if (udesc->extension_buf) gf_free(udesc->extension_buf);
gf_free(udesc);
}
break;
case GF_4CC('q','t','v','r'):
has_qtvr = 1;
break;
}
}
if (!has_qtvr) {
gf_isom_delete(src);
return gf_qt_report(load, GF_NOT_SUPPORTED, "QTVR not found - no conversion available for this QuickTime movie");
}
if (!tk) {
gf_isom_delete(src);
return gf_qt_report(load, GF_NON_COMPLIANT_BITSTREAM, "No associated visual track with QTVR movie");
}
if (nb_samp!=6) {
gf_isom_delete(src);
return gf_qt_report(load, GF_NOT_SUPPORTED, "Movie %s doesn't look a Cubic QTVR - sorry...", load->fileName);
}
GF_LOG(GF_LOG_INFO, GF_LOG_PARSER, ("QT: Importing Cubic QTVR Movie"));
/*create scene*/
sg = load->ctx->scene_graph;
gr = (M_Group *) gf_node_new(sg, TAG_MPEG4_Group);
gf_node_register((GF_Node *)gr, NULL);
st = gf_sm_stream_new(load->ctx, 1, GF_STREAM_SCENE, 1);
au = gf_sm_stream_au_new(st, 0, 0, 1);
com = gf_sg_command_new(load->ctx->scene_graph, GF_SG_SCENE_REPLACE);
gf_list_add(au->commands, com);
com->node = (GF_Node *)gr;
back = (M_Background *) gf_node_new(sg, TAG_MPEG4_Background);
gf_node_list_add_child( &gr->children, (GF_Node*)back);
gf_node_register((GF_Node *)back, (GF_Node *)gr);
gf_sg_vrml_mf_alloc(&back->leftUrl, GF_SG_VRML_MFURL, 1);
back->leftUrl.vals[0].OD_ID = 2;
gf_sg_vrml_mf_alloc(&back->frontUrl, GF_SG_VRML_MFURL, 1);
back->frontUrl.vals[0].OD_ID = 3;
gf_sg_vrml_mf_alloc(&back->rightUrl, GF_SG_VRML_MFURL, 1);
back->rightUrl.vals[0].OD_ID = 4;
gf_sg_vrml_mf_alloc(&back->backUrl, GF_SG_VRML_MFURL, 1);
back->backUrl.vals[0].OD_ID = 5;
gf_sg_vrml_mf_alloc(&back->topUrl, GF_SG_VRML_MFURL, 1);
back->topUrl.vals[0].OD_ID = 6;
gf_sg_vrml_mf_alloc(&back->bottomUrl, GF_SG_VRML_MFURL, 1);
back->bottomUrl.vals[0].OD_ID = 7;
ni = (M_NavigationInfo *) gf_node_new(sg, TAG_MPEG4_NavigationInfo);
gf_node_list_add_child(&gr->children, (GF_Node*)ni);
gf_node_register((GF_Node *)ni, (GF_Node *)gr);
gf_sg_vrml_mf_reset(&ni->type, GF_SG_VRML_MFSTRING);
gf_sg_vrml_mf_alloc(&ni->type, GF_SG_VRML_MFSTRING, 1);
ni->type.vals[0] = gf_strdup("QTVR");
/*create ODs*/
st = gf_sm_stream_new(load->ctx, 2, GF_STREAM_OD, 1);
au = gf_sm_stream_au_new(st, 0, 0, 1);
odU = (GF_ODUpdate*) gf_odf_com_new(GF_ODF_OD_UPDATE_TAG);
gf_list_add(au->commands, odU);
for (i=0; i<6; i++) {
GF_MuxInfo *mi;
FILE *img;
char szName[1024];
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->objectDescriptorID = 2+i;
esd = gf_odf_desc_esd_new(2);
esd->decoderConfig->streamType = GF_STREAM_VISUAL;
esd->decoderConfig->objectTypeIndication = GPAC_OTI_IMAGE_JPEG;
esd->ESID = 3+i;
/*extract image and remember it*/
mi = (GF_MuxInfo *) gf_odf_desc_new(GF_ODF_MUXINFO_TAG);
gf_list_add(esd->extensionDescriptors, mi);
mi->delete_file = 1;
sprintf(szName, "%s_img%d.jpg", load->fileName, esd->ESID);
mi->file_name = gf_strdup(szName);
gf_list_add(od->ESDescriptors, esd);
gf_list_add(odU->objectDescriptors, od);
samp = gf_isom_get_sample(src, tk, i+1, &di);
img = gf_f64_open(mi->file_name, "wb");
fwrite(samp->data, samp->dataLength, 1, img);
fclose(img);
gf_isom_sample_del(&samp);
}
gf_isom_delete(src);
return GF_OK;
}
GF_EXPORT
GF_ISOMRTPStreamer *gf_isom_streamer_new(const char *file_name, const char *ip_dest, u16 port, Bool loop, Bool force_mpeg4, u32 path_mtu, u32 ttl, char *ifce_addr)
{
GF_ISOMRTPStreamer *streamer;
GF_Err e = GF_OK;
const char *opt = NULL;
/*GF_Config *configFile = NULL; */
u32 i, max_ptime, au_sn_len;
u8 payt;
GF_ISOFile *file;
GF_RTPTrack *track, *prev_track;
u16 first_port;
u32 nb_tracks;
u32 sess_data_size;
if (!ip_dest) ip_dest = "127.0.0.1";
if (!port) port = 7000;
if (!path_mtu) path_mtu = 1450;
GF_SAFEALLOC(streamer, GF_ISOMRTPStreamer);
streamer->dest_ip = gf_strdup(ip_dest);
payt = 96;
max_ptime = au_sn_len = 0;
file = gf_isom_open(file_name, GF_ISOM_OPEN_READ, NULL);
if (!file) {
GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("Error opening file %s: %s\n", opt, gf_error_to_string(gf_isom_last_error(NULL))));
return NULL;
}
streamer->isom = file;
streamer->loop = loop;
streamer->force_mpeg4_generic = force_mpeg4;
first_port = port;
sess_data_size = 0;
prev_track = NULL;
nb_tracks = gf_isom_get_track_count(streamer->isom);
for (i=0; i<nb_tracks; i++) {
u32 mediaSize, mediaDuration, flags, MinSize, MaxSize, avgTS, streamType, oti, const_dur, nb_ch, samplerate, maxDTSDelta, TrackMediaSubType, TrackMediaType, bandwidth, IV_length, KI_length, dsi_len;
const char *url, *urn;
char *dsi;
Bool is_crypted;
dsi_len = samplerate = streamType = oti = nb_ch = IV_length = KI_length = 0;
is_crypted = 0;
dsi = NULL;
flags = 0;
/*we only support self-contained files for hinting*/
gf_isom_get_data_reference(streamer->isom, i+1, 1, &url, &urn);
if (url || urn) continue;
TrackMediaType = gf_isom_get_media_type(streamer->isom, i+1);
TrackMediaSubType = gf_isom_get_media_subtype(streamer->isom, i+1, 1);
switch (TrackMediaType) {
case GF_ISOM_MEDIA_TEXT:
break;
case GF_ISOM_MEDIA_VISUAL:
case GF_ISOM_MEDIA_AUDIO:
case GF_ISOM_MEDIA_SUBT:
case GF_ISOM_MEDIA_OD:
case GF_ISOM_MEDIA_SCENE:
if (gf_isom_get_sample_description_count(streamer->isom, i+1) > 1) continue;
break;
default:
continue;
}
GF_SAFEALLOC(track, GF_RTPTrack);
if (prev_track) prev_track->next = track;
else streamer->stream = track;
prev_track = track;
track->track_num = i+1;
track->nb_aus = gf_isom_get_sample_count(streamer->isom, track->track_num);
track->timescale = gf_isom_get_media_timescale(streamer->isom, track->track_num);
mediaDuration = (u32)(gf_isom_get_media_duration(streamer->isom, track->track_num)*1000/track->timescale); // ms
mediaSize = (u32)gf_isom_get_media_data_size(streamer->isom, track->track_num);
sess_data_size += mediaSize;
if (mediaDuration > streamer->duration_ms) streamer->duration_ms = mediaDuration;
track->port = check_next_port(streamer, first_port);
first_port = track->port+2;
/*init packetizer*/
if (streamer->force_mpeg4_generic) flags = GP_RTP_PCK_SIGNAL_RAP | GP_RTP_PCK_FORCE_MPEG4;
switch (TrackMediaSubType) {
case GF_ISOM_SUBTYPE_MPEG4_CRYP:
is_crypted = 1;
case GF_ISOM_SUBTYPE_MPEG4:
{
GF_ESD *esd = gf_isom_get_esd(streamer->isom, track->track_num, 1);
if (esd) {
streamType = esd->decoderConfig->streamType;
oti = esd->decoderConfig->objectTypeIndication;
/*systems streams*/
if (streamType==GF_STREAM_AUDIO) {
gf_isom_get_audio_info(streamer->isom, track->track_num, 1, &samplerate, &nb_ch, NULL);
}
/*systems streams*/
else if (streamType==GF_STREAM_SCENE) {
if (gf_isom_has_sync_shadows(streamer->isom, track->track_num) || gf_isom_has_sample_dependency(streamer->isom, track->track_num))
flags |= GP_RTP_PCK_SYSTEMS_CAROUSEL;
}
if (esd->decoderConfig->decoderSpecificInfo) {
dsi = esd->decoderConfig->decoderSpecificInfo->data;
dsi_len = esd->decoderConfig->decoderSpecificInfo->dataLength;
esd->decoderConfig->decoderSpecificInfo->data = NULL;
esd->decoderConfig->decoderSpecificInfo->dataLength = 0;
}
gf_odf_desc_del((GF_Descriptor*)esd);
}
}
break;
case GF_ISOM_SUBTYPE_AVC_H264:
case GF_ISOM_SUBTYPE_AVC2_H264:
case GF_ISOM_SUBTYPE_SVC_H264:
{
GF_AVCConfig *avcc = gf_isom_avc_config_get(streamer->isom, track->track_num, 1);
track->avc_nalu_size = avcc->nal_unit_size;
gf_odf_avc_cfg_del(avcc);
streamType = GF_STREAM_VISUAL;
oti = GPAC_OTI_VIDEO_AVC;
}
break;
default:
streamType = GF_STREAM_4CC;
oti = TrackMediaSubType;
break;
}
/*get sample info*/
gf_media_get_sample_average_infos(streamer->isom, track->track_num, &MinSize, &MaxSize, &avgTS, &maxDTSDelta, &const_dur, &bandwidth);
if (is_crypted) {
Bool use_sel_enc;
gf_isom_get_ismacryp_info(streamer->isom, track->track_num, 1, NULL, NULL, NULL, NULL, NULL, &use_sel_enc, &IV_length, &KI_length);
if (use_sel_enc) flags |= GP_RTP_PCK_SELECTIVE_ENCRYPTION;
}
track->rtp = gf_rtp_streamer_new_extended(streamType, oti, track->timescale,
(char *) streamer->dest_ip, track->port, path_mtu, ttl, ifce_addr,
flags, dsi, dsi_len,
payt, samplerate, nb_ch,
is_crypted, IV_length, KI_length,
MinSize, MaxSize, avgTS, maxDTSDelta, const_dur, bandwidth, max_ptime, au_sn_len);
if (!track->rtp) {
GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("Could not initialize RTP streamer: %s\n", gf_error_to_string(e)));
goto exit;
}
payt++;
track->microsec_ts_scale = 1000000;
track->microsec_ts_scale /= gf_isom_get_media_timescale(streamer->isom, track->track_num);
}
return streamer;
exit:
gf_free(streamer);
return NULL;
}
static GF_Err gf_isom_streamer_setup_sdp(GF_ISOMRTPStreamer *streamer, char*sdpfilename, char **out_sdp_buffer)
{
GF_RTPTrack *track;
FILE *sdp_out;
char filename[GF_MAX_PATH];
char sdpLine[20000];
u32 t, count;
u8 *payload_type;
strcpy(filename, sdpfilename ? sdpfilename : "videosession.sdp");
sdp_out = gf_fopen(filename, "wt");
if (!sdp_out) return GF_IO_ERR;
if (!out_sdp_buffer) {
sprintf(sdpLine, "v=0");
fprintf(sdp_out, "%s\n", sdpLine);
sprintf(sdpLine, "o=MP4Streamer 3357474383 1148485440000 IN IP%d %s", gf_net_is_ipv6(streamer->dest_ip) ? 6 : 4, streamer->dest_ip);
fprintf(sdp_out, "%s\n", sdpLine);
sprintf(sdpLine, "s=livesession");
fprintf(sdp_out, "%s\n", sdpLine);
sprintf(sdpLine, "i=This is an MP4 time-sliced Streaming demo");
fprintf(sdp_out, "%s\n", sdpLine);
sprintf(sdpLine, "u=http://gpac.sourceforge.net");
fprintf(sdp_out, "%s\n", sdpLine);
sprintf(sdpLine, "e=admin@");
fprintf(sdp_out, "%s\n", sdpLine);
sprintf(sdpLine, "c=IN IP%d %s", gf_net_is_ipv6(streamer->dest_ip) ? 6 : 4, streamer->dest_ip);
fprintf(sdp_out, "%s\n", sdpLine);
sprintf(sdpLine, "t=0 0");
fprintf(sdp_out, "%s\n", sdpLine);
sprintf(sdpLine, "a=x-copyright: Streamed with GPAC (C)2000-200X - http://gpac.sourceforge.net");
fprintf(sdp_out, "%s\n", sdpLine);
if (streamer->base_track)
{
sprintf(sdpLine, "a=group:DDP L%d", streamer->base_track);
fprintf(sdp_out, "%s", sdpLine);
count = gf_isom_get_track_count(streamer->isom);
for (t = 0; t < count; t++)
{
if (gf_isom_has_track_reference(streamer->isom, t+1, GF_ISOM_REF_BASE, gf_isom_get_track_id(streamer->isom, streamer->base_track)))
{
sprintf(sdpLine, " L%d", t+1);
fprintf(sdp_out, "%s", sdpLine);
}
}
fprintf(sdp_out, "\n");
}
}
/*prepare array of payload type*/
count = gf_isom_get_track_count(streamer->isom);
payload_type = (u8 *)gf_malloc(count * sizeof(u8));
track = streamer->stream;
while (track) {
payload_type[track->track_num-1] = gf_rtp_streamer_get_payload_type(track->rtp);
track = track->next;
}
track = streamer->stream;
while (track) {
char *sdp_media=NULL;
const char *KMS = NULL;
char *dsi = NULL;
u32 w, h;
u32 dsi_len = 0;
GF_DecoderConfig *dcd;
//use inspect mode so that we don't aggregate xPS from the base in the enhancement ESD
gf_isom_set_nalu_extract_mode(streamer->isom, track->track_num, GF_ISOM_NALU_EXTRACT_INSPECT);
dcd = gf_isom_get_decoder_config(streamer->isom, track->track_num, 1);
if (dcd && dcd->decoderSpecificInfo) {
dsi = dcd->decoderSpecificInfo->data;
dsi_len = dcd->decoderSpecificInfo->dataLength;
}
w = h = 0;
if (gf_isom_get_media_type(streamer->isom, track->track_num) == GF_ISOM_MEDIA_VISUAL) {
gf_isom_get_visual_info(streamer->isom, track->track_num, 1, &w, &h);
}
gf_isom_get_ismacryp_info(streamer->isom, track->track_num, 1, NULL, NULL, NULL, NULL, &KMS, NULL, NULL, NULL);
/*TODO retrieve DIMS content encoding from track to set the flags */
gf_rtp_streamer_append_sdp_extended(track->rtp, gf_isom_get_track_id(streamer->isom, track->track_num), dsi, dsi_len, streamer->isom, track->track_num, (char *)KMS, w, h, &sdp_media);
if (streamer->base_track)
gf_rtp_streamer_append_sdp_decoding_dependency(streamer->isom, track->track_num, payload_type, &sdp_media);
if (sdp_media) {
fprintf(sdp_out, "%s", sdp_media);
gf_free(sdp_media);
}
if (dcd) gf_odf_desc_del((GF_Descriptor *)dcd);
track = track->next;
}
fprintf(sdp_out, "\n");
gf_fclose(sdp_out);
if (out_sdp_buffer) {
u64 size;
sdp_out = gf_fopen(filename, "r");
gf_fseek(sdp_out, 0, SEEK_END);
size = gf_ftell(sdp_out);
gf_fseek(sdp_out, 0, SEEK_SET);
if (*out_sdp_buffer) gf_free(*out_sdp_buffer);
*out_sdp_buffer = gf_malloc(sizeof(char)*(size_t)(size+1));
size = fread(*out_sdp_buffer, 1, (size_t)size, sdp_out);
gf_fclose(sdp_out);
(*out_sdp_buffer)[size]=0;
}
gf_free(payload_type);
return GF_OK;
}
void bifs_to_vid(GF_ISOFile *file, char *szConfigFile, u32 width, u32 height, char *rad_name, u32 dump_type, char *out_dir, Double fps, s32 frameID, s32 dump_time)
{
GF_User user;
BIFSVID b2v;
u16 es_id;
Bool first_dump, needs_raw;
u32 i, j, di, count, timescale, frameNum;
u32 duration, cur_time;
GF_VideoSurface fb;
GF_Err e;
char old_driv[1024];
const char *test;
char config_path[GF_MAX_PATH];
avi_t *avi_out;
Bool reset_fps;
GF_ESD *esd;
char comp[5];
char *conv_buf;
memset(&user, 0, sizeof(GF_User));
if (szConfigFile && strlen(szConfigFile)) {
user.config = gf_cfg_init(config_path, NULL);
} else {
user.config = gf_cfg_init(NULL, NULL);
}
if (!user.config) {
fprintf(stdout, "Error: Configuration File \"%s\" not found in %s\n", GPAC_CFG_FILE, config_path);
return;
}
avi_out = NULL;
conv_buf = NULL;
esd = NULL;
needs_raw = 0;
test = gf_cfg_get_key(user.config, "General", "ModulesDirectory");
user.modules = gf_modules_new((const unsigned char *) test, user.config);
strcpy(old_driv, "raw_out");
if (!gf_modules_get_count(user.modules)) {
printf("Error: no modules found\n");
goto err_exit;
}
/*switch driver to raw_driver*/
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (test) strcpy(old_driv, test);
test = gf_cfg_get_key(user.config, "Compositor", "RendererName");
/*since we only support RGB24 for MP42AVI force using RAW out with 2D driver*/
if (test && strstr(test, "2D")) {
gf_cfg_set_key(user.config, "Video", "DriverName", "Raw Video Output");
needs_raw = 1;
}
needs_raw = 0;
user.init_flags = GF_TERM_NO_AUDIO | GF_TERM_FORCE_3D;
b2v.sr = gf_sc_new(&user, 0, NULL);
gf_sc_set_option(b2v.sr, GF_OPT_VISIBLE, 0);
b2v.sg = gf_sg_new();
gf_sg_set_scene_time_callback(b2v.sg, get_scene_time, &b2v);
gf_sg_set_init_callback(b2v.sg, node_init, &b2v);
gf_sg_set_modified_callback(b2v.sg, node_modif, &b2v);
/*load config*/
gf_sc_set_option(b2v.sr, GF_OPT_RELOAD_CONFIG, 1);
b2v.bifs = gf_bifs_decoder_new(b2v.sg, 0);
if (needs_raw) {
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (stricmp(test, "raw_out") && stricmp(test, "Raw Video Output")) {
printf("couldn't load raw output driver (%s used)\n", test);
goto err_exit;
}
}
strcpy(config_path, "");
if (out_dir) {
strcat(config_path, out_dir);
if (config_path[strlen(config_path)-1] != '\\') strcat(config_path, "\\");
}
strcat(config_path, rad_name);
strcat(config_path, "_bifs");
if (!dump_type) {
strcat(config_path, ".avi");
avi_out = AVI_open_output_file(config_path);
comp[0] = comp[1] = comp[2] = comp[3] = comp[4] = 0;
if (!avi_out) goto err_exit;
}
for (i=0; i<gf_isom_get_track_count(file); i++) {
esd = gf_isom_get_esd(file, i+1, 1);
if (!esd) continue;
if (!esd->dependsOnESID && (esd->decoderConfig->streamType == GF_STREAM_SCENE)) break;
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
}
if (!esd) {
printf("no bifs track found\n");
goto err_exit;
}
b2v.duration = gf_isom_get_media_duration(file, i+1);
timescale = gf_isom_get_media_timescale(file, i+1);
es_id = (u16) gf_isom_get_track_id(file, i+1);
e = gf_bifs_decoder_configure_stream(b2v.bifs, es_id, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, esd->decoderConfig->objectTypeIndication);
if (e) {
printf("BIFS init error %s\n", gf_error_to_string(e));
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
goto err_exit;
}
if (dump_time>=0) dump_time = dump_time *1000 / timescale;
gf_sc_set_scene(b2v.sr, b2v.sg);
count = gf_isom_get_sample_count(file, i+1);
reset_fps = 0;
if (!fps) {
fps = (Float) (count * timescale);
fps /= (Double) (s64) b2v.duration;
printf("Estimated BIFS FrameRate %g\n", fps);
reset_fps = 1;
}
if (!width || !height) {
gf_sg_get_scene_size_info(b2v.sg, &width, &height);
}
/*we work in RGB24, and we must make sure the pitch is %4*/
if ((width*3)%4) {
printf("Adjusting width (%d) to have a stride multiple of 4\n", width);
while ((width*3)%4) width--;
}
gf_sc_set_size(b2v.sr, width, height);
gf_sc_draw_frame(b2v.sr);
gf_sc_get_screen_buffer(b2v.sr, &fb);
width = fb.width;
height = fb.height;
if (avi_out) {
AVI_set_video(avi_out, width, height, fps, comp);
conv_buf = gf_malloc(sizeof(char) * width * height * 3);
}
printf("Dumping at BIFS resolution %d x %d\n\n", width, height);
gf_sc_release_screen_buffer(b2v.sr, &fb);
cur_time = 0;
duration = (u32)(timescale / fps);
if (reset_fps) fps = 0;
frameNum = 1;
first_dump = 1;
for (j=0; j<count; j++) {
GF_ISOSample *samp = gf_isom_get_sample(file, i+1, j+1, &di);
b2v.cts = samp->DTS + samp->CTS_Offset;
/*apply command*/
gf_bifs_decode_au(b2v.bifs, es_id, samp->data, samp->dataLength, ((Double)(s64)b2v.cts)/1000.0);
gf_isom_sample_del(&samp);
if ((frameID>=0) && (j<(u32)frameID)) continue;
if ((dump_time>=0) && ((u32) dump_time>b2v.cts)) continue;
/*render frame*/
gf_sc_draw_frame(b2v.sr);
/*needed for background2D !!*/
if (first_dump) {
gf_sc_draw_frame(b2v.sr);
first_dump = 0;
}
if (fps) {
if (cur_time > b2v.cts) continue;
while (1) {
printf("dumped frame time %f (frame %d - sample %d)\r", ((Float)cur_time)/timescale, frameNum, j+1);
dump_frame(b2v, conv_buf, config_path, dump_type, avi_out, frameNum);
frameNum++;
cur_time += duration;
if (cur_time > b2v.cts) break;
}
} else {
dump_frame(b2v, conv_buf, config_path, dump_type, avi_out, (frameID>=0) ? frameID : frameNum);
if (frameID>=0 || dump_time>=0) break;
frameNum++;
printf("dumped frame %d / %d\r", j+1, count);
}
}
gf_odf_desc_del((GF_Descriptor *) esd);
/*destroy everything*/
gf_bifs_decoder_del(b2v.bifs);
gf_sg_del(b2v.sg);
gf_sc_set_scene(b2v.sr, NULL);
gf_sc_del(b2v.sr);
err_exit:
if (avi_out) AVI_close(avi_out);
if (conv_buf) gf_free(conv_buf);
if (user.modules) gf_modules_del(user.modules);
if (needs_raw) gf_cfg_set_key(user.config, "Video", "DriverName", old_driv);
gf_cfg_del(user.config);
}
/*generates an intertwined bmp from a scene file with 5 different viewpoints*/
void bifs3d_viewpoints_merger(GF_ISOFile *file, char *szConfigFile, u32 width, u32 height, char *rad_name, u32 dump_type, char *out_dir, Double fps, s32 frameID, s32 dump_time)
{
GF_User user;
char out_path[GF_MAX_PATH];
char old_driv[1024];
BIFSVID b2v;
Bool needs_raw;
GF_Err e;
GF_VideoSurface fb;
unsigned char **rendered_frames;
u32 nb_viewpoints = 5;
u32 viewpoint_index;
/* Configuration of the Rendering Capabilities */
{
const char *test;
char config_path[GF_MAX_PATH];
memset(&user, 0, sizeof(GF_User));
user.config = gf_cfg_init(szConfigFile, NULL);
if (!user.config) {
fprintf(stdout, "Error: Configuration File \"%s\" not found in %s\n", GPAC_CFG_FILE, config_path);
return;
}
test = gf_cfg_get_key(user.config, "General", "ModulesDirectory");
user.modules = gf_modules_new((const unsigned char *) test, user.config);
strcpy(old_driv, "raw_out");
if (!gf_modules_get_count(user.modules)) {
printf("Error: no modules found\n");
goto err_exit;
}
/*switch driver to raw_driver*/
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (test) strcpy(old_driv, test);
needs_raw = 0;
test = gf_cfg_get_key(user.config, "Compositor", "RendererName");
/*since we only support RGB24 for MP42AVI force using RAW out with 2D driver*/
if (test && strstr(test, "2D")) {
gf_cfg_set_key(user.config, "Video", "DriverName", "Raw Video Output");
needs_raw = 1;
}
if (needs_raw) {
test = gf_cfg_get_key(user.config, "Video", "DriverName");
if (stricmp(test, "raw_out") && stricmp(test, "Raw Video Output")) {
printf("couldn't load raw output driver (%s used)\n", test);
goto err_exit;
}
}
}
memset(&b2v, 0, sizeof(BIFSVID));
user.init_flags = GF_TERM_NO_AUDIO;
/* Initialization of the compositor */
b2v.sr = gf_sc_new(&user, 0, NULL);
gf_sc_set_option(b2v.sr, GF_OPT_VISIBLE, 0);
/* Initialization of the scene graph */
b2v.sg = gf_sg_new();
gf_sg_set_scene_time_callback(b2v.sg, get_scene_time, &b2v);
gf_sg_set_init_callback(b2v.sg, node_init, &b2v);
gf_sg_set_modified_callback(b2v.sg, node_modif, &b2v);
/*load config*/
gf_sc_set_option(b2v.sr, GF_OPT_RELOAD_CONFIG, 1);
{
u32 di;
u32 track_number;
GF_ESD *esd;
u16 es_id;
b2v.bifs = gf_bifs_decoder_new(b2v.sg, 0);
for (track_number=0; track_number<gf_isom_get_track_count(file); track_number++) {
esd = gf_isom_get_esd(file, track_number+1, 1);
if (!esd) continue;
if (!esd->dependsOnESID && (esd->decoderConfig->streamType == GF_STREAM_SCENE)) break;
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
}
if (!esd) {
printf("no bifs track found\n");
goto err_exit;
}
es_id = (u16) gf_isom_get_track_id(file, track_number+1);
e = gf_bifs_decoder_configure_stream(b2v.bifs, es_id, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, esd->decoderConfig->objectTypeIndication);
if (e) {
printf("BIFS init error %s\n", gf_error_to_string(e));
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
goto err_exit;
}
{
GF_ISOSample *samp = gf_isom_get_sample(file, track_number+1, 1, &di);
b2v.cts = samp->DTS + samp->CTS_Offset;
/*apply command*/
gf_bifs_decode_au(b2v.bifs, es_id, samp->data, samp->dataLength, ((Double)(s64)b2v.cts)/1000.0);
gf_isom_sample_del(&samp);
}
b2v.duration = gf_isom_get_media_duration(file, track_number+1);
gf_odf_desc_del((GF_Descriptor *) esd);
}
gf_sc_set_scene(b2v.sr, b2v.sg);
if (!width || !height) {
gf_sg_get_scene_size_info(b2v.sg, &width, &height);
}
/*we work in RGB24, and we must make sure the pitch is %4*/
if ((width*3)%4) {
printf("Adjusting width (%d) to have a stride multiple of 4\n", width);
while ((width*3)%4) width--;
}
gf_sc_set_size(b2v.sr, width, height);
gf_sc_get_screen_buffer(b2v.sr, &fb);
width = fb.width;
height = fb.height;
gf_sc_release_screen_buffer(b2v.sr, &fb);
GF_SAFEALLOC(rendered_frames, nb_viewpoints*sizeof(char *));
for (viewpoint_index = 1; viewpoint_index <= nb_viewpoints; viewpoint_index++) {
GF_SAFEALLOC(rendered_frames[viewpoint_index-1], fb.width*fb.height*3);
gf_sc_set_viewpoint(b2v.sr, viewpoint_index, NULL);
gf_sc_draw_frame(b2v.sr);
/*needed for background2D !!*/
gf_sc_draw_frame(b2v.sr);
strcpy(out_path, "");
if (out_dir) {
strcat(out_path, out_dir);
if (out_path[strlen(out_path)-1] != '\\') strcat(out_path, "\\");
}
strcat(out_path, rad_name);
strcat(out_path, "_view");
gf_sc_get_screen_buffer(b2v.sr, &fb);
write_bmp(&fb, out_path, viewpoint_index);
memcpy(rendered_frames[viewpoint_index-1], fb.video_buffer, fb.width*fb.height*3);
gf_sc_release_screen_buffer(b2v.sr, &fb);
}
if (width != 800 || height != 480) {
printf("Wrong scene dimension, cannot produce output\n");
goto err_exit;
} else {
u32 x, y;
GF_VideoSurface out_fb;
u32 bpp = 3;
out_fb.width = 800;
out_fb.height = 480;
out_fb.pitch = 800*bpp;
out_fb.pixel_format = GF_PIXEL_RGB_24;
out_fb.is_hardware_memory = 0;
GF_SAFEALLOC(out_fb.video_buffer, out_fb.pitch*out_fb.height)
#if 1
for (y=0; y<out_fb.height; y++) {
/*starting red pixel is R1, R5, R4, R3, R2, R1, R5, ... when increasing line num*/
u32 line_shift = (5-y) % 5;
for (x=0; x<out_fb.width; x++) {
u32 view_shift = (line_shift+bpp*x)%5;
u32 offset = out_fb.pitch*y + x*bpp;
/* red */
out_fb.video_buffer[offset] = rendered_frames[view_shift][offset];
/* green */
out_fb.video_buffer[offset+1] = rendered_frames[(view_shift+1)%5][offset+1];
/* blue */
out_fb.video_buffer[offset+2] = rendered_frames[(view_shift+2)%5][offset+2];
}
}
#else
/*calibration*/
for (y=0; y<out_fb.height; y++) {
u32 line_shift = (5- y%5) % 5;
for (x=0; x<out_fb.width; x++) {
u32 view_shift = (line_shift+bpp*x)%5;
u32 offset = out_fb.pitch*y + x*bpp;
out_fb.video_buffer[offset] = ((view_shift)%5 == 2) ? 0xFF : 0;
out_fb.video_buffer[offset+1] = ((view_shift+1)%5 == 2) ? 0xFF : 0;
out_fb.video_buffer[offset+2] = ((view_shift+2)%5 == 2) ? 0xFF : 0;
}
}
#endif
write_bmp(&out_fb, "output", 0);
}
/*destroy everything*/
gf_bifs_decoder_del(b2v.bifs);
gf_sg_del(b2v.sg);
gf_sc_set_scene(b2v.sr, NULL);
gf_sc_del(b2v.sr);
err_exit:
/* if (rendered_frames) {
for (viewpoint_index = 1; viewpoint_index <= nb_viewpoints; viewpoint_index++) {
if (rendered_frames[viewpoint_index-1]) gf_free(rendered_frames[viewpoint_index-1]);
}
gf_free(rendered_frames);
}
if (output_merged_frame) gf_free(output_merged_frame);
*/
if (user.modules) gf_modules_del(user.modules);
if (needs_raw) gf_cfg_set_key(user.config, "Video", "DriverName", old_driv);
gf_cfg_del(user.config);
}
GF_Err ISOR_ServiceCommand(GF_InputService *plug, GF_NetworkCommand *com)
{
Double track_dur, media_dur;
ISOMChannel *ch;
ISOMReader *read;
u32 count, i;
if (!plug || !plug->priv || !com) return GF_SERVICE_ERROR;
read = (ISOMReader *) plug->priv;
if (read->disconnected) return GF_OK;
if (com->command_type==GF_NET_SERVICE_INFO) {
u32 tag_len;
const char *tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_NAME, &tag, &tag_len)==GF_OK) com->info.name = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_ARTIST, &tag, &tag_len)==GF_OK) com->info.artist = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_ALBUM, &tag, &tag_len)==GF_OK) com->info.album = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_COMMENT, &tag, &tag_len)==GF_OK) com->info.comment = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_TRACK, &tag, &tag_len)==GF_OK) {
com->info.track_info = (((tag[2]<<8)|tag[3]) << 16) | ((tag[4]<<8)|tag[5]);
}
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_COMPOSER, &tag, &tag_len)==GF_OK) com->info.composer = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_WRITER, &tag, &tag_len)==GF_OK) com->info.writer = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_GENRE, &tag, &tag_len)==GF_OK) {
if (tag[0]) {
com->info.genre = 0;
} else {
com->info.genre = (tag[0]<<8) | tag[1];
}
}
return GF_OK;
}
if (com->command_type==GF_NET_SERVICE_HAS_AUDIO) {
u32 i, count;
count = gf_isom_get_track_count(read->mov);
for (i=0; i<count; i++) {
if (gf_isom_get_media_type(read->mov, i+1) == GF_ISOM_MEDIA_AUDIO) return GF_OK;
}
return GF_NOT_SUPPORTED;
}
if (com->command_type == GF_NET_SERVICE_QUALITY_SWITCH)
{
count = gf_list_count(read->channels);
for (i = 0; i < count; i++)
{
ch = (ISOMChannel *)gf_list_get(read->channels, i);
if (gf_isom_has_scalable_layer(read->mov)) {
ch->next_track = gf_channel_switch_quality(ch, read->mov, com->switch_quality.up);
}
}
return GF_OK;
}
if (com->command_type == GF_NET_SERVICE_PROXY_DATA_RECEIVE) {
isor_flush_data(read, 1, com->proxy_data.is_chunk);
return GF_OK;
}
if (com->command_type == GF_NET_SERVICE_FLUSH_DATA) {
if (read->nb_playing && plug->query_proxy)
isor_flush_data(read, 0, 0);
return GF_OK;
}
if (com->command_type == GF_NET_SERVICE_CAN_REVERSE_PLAYBACK)
return GF_OK;
if (!com->base.on_channel) return GF_NOT_SUPPORTED;
ch = isor_get_channel(read, com->base.on_channel);
if (!ch) return GF_STREAM_NOT_FOUND;
switch (com->command_type) {
case GF_NET_CHAN_SET_PADDING:
if (!ch->track) return GF_OK;
gf_isom_set_sample_padding(read->mov, ch->track, com->pad.padding_bytes);
return GF_OK;
case GF_NET_CHAN_SET_PULL:
//we don't pull in DASH base services, we flush as soon as we have a complete segment
#ifndef DASH_USE_PULL
if (read->input->proxy_udta && !read->input->proxy_type)
return GF_NOT_SUPPORTED;
#endif
ch->is_pulling = 1;
return GF_OK;
case GF_NET_CHAN_INTERACTIVE:
return GF_OK;
case GF_NET_CHAN_BUFFER:
//dash or HTTP, do rebuffer if not disabled
if (plug->query_proxy) {
} else if (read->dnload) {
ch->buffer_min = com->buffer.min;
ch->buffer_max = com->buffer.max;
} else {
com->buffer.max = com->buffer.min = 0;
}
return GF_OK;
case GF_NET_CHAN_DURATION:
if (!ch->track) {
com->duration.duration = 0;
return GF_OK;
}
ch->duration = gf_isom_get_track_duration(read->mov, ch->track);
track_dur = (Double) (s64) ch->duration;
track_dur /= read->time_scale;
if (gf_isom_get_edit_segment_count(read->mov, ch->track)) {
com->duration.duration = (Double) track_dur;
ch->duration = (u32) (track_dur * ch->time_scale);
} else {
/*some file indicate a wrong TrackDuration, get the longest*/
ch->duration = gf_isom_get_media_duration(read->mov, ch->track);
media_dur = (Double) (s64) ch->duration;
media_dur /= ch->time_scale;
com->duration.duration = MAX(track_dur, media_dur);
}
return GF_OK;
case GF_NET_CHAN_PLAY:
gf_mx_p(read->segment_mutex);
isor_reset_reader(ch);
ch->speed = com->play.speed;
read->reset_frag_state = 1;
if (read->frag_type)
read->frag_type = 1;
gf_mx_v(read->segment_mutex);
ch->start = ch->end = 0;
if (com->play.speed>0) {
if (com->play.start_range>=0) {
ch->start = (u64) (s64) (com->play.start_range * ch->time_scale);
ch->start = check_round(ch, ch->start, com->play.start_range, 1);
}
if (com->play.end_range >= com->play.start_range) {
ch->end = (u64) (s64) (com->play.end_range*ch->time_scale);
ch->end = check_round(ch, ch->end, com->play.end_range, 0);
}
} else if (com->play.speed<0) {
Double end = com->play.end_range;
if (end==-1) end = 0;
ch->start = (u64) (s64) (com->play.start_range * ch->time_scale);
if (end <= com->play.start_range)
ch->end = (u64) (s64) (end * ch->time_scale);
}
ch->is_playing = 1;
if (com->play.dash_segment_switch) ch->wait_for_segment_switch = 1;
GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[IsoMedia] Starting channel playback "LLD" to "LLD" (%g to %g)\n", ch->start, ch->end, com->play.start_range, com->play.end_range));
//and check buffer level on play request
isor_check_buffer_level(read);
read->nb_playing++;
return GF_OK;
case GF_NET_CHAN_STOP:
if (read->nb_playing) read->nb_playing--;
isor_reset_reader(ch);
return GF_OK;
case GF_NET_CHAN_SET_SPEED:
gf_mx_p(read->segment_mutex);
ch->speed = com->play.speed;
gf_mx_v(read->segment_mutex);
return GF_OK;
/*nothing to do on MP4 for channel config*/
case GF_NET_CHAN_CONFIG:
return GF_OK;
case GF_NET_CHAN_GET_PIXEL_AR:
return gf_isom_get_pixel_aspect_ratio(read->mov, ch->track, 1, &com->par.hSpacing, &com->par.vSpacing);
case GF_NET_CHAN_GET_DSI:
{
/*it may happen that there are conflicting config when using ESD URLs...*/
GF_DecoderConfig *dcd = gf_isom_get_decoder_config(read->mov, ch->track, 1);
com->get_dsi.dsi = NULL;
com->get_dsi.dsi_len = 0;
if (dcd) {
if (dcd->decoderSpecificInfo) {
com->get_dsi.dsi = dcd->decoderSpecificInfo->data;
com->get_dsi.dsi_len = dcd->decoderSpecificInfo->dataLength;
dcd->decoderSpecificInfo->data = NULL;
}
gf_odf_desc_del((GF_Descriptor *) dcd);
}
return GF_OK;
}
case GF_NET_CHAN_NALU_MODE:
ch->nalu_extract_mode = GF_ISOM_NALU_EXTRACT_INBAND_PS_FLAG;
ch->disable_seek = 1;
//when this is set, we work in real scalable (eg N streams reassembled by the player) so only extract the layer. This wll need refinements if we plan to support
//several scalable layers ...
if (com->nalu_mode.extract_mode==1) {
ch->nalu_extract_mode |= GF_ISOM_NALU_EXTRACT_ANNEXB_FLAG | GF_ISOM_NALU_EXTRACT_VDRD_FLAG | GF_ISOM_NALU_EXTRACT_LAYER_ONLY;
}
gf_isom_set_nalu_extract_mode(ch->owner->mov, ch->track, ch->nalu_extract_mode);
break;
default:
break;
}
return GF_NOT_SUPPORTED;
}
void isor_declare_objects(ISOMReader *read)
{
GF_ObjectDescriptor *od;
GF_ESD *esd;
const char *tag;
u32 i, count, ocr_es_id, tlen, base_track, j, track_id;
Bool highest_stream;
char *opt;
Bool add_ps_lower = GF_TRUE;
ocr_es_id = 0;
opt = (char*) gf_modules_get_option((GF_BaseInterface *)read->input, "ISOReader", "DeclareScalableXPS");
if (!opt) {
gf_modules_set_option((GF_BaseInterface *)read->input, "ISOReader", "DeclareScalableXPS", "yes");
} else if (!strcmp(opt, "no")) {
add_ps_lower = GF_FALSE;
}
/*TODO check for alternate tracks*/
count = gf_isom_get_track_count(read->mov);
for (i=0; i<count; i++) {
if (!gf_isom_is_track_enabled(read->mov, i+1)) continue;
switch (gf_isom_get_media_type(read->mov, i+1)) {
case GF_ISOM_MEDIA_AUDIO:
case GF_ISOM_MEDIA_VISUAL:
case GF_ISOM_MEDIA_TEXT:
case GF_ISOM_MEDIA_SUBT:
case GF_ISOM_MEDIA_SCENE:
case GF_ISOM_MEDIA_SUBPIC:
break;
default:
continue;
}
/*we declare only the highest video track (i.e the track we play)*/
highest_stream = GF_TRUE;
track_id = gf_isom_get_track_id(read->mov, i+1);
for (j = 0; j < count; j++) {
if (gf_isom_has_track_reference(read->mov, j+1, GF_ISOM_REF_SCAL, track_id) > 0) {
highest_stream = GF_FALSE;
break;
}
}
if ((gf_isom_get_media_type(read->mov, i+1) == GF_ISOM_MEDIA_VISUAL) && !highest_stream)
continue;
esd = gf_media_map_esd(read->mov, i+1);
if (esd) {
gf_isom_get_reference(read->mov, i+1, GF_ISOM_REF_BASE, 1, &base_track);
esd->has_ref_base = base_track ? GF_TRUE : GF_FALSE;
/*FIXME: if we declare only SPS/PPS of the highest layer, we have a problem in decoding even though we have all SPS/PPS inband (OpenSVC bug ?)*/
/*so we add by default the SPS/PPS of the lower layers to this esd*/
if (esd->has_ref_base && add_ps_lower) {
u32 count, refIndex, ref_track, num_sps, num_pps, t;
GF_AVCConfig *cfg = gf_odf_avc_cfg_read(esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength);
GF_AVCConfig *avccfg, *svccfg;
count = gf_isom_get_reference_count(read->mov, i+1, GF_ISOM_REF_SCAL);
for (refIndex = count; refIndex != 0; refIndex--) {
gf_isom_get_reference(read->mov, i+1, GF_ISOM_REF_SCAL, refIndex, &ref_track);
avccfg = gf_isom_avc_config_get(read->mov, ref_track, 1);
svccfg = gf_isom_svc_config_get(read->mov, ref_track, 1);
if (avccfg) {
num_sps = gf_list_count(avccfg->sequenceParameterSets);
for (t = 0; t < num_sps; t++) {
GF_AVCConfigSlot *slc = gf_list_get(avccfg->sequenceParameterSets, t);
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot*)gf_malloc(sizeof(GF_AVCConfigSlot));
sl->id = slc->id;
sl->size = slc->size;
sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
memcpy(sl->data, slc->data, sizeof(char)*sl->size);
gf_list_insert(cfg->sequenceParameterSets, sl, 0);
}
num_pps = gf_list_count(avccfg->pictureParameterSets);
for (t = 0; t < num_sps; t++) {
GF_AVCConfigSlot *slc = gf_list_get(avccfg->pictureParameterSets, t);
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot*)gf_malloc(sizeof(GF_AVCConfigSlot));
sl->id = slc->id;
sl->size = slc->size;
sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
memcpy(sl->data, slc->data, sizeof(char)*sl->size);
gf_list_insert(cfg->pictureParameterSets, sl, 0);
}
gf_odf_avc_cfg_del(avccfg);
}
if (svccfg) {
num_sps = gf_list_count(svccfg->sequenceParameterSets);
for (t = 0; t < num_sps; t++) {
GF_AVCConfigSlot *slc = gf_list_get(svccfg->sequenceParameterSets, t);
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot*)gf_malloc(sizeof(GF_AVCConfigSlot));
sl->id = slc->id;
sl->size = slc->size;
sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
memcpy(sl->data, slc->data, sizeof(char)*sl->size);
gf_list_insert(cfg->sequenceParameterSets, sl, 0);
}
num_pps = gf_list_count(svccfg->pictureParameterSets);
for (t = 0; t < num_pps; t++) {
GF_AVCConfigSlot *slc = gf_list_get(svccfg->pictureParameterSets, t);
GF_AVCConfigSlot *sl = (GF_AVCConfigSlot*)gf_malloc(sizeof(GF_AVCConfigSlot));
sl->id = slc->id;
sl->size = slc->size;
sl->data = (char*)gf_malloc(sizeof(char)*sl->size);
memcpy(sl->data, slc->data, sizeof(char)*sl->size);
gf_list_insert(cfg->pictureParameterSets, sl, 0);
}
gf_odf_avc_cfg_del(svccfg);
}
}
if (esd->decoderConfig->decoderSpecificInfo->data) gf_free(esd->decoderConfig->decoderSpecificInfo->data);
gf_odf_avc_cfg_write(cfg, &esd->decoderConfig->decoderSpecificInfo->data, &esd->decoderConfig->decoderSpecificInfo->dataLength);
gf_odf_avc_cfg_del(cfg);
}
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->service_ifce = read->input;
od->objectDescriptorID = 0;
if (!ocr_es_id) ocr_es_id = esd->ESID;
esd->OCRESID = ocr_es_id;
gf_list_add(od->ESDescriptors, esd);
if (read->input->query_proxy && read->input->proxy_udta && read->input->proxy_type) {
send_proxy_command(read, GF_FALSE, GF_TRUE, GF_OK, (GF_Descriptor*)od, NULL);
} else {
gf_term_add_media(read->service, (GF_Descriptor*)od, GF_TRUE);
}
}
}
/*if cover art, extract it in cache*/
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_COVER_ART, &tag, &tlen)==GF_OK) {
const char *cdir = gf_modules_get_option((GF_BaseInterface *)gf_term_get_service_interface(read->service), "General", "CacheDirectory");
if (cdir) {
char szName[GF_MAX_PATH];
const char *sep;
FILE *t;
sep = strrchr(gf_isom_get_filename(read->mov), '\\');
if (!sep) sep = strrchr(gf_isom_get_filename(read->mov), '/');
if (!sep) sep = gf_isom_get_filename(read->mov);
if ((cdir[strlen(cdir)-1] != '\\') && (cdir[strlen(cdir)-1] != '/')) {
sprintf(szName, "%s/%s_cover.%s", cdir, sep, (tlen & 0x80000000) ? "png" : "jpg");
} else {
sprintf(szName, "%s%s_cover.%s", cdir, sep, (tlen & 0x80000000) ? "png" : "jpg");
}
t = gf_f64_open(szName, "wb");
if (t) {
Bool isom_contains_video = GF_FALSE;
/*write cover data*/
assert(!(tlen & 0x80000000));
gf_fwrite(tag, tlen & 0x7FFFFFFF, 1, t);
fclose(t);
/*don't display cover art when video is present*/
for (i=0; i<gf_isom_get_track_count(read->mov); i++) {
if (!gf_isom_is_track_enabled(read->mov, i+1))
continue;
if (gf_isom_get_media_type(read->mov, i+1) == GF_ISOM_MEDIA_VISUAL) {
isom_contains_video = GF_TRUE;
break;
}
}
if (!isom_contains_video) {
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->service_ifce = read->input;
od->objectDescriptorID = GF_MEDIA_EXTERNAL_ID;
od->URLString = gf_strdup(szName);
if (read->input->query_proxy && read->input->proxy_udta && read->input->proxy_type) {
send_proxy_command(read, GF_FALSE, GF_TRUE, GF_OK, (GF_Descriptor*)od, NULL);
} else {
gf_term_add_media(read->service, (GF_Descriptor*)od, GF_TRUE);
}
}
}
}
}
if (read->input->query_proxy && read->input->proxy_udta && read->input->proxy_type) {
send_proxy_command(read, GF_FALSE, GF_TRUE, GF_OK, NULL, NULL);
} else {
gf_term_add_media(read->service, NULL, GF_FALSE);
}
}
static GF_Err gf_sm_load_run_isom(GF_SceneLoader *load)
{
GF_Err e;
FILE *logs;
u32 i, j, di, nbBifs, nbLaser, nb_samp, samp_done, init_offset;
GF_StreamContext *sc;
GF_ESD *esd;
GF_ODCodec *od_dec;
#ifndef GPAC_DISABLE_BIFS
GF_BifsDecoder *bifs_dec;
#endif
#ifndef GPAC_DISABLE_LASER
GF_LASeRCodec *lsr_dec;
#endif
if (!load || !load->isom) return GF_BAD_PARAM;
nbBifs = nbLaser = 0;
e = GF_OK;
#ifndef GPAC_DISABLE_BIFS
bifs_dec = gf_bifs_decoder_new(load->scene_graph, 1);
gf_bifs_decoder_set_extraction_path(bifs_dec, load->localPath, load->fileName);
#endif
od_dec = gf_odf_codec_new();
logs = NULL;
#ifndef GPAC_DISABLE_LASER
lsr_dec = gf_laser_decoder_new(load->scene_graph);
#endif
esd = NULL;
/*load each stream*/
nb_samp = 0;
for (i=0; i<gf_isom_get_track_count(load->isom); i++) {
u32 type = gf_isom_get_media_type(load->isom, i+1);
switch (type) {
case GF_ISOM_MEDIA_SCENE:
case GF_ISOM_MEDIA_OD:
nb_samp += gf_isom_get_sample_count(load->isom, i+1);
break;
default:
break;
}
}
samp_done = 1;
gf_isom_text_set_streaming_mode(load->isom, 1);
for (i=0; i<gf_isom_get_track_count(load->isom); i++) {
u32 type = gf_isom_get_media_type(load->isom, i+1);
switch (type) {
case GF_ISOM_MEDIA_SCENE:
case GF_ISOM_MEDIA_OD:
break;
default:
continue;
}
esd = gf_isom_get_esd(load->isom, i+1, 1);
if (!esd) continue;
if ((esd->decoderConfig->objectTypeIndication == GPAC_OTI_SCENE_AFX) ||
(esd->decoderConfig->objectTypeIndication == GPAC_OTI_SCENE_SYNTHESIZED_TEXTURE)
) {
nb_samp += gf_isom_get_sample_count(load->isom, i+1);
continue;
}
sc = gf_sm_stream_new(load->ctx, esd->ESID, esd->decoderConfig->streamType, esd->decoderConfig->objectTypeIndication);
sc->streamType = esd->decoderConfig->streamType;
sc->ESID = esd->ESID;
sc->objectType = esd->decoderConfig->objectTypeIndication;
sc->timeScale = gf_isom_get_media_timescale(load->isom, i+1);
/*we still need to reconfig the BIFS*/
if (esd->decoderConfig->streamType==GF_STREAM_SCENE) {
#ifndef GPAC_DISABLE_BIFS
/*BIFS*/
if (esd->decoderConfig->objectTypeIndication<=2) {
if (!esd->dependsOnESID && nbBifs && !i)
mp4_report(load, GF_OK, "several scene namespaces used or improper scene dependencies in file - import may be incorrect");
if (!esd->decoderConfig->decoderSpecificInfo) {
/* Hack for T-DMB non compliant streams */
e = gf_bifs_decoder_configure_stream(bifs_dec, esd->ESID, NULL, 0, esd->decoderConfig->objectTypeIndication);
} else {
e = gf_bifs_decoder_configure_stream(bifs_dec, esd->ESID, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength, esd->decoderConfig->objectTypeIndication);
}
if (e) goto exit;
nbBifs++;
}
#endif
#ifndef GPAC_DISABLE_LASER
/*LASER*/
if (esd->decoderConfig->objectTypeIndication==0x09) {
if (!esd->dependsOnESID && nbBifs && !i)
mp4_report(load, GF_OK, "several scene namespaces used or improper scene dependencies in file - import may be incorrect");
e = gf_laser_decoder_configure_stream(lsr_dec, esd->ESID, esd->decoderConfig->decoderSpecificInfo->data, esd->decoderConfig->decoderSpecificInfo->dataLength);
if (e) goto exit;
nbLaser++;
}
#endif
}
init_offset = 0;
/*dump all AUs*/
for (j=0; j<gf_isom_get_sample_count(load->isom, i+1); j++) {
GF_AUContext *au;
GF_ISOSample *samp = gf_isom_get_sample(load->isom, i+1, j+1, &di);
if (!samp) {
mp4_report(load, gf_isom_last_error(load->isom), "Unable to fetch sample %d from track ID %d - aborting track import", j+1, gf_isom_get_track_id(load->isom, i+1));
break;
}
/*check if track has initial offset*/
if (!j && gf_isom_get_edit_segment_count(load->isom, i+1)) {
u64 EditTime, dur, mtime;
u8 mode;
gf_isom_get_edit_segment(load->isom, i+1, 1, &EditTime, &dur, &mtime, &mode);
if (mode==GF_ISOM_EDIT_EMPTY) {
init_offset = (u32) (dur * sc->timeScale / gf_isom_get_timescale(load->isom) );
}
}
samp->DTS += init_offset;
au = gf_sm_stream_au_new(sc, samp->DTS, ((Double)(s64) samp->DTS) / sc->timeScale, (samp->IsRAP==RAP) ? 1 : 0);
if (esd->decoderConfig->streamType==GF_STREAM_SCENE) {
#ifndef GPAC_DISABLE_BIFS
if (esd->decoderConfig->objectTypeIndication<=2)
e = gf_bifs_decode_command_list(bifs_dec, esd->ESID, samp->data, samp->dataLength, au->commands);
#endif
#ifndef GPAC_DISABLE_LASER
if (esd->decoderConfig->objectTypeIndication==0x09)
e = gf_laser_decode_command_list(lsr_dec, esd->ESID, samp->data, samp->dataLength, au->commands);
#endif
} else {
e = gf_odf_codec_set_au(od_dec, samp->data, samp->dataLength);
if (!e) e = gf_odf_codec_decode(od_dec);
if (!e) {
while (1) {
GF_ODCom *odc = gf_odf_codec_get_com(od_dec);
if (!odc) break;
/*update ESDs if any*/
UpdateODCommand(load->isom, odc);
gf_list_add(au->commands, odc);
}
}
}
gf_isom_sample_del(&samp);
if (e) {
mp4_report(load, gf_isom_last_error(load->isom), "decoding sample %d from track ID %d failed", j+1, gf_isom_get_track_id(load->isom, i+1));
goto exit;
}
samp_done++;
gf_set_progress("MP4 Loading", samp_done, nb_samp);
}
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
}
gf_isom_text_set_streaming_mode(load->isom, 0);
exit:
#ifndef GPAC_DISABLE_BIFS
gf_bifs_decoder_del(bifs_dec);
#endif
gf_odf_codec_del(od_dec);
#ifndef GPAC_DISABLE_LASER
gf_laser_decoder_del(lsr_dec);
#endif
if (esd) gf_odf_desc_del((GF_Descriptor *) esd);
if (logs) gf_fclose(logs);
return e;
}
GF_Err ISOR_ServiceCommand(GF_InputService *plug, GF_NetworkCommand *com)
{
Double track_dur, media_dur;
ISOMChannel *ch;
ISOMReader *read;
if (!plug || !plug->priv || !com) return GF_SERVICE_ERROR;
read = (ISOMReader *) plug->priv;
if (com->command_type==GF_NET_SERVICE_INFO) {
u32 tag_len;
const char *tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_NAME, &tag, &tag_len)==GF_OK) com->info.name = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_ARTIST, &tag, &tag_len)==GF_OK) com->info.artist = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_ALBUM, &tag, &tag_len)==GF_OK) com->info.album = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_COMMENT, &tag, &tag_len)==GF_OK) com->info.comment = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_TRACK, &tag, &tag_len)==GF_OK) {
com->info.track_info = (((tag[2]<<8)|tag[3]) << 16) | ((tag[4]<<8)|tag[5]);
}
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_COMPOSER, &tag, &tag_len)==GF_OK) com->info.composer = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_WRITER, &tag, &tag_len)==GF_OK) com->info.writer = tag;
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_GENRE, &tag, &tag_len)==GF_OK) {
if (tag[0]) {
com->info.genre = 0;
} else {
com->info.genre = (tag[0]<<8) | tag[1];
}
}
return GF_OK;
}
if (com->command_type==GF_NET_SERVICE_HAS_AUDIO) {
u32 i, count;
count = gf_isom_get_track_count(read->mov);
for (i=0; i<count; i++) {
if (gf_isom_get_media_type(read->mov, i+1) == GF_ISOM_MEDIA_AUDIO) return GF_OK;
}
return GF_NOT_SUPPORTED;
}
if (!com->base.on_channel) return GF_NOT_SUPPORTED;
ch = isor_get_channel(read, com->base.on_channel);
if (!ch) return GF_STREAM_NOT_FOUND;
switch (com->command_type) {
case GF_NET_CHAN_SET_PADDING:
if (!ch->track) return GF_OK;
gf_isom_set_sample_padding(read->mov, ch->track, com->pad.padding_bytes);
return GF_OK;
case GF_NET_CHAN_SET_PULL:
ch->is_pulling = 1;
return GF_OK;
case GF_NET_CHAN_INTERACTIVE:
return GF_OK;
case GF_NET_CHAN_BUFFER:
com->buffer.max = com->buffer.min = 0;
return GF_OK;
case GF_NET_CHAN_DURATION:
if (!ch->track) {
com->duration.duration = 0;
return GF_OK;
}
ch->duration = gf_isom_get_track_duration(read->mov, ch->track);
track_dur = (Double) (s64) ch->duration;
track_dur /= read->time_scale;
if (gf_isom_get_edit_segment_count(read->mov, ch->track)) {
com->duration.duration = (Double) track_dur;
ch->duration = (u32) (track_dur * ch->time_scale);
} else {
/*some file indicate a wrong TrackDuration, get the longest*/
ch->duration = gf_isom_get_media_duration(read->mov, ch->track);
media_dur = (Double) (s64) ch->duration;
media_dur /= ch->time_scale;
com->duration.duration = MAX(track_dur, media_dur);
}
return GF_OK;
case GF_NET_CHAN_PLAY:
if (!ch->is_pulling) return GF_NOT_SUPPORTED;
assert(!ch->is_playing);
isor_reset_reader(ch);
ch->speed = com->play.speed;
ch->start = ch->end = 0;
if (com->play.speed>0) {
if (com->play.start_range>=0) {
ch->start = (u64) (s64) (com->play.start_range * ch->time_scale);
ch->start = check_round(ch, ch->start, com->play.start_range, 1);
}
if (com->play.end_range >= com->play.start_range) {
ch->end = (u64) (s64) (com->play.end_range*ch->time_scale);
ch->end = check_round(ch, ch->end, com->play.end_range, 0);
}
} else if (com->play.speed<0) {
if (com->play.end_range>=com->play.start_range) ch->start = (u64) (s64) (com->play.start_range * ch->time_scale);
if (com->play.end_range >= 0) ch->end = (u64) (s64) (com->play.end_range*ch->time_scale);
}
ch->is_playing = 1;
if (com->play.dash_segment_switch) ch->wait_for_segment_switch = 1;
GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[IsoMedia] Starting channel playback "LLD" to "LLD" (%g to %g)\n", ch->start, ch->end, com->play.start_range, com->play.end_range));
return GF_OK;
case GF_NET_CHAN_STOP:
isor_reset_reader(ch);
return GF_OK;
/*nothing to do on MP4 for channel config*/
case GF_NET_CHAN_CONFIG:
return GF_OK;
case GF_NET_CHAN_GET_PIXEL_AR:
return gf_isom_get_pixel_aspect_ratio(read->mov, ch->track, 1, &com->par.hSpacing, &com->par.vSpacing);
case GF_NET_CHAN_GET_DSI:
{
/*it may happen that there are conflicting config when using ESD URLs...*/
GF_DecoderConfig *dcd = gf_isom_get_decoder_config(read->mov, ch->track, 1);
com->get_dsi.dsi = NULL;
com->get_dsi.dsi_len = 0;
if (dcd) {
if (dcd->decoderSpecificInfo) {
com->get_dsi.dsi = dcd->decoderSpecificInfo->data;
com->get_dsi.dsi_len = dcd->decoderSpecificInfo->dataLength;
dcd->decoderSpecificInfo->data = NULL;
}
gf_odf_desc_del((GF_Descriptor *) dcd);
}
}
return GF_OK;
}
return GF_NOT_SUPPORTED;
}
GF_Err ISOR_ConnectChannel(GF_InputService *plug, LPNETCHANNEL channel, const char *url, Bool upstream)
{
u32 ESID;
ISOMChannel *ch;
GF_NetworkCommand com;
u32 track;
Bool is_esd_url;
GF_Err e;
ISOMReader *read;
if (!plug || !plug->priv) return GF_SERVICE_ERROR;
read = (ISOMReader *) plug->priv;
track = 0;
ch = NULL;
is_esd_url = 0;
e = GF_OK;
if (upstream) {
e = GF_ISOM_INVALID_FILE;
goto exit;
}
if (!read->mov) return GF_SERVICE_ERROR;
if (strstr(url, "ES_ID")) {
sscanf(url, "ES_ID=%ud", &ESID);
} else {
/*handle url like mypath/myfile.mp4#trackID*/
char *track_id = strrchr(url, '.');
if (track_id) {
track_id = strchr(url, '#');
if (track_id) track_id ++;
}
is_esd_url = 1;
ESID = 0;
/*if only one track ok*/
if (gf_isom_get_track_count(read->mov)==1) ESID = gf_isom_get_track_id(read->mov, 1);
else if (track_id) {
ESID = atoi(track_id);
track = gf_isom_get_track_by_id(read->mov, (u32) ESID);
if (!track) ESID = 0;
}
}
if (!ESID) {
e = GF_NOT_SUPPORTED;
goto exit;
}
/*a channel cannot be open twice, it has to be closed before - NOTE a track is NOT a channel and the user can open
several times the same track as long as a dedicated channel is used*/
ch = isor_get_channel(read, channel);
if (ch) {
e = GF_SERVICE_ERROR;
goto exit;
}
track = gf_isom_get_track_by_id(read->mov, (u32) ESID);
if (!track) {
e = GF_STREAM_NOT_FOUND;
goto exit;
}
GF_SAFEALLOC(ch, ISOMChannel);
ch->owner = read;
ch->channel = channel;
gf_list_add(read->channels, ch);
ch->track = track;
switch (gf_isom_get_media_type(ch->owner->mov, ch->track)) {
case GF_ISOM_MEDIA_OCR:
ch->streamType = GF_STREAM_OCR;
break;
case GF_ISOM_MEDIA_SCENE:
ch->streamType = GF_STREAM_SCENE;
break;
}
ch->has_edit_list = gf_isom_get_edit_segment_count(ch->owner->mov, ch->track) ? 1 : 0;
ch->has_rap = (gf_isom_has_sync_points(ch->owner->mov, ch->track)==1) ? 1 : 0;
ch->time_scale = gf_isom_get_media_timescale(ch->owner->mov, ch->track);
exit:
gf_term_on_connect(read->service, channel, e);
/*if esd url reconfig SL layer*/
if (!e && is_esd_url) {
GF_ESD *esd;
memset(&com, 0, sizeof(GF_NetworkCommand));
com.base.on_channel = channel;
com.command_type = GF_NET_CHAN_RECONFIG;
esd = gf_isom_get_esd(read->mov, ch->track, 1);
if (esd) {
memcpy(&com.cfg.sl_config, esd->slConfig, sizeof(GF_SLConfig));
gf_odf_desc_del((GF_Descriptor *)esd);
} else {
com.cfg.sl_config.tag = GF_ODF_SLC_TAG;
com.cfg.sl_config.timestampLength = 32;
com.cfg.sl_config.timestampResolution = ch->time_scale;
com.cfg.sl_config.useRandomAccessPointFlag = 1;
}
gf_term_on_command(read->service, &com, GF_OK);
}
if (!e && track && gf_isom_is_track_encrypted(read->mov, track)) {
memset(&com, 0, sizeof(GF_NetworkCommand));
com.base.on_channel = channel;
com.command_type = GF_NET_CHAN_DRM_CFG;
ch->is_encrypted = 1;
if (gf_isom_is_ismacryp_media(read->mov, track, 1)) {
gf_isom_get_ismacryp_info(read->mov, track, 1, NULL, &com.drm_cfg.scheme_type, &com.drm_cfg.scheme_version, &com.drm_cfg.scheme_uri, &com.drm_cfg.kms_uri, NULL, NULL, NULL);
gf_term_on_command(read->service, &com, GF_OK);
} else if (gf_isom_is_omadrm_media(read->mov, track, 1)) {
gf_isom_get_omadrm_info(read->mov, track, 1, NULL, &com.drm_cfg.scheme_type, &com.drm_cfg.scheme_version, &com.drm_cfg.contentID, &com.drm_cfg.kms_uri, &com.drm_cfg.oma_drm_textual_headers, &com.drm_cfg.oma_drm_textual_headers_len, NULL, &com.drm_cfg.oma_drm_crypt_type, NULL, NULL, NULL);
gf_media_get_file_hash(gf_isom_get_filename(read->mov), com.drm_cfg.hash);
gf_term_on_command(read->service, &com, GF_OK);
}
}
return e;
}
/*fixme, this doesn't work properly with respect to @expect_type*/
static GF_Descriptor *ISOR_GetServiceDesc(GF_InputService *plug, u32 expect_type, const char *sub_url)
{
u32 count, nb_st, i, trackID;
GF_ESD *esd;
ISOMReader *read;
GF_InitialObjectDescriptor *iod;
if (!plug || !plug->priv) return NULL;
read = (ISOMReader *) plug->priv;
if (!read->mov) return NULL;
/*no matter what always read text as TTUs*/
gf_isom_text_set_streaming_mode(read->mov, 1);
trackID = 0;
if (!sub_url) {
trackID = read->base_track_id;
read->base_track_id = 0;
} else {
char *ext = strrchr(sub_url, '#');
if (!ext) {
trackID = 0;
} else {
if (!strnicmp(ext, "#trackID=", 9)) trackID = atoi(ext+9);
else if (!stricmp(ext, "#video")) trackID = get_track_id(read->mov, GF_ISOM_MEDIA_VISUAL, 0);
else if (!strnicmp(ext, "#video", 6)) {
trackID = atoi(ext+6);
trackID = get_track_id(read->mov, GF_ISOM_MEDIA_VISUAL, trackID);
}
else if (!stricmp(ext, "#audio")) trackID = get_track_id(read->mov, GF_ISOM_MEDIA_AUDIO, 0);
else if (!strnicmp(ext, "#audio", 6)) {
trackID = atoi(ext+6);
trackID = get_track_id(read->mov, GF_ISOM_MEDIA_AUDIO, trackID);
}
else trackID = atoi(ext+1);
/*if trackID is 0, assume this is a fragment identifier*/
}
}
if (!trackID && (expect_type!=GF_MEDIA_OBJECT_SCENE) && (expect_type!=GF_MEDIA_OBJECT_UNDEF)) {
for (i=0; i<gf_isom_get_track_count(read->mov); i++) {
u32 type = gf_isom_get_media_type(read->mov, i+1);
if (
((type==GF_ISOM_MEDIA_VISUAL) && (expect_type==GF_MEDIA_OBJECT_VIDEO))
|| ((type==GF_ISOM_MEDIA_AUDIO) && (expect_type==GF_MEDIA_OBJECT_AUDIO)) ) {
trackID = gf_isom_get_track_id(read->mov, i+1);
break;
}
}
}
if (trackID && (expect_type!=GF_MEDIA_OBJECT_SCENE) ) {
u32 track = gf_isom_get_track_by_id(read->mov, trackID);
if (!track) return NULL;
esd = gf_media_map_esd(read->mov, track);
esd->OCRESID = 0;
iod = (GF_InitialObjectDescriptor *) gf_isom_get_root_od(read->mov);
if (!iod) {
iod = (GF_InitialObjectDescriptor *) gf_odf_desc_new(GF_ODF_IOD_TAG);
iod->OD_profileAndLevel = iod->audio_profileAndLevel = iod->graphics_profileAndLevel = iod->scene_profileAndLevel = iod->visual_profileAndLevel = 0xFE;
} else {
while (gf_list_count(iod->ESDescriptors)) {
GF_ESD *old = (GF_ESD *)gf_list_get(iod->ESDescriptors, 0);
gf_odf_desc_del((GF_Descriptor *) old);
gf_list_rem(iod->ESDescriptors, 0);
}
}
gf_list_add(iod->ESDescriptors, esd);
isor_emulate_chapters(read->mov, iod);
return (GF_Descriptor *) iod;
}
iod = NULL;
if (check_mpeg4_systems(plug, read->mov)) {
iod = (GF_InitialObjectDescriptor *) gf_isom_get_root_od(read->mov);
if (!iod) {
#ifndef GPAC_DISABLE_LOG
GF_Err e = gf_isom_last_error(read->mov);
if (e) {
GF_LOG(GF_LOG_ERROR, GF_LOG_NETWORK, ("[IsoMedia] Cannot fetch MPEG-4 IOD (error %s) - generating one\n", gf_error_to_string(e) ));
} else {
GF_LOG(GF_LOG_DEBUG, GF_LOG_NETWORK, ("[IsoMedia] No MPEG-4 IOD found in file - generating one\n"));
}
#endif
}
}
if (!iod) return isor_emulate_iod(read);
count = gf_list_count(iod->ESDescriptors);
if (!count) {
gf_odf_desc_del((GF_Descriptor*) iod);
return isor_emulate_iod(read);
}
if (count==1) {
esd = (GF_ESD *)gf_list_get(iod->ESDescriptors, 0);
switch (esd->decoderConfig->streamType) {
case GF_STREAM_SCENE:
case GF_STREAM_PRIVATE_SCENE:
break;
case GF_STREAM_VISUAL:
if (expect_type!=GF_MEDIA_OBJECT_VIDEO) {
gf_odf_desc_del((GF_Descriptor*) iod);
return isor_emulate_iod(read);
}
break;
case GF_STREAM_AUDIO:
/*we need a fake scene graph*/
if (expect_type!=GF_MEDIA_OBJECT_AUDIO) {
gf_odf_desc_del((GF_Descriptor*) iod);
return isor_emulate_iod(read);
}
break;
default:
gf_odf_desc_del((GF_Descriptor*) iod);
return NULL;
}
}
/*check IOD is not badly formed (eg mixing audio, video or text streams)*/
nb_st = 0;
for (i=0; i<count; i++) {
esd = (GF_ESD *)gf_list_get(iod->ESDescriptors, i);
switch (esd->decoderConfig->streamType) {
case GF_STREAM_VISUAL:
nb_st |= 1;
break;
case GF_STREAM_AUDIO:
nb_st |= 2;
break;
case GF_STREAM_TEXT:
nb_st |= 4;
break;
}
}
if ( (nb_st & 1) + (nb_st & 2) + (nb_st & 4) > 1) {
gf_odf_desc_del((GF_Descriptor*) iod);
return isor_emulate_iod(read);
}
isor_emulate_chapters(read->mov, iod);
return (GF_Descriptor *) iod;
}
GF_EXPORT
GF_Err gf_hinter_finalize(GF_ISOFile *file, u32 IOD_Profile, u32 bandwidth)
{
u32 i, sceneT, odT, descIndex, size, size64;
GF_InitialObjectDescriptor *iod;
GF_SLConfig slc;
GF_ESD *esd;
GF_ISOSample *samp;
Bool remove_ocr;
char *buffer;
char buf64[5000], sdpLine[2300];
gf_isom_sdp_clean(file);
if (bandwidth) {
sprintf(buf64, "b=AS:%d", bandwidth);
gf_isom_sdp_add_line(file, buf64);
}
//xtended attribute for copyright
sprintf(buf64, "a=x-copyright: %s", "MP4/3GP File hinted with GPAC " GPAC_FULL_VERSION " (C)2000-2005 - http://gpac.sourceforge.net");
gf_isom_sdp_add_line(file, buf64);
if (IOD_Profile == GF_SDP_IOD_NONE) return GF_OK;
odT = sceneT = 0;
for (i=0; i<gf_isom_get_track_count(file); i++) {
if (!gf_isom_is_track_in_root_od(file, i+1)) continue;
switch (gf_isom_get_media_type(file,i+1)) {
case GF_ISOM_MEDIA_OD:
odT = i+1;
break;
case GF_ISOM_MEDIA_SCENE:
sceneT = i+1;
break;
}
}
remove_ocr = 0;
if (IOD_Profile == GF_SDP_IOD_ISMA_STRICT) {
IOD_Profile = GF_SDP_IOD_ISMA;
remove_ocr = 1;
}
/*if we want ISMA like iods, we need at least BIFS */
if ( (IOD_Profile == GF_SDP_IOD_ISMA) && !sceneT ) return GF_BAD_PARAM;
/*do NOT change PLs, we assume they are correct*/
iod = (GF_InitialObjectDescriptor *) gf_isom_get_root_od(file);
if (!iod) return GF_NOT_SUPPORTED;
/*rewrite an IOD with good SL config - embbed data if possible*/
if (IOD_Profile == GF_SDP_IOD_ISMA) {
Bool is_ok = 1;
while (gf_list_count(iod->ESDescriptors)) {
esd = (GF_ESD*)gf_list_get(iod->ESDescriptors, 0);
gf_odf_desc_del((GF_Descriptor *) esd);
gf_list_rem(iod->ESDescriptors, 0);
}
/*get OD esd, and embbed stream data if possible*/
if (odT) {
esd = gf_isom_get_esd(file, odT, 1);
if (gf_isom_get_sample_count(file, odT)==1) {
samp = gf_isom_get_sample(file, odT, 1, &descIndex);
if (gf_hinter_can_embbed_data(samp->data, samp->dataLength, GF_STREAM_OD)) {
InitSL_NULL(&slc);
slc.predefined = 0;
slc.hasRandomAccessUnitsOnlyFlag = 1;
slc.timeScale = slc.timestampResolution = gf_isom_get_media_timescale(file, odT);
slc.OCRResolution = 1000;
slc.startCTS = samp->DTS+samp->CTS_Offset;
slc.startDTS = samp->DTS;
//set the SL for future extraction
gf_isom_set_extraction_slc(file, odT, 1, &slc);
size64 = gf_base64_encode(samp->data, samp->dataLength, buf64, 2000);
buf64[size64] = 0;
sprintf(sdpLine, "data:application/mpeg4-od-au;base64,%s", buf64);
esd->decoderConfig->avgBitrate = 0;
esd->decoderConfig->bufferSizeDB = samp->dataLength;
esd->decoderConfig->maxBitrate = 0;
size64 = strlen(sdpLine)+1;
esd->URLString = (char*)gf_malloc(sizeof(char) * size64);
strcpy(esd->URLString, sdpLine);
} else {
GF_LOG(GF_LOG_WARNING, GF_LOG_RTP, ("[rtp hinter] OD sample too large to be embedded in IOD - ISMA disabled\n"));
is_ok = 0;
}
gf_isom_sample_del(&samp);
}
if (remove_ocr) esd->OCRESID = 0;
else if (esd->OCRESID == esd->ESID) esd->OCRESID = 0;
//OK, add this to our IOD
gf_list_add(iod->ESDescriptors, esd);
}
esd = gf_isom_get_esd(file, sceneT, 1);
if (gf_isom_get_sample_count(file, sceneT)==1) {
samp = gf_isom_get_sample(file, sceneT, 1, &descIndex);
if (gf_hinter_can_embbed_data(samp->data, samp->dataLength, GF_STREAM_SCENE)) {
slc.timeScale = slc.timestampResolution = gf_isom_get_media_timescale(file, sceneT);
slc.OCRResolution = 1000;
slc.startCTS = samp->DTS+samp->CTS_Offset;
slc.startDTS = samp->DTS;
//set the SL for future extraction
gf_isom_set_extraction_slc(file, sceneT, 1, &slc);
//encode in Base64 the sample
size64 = gf_base64_encode(samp->data, samp->dataLength, buf64, 2000);
buf64[size64] = 0;
sprintf(sdpLine, "data:application/mpeg4-bifs-au;base64,%s", buf64);
esd->decoderConfig->avgBitrate = 0;
esd->decoderConfig->bufferSizeDB = samp->dataLength;
esd->decoderConfig->maxBitrate = 0;
esd->URLString = (char*)gf_malloc(sizeof(char) * (strlen(sdpLine)+1));
strcpy(esd->URLString, sdpLine);
} else {
GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("[rtp hinter] Scene description sample too large to be embedded in IOD - ISMA disabled\n"));
is_ok = 0;
}
gf_isom_sample_del(&samp);
}
if (remove_ocr) esd->OCRESID = 0;
else if (esd->OCRESID == esd->ESID) esd->OCRESID = 0;
gf_list_add(iod->ESDescriptors, esd);
if (is_ok) {
u32 has_a, has_v, has_i_a, has_i_v;
has_a = has_v = has_i_a = has_i_v = 0;
for (i=0; i<gf_isom_get_track_count(file); i++) {
esd = gf_isom_get_esd(file, i+1, 1);
if (!esd) continue;
if (esd->decoderConfig->streamType==GF_STREAM_VISUAL) {
if (esd->decoderConfig->objectTypeIndication==GPAC_OTI_VIDEO_MPEG4_PART2) has_i_v ++;
else has_v++;
} else if (esd->decoderConfig->streamType==GF_STREAM_AUDIO) {
if (esd->decoderConfig->objectTypeIndication==GPAC_OTI_AUDIO_AAC_MPEG4) has_i_a ++;
else has_a++;
}
gf_odf_desc_del((GF_Descriptor *)esd);
}
/*only 1 MPEG-4 visual max and 1 MPEG-4 audio max for ISMA compliancy*/
if (!has_v && !has_a && (has_i_v<=1) && (has_i_a<=1)) {
sprintf(sdpLine, "a=isma-compliance:1,1.0,1");
gf_isom_sdp_add_line(file, sdpLine);
}
}
}
//encode the IOD
buffer = NULL;
size = 0;
gf_odf_desc_write((GF_Descriptor *) iod, &buffer, &size);
gf_odf_desc_del((GF_Descriptor *)iod);
//encode in Base64 the iod
size64 = gf_base64_encode(buffer, size, buf64, 2000);
buf64[size64] = 0;
gf_free(buffer);
sprintf(sdpLine, "a=mpeg4-iod:\"data:application/mpeg4-iod;base64,%s\"", buf64);
gf_isom_sdp_add_line(file, sdpLine);
return GF_OK;
}
GF_Err gf_sm_load_init_isom(GF_SceneLoader *load)
{
u32 i;
GF_BIFSConfig *bc;
GF_ESD *esd;
GF_Err e;
char *scene_msg = "MPEG-4 BIFS Scene Parsing";
if (!load->isom) return GF_BAD_PARAM;
/*load IOD*/
load->ctx->root_od = (GF_ObjectDescriptor *) gf_isom_get_root_od(load->isom);
if (!load->ctx->root_od) {
e = gf_isom_last_error(load->isom);
if (e) return e;
} else if ((load->ctx->root_od->tag != GF_ODF_OD_TAG) && (load->ctx->root_od->tag != GF_ODF_IOD_TAG)) {
gf_odf_desc_del((GF_Descriptor *) load->ctx->root_od);
load->ctx->root_od = NULL;
}
esd = NULL;
/*get root scene stream*/
for (i=0; i<gf_isom_get_track_count(load->isom); i++) {
u32 type = gf_isom_get_media_type(load->isom, i+1);
if (type != GF_ISOM_MEDIA_SCENE) continue;
if (! gf_isom_is_track_in_root_od(load->isom, i+1) ) continue;
esd = gf_isom_get_esd(load->isom, i+1, 1);
if (esd && esd->URLString) {
gf_odf_desc_del((GF_Descriptor *)esd);
esd = NULL;
continue;
}
/*make sure we load the root BIFS stream first*/
if (esd && esd->dependsOnESID && (esd->dependsOnESID!=esd->ESID) ) {
u32 track = gf_isom_get_track_by_id(load->isom, esd->dependsOnESID);
if (gf_isom_get_media_type(load->isom, track) != GF_ISOM_MEDIA_OD) {
gf_odf_desc_del((GF_Descriptor *)esd);
esd = NULL;
continue;
}
}
if (esd->decoderConfig->objectTypeIndication==0x09) scene_msg = "MPEG-4 LASeR Scene Parsing";
break;
}
if (!esd) return GF_OK;
e = GF_OK;
GF_LOG(GF_LOG_INFO, GF_LOG_PARSER, ("%s\n", scene_msg));
/*BIFS: update size & pixel metrics info*/
if (esd->decoderConfig->objectTypeIndication<=2) {
bc = gf_odf_get_bifs_config(esd->decoderConfig->decoderSpecificInfo, esd->decoderConfig->objectTypeIndication);
if (!bc->elementaryMasks && bc->pixelWidth && bc->pixelHeight) {
load->ctx->scene_width = bc->pixelWidth;
load->ctx->scene_height = bc->pixelHeight;
load->ctx->is_pixel_metrics = bc->pixelMetrics;
}
gf_odf_desc_del((GF_Descriptor *) bc);
/*note we don't load the first BIFS AU to avoid storing the BIFS decoder, needed to properly handle quantization*/
}
/*LASeR*/
else if (esd->decoderConfig->objectTypeIndication==0x09) {
load->ctx->is_pixel_metrics = 1;
}
gf_odf_desc_del((GF_Descriptor *) esd);
esd = NULL;
load->process = gf_sm_load_run_isom;
load->done = gf_sm_load_done_isom;
load->suspend = gf_sm_isom_suspend;
return GF_OK;
}
void isor_declare_objects(ISOMReader *read)
{
GF_ObjectDescriptor *od;
GF_ESD *esd;
const char *tag;
u32 i, count, ocr_es_id, tlen, base_track, j, track_id;
Bool highest_stream;
ocr_es_id = 0;
/*TODO check for alternate tracks*/
count = gf_isom_get_track_count(read->mov);
for (i=0; i<count; i++) {
if (!gf_isom_is_track_enabled(read->mov, i+1))
continue;
switch (gf_isom_get_media_type(read->mov, i+1)) {
case GF_ISOM_MEDIA_AUDIO:
case GF_ISOM_MEDIA_VISUAL:
case GF_ISOM_MEDIA_TEXT:
case GF_ISOM_MEDIA_SUBT:
case GF_ISOM_MEDIA_SCENE:
case GF_ISOM_MEDIA_SUBPIC:
break;
default:
continue;
}
//some subtypes are not declared as readable objects
switch (gf_isom_get_media_subtype(read->mov, i+1, 1)) {
case GF_ISOM_SUBTYPE_HVT1:
continue;
default:
break;
}
/*we declare only the highest video track (i.e the track we play)*/
highest_stream = GF_TRUE;
track_id = gf_isom_get_track_id(read->mov, i+1);
if (read->play_only_track_id && (read->play_only_track_id != track_id)) continue;
for (j = 0; j < count; j++) {
if (gf_isom_has_track_reference(read->mov, j+1, GF_ISOM_REF_SCAL, track_id) > 0) {
highest_stream = GF_FALSE;
break;
}
}
if ((gf_isom_get_media_type(read->mov, i+1) == GF_ISOM_MEDIA_VISUAL) && !highest_stream)
continue;
esd = gf_media_map_esd(read->mov, i+1);
if (esd) {
gf_isom_get_reference(read->mov, i+1, GF_ISOM_REF_BASE, 1, &base_track);
esd->has_ref_base = base_track ? GF_TRUE : GF_FALSE;
if (!esd->langDesc) {
esd->langDesc = (GF_Language *) gf_odf_desc_new(GF_ODF_LANG_TAG);
gf_isom_get_media_language(read->mov, i+1, &esd->langDesc->full_lang_code);
}
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->service_ifce = read->input;
od->objectDescriptorID = 0;
if (!ocr_es_id) ocr_es_id = esd->ESID;
esd->OCRESID = ocr_es_id;
gf_list_add(od->ESDescriptors, esd);
if (read->input->query_proxy && read->input->proxy_udta && read->input->proxy_type) {
send_proxy_command(read, GF_FALSE, GF_TRUE, GF_OK, (GF_Descriptor*)od, NULL);
} else {
gf_service_declare_media(read->service, (GF_Descriptor*)od, GF_TRUE);
}
}
}
/*if cover art, extract it in cache*/
if (gf_isom_apple_get_tag(read->mov, GF_ISOM_ITUNE_COVER_ART, &tag, &tlen)==GF_OK) {
const char *cdir = gf_modules_get_option((GF_BaseInterface *)gf_service_get_interface(read->service), "General", "CacheDirectory");
if (cdir) {
char szName[GF_MAX_PATH];
const char *sep;
FILE *t;
sep = strrchr(gf_isom_get_filename(read->mov), '\\');
if (!sep) sep = strrchr(gf_isom_get_filename(read->mov), '/');
if (!sep) sep = gf_isom_get_filename(read->mov);
if ((cdir[strlen(cdir)-1] != '\\') && (cdir[strlen(cdir)-1] != '/')) {
sprintf(szName, "%s/%s_cover.%s", cdir, sep, (tlen & 0x80000000) ? "png" : "jpg");
} else {
sprintf(szName, "%s%s_cover.%s", cdir, sep, (tlen & 0x80000000) ? "png" : "jpg");
}
t = gf_fopen(szName, "wb");
if (t) {
Bool isom_contains_video = GF_FALSE;
/*write cover data*/
assert(!(tlen & 0x80000000));
gf_fwrite(tag, tlen & 0x7FFFFFFF, 1, t);
gf_fclose(t);
/*don't display cover art when video is present*/
for (i=0; i<gf_isom_get_track_count(read->mov); i++) {
if (!gf_isom_is_track_enabled(read->mov, i+1))
continue;
if (gf_isom_get_media_type(read->mov, i+1) == GF_ISOM_MEDIA_VISUAL) {
isom_contains_video = GF_TRUE;
break;
}
}
if (!isom_contains_video) {
od = (GF_ObjectDescriptor *) gf_odf_desc_new(GF_ODF_OD_TAG);
od->service_ifce = read->input;
od->objectDescriptorID = GF_MEDIA_EXTERNAL_ID;
od->URLString = gf_strdup(szName);
if (read->input->query_proxy && read->input->proxy_udta && read->input->proxy_type) {
send_proxy_command(read, GF_FALSE, GF_TRUE, GF_OK, (GF_Descriptor*)od, NULL);
} else {
gf_service_declare_media(read->service, (GF_Descriptor*)od, GF_TRUE);
}
}
}
}
}
if (read->input->query_proxy && read->input->proxy_udta && read->input->proxy_type) {
send_proxy_command(read, GF_FALSE, GF_TRUE, GF_OK, NULL, NULL);
} else {
gf_service_declare_media(read->service, NULL, GF_FALSE);
}
}
/* Rewrite mode:
* mode = 0: playback
* mode = 1: streaming
*/
GF_Err gf_isom_nalu_sample_rewrite(GF_MediaBox *mdia, GF_ISOSample *sample, u32 sampleNumber, GF_MPEGVisualSampleEntryBox *entry)
{
Bool is_hevc = 0;
GF_Err e = GF_OK;
GF_ISOSample *ref_samp;
GF_BitStream *src_bs, *ref_bs, *dst_bs;
u64 offset;
u32 ref_nalu_size, data_offset, data_length, copy_size, nal_size, max_size, di, nal_unit_size_field, cur_extract_mode, extractor_mode;
Bool rewrite_ps, rewrite_start_codes;
u8 ref_track_ID, ref_track_num;
s8 sample_offset, nal_type;
u32 nal_hdr;
char *buffer;
GF_ISOFile *file = mdia->mediaTrack->moov->mov;
src_bs = ref_bs = dst_bs = NULL;
ref_samp = NULL;
buffer = NULL;
rewrite_ps = (mdia->mediaTrack->extractor_mode & GF_ISOM_NALU_EXTRACT_INBAND_PS_FLAG) ? 1 : 0;
if (! sample->IsRAP) rewrite_ps = 0;
rewrite_start_codes = (mdia->mediaTrack->extractor_mode & GF_ISOM_NALU_EXTRACT_ANNEXB_FLAG) ? 1 : 0;
extractor_mode = mdia->mediaTrack->extractor_mode&0x0000FFFF;
if (extractor_mode == GF_ISOM_NALU_EXTRACT_INSPECT) {
if (!rewrite_ps && !rewrite_start_codes)
return GF_OK;
}
if (!entry) return GF_BAD_PARAM;
nal_unit_size_field = 0;
/*if svc rewrire*/
if (entry->svc_config && entry->svc_config->config) nal_unit_size_field = entry->svc_config->config->nal_unit_size;
/*if mvc rewrire*/
/*otherwise do nothing*/
else if (!rewrite_ps && !rewrite_start_codes) {
return GF_OK;
}
if (!nal_unit_size_field) {
if (entry->avc_config) nal_unit_size_field = entry->avc_config->config->nal_unit_size;
else if (entry->hevc_config) {
nal_unit_size_field = entry->hevc_config->config->nal_unit_size;
is_hevc = 1;
}
}
if (!nal_unit_size_field) return GF_ISOM_INVALID_FILE;
dst_bs = gf_bs_new(NULL, 0, GF_BITSTREAM_WRITE);
src_bs = gf_bs_new(sample->data, sample->dataLength, GF_BITSTREAM_READ);
max_size = 4096;
/*rewrite start code with NALU delim*/
if (rewrite_start_codes) {
gf_bs_write_int(dst_bs, 1, 32);
if (is_hevc) {
gf_bs_write_int(dst_bs, 0, 1);
gf_bs_write_int(dst_bs, GF_HEVC_NALU_ACCESS_UNIT, 6);
gf_bs_write_int(dst_bs, 0, 9);
/*pic-type - by default we signal all slice types possible*/
gf_bs_write_int(dst_bs, 2, 3);
gf_bs_write_int(dst_bs, 0, 5);
} else {
gf_bs_write_int(dst_bs, (sample->data[0] & 0x60) | GF_AVC_NALU_ACCESS_UNIT, 8);
gf_bs_write_int(dst_bs, 0xF0 , 8); /*7 "all supported NALUs" (=111) + rbsp trailing (10000)*/;
}
}
if (rewrite_ps) {
if (is_hevc) {
u32 i, count;
count = gf_list_count(entry->hevc_config->config->param_array);
for (i=0; i<count; i++) {
GF_HEVCParamArray *ar = gf_list_get(entry->hevc_config->config->param_array, i);
rewrite_nalus_list(ar->nalus, dst_bs, rewrite_start_codes, nal_unit_size_field);
}
/*little optimization if we are not asked to start codes: copy over the sample*/
if (!rewrite_start_codes) {
gf_bs_write_data(dst_bs, sample->data, sample->dataLength);
gf_free(sample->data);
sample->data = NULL;
gf_bs_get_content(dst_bs, &sample->data, &sample->dataLength);
gf_bs_del(src_bs);
gf_bs_del(dst_bs);
return GF_OK;
}
} else {
/*this is an SVC track: get all SPS/PPS from this track down to the base layer and rewrite them*/
if (mdia->mediaTrack->has_base_layer) {
u32 j;
GF_List *nalu_sps = gf_list_new();
GF_List *nalu_pps = gf_list_new();
GF_TrackReferenceTypeBox *dpnd = NULL;
Track_FindRef(mdia->mediaTrack, GF_ISOM_REF_SCAL, &dpnd);
#if 0
/*get all upper layers with SCAL reference to this track*/
for (j = 0; j < gf_isom_get_track_count(file); j++) {
if (gf_isom_has_track_reference(file, j+1, GF_ISOM_REF_SCAL, mdia->mediaTrack->Header->trackID)) {
u32 tkID;
GF_TrackBox *base_track;
GF_MPEGVisualSampleEntryBox *base_entry;
gf_isom_get_reference_ID(file, j+1, GF_ISOM_REF_SCAL, 1, &tkID);
base_track = GetTrackbyID(mdia->mediaTrack->moov, tkID);
base_entry = base_track ? gf_list_get(base_track->Media->information->sampleTable->SampleDescription->other_boxes, 0) : NULL;
if (base_entry)
merge_nalus(base_entry, nalu_sps, nalu_pps);
}
}
#endif
merge_nalus(entry, nalu_sps, nalu_pps);
if (dpnd) {
for (j=0; j<dpnd->trackIDCount; j++) {
GF_TrackBox *base_track = GetTrackbyID(mdia->mediaTrack->moov, dpnd->trackIDs[j]);
GF_MPEGVisualSampleEntryBox *base_entry = base_track ? gf_list_get(base_track->Media->information->sampleTable->SampleDescription->other_boxes, 0) : NULL;
if (base_entry)
merge_nalus(base_entry, nalu_sps, nalu_pps);
}
}
//rewrite nalus
rewrite_nalus_list(nalu_sps, dst_bs, rewrite_start_codes, nal_unit_size_field);
rewrite_nalus_list(nalu_pps, dst_bs, rewrite_start_codes, nal_unit_size_field);
gf_list_del(nalu_sps);
gf_list_del(nalu_pps);
} else {
if (entry->avc_config) {
rewrite_nalus_list(entry->avc_config->config->sequenceParameterSets, dst_bs, rewrite_start_codes, nal_unit_size_field);
rewrite_nalus_list(entry->avc_config->config->pictureParameterSets, dst_bs, rewrite_start_codes, nal_unit_size_field);
rewrite_nalus_list(entry->avc_config->config->sequenceParameterSetExtensions, dst_bs, rewrite_start_codes, nal_unit_size_field);
}
/*add svc config */
if (entry->svc_config) {
rewrite_nalus_list(entry->svc_config->config->sequenceParameterSets, dst_bs, rewrite_start_codes, nal_unit_size_field);
rewrite_nalus_list(entry->svc_config->config->pictureParameterSets, dst_bs, rewrite_start_codes, nal_unit_size_field);
}
/*little optimization if we are not asked to rewrite extractors or start codes: copy over the sample*/
if (!entry->svc_config && !rewrite_start_codes) {
gf_bs_write_data(dst_bs, sample->data, sample->dataLength);
gf_free(sample->data);
sample->data = NULL;
gf_bs_get_content(dst_bs, &sample->data, &sample->dataLength);
gf_bs_del(src_bs);
gf_bs_del(dst_bs);
return GF_OK;
}
}
}
}
buffer = (char *)gf_malloc(sizeof(char)*max_size);
while (gf_bs_available(src_bs))
{
nal_size = gf_bs_read_int(src_bs, 8*nal_unit_size_field);
if (nal_size>max_size) {
buffer = (char*) gf_realloc(buffer, sizeof(char)*nal_size);
max_size = nal_size;
}
if (is_hevc) {
nal_hdr = gf_bs_read_u16(src_bs);
nal_type = (nal_hdr&0x7E00) >> 9;
} else {
nal_hdr = gf_bs_read_u8(src_bs);
nal_type = nal_hdr & 0x1F;
}
if (is_hevc) {
/*we already wrote this stuff*/
if (nal_type==GF_HEVC_NALU_ACCESS_UNIT) {
gf_bs_skip_bytes(src_bs, nal_size-2);
continue;
}
/*rewrite nal*/
gf_bs_read_data(src_bs, buffer, nal_size-2);
if (rewrite_start_codes)
gf_bs_write_u32(dst_bs, 1);
else
gf_bs_write_int(dst_bs, nal_size, 8*nal_unit_size_field);
gf_bs_write_u16(dst_bs, nal_hdr);
gf_bs_write_data(dst_bs, buffer, nal_size-2);
continue;
}
/*we already wrote this stuff*/
if (nal_type==GF_AVC_NALU_ACCESS_UNIT) {
gf_bs_skip_bytes(src_bs, nal_size-1);
continue;
}
//extractor
if (nal_type == 31) {
switch (extractor_mode) {
case 0:
gf_bs_read_int(src_bs, 24); //3 bytes of NALUHeader in extractor
ref_track_ID = gf_bs_read_u8(src_bs);
sample_offset = (s8) gf_bs_read_int(src_bs, 8);
data_offset = gf_bs_read_u32(src_bs);
data_length = gf_bs_read_u32(src_bs);
ref_track_num = gf_isom_get_track_by_id(file, ref_track_ID);
if (!ref_track_num) {
e = GF_BAD_PARAM;
goto exit;
}
cur_extract_mode = gf_isom_get_nalu_extract_mode(file, ref_track_num);
gf_isom_set_nalu_extract_mode(file, ref_track_num, GF_ISOM_NALU_EXTRACT_INSPECT);
ref_samp = gf_isom_get_sample(file, ref_track_num, sampleNumber+sample_offset, &di);
if (!ref_samp) {
e = GF_IO_ERR;
goto exit;
}
ref_bs = gf_bs_new(ref_samp->data, ref_samp->dataLength, GF_BITSTREAM_READ);
offset = 0;
while (gf_bs_available(ref_bs)) {
if (gf_bs_get_position(ref_bs) < data_offset) {
ref_nalu_size = gf_bs_read_int(ref_bs, 8*nal_unit_size_field);
offset += ref_nalu_size + nal_unit_size_field;
if ((offset > data_offset) || (offset >= gf_bs_get_size(ref_bs))) {
e = GF_BAD_PARAM;
goto exit;
}
e = gf_bs_seek(ref_bs, offset);
if (e)
goto exit;
continue;
}
ref_nalu_size = gf_bs_read_int(ref_bs, 8*nal_unit_size_field);
copy_size = data_length ? data_length : ref_nalu_size;
assert(copy_size <= ref_nalu_size);
nal_hdr = gf_bs_read_u8(ref_bs); //rewrite NAL type
if ((copy_size-1)>max_size) {
buffer = (char*)gf_realloc(buffer, sizeof(char)*(copy_size-1));
max_size = copy_size-1;
}
gf_bs_read_data(ref_bs, buffer, copy_size-1);
if (rewrite_start_codes)
gf_bs_write_u32(dst_bs, 1);
else
gf_bs_write_int(dst_bs, copy_size, 8*nal_unit_size_field);
gf_bs_write_u8(dst_bs, nal_hdr);
gf_bs_write_data(dst_bs, buffer, copy_size-1);
}
gf_isom_sample_del(&ref_samp);
ref_samp = NULL;
gf_bs_del(ref_bs);
ref_bs = NULL;
gf_isom_set_nalu_extract_mode(file, ref_track_num, cur_extract_mode);
break;
default:
//skip to end of this NALU
gf_bs_skip_bytes(src_bs, nal_size-1);
continue;
}
} else {
gf_bs_read_data(src_bs, buffer, nal_size-1);
if (rewrite_start_codes)
gf_bs_write_u32(dst_bs, 1);
else
gf_bs_write_int(dst_bs, nal_size, 8*nal_unit_size_field);
gf_bs_write_u8(dst_bs, nal_hdr);
gf_bs_write_data(dst_bs, buffer, nal_size-1);
}
}