72 #if HAVE_PTHREADS || HAVE_W32THREADS || HAVE_OS2THREADS
128 if (min_size <= *size && *p)
130 min_size =
FFMAX(17 * min_size / 16 + 32, min_size);
177 static int initialized = 0;
179 if (initialized != 0)
194 return codec && codec->
decode;
206 last_avcodec = &codec->
next;
219 #if FF_API_SET_DIMENSIONS
274 *data = matrix_encoding;
422 w_align =
FFMAX(w_align, 8);
425 *width =
FFALIGN(*width, w_align);
426 *height =
FFALIGN(*height, h_align);
432 for (i = 0; i < 4; i++)
444 align =
FFMAX(linesize_align[0], linesize_align[3]);
445 linesize_align[1] <<= chroma_shift;
446 linesize_align[2] <<= chroma_shift;
447 align =
FFMAX3(align, linesize_align[1], linesize_align[2]);
448 *width =
FFALIGN(*width, align);
457 *xpos = (pos&1) * 128;
458 *ypos = ((pos>>1)^(pos<4)) * 128;
476 int buf_size,
int align)
478 int ch, planar, needed_size,
ret = 0;
483 if (buf_size < needed_size)
497 sample_fmt, align)) < 0) {
519 int w = frame->
width;
521 int tmpsize, unaligned;
537 for (i = 0; i < 4; i++)
546 for (i = 0; i < 3 && picture.
data[i + 1]; i++)
547 size[i] = picture.
data[i + 1] - picture.
data[i];
548 size[i] = tmpsize - (picture.
data[i] - picture.
data[0]);
550 for (i = 0; i < 4; i++) {
558 if (!pool->
pools[i]) {
573 int planes = planar ? ch : 1;
586 if (!pool->
pools[0]) {
601 for (i = 0; i < 4; i++)
612 int planes = pool->
planes;
664 memset(pic->
data, 0,
sizeof(pic->
data));
667 for (i = 0; i < 4 && pool->
pools[i]; i++) {
701 int is_chroma = p == 1 || p == 2;
704 for (y = 0; y <
height; y++) {
706 for (x = 0; x<bytes; x++)
707 ((uint16_t*)dst)[x] = c[p];
709 memset(dst, c[p], bytes);
722 #if FF_API_GET_BUFFER
742 static const struct {
768 memcpy(frame_sd->
data, packet_sd, size);
835 #if FF_API_GET_BUFFER
872 int override_dimensions = 1;
885 override_dimensions = 0;
902 #if FF_API_GET_BUFFER
935 priv->
avctx = *avctx;
944 #define WRAP_PLANE(ref_out, data, data_size) \
946 AVBufferRef *dummy_ref = av_buffer_ref(dummy_buf); \
948 ret = AVERROR(ENOMEM); \
951 ref_out = av_buffer_create(data, data_size, compat_release_buffer, \
954 av_frame_unref(frame); \
955 ret = AVERROR(ENOMEM); \
968 if (!desc || planes <= 0) {
973 for (i = 0; i < planes; i++) {
981 planes = planar ? avctx->
channels : 1;
1046 av_log(avctx,
AV_LOG_WARNING,
"Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1053 if (!frame->
data[0])
1085 #if FF_API_GET_BUFFER
1104 for (i = 0; i <
count; i++) {
1105 int r =
func(c, (
char *)arg + i * size);
1116 for (i = 0; i <
count; i++) {
1117 int r =
func(c, arg, i, 0);
1125 unsigned int fourcc)
1128 if (tags->
fourcc == fourcc)
1154 if (hwaccel->
id == codec_id
1155 && hwaccel->
pix_fmt == pix_fmt)
1169 "Could not find an AVHWAccel for the pixel format: %s",
1181 ret = hwa->
init(avctx);
1211 memcpy(choices, fmt, (n + 1) *
sizeof(*choices));
1236 for (n = 0; choices[
n] !=
ret; n++)
1240 choices[
n] = choices[n + 1];
1248 #if FF_API_AVFRAME_LAVC
1251 #if LIBAVCODEC_VERSION_MAJOR >= 55
1258 memset(frame, 0,
sizeof(
AVFrame));
1262 AVFrame *avcodec_alloc_frame(
void)
1267 void avcodec_free_frame(
AVFrame **frame)
1277 MAKE_ACCESSORS(AVCodecContext, codec, uint16_t*, chroma_intra_matrix)
1281 return codec->max_lowres;
1286 memset(sub, 0,
sizeof(*sub));
1293 int bits_per_sample;
1333 if ((!codec && !avctx->
codec)) {
1337 if ((codec && avctx->
codec && codec != avctx->
codec)) {
1339 "but %s passed to avcodec_open2()\n", avctx->
codec->
name, codec->
name);
1343 codec = avctx->
codec;
1437 avctx->
codec = codec;
1457 "The %s '%s' is experimental but experimental codecs are not enabled, "
1458 "add '-strict %d' if you want to use it.\n",
1463 codec_string, codec2->
name);
1475 av_log(avctx,
AV_LOG_WARNING,
"Warning: not compiled with thread support, using thread emulation\n");
1496 av_log(avctx,
AV_LOG_ERROR,
"The maximum value for lowres supported by the decoder is %d\n",
1505 "see the codecview filter instead.\n");
1524 av_log(avctx,
AV_LOG_ERROR,
"Specified sample format %s is invalid or not supported\n",
1539 av_log(avctx,
AV_LOG_ERROR,
"Specified pixel format %s is invalid or not supported\n",
1572 av_log(avctx,
AV_LOG_ERROR,
"Specified channel layout '%s' is not supported\n", buf);
1584 "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
1623 #if FF_API_AUDIOENC_DELAY
1636 else if (channels != avctx->
channels) {
1640 "Channel layout '%s' with %d channels does not match specified number of channels %d: "
1641 "ignoring specified channel layout\n",
1654 "supported with subtitles codecs\n");
1659 "subtitles character encoding will be ignored\n",
1670 iconv_t cd = iconv_open(
"UTF-8", avctx->
sub_charenc);
1671 if (cd == (iconv_t)-1) {
1674 "with input character encoding \"%s\"\n", avctx->
sub_charenc);
1680 "conversion needs a libavcodec built with iconv support "
1681 "for this codec\n");
1689 #if FF_API_AVCTX_TIMEBASE
1722 if (avpkt->
size < 0) {
1727 av_log(avctx,
AV_LOG_ERROR,
"Invalid minimum required packet size %"PRId64
" (max allowed is %d)\n",
1734 if (!avpkt->
data || avpkt->
size < size) {
1738 #if FF_API_DESTRUCT_PACKET
1748 #if FF_API_DESTRUCT_PACKET
1754 if (avpkt->
size < size) {
1760 #if FF_API_DESTRUCT_PACKET
1824 int *got_packet_ptr)
1830 int needs_realloc = !user_pkt.
data;
1832 *got_packet_ptr = 0;
1845 "with more than %d channels, but extended_data is not set.\n",
1852 if (!extended_frame)
1855 memcpy(extended_frame, frame,
sizeof(
AVFrame));
1857 frame = extended_frame;
1871 av_log(avctx,
AV_LOG_ERROR,
"more samples than frame size (avcodec_encode_audio2)\n");
1882 frame = padded_frame;
1894 ret = avctx->
codec->
encode2(avctx, avpkt, frame, got_packet_ptr);
1896 if (*got_packet_ptr) {
1911 if (user_pkt.
data) {
1912 if (user_pkt.
size >= avpkt->
size) {
1919 avpkt->
buf = user_pkt.
buf;
1921 #if FF_API_DESTRUCT_PACKET
1934 if (needs_realloc && avpkt->
data) {
1943 if (ret < 0 || !*got_packet_ptr) {
1958 #if FF_API_AUDIOENC_DELAY
1965 #if FF_API_OLD_ENCODE_AUDIO
1968 const short *samples)
1972 int ret, samples_size, got_packet;
1976 pkt.
size = buf_size;
1991 "support this codec\n");
1995 nb_samples = (int64_t)buf_size * 8 /
1998 if (nb_samples >= INT_MAX) {
2013 samples_size, 1)) < 0) {
2044 return ret ? ret : pkt.
size;
2049 #if FF_API_OLD_ENCODE_VIDEO
2054 int ret, got_packet = 0;
2063 pkt.
size = buf_size;
2080 return ret ? ret : pkt.
size;
2088 int *got_packet_ptr)
2092 int needs_realloc = !user_pkt.
data;
2094 *got_packet_ptr = 0;
2115 if (frame && (frame->
width == 0 || frame->
height == 0))
2120 ret = avctx->
codec->
encode2(avctx, avpkt, frame, got_packet_ptr);
2125 if (user_pkt.
data) {
2126 if (user_pkt.
size >= avpkt->
size) {
2133 avpkt->
buf = user_pkt.
buf;
2135 #if FF_API_DESTRUCT_PACKET
2148 if (!*got_packet_ptr)
2153 if (needs_realloc && avpkt->
data) {
2162 if (ret < 0 || !*got_packet_ptr)
2196 int64_t reordered_pts, int64_t dts)
2214 pts = reordered_pts;
2233 "changes, but PARAM_CHANGE side data was sent to it.\n");
2240 flags = bytestream_get_le32(&data);
2246 avctx->
channels = bytestream_get_le32(&data);
2264 avctx->
width = bytestream_get_le32(&data);
2265 avctx->
height = bytestream_get_le32(&data);
2337 int *got_picture_ptr,
2352 *got_picture_ptr = 0;
2372 ret = avctx->
codec->
decode(avctx, picture, got_picture_ptr,
2400 if (*got_picture_ptr) {
2421 #if FF_API_AVCTX_TIMEBASE
2429 #if FF_API_OLD_DECODE_AUDIO
2431 int *frame_size_ptr,
2435 int ret, got_frame = 0;
2441 "avcodec_decode_audio3() detected. Overriding with avcodec_default_get_buffer\n");
2443 "avcodec_decode_audio4()\n");
2450 if (ret >= 0 && got_frame) {
2456 if (*frame_size_ptr < data_size) {
2458 "the current frame (%d < %d)\n", *frame_size_ptr, data_size);
2465 if (planar && avctx->
channels > 1) {
2467 for (ch = 1; ch < avctx->
channels; ch++) {
2472 *frame_size_ptr = data_size;
2474 *frame_size_ptr = 0;
2508 uint32_t discard_padding = 0;
2525 ret = avctx->
codec->
decode(avctx, frame, got_frame_ptr, &tmp);
2528 if (ret >= 0 && *got_frame_ptr) {
2546 if(side && side_size>=10) {
2550 discard_padding =
AV_RL32(side + 4);
2551 skip_reason =
AV_RL8(side + 8);
2552 discard_reason =
AV_RL8(side + 9);
2584 if (discard_padding > 0 && discard_padding <= frame->nb_samples && *got_frame_ptr &&
2622 if (ret >= 0 && *got_frame_ptr) {
2635 #define UTF8_MAX_BYTES 4
2640 iconv_t cd = (iconv_t)-1;
2669 outb = outpkt->
data;
2670 outl = outpkt->
size;
2672 if (iconv(cd, &inb, &inl, &outb, &outl) == (
size_t)-1 ||
2673 iconv(cd,
NULL,
NULL, &outb, &outl) == (
size_t)-1 ||
2674 outl >= outpkt->
size || inl != 0) {
2681 outpkt->
size -= outl;
2682 memset(outpkt->
data + outpkt->
size, 0, outl);
2685 if (cd != (iconv_t)-1)
2697 uint32_t codepoint,
min;
2701 GET_UTF8(codepoint, *(byte++),
return 0;);
2702 min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
2703 1 << (5 * (byte - str) - 4);
2704 if (codepoint < min || codepoint >= 0x110000 ||
2705 codepoint == 0xFFFE ||
2706 codepoint >= 0xD800 && codepoint <= 0xDFFF )
2759 ret = avctx->
codec->
decode(avctx, sub, got_sub_ptr, &pkt_recoded);
2773 "Invalid UTF-8 in decoded subtitles text; "
2774 "maybe missing -sub_charenc option\n");
2780 if (tmp.
data != pkt_recoded.
data) {
2893 default :
return id;
2912 return experimental;
2970 return "unknown_codec";
2977 #define TAG_PRINT(x) \
2978 (((x) >= '0' && (x) <= '9') || \
2979 ((x) >= 'a' && (x) <= 'z') || ((x) >= 'A' && (x) <= 'Z') || \
2980 ((x) == '.' || (x) == ' ' || (x) == '-' || (x) == '_'))
2982 for (i = 0; i < 4; i++) {
2984 TAG_PRINT(codec_tag & 0xFF) ?
"%c" :
"[%d]", codec_tag & 0xFF);
2986 buf_size = buf_size > len ? buf_size - len : 0;
2996 const char *codec_name;
3004 if (!buf || buf_size <= 0)
3018 snprintf(buf, buf_size,
"%s: %s", codec_type ? codec_type :
"unknown",
3020 buf[0] ^=
'a' ^
'A';
3026 snprintf(buf + strlen(buf), buf_size - strlen(buf),
" (%s)", profile);
3031 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3032 " (%s / 0x%04X)", tag_buf, enc->
codec_tag);
3038 char detail[256] =
"(";
3042 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3072 if (strlen(detail) > 1) {
3073 detail[strlen(detail) - 2] = 0;
3079 av_strlcat(buf, new_line ? separator :
", ", buf_size);
3081 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3088 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3096 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3097 " [SAR %d:%d DAR %d:%d]",
3099 display_aspect_ratio.
num, display_aspect_ratio.
den);
3103 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3109 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3110 ", q=%d-%d", enc->
qmin, enc->
qmax);
3117 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3122 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3127 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3134 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3141 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3149 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3152 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3157 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3158 ", %d kb/s", bitrate / 1000);
3160 snprintf(buf + strlen(buf), buf_size - strlen(buf),
3202 #define LICENSE_PREFIX "libavcodec license: "
3290 if (be < 0 || be > 1)
3292 return map[
fmt][be];
3325 if (bps > 0 && ch > 0 && frame_bytes > 0 && ch < 32768 && bps < 32768)
3326 return (frame_bytes * 8LL) / (bps * ch);
3353 return 256 * sr / 245;
3358 return (480 << (sr / 22050)) / ch;
3366 case 20:
return 160;
3367 case 19:
return 144;
3368 case 29:
return 288;
3369 case 37:
return 480;
3373 case 38:
return 160;
3374 case 50:
return 240;
3379 if (frame_bytes > 0) {
3382 return 240 * (frame_bytes / 32);
3384 return 256 * (frame_bytes / 64);
3386 return 160 * (frame_bytes / 20);
3388 return 240 * (frame_bytes / 24);
3393 return frame_bytes * 8 /
bps;
3400 return frame_bytes / (9 * ch) * 16;
3402 return frame_bytes / (16 * ch) * 28;
3405 return (frame_bytes - 4 * ch) * 2 / ch;
3407 return (frame_bytes - 4) * 2 / ch;
3409 return (frame_bytes - 8) * 2 / ch;
3411 return (frame_bytes / 128) * 224 / ch;
3413 return (frame_bytes - 6 - ch) / ch;
3415 return (frame_bytes - 8) / ch;
3417 return (frame_bytes - 2 * ch) / ch;
3419 return 3 * frame_bytes / ch;
3421 return 6 * frame_bytes / ch;
3423 return 2 * (frame_bytes / (5 * ch));
3426 return 4 * frame_bytes / ch;
3433 return frame_bytes / ch;
3435 return frame_bytes * 2 / ch;
3441 int blocks = frame_bytes / ba;
3444 if (bps < 2 || bps > 5)
3446 return blocks * (1 + (ba - 4 * ch) / (bps * ch) * 8);
3448 return blocks * (((ba - 16) * 2 / 3 * 4) / ch);
3450 return blocks * (1 + (ba - 4 * ch) * 2 / ch);
3452 return blocks * ((ba - 4 * ch) * 2 / ch);
3454 return blocks * (2 + (ba - 7 * ch) * 2 / ch);
3464 return 2 * (frame_bytes / ((bps * 2 / 8) * ch));
3468 return frame_bytes / ((
FFALIGN(ch, 2) *
bps) / 8);
3470 return 2 * (frame_bytes / ((bps + 4) / 4)) / ch;
3515 for (i = 0; i < size && !(
tab[i][0] == a &&
tab[i][1] ==
b); i++) ;
3519 #if FF_API_MISSING_SAMPLE
3524 "version to the newest one from Git. If the problem still "
3525 "occurs, it means that your file has a feature which has not "
3526 "been implemented.\n", feature);
3533 va_list argument_list;
3535 va_start(argument_list, msg);
3540 "of this file to ftp://upload.ffmpeg.org/incoming/ "
3541 "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n");
3543 va_end(argument_list);
3557 last_hwaccel = &hwaccel->
next;
3578 void *new_codec_mutex =
NULL;
3579 void *new_avformat_mutex =
NULL;
3605 av_log(log_ctx,
AV_LOG_ERROR,
"Insufficient thread locking around avcodec_open/close()\n");
3607 av_log(log_ctx,
AV_LOG_ERROR,
"No lock manager is set, please see av_lockmgr_register()\n");
3653 ((
unsigned)
av_toupper((x >> 24) & 0xFF) << 24);
3790 for (i = 0; i < 3; i++) {
3791 uint32_t tmp = *state << 8;
3792 *state = tmp + *(p++);
3793 if (tmp == 0x100 || p == end)
3798 if (p[-1] > 1 ) p += 3;
3799 else if (p[-2] ) p += 2;
3800 else if (p[-3]|(p[-1]-1)) p++;
3807 p =
FFMIN(p, end) - 4;
#define WRAP_PLANE(ref_out, data, data_size)
#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)
#define CONFIG_FRAME_THREAD_ENCODER
const struct AVCodec * codec
planar YUV 4:2:2, 18bpp, (1 Cr & Cb sample per 2x1 Y samples), big-endian
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: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 CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
#define CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
int coded_width
Bitstream width / height, may be different from width/height e.g.
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 CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
AVFrame * coded_frame
the picture in the bitstream
#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.
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 FF_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.
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everythnig 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.
#define FF_ARRAY_ELEMS(a)
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.
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
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
int ff_lock_avcodec(AVCodecContext *log_ctx)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and/or allocate data.
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)
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 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.
#define CODEC_CAP_HWACCEL_VDPAU
Codec can export data for HW decoding (VDPAU).
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.
int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
planar YUV 4:2:0 40bpp, (1 Cr & Cb sample per 2x2 Y & A samples, little-endian)
void * frame_thread_encoder
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 GBR 4:4:4 48bpp, big-endian
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of 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();
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of PIX_FMT_YUV422P and setting color_...
planar YUV 4:4:4 64bpp, (1 Cr & Cb sample per 1x1 Y & A samples, big-endian)
#define AV_LOG_VERBOSE
Detailed information.
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).
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
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.
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
#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 CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
#define AV_EF_EXPLODE
abort decoding on minor error detection
#define CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#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...
#define CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
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 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)
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
int av_packet_merge_side_data(AVPacket *pkt)
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_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
#define FF_MAX_EXTRADATA_SIZE
Maximum size in bytes of extradata.
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
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.
volatile int ff_avcodec_locked
#define FF_MIN_BUFFER_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
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 PIX_FMT_YUV420P and setting color_...
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 CODEC_CAP_AUTO_THREADS
Codec supports avctx->thread_count == 0 (auto).
void av_frame_set_pkt_pos(AVFrame *frame, int64_t val)
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
#define CODEC_FLAG2_SKIP_MANUAL
Do not skip samples and export skip information as frame side data.
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...
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.
static int ff_fast_malloc(void *ptr, unsigned int *size, size_t min_size, int zero_realloc)
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...
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.
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 attribute_align_arg
#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.
static int add_metadata_from_side_data(AVCodecContext *avctx, AVFrame *frame)
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.
AVDictionary ** avpriv_frame_get_metadatap(AVFrame *frame)
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
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.
int sample_rate
samples per second
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
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
#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.
#define CONFIG_MEMORY_POISONING
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
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 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_dlog(ac->avr,"%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
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)
void av_register_hwaccel(AVHWAccel *hwaccel)
Register the hardware accelerator hwaccel.
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.
#define CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
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 PIX_FMT_YUV444P and setting color_...
int ff_thread_can_start_frame(AVCodecContext *avctx)
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)
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 FFMPEG_CONFIGURATION
void avcodec_string(char *buf, int buf_size, AVCodecContext *enc, int encode)
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
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
enum AVColorPrimaries color_primaries
static const struct twinvq_data tab
unsigned int byte_buffer_size
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 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.
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.
#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
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
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