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