FFmpeg
indeo3.c
Go to the documentation of this file.
1 /*
2  * Indeo Video v3 compatible decoder
3  * Copyright (c) 2009 - 2011 Maxim Poliakovski
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 /**
23  * @file
24  * This is a decoder for Intel Indeo Video v3.
25  * It is based on vector quantization, run-length coding and motion compensation.
26  * Known container formats: .avi and .mov
27  * Known FOURCCs: 'IV31', 'IV32'
28  *
29  * @see http://wiki.multimedia.cx/index.php?title=Indeo_3
30  */
31 
32 #include "libavutil/imgutils.h"
33 #include "libavutil/intreadwrite.h"
34 #include "libavutil/thread.h"
35 #include "avcodec.h"
36 #include "codec_internal.h"
37 #include "decode.h"
38 #include "copy_block.h"
39 #include "bytestream.h"
40 #include "get_bits.h"
41 #include "hpeldsp.h"
42 
43 #include "indeo3data.h"
44 
45 /* RLE opcodes. */
46 enum {
47  RLE_ESC_F9 = 249, ///< same as RLE_ESC_FA + do the same with next block
48  RLE_ESC_FA = 250, ///< INTRA: skip block, INTER: copy data from reference
49  RLE_ESC_FB = 251, ///< apply null delta to N blocks / skip N blocks
50  RLE_ESC_FC = 252, ///< same as RLE_ESC_FD + do the same with next block
51  RLE_ESC_FD = 253, ///< apply null delta to all remaining lines of this block
52  RLE_ESC_FE = 254, ///< apply null delta to all lines up to the 3rd line
53  RLE_ESC_FF = 255 ///< apply null delta to all lines up to the 2nd line
54 };
55 
56 
57 /* Some constants for parsing frame bitstream flags. */
58 #define BS_8BIT_PEL (1 << 1) ///< 8-bit pixel bitdepth indicator
59 #define BS_KEYFRAME (1 << 2) ///< intra frame indicator
60 #define BS_MV_Y_HALF (1 << 4) ///< vertical mv halfpel resolution indicator
61 #define BS_MV_X_HALF (1 << 5) ///< horizontal mv halfpel resolution indicator
62 #define BS_NONREF (1 << 8) ///< nonref (discardable) frame indicator
63 #define BS_BUFFER 9 ///< indicates which of two frame buffers should be used
64 
65 
66 typedef struct Plane {
67  uint8_t *buffers[2];
68  uint8_t *pixels[2]; ///< pointer to the actual pixel data of the buffers above
69  uint32_t width;
70  uint32_t height;
71  ptrdiff_t pitch;
72 } Plane;
73 
74 #define CELL_STACK_MAX 20
75 
76 typedef struct Cell {
77  int16_t xpos; ///< cell coordinates in 4x4 blocks
78  int16_t ypos;
79  int16_t width; ///< cell width in 4x4 blocks
80  int16_t height; ///< cell height in 4x4 blocks
81  uint8_t tree; ///< tree id: 0- MC tree, 1 - VQ tree
82  const int8_t *mv_ptr; ///< ptr to the motion vector if any
83 } Cell;
84 
85 typedef struct Indeo3DecodeContext {
88 
91  int skip_bits;
92  const uint8_t *next_cell_data;
93  const uint8_t *last_byte;
94  const int8_t *mc_vectors;
95  unsigned num_vectors; ///< number of motion vectors in mc_vectors
96 
97  int16_t width, height;
98  uint32_t frame_num; ///< current frame number (zero-based)
99  int data_size; ///< size of the frame data in bytes
100  uint16_t frame_flags; ///< frame properties
101  uint8_t cb_offset; ///< needed for selecting VQ tables
102  uint8_t buf_sel; ///< active frame buffer: 0 - primary, 1 -secondary
103  const uint8_t *y_data_ptr;
104  const uint8_t *v_data_ptr;
105  const uint8_t *u_data_ptr;
109  const uint8_t *alt_quant; ///< secondary VQ table set for the modes 1 and 4
112 
113 
114 static uint8_t requant_tab[8][128];
115 
116 /*
117  * Build the static requantization table.
118  * This table is used to remap pixel values according to a specific
119  * quant index and thus avoid overflows while adding deltas.
120  */
121 static av_cold void build_requant_tab(void)
122 {
123  static const int8_t offsets[8] = { 1, 1, 2, -3, -3, 3, 4, 4 };
124  static const int8_t deltas [8] = { 0, 1, 0, 4, 4, 1, 0, 1 };
125 
126  int i, j, step;
127 
128  for (i = 0; i < 8; i++) {
129  step = i + 2;
130  for (j = 0; j < 128; j++)
131  requant_tab[i][j] = (j + offsets[i]) / step * step + deltas[i];
132  }
133 
134  /* some last elements calculated above will have values >= 128 */
135  /* pixel values shall never exceed 127 so set them to non-overflowing values */
136  /* according with the quantization step of the respective section */
137  requant_tab[0][127] = 126;
138  requant_tab[1][119] = 118;
139  requant_tab[1][120] = 118;
140  requant_tab[2][126] = 124;
141  requant_tab[2][127] = 124;
142  requant_tab[6][124] = 120;
143  requant_tab[6][125] = 120;
144  requant_tab[6][126] = 120;
145  requant_tab[6][127] = 120;
146 
147  /* Patch for compatibility with the Intel's binary decoders */
148  requant_tab[1][7] = 10;
149  requant_tab[4][8] = 10;
150 }
151 
152 
154 {
155  int p;
156 
157  ctx->width = ctx->height = 0;
158 
159  for (p = 0; p < 3; p++) {
160  av_freep(&ctx->planes[p].buffers[0]);
161  av_freep(&ctx->planes[p].buffers[1]);
162  ctx->planes[p].pixels[0] = ctx->planes[p].pixels[1] = 0;
163  }
164 }
165 
166 
168  AVCodecContext *avctx, int luma_width, int luma_height)
169 {
170  int p, chroma_width, chroma_height;
171  int luma_size, chroma_size;
172  ptrdiff_t luma_pitch, chroma_pitch;
173 
174  luma_width = FFALIGN(luma_width , 2);
175  luma_height = FFALIGN(luma_height, 2);
176 
177  if (luma_width < 16 || luma_width > 640 ||
178  luma_height < 16 || luma_height > 480 ||
179  luma_width & 1 || luma_height & 1) {
180  av_log(avctx, AV_LOG_ERROR, "Invalid picture dimensions: %d x %d!\n",
181  luma_width, luma_height);
182  return AVERROR_INVALIDDATA;
183  }
184 
185  ctx->width = luma_width ;
186  ctx->height = luma_height;
187 
188  chroma_width = FFALIGN(luma_width >> 2, 4);
189  chroma_height = FFALIGN(luma_height >> 2, 4);
190 
191  luma_pitch = FFALIGN(luma_width, 16);
192  chroma_pitch = FFALIGN(chroma_width, 16);
193 
194  /* Calculate size of the luminance plane. */
195  /* Add one line more for INTRA prediction. */
196  luma_size = luma_pitch * (luma_height + 1);
197 
198  /* Calculate size of a chrominance planes. */
199  /* Add one line more for INTRA prediction. */
200  chroma_size = chroma_pitch * (chroma_height + 1);
201 
202  /* allocate frame buffers */
203  for (p = 0; p < 3; p++) {
204  ctx->planes[p].pitch = !p ? luma_pitch : chroma_pitch;
205  ctx->planes[p].width = !p ? luma_width : chroma_width;
206  ctx->planes[p].height = !p ? luma_height : chroma_height;
207 
208  ctx->planes[p].buffers[0] = av_malloc(!p ? luma_size : chroma_size);
209  ctx->planes[p].buffers[1] = av_malloc(!p ? luma_size : chroma_size);
210 
211  if (!ctx->planes[p].buffers[0] || !ctx->planes[p].buffers[1])
212  return AVERROR(ENOMEM);
213 
214  /* fill the INTRA prediction lines with the middle pixel value = 64 */
215  memset(ctx->planes[p].buffers[0], 0x40, ctx->planes[p].pitch);
216  memset(ctx->planes[p].buffers[1], 0x40, ctx->planes[p].pitch);
217 
218  /* set buffer pointers = buf_ptr + pitch and thus skip the INTRA prediction line */
219  ctx->planes[p].pixels[0] = ctx->planes[p].buffers[0] + ctx->planes[p].pitch;
220  ctx->planes[p].pixels[1] = ctx->planes[p].buffers[1] + ctx->planes[p].pitch;
221  memset(ctx->planes[p].pixels[0], 0, ctx->planes[p].pitch * ctx->planes[p].height);
222  memset(ctx->planes[p].pixels[1], 0, ctx->planes[p].pitch * ctx->planes[p].height);
223  }
224 
225  return 0;
226 }
227 
228 /**
229  * Copy pixels of the cell(x + mv_x, y + mv_y) from the previous frame into
230  * the cell(x, y) in the current frame.
231  *
232  * @param ctx pointer to the decoder context
233  * @param plane pointer to the plane descriptor
234  * @param cell pointer to the cell descriptor
235  */
236 static int copy_cell(Indeo3DecodeContext *ctx, Plane *plane, Cell *cell)
237 {
238  int h, w, mv_x, mv_y, offset, offset_dst;
239  uint8_t *src, *dst;
240 
241  /* setup output and reference pointers */
242  offset_dst = (cell->ypos << 2) * plane->pitch + (cell->xpos << 2);
243  dst = plane->pixels[ctx->buf_sel] + offset_dst;
244  if(cell->mv_ptr){
245  mv_y = cell->mv_ptr[0];
246  mv_x = cell->mv_ptr[1];
247  }else
248  mv_x= mv_y= 0;
249 
250  /* -1 because there is an extra line on top for prediction */
251  if ((cell->ypos << 2) + mv_y < -1 || (cell->xpos << 2) + mv_x < 0 ||
252  ((cell->ypos + cell->height) << 2) + mv_y > plane->height ||
253  ((cell->xpos + cell->width) << 2) + mv_x > plane->width) {
254  av_log(ctx->avctx, AV_LOG_ERROR,
255  "Motion vectors point out of the frame.\n");
256  return AVERROR_INVALIDDATA;
257  }
258 
259  offset = offset_dst + mv_y * plane->pitch + mv_x;
260  src = plane->pixels[ctx->buf_sel ^ 1] + offset;
261 
262  h = cell->height << 2;
263 
264  for (w = cell->width; w > 0;) {
265  /* copy using 16xH blocks */
266  if (!((cell->xpos << 2) & 15) && w >= 4) {
267  for (; w >= 4; src += 16, dst += 16, w -= 4)
268  ctx->hdsp.put_pixels_tab[0][0](dst, src, plane->pitch, h);
269  }
270 
271  /* copy using 8xH blocks */
272  if (!((cell->xpos << 2) & 7) && w >= 2) {
273  ctx->hdsp.put_pixels_tab[1][0](dst, src, plane->pitch, h);
274  w -= 2;
275  src += 8;
276  dst += 8;
277  } else if (w >= 1) {
278  ctx->hdsp.put_pixels_tab[2][0](dst, src, plane->pitch, h);
279  w--;
280  src += 4;
281  dst += 4;
282  }
283  }
284 
285  return 0;
286 }
287 
288 
289 /* Average 4/8 pixels at once without rounding using SWAR */
290 #define AVG_32(dst, src, ref) \
291  AV_WN32A(dst, ((AV_RN32(src) + AV_RN32(ref)) >> 1) & 0x7F7F7F7FUL)
292 
293 #define AVG_64(dst, src, ref) \
294  AV_WN64A(dst, ((AV_RN64(src) + AV_RN64(ref)) >> 1) & 0x7F7F7F7F7F7F7F7FULL)
295 
296 
297 /*
298  * Replicate each even pixel as follows:
299  * ABCDEFGH -> AACCEEGG
300  */
301 static inline uint64_t replicate64(uint64_t a) {
302 #if HAVE_BIGENDIAN
303  a &= 0xFF00FF00FF00FF00ULL;
304  a |= a >> 8;
305 #else
306  a &= 0x00FF00FF00FF00FFULL;
307  a |= a << 8;
308 #endif
309  return a;
310 }
311 
312 static inline uint32_t replicate32(uint32_t a) {
313 #if HAVE_BIGENDIAN
314  a &= 0xFF00FF00UL;
315  a |= a >> 8;
316 #else
317  a &= 0x00FF00FFUL;
318  a |= a << 8;
319 #endif
320  return a;
321 }
322 
323 
324 /* Fill n lines with 64-bit pixel value pix */
325 static inline void fill_64(uint8_t *dst, const uint64_t pix, int32_t n,
326  int32_t row_offset)
327 {
328  for (; n > 0; dst += row_offset, n--)
329  AV_WN64A(dst, pix);
330 }
331 
332 
333 /* Error codes for cell decoding. */
334 enum {
341 };
342 
343 
344 #define BUFFER_PRECHECK \
345 if (*data_ptr >= last_ptr) \
346  return IV3_OUT_OF_DATA; \
347 
348 #define RLE_BLOCK_COPY \
349  if (cell->mv_ptr || !skip_flag) \
350  copy_block4(dst, ref, row_offset, row_offset, 4 << v_zoom)
351 
352 #define RLE_BLOCK_COPY_8 \
353  pix64 = AV_RN64(ref);\
354  if (is_first_row) {/* special prediction case: top line of a cell */\
355  pix64 = replicate64(pix64);\
356  fill_64(dst + row_offset, pix64, 7, row_offset);\
357  AVG_64(dst, ref, dst + row_offset);\
358  } else \
359  fill_64(dst, pix64, 8, row_offset)
360 
361 #define RLE_LINES_COPY \
362  copy_block4(dst, ref, row_offset, row_offset, num_lines << v_zoom)
363 
364 #define RLE_LINES_COPY_M10 \
365  pix64 = AV_RN64(ref);\
366  if (is_top_of_cell) {\
367  pix64 = replicate64(pix64);\
368  fill_64(dst + row_offset, pix64, (num_lines << 1) - 1, row_offset);\
369  AVG_64(dst, ref, dst + row_offset);\
370  } else \
371  fill_64(dst, pix64, num_lines << 1, row_offset)
372 
373 #define APPLY_DELTA_4 \
374  AV_WN16A(dst + line_offset ,\
375  (AV_RN16(ref ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
376  AV_WN16A(dst + line_offset + 2,\
377  (AV_RN16(ref + 2) + delta_tab->deltas[dyad2]) & 0x7F7F);\
378  if (mode >= 3) {\
379  if (is_top_of_cell && !cell->ypos) {\
380  AV_COPY32U(dst, dst + row_offset);\
381  } else {\
382  AVG_32(dst, ref, dst + row_offset);\
383  }\
384  }
385 
386 #define APPLY_DELTA_8 \
387  /* apply two 32-bit VQ deltas to next even line */\
388  if (is_top_of_cell) { \
389  AV_WN32A(dst + row_offset , \
390  (replicate32(AV_RN32(ref )) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
391  AV_WN32A(dst + row_offset + 4, \
392  (replicate32(AV_RN32(ref + 4)) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
393  } else { \
394  AV_WN32A(dst + row_offset , \
395  (AV_RN32(ref ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
396  AV_WN32A(dst + row_offset + 4, \
397  (AV_RN32(ref + 4) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
398  } \
399  /* odd lines are not coded but rather interpolated/replicated */\
400  /* first line of the cell on the top of image? - replicate */\
401  /* otherwise - interpolate */\
402  if (is_top_of_cell && !cell->ypos) {\
403  AV_COPY64U(dst, dst + row_offset);\
404  } else \
405  AVG_64(dst, ref, dst + row_offset);
406 
407 
408 #define APPLY_DELTA_1011_INTER \
409  if (mode == 10) { \
410  AV_WN32A(dst , \
411  (AV_RN32(dst ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
412  AV_WN32A(dst + 4 , \
413  (AV_RN32(dst + 4 ) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
414  AV_WN32A(dst + row_offset , \
415  (AV_RN32(dst + row_offset ) + delta_tab->deltas_m10[dyad1]) & 0x7F7F7F7F);\
416  AV_WN32A(dst + row_offset + 4, \
417  (AV_RN32(dst + row_offset + 4) + delta_tab->deltas_m10[dyad2]) & 0x7F7F7F7F);\
418  } else { \
419  AV_WN16A(dst , \
420  (AV_RN16(dst ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
421  AV_WN16A(dst + 2 , \
422  (AV_RN16(dst + 2 ) + delta_tab->deltas[dyad2]) & 0x7F7F);\
423  AV_WN16A(dst + row_offset , \
424  (AV_RN16(dst + row_offset ) + delta_tab->deltas[dyad1]) & 0x7F7F);\
425  AV_WN16A(dst + row_offset + 2, \
426  (AV_RN16(dst + row_offset + 2) + delta_tab->deltas[dyad2]) & 0x7F7F);\
427  }
428 
429 
431  uint8_t *block, uint8_t *ref_block,
432  ptrdiff_t row_offset, int h_zoom, int v_zoom, int mode,
433  const vqEntry *delta[2], int swap_quads[2],
434  const uint8_t **data_ptr, const uint8_t *last_ptr)
435 {
436  int x, y, line, num_lines;
437  int rle_blocks = 0;
438  uint8_t code, *dst, *ref;
439  const vqEntry *delta_tab;
440  unsigned int dyad1, dyad2;
441  uint64_t pix64;
442  int skip_flag = 0, is_top_of_cell, is_first_row = 1;
443  int blk_row_offset, line_offset;
444 
445  blk_row_offset = (row_offset << (2 + v_zoom)) - (cell->width << 2);
446  line_offset = v_zoom ? row_offset : 0;
447 
448  if (cell->height & v_zoom || cell->width & h_zoom)
449  return IV3_BAD_DATA;
450 
451  for (y = 0; y < cell->height; is_first_row = 0, y += 1 + v_zoom) {
452  for (x = 0; x < cell->width; x += 1 + h_zoom) {
453  ref = ref_block;
454  dst = block;
455 
456  if (rle_blocks > 0) {
457  if (mode <= 4) {
459  } else if (mode == 10 && !cell->mv_ptr) {
461  }
462  rle_blocks--;
463  } else {
464  for (line = 0; line < 4;) {
465  num_lines = 1;
466  is_top_of_cell = is_first_row && !line;
467 
468  /* select primary VQ table for odd, secondary for even lines */
469  if (mode <= 4)
470  delta_tab = delta[line & 1];
471  else
472  delta_tab = delta[1];
474  code = bytestream_get_byte(data_ptr);
475  if (code < 248) {
476  if (code < delta_tab->num_dyads) {
478  dyad1 = bytestream_get_byte(data_ptr);
479  dyad2 = code;
480  if (dyad1 >= delta_tab->num_dyads || dyad1 >= 248)
481  return IV3_BAD_DATA;
482  } else {
483  /* process QUADS */
484  code -= delta_tab->num_dyads;
485  dyad1 = code / delta_tab->quad_exp;
486  dyad2 = code % delta_tab->quad_exp;
487  if (swap_quads[line & 1])
488  FFSWAP(unsigned int, dyad1, dyad2);
489  }
490  if (mode <= 4) {
492  } else if (mode == 10 && !cell->mv_ptr) {
494  } else {
496  }
497  } else {
498  /* process RLE codes */
499  switch (code) {
500  case RLE_ESC_FC:
501  skip_flag = 0;
502  rle_blocks = 1;
503  code = 253;
504  /* FALLTHROUGH */
505  case RLE_ESC_FF:
506  case RLE_ESC_FE:
507  case RLE_ESC_FD:
508  num_lines = 257 - code - line;
509  if (num_lines <= 0)
510  return IV3_BAD_RLE;
511  if (mode <= 4) {
513  } else if (mode == 10 && !cell->mv_ptr) {
515  }
516  break;
517  case RLE_ESC_FB:
519  code = bytestream_get_byte(data_ptr);
520  rle_blocks = (code & 0x1F) - 1; /* set block counter */
521  if (code >= 64 || rle_blocks < 0)
522  return IV3_BAD_COUNTER;
523  skip_flag = code & 0x20;
524  num_lines = 4 - line; /* enforce next block processing */
525  if (mode >= 10 || (cell->mv_ptr || !skip_flag)) {
526  if (mode <= 4) {
528  } else if (mode == 10 && !cell->mv_ptr) {
530  }
531  }
532  break;
533  case RLE_ESC_F9:
534  skip_flag = 1;
535  rle_blocks = 1;
536  /* FALLTHROUGH */
537  case RLE_ESC_FA:
538  if (line)
539  return IV3_BAD_RLE;
540  num_lines = 4; /* enforce next block processing */
541  if (cell->mv_ptr) {
542  if (mode <= 4) {
544  } else if (mode == 10 && !cell->mv_ptr) {
546  }
547  }
548  break;
549  default:
550  return IV3_UNSUPPORTED;
551  }
552  }
553 
554  line += num_lines;
555  ref += row_offset * (num_lines << v_zoom);
556  dst += row_offset * (num_lines << v_zoom);
557  }
558  }
559 
560  /* move to next horizontal block */
561  block += 4 << h_zoom;
562  ref_block += 4 << h_zoom;
563  }
564 
565  /* move to next line of blocks */
566  ref_block += blk_row_offset;
567  block += blk_row_offset;
568  }
569  return IV3_NOERR;
570 }
571 
572 
573 /**
574  * Decode a vector-quantized cell.
575  * It consists of several routines, each of which handles one or more "modes"
576  * with which a cell can be encoded.
577  *
578  * @param ctx pointer to the decoder context
579  * @param avctx ptr to the AVCodecContext
580  * @param plane pointer to the plane descriptor
581  * @param cell pointer to the cell descriptor
582  * @param data_ptr pointer to the compressed data
583  * @param last_ptr pointer to the last byte to catch reads past end of buffer
584  * @return number of consumed bytes or negative number in case of error
585  */
587  Plane *plane, Cell *cell, const uint8_t *data_ptr,
588  const uint8_t *last_ptr)
589 {
590  int x, mv_x, mv_y, mode, vq_index, prim_indx, second_indx;
591  int zoom_fac;
592  int offset, error = 0, swap_quads[2];
593  uint8_t code, *block, *ref_block = 0;
594  const vqEntry *delta[2];
595  const uint8_t *data_start = data_ptr;
596 
597  /* get coding mode and VQ table index from the VQ descriptor byte */
598  code = *data_ptr++;
599  mode = code >> 4;
600  vq_index = code & 0xF;
601 
602  /* setup output and reference pointers */
603  offset = (cell->ypos << 2) * plane->pitch + (cell->xpos << 2);
604  block = plane->pixels[ctx->buf_sel] + offset;
605 
606  if (!cell->mv_ptr) {
607  /* use previous line as reference for INTRA cells */
608  ref_block = block - plane->pitch;
609  } else if (mode >= 10) {
610  /* for mode 10 and 11 INTER first copy the predicted cell into the current one */
611  /* so we don't need to do data copying for each RLE code later */
612  int ret = copy_cell(ctx, plane, cell);
613  if (ret < 0)
614  return ret;
615  } else {
616  /* set the pointer to the reference pixels for modes 0-4 INTER */
617  mv_y = cell->mv_ptr[0];
618  mv_x = cell->mv_ptr[1];
619 
620  /* -1 because there is an extra line on top for prediction */
621  if ((cell->ypos << 2) + mv_y < -1 || (cell->xpos << 2) + mv_x < 0 ||
622  ((cell->ypos + cell->height) << 2) + mv_y > plane->height ||
623  ((cell->xpos + cell->width) << 2) + mv_x > plane->width) {
624  av_log(ctx->avctx, AV_LOG_ERROR,
625  "Motion vectors point out of the frame.\n");
626  return AVERROR_INVALIDDATA;
627  }
628 
629  offset += mv_y * plane->pitch + mv_x;
630  ref_block = plane->pixels[ctx->buf_sel ^ 1] + offset;
631  }
632 
633  /* select VQ tables as follows: */
634  /* modes 0 and 3 use only the primary table for all lines in a block */
635  /* while modes 1 and 4 switch between primary and secondary tables on alternate lines */
636  if (mode == 1 || mode == 4) {
637  code = ctx->alt_quant[vq_index];
638  prim_indx = (code >> 4) + ctx->cb_offset;
639  second_indx = (code & 0xF) + ctx->cb_offset;
640  } else {
641  vq_index += ctx->cb_offset;
642  prim_indx = second_indx = vq_index;
643  }
644 
645  if (prim_indx >= 24 || second_indx >= 24) {
646  av_log(avctx, AV_LOG_ERROR, "Invalid VQ table indexes! Primary: %d, secondary: %d!\n",
647  prim_indx, second_indx);
648  return AVERROR_INVALIDDATA;
649  }
650 
651  delta[0] = &vq_tab[second_indx];
652  delta[1] = &vq_tab[prim_indx];
653  swap_quads[0] = second_indx >= 16;
654  swap_quads[1] = prim_indx >= 16;
655 
656  /* requantize the prediction if VQ index of this cell differs from VQ index */
657  /* of the predicted cell in order to avoid overflows. */
658  if (vq_index >= 8 && ref_block) {
659  for (x = 0; x < cell->width << 2; x++)
660  ref_block[x] = requant_tab[vq_index & 7][ref_block[x] & 127];
661  }
662 
663  error = IV3_NOERR;
664 
665  switch (mode) {
666  case 0: /*------------------ MODES 0 & 1 (4x4 block processing) --------------------*/
667  case 1:
668  case 3: /*------------------ MODES 3 & 4 (4x8 block processing) --------------------*/
669  case 4:
670  if (mode >= 3 && cell->mv_ptr) {
671  av_log(avctx, AV_LOG_ERROR, "Attempt to apply Mode 3/4 to an INTER cell!\n");
672  return AVERROR_INVALIDDATA;
673  }
674 
675  zoom_fac = mode >= 3;
676  error = decode_cell_data(ctx, cell, block, ref_block, plane->pitch,
677  0, zoom_fac, mode, delta, swap_quads,
678  &data_ptr, last_ptr);
679  break;
680  case 10: /*-------------------- MODE 10 (8x8 block processing) ---------------------*/
681  case 11: /*----------------- MODE 11 (4x8 INTER block processing) ------------------*/
682  if (mode == 10 && !cell->mv_ptr) { /* MODE 10 INTRA processing */
683  error = decode_cell_data(ctx, cell, block, ref_block, plane->pitch,
684  1, 1, mode, delta, swap_quads,
685  &data_ptr, last_ptr);
686  } else { /* mode 10 and 11 INTER processing */
687  if (mode == 11 && !cell->mv_ptr) {
688  av_log(avctx, AV_LOG_ERROR, "Attempt to use Mode 11 for an INTRA cell!\n");
689  return AVERROR_INVALIDDATA;
690  }
691 
692  zoom_fac = mode == 10;
693  error = decode_cell_data(ctx, cell, block, ref_block, plane->pitch,
694  zoom_fac, 1, mode, delta, swap_quads,
695  &data_ptr, last_ptr);
696  }
697  break;
698  default:
699  av_log(avctx, AV_LOG_ERROR, "Unsupported coding mode: %d\n", mode);
700  return AVERROR_INVALIDDATA;
701  }//switch mode
702 
703  switch (error) {
704  case IV3_BAD_RLE:
705  av_log(avctx, AV_LOG_ERROR, "Mode %d: RLE code %X is not allowed at the current line\n",
706  mode, data_ptr[-1]);
707  return AVERROR_INVALIDDATA;
708  case IV3_BAD_DATA:
709  av_log(avctx, AV_LOG_ERROR, "Mode %d: invalid VQ data\n", mode);
710  return AVERROR_INVALIDDATA;
711  case IV3_BAD_COUNTER:
712  av_log(avctx, AV_LOG_ERROR, "Mode %d: RLE-FB invalid counter: %d\n", mode, code);
713  return AVERROR_INVALIDDATA;
714  case IV3_UNSUPPORTED:
715  av_log(avctx, AV_LOG_ERROR, "Mode %d: unsupported RLE code: %X\n", mode, data_ptr[-1]);
716  return AVERROR_INVALIDDATA;
717  case IV3_OUT_OF_DATA:
718  av_log(avctx, AV_LOG_ERROR, "Mode %d: attempt to read past end of buffer\n", mode);
719  return AVERROR_INVALIDDATA;
720  }
721 
722  return data_ptr - data_start; /* report number of bytes consumed from the input buffer */
723 }
724 
725 
726 /* Binary tree codes. */
727 enum {
728  H_SPLIT = 0,
729  V_SPLIT = 1,
732 };
733 
734 
735 #define SPLIT_CELL(size, new_size) (new_size) = ((size) > 2) ? ((((size) + 2) >> 2) << 1) : 1
736 
737 #define UPDATE_BITPOS(n) \
738  ctx->skip_bits += (n); \
739  ctx->need_resync = 1
740 
741 #define RESYNC_BITSTREAM \
742  if (ctx->need_resync && !(get_bits_count(&ctx->gb) & 7)) { \
743  skip_bits_long(&ctx->gb, ctx->skip_bits); \
744  ctx->skip_bits = 0; \
745  ctx->need_resync = 0; \
746  }
747 
748 #define CHECK_CELL \
749  if (curr_cell.xpos + curr_cell.width > (plane->width >> 2) || \
750  curr_cell.ypos + curr_cell.height > (plane->height >> 2)) { \
751  av_log(avctx, AV_LOG_ERROR, "Invalid cell: x=%d, y=%d, w=%d, h=%d\n", \
752  curr_cell.xpos, curr_cell.ypos, curr_cell.width, curr_cell.height); \
753  return AVERROR_INVALIDDATA; \
754  }
755 
756 
758  Plane *plane, int code, Cell *ref_cell,
759  const int depth, const int strip_width)
760 {
761  Cell curr_cell;
762  int bytes_used, ret;
763 
764  if (depth <= 0) {
765  av_log(avctx, AV_LOG_ERROR, "Stack overflow (corrupted binary tree)!\n");
766  return AVERROR_INVALIDDATA; // unwind recursion
767  }
768 
769  curr_cell = *ref_cell; // clone parent cell
770  if (code == H_SPLIT) {
771  SPLIT_CELL(ref_cell->height, curr_cell.height);
772  ref_cell->ypos += curr_cell.height;
773  ref_cell->height -= curr_cell.height;
774  if (ref_cell->height <= 0 || curr_cell.height <= 0)
775  return AVERROR_INVALIDDATA;
776  } else if (code == V_SPLIT) {
777  if (curr_cell.width > strip_width) {
778  /* split strip */
779  curr_cell.width = (curr_cell.width <= (strip_width << 1) ? 1 : 2) * strip_width;
780  } else
781  SPLIT_CELL(ref_cell->width, curr_cell.width);
782  ref_cell->xpos += curr_cell.width;
783  ref_cell->width -= curr_cell.width;
784  if (ref_cell->width <= 0 || curr_cell.width <= 0)
785  return AVERROR_INVALIDDATA;
786  }
787 
788  while (get_bits_left(&ctx->gb) >= 2) { /* loop until return */
790  switch (code = get_bits(&ctx->gb, 2)) {
791  case H_SPLIT:
792  case V_SPLIT:
793  if (parse_bintree(ctx, avctx, plane, code, &curr_cell, depth - 1, strip_width))
794  return AVERROR_INVALIDDATA;
795  break;
796  case INTRA_NULL:
797  if (!curr_cell.tree) { /* MC tree INTRA code */
798  curr_cell.mv_ptr = 0; /* mark the current strip as INTRA */
799  curr_cell.tree = 1; /* enter the VQ tree */
800  } else { /* VQ tree NULL code */
802  code = get_bits(&ctx->gb, 2);
803  if (code >= 2) {
804  av_log(avctx, AV_LOG_ERROR, "Invalid VQ_NULL code: %d\n", code);
805  return AVERROR_INVALIDDATA;
806  }
807  if (code == 1)
808  av_log(avctx, AV_LOG_ERROR, "SkipCell procedure not implemented yet!\n");
809 
810  CHECK_CELL
811  if (!curr_cell.mv_ptr)
812  return AVERROR_INVALIDDATA;
813 
814  ret = copy_cell(ctx, plane, &curr_cell);
815  return ret;
816  }
817  break;
818  case INTER_DATA:
819  if (!curr_cell.tree) { /* MC tree INTER code */
820  unsigned mv_idx;
821  /* get motion vector index and setup the pointer to the mv set */
822  if (!ctx->need_resync)
823  ctx->next_cell_data = &ctx->gb.buffer[(get_bits_count(&ctx->gb) + 7) >> 3];
824  if (ctx->next_cell_data >= ctx->last_byte) {
825  av_log(avctx, AV_LOG_ERROR, "motion vector out of array\n");
826  return AVERROR_INVALIDDATA;
827  }
828  mv_idx = *(ctx->next_cell_data++);
829  if (mv_idx >= ctx->num_vectors) {
830  av_log(avctx, AV_LOG_ERROR, "motion vector index out of range\n");
831  return AVERROR_INVALIDDATA;
832  }
833  curr_cell.mv_ptr = &ctx->mc_vectors[mv_idx << 1];
834  curr_cell.tree = 1; /* enter the VQ tree */
835  UPDATE_BITPOS(8);
836  } else { /* VQ tree DATA code */
837  if (!ctx->need_resync)
838  ctx->next_cell_data = &ctx->gb.buffer[(get_bits_count(&ctx->gb) + 7) >> 3];
839 
840  CHECK_CELL
841  bytes_used = decode_cell(ctx, avctx, plane, &curr_cell,
842  ctx->next_cell_data, ctx->last_byte);
843  if (bytes_used < 0)
844  return AVERROR_INVALIDDATA;
845 
846  UPDATE_BITPOS(bytes_used << 3);
847  ctx->next_cell_data += bytes_used;
848  return 0;
849  }
850  break;
851  }
852  }//while
853 
854  return AVERROR_INVALIDDATA;
855 }
856 
857 
859  Plane *plane, const uint8_t *data, int32_t data_size,
860  int32_t strip_width)
861 {
862  Cell curr_cell;
863  unsigned num_vectors;
864 
865  /* each plane data starts with mc_vector_count field, */
866  /* an optional array of motion vectors followed by the vq data */
867  num_vectors = bytestream_get_le32(&data); data_size -= 4;
868  if (num_vectors > 256) {
869  av_log(ctx->avctx, AV_LOG_ERROR,
870  "Read invalid number of motion vectors %d\n", num_vectors);
871  return AVERROR_INVALIDDATA;
872  }
873  if (num_vectors * 2 > data_size)
874  return AVERROR_INVALIDDATA;
875 
876  ctx->num_vectors = num_vectors;
877  ctx->mc_vectors = num_vectors ? data : 0;
878 
879  /* init the bitreader */
880  init_get_bits(&ctx->gb, &data[num_vectors * 2], (data_size - num_vectors * 2) << 3);
881  ctx->skip_bits = 0;
882  ctx->need_resync = 0;
883 
884  ctx->last_byte = data + data_size;
885 
886  /* initialize the 1st cell and set its dimensions to whole plane */
887  curr_cell.xpos = curr_cell.ypos = 0;
888  curr_cell.width = plane->width >> 2;
889  curr_cell.height = plane->height >> 2;
890  curr_cell.tree = 0; // we are in the MC tree now
891  curr_cell.mv_ptr = 0; // no motion vector = INTRA cell
892 
893  return parse_bintree(ctx, avctx, plane, INTRA_NULL, &curr_cell, CELL_STACK_MAX, strip_width);
894 }
895 
896 
897 #define OS_HDR_ID MKBETAG('F', 'R', 'M', 'H')
898 
900  const uint8_t *buf, int buf_size)
901 {
902  GetByteContext gb;
903  const uint8_t *bs_hdr;
904  uint32_t frame_num, word2, check_sum, data_size;
905  int y_offset, u_offset, v_offset;
906  uint32_t starts[3], ends[3];
907  uint16_t height, width;
908  int i, j;
909 
910  bytestream2_init(&gb, buf, buf_size);
911 
912  /* parse and check the OS header */
913  frame_num = bytestream2_get_le32(&gb);
914  word2 = bytestream2_get_le32(&gb);
915  check_sum = bytestream2_get_le32(&gb);
916  data_size = bytestream2_get_le32(&gb);
917 
918  if ((frame_num ^ word2 ^ data_size ^ OS_HDR_ID) != check_sum) {
919  av_log(avctx, AV_LOG_ERROR, "OS header checksum mismatch!\n");
920  return AVERROR_INVALIDDATA;
921  }
922 
923  /* parse the bitstream header */
924  bs_hdr = gb.buffer;
925 
926  if (bytestream2_get_le16(&gb) != 32) {
927  av_log(avctx, AV_LOG_ERROR, "Unsupported codec version!\n");
928  return AVERROR_INVALIDDATA;
929  }
930 
931  ctx->frame_num = frame_num;
932  ctx->frame_flags = bytestream2_get_le16(&gb);
933  ctx->data_size = (bytestream2_get_le32(&gb) + 7) >> 3;
934  ctx->cb_offset = bytestream2_get_byte(&gb);
935 
936  if (ctx->data_size == 16)
937  return 4;
938  ctx->data_size = FFMIN(ctx->data_size, buf_size - 16);
939 
940  bytestream2_skip(&gb, 3); // skip reserved byte and checksum
941 
942  /* check frame dimensions */
943  height = bytestream2_get_le16(&gb);
944  width = bytestream2_get_le16(&gb);
945  if (av_image_check_size(width, height, 0, avctx))
946  return AVERROR_INVALIDDATA;
947 
948  if (width != ctx->width || height != ctx->height) {
949  int res;
950 
951  ff_dlog(avctx, "Frame dimensions changed!\n");
952 
953  if (width < 16 || width > 640 ||
954  height < 16 || height > 480 ||
955  width & 3 || height & 3) {
956  av_log(avctx, AV_LOG_ERROR,
957  "Invalid picture dimensions: %d x %d!\n", width, height);
958  return AVERROR_INVALIDDATA;
959  }
961  if ((res = allocate_frame_buffers(ctx, avctx, width, height)) < 0)
962  return res;
963  if ((res = ff_set_dimensions(avctx, width, height)) < 0)
964  return res;
965  }
966 
967  y_offset = bytestream2_get_le32(&gb);
968  v_offset = bytestream2_get_le32(&gb);
969  u_offset = bytestream2_get_le32(&gb);
970  bytestream2_skip(&gb, 4);
971 
972  /* unfortunately there is no common order of planes in the buffer */
973  /* so we use that sorting algo for determining planes data sizes */
974  starts[0] = y_offset;
975  starts[1] = v_offset;
976  starts[2] = u_offset;
977 
978  for (j = 0; j < 3; j++) {
979  ends[j] = ctx->data_size;
980  for (i = 2; i >= 0; i--)
981  if (starts[i] < ends[j] && starts[i] > starts[j])
982  ends[j] = starts[i];
983  }
984 
985  ctx->y_data_size = ends[0] - starts[0];
986  ctx->v_data_size = ends[1] - starts[1];
987  ctx->u_data_size = ends[2] - starts[2];
988  if (FFMIN3(y_offset, v_offset, u_offset) < 0 ||
989  FFMAX3(y_offset, v_offset, u_offset) >= ctx->data_size - 16 ||
990  FFMIN3(y_offset, v_offset, u_offset) < gb.buffer - bs_hdr + 16 ||
991  FFMIN3(ctx->y_data_size, ctx->v_data_size, ctx->u_data_size) <= 0) {
992  av_log(avctx, AV_LOG_ERROR, "One of the y/u/v offsets is invalid\n");
993  return AVERROR_INVALIDDATA;
994  }
995 
996  ctx->y_data_ptr = bs_hdr + y_offset;
997  ctx->v_data_ptr = bs_hdr + v_offset;
998  ctx->u_data_ptr = bs_hdr + u_offset;
999  ctx->alt_quant = gb.buffer;
1000 
1001  if (ctx->data_size == 16) {
1002  av_log(avctx, AV_LOG_DEBUG, "Sync frame encountered!\n");
1003  return 16;
1004  }
1005 
1006  if (ctx->frame_flags & BS_8BIT_PEL) {
1007  avpriv_request_sample(avctx, "8-bit pixel format");
1008  return AVERROR_PATCHWELCOME;
1009  }
1010 
1011  if (ctx->frame_flags & BS_MV_X_HALF || ctx->frame_flags & BS_MV_Y_HALF) {
1012  avpriv_request_sample(avctx, "Halfpel motion vectors");
1013  return AVERROR_PATCHWELCOME;
1014  }
1015 
1016  return 0;
1017 }
1018 
1019 
1020 /**
1021  * Convert and output the current plane.
1022  * All pixel values will be upsampled by shifting right by one bit.
1023  *
1024  * @param[in] plane pointer to the descriptor of the plane being processed
1025  * @param[in] buf_sel indicates which frame buffer the input data stored in
1026  * @param[out] dst pointer to the buffer receiving converted pixels
1027  * @param[in] dst_pitch pitch for moving to the next y line
1028  * @param[in] dst_height output plane height
1029  */
1030 static void output_plane(const Plane *plane, int buf_sel, uint8_t *dst,
1031  ptrdiff_t dst_pitch, int dst_height)
1032 {
1033  int x,y;
1034  const uint8_t *src = plane->pixels[buf_sel];
1035  ptrdiff_t pitch = plane->pitch;
1036 
1037  dst_height = FFMIN(dst_height, plane->height);
1038  for (y = 0; y < dst_height; y++) {
1039  /* convert four pixels at once using SWAR */
1040  for (x = 0; x < plane->width >> 2; x++) {
1041  AV_WN32A(dst, (AV_RN32A(src) & 0x7F7F7F7F) << 1);
1042  src += 4;
1043  dst += 4;
1044  }
1045 
1046  for (x <<= 2; x < plane->width; x++)
1047  *dst++ = *src++ << 1;
1048 
1049  src += pitch - plane->width;
1050  dst += dst_pitch - plane->width;
1051  }
1052 }
1053 
1054 
1056 {
1057  static AVOnce init_static_once = AV_ONCE_INIT;
1058  Indeo3DecodeContext *ctx = avctx->priv_data;
1059 
1060  ctx->avctx = avctx;
1061  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
1062 
1063  ff_thread_once(&init_static_once, build_requant_tab);
1064 
1065  ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
1066 
1067  return allocate_frame_buffers(ctx, avctx, avctx->width, avctx->height);
1068 }
1069 
1070 
1072  int *got_frame, AVPacket *avpkt)
1073 {
1074  Indeo3DecodeContext *ctx = avctx->priv_data;
1075  const uint8_t *buf = avpkt->data;
1076  int buf_size = avpkt->size;
1077  int res;
1078 
1079  res = decode_frame_headers(ctx, avctx, buf, buf_size);
1080  if (res < 0)
1081  return res;
1082 
1083  /* skip sync(null) frames */
1084  if (res) {
1085  // we have processed 16 bytes but no data was decoded
1086  *got_frame = 0;
1087  return buf_size;
1088  }
1089 
1090  /* skip droppable INTER frames if requested */
1091  if (ctx->frame_flags & BS_NONREF &&
1092  (avctx->skip_frame >= AVDISCARD_NONREF))
1093  return 0;
1094 
1095  /* skip INTER frames if requested */
1096  if (!(ctx->frame_flags & BS_KEYFRAME) && avctx->skip_frame >= AVDISCARD_NONKEY)
1097  return 0;
1098 
1099  /* use BS_BUFFER flag for buffer switching */
1100  ctx->buf_sel = (ctx->frame_flags >> BS_BUFFER) & 1;
1101 
1102  if ((res = ff_get_buffer(avctx, frame, 0)) < 0)
1103  return res;
1104 
1105  /* decode luma plane */
1106  if ((res = decode_plane(ctx, avctx, ctx->planes, ctx->y_data_ptr, ctx->y_data_size, 40)))
1107  return res;
1108 
1109  /* decode chroma planes */
1110  if ((res = decode_plane(ctx, avctx, &ctx->planes[1], ctx->u_data_ptr, ctx->u_data_size, 10)))
1111  return res;
1112 
1113  if ((res = decode_plane(ctx, avctx, &ctx->planes[2], ctx->v_data_ptr, ctx->v_data_size, 10)))
1114  return res;
1115 
1116  output_plane(&ctx->planes[0], ctx->buf_sel,
1117  frame->data[0], frame->linesize[0],
1118  avctx->height);
1119  output_plane(&ctx->planes[1], ctx->buf_sel,
1120  frame->data[1], frame->linesize[1],
1121  (avctx->height + 3) >> 2);
1122  output_plane(&ctx->planes[2], ctx->buf_sel,
1123  frame->data[2], frame->linesize[2],
1124  (avctx->height + 3) >> 2);
1125 
1126  *got_frame = 1;
1127 
1128  return buf_size;
1129 }
1130 
1131 
1133 {
1134  free_frame_buffers(avctx->priv_data);
1135 
1136  return 0;
1137 }
1138 
1140  .p.name = "indeo3",
1141  CODEC_LONG_NAME("Intel Indeo 3"),
1142  .p.type = AVMEDIA_TYPE_VIDEO,
1143  .p.id = AV_CODEC_ID_INDEO3,
1144  .priv_data_size = sizeof(Indeo3DecodeContext),
1145  .init = decode_init,
1146  .close = decode_close,
1148  .p.capabilities = AV_CODEC_CAP_DR1,
1149  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1150 };
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:31
IV3_UNSUPPORTED
@ IV3_UNSUPPORTED
Definition: indeo3.c:339
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
APPLY_DELTA_8
#define APPLY_DELTA_8
Definition: indeo3.c:386
vq_tab
static const vqEntry vq_tab[24]
Definition: indeo3data.h:330
BS_NONREF
#define BS_NONREF
nonref (discardable) frame indicator
Definition: indeo3.c:62
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
AVERROR
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
Cell::height
int16_t height
cell height in 4x4 blocks
Definition: indeo3.c:80
RLE_ESC_FF
@ RLE_ESC_FF
apply null delta to all lines up to the 2nd line
Definition: indeo3.c:53
APPLY_DELTA_4
#define APPLY_DELTA_4
Definition: indeo3.c:373
GetByteContext
Definition: bytestream.h:33
OS_HDR_ID
#define OS_HDR_ID
Definition: indeo3.c:897
thread.h
RLE_ESC_FE
@ RLE_ESC_FE
apply null delta to all lines up to the 3rd line
Definition: indeo3.c:52
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: indeo3.c:1132
IV3_BAD_RLE
@ IV3_BAD_RLE
Definition: indeo3.c:336
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
step
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
Definition: rate_distortion.txt:58
BS_MV_Y_HALF
#define BS_MV_Y_HALF
vertical mv halfpel resolution indicator
Definition: indeo3.c:60
w
uint8_t w
Definition: llviddspenc.c:38
AV_CODEC_ID_INDEO3
@ AV_CODEC_ID_INDEO3
Definition: codec_id.h:80
AVPacket::data
uint8_t * data
Definition: packet.h:522
data
const char data[16]
Definition: mxf.c:148
decode_frame_headers
static int decode_frame_headers(Indeo3DecodeContext *ctx, AVCodecContext *avctx, const uint8_t *buf, int buf_size)
Definition: indeo3.c:899
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: indeo3.c:1071
FFCodec
Definition: codec_internal.h:127
Indeo3DecodeContext::alt_quant
const uint8_t * alt_quant
secondary VQ table set for the modes 1 and 4
Definition: indeo3.c:109
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:536
BS_MV_X_HALF
#define BS_MV_X_HALF
horizontal mv halfpel resolution indicator
Definition: indeo3.c:61
CELL_STACK_MAX
#define CELL_STACK_MAX
Definition: indeo3.c:74
decode_cell
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.
Definition: indeo3.c:586
Indeo3DecodeContext::mc_vectors
const int8_t * mc_vectors
Definition: indeo3.c:94
ff_set_dimensions
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.
Definition: utils.c:94
RLE_ESC_FB
@ RLE_ESC_FB
apply null delta to N blocks / skip N blocks
Definition: indeo3.c:49
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:30
BUFFER_PRECHECK
#define BUFFER_PRECHECK
Definition: indeo3.c:344
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
decode_cell_data
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)
Definition: indeo3.c:430
Cell::xpos
int16_t xpos
cell coordinates in 4x4 blocks
Definition: indeo3.c:77
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1770
GetBitContext
Definition: get_bits.h:108
requant_tab
static uint8_t requant_tab[8][128]
Definition: indeo3.c:114
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:525
BS_BUFFER
#define BS_BUFFER
indicates which of two frame buffers should be used
Definition: indeo3.c:63
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
Indeo3DecodeContext::width
int16_t width
Definition: indeo3.c:97
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
build_requant_tab
static av_cold void build_requant_tab(void)
Definition: indeo3.c:121
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
intreadwrite.h
Indeo3DecodeContext::gb
GetBitContext gb
Definition: indeo3.c:89
offsets
static const int offsets[]
Definition: hevc_pel.c:34
Indeo3DecodeContext::buf_sel
uint8_t buf_sel
active frame buffer: 0 - primary, 1 -secondary
Definition: indeo3.c:102
copy_cell
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,...
Definition: indeo3.c:236
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
Indeo3DecodeContext::hdsp
HpelDSPContext hdsp
Definition: indeo3.c:87
UPDATE_BITPOS
#define UPDATE_BITPOS(n)
Definition: indeo3.c:737
RLE_LINES_COPY_M10
#define RLE_LINES_COPY_M10
Definition: indeo3.c:364
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: indeo3.c:1055
Indeo3DecodeContext::v_data_size
int32_t v_data_size
Definition: indeo3.c:107
decode.h
get_bits.h
BS_KEYFRAME
#define BS_KEYFRAME
intra frame indicator
Definition: indeo3.c:59
Plane::buffers
uint8_t * buffers[2]
Definition: indeo3.c:67
RLE_ESC_FD
@ RLE_ESC_FD
apply null delta to all remaining lines of this block
Definition: indeo3.c:51
INTER_DATA
@ INTER_DATA
Definition: indeo3.c:731
vqEntry
Definition: indeo3data.h:323
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
frame
static AVFrame * frame
Definition: demux_decode.c:54
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
parse_bintree
static int parse_bintree(Indeo3DecodeContext *ctx, AVCodecContext *avctx, Plane *plane, int code, Cell *ref_cell, const int depth, const int strip_width)
Definition: indeo3.c:757
INTRA_NULL
@ INTRA_NULL
Definition: indeo3.c:730
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
Indeo3DecodeContext::y_data_ptr
const uint8_t * y_data_ptr
Definition: indeo3.c:103
Indeo3DecodeContext::next_cell_data
const uint8_t * next_cell_data
Definition: indeo3.c:92
IV3_BAD_DATA
@ IV3_BAD_DATA
Definition: indeo3.c:337
Indeo3DecodeContext::num_vectors
unsigned num_vectors
number of motion vectors in mc_vectors
Definition: indeo3.c:95
Indeo3DecodeContext::height
int16_t height
Definition: indeo3.c:97
Indeo3DecodeContext::u_data_ptr
const uint8_t * u_data_ptr
Definition: indeo3.c:105
Indeo3DecodeContext
Definition: indeo3.c:85
RLE_LINES_COPY
#define RLE_LINES_COPY
Definition: indeo3.c:361
Indeo3DecodeContext::last_byte
const uint8_t * last_byte
Definition: indeo3.c:93
Indeo3DecodeContext::planes
Plane planes[3]
Definition: indeo3.c:110
AVOnce
#define AVOnce
Definition: thread.h:202
SPLIT_CELL
#define SPLIT_CELL(size, new_size)
Definition: indeo3.c:735
IV3_NOERR
@ IV3_NOERR
Definition: indeo3.c:335
RLE_ESC_FA
@ RLE_ESC_FA
INTRA: skip block, INTER: copy data from reference.
Definition: indeo3.c:48
RLE_ESC_FC
@ RLE_ESC_FC
same as RLE_ESC_FD + do the same with next block
Definition: indeo3.c:50
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:45
Cell
Definition: indeo3.c:76
Plane::pixels
uint8_t * pixels[2]
pointer to the actual pixel data of the buffers above
Definition: indeo3.c:68
Cell::width
int16_t width
cell width in 4x4 blocks
Definition: indeo3.c:79
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:218
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1618
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:523
codec_internal.h
Plane::height
int height
Definition: cfhd.h:119
Indeo3DecodeContext::cb_offset
uint8_t cb_offset
needed for selecting VQ tables
Definition: indeo3.c:101
decode_plane
static int decode_plane(Indeo3DecodeContext *ctx, AVCodecContext *avctx, Plane *plane, const uint8_t *data, int32_t data_size, int32_t strip_width)
Definition: indeo3.c:858
Indeo3DecodeContext::v_data_ptr
const uint8_t * v_data_ptr
Definition: indeo3.c:104
Plane::pitch
ptrdiff_t pitch
Definition: indeo3.c:71
height
#define height
a
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
Definition: undefined.txt:41
allocate_frame_buffers
static av_cold int allocate_frame_buffers(Indeo3DecodeContext *ctx, AVCodecContext *avctx, int luma_width, int luma_height)
Definition: indeo3.c:167
Plane::width
int width
Definition: cfhd.h:118
Cell::ypos
int16_t ypos
Definition: indeo3.c:78
offset
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
Definition: writing_filters.txt:86
line
Definition: graph2dot.c:48
indeo3data.h
is_first_row
static int is_first_row(const VVCFrameContext *fc, const int rx, const int ry)
Definition: vvc_thread.c:144
Indeo3DecodeContext::avctx
AVCodecContext * avctx
Definition: indeo3.c:86
Indeo3DecodeContext::u_data_size
int32_t u_data_size
Definition: indeo3.c:108
Indeo3DecodeContext::data_size
int data_size
size of the frame data in bytes
Definition: indeo3.c:99
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:245
code
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
Definition: filter_design.txt:178
V_SPLIT
@ V_SPLIT
Definition: indeo3.c:729
copy_block.h
FFMIN3
#define FFMIN3(a, b, c)
Definition: macros.h:50
vqEntry::num_dyads
uint8_t num_dyads
number of two-pixel deltas
Definition: indeo3data.h:326
delta
float delta
Definition: vorbis_enc_data.h:430
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
RESYNC_BITSTREAM
#define RESYNC_BITSTREAM
Definition: indeo3.c:741
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
Cell::mv_ptr
const int8_t * mv_ptr
ptr to the motion vector if any
Definition: indeo3.c:82
AVCodecContext::height
int height
Definition: avcodec.h:625
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
Plane::width
uint32_t width
Definition: indeo3.c:69
avcodec.h
AV_RN32A
#define AV_RN32A(p)
Definition: intreadwrite.h:524
ret
ret
Definition: filter_design.txt:187
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
Indeo3DecodeContext::frame_num
uint32_t frame_num
current frame number (zero-based)
Definition: indeo3.c:98
Indeo3DecodeContext::y_data_size
int32_t y_data_size
Definition: indeo3.c:106
replicate64
static uint64_t replicate64(uint64_t a)
Definition: indeo3.c:301
free_frame_buffers
static av_cold void free_frame_buffers(Indeo3DecodeContext *ctx)
Definition: indeo3.c:153
BS_8BIT_PEL
#define BS_8BIT_PEL
8-bit pixel bitdepth indicator
Definition: indeo3.c:58
AV_WN64A
#define AV_WN64A(p, v)
Definition: intreadwrite.h:540
H_SPLIT
@ H_SPLIT
Definition: indeo3.c:728
Plane::height
uint32_t height
Definition: indeo3.c:70
AVCodecContext
main external API structure.
Definition: avcodec.h:445
Indeo3DecodeContext::skip_bits
int skip_bits
Definition: indeo3.c:91
RLE_ESC_F9
@ RLE_ESC_F9
same as RLE_ESC_FA + do the same with next block
Definition: indeo3.c:47
CHECK_CELL
#define CHECK_CELL
Definition: indeo3.c:748
mode
mode
Definition: ebur128.h:83
IV3_OUT_OF_DATA
@ IV3_OUT_OF_DATA
Definition: indeo3.c:340
APPLY_DELTA_1011_INTER
#define APPLY_DELTA_1011_INTER
Definition: indeo3.c:408
IV3_BAD_COUNTER
@ IV3_BAD_COUNTER
Definition: indeo3.c:338
output_plane
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.
Definition: indeo3.c:1030
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:112
RLE_BLOCK_COPY_8
#define RLE_BLOCK_COPY_8
Definition: indeo3.c:352
Plane
Definition: cfhd.h:117
Cell::tree
uint8_t tree
tree id: 0- MC tree, 1 - VQ tree
Definition: indeo3.c:81
RLE_BLOCK_COPY
#define RLE_BLOCK_COPY
Definition: indeo3.c:348
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
replicate32
static uint32_t replicate32(uint32_t a)
Definition: indeo3.c:312
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:499
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:625
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
imgutils.h
hpeldsp.h
ff_indeo3_decoder
const FFCodec ff_indeo3_decoder
Definition: indeo3.c:1139
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
h
h
Definition: vp9dsp_template.c:2038
av_image_check_size
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...
Definition: imgutils.c:318
Indeo3DecodeContext::need_resync
int need_resync
Definition: indeo3.c:90
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:215
Indeo3DecodeContext::frame_flags
uint16_t frame_flags
frame properties
Definition: indeo3.c:100
vqEntry::quad_exp
uint8_t quad_exp
log2 of four-pixel deltas
Definition: indeo3data.h:327
line
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
Definition: swscale.txt:40
fill_64
static void fill_64(uint8_t *dst, const uint64_t pix, int32_t n, int32_t row_offset)
Definition: indeo3.c:325