78 #define OFFSET(x) offsetof(MovieContext, x) 79 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_VIDEO_PARAM 86 {
"si",
"set stream index",
OFFSET(stream_index),
AV_OPT_TYPE_INT, { .i64 = -1 }, -1, INT_MAX, FLAGS },
87 {
"seek_point",
"set seekpoint (seconds)",
OFFSET(seek_point_d),
AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
88 {
"sp",
"set seekpoint (seconds)",
OFFSET(seek_point_d),
AV_OPT_TYPE_DOUBLE, { .dbl = 0 }, 0, (INT64_MAX-1) / 1000000, FLAGS },
101 int i,
ret, already = 0, stream_id = -1;
102 char type_char[2],
dummy;
106 ret = sscanf(spec,
"d%1[av]%d%c", type_char, &stream_id, &dummy);
107 if (ret >= 1 && ret <= 2) {
121 "Invalid stream specifier \"%s\"\n", spec);
132 "Ambiguous stream specifier \"%s\", using #%d\n", spec, i);
139 already ?
"matched only already used streams" :
140 "did not match any stream");
146 "currently unsupported by libavfilter\n", spec,
190 "Channel layout is not set in stream %d, and could not " 191 "be guessed from the number of channels (%d)\n",
198 "Channel layout is not set in output stream %d, " 199 "guessed channel layout is '%s'\n",
211 char default_streams[16], *stream_specs, *spec, *cursor;
223 snprintf(default_streams,
sizeof(default_streams),
"d%c%d",
224 !strcmp(ctx->
filter->
name,
"amovie") ?
'a' :
'v',
226 stream_specs = default_streams;
228 for (cursor = stream_specs; *cursor; cursor++)
232 if (movie->
loop_count != 1 && nb_streams != 1) {
234 "Loop with several streams is currently unsupported\n");
244 "Failed to avformat_open_input '%s'\n", movie->
file_name);
257 "%s: seek value overflow with start_time:%"PRId64
" seek_point:%"PRId64
"\n",
278 spec =
av_strtok(stream_specs,
"+", &cursor);
324 av_log(ctx,
AV_LOG_VERBOSE,
"seek_point:%"PRIi64
" format_name:%s file_name:%s stream_index:%d\n",
350 int list[] = { 0, -1 };
351 int64_t list64[] = { 0, -1 };
410 switch (frame_type) {
413 "video pts:%s time:%s size:%dx%d aspect:%d/%d",
421 "audio pts:%s time:%s samples:%d",
570 else if (
i == out_id)
579 }
else if (got_eof) {
595 char *res,
int res_len,
int flags)
600 if (!strcmp(cmd,
"seek")) {
605 if (sscanf(args,
"%i|%"SCNi64
"|%i %1s", &idx, &ts, &flags, tail) != 3)
616 }
else if (!strcmp(cmd,
"get_duration")) {
620 if (!res || res_len <= 0)
623 if (args && sscanf(args,
"%1s", tail) == 1)
627 if (print_len < 0 || print_len >= res_len)
636 #if CONFIG_MOVIE_FILTER 644 .priv_class = &movie_class,
657 #if CONFIG_AMOVIE_FILTER 659 #define amovie_options movie_options 672 .priv_class = &amovie_class,
static AVStream * find_stream(void *log, AVFormatContext *avf, const char *spec)
int64_t discontinuity_threshold
This structure describes decoded (raw) audio or video data.
static av_cold void movie_uninit(AVFilterContext *ctx)
#define AV_LOG_WARNING
Something somehow does not look correct.
Main libavfilter public API header.
static av_cold int init(AVCodecContext *avctx)
int h
agreed upon image height
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
int index
stream index in AVFormatContext
static const AVOption movie_options[]
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
enum AVMediaType type
AVFilterPad type.
#define FF_OUTLINK_IDX(link)
char * stream_specs
user-provided list of streams, separated by +
This struct describes the properties of an encoded stream.
Macro definitions for various function/variable attributes.
void * av_calloc(size_t nmemb, size_t size)
Non-inlined equivalent of av_mallocz_array().
const char * name
Pad name.
static int open_stream(AVFilterContext *ctx, MovieStream *st)
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
AVFilterPad * output_pads
array of output pads
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
static av_cold int uninit(AVCodecContext *avctx)
timestamp utils, mostly useful for debugging/logging purposes
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the stream st contained in s is matched by the stream specifier spec.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
AVStream ** streams
A list of all streams in the file.
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
#define AVERROR_EOF
End of file.
#define AV_LOG_VERBOSE
Detailed information.
#define AVFILTER_FLAG_DYNAMIC_OUTPUTS
The number of the filter outputs is not determined just by AVFilter.outputs.
uint64_t channel_layout
Audio only.
A filter pad used for either input or output.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
A link between two filters.
int av_find_best_stream(AVFormatContext *ic, enum AVMediaType type, int wanted_stream_nb, int related_stream, AVCodec **decoder_ret, int flags)
Find the "best" stream in the file.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
AVRational frame_rate
Frame rate of the stream on the link, or 1/0 if unknown or variable; if left to 0/0, will be automatically copied from the first input of the source filter if it exists.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
unsigned nb_outputs
number of output pads
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
void * priv
private data for use by the filter
enum AVMediaType codec_type
General type of the encoded data.
ff_const59 AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
AVRational time_base
Define the time base used by the PTS of the frames/samples which will pass through this link...
simple assert() macros that are a bit more flexible than ISO C assert().
static int guess_channel_layout(MovieStream *st, int st_index, void *log_ctx)
int w
agreed upon image width
char * av_asprintf(const char *fmt,...)
common internal API header
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
int(* config_props)(AVFilterLink *link)
Link configuration callback.
int ff_filter_get_nb_threads(AVFilterContext *ctx)
Get number of threads for current filter instance.
int64_t discontinuity_threshold
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static int movie_config_output_props(AVFilterLink *outlink)
AVFilterContext * src
source filter
static int movie_decode_packet(AVFilterContext *ctx)
int max_stream_index
max stream # actually used for output
static int got_eagain(void)
static av_cold int movie_common_init(AVFilterContext *ctx)
static const AVFilterPad outputs[]
int format
agreed upon media format
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
int * out_index
stream number -> output number map, or -1
static AVInputFormat * iformat
Libavcodec external API header.
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer...
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
main external API structure.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
static int process_command(AVFilterContext *ctx, const char *cmd, const char *args, char *res, int res_len, int flags)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several inputs
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Describe the class of an AVClass context structure.
int64_t seek_point
seekpoint in microseconds
static int movie_push_frame(AVFilterContext *ctx, unsigned out_id)
Try to push a frame to the requested output.
discard useless packets like 0 size packets in avi
const char * name
Filter name.
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a link
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
AVFilterLink ** outputs
array of pointers to output links
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
static char * describe_frame_to_str(char *dst, size_t dst_size, AVFrame *frame, enum AVMediaType frame_type, AVFilterLink *link)
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
#define flags(name, subs,...)
static int format_name(const char *buf, char **s, int index, const char *varname)
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
int stream_index
for compatibility
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the keyframe at timestamp.
char * av_strtok(char *s, const char *delim, char **saveptr)
Split the string into several tokens which can be accessed by successive calls to av_strtok()...
int sample_rate
Audio only.
static int movie_request_frame(AVFilterLink *outlink)
static int query_formats(AVFilterContext *ctx)
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
AVFilterFormatsConfig incfg
Lists of supported formats / etc.
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
static int movie_query_formats(AVFilterContext *ctx)
static av_always_inline int diff(const uint32_t a, const uint32_t b)
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
#define AVFILTER_DEFINE_CLASS(fname)
static int rewind_file(AVFilterContext *ctx)
AVCodecContext * codec_ctx
AVFormatContext * format_ctx
int(* request_frame)(AVFilterLink *link)
Frame request callback.
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
AVCodecParameters * codecpar
Codec parameters associated with this stream.
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
AVRational r_frame_rate
Real base framerate of the stream.
static int ff_insert_outpad(AVFilterContext *f, unsigned index, AVFilterPad *p)
Insert a new output pad for the filter.
This structure stores compressed data.
int nb_samples
number of audio samples (per channel) described by this frame
const AVFilter * filter
the AVFilter of which this is an instance
#define AV_NOPTS_VALUE
Undefined timestamp value.
MovieStream * st
array of all streams, one per output