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