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