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