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