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