56 #define BS_8BIT_PEL (1 << 1)
57 #define BS_KEYFRAME (1 << 2)
58 #define BS_MV_Y_HALF (1 << 4)
59 #define BS_MV_X_HALF (1 << 5)
60 #define BS_NONREF (1 << 8)
64 typedef struct Plane {
72 #define CELL_STACK_MAX 20
121 static const int8_t
offsets[8] = { 1, 1, 2, -3, -3, 3, 4, 4 };
122 static const int8_t deltas [8] = { 0, 1, 0, 4, 4, 1, 0, 1 };
126 for (
i = 0;
i < 8;
i++) {
128 for (j = 0; j < 128; j++)
155 ctx->width =
ctx->height = 0;
157 for (p = 0; p < 3; p++) {
160 ctx->planes[p].pixels[0] =
ctx->planes[p].pixels[1] = 0;
168 int p, chroma_width, chroma_height;
169 int luma_size, chroma_size;
170 ptrdiff_t luma_pitch, chroma_pitch;
172 if (luma_width < 16 || luma_width > 640 ||
173 luma_height < 16 || luma_height > 480 ||
174 luma_width & 1 || luma_height & 1) {
176 luma_width, luma_height);
180 ctx->width = luma_width ;
181 ctx->height = luma_height;
183 chroma_width =
FFALIGN(luma_width >> 2, 4);
184 chroma_height =
FFALIGN(luma_height >> 2, 4);
186 luma_pitch =
FFALIGN(luma_width, 16);
187 chroma_pitch =
FFALIGN(chroma_width, 16);
191 luma_size = luma_pitch * (luma_height + 1);
195 chroma_size = chroma_pitch * (chroma_height + 1);
198 for (p = 0; p < 3; p++) {
199 ctx->planes[p].pitch = !p ? luma_pitch : chroma_pitch;
200 ctx->planes[p].width = !p ? luma_width : chroma_width;
201 ctx->planes[p].height = !p ? luma_height : chroma_height;
203 ctx->planes[p].buffers[0] =
av_malloc(!p ? luma_size : chroma_size);
204 ctx->planes[p].buffers[1] =
av_malloc(!p ? luma_size : chroma_size);
206 if (!
ctx->planes[p].buffers[0] || !
ctx->planes[p].buffers[1])
210 memset(
ctx->planes[p].buffers[0], 0x40,
ctx->planes[p].pitch);
211 memset(
ctx->planes[p].buffers[1], 0x40,
ctx->planes[p].pitch);
214 ctx->planes[p].pixels[0] =
ctx->planes[p].buffers[0] +
ctx->planes[p].pitch;
215 ctx->planes[p].pixels[1] =
ctx->planes[p].buffers[1] +
ctx->planes[p].pitch;
216 memset(
ctx->planes[p].pixels[0], 0,
ctx->planes[p].pitch *
ctx->planes[p].height);
217 memset(
ctx->planes[p].pixels[1], 0,
ctx->planes[p].pitch *
ctx->planes[p].height);
233 int h,
w, mv_x, mv_y,
offset, offset_dst;
237 offset_dst = (
cell->ypos << 2) * plane->
pitch + (
cell->xpos << 2);
238 dst = plane->
pixels[
ctx->buf_sel] + offset_dst;
240 mv_y =
cell->mv_ptr[0];
241 mv_x =
cell->mv_ptr[1];
246 if ((
cell->ypos << 2) + mv_y < -1 || (
cell->xpos << 2) + mv_x < 0 ||
250 "Motion vectors point out of the frame.\n");
257 h =
cell->height << 2;
259 for (
w =
cell->width;
w > 0;) {
261 if (!((
cell->xpos << 2) & 15) &&
w >= 4) {
262 for (;
w >= 4;
src += 16, dst += 16,
w -= 4)
263 ctx->hdsp.put_pixels_tab[0][0](dst,
src, plane->
pitch,
h);
267 if (!((
cell->xpos << 2) & 7) &&
w >= 2) {
268 ctx->hdsp.put_pixels_tab[1][0](dst,
src, plane->
pitch,
h);
273 ctx->hdsp.put_pixels_tab[2][0](dst,
src, plane->
pitch,
h);
285 #define AVG_32(dst, src, ref) \
286 AV_WN32A(dst, ((AV_RN32(src) + AV_RN32(ref)) >> 1) & 0x7F7F7F7FUL)
288 #define AVG_64(dst, src, ref) \
289 AV_WN64A(dst, ((AV_RN64(src) + AV_RN64(ref)) >> 1) & 0x7F7F7F7F7F7F7F7FULL)
298 a &= 0xFF00FF00FF00FF00ULL;
301 a &= 0x00FF00FF00FF00FFULL;
323 for (; n > 0; dst += row_offset, n--)
339 #define BUFFER_PRECHECK \
340 if (*data_ptr >= last_ptr) \
341 return IV3_OUT_OF_DATA; \
343 #define RLE_BLOCK_COPY \
344 if (cell->mv_ptr || !skip_flag) \
345 copy_block4(dst, ref, row_offset, row_offset, 4 << v_zoom)
347 #define RLE_BLOCK_COPY_8 \
348 pix64 = AV_RN64(ref);\
350 pix64 = replicate64(pix64);\
351 fill_64(dst + row_offset, pix64, 7, row_offset);\
352 AVG_64(dst, ref, dst + row_offset);\
354 fill_64(dst, pix64, 8, row_offset)
356 #define RLE_LINES_COPY \
357 copy_block4(dst, ref, row_offset, row_offset, num_lines << v_zoom)
359 #define RLE_LINES_COPY_M10 \
360 pix64 = AV_RN64(ref);\
361 if (is_top_of_cell) {\
362 pix64 = replicate64(pix64);\
363 fill_64(dst + row_offset, pix64, (num_lines << 1) - 1, row_offset);\
364 AVG_64(dst, ref, dst + row_offset);\
366 fill_64(dst, pix64, num_lines << 1, row_offset)
368 #define APPLY_DELTA_4 \
369 AV_WN16A(dst + line_offset ,\
370 (AV_RN16(ref ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
371 AV_WN16A(dst + line_offset + 2,\
372 (AV_RN16(ref + 2) + delta_tab->deltas[dyad2]) & 0x7F7F);\
374 if (is_top_of_cell && !cell->ypos) {\
375 AV_COPY32U(dst, dst + row_offset);\
377 AVG_32(dst, ref, dst + row_offset);\
381 #define APPLY_DELTA_8 \
383 if (is_top_of_cell) { \
384 AV_WN32A(dst + row_offset , \
385 (replicate32(AV_RN32(ref )) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
386 AV_WN32A(dst + row_offset + 4, \
387 (replicate32(AV_RN32(ref + 4)) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
389 AV_WN32A(dst + row_offset , \
390 (AV_RN32(ref ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
391 AV_WN32A(dst + row_offset + 4, \
392 (AV_RN32(ref + 4) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
397 if (is_top_of_cell && !cell->ypos) {\
398 AV_COPY64U(dst, dst + row_offset);\
400 AVG_64(dst, ref, dst + row_offset);
403 #define APPLY_DELTA_1011_INTER \
406 (AV_RN32(dst ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
408 (AV_RN32(dst + 4 ) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
409 AV_WN32A(dst + row_offset , \
410 (AV_RN32(dst + row_offset ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
411 AV_WN32A(dst + row_offset + 4, \
412 (AV_RN32(dst + row_offset + 4) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
415 (AV_RN16(dst ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
417 (AV_RN16(dst + 2 ) + delta_tab->deltas[dyad2]) & 0x7F7F);\
418 AV_WN16A(dst + row_offset , \
419 (AV_RN16(dst + row_offset ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
420 AV_WN16A(dst + row_offset + 2, \
421 (AV_RN16(dst + row_offset + 2) + delta_tab->deltas[dyad2]) & 0x7F7F);\
427 ptrdiff_t row_offset,
int h_zoom,
int v_zoom,
int mode,
431 int x, y,
line, num_lines;
435 unsigned int dyad1, dyad2;
437 int skip_flag = 0, is_top_of_cell, is_first_row = 1;
438 int blk_row_offset, line_offset;
440 blk_row_offset = (row_offset << (2 + v_zoom)) - (
cell->width << 2);
441 line_offset = v_zoom ? row_offset : 0;
443 if (
cell->height & v_zoom ||
cell->width & h_zoom)
446 for (y = 0; y <
cell->height; is_first_row = 0, y += 1 + v_zoom) {
447 for (x = 0; x <
cell->width; x += 1 + h_zoom) {
451 if (rle_blocks > 0) {
454 }
else if (
mode == 10 && !
cell->mv_ptr) {
461 is_top_of_cell = is_first_row && !
line;
467 delta_tab =
delta[1];
469 code = bytestream_get_byte(data_ptr);
471 if (code < delta_tab->num_dyads) {
473 dyad1 = bytestream_get_byte(data_ptr);
475 if (dyad1 >= delta_tab->
num_dyads || dyad1 >= 248)
482 if (swap_quads[
line & 1])
483 FFSWAP(
unsigned int, dyad1, dyad2);
487 }
else if (
mode == 10 && !
cell->mv_ptr) {
508 }
else if (
mode == 10 && !
cell->mv_ptr) {
514 code = bytestream_get_byte(data_ptr);
515 rle_blocks = (
code & 0x1F) - 1;
516 if (
code >= 64 || rle_blocks < 0)
518 skip_flag =
code & 0x20;
519 num_lines = 4 -
line;
520 if (
mode >= 10 || (
cell->mv_ptr || !skip_flag)) {
523 }
else if (
mode == 10 && !
cell->mv_ptr) {
539 }
else if (
mode == 10 && !
cell->mv_ptr) {
550 ref += row_offset * (num_lines << v_zoom);
551 dst += row_offset * (num_lines << v_zoom);
556 block += 4 << h_zoom;
557 ref_block += 4 << h_zoom;
561 ref_block += blk_row_offset;
562 block += blk_row_offset;
585 int x, mv_x, mv_y,
mode, vq_index, prim_indx, second_indx;
590 const uint8_t *data_start = data_ptr;
595 vq_index =
code & 0xF;
604 }
else if (
mode >= 10) {
612 mv_y =
cell->mv_ptr[0];
613 mv_x =
cell->mv_ptr[1];
616 if ((
cell->ypos << 2) + mv_y < -1 || (
cell->xpos << 2) + mv_x < 0 ||
620 "Motion vectors point out of the frame.\n");
632 code =
ctx->alt_quant[vq_index];
633 prim_indx = (
code >> 4) +
ctx->cb_offset;
634 second_indx = (
code & 0xF) +
ctx->cb_offset;
636 vq_index +=
ctx->cb_offset;
637 prim_indx = second_indx = vq_index;
640 if (prim_indx >= 24 || second_indx >= 24) {
641 av_log(avctx,
AV_LOG_ERROR,
"Invalid VQ table indexes! Primary: %d, secondary: %d!\n",
642 prim_indx, second_indx);
648 swap_quads[0] = second_indx >= 16;
649 swap_quads[1] = prim_indx >= 16;
653 if (vq_index >= 8 && ref_block) {
654 for (x = 0; x <
cell->width << 2; x++)
655 ref_block[x] =
requant_tab[vq_index & 7][ref_block[x] & 127];
670 zoom_fac =
mode >= 3;
673 &data_ptr, last_ptr);
680 &data_ptr, last_ptr);
687 zoom_fac =
mode == 10;
690 &data_ptr, last_ptr);
700 av_log(avctx,
AV_LOG_ERROR,
"Mode %d: RLE code %X is not allowed at the current line\n",
717 return data_ptr - data_start;
730 #define SPLIT_CELL(size, new_size) (new_size) = ((size) > 2) ? ((((size) + 2) >> 2) << 1) : 1
732 #define UPDATE_BITPOS(n) \
733 ctx->skip_bits += (n); \
736 #define RESYNC_BITSTREAM \
737 if (ctx->need_resync && !(get_bits_count(&ctx->gb) & 7)) { \
738 skip_bits_long(&ctx->gb, ctx->skip_bits); \
739 ctx->skip_bits = 0; \
740 ctx->need_resync = 0; \
744 if (curr_cell.xpos + curr_cell.width > (plane->width >> 2) || \
745 curr_cell.ypos + curr_cell.height > (plane->height >> 2)) { \
746 av_log(avctx, AV_LOG_ERROR, "Invalid cell: x=%d, y=%d, w=%d, h=%d\n", \
747 curr_cell.xpos, curr_cell.ypos, curr_cell.width, curr_cell.height); \
748 return AVERROR_INVALIDDATA; \
754 const int depth,
const int strip_width)
764 curr_cell = *ref_cell;
772 if (curr_cell.
width > strip_width) {
774 curr_cell.
width = (curr_cell.
width <= (strip_width << 1) ? 1 : 2) * strip_width;
779 if (ref_cell->
width <= 0 || curr_cell.
width <= 0)
792 if (!curr_cell.
tree) {
814 if (!curr_cell.
tree) {
817 if (!
ctx->need_resync)
819 if (
ctx->next_cell_data >=
ctx->last_byte) {
823 mv_idx = *(
ctx->next_cell_data++);
824 if (mv_idx >=
ctx->num_vectors) {
828 curr_cell.
mv_ptr = &
ctx->mc_vectors[mv_idx << 1];
832 if (!
ctx->need_resync)
837 ctx->next_cell_data,
ctx->last_byte);
842 ctx->next_cell_data += bytes_used;
858 unsigned num_vectors;
862 num_vectors = bytestream_get_le32(&
data); data_size -= 4;
863 if (num_vectors > 256) {
865 "Read invalid number of motion vectors %d\n", num_vectors);
868 if (num_vectors * 2 > data_size)
871 ctx->num_vectors = num_vectors;
872 ctx->mc_vectors = num_vectors ?
data : 0;
877 ctx->need_resync = 0;
879 ctx->last_byte =
data + data_size;
882 curr_cell.
xpos = curr_cell.
ypos = 0;
892 #define OS_HDR_ID MKBETAG('F', 'R', 'M', 'H')
895 const uint8_t *buf,
int buf_size)
899 uint32_t frame_num, word2, check_sum, data_size;
900 int y_offset, u_offset, v_offset;
901 uint32_t starts[3], ends[3];
908 frame_num = bytestream2_get_le32(&gb);
909 word2 = bytestream2_get_le32(&gb);
910 check_sum = bytestream2_get_le32(&gb);
911 data_size = bytestream2_get_le32(&gb);
913 if ((frame_num ^ word2 ^ data_size ^
OS_HDR_ID) != check_sum) {
921 if (bytestream2_get_le16(&gb) != 32) {
926 ctx->frame_num = frame_num;
927 ctx->frame_flags = bytestream2_get_le16(&gb);
928 ctx->data_size = (bytestream2_get_le32(&gb) + 7) >> 3;
929 ctx->cb_offset = bytestream2_get_byte(&gb);
931 if (
ctx->data_size == 16)
933 ctx->data_size =
FFMIN(
ctx->data_size, buf_size - 16);
938 height = bytestream2_get_le16(&gb);
939 width = bytestream2_get_le16(&gb);
946 ff_dlog(avctx,
"Frame dimensions changed!\n");
948 if (width < 16 || width > 640 ||
949 height < 16 || height > 480 ||
952 "Invalid picture dimensions: %d x %d!\n",
width,
height);
962 y_offset = bytestream2_get_le32(&gb);
963 v_offset = bytestream2_get_le32(&gb);
964 u_offset = bytestream2_get_le32(&gb);
969 starts[0] = y_offset;
970 starts[1] = v_offset;
971 starts[2] = u_offset;
973 for (j = 0; j < 3; j++) {
974 ends[j] =
ctx->data_size;
975 for (
i = 2;
i >= 0;
i--)
976 if (starts[
i] < ends[j] && starts[
i] > starts[j])
980 ctx->y_data_size = ends[0] - starts[0];
981 ctx->v_data_size = ends[1] - starts[1];
982 ctx->u_data_size = ends[2] - starts[2];
983 if (
FFMIN3(y_offset, v_offset, u_offset) < 0 ||
984 FFMAX3(y_offset, v_offset, u_offset) >=
ctx->data_size - 16 ||
985 FFMIN3(y_offset, v_offset, u_offset) < gb.
buffer - bs_hdr + 16 ||
991 ctx->y_data_ptr = bs_hdr + y_offset;
992 ctx->v_data_ptr = bs_hdr + v_offset;
993 ctx->u_data_ptr = bs_hdr + u_offset;
996 if (
ctx->data_size == 16) {
1026 ptrdiff_t dst_pitch,
int dst_height)
1030 ptrdiff_t pitch = plane->
pitch;
1033 for (y = 0; y < dst_height; y++) {
1035 for (x = 0; x < plane->
width >> 2; x++) {
1041 for (x <<= 2; x < plane->
width; x++)
1042 *dst++ = *
src++ << 1;
1045 dst += dst_pitch - plane->
width;
1070 int buf_size = avpkt->
size;
1116 (avctx->
height + 3) >> 2);
1119 (avctx->
height + 3) >> 2);
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
#define FFSWAP(type, a, b)
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
mode
Use these values in ebur128_init (or'ed).
bitstream reader API header.
static int get_bits_left(GetBitContext *gb)
static int get_bits_count(const GetBitContext *s)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
@ AVDISCARD_NONKEY
discard all frames except keyframes
@ AVDISCARD_NONREF
discard all non reference
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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...
static const int offsets[]
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
#define SPLIT_CELL(size, new_size)
@ RLE_ESC_FE
apply null delta to all lines up to the 3rd line
@ RLE_ESC_F9
same as RLE_ESC_FA + do the same with next block
@ RLE_ESC_FF
apply null delta to all lines up to the 2nd line
@ RLE_ESC_FB
apply null delta to N blocks / skip N blocks
@ RLE_ESC_FD
apply null delta to all remaining lines of this block
@ RLE_ESC_FA
INTRA: skip block, INTER: copy data from reference.
@ RLE_ESC_FC
same as RLE_ESC_FD + do the same with next block
#define BS_BUFFER
indicates which of two frame buffers should be used
#define BS_8BIT_PEL
8-bit pixel bitdepth indicator
static void output_plane(const Plane *plane, int buf_sel, uint8_t *dst, ptrdiff_t dst_pitch, int dst_height)
Convert and output the current plane.
#define BS_NONREF
nonref (discardable) frame indicator
static av_cold int decode_close(AVCodecContext *avctx)
static int parse_bintree(Indeo3DecodeContext *ctx, AVCodecContext *avctx, Plane *plane, int code, Cell *ref_cell, const int depth, const int strip_width)
AVCodec ff_indeo3_decoder
static int decode_cell(Indeo3DecodeContext *ctx, AVCodecContext *avctx, Plane *plane, Cell *cell, const uint8_t *data_ptr, const uint8_t *last_ptr)
Decode a vector-quantized cell.
static av_cold int decode_init(AVCodecContext *avctx)
#define BS_MV_Y_HALF
vertical mv halfpel resolution indicator
static uint8_t requant_tab[8][128]
#define APPLY_DELTA_1011_INTER
static int decode_cell_data(Indeo3DecodeContext *ctx, Cell *cell, uint8_t *block, uint8_t *ref_block, ptrdiff_t row_offset, int h_zoom, int v_zoom, int mode, const vqEntry *delta[2], int swap_quads[2], const uint8_t **data_ptr, const uint8_t *last_ptr)
static int decode_plane(Indeo3DecodeContext *ctx, AVCodecContext *avctx, Plane *plane, const uint8_t *data, int32_t data_size, int32_t strip_width)
static av_cold void free_frame_buffers(Indeo3DecodeContext *ctx)
static av_cold int allocate_frame_buffers(Indeo3DecodeContext *ctx, AVCodecContext *avctx, int luma_width, int luma_height)
#define RLE_LINES_COPY_M10
#define BS_MV_X_HALF
horizontal mv halfpel resolution indicator
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static int copy_cell(Indeo3DecodeContext *ctx, Plane *plane, Cell *cell)
Copy pixels of the cell(x + mv_x, y + mv_y) from the previous frame into the cell(x,...
static uint32_t replicate32(uint32_t a)
static int decode_frame_headers(Indeo3DecodeContext *ctx, AVCodecContext *avctx, const uint8_t *buf, int buf_size)
static av_cold void build_requant_tab(void)
static void fill_64(uint8_t *dst, const uint64_t pix, int32_t n, int32_t row_offset)
#define BS_KEYFRAME
intra frame indicator
static uint64_t replicate64(uint64_t a)
static const vqEntry vq_tab[24]
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
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.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
int width
picture width / height.
int flags
AV_CODEC_FLAG_*.
enum AVDiscard skip_frame
Skip decoding for selected frames.
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
This structure stores compressed data.
const int8_t * mv_ptr
ptr to the motion vector if any
int16_t height
cell height in 4x4 blocks
int16_t width
cell width in 4x4 blocks
uint8_t tree
tree id: 0- MC tree, 1 - VQ tree
int16_t xpos
cell coordinates in 4x4 blocks
uint16_t frame_flags
frame properties
uint32_t frame_num
current frame number (zero-based)
const uint8_t * u_data_ptr
const uint8_t * y_data_ptr
uint8_t cb_offset
needed for selecting VQ tables
unsigned num_vectors
number of motion vectors in mc_vectors
const uint8_t * v_data_ptr
int data_size
size of the frame data in bytes
const uint8_t * next_cell_data
uint8_t buf_sel
active frame buffer: 0 - primary, 1 -secondary
const uint8_t * alt_quant
secondary VQ table set for the modes 1 and 4
const uint8_t * last_byte
const int8_t * mc_vectors
uint8_t * pixels[2]
pointer to the actual pixel data of the buffers above
In the ELBG jargon, a cell is the set of points that are closest to a codebook entry.
uint8_t num_dyads
number of two-pixel deltas
uint8_t quad_exp
log2 of four-pixel deltas
#define avpriv_request_sample(...)
static void error(const char *err)
static int ref[MAX_W *MAX_W]
static const uint8_t offset[127][2]