#include "config.h"

#include <ctype.h>

#include <string.h>

#include <math.h>

#include <stdlib.h>

#include <errno.h>

#include <limits.h>

#include <stdint.h>

#if HAVE_ISATTY

#if HAVE_IO_H

#include <io.h>

#if HAVE_UNISTD_H

#include <unistd.h>

#include "libavformat/avformat.h"

#include "libavdevice/avdevice.h"

#include "libswresample/swresample.h"

#include "libavutil/opt.h"

#include "libavutil/channel_layout.h"

#include "libavutil/parseutils.h"

#include "libavutil/samplefmt.h"

#include "libavutil/fifo.h"

#include "libavutil/intreadwrite.h"

#include "libavutil/dict.h"

#include "libavutil/mathematics.h"

#include "libavutil/pixdesc.h"

#include "libavutil/avstring.h"

#include "libavutil/libm.h"

#include "libavutil/imgutils.h"

#include "libavutil/timestamp.h"

#include "libavutil/bprint.h"

#include "libavutil/time.h"

#include "libavutil/threadmessage.h"

#include "libavformat/os_support.h"

#include "libavformat/ffm.h" // not public API

# include "libavfilter/avcodec.h"

# include "libavfilter/avfilter.h"

# include "libavfilter/buffersrc.h"

# include "libavfilter/buffersink.h"

#if HAVE_SYS_RESOURCE_H

#include <sys/time.h>

#include <sys/types.h>

#include <sys/resource.h>

#elif HAVE_GETPROCESSTIMES

#include <windows.h>

#if HAVE_GETPROCESSMEMORYINFO

#include <windows.h>

#include <psapi.h>

#if HAVE_SYS_SELECT_H

#include <sys/select.h>

#if HAVE_TERMIOS_H

#include <fcntl.h>

#include <sys/ioctl.h>

#include <sys/time.h>

#include <termios.h>

#elif HAVE_KBHIT

#include <conio.h>

#if HAVE_PTHREADS

#include <pthread.h>

#include <time.h>

#include "ffmpeg.h"

#include "cmdutils.h"

#include "libavutil/avassert.h"

const char program_name[] = "ffmpeg";

const int program_birth_year = 2000;

static FILE *vstats_file;

const char *const forced_keyframes_const_names[] = {

"n",

"n_forced",

"prev_forced_n",

"prev_forced_t",

"t",

NULL

};

static void do_video_stats(OutputStream *ost, int frame_size);

static int64_t getutime(void);

static int64_t getmaxrss(void);

static int run_as_daemon = 0;

static int nb_frames_dup = 0;

static int nb_frames_drop = 0;

static int64_t decode_error_stat[2];

static int current_time;

AVIOContext *progress_avio = NULL;

static uint8_t *subtitle_out;

#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"

InputStream **input_streams = NULL;

int nb_input_streams = 0;

InputFile **input_files = NULL;

int nb_input_files = 0;

OutputStream **output_streams = NULL;

int nb_output_streams = 0;

OutputFile **output_files = NULL;

int nb_output_files = 0;

FilterGraph **filtergraphs;

int nb_filtergraphs;

#if HAVE_TERMIOS_H

static struct termios oldtty;

static int restore_tty;

static void free_input_threads(void);

static int sub2video_get_blank_frame(InputStream *ist)

{

int ret;

AVFrame *frame = ist->sub2video.frame;

av_frame_unref(frame);

ist->sub2video.frame->width = ist->sub2video.w;

ist->sub2video.frame->height = ist->sub2video.h;

ist->sub2video.frame->format = AV_PIX_FMT_RGB32;

if ((ret = av_frame_get_buffer(frame, 32)) < 0)

return ret;

memset(frame->data[0], 0, frame->height * frame->linesize[0]);

return 0;

}

static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,

AVSubtitleRect *r)

{

uint32_t *pal, *dst2;

uint8_t *src, *src2;

int x, y;

if (r->type != SUBTITLE_BITMAP) {

av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");

return;

}

if (r->x < 0 || r->x + r->w > w || r->y < 0 || r->y + r->h > h) {

av_log(NULL, AV_LOG_WARNING, "sub2video: rectangle overflowing\n");

return;

}

dst += r->y * dst_linesize + r->x * 4;

src = r->pict.data[0];

pal = (uint32_t *)r->pict.data[1];

for (y = 0; y < r->h; y++) {

dst2 = (uint32_t *)dst;

src2 = src;

for (x = 0; x < r->w; x++)

*(dst2++) = pal[*(src2++)];

dst += dst_linesize;

src += r->pict.linesize[0];

}

}

