FFmpeg: libavcodec/avcodec.c Source File
Go to the documentation of this file. 1 /*
2 * AVCodecContext functions for libavcodec
3 *
4 * This file is part of FFmpeg.
5 *
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /**
22 * @file
23 * AVCodecContext functions for libavcodec
24 */
25
26 #include "config.h"
44
46 {
48
49 for (
i = 0;
i < count;
i++) {
53 }
54 emms_c();
55 return 0;
56 }
57
59 {
61
62 for (
i = 0;
i < count;
i++) {
66 }
67 emms_c();
68 return 0;
69 }
70
72
74 {
77 }
78
80 {
83 }
84
86 {
87 int64_t bit_rate;
88 int bits_per_sample;
89
90 switch (
ctx->codec_type) {
96 break;
99 if (bits_per_sample) {
100 bit_rate =
ctx->sample_rate * (int64_t)
ctx->ch_layout.nb_channels;
101 if (bit_rate > INT64_MAX / bits_per_sample) {
102 bit_rate = 0;
103 } else
104 bit_rate *= bits_per_sample;
105 } else
107 break;
108 default:
109 bit_rate = 0;
110 break;
111 }
112 return bit_rate;
113 }
114
116 {
120
122 return 0;
123
124 if (!codec && !avctx->
codec) {
127 }
128 if (codec && avctx->
codec && codec != avctx->
codec) {
130 "but %s passed to avcodec_open2()\n", avctx->
codec->
name, codec->
name);
132 }
133 if (!codec)
134 codec = avctx->
codec;
136
141 }
142
145 avctx->
codec = codec;
146
149
151 if (!avci) {
153 goto end;
154 }
156
161 goto free_and_end;
162 }
163
169 goto free_and_end;
170 }
174 }
175 }
177 goto free_and_end;
178 } else {
180 }
182 goto free_and_end;
183
187 goto free_and_end;
188 }
189
190 // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
198 goto free_and_end;
199 }
200
206 }
207
215 }
216 }
217
221 goto free_and_end;
222 }
226 goto free_and_end;
227 }
228
229 #if FF_API_OLD_CHANNEL_LAYOUT
231 /* compat wrapper for old-style callers */
232 if (avctx->channel_layout && !avctx->channels)
234
239 if (avctx->channel_layout) {
241 } else {
243 }
245 }
247 #endif
248
249 /* AV_CODEC_CAP_CHANNEL_CONF is a decoder-only flag; so the code below
250 * in particular checks that nb_channels is set for all audio encoders. */
256 goto free_and_end;
257 }
261 goto free_and_end;
262 }
266 goto free_and_end;
267 }
268
270 #if FF_API_AVCTX_FRAME_NUMBER
274 #endif
276
282 "The %s '%s' is experimental but experimental codecs are not enabled, "
283 "add '-strict %d' if you want to use it.\n",
290 goto free_and_end;
291 }
292
297 }
298
301 else
304 goto free_and_end;
305
307 /* Frame-threaded decoders call FFCodec.init for their child contexts. */
312 goto free_and_end;
313 }
314 }
317
326 goto free_and_end;
327 }
328 }
330 }
331
333
337
338 #if FF_API_OLD_CHANNEL_LAYOUT
340 /* update the deprecated fields for old-style callers */
345 #endif
346
347 /* validate channel layout from the decoder */
351 goto free_and_end;
352 }
355 goto free_and_end;
356 }
357 }
360
361 end:
362
364 free_and_end:
366 goto end;
367 }
368
370 {
372
375
377 // Only encoders that explicitly declare support for it can be
378 // flushed. Otherwise, this is a no-op.
380 "that doesn't support it\n");
381 return;
382 }
387 } else {
390
393
395 }
396
402
407 }
408
410 {
412
413 for (
i = 0;
i <
sub->num_rects;
i++) {
415
422
424 }
425
427
428 memset(
sub, 0,
sizeof(*
sub));
429 }
430
432 {
434
435 if (!avctx)
436 return 0;
437
440
441 if (CONFIG_FRAME_THREAD_ENCODER &&
444 }
454
458
460
464
466
468
469 #if CONFIG_LCMS2
471 #endif
472
474 }
475
480
483
493
496
497 return 0;
498 }
499
501 {
502 return str ?
str :
"unknown";
503 }
504
506 {
508 const char *codec_name;
510 AVBPrint bprint;
512 int new_line = 0;
516
517 if (!buf || buf_size <= 0)
518 return;
523
525 codec_name);
526 buf[0] ^= 'a' ^ 'A'; /* first letter in uppercase */
527
530
537 enc->
refs, enc->
refs > 1 ?
"s" :
"");
538
542
545 {
547
551
554
555 /* The following check ensures that '(' has been written
556 * and therefore allows us to erase it if it turns out
557 * to be unnecessary. */
559 return;
560
567
574 if (strcmp(col, pri) || strcmp(col, trc)) {
575 new_line = 1;
576 av_bprintf(&bprint,
"%s/%s/%s, ", col, pri, trc);
577 } else
579 }
580
582 const char *field_order = "progressive";
584 field_order = "top first";
586 field_order = "bottom first";
588 field_order = "top coded first (swapped)";
590 field_order = "bottom coded first (swapped)";
591
593 }
594
599
600 if (
len == bprint.len) {
601 bprint.str[
len - 1] =
'0円';
602 bprint.len--;
603 } else {
604 if (bprint.len - 2 < bprint.size) {
605 /* Erase the last ", " */
606 bprint.len -= 2;
607 bprint.str[bprint.len] = '0円';
608 }
610 }
611 }
612
614 av_bprintf(&bprint,
"%s%dx%d", new_line ? separator :
", ",
616
622
627 1024 * 1024);
630 display_aspect_ratio.
num, display_aspect_ratio.
den);
631 }
636 }
637 }
640 } else {
647 }
648 break;
651
654 }
655 {
656 char buf[512];
660 }
664 }
673 }
674 break;
681 }
682 break;
686 break;
687 default:
688 return;
689 }
695 }
701 }
702 }
703
705 {
706 return !!
s->internal;
707 }
708
710 {
712
716 }
av_cold int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
int(* func)(AVBPrint *dst, const char *in, const char *arg)
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
#define FF_ENABLE_DEPRECATION_WARNINGS
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
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 AVColorSpace colorspace
YUV colorspace type.
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
int sample_rate
samples per second
const AVClass * priv_class
AVClass for the private context.
static float sub(float src0, float src1)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
const AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
int ff_encode_receive_frame(AVCodecContext *avctx, AVFrame *frame)
avcodec_receive_frame() implementation for encoders.
This structure describes decoded (raw) audio or video data.
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
int capabilities
Codec capabilities.
int depth
Number of bits in the component.
enum AVFieldOrder field_order
Field order.
void * frame_thread_encoder
AVFrame * in_frame
The input frame is stored here for encoders implementing the simple encode API.
static const char * unknown_if_null(const char *str)
#define FF_CODEC_CAP_NOT_INIT_THREADSAFE
The codec is not known to be init-threadsafe (i.e.
uint8_t * subtitle_header
Header containing style information for text subtitles.
#define AV_LOG_VERBOSE
Detailed information.
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
enum AVChannelOrder order
Channel order used in this layout.
const char * avcodec_profile_name(enum AVCodecID codec_id, int profile)
Return a name for the specified profile, if available.
int ff_thread_init(AVCodecContext *avctx)
int avcodec_is_open(AVCodecContext *s)
uint64_t mask
This member must be used for AV_CHANNEL_ORDER_NATIVE, and may be used for AV_CHANNEL_ORDER_AMBISONIC ...
int qmax
maximum quantizer
int nb_channels
Number of channels in this layout.
enum AVMediaType codec_type
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
const char * av_chroma_location_name(enum AVChromaLocation location)
int64_t av_gcd(int64_t a, int64_t b)
Compute the greatest common divisor of two integer operands.
static int ff_mutex_unlock(AVMutex *mutex)
const char * av_color_space_name(enum AVColorSpace space)
void av_bprint_init_for_buffer(AVBPrint *buf, char *buffer, unsigned size)
Init a print buffer using a pre-existing buffer.
const struct AVCodec * codec
AVChannelLayout ch_layout
Audio channel layout.
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
static int64_t get_bit_rate(AVCodecContext *ctx)
int initial_padding
Audio only.
int refs
number of reference frames
int flags
AV_CODEC_FLAG_*.
#define AV_CODEC_CAP_ENCODER_FLUSH
This encoder can be flushed using avcodec_flush_buffers().
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
int64_t bit_rate
Total stream bitrate in bit/s, 0 if not available.
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
int ff_decode_receive_frame(AVCodecContext *avctx, AVFrame *frame)
avcodec_receive_frame() implementation for decoders.
#define FF_CODEC_PROPERTY_LOSSLESS
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
AVPacket * buffer_pkt
Temporary buffers for newly received or not yet output packets/frames.
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state.
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
FF_ENABLE_DEPRECATION_WARNINGS int av_channel_layout_from_mask(AVChannelLayout *channel_layout, uint64_t mask)
Initialize a native channel layout from a bitmask indicating which channels are present.
static void unlock_avcodec(const FFCodec *codec)
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder or encoder (when the AV_CODEC_FLAG_RECON_FRAME flag is used...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
void(* flush)(struct AVCodecContext *)
Flush buffers.
int64_t max_pixels
The number of pixels per image to maximally accept.
void ff_icc_context_uninit(FFIccContext *s)
int64_t rc_max_rate
maximum bitrate
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
void ff_thread_free(AVCodecContext *avctx)
int(* init)(struct AVCodecContext *)
#define FF_CODEC_PROPERTY_FILM_GRAIN
const char * av_color_range_name(enum AVColorRange range)
int av_log_get_level(void)
Get the current log level.
Describe the class of an AVClass context structure.
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Rational number (pair of numerator and denominator).
struct AVCodecInternal * internal
Private context used for internal data.
int64_t bit_rate
the average bitrate
int trailing_padding
Audio only.
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
void av_opt_free(void *obj)
Free all allocated objects in obj.
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
@ AVCOL_RANGE_UNSPECIFIED
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
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
#define AV_CODEC_CAP_CHANNEL_CONF
Codec should fill in channel configuration and samplerate instead of container.
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
int av_codec_is_decoder(const AVCodec *codec)
const OptionDef options[]
void * hwaccel_priv_data
hwaccel-specific private data
struct AVBSFContext * bsf
enum AVSampleFormat sample_fmt
audio sample format
#define AV_MUTEX_INITIALIZER
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
@ AVCHROMA_LOC_UNSPECIFIED
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
static AVMutex codec_mutex
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
static void encode(AVCodecContext *ctx, AVFrame *frame, AVPacket *pkt, FILE *output)
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
@ AV_FIELD_TT
Top coded_first, top displayed first.
int avcodec_default_execute(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
@ AV_CHANNEL_ORDER_NATIVE
The native channel order, i.e.
static int ff_mutex_lock(AVMutex *mutex)
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
unsigned int byte_buffer_size
int ff_encode_preinit(AVCodecContext *avctx)
#define FF_THREAD_FRAME
Decode more than one frame at once.
int av_codec_is_encoder(const AVCodec *codec)
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
int avcodec_default_execute2(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
#define i(width, name, range_min, range_max)
unsigned properties
Properties of the stream that gets decoded.
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
AVPacket * in_pkt
This packet is used to hold the packet given to decoders implementing the .decode API; it is unused b...
int64_t pts_correction_last_dts
PTS of the last frame.
int ff_decode_preinit(AVCodecContext *avctx)
Perform decoder initialization and validation.
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
uint8_t * dump_separator
dump format separator.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
const char * name
Name of the codec implementation.
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
int64_t frame_num
Frame counter, set by libavcodec.
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs.
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal codec state / flush internal buffers.
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
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
int av_channel_layout_check(const AVChannelLayout *channel_layout)
Check whether a channel layout is valid, i.e.
void av_bprintf(AVBPrint *buf, const char *fmt,...)
AVFrame * recon_frame
When the AV_CODEC_FLAG_RECON_FRAME flag is used.
int needs_close
If this is set, then FFCodec->close (if existing) needs to be called for the parent AVCodecContext.
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.
main external API structure.
int active_thread_type
Which multithreading methods are in use by the codec.
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
int qmin
minimum quantizer
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
int(* close)(struct AVCodecContext *)
av_cold void ff_frame_thread_encoder_free(AVCodecContext *avctx)
int draining
checks API usage: after codec draining, flush is required to resume operation
#define FF_DISABLE_DEPRECATION_WARNINGS
int coded_width
Bitstream width / height, may be different from width/height e.g.
enum AVMediaType codec_type
#define FF_CODEC_CAP_AUTO_THREADS
Codec handles avctx->thread_count == 0 (auto) internally.
AVChannelLayout initial_ch_layout
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
@ AV_FIELD_TB
Top coded first, bottom displayed first.
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
int width
picture width / height.
attribute_deprecated int frame_number
Frame counter, set by libavcodec.
union AVChannelLayout::@314 u
Details about which channels are present in this layout.
void av_bprint_chars(AVBPrint *buf, char c, unsigned n)
Append char c n times to a print buffer.
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
int av_image_check_sar(unsigned int w, unsigned int h, AVRational sar)
Check if the given sample aspect ratio of an image is valid.
#define FF_SANE_NB_CHANNELS
char * codec_whitelist
',' separated list of allowed decoders.
static void lock_avcodec(const FFCodec *codec)
@ AV_FIELD_BT
Bottom coded first, top displayed first.
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
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.
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
#define av_fourcc2str(fourcc)
Generated on Tue Feb 28 2023 21:33:09 for FFmpeg by
doxygen
1.8.17