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