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