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