int dc_gpac_audio_isom_close_seg(AudioOutputFile *audio_output_file)
{
GF_Err ret;
ret = gf_isom_close_segment(audio_output_file->isof, 0, 0,0, 0, 0, 0, 1, audio_output_file->seg_marker, NULL, NULL);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_close_segment\n", gf_error_to_string(ret)));
return -1;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DashCast] Audio segment closed at "LLU"\n", gf_net_get_utc() ));
//audio_output_file->acc_samples = 0;
return 0;
}
int dc_video_encoder_encode(VideoOutputFile *video_output_file, VideoScaledData *video_scaled_data)
{
//AVPacket pkt;
VideoDataNode *video_data_node;
int ret;
//int out_size;
// AVStream *video_stream = video_output_file->av_fmt_ctx->streams[video_output_file->vstream_idx];
// AVCodecContext *video_codec_ctx = video_stream->codec;
AVCodecContext *video_codec_ctx = video_output_file->codec_ctx;
//FIXME: deadlock when pressing 'q' with BigBuckBunny_640x360.m4v
ret = dc_consumer_lock(&video_output_file->consumer, &video_scaled_data->circular_buf);
if (ret < 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Video encoder got an end of buffer!\n"));
return -2;
}
if (video_scaled_data->circular_buf.size > 1)
dc_consumer_unlock_previous(&video_output_file->consumer, &video_scaled_data->circular_buf);
video_data_node = (VideoDataNode*)dc_consumer_consume(&video_output_file->consumer, &video_scaled_data->circular_buf);
/*
* Set PTS (method 1)
*/
if (!video_output_file->use_source_timing) {
video_data_node->vframe->pts = video_codec_ctx->frame_number;
}
/* Encoding video */
{
int got_packet = 0;
AVPacket pkt;
av_init_packet(&pkt);
pkt.data = video_output_file->vbuf;
pkt.size = video_output_file->vbuf_size;
pkt.pts = pkt.dts = video_data_node->vframe->pkt_dts = video_data_node->vframe->pkt_pts = video_data_node->vframe->pts;
#ifdef GPAC_USE_LIBAV
video_output_file->encoded_frame_size = avcodec_encode_video(video_codec_ctx, video_output_file->vbuf, video_output_file->vbuf_size, video_data_node->vframe);
got_packet = video_output_file->encoded_frame_size>=0 ? 1 : 0;
#else
video_output_file->encoded_frame_size = avcodec_encode_video2(video_codec_ctx, &pkt, video_data_node->vframe, &got_packet);
//this is not true with libav !
if (video_output_file->encoded_frame_size >= 0)
video_output_file->encoded_frame_size = pkt.size;
#endif
if (video_output_file->encoded_frame_size >= 0) {
if (got_packet) {
video_codec_ctx->coded_frame->pts = video_codec_ctx->coded_frame->pkt_pts = pkt.pts;
video_codec_ctx->coded_frame->pkt_dts = pkt.dts;
video_codec_ctx->coded_frame->key_frame = (pkt.flags & AV_PKT_FLAG_KEY) ? 1 : 0;
}
}
}
dc_consumer_advance(&video_output_file->consumer);
if (video_scaled_data->circular_buf.size == 1)
dc_consumer_unlock_previous(&video_output_file->consumer, &video_scaled_data->circular_buf);
if (video_output_file->encoded_frame_size < 0) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Error occured while encoding video frame.\n"));
return -1;
}
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[DashCast] Video %s Frame TS "LLU" encoded at UTC "LLU" ms\n", video_output_file->rep_id, /*video_data_node->source_number, */video_data_node->vframe->pts, gf_net_get_utc() ));
/* if zero size, it means the image was buffered */
// if (out_size > 0) {
//
// av_init_packet(&pkt);
// pkt.data = NULL;
// pkt.size = 0;
//
// if (video_codec_ctx->coded_frame->pts != AV_NOPTS_VALUE) {
// pkt.pts = av_rescale_q(video_codec_ctx->coded_frame->pts,
// video_codec_ctx->time_base, video_stream->time_base);
// }
//
//
// if (video_codec_ctx->coded_frame->key_frame)
// pkt.flags |= AV_PKT_FLAG_KEY;
//
// pkt.stream_index = video_stream->index;
// pkt.data = video_output_file->vbuf;
// pkt.size = out_size;
//
// // write the compressed frame in the media file
// if (av_interleaved_write_frame(video_output_file->av_fmt_ctx, &pkt)
// != 0) {
// GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Writing frame is not successful\n"));
// return -1;
// }
//
// av_free_packet(&pkt);
//
// }
return video_output_file->encoded_frame_size;
}
static void mpdin_dash_segment_netio(void *cbk, GF_NETIO_Parameter *param)
{
GF_MPDGroup *group = (GF_MPDGroup *)cbk;
if (param->msg_type == GF_NETIO_PARSE_HEADER) {
if (!strcmp(param->name, "Dash-Newest-Segment")) {
gf_dash_resync_to_segment(group->mpdin->dash, param->value, gf_dm_sess_get_header(param->sess, "Dash-Oldest-Segment") );
}
}
if (param->msg_type == GF_NETIO_DATA_EXCHANGE) {
group->has_new_data = 1;
if (param->reply) {
u32 bytes_per_sec;
const char *url;
gf_dm_sess_get_stats(group->sess, NULL, &url, NULL, NULL, &bytes_per_sec, NULL);
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] End of chunk received for %s at UTC "LLU" ms - estimated bandwidth %d kbps - chunk start at UTC "LLU"\n", url, gf_net_get_utc(), 8*bytes_per_sec/1000, gf_dm_sess_get_utc_start(group->sess)));
if (group->mpdin->use_low_latency)
MPD_NotifyData(group, 1);
} else if (group->mpdin->use_low_latency==2) {
MPD_NotifyData(group, 1);
}
if (group->mpdin->allow_http_abort)
gf_dash_group_check_bandwidth(group->mpdin->dash, group->idx);
}
if (param->msg_type == GF_NETIO_DATA_TRANSFERED) {
u32 bytes_per_sec;
const char *url;
gf_dm_sess_get_stats(group->sess, NULL, &url, NULL, NULL, &bytes_per_sec, NULL);
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[MPD_IN] End of file %s download at UTC "LLU" ms - estimated bandwidth %d kbps - started file or last chunk at UTC "LLU"\n", url, gf_net_get_utc(), 8*bytes_per_sec/1000, gf_dm_sess_get_utc_start(group->sess)));
}
}
int dc_video_decoder_read(VideoInputFile *video_input_file, VideoInputData *video_input_data, int source_number, int use_source_timing, int is_live_capture, const int *exit_signal_addr)
{
#ifdef DASHCAST_DEBUG_TIME_
struct timeval start, end;
long elapsed_time;
#endif
AVPacket packet;
int ret, got_frame, already_locked = 0;
AVCodecContext *codec_ctx;
VideoDataNode *video_data_node;
/* Get a pointer to the codec context for the video stream */
codec_ctx = video_input_file->av_fmt_ctx->streams[video_input_file->vstream_idx]->codec;
/* Read frames */
while (1) {
#ifdef DASHCAST_DEBUG_TIME_
gf_gettimeofday(&start, NULL);
#endif
memset(&packet, 0, sizeof(AVPacket));
ret = av_read_frame(video_input_file->av_fmt_ctx, &packet);
#ifdef DASHCAST_DEBUG_TIME_
gf_gettimeofday(&end, NULL);
elapsed_time = (end.tv_sec * 1000000 + end.tv_usec) - (start.tv_sec * 1000000 + start.tv_usec);
fprintf(stdout, "fps: %f\n", 1000000.0/elapsed_time);
#endif
/* If we demux for the audio thread, send the packet to the audio */
if (video_input_file->av_fmt_ctx_ref_cnt && ((packet.stream_index != video_input_file->vstream_idx) || (ret == AVERROR_EOF))) {
AVPacket *packet_copy = NULL;
if (ret != AVERROR_EOF) {
GF_SAFEALLOC(packet_copy, AVPacket);
memcpy(packet_copy, &packet, sizeof(AVPacket));
}
assert(video_input_file->av_pkt_list);
gf_mx_p(video_input_file->av_pkt_list_mutex);
gf_list_add(video_input_file->av_pkt_list, packet_copy);
gf_mx_v(video_input_file->av_pkt_list_mutex);
if (ret != AVERROR_EOF) {
continue;
}
}
if (ret == AVERROR_EOF) {
if (video_input_file->mode == LIVE_MEDIA && video_input_file->no_loop == 0) {
av_seek_frame(video_input_file->av_fmt_ctx, video_input_file->vstream_idx, 0, 0);
av_free_packet(&packet);
continue;
}
dc_producer_lock(&video_input_data->producer, &video_input_data->circular_buf);
dc_producer_unlock_previous(&video_input_data->producer, &video_input_data->circular_buf);
video_data_node = (VideoDataNode *) dc_producer_produce(&video_input_data->producer, &video_input_data->circular_buf);
video_data_node->source_number = source_number;
/* Flush decoder */
memset(&packet, 0, sizeof(AVPacket));
#ifndef FF_API_AVFRAME_LAVC
avcodec_get_frame_defaults(video_data_node->vframe);
#else
av_frame_unref(video_data_node->vframe);
#endif
avcodec_decode_video2(codec_ctx, video_data_node->vframe, &got_frame, &packet);
if (got_frame) {
dc_producer_advance(&video_input_data->producer, &video_input_data->circular_buf);
return 0;
}
dc_producer_end_signal(&video_input_data->producer, &video_input_data->circular_buf);
dc_producer_unlock(&video_input_data->producer, &video_input_data->circular_buf);
return -2;
}
else if (ret < 0)
{
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Cannot read video frame.\n"));
continue;
}
/* Is this a packet from the video stream? */
if (packet.stream_index == video_input_file->vstream_idx) {
u32 nb_retry = 10;
while (!already_locked) {
if (dc_producer_lock(&video_input_data->producer, &video_input_data->circular_buf) < 0) {
if (!nb_retry) break;
gf_sleep(10);
nb_retry--;
continue;
}
dc_producer_unlock_previous(&video_input_data->producer, &video_input_data->circular_buf);
already_locked = 1;
}
if (!already_locked) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("[dashcast] Live system dropped a video frame\n"));
continue;
}
video_data_node = (VideoDataNode *) dc_producer_produce(&video_input_data->producer, &video_input_data->circular_buf);
video_data_node->source_number = source_number;
/* Set video frame to default */
#ifndef FF_API_AVFRAME_LAVC
avcodec_get_frame_defaults(video_data_node->vframe);
#else
av_frame_unref(video_data_node->vframe);
#endif
/* Decode video frame */
if (avcodec_decode_video2(codec_ctx, video_data_node->vframe, &got_frame, &packet) < 0) {
av_free_packet(&packet);
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Error while decoding video.\n"));
dc_producer_end_signal(&video_input_data->producer, &video_input_data->circular_buf);
dc_producer_unlock(&video_input_data->producer, &video_input_data->circular_buf);
return -1;
}
/* Did we get a video frame? */
if (got_frame) {
if (use_source_timing && is_live_capture) {
u64 pts;
if (video_input_file->pts_init == 0) {
video_input_file->pts_init = 1;
video_input_file->utc_at_init = gf_net_get_utc();
video_input_file->first_pts = packet.pts;
video_input_file->prev_pts = 0;
video_input_data->frame_duration = 0;
}
if (video_input_file->pts_init && (video_input_file->pts_init!=3) ) {
if (packet.pts==AV_NOPTS_VALUE) {
video_input_file->pts_init=1;
} else if (video_input_file->pts_init==1) {
video_input_file->pts_init=2;
video_input_file->pts_dur_estimate = packet.pts;
} else if (video_input_file->pts_init==2) {
video_input_file->pts_init=3;
video_input_data->frame_duration = packet.pts - video_input_file->pts_dur_estimate;
video_input_file->sync_tolerance = 9*video_input_data->frame_duration/5;
//TODO - check with audio if sync is OK
}
}
//move to 0-based PTS
if (packet.pts!=AV_NOPTS_VALUE) {
pts = packet.pts - video_input_file->first_pts;
} else {
pts = video_input_file->prev_pts + video_input_data->frame_duration;
}
//check for drop frames
#ifndef GPAC_DISABLE_LOG
if (0 && gf_log_tool_level_on(GF_LOG_DASH, GF_LOG_WARNING)) {
if (pts - video_input_file->prev_pts > video_input_file->sync_tolerance) {
u32 nb_lost=0;
while (video_input_file->prev_pts + video_input_data->frame_duration + video_input_file->sync_tolerance < pts) {
video_input_file->prev_pts += video_input_data->frame_duration;
nb_lost++;
}
if (nb_lost) {
GF_LOG(GF_LOG_WARNING, GF_LOG_DASH, ("[DashCast] Capture lost %d video frames \n", nb_lost));
}
}
}
#endif
video_input_file->prev_pts = pts;
video_data_node->vframe->pts = pts;
}
if (video_data_node->vframe->pts==AV_NOPTS_VALUE) {
if (!use_source_timing) {
video_data_node->vframe->pts = video_input_file->frame_decoded;
} else {
video_data_node->vframe->pts = video_data_node->vframe->pkt_pts;
}
}
video_input_file->frame_decoded++;
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DashCast] Video Frame TS "LLU" decoded at UTC "LLU" ms\n", video_data_node->vframe->pts, gf_net_get_utc() ));
// For a decode/encode process we must free this memory.
//But if the input is raw and there is no need to decode then
// the packet is directly passed for decoded frame. We must wait until rescale is done before freeing it
if (codec_ctx->codec->id == CODEC_ID_RAWVIDEO) {
video_data_node->nb_raw_frames_ref = video_input_file->nb_consumers;
video_data_node->raw_packet = packet;
dc_producer_advance(&video_input_data->producer, &video_input_data->circular_buf);
while (video_data_node->nb_raw_frames_ref && ! *exit_signal_addr) {
gf_sleep(0);
}
} else {
dc_producer_advance(&video_input_data->producer, &video_input_data->circular_buf);
av_free_packet(&packet);
}
return 0;
}
}
/* Free the packet that was allocated by av_read_frame */
av_free_packet(&packet);
}
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("Unknown error while reading video frame.\n"));
return -1;
}
int dc_audio_muxer_write(AudioOutputFile *audio_output_file, int frame_nb, Bool insert_ntp)
{
switch (audio_output_file->muxer_type) {
case FFMPEG_AUDIO_MUXER:
return dc_ffmpeg_audio_muxer_write(audio_output_file);
#ifndef GPAC_DISABLE_ISOM
case GPAC_AUDIO_MUXER:
case GPAC_INIT_AUDIO_MUXER:
if (frame_nb % audio_output_file->frame_per_frag == 0) {
gf_isom_start_fragment(audio_output_file->isof, 1);
if (insert_ntp) {
gf_isom_set_fragment_reference_time(audio_output_file->isof, 1, audio_output_file->frame_ntp, audio_output_file->first_dts * audio_output_file->codec_ctx->frame_size);
}
gf_isom_set_traf_base_media_decode_time(audio_output_file->isof, 1, audio_output_file->first_dts * audio_output_file->codec_ctx->frame_size);
audio_output_file->first_dts += audio_output_file->frame_per_frag;
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DashCast] Audio start fragment first DTS %d at "LLU"\n", audio_output_file->first_dts, gf_net_get_utc() ));
}
dc_gpac_audio_isom_write(audio_output_file);
if (frame_nb % audio_output_file->frame_per_frag == audio_output_file->frame_per_frag - 1) {
gf_isom_flush_fragments(audio_output_file->isof, 1);
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DashCast] Audio flush fragment first DTS %d at "LLU"\n", audio_output_file->first_dts, gf_net_get_utc() ));
}
//TODO - do same as video, flush based on time in case of losses
if (frame_nb + 1 == audio_output_file->frame_per_seg) {
return 1;
}
return 0;
#endif
default:
return GF_BAD_PARAM;
}
return GF_BAD_PARAM;
}
int dc_gpac_audio_isom_open_seg(AudioOutputFile *audio_output_file, char *filename)
{
GF_Err ret;
ret = gf_isom_start_segment(audio_output_file->isof, filename, GF_TRUE);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_start_segment\n", gf_error_to_string(ret)));
return -1;
}
GF_LOG(GF_LOG_DEBUG, GF_LOG_DASH, ("[DashCast] Audio segment %s started at "LLU"\n", filename, gf_net_get_utc() ));
audio_output_file->dts = 0;
return 0;
}
int dc_video_muxer_write(VideoOutputFile *video_output_file, int frame_nb, Bool insert_utc)
{
u64 frame_dur;
GF_Err ret;
switch (video_output_file->muxer_type) {
case FFMPEG_VIDEO_MUXER:
return dc_ffmpeg_video_muxer_write(video_output_file);
case RAW_VIDEO_H264:
return dc_raw_h264_write(video_output_file);
case GPAC_VIDEO_MUXER:
case GPAC_INIT_VIDEO_MUXER_AVC1:
case GPAC_INIT_VIDEO_MUXER_AVC3:
if (video_output_file->use_source_timing) {
if (!video_output_file->fragment_started) {
video_output_file->fragment_started = 1;
ret = gf_isom_start_fragment(video_output_file->isof, 1);
if (ret < 0)
return -1;
video_output_file->first_dts = video_output_file->codec_ctx->coded_frame->pkt_dts;
if (!video_output_file->segment_started) {
u32 sec, frac;
u64 ntpts;
video_output_file->pts_at_segment_start = video_output_file->codec_ctx->coded_frame->pts;
video_output_file->segment_started = 1;
if (insert_utc) {
gf_net_get_ntp(&sec, &frac);
ntpts = sec;
ntpts <<= 32;
ntpts |= frac;
gf_isom_set_fragment_reference_time(video_output_file->isof, video_output_file->trackID, ntpts, video_output_file->pts_at_segment_start);
}
}
gf_isom_set_traf_base_media_decode_time(video_output_file->isof, video_output_file->trackID, video_output_file->first_dts);
}
//keep track of previous frame dur and use last dur as the default duration for next sample
//this works fine because we perform frame rate regulation at the capture stage
frame_dur = video_output_file->codec_ctx->coded_frame->pts - video_output_file->last_pts;
if (frame_dur && (video_output_file->frame_dur>(u32) frame_dur)) {
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("New frame dur detected: %d vs %d old\n", (u32) frame_dur, (u32) video_output_file->frame_dur));
video_output_file->frame_dur = (u32)frame_dur;
}
if (dc_gpac_video_isom_write(video_output_file) < 0) {
return -1;
}
video_output_file->last_pts = video_output_file->codec_ctx->coded_frame->pts;
video_output_file->last_dts = video_output_file->codec_ctx->coded_frame->pkt_dts;
if (( video_output_file->last_dts - video_output_file->first_dts + video_output_file->frame_dur) /video_output_file->timescale >= video_output_file->frag_dur / 1000) {
gf_isom_flush_fragments(video_output_file->isof, 1);
video_output_file->fragment_started = 0;
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[DashCast] Flushed fragment to disk at UTC "LLU" ms - last coded frame PTS %d\n", gf_net_get_utc(), video_output_file->codec_ctx->coded_frame->pts));
}
//we may have rounding errors on the input PTS :( add half frame dur safety
if (1000 * ( video_output_file->last_pts - video_output_file->pts_at_segment_start + 3*video_output_file->frame_dur/2) /video_output_file->timescale >= video_output_file->seg_dur ) {
return 1;
}
return 0;
}
if (frame_nb % video_output_file->frame_per_fragment == 0) {
gf_isom_start_fragment(video_output_file->isof, 1);
if (!video_output_file->segment_started) {
u32 sec, frac;
u64 ntpts;
video_output_file->pts_at_segment_start = video_output_file->codec_ctx->coded_frame->pts;
video_output_file->segment_started = 1;
if (insert_utc) {
time_t secs;
struct tm t;
gf_net_get_ntp(&sec, &frac);
ntpts = sec;
ntpts <<= 32;
ntpts |= frac;
gf_isom_set_fragment_reference_time(video_output_file->isof, video_output_file->trackID, ntpts, video_output_file->pts_at_segment_start);
secs = sec - GF_NTP_SEC_1900_TO_1970;
t = *gmtime(&secs);
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[DashCast] Producer reference clock: Timestamp %d matches sender NTP time %d-%02d-%02dT%02d:%02d:%02dZ (NTP frac part %u) \n", (u32) video_output_file->pts_at_segment_start, 1900+t.tm_year, t.tm_mon+1, t.tm_mday, t.tm_hour, t.tm_min, t.tm_sec, (u32) frac ));
}
}
gf_isom_set_traf_base_media_decode_time(video_output_file->isof, video_output_file->trackID, video_output_file->first_dts);
video_output_file->first_dts += video_output_file->frame_per_fragment;
}
dc_gpac_video_isom_write(video_output_file);
if (frame_nb % video_output_file->frame_per_fragment == video_output_file->frame_per_fragment - 1) {
gf_isom_flush_fragments(video_output_file->isof, 1);
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[DashCast] Flushed fragment to disk at UTC "LLU" ms - last coded frame PTS %d\n", gf_net_get_utc(), video_output_file->codec_ctx->coded_frame->pts));
}
if (frame_nb + 1 == video_output_file->frame_per_segment)
return 1;
return 0;
default:
return -2;
}
return -2;
}
int dc_gpac_video_isom_close_seg(VideoOutputFile *video_output_file)
{
GF_Err ret;
ret = gf_isom_close_segment(video_output_file->isof, 0, 0, 0, 0, 0, 0, 1, video_output_file->seg_marker, NULL, NULL);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_close_segment\n", gf_error_to_string(ret)));
return -1;
}
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[DashCast] Rep %s Closing segment at UTC "LLU" ms\n", video_output_file->rep_id, gf_net_get_utc() ));
return 0;
}
int dc_gpac_video_isom_open_seg(VideoOutputFile *video_output_file, char *filename)
{
GF_Err ret;
ret = gf_isom_start_segment(video_output_file->isof, filename, 1);
if (ret != GF_OK) {
GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_start_segment\n", gf_error_to_string(ret)));
return -1;
}
// ret = gf_isom_set_traf_base_media_decode_time(video_output_file->isof, 1,
// video_output_file->first_dts);
// if (ret != GF_OK) {
// GF_LOG(GF_LOG_ERROR, GF_LOG_DASH, ("%s: gf_isom_set_traf_base_media_decode_time\n", gf_error_to_string(ret)));
// return -1;
// }
//
// video_output_file->first_dts += video_output_file->frame_per_segment;
GF_LOG(GF_LOG_INFO, GF_LOG_DASH, ("[DashCast] Opening new segment %s at UTC "LLU" ms\n", filename, gf_net_get_utc() ));
return 0;
}
