avconv: remove deprecated options.
[libav.git] / avconv.c
CommitLineData
6291d7e4
AK
1/*
2 * avconv main
3 * Copyright (c) 2000-2011 The libav developers.
4 *
5 * This file is part of Libav.
6 *
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22#include "config.h"
23#include <ctype.h>
24#include <string.h>
25#include <math.h>
26#include <stdlib.h>
27#include <errno.h>
28#include <signal.h>
29#include <limits.h>
30#include <unistd.h>
31#include "libavformat/avformat.h"
32#include "libavdevice/avdevice.h"
33#include "libswscale/swscale.h"
34#include "libavutil/opt.h"
35#include "libavcodec/audioconvert.h"
36#include "libavutil/audioconvert.h"
37#include "libavutil/parseutils.h"
38#include "libavutil/samplefmt.h"
39#include "libavutil/colorspace.h"
40#include "libavutil/fifo.h"
41#include "libavutil/intreadwrite.h"
42#include "libavutil/dict.h"
43#include "libavutil/mathematics.h"
44#include "libavutil/pixdesc.h"
45#include "libavutil/avstring.h"
46#include "libavutil/libm.h"
47#include "libavformat/os_support.h"
48
49#if CONFIG_AVFILTER
50# include "libavfilter/avfilter.h"
51# include "libavfilter/avfiltergraph.h"
52# include "libavfilter/vsrc_buffer.h"
53#endif
54
55#if HAVE_SYS_RESOURCE_H
56#include <sys/types.h>
57#include <sys/time.h>
58#include <sys/resource.h>
59#elif HAVE_GETPROCESSTIMES
60#include <windows.h>
61#endif
62#if HAVE_GETPROCESSMEMORYINFO
63#include <windows.h>
64#include <psapi.h>
65#endif
66
67#if HAVE_SYS_SELECT_H
68#include <sys/select.h>
69#endif
70
71#include <time.h>
72
73#include "cmdutils.h"
74
75#include "libavutil/avassert.h"
76
77const char program_name[] = "avconv";
78const int program_birth_year = 2000;
79
80/* select an input stream for an output stream */
81typedef struct StreamMap {
82 int file_index;
83 int stream_index;
84 int sync_file_index;
85 int sync_stream_index;
86} StreamMap;
87
88/**
89 * select an input file for an output file
90 */
91typedef struct MetadataMap {
92 int file; //< file index
93 char type; //< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
94 int index; //< stream/chapter/program number
95} MetadataMap;
96
6291d7e4
AK
97static const OptionDef options[];
98
99#define MAX_FILES 100
100
101static const char *last_asked_format = NULL;
102static double *ts_scale;
103static int nb_ts_scale;
104
105static AVFormatContext *output_files[MAX_FILES];
106static AVDictionary *output_opts[MAX_FILES];
107static int nb_output_files = 0;
108
109static StreamMap *stream_maps = NULL;
110static int nb_stream_maps;
111
112/* first item specifies output metadata, second is input */
113static MetadataMap (*meta_data_maps)[2] = NULL;
114static int nb_meta_data_maps;
115static int metadata_global_autocopy = 1;
116static int metadata_streams_autocopy = 1;
117static int metadata_chapters_autocopy = 1;
118
b9aac90b 119static int chapters_input_file = INT_MAX;
6291d7e4
AK
120
121/* indexed by output file stream index */
122static int *streamid_map = NULL;
123static int nb_streamid_map = 0;
124
125static int frame_width = 0;
126static int frame_height = 0;
127static float frame_aspect_ratio = 0;
128static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
129static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
130static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
131static AVRational frame_rate;
132static float video_qscale = 0;
133static uint16_t *intra_matrix = NULL;
134static uint16_t *inter_matrix = NULL;
135static const char *video_rc_override_string=NULL;
136static int video_disable = 0;
137static int video_discard = 0;
138static char *video_codec_name = NULL;
139static unsigned int video_codec_tag = 0;
140static char *video_language = NULL;
141static int same_quality = 0;
142static int do_deinterlace = 0;
143static int top_field_first = -1;
144static int me_threshold = 0;
145static int intra_dc_precision = 8;
6291d7e4
AK
146static int qp_hist = 0;
147#if CONFIG_AVFILTER
148static char *vfilters = NULL;
149#endif
150
151static int intra_only = 0;
152static int audio_sample_rate = 0;
153#define QSCALE_NONE -99999
154static float audio_qscale = QSCALE_NONE;
155static int audio_disable = 0;
156static int audio_channels = 0;
157static char *audio_codec_name = NULL;
158static unsigned int audio_codec_tag = 0;
159static char *audio_language = NULL;
160
161static int subtitle_disable = 0;
162static char *subtitle_codec_name = NULL;
163static char *subtitle_language = NULL;
164static unsigned int subtitle_codec_tag = 0;
165
166static int data_disable = 0;
167static char *data_codec_name = NULL;
168static unsigned int data_codec_tag = 0;
169
170static float mux_preload= 0.5;
171static float mux_max_delay= 0.7;
172
173static int64_t recording_time = INT64_MAX;
174static int64_t start_time = 0;
175static int64_t input_ts_offset = 0;
176static int file_overwrite = 0;
177static AVDictionary *metadata;
178static int do_benchmark = 0;
179static int do_hex_dump = 0;
180static int do_pkt_dump = 0;
181static int do_psnr = 0;
182static int do_pass = 0;
183static char *pass_logfilename_prefix = NULL;
184static int audio_stream_copy = 0;
185static int video_stream_copy = 0;
186static int subtitle_stream_copy = 0;
187static int data_stream_copy = 0;
188static int video_sync_method= -1;
189static int audio_sync_method= 0;
190static float audio_drift_threshold= 0.1;
191static int copy_ts= 0;
192static int copy_tb;
193static int opt_shortest = 0;
194static char *vstats_filename;
195static FILE *vstats_file;
196static int opt_programid = 0;
197static int copy_initial_nonkeyframes = 0;
198
199static int rate_emu = 0;
200
201static int audio_volume = 256;
202
203static int exit_on_error = 0;
204static int using_stdin = 0;
205static int verbose = 1;
206static int thread_count= 1;
207static int64_t video_size = 0;
208static int64_t audio_size = 0;
209static int64_t extra_size = 0;
210static int nb_frames_dup = 0;
211static int nb_frames_drop = 0;
212static int input_sync;
213static uint64_t limit_filesize = 0;
214static int force_fps = 0;
215static char *forced_key_frames = NULL;
216
217static float dts_delta_threshold = 10;
218
219static int64_t timer_start;
220
221static uint8_t *audio_buf;
222static uint8_t *audio_out;
223static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
224
225static short *samples;
226
227static AVBitStreamFilterContext *video_bitstream_filters=NULL;
228static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
229static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
230
231#define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
232
233struct InputStream;
234
235typedef struct OutputStream {
236 int file_index; /* file index */
237 int index; /* stream index in the output file */
238 int source_index; /* InputStream index */
239 AVStream *st; /* stream in the output file */
240 int encoding_needed; /* true if encoding needed for this stream */
241 int frame_number;
242 /* input pts and corresponding output pts
243 for A/V sync */
244 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
245 struct InputStream *sync_ist; /* input stream to sync against */
246 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
247 AVBitStreamFilterContext *bitstream_filters;
248 AVCodec *enc;
249
250 /* video only */
251 int video_resample;
252 AVFrame pict_tmp; /* temporary image for resampling */
253 struct SwsContext *img_resample_ctx; /* for image resampling */
254 int resample_height;
255 int resample_width;
256 int resample_pix_fmt;
257 AVRational frame_rate;
258
259 float frame_aspect_ratio;
260
261 /* forced key frames */
262 int64_t *forced_kf_pts;
263 int forced_kf_count;
264 int forced_kf_index;
265
266 /* audio only */
267 int audio_resample;
268 ReSampleContext *resample; /* for audio resampling */
269 int resample_sample_fmt;
270 int resample_channels;
271 int resample_sample_rate;
272 int reformat_pair;
273 AVAudioConvert *reformat_ctx;
274 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
275 FILE *logfile;
276
277#if CONFIG_AVFILTER
278 AVFilterContext *output_video_filter;
279 AVFilterContext *input_video_filter;
280 AVFilterBufferRef *picref;
281 char *avfilter;
282 AVFilterGraph *graph;
283#endif
284
285 int sws_flags;
286 AVDictionary *opts;
287} OutputStream;
288
289static OutputStream **output_streams_for_file[MAX_FILES] = { NULL };
290static int nb_output_streams_for_file[MAX_FILES] = { 0 };
291
292typedef struct InputStream {
293 int file_index;
294 AVStream *st;
295 int discard; /* true if stream data should be discarded */
296 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
297 AVCodec *dec;
298
299 int64_t start; /* time when read started */
300 int64_t next_pts; /* synthetic pts for cases where pkt.pts
301 is not defined */
302 int64_t pts; /* current pts */
303 PtsCorrectionContext pts_ctx;
304 double ts_scale;
305 int is_start; /* is 1 at the start and after a discontinuity */
306 int showed_multi_packet_warning;
307 int is_past_recording_time;
308 AVDictionary *opts;
309} InputStream;
310
311typedef struct InputFile {
312 AVFormatContext *ctx;
313 int eof_reached; /* true if eof reached */
314 int ist_index; /* index of first stream in ist_table */
315 int buffer_size; /* current total buffer size */
316 int64_t ts_offset;
317} InputFile;
318
319static InputStream *input_streams = NULL;
320static int nb_input_streams = 0;
321static InputFile *input_files = NULL;
322static int nb_input_files = 0;
323
324#if CONFIG_AVFILTER
325
326static int configure_video_filters(InputStream *ist, OutputStream *ost)
327{
328 AVFilterContext *last_filter, *filter;
329 /** filter graph containing all filters including input & output */
330 AVCodecContext *codec = ost->st->codec;
331 AVCodecContext *icodec = ist->st->codec;
332 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
333 AVRational sample_aspect_ratio;
334 char args[255];
335 int ret;
336
337 ost->graph = avfilter_graph_alloc();
338
339 if (ist->st->sample_aspect_ratio.num){
340 sample_aspect_ratio = ist->st->sample_aspect_ratio;
341 }else
342 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
343
344 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
345 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
346 sample_aspect_ratio.num, sample_aspect_ratio.den);
347
348 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
349 "src", args, NULL, ost->graph);
350 if (ret < 0)
351 return ret;
352 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
353 "out", NULL, &ffsink_ctx, ost->graph);
354 if (ret < 0)
355 return ret;
356 last_filter = ost->input_video_filter;
357
358 if (codec->width != icodec->width || codec->height != icodec->height) {
359 snprintf(args, 255, "%d:%d:flags=0x%X",
360 codec->width,
361 codec->height,
362 ost->sws_flags);
363 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
364 NULL, args, NULL, ost->graph)) < 0)
365 return ret;
366 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
367 return ret;
368 last_filter = filter;
369 }
370
371 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
372 ost->graph->scale_sws_opts = av_strdup(args);
373
374 if (ost->avfilter) {
375 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
376 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
377
378 outputs->name = av_strdup("in");
379 outputs->filter_ctx = last_filter;
380 outputs->pad_idx = 0;
381 outputs->next = NULL;
382
383 inputs->name = av_strdup("out");
384 inputs->filter_ctx = ost->output_video_filter;
385 inputs->pad_idx = 0;
386 inputs->next = NULL;
387
388 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
389 return ret;
390 av_freep(&ost->avfilter);
391 } else {
392 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
393 return ret;
394 }
395
396 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
397 return ret;
398
399 codec->width = ost->output_video_filter->inputs[0]->w;
400 codec->height = ost->output_video_filter->inputs[0]->h;
401 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
402 ost->frame_aspect_ratio ? // overriden by the -aspect cli option
403 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
404 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
405
406 return 0;
407}
408#endif /* CONFIG_AVFILTER */
409
410static void term_exit(void)
411{
412 av_log(NULL, AV_LOG_QUIET, "");
413}
414
415static volatile int received_sigterm = 0;
416static volatile int received_nb_signals = 0;
417
418static void
419sigterm_handler(int sig)
420{
421 received_sigterm = sig;
422 received_nb_signals++;
423 term_exit();
424}
425
426static void term_init(void)
427{
428 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
429 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
430#ifdef SIGXCPU
431 signal(SIGXCPU, sigterm_handler);
432#endif
433}
434
435static int decode_interrupt_cb(void)
436{
437 return received_nb_signals > 1;
438}
439
440static int exit_program(int ret)
441{
442 int i;
443
444 /* close files */
445 for(i=0;i<nb_output_files;i++) {
446 AVFormatContext *s = output_files[i];
447 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
448 avio_close(s->pb);
449 avformat_free_context(s);
450 av_free(output_streams_for_file[i]);
451 av_dict_free(&output_opts[i]);
452 }
453 for(i=0;i<nb_input_files;i++) {
454 av_close_input_file(input_files[i].ctx);
455 }
456 for (i = 0; i < nb_input_streams; i++)
457 av_dict_free(&input_streams[i].opts);
458
459 av_free(intra_matrix);
460 av_free(inter_matrix);
461
462 if (vstats_file)
463 fclose(vstats_file);
464 av_free(vstats_filename);
465
466 av_free(streamid_map);
467 av_free(stream_maps);
468 av_free(meta_data_maps);
469
470 av_freep(&input_streams);
471 av_freep(&input_files);
472
473 av_free(video_codec_name);
474 av_free(audio_codec_name);
475 av_free(subtitle_codec_name);
476 av_free(data_codec_name);
477
478 uninit_opts();
479 av_free(audio_buf);
480 av_free(audio_out);
481 allocated_audio_buf_size= allocated_audio_out_size= 0;
482 av_free(samples);
483
484#if CONFIG_AVFILTER
485 avfilter_uninit();
486#endif
487
488 if (received_sigterm) {
489 fprintf(stderr,
490 "Received signal %d: terminating.\n",
491 (int) received_sigterm);
492 exit (255);
493 }
494
495 exit(ret); /* not all OS-es handle main() return value */
496 return ret;
497}
498
499static void assert_avoptions(AVDictionary *m)
500{
501 AVDictionaryEntry *t;
502 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
503 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
504 exit_program(1);
505 }
506}
507
508static void assert_codec_experimental(AVCodecContext *c, int encoder)
509{
510 const char *codec_string = encoder ? "encoder" : "decoder";
511 AVCodec *codec;
512 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
513 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
514 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
515 "results.\nAdd '-strict experimental' if you want to use it.\n",
516 codec_string, c->codec->name);
517 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
518 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
519 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
520 codec_string, codec->name);
521 exit_program(1);
522 }
523}
524
525/* similar to ff_dynarray_add() and av_fast_realloc() */
526static void *grow_array(void *array, int elem_size, int *size, int new_size)
527{
528 if (new_size >= INT_MAX / elem_size) {
529 fprintf(stderr, "Array too big.\n");
530 exit_program(1);
531 }
532 if (*size < new_size) {
533 uint8_t *tmp = av_realloc(array, new_size*elem_size);
534 if (!tmp) {
535 fprintf(stderr, "Could not alloc buffer.\n");
536 exit_program(1);
537 }
538 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
539 *size = new_size;
540 return tmp;
541 }
542 return array;
543}
544
545static void choose_sample_fmt(AVStream *st, AVCodec *codec)
546{
547 if(codec && codec->sample_fmts){
548 const enum AVSampleFormat *p= codec->sample_fmts;
549 for(; *p!=-1; p++){
550 if(*p == st->codec->sample_fmt)
551 break;
552 }
553 if (*p == -1) {
554 av_log(NULL, AV_LOG_WARNING,
555 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
556 av_get_sample_fmt_name(st->codec->sample_fmt),
557 codec->name,
558 av_get_sample_fmt_name(codec->sample_fmts[0]));
559 st->codec->sample_fmt = codec->sample_fmts[0];
560 }
561 }
562}
563
564/**
565 * Update the requested input sample format based on the output sample format.
566 * This is currently only used to request float output from decoders which
567 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
568 * Ideally this will be removed in the future when decoders do not do format
569 * conversion and only output in their native format.
570 */
571static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
572 AVCodecContext *enc)
573{
574 /* if sample formats match or a decoder sample format has already been
575 requested, just return */
576 if (enc->sample_fmt == dec->sample_fmt ||
577 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
578 return;
579
580 /* if decoder supports more than one output format */
581 if (dec_codec && dec_codec->sample_fmts &&
582 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
583 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
584 const enum AVSampleFormat *p;
585 int min_dec = -1, min_inc = -1;
586
587 /* find a matching sample format in the encoder */
588 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
589 if (*p == enc->sample_fmt) {
590 dec->request_sample_fmt = *p;
591 return;
592 } else if (*p > enc->sample_fmt) {
593 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
594 } else
595 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
596 }
597
598 /* if none match, provide the one that matches quality closest */
599 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
600 enc->sample_fmt - min_dec;
601 }
602}
603
604static void choose_sample_rate(AVStream *st, AVCodec *codec)
605{
606 if(codec && codec->supported_samplerates){
607 const int *p= codec->supported_samplerates;
608 int best=0;
609 int best_dist=INT_MAX;
610 for(; *p; p++){
611 int dist= abs(st->codec->sample_rate - *p);
612 if(dist < best_dist){
613 best_dist= dist;
614 best= *p;
615 }
616 }
617 if(best_dist){
618 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
619 }
620 st->codec->sample_rate= best;
621 }
622}
623
624static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
625{
626 if(codec && codec->pix_fmts){
627 const enum PixelFormat *p= codec->pix_fmts;
628 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
629 if(st->codec->codec_id==CODEC_ID_MJPEG){
630 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
631 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
632 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
633 }
634 }
635 for(; *p!=-1; p++){
636 if(*p == st->codec->pix_fmt)
637 break;
638 }
639 if (*p == -1) {
640 if(st->codec->pix_fmt != PIX_FMT_NONE)
641 av_log(NULL, AV_LOG_WARNING,
642 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
643 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
644 codec->name,
645 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
646 st->codec->pix_fmt = codec->pix_fmts[0];
647 }
648 }
649}
650
651static OutputStream *new_output_stream(AVFormatContext *oc, int file_idx, AVCodec *codec)
652{
653 OutputStream *ost;
654 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
655 int idx = oc->nb_streams - 1;
656
657 if (!st) {
658 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
659 exit_program(1);
660 }
661
662 output_streams_for_file[file_idx] =
663 grow_array(output_streams_for_file[file_idx],
664 sizeof(*output_streams_for_file[file_idx]),
665 &nb_output_streams_for_file[file_idx],
666 oc->nb_streams);
667 ost = output_streams_for_file[file_idx][idx] =
668 av_mallocz(sizeof(OutputStream));
669 if (!ost) {
670 fprintf(stderr, "Could not alloc output stream\n");
671 exit_program(1);
672 }
673 ost->file_index = file_idx;
674 ost->index = idx;
675 ost->st = st;
676 ost->enc = codec;
677 if (codec)
678 ost->opts = filter_codec_opts(codec_opts, codec->id, 1);
679
680 avcodec_get_context_defaults3(st->codec, codec);
681
682 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
683 return ost;
684}
685
686static int read_avserver_streams(AVFormatContext *s, const char *filename)
687{
688 int i, err;
689 AVFormatContext *ic = NULL;
690 int nopts = 0;
691
692 err = avformat_open_input(&ic, filename, NULL, NULL);
693 if (err < 0)
694 return err;
695 /* copy stream format */
696 for(i=0;i<ic->nb_streams;i++) {
697 AVStream *st;
698 OutputStream *ost;
699 AVCodec *codec;
700
701 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
702 ost = new_output_stream(s, nb_output_files, codec);
703 st = ost->st;
704
705 // FIXME: a more elegant solution is needed
706 memcpy(st, ic->streams[i], sizeof(AVStream));
707 st->info = NULL;
708 avcodec_copy_context(st->codec, ic->streams[i]->codec);
709
710 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
711 if (audio_stream_copy) {
712 st->stream_copy = 1;
713 } else
714 choose_sample_fmt(st, codec);
715 } else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
716 if (video_stream_copy) {
717 st->stream_copy = 1;
718 } else
719 choose_pixel_fmt(st, codec);
720 }
721
722 if(st->codec->flags & CODEC_FLAG_BITEXACT)
723 nopts = 1;
724 }
725
726 av_close_input_file(ic);
727 return 0;
728}
729
730static double
731get_sync_ipts(const OutputStream *ost)
732{
733 const InputStream *ist = ost->sync_ist;
734 return (double)(ist->pts - start_time)/AV_TIME_BASE;
735}
736
737static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
738 int ret;
739
740 while(bsfc){
741 AVPacket new_pkt= *pkt;
742 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
743 &new_pkt.data, &new_pkt.size,
744 pkt->data, pkt->size,
745 pkt->flags & AV_PKT_FLAG_KEY);
746 if(a>0){
747 av_free_packet(pkt);
748 new_pkt.destruct= av_destruct_packet;
749 } else if(a<0){
750 fprintf(stderr, "%s failed for stream %d, codec %s",
751 bsfc->filter->name, pkt->stream_index,
752 avctx->codec ? avctx->codec->name : "copy");
753 print_error("", a);
754 if (exit_on_error)
755 exit_program(1);
756 }
757 *pkt= new_pkt;
758
759 bsfc= bsfc->next;
760 }
761
762 ret= av_interleaved_write_frame(s, pkt);
763 if(ret < 0){
764 print_error("av_interleaved_write_frame()", ret);
765 exit_program(1);
766 }
767}
768
769#define MAX_AUDIO_PACKET_SIZE (128 * 1024)
770
771static void do_audio_out(AVFormatContext *s,
772 OutputStream *ost,
773 InputStream *ist,
774 unsigned char *buf, int size)
775{
776 uint8_t *buftmp;
777 int64_t audio_out_size, audio_buf_size;
778 int64_t allocated_for_size= size;
779
780 int size_out, frame_bytes, ret, resample_changed;
781 AVCodecContext *enc= ost->st->codec;
782 AVCodecContext *dec= ist->st->codec;
783 int osize = av_get_bytes_per_sample(enc->sample_fmt);
784 int isize = av_get_bytes_per_sample(dec->sample_fmt);
785 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
786
787need_realloc:
788 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
789 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
790 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
791 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
792 audio_buf_size*= osize*enc->channels;
793
794 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
795 if(coded_bps > 8*osize)
796 audio_out_size= audio_out_size * coded_bps / (8*osize);
797 audio_out_size += FF_MIN_BUFFER_SIZE;
798
799 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
800 fprintf(stderr, "Buffer sizes too large\n");
801 exit_program(1);
802 }
803
804 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
805 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
806 if (!audio_buf || !audio_out){
807 fprintf(stderr, "Out of memory in do_audio_out\n");
808 exit_program(1);
809 }
810
811 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
812 ost->audio_resample = 1;
813
814 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
815 ost->resample_channels != dec->channels ||
816 ost->resample_sample_rate != dec->sample_rate;
817
818 if ((ost->audio_resample && !ost->resample) || resample_changed) {
819 if (resample_changed) {
820 av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
821 ist->file_index, ist->st->index,
822 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
823 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
824 ost->resample_sample_fmt = dec->sample_fmt;
825 ost->resample_channels = dec->channels;
826 ost->resample_sample_rate = dec->sample_rate;
827 if (ost->resample)
828 audio_resample_close(ost->resample);
829 }
830 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
831 if (audio_sync_method <= 1 &&
832 ost->resample_sample_fmt == enc->sample_fmt &&
833 ost->resample_channels == enc->channels &&
834 ost->resample_sample_rate == enc->sample_rate) {
835 ost->resample = NULL;
836 ost->audio_resample = 0;
837 } else if (ost->audio_resample) {
838 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
839 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
840 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
841 enc->sample_rate, dec->sample_rate,
842 enc->sample_fmt, dec->sample_fmt,
843 16, 10, 0, 0.8);
844 if (!ost->resample) {
845 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
846 dec->channels, dec->sample_rate,
847 enc->channels, enc->sample_rate);
848 exit_program(1);
849 }
850 }
851 }
852
853#define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
854 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
855 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
856 if (ost->reformat_ctx)
857 av_audio_convert_free(ost->reformat_ctx);
858 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
859 dec->sample_fmt, 1, NULL, 0);
860 if (!ost->reformat_ctx) {
861 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
862 av_get_sample_fmt_name(dec->sample_fmt),
863 av_get_sample_fmt_name(enc->sample_fmt));
864 exit_program(1);
865 }
866 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
867 }
868
869 if(audio_sync_method){
870 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
871 - av_fifo_size(ost->fifo)/(enc->channels * 2);
872 double idelta= delta*dec->sample_rate / enc->sample_rate;
873 int byte_delta= ((int)idelta)*2*dec->channels;
874
875 //FIXME resample delay
876 if(fabs(delta) > 50){
877 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
878 if(byte_delta < 0){
879 byte_delta= FFMAX(byte_delta, -size);
880 size += byte_delta;
881 buf -= byte_delta;
882 if(verbose > 2)
883 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
884 if(!size)
885 return;
886 ist->is_start=0;
887 }else{
888 static uint8_t *input_tmp= NULL;
889 input_tmp= av_realloc(input_tmp, byte_delta + size);
890
891 if(byte_delta > allocated_for_size - size){
892 allocated_for_size= byte_delta + (int64_t)size;
893 goto need_realloc;
894 }
895 ist->is_start=0;
896
897 memset(input_tmp, 0, byte_delta);
898 memcpy(input_tmp + byte_delta, buf, size);
899 buf= input_tmp;
900 size += byte_delta;
901 if(verbose > 2)
902 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
903 }
904 }else if(audio_sync_method>1){
905 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
906 av_assert0(ost->audio_resample);
907 if(verbose > 2)
908 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
909// fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
910 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
911 }
912 }
913 }else
914 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
915 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
916
917 if (ost->audio_resample) {
918 buftmp = audio_buf;
919 size_out = audio_resample(ost->resample,
920 (short *)buftmp, (short *)buf,
921 size / (dec->channels * isize));
922 size_out = size_out * enc->channels * osize;
923 } else {
924 buftmp = buf;
925 size_out = size;
926 }
927
928 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
929 const void *ibuf[6]= {buftmp};
930 void *obuf[6]= {audio_buf};
931 int istride[6]= {isize};
932 int ostride[6]= {osize};
933 int len= size_out/istride[0];
934 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
935 printf("av_audio_convert() failed\n");
936 if (exit_on_error)
937 exit_program(1);
938 return;
939 }
940 buftmp = audio_buf;
941 size_out = len*osize;
942 }
943
944 /* now encode as many frames as possible */
945 if (enc->frame_size > 1) {
946 /* output resampled raw samples */
947 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
948 fprintf(stderr, "av_fifo_realloc2() failed\n");
949 exit_program(1);
950 }
951 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
952
953 frame_bytes = enc->frame_size * osize * enc->channels;
954
955 while (av_fifo_size(ost->fifo) >= frame_bytes) {
956 AVPacket pkt;
957 av_init_packet(&pkt);
958
959 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
960
961 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
962
963 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
964 (short *)audio_buf);
965 if (ret < 0) {
966 fprintf(stderr, "Audio encoding failed\n");
967 exit_program(1);
968 }
969 audio_size += ret;
970 pkt.stream_index= ost->index;
971 pkt.data= audio_out;
972 pkt.size= ret;
973 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
974 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
975 pkt.flags |= AV_PKT_FLAG_KEY;
976 write_frame(s, &pkt, enc, ost->bitstream_filters);
977
978 ost->sync_opts += enc->frame_size;
979 }
980 } else {
981 AVPacket pkt;
982 av_init_packet(&pkt);
983
984 ost->sync_opts += size_out / (osize * enc->channels);
985
986 /* output a pcm frame */
987 /* determine the size of the coded buffer */
988 size_out /= osize;
989 if (coded_bps)
990 size_out = size_out*coded_bps/8;
991
992 if(size_out > audio_out_size){
993 fprintf(stderr, "Internal error, buffer size too small\n");
994 exit_program(1);
995 }
996
997 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
998 ret = avcodec_encode_audio(enc, audio_out, size_out,
999 (short *)buftmp);
1000 if (ret < 0) {
1001 fprintf(stderr, "Audio encoding failed\n");
1002 exit_program(1);
1003 }
1004 audio_size += ret;
1005 pkt.stream_index= ost->index;
1006 pkt.data= audio_out;
1007 pkt.size= ret;
1008 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1009 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1010 pkt.flags |= AV_PKT_FLAG_KEY;
1011 write_frame(s, &pkt, enc, ost->bitstream_filters);
1012 }
1013}
1014
1015static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1016{
1017 AVCodecContext *dec;
1018 AVPicture *picture2;
1019 AVPicture picture_tmp;
1020 uint8_t *buf = 0;
1021
1022 dec = ist->st->codec;
1023
1024 /* deinterlace : must be done before any resize */
1025 if (do_deinterlace) {
1026 int size;
1027
1028 /* create temporary picture */
1029 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1030 buf = av_malloc(size);
1031 if (!buf)
1032 return;
1033
1034 picture2 = &picture_tmp;
1035 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1036
1037 if(avpicture_deinterlace(picture2, picture,
1038 dec->pix_fmt, dec->width, dec->height) < 0) {
1039 /* if error, do not deinterlace */
1040 fprintf(stderr, "Deinterlacing failed\n");
1041 av_free(buf);
1042 buf = NULL;
1043 picture2 = picture;
1044 }
1045 } else {
1046 picture2 = picture;
1047 }
1048
1049 if (picture != picture2)
1050 *picture = *picture2;
1051 *bufp = buf;
1052}
1053
1054/* we begin to correct av delay at this threshold */
1055#define AV_DELAY_MAX 0.100
1056
1057static void do_subtitle_out(AVFormatContext *s,
1058 OutputStream *ost,
1059 InputStream *ist,
1060 AVSubtitle *sub,
1061 int64_t pts)
1062{
1063 static uint8_t *subtitle_out = NULL;
1064 int subtitle_out_max_size = 1024 * 1024;
1065 int subtitle_out_size, nb, i;
1066 AVCodecContext *enc;
1067 AVPacket pkt;
1068
1069 if (pts == AV_NOPTS_VALUE) {
1070 fprintf(stderr, "Subtitle packets must have a pts\n");
1071 if (exit_on_error)
1072 exit_program(1);
1073 return;
1074 }
1075
1076 enc = ost->st->codec;
1077
1078 if (!subtitle_out) {
1079 subtitle_out = av_malloc(subtitle_out_max_size);
1080 }
1081
1082 /* Note: DVB subtitle need one packet to draw them and one other
1083 packet to clear them */
1084 /* XXX: signal it in the codec context ? */
1085 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1086 nb = 2;
1087 else
1088 nb = 1;
1089
1090 for(i = 0; i < nb; i++) {
1091 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1092 // start_display_time is required to be 0
1093 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1094 sub->end_display_time -= sub->start_display_time;
1095 sub->start_display_time = 0;
1096 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1097 subtitle_out_max_size, sub);
1098 if (subtitle_out_size < 0) {
1099 fprintf(stderr, "Subtitle encoding failed\n");
1100 exit_program(1);
1101 }
1102
1103 av_init_packet(&pkt);
1104 pkt.stream_index = ost->index;
1105 pkt.data = subtitle_out;
1106 pkt.size = subtitle_out_size;
1107 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1108 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1109 /* XXX: the pts correction is handled here. Maybe handling
1110 it in the codec would be better */
1111 if (i == 0)
1112 pkt.pts += 90 * sub->start_display_time;
1113 else
1114 pkt.pts += 90 * sub->end_display_time;
1115 }
1116 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1117 }
1118}
1119
1120static int bit_buffer_size= 1024*256;
1121static uint8_t *bit_buffer= NULL;
1122
1123static void do_video_out(AVFormatContext *s,
1124 OutputStream *ost,
1125 InputStream *ist,
1126 AVFrame *in_picture,
1127 int *frame_size, float quality)
1128{
1129 int nb_frames, i, ret, resample_changed;
1130 AVFrame *final_picture, *formatted_picture;
1131 AVCodecContext *enc, *dec;
1132 double sync_ipts;
1133
1134 enc = ost->st->codec;
1135 dec = ist->st->codec;
1136
1137 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1138
1139 /* by default, we output a single frame */
1140 nb_frames = 1;
1141
1142 *frame_size = 0;
1143
1144 if(video_sync_method){
1145 double vdelta = sync_ipts - ost->sync_opts;
1146 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1147 if (vdelta < -1.1)
1148 nb_frames = 0;
1149 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
1150 if(vdelta<=-0.6){
1151 nb_frames=0;
1152 }else if(vdelta>0.6)
1153 ost->sync_opts= lrintf(sync_ipts);
1154 }else if (vdelta > 1.1)
1155 nb_frames = lrintf(vdelta);
1156//fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1157 if (nb_frames == 0){
1158 ++nb_frames_drop;
1159 if (verbose>2)
1160 fprintf(stderr, "*** drop!\n");
1161 }else if (nb_frames > 1) {
1162 nb_frames_dup += nb_frames - 1;
1163 if (verbose>2)
1164 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1165 }
1166 }else
1167 ost->sync_opts= lrintf(sync_ipts);
1168
1169 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1170 if (nb_frames <= 0)
1171 return;
1172
1173 formatted_picture = in_picture;
1174 final_picture = formatted_picture;
1175
1176 resample_changed = ost->resample_width != dec->width ||
1177 ost->resample_height != dec->height ||
1178 ost->resample_pix_fmt != dec->pix_fmt;
1179
1180 if (resample_changed) {
1181 av_log(NULL, AV_LOG_INFO,
1182 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1183 ist->file_index, ist->st->index,
1184 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1185 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1186 if(!ost->video_resample)
1187 exit_program(1);
1188 }
1189
1190#if !CONFIG_AVFILTER
1191 if (ost->video_resample) {
1192 final_picture = &ost->pict_tmp;
1193 if (resample_changed) {
1194 /* initialize a new scaler context */
1195 sws_freeContext(ost->img_resample_ctx);
1196 ost->img_resample_ctx = sws_getContext(
1197 ist->st->codec->width,
1198 ist->st->codec->height,
1199 ist->st->codec->pix_fmt,
1200 ost->st->codec->width,
1201 ost->st->codec->height,
1202 ost->st->codec->pix_fmt,
1203 ost->sws_flags, NULL, NULL, NULL);
1204 if (ost->img_resample_ctx == NULL) {
1205 fprintf(stderr, "Cannot get resampling context\n");
1206 exit_program(1);
1207 }
1208 }
1209 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1210 0, ost->resample_height, final_picture->data, final_picture->linesize);
1211 }
1212#endif
1213
1214 /* duplicates frame if needed */
1215 for(i=0;i<nb_frames;i++) {
1216 AVPacket pkt;
1217 av_init_packet(&pkt);
1218 pkt.stream_index= ost->index;
1219
1220 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1221 /* raw pictures are written as AVPicture structure to
1222 avoid any copies. We support temorarily the older
1223 method. */
1224 AVFrame* old_frame = enc->coded_frame;
1225 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1226 pkt.data= (uint8_t *)final_picture;
1227 pkt.size= sizeof(AVPicture);
1228 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1229 pkt.flags |= AV_PKT_FLAG_KEY;
1230
1231 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1232 enc->coded_frame = old_frame;
1233 } else {
1234 AVFrame big_picture;
1235
1236 big_picture= *final_picture;
1237 /* better than nothing: use input picture interlaced
1238 settings */
1239 big_picture.interlaced_frame = in_picture->interlaced_frame;
1240 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1241 if(top_field_first == -1)
1242 big_picture.top_field_first = in_picture->top_field_first;
1243 else
1244 big_picture.top_field_first = top_field_first;
1245 }
1246
1247 /* handles sameq here. This is not correct because it may
1248 not be a global option */
1249 big_picture.quality = quality;
1250 if(!me_threshold)
1251 big_picture.pict_type = 0;
1252// big_picture.pts = AV_NOPTS_VALUE;
1253 big_picture.pts= ost->sync_opts;
1254// big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1255//av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1256 if (ost->forced_kf_index < ost->forced_kf_count &&
1257 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1258 big_picture.pict_type = AV_PICTURE_TYPE_I;
1259 ost->forced_kf_index++;
1260 }
1261 ret = avcodec_encode_video(enc,
1262 bit_buffer, bit_buffer_size,
1263 &big_picture);
1264 if (ret < 0) {
1265 fprintf(stderr, "Video encoding failed\n");
1266 exit_program(1);
1267 }
1268
1269 if(ret>0){
1270 pkt.data= bit_buffer;
1271 pkt.size= ret;
1272 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1273 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1274/*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1275 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1276 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1277
1278 if(enc->coded_frame->key_frame)
1279 pkt.flags |= AV_PKT_FLAG_KEY;
1280 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1281 *frame_size = ret;
1282 video_size += ret;
1283 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1284 // enc->frame_number-1, ret, enc->pict_type);
1285 /* if two pass, output log */
1286 if (ost->logfile && enc->stats_out) {
1287 fprintf(ost->logfile, "%s", enc->stats_out);
1288 }
1289 }
1290 }
1291 ost->sync_opts++;
1292 ost->frame_number++;
1293 }
1294}
1295
1296static double psnr(double d){
1297 return -10.0*log(d)/log(10.0);
1298}
1299
1300static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1301 int frame_size)
1302{
1303 AVCodecContext *enc;
1304 int frame_number;
1305 double ti1, bitrate, avg_bitrate;
1306
1307 /* this is executed just the first time do_video_stats is called */
1308 if (!vstats_file) {
1309 vstats_file = fopen(vstats_filename, "w");
1310 if (!vstats_file) {
1311 perror("fopen");
1312 exit_program(1);
1313 }
1314 }
1315
1316 enc = ost->st->codec;
1317 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1318 frame_number = ost->frame_number;
1319 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1320 if (enc->flags&CODEC_FLAG_PSNR)
1321 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1322
1323 fprintf(vstats_file,"f_size= %6d ", frame_size);
1324 /* compute pts value */
1325 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1326 if (ti1 < 0.01)
1327 ti1 = 0.01;
1328
1329 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1330 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1331 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1332 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1333 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1334 }
1335}
1336
1337static void print_report(AVFormatContext **output_files,
1338 OutputStream **ost_table, int nb_ostreams,
1339 int is_last_report)
1340{
1341 char buf[1024];
1342 OutputStream *ost;
1343 AVFormatContext *oc;
1344 int64_t total_size;
1345 AVCodecContext *enc;
1346 int frame_number, vid, i;
1347 double bitrate, ti1, pts;
1348 static int64_t last_time = -1;
1349 static int qp_histogram[52];
1350
1351 if (!is_last_report) {
1352 int64_t cur_time;
1353 /* display the report every 0.5 seconds */
1354 cur_time = av_gettime();
1355 if (last_time == -1) {
1356 last_time = cur_time;
1357 return;
1358 }
1359 if ((cur_time - last_time) < 500000)
1360 return;
1361 last_time = cur_time;
1362 }
1363
1364
1365 oc = output_files[0];
1366
1367 total_size = avio_size(oc->pb);
1368 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1369 total_size= avio_tell(oc->pb);
1370
1371 buf[0] = '\0';
1372 ti1 = 1e10;
1373 vid = 0;
1374 for(i=0;i<nb_ostreams;i++) {
1375 float q = -1;
1376 ost = ost_table[i];
1377 enc = ost->st->codec;
1378 if (!ost->st->stream_copy && enc->coded_frame)
1379 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1380 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1381 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1382 }
1383 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1384 float t = (av_gettime()-timer_start) / 1000000.0;
1385
1386 frame_number = ost->frame_number;
1387 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1388 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1389 if(is_last_report)
1390 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1391 if(qp_hist){
1392 int j;
1393 int qp = lrintf(q);
1394 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1395 qp_histogram[qp]++;
1396 for(j=0; j<32; j++)
1397 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1398 }
1399 if (enc->flags&CODEC_FLAG_PSNR){
1400 int j;
1401 double error, error_sum=0;
1402 double scale, scale_sum=0;
1403 char type[3]= {'Y','U','V'};
1404 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1405 for(j=0; j<3; j++){
1406 if(is_last_report){
1407 error= enc->error[j];
1408 scale= enc->width*enc->height*255.0*255.0*frame_number;
1409 }else{
1410 error= enc->coded_frame->error[j];
1411 scale= enc->width*enc->height*255.0*255.0;
1412 }
1413 if(j) scale/=4;
1414 error_sum += error;
1415 scale_sum += scale;
1416 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1417 }
1418 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1419 }
1420 vid = 1;
1421 }
1422 /* compute min output value */
1423 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1424 if ((pts < ti1) && (pts > 0))
1425 ti1 = pts;
1426 }
1427 if (ti1 < 0.01)
1428 ti1 = 0.01;
1429
1430 if (verbose > 0 || is_last_report) {
1431 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1432
1433 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1434 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1435 (double)total_size / 1024, ti1, bitrate);
1436
1437 if (nb_frames_dup || nb_frames_drop)
1438 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1439 nb_frames_dup, nb_frames_drop);
1440
1441 if (verbose >= 0)
1442 fprintf(stderr, "%s \r", buf);
1443
1444 fflush(stderr);
1445 }
1446
1447 if (is_last_report && verbose >= 0){
1448 int64_t raw= audio_size + video_size + extra_size;
1449 fprintf(stderr, "\n");
1450 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1451 video_size/1024.0,
1452 audio_size/1024.0,
1453 extra_size/1024.0,
1454 100.0*(total_size - raw)/raw
1455 );
1456 }
1457}
1458
1459static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1460{
1461 int fill_char = 0x00;
1462 if (sample_fmt == AV_SAMPLE_FMT_U8)
1463 fill_char = 0x80;
1464 memset(buf, fill_char, size);
1465}
1466
1467/* pkt = NULL means EOF (needed to flush decoder buffers) */
1468static int output_packet(InputStream *ist, int ist_index,
1469 OutputStream **ost_table, int nb_ostreams,
1470 const AVPacket *pkt)
1471{
1472 AVFormatContext *os;
1473 OutputStream *ost;
1474 int ret, i;
1475 int got_output;
1476 AVFrame picture;
1477 void *buffer_to_free = NULL;
1478 static unsigned int samples_size= 0;
1479 AVSubtitle subtitle, *subtitle_to_free;
1480 int64_t pkt_pts = AV_NOPTS_VALUE;
1481#if CONFIG_AVFILTER
1482 int frame_available;
1483#endif
1484 float quality;
1485
1486 AVPacket avpkt;
1487 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1488
1489 if(ist->next_pts == AV_NOPTS_VALUE)
1490 ist->next_pts= ist->pts;
1491
1492 if (pkt == NULL) {
1493 /* EOF handling */
1494 av_init_packet(&avpkt);
1495 avpkt.data = NULL;
1496 avpkt.size = 0;
1497 goto handle_eof;
1498 } else {
1499 avpkt = *pkt;
1500 }
1501
1502 if(pkt->dts != AV_NOPTS_VALUE)
1503 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1504 if(pkt->pts != AV_NOPTS_VALUE)
1505 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1506
1507 //while we have more to decode or while the decoder did output something on EOF
1508 while (avpkt.size > 0 || (!pkt && got_output)) {
1509 uint8_t *data_buf, *decoded_data_buf;
1510 int data_size, decoded_data_size;
1511 handle_eof:
1512 ist->pts= ist->next_pts;
1513
1514 if(avpkt.size && avpkt.size != pkt->size &&
1515 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1516 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1517 ist->showed_multi_packet_warning=1;
1518 }
1519
1520 /* decode the packet if needed */
1521 decoded_data_buf = NULL; /* fail safe */
1522 decoded_data_size= 0;
1523 data_buf = avpkt.data;
1524 data_size = avpkt.size;
1525 subtitle_to_free = NULL;
1526 if (ist->decoding_needed) {
1527 switch(ist->st->codec->codec_type) {
1528 case AVMEDIA_TYPE_AUDIO:{
1529 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1530 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1531 av_free(samples);
1532 samples= av_malloc(samples_size);
1533 }
1534 decoded_data_size= samples_size;
1535 /* XXX: could avoid copy if PCM 16 bits with same
1536 endianness as CPU */
1537 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1538 &avpkt);
1539 if (ret < 0)
1540 return ret;
1541 avpkt.data += ret;
1542 avpkt.size -= ret;
1543 data_size = ret;
1544 got_output = decoded_data_size > 0;
1545 /* Some bug in mpeg audio decoder gives */
1546 /* decoded_data_size < 0, it seems they are overflows */
1547 if (!got_output) {
1548 /* no audio frame */
1549 continue;
1550 }
1551 decoded_data_buf = (uint8_t *)samples;
1552 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1553 (ist->st->codec->sample_rate * ist->st->codec->channels);
1554 break;}
1555 case AVMEDIA_TYPE_VIDEO:
1556 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1557 /* XXX: allocate picture correctly */
1558 avcodec_get_frame_defaults(&picture);
1559 avpkt.pts = pkt_pts;
1560 avpkt.dts = ist->pts;
1561 pkt_pts = AV_NOPTS_VALUE;
1562
1563 ret = avcodec_decode_video2(ist->st->codec,
1564 &picture, &got_output, &avpkt);
1565 quality = same_quality ? picture.quality : 0;
1566 if (ret < 0)
1567 return ret;
1568 if (!got_output) {
1569 /* no picture yet */
1570 goto discard_packet;
1571 }
1572 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1573 if (ist->st->codec->time_base.num != 0) {
1574 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1575 ist->next_pts += ((int64_t)AV_TIME_BASE *
1576 ist->st->codec->time_base.num * ticks) /
1577 ist->st->codec->time_base.den;
1578 }
1579 avpkt.size = 0;
1580 buffer_to_free = NULL;
1581 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1582 break;
1583 case AVMEDIA_TYPE_SUBTITLE:
1584 ret = avcodec_decode_subtitle2(ist->st->codec,
1585 &subtitle, &got_output, &avpkt);
1586 if (ret < 0)
1587 return ret;
1588 if (!got_output) {
1589 goto discard_packet;
1590 }
1591 subtitle_to_free = &subtitle;
1592 avpkt.size = 0;
1593 break;
1594 default:
1595 return -1;
1596 }
1597 } else {
1598 switch(ist->st->codec->codec_type) {
1599 case AVMEDIA_TYPE_AUDIO:
1600 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1601 ist->st->codec->sample_rate;
1602 break;
1603 case AVMEDIA_TYPE_VIDEO:
1604 if (ist->st->codec->time_base.num != 0) {
1605 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1606 ist->next_pts += ((int64_t)AV_TIME_BASE *
1607 ist->st->codec->time_base.num * ticks) /
1608 ist->st->codec->time_base.den;
1609 }
1610 break;
1611 }
1612 ret = avpkt.size;
1613 avpkt.size = 0;
1614 }
1615
1616#if CONFIG_AVFILTER
1617 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1618 for (i = 0; i < nb_ostreams; i++) {
1619 ost = ost_table[i];
1620 if (ost->input_video_filter && ost->source_index == ist_index) {
1621 AVRational sar;
1622 if (ist->st->sample_aspect_ratio.num)
1623 sar = ist->st->sample_aspect_ratio;
1624 else
1625 sar = ist->st->codec->sample_aspect_ratio;
1626 // add it to be filtered
1627 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture,
1628 ist->pts,
1629 sar);
1630 }
1631 }
1632 }
1633#endif
1634
1635 // preprocess audio (volume)
1636 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1637 if (audio_volume != 256) {
1638 short *volp;
1639 volp = samples;
1640 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1641 int v = ((*volp) * audio_volume + 128) >> 8;
1642 if (v < -32768) v = -32768;
1643 if (v > 32767) v = 32767;
1644 *volp++ = v;
1645 }
1646 }
1647 }
1648
1649 /* frame rate emulation */
1650 if (rate_emu) {
1651 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1652 int64_t now = av_gettime() - ist->start;
1653 if (pts > now)
1654 usleep(pts - now);
1655 }
1656 /* if output time reached then transcode raw format,
1657 encode packets and output them */
1658 if (start_time == 0 || ist->pts >= start_time)
1659 for(i=0;i<nb_ostreams;i++) {
1660 int frame_size;
1661
1662 ost = ost_table[i];
1663 if (ost->source_index == ist_index) {
1664#if CONFIG_AVFILTER
1665 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1666 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1667 while (frame_available) {
1668 AVRational ist_pts_tb;
1669 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1670 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1671 if (ost->picref)
1672 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1673#endif
1674 os = output_files[ost->file_index];
1675
1676 /* set the input output pts pairs */
1677 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1678
1679 if (ost->encoding_needed) {
1680 av_assert0(ist->decoding_needed);
1681 switch(ost->st->codec->codec_type) {
1682 case AVMEDIA_TYPE_AUDIO:
1683 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1684 break;
1685 case AVMEDIA_TYPE_VIDEO:
1686#if CONFIG_AVFILTER
1687 if (ost->picref->video && !ost->frame_aspect_ratio)
1688 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1689#endif
1690 do_video_out(os, ost, ist, &picture, &frame_size,
1691 same_quality ? quality : ost->st->codec->global_quality);
1692 if (vstats_filename && frame_size)
1693 do_video_stats(os, ost, frame_size);
1694 break;
1695 case AVMEDIA_TYPE_SUBTITLE:
1696 do_subtitle_out(os, ost, ist, &subtitle,
1697 pkt->pts);
1698 break;
1699 default:
1700 abort();
1701 }
1702 } else {
1703 AVFrame avframe; //FIXME/XXX remove this
1704 AVPacket opkt;
1705 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1706
1707 av_init_packet(&opkt);
1708
1709 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1710#if !CONFIG_AVFILTER
1711 continue;
1712#else
1713 goto cont;
1714#endif
1715
1716 /* no reencoding needed : output the packet directly */
1717 /* force the input stream PTS */
1718
1719 avcodec_get_frame_defaults(&avframe);
1720 ost->st->codec->coded_frame= &avframe;
1721 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1722
1723 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1724 audio_size += data_size;
1725 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1726 video_size += data_size;
1727 ost->sync_opts++;
1728 }
1729
1730 opkt.stream_index= ost->index;
1731 if(pkt->pts != AV_NOPTS_VALUE)
1732 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1733 else
1734 opkt.pts= AV_NOPTS_VALUE;
1735
1736 if (pkt->dts == AV_NOPTS_VALUE)
1737 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1738 else
1739 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1740 opkt.dts -= ost_tb_start_time;
1741
1742 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1743 opkt.flags= pkt->flags;
1744
1745 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1746 if( ost->st->codec->codec_id != CODEC_ID_H264
1747 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1748 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1749 ) {
1750 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1751 opkt.destruct= av_destruct_packet;
1752 } else {
1753 opkt.data = data_buf;
1754 opkt.size = data_size;
1755 }
1756
1757 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1758 ost->st->codec->frame_number++;
1759 ost->frame_number++;
1760 av_free_packet(&opkt);
1761 }
1762#if CONFIG_AVFILTER
1763 cont:
1764 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1765 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1766 if (ost->picref)
1767 avfilter_unref_buffer(ost->picref);
1768 }
1769#endif
1770 }
1771 }
1772
1773 av_free(buffer_to_free);
1774 /* XXX: allocate the subtitles in the codec ? */
1775 if (subtitle_to_free) {
1776 avsubtitle_free(subtitle_to_free);
1777 subtitle_to_free = NULL;
1778 }
1779 }
1780 discard_packet:
1781 if (pkt == NULL) {
1782 /* EOF handling */
1783
1784 for(i=0;i<nb_ostreams;i++) {
1785 ost = ost_table[i];
1786 if (ost->source_index == ist_index) {
1787 AVCodecContext *enc= ost->st->codec;
1788 os = output_files[ost->file_index];
1789
1790 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1791 continue;
1792 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1793 continue;
1794
1795 if (ost->encoding_needed) {
1796 for(;;) {
1797 AVPacket pkt;
1798 int fifo_bytes;
1799 av_init_packet(&pkt);
1800 pkt.stream_index= ost->index;
1801
1802 switch(ost->st->codec->codec_type) {
1803 case AVMEDIA_TYPE_AUDIO:
1804 fifo_bytes = av_fifo_size(ost->fifo);
1805 ret = 0;
1806 /* encode any samples remaining in fifo */
1807 if (fifo_bytes > 0) {
1808 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1809 int fs_tmp = enc->frame_size;
1810
1811 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1812 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1813 enc->frame_size = fifo_bytes / (osize * enc->channels);
1814 } else { /* pad */
1815 int frame_bytes = enc->frame_size*osize*enc->channels;
1816 if (allocated_audio_buf_size < frame_bytes)
1817 exit_program(1);
1818 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1819 }
1820
1821 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1822 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1823 ost->st->time_base.num, enc->sample_rate);
1824 enc->frame_size = fs_tmp;
1825 }
1826 if(ret <= 0) {
1827 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1828 }
1829 if (ret < 0) {
1830 fprintf(stderr, "Audio encoding failed\n");
1831 exit_program(1);
1832 }
1833 audio_size += ret;
1834 pkt.flags |= AV_PKT_FLAG_KEY;
1835 break;
1836 case AVMEDIA_TYPE_VIDEO:
1837 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1838 if (ret < 0) {
1839 fprintf(stderr, "Video encoding failed\n");
1840 exit_program(1);
1841 }
1842 video_size += ret;
1843 if(enc->coded_frame && enc->coded_frame->key_frame)
1844 pkt.flags |= AV_PKT_FLAG_KEY;
1845 if (ost->logfile && enc->stats_out) {
1846 fprintf(ost->logfile, "%s", enc->stats_out);
1847 }
1848 break;
1849 default:
1850 ret=-1;
1851 }
1852
1853 if(ret<=0)
1854 break;
1855 pkt.data= bit_buffer;
1856 pkt.size= ret;
1857 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1858 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1859 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1860 }
1861 }
1862 }
1863 }
1864 }
1865
1866 return 0;
1867}
1868
1869static void print_sdp(AVFormatContext **avc, int n)
1870{
1871 char sdp[2048];
1872
1873 av_sdp_create(avc, n, sdp, sizeof(sdp));
1874 printf("SDP:\n%s\n", sdp);
1875 fflush(stdout);
1876}
1877
1878static int copy_chapters(int infile, int outfile)
1879{
1880 AVFormatContext *is = input_files[infile].ctx;
1881 AVFormatContext *os = output_files[outfile];
1882 int i;
1883
1884 for (i = 0; i < is->nb_chapters; i++) {
1885 AVChapter *in_ch = is->chapters[i], *out_ch;
1886 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
1887 AV_TIME_BASE_Q, in_ch->time_base);
1888 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
1889 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
1890
1891
1892 if (in_ch->end < ts_off)
1893 continue;
1894 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
1895 break;
1896
1897 out_ch = av_mallocz(sizeof(AVChapter));
1898 if (!out_ch)
1899 return AVERROR(ENOMEM);
1900
1901 out_ch->id = in_ch->id;
1902 out_ch->time_base = in_ch->time_base;
1903 out_ch->start = FFMAX(0, in_ch->start - ts_off);
1904 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
1905
1906 if (metadata_chapters_autocopy)
1907 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
1908
1909 os->nb_chapters++;
1910 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
1911 if (!os->chapters)
1912 return AVERROR(ENOMEM);
1913 os->chapters[os->nb_chapters - 1] = out_ch;
1914 }
1915 return 0;
1916}
1917
1918static void parse_forced_key_frames(char *kf, OutputStream *ost,
1919 AVCodecContext *avctx)
1920{
1921 char *p;
1922 int n = 1, i;
1923 int64_t t;
1924
1925 for (p = kf; *p; p++)
1926 if (*p == ',')
1927 n++;
1928 ost->forced_kf_count = n;
1929 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1930 if (!ost->forced_kf_pts) {
1931 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1932 exit_program(1);
1933 }
1934 for (i = 0; i < n; i++) {
1935 p = i ? strchr(p, ',') + 1 : kf;
1936 t = parse_time_or_die("force_key_frames", p, 1);
1937 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1938 }
1939}
1940
1941/*
1942 * The following code is the main loop of the file converter
1943 */
1944static int transcode(AVFormatContext **output_files,
1945 int nb_output_files,
1946 InputFile *input_files,
1947 int nb_input_files,
1948 StreamMap *stream_maps, int nb_stream_maps)
1949{
1950 int ret = 0, i, j, k, n, nb_ostreams = 0;
1951 AVFormatContext *is, *os;
1952 AVCodecContext *codec, *icodec;
1953 OutputStream *ost, **ost_table = NULL;
1954 InputStream *ist;
1955 char error[1024];
1956 int want_sdp = 1;
1957 uint8_t no_packet[MAX_FILES]={0};
1958 int no_packet_count=0;
1959
1960 if (rate_emu)
1961 for (i = 0; i < nb_input_streams; i++)
1962 input_streams[i].start = av_gettime();
1963
1964 /* output stream init */
1965 nb_ostreams = 0;
1966 for(i=0;i<nb_output_files;i++) {
1967 os = output_files[i];
1968 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1969 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
1970 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1971 ret = AVERROR(EINVAL);
1972 goto fail;
1973 }
1974 nb_ostreams += os->nb_streams;
1975 }
1976 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1977 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1978 ret = AVERROR(EINVAL);
1979 goto fail;
1980 }
1981
1982 /* Sanity check the mapping args -- do the input files & streams exist? */
1983 for(i=0;i<nb_stream_maps;i++) {
1984 int fi = stream_maps[i].file_index;
1985 int si = stream_maps[i].stream_index;
1986
1987 if (fi < 0 || fi > nb_input_files - 1 ||
1988 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1989 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1990 ret = AVERROR(EINVAL);
1991 goto fail;
1992 }
1993 fi = stream_maps[i].sync_file_index;
1994 si = stream_maps[i].sync_stream_index;
1995 if (fi < 0 || fi > nb_input_files - 1 ||
1996 si < 0 || si > input_files[fi].ctx->nb_streams - 1) {
1997 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1998 ret = AVERROR(EINVAL);
1999 goto fail;
2000 }
2001 }
2002
2003 ost_table = av_mallocz(sizeof(OutputStream *) * nb_ostreams);
2004 if (!ost_table)
2005 goto fail;
2006 n = 0;
2007 for(k=0;k<nb_output_files;k++) {
2008 os = output_files[k];
2009 for(i=0;i<os->nb_streams;i++,n++) {
2010 int found;
2011 ost = ost_table[n] = output_streams_for_file[k][i];
2012 if (nb_stream_maps > 0) {
2013 ost->source_index = input_files[stream_maps[n].file_index].ist_index +
2014 stream_maps[n].stream_index;
2015
2016 /* Sanity check that the stream types match */
2017 if (input_streams[ost->source_index].st->codec->codec_type != ost->st->codec->codec_type) {
2018 int i= ost->file_index;
2019 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2020 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
2021 stream_maps[n].file_index, stream_maps[n].stream_index,
2022 ost->file_index, ost->index);
2023 exit_program(1);
2024 }
2025
2026 } else {
2027 int best_nb_frames=-1;
2028 /* get corresponding input stream index : we select the first one with the right type */
2029 found = 0;
2030 for (j = 0; j < nb_input_streams; j++) {
2031 int skip=0;
2032 ist = &input_streams[j];
2033 if(opt_programid){
2034 int pi,si;
2035 AVFormatContext *f = input_files[ist->file_index].ctx;
2036 skip=1;
2037 for(pi=0; pi<f->nb_programs; pi++){
2038 AVProgram *p= f->programs[pi];
2039 if(p->id == opt_programid)
2040 for(si=0; si<p->nb_stream_indexes; si++){
2041 if(f->streams[ p->stream_index[si] ] == ist->st)
2042 skip=0;
2043 }
2044 }
2045 }
2046 if (ist->discard && ist->st->discard != AVDISCARD_ALL && !skip &&
2047 ist->st->codec->codec_type == ost->st->codec->codec_type) {
2048 if(best_nb_frames < ist->st->codec_info_nb_frames){
2049 best_nb_frames= ist->st->codec_info_nb_frames;
2050 ost->source_index = j;
2051 found = 1;
2052 }
2053 }
2054 }
2055
2056 if (!found) {
2057 if(! opt_programid) {
2058 /* try again and reuse existing stream */
2059 for (j = 0; j < nb_input_streams; j++) {
2060 ist = &input_streams[j];
2061 if ( ist->st->codec->codec_type == ost->st->codec->codec_type
2062 && ist->st->discard != AVDISCARD_ALL) {
2063 ost->source_index = j;
2064 found = 1;
2065 }
2066 }
2067 }
2068 if (!found) {
2069 int i= ost->file_index;
2070 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2071 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
2072 ost->file_index, ost->index);
2073 exit_program(1);
2074 }
2075 }
2076 }
2077 ist = &input_streams[ost->source_index];
2078 ist->discard = 0;
2079 ost->sync_ist = (nb_stream_maps > 0) ?
2080 &input_streams[input_files[stream_maps[n].sync_file_index].ist_index +
2081 stream_maps[n].sync_stream_index] : ist;
2082 }
2083 }
2084
2085 /* for each output stream, we compute the right encoding parameters */
2086 for(i=0;i<nb_ostreams;i++) {
2087 ost = ost_table[i];
2088 os = output_files[ost->file_index];
2089 ist = &input_streams[ost->source_index];
2090
2091 codec = ost->st->codec;
2092 icodec = ist->st->codec;
2093
2094 if (metadata_streams_autocopy)
2095 av_dict_copy(&ost->st->metadata, ist->st->metadata,
2096 AV_DICT_DONT_OVERWRITE);
2097
2098 ost->st->disposition = ist->st->disposition;
2099 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2100 codec->chroma_sample_location = icodec->chroma_sample_location;
2101
2102 if (ost->st->stream_copy) {
2103 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2104
2105 if (extra_size > INT_MAX)
2106 goto fail;
2107
2108 /* if stream_copy is selected, no need to decode or encode */
2109 codec->codec_id = icodec->codec_id;
2110 codec->codec_type = icodec->codec_type;
2111
2112 if(!codec->codec_tag){
2113 if( !os->oformat->codec_tag
2114 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2115 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2116 codec->codec_tag = icodec->codec_tag;
2117 }
2118
2119 codec->bit_rate = icodec->bit_rate;
2120 codec->rc_max_rate = icodec->rc_max_rate;
2121 codec->rc_buffer_size = icodec->rc_buffer_size;
2122 codec->extradata= av_mallocz(extra_size);
2123 if (!codec->extradata)
2124 goto fail;
2125 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2126 codec->extradata_size= icodec->extradata_size;
2127 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2128 codec->time_base = icodec->time_base;
2129 codec->time_base.num *= icodec->ticks_per_frame;
2130 av_reduce(&codec->time_base.num, &codec->time_base.den,
2131 codec->time_base.num, codec->time_base.den, INT_MAX);
2132 }else
2133 codec->time_base = ist->st->time_base;
2134 switch(codec->codec_type) {
2135 case AVMEDIA_TYPE_AUDIO:
2136 if(audio_volume != 256) {
2137 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2138 exit_program(1);
2139 }
2140 codec->channel_layout = icodec->channel_layout;
2141 codec->sample_rate = icodec->sample_rate;
2142 codec->channels = icodec->channels;
2143 codec->frame_size = icodec->frame_size;
2144 codec->audio_service_type = icodec->audio_service_type;
2145 codec->block_align= icodec->block_align;
2146 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2147 codec->block_align= 0;
2148 if(codec->codec_id == CODEC_ID_AC3)
2149 codec->block_align= 0;
2150 break;
2151 case AVMEDIA_TYPE_VIDEO:
2152 codec->pix_fmt = icodec->pix_fmt;
2153 codec->width = icodec->width;
2154 codec->height = icodec->height;
2155 codec->has_b_frames = icodec->has_b_frames;
2156 if (!codec->sample_aspect_ratio.num) {
2157 codec->sample_aspect_ratio =
2158 ost->st->sample_aspect_ratio =
2159 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2160 ist->st->codec->sample_aspect_ratio.num ?
2161 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2162 }
2163 break;
2164 case AVMEDIA_TYPE_SUBTITLE:
2165 codec->width = icodec->width;
2166 codec->height = icodec->height;
2167 break;
2168 case AVMEDIA_TYPE_DATA:
2169 break;
2170 default:
2171 abort();
2172 }
2173 } else {
2174 if (!ost->enc)
2175 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2176 switch(codec->codec_type) {
2177 case AVMEDIA_TYPE_AUDIO:
2178 ost->fifo= av_fifo_alloc(1024);
2179 if(!ost->fifo)
2180 goto fail;
2181 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2182 if (!codec->sample_rate) {
2183 codec->sample_rate = icodec->sample_rate;
2184 if (icodec->lowres)
2185 codec->sample_rate >>= icodec->lowres;
2186 }
2187 choose_sample_rate(ost->st, ost->enc);
2188 codec->time_base = (AVRational){1, codec->sample_rate};
2189 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2190 codec->sample_fmt = icodec->sample_fmt;
2191 choose_sample_fmt(ost->st, ost->enc);
2192 if (!codec->channels)
2193 codec->channels = icodec->channels;
2194 codec->channel_layout = icodec->channel_layout;
2195 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2196 codec->channel_layout = 0;
2197 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2198 icodec->request_channels = codec->channels;
2199 ist->decoding_needed = 1;
2200 ost->encoding_needed = 1;
2201 ost->resample_sample_fmt = icodec->sample_fmt;
2202 ost->resample_sample_rate = icodec->sample_rate;
2203 ost->resample_channels = icodec->channels;
2204 break;
2205 case AVMEDIA_TYPE_VIDEO:
2206 if (codec->pix_fmt == PIX_FMT_NONE)
2207 codec->pix_fmt = icodec->pix_fmt;
2208 choose_pixel_fmt(ost->st, ost->enc);
2209
2210 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2211 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2212 exit_program(1);
2213 }
2214
2215 if (!codec->width || !codec->height) {
2216 codec->width = icodec->width;
2217 codec->height = icodec->height;
2218 }
2219
2220 ost->video_resample = codec->width != icodec->width ||
2221 codec->height != icodec->height ||
2222 codec->pix_fmt != icodec->pix_fmt;
2223 if (ost->video_resample) {
2224#if !CONFIG_AVFILTER
2225 avcodec_get_frame_defaults(&ost->pict_tmp);
2226 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2227 codec->width, codec->height)) {
2228 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2229 exit_program(1);
2230 }
2231 ost->img_resample_ctx = sws_getContext(
2232 icodec->width,
2233 icodec->height,
2234 icodec->pix_fmt,
2235 codec->width,
2236 codec->height,
2237 codec->pix_fmt,
2238 ost->sws_flags, NULL, NULL, NULL);
2239 if (ost->img_resample_ctx == NULL) {
2240 fprintf(stderr, "Cannot get resampling context\n");
2241 exit_program(1);
2242 }
2243#endif
2244 codec->bits_per_raw_sample= 0;
2245 }
2246
2247 ost->resample_height = icodec->height;
2248 ost->resample_width = icodec->width;
2249 ost->resample_pix_fmt= icodec->pix_fmt;
2250 ost->encoding_needed = 1;
2251 ist->decoding_needed = 1;
2252
2253 if (!ost->frame_rate.num)
2254 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2255 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2256 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2257 ost->frame_rate = ost->enc->supported_framerates[idx];
2258 }
2259 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2260
2261#if CONFIG_AVFILTER
2262 if (configure_video_filters(ist, ost)) {
2263 fprintf(stderr, "Error opening filters!\n");
2264 exit(1);
2265 }
2266#endif
2267 break;
2268 case AVMEDIA_TYPE_SUBTITLE:
2269 ost->encoding_needed = 1;
2270 ist->decoding_needed = 1;
2271 break;
2272 default:
2273 abort();
2274 break;
2275 }
2276 /* two pass mode */
2277 if (ost->encoding_needed &&
2278 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2279 char logfilename[1024];
2280 FILE *f;
2281
2282 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2283 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2284 i);
2285 if (codec->flags & CODEC_FLAG_PASS1) {
2286 f = fopen(logfilename, "wb");
2287 if (!f) {
2288 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2289 exit_program(1);
2290 }
2291 ost->logfile = f;
2292 } else {
2293 char *logbuffer;
2294 size_t logbuffer_size;
2295 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2296 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2297 exit_program(1);
2298 }
2299 codec->stats_in = logbuffer;
2300 }
2301 }
2302 }
2303 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2304 int size= codec->width * codec->height;
2305 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2306 }
2307 }
2308
2309 if (!bit_buffer)
2310 bit_buffer = av_malloc(bit_buffer_size);
2311 if (!bit_buffer) {
2312 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2313 bit_buffer_size);
2314 ret = AVERROR(ENOMEM);
2315 goto fail;
2316 }
2317
2318 /* open each encoder */
2319 for(i=0;i<nb_ostreams;i++) {
2320 ost = ost_table[i];
2321 if (ost->encoding_needed) {
2322 AVCodec *codec = ost->enc;
2323 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2324 if (!codec) {
2325 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2326 ost->st->codec->codec_id, ost->file_index, ost->index);
2327 ret = AVERROR(EINVAL);
2328 goto dump_format;
2329 }
2330 if (dec->subtitle_header) {
2331 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2332 if (!ost->st->codec->subtitle_header) {
2333 ret = AVERROR(ENOMEM);
2334 goto dump_format;
2335 }
2336 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2337 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2338 }
2339 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2340 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2341 ost->file_index, ost->index);
2342 ret = AVERROR(EINVAL);
2343 goto dump_format;
2344 }
2345 assert_codec_experimental(ost->st->codec, 1);
2346 assert_avoptions(ost->opts);
2347 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2348 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2349 "It takes bits/s as argument, not kbits/s\n");
2350 extra_size += ost->st->codec->extradata_size;
2351 }
2352 }
2353
2354 /* open each decoder */
2355 for (i = 0; i < nb_input_streams; i++) {
2356 ist = &input_streams[i];
2357 if (ist->decoding_needed) {
2358 AVCodec *codec = ist->dec;
2359 if (!codec)
2360 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2361 if (!codec) {
2362 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2363 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2364 ret = AVERROR(EINVAL);
2365 goto dump_format;
2366 }
2367
2368 /* update requested sample format for the decoder based on the
2369 corresponding encoder sample format */
2370 for (j = 0; j < nb_ostreams; j++) {
2371 ost = ost_table[j];
2372 if (ost->source_index == i) {
2373 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2374 break;
2375 }
2376 }
2377
2378 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2379 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2380 ist->file_index, ist->st->index);
2381 ret = AVERROR(EINVAL);
2382 goto dump_format;
2383 }
2384 assert_codec_experimental(ist->st->codec, 0);
2385 assert_avoptions(ost->opts);
2386 //if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
2387 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2388 }
2389 }
2390
2391 /* init pts */
2392 for (i = 0; i < nb_input_streams; i++) {
2393 AVStream *st;
2394 ist = &input_streams[i];
2395 st= ist->st;
2396 ist->pts = st->avg_frame_rate.num ? - st->codec->has_b_frames*AV_TIME_BASE / av_q2d(st->avg_frame_rate) : 0;
2397 ist->next_pts = AV_NOPTS_VALUE;
2398 init_pts_correction(&ist->pts_ctx);
2399 ist->is_start = 1;
2400 }
2401
2402 /* set meta data information from input file if required */
2403 for (i=0;i<nb_meta_data_maps;i++) {
2404 AVFormatContext *files[2];
2405 AVDictionary **meta[2];
2406 int j;
2407
2408#define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2409 if ((index) < 0 || (index) >= (nb_elems)) {\
2410 snprintf(error, sizeof(error), "Invalid %s index %d while processing metadata maps\n",\
2411 (desc), (index));\
2412 ret = AVERROR(EINVAL);\
2413 goto dump_format;\
2414 }
2415
2416 int out_file_index = meta_data_maps[i][0].file;
2417 int in_file_index = meta_data_maps[i][1].file;
2418 if (in_file_index < 0 || out_file_index < 0)
2419 continue;
2420 METADATA_CHECK_INDEX(out_file_index, nb_output_files, "output file")
2421 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
2422
2423 files[0] = output_files[out_file_index];
2424 files[1] = input_files[in_file_index].ctx;
2425
2426 for (j = 0; j < 2; j++) {
2427 MetadataMap *map = &meta_data_maps[i][j];
2428
2429 switch (map->type) {
2430 case 'g':
2431 meta[j] = &files[j]->metadata;
2432 break;
2433 case 's':
2434 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
2435 meta[j] = &files[j]->streams[map->index]->metadata;
2436 break;
2437 case 'c':
2438 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
2439 meta[j] = &files[j]->chapters[map->index]->metadata;
2440 break;
2441 case 'p':
2442 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
2443 meta[j] = &files[j]->programs[map->index]->metadata;
2444 break;
2445 }
2446 }
2447
2448 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
2449 }
2450
2451 /* copy global metadata by default */
2452 if (metadata_global_autocopy) {
2453
2454 for (i = 0; i < nb_output_files; i++)
2455 av_dict_copy(&output_files[i]->metadata, input_files[0].ctx->metadata,
2456 AV_DICT_DONT_OVERWRITE);
2457 }
2458
6291d7e4
AK
2459 /* open files and write file headers */
2460 for(i=0;i<nb_output_files;i++) {
2461 os = output_files[i];
2462 if (avformat_write_header(os, &output_opts[i]) < 0) {
2463 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2464 ret = AVERROR(EINVAL);
2465 goto dump_format;
2466 }
2467 assert_avoptions(output_opts[i]);
2468 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2469 want_sdp = 0;
2470 }
2471 }
2472
2473 dump_format:
2474 /* dump the file output parameters - cannot be done before in case
2475 of stream copy */
2476 for(i=0;i<nb_output_files;i++) {
2477 av_dump_format(output_files[i], i, output_files[i]->filename, 1);
2478 }
2479
2480 /* dump the stream mapping */
2481 if (verbose >= 0) {
2482 fprintf(stderr, "Stream mapping:\n");
2483 for(i=0;i<nb_ostreams;i++) {
2484 ost = ost_table[i];
2485 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2486 input_streams[ost->source_index].file_index,
2487 input_streams[ost->source_index].st->index,
2488 ost->file_index,
2489 ost->index);
2490 if (ost->sync_ist != &input_streams[ost->source_index])
2491 fprintf(stderr, " [sync #%d.%d]",
2492 ost->sync_ist->file_index,
2493 ost->sync_ist->st->index);
2494 fprintf(stderr, "\n");
2495 }
2496 }
2497
2498 if (ret) {
2499 fprintf(stderr, "%s\n", error);
2500 goto fail;
2501 }
2502
2503 if (want_sdp) {
2504 print_sdp(output_files, nb_output_files);
2505 }
2506
2507 if (verbose >= 0)
2508 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2509 term_init();
2510
2511 timer_start = av_gettime();
2512
2513 for(; received_sigterm == 0;) {
2514 int file_index, ist_index;
2515 AVPacket pkt;
2516 double ipts_min;
2517 double opts_min;
2518
2519 redo:
2520 ipts_min= 1e100;
2521 opts_min= 1e100;
2522
2523 /* select the stream that we must read now by looking at the
2524 smallest output pts */
2525 file_index = -1;
2526 for(i=0;i<nb_ostreams;i++) {
2527 double ipts, opts;
2528 ost = ost_table[i];
2529 os = output_files[ost->file_index];
2530 ist = &input_streams[ost->source_index];
2531 if(ist->is_past_recording_time || no_packet[ist->file_index])
2532 continue;
2533 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2534 ipts = (double)ist->pts;
2535 if (!input_files[ist->file_index].eof_reached){
2536 if(ipts < ipts_min) {
2537 ipts_min = ipts;
2538 if(input_sync ) file_index = ist->file_index;
2539 }
2540 if(opts < opts_min) {
2541 opts_min = opts;
2542 if(!input_sync) file_index = ist->file_index;
2543 }
2544 }
2545 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2546 file_index= -1;
2547 break;
2548 }
2549 }
2550 /* if none, if is finished */
2551 if (file_index < 0) {
2552 if(no_packet_count){
2553 no_packet_count=0;
2554 memset(no_packet, 0, sizeof(no_packet));
2555 usleep(10000);
2556 continue;
2557 }
2558 break;
2559 }
2560
2561 /* finish if limit size exhausted */
2562 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0]->pb))
2563 break;
2564
2565 /* read a frame from it and output it in the fifo */
2566 is = input_files[file_index].ctx;
2567 ret= av_read_frame(is, &pkt);
2568 if(ret == AVERROR(EAGAIN)){
2569 no_packet[file_index]=1;
2570 no_packet_count++;
2571 continue;
2572 }
2573 if (ret < 0) {
2574 input_files[file_index].eof_reached = 1;
2575 if (opt_shortest)
2576 break;
2577 else
2578 continue;
2579 }
2580
2581 no_packet_count=0;
2582 memset(no_packet, 0, sizeof(no_packet));
2583
2584 if (do_pkt_dump) {
2585 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2586 is->streams[pkt.stream_index]);
2587 }
2588 /* the following test is needed in case new streams appear
2589 dynamically in stream : we ignore them */
2590 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2591 goto discard_packet;
2592 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2593 ist = &input_streams[ist_index];
2594 if (ist->discard)
2595 goto discard_packet;
2596
2597 if (pkt.dts != AV_NOPTS_VALUE)
2598 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2599 if (pkt.pts != AV_NOPTS_VALUE)
2600 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2601
2602 if (ist->ts_scale) {
2603 if(pkt.pts != AV_NOPTS_VALUE)
2604 pkt.pts *= ist->ts_scale;
2605 if(pkt.dts != AV_NOPTS_VALUE)
2606 pkt.dts *= ist->ts_scale;
2607 }
2608
2609// fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2610 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2611 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2612 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2613 int64_t delta= pkt_dts - ist->next_pts;
2614 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2615 input_files[ist->file_index].ts_offset -= delta;
2616 if (verbose > 2)
2617 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2618 delta, input_files[ist->file_index].ts_offset);
2619 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2620 if(pkt.pts != AV_NOPTS_VALUE)
2621 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2622 }
2623 }
2624
2625 /* finish if recording time exhausted */
2626 if (recording_time != INT64_MAX &&
2627 av_compare_ts(pkt.pts, ist->st->time_base, recording_time + start_time, (AVRational){1, 1000000}) >= 0) {
2628 ist->is_past_recording_time = 1;
2629 goto discard_packet;
2630 }
2631
2632 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2633 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2634
2635 if (verbose >= 0)
2636 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2637 ist->file_index, ist->st->index);
2638 if (exit_on_error)
2639 exit_program(1);
2640 av_free_packet(&pkt);
2641 goto redo;
2642 }
2643
2644 discard_packet:
2645 av_free_packet(&pkt);
2646
2647 /* dump report by using the output first video and audio streams */
2648 print_report(output_files, ost_table, nb_ostreams, 0);
2649 }
2650
2651 /* at the end of stream, we must flush the decoder buffers */
2652 for (i = 0; i < nb_input_streams; i++) {
2653 ist = &input_streams[i];
2654 if (ist->decoding_needed) {
2655 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2656 }
2657 }
2658
2659 term_exit();
2660
2661 /* write the trailer if needed and close file */
2662 for(i=0;i<nb_output_files;i++) {
2663 os = output_files[i];
2664 av_write_trailer(os);
2665 }
2666
2667 /* dump report by using the first video and audio streams */
2668 print_report(output_files, ost_table, nb_ostreams, 1);
2669
2670 /* close each encoder */
2671 for(i=0;i<nb_ostreams;i++) {
2672 ost = ost_table[i];
2673 if (ost->encoding_needed) {
2674 av_freep(&ost->st->codec->stats_in);
2675 avcodec_close(ost->st->codec);
2676 }
2677#if CONFIG_AVFILTER
2678 avfilter_graph_free(&ost->graph);
2679#endif
2680 }
2681
2682 /* close each decoder */
2683 for (i = 0; i < nb_input_streams; i++) {
2684 ist = &input_streams[i];
2685 if (ist->decoding_needed) {
2686 avcodec_close(ist->st->codec);
2687 }
2688 }
2689
2690 /* finished ! */
2691 ret = 0;
2692
2693 fail:
2694 av_freep(&bit_buffer);
2695
2696 if (ost_table) {
2697 for(i=0;i<nb_ostreams;i++) {
2698 ost = ost_table[i];
2699 if (ost) {
2700 if (ost->st->stream_copy)
2701 av_freep(&ost->st->codec->extradata);
2702 if (ost->logfile) {
2703 fclose(ost->logfile);
2704 ost->logfile = NULL;
2705 }
2706 av_fifo_free(ost->fifo); /* works even if fifo is not
2707 initialized but set to zero */
2708 av_freep(&ost->st->codec->subtitle_header);
2709 av_free(ost->pict_tmp.data[0]);
2710 av_free(ost->forced_kf_pts);
2711 if (ost->video_resample)
2712 sws_freeContext(ost->img_resample_ctx);
2713 if (ost->resample)
2714 audio_resample_close(ost->resample);
2715 if (ost->reformat_ctx)
2716 av_audio_convert_free(ost->reformat_ctx);
2717 av_dict_free(&ost->opts);
2718 av_free(ost);
2719 }
2720 }
2721 av_free(ost_table);
2722 }
2723 return ret;
2724}
2725
2726static int opt_format(const char *opt, const char *arg)
2727{
2728 last_asked_format = arg;
2729 return 0;
2730}
2731
2732static int opt_video_rc_override_string(const char *opt, const char *arg)
2733{
2734 video_rc_override_string = arg;
2735 return 0;
2736}
2737
2738static int opt_me_threshold(const char *opt, const char *arg)
2739{
2740 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2741 return 0;
2742}
2743
2744static int opt_verbose(const char *opt, const char *arg)
2745{
2746 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2747 return 0;
2748}
2749
2750static int opt_frame_rate(const char *opt, const char *arg)
2751{
2752 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2753 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2754 exit_program(1);
2755 }
2756 return 0;
2757}
2758
2759static int opt_frame_crop(const char *opt, const char *arg)
2760{
2761 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2762 return AVERROR(EINVAL);
2763}
2764
2765static int opt_frame_size(const char *opt, const char *arg)
2766{
2767 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2768 fprintf(stderr, "Incorrect frame size\n");
2769 return AVERROR(EINVAL);
2770 }
2771 return 0;
2772}
2773
2774static int opt_pad(const char *opt, const char *arg) {
2775 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2776 return -1;
2777}
2778
2779static int opt_frame_pix_fmt(const char *opt, const char *arg)
2780{
2781 if (strcmp(arg, "list")) {
2782 frame_pix_fmt = av_get_pix_fmt(arg);
2783 if (frame_pix_fmt == PIX_FMT_NONE) {
2784 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2785 return AVERROR(EINVAL);
2786 }
2787 } else {
2788 show_pix_fmts();
2789 exit_program(0);
2790 }
2791 return 0;
2792}
2793
2794static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2795{
2796 int x = 0, y = 0;
2797 double ar = 0;
2798 const char *p;
2799 char *end;
2800
2801 p = strchr(arg, ':');
2802 if (p) {
2803 x = strtol(arg, &end, 10);
2804 if (end == p)
2805 y = strtol(end+1, &end, 10);
2806 if (x > 0 && y > 0)
2807 ar = (double)x / (double)y;
2808 } else
2809 ar = strtod(arg, NULL);
2810
2811 if (!ar) {
2812 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2813 return AVERROR(EINVAL);
2814 }
2815 frame_aspect_ratio = ar;
2816 return 0;
2817}
2818
2819static int opt_metadata(const char *opt, const char *arg)
2820{
2821 char *mid= strchr(arg, '=');
2822
2823 if(!mid){
2824 fprintf(stderr, "Missing =\n");
2825 exit_program(1);
2826 }
2827 *mid++= 0;
2828
2829 av_dict_set(&metadata, arg, mid, 0);
2830
2831 return 0;
2832}
2833
2834static int opt_qscale(const char *opt, const char *arg)
2835{
2836 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2837 if (video_qscale == 0) {
2838 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2839 return AVERROR(EINVAL);
2840 }
2841 return 0;
2842}
2843
2844static int opt_top_field_first(const char *opt, const char *arg)
2845{
2846 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2847 return 0;
2848}
2849
2850static int opt_thread_count(const char *opt, const char *arg)
2851{
2852 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2853#if !HAVE_THREADS
2854 if (verbose >= 0)
2855 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2856#endif
2857 return 0;
2858}
2859
2860static int opt_audio_sample_fmt(const char *opt, const char *arg)
2861{
2862 if (strcmp(arg, "list")) {
2863 audio_sample_fmt = av_get_sample_fmt(arg);
2864 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2865 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2866 return AVERROR(EINVAL);
2867 }
2868 } else {
2869 int i;
2870 char fmt_str[128];
2871 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2872 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2873 exit_program(0);
2874 }
2875 return 0;
2876}
2877
2878static int opt_audio_rate(const char *opt, const char *arg)
2879{
2880 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2881 return 0;
2882}
2883
2884static int opt_audio_channels(const char *opt, const char *arg)
2885{
2886 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2887 return 0;
2888}
2889
6291d7e4
AK
2890static int opt_codec(int *pstream_copy, char **pcodec_name,
2891 int codec_type, const char *arg)
2892{
2893 av_freep(pcodec_name);
2894 if (!strcmp(arg, "copy")) {
2895 *pstream_copy = 1;
2896 } else {
2897 *pcodec_name = av_strdup(arg);
2898 }
2899 return 0;
2900}
2901
2902static int opt_audio_codec(const char *opt, const char *arg)
2903{
2904 return opt_codec(&audio_stream_copy, &audio_codec_name, AVMEDIA_TYPE_AUDIO, arg);
2905}
2906
2907static int opt_video_codec(const char *opt, const char *arg)
2908{
2909 return opt_codec(&video_stream_copy, &video_codec_name, AVMEDIA_TYPE_VIDEO, arg);
2910}
2911
2912static int opt_subtitle_codec(const char *opt, const char *arg)
2913{
2914 return opt_codec(&subtitle_stream_copy, &subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, arg);
2915}
2916
2917static int opt_data_codec(const char *opt, const char *arg)
2918{
2919 return opt_codec(&data_stream_copy, &data_codec_name, AVMEDIA_TYPE_DATA, arg);
2920}
2921
2922static int opt_codec_tag(const char *opt, const char *arg)
2923{
2924 char *tail;
2925 uint32_t *codec_tag;
2926
2927 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2928 !strcmp(opt, "vtag") ? &video_codec_tag :
2929 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2930 if (!codec_tag)
2931 return -1;
2932
2933 *codec_tag = strtol(arg, &tail, 0);
2934 if (!tail || *tail)
2935 *codec_tag = AV_RL32(arg);
2936
2937 return 0;
2938}
2939
2940static int opt_map(const char *opt, const char *arg)
2941{
2942 StreamMap *m;
2943 char *p;
2944
2945 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2946 m = &stream_maps[nb_stream_maps-1];
2947
2948 m->file_index = strtol(arg, &p, 0);
2949 if (*p)
2950 p++;
2951
2952 m->stream_index = strtol(p, &p, 0);
2953 if (*p) {
2954 p++;
2955 m->sync_file_index = strtol(p, &p, 0);
2956 if (*p)
2957 p++;
2958 m->sync_stream_index = strtol(p, &p, 0);
2959 } else {
2960 m->sync_file_index = m->file_index;
2961 m->sync_stream_index = m->stream_index;
2962 }
2963 return 0;
2964}
2965
2966static void parse_meta_type(char *arg, char *type, int *index, char **endptr)
2967{
2968 *endptr = arg;
2969 if (*arg == ',') {
2970 *type = *(++arg);
2971 switch (*arg) {
2972 case 'g':
2973 break;
2974 case 's':
2975 case 'c':
2976 case 'p':
2977 *index = strtol(++arg, endptr, 0);
2978 break;
2979 default:
2980 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2981 exit_program(1);
2982 }
2983 } else
2984 *type = 'g';
2985}
2986
2987static int opt_map_metadata(const char *opt, const char *arg)
2988{
2989 MetadataMap *m, *m1;
2990 char *p;
2991
2992 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2993 &nb_meta_data_maps, nb_meta_data_maps + 1);
2994
2995 m = &meta_data_maps[nb_meta_data_maps - 1][0];
2996 m->file = strtol(arg, &p, 0);
2997 parse_meta_type(p, &m->type, &m->index, &p);
2998 if (*p)
2999 p++;
3000
3001 m1 = &meta_data_maps[nb_meta_data_maps - 1][1];
3002 m1->file = strtol(p, &p, 0);
3003 parse_meta_type(p, &m1->type, &m1->index, &p);
3004
3005 if (m->type == 'g' || m1->type == 'g')
3006 metadata_global_autocopy = 0;
3007 if (m->type == 's' || m1->type == 's')
3008 metadata_streams_autocopy = 0;
3009 if (m->type == 'c' || m1->type == 'c')
3010 metadata_chapters_autocopy = 0;
3011
3012 return 0;
3013}
3014
6291d7e4
AK
3015static int opt_input_ts_scale(const char *opt, const char *arg)
3016{
3017 unsigned int stream;
3018 double scale;
3019 char *p;
3020
3021 stream = strtol(arg, &p, 0);
3022 if (*p)
3023 p++;
3024 scale= strtod(p, &p);
3025
3026 ts_scale = grow_array(ts_scale, sizeof(*ts_scale), &nb_ts_scale, stream + 1);
3027 ts_scale[stream] = scale;
3028 return 0;
3029}
3030
3031static int opt_recording_time(const char *opt, const char *arg)
3032{
3033 recording_time = parse_time_or_die(opt, arg, 1);
3034 return 0;
3035}
3036
3037static int opt_start_time(const char *opt, const char *arg)
3038{
3039 start_time = parse_time_or_die(opt, arg, 1);
3040 return 0;
3041}
3042
6291d7e4
AK
3043static int opt_input_ts_offset(const char *opt, const char *arg)
3044{
3045 input_ts_offset = parse_time_or_die(opt, arg, 1);
3046 return 0;
3047}
3048
3049static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
3050{
3051 const char *codec_string = encoder ? "encoder" : "decoder";
3052 AVCodec *codec;
3053
3054 if(!name)
3055 return CODEC_ID_NONE;
3056 codec = encoder ?
3057 avcodec_find_encoder_by_name(name) :
3058 avcodec_find_decoder_by_name(name);
3059 if(!codec) {
3060 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
3061 exit_program(1);
3062 }
3063 if(codec->type != type) {
3064 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
3065 exit_program(1);
3066 }
3067 return codec->id;
3068}
3069
3070static int opt_input_file(const char *opt, const char *filename)
3071{
3072 AVFormatContext *ic;
3073 AVInputFormat *file_iformat = NULL;
3074 int err, i, ret, rfps, rfps_base;
3075 int64_t timestamp;
3076 uint8_t buf[128];
3077 AVDictionary **opts;
3078 int orig_nb_streams; // number of streams before avformat_find_stream_info
3079
3080 if (last_asked_format) {
3081 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3082 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3083 exit_program(1);
3084 }
3085 last_asked_format = NULL;
3086 }
3087
3088 if (!strcmp(filename, "-"))
3089 filename = "pipe:";
3090
3091 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3092 !strcmp(filename, "/dev/stdin");
3093
3094 /* get default parameters from command line */
3095 ic = avformat_alloc_context();
3096 if (!ic) {
3097 print_error(filename, AVERROR(ENOMEM));
3098 exit_program(1);
3099 }
3100 if (audio_sample_rate) {
3101 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3102 av_dict_set(&format_opts, "sample_rate", buf, 0);
3103 }
3104 if (audio_channels) {
3105 snprintf(buf, sizeof(buf), "%d", audio_channels);
3106 av_dict_set(&format_opts, "channels", buf, 0);
3107 }
3108 if (frame_rate.num) {
3109 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3110 av_dict_set(&format_opts, "framerate", buf, 0);
3111 }
3112 if (frame_width && frame_height) {
3113 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3114 av_dict_set(&format_opts, "video_size", buf, 0);
3115 }
3116 if (frame_pix_fmt != PIX_FMT_NONE)
3117 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3118
3119 ic->video_codec_id =
3120 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3121 ic->audio_codec_id =
3122 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3123 ic->subtitle_codec_id=
3124 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3125 ic->flags |= AVFMT_FLAG_NONBLOCK;
3126
3127 /* open the input file with generic libav function */
3128 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3129 if (err < 0) {
3130 print_error(filename, err);
3131 exit_program(1);
3132 }
3133 assert_avoptions(format_opts);
3134
3135 if(opt_programid) {
3136 int i, j;
3137 int found=0;
3138 for(i=0; i<ic->nb_streams; i++){
3139 ic->streams[i]->discard= AVDISCARD_ALL;
3140 }
3141 for(i=0; i<ic->nb_programs; i++){
3142 AVProgram *p= ic->programs[i];
3143 if(p->id != opt_programid){
3144 p->discard = AVDISCARD_ALL;
3145 }else{
3146 found=1;
3147 for(j=0; j<p->nb_stream_indexes; j++){
3148 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3149 }
3150 }
3151 }
3152 if(!found){
3153 fprintf(stderr, "Specified program id not found\n");
3154 exit_program(1);
3155 }
3156 opt_programid=0;
3157 }
3158
6291d7e4
AK
3159 /* Set AVCodecContext options for avformat_find_stream_info */
3160 opts = setup_find_stream_info_opts(ic, codec_opts);
3161 orig_nb_streams = ic->nb_streams;
3162
3163 /* If not enough info to get the stream parameters, we decode the
3164 first frames to get it. (used in mpeg case for example) */
3165 ret = avformat_find_stream_info(ic, opts);
3166 if (ret < 0 && verbose >= 0) {
3167 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3168 av_close_input_file(ic);
3169 exit_program(1);
3170 }
3171
3172 timestamp = start_time;
3173 /* add the stream start time */
3174 if (ic->start_time != AV_NOPTS_VALUE)
3175 timestamp += ic->start_time;
3176
3177 /* if seeking requested, we execute it */
3178 if (start_time != 0) {
3179 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3180 if (ret < 0) {
3181 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3182 filename, (double)timestamp / AV_TIME_BASE);
3183 }
3184 /* reset seek info */
3185 start_time = 0;
3186 }
3187
3188 /* update the current parameters so that they match the one of the input stream */
3189 for(i=0;i<ic->nb_streams;i++) {
3190 AVStream *st = ic->streams[i];
3191 AVCodecContext *dec = st->codec;
3192 InputStream *ist;
3193
3194 dec->thread_count = thread_count;
3195
3196 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3197 ist = &input_streams[nb_input_streams - 1];
3198 ist->st = st;
3199 ist->file_index = nb_input_files;
3200 ist->discard = 1;
3201 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, 0);
3202
3203 if (i < nb_ts_scale)
3204 ist->ts_scale = ts_scale[i];
3205
3206 switch (dec->codec_type) {
3207 case AVMEDIA_TYPE_AUDIO:
3208 ist->dec = avcodec_find_decoder_by_name(audio_codec_name);
3209 if(audio_disable)
3210 st->discard= AVDISCARD_ALL;
3211 break;
3212 case AVMEDIA_TYPE_VIDEO:
3213 ist->dec = avcodec_find_decoder_by_name(video_codec_name);
3214 rfps = ic->streams[i]->r_frame_rate.num;
3215 rfps_base = ic->streams[i]->r_frame_rate.den;
3216 if (dec->lowres) {
3217 dec->flags |= CODEC_FLAG_EMU_EDGE;
3218 dec->height >>= dec->lowres;
3219 dec->width >>= dec->lowres;
3220 }
3221 if(me_threshold)
3222 dec->debug |= FF_DEBUG_MV;
3223
3224 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3225
3226 if (verbose >= 0)
3227 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3228 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3229
3230 (float)rfps / rfps_base, rfps, rfps_base);
3231 }
3232
3233 if(video_disable)
3234 st->discard= AVDISCARD_ALL;
3235 else if(video_discard)
3236 st->discard= video_discard;
3237 break;
3238 case AVMEDIA_TYPE_DATA:
3239 break;
3240 case AVMEDIA_TYPE_SUBTITLE:
3241 ist->dec = avcodec_find_decoder_by_name(subtitle_codec_name);
3242 if(subtitle_disable)
3243 st->discard = AVDISCARD_ALL;
3244 break;
3245 case AVMEDIA_TYPE_ATTACHMENT:
3246 case AVMEDIA_TYPE_UNKNOWN:
3247 break;
3248 default:
3249 abort();
3250 }
3251 }
3252
3253 /* dump the file content */
3254 if (verbose >= 0)
3255 av_dump_format(ic, nb_input_files, filename, 0);
3256
3257 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3258 input_files[nb_input_files - 1].ctx = ic;
3259 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3260 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3261
3262 frame_rate = (AVRational){0, 0};
3263 frame_pix_fmt = PIX_FMT_NONE;
3264 frame_height = 0;
3265 frame_width = 0;
3266 audio_sample_rate = 0;
3267 audio_channels = 0;
3268 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3269 av_freep(&ts_scale);
3270 nb_ts_scale = 0;
3271
3272 for (i = 0; i < orig_nb_streams; i++)
3273 av_dict_free(&opts[i]);
3274 av_freep(&opts);
3275 av_freep(&video_codec_name);
3276 av_freep(&audio_codec_name);
3277 av_freep(&subtitle_codec_name);
3278 uninit_opts();
3279 init_opts();
3280 return 0;
3281}
3282
3283static void check_inputs(int *has_video_ptr,
3284 int *has_audio_ptr,
3285 int *has_subtitle_ptr,
3286 int *has_data_ptr)
3287{
3288 int has_video, has_audio, has_subtitle, has_data, i, j;
3289 AVFormatContext *ic;
3290
3291 has_video = 0;
3292 has_audio = 0;
3293 has_subtitle = 0;
3294 has_data = 0;
3295
3296 for(j=0;j<nb_input_files;j++) {
3297 ic = input_files[j].ctx;
3298 for(i=0;i<ic->nb_streams;i++) {
3299 AVCodecContext *enc = ic->streams[i]->codec;
3300 switch(enc->codec_type) {
3301 case AVMEDIA_TYPE_AUDIO:
3302 has_audio = 1;
3303 break;
3304 case AVMEDIA_TYPE_VIDEO:
3305 has_video = 1;
3306 break;
3307 case AVMEDIA_TYPE_SUBTITLE:
3308 has_subtitle = 1;
3309 break;
3310 case AVMEDIA_TYPE_DATA:
3311 case AVMEDIA_TYPE_ATTACHMENT:
3312 case AVMEDIA_TYPE_UNKNOWN:
3313 has_data = 1;
3314 break;
3315 default:
3316 abort();
3317 }
3318 }
3319 }
3320 *has_video_ptr = has_video;
3321 *has_audio_ptr = has_audio;
3322 *has_subtitle_ptr = has_subtitle;
3323 *has_data_ptr = has_data;
3324}
3325
3326static void new_video_stream(AVFormatContext *oc, int file_idx)
3327{
3328 AVStream *st;
3329 OutputStream *ost;
3330 AVCodecContext *video_enc;
3331 enum CodecID codec_id = CODEC_ID_NONE;
3332 AVCodec *codec= NULL;
3333
3334 if(!video_stream_copy){
3335 if (video_codec_name) {
3336 codec_id = find_codec_or_die(video_codec_name, AVMEDIA_TYPE_VIDEO, 1);
3337 codec = avcodec_find_encoder_by_name(video_codec_name);
3338 } else {
3339 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_VIDEO);
3340 codec = avcodec_find_encoder(codec_id);
3341 }
3342 }
3343
3344 ost = new_output_stream(oc, file_idx, codec);
3345 st = ost->st;
3346 if (!video_stream_copy) {
3347 ost->frame_aspect_ratio = frame_aspect_ratio;
3348 frame_aspect_ratio = 0;
3349#if CONFIG_AVFILTER
3350 ost->avfilter= vfilters;
3351 vfilters = NULL;
3352#endif
3353 }
3354
3355 ost->bitstream_filters = video_bitstream_filters;
3356 video_bitstream_filters= NULL;
3357
3358 st->codec->thread_count= thread_count;
3359
3360 video_enc = st->codec;
3361
3362 if(video_codec_tag)
3363 video_enc->codec_tag= video_codec_tag;
3364
3365 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3366 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3367 }
3368
3369 video_enc->codec_type = AVMEDIA_TYPE_VIDEO;
3370 if (video_stream_copy) {
3371 st->stream_copy = 1;
3372 video_enc->sample_aspect_ratio =
3373 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3374 } else {
3375 const char *p;
3376 int i;
3377
3378 if (frame_rate.num)
3379 ost->frame_rate = frame_rate;
3380 video_enc->codec_id = codec_id;
3381
3382 video_enc->width = frame_width;
3383 video_enc->height = frame_height;
3384 video_enc->pix_fmt = frame_pix_fmt;
3385 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3386
3387 if (intra_only)
3388 video_enc->gop_size = 0;
3389 if (video_qscale || same_quality) {
3390 video_enc->flags |= CODEC_FLAG_QSCALE;
3391 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3392 }
3393
3394 if(intra_matrix)
3395 video_enc->intra_matrix = intra_matrix;
3396 if(inter_matrix)
3397 video_enc->inter_matrix = inter_matrix;
3398
3399 p= video_rc_override_string;
3400 for(i=0; p; i++){
3401 int start, end, q;
3402 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3403 if(e!=3){
3404 fprintf(stderr, "error parsing rc_override\n");
3405 exit_program(1);
3406 }
3407 video_enc->rc_override=
3408 av_realloc(video_enc->rc_override,
3409 sizeof(RcOverride)*(i+1));
3410 video_enc->rc_override[i].start_frame= start;
3411 video_enc->rc_override[i].end_frame = end;
3412 if(q>0){
3413 video_enc->rc_override[i].qscale= q;
3414 video_enc->rc_override[i].quality_factor= 1.0;
3415 }
3416 else{
3417 video_enc->rc_override[i].qscale= 0;
3418 video_enc->rc_override[i].quality_factor= -q/100.0;
3419 }
3420 p= strchr(p, '/');
3421 if(p) p++;
3422 }
3423 video_enc->rc_override_count=i;
3424 if (!video_enc->rc_initial_buffer_occupancy)
3425 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3426 video_enc->me_threshold= me_threshold;
3427 video_enc->intra_dc_precision= intra_dc_precision - 8;
3428
3429 if (do_psnr)
3430 video_enc->flags|= CODEC_FLAG_PSNR;
3431
3432 /* two pass mode */
3433 if (do_pass) {
3434 if (do_pass == 1) {
3435 video_enc->flags |= CODEC_FLAG_PASS1;
3436 } else {
3437 video_enc->flags |= CODEC_FLAG_PASS2;
3438 }
3439 }
3440
3441 if (forced_key_frames)
3442 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3443 }
3444 if (video_language) {
3445 av_dict_set(&st->metadata, "language", video_language, 0);
3446 av_freep(&video_language);
3447 }
3448
3449 /* reset some key parameters */
3450 video_disable = 0;
3451 av_freep(&video_codec_name);
3452 av_freep(&forced_key_frames);
3453 video_stream_copy = 0;
3454 frame_pix_fmt = PIX_FMT_NONE;
3455}
3456
3457static void new_audio_stream(AVFormatContext *oc, int file_idx)
3458{
3459 AVStream *st;
3460 OutputStream *ost;
3461 AVCodec *codec= NULL;
3462 AVCodecContext *audio_enc;
3463 enum CodecID codec_id = CODEC_ID_NONE;
3464
3465 if(!audio_stream_copy){
3466 if (audio_codec_name) {
3467 codec_id = find_codec_or_die(audio_codec_name, AVMEDIA_TYPE_AUDIO, 1);
3468 codec = avcodec_find_encoder_by_name(audio_codec_name);
3469 } else {
3470 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_AUDIO);
3471 codec = avcodec_find_encoder(codec_id);
3472 }
3473 }
3474 ost = new_output_stream(oc, file_idx, codec);
3475 st = ost->st;
3476
3477 ost->bitstream_filters = audio_bitstream_filters;
3478 audio_bitstream_filters= NULL;
3479
3480 st->codec->thread_count= thread_count;
3481
3482 audio_enc = st->codec;
3483 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3484
3485 if(audio_codec_tag)
3486 audio_enc->codec_tag= audio_codec_tag;
3487
3488 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3489 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3490 }
3491 if (audio_stream_copy) {
3492 st->stream_copy = 1;
3493 } else {
3494 audio_enc->codec_id = codec_id;
3495
3496 if (audio_qscale > QSCALE_NONE) {
3497 audio_enc->flags |= CODEC_FLAG_QSCALE;
3498 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3499 }
3500 if (audio_channels)
3501 audio_enc->channels = audio_channels;
3502 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3503 audio_enc->sample_fmt = audio_sample_fmt;
3504 if (audio_sample_rate)
3505 audio_enc->sample_rate = audio_sample_rate;
3506 }
3507 if (audio_language) {
3508 av_dict_set(&st->metadata, "language", audio_language, 0);
3509 av_freep(&audio_language);
3510 }
3511
3512 /* reset some key parameters */
3513 audio_disable = 0;
3514 av_freep(&audio_codec_name);
3515 audio_stream_copy = 0;
3516}
3517
3518static void new_data_stream(AVFormatContext *oc, int file_idx)
3519{
3520 AVStream *st;
3521 OutputStream *ost;
3522 AVCodecContext *data_enc;
3523
3524 ost = new_output_stream(oc, file_idx, NULL);
3525 st = ost->st;
3526 data_enc = st->codec;
3527 if (!data_stream_copy) {
3528 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3529 exit_program(1);
3530 }
3531
3532 data_enc->codec_type = AVMEDIA_TYPE_DATA;
3533
3534 if (data_codec_tag)
3535 data_enc->codec_tag= data_codec_tag;
3536
3537 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3538 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3539 }
3540 if (data_stream_copy) {
3541 st->stream_copy = 1;
3542 }
3543
3544 data_disable = 0;
3545 av_freep(&data_codec_name);
3546 data_stream_copy = 0;
3547}
3548
3549static void new_subtitle_stream(AVFormatContext *oc, int file_idx)
3550{
3551 AVStream *st;
3552 OutputStream *ost;
3553 AVCodec *codec=NULL;
3554 AVCodecContext *subtitle_enc;
3555 enum CodecID codec_id = CODEC_ID_NONE;
3556
3557 if(!subtitle_stream_copy){
3558 if (subtitle_codec_name) {
3559 codec_id = find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 1);
3560 codec = avcodec_find_encoder_by_name(subtitle_codec_name);
3561 } else {
3562 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, AVMEDIA_TYPE_SUBTITLE);
3563 codec = avcodec_find_encoder(codec_id);
3564 }
3565 }
3566 ost = new_output_stream(oc, file_idx, codec);
3567 st = ost->st;
3568 subtitle_enc = st->codec;
3569
3570 ost->bitstream_filters = subtitle_bitstream_filters;
3571 subtitle_bitstream_filters= NULL;
3572
3573 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3574
3575 if(subtitle_codec_tag)
3576 subtitle_enc->codec_tag= subtitle_codec_tag;
3577
3578 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3579 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3580 }
3581 if (subtitle_stream_copy) {
3582 st->stream_copy = 1;
3583 } else {
3584 subtitle_enc->codec_id = codec_id;
3585 }
3586
3587 if (subtitle_language) {
3588 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3589 av_freep(&subtitle_language);
3590 }
3591
3592 subtitle_disable = 0;
3593 av_freep(&subtitle_codec_name);
3594 subtitle_stream_copy = 0;
3595}
3596
3597static int opt_new_stream(const char *opt, const char *arg)
3598{
3599 AVFormatContext *oc;
3600 int file_idx = nb_output_files - 1;
3601 if (nb_output_files <= 0) {
3602 fprintf(stderr, "At least one output file must be specified\n");
3603 exit_program(1);
3604 }
3605 oc = output_files[file_idx];
3606
3607 if (!strcmp(opt, "newvideo" )) new_video_stream (oc, file_idx);
3608 else if (!strcmp(opt, "newaudio" )) new_audio_stream (oc, file_idx);
3609 else if (!strcmp(opt, "newsubtitle")) new_subtitle_stream(oc, file_idx);
3610 else if (!strcmp(opt, "newdata" )) new_data_stream (oc, file_idx);
3611 else av_assert0(0);
3612 return 0;
3613}
3614
3615/* arg format is "output-stream-index:streamid-value". */
3616static int opt_streamid(const char *opt, const char *arg)
3617{
3618 int idx;
3619 char *p;
3620 char idx_str[16];
3621
3622 av_strlcpy(idx_str, arg, sizeof(idx_str));
3623 p = strchr(idx_str, ':');
3624 if (!p) {
3625 fprintf(stderr,
3626 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3627 arg, opt);
3628 exit_program(1);
3629 }
3630 *p++ = '\0';
3631 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3632 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3633 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3634 return 0;
3635}
3636
3637static void opt_output_file(const char *filename)
3638{
3639 AVFormatContext *oc;
b9aac90b 3640 int i, err, use_video, use_audio, use_subtitle, use_data;
6291d7e4
AK
3641 int input_has_video, input_has_audio, input_has_subtitle, input_has_data;
3642 AVOutputFormat *file_oformat;
3643
3644 if (!strcmp(filename, "-"))
3645 filename = "pipe:";
3646
3647 oc = avformat_alloc_context();
3648 if (!oc) {
3649 print_error(filename, AVERROR(ENOMEM));
3650 exit_program(1);
3651 }
3652
3653 if (last_asked_format) {
3654 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3655 if (!file_oformat) {
3656 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3657 exit_program(1);
3658 }
3659 last_asked_format = NULL;
3660 } else {
3661 file_oformat = av_guess_format(NULL, filename, NULL);
3662 if (!file_oformat) {
3663 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3664 filename);
3665 exit_program(1);
3666 }
3667 }
3668
3669 oc->oformat = file_oformat;
3670 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3671
3672 if (!strcmp(file_oformat->name, "ffm") &&
3673 av_strstart(filename, "http:", NULL)) {
3674 /* special case for files sent to avserver: we get the stream
3675 parameters from avserver */
3676 int err = read_avserver_streams(oc, filename);
3677 if (err < 0) {
3678 print_error(filename, err);
3679 exit_program(1);
3680 }
3681 } else {
3682 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3683 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3684 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3685 use_data = data_stream_copy || data_codec_name; /* XXX once generic data codec will be available add a ->data_codec reference and use it here */
3686
3687 /* disable if no corresponding type found */
3688 check_inputs(&input_has_video,
3689 &input_has_audio,
3690 &input_has_subtitle,
3691 &input_has_data);
3692
3693 if (!input_has_video)
3694 use_video = 0;
3695 if (!input_has_audio)
3696 use_audio = 0;
3697 if (!input_has_subtitle)
3698 use_subtitle = 0;
3699 if (!input_has_data)
3700 use_data = 0;
3701
3702 /* manual disable */
3703 if (audio_disable) use_audio = 0;
3704 if (video_disable) use_video = 0;
3705 if (subtitle_disable) use_subtitle = 0;
3706 if (data_disable) use_data = 0;
3707
3708 if (use_video) new_video_stream(oc, nb_output_files);
3709 if (use_audio) new_audio_stream(oc, nb_output_files);
3710 if (use_subtitle) new_subtitle_stream(oc, nb_output_files);
3711 if (use_data) new_data_stream(oc, nb_output_files);
3712
3713 av_dict_copy(&oc->metadata, metadata, 0);
3714 av_dict_free(&metadata);
3715 }
3716
3717 av_dict_copy(&output_opts[nb_output_files], format_opts, 0);
3718 output_files[nb_output_files++] = oc;
3719
3720 /* check filename in case of an image number is expected */
3721 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3722 if (!av_filename_number_test(oc->filename)) {
3723 print_error(oc->filename, AVERROR(EINVAL));
3724 exit_program(1);
3725 }
3726 }
3727
3728 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3729 /* test if it already exists to avoid loosing precious files */
3730 if (!file_overwrite &&
3731 (strchr(filename, ':') == NULL ||
3732 filename[1] == ':' ||
3733 av_strstart(filename, "file:", NULL))) {
3734 if (avio_check(filename, 0) == 0) {
3735 if (!using_stdin) {
3736 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3737 fflush(stderr);
3738 if (!read_yesno()) {
3739 fprintf(stderr, "Not overwriting - exiting\n");
3740 exit_program(1);
3741 }
3742 }
3743 else {
3744 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3745 exit_program(1);
3746 }
3747 }
3748 }
3749
3750 /* open the file */
3751 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3752 print_error(filename, err);
3753 exit_program(1);
3754 }
3755 }
3756
3757 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3758 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
6291d7e4
AK
3759 oc->flags |= AVFMT_FLAG_NONBLOCK;
3760
b9aac90b
AK
3761 /* copy chapters */
3762 if (chapters_input_file >= nb_input_files) {
3763 if (chapters_input_file == INT_MAX) {
3764 /* copy chapters from the first input file that has them*/
3765 chapters_input_file = -1;
3766 for (i = 0; i < nb_input_files; i++)
3767 if (input_files[i].ctx->nb_chapters) {
3768 chapters_input_file = i;
3769 break;
3770 }
3771 } else {
3772 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3773 chapters_input_file);
3774 exit_program(1);
3775 }
3776 }
3777 if (chapters_input_file >= 0)
3778 copy_chapters(chapters_input_file, nb_output_files - 1);
3779
6291d7e4
AK
3780 frame_rate = (AVRational){0, 0};
3781 frame_width = 0;
3782 frame_height = 0;
3783 audio_sample_rate = 0;
3784 audio_channels = 0;
3785 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
b9aac90b 3786 chapters_input_file = INT_MAX;
6291d7e4
AK
3787
3788 av_freep(&forced_key_frames);
3789 uninit_opts();
3790 init_opts();
3791}
3792
3793/* same option as mencoder */
3794static int opt_pass(const char *opt, const char *arg)
3795{
3796 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3797 return 0;
3798}
3799
3800static int64_t getutime(void)
3801{
3802#if HAVE_GETRUSAGE
3803 struct rusage rusage;
3804
3805 getrusage(RUSAGE_SELF, &rusage);
3806 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3807#elif HAVE_GETPROCESSTIMES
3808 HANDLE proc;
3809 FILETIME c, e, k, u;
3810 proc = GetCurrentProcess();
3811 GetProcessTimes(proc, &c, &e, &k, &u);
3812 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3813#else
3814 return av_gettime();
3815#endif
3816}
3817
3818static int64_t getmaxrss(void)
3819{
3820#if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3821 struct rusage rusage;
3822 getrusage(RUSAGE_SELF, &rusage);
3823 return (int64_t)rusage.ru_maxrss * 1024;
3824#elif HAVE_GETPROCESSMEMORYINFO
3825 HANDLE proc;
3826 PROCESS_MEMORY_COUNTERS memcounters;
3827 proc = GetCurrentProcess();
3828 memcounters.cb = sizeof(memcounters);
3829 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3830 return memcounters.PeakPagefileUsage;
3831#else
3832 return 0;
3833#endif
3834}
3835
3836static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3837{
3838 int i;
3839 const char *p = str;
3840 for(i = 0;; i++) {
3841 dest[i] = atoi(p);
3842 if(i == 63)
3843 break;
3844 p = strchr(p, ',');
3845 if(!p) {
3846 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3847 exit_program(1);
3848 }
3849 p++;
3850 }
3851}
3852
3853static void opt_inter_matrix(const char *arg)
3854{
3855 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3856 parse_matrix_coeffs(inter_matrix, arg);
3857}
3858
3859static void opt_intra_matrix(const char *arg)
3860{
3861 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3862 parse_matrix_coeffs(intra_matrix, arg);
3863}
3864
3865static void show_usage(void)
3866{
3867 printf("Hyper fast Audio and Video encoder\n");
3868 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3869 printf("\n");
3870}
3871
3872static void show_help(void)
3873{
3874 AVCodec *c;
3875 AVOutputFormat *oformat = NULL;
3876 AVInputFormat *iformat = NULL;
3877
3878 av_log_set_callback(log_callback_help);
3879 show_usage();
3880 show_help_options(options, "Main options:\n",
3881 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3882 show_help_options(options, "\nAdvanced options:\n",
3883 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3884 OPT_EXPERT);
3885 show_help_options(options, "\nVideo options:\n",
3886 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3887 OPT_VIDEO);
3888 show_help_options(options, "\nAdvanced Video options:\n",
3889 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3890 OPT_VIDEO | OPT_EXPERT);
3891 show_help_options(options, "\nAudio options:\n",
3892 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3893 OPT_AUDIO);
3894 show_help_options(options, "\nAdvanced Audio options:\n",
3895 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3896 OPT_AUDIO | OPT_EXPERT);
3897 show_help_options(options, "\nSubtitle options:\n",
3898 OPT_SUBTITLE | OPT_GRAB,
3899 OPT_SUBTITLE);
3900 show_help_options(options, "\nAudio/Video grab options:\n",
3901 OPT_GRAB,
3902 OPT_GRAB);
3903 printf("\n");
3904 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3905 printf("\n");
3906
3907 /* individual codec options */
3908 c = NULL;
3909 while ((c = av_codec_next(c))) {
3910 if (c->priv_class) {
3911 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3912 printf("\n");
3913 }
3914 }
3915
3916 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3917 printf("\n");
3918
3919 /* individual muxer options */
3920 while ((oformat = av_oformat_next(oformat))) {
3921 if (oformat->priv_class) {
3922 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3923 printf("\n");
3924 }
3925 }
3926
3927 /* individual demuxer options */
3928 while ((iformat = av_iformat_next(iformat))) {
3929 if (iformat->priv_class) {
3930 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3931 printf("\n");
3932 }
3933 }
3934
3935 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3936}
3937
3938static int opt_target(const char *opt, const char *arg)
3939{
3940 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3941 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3942
3943 if(!strncmp(arg, "pal-", 4)) {
3944 norm = PAL;
3945 arg += 4;
3946 } else if(!strncmp(arg, "ntsc-", 5)) {
3947 norm = NTSC;
3948 arg += 5;
3949 } else if(!strncmp(arg, "film-", 5)) {
3950 norm = FILM;
3951 arg += 5;
3952 } else {
3953 int fr;
3954 /* Calculate FR via float to avoid int overflow */
3955 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3956 if(fr == 25000) {
3957 norm = PAL;
3958 } else if((fr == 29970) || (fr == 23976)) {
3959 norm = NTSC;
3960 } else {
3961 /* Try to determine PAL/NTSC by peeking in the input files */
3962 if(nb_input_files) {
3963 int i, j;
3964 for (j = 0; j < nb_input_files; j++) {
3965 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
3966 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3967 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3968 continue;
3969 fr = c->time_base.den * 1000 / c->time_base.num;
3970 if(fr == 25000) {
3971 norm = PAL;
3972 break;
3973 } else if((fr == 29970) || (fr == 23976)) {
3974 norm = NTSC;
3975 break;
3976 }
3977 }
3978 if(norm != UNKNOWN)
3979 break;
3980 }
3981 }
3982 }
3983 if(verbose > 0 && norm != UNKNOWN)
3984 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3985 }
3986
3987 if(norm == UNKNOWN) {
3988 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3989 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3990 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3991 exit_program(1);
3992 }
3993
3994 if(!strcmp(arg, "vcd")) {
3995 opt_video_codec("vcodec", "mpeg1video");
3996 opt_audio_codec("vcodec", "mp2");
3997 opt_format("f", "vcd");
3998
3999 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4000 opt_frame_rate("r", frame_rates[norm]);
4001 opt_default("g", norm == PAL ? "15" : "18");
4002
4003 opt_default("b", "1150000");
4004 opt_default("maxrate", "1150000");
4005 opt_default("minrate", "1150000");
4006 opt_default("bufsize", "327680"); // 40*1024*8;
4007
4008 opt_default("ab", "224000");
4009 audio_sample_rate = 44100;
4010 audio_channels = 2;
4011
4012 opt_default("packetsize", "2324");
4013 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4014
4015 /* We have to offset the PTS, so that it is consistent with the SCR.
4016 SCR starts at 36000, but the first two packs contain only padding
4017 and the first pack from the other stream, respectively, may also have
4018 been written before.
4019 So the real data starts at SCR 36000+3*1200. */
4020 mux_preload= (36000+3*1200) / 90000.0; //0.44
4021 } else if(!strcmp(arg, "svcd")) {
4022
4023 opt_video_codec("vcodec", "mpeg2video");
4024 opt_audio_codec("acodec", "mp2");
4025 opt_format("f", "svcd");
4026
4027 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4028 opt_frame_rate("r", frame_rates[norm]);
4029 opt_default("g", norm == PAL ? "15" : "18");
4030
4031 opt_default("b", "2040000");
4032 opt_default("maxrate", "2516000");
4033 opt_default("minrate", "0"); //1145000;
4034 opt_default("bufsize", "1835008"); //224*1024*8;
4035 opt_default("flags", "+scan_offset");
4036
4037
4038 opt_default("ab", "224000");
4039 audio_sample_rate = 44100;
4040
4041 opt_default("packetsize", "2324");
4042
4043 } else if(!strcmp(arg, "dvd")) {
4044
4045 opt_video_codec("vcodec", "mpeg2video");
4046 opt_audio_codec("vcodec", "ac3");
4047 opt_format("f", "dvd");
4048
4049 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4050 opt_frame_rate("r", frame_rates[norm]);
4051 opt_default("g", norm == PAL ? "15" : "18");
4052
4053 opt_default("b", "6000000");
4054 opt_default("maxrate", "9000000");
4055 opt_default("minrate", "0"); //1500000;
4056 opt_default("bufsize", "1835008"); //224*1024*8;
4057
4058 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4059 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4060
4061 opt_default("ab", "448000");
4062 audio_sample_rate = 48000;
4063
4064 } else if(!strncmp(arg, "dv", 2)) {
4065
4066 opt_format("f", "dv");
4067
4068 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4069 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4070 norm == PAL ? "yuv420p" : "yuv411p");
4071 opt_frame_rate("r", frame_rates[norm]);
4072
4073 audio_sample_rate = 48000;
4074 audio_channels = 2;
4075
4076 } else {
4077 fprintf(stderr, "Unknown target: %s\n", arg);
4078 return AVERROR(EINVAL);
4079 }
4080 return 0;
4081}
4082
4083static int opt_vstats_file(const char *opt, const char *arg)
4084{
4085 av_free (vstats_filename);
4086 vstats_filename=av_strdup (arg);
4087 return 0;
4088}
4089
4090static int opt_vstats(const char *opt, const char *arg)
4091{
4092 char filename[40];
4093 time_t today2 = time(NULL);
4094 struct tm *today = localtime(&today2);
4095
4096 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4097 today->tm_sec);
4098 return opt_vstats_file(opt, filename);
4099}
4100
4101static int opt_bsf(const char *opt, const char *arg)
4102{
4103 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4104 AVBitStreamFilterContext **bsfp;
4105
4106 if(!bsfc){
4107 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4108 exit_program(1);
4109 }
4110
4111 bsfp= *opt == 'v' ? &video_bitstream_filters :
4112 *opt == 'a' ? &audio_bitstream_filters :
4113 &subtitle_bitstream_filters;
4114 while(*bsfp)
4115 bsfp= &(*bsfp)->next;
4116
4117 *bsfp= bsfc;
4118
4119 return 0;
4120}
4121
4122static int opt_preset(const char *opt, const char *arg)
4123{
4124 FILE *f=NULL;
4125 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4126 char *codec_name = *opt == 'v' ? video_codec_name :
4127 *opt == 'a' ? audio_codec_name :
4128 subtitle_codec_name;
4129
4130 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4131 fprintf(stderr, "File for preset '%s' not found\n", arg);
4132 exit_program(1);
4133 }
4134
4135 while(!feof(f)){
4136 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4137 if(line[0] == '#' && !e)
4138 continue;
4139 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4140 if(e){
4141 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4142 exit_program(1);
4143 }
4144 if(!strcmp(tmp, "acodec")){
4145 opt_audio_codec(tmp, tmp2);
4146 }else if(!strcmp(tmp, "vcodec")){
4147 opt_video_codec(tmp, tmp2);
4148 }else if(!strcmp(tmp, "scodec")){
4149 opt_subtitle_codec(tmp, tmp2);
4150 }else if(!strcmp(tmp, "dcodec")){
4151 opt_data_codec(tmp, tmp2);
4152 }else if(opt_default(tmp, tmp2) < 0){
4153 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4154 exit_program(1);
4155 }
4156 }
4157
4158 fclose(f);
4159
4160 return 0;
4161}
4162
4163static const OptionDef options[] = {
4164 /* main options */
4165#include "cmdutils_common_opts.h"
4166 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4167 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4168 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4169 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
6291d7e4
AK
4170 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4171 "outfile[,metadata]:infile[,metadata]" },
b9aac90b 4172 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file}, "set chapters mapping", "input_file_index" },
6291d7e4
AK
4173 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4174 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4175 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4176 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4177 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
6291d7e4
AK
4178 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4179 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4180 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4181 "add timings for benchmarking" },
4182 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4183 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4184 "dump each input packet" },
4185 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4186 "when dumping packets, also dump the payload" },
4187 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
6291d7e4
AK
4188 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4189 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4190 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4191 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4192 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4193 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4194 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
4195 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)&copy_tb}, "copy input stream time base when stream copying" },
4196 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4197 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4198 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4199 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4200 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)&copy_initial_nonkeyframes}, "copy initial non-keyframes" },
4201
4202 /* video options */
4203 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4204 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4205 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4206 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4207 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
4208 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4209 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4210 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4211 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4212 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4213 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4214 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4215 { "padright", HAS_ARG | OPT_