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