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