/*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;
}
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;
}
GF_EXPORT
GF_Err gf_isom_streamer_send_next_packet(GF_ISOMRTPStreamer *streamer, s32 send_ahead_delay, s32 max_sleep_time)
{
GF_Err e = GF_OK;
GF_RTPTrack *track, *to_send;
u32 time, duration;
s32 diff;
u64 min_ts, dts, cts;
if (!streamer) return GF_BAD_PARAM;
/*browse all sessions and locate most mature stream*/
to_send = NULL;
min_ts = (u64) -1;
time = gf_sys_clock();
/*init session timeline - all sessions are sync'ed for packet scheduling purposes*/
if (!streamer->timelineOrigin) {
streamer->timelineOrigin = time*1000;
GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("[FileStreamer] RTP session %s initialized - time origin set to %d\n", gf_isom_get_filename(streamer->isom), time));
}
track = streamer->stream;
while (track) {
/*load next AU*/
gf_isom_set_nalu_extract_mode(streamer->isom, track->track_num, GF_ISOM_NALU_EXTRACT_LAYER_ONLY);
if (!track->au) {
if (track->current_au >= track->nb_aus) {
Double scale;
if (!streamer->loop) {
track = track->next;
continue;
}
/*increment ts offset*/
scale = track->timescale/1000.0;
track->ts_offset += (u32) (streamer->duration_ms * scale);
track->microsec_ts_offset = (u32) (track->ts_offset*(1000000.0/track->timescale)) + streamer->timelineOrigin;
track->current_au = 0;
}
track->au = gf_isom_get_sample(streamer->isom, track->track_num, track->current_au + 1, &track->sample_desc_index);
track->current_au ++;
if (track->au) {
track->microsec_dts = (u64) (track->microsec_ts_scale * (s64) (track->au->DTS)) + track->microsec_ts_offset + streamer->timelineOrigin;
}
}
/*check timing*/
if (track->au) {
if (min_ts > track->microsec_dts) {
min_ts = track->microsec_dts;
to_send = track;
}
}
track = track->next;
}
/*no input data ...*/
if( !to_send) return GF_EOS;
/*we are about to send scalable base: trigger RTCP reports with the same NTP. This avoids
NTP drift due to system clock precision which could break sync decoding*/
if (!streamer->first_RTCP_sent || (streamer->base_track && streamer->base_track==to_send->track_num)) {
u32 ntp_sec, ntp_frac;
/*force sending RTCP SR every RAP ? - not really compliant but we cannot perform scalable tuning otherwise*/
u32 ntp_type = to_send->au->IsRAP ? 2 : 1;
gf_net_get_ntp(&ntp_sec, &ntp_frac);
track = streamer->stream;
while (track) {
u32 ts = (u32) (track->au->DTS + track->au->CTS_Offset + track->ts_offset);
gf_rtp_streamer_send_rtcp(track->rtp, GF_TRUE, ts, ntp_type, ntp_sec, ntp_frac);
track = track->next;
}
streamer->first_RTCP_sent = 1;
}
min_ts /= 1000;
if (max_sleep_time) {
diff = ((u32) min_ts) - gf_sys_clock();
if (diff>max_sleep_time)
return GF_OK;
}
/*sleep until TS is mature*/
while (1) {
diff = ((u32) min_ts) - gf_sys_clock();
if (diff > send_ahead_delay) {
gf_sleep(1);
} else {
if (diff<10) {
GF_LOG(GF_LOG_DEBUG, GF_LOG_RTP, ("WARNING: RTP session %s stream %d - sending packet %d ms too late\n", gf_isom_get_filename(streamer->isom), to_send->track_num, -diff));
}
break;
}
}
/*send packets*/
dts = to_send->au->DTS + to_send->ts_offset;
cts = to_send->au->DTS + to_send->au->CTS_Offset + to_send->ts_offset;
duration = gf_isom_get_sample_duration(streamer->isom, to_send->track_num, to_send->current_au);
GF_LOG(GF_LOG_INFO, GF_LOG_RTP, ("[FileStreamer] Sending RTP packets for track %d AU %d/%d DTS "LLU" - CTS "LLU" - RTP TS "LLU" - size %d - RAP %d\n", to_send->track_num, to_send->current_au, to_send->nb_aus, to_send->au->DTS, to_send->au->DTS+to_send->au->CTS_Offset, cts, to_send->au->dataLength, to_send->au->IsRAP ) );
/*unpack nal units*/
if (to_send->avc_nalu_size) {
Bool au_start, au_end;
u32 v, size;
u32 remain = to_send->au->dataLength;
char *ptr = to_send->au->data;
au_start = 1;
au_end = 0;
while (remain) {
size = 0;
v = to_send->avc_nalu_size;
while (v) {
size |= (u8) *ptr;
ptr++;
remain--;
v-=1;
if (v) size<<=8;
}
if (remain < size) {
GF_LOG(GF_LOG_ERROR, GF_LOG_RTP, ("[rtp hinter] Broken AVC nalu encapsulation: NALU size is %d but only %d bytes left in sample %d\n", size, remain, to_send->current_au));
break;
}
remain -= size;
au_end = remain ? 0 : 1;
e = gf_rtp_streamer_send_data(to_send->rtp, ptr, size, to_send->au->dataLength, cts, dts, (to_send->au->IsRAP==RAP) ? 1 : 0, au_start, au_end, to_send->current_au, duration, to_send->sample_desc_index);
ptr += size;
au_start = 0;
}
} else {
e = gf_rtp_streamer_send_data(to_send->rtp, to_send->au->data, to_send->au->dataLength, to_send->au->dataLength, cts, dts, (to_send->au->IsRAP==RAP) ? 1 : 0, 1, 1, to_send->current_au, duration, to_send->sample_desc_index);
}
/*delete sample*/
gf_isom_sample_del(&to_send->au);
return e;
}
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 = GF_FALSE;
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 = (char *)strrchr(url, '.');
if (track_id) {
track_id = (char *)strchr(url, '#');
if (track_id) track_id ++;
}
is_esd_url = GF_TRUE;
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;
ch->track_id = gf_isom_get_track_id(read->mov, ch->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;
case GF_ISOM_MEDIA_VISUAL:
gf_isom_get_reference(ch->owner->mov, ch->track, GF_ISOM_REF_BASE, 1, &ch->base_track);
ch->next_track = 0;
/*in scalable mode add SPS/PPS in-band*/
ch->nalu_extract_mode = GF_ISOM_NALU_EXTRACT_INBAND_PS_FLAG /*| GF_ISOM_NALU_EXTRACT_ANNEXB_FLAG*/;
gf_isom_set_nalu_extract_mode(ch->owner->mov, ch->track, ch->nalu_extract_mode);
break;
}
ch->has_edit_list = gf_isom_get_edit_list_type(ch->owner->mov, ch->track, &ch->dts_offset) ? GF_TRUE : GF_FALSE;
ch->has_rap = (gf_isom_has_sync_points(ch->owner->mov, ch->track)==1) ? GF_TRUE : GF_FALSE;
ch->time_scale = gf_isom_get_media_timescale(ch->owner->mov, ch->track);
exit:
if (read->input->query_proxy && read->input->proxy_udta && read->input->proxy_type) {
send_proxy_command(read, GF_FALSE, GF_FALSE, e, NULL, channel);
} else {
gf_service_connect_ack(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;
}
if (read->input->query_proxy && read->input->proxy_udta) {
read->input->query_proxy(read->input, &com);
} else {
gf_service_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 = GF_TRUE;
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);
if (read->input->query_proxy && read->input->proxy_udta) {
read->input->query_proxy(read->input, &com);
} else {
gf_service_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);
if (read->input->query_proxy && read->input->proxy_udta) {
read->input->query_proxy(read->input, &com);
} else {
gf_service_command(read->service, &com, GF_OK);
}
} else if (gf_isom_is_cenc_media(read->mov, track, 1)) {
ch->is_cenc = GF_TRUE;
isor_send_cenc_config(ch);
}
}
return e;
}
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;
}
/* 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);
}
}
