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