?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
move decoder initialization in separate function, earlier failure detection
[FFMpeg-mirror/ffmpeg-vdpau.git] / ffmpeg.c
blob651fa71b81936550a551683c66f745091267e0bf
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 dump_format(output_files[i], i, output_files[i]->filename, 1);
1586 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1587 av_exit(1);
1588 }
1589 nb_ostreams += os->nb_streams;
1590 }
1591 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1592 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1593 av_exit(1);
1594 }
1595
1596 /* Sanity check the mapping args -- do the input files & streams exist? */
1597 for(i=0;i<nb_stream_maps;i++) {
1598 int fi = stream_maps[i].file_index;
1599 int si = stream_maps[i].stream_index;
1600
1601 if (fi < 0 || fi > nb_input_files - 1 ||
1602 si < 0 || si > file_table[fi].nb_streams - 1) {
1603 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1604 av_exit(1);
1605 }
1606 fi = stream_maps[i].sync_file_index;
1607 si = stream_maps[i].sync_stream_index;
1608 if (fi < 0 || fi > nb_input_files - 1 ||
1609 si < 0 || si > file_table[fi].nb_streams - 1) {
1610 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1611 av_exit(1);
1612 }
1613 }
1614
1615 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1616 if (!ost_table)
1617 goto fail;
1618 for(i=0;i<nb_ostreams;i++) {
1619 ost = av_mallocz(sizeof(AVOutputStream));
1620 if (!ost)
1621 goto fail;
1622 ost_table[i] = ost;
1623 }
1624
1625 n = 0;
1626 for(k=0;k<nb_output_files;k++) {
1627 os = output_files[k];
1628 for(i=0;i<os->nb_streams;i++,n++) {
1629 int found;
1630 ost = ost_table[n];
1631 ost->file_index = k;
1632 ost->index = i;
1633 ost->st = os->streams[i];
1634 if (nb_stream_maps > 0) {
1635 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1636 stream_maps[n].stream_index;
1637
1638 /* Sanity check that the stream types match */
1639 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1640 int i= ost->file_index;
1641 dump_format(output_files[i], i, output_files[i]->filename, 1);
1642 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1643 stream_maps[n].file_index, stream_maps[n].stream_index,
1644 ost->file_index, ost->index);
1645 av_exit(1);
1646 }
1647
1648 } else {
1649 if(opt_programid) {
1650 found = 0;
1651 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1652 if(j != -1) {
1653 ost->source_index = j;
1654 found = 1;
1655 }
1656 } else {
1657 /* get corresponding input stream index : we select the first one with the right type */
1658 found = 0;
1659 for(j=0;j<nb_istreams;j++) {
1660 ist = ist_table[j];
1661 if (ist->discard &&
1662 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1663 ost->source_index = j;
1664 found = 1;
1665 break;
1666 }
1667 }
1668 }
1669
1670 if (!found) {
1671 if(! opt_programid) {
1672 /* try again and reuse existing stream */
1673 for(j=0;j<nb_istreams;j++) {
1674 ist = ist_table[j];
1675 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1676 ost->source_index = j;
1677 found = 1;
1678 }
1679 }
1680 }
1681 if (!found) {
1682 int i= ost->file_index;
1683 dump_format(output_files[i], i, output_files[i]->filename, 1);
1684 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1685 ost->file_index, ost->index);
1686 av_exit(1);
1687 }
1688 }
1689 }
1690 ist = ist_table[ost->source_index];
1691 ist->discard = 0;
1692 ost->sync_ist = (nb_stream_maps > 0) ?
1693 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1694 stream_maps[n].sync_stream_index] : ist;
1695 }
1696 }
1697
1698 /* for each output stream, we compute the right encoding parameters */
1699 for(i=0;i<nb_ostreams;i++) {
1700 ost = ost_table[i];
1701 os = output_files[ost->file_index];
1702 ist = ist_table[ost->source_index];
1703
1704 codec = ost->st->codec;
1705 icodec = ist->st->codec;
1706
1707 if (!ost->st->language[0])
1708 av_strlcpy(ost->st->language, ist->st->language,
1709 sizeof(ost->st->language));
1710
1711 ost->st->disposition = ist->st->disposition;
1712
1713 if (ost->st->stream_copy) {
1714 /* if stream_copy is selected, no need to decode or encode */
1715 codec->codec_id = icodec->codec_id;
1716 codec->codec_type = icodec->codec_type;
1717
1718 if(!codec->codec_tag){
1719 if( !os->oformat->codec_tag
1720 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1721 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1722 codec->codec_tag = icodec->codec_tag;
1723 }
1724
1725 codec->bit_rate = icodec->bit_rate;
1726 codec->extradata= icodec->extradata;
1727 codec->extradata_size= icodec->extradata_size;
1728 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1729 codec->time_base = icodec->time_base;
1730 else
1731 codec->time_base = ist->st->time_base;
1732 switch(codec->codec_type) {
1733 case CODEC_TYPE_AUDIO:
1734 if(audio_volume != 256) {
1735 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1736 av_exit(1);
1737 }
1738 codec->sample_rate = icodec->sample_rate;
1739 codec->channels = icodec->channels;
1740 codec->frame_size = icodec->frame_size;
1741 codec->block_align= icodec->block_align;
1742 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1743 codec->block_align= 0;
1744 if(codec->codec_id == CODEC_ID_AC3)
1745 codec->block_align= 0;
1746 break;
1747 case CODEC_TYPE_VIDEO:
1748 if(using_vhook) {
1749 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1750 av_exit(1);
1751 }
1752 codec->pix_fmt = icodec->pix_fmt;
1753 codec->width = icodec->width;
1754 codec->height = icodec->height;
1755 codec->has_b_frames = icodec->has_b_frames;
1756 break;
1757 case CODEC_TYPE_SUBTITLE:
1758 break;
1759 default:
1760 abort();
1761 }
1762 } else {
1763 switch(codec->codec_type) {
1764 case CODEC_TYPE_AUDIO:
1765 if (av_fifo_init(&ost->fifo, 1024))
1766 goto fail;
1767 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1768 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1769 icodec->request_channels = codec->channels;
1770 ist->decoding_needed = 1;
1771 ost->encoding_needed = 1;
1772 break;
1773 case CODEC_TYPE_VIDEO:
1774 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1775 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1776 ost->video_resample = ((codec->width != icodec->width -
1777 (frame_leftBand + frame_rightBand) +
1778 (frame_padleft + frame_padright)) ||
1779 (codec->height != icodec->height -
1780 (frame_topBand + frame_bottomBand) +
1781 (frame_padtop + frame_padbottom)) ||
1782 (codec->pix_fmt != icodec->pix_fmt));
1783 if (ost->video_crop) {
1784 ost->topBand = frame_topBand;
1785 ost->leftBand = frame_leftBand;
1786 }
1787 if (ost->video_pad) {
1788 ost->padtop = frame_padtop;
1789 ost->padleft = frame_padleft;
1790 ost->padbottom = frame_padbottom;
1791 ost->padright = frame_padright;
1792 if (!ost->video_resample) {
1793 avcodec_get_frame_defaults(&ost->pict_tmp);
1794 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1795 codec->width, codec->height))
1796 goto fail;
1797 }
1798 }
1799 if (ost->video_resample) {
1800 avcodec_get_frame_defaults(&ost->pict_tmp);
1801 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1802 codec->width, codec->height)) {
1803 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1804 av_exit(1);
1805 }
1806 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1807 ost->img_resample_ctx = sws_getContext(
1808 icodec->width - (frame_leftBand + frame_rightBand),
1809 icodec->height - (frame_topBand + frame_bottomBand),
1810 icodec->pix_fmt,
1811 codec->width - (frame_padleft + frame_padright),
1812 codec->height - (frame_padtop + frame_padbottom),
1813 codec->pix_fmt,
1814 sws_flags, NULL, NULL, NULL);
1815 if (ost->img_resample_ctx == NULL) {
1816 fprintf(stderr, "Cannot get resampling context\n");
1817 av_exit(1);
1818 }
1819 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1820 }
1821 ost->encoding_needed = 1;
1822 ist->decoding_needed = 1;
1823 break;
1824 case CODEC_TYPE_SUBTITLE:
1825 ost->encoding_needed = 1;
1826 ist->decoding_needed = 1;
1827 break;
1828 default:
1829 abort();
1830 break;
1831 }
1832 /* two pass mode */
1833 if (ost->encoding_needed &&
1834 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1835 char logfilename[1024];
1836 FILE *f;
1837 int size;
1838 char *logbuffer;
1839
1840 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1841 pass_logfilename ?
1842 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1843 if (codec->flags & CODEC_FLAG_PASS1) {
1844 f = fopen(logfilename, "w");
1845 if (!f) {
1846 perror(logfilename);
1847 av_exit(1);
1848 }
1849 ost->logfile = f;
1850 } else {
1851 /* read the log file */
1852 f = fopen(logfilename, "r");
1853 if (!f) {
1854 perror(logfilename);
1855 av_exit(1);
1856 }
1857 fseek(f, 0, SEEK_END);
1858 size = ftell(f);
1859 fseek(f, 0, SEEK_SET);
1860 logbuffer = av_malloc(size + 1);
1861 if (!logbuffer) {
1862 fprintf(stderr, "Could not allocate log buffer\n");
1863 av_exit(1);
1864 }
1865 size = fread(logbuffer, 1, size, f);
1866 fclose(f);
1867 logbuffer[size] = '\0';
1868 codec->stats_in = logbuffer;
1869 }
1870 }
1871 }
1872 if(codec->codec_type == CODEC_TYPE_VIDEO){
1873 int size= codec->width * codec->height;
1874 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1875 }
1876 }
1877
1878 if (!bit_buffer)
1879 bit_buffer = av_malloc(bit_buffer_size);
1880 if (!bit_buffer)
1881 goto fail;
1882
1883 /* dump the file output parameters - cannot be done before in case
1884 of stream copy */
1885 for(i=0;i<nb_output_files;i++) {
1886 dump_format(output_files[i], i, output_files[i]->filename, 1);
1887 }
1888
1889 /* dump the stream mapping */
1890 if (verbose >= 0) {
1891 fprintf(stderr, "Stream mapping:\n");
1892 for(i=0;i<nb_ostreams;i++) {
1893 ost = ost_table[i];
1894 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1895 ist_table[ost->source_index]->file_index,
1896 ist_table[ost->source_index]->index,
1897 ost->file_index,
1898 ost->index);
1899 if (ost->sync_ist != ist_table[ost->source_index])
1900 fprintf(stderr, " [sync #%d.%d]",
1901 ost->sync_ist->file_index,
1902 ost->sync_ist->index);
1903 fprintf(stderr, "\n");
1904 }
1905 }
1906
1907 /* open each encoder */
1908 for(i=0;i<nb_ostreams;i++) {
1909 ost = ost_table[i];
1910 if (ost->encoding_needed) {
1911 AVCodec *codec = output_codecs[i];
1912 if (!codec)
1913 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1914 if (!codec) {
1915 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1916 ost->file_index, ost->index);
1917 av_exit(1);
1918 }
1919 if (avcodec_open(ost->st->codec, codec) < 0) {
1920 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1921 ost->file_index, ost->index);
1922 av_exit(1);
1923 }
1924 extra_size += ost->st->codec->extradata_size;
1925 }
1926 }
1927
1928 /* open each decoder */
1929 for(i=0;i<nb_istreams;i++) {
1930 ist = ist_table[i];
1931 if (ist->decoding_needed) {
1932 AVCodec *codec = input_codecs[i];
1933 if (!codec)
1934 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1935 if (!codec) {
1936 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1937 ist->st->codec->codec_id, ist->file_index, ist->index);
1938 av_exit(1);
1939 }
1940 if (avcodec_open(ist->st->codec, codec) < 0) {
1941 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1942 ist->file_index, ist->index);
1943 av_exit(1);
1944 }
1945 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1946 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1947 }
1948 }
1949
1950 /* init pts */
1951 for(i=0;i<nb_istreams;i++) {
1952 ist = ist_table[i];
1953 is = input_files[ist->file_index];
1954 ist->pts = 0;
1955 ist->next_pts = AV_NOPTS_VALUE;
1956 ist->is_start = 1;
1957 }
1958
1959 /* set meta data information from input file if required */
1960 for (i=0;i<nb_meta_data_maps;i++) {
1961 AVFormatContext *out_file;
1962 AVFormatContext *in_file;
1963
1964 int out_file_index = meta_data_maps[i].out_file;
1965 int in_file_index = meta_data_maps[i].in_file;
1966 if (out_file_index < 0 || out_file_index >= nb_output_files) {
1967 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1968 ret = AVERROR(EINVAL);
1969 goto fail;
1970 }
1971 if (in_file_index < 0 || in_file_index >= nb_input_files) {
1972 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1973 ret = AVERROR(EINVAL);
1974 goto fail;
1975 }
1976
1977 out_file = output_files[out_file_index];
1978 in_file = input_files[in_file_index];
1979
1980 strcpy(out_file->title, in_file->title);
1981 strcpy(out_file->author, in_file->author);
1982 strcpy(out_file->copyright, in_file->copyright);
1983 strcpy(out_file->comment, in_file->comment);
1984 strcpy(out_file->album, in_file->album);
1985 out_file->year = in_file->year;
1986 out_file->track = in_file->track;
1987 strcpy(out_file->genre, in_file->genre);
1988 }
1989
1990 /* open files and write file headers */
1991 for(i=0;i<nb_output_files;i++) {
1992 os = output_files[i];
1993 if (av_write_header(os) < 0) {
1994 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1995 ret = AVERROR(EINVAL);
1996 goto fail;
1997 }
1998 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1999 want_sdp = 0;
2000 }
2001 }
2002 if (want_sdp) {
2003 print_sdp(output_files, nb_output_files);
2004 }
2005
2006 if (!using_stdin && verbose >= 0) {
2007 fprintf(stderr, "Press [q] to stop encoding\n");
2008 url_set_interrupt_cb(decode_interrupt_cb);
2009 }
2010 term_init();
2011
2012 key = -1;
2013 timer_start = av_gettime();
2014
2015 for(; received_sigterm == 0;) {
2016 int file_index, ist_index;
2017 AVPacket pkt;
2018 double ipts_min;
2019 double opts_min;
2020
2021 redo:
2022 ipts_min= 1e100;
2023 opts_min= 1e100;
2024 /* if 'q' pressed, exits */
2025 if (!using_stdin) {
2026 if (q_pressed)
2027 break;
2028 /* read_key() returns 0 on EOF */
2029 key = read_key();
2030 if (key == 'q')
2031 break;
2032 }
2033
2034 /* select the stream that we must read now by looking at the
2035 smallest output pts */
2036 file_index = -1;
2037 for(i=0;i<nb_ostreams;i++) {
2038 double ipts, opts;
2039 ost = ost_table[i];
2040 os = output_files[ost->file_index];
2041 ist = ist_table[ost->source_index];
2042 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2043 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2044 else
2045 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2046 ipts = (double)ist->pts;
2047 if (!file_table[ist->file_index].eof_reached){
2048 if(ipts < ipts_min) {
2049 ipts_min = ipts;
2050 if(input_sync ) file_index = ist->file_index;
2051 }
2052 if(opts < opts_min) {
2053 opts_min = opts;
2054 if(!input_sync) file_index = ist->file_index;
2055 }
2056 }
2057 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2058 file_index= -1;
2059 break;
2060 }
2061 }
2062 /* if none, if is finished */
2063 if (file_index < 0) {
2064 break;
2065 }
2066
2067 /* finish if recording time exhausted */
2068 if (opts_min >= (recording_time / 1000000.0))
2069 break;
2070
2071 /* finish if limit size exhausted */
2072 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2073 break;
2074
2075 /* read a frame from it and output it in the fifo */
2076 is = input_files[file_index];
2077 if (av_read_frame(is, &pkt) < 0) {
2078 file_table[file_index].eof_reached = 1;
2079 if (opt_shortest)
2080 break;
2081 else
2082 continue;
2083 }
2084
2085 if (do_pkt_dump) {
2086 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2087 }
2088 /* the following test is needed in case new streams appear
2089 dynamically in stream : we ignore them */
2090 if (pkt.stream_index >= file_table[file_index].nb_streams)
2091 goto discard_packet;
2092 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2093 ist = ist_table[ist_index];
2094 if (ist->discard)
2095 goto discard_packet;
2096
2097 if (pkt.dts != AV_NOPTS_VALUE)
2098 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2099 if (pkt.pts != AV_NOPTS_VALUE)
2100 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2101
2102 if(input_files_ts_scale[file_index][pkt.stream_index]){
2103 if(pkt.pts != AV_NOPTS_VALUE)
2104 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2105 if(pkt.dts != AV_NOPTS_VALUE)
2106 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2107 }
2108
2109 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2110 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2111 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2112 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2113 int64_t delta= pkt_dts - ist->next_pts;
2114 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2115 input_files_ts_offset[ist->file_index]-= delta;
2116 if (verbose > 2)
2117 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2118 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2119 if(pkt.pts != AV_NOPTS_VALUE)
2120 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2121 }
2122 }
2123
2124 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2125 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2126
2127 if (verbose >= 0)
2128 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2129 ist->file_index, ist->index);
2130 if (exit_on_error)
2131 av_exit(1);
2132 av_free_packet(&pkt);
2133 goto redo;
2134 }
2135
2136 discard_packet:
2137 av_free_packet(&pkt);
2138
2139 /* dump report by using the output first video and audio streams */
2140 print_report(output_files, ost_table, nb_ostreams, 0);
2141 }
2142
2143 /* at the end of stream, we must flush the decoder buffers */
2144 for(i=0;i<nb_istreams;i++) {
2145 ist = ist_table[i];
2146 if (ist->decoding_needed) {
2147 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2148 }
2149 }
2150
2151 term_exit();
2152
2153 /* write the trailer if needed and close file */
2154 for(i=0;i<nb_output_files;i++) {
2155 os = output_files[i];
2156 av_write_trailer(os);
2157 }
2158
2159 /* dump report by using the first video and audio streams */
2160 print_report(output_files, ost_table, nb_ostreams, 1);
2161
2162 /* close each encoder */
2163 for(i=0;i<nb_ostreams;i++) {
2164 ost = ost_table[i];
2165 if (ost->encoding_needed) {
2166 av_freep(&ost->st->codec->stats_in);
2167 avcodec_close(ost->st->codec);
2168 }
2169 }
2170
2171 /* close each decoder */
2172 for(i=0;i<nb_istreams;i++) {
2173 ist = ist_table[i];
2174 if (ist->decoding_needed) {
2175 avcodec_close(ist->st->codec);
2176 }
2177 }
2178
2179 /* finished ! */
2180
2181 ret = 0;
2182 fail1:
2183 av_freep(&bit_buffer);
2184 av_free(file_table);
2185
2186 if (ist_table) {
2187 for(i=0;i<nb_istreams;i++) {
2188 ist = ist_table[i];
2189 av_free(ist);
2190 }
2191 av_free(ist_table);
2192 }
2193 if (ost_table) {
2194 for(i=0;i<nb_ostreams;i++) {
2195 ost = ost_table[i];
2196 if (ost) {
2197 if (ost->logfile) {
2198 fclose(ost->logfile);
2199 ost->logfile = NULL;
2200 }
2201 av_fifo_free(&ost->fifo); /* works even if fifo is not
2202 initialized but set to zero */
2203 av_free(ost->pict_tmp.data[0]);
2204 if (ost->video_resample)
2205 sws_freeContext(ost->img_resample_ctx);
2206 if (ost->resample)
2207 audio_resample_close(ost->resample);
2208 if (ost->reformat_ctx)
2209 av_audio_convert_free(ost->reformat_ctx);
2210 av_free(ost);
2211 }
2212 }
2213 av_free(ost_table);
2214 }
2215 return ret;
2216 fail:
2217 ret = AVERROR(ENOMEM);
2218 goto fail1;
2219 }
2220
2221 #if 0
2222 int file_read(const char *filename)
2223 {
2224 URLContext *h;
2225 unsigned char buffer[1024];
2226 int len, i;
2227
2228 if (url_open(&h, filename, O_RDONLY) < 0) {
2229 printf("could not open '%s'\n", filename);
2230 return -1;
2231 }
2232 for(;;) {
2233 len = url_read(h, buffer, sizeof(buffer));
2234 if (len <= 0)
2235 break;
2236 for(i=0;i<len;i++) putchar(buffer[i]);
2237 }
2238 url_close(h);
2239 return 0;
2240 }
2241 #endif
2242
2243 static void opt_format(const char *arg)
2244 {
2245 /* compatibility stuff for pgmyuv */
2246 if (!strcmp(arg, "pgmyuv")) {
2247 pgmyuv_compatibility_hack=1;
2248 // opt_image_format(arg);
2249 arg = "image2";
2250 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2251 }
2252
2253 file_iformat = av_find_input_format(arg);
2254 file_oformat = guess_format(arg, NULL, NULL);
2255 if (!file_iformat && !file_oformat) {
2256 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2257 av_exit(1);
2258 }
2259 }
2260
2261 static void opt_video_rc_override_string(const char *arg)
2262 {
2263 video_rc_override_string = arg;
2264 }
2265
2266 static int opt_me_threshold(const char *opt, const char *arg)
2267 {
2268 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2269 return 0;
2270 }
2271
2272 static int opt_verbose(const char *opt, const char *arg)
2273 {
2274 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2275 av_log_set_level(verbose);
2276 return 0;
2277 }
2278
2279 static int opt_frame_rate(const char *opt, const char *arg)
2280 {
2281 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2282 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2283 av_exit(1);
2284 }
2285 return 0;
2286 }
2287
2288 static int opt_bitrate(const char *opt, const char *arg)
2289 {
2290 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2291
2292 opt_default(opt, arg);
2293
2294 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2295 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2296
2297 return 0;
2298 }
2299
2300 static void opt_frame_crop_top(const char *arg)
2301 {
2302 frame_topBand = atoi(arg);
2303 if (frame_topBand < 0) {
2304 fprintf(stderr, "Incorrect top crop size\n");
2305 av_exit(1);
2306 }
2307 if ((frame_topBand % 2) != 0) {
2308 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2309 av_exit(1);
2310 }
2311 if ((frame_topBand) >= frame_height){
2312 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2313 av_exit(1);
2314 }
2315 frame_height -= frame_topBand;
2316 }
2317
2318 static void opt_frame_crop_bottom(const char *arg)
2319 {
2320 frame_bottomBand = atoi(arg);
2321 if (frame_bottomBand < 0) {
2322 fprintf(stderr, "Incorrect bottom crop size\n");
2323 av_exit(1);
2324 }
2325 if ((frame_bottomBand % 2) != 0) {
2326 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2327 av_exit(1);
2328 }
2329 if ((frame_bottomBand) >= frame_height){
2330 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2331 av_exit(1);
2332 }
2333 frame_height -= frame_bottomBand;
2334 }
2335
2336 static void opt_frame_crop_left(const char *arg)
2337 {
2338 frame_leftBand = atoi(arg);
2339 if (frame_leftBand < 0) {
2340 fprintf(stderr, "Incorrect left crop size\n");
2341 av_exit(1);
2342 }
2343 if ((frame_leftBand % 2) != 0) {
2344 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2345 av_exit(1);
2346 }
2347 if ((frame_leftBand) >= frame_width){
2348 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2349 av_exit(1);
2350 }
2351 frame_width -= frame_leftBand;
2352 }
2353
2354 static void opt_frame_crop_right(const char *arg)
2355 {
2356 frame_rightBand = atoi(arg);
2357 if (frame_rightBand < 0) {
2358 fprintf(stderr, "Incorrect right crop size\n");
2359 av_exit(1);
2360 }
2361 if ((frame_rightBand % 2) != 0) {
2362 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2363 av_exit(1);
2364 }
2365 if ((frame_rightBand) >= frame_width){
2366 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2367 av_exit(1);
2368 }
2369 frame_width -= frame_rightBand;
2370 }
2371
2372 static void opt_frame_size(const char *arg)
2373 {
2374 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2375 fprintf(stderr, "Incorrect frame size\n");
2376 av_exit(1);
2377 }
2378 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2379 fprintf(stderr, "Frame size must be a multiple of 2\n");
2380 av_exit(1);
2381 }
2382 }
2383
2384
2385 #define SCALEBITS 10
2386 #define ONE_HALF (1 << (SCALEBITS - 1))
2387 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2388
2389 #define RGB_TO_Y(r, g, b) \
2390 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2391 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2392
2393 #define RGB_TO_U(r1, g1, b1, shift)\
2394 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2395 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2396
2397 #define RGB_TO_V(r1, g1, b1, shift)\
2398 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2399 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2400
2401 static void opt_pad_color(const char *arg) {
2402 /* Input is expected to be six hex digits similar to
2403 how colors are expressed in html tags (but without the #) */
2404 int rgb = strtol(arg, NULL, 16);
2405 int r,g,b;
2406
2407 r = (rgb >> 16);
2408 g = ((rgb >> 8) & 255);
2409 b = (rgb & 255);
2410
2411 padcolor[0] = RGB_TO_Y(r,g,b);
2412 padcolor[1] = RGB_TO_U(r,g,b,0);
2413 padcolor[2] = RGB_TO_V(r,g,b,0);
2414 }
2415
2416 static void opt_frame_pad_top(const char *arg)
2417 {
2418 frame_padtop = atoi(arg);
2419 if (frame_padtop < 0) {
2420 fprintf(stderr, "Incorrect top pad size\n");
2421 av_exit(1);
2422 }
2423 if ((frame_padtop % 2) != 0) {
2424 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2425 av_exit(1);
2426 }
2427 }
2428
2429 static void opt_frame_pad_bottom(const char *arg)
2430 {
2431 frame_padbottom = atoi(arg);
2432 if (frame_padbottom < 0) {
2433 fprintf(stderr, "Incorrect bottom pad size\n");
2434 av_exit(1);
2435 }
2436 if ((frame_padbottom % 2) != 0) {
2437 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2438 av_exit(1);
2439 }
2440 }
2441
2442
2443 static void opt_frame_pad_left(const char *arg)
2444 {
2445 frame_padleft = atoi(arg);
2446 if (frame_padleft < 0) {
2447 fprintf(stderr, "Incorrect left pad size\n");
2448 av_exit(1);
2449 }
2450 if ((frame_padleft % 2) != 0) {
2451 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2452 av_exit(1);
2453 }
2454 }
2455
2456
2457 static void opt_frame_pad_right(const char *arg)
2458 {
2459 frame_padright = atoi(arg);
2460 if (frame_padright < 0) {
2461 fprintf(stderr, "Incorrect right pad size\n");
2462 av_exit(1);
2463 }
2464 if ((frame_padright % 2) != 0) {
2465 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2466 av_exit(1);
2467 }
2468 }
2469
2470 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2471 {
2472 int i;
2473 char fmt_str[128];
2474 for (i=-1; i < nb_fmts; i++) {
2475 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2476 fprintf(stdout, "%s\n", fmt_str);
2477 }
2478 }
2479
2480 static void opt_frame_pix_fmt(const char *arg)
2481 {
2482 if (strcmp(arg, "list"))
2483 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2484 else {
2485 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2486 av_exit(0);
2487 }
2488 }
2489
2490 static void opt_frame_aspect_ratio(const char *arg)
2491 {
2492 int x = 0, y = 0;
2493 double ar = 0;
2494 const char *p;
2495 char *end;
2496
2497 p = strchr(arg, ':');
2498 if (p) {
2499 x = strtol(arg, &end, 10);
2500 if (end == p)
2501 y = strtol(end+1, &end, 10);
2502 if (x > 0 && y > 0)
2503 ar = (double)x / (double)y;
2504 } else
2505 ar = strtod(arg, NULL);
2506
2507 if (!ar) {
2508 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2509 av_exit(1);
2510 }
2511 frame_aspect_ratio = ar;
2512 }
2513
2514 static void opt_qscale(const char *arg)
2515 {
2516 video_qscale = atof(arg);
2517 if (video_qscale <= 0 ||
2518 video_qscale > 255) {
2519 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2520 av_exit(1);
2521 }
2522 }
2523
2524 static void opt_top_field_first(const char *arg)
2525 {
2526 top_field_first= atoi(arg);
2527 }
2528
2529 static int opt_thread_count(const char *opt, const char *arg)
2530 {
2531 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2532 #if !defined(HAVE_THREADS)
2533 if (verbose >= 0)
2534 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2535 #endif
2536 return 0;
2537 }
2538
2539 static void opt_audio_sample_fmt(const char *arg)
2540 {
2541 if (strcmp(arg, "list"))
2542 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2543 else {
2544 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2545 av_exit(0);
2546 }
2547 }
2548
2549 static int opt_audio_rate(const char *opt, const char *arg)
2550 {
2551 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2552 return 0;
2553 }
2554
2555 static int opt_audio_channels(const char *opt, const char *arg)
2556 {
2557 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2558 return 0;
2559 }
2560
2561 static void opt_video_channel(const char *arg)
2562 {
2563 video_channel = strtol(arg, NULL, 0);
2564 }
2565
2566 static void opt_video_standard(const char *arg)
2567 {
2568 video_standard = av_strdup(arg);
2569 }
2570
2571 static void opt_codec(int *pstream_copy, char **pcodec_name,
2572 int codec_type, const char *arg)
2573 {
2574 av_freep(pcodec_name);
2575 if (!strcmp(arg, "copy")) {
2576 *pstream_copy = 1;
2577 } else {
2578 *pcodec_name = av_strdup(arg);
2579 }
2580 }
2581
2582 static void opt_audio_codec(const char *arg)
2583 {
2584 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2585 }
2586
2587 static void opt_audio_tag(const char *arg)
2588 {
2589 char *tail;
2590 audio_codec_tag= strtol(arg, &tail, 0);
2591
2592 if(!tail || *tail)
2593 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2594 }
2595
2596 static void opt_video_tag(const char *arg)
2597 {
2598 char *tail;
2599 video_codec_tag= strtol(arg, &tail, 0);
2600
2601 if(!tail || *tail)
2602 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2603 }
2604
2605 #ifdef CONFIG_VHOOK
2606 static void add_frame_hooker(const char *arg)
2607 {
2608 int argc = 0;
2609 char *argv[64];
2610 int i;
2611 char *args = av_strdup(arg);
2612
2613 using_vhook = 1;
2614
2615 argv[0] = strtok(args, " ");
2616 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2617 }
2618
2619 i = frame_hook_add(argc, argv);
2620
2621 if (i != 0) {
2622 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2623 av_exit(1);
2624 }
2625 }
2626 #endif
2627
2628 static void opt_video_codec(const char *arg)
2629 {
2630 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2631 }
2632
2633 static void opt_subtitle_codec(const char *arg)
2634 {
2635 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2636 }
2637
2638 static void opt_map(const char *arg)
2639 {
2640 AVStreamMap *m;
2641 char *p;
2642
2643 m = &stream_maps[nb_stream_maps++];
2644
2645 m->file_index = strtol(arg, &p, 0);
2646 if (*p)
2647 p++;
2648
2649 m->stream_index = strtol(p, &p, 0);
2650 if (*p) {
2651 p++;
2652 m->sync_file_index = strtol(p, &p, 0);
2653 if (*p)
2654 p++;
2655 m->sync_stream_index = strtol(p, &p, 0);
2656 } else {
2657 m->sync_file_index = m->file_index;
2658 m->sync_stream_index = m->stream_index;
2659 }
2660 }
2661
2662 static void opt_map_meta_data(const char *arg)
2663 {
2664 AVMetaDataMap *m;
2665 char *p;
2666
2667 m = &meta_data_maps[nb_meta_data_maps++];
2668
2669 m->out_file = strtol(arg, &p, 0);
2670 if (*p)
2671 p++;
2672
2673 m->in_file = strtol(p, &p, 0);
2674 }
2675
2676 static void opt_input_ts_scale(const char *arg)
2677 {
2678 unsigned int stream;
2679 double scale;
2680 char *p;
2681
2682 stream = strtol(arg, &p, 0);
2683 if (*p)
2684 p++;
2685 scale= strtod(p, &p);
2686
2687 if(stream >= MAX_STREAMS)
2688 av_exit(1);
2689
2690 input_files_ts_scale[nb_input_files][stream]= scale;
2691 }
2692
2693 static int opt_recording_time(const char *opt, const char *arg)
2694 {
2695 recording_time = parse_time_or_die(opt, arg, 1);
2696 return 0;
2697 }
2698
2699 static int opt_start_time(const char *opt, const char *arg)
2700 {
2701 start_time = parse_time_or_die(opt, arg, 1);
2702 return 0;
2703 }
2704
2705 static int opt_rec_timestamp(const char *opt, const char *arg)
2706 {
2707 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2708 return 0;
2709 }
2710
2711 static int opt_input_ts_offset(const char *opt, const char *arg)
2712 {
2713 input_ts_offset = parse_time_or_die(opt, arg, 1);
2714 return 0;
2715 }
2716
2717 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2718 {
2719 const char *codec_string = encoder ? "encoder" : "decoder";
2720 AVCodec *codec;
2721
2722 if(!name)
2723 return CODEC_ID_NONE;
2724 codec = encoder ?
2725 avcodec_find_encoder_by_name(name) :
2726 avcodec_find_decoder_by_name(name);
2727 if(!codec) {
2728 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2729 av_exit(1);
2730 }
2731 if(codec->type != type) {
2732 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2733 av_exit(1);
2734 }
2735 return codec->id;
2736 }
2737
2738 static void opt_input_file(const char *filename)
2739 {
2740 AVFormatContext *ic;
2741 AVFormatParameters params, *ap = &params;
2742 int err, i, ret, rfps, rfps_base;
2743 int64_t timestamp;
2744
2745 if (!strcmp(filename, "-"))
2746 filename = "pipe:";
2747
2748 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2749 !strcmp(filename, "/dev/stdin");
2750
2751 /* get default parameters from command line */
2752 ic = av_alloc_format_context();
2753
2754 memset(ap, 0, sizeof(*ap));
2755 ap->prealloced_context = 1;
2756 ap->sample_rate = audio_sample_rate;
2757 ap->channels = audio_channels;
2758 ap->time_base.den = frame_rate.num;
2759 ap->time_base.num = frame_rate.den;
2760 ap->width = frame_width + frame_padleft + frame_padright;
2761 ap->height = frame_height + frame_padtop + frame_padbottom;
2762 ap->pix_fmt = frame_pix_fmt;
2763 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2764 ap->channel = video_channel;
2765 ap->standard = video_standard;
2766 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2767 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2768 if(pgmyuv_compatibility_hack)
2769 ap->video_codec_id= CODEC_ID_PGMYUV;
2770
2771 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2772
2773 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2774 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2775 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2776
2777 /* open the input file with generic libav function */
2778 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2779 if (err < 0) {
2780 print_error(filename, err);
2781 av_exit(1);
2782 }
2783 if(opt_programid) {
2784 int i;
2785 for(i=0; i<ic->nb_programs; i++)
2786 if(ic->programs[i]->id != opt_programid)
2787 ic->programs[i]->discard = AVDISCARD_ALL;
2788 }
2789
2790 ic->loop_input = loop_input;
2791
2792 /* If not enough info to get the stream parameters, we decode the
2793 first frames to get it. (used in mpeg case for example) */
2794 ret = av_find_stream_info(ic);
2795 if (ret < 0 && verbose >= 0) {
2796 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2797 av_exit(1);
2798 }
2799
2800 timestamp = start_time;
2801 /* add the stream start time */
2802 if (ic->start_time != AV_NOPTS_VALUE)
2803 timestamp += ic->start_time;
2804
2805 /* if seeking requested, we execute it */
2806 if (start_time != 0) {
2807 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2808 if (ret < 0) {
2809 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2810 filename, (double)timestamp / AV_TIME_BASE);
2811 }
2812 /* reset seek info */
2813 start_time = 0;
2814 }
2815
2816 /* update the current parameters so that they match the one of the input stream */
2817 for(i=0;i<ic->nb_streams;i++) {
2818 AVCodecContext *enc = ic->streams[i]->codec;
2819 if(thread_count>1)
2820 avcodec_thread_init(enc, thread_count);
2821 enc->thread_count= thread_count;
2822 switch(enc->codec_type) {
2823 case CODEC_TYPE_AUDIO:
2824 set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2825 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2826 audio_channels = enc->channels;
2827 audio_sample_rate = enc->sample_rate;
2828 audio_sample_fmt = enc->sample_fmt;
2829 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2830 if(audio_disable)
2831 ic->streams[i]->discard= AVDISCARD_ALL;
2832 break;
2833 case CODEC_TYPE_VIDEO:
2834 set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2835 frame_height = enc->height;
2836 frame_width = enc->width;
2837 if(ic->streams[i]->sample_aspect_ratio.num)
2838 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2839 else
2840 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2841 frame_aspect_ratio *= (float) enc->width / enc->height;
2842 frame_pix_fmt = enc->pix_fmt;
2843 rfps = ic->streams[i]->r_frame_rate.num;
2844 rfps_base = ic->streams[i]->r_frame_rate.den;
2845 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2846 if(me_threshold)
2847 enc->debug |= FF_DEBUG_MV;
2848
2849 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2850
2851 if (verbose >= 0)
2852 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2853 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2854
2855 (float)rfps / rfps_base, rfps, rfps_base);
2856 }
2857 /* update the current frame rate to match the stream frame rate */
2858 frame_rate.num = rfps;
2859 frame_rate.den = rfps_base;
2860
2861 enc->rate_emu = rate_emu;
2862 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2863 if(video_disable)
2864 ic->streams[i]->discard= AVDISCARD_ALL;
2865 else if(video_discard)
2866 ic->streams[i]->discard= video_discard;
2867 break;
2868 case CODEC_TYPE_DATA:
2869 break;
2870 case CODEC_TYPE_SUBTITLE:
2871 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2872 if(subtitle_disable)
2873 ic->streams[i]->discard = AVDISCARD_ALL;
2874 break;
2875 case CODEC_TYPE_ATTACHMENT:
2876 case CODEC_TYPE_UNKNOWN:
2877 nb_icodecs++;
2878 break;
2879 default:
2880 abort();
2881 }
2882 }
2883
2884 input_files[nb_input_files] = ic;
2885 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2886 /* dump the file content */
2887 if (verbose >= 0)
2888 dump_format(ic, nb_input_files, filename, 0);
2889
2890 nb_input_files++;
2891 file_iformat = NULL;
2892 file_oformat = NULL;
2893
2894 video_channel = 0;
2895
2896 rate_emu = 0;
2897 av_freep(&video_codec_name);
2898 av_freep(&audio_codec_name);
2899 av_freep(&subtitle_codec_name);
2900 }
2901
2902 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2903 int *has_subtitle_ptr)
2904 {
2905 int has_video, has_audio, has_subtitle, i, j;
2906 AVFormatContext *ic;
2907
2908 has_video = 0;
2909 has_audio = 0;
2910 has_subtitle = 0;
2911 for(j=0;j<nb_input_files;j++) {
2912 ic = input_files[j];
2913 for(i=0;i<ic->nb_streams;i++) {
2914 AVCodecContext *enc = ic->streams[i]->codec;
2915 switch(enc->codec_type) {
2916 case CODEC_TYPE_AUDIO:
2917 has_audio = 1;
2918 break;
2919 case CODEC_TYPE_VIDEO:
2920 has_video = 1;
2921 break;
2922 case CODEC_TYPE_SUBTITLE:
2923 has_subtitle = 1;
2924 break;
2925 case CODEC_TYPE_DATA:
2926 case CODEC_TYPE_ATTACHMENT:
2927 case CODEC_TYPE_UNKNOWN:
2928 break;
2929 default:
2930 abort();
2931 }
2932 }
2933 }
2934 *has_video_ptr = has_video;
2935 *has_audio_ptr = has_audio;
2936 *has_subtitle_ptr = has_subtitle;
2937 }
2938
2939 static void new_video_stream(AVFormatContext *oc)
2940 {
2941 AVStream *st;
2942 AVCodecContext *video_enc;
2943 int codec_id;
2944
2945 st = av_new_stream(oc, oc->nb_streams);
2946 if (!st) {
2947 fprintf(stderr, "Could not alloc stream\n");
2948 av_exit(1);
2949 }
2950 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2951 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2952 video_bitstream_filters= NULL;
2953
2954 if(thread_count>1)
2955 avcodec_thread_init(st->codec, thread_count);
2956
2957 video_enc = st->codec;
2958
2959 if(video_codec_tag)
2960 video_enc->codec_tag= video_codec_tag;
2961
2962 if( (video_global_header&1)
2963 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2964 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2965 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2966 }
2967 if(video_global_header&2){
2968 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2969 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2970 }
2971
2972 if (video_stream_copy) {
2973 st->stream_copy = 1;
2974 video_enc->codec_type = CODEC_TYPE_VIDEO;
2975 video_enc->sample_aspect_ratio =
2976 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2977 } else {
2978 const char *p;
2979 int i;
2980 AVCodec *codec;
2981 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
2982
2983 if (video_codec_name) {
2984 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2985 codec = avcodec_find_encoder_by_name(video_codec_name);
2986 output_codecs[nb_ocodecs] = codec;
2987 } else {
2988 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2989 codec = avcodec_find_encoder(codec_id);
2990 }
2991
2992 video_enc->codec_id = codec_id;
2993
2994 set_context_opts(video_enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
2995
2996 if (codec && codec->supported_framerates && !force_fps)
2997 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
2998 video_enc->time_base.den = fps.num;
2999 video_enc->time_base.num = fps.den;
3000
3001 video_enc->width = frame_width + frame_padright + frame_padleft;
3002 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3003 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3004 video_enc->pix_fmt = frame_pix_fmt;
3005 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3006
3007 if(codec && codec->pix_fmts){
3008 const enum PixelFormat *p= codec->pix_fmts;
3009 for(; *p!=-1; p++){
3010 if(*p == video_enc->pix_fmt)
3011 break;
3012 }
3013 if(*p == -1)
3014 video_enc->pix_fmt = codec->pix_fmts[0];
3015 }
3016
3017 if (intra_only)
3018 video_enc->gop_size = 0;
3019 if (video_qscale || same_quality) {
3020 video_enc->flags |= CODEC_FLAG_QSCALE;
3021 video_enc->global_quality=
3022 st->quality = FF_QP2LAMBDA * video_qscale;
3023 }
3024
3025 if(intra_matrix)
3026 video_enc->intra_matrix = intra_matrix;
3027 if(inter_matrix)
3028 video_enc->inter_matrix = inter_matrix;
3029
3030 video_enc->thread_count = thread_count;
3031 p= video_rc_override_string;
3032 for(i=0; p; i++){
3033 int start, end, q;
3034 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3035 if(e!=3){
3036 fprintf(stderr, "error parsing rc_override\n");
3037 av_exit(1);
3038 }
3039 video_enc->rc_override=
3040 av_realloc(video_enc->rc_override,
3041 sizeof(RcOverride)*(i+1));
3042 video_enc->rc_override[i].start_frame= start;
3043 video_enc->rc_override[i].end_frame = end;
3044 if(q>0){
3045 video_enc->rc_override[i].qscale= q;
3046 video_enc->rc_override[i].quality_factor= 1.0;
3047 }
3048 else{
3049 video_enc->rc_override[i].qscale= 0;
3050 video_enc->rc_override[i].quality_factor= -q/100.0;
3051 }
3052 p= strchr(p, '/');
3053 if(p) p++;
3054 }
3055 video_enc->rc_override_count=i;
3056 if (!video_enc->rc_initial_buffer_occupancy)
3057 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3058 video_enc->me_threshold= me_threshold;
3059 video_enc->intra_dc_precision= intra_dc_precision - 8;
3060
3061 if (do_psnr)
3062 video_enc->flags|= CODEC_FLAG_PSNR;
3063
3064 /* two pass mode */
3065 if (do_pass) {
3066 if (do_pass == 1) {
3067 video_enc->flags |= CODEC_FLAG_PASS1;
3068 } else {
3069 video_enc->flags |= CODEC_FLAG_PASS2;
3070 }
3071 }
3072 }
3073 nb_ocodecs++;
3074
3075 /* reset some key parameters */
3076 video_disable = 0;
3077 av_freep(&video_codec_name);
3078 video_stream_copy = 0;
3079 }
3080
3081 static void new_audio_stream(AVFormatContext *oc)
3082 {
3083 AVStream *st;
3084 AVCodecContext *audio_enc;
3085 int codec_id;
3086
3087 st = av_new_stream(oc, oc->nb_streams);
3088 if (!st) {
3089 fprintf(stderr, "Could not alloc stream\n");
3090 av_exit(1);
3091 }
3092 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3093
3094 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3095 audio_bitstream_filters= NULL;
3096
3097 if(thread_count>1)
3098 avcodec_thread_init(st->codec, thread_count);
3099
3100 audio_enc = st->codec;
3101 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3102
3103 if(audio_codec_tag)
3104 audio_enc->codec_tag= audio_codec_tag;
3105
3106 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3107 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3108 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3109 }
3110 if (audio_stream_copy) {
3111 st->stream_copy = 1;
3112 audio_enc->channels = audio_channels;
3113 } else {
3114 AVCodec *codec;
3115
3116 set_context_opts(audio_enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3117
3118 if (audio_codec_name) {
3119 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3120 codec = avcodec_find_encoder_by_name(audio_codec_name);
3121 output_codecs[nb_ocodecs] = codec;
3122 } else {
3123 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3124 codec = avcodec_find_encoder(codec_id);
3125 }
3126 audio_enc->codec_id = codec_id;
3127
3128 if (audio_qscale > QSCALE_NONE) {
3129 audio_enc->flags |= CODEC_FLAG_QSCALE;
3130 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3131 }
3132 audio_enc->thread_count = thread_count;
3133 audio_enc->channels = audio_channels;
3134 audio_enc->sample_fmt = audio_sample_fmt;
3135
3136 if(codec && codec->sample_fmts){
3137 const enum SampleFormat *p= codec->sample_fmts;
3138 for(; *p!=-1; p++){
3139 if(*p == audio_enc->sample_fmt)
3140 break;
3141 }
3142 if(*p == -1)
3143 audio_enc->sample_fmt = codec->sample_fmts[0];
3144 }
3145 }
3146 nb_ocodecs++;
3147 audio_enc->sample_rate = audio_sample_rate;
3148 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3149 if (audio_language) {
3150 av_strlcpy(st->language, audio_language, sizeof(st->language));
3151 av_free(audio_language);
3152 audio_language = NULL;
3153 }
3154
3155 /* reset some key parameters */
3156 audio_disable = 0;
3157 av_freep(&audio_codec_name);
3158 audio_stream_copy = 0;
3159 }
3160
3161 static void new_subtitle_stream(AVFormatContext *oc)
3162 {
3163 AVStream *st;
3164 AVCodecContext *subtitle_enc;
3165
3166 st = av_new_stream(oc, oc->nb_streams);
3167 if (!st) {
3168 fprintf(stderr, "Could not alloc stream\n");
3169 av_exit(1);
3170 }
3171 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3172
3173 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3174 subtitle_bitstream_filters= NULL;
3175
3176 subtitle_enc = st->codec;
3177 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3178 if (subtitle_stream_copy) {
3179 st->stream_copy = 1;
3180 } else {
3181 set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3182 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3183 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3184 }
3185 nb_ocodecs++;
3186
3187 if (subtitle_language) {
3188 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3189 av_free(subtitle_language);
3190 subtitle_language = NULL;
3191 }
3192
3193 subtitle_disable = 0;
3194 av_freep(&subtitle_codec_name);
3195 subtitle_stream_copy = 0;
3196 }
3197
3198 static void opt_new_audio_stream(void)
3199 {
3200 AVFormatContext *oc;
3201 if (nb_output_files <= 0) {
3202 fprintf(stderr, "At least one output file must be specified\n");
3203 av_exit(1);
3204 }
3205 oc = output_files[nb_output_files - 1];
3206 new_audio_stream(oc);
3207 }
3208
3209 static void opt_new_video_stream(void)
3210 {
3211 AVFormatContext *oc;
3212 if (nb_output_files <= 0) {
3213 fprintf(stderr, "At least one output file must be specified\n");
3214 av_exit(1);
3215 }
3216 oc = output_files[nb_output_files - 1];
3217 new_video_stream(oc);
3218 }
3219
3220 static void opt_new_subtitle_stream(void)
3221 {
3222 AVFormatContext *oc;
3223 if (nb_output_files <= 0) {
3224 fprintf(stderr, "At least one output file must be specified\n");
3225 av_exit(1);
3226 }
3227 oc = output_files[nb_output_files - 1];
3228 new_subtitle_stream(oc);
3229 }
3230
3231 static void opt_output_file(const char *filename)
3232 {
3233 AVFormatContext *oc;
3234 int use_video, use_audio, use_subtitle;
3235 int input_has_video, input_has_audio, input_has_subtitle;
3236 AVFormatParameters params, *ap = &params;
3237
3238 if (!strcmp(filename, "-"))
3239 filename = "pipe:";
3240
3241 oc = av_alloc_format_context();
3242
3243 if (!file_oformat) {
3244 file_oformat = guess_format(NULL, filename, NULL);
3245 if (!file_oformat) {
3246 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3247 filename);
3248 av_exit(1);
3249 }
3250 }
3251
3252 oc->oformat = file_oformat;
3253 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3254
3255 if (!strcmp(file_oformat->name, "ffm") &&
3256 av_strstart(filename, "http:", NULL)) {
3257 /* special case for files sent to ffserver: we get the stream
3258 parameters from ffserver */
3259 int err = read_ffserver_streams(oc, filename);
3260 if (err < 0) {
3261 print_error(filename, err);
3262 av_exit(1);
3263 }
3264 } else {
3265 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3266 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3267 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3268
3269 /* disable if no corresponding type found and at least one
3270 input file */
3271 if (nb_input_files > 0) {
3272 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3273 &input_has_subtitle);
3274 if (!input_has_video)
3275 use_video = 0;
3276 if (!input_has_audio)
3277 use_audio = 0;
3278 if (!input_has_subtitle)
3279 use_subtitle = 0;
3280 }
3281
3282 /* manual disable */
3283 if (audio_disable) {
3284 use_audio = 0;
3285 }
3286 if (video_disable) {
3287 use_video = 0;
3288 }
3289 if (subtitle_disable) {
3290 use_subtitle = 0;
3291 }
3292
3293 if (use_video) {
3294 new_video_stream(oc);
3295 }
3296
3297 if (use_audio) {
3298 new_audio_stream(oc);
3299 }
3300
3301 if (use_subtitle) {
3302 new_subtitle_stream(oc);
3303 }
3304
3305 oc->timestamp = rec_timestamp;
3306
3307 if (str_title)
3308 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3309 if (str_author)
3310 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3311 if (str_copyright)
3312 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3313 if (str_comment)
3314 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3315 if (str_album)
3316 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3317 if (str_genre)
3318 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3319 }
3320
3321 output_files[nb_output_files++] = oc;
3322
3323 /* check filename in case of an image number is expected */
3324 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3325 if (!av_filename_number_test(oc->filename)) {
3326 print_error(oc->filename, AVERROR_NUMEXPECTED);
3327 av_exit(1);
3328 }
3329 }
3330
3331 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3332 /* test if it already exists to avoid loosing precious files */
3333 if (!file_overwrite &&
3334 (strchr(filename, ':') == NULL ||
3335 filename[1] == ':' ||
3336 av_strstart(filename, "file:", NULL))) {
3337 if (url_exist(filename)) {
3338 int c;
3339
3340 if (!using_stdin) {
3341 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3342 fflush(stderr);
3343 c = getchar();
3344 if (toupper(c) != 'Y') {
3345 fprintf(stderr, "Not overwriting - exiting\n");
3346 av_exit(1);
3347 }
3348 }
3349 else {
3350 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3351 av_exit(1);
3352 }
3353 }
3354 }
3355
3356 /* open the file */
3357 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3358 fprintf(stderr, "Could not open '%s'\n", filename);
3359 av_exit(1);
3360 }
3361 }
3362
3363 memset(ap, 0, sizeof(*ap));
3364 if (av_set_parameters(oc, ap) < 0) {
3365 fprintf(stderr, "%s: Invalid encoding parameters\n",
3366 oc->filename);
3367 av_exit(1);
3368 }
3369
3370 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3371 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3372 oc->loop_output = loop_output;
3373
3374 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3375
3376 /* reset some options */
3377 file_oformat = NULL;
3378 file_iformat = NULL;
3379 }
3380
3381 /* same option as mencoder */
3382 static void opt_pass(const char *pass_str)
3383 {
3384 int pass;
3385 pass = atoi(pass_str);
3386 if (pass != 1 && pass != 2) {
3387 fprintf(stderr, "pass number can be only 1 or 2\n");
3388 av_exit(1);
3389 }
3390 do_pass = pass;
3391 }
3392
3393 static int64_t getutime(void)
3394 {
3395 #ifdef HAVE_GETRUSAGE
3396 struct rusage rusage;
3397
3398 getrusage(RUSAGE_SELF, &rusage);
3399 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3400 #elif defined(HAVE_GETPROCESSTIMES)
3401 HANDLE proc;
3402 FILETIME c, e, k, u;
3403 proc = GetCurrentProcess();
3404 GetProcessTimes(proc, &c, &e, &k, &u);
3405 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3406 #else
3407 return av_gettime();
3408 #endif
3409 }
3410
3411 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3412 {
3413 int i;
3414 const char *p = str;
3415 for(i = 0;; i++) {
3416 dest[i] = atoi(p);
3417 if(i == 63)
3418 break;
3419 p = strchr(p, ',');
3420 if(!p) {
3421 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3422 av_exit(1);
3423 }
3424 p++;
3425 }
3426 }
3427
3428 static void opt_inter_matrix(const char *arg)
3429 {
3430 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3431 parse_matrix_coeffs(inter_matrix, arg);
3432 }
3433
3434 static void opt_intra_matrix(const char *arg)
3435 {
3436 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3437 parse_matrix_coeffs(intra_matrix, arg);
3438 }
3439
3440 /**
3441 * Trivial log callback.
3442 * Only suitable for show_help and similar since it lacks prefix handling.
3443 */
3444 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3445 {
3446 vfprintf(stdout, fmt, vl);
3447 }
3448
3449 static void show_help(void)
3450 {
3451 av_log_set_callback(log_callback_help);
3452 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3453 "Hyper fast Audio and Video encoder\n");
3454 printf("\n");
3455 show_help_options(options, "Main options:\n",
3456 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3457 show_help_options(options, "\nAdvanced options:\n",
3458 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3459 OPT_EXPERT);
3460 show_help_options(options, "\nVideo options:\n",
3461 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3462 OPT_VIDEO);
3463 show_help_options(options, "\nAdvanced Video options:\n",
3464 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3465 OPT_VIDEO | OPT_EXPERT);
3466 show_help_options(options, "\nAudio options:\n",
3467 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3468 OPT_AUDIO);
3469 show_help_options(options, "\nAdvanced Audio options:\n",
3470 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3471 OPT_AUDIO | OPT_EXPERT);
3472 show_help_options(options, "\nSubtitle options:\n",
3473 OPT_SUBTITLE | OPT_GRAB,
3474 OPT_SUBTITLE);
3475 show_help_options(options, "\nAudio/Video grab options:\n",
3476 OPT_GRAB,
3477 OPT_GRAB);
3478 printf("\n");
3479 av_opt_show(avctx_opts[0], NULL);
3480 printf("\n");
3481 av_opt_show(avformat_opts, NULL);
3482 printf("\n");
3483 av_opt_show(sws_opts, NULL);
3484 }
3485
3486 static void opt_target(const char *arg)
3487 {
3488 int norm = -1;
3489 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3490
3491 if(!strncmp(arg, "pal-", 4)) {
3492 norm = 0;
3493 arg += 4;
3494 } else if(!strncmp(arg, "ntsc-", 5)) {
3495 norm = 1;
3496 arg += 5;
3497 } else if(!strncmp(arg, "film-", 5)) {
3498 norm = 2;
3499 arg += 5;
3500 } else {
3501 int fr;
3502 /* Calculate FR via float to avoid int overflow */
3503 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3504 if(fr == 25000) {
3505 norm = 0;
3506 } else if((fr == 29970) || (fr == 23976)) {
3507 norm = 1;
3508 } else {
3509 /* Try to determine PAL/NTSC by peeking in the input files */
3510 if(nb_input_files) {
3511 int i, j;
3512 for(j = 0; j < nb_input_files; j++) {
3513 for(i = 0; i < input_files[j]->nb_streams; i++) {
3514 AVCodecContext *c = input_files[j]->streams[i]->codec;
3515 if(c->codec_type != CODEC_TYPE_VIDEO)
3516 continue;
3517 fr = c->time_base.den * 1000 / c->time_base.num;
3518 if(fr == 25000) {
3519 norm = 0;
3520 break;
3521 } else if((fr == 29970) || (fr == 23976)) {
3522 norm = 1;
3523 break;
3524 }
3525 }
3526 if(norm >= 0)
3527 break;
3528 }
3529 }
3530 }
3531 if(verbose && norm >= 0)
3532 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3533 }
3534
3535 if(norm < 0) {
3536 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3537 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3538 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3539 av_exit(1);
3540 }
3541
3542 if(!strcmp(arg, "vcd")) {
3543
3544 opt_video_codec("mpeg1video");
3545 opt_audio_codec("mp2");
3546 opt_format("vcd");
3547
3548 opt_frame_size(norm ? "352x240" : "352x288");
3549 opt_frame_rate(NULL, frame_rates[norm]);
3550 opt_default("gop", norm ? "18" : "15");
3551
3552 opt_default("b", "1150000");
3553 opt_default("maxrate", "1150000");
3554 opt_default("minrate", "1150000");
3555 opt_default("bufsize", "327680"); // 40*1024*8;
3556
3557 opt_default("ab", "224000");
3558 audio_sample_rate = 44100;
3559 audio_channels = 2;
3560
3561 opt_default("packetsize", "2324");
3562 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3563
3564 /* We have to offset the PTS, so that it is consistent with the SCR.
3565 SCR starts at 36000, but the first two packs contain only padding
3566 and the first pack from the other stream, respectively, may also have
3567 been written before.
3568 So the real data starts at SCR 36000+3*1200. */
3569 mux_preload= (36000+3*1200) / 90000.0; //0.44
3570 } else if(!strcmp(arg, "svcd")) {
3571
3572 opt_video_codec("mpeg2video");
3573 opt_audio_codec("mp2");
3574 opt_format("svcd");
3575
3576 opt_frame_size(norm ? "480x480" : "480x576");
3577 opt_frame_rate(NULL, frame_rates[norm]);
3578 opt_default("gop", norm ? "18" : "15");
3579
3580 opt_default("b", "2040000");
3581 opt_default("maxrate", "2516000");
3582 opt_default("minrate", "0"); //1145000;
3583 opt_default("bufsize", "1835008"); //224*1024*8;
3584 opt_default("flags", "+scan_offset");
3585
3586
3587 opt_default("ab", "224000");
3588 audio_sample_rate = 44100;
3589
3590 opt_default("packetsize", "2324");
3591
3592 } else if(!strcmp(arg, "dvd")) {
3593
3594 opt_video_codec("mpeg2video");
3595 opt_audio_codec("ac3");
3596 opt_format("dvd");
3597
3598 opt_frame_size(norm ? "720x480" : "720x576");
3599 opt_frame_rate(NULL, frame_rates[norm]);
3600 opt_default("gop", norm ? "18" : "15");
3601
3602 opt_default("b", "6000000");
3603 opt_default("maxrate", "9000000");
3604 opt_default("minrate", "0"); //1500000;
3605 opt_default("bufsize", "1835008"); //224*1024*8;
3606
3607 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3608 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3609
3610 opt_default("ab", "448000");
3611 audio_sample_rate = 48000;
3612
3613 } else if(!strncmp(arg, "dv", 2)) {
3614
3615 opt_format("dv");
3616
3617 opt_frame_size(norm ? "720x480" : "720x576");
3618 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3619 (norm ? "yuv411p" : "yuv420p"));
3620 opt_frame_rate(NULL, frame_rates[norm]);
3621
3622 audio_sample_rate = 48000;
3623 audio_channels = 2;
3624
3625 } else {
3626 fprintf(stderr, "Unknown target: %s\n", arg);
3627 av_exit(1);
3628 }
3629 }
3630
3631 static void opt_vstats_file (const char *arg)
3632 {
3633 av_free (vstats_filename);
3634 vstats_filename=av_strdup (arg);
3635 }
3636
3637 static void opt_vstats (void)
3638 {
3639 char filename[40];
3640 time_t today2 = time(NULL);
3641 struct tm *today = localtime(&today2);
3642
3643 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3644 today->tm_sec);
3645 opt_vstats_file(filename);
3646 }
3647
3648 static int opt_bsf(const char *opt, const char *arg)
3649 {
3650 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3651 AVBitStreamFilterContext **bsfp;
3652
3653 if(!bsfc){
3654 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3655 av_exit(1);
3656 }
3657
3658 bsfp= *opt == 'v' ? &video_bitstream_filters :
3659 *opt == 'a' ? &audio_bitstream_filters :
3660 &subtitle_bitstream_filters;
3661 while(*bsfp)
3662 bsfp= &(*bsfp)->next;
3663
3664 *bsfp= bsfc;
3665
3666 return 0;
3667 }
3668
3669 static int opt_preset(const char *opt, const char *arg)
3670 {
3671 FILE *f=NULL;
3672 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3673 int i;
3674 const char *base[3]= { getenv("HOME"),
3675 "/usr/local/share",
3676 "/usr/share",
3677 };
3678
3679 for(i=!base[0]; i<3 && !f; i++){
3680 snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3681 f= fopen(filename, "r");
3682 if(!f){
3683 char *codec_name= *opt == 'v' ? video_codec_name :
3684 *opt == 'a' ? audio_codec_name :
3685 subtitle_codec_name;
3686 snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s-%s.ffpreset", base[i], i ? "" : ".", codec_name, arg);
3687 f= fopen(filename, "r");
3688 }
3689 }
3690 if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3691 is_dos_path(arg))){
3692 snprintf(filename, sizeof(filename), arg);
3693 f= fopen(filename, "r");
3694 }
3695
3696 if(!f){
3697 fprintf(stderr, "File for preset '%s' not found\n", arg);
3698 av_exit(1);
3699 }
3700
3701 while(!feof(f)){
3702 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3703 if(line[0] == '#' && !e)
3704 continue;
3705 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3706 if(e){
3707 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3708 av_exit(1);
3709 }
3710 if(!strcmp(tmp, "acodec")){
3711 opt_audio_codec(tmp2);
3712 }else if(!strcmp(tmp, "vcodec")){
3713 opt_video_codec(tmp2);
3714 }else if(!strcmp(tmp, "scodec")){
3715 opt_subtitle_codec(tmp2);
3716 }else if(opt_default(tmp, tmp2) < 0){
3717 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3718 av_exit(1);
3719 }
3720 }
3721
3722 fclose(f);
3723
3724 return 0;
3725 }
3726
3727 static const OptionDef options[] = {
3728 /* main options */
3729 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3730 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3731 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3732 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3733 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3734 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3735 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3736 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3737 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3738 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3739 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3740 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3741 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3742 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3743 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3744 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3745 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3746 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3747 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3748 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3749 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3750 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3751 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3752 "add timings for benchmarking" },
3753 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3754 "dump each input packet" },
3755 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3756 "when dumping packets, also dump the payload" },
3757 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3758 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3759 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3760 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3761 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3762 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3763 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3764 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3765 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3766 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3767 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3768 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3769 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3770 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3771 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3772
3773 /* video options */
3774 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3775 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3776 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3777 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3778 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3779 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3780 { "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" },
3781 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3782 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3783 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3784 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3785 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3786 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3787 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3788 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3789 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3790 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3791 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3792 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3793 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3794 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3795 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3796 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3797 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3798 "use same video quality as source (implies VBR)" },
3799 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3800 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3801 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3802 "deinterlace pictures" },
3803 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3804 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3805 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3806 #ifdef CONFIG_VHOOK
3807 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3808 #endif
3809 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3810 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3811 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3812 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3813 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3814 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3815 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3816 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3817
3818 /* audio options */
3819 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3820 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3821 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3822 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3823 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3824 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3825 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3826 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3827 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3828 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3829 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3830 { "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" },
3831
3832 /* subtitle options */
3833 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3834 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3835 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3836 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3837
3838 /* grab options */
3839 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3840 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3841 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3842
3843 /* muxer options */
3844 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3845 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3846
3847 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3848 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3849 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3850
3851 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3852 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3853 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3854
3855 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3856 { NULL, },
3857 };
3858
3859 int main(int argc, char **argv)
3860 {
3861 int i;
3862 int64_t ti;
3863
3864 avcodec_register_all();
3865 avdevice_register_all();
3866 av_register_all();
3867
3868 if(isatty(STDIN_FILENO))
3869 url_set_interrupt_cb(decode_interrupt_cb);
3870
3871 for(i=0; i<CODEC_TYPE_NB; i++){
3872 avctx_opts[i]= avcodec_alloc_context2(i);
3873 }
3874 avformat_opts = av_alloc_format_context();
3875 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3876
3877 show_banner();
3878
3879 /* parse options */
3880 parse_options(argc, argv, options, opt_output_file);
3881
3882 /* file converter / grab */
3883 if (nb_output_files <= 0) {
3884 fprintf(stderr, "At least one output file must be specified\n");
3885 av_exit(1);
3886 }
3887
3888 if (nb_input_files == 0) {
3889 fprintf(stderr, "At least one input file must be specified\n");
3890 av_exit(1);
3891 }
3892
3893 ti = getutime();
3894 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3895 stream_maps, nb_stream_maps);
3896 ti = getutime() - ti;
3897 if (do_benchmark) {
3898 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3899 }
3900
3901 return av_exit(0);
3902 }
VDPAU for FFmpeg