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 luma_width =
FFALIGN(luma_width , 2);
173 luma_height =
FFALIGN(luma_height, 2);
175 if (luma_width < 16 || luma_width > 640 ||
176 luma_height < 16 || luma_height > 480 ||
177 luma_width & 1 || luma_height & 1) {
179 luma_width, luma_height);
183 ctx->width = luma_width ;
184 ctx->height = luma_height;
186 chroma_width =
FFALIGN(luma_width >> 2, 4);
187 chroma_height =
FFALIGN(luma_height >> 2, 4);
189 luma_pitch =
FFALIGN(luma_width, 16);
190 chroma_pitch =
FFALIGN(chroma_width, 16);
194 luma_size = luma_pitch * (luma_height + 1);
198 chroma_size = chroma_pitch * (chroma_height + 1);
201 for (p = 0; p < 3; p++) {
202 ctx->planes[p].pitch = !p ? luma_pitch : chroma_pitch;
203 ctx->planes[p].width = !p ? luma_width : chroma_width;
204 ctx->planes[p].height = !p ? luma_height : chroma_height;
206 ctx->planes[p].buffers[0] =
av_malloc(!p ? luma_size : chroma_size);
207 ctx->planes[p].buffers[1] =
av_malloc(!p ? luma_size : chroma_size);
209 if (!
ctx->planes[p].buffers[0] || !
ctx->planes[p].buffers[1])
213 memset(
ctx->planes[p].buffers[0], 0x40,
ctx->planes[p].pitch);
214 memset(
ctx->planes[p].buffers[1], 0x40,
ctx->planes[p].pitch);
217 ctx->planes[p].pixels[0] =
ctx->planes[p].buffers[0] +
ctx->planes[p].pitch;
218 ctx->planes[p].pixels[1] =
ctx->planes[p].buffers[1] +
ctx->planes[p].pitch;
219 memset(
ctx->planes[p].pixels[0], 0,
ctx->planes[p].pitch *
ctx->planes[p].height);
220 memset(
ctx->planes[p].pixels[1], 0,
ctx->planes[p].pitch *
ctx->planes[p].height);
236 int h,
w, mv_x, mv_y,
offset, offset_dst;
240 offset_dst = (
cell->ypos << 2) * plane->
pitch + (
cell->xpos << 2);
241 dst = plane->
pixels[
ctx->buf_sel] + offset_dst;
243 mv_y =
cell->mv_ptr[0];
244 mv_x =
cell->mv_ptr[1];
249 if ((
cell->ypos << 2) + mv_y < -1 || (
cell->xpos << 2) + mv_x < 0 ||
253 "Motion vectors point out of the frame.\n");
260 h =
cell->height << 2;
262 for (
w =
cell->width;
w > 0;) {
264 if (!((
cell->xpos << 2) & 15) &&
w >= 4) {
265 for (;
w >= 4;
src += 16, dst += 16,
w -= 4)
266 ctx->hdsp.put_pixels_tab[0][0](dst,
src, plane->
pitch,
h);
270 if (!((
cell->xpos << 2) & 7) &&
w >= 2) {
271 ctx->hdsp.put_pixels_tab[1][0](dst,
src, plane->
pitch,
h);
276 ctx->hdsp.put_pixels_tab[2][0](dst,
src, plane->
pitch,
h);
288 #define AVG_32(dst, src, ref) \
289 AV_WN32A(dst, ((AV_RN32(src) + AV_RN32(ref)) >> 1) & 0x7F7F7F7FUL)
291 #define AVG_64(dst, src, ref) \
292 AV_WN64A(dst, ((AV_RN64(src) + AV_RN64(ref)) >> 1) & 0x7F7F7F7F7F7F7F7FULL)
301 a &= 0xFF00FF00FF00FF00ULL;
304 a &= 0x00FF00FF00FF00FFULL;
326 for (; n > 0; dst += row_offset, n--)
342 #define BUFFER_PRECHECK \
343 if (*data_ptr >= last_ptr) \
344 return IV3_OUT_OF_DATA; \
346 #define RLE_BLOCK_COPY \
347 if (cell->mv_ptr || !skip_flag) \
348 copy_block4(dst, ref, row_offset, row_offset, 4 << v_zoom)
350 #define RLE_BLOCK_COPY_8 \
351 pix64 = AV_RN64(ref);\
353 pix64 = replicate64(pix64);\
354 fill_64(dst + row_offset, pix64, 7, row_offset);\
355 AVG_64(dst, ref, dst + row_offset);\
357 fill_64(dst, pix64, 8, row_offset)
359 #define RLE_LINES_COPY \
360 copy_block4(dst, ref, row_offset, row_offset, num_lines << v_zoom)
362 #define RLE_LINES_COPY_M10 \
363 pix64 = AV_RN64(ref);\
364 if (is_top_of_cell) {\
365 pix64 = replicate64(pix64);\
366 fill_64(dst + row_offset, pix64, (num_lines << 1) - 1, row_offset);\
367 AVG_64(dst, ref, dst + row_offset);\
369 fill_64(dst, pix64, num_lines << 1, row_offset)
371 #define APPLY_DELTA_4 \
372 AV_WN16A(dst + line_offset ,\
373 (AV_RN16(ref ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
374 AV_WN16A(dst + line_offset + 2,\
375 (AV_RN16(ref + 2) + delta_tab->deltas[dyad2]) & 0x7F7F);\
377 if (is_top_of_cell && !cell->ypos) {\
378 AV_COPY32U(dst, dst + row_offset);\
380 AVG_32(dst, ref, dst + row_offset);\
384 #define APPLY_DELTA_8 \
386 if (is_top_of_cell) { \
387 AV_WN32A(dst + row_offset , \
388 (replicate32(AV_RN32(ref )) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
389 AV_WN32A(dst + row_offset + 4, \
390 (replicate32(AV_RN32(ref + 4)) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
392 AV_WN32A(dst + row_offset , \
393 (AV_RN32(ref ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
394 AV_WN32A(dst + row_offset + 4, \
395 (AV_RN32(ref + 4) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
400 if (is_top_of_cell && !cell->ypos) {\
401 AV_COPY64U(dst, dst + row_offset);\
403 AVG_64(dst, ref, dst + row_offset);
406 #define APPLY_DELTA_1011_INTER \
409 (AV_RN32(dst ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
411 (AV_RN32(dst + 4 ) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
412 AV_WN32A(dst + row_offset , \
413 (AV_RN32(dst + row_offset ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
414 AV_WN32A(dst + row_offset + 4, \
415 (AV_RN32(dst + row_offset + 4) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
418 (AV_RN16(dst ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
420 (AV_RN16(dst + 2 ) + delta_tab->deltas[dyad2]) & 0x7F7F);\
421 AV_WN16A(dst + row_offset , \
422 (AV_RN16(dst + row_offset ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
423 AV_WN16A(dst + row_offset + 2, \
424 (AV_RN16(dst + row_offset + 2) + delta_tab->deltas[dyad2]) & 0x7F7F);\
430 ptrdiff_t row_offset,
int h_zoom,
int v_zoom,
int mode,
434 int x, y,
line, num_lines;
438 unsigned int dyad1, dyad2;
440 int skip_flag = 0, is_top_of_cell, is_first_row = 1;
441 int blk_row_offset, line_offset;
443 blk_row_offset = (row_offset << (2 + v_zoom)) - (
cell->width << 2);
444 line_offset = v_zoom ? row_offset : 0;
446 if (
cell->height & v_zoom ||
cell->width & h_zoom)
449 for (y = 0; y <
cell->height; is_first_row = 0, y += 1 + v_zoom) {
450 for (x = 0; x <
cell->width; x += 1 + h_zoom) {
454 if (rle_blocks > 0) {
457 }
else if (
mode == 10 && !
cell->mv_ptr) {
464 is_top_of_cell = is_first_row && !
line;
470 delta_tab =
delta[1];
472 code = bytestream_get_byte(data_ptr);
474 if (code < delta_tab->num_dyads) {
476 dyad1 = bytestream_get_byte(data_ptr);
478 if (dyad1 >= delta_tab->
num_dyads || dyad1 >= 248)
485 if (swap_quads[
line & 1])
486 FFSWAP(
unsigned int, dyad1, dyad2);
490 }
else if (
mode == 10 && !
cell->mv_ptr) {
511 }
else if (
mode == 10 && !
cell->mv_ptr) {
517 code = bytestream_get_byte(data_ptr);
518 rle_blocks = (
code & 0x1F) - 1;
519 if (
code >= 64 || rle_blocks < 0)
521 skip_flag =
code & 0x20;
522 num_lines = 4 -
line;
523 if (
mode >= 10 || (
cell->mv_ptr || !skip_flag)) {
526 }
else if (
mode == 10 && !
cell->mv_ptr) {
542 }
else if (
mode == 10 && !
cell->mv_ptr) {
553 ref += row_offset * (num_lines << v_zoom);
554 dst += row_offset * (num_lines << v_zoom);
559 block += 4 << h_zoom;
560 ref_block += 4 << h_zoom;
564 ref_block += blk_row_offset;
565 block += blk_row_offset;
588 int x, mv_x, mv_y,
mode, vq_index, prim_indx, second_indx;
593 const uint8_t *data_start = data_ptr;
598 vq_index =
code & 0xF;
607 }
else if (
mode >= 10) {
615 mv_y =
cell->mv_ptr[0];
616 mv_x =
cell->mv_ptr[1];
619 if ((
cell->ypos << 2) + mv_y < -1 || (
cell->xpos << 2) + mv_x < 0 ||
623 "Motion vectors point out of the frame.\n");
635 code =
ctx->alt_quant[vq_index];
636 prim_indx = (
code >> 4) +
ctx->cb_offset;
637 second_indx = (
code & 0xF) +
ctx->cb_offset;
639 vq_index +=
ctx->cb_offset;
640 prim_indx = second_indx = vq_index;
643 if (prim_indx >= 24 || second_indx >= 24) {
644 av_log(avctx,
AV_LOG_ERROR,
"Invalid VQ table indexes! Primary: %d, secondary: %d!\n",
645 prim_indx, second_indx);
651 swap_quads[0] = second_indx >= 16;
652 swap_quads[1] = prim_indx >= 16;
656 if (vq_index >= 8 && ref_block) {
657 for (x = 0; x <
cell->width << 2; x++)
658 ref_block[x] =
requant_tab[vq_index & 7][ref_block[x] & 127];
673 zoom_fac =
mode >= 3;
676 &data_ptr, last_ptr);
683 &data_ptr, last_ptr);
690 zoom_fac =
mode == 10;
693 &data_ptr, last_ptr);
703 av_log(avctx,
AV_LOG_ERROR,
"Mode %d: RLE code %X is not allowed at the current line\n",
720 return data_ptr - data_start;
733 #define SPLIT_CELL(size, new_size) (new_size) = ((size) > 2) ? ((((size) + 2) >> 2) << 1) : 1
735 #define UPDATE_BITPOS(n) \
736 ctx->skip_bits += (n); \
739 #define RESYNC_BITSTREAM \
740 if (ctx->need_resync && !(get_bits_count(&ctx->gb) & 7)) { \
741 skip_bits_long(&ctx->gb, ctx->skip_bits); \
742 ctx->skip_bits = 0; \
743 ctx->need_resync = 0; \
747 if (curr_cell.xpos + curr_cell.width > (plane->width >> 2) || \
748 curr_cell.ypos + curr_cell.height > (plane->height >> 2)) { \
749 av_log(avctx, AV_LOG_ERROR, "Invalid cell: x=%d, y=%d, w=%d, h=%d\n", \
750 curr_cell.xpos, curr_cell.ypos, curr_cell.width, curr_cell.height); \
751 return AVERROR_INVALIDDATA; \
757 const int depth,
const int strip_width)
767 curr_cell = *ref_cell;
775 if (curr_cell.
width > strip_width) {
777 curr_cell.
width = (curr_cell.
width <= (strip_width << 1) ? 1 : 2) * strip_width;
782 if (ref_cell->
width <= 0 || curr_cell.
width <= 0)
795 if (!curr_cell.
tree) {
817 if (!curr_cell.
tree) {
820 if (!
ctx->need_resync)
822 if (
ctx->next_cell_data >=
ctx->last_byte) {
826 mv_idx = *(
ctx->next_cell_data++);
827 if (mv_idx >=
ctx->num_vectors) {
831 curr_cell.
mv_ptr = &
ctx->mc_vectors[mv_idx << 1];
835 if (!
ctx->need_resync)
840 ctx->next_cell_data,
ctx->last_byte);
845 ctx->next_cell_data += bytes_used;
861 unsigned num_vectors;
865 num_vectors = bytestream_get_le32(&
data); data_size -= 4;
866 if (num_vectors > 256) {
868 "Read invalid number of motion vectors %d\n", num_vectors);
871 if (num_vectors * 2 > data_size)
874 ctx->num_vectors = num_vectors;
875 ctx->mc_vectors = num_vectors ?
data : 0;
880 ctx->need_resync = 0;
882 ctx->last_byte =
data + data_size;
885 curr_cell.
xpos = curr_cell.
ypos = 0;
895 #define OS_HDR_ID MKBETAG('F', 'R', 'M', 'H')
898 const uint8_t *buf,
int buf_size)
902 uint32_t frame_num, word2, check_sum, data_size;
903 int y_offset, u_offset, v_offset;
904 uint32_t starts[3], ends[3];
911 frame_num = bytestream2_get_le32(&gb);
912 word2 = bytestream2_get_le32(&gb);
913 check_sum = bytestream2_get_le32(&gb);
914 data_size = bytestream2_get_le32(&gb);
916 if ((frame_num ^ word2 ^ data_size ^
OS_HDR_ID) != check_sum) {
924 if (bytestream2_get_le16(&gb) != 32) {
929 ctx->frame_num = frame_num;
930 ctx->frame_flags = bytestream2_get_le16(&gb);
931 ctx->data_size = (bytestream2_get_le32(&gb) + 7) >> 3;
932 ctx->cb_offset = bytestream2_get_byte(&gb);
934 if (
ctx->data_size == 16)
936 ctx->data_size =
FFMIN(
ctx->data_size, buf_size - 16);
941 height = bytestream2_get_le16(&gb);
942 width = bytestream2_get_le16(&gb);
949 ff_dlog(avctx,
"Frame dimensions changed!\n");
951 if (width < 16 || width > 640 ||
952 height < 16 || height > 480 ||
955 "Invalid picture dimensions: %d x %d!\n",
width,
height);
965 y_offset = bytestream2_get_le32(&gb);
966 v_offset = bytestream2_get_le32(&gb);
967 u_offset = bytestream2_get_le32(&gb);
972 starts[0] = y_offset;
973 starts[1] = v_offset;
974 starts[2] = u_offset;
976 for (j = 0; j < 3; j++) {
977 ends[j] =
ctx->data_size;
978 for (
i = 2;
i >= 0;
i--)
979 if (starts[
i] < ends[j] && starts[
i] > starts[j])
983 ctx->y_data_size = ends[0] - starts[0];
984 ctx->v_data_size = ends[1] - starts[1];
985 ctx->u_data_size = ends[2] - starts[2];
986 if (
FFMIN3(y_offset, v_offset, u_offset) < 0 ||
987 FFMAX3(y_offset, v_offset, u_offset) >=
ctx->data_size - 16 ||
988 FFMIN3(y_offset, v_offset, u_offset) < gb.
buffer - bs_hdr + 16 ||
994 ctx->y_data_ptr = bs_hdr + y_offset;
995 ctx->v_data_ptr = bs_hdr + v_offset;
996 ctx->u_data_ptr = bs_hdr + u_offset;
999 if (
ctx->data_size == 16) {
1029 ptrdiff_t dst_pitch,
int dst_height)
1033 ptrdiff_t pitch = plane->
pitch;
1036 for (y = 0; y < dst_height; y++) {
1038 for (x = 0; x < plane->
width >> 2; x++) {
1044 for (x <<= 2; x < plane->
width; x++)
1045 *dst++ = *
src++ << 1;
1048 dst += dst_pitch - plane->
width;
1073 int buf_size = avpkt->
size;
1119 (avctx->
height + 3) >> 2);
1122 (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]