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