3 * Copyright (c) 2000-2011 The libav developers.
5 * This file is part of Libav.
7 * Libav 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.
12 * Libav 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.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 #include "libavformat/avformat.h"
31 #include "libavdevice/avdevice.h"
32 #include "libswscale/swscale.h"
33 #include "libavresample/avresample.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/audioconvert.h"
36 #include "libavutil/parseutils.h"
37 #include "libavutil/samplefmt.h"
38 #include "libavutil/colorspace.h"
39 #include "libavutil/fifo.h"
40 #include "libavutil/intreadwrite.h"
41 #include "libavutil/dict.h"
42 #include "libavutil/mathematics.h"
43 #include "libavutil/pixdesc.h"
44 #include "libavutil/avstring.h"
45 #include "libavutil/libm.h"
46 #include "libavutil/imgutils.h"
47 #include "libavutil/time.h"
48 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/buffersrc.h"
53 # include "libavfilter/buffersink.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
57 #include <sys/resource.h>
58 #elif HAVE_GETPROCESSTIMES
61 #if HAVE_GETPROCESSMEMORYINFO
67 #include <sys/select.h>
79 #include "libavutil/avassert.h"
81 const char program_name
[] = "avconv";
82 const int program_birth_year
= 2000;
84 static FILE *vstats_file
;
86 static int64_t video_size
= 0;
87 static int64_t audio_size
= 0;
88 static int64_t extra_size
= 0;
89 static int nb_frames_dup
= 0;
90 static int nb_frames_drop
= 0;
95 /* signal to input threads that they should exit; set by the main thread */
96 static int transcoding_finished
;
99 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
101 InputStream
**input_streams
= NULL
;
102 int nb_input_streams
= 0;
103 InputFile
**input_files
= NULL
;
104 int nb_input_files
= 0;
106 OutputStream
**output_streams
= NULL
;
107 int nb_output_streams
= 0;
108 OutputFile
**output_files
= NULL
;
109 int nb_output_files
= 0;
111 FilterGraph
**filtergraphs
;
114 static void term_exit(void)
116 av_log(NULL
, AV_LOG_QUIET
, "");
119 static volatile int received_sigterm
= 0;
120 static volatile int received_nb_signals
= 0;
123 sigterm_handler(int sig
)
125 received_sigterm
= sig
;
126 received_nb_signals
++;
130 static void term_init(void)
132 signal(SIGINT
, sigterm_handler
); /* Interrupt (ANSI). */
133 signal(SIGTERM
, sigterm_handler
); /* Termination (ANSI). */
135 signal(SIGXCPU
, sigterm_handler
);
139 static int decode_interrupt_cb(void *ctx
)
141 return received_nb_signals
> 1;
144 const AVIOInterruptCB int_cb
= { decode_interrupt_cb
, NULL
};
146 void exit_program(int ret
)
150 for (i
= 0; i
< nb_filtergraphs
; i
++) {
151 avfilter_graph_free(&filtergraphs
[i
]->graph
);
152 for (j
= 0; j
< filtergraphs
[i
]->nb_inputs
; j
++) {
153 av_freep(&filtergraphs
[i
]->inputs
[j
]->name
);
154 av_freep(&filtergraphs
[i
]->inputs
[j
]);
156 av_freep(&filtergraphs
[i
]->inputs
);
157 for (j
= 0; j
< filtergraphs
[i
]->nb_outputs
; j
++) {
158 av_freep(&filtergraphs
[i
]->outputs
[j
]->name
);
159 av_freep(&filtergraphs
[i
]->outputs
[j
]);
161 av_freep(&filtergraphs
[i
]->outputs
);
162 av_freep(&filtergraphs
[i
]);
164 av_freep(&filtergraphs
);
167 for (i
= 0; i
< nb_output_files
; i
++) {
168 AVFormatContext
*s
= output_files
[i
]->ctx
;
169 if (!(s
->oformat
->flags
& AVFMT_NOFILE
) && s
->pb
)
171 avformat_free_context(s
);
172 av_dict_free(&output_files
[i
]->opts
);
173 av_freep(&output_files
[i
]);
175 for (i
= 0; i
< nb_output_streams
; i
++) {
176 AVBitStreamFilterContext
*bsfc
= output_streams
[i
]->bitstream_filters
;
178 AVBitStreamFilterContext
*next
= bsfc
->next
;
179 av_bitstream_filter_close(bsfc
);
182 output_streams
[i
]->bitstream_filters
= NULL
;
183 avcodec_free_frame(&output_streams
[i
]->filtered_frame
);
185 av_freep(&output_streams
[i
]->forced_keyframes
);
186 av_freep(&output_streams
[i
]->avfilter
);
187 av_freep(&output_streams
[i
]->logfile_prefix
);
188 av_freep(&output_streams
[i
]);
190 for (i
= 0; i
< nb_input_files
; i
++) {
191 avformat_close_input(&input_files
[i
]->ctx
);
192 av_freep(&input_files
[i
]);
194 for (i
= 0; i
< nb_input_streams
; i
++) {
195 avcodec_free_frame(&input_streams
[i
]->decoded_frame
);
196 av_dict_free(&input_streams
[i
]->opts
);
197 free_buffer_pool(&input_streams
[i
]->buffer_pool
);
198 av_freep(&input_streams
[i
]->filters
);
199 av_freep(&input_streams
[i
]);
204 av_free(vstats_filename
);
206 av_freep(&input_streams
);
207 av_freep(&input_files
);
208 av_freep(&output_streams
);
209 av_freep(&output_files
);
214 avformat_network_deinit();
216 if (received_sigterm
) {
217 av_log(NULL
, AV_LOG_INFO
, "Received signal %d: terminating.\n",
218 (int) received_sigterm
);
225 void assert_avoptions(AVDictionary
*m
)
227 AVDictionaryEntry
*t
;
228 if ((t
= av_dict_get(m
, "", NULL
, AV_DICT_IGNORE_SUFFIX
))) {
229 av_log(NULL
, AV_LOG_FATAL
, "Option %s not found.\n", t
->key
);
234 static void assert_codec_experimental(AVCodecContext
*c
, int encoder
)
236 const char *codec_string
= encoder
? "encoder" : "decoder";
238 if (c
->codec
->capabilities
& CODEC_CAP_EXPERIMENTAL
&&
239 c
->strict_std_compliance
> FF_COMPLIANCE_EXPERIMENTAL
) {
240 av_log(NULL
, AV_LOG_FATAL
, "%s '%s' is experimental and might produce bad "
241 "results.\nAdd '-strict experimental' if you want to use it.\n",
242 codec_string
, c
->codec
->name
);
243 codec
= encoder
? avcodec_find_encoder(c
->codec
->id
) : avcodec_find_decoder(c
->codec
->id
);
244 if (!(codec
->capabilities
& CODEC_CAP_EXPERIMENTAL
))
245 av_log(NULL
, AV_LOG_FATAL
, "Or use the non experimental %s '%s'.\n",
246 codec_string
, codec
->name
);
252 * Update the requested input sample format based on the output sample format.
253 * This is currently only used to request float output from decoders which
254 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
255 * Ideally this will be removed in the future when decoders do not do format
256 * conversion and only output in their native format.
258 static void update_sample_fmt(AVCodecContext
*dec
, AVCodec
*dec_codec
,
261 /* if sample formats match or a decoder sample format has already been
262 requested, just return */
263 if (enc
->sample_fmt
== dec
->sample_fmt
||
264 dec
->request_sample_fmt
> AV_SAMPLE_FMT_NONE
)
267 /* if decoder supports more than one output format */
268 if (dec_codec
&& dec_codec
->sample_fmts
&&
269 dec_codec
->sample_fmts
[0] != AV_SAMPLE_FMT_NONE
&&
270 dec_codec
->sample_fmts
[1] != AV_SAMPLE_FMT_NONE
) {
271 const enum AVSampleFormat
*p
;
272 int min_dec
= -1, min_inc
= -1;
274 /* find a matching sample format in the encoder */
275 for (p
= dec_codec
->sample_fmts
; *p
!= AV_SAMPLE_FMT_NONE
; p
++) {
276 if (*p
== enc
->sample_fmt
) {
277 dec
->request_sample_fmt
= *p
;
279 } else if (*p
> enc
->sample_fmt
) {
280 min_inc
= FFMIN(min_inc
, *p
- enc
->sample_fmt
);
282 min_dec
= FFMIN(min_dec
, enc
->sample_fmt
- *p
);
285 /* if none match, provide the one that matches quality closest */
286 dec
->request_sample_fmt
= min_inc
> 0 ? enc
->sample_fmt
+ min_inc
:
287 enc
->sample_fmt
- min_dec
;
291 static void write_frame(AVFormatContext
*s
, AVPacket
*pkt
, OutputStream
*ost
)
293 AVBitStreamFilterContext
*bsfc
= ost
->bitstream_filters
;
294 AVCodecContext
*avctx
= ost
->st
->codec
;
298 * Audio encoders may split the packets -- #frames in != #packets out.
299 * But there is no reordering, so we can limit the number of output packets
300 * by simply dropping them here.
301 * Counting encoded video frames needs to be done separately because of
302 * reordering, see do_video_out()
304 if (!(avctx
->codec_type
== AVMEDIA_TYPE_VIDEO
&& avctx
->codec
)) {
305 if (ost
->frame_number
>= ost
->max_frames
) {
313 AVPacket new_pkt
= *pkt
;
314 int a
= av_bitstream_filter_filter(bsfc
, avctx
, NULL
,
315 &new_pkt
.data
, &new_pkt
.size
,
316 pkt
->data
, pkt
->size
,
317 pkt
->flags
& AV_PKT_FLAG_KEY
);
320 new_pkt
.destruct
= av_destruct_packet
;
322 av_log(NULL
, AV_LOG_ERROR
, "%s failed for stream %d, codec %s",
323 bsfc
->filter
->name
, pkt
->stream_index
,
324 avctx
->codec
? avctx
->codec
->name
: "copy");
334 pkt
->stream_index
= ost
->index
;
335 ret
= av_interleaved_write_frame(s
, pkt
);
337 print_error("av_interleaved_write_frame()", ret
);
342 static int check_recording_time(OutputStream
*ost
)
344 OutputFile
*of
= output_files
[ost
->file_index
];
346 if (of
->recording_time
!= INT64_MAX
&&
347 av_compare_ts(ost
->sync_opts
- ost
->first_pts
, ost
->st
->codec
->time_base
, of
->recording_time
,
348 AV_TIME_BASE_Q
) >= 0) {
355 static void do_audio_out(AVFormatContext
*s
, OutputStream
*ost
,
358 AVCodecContext
*enc
= ost
->st
->codec
;
362 av_init_packet(&pkt
);
366 if (!check_recording_time(ost
))
369 if (frame
->pts
== AV_NOPTS_VALUE
|| audio_sync_method
< 0)
370 frame
->pts
= ost
->sync_opts
;
371 ost
->sync_opts
= frame
->pts
+ frame
->nb_samples
;
373 if (avcodec_encode_audio2(enc
, &pkt
, frame
, &got_packet
) < 0) {
374 av_log(NULL
, AV_LOG_FATAL
, "Audio encoding failed\n");
379 if (pkt
.pts
!= AV_NOPTS_VALUE
)
380 pkt
.pts
= av_rescale_q(pkt
.pts
, enc
->time_base
, ost
->st
->time_base
);
381 if (pkt
.dts
!= AV_NOPTS_VALUE
)
382 pkt
.dts
= av_rescale_q(pkt
.dts
, enc
->time_base
, ost
->st
->time_base
);
383 if (pkt
.duration
> 0)
384 pkt
.duration
= av_rescale_q(pkt
.duration
, enc
->time_base
, ost
->st
->time_base
);
386 write_frame(s
, &pkt
, ost
);
388 audio_size
+= pkt
.size
;
392 static void pre_process_video_frame(InputStream
*ist
, AVPicture
*picture
, void **bufp
)
396 AVPicture picture_tmp
;
399 dec
= ist
->st
->codec
;
401 /* deinterlace : must be done before any resize */
402 if (do_deinterlace
) {
405 /* create temporary picture */
406 size
= avpicture_get_size(dec
->pix_fmt
, dec
->width
, dec
->height
);
407 buf
= av_malloc(size
);
411 picture2
= &picture_tmp
;
412 avpicture_fill(picture2
, buf
, dec
->pix_fmt
, dec
->width
, dec
->height
);
414 if (avpicture_deinterlace(picture2
, picture
,
415 dec
->pix_fmt
, dec
->width
, dec
->height
) < 0) {
416 /* if error, do not deinterlace */
417 av_log(NULL
, AV_LOG_WARNING
, "Deinterlacing failed\n");
426 if (picture
!= picture2
)
427 *picture
= *picture2
;
431 static void do_subtitle_out(AVFormatContext
*s
,
437 static uint8_t *subtitle_out
= NULL
;
438 int subtitle_out_max_size
= 1024 * 1024;
439 int subtitle_out_size
, nb
, i
;
443 if (pts
== AV_NOPTS_VALUE
) {
444 av_log(NULL
, AV_LOG_ERROR
, "Subtitle packets must have a pts\n");
450 enc
= ost
->st
->codec
;
453 subtitle_out
= av_malloc(subtitle_out_max_size
);
456 /* Note: DVB subtitle need one packet to draw them and one other
457 packet to clear them */
458 /* XXX: signal it in the codec context ? */
459 if (enc
->codec_id
== AV_CODEC_ID_DVB_SUBTITLE
)
464 for (i
= 0; i
< nb
; i
++) {
465 ost
->sync_opts
= av_rescale_q(pts
, ist
->st
->time_base
, enc
->time_base
);
466 if (!check_recording_time(ost
))
469 sub
->pts
= av_rescale_q(pts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
470 // start_display_time is required to be 0
471 sub
->pts
+= av_rescale_q(sub
->start_display_time
, (AVRational
){ 1, 1000 }, AV_TIME_BASE_Q
);
472 sub
->end_display_time
-= sub
->start_display_time
;
473 sub
->start_display_time
= 0;
474 subtitle_out_size
= avcodec_encode_subtitle(enc
, subtitle_out
,
475 subtitle_out_max_size
, sub
);
476 if (subtitle_out_size
< 0) {
477 av_log(NULL
, AV_LOG_FATAL
, "Subtitle encoding failed\n");
481 av_init_packet(&pkt
);
482 pkt
.data
= subtitle_out
;
483 pkt
.size
= subtitle_out_size
;
484 pkt
.pts
= av_rescale_q(sub
->pts
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
485 if (enc
->codec_id
== AV_CODEC_ID_DVB_SUBTITLE
) {
486 /* XXX: the pts correction is handled here. Maybe handling
487 it in the codec would be better */
489 pkt
.pts
+= 90 * sub
->start_display_time
;
491 pkt
.pts
+= 90 * sub
->end_display_time
;
493 write_frame(s
, &pkt
, ost
);
497 static void do_video_out(AVFormatContext
*s
,
500 int *frame_size
, float quality
)
502 int ret
, format_video_sync
;
504 AVCodecContext
*enc
= ost
->st
->codec
;
508 format_video_sync
= video_sync_method
;
509 if (format_video_sync
== VSYNC_AUTO
)
510 format_video_sync
= (s
->oformat
->flags
& AVFMT_NOTIMESTAMPS
) ? VSYNC_PASSTHROUGH
:
511 (s
->oformat
->flags
& AVFMT_VARIABLE_FPS
) ? VSYNC_VFR
: VSYNC_CFR
;
512 if (format_video_sync
!= VSYNC_PASSTHROUGH
&&
514 in_picture
->pts
!= AV_NOPTS_VALUE
&&
515 in_picture
->pts
< ost
->sync_opts
) {
517 av_log(NULL
, AV_LOG_VERBOSE
, "*** drop!\n");
521 if (in_picture
->pts
== AV_NOPTS_VALUE
)
522 in_picture
->pts
= ost
->sync_opts
;
523 ost
->sync_opts
= in_picture
->pts
;
526 if (!ost
->frame_number
)
527 ost
->first_pts
= in_picture
->pts
;
529 av_init_packet(&pkt
);
533 if (!check_recording_time(ost
) ||
534 ost
->frame_number
>= ost
->max_frames
)
537 if (s
->oformat
->flags
& AVFMT_RAWPICTURE
&&
538 enc
->codec
->id
== AV_CODEC_ID_RAWVIDEO
) {
539 /* raw pictures are written as AVPicture structure to
540 avoid any copies. We support temporarily the older
542 enc
->coded_frame
->interlaced_frame
= in_picture
->interlaced_frame
;
543 enc
->coded_frame
->top_field_first
= in_picture
->top_field_first
;
544 pkt
.data
= (uint8_t *)in_picture
;
545 pkt
.size
= sizeof(AVPicture
);
546 pkt
.pts
= av_rescale_q(in_picture
->pts
, enc
->time_base
, ost
->st
->time_base
);
547 pkt
.flags
|= AV_PKT_FLAG_KEY
;
549 write_frame(s
, &pkt
, ost
);
554 big_picture
= *in_picture
;
555 /* better than nothing: use input picture interlaced
557 big_picture
.interlaced_frame
= in_picture
->interlaced_frame
;
558 if (ost
->st
->codec
->flags
& (CODEC_FLAG_INTERLACED_DCT
|CODEC_FLAG_INTERLACED_ME
)) {
559 if (ost
->top_field_first
== -1)
560 big_picture
.top_field_first
= in_picture
->top_field_first
;
562 big_picture
.top_field_first
= !!ost
->top_field_first
;
565 /* handles same_quant here. This is not correct because it may
566 not be a global option */
567 big_picture
.quality
= quality
;
568 if (!enc
->me_threshold
)
569 big_picture
.pict_type
= 0;
570 if (ost
->forced_kf_index
< ost
->forced_kf_count
&&
571 big_picture
.pts
>= ost
->forced_kf_pts
[ost
->forced_kf_index
]) {
572 big_picture
.pict_type
= AV_PICTURE_TYPE_I
;
573 ost
->forced_kf_index
++;
575 ret
= avcodec_encode_video2(enc
, &pkt
, &big_picture
, &got_packet
);
577 av_log(NULL
, AV_LOG_FATAL
, "Video encoding failed\n");
582 if (pkt
.pts
!= AV_NOPTS_VALUE
)
583 pkt
.pts
= av_rescale_q(pkt
.pts
, enc
->time_base
, ost
->st
->time_base
);
584 if (pkt
.dts
!= AV_NOPTS_VALUE
)
585 pkt
.dts
= av_rescale_q(pkt
.dts
, enc
->time_base
, ost
->st
->time_base
);
587 write_frame(s
, &pkt
, ost
);
588 *frame_size
= pkt
.size
;
589 video_size
+= pkt
.size
;
591 /* if two pass, output log */
592 if (ost
->logfile
&& enc
->stats_out
) {
593 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
599 * For video, number of frames in == number of packets out.
600 * But there may be reordering, so we can't throw away frames on encoder
601 * flush, we need to limit them here, before they go into encoder.
606 static double psnr(double d
)
608 return -10.0 * log(d
) / log(10.0);
611 static void do_video_stats(AVFormatContext
*os
, OutputStream
*ost
,
616 double ti1
, bitrate
, avg_bitrate
;
618 /* this is executed just the first time do_video_stats is called */
620 vstats_file
= fopen(vstats_filename
, "w");
627 enc
= ost
->st
->codec
;
628 if (enc
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
629 frame_number
= ost
->frame_number
;
630 fprintf(vstats_file
, "frame= %5d q= %2.1f ", frame_number
, enc
->coded_frame
->quality
/ (float)FF_QP2LAMBDA
);
631 if (enc
->flags
&CODEC_FLAG_PSNR
)
632 fprintf(vstats_file
, "PSNR= %6.2f ", psnr(enc
->coded_frame
->error
[0] / (enc
->width
* enc
->height
* 255.0 * 255.0)));
634 fprintf(vstats_file
,"f_size= %6d ", frame_size
);
635 /* compute pts value */
636 ti1
= ost
->sync_opts
* av_q2d(enc
->time_base
);
640 bitrate
= (frame_size
* 8) / av_q2d(enc
->time_base
) / 1000.0;
641 avg_bitrate
= (double)(video_size
* 8) / ti1
/ 1000.0;
642 fprintf(vstats_file
, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
643 (double)video_size
/ 1024, ti1
, bitrate
, avg_bitrate
);
644 fprintf(vstats_file
, "type= %c\n", av_get_picture_type_char(enc
->coded_frame
->pict_type
));
649 * Read one frame for lavfi output for ost and encode it.
651 static int poll_filter(OutputStream
*ost
)
653 OutputFile
*of
= output_files
[ost
->file_index
];
654 AVFilterBufferRef
*picref
;
655 AVFrame
*filtered_frame
= NULL
;
658 if (!ost
->filtered_frame
&& !(ost
->filtered_frame
= avcodec_alloc_frame())) {
659 return AVERROR(ENOMEM
);
661 avcodec_get_frame_defaults(ost
->filtered_frame
);
662 filtered_frame
= ost
->filtered_frame
;
664 if (ost
->enc
->type
== AVMEDIA_TYPE_AUDIO
&&
665 !(ost
->enc
->capabilities
& CODEC_CAP_VARIABLE_FRAME_SIZE
))
666 ret
= av_buffersink_read_samples(ost
->filter
->filter
, &picref
,
667 ost
->st
->codec
->frame_size
);
669 ret
= av_buffersink_read(ost
->filter
->filter
, &picref
);
674 avfilter_copy_buf_props(filtered_frame
, picref
);
675 if (picref
->pts
!= AV_NOPTS_VALUE
) {
676 filtered_frame
->pts
= av_rescale_q(picref
->pts
,
677 ost
->filter
->filter
->inputs
[0]->time_base
,
678 ost
->st
->codec
->time_base
) -
679 av_rescale_q(of
->start_time
,
681 ost
->st
->codec
->time_base
);
683 if (of
->start_time
&& filtered_frame
->pts
< 0) {
684 avfilter_unref_buffer(picref
);
689 switch (ost
->filter
->filter
->inputs
[0]->type
) {
690 case AVMEDIA_TYPE_VIDEO
:
691 if (!ost
->frame_aspect_ratio
)
692 ost
->st
->codec
->sample_aspect_ratio
= picref
->video
->pixel_aspect
;
694 do_video_out(of
->ctx
, ost
, filtered_frame
, &frame_size
,
695 same_quant
? ost
->last_quality
:
696 ost
->st
->codec
->global_quality
);
697 if (vstats_filename
&& frame_size
)
698 do_video_stats(of
->ctx
, ost
, frame_size
);
700 case AVMEDIA_TYPE_AUDIO
:
701 do_audio_out(of
->ctx
, ost
, filtered_frame
);
704 // TODO support subtitle filters
708 avfilter_unref_buffer(picref
);
714 * Read as many frames from possible from lavfi and encode them.
716 * Always read from the active stream with the lowest timestamp. If no frames
717 * are available for it then return EAGAIN and wait for more input. This way we
718 * can use lavfi sources that generate unlimited amount of frames without memory
721 static int poll_filters(void)
725 while (ret
>= 0 && !received_sigterm
) {
726 OutputStream
*ost
= NULL
;
727 int64_t min_pts
= INT64_MAX
;
729 /* choose output stream with the lowest timestamp */
730 for (i
= 0; i
< nb_output_streams
; i
++) {
731 int64_t pts
= output_streams
[i
]->sync_opts
;
733 if (!output_streams
[i
]->filter
|| output_streams
[i
]->finished
)
736 pts
= av_rescale_q(pts
, output_streams
[i
]->st
->codec
->time_base
,
740 ost
= output_streams
[i
];
747 ret
= poll_filter(ost
);
749 if (ret
== AVERROR_EOF
) {
750 OutputFile
*of
= output_files
[ost
->file_index
];
755 for (j
= 0; j
< of
->ctx
->nb_streams
; j
++)
756 output_streams
[of
->ost_index
+ j
]->finished
= 1;
760 } else if (ret
== AVERROR(EAGAIN
))
767 static void print_report(int is_last_report
, int64_t timer_start
)
774 int frame_number
, vid
, i
;
775 double bitrate
, ti1
, pts
;
776 static int64_t last_time
= -1;
777 static int qp_histogram
[52];
779 if (!print_stats
&& !is_last_report
)
782 if (!is_last_report
) {
784 /* display the report every 0.5 seconds */
785 cur_time
= av_gettime();
786 if (last_time
== -1) {
787 last_time
= cur_time
;
790 if ((cur_time
- last_time
) < 500000)
792 last_time
= cur_time
;
796 oc
= output_files
[0]->ctx
;
798 total_size
= avio_size(oc
->pb
);
799 if (total_size
< 0) // FIXME improve avio_size() so it works with non seekable output too
800 total_size
= avio_tell(oc
->pb
);
805 for (i
= 0; i
< nb_output_streams
; i
++) {
807 ost
= output_streams
[i
];
808 enc
= ost
->st
->codec
;
809 if (!ost
->stream_copy
&& enc
->coded_frame
)
810 q
= enc
->coded_frame
->quality
/ (float)FF_QP2LAMBDA
;
811 if (vid
&& enc
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
812 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "q=%2.1f ", q
);
814 if (!vid
&& enc
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
815 float t
= (av_gettime() - timer_start
) / 1000000.0;
817 frame_number
= ost
->frame_number
;
818 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "frame=%5d fps=%3d q=%3.1f ",
819 frame_number
, (t
> 1) ? (int)(frame_number
/ t
+ 0.5) : 0, q
);
821 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "L");
825 if (qp
>= 0 && qp
< FF_ARRAY_ELEMS(qp_histogram
))
827 for (j
= 0; j
< 32; j
++)
828 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%X", (int)lrintf(log2(qp_histogram
[j
] + 1)));
830 if (enc
->flags
&CODEC_FLAG_PSNR
) {
832 double error
, error_sum
= 0;
833 double scale
, scale_sum
= 0;
834 char type
[3] = { 'Y','U','V' };
835 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "PSNR=");
836 for (j
= 0; j
< 3; j
++) {
837 if (is_last_report
) {
838 error
= enc
->error
[j
];
839 scale
= enc
->width
* enc
->height
* 255.0 * 255.0 * frame_number
;
841 error
= enc
->coded_frame
->error
[j
];
842 scale
= enc
->width
* enc
->height
* 255.0 * 255.0;
848 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "%c:%2.2f ", type
[j
], psnr(error
/ scale
));
850 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), "*:%2.2f ", psnr(error_sum
/ scale_sum
));
854 /* compute min output value */
855 pts
= (double)ost
->st
->pts
.val
* av_q2d(ost
->st
->time_base
);
856 if ((pts
< ti1
) && (pts
> 0))
862 bitrate
= (double)(total_size
* 8) / ti1
/ 1000.0;
864 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
),
865 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
866 (double)total_size
/ 1024, ti1
, bitrate
);
868 if (nb_frames_dup
|| nb_frames_drop
)
869 snprintf(buf
+ strlen(buf
), sizeof(buf
) - strlen(buf
), " dup=%d drop=%d",
870 nb_frames_dup
, nb_frames_drop
);
872 av_log(NULL
, AV_LOG_INFO
, "%s \r", buf
);
876 if (is_last_report
) {
877 int64_t raw
= audio_size
+ video_size
+ extra_size
;
878 av_log(NULL
, AV_LOG_INFO
, "\n");
879 av_log(NULL
, AV_LOG_INFO
, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
883 100.0 * (total_size
- raw
) / raw
888 static void flush_encoders(void)
892 for (i
= 0; i
< nb_output_streams
; i
++) {
893 OutputStream
*ost
= output_streams
[i
];
894 AVCodecContext
*enc
= ost
->st
->codec
;
895 AVFormatContext
*os
= output_files
[ost
->file_index
]->ctx
;
896 int stop_encoding
= 0;
898 if (!ost
->encoding_needed
)
901 if (ost
->st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
&& enc
->frame_size
<= 1)
903 if (ost
->st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
&& (os
->oformat
->flags
& AVFMT_RAWPICTURE
) && enc
->codec
->id
== AV_CODEC_ID_RAWVIDEO
)
907 int (*encode
)(AVCodecContext
*, AVPacket
*, const AVFrame
*, int*) = NULL
;
911 switch (ost
->st
->codec
->codec_type
) {
912 case AVMEDIA_TYPE_AUDIO
:
913 encode
= avcodec_encode_audio2
;
917 case AVMEDIA_TYPE_VIDEO
:
918 encode
= avcodec_encode_video2
;
929 av_init_packet(&pkt
);
933 ret
= encode(enc
, &pkt
, NULL
, &got_packet
);
935 av_log(NULL
, AV_LOG_FATAL
, "%s encoding failed\n", desc
);
939 if (ost
->logfile
&& enc
->stats_out
) {
940 fprintf(ost
->logfile
, "%s", enc
->stats_out
);
946 if (pkt
.pts
!= AV_NOPTS_VALUE
)
947 pkt
.pts
= av_rescale_q(pkt
.pts
, enc
->time_base
, ost
->st
->time_base
);
948 if (pkt
.dts
!= AV_NOPTS_VALUE
)
949 pkt
.dts
= av_rescale_q(pkt
.dts
, enc
->time_base
, ost
->st
->time_base
);
950 write_frame(os
, &pkt
, ost
);
960 * Check whether a packet from ist should be written into ost at this time
962 static int check_output_constraints(InputStream
*ist
, OutputStream
*ost
)
964 OutputFile
*of
= output_files
[ost
->file_index
];
965 int ist_index
= input_files
[ist
->file_index
]->ist_index
+ ist
->st
->index
;
967 if (ost
->source_index
!= ist_index
)
970 if (of
->start_time
&& ist
->last_dts
< of
->start_time
)
976 static void do_streamcopy(InputStream
*ist
, OutputStream
*ost
, const AVPacket
*pkt
)
978 OutputFile
*of
= output_files
[ost
->file_index
];
979 int64_t ost_tb_start_time
= av_rescale_q(of
->start_time
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
982 av_init_packet(&opkt
);
984 if ((!ost
->frame_number
&& !(pkt
->flags
& AV_PKT_FLAG_KEY
)) &&
985 !ost
->copy_initial_nonkeyframes
)
988 if (of
->recording_time
!= INT64_MAX
&&
989 ist
->last_dts
>= of
->recording_time
+ of
->start_time
) {
994 /* force the input stream PTS */
995 if (ost
->st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
)
996 audio_size
+= pkt
->size
;
997 else if (ost
->st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
998 video_size
+= pkt
->size
;
1002 if (pkt
->pts
!= AV_NOPTS_VALUE
)
1003 opkt
.pts
= av_rescale_q(pkt
->pts
, ist
->st
->time_base
, ost
->st
->time_base
) - ost_tb_start_time
;
1005 opkt
.pts
= AV_NOPTS_VALUE
;
1007 if (pkt
->dts
== AV_NOPTS_VALUE
)
1008 opkt
.dts
= av_rescale_q(ist
->last_dts
, AV_TIME_BASE_Q
, ost
->st
->time_base
);
1010 opkt
.dts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, ost
->st
->time_base
);
1011 opkt
.dts
-= ost_tb_start_time
;
1013 opkt
.duration
= av_rescale_q(pkt
->duration
, ist
->st
->time_base
, ost
->st
->time_base
);
1014 opkt
.flags
= pkt
->flags
;
1016 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1017 if ( ost
->st
->codec
->codec_id
!= AV_CODEC_ID_H264
1018 && ost
->st
->codec
->codec_id
!= AV_CODEC_ID_MPEG1VIDEO
1019 && ost
->st
->codec
->codec_id
!= AV_CODEC_ID_MPEG2VIDEO
1020 && ost
->st
->codec
->codec_id
!= AV_CODEC_ID_VC1
1022 if (av_parser_change(ist
->st
->parser
, ost
->st
->codec
, &opkt
.data
, &opkt
.size
, pkt
->data
, pkt
->size
, pkt
->flags
& AV_PKT_FLAG_KEY
))
1023 opkt
.destruct
= av_destruct_packet
;
1025 opkt
.data
= pkt
->data
;
1026 opkt
.size
= pkt
->size
;
1029 write_frame(of
->ctx
, &opkt
, ost
);
1030 ost
->st
->codec
->frame_number
++;
1031 av_free_packet(&opkt
);
1034 static void rate_emu_sleep(InputStream
*ist
)
1036 if (input_files
[ist
->file_index
]->rate_emu
) {
1037 int64_t pts
= av_rescale(ist
->last_dts
, 1000000, AV_TIME_BASE
);
1038 int64_t now
= av_gettime() - ist
->start
;
1040 av_usleep(pts
- now
);
1044 int guess_input_channel_layout(InputStream
*ist
)
1046 AVCodecContext
*dec
= ist
->st
->codec
;
1048 if (!dec
->channel_layout
) {
1049 char layout_name
[256];
1051 dec
->channel_layout
= av_get_default_channel_layout(dec
->channels
);
1052 if (!dec
->channel_layout
)
1054 av_get_channel_layout_string(layout_name
, sizeof(layout_name
),
1055 dec
->channels
, dec
->channel_layout
);
1056 av_log(NULL
, AV_LOG_WARNING
, "Guessed Channel Layout for Input Stream "
1057 "#%d.%d : %s\n", ist
->file_index
, ist
->st
->index
, layout_name
);
1062 static int decode_audio(InputStream
*ist
, AVPacket
*pkt
, int *got_output
)
1064 AVFrame
*decoded_frame
;
1065 AVCodecContext
*avctx
= ist
->st
->codec
;
1066 int bps
= av_get_bytes_per_sample(ist
->st
->codec
->sample_fmt
);
1067 int i
, ret
, resample_changed
;
1069 if (!ist
->decoded_frame
&& !(ist
->decoded_frame
= avcodec_alloc_frame()))
1070 return AVERROR(ENOMEM
);
1072 avcodec_get_frame_defaults(ist
->decoded_frame
);
1073 decoded_frame
= ist
->decoded_frame
;
1075 ret
= avcodec_decode_audio4(avctx
, decoded_frame
, got_output
, pkt
);
1076 if (!*got_output
|| ret
< 0) {
1078 for (i
= 0; i
< ist
->nb_filters
; i
++)
1079 av_buffersrc_buffer(ist
->filters
[i
]->filter
, NULL
);
1084 /* if the decoder provides a pts, use it instead of the last packet pts.
1085 the decoder could be delaying output by a packet or more. */
1086 if (decoded_frame
->pts
!= AV_NOPTS_VALUE
)
1087 ist
->next_dts
= decoded_frame
->pts
;
1088 else if (pkt
->pts
!= AV_NOPTS_VALUE
) {
1089 decoded_frame
->pts
= pkt
->pts
;
1090 pkt
->pts
= AV_NOPTS_VALUE
;
1093 // preprocess audio (volume)
1094 if (audio_volume
!= 256) {
1095 int decoded_data_size
= decoded_frame
->nb_samples
* avctx
->channels
* bps
;
1096 void *samples
= decoded_frame
->data
[0];
1097 switch (avctx
->sample_fmt
) {
1098 case AV_SAMPLE_FMT_U8
:
1100 uint8_t *volp
= samples
;
1101 for (i
= 0; i
< (decoded_data_size
/ sizeof(*volp
)); i
++) {
1102 int v
= (((*volp
- 128) * audio_volume
+ 128) >> 8) + 128;
1103 *volp
++ = av_clip_uint8(v
);
1107 case AV_SAMPLE_FMT_S16
:
1109 int16_t *volp
= samples
;
1110 for (i
= 0; i
< (decoded_data_size
/ sizeof(*volp
)); i
++) {
1111 int v
= ((*volp
) * audio_volume
+ 128) >> 8;
1112 *volp
++ = av_clip_int16(v
);
1116 case AV_SAMPLE_FMT_S32
:
1118 int32_t *volp
= samples
;
1119 for (i
= 0; i
< (decoded_data_size
/ sizeof(*volp
)); i
++) {
1120 int64_t v
= (((int64_t)*volp
* audio_volume
+ 128) >> 8);
1121 *volp
++ = av_clipl_int32(v
);
1125 case AV_SAMPLE_FMT_FLT
:
1127 float *volp
= samples
;
1128 float scale
= audio_volume
/ 256.f
;
1129 for (i
= 0; i
< (decoded_data_size
/ sizeof(*volp
)); i
++) {
1134 case AV_SAMPLE_FMT_DBL
:
1136 double *volp
= samples
;
1137 double scale
= audio_volume
/ 256.;
1138 for (i
= 0; i
< (decoded_data_size
/ sizeof(*volp
)); i
++) {
1144 av_log(NULL
, AV_LOG_FATAL
,
1145 "Audio volume adjustment on sample format %s is not supported.\n",
1146 av_get_sample_fmt_name(ist
->st
->codec
->sample_fmt
));
1151 rate_emu_sleep(ist
);
1153 resample_changed
= ist
->resample_sample_fmt
!= decoded_frame
->format
||
1154 ist
->resample_channels
!= avctx
->channels
||
1155 ist
->resample_channel_layout
!= decoded_frame
->channel_layout
||
1156 ist
->resample_sample_rate
!= decoded_frame
->sample_rate
;
1157 if (resample_changed
) {
1158 char layout1
[64], layout2
[64];
1160 if (!guess_input_channel_layout(ist
)) {
1161 av_log(NULL
, AV_LOG_FATAL
, "Unable to find default channel "
1162 "layout for Input Stream #%d.%d\n", ist
->file_index
,
1166 decoded_frame
->channel_layout
= avctx
->channel_layout
;
1168 av_get_channel_layout_string(layout1
, sizeof(layout1
), ist
->resample_channels
,
1169 ist
->resample_channel_layout
);
1170 av_get_channel_layout_string(layout2
, sizeof(layout2
), avctx
->channels
,
1171 decoded_frame
->channel_layout
);
1173 av_log(NULL
, AV_LOG_INFO
,
1174 "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n",
1175 ist
->file_index
, ist
->st
->index
,
1176 ist
->resample_sample_rate
, av_get_sample_fmt_name(ist
->resample_sample_fmt
),
1177 ist
->resample_channels
, layout1
,
1178 decoded_frame
->sample_rate
, av_get_sample_fmt_name(decoded_frame
->format
),
1179 avctx
->channels
, layout2
);
1181 ist
->resample_sample_fmt
= decoded_frame
->format
;
1182 ist
->resample_sample_rate
= decoded_frame
->sample_rate
;
1183 ist
->resample_channel_layout
= decoded_frame
->channel_layout
;
1184 ist
->resample_channels
= avctx
->channels
;
1186 for (i
= 0; i
< nb_filtergraphs
; i
++)
1187 if (ist_in_filtergraph(filtergraphs
[i
], ist
) &&
1188 configure_filtergraph(filtergraphs
[i
]) < 0) {
1189 av_log(NULL
, AV_LOG_FATAL
, "Error reinitializing filters!\n");
1194 if (decoded_frame
->pts
!= AV_NOPTS_VALUE
)
1195 decoded_frame
->pts
= av_rescale_q(decoded_frame
->pts
,
1197 (AVRational
){1, ist
->st
->codec
->sample_rate
});
1198 for (i
= 0; i
< ist
->nb_filters
; i
++)
1199 av_buffersrc_write_frame(ist
->filters
[i
]->filter
, decoded_frame
);
1204 static int decode_video(InputStream
*ist
, AVPacket
*pkt
, int *got_output
)
1206 AVFrame
*decoded_frame
;
1207 void *buffer_to_free
= NULL
;
1208 int i
, ret
= 0, resample_changed
;
1211 if (!ist
->decoded_frame
&& !(ist
->decoded_frame
= avcodec_alloc_frame()))
1212 return AVERROR(ENOMEM
);
1214 avcodec_get_frame_defaults(ist
->decoded_frame
);
1215 decoded_frame
= ist
->decoded_frame
;
1217 ret
= avcodec_decode_video2(ist
->st
->codec
,
1218 decoded_frame
, got_output
, pkt
);
1219 if (!*got_output
|| ret
< 0) {
1221 for (i
= 0; i
< ist
->nb_filters
; i
++)
1222 av_buffersrc_buffer(ist
->filters
[i
]->filter
, NULL
);
1227 quality
= same_quant
? decoded_frame
->quality
: 0;
1228 decoded_frame
->pts
= guess_correct_pts(&ist
->pts_ctx
, decoded_frame
->pkt_pts
,
1229 decoded_frame
->pkt_dts
);
1231 pre_process_video_frame(ist
, (AVPicture
*)decoded_frame
, &buffer_to_free
);
1233 rate_emu_sleep(ist
);
1235 if (ist
->st
->sample_aspect_ratio
.num
)
1236 decoded_frame
->sample_aspect_ratio
= ist
->st
->sample_aspect_ratio
;
1238 resample_changed
= ist
->resample_width
!= decoded_frame
->width
||
1239 ist
->resample_height
!= decoded_frame
->height
||
1240 ist
->resample_pix_fmt
!= decoded_frame
->format
;
1241 if (resample_changed
) {
1242 av_log(NULL
, AV_LOG_INFO
,
1243 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1244 ist
->file_index
, ist
->st
->index
,
1245 ist
->resample_width
, ist
->resample_height
, av_get_pix_fmt_name(ist
->resample_pix_fmt
),
1246 decoded_frame
->width
, decoded_frame
->height
, av_get_pix_fmt_name(decoded_frame
->format
));
1248 ret
= poll_filters();
1249 if (ret
< 0 && (ret
!= AVERROR_EOF
&& ret
!= AVERROR(EAGAIN
)))
1250 av_log(NULL
, AV_LOG_ERROR
, "Error while filtering.\n");
1252 ist
->resample_width
= decoded_frame
->width
;
1253 ist
->resample_height
= decoded_frame
->height
;
1254 ist
->resample_pix_fmt
= decoded_frame
->format
;
1256 for (i
= 0; i
< nb_filtergraphs
; i
++)
1257 if (ist_in_filtergraph(filtergraphs
[i
], ist
) &&
1258 configure_filtergraph(filtergraphs
[i
]) < 0) {
1259 av_log(NULL
, AV_LOG_FATAL
, "Error reinitializing filters!\n");
1264 for (i
= 0; i
< ist
->nb_filters
; i
++) {
1265 // XXX what an ugly hack
1266 if (ist
->filters
[i
]->graph
->nb_outputs
== 1)
1267 ist
->filters
[i
]->graph
->outputs
[0]->ost
->last_quality
= quality
;
1269 if (ist
->st
->codec
->codec
->capabilities
& CODEC_CAP_DR1
) {
1270 FrameBuffer
*buf
= decoded_frame
->opaque
;
1271 AVFilterBufferRef
*fb
= avfilter_get_video_buffer_ref_from_arrays(
1272 decoded_frame
->data
, decoded_frame
->linesize
,
1273 AV_PERM_READ
| AV_PERM_PRESERVE
,
1274 ist
->st
->codec
->width
, ist
->st
->codec
->height
,
1275 ist
->st
->codec
->pix_fmt
);
1277 avfilter_copy_frame_props(fb
, decoded_frame
);
1278 fb
->buf
->priv
= buf
;
1279 fb
->buf
->free
= filter_release_buffer
;
1282 av_buffersrc_buffer(ist
->filters
[i
]->filter
, fb
);
1284 av_buffersrc_write_frame(ist
->filters
[i
]->filter
, decoded_frame
);
1287 av_free(buffer_to_free
);
1291 static int transcode_subtitles(InputStream
*ist
, AVPacket
*pkt
, int *got_output
)
1293 AVSubtitle subtitle
;
1294 int i
, ret
= avcodec_decode_subtitle2(ist
->st
->codec
,
1295 &subtitle
, got_output
, pkt
);
1301 rate_emu_sleep(ist
);
1303 for (i
= 0; i
< nb_output_streams
; i
++) {
1304 OutputStream
*ost
= output_streams
[i
];
1306 if (!check_output_constraints(ist
, ost
) || !ost
->encoding_needed
)
1309 do_subtitle_out(output_files
[ost
->file_index
]->ctx
, ost
, ist
, &subtitle
, pkt
->pts
);
1312 avsubtitle_free(&subtitle
);
1316 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1317 static int output_packet(InputStream
*ist
, const AVPacket
*pkt
)
1323 if (ist
->next_dts
== AV_NOPTS_VALUE
)
1324 ist
->next_dts
= ist
->last_dts
;
1328 av_init_packet(&avpkt
);
1336 if (pkt
->dts
!= AV_NOPTS_VALUE
)
1337 ist
->next_dts
= ist
->last_dts
= av_rescale_q(pkt
->dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1339 // while we have more to decode or while the decoder did output something on EOF
1340 while (ist
->decoding_needed
&& (avpkt
.size
> 0 || (!pkt
&& got_output
))) {
1344 ist
->last_dts
= ist
->next_dts
;
1346 if (avpkt
.size
&& avpkt
.size
!= pkt
->size
) {
1347 av_log(NULL
, ist
->showed_multi_packet_warning
? AV_LOG_VERBOSE
: AV_LOG_WARNING
,
1348 "Multiple frames in a packet from stream %d\n", pkt
->stream_index
);
1349 ist
->showed_multi_packet_warning
= 1;
1352 switch (ist
->st
->codec
->codec_type
) {
1353 case AVMEDIA_TYPE_AUDIO
:
1354 ret
= decode_audio (ist
, &avpkt
, &got_output
);
1356 case AVMEDIA_TYPE_VIDEO
:
1357 ret
= decode_video (ist
, &avpkt
, &got_output
);
1359 ist
->next_dts
+= av_rescale_q(avpkt
.duration
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
1360 else if (ist
->st
->avg_frame_rate
.num
)
1361 ist
->next_dts
+= av_rescale_q(1, av_inv_q(ist
->st
->avg_frame_rate
),
1363 else if (ist
->st
->codec
->time_base
.num
!= 0) {
1364 int ticks
= ist
->st
->parser
? ist
->st
->parser
->repeat_pict
+ 1 :
1365 ist
->st
->codec
->ticks_per_frame
;
1366 ist
->next_dts
+= av_rescale_q(ticks
, ist
->st
->codec
->time_base
, AV_TIME_BASE_Q
);
1369 case AVMEDIA_TYPE_SUBTITLE
:
1370 ret
= transcode_subtitles(ist
, &avpkt
, &got_output
);
1378 // touch data and size only if not EOF
1388 /* handle stream copy */
1389 if (!ist
->decoding_needed
) {
1390 rate_emu_sleep(ist
);
1391 ist
->last_dts
= ist
->next_dts
;
1392 switch (ist
->st
->codec
->codec_type
) {
1393 case AVMEDIA_TYPE_AUDIO
:
1394 ist
->next_dts
+= ((int64_t)AV_TIME_BASE
* ist
->st
->codec
->frame_size
) /
1395 ist
->st
->codec
->sample_rate
;
1397 case AVMEDIA_TYPE_VIDEO
:
1398 if (ist
->st
->codec
->time_base
.num
!= 0) {
1399 int ticks
= ist
->st
->parser
? ist
->st
->parser
->repeat_pict
+ 1 : ist
->st
->codec
->ticks_per_frame
;
1400 ist
->next_dts
+= ((int64_t)AV_TIME_BASE
*
1401 ist
->st
->codec
->time_base
.num
* ticks
) /
1402 ist
->st
->codec
->time_base
.den
;
1407 for (i
= 0; pkt
&& i
< nb_output_streams
; i
++) {
1408 OutputStream
*ost
= output_streams
[i
];
1410 if (!check_output_constraints(ist
, ost
) || ost
->encoding_needed
)
1413 do_streamcopy(ist
, ost
, pkt
);
1419 static void print_sdp(void)
1423 AVFormatContext
**avc
= av_malloc(sizeof(*avc
) * nb_output_files
);
1427 for (i
= 0; i
< nb_output_files
; i
++)
1428 avc
[i
] = output_files
[i
]->ctx
;
1430 av_sdp_create(avc
, nb_output_files
, sdp
, sizeof(sdp
));
1431 printf("SDP:\n%s\n", sdp
);
1436 static int init_input_stream(int ist_index
, char *error
, int error_len
)
1439 InputStream
*ist
= input_streams
[ist_index
];
1440 if (ist
->decoding_needed
) {
1441 AVCodec
*codec
= ist
->dec
;
1443 snprintf(error
, error_len
, "Decoder (codec id %d) not found for input stream #%d:%d",
1444 ist
->st
->codec
->codec_id
, ist
->file_index
, ist
->st
->index
);
1445 return AVERROR(EINVAL
);
1448 /* update requested sample format for the decoder based on the
1449 corresponding encoder sample format */
1450 for (i
= 0; i
< nb_output_streams
; i
++) {
1451 OutputStream
*ost
= output_streams
[i
];
1452 if (ost
->source_index
== ist_index
) {
1453 update_sample_fmt(ist
->st
->codec
, codec
, ost
->st
->codec
);
1458 if (codec
->type
== AVMEDIA_TYPE_VIDEO
&& codec
->capabilities
& CODEC_CAP_DR1
) {
1459 ist
->st
->codec
->get_buffer
= codec_get_buffer
;
1460 ist
->st
->codec
->release_buffer
= codec_release_buffer
;
1461 ist
->st
->codec
->opaque
= &ist
->buffer_pool
;
1464 if (!av_dict_get(ist
->opts
, "threads", NULL
, 0))
1465 av_dict_set(&ist
->opts
, "threads", "auto", 0);
1466 if (avcodec_open2(ist
->st
->codec
, codec
, &ist
->opts
) < 0) {
1467 snprintf(error
, error_len
, "Error while opening decoder for input stream #%d:%d",
1468 ist
->file_index
, ist
->st
->index
);
1469 return AVERROR(EINVAL
);
1471 assert_codec_experimental(ist
->st
->codec
, 0);
1472 assert_avoptions(ist
->opts
);
1475 ist
->last_dts
= ist
->st
->avg_frame_rate
.num
? - ist
->st
->codec
->has_b_frames
* AV_TIME_BASE
/ av_q2d(ist
->st
->avg_frame_rate
) : 0;
1476 ist
->next_dts
= AV_NOPTS_VALUE
;
1477 init_pts_correction(&ist
->pts_ctx
);
1483 static InputStream
*get_input_stream(OutputStream
*ost
)
1485 if (ost
->source_index
>= 0)
1486 return input_streams
[ost
->source_index
];
1489 FilterGraph
*fg
= ost
->filter
->graph
;
1492 for (i
= 0; i
< fg
->nb_inputs
; i
++)
1493 if (fg
->inputs
[i
]->ist
->st
->codec
->codec_type
== ost
->st
->codec
->codec_type
)
1494 return fg
->inputs
[i
]->ist
;
1500 static void parse_forced_key_frames(char *kf
, OutputStream
*ost
,
1501 AVCodecContext
*avctx
)
1507 for (p
= kf
; *p
; p
++)
1510 ost
->forced_kf_count
= n
;
1511 ost
->forced_kf_pts
= av_malloc(sizeof(*ost
->forced_kf_pts
) * n
);
1512 if (!ost
->forced_kf_pts
) {
1513 av_log(NULL
, AV_LOG_FATAL
, "Could not allocate forced key frames array.\n");
1518 for (i
= 0; i
< n
; i
++) {
1519 char *next
= strchr(p
, ',');
1524 t
= parse_time_or_die("force_key_frames", p
, 1);
1525 ost
->forced_kf_pts
[i
] = av_rescale_q(t
, AV_TIME_BASE_Q
, avctx
->time_base
);
1531 static int transcode_init(void)
1533 int ret
= 0, i
, j
, k
;
1534 AVFormatContext
*oc
;
1535 AVCodecContext
*codec
;
1541 /* init framerate emulation */
1542 for (i
= 0; i
< nb_input_files
; i
++) {
1543 InputFile
*ifile
= input_files
[i
];
1544 if (ifile
->rate_emu
)
1545 for (j
= 0; j
< ifile
->nb_streams
; j
++)
1546 input_streams
[j
+ ifile
->ist_index
]->start
= av_gettime();
1549 /* output stream init */
1550 for (i
= 0; i
< nb_output_files
; i
++) {
1551 oc
= output_files
[i
]->ctx
;
1552 if (!oc
->nb_streams
&& !(oc
->oformat
->flags
& AVFMT_NOSTREAMS
)) {
1553 av_dump_format(oc
, i
, oc
->filename
, 1);
1554 av_log(NULL
, AV_LOG_ERROR
, "Output file #%d does not contain any stream\n", i
);
1555 return AVERROR(EINVAL
);
1559 /* init complex filtergraphs */
1560 for (i
= 0; i
< nb_filtergraphs
; i
++)
1561 if ((ret
= avfilter_graph_config(filtergraphs
[i
]->graph
, NULL
)) < 0)
1564 /* for each output stream, we compute the right encoding parameters */
1565 for (i
= 0; i
< nb_output_streams
; i
++) {
1566 AVCodecContext
*icodec
= NULL
;
1567 ost
= output_streams
[i
];
1568 oc
= output_files
[ost
->file_index
]->ctx
;
1569 ist
= get_input_stream(ost
);
1571 if (ost
->attachment_filename
)
1574 codec
= ost
->st
->codec
;
1577 icodec
= ist
->st
->codec
;
1579 ost
->st
->disposition
= ist
->st
->disposition
;
1580 codec
->bits_per_raw_sample
= icodec
->bits_per_raw_sample
;
1581 codec
->chroma_sample_location
= icodec
->chroma_sample_location
;
1584 if (ost
->stream_copy
) {
1585 uint64_t extra_size
;
1587 av_assert0(ist
&& !ost
->filter
);
1589 extra_size
= (uint64_t)icodec
->extradata_size
+ FF_INPUT_BUFFER_PADDING_SIZE
;
1591 if (extra_size
> INT_MAX
) {
1592 return AVERROR(EINVAL
);
1595 /* if stream_copy is selected, no need to decode or encode */
1596 codec
->codec_id
= icodec
->codec_id
;
1597 codec
->codec_type
= icodec
->codec_type
;
1599 if (!codec
->codec_tag
) {
1600 if (!oc
->oformat
->codec_tag
||
1601 av_codec_get_id (oc
->oformat
->codec_tag
, icodec
->codec_tag
) == codec
->codec_id
||
1602 av_codec_get_tag(oc
->oformat
->codec_tag
, icodec
->codec_id
) <= 0)
1603 codec
->codec_tag
= icodec
->codec_tag
;
1606 codec
->bit_rate
= icodec
->bit_rate
;
1607 codec
->rc_max_rate
= icodec
->rc_max_rate
;
1608 codec
->rc_buffer_size
= icodec
->rc_buffer_size
;
1609 codec
->field_order
= icodec
->field_order
;
1610 codec
->extradata
= av_mallocz(extra_size
);
1611 if (!codec
->extradata
) {
1612 return AVERROR(ENOMEM
);
1614 memcpy(codec
->extradata
, icodec
->extradata
, icodec
->extradata_size
);
1615 codec
->extradata_size
= icodec
->extradata_size
;
1617 codec
->time_base
= icodec
->time_base
;
1618 codec
->time_base
.num
*= icodec
->ticks_per_frame
;
1619 av_reduce(&codec
->time_base
.num
, &codec
->time_base
.den
,
1620 codec
->time_base
.num
, codec
->time_base
.den
, INT_MAX
);
1622 codec
->time_base
= ist
->st
->time_base
;
1624 switch (codec
->codec_type
) {
1625 case AVMEDIA_TYPE_AUDIO
:
1626 if (audio_volume
!= 256) {
1627 av_log(NULL
, AV_LOG_FATAL
, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
1630 codec
->channel_layout
= icodec
->channel_layout
;
1631 codec
->sample_rate
= icodec
->sample_rate
;
1632 codec
->channels
= icodec
->channels
;
1633 codec
->frame_size
= icodec
->frame_size
;
1634 codec
->audio_service_type
= icodec
->audio_service_type
;
1635 codec
->block_align
= icodec
->block_align
;
1637 case AVMEDIA_TYPE_VIDEO
:
1638 codec
->pix_fmt
= icodec
->pix_fmt
;
1639 codec
->width
= icodec
->width
;
1640 codec
->height
= icodec
->height
;
1641 codec
->has_b_frames
= icodec
->has_b_frames
;
1642 if (!codec
->sample_aspect_ratio
.num
) {
1643 codec
->sample_aspect_ratio
=
1644 ost
->st
->sample_aspect_ratio
=
1645 ist
->st
->sample_aspect_ratio
.num
? ist
->st
->sample_aspect_ratio
:
1646 ist
->st
->codec
->sample_aspect_ratio
.num
?
1647 ist
->st
->codec
->sample_aspect_ratio
: (AVRational
){0, 1};
1650 case AVMEDIA_TYPE_SUBTITLE
:
1651 codec
->width
= icodec
->width
;
1652 codec
->height
= icodec
->height
;
1654 case AVMEDIA_TYPE_DATA
:
1655 case AVMEDIA_TYPE_ATTACHMENT
:
1662 /* should only happen when a default codec is not present. */
1663 snprintf(error
, sizeof(error
), "Automatic encoder selection "
1664 "failed for output stream #%d:%d. Default encoder for "
1665 "format %s is probably disabled. Please choose an "
1666 "encoder manually.\n", ost
->file_index
, ost
->index
,
1668 ret
= AVERROR(EINVAL
);
1673 ist
->decoding_needed
= 1;
1674 ost
->encoding_needed
= 1;
1677 * We want CFR output if and only if one of those is true:
1678 * 1) user specified output framerate with -r
1679 * 2) user specified -vsync cfr
1680 * 3) output format is CFR and the user didn't force vsync to
1681 * something else than CFR
1683 * in such a case, set ost->frame_rate
1685 if (codec
->codec_type
== AVMEDIA_TYPE_VIDEO
&&
1686 !ost
->frame_rate
.num
&& ist
&&
1687 (video_sync_method
== VSYNC_CFR
||
1688 (video_sync_method
== VSYNC_AUTO
&&
1689 !(oc
->oformat
->flags
& (AVFMT_NOTIMESTAMPS
| AVFMT_VARIABLE_FPS
))))) {
1690 ost
->frame_rate
= ist
->framerate
.num
? ist
->framerate
:
1691 ist
->st
->avg_frame_rate
.num
?
1692 ist
->st
->avg_frame_rate
:
1693 (AVRational
){25, 1};
1695 if (ost
->enc
&& ost
->enc
->supported_framerates
&& !ost
->force_fps
) {
1696 int idx
= av_find_nearest_q_idx(ost
->frame_rate
, ost
->enc
->supported_framerates
);
1697 ost
->frame_rate
= ost
->enc
->supported_framerates
[idx
];
1702 (codec
->codec_type
== AVMEDIA_TYPE_VIDEO
||
1703 codec
->codec_type
== AVMEDIA_TYPE_AUDIO
)) {
1705 fg
= init_simple_filtergraph(ist
, ost
);
1706 if (configure_filtergraph(fg
)) {
1707 av_log(NULL
, AV_LOG_FATAL
, "Error opening filters!\n");
1712 switch (codec
->codec_type
) {
1713 case AVMEDIA_TYPE_AUDIO
:
1714 codec
->sample_fmt
= ost
->filter
->filter
->inputs
[0]->format
;
1715 codec
->sample_rate
= ost
->filter
->filter
->inputs
[0]->sample_rate
;
1716 codec
->channel_layout
= ost
->filter
->filter
->inputs
[0]->channel_layout
;
1717 codec
->channels
= av_get_channel_layout_nb_channels(codec
->channel_layout
);
1718 codec
->time_base
= (AVRational
){ 1, codec
->sample_rate
};
1720 case AVMEDIA_TYPE_VIDEO
:
1721 codec
->time_base
= ost
->filter
->filter
->inputs
[0]->time_base
;
1723 codec
->width
= ost
->filter
->filter
->inputs
[0]->w
;
1724 codec
->height
= ost
->filter
->filter
->inputs
[0]->h
;
1725 codec
->sample_aspect_ratio
= ost
->st
->sample_aspect_ratio
=
1726 ost
->frame_aspect_ratio
? // overridden by the -aspect cli option
1727 av_d2q(ost
->frame_aspect_ratio
* codec
->height
/codec
->width
, 255) :
1728 ost
->filter
->filter
->inputs
[0]->sample_aspect_ratio
;
1729 codec
->pix_fmt
= ost
->filter
->filter
->inputs
[0]->format
;
1732 (codec
->width
!= icodec
->width
||
1733 codec
->height
!= icodec
->height
||
1734 codec
->pix_fmt
!= icodec
->pix_fmt
)) {
1735 codec
->bits_per_raw_sample
= 0;
1738 if (ost
->forced_keyframes
)
1739 parse_forced_key_frames(ost
->forced_keyframes
, ost
,
1742 case AVMEDIA_TYPE_SUBTITLE
:
1743 codec
->time_base
= (AVRational
){1, 1000};
1750 if ((codec
->flags
& (CODEC_FLAG_PASS1
| CODEC_FLAG_PASS2
))) {
1751 char logfilename
[1024];
1754 snprintf(logfilename
, sizeof(logfilename
), "%s-%d.log",
1755 ost
->logfile_prefix
? ost
->logfile_prefix
:
1756 DEFAULT_PASS_LOGFILENAME_PREFIX
,
1758 if (!strcmp(ost
->enc
->name
, "libx264")) {
1759 av_dict_set(&ost
->opts
, "stats", logfilename
, AV_DICT_DONT_OVERWRITE
);
1761 if (codec
->flags
& CODEC_FLAG_PASS1
) {
1762 f
= fopen(logfilename
, "wb");
1764 av_log(NULL
, AV_LOG_FATAL
, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1765 logfilename
, strerror(errno
));
1771 size_t logbuffer_size
;
1772 if (cmdutils_read_file(logfilename
, &logbuffer
, &logbuffer_size
) < 0) {
1773 av_log(NULL
, AV_LOG_FATAL
, "Error reading log file '%s' for pass-2 encoding\n",
1777 codec
->stats_in
= logbuffer
;
1784 /* open each encoder */
1785 for (i
= 0; i
< nb_output_streams
; i
++) {
1786 ost
= output_streams
[i
];
1787 if (ost
->encoding_needed
) {
1788 AVCodec
*codec
= ost
->enc
;
1789 AVCodecContext
*dec
= NULL
;
1791 if ((ist
= get_input_stream(ost
)))
1792 dec
= ist
->st
->codec
;
1793 if (dec
&& dec
->subtitle_header
) {
1794 ost
->st
->codec
->subtitle_header
= av_malloc(dec
->subtitle_header_size
);
1795 if (!ost
->st
->codec
->subtitle_header
) {
1796 ret
= AVERROR(ENOMEM
);
1799 memcpy(ost
->st
->codec
->subtitle_header
, dec
->subtitle_header
, dec
->subtitle_header_size
);
1800 ost
->st
->codec
->subtitle_header_size
= dec
->subtitle_header_size
;
1802 if (!av_dict_get(ost
->opts
, "threads", NULL
, 0))
1803 av_dict_set(&ost
->opts
, "threads", "auto", 0);
1804 if (avcodec_open2(ost
->st
->codec
, codec
, &ost
->opts
) < 0) {
1805 snprintf(error
, sizeof(error
), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1806 ost
->file_index
, ost
->index
);
1807 ret
= AVERROR(EINVAL
);
1810 assert_codec_experimental(ost
->st
->codec
, 1);
1811 assert_avoptions(ost
->opts
);
1812 if (ost
->st
->codec
->bit_rate
&& ost
->st
->codec
->bit_rate
< 1000)
1813 av_log(NULL
, AV_LOG_WARNING
, "The bitrate parameter is set too low."
1814 "It takes bits/s as argument, not kbits/s\n");
1815 extra_size
+= ost
->st
->codec
->extradata_size
;
1817 if (ost
->st
->codec
->me_threshold
)
1818 input_streams
[ost
->source_index
]->st
->codec
->debug
|= FF_DEBUG_MV
;
1822 /* init input streams */
1823 for (i
= 0; i
< nb_input_streams
; i
++)
1824 if ((ret
= init_input_stream(i
, error
, sizeof(error
))) < 0)
1827 /* discard unused programs */
1828 for (i
= 0; i
< nb_input_files
; i
++) {
1829 InputFile
*ifile
= input_files
[i
];
1830 for (j
= 0; j
< ifile
->ctx
->nb_programs
; j
++) {
1831 AVProgram
*p
= ifile
->ctx
->programs
[j
];
1832 int discard
= AVDISCARD_ALL
;
1834 for (k
= 0; k
< p
->nb_stream_indexes
; k
++)
1835 if (!input_streams
[ifile
->ist_index
+ p
->stream_index
[k
]]->discard
) {
1836 discard
= AVDISCARD_DEFAULT
;
1839 p
->discard
= discard
;
1843 /* open files and write file headers */
1844 for (i
= 0; i
< nb_output_files
; i
++) {
1845 oc
= output_files
[i
]->ctx
;
1846 oc
->interrupt_callback
= int_cb
;
1847 if ((ret
= avformat_write_header(oc
, &output_files
[i
]->opts
)) < 0) {
1849 const char *errbuf_ptr
= errbuf
;
1850 if (av_strerror(ret
, errbuf
, sizeof(errbuf
)) < 0)
1851 errbuf_ptr
= strerror(AVUNERROR(ret
));
1852 snprintf(error
, sizeof(error
), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i
, errbuf_ptr
);
1853 ret
= AVERROR(EINVAL
);
1856 assert_avoptions(output_files
[i
]->opts
);
1857 if (strcmp(oc
->oformat
->name
, "rtp")) {
1863 /* dump the file output parameters - cannot be done before in case
1865 for (i
= 0; i
< nb_output_files
; i
++) {
1866 av_dump_format(output_files
[i
]->ctx
, i
, output_files
[i
]->ctx
->filename
, 1);
1869 /* dump the stream mapping */
1870 av_log(NULL
, AV_LOG_INFO
, "Stream mapping:\n");
1871 for (i
= 0; i
< nb_input_streams
; i
++) {
1872 ist
= input_streams
[i
];
1874 for (j
= 0; j
< ist
->nb_filters
; j
++) {
1875 if (ist
->filters
[j
]->graph
->graph_desc
) {
1876 av_log(NULL
, AV_LOG_INFO
, " Stream #%d:%d (%s) -> %s",
1877 ist
->file_index
, ist
->st
->index
, ist
->dec
? ist
->dec
->name
: "?",
1878 ist
->filters
[j
]->name
);
1879 if (nb_filtergraphs
> 1)
1880 av_log(NULL
, AV_LOG_INFO
, " (graph %d)", ist
->filters
[j
]->graph
->index
);
1881 av_log(NULL
, AV_LOG_INFO
, "\n");
1886 for (i
= 0; i
< nb_output_streams
; i
++) {
1887 ost
= output_streams
[i
];
1889 if (ost
->attachment_filename
) {
1890 /* an attached file */
1891 av_log(NULL
, AV_LOG_INFO
, " File %s -> Stream #%d:%d\n",
1892 ost
->attachment_filename
, ost
->file_index
, ost
->index
);
1896 if (ost
->filter
&& ost
->filter
->graph
->graph_desc
) {
1897 /* output from a complex graph */
1898 av_log(NULL
, AV_LOG_INFO
, " %s", ost
->filter
->name
);
1899 if (nb_filtergraphs
> 1)
1900 av_log(NULL
, AV_LOG_INFO
, " (graph %d)", ost
->filter
->graph
->index
);
1902 av_log(NULL
, AV_LOG_INFO
, " -> Stream #%d:%d (%s)\n", ost
->file_index
,
1903 ost
->index
, ost
->enc
? ost
->enc
->name
: "?");
1907 av_log(NULL
, AV_LOG_INFO
, " Stream #%d:%d -> #%d:%d",
1908 input_streams
[ost
->source_index
]->file_index
,
1909 input_streams
[ost
->source_index
]->st
->index
,
1912 if (ost
->sync_ist
!= input_streams
[ost
->source_index
])
1913 av_log(NULL
, AV_LOG_INFO
, " [sync #%d:%d]",
1914 ost
->sync_ist
->file_index
,
1915 ost
->sync_ist
->st
->index
);
1916 if (ost
->stream_copy
)
1917 av_log(NULL
, AV_LOG_INFO
, " (copy)");
1919 av_log(NULL
, AV_LOG_INFO
, " (%s -> %s)", input_streams
[ost
->source_index
]->dec
?
1920 input_streams
[ost
->source_index
]->dec
->name
: "?",
1921 ost
->enc
? ost
->enc
->name
: "?");
1922 av_log(NULL
, AV_LOG_INFO
, "\n");
1926 av_log(NULL
, AV_LOG_ERROR
, "%s\n", error
);
1938 * @return 1 if there are still streams where more output is wanted,
1941 static int need_output(void)
1945 for (i
= 0; i
< nb_output_streams
; i
++) {
1946 OutputStream
*ost
= output_streams
[i
];
1947 OutputFile
*of
= output_files
[ost
->file_index
];
1948 AVFormatContext
*os
= output_files
[ost
->file_index
]->ctx
;
1950 if (ost
->finished
||
1951 (os
->pb
&& avio_tell(os
->pb
) >= of
->limit_filesize
))
1953 if (ost
->frame_number
>= ost
->max_frames
) {
1955 for (j
= 0; j
< of
->ctx
->nb_streams
; j
++)
1956 output_streams
[of
->ost_index
+ j
]->finished
= 1;
1966 static InputFile
*select_input_file(void)
1968 InputFile
*ifile
= NULL
;
1969 int64_t ipts_min
= INT64_MAX
;
1972 for (i
= 0; i
< nb_input_streams
; i
++) {
1973 InputStream
*ist
= input_streams
[i
];
1974 int64_t ipts
= ist
->last_dts
;
1976 if (ist
->discard
|| input_files
[ist
->file_index
]->eagain
)
1978 if (!input_files
[ist
->file_index
]->eof_reached
) {
1979 if (ipts
< ipts_min
) {
1981 ifile
= input_files
[ist
->file_index
];
1990 static void *input_thread(void *arg
)
1995 while (!transcoding_finished
&& ret
>= 0) {
1997 ret
= av_read_frame(f
->ctx
, &pkt
);
1999 if (ret
== AVERROR(EAGAIN
)) {
2006 pthread_mutex_lock(&f
->fifo_lock
);
2007 while (!av_fifo_space(f
->fifo
))
2008 pthread_cond_wait(&f
->fifo_cond
, &f
->fifo_lock
);
2010 av_dup_packet(&pkt
);
2011 av_fifo_generic_write(f
->fifo
, &pkt
, sizeof(pkt
), NULL
);
2013 pthread_mutex_unlock(&f
->fifo_lock
);
2020 static void free_input_threads(void)
2024 if (nb_input_files
== 1)
2027 transcoding_finished
= 1;
2029 for (i
= 0; i
< nb_input_files
; i
++) {
2030 InputFile
*f
= input_files
[i
];
2033 if (!f
->fifo
|| f
->joined
)
2036 pthread_mutex_lock(&f
->fifo_lock
);
2037 while (av_fifo_size(f
->fifo
)) {
2038 av_fifo_generic_read(f
->fifo
, &pkt
, sizeof(pkt
), NULL
);
2039 av_free_packet(&pkt
);
2041 pthread_cond_signal(&f
->fifo_cond
);
2042 pthread_mutex_unlock(&f
->fifo_lock
);
2044 pthread_join(f
->thread
, NULL
);
2047 while (av_fifo_size(f
->fifo
)) {
2048 av_fifo_generic_read(f
->fifo
, &pkt
, sizeof(pkt
), NULL
);
2049 av_free_packet(&pkt
);
2051 av_fifo_free(f
->fifo
);
2055 static int init_input_threads(void)
2059 if (nb_input_files
== 1)
2062 for (i
= 0; i
< nb_input_files
; i
++) {
2063 InputFile
*f
= input_files
[i
];
2065 if (!(f
->fifo
= av_fifo_alloc(8*sizeof(AVPacket
))))
2066 return AVERROR(ENOMEM
);
2068 pthread_mutex_init(&f
->fifo_lock
, NULL
);
2069 pthread_cond_init (&f
->fifo_cond
, NULL
);
2071 if ((ret
= pthread_create(&f
->thread
, NULL
, input_thread
, f
)))
2072 return AVERROR(ret
);
2077 static int get_input_packet_mt(InputFile
*f
, AVPacket
*pkt
)
2081 pthread_mutex_lock(&f
->fifo_lock
);
2083 if (av_fifo_size(f
->fifo
)) {
2084 av_fifo_generic_read(f
->fifo
, pkt
, sizeof(*pkt
), NULL
);
2085 pthread_cond_signal(&f
->fifo_cond
);
2090 ret
= AVERROR(EAGAIN
);
2093 pthread_mutex_unlock(&f
->fifo_lock
);
2099 static int get_input_packet(InputFile
*f
, AVPacket
*pkt
)
2102 if (nb_input_files
> 1)
2103 return get_input_packet_mt(f
, pkt
);
2105 return av_read_frame(f
->ctx
, pkt
);
2108 static int got_eagain(void)
2111 for (i
= 0; i
< nb_input_files
; i
++)
2112 if (input_files
[i
]->eagain
)
2117 static void reset_eagain(void)
2120 for (i
= 0; i
< nb_input_files
; i
++)
2121 input_files
[i
]->eagain
= 0;
2125 * Read one packet from an input file and send it for
2126 * - decoding -> lavfi (audio/video)
2127 * - decoding -> encoding -> muxing (subtitles)
2128 * - muxing (streamcopy)
2131 * - 0 -- one packet was read and processed
2132 * - AVERROR(EAGAIN) -- no packets were available for selected file,
2133 * this function should be called again
2134 * - AVERROR_EOF -- this function should not be called again
2136 static int process_input(void)
2139 AVFormatContext
*is
;
2144 /* select the stream that we must read now */
2145 ifile
= select_input_file();
2146 /* if none, if is finished */
2151 return AVERROR(EAGAIN
);
2153 av_log(NULL
, AV_LOG_VERBOSE
, "No more inputs to read from.\n");
2158 ret
= get_input_packet(ifile
, &pkt
);
2160 if (ret
== AVERROR(EAGAIN
)) {
2165 if (ret
!= AVERROR_EOF
) {
2166 print_error(is
->filename
, ret
);
2170 ifile
->eof_reached
= 1;
2172 for (i
= 0; i
< ifile
->nb_streams
; i
++) {
2173 ist
= input_streams
[ifile
->ist_index
+ i
];
2174 if (ist
->decoding_needed
)
2175 output_packet(ist
, NULL
);
2177 /* mark all outputs that don't go through lavfi as finished */
2178 for (j
= 0; j
< nb_output_streams
; j
++) {
2179 OutputStream
*ost
= output_streams
[j
];
2181 if (ost
->source_index
== ifile
->ist_index
+ i
&&
2182 (ost
->stream_copy
|| ost
->enc
->type
== AVMEDIA_TYPE_SUBTITLE
))
2187 return AVERROR(EAGAIN
);
2193 av_pkt_dump_log2(NULL
, AV_LOG_DEBUG
, &pkt
, do_hex_dump
,
2194 is
->streams
[pkt
.stream_index
]);
2196 /* the following test is needed in case new streams appear
2197 dynamically in stream : we ignore them */
2198 if (pkt
.stream_index
>= ifile
->nb_streams
)
2199 goto discard_packet
;
2201 ist
= input_streams
[ifile
->ist_index
+ pkt
.stream_index
];
2203 goto discard_packet
;
2205 if (pkt
.dts
!= AV_NOPTS_VALUE
)
2206 pkt
.dts
+= av_rescale_q(ifile
->ts_offset
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
2207 if (pkt
.pts
!= AV_NOPTS_VALUE
)
2208 pkt
.pts
+= av_rescale_q(ifile
->ts_offset
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
2210 if (pkt
.pts
!= AV_NOPTS_VALUE
)
2211 pkt
.pts
*= ist
->ts_scale
;
2212 if (pkt
.dts
!= AV_NOPTS_VALUE
)
2213 pkt
.dts
*= ist
->ts_scale
;
2215 if (pkt
.dts
!= AV_NOPTS_VALUE
&& ist
->next_dts
!= AV_NOPTS_VALUE
&&
2216 (is
->iformat
->flags
& AVFMT_TS_DISCONT
)) {
2217 int64_t pkt_dts
= av_rescale_q(pkt
.dts
, ist
->st
->time_base
, AV_TIME_BASE_Q
);
2218 int64_t delta
= pkt_dts
- ist
->next_dts
;
2220 if ((FFABS(delta
) > 1LL * dts_delta_threshold
* AV_TIME_BASE
|| pkt_dts
+ 1 < ist
->last_dts
) && !copy_ts
) {
2221 ifile
->ts_offset
-= delta
;
2222 av_log(NULL
, AV_LOG_DEBUG
,
2223 "timestamp discontinuity %"PRId64
", new offset= %"PRId64
"\n",
2224 delta
, ifile
->ts_offset
);
2225 pkt
.dts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
2226 if (pkt
.pts
!= AV_NOPTS_VALUE
)
2227 pkt
.pts
-= av_rescale_q(delta
, AV_TIME_BASE_Q
, ist
->st
->time_base
);
2231 ret
= output_packet(ist
, &pkt
);
2233 av_log(NULL
, AV_LOG_ERROR
, "Error while decoding stream #%d:%d\n",
2234 ist
->file_index
, ist
->st
->index
);
2240 av_free_packet(&pkt
);
2246 * The following code is the main loop of the file converter
2248 static int transcode(void)
2250 int ret
, i
, need_input
= 1;
2251 AVFormatContext
*os
;
2254 int64_t timer_start
;
2256 ret
= transcode_init();
2260 av_log(NULL
, AV_LOG_INFO
, "Press ctrl-c to stop encoding\n");
2263 timer_start
= av_gettime();
2266 if ((ret
= init_input_threads()) < 0)
2270 while (!received_sigterm
) {
2271 /* check if there's any stream where output is still needed */
2272 if (!need_output()) {
2273 av_log(NULL
, AV_LOG_VERBOSE
, "No more output streams to write to, finishing.\n");
2277 /* read and process one input packet if needed */
2279 ret
= process_input();
2280 if (ret
== AVERROR_EOF
)
2284 ret
= poll_filters();
2286 if (ret
== AVERROR_EOF
|| ret
== AVERROR(EAGAIN
))
2289 av_log(NULL
, AV_LOG_ERROR
, "Error while filtering.\n");
2293 /* dump report by using the output first video and audio streams */
2294 print_report(0, timer_start
);
2297 free_input_threads();
2300 /* at the end of stream, we must flush the decoder buffers */
2301 for (i
= 0; i
< nb_input_streams
; i
++) {
2302 ist
= input_streams
[i
];
2303 if (!input_files
[ist
->file_index
]->eof_reached
&& ist
->decoding_needed
) {
2304 output_packet(ist
, NULL
);
2312 /* write the trailer if needed and close file */
2313 for (i
= 0; i
< nb_output_files
; i
++) {
2314 os
= output_files
[i
]->ctx
;
2315 av_write_trailer(os
);
2318 /* dump report by using the first video and audio streams */
2319 print_report(1, timer_start
);
2321 /* close each encoder */
2322 for (i
= 0; i
< nb_output_streams
; i
++) {
2323 ost
= output_streams
[i
];
2324 if (ost
->encoding_needed
) {
2325 av_freep(&ost
->st
->codec
->stats_in
);
2326 avcodec_close(ost
->st
->codec
);
2330 /* close each decoder */
2331 for (i
= 0; i
< nb_input_streams
; i
++) {
2332 ist
= input_streams
[i
];
2333 if (ist
->decoding_needed
) {
2334 avcodec_close(ist
->st
->codec
);
2343 free_input_threads();
2346 if (output_streams
) {
2347 for (i
= 0; i
< nb_output_streams
; i
++) {
2348 ost
= output_streams
[i
];
2350 if (ost
->stream_copy
)
2351 av_freep(&ost
->st
->codec
->extradata
);
2353 fclose(ost
->logfile
);
2354 ost
->logfile
= NULL
;
2356 av_freep(&ost
->st
->codec
->subtitle_header
);
2357 av_free(ost
->forced_kf_pts
);
2358 av_dict_free(&ost
->opts
);
2365 static int64_t getutime(void)
2368 struct rusage rusage
;
2370 getrusage(RUSAGE_SELF
, &rusage
);
2371 return (rusage
.ru_utime
.tv_sec
* 1000000LL) + rusage
.ru_utime
.tv_usec
;
2372 #elif HAVE_GETPROCESSTIMES
2374 FILETIME c
, e
, k
, u
;
2375 proc
= GetCurrentProcess();
2376 GetProcessTimes(proc
, &c
, &e
, &k
, &u
);
2377 return ((int64_t) u
.dwHighDateTime
<< 32 | u
.dwLowDateTime
) / 10;
2379 return av_gettime();
2383 static int64_t getmaxrss(void)
2385 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
2386 struct rusage rusage
;
2387 getrusage(RUSAGE_SELF
, &rusage
);
2388 return (int64_t)rusage
.ru_maxrss
* 1024;
2389 #elif HAVE_GETPROCESSMEMORYINFO
2391 PROCESS_MEMORY_COUNTERS memcounters
;
2392 proc
= GetCurrentProcess();
2393 memcounters
.cb
= sizeof(memcounters
);
2394 GetProcessMemoryInfo(proc
, &memcounters
, sizeof(memcounters
));
2395 return memcounters
.PeakPagefileUsage
;
2401 static void parse_cpuflags(int argc
, char **argv
, const OptionDef
*options
)
2403 int idx
= locate_option(argc
, argv
, options
, "cpuflags");
2404 if (idx
&& argv
[idx
+ 1])
2405 opt_cpuflags(NULL
, "cpuflags", argv
[idx
+ 1]);
2408 int main(int argc
, char **argv
)
2410 OptionsContext o
= { 0 };
2415 av_log_set_flags(AV_LOG_SKIP_REPEATED
);
2416 parse_loglevel(argc
, argv
, options
);
2418 avcodec_register_all();
2420 avdevice_register_all();
2422 avfilter_register_all();
2424 avformat_network_init();
2428 parse_cpuflags(argc
, argv
, options
);
2431 parse_options(&o
, argc
, argv
, options
, opt_output_file
);
2433 if (nb_output_files
<= 0 && nb_input_files
== 0) {
2435 av_log(NULL
, AV_LOG_WARNING
, "Use -h to get full help or, even better, run 'man %s'\n", program_name
);
2439 /* file converter / grab */
2440 if (nb_output_files
<= 0) {
2441 fprintf(stderr
, "At least one output file must be specified\n");
2446 if (transcode() < 0)
2448 ti
= getutime() - ti
;
2450 int maxrss
= getmaxrss() / 1024;
2451 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti
/ 1000000.0, maxrss
);