30 #define CACHED_BITSTREAM_READER !ARCH_X86_32 31 #define UNCHECKED_BITSTREAM_READER 1 49 int *fsym,
unsigned nb_elems)
54 uint16_t codes_count[33] = { 0 };
57 for (i = 0; i < nb_elems; i++) {
61 }
else if (src[i] == 255) {
63 }
else if (src[i] <= 32) {
68 codes_count[bits[
i]]++;
70 if (codes_count[0] == nb_elems)
78 for (
int i = 31; i >= 0; i--)
79 codes_count[i] += codes_count[i + 1];
81 for (
unsigned i = 0; i < nb_elems; i++)
82 he[--codes_count[bits[i]]] = (
HuffEntry) { bits[
i], i };
86 &he[0].
len,
sizeof(*he),
87 &he[0].
sym,
sizeof(*he), 2, 0, 0, c->
avctx);
91 uint16_t *dst, ptrdiff_t
stride,
96 int i, j, slice, pix,
ret;
102 if ((ret =
build_huff(c, huff, &vlc, &fsym, 1024)) < 0) {
108 for (slice = 0; slice < c->
slices; slice++) {
112 send = (height * (slice + 1) / c->
slices);
113 dest = dst + sstart *
stride;
116 for (j = sstart; j < send; j++) {
117 for (i = 0; i <
width; i++) {
133 for (slice = 0; slice < c->
slices; slice++) {
135 int slice_data_start, slice_data_end, slice_size;
138 send = (height * (slice + 1) / c->
slices);
139 dest = dst + sstart *
stride;
142 slice_data_start = slice ?
AV_RL32(src + slice * 4 - 4) : 0;
143 slice_data_end =
AV_RL32(src + slice * 4);
144 slice_size = slice_data_end - slice_data_start;
148 "yet a slice has a length of zero.\n");
154 (uint32_t *)(src + slice_data_start + c->
slices * 4),
155 (slice_data_end - slice_data_start + 3) >> 2);
159 for (j = sstart; j < send; j++) {
160 for (i = 0; i <
width; i++) {
176 "Slice decoding ran out of bits\n");
198 return ~(1 + 2 * is_luma);
208 int i, j, slice, pix;
217 for (slice = 0; slice < c->
slices; slice++) {
230 send = (height * (slice + 1) / c->
slices) & cmask;
231 dest = dst + sstart *
stride;
233 if (3 * ((dst + send * stride - dest + 7)/8) >
get_bits_left(&cbit))
236 for (p = dest; p < dst + send *
stride; p += 8) {
242 uint32_t
sub = 0x80 >> (8 - (bits + 1)),
add;
248 for (k = 0; k < 8; k++) {
251 add = (~p[k] &
sub) << (8 - bits);
268 for (slice = 0; slice < c->
slices; slice++) {
272 send = (height * (slice + 1) / c->
slices) & cmask;
273 dest = dst + sstart *
stride;
276 for (j = sstart; j < send; j++) {
277 for (i = 0; i <
width; i++) {
280 prev += (unsigned)pix;
294 for (slice = 0; slice < c->
slices; slice++) {
296 int slice_data_start, slice_data_end, slice_size;
299 send = (height * (slice + 1) / c->
slices) & cmask;
300 dest = dst + sstart *
stride;
303 slice_data_start = slice ?
AV_RL32(src + slice * 4 - 4) : 0;
304 slice_data_end =
AV_RL32(src + slice * 4);
305 slice_size = slice_data_end - slice_data_start;
309 "yet a slice has a length of zero.\n");
315 (uint32_t *)(src + slice_data_start + c->
slices * 4),
316 (slice_data_end - slice_data_start + 3) >> 2);
320 for (j = sstart; j < send; j++) {
321 for (i = 0; i <
width; i++) {
335 "Slice decoding ran out of bits\n");
363 int slice_start, slice_height;
364 const int cmask = ~rmode;
366 for (slice = 0; slice < slices; slice++) {
367 slice_start = ((slice *
height) / slices) & cmask;
368 slice_height = ((((slice + 1) * height) / slices) & cmask) -
373 bsrc = src + slice_start *
stride;
379 if (slice_height <= 1)
385 for (i = 1; i <
FFMIN(width, 16); i++) {
393 bsrc + 16, width - 16, &A, &B);
397 for (j = 2; j < slice_height; j++) {
399 bsrc, width, &A, &B);
415 int slice_start, slice_height;
416 const int cmask = ~(rmode ? 3 : 1);
417 const ptrdiff_t stride2 = stride << 1;
419 for (slice = 0; slice < slices; slice++) {
420 slice_start = ((slice *
height) / slices) & cmask;
421 slice_height = ((((slice + 1) * height) / slices) & cmask) -
427 bsrc = src + slice_start *
stride;
434 if (slice_height <= 1)
440 for (i = 1; i <
FFMIN(width, 16); i++) {
441 B = bsrc[i - stride2];
448 bsrc + 16, width - 16, &A, &B);
451 bsrc + stride, width, &A, &B);
454 for (j = 2; j < slice_height; j++) {
456 bsrc, width, &A, &B);
458 bsrc + stride, width, &A, &B);
470 int slice_start, slice_height;
471 const int cmask = ~rmode;
472 int min_width =
FFMIN(width, 32);
474 for (slice = 0; slice < slices; slice++) {
475 slice_start = ((slice *
height) / slices) & cmask;
476 slice_height = ((((slice + 1) * height) / slices) & cmask) -
481 bsrc = src + slice_start *
stride;
487 if (slice_height <= 1)
489 for (j = 1; j < slice_height; j++) {
491 bsrc[0] = (bsrc[0] + bsrc[-
stride]) & 0xFF;
492 for (i = 1; i < min_width; i++) {
494 B = bsrc[i - (stride + 1)];
496 bsrc[
i] = (A - B + C + bsrc[
i]) & 0xFF;
511 int slice_start, slice_height;
512 const int cmask = ~(rmode ? 3 : 1);
513 const ptrdiff_t stride2 = stride << 1;
514 int min_width =
FFMIN(width, 32);
516 for (slice = 0; slice < slices; slice++) {
517 slice_start = ((slice *
height) / slices) & cmask;
518 slice_height = ((((slice + 1) * height) / slices) & cmask) -
524 bsrc = src + slice_start *
stride;
531 if (slice_height <= 1)
533 for (j = 1; j < slice_height; j++) {
535 bsrc[0] = (bsrc[0] + bsrc[-stride2]) & 0xFF;
536 for (i = 1; i < min_width; i++) {
537 A = bsrc[i - stride2];
538 B = bsrc[i - (stride2 + 1)];
540 bsrc[
i] = (A - B + C + bsrc[
i]) & 0xFF;
546 B = bsrc[-(1 + stride + stride -
width)];
549 for (i = 1; i <
width; i++) {
551 B = bsrc[i - (1 +
stride)];
553 bsrc[i +
stride] = (A - B + C + bsrc[i +
stride]) & 0xFF;
564 int buf_size = avpkt->
size;
568 int plane_size, max_slice_size = 0, slice_start,
slice_end, slice_size;
588 if (bytestream2_get_byte(&gb) != 1)
591 c->
offset = bytestream2_get_le32(&gb);
593 if (buf_size <= c->
offset + 8LL)
598 nb_cbs = bytestream2_get_le32(&pb);
602 packed_stream = buf + 8;
603 control_stream = packed_stream + (c->
offset - nb_cbs);
604 left = control_stream - packed_stream;
606 for (i = 0; i < c->
planes; i++) {
607 for (j = 0; j < c->
slices; j++) {
617 left = buf + buf_size - control_stream;
619 for (i = 0; i < c->
planes; i++) {
620 for (j = 0; j < c->
slices; j++) {
636 for (i = 0; i < c->
planes; i++) {
644 for (j = 0; j < c->
slices; j++) {
645 slice_end = bytestream2_get_le32u(&gb);
646 if (slice_end < 0 || slice_end < slice_start ||
651 slice_size = slice_end - slice_start;
653 max_slice_size =
FFMAX(max_slice_size, slice_size);
661 for (i = 0; i < c->
planes; i++) {
670 for (j = 0; j < c->
slices; j++) {
671 slice_end = bytestream2_get_le32u(&gb);
672 if (slice_end < 0 || slice_end < slice_start ||
677 slice_size = slice_end - slice_start;
679 max_slice_size =
FFMAX(max_slice_size, slice_size);
696 max_slice_size += 4*avctx->
width;
711 for (i = 0; i < c->
planes; i++) {
714 avctx->
height, plane_start[i],
748 for (i = 0; i < c->
planes; i++) {
751 avctx->
height, plane_start[i],
752 plane_start[i + 1] - 1024,
762 for (i = 0; i < 3; i++) {
794 for (i = 0; i < 3; i++) {
824 for (i = 0; i < 3; i++) {
854 for (i = 0; i < 3; i++) {
863 for (i = 0; i < 3; i++) {
886 int h_shift, v_shift;
897 case MKTAG(
'U',
'L',
'R',
'G'):
901 case MKTAG(
'U',
'L',
'R',
'A'):
905 case MKTAG(
'U',
'L',
'Y',
'0'):
910 case MKTAG(
'U',
'L',
'Y',
'2'):
915 case MKTAG(
'U',
'L',
'Y',
'4'):
920 case MKTAG(
'U',
'Q',
'Y',
'0'):
925 case MKTAG(
'U',
'Q',
'Y',
'2'):
930 case MKTAG(
'U',
'Q',
'R',
'G'):
935 case MKTAG(
'U',
'Q',
'R',
'A'):
940 case MKTAG(
'U',
'L',
'H',
'0'):
945 case MKTAG(
'U',
'L',
'H',
'2'):
950 case MKTAG(
'U',
'L',
'H',
'4'):
955 case MKTAG(
'U',
'M',
'Y',
'2'):
961 case MKTAG(
'U',
'M',
'H',
'2'):
967 case MKTAG(
'U',
'M',
'Y',
'4'):
973 case MKTAG(
'U',
'M',
'H',
'4'):
979 case MKTAG(
'U',
'M',
'R',
'G'):
984 case MKTAG(
'U',
'M',
'R',
'A'):
996 if ((avctx->
width & ((1<<h_shift)-1)) ||
997 (avctx->
height & ((1<<v_shift)-1))) {
1037 "Insufficient extradata size %d, should be at least 16\n",
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
static void restore_median_planar_il(UtvideoContext *c, uint8_t *src, ptrdiff_t stride, int width, int height, int slices, int rmode)
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
int(* add_left_pred)(uint8_t *dst, const uint8_t *src, ptrdiff_t w, int left)
static enum AVPixelFormat pix_fmt
ptrdiff_t const GLvoid * data
#define AV_PIX_FMT_GBRAP10
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
#define AV_LOG_WARNING
Something somehow does not look correct.
static av_cold int init(AVCodecContext *avctx)
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
#define avpriv_request_sample(...)
#define AV_PIX_FMT_GBRP10
void(* restore_rgb_planes10)(uint16_t *src_r, uint16_t *src_g, uint16_t *src_b, ptrdiff_t linesize_r, ptrdiff_t linesize_g, ptrdiff_t linesize_b, int width, int height)
static av_cold int decode_end(AVCodecContext *avctx)
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
av_cold void ff_utvideodsp_init(UTVideoDSPContext *c)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
static void restore_gradient_planar(UtvideoContext *c, uint8_t *src, ptrdiff_t stride, int width, int height, int slices, int rmode)
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
static void restore_gradient_planar_il(UtvideoContext *c, uint8_t *src, ptrdiff_t stride, int width, int height, int slices, int rmode)
Multithreading support functions.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
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
void(* add_median_pred)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, ptrdiff_t w, int *left, int *left_top)
static av_always_inline void bytestream2_skipu(GetByteContext *g, unsigned int size)
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
static int decode_plane10(UtvideoContext *c, int plane_no, uint16_t *dst, ptrdiff_t stride, int width, int height, const uint8_t *src, const uint8_t *huff, int use_pred)
void(* add_gradient_pred)(uint8_t *src, const ptrdiff_t stride, const ptrdiff_t width)
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
static int get_bits_left(GetBitContext *gb)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_cold int decode_init(AVCodecContext *avctx)
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
const char * name
Name of the codec implementation.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames.The frames must then be freed with ff_thread_release_buffer().Otherwise decode directly into the user-supplied frames.Call ff_thread_report_progress() after some part of the current picture has decoded.A good place to put this is where draw_horiz_band() is called-add this if it isn't called anywhere
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
void(* restore_rgb_planes)(uint8_t *src_r, uint8_t *src_g, uint8_t *src_b, ptrdiff_t linesize_r, ptrdiff_t linesize_g, ptrdiff_t linesize_b, int width, int height)
static void restore_median_planar(UtvideoContext *c, uint8_t *src, ptrdiff_t stride, int width, int height, int slices, int rmode)
enum AVPictureType pict_type
Picture type of the frame.
static int compute_cmask(int plane_no, int interlaced, enum AVPixelFormat pix_fmt)
int width
picture width / height.
size_t control_stream_size[4][256]
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going which in turn will define variables for the build system and the C
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
main external API structure.
const uint8_t * control_stream[4][256]
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2]...the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so...,+,-,+,-,+,+,-,+,-,+,...hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32-hcoeff[1]-hcoeff[2]-...a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2}an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||.........intra?||||:Block01:yes no||||:Block02:.................||||:Block03::y DC::ref index:||||:Block04::cb DC::motion x:||||.........:cr DC::motion y:||||.................|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------------------------------|||Y subbands||Cb subbands||Cr subbands||||------||------||------|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||------||------||------||||------||------||------|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||------||------||------||||------||------||------|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||------||------||------||||------||------||------|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------------------------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction------------|\Dequantization-------------------\||Reference frames|\IDWT|--------------|Motion\|||Frame 0||Frame 1||Compensation.OBMC v-------|--------------|--------------.\------> Frame n output Frame Frame<----------------------------------/|...|-------------------Range Coder:============Binary Range Coder:-------------------The implemented range coder is an adapted version based upon"Range encoding: an algorithm for removing redundancy from a digitised message."by G.N.N.Martin.The symbols encoded by the Snow range coder are bits(0|1).The associated probabilities are not fix but change depending on the symbol mix seen so far.bit seen|new state---------+-----------------------------------------------0|256-state_transition_table[256-old_state];1|state_transition_table[old_state];state_transition_table={0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:-------------------------FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1.the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
void ff_llviddsp_init(LLVidDSPContext *c)
#define AV_PIX_FMT_YUV420P10
enum AVColorSpace colorspace
YUV colorspace type.
int ff_init_vlc_from_lengths(VLC *vlc_arg, int nb_bits, int nb_codes, const int8_t *lens, int lens_wrap, const void *symbols, int symbols_wrap, int symbols_size, int offset, int flags, void *logctx)
Build VLC decoding tables suitable for use with get_vlc2()
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static unsigned int get_bits_le(GetBitContext *s, int n)
#define AV_PIX_FMT_YUV422P10
static int decode_plane(UtvideoContext *c, int plane_no, uint8_t *dst, ptrdiff_t stride, int width, int height, const uint8_t *src, int use_pred)
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
GLint GLenum GLboolean GLsizei stride
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
common internal api header.
planar GBRA 4:4:4:4 32bpp
static int build_huff(UtvideoContext *c, const uint8_t *src, VLC *vlc, int *fsym, unsigned nb_elems)
static int init_get_bits8_le(GetBitContext *s, const uint8_t *buffer, int byte_size)
size_t packed_stream_size[4][256]
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
VLC_TYPE(* table)[2]
code, bits
int key_frame
1 -> keyframe, 0-> not
static float add(float src0, float src1)
const uint8_t * packed_stream[4][256]
static float sub(float src0, float src1)
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
#define MKTAG(a, b, c, d)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
AVPixelFormat
Pixel format.
AVCodec ff_utvideo_decoder
This structure stores compressed data.
void ff_free_vlc(VLC *vlc)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.