static const char *subtitle_codec_name = NULL;
static int file_overwrite = 0;
+static int no_file_overwrite = 0;
static int do_benchmark = 0;
static int do_hex_dump = 0;
static int do_pkt_dump = 0;
static int audio_sync_method= 0;
static float audio_drift_threshold= 0.1;
static int copy_ts= 0;
-static int copy_tb= 0;
+static int copy_tb= -1;
static int opt_shortest = 0;
static char *vstats_filename;
static FILE *vstats_file;
static uint8_t *audio_out;
static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
-static void *samples;
static uint8_t *input_tmp= NULL;
#define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
int discard; /* true if stream data should be discarded */
int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
AVCodec *dec;
+ AVFrame *decoded_frame;
+ AVFrame *filtered_frame;
int64_t start; /* time when read started */
int64_t next_pts; /* synthetic pts for cases where pkt.pts
return -1;
}
-static int decode_interrupt_cb(void)
+static int decode_interrupt_cb(void *ctx)
{
return received_nb_signals > 1;
}
+static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
+
void av_noreturn exit_program(int ret)
{
int i;
av_dict_free(&output_files[i].opts);
}
for(i=0;i<nb_input_files;i++) {
- av_close_input_file(input_files[i].ctx);
+ avformat_close_input(&input_files[i].ctx);
}
- for (i = 0; i < nb_input_streams; i++)
+ for (i = 0; i < nb_input_streams; i++) {
+ av_freep(&input_streams[i].decoded_frame);
+ av_freep(&input_streams[i].filtered_frame);
av_dict_free(&input_streams[i].opts);
+ }
if (vstats_file)
fclose(vstats_file);
av_free(audio_buf);
av_free(audio_out);
allocated_audio_buf_size= allocated_audio_out_size= 0;
- av_free(samples);
#if CONFIG_AVFILTER
avfilter_uninit();
{
if(codec && codec->pix_fmts){
const enum PixelFormat *p= codec->pix_fmts;
+ int has_alpha= av_pix_fmt_descriptors[st->codec->pix_fmt].nb_components % 2 == 0;
+ enum PixelFormat best= PIX_FMT_NONE;
if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
if(st->codec->codec_id==CODEC_ID_MJPEG){
p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
}
}
- for(; *p!=-1; p++){
+ for (; *p != PIX_FMT_NONE; p++) {
+ best= avcodec_find_best_pix_fmt2(best, *p, st->codec->pix_fmt, has_alpha, NULL);
if(*p == st->codec->pix_fmt)
break;
}
- if (*p == -1) {
+ if (*p == PIX_FMT_NONE) {
if(st->codec->pix_fmt != PIX_FMT_NONE)
av_log(NULL, AV_LOG_WARNING,
"Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
av_pix_fmt_descriptors[st->codec->pix_fmt].name,
codec->name,
- av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
- st->codec->pix_fmt = codec->pix_fmts[0];
+ av_pix_fmt_descriptors[best].name);
+ st->codec->pix_fmt = best;
}
}
}
}
}
-static void do_audio_out(AVFormatContext *s,
- OutputStream *ost,
- InputStream *ist,
- unsigned char *buf, int size)
+static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
+{
+ int fill_char = 0x00;
+ if (sample_fmt == AV_SAMPLE_FMT_U8)
+ fill_char = 0x80;
+ memset(buf, fill_char, size);
+}
+
+static void do_audio_out(AVFormatContext *s, OutputStream *ost,
+ InputStream *ist, AVFrame *decoded_frame)
{
uint8_t *buftmp;
int64_t audio_out_size, audio_buf_size;
- int64_t allocated_for_size= size;
int size_out, frame_bytes, ret, resample_changed;
AVCodecContext *enc= ost->st->codec;
int osize = av_get_bytes_per_sample(enc->sample_fmt);
int isize = av_get_bytes_per_sample(dec->sample_fmt);
const int coded_bps = av_get_bits_per_sample(enc->codec->id);
+ uint8_t *buf = decoded_frame->data[0];
+ int size = decoded_frame->nb_samples * dec->channels * isize;
+ int64_t allocated_for_size = size;
need_realloc:
audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
}
if (enc->channels != dec->channels
- || enc->sample_fmt != dec->sample_fmt)
+ || enc->sample_fmt != dec->sample_fmt
+ || enc->sample_rate!= dec->sample_rate
+ )
ost->audio_resample = 1;
resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
//ost->swr = NULL;
ost->audio_resample = 0;
} else {
- ost->swr = swr_alloc2(ost->swr,
- enc->channel_layout, enc->sample_fmt, enc->sample_rate,
- dec->channel_layout, dec->sample_fmt, dec->sample_rate,
- ost->audio_channels_mapped ? ost->audio_channels_map : NULL,
- 0, NULL);
+ ost->swr = swr_alloc_set_opts(ost->swr,
+ enc->channel_layout, enc->sample_fmt, enc->sample_rate,
+ dec->channel_layout, dec->sample_fmt, dec->sample_rate,
+ 0, NULL);
+ if (ost->audio_channels_mapped)
+ swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
if (ost->audio_channels_mapped) {
av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
if(audio_sync_method){
double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
- - av_fifo_size(ost->fifo)/(enc->channels * 2);
- double idelta= delta*dec->sample_rate / enc->sample_rate;
- int byte_delta= ((int)idelta)*2*dec->channels;
+ - av_fifo_size(ost->fifo)/(enc->channels * osize);
+ int idelta = delta * dec->sample_rate / enc->sample_rate;
+ int byte_delta = idelta * isize * dec->channels;
//FIXME resample delay
if(fabs(delta) > 50){
byte_delta= FFMAX(byte_delta, -size);
size += byte_delta;
buf -= byte_delta;
- av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
+ av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
+ -byte_delta / (isize * dec->channels));
if(!size)
return;
ist->is_start=0;
}
ist->is_start=0;
- memset(input_tmp, 0, byte_delta);
+ generate_silence(input_tmp, dec->sample_fmt, byte_delta);
memcpy(input_tmp + byte_delta, buf, size);
buf= input_tmp;
size += byte_delta;
- av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
+ av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
}
}else if(audio_sync_method>1){
int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
}
}else
ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
- - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
+ - av_fifo_size(ost->fifo)/(enc->channels * osize); //FIXME wrong
if (ost->audio_resample) {
buftmp = audio_buf;
format_video_sync = video_sync_method;
if (format_video_sync < 0)
- format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
+ format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? 0 : 2) : 1;
if (format_video_sync) {
double vdelta = sync_ipts - ost->sync_opts + duration;
av_init_packet(&pkt);
pkt.stream_index= ost->index;
- if (s->oformat->flags & AVFMT_RAWPICTURE) {
+ if (s->oformat->flags & AVFMT_RAWPICTURE &&
+ enc->codec->id == CODEC_ID_RAWVIDEO) {
/* raw pictures are written as AVPicture structure to
avoid any copies. We support temporarily the older
method. */
oc = output_files[0].ctx;
total_size = avio_size(oc->pb);
- if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
+ if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
total_size= avio_tell(oc->pb);
+ if (total_size < 0)
+ total_size = 0;
+ }
buf[0] = '\0';
vid = 0;
extra_size/1024.0,
100.0*(total_size - raw)/raw
);
+ if(video_size + audio_size + extra_size == 0){
+ av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
+ }
}
}
-static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
-{
- int fill_char = 0x00;
- if (sample_fmt == AV_SAMPLE_FMT_U8)
- fill_char = 0x80;
- memset(buf, fill_char, size);
-}
-
static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
{
int i, ret;
if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
continue;
- if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
+ if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
continue;
for(;;) {
}
}
+/*
+ * Check whether a packet from ist should be written into ost at this time
+ */
+static int check_output_constraints(InputStream *ist, OutputStream *ost)
+{
+ OutputFile *of = &output_files[ost->file_index];
+ int ist_index = ist - input_streams;
+
+ if (ost->source_index != ist_index)
+ return 0;
+
+ if (of->start_time && ist->pts < of->start_time)
+ return 0;
+
+ if (of->recording_time != INT64_MAX &&
+ av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
+ (AVRational){1, 1000000}) >= 0) {
+ ost->is_past_recording_time = 1;
+ return 0;
+ }
+
+ return 1;
+}
+
+static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
+{
+ OutputFile *of = &output_files[ost->file_index];
+ int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
+ AVPicture pict;
+ AVPacket opkt;
+
+ av_init_packet(&opkt);
+
+ if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
+ !ost->copy_initial_nonkeyframes)
+ return;
+
+ /* force the input stream PTS */
+ if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
+ audio_size += pkt->size;
+ else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+ video_size += pkt->size;
+ ost->sync_opts++;
+ }
+
+ opkt.stream_index = ost->index;
+ if (pkt->pts != AV_NOPTS_VALUE)
+ opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
+ else
+ opkt.pts = AV_NOPTS_VALUE;
+
+ if (pkt->dts == AV_NOPTS_VALUE)
+ opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
+ else
+ opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
+ opkt.dts -= ost_tb_start_time;
+
+ opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
+ opkt.flags = pkt->flags;
+
+ //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
+ if( ost->st->codec->codec_id != CODEC_ID_H264
+ && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
+ && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
+ ) {
+ if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
+ opkt.destruct = av_destruct_packet;
+ } else {
+ opkt.data = pkt->data;
+ opkt.size = pkt->size;
+ }
+ if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
+ /* store AVPicture in AVPacket, as expected by the output format */
+ avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
+ opkt.data = (uint8_t *)&pict;
+ opkt.size = sizeof(AVPicture);
+ opkt.flags |= AV_PKT_FLAG_KEY;
+ }
+
+ write_frame(of->ctx, &opkt, ost->st->codec, ost->bitstream_filters);
+ ost->st->codec->frame_number++;
+ ost->frame_number++;
+ av_free_packet(&opkt);
+}
+
+static void rate_emu_sleep(InputStream *ist)
+{
+ if (input_files[ist->file_index].rate_emu) {
+ int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
+ int64_t now = av_gettime() - ist->start;
+ if (pts > now)
+ usleep(pts - now);
+ }
+}
+
+static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
+{
+ AVFrame *decoded_frame;
+ AVCodecContext *avctx = ist->st->codec;
+ int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
+ int i, ret;
+
+ if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
+ return AVERROR(ENOMEM);
+ else
+ avcodec_get_frame_defaults(ist->decoded_frame);
+ decoded_frame = ist->decoded_frame;
+
+ ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
+ if (ret < 0) {
+ return ret;
+ }
+
+ if (!*got_output) {
+ /* no audio frame */
+ return ret;
+ }
+
+ /* if the decoder provides a pts, use it instead of the last packet pts.
+ the decoder could be delaying output by a packet or more. */
+ if (decoded_frame->pts != AV_NOPTS_VALUE)
+ ist->next_pts = decoded_frame->pts;
+
+ /* increment next_pts to use for the case where the input stream does not
+ have timestamps or there are multiple frames in the packet */
+ ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
+ avctx->sample_rate;
+
+ // preprocess audio (volume)
+ if (audio_volume != 256) {
+ int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
+ void *samples = decoded_frame->data[0];
+ switch (avctx->sample_fmt) {
+ case AV_SAMPLE_FMT_U8:
+ {
+ uint8_t *volp = samples;
+ for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
+ int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
+ *volp++ = av_clip_uint8(v);
+ }
+ break;
+ }
+ case AV_SAMPLE_FMT_S16:
+ {
+ int16_t *volp = samples;
+ for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
+ int v = ((*volp) * audio_volume + 128) >> 8;
+ *volp++ = av_clip_int16(v);
+ }
+ break;
+ }
+ case AV_SAMPLE_FMT_S32:
+ {
+ int32_t *volp = samples;
+ for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
+ int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
+ *volp++ = av_clipl_int32(v);
+ }
+ break;
+ }
+ case AV_SAMPLE_FMT_FLT:
+ {
+ float *volp = samples;
+ float scale = audio_volume / 256.f;
+ for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
+ *volp++ *= scale;
+ }
+ break;
+ }
+ case AV_SAMPLE_FMT_DBL:
+ {
+ double *volp = samples;
+ double scale = audio_volume / 256.;
+ for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
+ *volp++ *= scale;
+ }
+ break;
+ }
+ default:
+ av_log(NULL, AV_LOG_FATAL,
+ "Audio volume adjustment on sample format %s is not supported.\n",
+ av_get_sample_fmt_name(ist->st->codec->sample_fmt));
+ exit_program(1);
+ }
+ }
+
+ rate_emu_sleep(ist);
+
+ for (i = 0; i < nb_output_streams; i++) {
+ OutputStream *ost = &output_streams[i];
+
+ if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
+ continue;
+ do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
+ }
+
+ return ret;
+}
+
+static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
+{
+ AVFrame *decoded_frame, *filtered_frame = NULL;
+ void *buffer_to_free = NULL;
+ int i, ret = 0;
+ float quality = 0;
+#if CONFIG_AVFILTER
+ int frame_available = 1;
+#endif
+ int duration=0;
+ int64_t *best_effort_timestamp;
+ AVRational *frame_sample_aspect;
+
+ if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
+ return AVERROR(ENOMEM);
+ else
+ avcodec_get_frame_defaults(ist->decoded_frame);
+ decoded_frame = ist->decoded_frame;
+ pkt->pts = *pkt_pts;
+ pkt->dts = *pkt_dts;
+ *pkt_pts = AV_NOPTS_VALUE;
+
+ if (pkt->duration) {
+ duration = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
+ } else if(ist->st->codec->time_base.num != 0) {
+ int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
+ duration = ((int64_t)AV_TIME_BASE *
+ ist->st->codec->time_base.num * ticks) /
+ ist->st->codec->time_base.den;
+ }
+
+ if(*pkt_dts != AV_NOPTS_VALUE && duration) {
+ *pkt_dts += duration;
+ }else
+ *pkt_dts = AV_NOPTS_VALUE;
+
+ ret = avcodec_decode_video2(ist->st->codec,
+ decoded_frame, got_output, pkt);
+ if (ret < 0)
+ return ret;
+
+ quality = same_quant ? decoded_frame->quality : 0;
+ if (!*got_output) {
+ /* no picture yet */
+ return ret;
+ }
+
+ best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
+ if(*best_effort_timestamp != AV_NOPTS_VALUE)
+ ist->next_pts = ist->pts = *best_effort_timestamp;
+
+ ist->next_pts += duration;
+ pkt->size = 0;
+
+ pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
+
+#if CONFIG_AVFILTER
+ frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
+ for(i=0;i<nb_output_streams;i++) {
+ OutputStream *ost = ost = &output_streams[i];
+ if(check_output_constraints(ist, ost)){
+ if (!frame_sample_aspect->num)
+ *frame_sample_aspect = ist->st->sample_aspect_ratio;
+ decoded_frame->pts = ist->pts;
+
+ av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
+ }
+ }
+#endif
+
+ rate_emu_sleep(ist);
+
+ for (i = 0; i < nb_output_streams; i++) {
+ OutputStream *ost = &output_streams[i];
+ int frame_size;
+
+ if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
+ continue;
+
+#if CONFIG_AVFILTER
+ if (ost->input_video_filter) {
+ frame_available = av_buffersink_poll_frame(ost->output_video_filter);
+ }
+ while (frame_available) {
+ if (ost->output_video_filter) {
+ AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
+ if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0){
+ av_log(0, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");
+ goto cont;
+ }
+ if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
+ av_free(buffer_to_free);
+ return AVERROR(ENOMEM);
+ } else
+ avcodec_get_frame_defaults(ist->filtered_frame);
+ filtered_frame = ist->filtered_frame;
+ *filtered_frame= *decoded_frame; //for me_threshold
+ if (ost->picref) {
+ avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
+ ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
+ }
+ }
+ if (ost->picref->video && !ost->frame_aspect_ratio)
+ ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
+#else
+ filtered_frame = decoded_frame;
+#endif
+
+ do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
+ same_quant ? quality : ost->st->codec->global_quality);
+ if (vstats_filename && frame_size)
+ do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
+#if CONFIG_AVFILTER
+ cont:
+ frame_available = ost->output_video_filter && av_buffersink_poll_frame(ost->output_video_filter);
+ avfilter_unref_buffer(ost->picref);
+ }
+#endif
+ }
+
+ av_free(buffer_to_free);
+ return ret;
+}
+
+static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
+{
+ AVSubtitle subtitle;
+ int i, ret = avcodec_decode_subtitle2(ist->st->codec,
+ &subtitle, got_output, pkt);
+ if (ret < 0)
+ return ret;
+ if (!*got_output)
+ return ret;
+
+ rate_emu_sleep(ist);
+
+ for (i = 0; i < nb_output_streams; i++) {
+ OutputStream *ost = &output_streams[i];
+
+ if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
+ continue;
+
+ do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
+ }
+
+ avsubtitle_free(&subtitle);
+ return ret;
+}
+
/* pkt = NULL means EOF (needed to flush decoder buffers) */
-static int output_packet(InputStream *ist, int ist_index,
+static int output_packet(InputStream *ist,
OutputStream *ost_table, int nb_ostreams,
const AVPacket *pkt)
{
- AVFormatContext *os;
- OutputStream *ost;
int ret = 0, i;
int got_output;
- void *buffer_to_free = NULL;
- static unsigned int samples_size= 0;
- AVSubtitle subtitle, *subtitle_to_free;
int64_t pkt_dts = AV_NOPTS_VALUE;
int64_t pkt_pts = AV_NOPTS_VALUE;
-#if CONFIG_AVFILTER
- int frame_available;
-#endif
- float quality = 0;
AVPacket avpkt;
- int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
- if(ist->next_pts == AV_NOPTS_VALUE)
- ist->next_pts= ist->pts;
+ if (ist->next_pts == AV_NOPTS_VALUE)
+ ist->next_pts = ist->pts;
if (pkt == NULL) {
/* EOF handling */
pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
//while we have more to decode or while the decoder did output something on EOF
- while (avpkt.size > 0 || (!pkt && got_output)) {
- uint8_t *data_buf, *decoded_data_buf;
- int data_size, decoded_data_size;
- AVFrame *decoded_frame, *filtered_frame;
+ while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
handle_eof:
- ist->pts= ist->next_pts;
- if(avpkt.size && avpkt.size != pkt->size)
+ ist->pts = ist->next_pts;
+
+ if (avpkt.size && avpkt.size != pkt->size) {
av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
"Multiple frames in a packet from stream %d\n", pkt->stream_index);
- ist->showed_multi_packet_warning=1;
-
- /* decode the packet if needed */
- decoded_frame = filtered_frame = NULL;
- decoded_data_buf = NULL; /* fail safe */
- decoded_data_size= 0;
- data_buf = avpkt.data;
- data_size = avpkt.size;
- subtitle_to_free = NULL;
- if (ist->decoding_needed) {
- switch(ist->st->codec->codec_type) {
- case AVMEDIA_TYPE_AUDIO:{
- if(pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
- samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
- av_free(samples);
- samples= av_malloc(samples_size);
- }
- decoded_data_size= samples_size;
- /* XXX: could avoid copy if PCM 16 bits with same
- endianness as CPU */
- ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
- &avpkt);
- if (ret < 0)
- return ret;
- avpkt.data += ret;
- avpkt.size -= ret;
- data_size = ret;
- got_output = decoded_data_size > 0;
- /* Some bug in mpeg audio decoder gives */
- /* decoded_data_size < 0, it seems they are overflows */
- if (!got_output) {
- /* no audio frame */
- continue;
- }
- decoded_data_buf = (uint8_t *)samples;
- ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
- (ist->st->codec->sample_rate * ist->st->codec->channels);
- break;}
- case AVMEDIA_TYPE_VIDEO:
- if (!(decoded_frame = avcodec_alloc_frame()))
- return AVERROR(ENOMEM);
- avpkt.pts = pkt_pts;
- avpkt.dts = pkt_dts;
- pkt_pts = AV_NOPTS_VALUE;
- if(pkt_dts != AV_NOPTS_VALUE && ist->st->codec->time_base.num != 0) {
- int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
- pkt_dts += ((int64_t)AV_TIME_BASE *
- ist->st->codec->time_base.num * ticks) /
- ist->st->codec->time_base.den;
- }else
- pkt_dts = AV_NOPTS_VALUE;
-
- ret = avcodec_decode_video2(ist->st->codec,
- decoded_frame, &got_output, &avpkt);
- quality = same_quant ? decoded_frame->quality : 0;
- if (ret < 0)
- goto fail;
- if (!got_output) {
- /* no picture yet */
- av_freep(&decoded_frame);
- goto discard_packet;
- }
-
- if(decoded_frame->best_effort_timestamp != AV_NOPTS_VALUE)
- ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
-
- if (ist->st->codec->time_base.num != 0) {
- int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
- ist->next_pts += ((int64_t)AV_TIME_BASE *
- ist->st->codec->time_base.num * ticks) /
- ist->st->codec->time_base.den;
- }
- avpkt.size = 0;
- buffer_to_free = NULL;
- pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
- break;
- case AVMEDIA_TYPE_SUBTITLE:
- ret = avcodec_decode_subtitle2(ist->st->codec,
- &subtitle, &got_output, &avpkt);
- if (ret < 0)
- return ret;
- if (!got_output) {
- goto discard_packet;
- }
- subtitle_to_free = &subtitle;
- avpkt.size = 0;
- break;
- default:
- return -1;
- }
- } else {
- switch(ist->st->codec->codec_type) {
- case AVMEDIA_TYPE_AUDIO:
- ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
- ist->st->codec->sample_rate;
- break;
- case AVMEDIA_TYPE_VIDEO:
- if (ist->st->codec->time_base.num != 0) {
- int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
- ist->next_pts += ((int64_t)AV_TIME_BASE *
- ist->st->codec->time_base.num * ticks) /
- ist->st->codec->time_base.den;
- }
- break;
- }
- avpkt.size = 0;
+ ist->showed_multi_packet_warning = 1;
}
-#if CONFIG_AVFILTER
- if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
- for(i=0;i<nb_ostreams;i++) {
- OutputFile *of = &output_files[ost_table[i].file_index];
- if (of->start_time == 0 || ist->pts >= of->start_time) {
- ost = &ost_table[i];
- if (ost->input_video_filter && ost->source_index == ist_index) {
- if (!decoded_frame->sample_aspect_ratio.num)
- decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
- decoded_frame->pts = ist->pts;
-
- av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
- }
- }
+ switch(ist->st->codec->codec_type) {
+ case AVMEDIA_TYPE_AUDIO:
+ ret = transcode_audio (ist, &avpkt, &got_output);
+ break;
+ case AVMEDIA_TYPE_VIDEO:
+ ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
+ break;
+ case AVMEDIA_TYPE_SUBTITLE:
+ ret = transcode_subtitles(ist, &avpkt, &got_output);
+ break;
+ default:
+ return -1;
}
-#endif
- // preprocess audio (volume)
- if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
- if (audio_volume != 256) {
- switch (ist->st->codec->sample_fmt) {
- case AV_SAMPLE_FMT_U8:
- {
- uint8_t *volp = samples;
- for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
- int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
- *volp++ = av_clip_uint8(v);
- }
- break;
- }
- case AV_SAMPLE_FMT_S16:
- {
- int16_t *volp = samples;
- for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
- int v = ((*volp) * audio_volume + 128) >> 8;
- *volp++ = av_clip_int16(v);
- }
- break;
- }
- case AV_SAMPLE_FMT_S32:
- {
- int32_t *volp = samples;
- for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
- int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
- *volp++ = av_clipl_int32(v);
- }
- break;
- }
- case AV_SAMPLE_FMT_FLT:
- {
- float *volp = samples;
- float scale = audio_volume / 256.f;
- for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
- *volp++ *= scale;
- }
- break;
- }
- case AV_SAMPLE_FMT_DBL:
- {
- double *volp = samples;
- double scale = audio_volume / 256.;
- for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
- *volp++ *= scale;
- }
- break;
- }
- default:
- av_log(NULL, AV_LOG_FATAL,
- "Audio volume adjustment on sample format %s is not supported.\n",
- av_get_sample_fmt_name(ist->st->codec->sample_fmt));
- exit_program(1);
- }
- }
+ if (ret < 0)
+ return ret;
+ // touch data and size only if not EOF
+ if (pkt) {
+ if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
+ ret = avpkt.size;
+ avpkt.data += ret;
+ avpkt.size -= ret;
}
-
- /* frame rate emulation */
- if (input_files[ist->file_index].rate_emu) {
- int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
- int64_t now = av_gettime() - ist->start;
- if (pts > now)
- usleep(pts - now);
+ if (!got_output) {
+ continue;
}
- /* if output time reached then transcode raw format,
- encode packets and output them */
- for (i = 0; i < nb_ostreams; i++) {
- OutputFile *of = &output_files[ost_table[i].file_index];
- int frame_size;
-
- ost = &ost_table[i];
- if (ost->source_index != ist_index)
- continue;
-
- if (of->start_time && ist->pts < of->start_time)
- continue;
-
- if (of->recording_time != INT64_MAX &&
- av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
- (AVRational){1, 1000000}) >= 0) {
- ost->is_past_recording_time = 1;
- continue;
- }
-
-#if CONFIG_AVFILTER
- frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
- !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
- while (frame_available) {
- if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
- AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
- if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
- goto cont;
- if (!filtered_frame && !(filtered_frame = avcodec_alloc_frame())) {
- ret = AVERROR(ENOMEM);
- goto fail;
- }
- *filtered_frame= *decoded_frame; //for me_threshold
- if (ost->picref) {
- avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
- ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
- }
- }
-#else
- filtered_frame = decoded_frame;
-#endif
- os = output_files[ost->file_index].ctx;
-
- /* set the input output pts pairs */
- //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
-
- if (ost->encoding_needed) {
- av_assert0(ist->decoding_needed);
- switch(ost->st->codec->codec_type) {
- case AVMEDIA_TYPE_AUDIO:
- do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
- break;
- case AVMEDIA_TYPE_VIDEO:
-#if CONFIG_AVFILTER
- if (ost->picref->video && !ost->frame_aspect_ratio)
- ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
-#endif
- do_video_out(os, ost, ist, filtered_frame, &frame_size,
- same_quant ? quality : ost->st->codec->global_quality);
- if (vstats_filename && frame_size)
- do_video_stats(os, ost, frame_size);
- break;
- case AVMEDIA_TYPE_SUBTITLE:
- do_subtitle_out(os, ost, ist, &subtitle,
- pkt->pts);
- break;
- default:
- abort();
- }
- } else {
- AVPicture pict;
- AVPacket opkt;
- int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
- av_init_packet(&opkt);
-
- if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
- !ost->copy_initial_nonkeyframes)
-#if !CONFIG_AVFILTER
- continue;
-#else
- goto cont;
-#endif
-
- /* no reencoding needed : output the packet directly */
- /* force the input stream PTS */
-
- if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
- audio_size += data_size;
- else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
- video_size += data_size;
- ost->sync_opts++;
- }
-
- opkt.stream_index= ost->index;
- if(pkt->pts != AV_NOPTS_VALUE)
- opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
- else
- opkt.pts= AV_NOPTS_VALUE;
-
- if (pkt->dts == AV_NOPTS_VALUE)
- opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
- else
- opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
- opkt.dts -= ost_tb_start_time;
-
- opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
- opkt.flags= pkt->flags;
-
- //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
- if( ost->st->codec->codec_id != CODEC_ID_H264
- && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
- && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
- ) {
- if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
- opkt.destruct= av_destruct_packet;
- } else {
- opkt.data = data_buf;
- opkt.size = data_size;
- }
+ }
- if (os->oformat->flags & AVFMT_RAWPICTURE) {
- /* store AVPicture in AVPacket, as expected by the output format */
- avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
- opkt.data = (uint8_t *)&pict;
- opkt.size = sizeof(AVPicture);
- opkt.flags |= AV_PKT_FLAG_KEY;
- }
- write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
- ost->st->codec->frame_number++;
- ost->frame_number++;
- av_free_packet(&opkt);
- }
-#if CONFIG_AVFILTER
- cont:
- frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
- ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
- avfilter_unref_buffer(ost->picref);
+ /* handle stream copy */
+ if (!ist->decoding_needed) {
+ rate_emu_sleep(ist);
+ ist->pts = ist->next_pts;
+ switch (ist->st->codec->codec_type) {
+ case AVMEDIA_TYPE_AUDIO:
+ ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
+ ist->st->codec->sample_rate;
+ break;
+ case AVMEDIA_TYPE_VIDEO:
+ if (pkt->duration) {
+ ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
+ } else if(ist->st->codec->time_base.num != 0) {
+ int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
+ ist->next_pts += ((int64_t)AV_TIME_BASE *
+ ist->st->codec->time_base.num * ticks) /
+ ist->st->codec->time_base.den;
}
- av_freep(&filtered_frame);
-#endif
+ break;
}
+ }
+ for (i = 0; pkt && i < nb_ostreams; i++) {
+ OutputStream *ost = &ost_table[i];
-fail:
- av_free(buffer_to_free);
- /* XXX: allocate the subtitles in the codec ? */
- if (subtitle_to_free) {
- avsubtitle_free(subtitle_to_free);
- subtitle_to_free = NULL;
- }
- av_freep(&decoded_frame);
- if (ret < 0)
- return ret;
+ if (!check_output_constraints(ist, ost) || ost->encoding_needed)
+ continue;
+
+ do_streamcopy(ist, ost, pkt);
}
- discard_packet:
return 0;
}
InputFile *input_files, int nb_input_files)
{
int ret = 0, i, j, k;
- AVFormatContext *os;
+ AVFormatContext *oc;
AVCodecContext *codec, *icodec;
OutputStream *ost;
InputStream *ist;
}
/* output stream init */
- for(i=0;i<nb_output_files;i++) {
- os = output_files[i].ctx;
- if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
- av_dump_format(os, i, os->filename, 1);
+ for (i = 0; i < nb_output_files; i++) {
+ oc = output_files[i].ctx;
+ if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
+ av_dump_format(oc, i, oc->filename, 1);
av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
return AVERROR(EINVAL);
}
/* for each output stream, we compute the right encoding parameters */
for (i = 0; i < nb_output_streams; i++) {
ost = &output_streams[i];
- os = output_files[ost->file_index].ctx;
+ oc = output_files[ost->file_index].ctx;
ist = &input_streams[ost->source_index];
if (ost->attachment_filename)
continue;
- codec = ost->st->codec;
+ codec = ost->st->codec;
icodec = ist->st->codec;
- ost->st->disposition = ist->st->disposition;
- codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
+ ost->st->disposition = ist->st->disposition;
+ codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
codec->chroma_sample_location = icodec->chroma_sample_location;
if (ost->stream_copy) {
}
/* if stream_copy is selected, no need to decode or encode */
- codec->codec_id = icodec->codec_id;
+ codec->codec_id = icodec->codec_id;
codec->codec_type = icodec->codec_type;
- if(!codec->codec_tag){
- if( !os->oformat->codec_tag
- || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
- || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
+ if (!codec->codec_tag) {
+ if (!oc->oformat->codec_tag ||
+ av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
+ av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
codec->codec_tag = icodec->codec_tag;
}
- codec->bit_rate = icodec->bit_rate;
+ codec->bit_rate = icodec->bit_rate;
codec->rc_max_rate = icodec->rc_max_rate;
codec->rc_buffer_size = icodec->rc_buffer_size;
- codec->extradata= av_mallocz(extra_size);
+ codec->extradata = av_mallocz(extra_size);
if (!codec->extradata) {
return AVERROR(ENOMEM);
}
codec->extradata_size= icodec->extradata_size;
codec->time_base = ist->st->time_base;
- if(!strcmp(os->oformat->name, "avi")) {
- if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
+ if(!strcmp(oc->oformat->name, "avi")) {
+ if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
+ && av_q2d(ist->st->time_base) < 1.0/500
+ || copy_tb==0){
codec->time_base = icodec->time_base;
codec->time_base.num *= icodec->ticks_per_frame;
codec->time_base.den *= 2;
}
- } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
- if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
+ } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
+ && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
+ && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
+ ) {
+ if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
+ && av_q2d(ist->st->time_base) < 1.0/500
+ || copy_tb==0){
codec->time_base = icodec->time_base;
codec->time_base.num *= icodec->ticks_per_frame;
}
av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
exit_program(1);
}
- codec->channel_layout = icodec->channel_layout;
- codec->sample_rate = icodec->sample_rate;
- codec->channels = icodec->channels;
- codec->frame_size = icodec->frame_size;
+ codec->channel_layout = icodec->channel_layout;
+ codec->sample_rate = icodec->sample_rate;
+ codec->channels = icodec->channels;
+ codec->frame_size = icodec->frame_size;
codec->audio_service_type = icodec->audio_service_type;
- codec->block_align= icodec->block_align;
+ codec->block_align = icodec->block_align;
break;
case AVMEDIA_TYPE_VIDEO:
- codec->pix_fmt = icodec->pix_fmt;
- codec->width = icodec->width;
- codec->height = icodec->height;
- codec->has_b_frames = icodec->has_b_frames;
+ codec->pix_fmt = icodec->pix_fmt;
+ codec->width = icodec->width;
+ codec->height = icodec->height;
+ codec->has_b_frames = icodec->has_b_frames;
if (!codec->sample_aspect_ratio.num) {
- codec->sample_aspect_ratio =
+ codec->sample_aspect_ratio =
ost->st->sample_aspect_ratio =
ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
ist->st->codec->sample_aspect_ratio.num ?
ost->st->avg_frame_rate = ist->st->avg_frame_rate;
break;
case AVMEDIA_TYPE_SUBTITLE:
- codec->width = icodec->width;
+ codec->width = icodec->width;
codec->height = icodec->height;
break;
case AVMEDIA_TYPE_DATA:
} else {
if (!ost->enc)
ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
+
ist->decoding_needed = 1;
ost->encoding_needed = 1;
+
switch(codec->codec_type) {
case AVMEDIA_TYPE_AUDIO:
- ost->fifo= av_fifo_alloc(1024);
+ ost->fifo = av_fifo_alloc(1024);
if (!ost->fifo) {
return AVERROR(ENOMEM);
}
codec->sample_rate = icodec->sample_rate;
choose_sample_rate(ost->st, ost->enc);
codec->time_base = (AVRational){1, codec->sample_rate};
+
if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
codec->sample_fmt = icodec->sample_fmt;
choose_sample_fmt(ost->st, ost->enc);
+
if (ost->audio_channels_mapped) {
/* the requested output channel is set to the number of
* -map_channel only if no -ac are specified */
}
if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
codec->channel_layout = 0;
- ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
- ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
- || codec->channel_layout != icodec->channel_layout;
- icodec->request_channels = codec->channels;
+
+ ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
+ ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
+ || codec->channel_layout != icodec->channel_layout;
+ icodec->request_channels = codec->channels;
ost->resample_sample_fmt = icodec->sample_fmt;
ost->resample_sample_rate = icodec->sample_rate;
ost->resample_channels = icodec->channels;
codec->bits_per_raw_sample= frame_bits_per_raw_sample;
}
- ost->resample_height = icodec->height;
- ost->resample_width = icodec->width;
- ost->resample_pix_fmt= icodec->pix_fmt;
+ ost->resample_height = icodec->height;
+ ost->resample_width = icodec->width;
+ ost->resample_pix_fmt = icodec->pix_fmt;
if (!ost->frame_rate.num)
ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
}
codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
if( av_q2d(codec->time_base) < 0.001 && video_sync_method
- && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
- av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
+ && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
+ av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
"Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
}
for (j = 0; j < ost->forced_kf_count; j++)
}
if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
/* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
- int size= codec->width * codec->height;
- bit_buffer_size= FFMAX(bit_buffer_size, 7*size + 10000);
+ int size = codec->width * codec->height;
+ bit_buffer_size = FFMAX(bit_buffer_size, 7*size + 10000);
}
}
for (i = 0; i < nb_output_streams; i++) {
ost = &output_streams[i];
if (ost->encoding_needed) {
- AVCodec *codec = ost->enc;
+ AVCodec *codec = ost->enc;
AVCodecContext *dec = input_streams[ost->source_index].st->codec;
if (!codec) {
snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
/* open files and write file headers */
for (i = 0; i < nb_output_files; i++) {
- os = output_files[i].ctx;
- if (avformat_write_header(os, &output_files[i].opts) < 0) {
+ oc = output_files[i].ctx;
+ oc->interrupt_callback = int_cb;
+ if (avformat_write_header(oc, &output_files[i].opts) < 0) {
snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
ret = AVERROR(EINVAL);
goto dump_format;
}
// assert_avoptions(output_files[i].opts);
- if (strcmp(os->oformat->name, "rtp")) {
+ if (strcmp(oc->oformat->name, "rtp")) {
want_sdp = 0;
}
}
dump_format:
/* dump the file output parameters - cannot be done before in case
of stream copy */
- for(i=0;i<nb_output_files;i++) {
+ for (i = 0; i < nb_output_files; i++) {
av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
}
if (!using_stdin) {
av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
- avio_set_interrupt_cb(decode_interrupt_cb);
}
timer_start = av_gettime();
}
//fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
- if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
+ if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
ist->file_index, ist->st->index);
for (i = 0; i < nb_input_streams; i++) {
ist = &input_streams[i];
if (ist->decoding_needed) {
- output_packet(ist, i, output_streams, nb_output_streams, NULL);
+ output_packet(ist, output_streams, nb_output_streams, NULL);
}
}
flush_encoders(output_streams, nb_output_streams);
ist->st = st;
ist->file_index = nb_input_files;
ist->discard = 1;
- ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
+ ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
ist->ts_scale = 1.0;
MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
st->discard= video_discard;
break;
case AVMEDIA_TYPE_DATA:
+ if (o->data_disable)
+ st->discard= AVDISCARD_ALL;
break;
case AVMEDIA_TYPE_SUBTITLE:
if(!ist->dec)
static void assert_file_overwrite(const char *filename)
{
- if (!file_overwrite &&
+ if ((!file_overwrite || no_file_overwrite) &&
(strchr(filename, ':') == NULL || filename[1] == ':' ||
av_strstart(filename, "file:", NULL))) {
if (avio_check(filename, 0) == 0) {
- if (!using_stdin) {
+ if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
fflush(stderr);
term_exit();
assert_file_overwrite(filename);
- if ((ret = avio_open (&out, filename, AVIO_FLAG_WRITE)) < 0) {
+ if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
filename);
exit_program(1);
ic->subtitle_codec_id= subtitle_codec_name ?
find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
ic->flags |= AVFMT_FLAG_NONBLOCK;
+ ic->interrupt_callback = int_cb;
if (loop_input) {
- av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
+ av_log(NULL, AV_LOG_WARNING,
+ "-loop_input is deprecated, use -loop 1\n"
+ "Note, both loop options only work with -f image2\n"
+ );
ic->loop_input = loop_input;
}
- /* open the input file with generic libav function */
+ /* open the input file with generic avformat function */
err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
if (err < 0) {
print_error(filename, err);
ret = avformat_find_stream_info(ic, opts);
if (ret < 0) {
av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
- av_close_input_file(ic);
+ avformat_close_input(&ic);
exit_program(1);
}
if (codec_name) {
snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
i != 1 ? "" : "/.avconv", codec_name, preset_name);
- ret = avio_open(s, filename, AVIO_FLAG_READ);
+ ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
}
if (ret) {
snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
i != 1 ? "" : "/.avconv", preset_name);
- ret = avio_open(s, filename, AVIO_FLAG_READ);
+ ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
}
}
return ret;
st->codec->codec_type = type;
choose_encoder(o, oc, ost);
if (ost->enc) {
- ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
+ ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
}
avcodec_get_context_defaults3(st->codec, ost->enc);
static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
{
int i, err;
- AVFormatContext *ic = NULL;
+ AVFormatContext *ic = avformat_alloc_context();
+ ic->interrupt_callback = int_cb;
err = avformat_open_input(&ic, filename, NULL, NULL);
if (err < 0)
return err;
ost = new_output_stream(o, s, codec->type);
st = ost->st;
avctx = st->codec;
+ ost->enc = codec;
// FIXME: a more elegant solution is needed
memcpy(st, ic->streams[i], sizeof(AVStream));
exit_program(1);
}
file_oformat= oc->oformat;
+ oc->interrupt_callback = int_cb;
if (!strcmp(file_oformat->name, "ffm") &&
av_strstart(filename, "http:", NULL)) {
break;
}
}
+ if(!ost->sync_ist){
+ av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
+ exit_program(1);
+ }
}
} else if (!o->nb_stream_maps) {
/* pick the "best" stream of each type */
continue;
if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
continue;
+ if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
+ continue;
switch (ist->st->codec->codec_type) {
case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
const char *p;
int64_t len;
- if ((err = avio_open(&pb, o->attachments[i], AVIO_FLAG_READ)) < 0) {
+ if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
o->attachments[i]);
exit_program(1);
}
if (!(oc->oformat->flags & AVFMT_NOFILE)) {
- /* test if it already exists to avoid loosing precious files */
+ /* test if it already exists to avoid losing precious files */
assert_file_overwrite(filename);
/* open the file */
- if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
+ if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
+ &oc->interrupt_callback,
+ &output_files[nb_output_files - 1].opts)) < 0) {
print_error(filename, err);
exit_program(1);
}
parse_option(o, "r", frame_rates[norm], options);
opt_default("g", norm == PAL ? "15" : "18");
- opt_default("b", "1150000");
+ opt_default("b:v", "1150000");
opt_default("maxrate", "1150000");
opt_default("minrate", "1150000");
opt_default("bufsize", "327680"); // 40*1024*8;
parse_option(o, "pix_fmt", "yuv420p", options);
opt_default("g", norm == PAL ? "15" : "18");
- opt_default("b", "2040000");
+ opt_default("b:v", "2040000");
opt_default("maxrate", "2516000");
opt_default("minrate", "0"); //1145000;
opt_default("bufsize", "1835008"); //224*1024*8;
parse_option(o, "pix_fmt", "yuv420p", options);
opt_default("g", norm == PAL ? "15" : "18");
- opt_default("b", "6000000");
+ opt_default("b:v", "6000000");
opt_default("maxrate", "9000000");
opt_default("minrate", "0"); //1500000;
opt_default("bufsize", "1835008"); //224*1024*8;
{ "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
{ "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
{ "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
+ { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
{ "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
{ "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
{ "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
- { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
+ { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
{ "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
{ "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
"outfile[,metadata]:infile[,metadata]" },
{ "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
{ "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
{ "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
- { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
+ { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
{ "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
{ "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
{ "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
{ "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
/* data codec support */
{ "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
+ { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
{ "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
{ NULL, },
av_register_all();
avformat_network_init();
-#if HAVE_ISATTY
- if(isatty(STDIN_FILENO))
- avio_set_interrupt_cb(decode_interrupt_cb);
-#endif
-
show_banner();
term_init();
projects / ffmpeg / blobdiff