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