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