static void sub2video_push_ref(InputStream *ist, int64_t pts)

{

AVFrame *frame = ist->sub2video.frame;

int i;

av_assert1(frame->data[0]);

ist->sub2video.last_pts = frame->pts = pts;

for (i = 0; i < ist->nb_filters; i++)

av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,

AV_BUFFERSRC_FLAG_KEEP_REF |

AV_BUFFERSRC_FLAG_PUSH);

}

static void sub2video_update(InputStream *ist, AVSubtitle *sub)

{

int w = ist->sub2video.w, h = ist->sub2video.h;

AVFrame *frame = ist->sub2video.frame;

int8_t *dst;

int dst_linesize;

int num_rects, i;

int64_t pts, end_pts;

if (!frame)

return;

if (sub) {

pts = av_rescale_q(sub->pts + sub->start_display_time * 1000LL,

AV_TIME_BASE_Q, ist->st->time_base);

end_pts = av_rescale_q(sub->pts + sub->end_display_time * 1000LL,

AV_TIME_BASE_Q, ist->st->time_base);

num_rects = sub->num_rects;

} else {

pts = ist->sub2video.end_pts;

end_pts = INT64_MAX;

num_rects = 0;

}

if (sub2video_get_blank_frame(ist) < 0) {

av_log(ist->dec_ctx, AV_LOG_ERROR,

"Impossible to get a blank canvas.\n");

return;

}

dst = frame->data [0];

dst_linesize = frame->linesize[0];

for (i = 0; i < num_rects; i++)

sub2video_copy_rect(dst, dst_linesize, w, h, sub->rects[i]);

sub2video_push_ref(ist, pts);

ist->sub2video.end_pts = end_pts;

}

static void sub2video_heartbeat(InputStream *ist, int64_t pts)

{

InputFile *infile = input_files[ist->file_index];

int i, j, nb_reqs;

int64_t pts2;

/* When a frame is read from a file, examine all sub2video streams in

for (i = 0; i < infile->nb_streams; i++) {

InputStream *ist2 = input_streams[infile->ist_index + i];

if (!ist2->sub2video.frame)

continue;

/* subtitles seem to be usually muxed ahead of other streams;

pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;

/* do not send the heartbeat frame if the subtitle is already ahead */

if (pts2 <= ist2->sub2video.last_pts)

continue;

if (pts2 >= ist2->sub2video.end_pts || !ist2->sub2video.frame->data[0])

sub2video_update(ist2, NULL);

for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)

nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);

if (nb_reqs)

sub2video_push_ref(ist2, pts2);

}

}

static void sub2video_flush(InputStream *ist)

{

int i;

if (ist->sub2video.end_pts < INT64_MAX)

sub2video_update(ist, NULL);

for (i = 0; i < ist->nb_filters; i++)

av_buffersrc_add_ref(ist->filters[i]->filter, NULL, 0);

}

static void term_exit_sigsafe(void)

{

#if HAVE_TERMIOS_H

if(restore_tty)

tcsetattr (0, TCSANOW, &oldtty);

}

void term_exit(void)

{

av_log(NULL, AV_LOG_QUIET, "%s", "");

term_exit_sigsafe();

}

static volatile int received_sigterm = 0;

static volatile int received_nb_signals = 0;

static volatile int transcode_init_done = 0;

static int main_return_code = 0;

static void

sigterm_handler(int sig)

{

received_sigterm = sig;

received_nb_signals++;

term_exit_sigsafe();

if(received_nb_signals > 3)

exit(123);

}

void term_init(void)

{

#if HAVE_TERMIOS_H

if(!run_as_daemon){

struct termios tty;

int istty = 1;

#if HAVE_ISATTY

istty = isatty(0) && isatty(2);

if (istty && tcgetattr (0, &tty) == 0) {

oldtty = tty;

restore_tty = 1;

tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP

|INLCR|IGNCR|ICRNL|IXON);

tty.c_oflag |= OPOST;

tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);

tty.c_cflag &= ~(CSIZE|PARENB);

tty.c_cflag |= CS8;

tty.c_cc[VMIN] = 1;

tty.c_cc[VTIME] = 0;

tcsetattr (0, TCSANOW, &tty);

}

signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */

}

avformat_network_deinit();

signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */

signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */

#ifdef SIGXCPU

signal(SIGXCPU, sigterm_handler);

}

static int read_key(void)

