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