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