{

unsigned char ch;

#if HAVE_TERMIOS_H

int n = 1;

struct timeval tv;

fd_set rfds;

FD_ZERO(&rfds);

FD_SET(0, &rfds);

tv.tv_sec = 0;

tv.tv_usec = 0;

n = select(1, &rfds, NULL, NULL, &tv);

if (n > 0) {

n = read(0, &ch, 1);

if (n == 1)

return ch;

return n;

}

#elif HAVE_KBHIT

# if HAVE_PEEKNAMEDPIPE

static int is_pipe;

static HANDLE input_handle;

DWORD dw, nchars;

if(!input_handle){

input_handle = GetStdHandle(STD_INPUT_HANDLE);

is_pipe = !GetConsoleMode(input_handle, &dw);

}

if (stdin->_cnt > 0) {

read(0, &ch, 1);

return ch;

}

if (is_pipe) {

/* When running under a GUI, you will end here. */

if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {

// input pipe may have been closed by the program that ran ffmpeg

return -1;

}

//Read it

if(nchars != 0) {

read(0, &ch, 1);

return ch;

}else{

return -1;

}

}

if(kbhit())

return(getch());

return -1;

}

static int decode_interrupt_cb(void *ctx)

{

return received_nb_signals > transcode_init_done;

}

const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };

static void ffmpeg_cleanup(int ret)

{

int i, j;

if (do_benchmark) {

int maxrss = getmaxrss() / 1024;

printf("bench: maxrss=%ikB\n", maxrss);

}

for (i = 0; i < nb_filtergraphs; i++) {

FilterGraph *fg = filtergraphs[i];

avfilter_graph_free(&fg->graph);

for (j = 0; j < fg->nb_inputs; j++) {

av_freep(&fg->inputs[j]->name);

av_freep(&fg->inputs[j]);

}

av_freep(&fg->inputs);

for (j = 0; j < fg->nb_outputs; j++) {

av_freep(&fg->outputs[j]->name);

av_freep(&fg->outputs[j]);

}

av_freep(&fg->outputs);

av_freep(&fg->graph_desc);

av_freep(&filtergraphs[i]);

}

av_freep(&filtergraphs);

av_freep(&subtitle_out);

/* close files */

for (i = 0; i < nb_output_files; i++) {

OutputFile *of = output_files[i];

AVFormatContext *s = of->ctx;

if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE))

avio_closep(&s->pb);

avformat_free_context(s);

av_dict_free(&of->opts);

av_freep(&output_files[i]);

}

for (i = 0; i < nb_output_streams; i++) {

OutputStream *ost = output_streams[i];

AVBitStreamFilterContext *bsfc = ost->bitstream_filters;

while (bsfc) {

AVBitStreamFilterContext *next = bsfc->next;

av_bitstream_filter_close(bsfc);

bsfc = next;

}

ost->bitstream_filters = NULL;

av_frame_free(&ost->filtered_frame);

av_frame_free(&ost->last_frame);

av_parser_close(ost->parser);

av_freep(&ost->forced_keyframes);

av_expr_free(ost->forced_keyframes_pexpr);

av_freep(&ost->avfilter);

av_freep(&ost->logfile_prefix);

av_freep(&ost->audio_channels_map);

ost->audio_channels_mapped = 0;

avcodec_free_context(&ost->enc_ctx);

av_freep(&output_streams[i]);

}

#if HAVE_PTHREADS

free_input_threads();

for (i = 0; i < nb_input_files; i++) {

avformat_close_input(&input_files[i]->ctx);

av_freep(&input_files[i]);

}

for (i = 0; i < nb_input_streams; i++) {

InputStream *ist = input_streams[i];

av_frame_free(&ist->decoded_frame);

av_frame_free(&ist->filter_frame);

av_dict_free(&ist->decoder_opts);

avsubtitle_free(&ist->prev_sub.subtitle);

av_frame_free(&ist->sub2video.frame);

av_freep(&ist->filters);

av_freep(&ist->hwaccel_device);

avcodec_free_context(&ist->dec_ctx);

av_freep(&input_streams[i]);

}

if (vstats_file)

fclose(vstats_file);

av_freep(&vstats_filename);

av_freep(&input_streams);

av_freep(&input_files);

av_freep(&output_streams);

av_freep(&output_files);

uninit_opts();

avformat_network_deinit();

if (received_sigterm) {

av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",

(int) received_sigterm);

} else if (ret && transcode_init_done) {

av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");

}

term_exit();

}

void remove_avoptions(AVDictionary **a, AVDictionary *b)

