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