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