80 "changes, but PARAM_CHANGE side data was sent to it.\n");
88 flags = bytestream_get_le32(&data);
94 val = bytestream_get_le32(&data);
95 if (val <= 0 || val > INT_MAX) {
112 val = bytestream_get_le32(&data);
113 if (val <= 0 || val > INT_MAX) {
124 avctx->
width = bytestream_get_le32(&data);
125 avctx->
height = bytestream_get_le32(&data);
317 int got_frame, actual_got_frame;
342 ret = avctx->
codec->
decode(avctx, frame, &got_frame, pkt);
360 actual_got_frame = got_frame;
372 uint32_t discard_padding = 0;
376 if (ret >= 0 && got_frame) {
391 if(side && side_size>=10) {
393 discard_padding =
AV_RL32(side + 4);
396 skip_reason =
AV_RL8(side + 8);
397 discard_reason =
AV_RL8(side + 9);
421 frame->
pts += diff_ts;
442 if (discard_padding > 0 && discard_padding <= frame->nb_samples && got_frame &&
486 #if FF_API_AVCTX_TIMEBASE 493 if (avci->
draining && !actual_got_frame) {
502 "Stop draining and force EOF.\n");
513 if (ret >= pkt->
size || ret < 0) {
518 pkt->
data += consumed;
519 pkt->
size -= consumed;
530 return ret < 0 ? ret : 0;
537 while (!frame->
buf[0]) {
597 if (avpkt && !avpkt->
size && avpkt->
data)
630 "Invalid cropping information set by a decoder: " 632 "(frame size %dx%d). This is a bug, please report it\n",
714 " drop count: %d \n",
743 "Got unexpected packet size after a partial decode\n");
752 else if (ret ==
AVERROR(EAGAIN)) {
781 "API cannot return all the frames for this decoder. " 782 "Some frames will be dropped. Update your code to the " 783 "new decoding API to fix this.\n");
807 int *got_picture_ptr,
810 return compat_decode(avctx, picture, got_picture_ptr, avpkt);
823 memset(sub, 0,
sizeof(*sub));
827 #define UTF8_MAX_BYTES 4 832 iconv_t cd = (iconv_t)-1;
864 if (iconv(cd, &inb, &inl, &outb, &outl) == (
size_t)-1 ||
865 iconv(cd,
NULL,
NULL, &outb, &outl) == (
size_t)-1 ||
866 outl >= outpkt->
size || inl != 0) {
873 outpkt->
size -= outl;
874 memset(outpkt->
data + outpkt->
size, 0, outl);
877 if (cd != (iconv_t)-1)
889 uint32_t codepoint,
min;
893 GET_UTF8(codepoint, *(byte++),
return 0;);
894 min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
895 1 << (5 * (byte -
str) - 4);
896 if (codepoint < min || codepoint >= 0x110000 ||
897 codepoint == 0xFFFE ||
898 codepoint >= 0xD800 && codepoint <= 0xDFFF )
905 #if FF_API_ASS_TIMING 913 h = ts/360000; ts -= 360000*
h;
914 m = ts/ 6000; ts -= 6000*m;
915 s = ts/ 100; ts -= 100*
s;
916 av_bprintf(buf,
"%d:%02d:%02d.%02d,", h, m, s, ts);
931 int ts_start, ts_duration = -1;
940 dialog = strchr(rect->
ass,
',');
946 layer = strtol(dialog, (
char**)&dialog, 10);
960 insert_ts(&buf, ts_duration == -1 ? -1 : ts_start + ts_duration);
970 rect->
ass = final_dialog;
1012 ret = avctx->
codec->
decode(avctx, sub, got_sub_ptr, &pkt_recoded);
1016 #if FF_API_ASS_TIMING 1043 "Invalid UTF-8 in decoded subtitles text; " 1044 "maybe missing -sub_charenc option\n");
1051 if (avpkt->
data != pkt_recoded.
data) {
1089 if (config->
pix_fmt == fmt[n])
1112 if (config->
pix_fmt == fmt[n])
1144 "required for hardware accelerated decoding.\n");
1149 if (device_ctx->
type != dev_type) {
1223 *out_frames_ref = frames_ref;
1252 if (hwaccel->
init) {
1253 err = hwaccel->
init(avctx);
1256 "hwaccel initialisation returned error.\n",
1304 memcpy(choices, fmt, (n + 1) *
sizeof(*choices));
1310 user_choice = avctx->
get_format(avctx, choices);
1320 "get_format() callback.\n");
1327 for (i = 0; i < n; i++) {
1328 if (choices[i] == user_choice)
1333 "%s not in possible list.\n", desc->
name);
1355 config = &hw_config->
public;
1362 if (frames_ctx->
format != user_choice) {
1364 "does not match the format of the provided frames " 1365 "context.\n", desc->
name);
1375 "does not match the type of the provided device " 1376 "context.\n", desc->
name);
1387 "missing configuration.\n", desc->
name);
1392 "initialisation.\n", desc->
name);
1402 "get_format() without it.\n", desc->
name);
1403 for (i = 0; i < n; i++) {
1404 if (choices[i] == user_choice)
1407 for (; i + 1 < n; i++)
1408 choices[i] = choices[i + 1];
1455 planes = planar ? ch : 1;
1476 int size[4] = { 0 };
1479 int tmpsize, unaligned;
1493 for (i = 0; i < 4; i++)
1495 }
while (unaligned);
1504 for (i = 0; i < 3 && data[i + 1]; i++)
1505 size[i] = data[i + 1] - data[i];
1506 size[
i] = tmpsize - (data[
i] - data[0]);
1508 for (i = 0; i < 4; i++) {
1515 if (!pool->
pools[i]) {
1534 if (!pool->
pools[0]) {
1615 "Unable to get pixel format descriptor for format %s\n",
1620 memset(pic->
data, 0,
sizeof(pic->
data));
1623 for (i = 0; i < 4 && pool->
pools[
i]; i++) {
1689 static const struct {
1725 memcpy(frame_sd->
data, packet_sd, size);
1775 "configuration.\n");
1805 for (i = 0; i < num_planes; i++) {
1811 av_log(avctx,
AV_LOG_ERROR,
"Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1857 int override_dimensions = 1;
1871 override_dimensions = 0;
1874 if (frame->
data[0] || frame->
data[1] || frame->
data[2] || frame->
data[3]) {
1932 av_log(avctx,
AV_LOG_WARNING,
"Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1937 if (!frame->
data[0])
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
#define FF_SANE_NB_CHANNELS
This struct aggregates all the (hardware/vendor-specific) "high-level" state, i.e.
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
AVCodecHWConfig public
This is the structure which will be returned to the user by avcodec_get_hw_config().
#define FF_SUB_CHARENC_MODE_PRE_DECODER
the AVPacket data needs to be recoded to UTF-8 before being fed to the decoder, requires iconv ...
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
const struct AVCodec * codec
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
The codec supports this format via the hw_frames_ctx interface.
#define AV_NUM_DATA_POINTERS
void av_bprintf(AVBPrint *buf, const char *fmt,...)
int64_t pts_correction_num_faulty_dts
Number of incorrect PTS values so far.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
#define GET_UTF8(val, GET_BYTE, ERROR)
Convert a UTF-8 character (up to 4 bytes) to its 32-bit UCS-4 encoded form.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
int stride_align[AV_NUM_DATA_POINTERS]
This side data must be associated with an audio frame and corresponds to enum AVAudioServiceType defi...
int apply_cropping
Video decoding only.
static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame)
const struct AVCodecHWConfigInternal ** hw_configs
Array of pointers to hardware configurations supported by the codec, or NULL if no hardware supported...
#define AV_CODEC_FLAG2_SKIP_MANUAL
Do not skip samples and export skip information as frame side data.
int coded_width
Bitstream width / height, may be different from width/height e.g.
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
int capabilities
Hardware accelerated codec capabilities.
AVPacket * last_pkt_props
Properties (timestamps+side data) extracted from the last packet passed for decoding.
#define AV_LOG_WARNING
Something somehow does not look correct.
static int convert_sub_to_old_ass_form(AVSubtitle *sub, const AVPacket *pkt, AVRational tb)
int changed_frames_dropped
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
int64_t pos
byte position in stream, -1 if unknown
static void get_subtitle_defaults(AVSubtitle *sub)
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.
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
int(* receive_frame)(struct AVCodecContext *avctx, struct AVFrame *frame)
Decode API with decoupled packet/frame dataflow.
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
ATSC A53 Part 4 Closed Captions.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
int nb_extended_buf
Number of elements in extended_buf.
int ff_decode_bsfs_init(AVCodecContext *avctx)
Called during avcodec_open2() to initialize avctx->internal->bsf.
Content light level (based on CTA-861.3).
int av_codec_is_decoder(const AVCodec *codec)
enum AVPixelFormat pix_fmt
Supported pixel format.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
void(* hwaccel_priv_free)(void *priv)
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
static void frame_pool_free(void *opaque, uint8_t *data)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame)
int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, const AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Mastering display metadata associated with a video frame.
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt)
static int recode_subtitle(AVCodecContext *avctx, AVPacket *outpkt, const AVPacket *inpkt)
AVBufferPool * pools[4]
Pools for each data plane.
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
int(* alloc_frame)(AVCodecContext *avctx, AVFrame *frame)
Allocate a custom buffer.
static int utf8_check(const uint8_t *str)
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Mastering display metadata (based on SMPTE-2086:2014).
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
static AVBufferRef * frame_pool_alloc(void)
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx, const enum AVPixelFormat *fmt)
enum AVSampleFormat sample_fmt
audio sample format
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
int ff_attach_decode_data(AVFrame *frame)
int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict)
Unpack a dictionary from side_data.
static int64_t guess_correct_pts(AVCodecContext *ctx, int64_t reordered_pts, int64_t dts)
Attempt to guess proper monotonic timestamps for decoded video frames which might have incorrect time...
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
static av_cold int end(AVCodecContext *avctx)
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
#define AV_CODEC_FLAG_UNALIGNED
Allow decoders to produce frames with data planes that are not aligned to CPU requirements (e...
Multithreading support functions.
AVBufferRef * private_ref
AVBufferRef for internal use by a single libav* library.
int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt)
Called by decoders to get the next packet for decoding.
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
enum AVPixelFormat pix_fmt
For decoders, a hardware pixel format which that decoder may be able to decode to if suitable hardwar...
Structure to hold side data for an AVFrame.
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.
size_t compat_decode_consumed
#define FF_REGET_BUFFER_FLAG_READONLY
the returned buffer does not need to be writable
#define AVERROR_EOF
End of file.
AVDictionary * metadata
metadata.
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
#define AV_BUFFER_FLAG_READONLY
Always treat the buffer as read-only, even when it has only one reference.
int(* init)(AVCodecContext *avctx)
Initialize the hwaccel private data.
The data represents the AVSphericalMapping structure defined in libavutil/spherical.h.
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
int av_packet_ref(AVPacket *dst, const AVPacket *src)
Setup a new reference to the data described by a given packet.
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
void avcodec_align_dimensions2(AVCodecContext *s, int *width, int *height, int linesize_align[AV_NUM_DATA_POINTERS])
Modify width and height values so that they will result in a memory buffer that is acceptable for the...
int ff_thread_decode_frame(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Submit a new frame to a decoding thread.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
#define i(width, name, range_min, range_max)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
int has_b_frames
Size of the frame reordering buffer in the decoder.
void * post_process_opaque
#define AV_BPRINT_SIZE_UNLIMITED
static int hwaccel_init(AVCodecContext *avctx, const AVCodecHWConfigInternal *hw_config)
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
int av_frame_apply_cropping(AVFrame *frame, int flags)
Crop the given video AVFrame according to its crop_left/crop_top/crop_right/ crop_bottom fields...
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
ICC profile data consisting of an opaque octet buffer following the format described by ISO 15076-1...
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Identical in function to ff_get_buffer(), except it reuses the existing buffer if available...
int active_thread_type
Which multithreading methods are in use by the codec.
int methods
Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible setup methods which can be used...
The codec supports this format via the hw_device_ctx interface.
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
int avcodec_is_open(AVCodecContext *s)
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
static int extract_packet_props(AVCodecInternal *avci, const AVPacket *pkt)
int capabilities
Codec capabilities.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
ATSC A53 Part 4 Closed Captions.
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
int flags
AV_CODEC_FLAG_*.
enum AVColorSpace colorspace
YUV colorspace type.
AVRational time_base_in
The timebase used for the timestamps of the input packets.
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
simple assert() macros that are a bit more flexible than ISO C assert().
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
int64_t max_pixels
The number of pixels per image to maximally accept.
int av_hwframe_ctx_init(AVBufferRef *ref)
Finalize the context before use.
enum AVHWDeviceType type
This field identifies the underlying API used for hardware access.
int av_hwframe_get_buffer(AVBufferRef *hwframe_ref, AVFrame *frame, int flags)
Allocate a new frame attached to the given AVHWFramesContext.
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
const AVHWAccel * hwaccel
If this configuration uses a hwaccel, a pointer to it.
#define FF_CODEC_CAP_EXPORTS_CROPPING
The decoder sets the cropping fields in the output frames manually.
int priv_data_size
Size of the private data to allocate in AVCodecInternal.hwaccel_priv_data.
int flags
A combination of AV_PKT_FLAG values.
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
reference-counted frame API
uint64_t channel_layout
Audio channel layout.
uint32_t end_display_time
int64_t pts
Same as packet pts, in AV_TIME_BASE.
uint64_t channel_layout
Channel layout of the audio data.
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
common internal API header
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
int initial_pool_size
Initial size of the frame pool.
int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
Parse string describing list of bitstream filters and create single AVBSFContext describing the whole...
int av_packet_copy_props(AVPacket *dst, const AVPacket *src)
Copy only "properties" fields from src to dst.
The codec supports this format by some ad-hoc method.
int channels
number of audio channels, only used for audio.
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
#define FF_THREAD_FRAME
Decode more than one frame at once.
const char * name
Name of the hardware accelerated codec.
AVBufferRef ** extended_buf
For planar audio which requires more than AV_NUM_DATA_POINTERS AVBufferRef pointers, this array will hold all the references which cannot fit into AVFrame.buf.
AVFrame * compat_decode_frame
int width
picture width / height.
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame)
static int compat_decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, const AVPacket *pkt)
This side data should be associated with a video stream and corresponds to the AVSphericalMapping str...
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
#define AVERROR_INPUT_CHANGED
Input changed between calls. Reconfiguration is required. (can be OR-ed with AVERROR_OUTPUT_CHANGED) ...
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
int64_t reordered_opaque
opaque 64-bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
#define AV_EF_EXPLODE
abort decoding on minor error detection
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
const char * bsfs
Decoding only, a comma-separated list of bitstream filters to apply to packets before decoding...
char * sub_charenc
DTS of the last frame.
static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
int draining
checks API usage: after codec draining, flush is required to resume operation
#define FF_ARRAY_ELEMS(a)
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
int sub_charenc_mode
Subtitles character encoding mode.
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(* post_process)(void *logctx, AVFrame *frame)
The callback to perform some delayed processing on the frame right before it is returned to the calle...
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Content light level (based on CTA-861.3).
int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
#define attribute_align_arg
int(* decode)(struct AVCodecContext *, void *outdata, int *outdata_size, struct AVPacket *avpkt)
void(* post_process_opaque_free)(void *opaque)
#define AV_LOG_INFO
Standard information.
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
char * av_strdup(const char *s)
Duplicate a string.
int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
int av_image_fill_pointers(uint8_t *data[4], enum AVPixelFormat pix_fmt, int height, uint8_t *ptr, const int linesizes[4])
Fill plane data pointers for an image with pixel format pix_fmt and height height.
Libavcodec external API header.
enum AVMediaType codec_type
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown...
A list of zero terminated key/value strings.
int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt)
Decode the video frame of size avpkt->size from avpkt->data into picture.
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
int av_frame_is_writable(AVFrame *frame)
Check if the frame data is writable.
int sample_rate
samples per second
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
static AVRational av_make_q(int num, int den)
Create an AVRational.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
main external API structure.
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
int skip_samples_multiplier
uint8_t * data
The data buffer.
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
int av_samples_copy(uint8_t **dst, uint8_t *const *src, int dst_offset, int src_offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Copy samples from src to dst.
int64_t max_samples
The number of samples per frame to maximally accept.
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
int64_t reordered_opaque
reordered opaque 64 bits (generally an integer or a double precision float PTS but can be anything)...
int sample_rate
Sample rate of the audio data.
int(* get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags)
This callback is called at the beginning of each frame to get data buffer(s) for it.
int showed_multi_packet_warning
int av_image_fill_linesizes(int linesizes[4], enum AVPixelFormat pix_fmt, int width)
Fill plane linesizes for an image with pixel format pix_fmt and width width.
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
#define AV_CODEC_CAP_SUBFRAMES
Codec can output multiple frames per AVPacket Normally demuxers return one frame at a time...
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
int av_samples_get_buffer_size(int *linesize, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Get the required buffer size for the given audio parameters.
enum AVColorSpace colorspace
YUV colorspace type.
Rational number (pair of numerator and denominator).
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
#define CONFIG_MEMORY_POISONING
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Recommmends skipping the specified number of samples.
This struct describes a set or pool of "hardware" frames (i.e.
int sub_text_format
Control the form of AVSubtitle.rects[N]->ass.
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
enum AVChromaLocation chroma_location
int(* frame_params)(AVCodecContext *avctx, AVBufferRef *hw_frames_ctx)
Fill the given hw_frames context with current codec parameters.
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
attribute_deprecated int refcounted_frames
If non-zero, the decoded audio and video frames returned from avcodec_decode_video2() and avcodec_dec...
#define AV_CODEC_FLAG_DROPCHANGED
Don't output frames whose parameters differ from first decoded frame in stream.
int size
Size of data in bytes.
The codec supports this format by some internal method.
Apply the maximum possible cropping, even if it requires setting the AVFrame.data[] entries to unalig...
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
#define flags(name, subs,...)
This side data should be associated with an audio stream and contains ReplayGain information in form ...
#define FF_CODEC_CAP_SETS_PKT_DTS
Decoders marked with FF_CODEC_CAP_SETS_PKT_DTS want to set AVFrame.pkt_dts manually.
int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx, enum AVHWDeviceType dev_type)
Make sure avctx.hw_frames_ctx is set.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static void decode_data_free(void *opaque, uint8_t *data)
attribute_deprecated int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
void av_bprint_clear(AVBPrint *buf)
Reset the string to "" but keep internal allocated data.
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
A reference to a data buffer.
static int unrefcount_frame(AVCodecInternal *avci, AVFrame *frame)
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
This struct stores per-frame lavc-internal data and is attached to it via private_ref.
int avcodec_get_hw_frames_parameters(AVCodecContext *avctx, AVBufferRef *device_ref, enum AVPixelFormat hw_pix_fmt, AVBufferRef **out_frames_ref)
Create and return a AVHWFramesContext with values adequate for hardware decoding. ...
static enum AVPixelFormat hw_pix_fmt
#define AV_PKT_FLAG_DISCARD
Flag is used to discard packets which are required to maintain valid decoder state but are not requir...
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
common internal and external API header
AVBufferPool * av_buffer_pool_init(int size, AVBufferRef *(*alloc)(int size))
Allocate and initialize a buffer pool.
#define AV_HWACCEL_CODEC_CAP_EXPERIMENTAL
HWAccel is experimental and is thus avoided in favor of non experimental codecs.
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)
Allocate an AVHWFramesContext tied to a given device context.
static void insert_ts(AVBPrint *buf, int ts)
void * hwaccel_priv_data
hwaccel-specific private data
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1<< 16)) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(UINT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(UINT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out->ch+ch,(const uint8_t **) in->ch+ch, off *(out-> planar
int caps_internal
Internal codec capabilities.
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...
uint64_t initial_channel_layout
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
Formatted text, the ass field must be set by the decoder and is authoritative.
#define FF_ENABLE_DEPRECATION_WARNINGS
int channels
number of audio channels
struct AVCodecInternal * internal
Private context used for internal data.
char * ass
0 terminated ASS/SSA compatible event line.
#define AV_FRAME_FLAG_DISCARD
A flag to mark the frames which need to be decoded, but shouldn't be output.
int flags2
AV_CODEC_FLAG2_*.
enum AVColorPrimaries color_primaries
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
int64_t pts_correction_last_dts
PTS of the last frame.
size_t compat_decode_partial_size
#define AV_CODEC_FLAG_TRUNCATED
Input bitstream might be truncated at a random location instead of only at frame boundaries.
int frame_number
Frame counter, set by libavcodec.
static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
int64_t pts_correction_num_faulty_pts
Current statistics for PTS correction.
enum AVColorTransferCharacteristic color_trc
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Recommmends skipping the specified number of samples.
void * hwaccel_priv
Per-frame private data for hwaccels.
#define av_malloc_array(a, b)
enum AVHWDeviceType device_type
The device type associated with the configuration.
#define FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS
#define FF_SUB_CHARENC_MODE_IGNORE
neither convert the subtitles, nor check them for valid UTF-8
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.
ReplayGain information in the form of the AVReplayGain struct.
uint8_t ** extended_data
pointers to the data planes/channels.
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
int pkt_size
size of the corresponding packet containing the compressed frame.
Stereoscopic 3d metadata.
AVPixelFormat
Pixel format.
static double val(void *priv, double ch)
This structure stores compressed data.
AVCodecParameters * par_in
Parameters of the input stream.
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
int nb_samples
number of audio samples (per channel) described by this frame
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
#define AV_NOPTS_VALUE
Undefined timestamp value.
static void hwaccel_uninit(AVCodecContext *avctx)
#define AV_CEIL_RSHIFT(a, b)
void * av_mallocz_array(size_t nmemb, size_t size)
Allocate a memory block for an array with av_mallocz().
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.