Go to the documentation of this file.
59 #define BS_8BIT_PEL (1 << 1)
60 #define BS_KEYFRAME (1 << 2)
61 #define BS_MV_Y_HALF (1 << 4)
62 #define BS_MV_X_HALF (1 << 5)
63 #define BS_NONREF (1 << 8)
67 typedef struct Plane {
75 #define CELL_STACK_MAX 20
124 static const int8_t
offsets[8] = { 1, 1, 2, -3, -3, 3, 4, 4 };
125 static const int8_t deltas [8] = { 0, 1, 0, 4, 4, 1, 0, 1 };
129 for (
i = 0;
i < 8;
i++) {
131 for (j = 0; j < 128; j++)
158 ctx->width =
ctx->height = 0;
160 for (p = 0; p < 3; p++) {
163 ctx->planes[p].pixels[0] =
ctx->planes[p].pixels[1] = 0;
171 int p, chroma_width, chroma_height;
172 int luma_size, chroma_size;
173 ptrdiff_t luma_pitch, chroma_pitch;
175 luma_width =
FFALIGN(luma_width , 2);
176 luma_height =
FFALIGN(luma_height, 2);
178 if (luma_width < 16 || luma_width > 640 ||
179 luma_height < 16 || luma_height > 480 ||
180 luma_width & 1 || luma_height & 1) {
182 luma_width, luma_height);
186 ctx->width = luma_width ;
187 ctx->height = luma_height;
189 chroma_width =
FFALIGN(luma_width >> 2, 4);
190 chroma_height =
FFALIGN(luma_height >> 2, 4);
192 luma_pitch =
FFALIGN(luma_width, 16);
193 chroma_pitch =
FFALIGN(chroma_width, 16);
197 luma_size = luma_pitch * (luma_height + 1);
201 chroma_size = chroma_pitch * (chroma_height + 1);
204 for (p = 0; p < 3; p++) {
205 ctx->planes[p].pitch = !p ? luma_pitch : chroma_pitch;
206 ctx->planes[p].width = !p ? luma_width : chroma_width;
207 ctx->planes[p].height = !p ? luma_height : chroma_height;
209 ctx->planes[p].buffers[0] =
av_malloc(!p ? luma_size : chroma_size);
210 ctx->planes[p].buffers[1] =
av_malloc(!p ? luma_size : chroma_size);
212 if (!
ctx->planes[p].buffers[0] || !
ctx->planes[p].buffers[1])
216 memset(
ctx->planes[p].buffers[0], 0x40,
ctx->planes[p].pitch);
217 memset(
ctx->planes[p].buffers[1], 0x40,
ctx->planes[p].pitch);
220 ctx->planes[p].pixels[0] =
ctx->planes[p].buffers[0] +
ctx->planes[p].pitch;
221 ctx->planes[p].pixels[1] =
ctx->planes[p].buffers[1] +
ctx->planes[p].pitch;
222 memset(
ctx->planes[p].pixels[0], 0,
ctx->planes[p].pitch *
ctx->planes[p].height);
223 memset(
ctx->planes[p].pixels[1], 0,
ctx->planes[p].pitch *
ctx->planes[p].height);
239 int h,
w, mv_x, mv_y,
offset, offset_dst;
243 offset_dst = (cell->
ypos << 2) * plane->
pitch + (cell->
xpos << 2);
244 dst = plane->
pixels[
ctx->buf_sel] + offset_dst;
252 if ((cell->
ypos << 2) + mv_y < -1 || (cell->
xpos << 2) + mv_x < 0 ||
256 "Motion vectors point out of the frame.\n");
265 for (
w = cell->
width;
w > 0;) {
267 if (!((cell->
xpos << 2) & 15) &&
w >= 4) {
268 for (;
w >= 4;
src += 16, dst += 16,
w -= 4)
269 ctx->hdsp.put_pixels_tab[0][0](dst,
src, plane->
pitch,
h);
273 if (!((cell->
xpos << 2) & 7) &&
w >= 2) {
274 ctx->hdsp.put_pixels_tab[1][0](dst,
src, plane->
pitch,
h);
279 ctx->hdsp.put_pixels_tab[2][0](dst,
src, plane->
pitch,
h);
291 #define AVG_32(dst, src, ref) \
292 AV_WN32A(dst, ((AV_RN32(src) + AV_RN32(ref)) >> 1) & 0x7F7F7F7FUL)
294 #define AVG_64(dst, src, ref) \
295 AV_WN64A(dst, ((AV_RN64(src) + AV_RN64(ref)) >> 1) & 0x7F7F7F7F7F7F7F7FULL)
304 a &= 0xFF00FF00FF00FF00ULL;
307 a &= 0x00FF00FF00FF00FFULL;
329 for (; n > 0; dst += row_offset, n--)
345 #define BUFFER_PRECHECK \
346 if (*data_ptr >= last_ptr) \
347 return IV3_OUT_OF_DATA; \
349 #define RLE_BLOCK_COPY \
350 if (cell->mv_ptr || !skip_flag) \
351 copy_block4(dst, ref, row_offset, row_offset, 4 << v_zoom)
353 #define RLE_BLOCK_COPY_8 \
354 pix64 = AV_RN64(ref);\
356 pix64 = replicate64(pix64);\
357 fill_64(dst + row_offset, pix64, 7, row_offset);\
358 AVG_64(dst, ref, dst + row_offset);\
360 fill_64(dst, pix64, 8, row_offset)
362 #define RLE_LINES_COPY \
363 copy_block4(dst, ref, row_offset, row_offset, num_lines << v_zoom)
365 #define RLE_LINES_COPY_M10 \
366 pix64 = AV_RN64(ref);\
367 if (is_top_of_cell) {\
368 pix64 = replicate64(pix64);\
369 fill_64(dst + row_offset, pix64, (num_lines << 1) - 1, row_offset);\
370 AVG_64(dst, ref, dst + row_offset);\
372 fill_64(dst, pix64, num_lines << 1, row_offset)
374 #define APPLY_DELTA_4 \
375 AV_WN16A(dst + line_offset ,\
376 (AV_RN16(ref ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
377 AV_WN16A(dst + line_offset + 2,\
378 (AV_RN16(ref + 2) + delta_tab->deltas[dyad2]) & 0x7F7F);\
380 if (is_top_of_cell && !cell->ypos) {\
381 AV_COPY32U(dst, dst + row_offset);\
383 AVG_32(dst, ref, dst + row_offset);\
387 #define APPLY_DELTA_8 \
389 if (is_top_of_cell) { \
390 AV_WN32A(dst + row_offset , \
391 (replicate32(AV_RN32(ref )) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
392 AV_WN32A(dst + row_offset + 4, \
393 (replicate32(AV_RN32(ref + 4)) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
395 AV_WN32A(dst + row_offset , \
396 (AV_RN32(ref ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
397 AV_WN32A(dst + row_offset + 4, \
398 (AV_RN32(ref + 4) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
403 if (is_top_of_cell && !cell->ypos) {\
404 AV_COPY64U(dst, dst + row_offset);\
406 AVG_64(dst, ref, dst + row_offset);
409 #define APPLY_DELTA_1011_INTER \
412 (AV_RN32(dst ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
414 (AV_RN32(dst + 4 ) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
415 AV_WN32A(dst + row_offset , \
416 (AV_RN32(dst + row_offset ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
417 AV_WN32A(dst + row_offset + 4, \
418 (AV_RN32(dst + row_offset + 4) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
421 (AV_RN16(dst ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
423 (AV_RN16(dst + 2 ) + delta_tab->deltas[dyad2]) & 0x7F7F);\
424 AV_WN16A(dst + row_offset , \
425 (AV_RN16(dst + row_offset ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
426 AV_WN16A(dst + row_offset + 2, \
427 (AV_RN16(dst + row_offset + 2) + delta_tab->deltas[dyad2]) & 0x7F7F);\
432 uint8_t *
block, uint8_t *ref_block,
433 ptrdiff_t row_offset,
int h_zoom,
int v_zoom,
int mode,
435 const uint8_t **data_ptr,
const uint8_t *last_ptr)
437 int x, y,
line, num_lines;
441 unsigned int dyad1, dyad2;
444 int blk_row_offset, line_offset;
446 blk_row_offset = (row_offset << (2 + v_zoom)) - (cell->
width << 2);
447 line_offset = v_zoom ? row_offset : 0;
453 for (x = 0; x < cell->
width; x += 1 + h_zoom) {
457 if (rle_blocks > 0) {
473 delta_tab =
delta[1];
475 code = bytestream_get_byte(data_ptr);
477 if (code < delta_tab->num_dyads) {
479 dyad1 = bytestream_get_byte(data_ptr);
481 if (dyad1 >= delta_tab->
num_dyads || dyad1 >= 248)
488 if (swap_quads[
line & 1])
489 FFSWAP(
unsigned int, dyad1, dyad2);
520 code = bytestream_get_byte(data_ptr);
521 rle_blocks = (
code & 0x1F) - 1;
522 if (
code >= 64 || rle_blocks < 0)
524 skip_flag =
code & 0x20;
525 num_lines = 4 -
line;
526 if (
mode >= 10 || (cell->
mv_ptr || !skip_flag)) {
556 ref += row_offset * (num_lines << v_zoom);
557 dst += row_offset * (num_lines << v_zoom);
562 block += 4 << h_zoom;
563 ref_block += 4 << h_zoom;
567 ref_block += blk_row_offset;
568 block += blk_row_offset;
588 Plane *plane,
Cell *cell,
const uint8_t *data_ptr,
589 const uint8_t *last_ptr)
591 int x, mv_x, mv_y,
mode, vq_index, prim_indx, second_indx;
596 const uint8_t *data_start = data_ptr;
601 vq_index =
code & 0xF;
610 }
else if (
mode >= 10) {
622 if ((cell->
ypos << 2) + mv_y < -1 || (cell->
xpos << 2) + mv_x < 0 ||
626 "Motion vectors point out of the frame.\n");
638 code =
ctx->alt_quant[vq_index];
639 prim_indx = (
code >> 4) +
ctx->cb_offset;
640 second_indx = (
code & 0xF) +
ctx->cb_offset;
642 vq_index +=
ctx->cb_offset;
643 prim_indx = second_indx = vq_index;
646 if (prim_indx >= 24 || second_indx >= 24) {
647 av_log(avctx,
AV_LOG_ERROR,
"Invalid VQ table indexes! Primary: %d, secondary: %d!\n",
648 prim_indx, second_indx);
654 swap_quads[0] = second_indx >= 16;
655 swap_quads[1] = prim_indx >= 16;
659 if (vq_index >= 8 && ref_block) {
660 for (x = 0; x < cell->
width << 2; x++)
661 ref_block[x] =
requant_tab[vq_index & 7][ref_block[x] & 127];
676 zoom_fac =
mode >= 3;
679 &data_ptr, last_ptr);
686 &data_ptr, last_ptr);
693 zoom_fac =
mode == 10;
696 &data_ptr, last_ptr);
706 av_log(avctx,
AV_LOG_ERROR,
"Mode %d: RLE code %X is not allowed at the current line\n",
723 return data_ptr - data_start;
736 #define SPLIT_CELL(size, new_size) (new_size) = ((size) > 2) ? ((((size) + 2) >> 2) << 1) : 1
738 #define UPDATE_BITPOS(n) \
739 ctx->skip_bits += (n); \
742 #define RESYNC_BITSTREAM \
743 if (ctx->need_resync && !(get_bits_count(&ctx->gb) & 7)) { \
744 skip_bits_long(&ctx->gb, ctx->skip_bits); \
745 ctx->skip_bits = 0; \
746 ctx->need_resync = 0; \
750 if (curr_cell.xpos + curr_cell.width > (plane->width >> 2) || \
751 curr_cell.ypos + curr_cell.height > (plane->height >> 2)) { \
752 av_log(avctx, AV_LOG_ERROR, "Invalid cell: x=%d, y=%d, w=%d, h=%d\n", \
753 curr_cell.xpos, curr_cell.ypos, curr_cell.width, curr_cell.height); \
754 return AVERROR_INVALIDDATA; \
760 const int depth,
const int strip_width)
770 curr_cell = *ref_cell;
778 if (curr_cell.
width > strip_width) {
780 curr_cell.
width = (curr_cell.
width <= (strip_width << 1) ? 1 : 2) * strip_width;
785 if (ref_cell->
width <= 0 || curr_cell.
width <= 0)
798 if (!curr_cell.
tree) {
820 if (!curr_cell.
tree) {
823 if (!
ctx->need_resync)
825 if (
ctx->next_cell_data >=
ctx->last_byte) {
829 mv_idx = *(
ctx->next_cell_data++);
830 if (mv_idx >=
ctx->num_vectors) {
834 curr_cell.
mv_ptr = &
ctx->mc_vectors[mv_idx << 1];
838 if (!
ctx->need_resync)
843 ctx->next_cell_data,
ctx->last_byte);
848 ctx->next_cell_data += bytes_used;
864 unsigned num_vectors;
868 num_vectors = bytestream_get_le32(&
data); data_size -= 4;
869 if (num_vectors > 256) {
871 "Read invalid number of motion vectors %d\n", num_vectors);
874 if (num_vectors * 2 > data_size)
877 ctx->num_vectors = num_vectors;
878 ctx->mc_vectors = num_vectors ?
data : 0;
883 ctx->need_resync = 0;
885 ctx->last_byte =
data + data_size;
888 curr_cell.
xpos = curr_cell.
ypos = 0;
898 #define OS_HDR_ID MKBETAG('F', 'R', 'M', 'H')
901 const uint8_t *buf,
int buf_size)
904 const uint8_t *bs_hdr;
905 uint32_t frame_num, word2, check_sum, data_size;
906 int y_offset, u_offset, v_offset;
907 uint32_t starts[3], ends[3];
914 frame_num = bytestream2_get_le32(&gb);
915 word2 = bytestream2_get_le32(&gb);
916 check_sum = bytestream2_get_le32(&gb);
917 data_size = bytestream2_get_le32(&gb);
919 if ((frame_num ^ word2 ^ data_size ^
OS_HDR_ID) != check_sum) {
927 if (bytestream2_get_le16(&gb) != 32) {
932 ctx->frame_num = frame_num;
933 ctx->frame_flags = bytestream2_get_le16(&gb);
934 ctx->data_size = (bytestream2_get_le32(&gb) + 7) >> 3;
935 ctx->cb_offset = bytestream2_get_byte(&gb);
937 if (
ctx->data_size == 16)
939 ctx->data_size =
FFMIN(
ctx->data_size, buf_size - 16);
944 height = bytestream2_get_le16(&gb);
945 width = bytestream2_get_le16(&gb);
952 ff_dlog(avctx,
"Frame dimensions changed!\n");
954 if (width < 16 || width > 640 ||
955 height < 16 || height > 480 ||
958 "Invalid picture dimensions: %d x %d!\n",
width,
height);
968 y_offset = bytestream2_get_le32(&gb);
969 v_offset = bytestream2_get_le32(&gb);
970 u_offset = bytestream2_get_le32(&gb);
975 starts[0] = y_offset;
976 starts[1] = v_offset;
977 starts[2] = u_offset;
979 for (j = 0; j < 3; j++) {
980 ends[j] =
ctx->data_size;
981 for (
i = 2;
i >= 0;
i--)
982 if (starts[
i] < ends[j] && starts[
i] > starts[j])
986 ctx->y_data_size = ends[0] - starts[0];
987 ctx->v_data_size = ends[1] - starts[1];
988 ctx->u_data_size = ends[2] - starts[2];
989 if (
FFMIN3(y_offset, v_offset, u_offset) < 0 ||
990 FFMAX3(y_offset, v_offset, u_offset) >=
ctx->data_size - 16 ||
991 FFMIN3(y_offset, v_offset, u_offset) < gb.
buffer - bs_hdr + 16 ||
997 ctx->y_data_ptr = bs_hdr + y_offset;
998 ctx->v_data_ptr = bs_hdr + v_offset;
999 ctx->u_data_ptr = bs_hdr + u_offset;
1002 if (
ctx->data_size == 16) {
1032 ptrdiff_t dst_pitch,
int dst_height)
1035 const uint8_t *
src = plane->
pixels[buf_sel];
1036 ptrdiff_t pitch = plane->
pitch;
1039 for (y = 0; y < dst_height; y++) {
1041 for (x = 0; x < plane->
width >> 2; x++) {
1047 for (x <<= 2; x < plane->
width; x++)
1048 *dst++ = *
src++ << 1;
1051 dst += dst_pitch - plane->
width;
1076 const uint8_t *buf = avpkt->
data;
1077 int buf_size = avpkt->
size;
1122 (avctx->
height + 3) >> 2);
1125 (avctx->
height + 3) >> 2);
static void error(const char *err)
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
static const vqEntry vq_tab[24]
#define BS_NONREF
nonref (discardable) frame indicator
static int get_bits_left(GetBitContext *gb)
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
int16_t height
cell height in 4x4 blocks
@ RLE_ESC_FB
apply null delta to N blocks / skip N blocks
static int get_bits_count(const GetBitContext *s)
static av_cold int decode_close(AVCodecContext *avctx)
This structure describes decoded (raw) audio or video data.
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about which is also called distortion Distortion can be quantified by almost any quality measurement one chooses the sum of squared differences is used but more complex methods that consider psychovisual effects can be used as well It makes no difference in this discussion First step
#define BS_MV_Y_HALF
vertical mv halfpel resolution indicator
static int decode_frame_headers(Indeo3DecodeContext *ctx, AVCodecContext *avctx, const uint8_t *buf, int buf_size)
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
@ RLE_ESC_FC
same as RLE_ESC_FD + do the same with next block
@ RLE_ESC_FD
apply null delta to all remaining lines of this block
const uint8_t * alt_quant
secondary VQ table set for the modes 1 and 4
#define BS_MV_X_HALF
horizontal mv halfpel resolution indicator
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.
@ RLE_ESC_F9
same as RLE_ESC_FA + do the same with next block
const int8_t * mc_vectors
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.
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
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)
int16_t xpos
cell coordinates in 4x4 blocks
AVCodec p
The public AVCodec.
enum AVDiscard skip_frame
Skip decoding for selected frames.
static uint8_t requant_tab[8][128]
int flags
AV_CODEC_FLAG_*.
#define BS_BUFFER
indicates which of two frame buffers should be used
static int ff_thread_once(char *control, void(*routine)(void))
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static av_cold void build_requant_tab(void)
#define FF_CODEC_DECODE_CB(func)
static const int offsets[]
uint8_t buf_sel
active frame buffer: 0 - primary, 1 -secondary
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,...
#define RLE_LINES_COPY_M10
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
static av_cold int decode_init(AVCodecContext *avctx)
#define BS_KEYFRAME
intra frame indicator
#define CODEC_LONG_NAME(str)
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
static int parse_bintree(Indeo3DecodeContext *ctx, AVCodecContext *avctx, Plane *plane, int code, Cell *ref_cell, const int depth, const int strip_width)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
const uint8_t * y_data_ptr
const uint8_t * next_cell_data
unsigned num_vectors
number of motion vectors in mc_vectors
const uint8_t * u_data_ptr
const uint8_t * last_byte
#define SPLIT_CELL(size, new_size)
uint8_t * pixels[2]
pointer to the actual pixel data of the buffers above
int16_t width
cell width in 4x4 blocks
@ AVDISCARD_NONKEY
discard all frames except keyframes
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
int(* init)(AVBSFContext *ctx)
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
@ RLE_ESC_FA
INTRA: skip block, INTER: copy data from reference.
uint8_t cb_offset
needed for selecting VQ tables
static int decode_plane(Indeo3DecodeContext *ctx, AVCodecContext *avctx, Plane *plane, const uint8_t *data, int32_t data_size, int32_t strip_width)
const uint8_t * v_data_ptr
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
static av_cold int allocate_frame_buffers(Indeo3DecodeContext *ctx, AVCodecContext *avctx, int luma_width, int luma_height)
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
int data_size
size of the frame data in bytes
#define i(width, name, range_min, range_max)
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
uint8_t num_dyads
number of two-pixel deltas
const char * name
Name of the codec implementation.
const int8_t * mv_ptr
ptr to the motion vector if any
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
#define FFSWAP(type, a, b)
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
uint32_t frame_num
current frame number (zero-based)
static uint64_t replicate64(uint64_t a)
static av_cold void free_frame_buffers(Indeo3DecodeContext *ctx)
#define BS_8BIT_PEL
8-bit pixel bitdepth indicator
main external API structure.
@ RLE_ESC_FF
apply null delta to all lines up to the 2nd line
#define APPLY_DELTA_1011_INTER
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.
static int ref[MAX_W *MAX_W]
@ RLE_ESC_FE
apply null delta to all lines up to the 3rd line
uint8_t tree
tree id: 0- MC tree, 1 - VQ tree
#define avpriv_request_sample(...)
static uint32_t replicate32(uint32_t a)
This structure stores compressed data.
int width
picture width / height.
const FFCodec ff_indeo3_decoder
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
The exact code depends on how similar the blocks are and how related they are to the block
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
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...
@ AVDISCARD_NONREF
discard all non reference
static int is_first_row(const VVCFrameContext *fc, const int rx, const int ry)
uint16_t frame_flags
frame properties
uint8_t quad_exp
log2 of four-pixel deltas
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted line
static void fill_64(uint8_t *dst, const uint64_t pix, int32_t n, int32_t row_offset)