{

AVDictionaryEntry *t = NULL;

while ((t = av_dict_get(b, "", t, AV_DICT_IGNORE_SUFFIX))) {

av_dict_set(a, t->key, NULL, AV_DICT_MATCH_CASE);

}

}

void assert_avoptions(AVDictionary *m)

{

AVDictionaryEntry *t;

if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {

av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);

exit_program(1);

}

}

static void abort_codec_experimental(AVCodec *c, int encoder)

{

exit_program(1);

}

static void update_benchmark(const char *fmt, ...)

{

if (do_benchmark_all) {

int64_t t = getutime();

va_list va;

char buf[1024];

if (fmt) {

va_start(va, fmt);

vsnprintf(buf, sizeof(buf), fmt, va);

va_end(va);

printf("bench: %8"PRIu64" %s \n", t - current_time, buf);

}

current_time = t;

}

}

static void close_all_output_streams(OutputStream *ost, OSTFinished this_stream, OSTFinished others)

{

int i;

for (i = 0; i < nb_output_streams; i++) {

OutputStream *ost2 = output_streams[i];

ost2->finished |= ost == ost2 ? this_stream : others;

}

}

static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)

{

AVBitStreamFilterContext *bsfc = ost->bitstream_filters;

AVCodecContext *avctx = ost->st->codec;

int ret;

if (!ost->st->codec->extradata_size && ost->enc_ctx->extradata_size) {

ost->st->codec->extradata = av_mallocz(ost->enc_ctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);

if (ost->st->codec->extradata) {

memcpy(ost->st->codec->extradata, ost->enc_ctx->extradata, ost->enc_ctx->extradata_size);

ost->st->codec->extradata_size = ost->enc_ctx->extradata_size;

}

}

if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||

(avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))

pkt->pts = pkt->dts = AV_NOPTS_VALUE;

