?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ac3dec: use uint8_t for band sizes
[FFMpeg-mirror/lagarith.git] / ffmpeg.c
blobd601dc5d6af4a30a69ef911d9b3c026bd2ef94c7
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 static int64_t channel_layout = 0;
155 #define QSCALE_NONE -99999
156 static float audio_qscale = QSCALE_NONE;
157 static int audio_disable = 0;
158 static int audio_channels = 1;
159 static char *audio_codec_name = NULL;
160 static int audio_codec_tag = 0;
161 static char *audio_language = NULL;
162
163 static int subtitle_disable = 0;
164 static char *subtitle_codec_name = NULL;
165 static char *subtitle_language = NULL;
166
167 static float mux_preload= 0.5;
168 static float mux_max_delay= 0.7;
169
170 static int64_t recording_time = INT64_MAX;
171 static int64_t start_time = 0;
172 static int64_t rec_timestamp = 0;
173 static int64_t input_ts_offset = 0;
174 static int file_overwrite = 0;
175 static char *str_title = NULL;
176 static char *str_author = NULL;
177 static char *str_copyright = NULL;
178 static char *str_comment = NULL;
179 static char *str_genre = NULL;
180 static char *str_album = NULL;
181 static int do_benchmark = 0;
182 static int do_hex_dump = 0;
183 static int do_pkt_dump = 0;
184 static int do_psnr = 0;
185 static int do_pass = 0;
186 static char *pass_logfilename = NULL;
187 static int audio_stream_copy = 0;
188 static int video_stream_copy = 0;
189 static int subtitle_stream_copy = 0;
190 static int video_sync_method= -1;
191 static int audio_sync_method= 0;
192 static float audio_drift_threshold= 0.1;
193 static int copy_ts= 0;
194 static int opt_shortest = 0; //
195 static int video_global_header = 0;
196 static char *vstats_filename;
197 static FILE *vstats_file;
198 static int opt_programid = 0;
199
200 static int rate_emu = 0;
201
202 static int video_channel = 0;
203 static char *video_standard;
204
205 static int audio_volume = 256;
206
207 static int exit_on_error = 0;
208 static int using_stdin = 0;
209 static int using_vhook = 0;
210 static int verbose = 1;
211 static int thread_count= 1;
212 static int q_pressed = 0;
213 static int64_t video_size = 0;
214 static int64_t audio_size = 0;
215 static int64_t extra_size = 0;
216 static int nb_frames_dup = 0;
217 static int nb_frames_drop = 0;
218 static int input_sync;
219 static uint64_t limit_filesize = 0; //
220 static int force_fps = 0;
221
222 static int pgmyuv_compatibility_hack=0;
223 static float dts_delta_threshold = 10;
224
225 static unsigned int sws_flags = SWS_BICUBIC;
226
227 static int64_t timer_start;
228
229 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
230 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
231 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
232 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
233
234 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
235
236 struct AVInputStream;
237
238 typedef struct AVOutputStream {
239 int file_index; /* file index */
240 int index; /* stream index in the output file */
241 int source_index; /* AVInputStream index */
242 AVStream *st; /* stream in the output file */
243 int encoding_needed; /* true if encoding needed for this stream */
244 int frame_number;
245 /* input pts and corresponding output pts
246 for A/V sync */
247 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
248 struct AVInputStream *sync_ist; /* input stream to sync against */
249 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
250 /* video only */
251 int video_resample;
252 AVFrame pict_tmp; /* temporary image for resampling */
253 struct SwsContext *img_resample_ctx; /* for image resampling */
254 int resample_height;
255
256 int video_crop;
257 int topBand; /* cropping area sizes */
258 int leftBand;
259
260 int video_pad;
261 int padtop; /* padding area sizes */
262 int padbottom;
263 int padleft;
264 int padright;
265
266 /* audio only */
267 int audio_resample;
268 ReSampleContext *resample; /* for audio resampling */
269 int reformat_pair;
270 AVAudioConvert *reformat_ctx;
271 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
272 FILE *logfile;
273 } AVOutputStream;
274
275 typedef struct AVInputStream {
276 int file_index;
277 int index;
278 AVStream *st;
279 int discard; /* true if stream data should be discarded */
280 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
281 int64_t sample_index; /* current sample */
282
283 int64_t start; /* time when read started */
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 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<FF_ARRAY_ELEMS(qp_histogram))
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 (rate_emu) {
1309 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1310 int64_t now = av_gettime() - ist->start;
1311 if (pts > now)
1312 usleep(pts - now);
1313 }
1314
1315 /* if output time reached then transcode raw format,
1316 encode packets and output them */
1317 if (start_time == 0 || ist->pts >= start_time)
1318 for(i=0;i<nb_ostreams;i++) {
1319 int frame_size;
1320
1321 ost = ost_table[i];
1322 if (ost->source_index == ist_index) {
1323 os = output_files[ost->file_index];
1324
1325 #if 0
1326 printf("%d: got pts=%0.3f %0.3f\n", i,
1327 (double)pkt->pts / AV_TIME_BASE,
1328 ((double)ist->pts / AV_TIME_BASE) -
1329 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1330 #endif
1331 /* set the input output pts pairs */
1332 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1333
1334 if (ost->encoding_needed) {
1335 switch(ost->st->codec->codec_type) {
1336 case CODEC_TYPE_AUDIO:
1337 do_audio_out(os, ost, ist, data_buf, data_size);
1338 break;
1339 case CODEC_TYPE_VIDEO:
1340 do_video_out(os, ost, ist, &picture, &frame_size);
1341 if (vstats_filename && frame_size)
1342 do_video_stats(os, ost, frame_size);
1343 break;
1344 case CODEC_TYPE_SUBTITLE:
1345 do_subtitle_out(os, ost, ist, &subtitle,
1346 pkt->pts);
1347 break;
1348 default:
1349 abort();
1350 }
1351 } else {
1352 AVFrame avframe; //FIXME/XXX remove this
1353 AVPacket opkt;
1354 av_init_packet(&opkt);
1355
1356 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1357 continue;
1358
1359 /* no reencoding needed : output the packet directly */
1360 /* force the input stream PTS */
1361
1362 avcodec_get_frame_defaults(&avframe);
1363 ost->st->codec->coded_frame= &avframe;
1364 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1365
1366 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1367 audio_size += data_size;
1368 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1369 video_size += data_size;
1370 ost->sync_opts++;
1371 }
1372
1373 opkt.stream_index= ost->index;
1374 if(pkt->pts != AV_NOPTS_VALUE)
1375 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1376 else
1377 opkt.pts= AV_NOPTS_VALUE;
1378
1379 if (pkt->dts == AV_NOPTS_VALUE)
1380 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1381 else
1382 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1383
1384 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1385 opkt.flags= pkt->flags;
1386
1387 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1388 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1389 opkt.destruct= av_destruct_packet;
1390
1391 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1392 ost->st->codec->frame_number++;
1393 ost->frame_number++;
1394 av_free_packet(&opkt);
1395 }
1396 }
1397 }
1398 av_free(buffer_to_free);
1399 /* XXX: allocate the subtitles in the codec ? */
1400 if (subtitle_to_free) {
1401 if (subtitle_to_free->rects != NULL) {
1402 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1403 av_free(subtitle_to_free->rects[i].bitmap);
1404 av_free(subtitle_to_free->rects[i].rgba_palette);
1405 }
1406 av_freep(&subtitle_to_free->rects);
1407 }
1408 subtitle_to_free->num_rects = 0;
1409 subtitle_to_free = NULL;
1410 }
1411 }
1412 discard_packet:
1413 if (pkt == NULL) {
1414 /* EOF handling */
1415
1416 for(i=0;i<nb_ostreams;i++) {
1417 ost = ost_table[i];
1418 if (ost->source_index == ist_index) {
1419 AVCodecContext *enc= ost->st->codec;
1420 os = output_files[ost->file_index];
1421
1422 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1423 continue;
1424 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1425 continue;
1426
1427 if (ost->encoding_needed) {
1428 for(;;) {
1429 AVPacket pkt;
1430 int fifo_bytes;
1431 av_init_packet(&pkt);
1432 pkt.stream_index= ost->index;
1433
1434 switch(ost->st->codec->codec_type) {
1435 case CODEC_TYPE_AUDIO:
1436 fifo_bytes = av_fifo_size(&ost->fifo);
1437 ret = 0;
1438 /* encode any samples remaining in fifo */
1439 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1440 int fs_tmp = enc->frame_size;
1441 enc->frame_size = fifo_bytes / (2 * enc->channels);
1442 av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes);
1443 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1444 enc->frame_size = fs_tmp;
1445 }
1446 if(ret <= 0) {
1447 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1448 }
1449 audio_size += ret;
1450 pkt.flags |= PKT_FLAG_KEY;
1451 break;
1452 case CODEC_TYPE_VIDEO:
1453 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1454 video_size += ret;
1455 if(enc->coded_frame && enc->coded_frame->key_frame)
1456 pkt.flags |= PKT_FLAG_KEY;
1457 if (ost->logfile && enc->stats_out) {
1458 fprintf(ost->logfile, "%s", enc->stats_out);
1459 }
1460 break;
1461 default:
1462 ret=-1;
1463 }
1464
1465 if(ret<=0)
1466 break;
1467 pkt.data= bit_buffer;
1468 pkt.size= ret;
1469 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1470 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1471 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1472 }
1473 }
1474 }
1475 }
1476 }
1477
1478 return 0;
1479 fail_decode:
1480 return -1;
1481 }
1482
1483 static void print_sdp(AVFormatContext **avc, int n)
1484 {
1485 char sdp[2048];
1486
1487 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1488 printf("SDP:\n%s\n", sdp);
1489 fflush(stdout);
1490 }
1491
1492 static int stream_index_from_inputs(AVFormatContext **input_files,
1493 int nb_input_files,
1494 AVInputFile *file_table,
1495 AVInputStream **ist_table,
1496 enum CodecType type,
1497 int programid)
1498 {
1499 int p, q, z;
1500 for(z=0; z<nb_input_files; z++) {
1501 AVFormatContext *ic = input_files[z];
1502 for(p=0; p<ic->nb_programs; p++) {
1503 AVProgram *program = ic->programs[p];
1504 if(program->id != programid)
1505 continue;
1506 for(q=0; q<program->nb_stream_indexes; q++) {
1507 int sidx = program->stream_index[q];
1508 int ris = file_table[z].ist_index + sidx;
1509 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1510 return ris;
1511 }
1512 }
1513 }
1514
1515 return -1;
1516 }
1517
1518 /*
1519 * The following code is the main loop of the file converter
1520 */
1521 static int av_encode(AVFormatContext **output_files,
1522 int nb_output_files,
1523 AVFormatContext **input_files,
1524 int nb_input_files,
1525 AVStreamMap *stream_maps, int nb_stream_maps)
1526 {
1527 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1528 AVFormatContext *is, *os;
1529 AVCodecContext *codec, *icodec;
1530 AVOutputStream *ost, **ost_table = NULL;
1531 AVInputStream *ist, **ist_table = NULL;
1532 AVInputFile *file_table;
1533 int key;
1534 int want_sdp = 1;
1535
1536 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1537 if (!file_table)
1538 goto fail;
1539
1540 /* input stream init */
1541 j = 0;
1542 for(i=0;i<nb_input_files;i++) {
1543 is = input_files[i];
1544 file_table[i].ist_index = j;
1545 file_table[i].nb_streams = is->nb_streams;
1546 j += is->nb_streams;
1547 }
1548 nb_istreams = j;
1549
1550 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1551 if (!ist_table)
1552 goto fail;
1553
1554 for(i=0;i<nb_istreams;i++) {
1555 ist = av_mallocz(sizeof(AVInputStream));
1556 if (!ist)
1557 goto fail;
1558 ist_table[i] = ist;
1559 }
1560 j = 0;
1561 for(i=0;i<nb_input_files;i++) {
1562 is = input_files[i];
1563 for(k=0;k<is->nb_streams;k++) {
1564 ist = ist_table[j++];
1565 ist->st = is->streams[k];
1566 ist->file_index = i;
1567 ist->index = k;
1568 ist->discard = 1; /* the stream is discarded by default
1569 (changed later) */
1570
1571 if (rate_emu) {
1572 ist->start = av_gettime();
1573 }
1574 }
1575 }
1576
1577 /* output stream init */
1578 nb_ostreams = 0;
1579 for(i=0;i<nb_output_files;i++) {
1580 os = output_files[i];
1581 if (!os->nb_streams) {
1582 dump_format(output_files[i], i, output_files[i]->filename, 1);
1583 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1584 av_exit(1);
1585 }
1586 nb_ostreams += os->nb_streams;
1587 }
1588 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1589 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1590 av_exit(1);
1591 }
1592
1593 /* Sanity check the mapping args -- do the input files & streams exist? */
1594 for(i=0;i<nb_stream_maps;i++) {
1595 int fi = stream_maps[i].file_index;
1596 int si = stream_maps[i].stream_index;
1597
1598 if (fi < 0 || fi > nb_input_files - 1 ||
1599 si < 0 || si > file_table[fi].nb_streams - 1) {
1600 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1601 av_exit(1);
1602 }
1603 fi = stream_maps[i].sync_file_index;
1604 si = stream_maps[i].sync_stream_index;
1605 if (fi < 0 || fi > nb_input_files - 1 ||
1606 si < 0 || si > file_table[fi].nb_streams - 1) {
1607 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1608 av_exit(1);
1609 }
1610 }
1611
1612 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1613 if (!ost_table)
1614 goto fail;
1615 for(i=0;i<nb_ostreams;i++) {
1616 ost = av_mallocz(sizeof(AVOutputStream));
1617 if (!ost)
1618 goto fail;
1619 ost_table[i] = ost;
1620 }
1621
1622 n = 0;
1623 for(k=0;k<nb_output_files;k++) {
1624 os = output_files[k];
1625 for(i=0;i<os->nb_streams;i++,n++) {
1626 int found;
1627 ost = ost_table[n];
1628 ost->file_index = k;
1629 ost->index = i;
1630 ost->st = os->streams[i];
1631 if (nb_stream_maps > 0) {
1632 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1633 stream_maps[n].stream_index;
1634
1635 /* Sanity check that the stream types match */
1636 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1637 int i= ost->file_index;
1638 dump_format(output_files[i], i, output_files[i]->filename, 1);
1639 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1640 stream_maps[n].file_index, stream_maps[n].stream_index,
1641 ost->file_index, ost->index);
1642 av_exit(1);
1643 }
1644
1645 } else {
1646 if(opt_programid) {
1647 found = 0;
1648 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1649 if(j != -1) {
1650 ost->source_index = j;
1651 found = 1;
1652 }
1653 } else {
1654 /* get corresponding input stream index : we select the first one with the right type */
1655 found = 0;
1656 for(j=0;j<nb_istreams;j++) {
1657 ist = ist_table[j];
1658 if (ist->discard &&
1659 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1660 ost->source_index = j;
1661 found = 1;
1662 break;
1663 }
1664 }
1665 }
1666
1667 if (!found) {
1668 if(! opt_programid) {
1669 /* try again and reuse existing stream */
1670 for(j=0;j<nb_istreams;j++) {
1671 ist = ist_table[j];
1672 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1673 ost->source_index = j;
1674 found = 1;
1675 }
1676 }
1677 }
1678 if (!found) {
1679 int i= ost->file_index;
1680 dump_format(output_files[i], i, output_files[i]->filename, 1);
1681 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1682 ost->file_index, ost->index);
1683 av_exit(1);
1684 }
1685 }
1686 }
1687 ist = ist_table[ost->source_index];
1688 ist->discard = 0;
1689 ost->sync_ist = (nb_stream_maps > 0) ?
1690 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1691 stream_maps[n].sync_stream_index] : ist;
1692 }
1693 }
1694
1695 /* for each output stream, we compute the right encoding parameters */
1696 for(i=0;i<nb_ostreams;i++) {
1697 ost = ost_table[i];
1698 os = output_files[ost->file_index];
1699 ist = ist_table[ost->source_index];
1700
1701 codec = ost->st->codec;
1702 icodec = ist->st->codec;
1703
1704 if (!ost->st->language[0])
1705 av_strlcpy(ost->st->language, ist->st->language,
1706 sizeof(ost->st->language));
1707
1708 ost->st->disposition = ist->st->disposition;
1709
1710 if (ost->st->stream_copy) {
1711 /* if stream_copy is selected, no need to decode or encode */
1712 codec->codec_id = icodec->codec_id;
1713 codec->codec_type = icodec->codec_type;
1714
1715 if(!codec->codec_tag){
1716 if( !os->oformat->codec_tag
1717 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1718 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1719 codec->codec_tag = icodec->codec_tag;
1720 }
1721
1722 codec->bit_rate = icodec->bit_rate;
1723 codec->extradata= icodec->extradata;
1724 codec->extradata_size= icodec->extradata_size;
1725 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1726 codec->time_base = icodec->time_base;
1727 else
1728 codec->time_base = ist->st->time_base;
1729 switch(codec->codec_type) {
1730 case CODEC_TYPE_AUDIO:
1731 if(audio_volume != 256) {
1732 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1733 av_exit(1);
1734 }
1735 codec->channel_layout = icodec->channel_layout;
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 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
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 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
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 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2110 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2111 int64_t delta= pkt_dts - ist->next_pts;
2112 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2113 input_files_ts_offset[ist->file_index]-= delta;
2114 if (verbose > 2)
2115 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2116 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2117 if(pkt.pts != AV_NOPTS_VALUE)
2118 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2119 }
2120 }
2121
2122 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2123 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2124
2125 if (verbose >= 0)
2126 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2127 ist->file_index, ist->index);
2128 if (exit_on_error)
2129 av_exit(1);
2130 av_free_packet(&pkt);
2131 goto redo;
2132 }
2133
2134 discard_packet:
2135 av_free_packet(&pkt);
2136
2137 /* dump report by using the output first video and audio streams */
2138 print_report(output_files, ost_table, nb_ostreams, 0);
2139 }
2140
2141 /* at the end of stream, we must flush the decoder buffers */
2142 for(i=0;i<nb_istreams;i++) {
2143 ist = ist_table[i];
2144 if (ist->decoding_needed) {
2145 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2146 }
2147 }
2148
2149 term_exit();
2150
2151 /* write the trailer if needed and close file */
2152 for(i=0;i<nb_output_files;i++) {
2153 os = output_files[i];
2154 av_write_trailer(os);
2155 }
2156
2157 /* dump report by using the first video and audio streams */
2158 print_report(output_files, ost_table, nb_ostreams, 1);
2159
2160 /* close each encoder */
2161 for(i=0;i<nb_ostreams;i++) {
2162 ost = ost_table[i];
2163 if (ost->encoding_needed) {
2164 av_freep(&ost->st->codec->stats_in);
2165 avcodec_close(ost->st->codec);
2166 }
2167 }
2168
2169 /* close each decoder */
2170 for(i=0;i<nb_istreams;i++) {
2171 ist = ist_table[i];
2172 if (ist->decoding_needed) {
2173 avcodec_close(ist->st->codec);
2174 }
2175 }
2176
2177 /* finished ! */
2178
2179 ret = 0;
2180 fail1:
2181 av_freep(&bit_buffer);
2182 av_free(file_table);
2183
2184 if (ist_table) {
2185 for(i=0;i<nb_istreams;i++) {
2186 ist = ist_table[i];
2187 av_free(ist);
2188 }
2189 av_free(ist_table);
2190 }
2191 if (ost_table) {
2192 for(i=0;i<nb_ostreams;i++) {
2193 ost = ost_table[i];
2194 if (ost) {
2195 if (ost->logfile) {
2196 fclose(ost->logfile);
2197 ost->logfile = NULL;
2198 }
2199 av_fifo_free(&ost->fifo); /* works even if fifo is not
2200 initialized but set to zero */
2201 av_free(ost->pict_tmp.data[0]);
2202 if (ost->video_resample)
2203 sws_freeContext(ost->img_resample_ctx);
2204 if (ost->resample)
2205 audio_resample_close(ost->resample);
2206 if (ost->reformat_ctx)
2207 av_audio_convert_free(ost->reformat_ctx);
2208 av_free(ost);
2209 }
2210 }
2211 av_free(ost_table);
2212 }
2213 return ret;
2214 fail:
2215 ret = AVERROR(ENOMEM);
2216 goto fail1;
2217 }
2218
2219 #if 0
2220 int file_read(const char *filename)
2221 {
2222 URLContext *h;
2223 unsigned char buffer[1024];
2224 int len, i;
2225
2226 if (url_open(&h, filename, O_RDONLY) < 0) {
2227 printf("could not open '%s'\n", filename);
2228 return -1;
2229 }
2230 for(;;) {
2231 len = url_read(h, buffer, sizeof(buffer));
2232 if (len <= 0)
2233 break;
2234 for(i=0;i<len;i++) putchar(buffer[i]);
2235 }
2236 url_close(h);
2237 return 0;
2238 }
2239 #endif
2240
2241 static void opt_format(const char *arg)
2242 {
2243 /* compatibility stuff for pgmyuv */
2244 if (!strcmp(arg, "pgmyuv")) {
2245 pgmyuv_compatibility_hack=1;
2246 // opt_image_format(arg);
2247 arg = "image2";
2248 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2249 }
2250
2251 file_iformat = av_find_input_format(arg);
2252 file_oformat = guess_format(arg, NULL, NULL);
2253 if (!file_iformat && !file_oformat) {
2254 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2255 av_exit(1);
2256 }
2257 }
2258
2259 static void opt_video_rc_override_string(const char *arg)
2260 {
2261 video_rc_override_string = arg;
2262 }
2263
2264 static int opt_me_threshold(const char *opt, const char *arg)
2265 {
2266 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2267 return 0;
2268 }
2269
2270 static int opt_verbose(const char *opt, const char *arg)
2271 {
2272 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2273 av_log_set_level(verbose);
2274 return 0;
2275 }
2276
2277 static int opt_frame_rate(const char *opt, const char *arg)
2278 {
2279 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2280 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2281 av_exit(1);
2282 }
2283 return 0;
2284 }
2285
2286 static int opt_bitrate(const char *opt, const char *arg)
2287 {
2288 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2289
2290 opt_default(opt, arg);
2291
2292 if (av_get_int(avctx_opts[codec_type], "b", NULL) < 1000)
2293 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2294
2295 return 0;
2296 }
2297
2298 static void opt_frame_crop_top(const char *arg)
2299 {
2300 frame_topBand = atoi(arg);
2301 if (frame_topBand < 0) {
2302 fprintf(stderr, "Incorrect top crop size\n");
2303 av_exit(1);
2304 }
2305 if ((frame_topBand % 2) != 0) {
2306 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2307 av_exit(1);
2308 }
2309 if ((frame_topBand) >= frame_height){
2310 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2311 av_exit(1);
2312 }
2313 frame_height -= frame_topBand;
2314 }
2315
2316 static void opt_frame_crop_bottom(const char *arg)
2317 {
2318 frame_bottomBand = atoi(arg);
2319 if (frame_bottomBand < 0) {
2320 fprintf(stderr, "Incorrect bottom crop size\n");
2321 av_exit(1);
2322 }
2323 if ((frame_bottomBand % 2) != 0) {
2324 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2325 av_exit(1);
2326 }
2327 if ((frame_bottomBand) >= frame_height){
2328 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2329 av_exit(1);
2330 }
2331 frame_height -= frame_bottomBand;
2332 }
2333
2334 static void opt_frame_crop_left(const char *arg)
2335 {
2336 frame_leftBand = atoi(arg);
2337 if (frame_leftBand < 0) {
2338 fprintf(stderr, "Incorrect left crop size\n");
2339 av_exit(1);
2340 }
2341 if ((frame_leftBand % 2) != 0) {
2342 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2343 av_exit(1);
2344 }
2345 if ((frame_leftBand) >= frame_width){
2346 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2347 av_exit(1);
2348 }
2349 frame_width -= frame_leftBand;
2350 }
2351
2352 static void opt_frame_crop_right(const char *arg)
2353 {
2354 frame_rightBand = atoi(arg);
2355 if (frame_rightBand < 0) {
2356 fprintf(stderr, "Incorrect right crop size\n");
2357 av_exit(1);
2358 }
2359 if ((frame_rightBand % 2) != 0) {
2360 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2361 av_exit(1);
2362 }
2363 if ((frame_rightBand) >= frame_width){
2364 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2365 av_exit(1);
2366 }
2367 frame_width -= frame_rightBand;
2368 }
2369
2370 static void opt_frame_size(const char *arg)
2371 {
2372 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2373 fprintf(stderr, "Incorrect frame size\n");
2374 av_exit(1);
2375 }
2376 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2377 fprintf(stderr, "Frame size must be a multiple of 2\n");
2378 av_exit(1);
2379 }
2380 }
2381
2382
2383 #define SCALEBITS 10
2384 #define ONE_HALF (1 << (SCALEBITS - 1))
2385 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2386
2387 #define RGB_TO_Y(r, g, b) \
2388 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2389 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2390
2391 #define RGB_TO_U(r1, g1, b1, shift)\
2392 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2393 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2394
2395 #define RGB_TO_V(r1, g1, b1, shift)\
2396 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2397 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2398
2399 static void opt_pad_color(const char *arg) {
2400 /* Input is expected to be six hex digits similar to
2401 how colors are expressed in html tags (but without the #) */
2402 int rgb = strtol(arg, NULL, 16);
2403 int r,g,b;
2404
2405 r = (rgb >> 16);
2406 g = ((rgb >> 8) & 255);
2407 b = (rgb & 255);
2408
2409 padcolor[0] = RGB_TO_Y(r,g,b);
2410 padcolor[1] = RGB_TO_U(r,g,b,0);
2411 padcolor[2] = RGB_TO_V(r,g,b,0);
2412 }
2413
2414 static void opt_frame_pad_top(const char *arg)
2415 {
2416 frame_padtop = atoi(arg);
2417 if (frame_padtop < 0) {
2418 fprintf(stderr, "Incorrect top pad size\n");
2419 av_exit(1);
2420 }
2421 if ((frame_padtop % 2) != 0) {
2422 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2423 av_exit(1);
2424 }
2425 }
2426
2427 static void opt_frame_pad_bottom(const char *arg)
2428 {
2429 frame_padbottom = atoi(arg);
2430 if (frame_padbottom < 0) {
2431 fprintf(stderr, "Incorrect bottom pad size\n");
2432 av_exit(1);
2433 }
2434 if ((frame_padbottom % 2) != 0) {
2435 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2436 av_exit(1);
2437 }
2438 }
2439
2440
2441 static void opt_frame_pad_left(const char *arg)
2442 {
2443 frame_padleft = atoi(arg);
2444 if (frame_padleft < 0) {
2445 fprintf(stderr, "Incorrect left pad size\n");
2446 av_exit(1);
2447 }
2448 if ((frame_padleft % 2) != 0) {
2449 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2450 av_exit(1);
2451 }
2452 }
2453
2454
2455 static void opt_frame_pad_right(const char *arg)
2456 {
2457 frame_padright = atoi(arg);
2458 if (frame_padright < 0) {
2459 fprintf(stderr, "Incorrect right pad size\n");
2460 av_exit(1);
2461 }
2462 if ((frame_padright % 2) != 0) {
2463 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2464 av_exit(1);
2465 }
2466 }
2467
2468 static void list_fmts(void (*get_fmt_string)(char *buf, int buf_size, int fmt), int nb_fmts)
2469 {
2470 int i;
2471 char fmt_str[128];
2472 for (i=-1; i < nb_fmts; i++) {
2473 get_fmt_string (fmt_str, sizeof(fmt_str), i);
2474 fprintf(stdout, "%s\n", fmt_str);
2475 }
2476 }
2477
2478 static void opt_frame_pix_fmt(const char *arg)
2479 {
2480 if (strcmp(arg, "list"))
2481 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2482 else {
2483 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2484 av_exit(0);
2485 }
2486 }
2487
2488 static void opt_frame_aspect_ratio(const char *arg)
2489 {
2490 int x = 0, y = 0;
2491 double ar = 0;
2492 const char *p;
2493 char *end;
2494
2495 p = strchr(arg, ':');
2496 if (p) {
2497 x = strtol(arg, &end, 10);
2498 if (end == p)
2499 y = strtol(end+1, &end, 10);
2500 if (x > 0 && y > 0)
2501 ar = (double)x / (double)y;
2502 } else
2503 ar = strtod(arg, NULL);
2504
2505 if (!ar) {
2506 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2507 av_exit(1);
2508 }
2509 frame_aspect_ratio = ar;
2510 }
2511
2512 static void opt_qscale(const char *arg)
2513 {
2514 video_qscale = atof(arg);
2515 if (video_qscale <= 0 ||
2516 video_qscale > 255) {
2517 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2518 av_exit(1);
2519 }
2520 }
2521
2522 static void opt_top_field_first(const char *arg)
2523 {
2524 top_field_first= atoi(arg);
2525 }
2526
2527 static int opt_thread_count(const char *opt, const char *arg)
2528 {
2529 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2530 #if !defined(HAVE_THREADS)
2531 if (verbose >= 0)
2532 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2533 #endif
2534 return 0;
2535 }
2536
2537 static void opt_audio_sample_fmt(const char *arg)
2538 {
2539 if (strcmp(arg, "list"))
2540 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2541 else {
2542 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2543 av_exit(0);
2544 }
2545 }
2546
2547 static int opt_audio_rate(const char *opt, const char *arg)
2548 {
2549 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2550 return 0;
2551 }
2552
2553 static int opt_audio_channels(const char *opt, const char *arg)
2554 {
2555 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2556 return 0;
2557 }
2558
2559 static void opt_video_channel(const char *arg)
2560 {
2561 video_channel = strtol(arg, NULL, 0);
2562 }
2563
2564 static void opt_video_standard(const char *arg)
2565 {
2566 video_standard = av_strdup(arg);
2567 }
2568
2569 static void opt_codec(int *pstream_copy, char **pcodec_name,
2570 int codec_type, const char *arg)
2571 {
2572 av_freep(pcodec_name);
2573 if (!strcmp(arg, "copy")) {
2574 *pstream_copy = 1;
2575 } else {
2576 *pcodec_name = av_strdup(arg);
2577 }
2578 }
2579
2580 static void opt_audio_codec(const char *arg)
2581 {
2582 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2583 }
2584
2585 static void opt_audio_tag(const char *arg)
2586 {
2587 char *tail;
2588 audio_codec_tag= strtol(arg, &tail, 0);
2589
2590 if(!tail || *tail)
2591 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2592 }
2593
2594 static void opt_video_tag(const char *arg)
2595 {
2596 char *tail;
2597 video_codec_tag= strtol(arg, &tail, 0);
2598
2599 if(!tail || *tail)
2600 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2601 }
2602
2603 #ifdef CONFIG_VHOOK
2604 static void add_frame_hooker(const char *arg)
2605 {
2606 int argc = 0;
2607 char *argv[64];
2608 int i;
2609 char *args = av_strdup(arg);
2610
2611 using_vhook = 1;
2612
2613 argv[0] = strtok(args, " ");
2614 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2615 }
2616
2617 i = frame_hook_add(argc, argv);
2618
2619 if (i != 0) {
2620 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2621 av_exit(1);
2622 }
2623 }
2624 #endif
2625
2626 static void opt_video_codec(const char *arg)
2627 {
2628 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2629 }
2630
2631 static void opt_subtitle_codec(const char *arg)
2632 {
2633 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2634 }
2635
2636 static void opt_map(const char *arg)
2637 {
2638 AVStreamMap *m;
2639 char *p;
2640
2641 m = &stream_maps[nb_stream_maps++];
2642
2643 m->file_index = strtol(arg, &p, 0);
2644 if (*p)
2645 p++;
2646
2647 m->stream_index = strtol(p, &p, 0);
2648 if (*p) {
2649 p++;
2650 m->sync_file_index = strtol(p, &p, 0);
2651 if (*p)
2652 p++;
2653 m->sync_stream_index = strtol(p, &p, 0);
2654 } else {
2655 m->sync_file_index = m->file_index;
2656 m->sync_stream_index = m->stream_index;
2657 }
2658 }
2659
2660 static void opt_map_meta_data(const char *arg)
2661 {
2662 AVMetaDataMap *m;
2663 char *p;
2664
2665 m = &meta_data_maps[nb_meta_data_maps++];
2666
2667 m->out_file = strtol(arg, &p, 0);
2668 if (*p)
2669 p++;
2670
2671 m->in_file = strtol(p, &p, 0);
2672 }
2673
2674 static void opt_input_ts_scale(const char *arg)
2675 {
2676 unsigned int stream;
2677 double scale;
2678 char *p;
2679
2680 stream = strtol(arg, &p, 0);
2681 if (*p)
2682 p++;
2683 scale= strtod(p, &p);
2684
2685 if(stream >= MAX_STREAMS)
2686 av_exit(1);
2687
2688 input_files_ts_scale[nb_input_files][stream]= scale;
2689 }
2690
2691 static int opt_recording_time(const char *opt, const char *arg)
2692 {
2693 recording_time = parse_time_or_die(opt, arg, 1);
2694 return 0;
2695 }
2696
2697 static int opt_start_time(const char *opt, const char *arg)
2698 {
2699 start_time = parse_time_or_die(opt, arg, 1);
2700 return 0;
2701 }
2702
2703 static int opt_rec_timestamp(const char *opt, const char *arg)
2704 {
2705 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2706 return 0;
2707 }
2708
2709 static int opt_input_ts_offset(const char *opt, const char *arg)
2710 {
2711 input_ts_offset = parse_time_or_die(opt, arg, 1);
2712 return 0;
2713 }
2714
2715 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2716 {
2717 const char *codec_string = encoder ? "encoder" : "decoder";
2718 AVCodec *codec;
2719
2720 if(!name)
2721 return CODEC_ID_NONE;
2722 codec = encoder ?
2723 avcodec_find_encoder_by_name(name) :
2724 avcodec_find_decoder_by_name(name);
2725 if(!codec) {
2726 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2727 av_exit(1);
2728 }
2729 if(codec->type != type) {
2730 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2731 av_exit(1);
2732 }
2733 return codec->id;
2734 }
2735
2736 static void opt_input_file(const char *filename)
2737 {
2738 AVFormatContext *ic;
2739 AVFormatParameters params, *ap = &params;
2740 int err, i, ret, rfps, rfps_base;
2741 int64_t timestamp;
2742
2743 if (!strcmp(filename, "-"))
2744 filename = "pipe:";
2745
2746 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2747 !strcmp(filename, "/dev/stdin");
2748
2749 /* get default parameters from command line */
2750 ic = av_alloc_format_context();
2751
2752 memset(ap, 0, sizeof(*ap));
2753 ap->prealloced_context = 1;
2754 ap->sample_rate = audio_sample_rate;
2755 ap->channels = audio_channels;
2756 ap->time_base.den = frame_rate.num;
2757 ap->time_base.num = frame_rate.den;
2758 ap->width = frame_width + frame_padleft + frame_padright;
2759 ap->height = frame_height + frame_padtop + frame_padbottom;
2760 ap->pix_fmt = frame_pix_fmt;
2761 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2762 ap->channel = video_channel;
2763 ap->standard = video_standard;
2764 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2765 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2766 if(pgmyuv_compatibility_hack)
2767 ap->video_codec_id= CODEC_ID_PGMYUV;
2768
2769 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2770
2771 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2772 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2773 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2774
2775 /* open the input file with generic libav function */
2776 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2777 if (err < 0) {
2778 print_error(filename, err);
2779 av_exit(1);
2780 }
2781 if(opt_programid) {
2782 int i;
2783 for(i=0; i<ic->nb_programs; i++)
2784 if(ic->programs[i]->id != opt_programid)
2785 ic->programs[i]->discard = AVDISCARD_ALL;
2786 }
2787
2788 ic->loop_input = loop_input;
2789
2790 /* If not enough info to get the stream parameters, we decode the
2791 first frames to get it. (used in mpeg case for example) */
2792 ret = av_find_stream_info(ic);
2793 if (ret < 0 && verbose >= 0) {
2794 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2795 av_exit(1);
2796 }
2797
2798 timestamp = start_time;
2799 /* add the stream start time */
2800 if (ic->start_time != AV_NOPTS_VALUE)
2801 timestamp += ic->start_time;
2802
2803 /* if seeking requested, we execute it */
2804 if (start_time != 0) {
2805 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2806 if (ret < 0) {
2807 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2808 filename, (double)timestamp / AV_TIME_BASE);
2809 }
2810 /* reset seek info */
2811 start_time = 0;
2812 }
2813
2814 /* update the current parameters so that they match the one of the input stream */
2815 for(i=0;i<ic->nb_streams;i++) {
2816 AVCodecContext *enc = ic->streams[i]->codec;
2817 if(thread_count>1)
2818 avcodec_thread_init(enc, thread_count);
2819 enc->thread_count= thread_count;
2820 switch(enc->codec_type) {
2821 case CODEC_TYPE_AUDIO:
2822 set_context_opts(enc, avctx_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2823 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2824 channel_layout = enc->channel_layout;
2825 audio_channels = enc->channels;
2826 audio_sample_rate = enc->sample_rate;
2827 audio_sample_fmt = enc->sample_fmt;
2828 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2829 if(audio_disable)
2830 ic->streams[i]->discard= AVDISCARD_ALL;
2831 break;
2832 case CODEC_TYPE_VIDEO:
2833 set_context_opts(enc, avctx_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2834 frame_height = enc->height;
2835 frame_width = enc->width;
2836 if(ic->streams[i]->sample_aspect_ratio.num)
2837 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2838 else
2839 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2840 frame_aspect_ratio *= (float) enc->width / enc->height;
2841 frame_pix_fmt = enc->pix_fmt;
2842 rfps = ic->streams[i]->r_frame_rate.num;
2843 rfps_base = ic->streams[i]->r_frame_rate.den;
2844 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2845 if(me_threshold)
2846 enc->debug |= FF_DEBUG_MV;
2847
2848 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2849
2850 if (verbose >= 0)
2851 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2852 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2853
2854 (float)rfps / rfps_base, rfps, rfps_base);
2855 }
2856 /* update the current frame rate to match the stream frame rate */
2857 frame_rate.num = rfps;
2858 frame_rate.den = rfps_base;
2859
2860 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2861 if(video_disable)
2862 ic->streams[i]->discard= AVDISCARD_ALL;
2863 else if(video_discard)
2864 ic->streams[i]->discard= video_discard;
2865 break;
2866 case CODEC_TYPE_DATA:
2867 break;
2868 case CODEC_TYPE_SUBTITLE:
2869 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2870 if(subtitle_disable)
2871 ic->streams[i]->discard = AVDISCARD_ALL;
2872 break;
2873 case CODEC_TYPE_ATTACHMENT:
2874 case CODEC_TYPE_UNKNOWN:
2875 nb_icodecs++;
2876 break;
2877 default:
2878 abort();
2879 }
2880 }
2881
2882 input_files[nb_input_files] = ic;
2883 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2884 /* dump the file content */
2885 if (verbose >= 0)
2886 dump_format(ic, nb_input_files, filename, 0);
2887
2888 nb_input_files++;
2889 file_iformat = NULL;
2890 file_oformat = NULL;
2891
2892 video_channel = 0;
2893
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 audio_enc->channel_layout = channel_layout;
3133
3134 if(codec && codec->sample_fmts){
3135 const enum SampleFormat *p= codec->sample_fmts;
3136 for(; *p!=-1; p++){
3137 if(*p == audio_enc->sample_fmt)
3138 break;
3139 }
3140 if(*p == -1)
3141 audio_enc->sample_fmt = codec->sample_fmts[0];
3142 }
3143 }
3144 nb_ocodecs++;
3145 audio_enc->sample_rate = audio_sample_rate;
3146 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3147 if (audio_language) {
3148 av_strlcpy(st->language, audio_language, sizeof(st->language));
3149 av_free(audio_language);
3150 audio_language = NULL;
3151 }
3152
3153 /* reset some key parameters */
3154 audio_disable = 0;
3155 av_freep(&audio_codec_name);
3156 audio_stream_copy = 0;
3157 }
3158
3159 static void new_subtitle_stream(AVFormatContext *oc)
3160 {
3161 AVStream *st;
3162 AVCodecContext *subtitle_enc;
3163
3164 st = av_new_stream(oc, oc->nb_streams);
3165 if (!st) {
3166 fprintf(stderr, "Could not alloc stream\n");
3167 av_exit(1);
3168 }
3169 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3170
3171 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3172 subtitle_bitstream_filters= NULL;
3173
3174 subtitle_enc = st->codec;
3175 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3176 if (subtitle_stream_copy) {
3177 st->stream_copy = 1;
3178 } else {
3179 set_context_opts(avctx_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3180 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3181 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3182 }
3183 nb_ocodecs++;
3184
3185 if (subtitle_language) {
3186 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3187 av_free(subtitle_language);
3188 subtitle_language = NULL;
3189 }
3190
3191 subtitle_disable = 0;
3192 av_freep(&subtitle_codec_name);
3193 subtitle_stream_copy = 0;
3194 }
3195
3196 static void opt_new_audio_stream(void)
3197 {
3198 AVFormatContext *oc;
3199 if (nb_output_files <= 0) {
3200 fprintf(stderr, "At least one output file must be specified\n");
3201 av_exit(1);
3202 }
3203 oc = output_files[nb_output_files - 1];
3204 new_audio_stream(oc);
3205 }
3206
3207 static void opt_new_video_stream(void)
3208 {
3209 AVFormatContext *oc;
3210 if (nb_output_files <= 0) {
3211 fprintf(stderr, "At least one output file must be specified\n");
3212 av_exit(1);
3213 }
3214 oc = output_files[nb_output_files - 1];
3215 new_video_stream(oc);
3216 }
3217
3218 static void opt_new_subtitle_stream(void)
3219 {
3220 AVFormatContext *oc;
3221 if (nb_output_files <= 0) {
3222 fprintf(stderr, "At least one output file must be specified\n");
3223 av_exit(1);
3224 }
3225 oc = output_files[nb_output_files - 1];
3226 new_subtitle_stream(oc);
3227 }
3228
3229 static void opt_output_file(const char *filename)
3230 {
3231 AVFormatContext *oc;
3232 int use_video, use_audio, use_subtitle;
3233 int input_has_video, input_has_audio, input_has_subtitle;
3234 AVFormatParameters params, *ap = &params;
3235
3236 if (!strcmp(filename, "-"))
3237 filename = "pipe:";
3238
3239 oc = av_alloc_format_context();
3240
3241 if (!file_oformat) {
3242 file_oformat = guess_format(NULL, filename, NULL);
3243 if (!file_oformat) {
3244 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3245 filename);
3246 av_exit(1);
3247 }
3248 }
3249
3250 oc->oformat = file_oformat;
3251 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3252
3253 if (!strcmp(file_oformat->name, "ffm") &&
3254 av_strstart(filename, "http:", NULL)) {
3255 /* special case for files sent to ffserver: we get the stream
3256 parameters from ffserver */
3257 int err = read_ffserver_streams(oc, filename);
3258 if (err < 0) {
3259 print_error(filename, err);
3260 av_exit(1);
3261 }
3262 } else {
3263 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3264 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3265 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3266
3267 /* disable if no corresponding type found and at least one
3268 input file */
3269 if (nb_input_files > 0) {
3270 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3271 &input_has_subtitle);
3272 if (!input_has_video)
3273 use_video = 0;
3274 if (!input_has_audio)
3275 use_audio = 0;
3276 if (!input_has_subtitle)
3277 use_subtitle = 0;
3278 }
3279
3280 /* manual disable */
3281 if (audio_disable) {
3282 use_audio = 0;
3283 }
3284 if (video_disable) {
3285 use_video = 0;
3286 }
3287 if (subtitle_disable) {
3288 use_subtitle = 0;
3289 }
3290
3291 if (use_video) {
3292 new_video_stream(oc);
3293 }
3294
3295 if (use_audio) {
3296 new_audio_stream(oc);
3297 }
3298
3299 if (use_subtitle) {
3300 new_subtitle_stream(oc);
3301 }
3302
3303 oc->timestamp = rec_timestamp;
3304
3305 if (str_title)
3306 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3307 if (str_author)
3308 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3309 if (str_copyright)
3310 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3311 if (str_comment)
3312 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3313 if (str_album)
3314 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3315 if (str_genre)
3316 av_strlcpy(oc->genre, str_genre, sizeof(oc->genre));
3317 }
3318
3319 output_files[nb_output_files++] = oc;
3320
3321 /* check filename in case of an image number is expected */
3322 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3323 if (!av_filename_number_test(oc->filename)) {
3324 print_error(oc->filename, AVERROR_NUMEXPECTED);
3325 av_exit(1);
3326 }
3327 }
3328
3329 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3330 /* test if it already exists to avoid loosing precious files */
3331 if (!file_overwrite &&
3332 (strchr(filename, ':') == NULL ||
3333 filename[1] == ':' ||
3334 av_strstart(filename, "file:", NULL))) {
3335 if (url_exist(filename)) {
3336 int c;
3337
3338 if (!using_stdin) {
3339 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3340 fflush(stderr);
3341 c = getchar();
3342 if (toupper(c) != 'Y') {
3343 fprintf(stderr, "Not overwriting - exiting\n");
3344 av_exit(1);
3345 }
3346 }
3347 else {
3348 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3349 av_exit(1);
3350 }
3351 }
3352 }
3353
3354 /* open the file */
3355 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3356 fprintf(stderr, "Could not open '%s'\n", filename);
3357 av_exit(1);
3358 }
3359 }
3360
3361 memset(ap, 0, sizeof(*ap));
3362 if (av_set_parameters(oc, ap) < 0) {
3363 fprintf(stderr, "%s: Invalid encoding parameters\n",
3364 oc->filename);
3365 av_exit(1);
3366 }
3367
3368 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3369 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3370 oc->loop_output = loop_output;
3371
3372 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3373
3374 /* reset some options */
3375 file_oformat = NULL;
3376 file_iformat = NULL;
3377 }
3378
3379 /* same option as mencoder */
3380 static void opt_pass(const char *pass_str)
3381 {
3382 int pass;
3383 pass = atoi(pass_str);
3384 if (pass != 1 && pass != 2) {
3385 fprintf(stderr, "pass number can be only 1 or 2\n");
3386 av_exit(1);
3387 }
3388 do_pass = pass;
3389 }
3390
3391 static int64_t getutime(void)
3392 {
3393 #ifdef HAVE_GETRUSAGE
3394 struct rusage rusage;
3395
3396 getrusage(RUSAGE_SELF, &rusage);
3397 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3398 #elif defined(HAVE_GETPROCESSTIMES)
3399 HANDLE proc;
3400 FILETIME c, e, k, u;
3401 proc = GetCurrentProcess();
3402 GetProcessTimes(proc, &c, &e, &k, &u);
3403 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3404 #else
3405 return av_gettime();
3406 #endif
3407 }
3408
3409 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3410 {
3411 int i;
3412 const char *p = str;
3413 for(i = 0;; i++) {
3414 dest[i] = atoi(p);
3415 if(i == 63)
3416 break;
3417 p = strchr(p, ',');
3418 if(!p) {
3419 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3420 av_exit(1);
3421 }
3422 p++;
3423 }
3424 }
3425
3426 static void opt_inter_matrix(const char *arg)
3427 {
3428 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3429 parse_matrix_coeffs(inter_matrix, arg);
3430 }
3431
3432 static void opt_intra_matrix(const char *arg)
3433 {
3434 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3435 parse_matrix_coeffs(intra_matrix, arg);
3436 }
3437
3438 /**
3439 * Trivial log callback.
3440 * Only suitable for show_help and similar since it lacks prefix handling.
3441 */
3442 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3443 {
3444 vfprintf(stdout, fmt, vl);
3445 }
3446
3447 static void show_help(void)
3448 {
3449 av_log_set_callback(log_callback_help);
3450 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3451 "Hyper fast Audio and Video encoder\n");
3452 printf("\n");
3453 show_help_options(options, "Main options:\n",
3454 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3455 show_help_options(options, "\nAdvanced options:\n",
3456 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3457 OPT_EXPERT);
3458 show_help_options(options, "\nVideo options:\n",
3459 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3460 OPT_VIDEO);
3461 show_help_options(options, "\nAdvanced Video options:\n",
3462 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3463 OPT_VIDEO | OPT_EXPERT);
3464 show_help_options(options, "\nAudio options:\n",
3465 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3466 OPT_AUDIO);
3467 show_help_options(options, "\nAdvanced Audio options:\n",
3468 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3469 OPT_AUDIO | OPT_EXPERT);
3470 show_help_options(options, "\nSubtitle options:\n",
3471 OPT_SUBTITLE | OPT_GRAB,
3472 OPT_SUBTITLE);
3473 show_help_options(options, "\nAudio/Video grab options:\n",
3474 OPT_GRAB,
3475 OPT_GRAB);
3476 printf("\n");
3477 av_opt_show(avctx_opts[0], NULL);
3478 printf("\n");
3479 av_opt_show(avformat_opts, NULL);
3480 printf("\n");
3481 av_opt_show(sws_opts, NULL);
3482 }
3483
3484 static void opt_target(const char *arg)
3485 {
3486 int norm = -1;
3487 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3488
3489 if(!strncmp(arg, "pal-", 4)) {
3490 norm = 0;
3491 arg += 4;
3492 } else if(!strncmp(arg, "ntsc-", 5)) {
3493 norm = 1;
3494 arg += 5;
3495 } else if(!strncmp(arg, "film-", 5)) {
3496 norm = 2;
3497 arg += 5;
3498 } else {
3499 int fr;
3500 /* Calculate FR via float to avoid int overflow */
3501 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3502 if(fr == 25000) {
3503 norm = 0;
3504 } else if((fr == 29970) || (fr == 23976)) {
3505 norm = 1;
3506 } else {
3507 /* Try to determine PAL/NTSC by peeking in the input files */
3508 if(nb_input_files) {
3509 int i, j;
3510 for(j = 0; j < nb_input_files; j++) {
3511 for(i = 0; i < input_files[j]->nb_streams; i++) {
3512 AVCodecContext *c = input_files[j]->streams[i]->codec;
3513 if(c->codec_type != CODEC_TYPE_VIDEO)
3514 continue;
3515 fr = c->time_base.den * 1000 / c->time_base.num;
3516 if(fr == 25000) {
3517 norm = 0;
3518 break;
3519 } else if((fr == 29970) || (fr == 23976)) {
3520 norm = 1;
3521 break;
3522 }
3523 }
3524 if(norm >= 0)
3525 break;
3526 }
3527 }
3528 }
3529 if(verbose && norm >= 0)
3530 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3531 }
3532
3533 if(norm < 0) {
3534 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3535 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3536 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3537 av_exit(1);
3538 }
3539
3540 if(!strcmp(arg, "vcd")) {
3541
3542 opt_video_codec("mpeg1video");
3543 opt_audio_codec("mp2");
3544 opt_format("vcd");
3545
3546 opt_frame_size(norm ? "352x240" : "352x288");
3547 opt_frame_rate(NULL, frame_rates[norm]);
3548 opt_default("gop", norm ? "18" : "15");
3549
3550 opt_default("b", "1150000");
3551 opt_default("maxrate", "1150000");
3552 opt_default("minrate", "1150000");
3553 opt_default("bufsize", "327680"); // 40*1024*8;
3554
3555 opt_default("ab", "224000");
3556 audio_sample_rate = 44100;
3557 audio_channels = 2;
3558
3559 opt_default("packetsize", "2324");
3560 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3561
3562 /* We have to offset the PTS, so that it is consistent with the SCR.
3563 SCR starts at 36000, but the first two packs contain only padding
3564 and the first pack from the other stream, respectively, may also have
3565 been written before.
3566 So the real data starts at SCR 36000+3*1200. */
3567 mux_preload= (36000+3*1200) / 90000.0; //0.44
3568 } else if(!strcmp(arg, "svcd")) {
3569
3570 opt_video_codec("mpeg2video");
3571 opt_audio_codec("mp2");
3572 opt_format("svcd");
3573
3574 opt_frame_size(norm ? "480x480" : "480x576");
3575 opt_frame_rate(NULL, frame_rates[norm]);
3576 opt_default("gop", norm ? "18" : "15");
3577
3578 opt_default("b", "2040000");
3579 opt_default("maxrate", "2516000");
3580 opt_default("minrate", "0"); //1145000;
3581 opt_default("bufsize", "1835008"); //224*1024*8;
3582 opt_default("flags", "+scan_offset");
3583
3584
3585 opt_default("ab", "224000");
3586 audio_sample_rate = 44100;
3587
3588 opt_default("packetsize", "2324");
3589
3590 } else if(!strcmp(arg, "dvd")) {
3591
3592 opt_video_codec("mpeg2video");
3593 opt_audio_codec("ac3");
3594 opt_format("dvd");
3595
3596 opt_frame_size(norm ? "720x480" : "720x576");
3597 opt_frame_rate(NULL, frame_rates[norm]);
3598 opt_default("gop", norm ? "18" : "15");
3599
3600 opt_default("b", "6000000");
3601 opt_default("maxrate", "9000000");
3602 opt_default("minrate", "0"); //1500000;
3603 opt_default("bufsize", "1835008"); //224*1024*8;
3604
3605 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3606 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3607
3608 opt_default("ab", "448000");
3609 audio_sample_rate = 48000;
3610
3611 } else if(!strncmp(arg, "dv", 2)) {
3612
3613 opt_format("dv");
3614
3615 opt_frame_size(norm ? "720x480" : "720x576");
3616 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3617 (norm ? "yuv411p" : "yuv420p"));
3618 opt_frame_rate(NULL, frame_rates[norm]);
3619
3620 audio_sample_rate = 48000;
3621 audio_channels = 2;
3622
3623 } else {
3624 fprintf(stderr, "Unknown target: %s\n", arg);
3625 av_exit(1);
3626 }
3627 }
3628
3629 static void opt_vstats_file (const char *arg)
3630 {
3631 av_free (vstats_filename);
3632 vstats_filename=av_strdup (arg);
3633 }
3634
3635 static void opt_vstats (void)
3636 {
3637 char filename[40];
3638 time_t today2 = time(NULL);
3639 struct tm *today = localtime(&today2);
3640
3641 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3642 today->tm_sec);
3643 opt_vstats_file(filename);
3644 }
3645
3646 static int opt_bsf(const char *opt, const char *arg)
3647 {
3648 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3649 AVBitStreamFilterContext **bsfp;
3650
3651 if(!bsfc){
3652 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3653 av_exit(1);
3654 }
3655
3656 bsfp= *opt == 'v' ? &video_bitstream_filters :
3657 *opt == 'a' ? &audio_bitstream_filters :
3658 &subtitle_bitstream_filters;
3659 while(*bsfp)
3660 bsfp= &(*bsfp)->next;
3661
3662 *bsfp= bsfc;
3663
3664 return 0;
3665 }
3666
3667 static int opt_preset(const char *opt, const char *arg)
3668 {
3669 FILE *f=NULL;
3670 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3671 int i;
3672 const char *base[3]= { getenv("HOME"),
3673 "/usr/local/share",
3674 "/usr/share",
3675 };
3676
3677 for(i=!base[0]; i<3 && !f; i++){
3678 snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s.ffpreset", base[i], i ? "" : ".", arg);
3679 f= fopen(filename, "r");
3680 if(!f){
3681 char *codec_name= *opt == 'v' ? video_codec_name :
3682 *opt == 'a' ? audio_codec_name :
3683 subtitle_codec_name;
3684 snprintf(filename, sizeof(filename), "%s/%sffmpeg/%s-%s.ffpreset", base[i], i ? "" : ".", codec_name, arg);
3685 f= fopen(filename, "r");
3686 }
3687 }
3688 if(!f && ((arg[0]=='.' && arg[1]=='/') || arg[0]=='/' ||
3689 is_dos_path(arg))){
3690 snprintf(filename, sizeof(filename), arg);
3691 f= fopen(filename, "r");
3692 }
3693
3694 if(!f){
3695 fprintf(stderr, "File for preset '%s' not found\n", arg);
3696 av_exit(1);
3697 }
3698
3699 while(!feof(f)){
3700 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3701 if(line[0] == '#' && !e)
3702 continue;
3703 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3704 if(e){
3705 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3706 av_exit(1);
3707 }
3708 if(!strcmp(tmp, "acodec")){
3709 opt_audio_codec(tmp2);
3710 }else if(!strcmp(tmp, "vcodec")){
3711 opt_video_codec(tmp2);
3712 }else if(!strcmp(tmp, "scodec")){
3713 opt_subtitle_codec(tmp2);
3714 }else if(opt_default(tmp, tmp2) < 0){
3715 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3716 av_exit(1);
3717 }
3718 }
3719
3720 fclose(f);
3721
3722 return 0;
3723 }
3724
3725 static const OptionDef options[] = {
3726 /* main options */
3727 { "L", OPT_EXIT, {(void*)show_license}, "show license" },
3728 { "h", OPT_EXIT, {(void*)show_help}, "show help" },
3729 { "version", OPT_EXIT, {(void*)show_version}, "show version" },
3730 { "formats", OPT_EXIT, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3731 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3732 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3733 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3734 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3735 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3736 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3737 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3738 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3739 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3740 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3741 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3742 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3743 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3744 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3745 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3746 { "genre", HAS_ARG | OPT_STRING, {(void*)&str_genre}, "set the genre", "string" },
3747 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3748 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3749 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3750 "add timings for benchmarking" },
3751 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3752 "dump each input packet" },
3753 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3754 "when dumping packets, also dump the payload" },
3755 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3756 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3757 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3758 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set the logging verbosity level", "number" },
3759 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3760 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3761 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3762 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3763 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3764 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3765 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)&copy_ts}, "copy timestamps" },
3766 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3767 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3768 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3769 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3770
3771 /* video options */
3772 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3773 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3774 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3775 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3776 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3777 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3778 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3779 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3780 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3781 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3782 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3783 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3784 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3785 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3786 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3787 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3788 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3789 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3790 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3791 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3792 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3793 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3794 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3795 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3796 "use same video quality as source (implies VBR)" },
3797 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3798 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3799 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3800 "deinterlace pictures" },
3801 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3802 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3803 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3804 #ifdef CONFIG_VHOOK
3805 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3806 #endif
3807 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3808 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3809 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3810 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3811 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3812 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3813 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3814 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3815
3816 /* audio options */
3817 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3818 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3819 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3820 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3821 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3822 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3823 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3824 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3825 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3826 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3827 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3828 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3829
3830 /* subtitle options */
3831 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3832 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3833 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3834 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3835
3836 /* grab options */
3837 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3838 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3839 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3840
3841 /* muxer options */
3842 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3843 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3844
3845 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3846 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3847 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3848
3849 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3850 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3851 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3852
3853 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3854 { NULL, },
3855 };
3856
3857 int main(int argc, char **argv)
3858 {
3859 int i;
3860 int64_t ti;
3861
3862 avcodec_register_all();
3863 avdevice_register_all();
3864 av_register_all();
3865
3866 if(isatty(STDIN_FILENO))
3867 url_set_interrupt_cb(decode_interrupt_cb);
3868
3869 for(i=0; i<CODEC_TYPE_NB; i++){
3870 avctx_opts[i]= avcodec_alloc_context2(i);
3871 }
3872 avformat_opts = av_alloc_format_context();
3873 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3874
3875 show_banner();
3876
3877 /* parse options */
3878 parse_options(argc, argv, options, opt_output_file);
3879
3880 /* file converter / grab */
3881 if (nb_output_files <= 0) {
3882 fprintf(stderr, "At least one output file must be specified\n");
3883 av_exit(1);
3884 }
3885
3886 if (nb_input_files == 0) {
3887 fprintf(stderr, "At least one input file must be specified\n");
3888 av_exit(1);
3889 }
3890
3891 ti = getutime();
3892 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3893 stream_maps, nb_stream_maps);
3894 ti = getutime() - ti;
3895 if (do_benchmark) {
3896 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
3897 }
3898
3899 return av_exit(0);
3900 }
ffmpeg Lagarith lossless decoder