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