/*

if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {

if (ost->frame_number >= ost->max_frames) {

av_free_packet(pkt);

return;

}

ost->frame_number++;

}

if (bsfc)

av_packet_split_side_data(pkt);

while (bsfc) {

AVPacket new_pkt = *pkt;

AVDictionaryEntry *bsf_arg = av_dict_get(ost->bsf_args,

bsfc->filter->name,

NULL, 0);

int a = av_bitstream_filter_filter(bsfc, avctx,

bsf_arg ? bsf_arg->value : NULL,

&new_pkt.data, &new_pkt.size,

pkt->data, pkt->size,

pkt->flags & AV_PKT_FLAG_KEY);

if(a == 0 && new_pkt.data != pkt->data && new_pkt.destruct) {

uint8_t *t = av_malloc(new_pkt.size + FF_INPUT_BUFFER_PADDING_SIZE); //the new should be a subset of the old so cannot overflow

if(t) {

memcpy(t, new_pkt.data, new_pkt.size);

memset(t + new_pkt.size, 0, FF_INPUT_BUFFER_PADDING_SIZE);

new_pkt.data = t;

new_pkt.buf = NULL;

a = 1;

} else

a = AVERROR(ENOMEM);

}

if (a > 0) {

pkt->side_data = NULL;

pkt->side_data_elems = 0;

av_free_packet(pkt);

new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,

av_buffer_default_free, NULL, 0);

if (!new_pkt.buf)

exit_program(1);

} else if (a < 0) {

av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",

bsfc->filter->name, pkt->stream_index,

avctx->codec ? avctx->codec->name : "copy");

print_error("", a);

if (exit_on_error)

exit_program(1);

}

*pkt = new_pkt;

bsfc = bsfc->next;

}

if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {

if (pkt->dts != AV_NOPTS_VALUE &&

pkt->pts != AV_NOPTS_VALUE &&

pkt->dts > pkt->pts) {

av_log(s, AV_LOG_WARNING, "Invalid DTS: %"PRId64" PTS: %"PRId64" in output stream %d:%d, replacing by guess\n",

pkt->dts, pkt->pts,

ost->file_index, ost->st->index);

pkt->pts =

pkt->dts = pkt->pts + pkt->dts + ost->last_mux_dts + 1

- FFMIN3(pkt->pts, pkt->dts, ost->last_mux_dts + 1)

- FFMAX3(pkt->pts, pkt->dts, ost->last_mux_dts + 1);

}

if(

(avctx->codec_type == AVMEDIA_TYPE_AUDIO || avctx->codec_type == AVMEDIA_TYPE_VIDEO) &&

pkt->dts != AV_NOPTS_VALUE &&

ost->last_mux_dts != AV_NOPTS_VALUE) {

int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);

if (pkt->dts < max) {

int loglevel = max - pkt->dts > 2 || avctx->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;

av_log(s, loglevel, "Non-monotonous DTS in output stream "

"%d:%d; previous: %"PRId64", current: %"PRId64"; ",

ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);

if (exit_on_error) {

av_log(NULL, AV_LOG_FATAL, "aborting.\n");

exit_program(1);

}

av_log(s, loglevel, "changing to %"PRId64". This may result "

"in incorrect timestamps in the output file.\n",

max);

if(pkt->pts >= pkt->dts)

pkt->pts = FFMAX(pkt->pts, max);

pkt->dts = max;

}

}

}

ost->last_mux_dts = pkt->dts;

ost->data_size += pkt->size;

ost->packets_written++;

pkt->stream_index = ost->index;

if (debug_ts) {

av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "

"pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",

av_get_media_type_string(ost->enc_ctx->codec_type),

av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),

av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),

pkt->size

);

}

ret = av_interleaved_write_frame(s, pkt);

if (ret < 0) {

print_error("av_interleaved_write_frame()", ret);

main_return_code = 1;

close_all_output_streams(ost, MUXER_FINISHED | ENCODER_FINISHED, ENCODER_FINISHED);

}

av_free_packet(pkt);

}

static void close_output_stream(OutputStream *ost)

{

OutputFile *of = output_files[ost->file_index];

ost->finished |= ENCODER_FINISHED;

if (of->shortest) {

int64_t end = av_rescale_q(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, AV_TIME_BASE_Q);

of->recording_time = FFMIN(of->recording_time, end);

}

}

static int check_recording_time(OutputStream *ost)

{

OutputFile *of = output_files[ost->file_index];

if (of->recording_time != INT64_MAX &&

av_compare_ts(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, of->recording_time,

AV_TIME_BASE_Q) >= 0) {

close_output_stream(ost);

return 0;

}

return 1;

}

static void do_audio_out(AVFormatContext *s, OutputStream *ost,

AVFrame *frame)

{

AVCodecContext *enc = ost->enc_ctx;

AVPacket pkt;

int got_packet = 0;

av_init_packet(&pkt);

pkt.data = NULL;

pkt.size = 0;

if (!check_recording_time(ost))

return;

if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)

frame->pts = ost->sync_opts;

ost->sync_opts = frame->pts + frame->nb_samples;

ost->samples_encoded += frame->nb_samples;

ost->frames_encoded++;

av_assert0(pkt.size || !pkt.data);

update_benchmark(NULL);

if (debug_ts) {

av_log(NULL, AV_LOG_INFO, "encoder <- type:audio "

"frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",

av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),

enc->time_base.num, enc->time_base.den);

}

if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {

av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");

exit_program(1);

}

update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);

if (got_packet) {

av_packet_rescale_ts(&pkt, enc->time_base, ost->st->time_base);

if (debug_ts) {

av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "

"pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",

av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),

av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));

}

write_frame(s, &pkt, ost);

}

}

static void do_subtitle_out(AVFormatContext *s,

OutputStream *ost,

InputStream *ist,

AVSubtitle *sub)

{

int subtitle_out_max_size = 1024 * 1024;

int subtitle_out_size, nb, i;

AVCodecContext *enc;

AVPacket pkt;

int64_t pts;

if (sub->pts == AV_NOPTS_VALUE) {

av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");

if (exit_on_error)

exit_program(1);

return;

}

enc = ost->enc_ctx;

if (!subtitle_out) {

subtitle_out = av_malloc(subtitle_out_max_size);

if (!subtitle_out) {

av_log(NULL, AV_LOG_FATAL, "Failed to allocate subtitle_out\n");

exit_program(1);

}

}

/* Note: DVB subtitle need one packet to draw them and one other

/* XXX: signal it in the codec context ? */

if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)

nb = 2;

else

nb = 1;

/* shift timestamp to honor -ss and make check_recording_time() work with -t */

pts = sub->pts;

if (output_files[ost->file_index]->start_time != AV_NOPTS_VALUE)

pts -= output_files[ost->file_index]->start_time;

for (i = 0; i < nb; i++) {

unsigned save_num_rects = sub->num_rects;

ost->sync_opts = av_rescale_q(pts, AV_TIME_BASE_Q, enc->time_base);

if (!check_recording_time(ost))

return;

sub->pts = pts;

// start_display_time is required to be 0

sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);

sub->end_display_time -= sub->start_display_time;

