#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
#include "libavutil/opt.h"
-#include "libavcodec/audioconvert.h"
#include "libavutil/audioconvert.h"
#include "libavutil/parseutils.h"
#include "libavutil/samplefmt.h"
# include "libavfilter/avfiltergraph.h"
# include "libavfilter/buffersink.h"
# include "libavfilter/buffersrc.h"
-# include "libavfilter/vsrc_buffer.h"
#if HAVE_SYS_RESOURCE_H
#include <sys/types.h>
int64_t pts; ///< current pts of the decoded frame
double ts_scale;
int is_start; /* is 1 at the start and after a discontinuity */
+ int saw_first_ts;
int showed_multi_packet_warning;
AVDictionary *opts;
int audio_channels_mapped; ///< number of channels in audio_channels_map
int resample_sample_fmt;
int resample_channels;
+ uint64_t resample_channel_layout;
int resample_sample_rate;
float rematrix_volume;
AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
int copy_initial_nonkeyframes;
enum PixelFormat pix_fmts[2];
+ int keep_pix_fmt;
} OutputStream;
if (!buf)
return AVERROR(ENOMEM);
+ avcodec_align_dimensions(s, &w, &h);
+
if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
w += 2*edge;
h += 2*edge;
}
- avcodec_align_dimensions(s, &w, &h);
if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
s->pix_fmt, 32)) < 0) {
av_freep(&buf);
for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
const int h_shift = i==0 ? 0 : h_chroma_shift;
const int v_shift = i==0 ? 0 : v_chroma_shift;
- if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1])
+ if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1] || !buf->base[i])
buf->data[i] = buf->base[i];
else
buf->data[i] = buf->base[i] +
return target;
}
-static const enum PixelFormat *choose_pixel_fmts(OutputStream *ost)
+static char *choose_pixel_fmts(OutputStream *ost)
{
- if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
- ost->pix_fmts[0] = choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt);
+ if (ost->keep_pix_fmt) {
+ if (ost->filter)
+ avfilter_graph_set_auto_convert(ost->filter->graph->graph,
+ AVFILTER_AUTO_CONVERT_NONE);
+ if (ost->st->codec->pix_fmt == PIX_FMT_NONE)
+ return NULL;
+ ost->pix_fmts[0] = ost->st->codec->pix_fmt;
return ost->pix_fmts;
+ }
+ if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
+ return av_strdup(av_get_pix_fmt_name(choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt)));
} else if (ost->enc->pix_fmts) {
+ const enum PixelFormat *p;
+ AVIOContext *s = NULL;
+ uint8_t *ret;
+ int len;
+
+ if (avio_open_dyn_buf(&s) < 0)
+ exit_program(1);
+
+ p = ost->enc->pix_fmts;
if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
if (ost->st->codec->codec_id == CODEC_ID_MJPEG) {
- return (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_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
} else if (ost->st->codec->codec_id == CODEC_ID_LJPEG) {
- return (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
+ 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 };
}
}
- return ost->enc->pix_fmts;
+
+ for (; *p != PIX_FMT_NONE; p++)
+ avio_printf(s, "%s:", av_get_pix_fmt_name(*p));
+ len = avio_close_dyn_buf(s, &ret);
+ ret[len - 1] = 0;
+ return ret;
} else
return NULL;
}
{
InputStream *ist = fg->inputs[0]->ist;
OutputStream *ost = fg->outputs[0]->ost;
- AVFilterContext *last_filter, *filter;
- /** filter graph containing all filters including input & output */
+ AVFilterContext *in_filter, *out_filter, *filter;
AVCodecContext *codec = ost->st->codec;
- enum PixelFormat *pix_fmts = choose_pixel_fmts(ost);
AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
+ char *pix_fmts;
AVRational sample_aspect_ratio;
char args[255];
int ret;
return ret;
#if FF_API_OLD_VSINK_API
- ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),
- "out", NULL, pix_fmts, fg->graph);
+ ret = avfilter_graph_create_filter(&fg->outputs[0]->filter,
+ avfilter_get_by_name("buffersink"),
+ "out", NULL, NULL, fg->graph);
#else
- buffersink_params->pixel_fmts = pix_fmts;
- ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),
+ ret = avfilter_graph_create_filter(&fg->outputs[0]->filter,
+ avfilter_get_by_name("buffersink"),
"out", NULL, buffersink_params, fg->graph);
#endif
av_freep(&buffersink_params);
if (ret < 0)
return ret;
- last_filter = fg->inputs[0]->filter;
+ in_filter = fg->inputs[0]->filter;
+ out_filter = fg->outputs[0]->filter;
if (codec->width || codec->height) {
snprintf(args, 255, "%d:%d:flags=0x%X",
if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
NULL, args, NULL, fg->graph)) < 0)
return ret;
- if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
+ if ((ret = avfilter_link(in_filter, 0, filter, 0)) < 0)
return ret;
- last_filter = filter;
+ in_filter = filter;
+ }
+
+ if ((pix_fmts = choose_pixel_fmts(ost))) {
+ if ((ret = avfilter_graph_create_filter(&filter,
+ avfilter_get_by_name("format"),
+ "format", pix_fmts, NULL,
+ fg->graph)) < 0)
+ return ret;
+ if ((ret = avfilter_link(filter, 0, out_filter, 0)) < 0)
+ return ret;
+
+ out_filter = filter;
+ av_freep(&pix_fmts);
}
snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
AVFilterInOut *inputs = avfilter_inout_alloc();
outputs->name = av_strdup("in");
- outputs->filter_ctx = last_filter;
+ outputs->filter_ctx = in_filter;
outputs->pad_idx = 0;
outputs->next = NULL;
inputs->name = av_strdup("out");
- inputs->filter_ctx = fg->outputs[0]->filter;
+ inputs->filter_ctx = out_filter;
inputs->pad_idx = 0;
inputs->next = NULL;
return ret;
av_freep(&ost->avfilter);
} else {
- if ((ret = avfilter_link(last_filter, 0, fg->outputs[0]->filter, 0)) < 0)
+ if ((ret = avfilter_link(in_filter, 0, out_filter, 0)) < 0)
return ret;
}
+ if (ost->keep_pix_fmt)
+ avfilter_graph_set_auto_convert(fg->graph,
+ AVFILTER_AUTO_CONVERT_NONE);
+
if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
return ret;
static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
{
- InputStream *ist;
+ InputStream *ist = NULL;
enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
int i;
static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
{
+ char *pix_fmts;
AVCodecContext *codec = ofilter->ost->st->codec;
AVFilterContext *last_filter = out->filter_ctx;
int pad_idx = out->pad_idx;
int ret;
- enum PixelFormat *pix_fmts = choose_pixel_fmts(ofilter->ost);
AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
#if FF_API_OLD_VSINK_API
- ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),
- "out", NULL, pix_fmts, fg->graph);
+ ret = avfilter_graph_create_filter(&ofilter->filter,
+ avfilter_get_by_name("buffersink"),
+ "out", NULL, NULL, fg->graph);
#else
- buffersink_params->pixel_fmts = pix_fmts;
- ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),
+ ret = avfilter_graph_create_filter(&ofilter->filter,
+ avfilter_get_by_name("buffersink"),
"out", NULL, buffersink_params, fg->graph);
#endif
av_freep(&buffersink_params);
if (codec->width || codec->height) {
char args[255];
+ AVFilterContext *filter;
+
snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
codec->width,
codec->height,
(unsigned)ofilter->ost->sws_flags);
- if ((ret = avfilter_graph_create_filter(&last_filter, avfilter_get_by_name("scale"),
+ if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
NULL, args, NULL, fg->graph)) < 0)
return ret;
- if ((ret = avfilter_link(out->filter_ctx, out->pad_idx, last_filter, 0)) < 0)
+ if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
return ret;
+
+ last_filter = filter;
pad_idx = 0;
}
+ if ((pix_fmts = choose_pixel_fmts(ofilter->ost))) {
+ AVFilterContext *filter;
+ if ((ret = avfilter_graph_create_filter(&filter,
+ avfilter_get_by_name("format"),
+ "format", pix_fmts, NULL,
+ fg->graph)) < 0)
+ return ret;
+ if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
+ return ret;
+
+ last_filter = filter;
+ pad_idx = 0;
+ av_freep(&pix_fmts);
+ }
+
if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
return ret;
{
#if HAVE_TERMIOS_H
if(!run_as_daemon){
- struct termios tty;
+ struct termios tty;
- if (tcgetattr (0, &tty) == 0) {
- oldtty = tty;
- restore_tty = 1;
- atexit(term_exit);
+ if (tcgetattr (0, &tty) == 0) {
+ oldtty = tty;
+ restore_tty = 1;
+ atexit(term_exit);
- tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
- |INLCR|IGNCR|ICRNL|IXON);
- tty.c_oflag |= OPOST;
- tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
- tty.c_cflag &= ~(CSIZE|PARENB);
- tty.c_cflag |= CS8;
- tty.c_cc[VMIN] = 1;
- tty.c_cc[VTIME] = 0;
+ tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
+ |INLCR|IGNCR|ICRNL|IXON);
+ tty.c_oflag |= OPOST;
+ tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
+ tty.c_cflag &= ~(CSIZE|PARENB);
+ tty.c_cflag |= CS8;
+ tty.c_cc[VMIN] = 1;
+ tty.c_cc[VTIME] = 0;
- tcsetattr (0, TCSANOW, &tty);
- }
- signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
+ tcsetattr (0, TCSANOW, &tty);
+ }
+ signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
}
#endif
avformat_network_deinit();
}
static int alloc_audio_output_buf(AVCodecContext *dec, AVCodecContext *enc,
- int nb_samples)
+ int nb_samples, int *buf_linesize)
{
int64_t audio_buf_samples;
int audio_buf_size;
if (audio_buf_samples > INT_MAX)
return AVERROR(EINVAL);
- audio_buf_size = av_samples_get_buffer_size(NULL, enc->channels,
+ audio_buf_size = av_samples_get_buffer_size(buf_linesize, enc->channels,
audio_buf_samples,
enc->sample_fmt, 0);
if (audio_buf_size < 0)
int size = decoded_frame->nb_samples * dec->channels * isize;
int planes = av_sample_fmt_is_planar(dec->sample_fmt) ? dec->channels : 1;
int i;
+ int out_linesize = 0;
av_assert0(planes <= AV_NUM_DATA_POINTERS);
for(i=0; i<planes; i++)
buf[i]= decoded_frame->data[i];
+
get_default_channel_layouts(ost, ist);
- if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples) < 0) {
+ if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples, &out_linesize) < 0) {
av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
exit_program(1);
}
- if (enc->channels != dec->channels
- || enc->sample_fmt != dec->sample_fmt
- || enc->sample_rate!= dec->sample_rate
- )
+ if (audio_sync_method > 1 ||
+ enc->channels != dec->channels ||
+ enc->channel_layout != dec->channel_layout ||
+ enc->sample_rate != dec->sample_rate ||
+ dec->sample_fmt != enc->sample_fmt)
ost->audio_resample = 1;
resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
ost->resample_channels != dec->channels ||
+ ost->resample_channel_layout != dec->channel_layout ||
ost->resample_sample_rate != dec->sample_rate;
if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
+
if (resample_changed) {
- av_log(NULL, AV_LOG_INFO, "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
+ av_log(NULL, AV_LOG_INFO, "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:0x%"PRIx64" to rate:%d fmt:%s ch:%d chl:0x%"PRIx64"\n",
ist->file_index, ist->st->index,
- ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
- dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
+ ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt),
+ ost->resample_channels, ost->resample_channel_layout,
+ dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt),
+ dec->channels, dec->channel_layout);
ost->resample_sample_fmt = dec->sample_fmt;
ost->resample_channels = dec->channels;
+ ost->resample_channel_layout = dec->channel_layout;
ost->resample_sample_rate = dec->sample_rate;
swr_free(&ost->swr);
}
if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
ost->resample_sample_fmt == enc->sample_fmt &&
ost->resample_channels == enc->channels &&
+ ost->resample_channel_layout == enc->channel_layout &&
ost->resample_sample_rate == enc->sample_rate) {
//ost->swr = NULL;
ost->audio_resample = 0;
dec->channel_layout, dec->sample_fmt, dec->sample_rate,
0, NULL);
av_opt_set_int(ost->swr, "dither_method", ost->swr_dither_method,0);
- av_opt_set_int(ost->swr, "dither_scale", ost->swr_dither_scale,0);
+ av_opt_set_double(ost->swr, "dither_scale", ost->swr_dither_scale,0);
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);
exit_program(1);
}
- if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples + idelta) < 0) {
+ if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples + idelta, &out_linesize) < 0) {
av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
exit_program(1);
}
}
} else if (audio_sync_method > 1) {
int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
- av_assert0(ost->audio_resample);
av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
delta, comp, enc->sample_rate);
// fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
if (ost->audio_resample || ost->audio_channels_mapped) {
buftmp = audio_buf;
- size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, allocated_audio_buf_size / (enc->channels * osize),
- buf, size / (dec->channels * isize));
+ size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp},
+ allocated_audio_buf_size / (enc->channels * osize),
+ (const uint8_t **)buf,
+ size / (dec->channels * isize));
if (size_out < 0) {
av_log(NULL, AV_LOG_FATAL, "swr_convert failed\n");
exit_program(1);
enc = ost->st->codec;
- if (ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
- duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
- if(ist->st->r_frame_rate.num)
- duration= FFMAX(duration, 1/av_q2d(ist->st->r_frame_rate));
- if(ist->st->avg_frame_rate.num && 0)
- duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
-
- duration /= av_q2d(enc->time_base);
- }
+ if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
+ duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));
sync_ipts = get_sync_ipts(ost, in_picture->pts) / av_q2d(enc->time_base);
delta = sync_ipts - ost->sync_opts + duration;
if (delta <= -0.6)
nb_frames = 0;
else if (delta > 0.6)
- ost->sync_opts = lrintf(sync_ipts);
+ ost->sync_opts = lrint(sync_ipts);
break;
case VSYNC_DROP:
case VSYNC_PASSTHROUGH:
- ost->sync_opts = lrintf(sync_ipts);
+ ost->sync_opts = lrint(sync_ipts);
break;
default:
av_assert0(0);
AVFrame *filtered_frame = NULL;
int i, ret, ret_all;
unsigned nb_success, nb_eof;
+ int64_t frame_pts;
while (1) {
/* Reap all buffers present in the buffer sinks */
- /* TODO reindent */
- for (i = 0; i < nb_output_streams; i++) {
- OutputStream *ost = output_streams[i];
- OutputFile *of = output_files[ost->file_index];
+ for (i = 0; i < nb_output_streams; i++) {
+ OutputStream *ost = output_streams[i];
+ OutputFile *of = output_files[ost->file_index];
- if (!ost->filter || ost->is_past_recording_time)
- continue;
+ if (!ost->filter || ost->is_past_recording_time)
+ continue;
- if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
- return AVERROR(ENOMEM);
- } else
- avcodec_get_frame_defaults(ost->filtered_frame);
- filtered_frame = ost->filtered_frame;
+ if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
+ return AVERROR(ENOMEM);
+ } else
+ avcodec_get_frame_defaults(ost->filtered_frame);
+ filtered_frame = ost->filtered_frame;
- while (1) {
- AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base;
- ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
- AV_BUFFERSINK_FLAG_NO_REQUEST);
- if (ret < 0) {
- if (ret != AVERROR(EAGAIN)) {
- char buf[256];
- av_strerror(ret, buf, sizeof(buf));
- av_log(NULL, AV_LOG_WARNING,
- "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
+ while (1) {
+ AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base;
+ ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
+ AV_BUFFERSINK_FLAG_NO_REQUEST);
+ if (ret < 0) {
+ if (ret != AVERROR(EAGAIN)) {
+ char buf[256];
+ av_strerror(ret, buf, sizeof(buf));
+ av_log(NULL, AV_LOG_WARNING,
+ "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
+ }
+ break;
+ }
+ filtered_frame->pts = frame_pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
+ //if (ost->source_index >= 0)
+ // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
+
+ if (of->start_time && filtered_frame->pts < of->start_time)
+ return 0;
+
+ switch (ost->filter->filter->inputs[0]->type) {
+ case AVMEDIA_TYPE_VIDEO:
+ avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);
+ filtered_frame->pts = frame_pts;
+ if (!ost->frame_aspect_ratio)
+ ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
+
+ do_video_out(of->ctx, ost, filtered_frame,
+ same_quant ? ost->last_quality :
+ ost->st->codec->global_quality);
+ break;
+ default:
+ // TODO support audio/subtitle filters
+ av_assert0(0);
}
- break;
- }
- filtered_frame->pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
-// if (ost->source_index >= 0)
-// *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
-
- if (of->start_time && filtered_frame->pts < of->start_time)
- return 0;
-
- switch (ost->filter->filter->inputs[0]->type) {
- case AVMEDIA_TYPE_VIDEO:
- avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);
- if (!ost->frame_aspect_ratio)
- ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
- do_video_out(of->ctx, ost, filtered_frame,
- same_quant ? ost->last_quality :
- ost->st->codec->global_quality);
- break;
- default:
- // TODO support audio/subtitle filters
- av_assert0(0);
+ avfilter_unref_buffer(picref);
}
-
- avfilter_unref_buffer(picref);
}
- }
/* Request frames through all the graphs */
ret_all = nb_success = nb_eof = 0;
for (i = 0; i < nb_filtergraphs; i++) {
av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
- /* pad last frame with silence if needed */
- if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
- frame_bytes = enc->frame_size * enc->channels *
- av_get_bytes_per_sample(enc->sample_fmt);
- if (allocated_audio_buf_size < frame_bytes)
- exit_program(1);
- generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
- }
encode_audio_frame(os, ost, audio_buf, frame_bytes);
} else {
/* flush encoder with NULL frames until it is done
AVFrame *decoded_frame;
void *buffer_to_free = NULL;
int i, ret = 0, resample_changed;
- int64_t *best_effort_timestamp;
+ int64_t best_effort_timestamp;
AVRational *frame_sample_aspect;
float quality;
/* no picture yet */
if (!pkt->size)
for (i = 0; i < ist->nb_filters; i++)
- av_buffersrc_buffer(ist->filters[i]->filter, NULL);
+ av_buffersrc_add_ref(ist->filters[i]->filter, NULL, 0);
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 = decoded_frame->pts = *best_effort_timestamp;
+ best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
+ if(best_effort_timestamp != AV_NOPTS_VALUE)
+ ist->next_pts = ist->pts = decoded_frame->pts = best_effort_timestamp;
pkt->size = 0;
av_assert0(buf->refcount>0);
buf->refcount++;
- av_buffersrc_buffer(ist->filters[i]->filter, fb);
+ av_buffersrc_add_ref(ist->filters[i]->filter, fb,
+ AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
+ AV_BUFFERSRC_FLAG_NO_COPY);
} else
- if(av_vsrc_buffer_add_frame(ist->filters[i]->filter, decoded_frame,AV_VSRC_BUF_FLAG_OVERWRITE)<0) {
+ if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0)<0) {
av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
exit_program(1);
}
int64_t pkt_pts = AV_NOPTS_VALUE;
AVPacket avpkt;
+ if (!ist->saw_first_ts) {
+ ist->dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
+ ist->pts = 0;
+ if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
+ ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
+ ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
+ }
+ ist->saw_first_ts = 1;
+ }
if (ist->next_dts == AV_NOPTS_VALUE)
ist->next_dts = ist->dts;
return AVERROR(EINVAL);
}
- ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
+ ist->dr1 = (codec->capabilities & CODEC_CAP_DR1) && !do_deinterlace;
if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
ist->st->codec->get_buffer = codec_get_buffer;
ist->st->codec->release_buffer = codec_release_buffer;
}
}
- ist->dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
ist->next_pts = AV_NOPTS_VALUE;
ist->next_dts = AV_NOPTS_VALUE;
ist->is_start = 1;
}
if (ost->stream_copy) {
- uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
+ uint64_t extra_size;
+
+ av_assert0(ist && !ost->filter);
+
+ extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
if (extra_size > INT_MAX) {
return AVERROR(EINVAL);
}
memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
codec->extradata_size= icodec->extradata_size;
+ codec->bits_per_coded_sample = icodec->bits_per_coded_sample;
codec->time_base = ist->st->time_base;
/*
codec->frame_size = icodec->frame_size;
codec->audio_service_type = icodec->audio_service_type;
codec->block_align = icodec->block_align;
+ if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
+ codec->block_align= 0;
+ if(codec->codec_id == CODEC_ID_AC3)
+ codec->block_align= 0;
break;
case AVMEDIA_TYPE_VIDEO:
codec->pix_fmt = icodec->pix_fmt;
if (!ost->fifo) {
return AVERROR(ENOMEM);
}
+
if (!codec->sample_rate)
codec->sample_rate = icodec->sample_rate;
choose_sample_rate(ost->st, ost->enc);
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;
+ ost->resample_channel_layout = icodec->channel_layout;
break;
case AVMEDIA_TYPE_VIDEO:
if (!ost->filter) {
if (debug_ts) {
av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
- "next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%"PRId64"\n",
+ "next_dts:%s next_dts_time:%s next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%"PRId64"\n",
ist_index, av_get_media_type_string(ist->st->codec->codec_type),
+ av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &ist->st->time_base),
av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
}
// fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
- if (output_packet(ist, &pkt) < 0 || poll_filters() < 0) {
+ if (output_packet(ist, &pkt) < 0 ||
+ ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
ist->file_index, ist->st->index);
if (exit_on_error)
av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
exit_program(1);
}
+ p = kf;
for (i = 0; i < n; i++) {
- p = i ? strchr(p, ',') + 1 : kf;
+ char *next = strchr(p, ',');
+ if (next) *next++ = 0;
ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
+ p = next;
}
}
video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
+ if (frame_pix_fmt && *frame_pix_fmt == '+') {
+ ost->keep_pix_fmt = 1;
+ if (!*++frame_pix_fmt)
+ frame_pix_fmt = NULL;
+ }
if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
exit_program(1);
ofilter->ost = ost;
+ if (ost->stream_copy) {
+ av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
+ "which is fed from a complex filtergraph. Filtering and streamcopy "
+ "cannot be used together.\n", ost->file_index, ost->index);
+ exit_program(1);
+ }
+
if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
exit_program(1);
static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
{
FILE *f=NULL;
- char filename[1000], tmp[1000], tmp2[1000], line[1000];
+ char filename[1000], line[1000], tmp_line[1000];
const char *codec_name = *opt == 'v' ? video_codec_name :
*opt == 'a' ? audio_codec_name :
subtitle_codec_name;
exit_program(1);
}
- while(!feof(f)){
- int e= fscanf(f, "%999[^\n]\n", line) - 1;
- if(line[0] == '#' && !e)
+ while (fgets(line, sizeof(line), f)) {
+ char *key = tmp_line, *value, *endptr;
+
+ if (strcspn(line, "#\n\r") == 0)
continue;
- e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
- if(e){
+ strcpy(tmp_line, line);
+ if (!av_strtok(key, "=", &value) ||
+ !av_strtok(value, "\r\n", &endptr)) {
av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
exit_program(1);
}
- if(!strcmp(tmp, "acodec")){
- opt_audio_codec(o, tmp, tmp2);
- }else if(!strcmp(tmp, "vcodec")){
- opt_video_codec(o, tmp, tmp2);
- }else if(!strcmp(tmp, "scodec")){
- opt_subtitle_codec(o, tmp, tmp2);
- }else if(!strcmp(tmp, "dcodec")){
- opt_data_codec(o, tmp, tmp2);
- }else if(opt_default(tmp, tmp2) < 0){
- av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
+ av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
+
+ if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
+ else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
+ else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
+ else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
+ else if (opt_default(key, value) < 0) {
+ av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
+ filename, line, key, value);
exit_program(1);
}
}