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