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