70 #include "libavutil/ffversion.h"
73 #if HAVE_PTHREADS || HAVE_W32THREADS || HAVE_OS2THREADS
164 static int initialized = 0;
166 if (initialized != 0)
181 return codec && codec->
decode;
193 last_avcodec = &codec->
next;
206 #if FF_API_SET_DIMENSIONS
261 *data = matrix_encoding;
413 w_align =
FFMAX(w_align, 8);
416 *width =
FFALIGN(*width, w_align);
417 *height =
FFALIGN(*height, h_align);
427 *width =
FFMAX(*width, 32);
430 for (i = 0; i < 4; i++)
442 align =
FFMAX(linesize_align[0], linesize_align[3]);
443 linesize_align[1] <<= chroma_shift;
444 linesize_align[2] <<= chroma_shift;
445 align =
FFMAX3(align, linesize_align[1], linesize_align[2]);
446 *width =
FFALIGN(*width, align);
455 *xpos = (pos&1) * 128;
456 *ypos = ((pos>>1)^(pos<4)) * 128;
474 int buf_size,
int align)
476 int ch, planar, needed_size, ret = 0;
481 if (buf_size < needed_size)
495 sample_fmt, align)) < 0) {
517 int w = frame->
width;
519 int tmpsize, unaligned;
535 for (i = 0; i < 4; i++)
544 for (i = 0; i < 3 && picture.
data[i + 1]; i++)
545 size[i] = picture.
data[i + 1] - picture.
data[i];
546 size[i] = tmpsize - (picture.
data[i] - picture.
data[0]);
548 for (i = 0; i < 4; i++) {
553 CONFIG_MEMORY_POISONING ?
556 if (!pool->
pools[i]) {
571 int planes = planar ? ch : 1;
584 if (!pool->
pools[0]) {
599 for (i = 0; i < 4; i++)
610 int planes = pool->
planes;
662 memset(pic->
data, 0,
sizeof(pic->
data));
665 for (i = 0; i < 4 && pool->
pools[i]; i++) {
699 int is_chroma = p == 1 || p == 2;
702 for (y = 0; y <
height; y++) {
704 for (x = 0; x<bytes; x++)
705 ((uint16_t*)dst)[x] = c[p];
707 memset(dst, c[p], bytes);
720 #if FF_API_GET_BUFFER
752 static const struct {
778 memcpy(frame_sd->
data, packet_sd, size);
846 #if FF_API_GET_BUFFER
883 int override_dimensions = 1;
896 override_dimensions = 0;
911 #if FF_API_GET_BUFFER
944 priv->
avctx = *avctx;
953 #define WRAP_PLANE(ref_out, data, data_size) \
955 AVBufferRef *dummy_ref = av_buffer_ref(dummy_buf); \
957 ret = AVERROR(ENOMEM); \
960 ref_out = av_buffer_create(data, data_size, compat_release_buffer, \
963 av_buffer_unref(&dummy_ref); \
964 av_frame_unref(frame); \
965 ret = AVERROR(ENOMEM); \
978 if (!desc || planes <= 0) {
983 for (i = 0; i < planes; i++) {
991 planes = planar ? avctx->
channels : 1;
1056 av_log(avctx,
AV_LOG_WARNING,
"Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1063 if (!frame->
data[0])
1095 #if FF_API_GET_BUFFER
1114 for (i = 0; i <
count; i++) {
1115 int r =
func(c, (
char *)arg + i * size);
1126 for (i = 0; i <
count; i++) {
1127 int r =
func(c, arg, i, 0);
1135 unsigned int fourcc)
1138 if (tags->
fourcc == fourcc)
1164 if (hwaccel->
id == codec_id
1165 && hwaccel->
pix_fmt == pix_fmt)
1179 "Could not find an AVHWAccel for the pixel format: %s",
1198 ret = hwa->
init(avctx);
1228 memcpy(choices, fmt, (n + 1) *
sizeof(*choices));
1246 #if FF_API_CAP_VDPAU
1255 for (n = 0; choices[
n] != ret; n++)
1259 choices[
n] = choices[n + 1];
1267 #if FF_API_AVFRAME_LAVC
1270 #if LIBAVCODEC_VERSION_MAJOR >= 55
1277 memset(frame, 0,
sizeof(
AVFrame));
1296 MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
1300 return codec->properties;
1310 memset(sub, 0,
sizeof(*sub));
1317 int bits_per_sample;
1357 if ((!codec && !avctx->
codec)) {
1361 if ((codec && avctx->
codec && codec != avctx->
codec)) {
1363 "but %s passed to avcodec_open2()\n", avctx->
codec->
name, codec->
name);
1367 codec = avctx->
codec;
1461 avctx->
codec = codec;
1481 "The %s '%s' is experimental but experimental codecs are not enabled, "
1482 "add '-strict %d' if you want to use it.\n",
1487 codec_string, codec2->
name);
1499 av_log(avctx,
AV_LOG_WARNING,
"Warning: not compiled with thread support, using thread emulation\n");
1501 if (CONFIG_FRAME_THREAD_ENCODER) {
1520 av_log(avctx,
AV_LOG_ERROR,
"The maximum value for lowres supported by the decoder is %d\n",
1529 "see the codecview filter instead.\n");
1534 #if FF_API_CODED_FRAME
1557 av_log(avctx,
AV_LOG_ERROR,
"Specified sample format %s is invalid or not supported\n",
1572 av_log(avctx,
AV_LOG_ERROR,
"Specified pixel format %s is invalid or not supported\n",
1611 av_log(avctx,
AV_LOG_ERROR,
"Specified channel layout '%s' is not supported\n", buf);
1623 "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
1661 "gray decoding requested but not enabled at configuration time\n");
1673 #if FF_API_AUDIOENC_DELAY
1686 else if (channels != avctx->
channels) {
1690 "Channel layout '%s' with %d channels does not match specified number of channels %d: "
1691 "ignoring specified channel layout\n",
1704 "supported with subtitles codecs\n");
1709 "subtitles character encoding will be ignored\n",
1720 iconv_t cd = iconv_open(
"UTF-8", avctx->
sub_charenc);
1721 if (cd == (iconv_t)-1) {
1724 "with input character encoding \"%s\"\n", avctx->
sub_charenc);
1730 "conversion needs a libavcodec built with iconv support "
1731 "for this codec\n");
1739 #if FF_API_AVCTX_TIMEBASE
1744 if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
1759 avctx->codec->close(avctx);
1761 if (codec->priv_class && codec->priv_data_size)
1765 #if FF_API_CODED_FRAME
1773 if (avctx->internal) {
1778 avctx->codec =
NULL;
1784 if (avpkt->
size < 0) {
1789 av_log(avctx,
AV_LOG_ERROR,
"Invalid minimum required packet size %"PRId64
" (max allowed is %d)\n",
1794 if (avctx && 2*min_size < size) {
1796 if (!avpkt->
data || avpkt->
size < size) {
1800 #if FF_API_DESTRUCT_PACKET
1810 #if FF_API_DESTRUCT_PACKET
1816 if (avpkt->
size < size) {
1822 #if FF_API_DESTRUCT_PACKET
1886 int *got_packet_ptr)
1892 int needs_realloc = !user_pkt.
data;
1894 *got_packet_ptr = 0;
1907 "with more than %d channels, but extended_data is not set.\n",
1914 if (!extended_frame)
1917 memcpy(extended_frame, frame,
sizeof(
AVFrame));
1919 frame = extended_frame;
1933 av_log(avctx,
AV_LOG_ERROR,
"more samples than frame size (avcodec_encode_audio2)\n");
1944 frame = padded_frame;
1958 ret = avctx->
codec->
encode2(avctx, avpkt, frame, got_packet_ptr);
1960 if (*got_packet_ptr) {
1975 if (user_pkt.
data) {
1976 if (user_pkt.
size >= avpkt->
size) {
1983 avpkt->
buf = user_pkt.
buf;
1985 #if FF_API_DESTRUCT_PACKET
1998 if (needs_realloc && avpkt->
data) {
2007 if (ret < 0 || !*got_packet_ptr) {
2022 #if FF_API_AUDIOENC_DELAY
2029 #if FF_API_OLD_ENCODE_AUDIO
2032 const short *samples)
2036 int ret, samples_size, got_packet;
2040 pkt.
size = buf_size;
2055 "support this codec\n");
2059 nb_samples = (int64_t)buf_size * 8 /
2062 if (nb_samples >= INT_MAX) {
2077 samples_size, 1)) < 0) {
2097 #if FF_API_CODED_FRAME
2113 return ret ? ret : pkt.
size;
2118 #if FF_API_OLD_ENCODE_VIDEO
2123 int ret, got_packet = 0;
2132 pkt.
size = buf_size;
2135 #if FF_API_CODED_FRAME
2155 return ret ? ret : pkt.
size;
2163 int *got_packet_ptr)
2167 int needs_realloc = !user_pkt.
data;
2169 *got_packet_ptr = 0;
2171 if(CONFIG_FRAME_THREAD_ENCODER &&
2190 if (frame && (frame->
width == 0 || frame->
height == 0))
2195 ret = avctx->
codec->
encode2(avctx, avpkt, frame, got_packet_ptr);
2200 if (user_pkt.
data) {
2201 if (user_pkt.
size >= avpkt->
size) {
2208 avpkt->
buf = user_pkt.
buf;
2210 #if FF_API_DESTRUCT_PACKET
2223 if (!*got_packet_ptr)
2228 if (needs_realloc && avpkt->
data) {
2237 if (ret < 0 || !*got_packet_ptr)
2269 int64_t reordered_pts, int64_t dts)
2287 pts = reordered_pts;
2307 "changes, but PARAM_CHANGE side data was sent to it.\n");
2314 flags = bytestream_get_le32(&data);
2320 val = bytestream_get_le32(&data);
2321 if (val <= 0 || val > INT_MAX) {
2337 val = bytestream_get_le32(&data);
2338 if (val <= 0 || val > INT_MAX) {
2348 avctx->
width = bytestream_get_le32(&data);
2349 avctx->
height = bytestream_get_le32(&data);
2409 int *got_picture_ptr,
2424 *got_picture_ptr = 0;
2445 ret = avctx->
codec->
decode(avctx, picture, got_picture_ptr,
2472 if (*got_picture_ptr) {
2493 #if FF_API_AVCTX_TIMEBASE
2501 #if FF_API_OLD_DECODE_AUDIO
2503 int *frame_size_ptr,
2507 int ret, got_frame = 0;
2511 #if FF_API_GET_BUFFER
2515 "avcodec_decode_audio3() detected. Overriding with avcodec_default_get_buffer\n");
2517 "avcodec_decode_audio4()\n");
2526 if (ret >= 0 && got_frame) {
2532 if (*frame_size_ptr < data_size) {
2534 "the current frame (%d < %d)\n", *frame_size_ptr, data_size);
2541 if (planar && avctx->
channels > 1) {
2543 for (ch = 1; ch < avctx->
channels; ch++) {
2548 *frame_size_ptr = data_size;
2550 *frame_size_ptr = 0;
2584 uint32_t discard_padding = 0;
2601 ret = avctx->
codec->
decode(avctx, frame, got_frame_ptr, &tmp);
2605 if (ret >= 0 && *got_frame_ptr) {
2622 if(side && side_size>=10) {
2624 discard_padding =
AV_RL32(side + 4);
2627 skip_reason =
AV_RL8(side + 8);
2628 discard_reason =
AV_RL8(side + 9);
2660 if (discard_padding > 0 && discard_padding <= frame->nb_samples && *got_frame_ptr &&
2683 AV_WL32(fside->
data, avctx->internal->skip_samples);
2687 avctx->internal->skip_samples = 0;
2691 avctx->internal->pkt =
NULL;
2698 if (ret >= 0 && *got_frame_ptr) {
2699 if (!avctx->refcounted_frames) {
2711 #define UTF8_MAX_BYTES 4
2716 iconv_t cd = (iconv_t)-1;
2745 outb = outpkt->
data;
2746 outl = outpkt->
size;
2748 if (iconv(cd, &inb, &inl, &outb, &outl) == (
size_t)-1 ||
2749 iconv(cd,
NULL,
NULL, &outb, &outl) == (
size_t)-1 ||
2750 outl >= outpkt->
size || inl != 0) {
2757 outpkt->
size -= outl;
2758 memset(outpkt->
data + outpkt->
size, 0, outl);
2761 if (cd != (iconv_t)-1)
2773 uint32_t codepoint,
min;
2777 GET_UTF8(codepoint, *(byte++),
return 0;);
2778 min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
2779 1 << (5 * (byte - str) - 4);
2780 if (codepoint < min || codepoint >= 0x110000 ||
2781 codepoint == 0xFFFE ||
2782 codepoint >= 0xD800 && codepoint <= 0xDFFF )
2835 ret = avctx->
codec->
decode(avctx, sub, got_sub_ptr, &pkt_recoded);
2849 "Invalid UTF-8 in decoded subtitles text; "
2850 "maybe missing -sub_charenc option\n");
2856 if (tmp.
data != pkt_recoded.
data) {
2910 if (CONFIG_FRAME_THREAD_ENCODER &&
2938 #if FF_API_CODED_FRAME
2975 default :
return id;
2994 return experimental;
3052 return "unknown_codec";
3057 int i,
len, ret = 0;
3059 #define TAG_PRINT(x) \
3060 (((x) >= '0' && (x) <= '9') || \
3061 ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
3062 ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
3064 for (i = 0; i < 4; i++) {
3066 TAG_PRINT(codec_tag & 0xFF) ?
"%c" :
"[%d]", codec_tag & 0xFF);
3068 buf_size = buf_size > len ? buf_size - len : 0;
3078 const char *codec_name;
3086 if (!buf || buf_size <= 0)
3100 snprintf(buf, buf_size,
"%s: %s", codec_type ? codec_type :
"unknown",
3102 buf[0] ^=
'a' ^
'A';
3108 snprintf(buf + strlen(buf), buf_size - strlen(buf),
" (%s)", profile);
3112 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3113 ", %d reference frame%s",
3114 enc->
refs, enc->
refs > 1 ?
"s" :
"");
3119 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3120 " (%s / 0x%04X)", tag_buf, enc->
codec_tag);
3126 char detail[256] =
"(";
3130 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3160 if (strlen(detail) > 1) {
3161 detail[strlen(detail) - 2] = 0;
3167 av_strlcat(buf, new_line ? separator :
", ", buf_size);
3169 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3176 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3184 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3185 " [SAR %d:%d DAR %d:%d]",
3187 display_aspect_ratio.
num, display_aspect_ratio.
den);
3191 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3197 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3198 ", q=%d-%d", enc->
qmin, enc->
qmax);
3201 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3202 ", Closed Captions");
3204 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3212 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3217 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3222 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3229 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3236 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3244 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3247 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3252 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3253 ", %d kb/s", bitrate / 1000);
3255 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3294 return FFMPEG_CONFIGURATION;
3299 #define LICENSE_PREFIX "libavcodec license: "
3387 if (be < 0 || be > 1)
3389 return map[
fmt][be];
3422 if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
3423 return (frame_bytes * 8LL) / (bps * ch);
3450 return 256 * sr / 245;
3455 return (480 << (sr / 22050)) / ch;
3463 case 20:
return 160;
3464 case 19:
return 144;
3465 case 29:
return 288;
3466 case 37:
return 480;
3470 case 38:
return 160;
3471 case 50:
return 240;
3476 if (frame_bytes > 0) {
3479 return 240 * (frame_bytes / 32);
3481 return 256 * (frame_bytes / 64);
3483 return 160 * (frame_bytes / 20);
3485 return 240 * (frame_bytes / 24);
3490 return frame_bytes * 8 /
bps;
3497 return frame_bytes / (9 * ch) * 16;
3499 return frame_bytes / (16 * ch) * 28;
3502 return (frame_bytes - 4 * ch) * 2 / ch;
3504 return (frame_bytes - 4) * 2 / ch;
3506 return (frame_bytes - 8) * 2 / ch;
3510 return frame_bytes * 14 / (8 * ch);
3513 return (frame_bytes / 128) * 224 / ch;
3515 return (frame_bytes - 6 - ch) / ch;
3517 return (frame_bytes - 8) / ch;
3519 return (frame_bytes - 2 * ch) / ch;
3521 return 3 * frame_bytes / ch;
3523 return 6 * frame_bytes / ch;
3525 return 2 * (frame_bytes / (5 * ch));
3528 return 4 * frame_bytes / ch;
3535 return frame_bytes / ch;
3537 return frame_bytes * 2 / ch;
3543 int blocks = frame_bytes / ba;
3546 if (bps < 2 || bps > 5)
3548 return blocks * (1 + (ba - 4 * ch) / (bps * ch) * 8);
3550 return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
3552 return blocks * (1 + (ba - 4 * ch) * 2 / ch);
3554 return blocks * ((ba - 4 * ch) * 2 / ch);
3556 return blocks * (2 + (ba - 7 * ch) * 2 / ch);
3566 return 2 * (frame_bytes / ((bps * 2 / 8) * ch));
3570 return frame_bytes / ((
FFALIGN(ch, 2) *
bps) / 8);
3572 return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
3617 for (i = 0; i < size && !(
tab[i][0] == a &&
tab[i][1] ==
b); i++) ;
3621 #if FF_API_MISSING_SAMPLE
3626 "version to the newest one from Git. If the problem still "
3627 "occurs, it means that your file has a feature which has not "
3628 "been implemented.\n", feature);
3635 va_list argument_list;
3637 va_start(argument_list, msg);
3642 "of this file to ftp://upload.ffmpeg.org/incoming/ "
3643 "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n");
3645 va_end(argument_list);
3659 last_hwaccel = &hwaccel->
next;
3680 void *new_codec_mutex =
NULL;
3681 void *new_avformat_mutex =
NULL;
3709 "Insufficient thread locking. At least %d threads are "
3710 "calling avcodec_open2() at the same time right now.\n",
3713 av_log(log_ctx,
AV_LOG_ERROR,
"No lock manager is set, please see av_lockmgr_register()\n");
3759 ((
unsigned)
av_toupper((x >> 24) & 0xFF) << 24);
3888 uint32_t *av_restrict
state)
3896 for (i = 0; i < 3; i++) {
3897 uint32_t tmp = *state << 8;
3898 *state = tmp + *(p++);
3899 if (tmp == 0x100 || p == end)
3904 if (p[-1] > 1 ) p += 3;
3905 else if (p[-2] ) p += 2;
3906 else if (p[-3]|(p[-1]-1)) p++;
3913 p =
FFMIN(p, end) - 4;
#define WRAP_PLANE(ref_out, data, data_size)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
#define FF_SANE_NB_CHANNELS
static int apply_param_change(AVCodecContext *avctx, AVPacket *avpkt)
packed YUV 4:2:2, 16bpp, Cb Y0 Cr Y1
void av_frame_set_channels(AVFrame *frame, int val)
const struct AVCodec * codec
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
const char const char void * val
#define avpriv_atomic_int_add_and_fetch
const AVCodecDescriptor * codec_descriptor
AVCodecDescriptor Code outside libavcodec should access this field using: av_codec_{get,set}_codec_descriptor(avctx)
static AVCodec * find_encdec(enum AVCodecID id, int encoder)
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Number of sample formats. DO NOT USE if linking dynamically.
static enum AVPixelFormat pix_fmt
#define AV_NUM_DATA_POINTERS
int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet_ptr)
int64_t av_frame_get_pkt_duration(const AVFrame *frame)
static int shift(int a, int b)
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
static av_always_inline int pthread_mutex_destroy(pthread_mutex_t *mutex)
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.
int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
void av_free_packet(AVPacket *pkt)
Free a packet.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
int(* init)(AVCodecContext *avctx)
Initialize the hwaccel private data.
int stride_align[AV_NUM_DATA_POINTERS]
A dummy id pointing at the start of audio codecs.
ptrdiff_t const GLvoid * data
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
This side data must be associated with an audio frame and corresponds to enum AVAudioServiceType defi...
#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.
int capabilities
Hardware accelerated codec capabilities.
void(* flush)(AVCodecContext *)
Flush buffers.
int av_lockmgr_register(int(*cb)(void **mutex, enum AVLockOp op))
Register a user provided lock manager supporting the operations specified by AVLockOp.
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AV_LOG_WARNING
Something somehow does not look correct.
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
packed RGB 8:8:8, 24bpp, RGBRGB...
int64_t pos
byte position in stream, -1 if unknown
enum AVColorRange av_frame_get_color_range(const AVFrame *frame)
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
#define LIBAVCODEC_VERSION_MICRO
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
This side data should be associated with a video stream and contains Stereoscopic 3D information in f...
void av_opt_set_defaults(void *s)
Set the values of all AVOption fields to their default values.
const char * avcodec_configuration(void)
Return the libavcodec build-time configuration.
enum AVColorRange color_range
MPEG vs JPEG YUV range.
int nb_extended_buf
Number of elements in extended_buf.
const char * avcodec_license(void)
Return the libavcodec license.
#define FF_CODEC_PROPERTY_LOSSLESS
enum AVPixelFormat pix_fmt
Supported pixel format.
static int get_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
Pad last frame with silence.
AVPacket * pkt
Current packet as passed into the decoder, to avoid having to pass the packet into every function...
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
enum AVMediaType codec_type
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
os2threads to pthreads wrapper
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
void avpriv_color_frame(AVFrame *frame, const int c[4])
void av_frame_set_pkt_duration(AVFrame *frame, int64_t val)
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
planar GBR 4:4:4 36bpp, little-endian
A dummy ID pointing at the start of various fake codecs.
The following 12 formats have the disadvantage of needing 1 format for each bit depth.
#define AV_CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
size_t av_get_codec_tag_string(char *buf, size_t buf_size, unsigned int codec_tag)
Put a string representing the codec tag codec_tag in buf.
AVBufferPool * pools[4]
Pools for each data plane.
int(* decode)(AVCodecContext *, void *outdata, int *outdata_size, AVPacket *avpkt)
int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of audio.
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
int avcodec_enum_to_chroma_pos(int *xpos, int *ypos, enum AVChromaLocation pos)
Converts AVChromaLocation to swscale x/y chroma position.
#define AV_CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
void avcodec_default_release_buffer(AVCodecContext *s, AVFrame *pic)
int av_dup_packet(AVPacket *pkt)
attribute_deprecated int(* get_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called at the beginning of each frame to get a buffer for it.
void av_frame_set_pkt_size(AVFrame *frame, int val)
planar GBR 4:4:4 36bpp, big-endian
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
uint8_t log2_chroma_w
Amount to shift the luma width right to find the chroma width.
AVLockOp
Lock operation used by lockmgr.
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
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.
attribute_deprecated void(* release_buffer)(struct AVCodecContext *c, AVFrame *pic)
Called to release buffers which were allocated with get_buffer.
char * text
0 terminated plain UTF-8 text
unsigned avcodec_get_edge_width(void)
Return the amount of padding in pixels which the get_buffer callback must provide around the edge of ...
const char * av_color_space_name(enum AVColorSpace space)
Macro definitions for various function/variable attributes.
FF_DISABLE_DEPRECATION_WARNINGS void av_log_missing_feature(void *avc, const char *feature, int want_sample)
Log a generic warning message about a missing feature.
static void * codec_mutex
#define AV_CODEC_CAP_INTRA_ONLY
Codec is intra only.
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.
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
int av_codec_is_decoder(const AVCodec *codec)
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
void ff_thread_await_progress2(AVCodecContext *avctx, int field, int thread, int shift)
int avcodec_fill_audio_frame(AVFrame *frame, int nb_channels, enum AVSampleFormat sample_fmt, const uint8_t *buf, int buf_size, int align)
Fill AVFrame audio data and linesize pointers.
int av_codec_is_encoder(const AVCodec *codec)
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), little-endian ...
void avcodec_align_dimensions(AVCodecContext *s, int *width, int *height)
Modify width and height values so that they will result in a memory buffer that is acceptable for the...
struct AVHWAccel * hwaccel
Hardware accelerator in use.
static int volatile entangled_thread_counter
#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.
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
int ff_unlock_avcodec(void)
static double cb(void *priv, double x, double y)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
enum AVSampleFormat sample_fmt
audio sample format
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Opaque data information usually continuous.
int av_packet_unpack_dictionary(const uint8_t *data, int size, AVDictionary **dict)
Unpack a dictionary from side_data.
#define av_assert2(cond)
assert() equivalent, that does lie in speed critical code.
8 bit with AV_PIX_FMT_RGB32 palette
attribute_deprecated void(* destruct)(struct AVPacket *)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointers to the image data planes
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
const char * av_color_range_name(enum AVColorRange range)
static av_cold int end(AVCodecContext *avctx)
static int setup_hwaccel(AVCodecContext *avctx, const enum AVPixelFormat fmt, const char *name)
static AVCodec * first_avcodec
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
int ff_side_data_update_matrix_encoding(AVFrame *frame, enum AVMatrixEncoding matrix_encoding)
Add or update AV_FRAME_DATA_MATRIXENCODING side data.
Multithreading support functions.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
planar YUV 4:4:4,36bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
#define FF_PROFILE_UNKNOWN
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
#define LIBAVCODEC_VERSION_INT
int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame)
Identical in function to av_frame_make_writable(), except it uses ff_get_buffer() to allocate the buf...
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
int64_t sample_count
Internal sample count used by avcodec_encode_audio() to fabricate pts.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
void * frame_thread_encoder
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.
int attribute_align_arg ff_codec_open2_recursive(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Call avcodec_open2 recursively by decrementing counter, unlocking mutex, calling the function and the...
planar YUV 4:4:0,20bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
planar GBR 4:4:4 48bpp, big-endian
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range...
static int(* lockmgr_cb)(void **mutex, enum AVLockOp op)
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
int ff_init_buffer_info(AVCodecContext *avctx, AVFrame *frame)
does needed setup of pkt_pts/pos and such for (re)get_buffer();
#define AV_CODEC_CAP_HWACCEL_VDPAU
Codec can export data for HW decoding (VDPAU).
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
#define AV_LOG_VERBOSE
Detailed information.
AVFrame * avcodec_alloc_frame(void)
int lowres
low resolution decoding, 1-> 1/2 size, 2->1/4 size
void av_frame_set_best_effort_timestamp(AVFrame *frame, int64_t val)
enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt)
Get the planar alternative form of the given sample format.
int ff_match_2uint16(const uint16_t(*tab)[2], int size, int a, int b)
Return the index into tab at which {a,b} match elements {[0],[1]} of tab.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), big-endian
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
char * stats_out
pass1 encoding statistics output buffer
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
const OptionDef options[]
void av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
#define FF_BUFFER_TYPE_INTERNAL
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
static void compat_release_buffer(void *opaque, uint8_t *data)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
AVCodec * avcodec_find_encoder_by_name(const char *name)
Find a registered encoder with the specified name.
void av_frame_set_color_range(AVFrame *frame, enum AVColorRange val)
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...
static av_cold void avcodec_init(void)
static void * av_x_if_null(const void *p, const void *x)
Return x default pointer in case p is NULL.
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.
planar YUV 4:2:0, 13.5bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
void avcodec_set_dimensions(AVCodecContext *s, int width, int height)
Libavcodec version macros.
int(* close)(AVCodecContext *)
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 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.
const uint64_t * channel_layouts
array of support channel layouts, or NULL if unknown. array is terminated by 0
planar GBR 4:4:4 27bpp, big-endian
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
const char * av_chroma_location_name(enum AVChromaLocation location)
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
uint16_t depth_minus1
Number of bits in the component minus 1.
AVCodecID
Identify the syntax and semantics of the bitstream.
int width
width and height of the video frame
#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.
int av_get_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
#define avpriv_atomic_ptr_cas
uint8_t log2_chroma_h
Amount to shift the luma height right to find the chroma height.
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.
int av_samples_set_silence(uint8_t **audio_data, int offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Fill an audio buffer with silence.
#define AV_EF_EXPLODE
abort decoding on minor error detection
#define MAKE_ACCESSORS(str, name, type, field)
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
An AV_PKT_DATA_PARAM_CHANGE side data packet is laid out as follows:
unsigned int avpriv_toupper4(unsigned int x)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
void av_packet_free_side_data(AVPacket *pkt)
Convenience function to free all the side data stored.
int qmax
maximum quantizer
void av_frame_set_colorspace(AVFrame *frame, enum AVColorSpace val)
AVCodec * av_codec_next(const AVCodec *c)
If c is NULL, returns the first registered codec, if c is non-NULL, returns the next registered codec...
int64_t pts_correction_last_pts
Number of incorrect DTS values so far.
int active_thread_type
Which multithreading methods are in use by the codec.
int avcodec_is_open(AVCodecContext *s)
int av_match_list(const char *name, const char *list, char separator)
Check if a name is in a list.
int capabilities
Codec capabilities.
int initial_padding
Audio only.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int ff_thread_init(AVCodecContext *s)
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), big-endian
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
int flags
AV_CODEC_FLAG_*.
int rc_max_rate
maximum bitrate
#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().
planar YUV 4:2:2,28bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
int64_t av_gcd(int64_t a, int64_t b)
Return the greatest common divisor of a and b.
enum AVMediaType avcodec_get_type(enum AVCodecID codec_id)
Get the type of the given codec.
int av_log_get_level(void)
Get the current log level.
const char * name
Name of the codec implementation.
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
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.
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.
int av_buffer_realloc(AVBufferRef **pbuf, int size)
Reallocate a given buffer.
planar YUV 4:4:4 36bpp, (1 Cr & Cb sample per 1x1 Y & A samples), little-endian
void ff_thread_free(AVCodecContext *avctx)
Libavcodec external API header.
const char av_codec_ffversion[]
av_cold void ff_me_cmp_init_static(void)
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
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.
const char * av_color_primaries_name(enum AVColorPrimaries primaries)
reference-counted frame API
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
uint64_t channel_layout
Audio channel layout.
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, big-endian)
uint32_t end_display_time
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
int64_t pts
Same as packet pts, in AV_TIME_BASE.
int rc_buffer_size
decoder bitstream buffer size
uint64_t channel_layout
Channel layout of the audio data.
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
int(* encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size, const struct AVSubtitle *sub)
static AVCodec ** last_avcodec
int ff_frame_thread_encoder_init(AVCodecContext *avctx, AVDictionary *options)
common internal API header
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
int refs
number of reference frames
static AVHWAccel * find_hwaccel(enum AVCodecID codec_id, enum AVPixelFormat pix_fmt)
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
uint8_t nb_components
The number of components each pixel has, (1-4)
static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
int bit_rate
the average bitrate
audio channel layout utility functions
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
enum AVPictureType pict_type
Picture type of the frame.
int attribute_align_arg avcodec_decode_audio3(AVCodecContext *avctx, int16_t *samples, int *frame_size_ptr, AVPacket *avpkt)
Wrapper function which calls avcodec_decode_audio4.
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.
AVPicture pict
data+linesize for the bitmap of this subtitle.
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
const char * name
Name of the hardware accelerated codec.
volatile int ff_avcodec_locked
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.
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
int(* alloc_frame)(AVCodecContext *avctx, AVFrame *frame)
Allocate a custom buffer.
static int is_hwaccel_pix_fmt(enum AVPixelFormat pix_fmt)
void ff_thread_report_progress2(AVCodecContext *avctx, int field, int thread, int n)
int width
picture width / height.
attribute_deprecated int reference
#define FF_CEIL_RSHIFT(a, b)
FF_ENABLE_DEPRECATION_WARNINGS int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
void av_frame_set_pkt_pos(AVFrame *frame, int64_t val)
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
static av_always_inline int pthread_mutex_init(pthread_mutex_t *mutex, const pthread_mutexattr_t *attr)
planar YUV 4:4:4 40bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
packed YUV 4:2:2, 16bpp, Y0 Cr Y1 Cb
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
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.
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), big-endian
const AVProfile * profiles
array of recognized profiles, or NULL if unknown, array is terminated by {FF_PROFILE_UNKNOWN} ...
int64_t reordered_opaque
opaque 64bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
int refcounted_frames
If non-zero, the decoded audio and video frames returned from avcodec_decode_video2() and avcodec_dec...
void avcodec_free_frame(AVFrame **frame)
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
packed RGB 8:8:8, 24bpp, BGRBGR...
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), little-endian
planar YUV 4:2:0, 15bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
uint8_t avframe_padding[1024]
Usually treated as AVMEDIA_TYPE_DATA.
void av_log_ask_for_sample(void *avc, const char *msg,...)
Opaque data information usually sparse.
int ff_alloc_packet(AVPacket *avpkt, int size)
const char * av_get_colorspace_name(enum AVColorSpace val)
Get the name of a colorspace.
static pthread_mutex_t * mutex
static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
#define FF_SUB_CHARENC_MODE_AUTOMATIC
libavcodec will select the mode itself
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
char * sub_charenc
DTS of the last frame.
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it...
#define FF_ARRAY_ELEMS(a)
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
int thread_count
thread count is used to decide how many independent tasks should be passed to execute() ...
the normal 2^n-1 "JPEG" YUV ranges
int sub_charenc_mode
Subtitles character encoding mode.
int av_packet_split_side_data(AVPacket *pkt)
int av_codec_get_max_lowres(const AVCodec *codec)
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 decoder 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...
const AVS_VideoInfo int align
const char * av_get_profile_name(const AVCodec *codec, int profile)
Return a name for the specified profile, if available.
int frame_size
Number of samples per channel in an audio frame.
#define FF_COMPLIANCE_UNOFFICIAL
Allow unofficial extensions.
packed RGB 3:3:2, 8bpp, (msb)2B 3G 3R(lsb)
planar YUV 4:2:0, 24bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
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.
enum AVMediaType codec_type
void(* init_static_data)(struct AVCodec *codec)
Initialize codec static data, called from avcodec_register().
A list of zero terminated key/value strings.
int avcodec_default_reget_buffer(AVCodecContext *s, AVFrame *pic)
AVSampleFormat
Audio sample formats.
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
AVDictionary ** avpriv_frame_get_metadatap(AVFrame *frame)
enum AVCodecID av_get_pcm_codec(enum AVSampleFormat fmt, int be)
Return the PCM codec associated with a sample format.
#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 av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_WB16 unsigned int_TMPL byte
int sample_rate
samples per second
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
planar GBR 4:4:4 30bpp, big-endian
main external API structure.
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
static int recode_subtitle(AVCodecContext *avctx, AVPacket *outpkt, const AVPacket *inpkt)
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
uint8_t * data
The data buffer.
int qmin
minimum quantizer
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.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
planar YUV 4:4:0,24bpp, (1 Cr & Cb sample per 1x2 Y samples), little-endian
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
planar GBR 4:4:4 42bpp, little-endian
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.
int attribute_align_arg avcodec_encode_video(AVCodecContext *avctx, uint8_t *buf, int buf_size, const AVFrame *pict)
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.
unsigned int av_xiphlacing(unsigned char *s, unsigned int v)
Encode extradata length to a buffer.
#define FF_SUB_CHARENC_MODE_DO_NOTHING
do nothing (demuxer outputs a stream supposed to be already in UTF-8, or the codec is bitmap for inst...
#define FF_THREAD_FRAME
Decode more than one frame at once.
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
planar YUV 4:2:2 48bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
static int utf8_check(const uint8_t *str)
int64_t reordered_opaque
reordered opaque 64bit (generally an integer or a double precision float PTS but can be anything)...
enum AVColorSpace av_frame_get_colorspace(const AVFrame *frame)
Describe the class of an AVClass context structure.
int sample_rate
Sample rate of the audio data.
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
int av_frame_get_channels(const AVFrame *frame)
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.
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, little-endian)
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
static av_const int av_toupper(int c)
Locale-independent conversion of ASCII characters to uppercase.
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 numerator/denominator
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
const char * name
short name for the profile
Recommmends skipping the specified number of samples.
planar YUV 4:2:0,21bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
void av_vlog(void *avcl, int level, const char *fmt, va_list vl)
Send the specified message to the log if the level is less than or equal to the current av_log_level...
int(* func)(AVBPrint *dst, const char *in, const char *arg)
size_t av_strlcatf(char *dst, size_t size, const char *fmt,...)
int skip_samples
Number of audio samples to skip at the start of the next decoded frame.
planar GBR 4:4:4 42bpp, big-endian
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.
static FF_ENABLE_DEPRECATION_WARNINGS AVHWAccel * first_hwaccel
char * codec_whitelist
',' separated list of allowed decoders.
planar YUV 4:2:0 22.5bpp, (1 Cr & Cb sample per 2x2 Y & A samples), big-endian
const char * name
Name of the codec described by this descriptor.
enum AVChromaLocation chroma_location
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
static AVHWAccel ** last_hwaccel
void avcodec_get_frame_defaults(AVFrame *frame)
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
static enum AVCodecID remap_deprecated_codec_id(enum AVCodecID id)
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes...
AVHWAccel * av_hwaccel_next(const AVHWAccel *hwaccel)
If hwaccel is NULL, returns the first registered hardware accelerator, if hwaccel is non-NULL...
This struct describes the properties of a single codec described by an AVCodecID. ...
int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
int avpriv_bprint_to_extradata(AVCodecContext *avctx, struct AVBPrint *buf)
Finalize buf into extradata and set its size appropriately.
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
static int64_t pts
Global timestamp for the audio frames.
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.
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, little-endian)
int attribute_align_arg avcodec_encode_audio(AVCodecContext *avctx, uint8_t *buf, int buf_size, const short *samples)
Encode an audio frame from samples into buf.
AVCodec * avcodec_find_decoder_by_name(const char *name)
Find a registered decoder with the specified name.
This side data should be associated with an audio stream and contains ReplayGain information in form ...
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
const AVClass * priv_class
AVClass for the private context.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
planar YUV 4:4:4, 27bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
planar YUV 4:4:4, 48bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
uint8_t max_lowres
maximum value for lowres supported by the decoder, no direct access, use av_codec_get_max_lowres() ...
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
A reference to a data buffer.
static int op(uint8_t **dst, const uint8_t *dst_end, GetByteContext *gb, int pixel, int count, int *x, int width, int linesize)
Perform decode operation.
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
void av_opt_free(void *obj)
Free all allocated objects in obj.
#define FF_DISABLE_DEPRECATION_WARNINGS
common internal api header.
enum AVChromaLocation avcodec_chroma_pos_to_enum(int xpos, int ypos)
Converts swscale x/y chroma position to AVChromaLocation.
AVBufferPool * av_buffer_pool_init(int size, AVBufferRef *(*alloc)(int size))
Allocate and initialize a buffer pool.
int avpriv_lock_avformat(void)
#define HWACCEL_CODEC_CAP_EXPERIMENTAL
HWAccel is experimental and is thus avoided in favor of non experimental codecs.
void av_register_hwaccel(AVHWAccel *hwaccel)
Register the hardware accelerator hwaccel.
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
planar GBRA 4:4:4:4 32bpp
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...
planar GBR 4:4:4 27bpp, little-endian
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
int(* uninit)(AVCodecContext *avctx)
Uninitialize the hwaccel private data.
void * hwaccel_priv_data
hwaccel-specific private data
uint32_t start_display_time
void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_padded_malloc except that buffer will always be 0-initialized after call...
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
planar YUV 4:2:2, 32bpp, (1 Cr & Cb sample per 2x1 Y samples), little-endian
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
int ff_thread_can_start_frame(AVCodecContext *avctx)
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
enum AVCodecID id
Codec implemented by the hardware accelerator.
void ff_thread_report_progress(ThreadFrame *f, int progress, int field)
Notify later decoding threads when part of their reference picture is ready.
packed RGB 3:3:2, 8bpp, (msb)2R 3G 3B(lsb)
#define AV_PIX_FMT_RGB555
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
int caps_internal
Internal codec capabilities.
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
int avcodec_default_execute2(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2, int jobnr, int threadnr), void *arg, int *ret, int count)
#define AVERROR_UNKNOWN
Unknown error, typically from an external library.
planar YUV 4:2:0 25bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
int ff_lock_avcodec(AVCodecContext *log_ctx, const AVCodec *codec)
int av_samples_fill_arrays(uint8_t **audio_data, int *linesize, const uint8_t *buf, int nb_channels, int nb_samples, enum AVSampleFormat sample_fmt, int align)
Fill plane data pointers and linesize for samples with sample format sample_fmt.
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame)
void ff_thread_flush(AVCodecContext *avctx)
Wait for decoding threads to finish and reset internal state.
static void get_subtitle_defaults(AVSubtitle *sub)
uint8_t * dump_separator
dump format separator.
#define FF_ENABLE_DEPRECATION_WARNINGS
planar YUV 4:4:4,42bpp, (1 Cr & Cb sample per 1x1 Y samples), little-endian
as in Berlin toast format
int channels
number of audio channels
static av_always_inline int pthread_mutex_unlock(pthread_mutex_t *mutex)
const int * supported_samplerates
array of supported audio samplerates, or NULL if unknown, array is terminated by 0 ...
struct AVCodecInternal * internal
Private context used for internal data.
unsigned avcodec_version(void)
Return the LIBAVCODEC_VERSION_INT constant.
Y , 16bpp, little-endian.
char * ass
0 terminated ASS/SSA compatible event line.
static void * avformat_mutex
int key_frame
1 -> keyframe, 0-> not
unsigned av_codec_get_codec_properties(const AVCodecContext *codec)
static int get_bit_rate(AVCodecContext *ctx)
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
w32threads to pthreads wrapper
int flags2
AV_CODEC_FLAG2_*.
enum AVColorPrimaries color_primaries
static const struct twinvq_data tab
unsigned int byte_buffer_size
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> out
void ff_thread_await_progress(ThreadFrame *f, int progress, int field)
Wait for earlier decoding threads to finish reference pictures.
planar YUV 4:2:2 30bpp, (1 Cr & Cb sample per 2x1 Y & A samples, big-endian)
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
av_cold void avcodec_register(AVCodec *codec)
Register the codec codec and initialize libavcodec.
int64_t pts_correction_last_dts
PTS of the last frame.
static void * av_mallocz_array(size_t nmemb, size_t size)
int frame_number
Frame counter, set by libavcodec.
void ff_frame_thread_encoder_free(AVCodecContext *avctx)
int64_t pts_correction_num_faulty_pts
Current statistics for PTS correction.
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
static int unrefcount_frame(AVCodecInternal *avci, AVFrame *frame)
AVChromaLocation
Location of chroma samples.
enum AVColorTransferCharacteristic color_trc
uint8_t * av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
planar GBR 4:4:4 48bpp, little-endian
static av_always_inline int pthread_mutex_lock(pthread_mutex_t *mutex)
static int add_metadata_from_side_data(AVPacket *avpkt, AVFrame *frame)
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
Recommmends skipping the specified number of samples.
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
#define av_malloc_array(a, b)
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
int ff_alloc_entries(AVCodecContext *avctx, int count)
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.
planar YUV 4:2:2 27bpp, (1 Cr & Cb sample per 2x1 Y & A samples), little-endian
int avpriv_unlock_avformat(void)
const uint8_t * avpriv_find_start_code(const uint8_t *av_restrict p, const uint8_t *end, uint32_t *av_restrict state)
int debug_mv
debug Code outside libavcodec should access this field using AVOptions
void ff_reset_entries(AVCodecContext *avctx)
ReplayGain information in the form of the AVReplayGain struct.
int(* init)(AVCodecContext *)
uint8_t ** extended_data
pointers to the data planes/channels.
attribute_deprecated int type
packed YUV 4:1:1, 12bpp, Cb Y0 Y1 Cr Y2 Y3
Stereoscopic 3d metadata.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
AVPixelFormat
Pixel format.
This structure stores compressed data.
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, const AVSubtitle *sub)
int(* encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
static int ff_fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)
#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
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
int strict_std_compliance
strictly follow the standard (MPEG4, ...).
planar YUV 4:2:0,18bpp, (1 Cr & Cb sample per 2x2 Y samples), big-endian
The data is the AVMatrixEncoding enum defined in libavutil/channel_layout.h.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
planar YUV 4:4:4, 30bpp, (1 Cr & Cb sample per 1x1 Y samples), big-endian
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
A dummy ID pointing at the start of subtitle codecs.
planar YUV 4:2:2,24bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
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 compat_free_buffer(void *opaque, uint8_t *data)
planar GBR 4:4:4 30bpp, little-endian
int avcodec_default_execute(AVCodecContext *c, int(*func)(AVCodecContext *c2, void *arg2), void *arg, int *ret, int count, int size)
#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 last_audio_frame
An audio frame with less than required samples has been submitted and padded with silence...
This side data should be associated with an audio stream and corresponds to enum AVAudioServiceType.
uint8_t * subtitle_header
Header containing style information for text subtitles.
FF_DISABLE_DEPRECATION_WARNINGS int avcodec_default_get_buffer(AVCodecContext *avctx, AVFrame *frame)
planar YUV 4:2:2, 20bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian