#include <errno.h>
#include <signal.h>
#include <limits.h>
+#if HAVE_ISATTY
#include <unistd.h>
+#endif
#include "libavformat/avformat.h"
#include "libavdevice/avdevice.h"
#include "libswscale/swscale.h"
#include "libavutil/imgutils.h"
#include "libavutil/timestamp.h"
#include "libavutil/bprint.h"
+#include "libavutil/time.h"
#include "libavformat/os_support.h"
#include "libavformat/ffm.h" // not public API
#if HAVE_SYS_RESOURCE_H
#include <sys/types.h>
-#include <sys/time.h>
#include <sys/resource.h>
#elif HAVE_GETPROCESSTIMES
#include <windows.h>
#include <conio.h>
#endif
-#if HAVE_THREADS
#if HAVE_PTHREADS
#include <pthread.h>
-#else
-//#include "libavcodec/w32pthreads.h"
-#undef HAVE_THREADS
-#define HAVE_THREADS 0
-#endif
#endif
#include <time.h>
#define VSYNC_VFR 2
#define VSYNC_DROP 0xff
-#define SINKA
-
const char program_name[] = "ffmpeg";
const int program_birth_year = 2000;
static volatile int received_nb_signals = 0;
static int64_t video_size = 0;
static int64_t audio_size = 0;
+static int64_t subtitle_size = 0;
static int64_t extra_size = 0;
static int nb_frames_dup = 0;
static int nb_frames_drop = 0;
static int debug_ts = 0;
static int current_time;
-#if HAVE_THREADS
+#if HAVE_PTHREADS
/* signal to input threads that they should exit; set by the main thread */
static int transcoding_finished;
#endif
AVFormatContext *ctx;
int eof_reached; /* true if eof reached */
int ist_index; /* index of first stream in input_streams */
- int buffer_size; /* current total buffer size */
int64_t ts_offset;
int nb_streams; /* number of stream that ffmpeg is aware of; may be different
from ctx.nb_streams if new streams appear during av_read_frame() */
int rate_emu;
-#if HAVE_THREADS
+#if HAVE_PTHREADS
pthread_t thread; /* thread reading from this file */
int finished; /* the thread has exited */
int joined; /* the thread has been joined */
int64_t *forced_kf_pts;
int forced_kf_count;
int forced_kf_index;
+ char *forced_keyframes;
/* audio only */
int audio_channels_map[SWR_CH_MAX]; /* list of the channels id to pick from the source stream */
static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
{
InputStream *ist = NULL;
- enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
+ enum AVMediaType type = avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx);
int i;
// TODO: support other filter types
exit_program(1);
}
}
+ av_assert0(ist);
+
ist->discard = 0;
ist->decoding_needed = 1;
ist->st->discard = AVDISCARD_NONE;
AVFilterContext *last_filter = out->filter_ctx;
int pad_idx = out->pad_idx;
int ret;
+ char name[255];
AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
-#if FF_API_OLD_VSINK_API
+ snprintf(name, sizeof(name), "output stream %d:%d", ost->file_index, ost->index);
ret = avfilter_graph_create_filter(&ofilter->filter,
avfilter_get_by_name("buffersink"),
- "ffmpeg_buffersink", NULL, NULL, fg->graph);
-#else
- ret = avfilter_graph_create_filter(&ofilter->filter,
- avfilter_get_by_name("buffersink"),
- "ffmpeg_buffersink", NULL, buffersink_params, fg->graph);
-#endif
+ name, NULL, NULL/*buffersink_params*/, fg->graph);
av_freep(&buffersink_params);
if (ret < 0)
codec->width,
codec->height,
(unsigned)ost->sws_flags);
+ snprintf(name, sizeof(name), "scaler for output stream %d:%d",
+ ost->file_index, ost->index);
if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
- NULL, args, NULL, fg->graph)) < 0)
+ name, args, NULL, fg->graph)) < 0)
return ret;
if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
return ret;
if ((pix_fmts = choose_pix_fmts(ost))) {
AVFilterContext *filter;
+ snprintf(name, sizeof(name), "pixel format for output stream %d:%d",
+ ost->file_index, ost->index);
if ((ret = avfilter_graph_create_filter(&filter,
avfilter_get_by_name("format"),
"format", pix_fmts, NULL,
snprintf(args, sizeof(args), "fps=%d/%d", ost->frame_rate.num,
ost->frame_rate.den);
+ snprintf(name, sizeof(name), "fps for output stream %d:%d",
+ ost->file_index, ost->index);
ret = avfilter_graph_create_filter(&fps, avfilter_get_by_name("fps"),
- "fps", args, NULL, fg->graph);
+ name, args, NULL, fg->graph);
if (ret < 0)
return ret;
AVFilterContext *last_filter = out->filter_ctx;
int pad_idx = out->pad_idx;
char *sample_fmts, *sample_rates, *channel_layouts;
+ char name[255];
int ret;
+
+ snprintf(name, sizeof(name), "output stream %d:%d", ost->file_index, ost->index);
ret = avfilter_graph_create_filter(&ofilter->filter,
avfilter_get_by_name("abuffersink_old"),
- "ffmpeg_abuffersink_old", NULL, NULL, fg->graph);
+ name, NULL, NULL, fg->graph);
if (ret < 0)
return ret;
av_freep(&sample_rates);
av_freep(&channel_layouts);
+ snprintf(name, sizeof(name), "audio format for output stream %d:%d",
+ ost->file_index, ost->index);
ret = avfilter_graph_create_filter(&format,
avfilter_get_by_name("aformat"),
- "aformat", args, NULL, fg->graph);
+ name, args, NULL, fg->graph);
if (ret < 0)
return ret;
pad_idx = 0;
}
- if (audio_sync_method > 0 && 0) {
- char args[256] = {0};
-
- av_strlcatf(args, sizeof(args), "min_comp=0.001:min_hard_comp=%f", audio_drift_threshold);
- if (audio_sync_method > 1)
- av_strlcatf(args, sizeof(args), ":max_soft_comp=%d", -audio_sync_method);
- AUTO_INSERT_FILTER("-async", "aresample", args);
- }
-
if (audio_volume != 256 && 0) {
char args[256];
\
avio_printf(pb, "%s", ctx->filter->name); \
if (nb_pads > 1) \
- avio_printf(pb, ":%s", pads[inout->pad_idx].name); \
+ avio_printf(pb, ":%s", avfilter_pad_get_name(pads, inout->pad_idx));\
avio_w8(pb, 0); \
avio_close_dyn_buf(pb, &f->name); \
}
av_freep(&ofilter->name);
DESCRIBE_FILTER_LINK(ofilter, out, 0);
- switch (out->filter_ctx->output_pads[out->pad_idx].type) {
+ switch (avfilter_pad_get_type(out->filter_ctx->output_pads, out->pad_idx)) {
case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, ofilter, out);
case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, ofilter, out);
default: av_assert0(0);
ist->st->r_frame_rate;
AVRational sar;
AVBPrint args;
+ char name[255];
int pad_idx = in->pad_idx;
int ret;
SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
if (fr.num && fr.den)
av_bprintf(&args, ":frame_rate=%d/%d", fr.num, fr.den);
+ snprintf(name, sizeof(name), "graph %d input from stream %d:%d", fg->index,
+ ist->file_index, ist->st->index);
- if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter, in->name,
+ if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter, name,
args.str, NULL, fg->graph)) < 0)
return ret;
if (ist->framerate.num) {
AVFilterContext *setpts;
+ snprintf(name, sizeof(name), "force CFR for input from stream %d:%d",
+ ist->file_index, ist->st->index);
if ((ret = avfilter_graph_create_filter(&setpts,
avfilter_get_by_name("setpts"),
- "setpts", "N", NULL,
+ name, "N", NULL,
fg->graph)) < 0)
return ret;
AVFilter *filter = avfilter_get_by_name("abuffer");
InputStream *ist = ifilter->ist;
int pad_idx = in->pad_idx;
- char args[255];
+ char args[255], name[255];
int ret;
snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s"
ist->st->codec->sample_rate,
av_get_sample_fmt_name(ist->st->codec->sample_fmt),
ist->st->codec->channel_layout);
+ snprintf(name, sizeof(name), "graph %d input from stream %d:%d", fg->index,
+ ist->file_index, ist->st->index);
if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter,
- in->name, args, NULL,
+ name, args, NULL,
fg->graph)) < 0)
return ret;
av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
"similarly to -af " filter_name "=%s.\n", arg); \
\
+ snprintf(name, sizeof(name), "graph %d %s for input stream %d:%d", \
+ fg->index, filter_name, ist->file_index, ist->st->index); \
ret = avfilter_graph_create_filter(&filt_ctx, \
avfilter_get_by_name(filter_name), \
- filter_name, arg, NULL, fg->graph); \
+ name, arg, NULL, fg->graph); \
if (ret < 0) \
return ret; \
\
av_freep(&ifilter->name);
DESCRIBE_FILTER_LINK(ifilter, in, 1);
- switch (in->filter_ctx->input_pads[in->pad_idx].type) {
+ switch (avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx)) {
case AVMEDIA_TYPE_VIDEO: return configure_input_video_filter(fg, ifilter, in);
case AVMEDIA_TYPE_AUDIO: return configure_input_audio_filter(fg, ifilter, in);
default: av_assert0(0);
}
output_streams[i]->bitstream_filters = NULL;
+ av_freep(&output_streams[i]->forced_keyframes);
av_freep(&output_streams[i]->filtered_frame);
av_freep(&output_streams[i]->avfilter);
av_freep(&output_streams[i]);
pkt.pts += 90 * sub->end_display_time;
}
write_frame(s, &pkt, ost);
+ subtitle_size += pkt.size;
}
}
!(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
ret = av_buffersink_read_samples(ost->filter->filter, &picref,
ost->st->codec->frame_size);
- else
-#ifdef SINKA
+ else if(ost->enc->type == AVMEDIA_TYPE_AUDIO)
ret = av_buffersink_read(ost->filter->filter, &picref);
-#else
+ else
ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
AV_BUFFERSINK_FLAG_NO_REQUEST);
-#endif
if (ret < 0) {
if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
char buf[256];
switch (ost->filter->filter->inputs[0]->type) {
case AVMEDIA_TYPE_VIDEO:
- avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);
+ avfilter_copy_buf_props(filtered_frame, picref);
filtered_frame->pts = frame_pts;
if (!ost->frame_aspect_ratio)
ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
fflush(stderr);
if (is_last_report) {
- int64_t raw= audio_size + video_size + extra_size;
+ int64_t raw= audio_size + video_size + subtitle_size + extra_size;
av_log(NULL, AV_LOG_INFO, "\n");
- av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
+ av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0f global headers:%1.0fkB muxing overhead %f%%\n",
video_size / 1024.0,
audio_size / 1024.0,
+ subtitle_size / 1024.0,
extra_size / 1024.0,
100.0 * (total_size - raw) / raw
);
- if(video_size + audio_size + extra_size == 0){
+ if(video_size + audio_size + subtitle_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");
}
}
else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
video_size += pkt->size;
ost->sync_opts++;
+ } else if (ost->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
+ subtitle_size += pkt->size;
}
if (pkt->pts != AV_NOPTS_VALUE)
int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
int64_t now = av_gettime() - ist->start;
if (pts > now)
- usleep(pts - now);
+ av_usleep(pts - now);
}
}
return NULL;
}
+static void parse_forced_key_frames(char *kf, OutputStream *ost,
+ AVCodecContext *avctx)
+{
+ char *p;
+ int n = 1, i;
+ int64_t t;
+
+ for (p = kf; *p; p++)
+ if (*p == ',')
+ n++;
+ ost->forced_kf_count = n;
+ ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
+ if (!ost->forced_kf_pts) {
+ av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
+ exit_program(1);
+ }
+ for (i = 0; i < n; i++) {
+ p = i ? strchr(p, ',') + 1 : kf;
+ t = parse_time_or_die("force_key_frames", p, 1);
+ ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
+ }
+}
+
static int transcode_init(void)
{
int ret = 0, i, j, k;
codec->bits_per_raw_sample = frame_bits_per_raw_sample;
}
+ if (ost->forced_keyframes)
+ parse_forced_key_frames(ost->forced_keyframes, ost,
+ ost->st->codec);
break;
case AVMEDIA_TYPE_SUBTITLE:
codec->time_base = (AVRational){1, 1000};
return 0;
}
-#if HAVE_THREADS
+#if HAVE_PTHREADS
static void *input_thread(void *arg)
{
InputFile *f = arg;
ret = av_read_frame(f->ctx, &pkt);
if (ret == AVERROR(EAGAIN)) {
- usleep(10000);
+ av_usleep(10000);
ret = 0;
continue;
} else if (ret < 0)
InputFile *f = input_files[i];
AVPacket pkt;
- if (f->joined)
+ if (!f->fifo || f->joined)
continue;
pthread_mutex_lock(&f->fifo_lock);
static int get_input_packet(InputFile *f, AVPacket *pkt)
{
-#if HAVE_THREADS
+#if HAVE_PTHREADS
if (nb_input_files > 1)
return get_input_packet_mt(f, pkt);
#endif
timer_start = av_gettime();
-#if HAVE_THREADS
+#if HAVE_PTHREADS
if ((ret = init_input_threads()) < 0)
goto fail;
#endif
if (no_packet_count) {
no_packet_count = 0;
memset(no_packet, 0, nb_input_files);
- usleep(10000);
+ av_usleep(10000);
continue;
}
av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
/* dump report by using the output first video and audio streams */
print_report(0, timer_start, cur_time);
}
-#if HAVE_THREADS
+#if HAVE_PTHREADS
free_input_threads();
#endif
fail:
av_freep(&no_packet);
-#if HAVE_THREADS
+#if HAVE_PTHREADS
free_input_threads();
#endif
METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
meta = &context->programs[index]->metadata;\
break;\
+ default: av_assert0(0);\
}\
SET_DICT(type_in, meta_in, ic, idx_in);
return 0;
}
-static void parse_forced_key_frames(char *kf, OutputStream *ost)
-{
- char *p;
- int n = 1, i;
-
- for (p = kf; *p; p++)
- if (*p == ',')
- n++;
- ost->forced_kf_count = n;
- ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
- if (!ost->forced_kf_pts) {
- 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++) {
- char *next = strchr(p, ',');
- if (next) *next++ = 0;
- ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
- p = next;
- }
-}
-
static uint8_t *get_line(AVIOContext *s)
{
AVIOContext *line;
if (!ost->stream_copy) {
const char *p = NULL;
- char *forced_key_frames = NULL, *frame_size = NULL;
+ char *frame_size = NULL;
char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
char *intra_matrix = NULL, *inter_matrix = NULL;
const char *filters = "null";
}
}
- MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
- if (forced_key_frames)
- parse_forced_key_frames(forced_key_frames, ost);
+ MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
+ if (ost->forced_keyframes)
+ ost->forced_keyframes = av_strdup(ost->forced_keyframes);
MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
{
OutputStream *ost;
- switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
+ switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
+ ofilter->out_tmp->pad_idx)) {
case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
default:
if (!ofilter->out_tmp || ofilter->out_tmp->name)
continue;
- switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
+ switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
+ ofilter->out_tmp->pad_idx)) {
case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
AV_DICT_DONT_OVERWRITE);
if(o->recording_time != INT64_MAX)
av_dict_set(&oc->metadata, "duration", NULL, 0);
+ av_dict_set(&oc->metadata, "creation_time", NULL, 0);
}
if (!o->metadata_streams_manual)
for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
} else if (ret < 0)
exit_program(1);
}
- printf("ret %d, stream_spec %s\n", ret, stream_spec);
}
else {
switch (type) {
show_help_children(avcodec_get_class(), flags);
show_help_children(avformat_get_class(), flags);
show_help_children(sws_get_class(), flags);
+ show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
return 0;
}
projects / ffmpeg / blobdiff