sub->start_display_time = 0;

if (i == 1)

sub->num_rects = 0;

ost->frames_encoded++;

subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,

subtitle_out_max_size, sub);

if (i == 1)

sub->num_rects = save_num_rects;

if (subtitle_out_size < 0) {

av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");

exit_program(1);

}

av_init_packet(&pkt);

pkt.data = subtitle_out;

pkt.size = subtitle_out_size;

pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);

pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);

if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {

/* XXX: the pts correction is handled here. Maybe handling

if (i == 0)

pkt.pts += 90 * sub->start_display_time;

else

pkt.pts += 90 * sub->end_display_time;

}

pkt.dts = pkt.pts;

write_frame(s, &pkt, ost);

}

}

static void do_video_out(AVFormatContext *s,

OutputStream *ost,

AVFrame *next_picture,

double sync_ipts)

{

int ret, format_video_sync;

AVPacket pkt;

AVCodecContext *enc = ost->enc_ctx;

AVCodecContext *mux_enc = ost->st->codec;

int nb_frames, nb0_frames, i;

double delta, delta0;

double duration = 0;

int frame_size = 0;

InputStream *ist = NULL;

AVFilterContext *filter = ost->filter->filter;

if (ost->source_index >= 0)

ist = input_streams[ost->source_index];

if (filter->inputs[0]->frame_rate.num > 0 &&

filter->inputs[0]->frame_rate.den > 0)

duration = 1/(av_q2d(filter->inputs[0]->frame_rate) * av_q2d(enc->time_base));

if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)

duration = FFMIN(duration, 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base)));

if (!ost->filters_script &&

!ost->filters &&

next_picture &&

ist &&

lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {

duration = lrintf(av_frame_get_pkt_duration(next_picture) * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));

}

delta0 = sync_ipts - ost->sync_opts;

delta = delta0 + duration;

/* by default, we output a single frame */

nb0_frames = 0;

nb_frames = 1;

format_video_sync = video_sync_method;

if (format_video_sync == VSYNC_AUTO) {

if(!strcmp(s->oformat->name, "avi")) {

format_video_sync = VSYNC_VFR;

} else

format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;

if ( ist

&& format_video_sync == VSYNC_CFR

&& input_files[ist->file_index]->ctx->nb_streams == 1

&& input_files[ist->file_index]->input_ts_offset == 0) {

format_video_sync = VSYNC_VSCFR;

}

if (format_video_sync == VSYNC_CFR && copy_ts) {

format_video_sync = VSYNC_VSCFR;

}

}

if (delta0 < 0 &&

delta > 0 &&

format_video_sync != VSYNC_PASSTHROUGH &&

format_video_sync != VSYNC_DROP) {

double cor = FFMIN(-delta0, duration);

if (delta0 < -0.6) {

av_log(NULL, AV_LOG_WARNING, "Past duration %f too large\n", -delta0);

} else

av_log(NULL, AV_LOG_DEBUG, "Cliping frame in rate conversion by %f\n", -delta0);

sync_ipts += cor;

duration -= cor;

delta0 += cor;

}

switch (format_video_sync) {

case VSYNC_VSCFR:

if (ost->frame_number == 0 && delta - duration >= 0.5) {

av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta - duration));

delta = duration;

delta0 = 0;

ost->sync_opts = lrint(sync_ipts);

}

case VSYNC_CFR:

// FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c

if (delta < -1.1)

nb_frames = 0;

else if (delta > 1.1) {

nb_frames = lrintf(delta);

if (delta0 > 1.1)

nb0_frames = lrintf(delta0 - 0.6);

}

break;

case VSYNC_VFR:

if (delta <= -0.6)

nb_frames = 0;

else if (delta > 0.6)

ost->sync_opts = lrint(sync_ipts);

break;

case VSYNC_DROP:

case VSYNC_PASSTHROUGH:

ost->sync_opts = lrint(sync_ipts);

break;

default:

av_assert0(0);

}

nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);

nb0_frames = FFMIN(nb0_frames, nb_frames);

if (nb0_frames == 0 && ost->last_droped) {

nb_frames_drop++;

av_log(NULL, AV_LOG_VERBOSE,

"*** dropping frame %d from stream %d at ts %"PRId64"\n",

ost->frame_number, ost->st->index, ost->last_frame->pts);

}

if (nb_frames > (nb0_frames && ost->last_droped) + (nb_frames > nb0_frames)) {

if (nb_frames > dts_error_threshold * 30) {

av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1);

nb_frames_drop++;

return;