FFmpeg
indeo4.c
Go to the documentation of this file.
1 /*
2  * Indeo Video Interactive v4 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  * Indeo Video Interactive version 4 decoder
25  *
26  * Indeo 4 data is usually transported within .avi or .mov files.
27  * Known FOURCCs: 'IV41'
28  */
29 
30 #define BITSTREAM_READER_LE
31 #include "avcodec.h"
32 #include "codec_internal.h"
33 #include "get_bits.h"
34 #include "libavutil/imgutils.h"
35 #include "indeo4data.h"
36 #include "ivi.h"
37 #include "ivi_dsp.h"
38 
39 #define IVI4_PIC_SIZE_ESC 7
40 
41 
42 static const struct {
46 } transforms[18] = {
54  { NULL, NULL, 0 }, /* inverse DCT 8x8 */
55  { NULL, NULL, 0 }, /* inverse DCT 8x1 */
56  { NULL, NULL, 0 }, /* inverse DCT 1x8 */
59  { NULL, NULL, 0 }, /* no transform 4x4 */
64  { NULL, NULL, 0 }, /* inverse DCT 4x4 */
65 };
66 
67 /**
68  * Decode subdivision of a plane.
69  * This is a simplified version that checks for two supported subdivisions:
70  * - 1 wavelet band per plane, size factor 1:1, code pattern: 3
71  * - 4 wavelet bands per plane, size factor 1:4, code pattern: 2,3,3,3,3
72  * Anything else is either unsupported or corrupt.
73  *
74  * @param[in,out] gb the GetBit context
75  * @return number of wavelet bands or 0 on error
76  */
78 {
79  int i;
80 
81  switch (get_bits(gb, 2)) {
82  case 3:
83  return 1;
84  case 2:
85  for (i = 0; i < 4; i++)
86  if (get_bits(gb, 2) != 3)
87  return 0;
88  return 4;
89  default:
90  return 0;
91  }
92 }
93 
94 static inline int scale_tile_size(int def_size, int size_factor)
95 {
96  return size_factor == 15 ? def_size : (size_factor + 1) << 5;
97 }
98 
99 /**
100  * Decode Indeo 4 picture header.
101  *
102  * @param[in,out] ctx pointer to the decoder context
103  * @param[in] avctx pointer to the AVCodecContext
104  * @return result code: 0 = OK, negative number = error
105  */
107 {
108  int pic_size_indx, i, p;
109  IVIPicConfig pic_conf;
110 
111  if (get_bits(&ctx->gb, 18) != 0x3FFF8) {
112  av_log(avctx, AV_LOG_ERROR, "Invalid picture start code!\n");
113  return AVERROR_INVALIDDATA;
114  }
115 
116  ctx->prev_frame_type = ctx->frame_type;
117  ctx->frame_type = get_bits(&ctx->gb, 3);
118  if (ctx->frame_type == 7) {
119  av_log(avctx, AV_LOG_ERROR, "Invalid frame type: %d\n", ctx->frame_type);
120  return AVERROR_INVALIDDATA;
121  }
122 
123  if (ctx->frame_type == IVI4_FRAMETYPE_BIDIR)
124  ctx->has_b_frames = 1;
125 
126  ctx->has_transp = get_bits1(&ctx->gb);
127 
128  /* unknown bit: Mac decoder ignores this bit, XANIM returns error */
129  if (get_bits1(&ctx->gb)) {
130  av_log(avctx, AV_LOG_ERROR, "Sync bit is set!\n");
131  return AVERROR_INVALIDDATA;
132  }
133 
134  ctx->data_size = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 24) : 0;
135 
136  /* null frames don't contain anything else so we just return */
137  if (ctx->frame_type >= IVI4_FRAMETYPE_NULL_FIRST) {
138  ff_dlog(avctx, "Null frame encountered!\n");
139  return 0;
140  }
141 
142  /* Check key lock status. If enabled - ignore lock word. */
143  /* Usually we have to prompt the user for the password, but */
144  /* we don't do that because Indeo 4 videos can be decoded anyway */
145  if (get_bits1(&ctx->gb)) {
146  skip_bits_long(&ctx->gb, 32);
147  ff_dlog(avctx, "Password-protected clip!\n");
148  }
149 
150  pic_size_indx = get_bits(&ctx->gb, 3);
151  if (pic_size_indx == IVI4_PIC_SIZE_ESC) {
152  pic_conf.pic_height = get_bits(&ctx->gb, 16);
153  pic_conf.pic_width = get_bits(&ctx->gb, 16);
154  } else {
155  pic_conf.pic_height = ivi4_common_pic_sizes[pic_size_indx * 2 + 1];
156  pic_conf.pic_width = ivi4_common_pic_sizes[pic_size_indx * 2 ];
157  }
158 
159  /* Decode tile dimensions. */
160  ctx->uses_tiling = get_bits1(&ctx->gb);
161  if (ctx->uses_tiling) {
162  pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, get_bits(&ctx->gb, 4));
163  pic_conf.tile_width = scale_tile_size(pic_conf.pic_width, get_bits(&ctx->gb, 4));
164  } else {
165  pic_conf.tile_height = pic_conf.pic_height;
166  pic_conf.tile_width = pic_conf.pic_width;
167  }
168 
169  /* Decode chroma subsampling. We support only 4:4 aka YVU9. */
170  if (get_bits(&ctx->gb, 2)) {
171  av_log(avctx, AV_LOG_ERROR, "Only YVU9 picture format is supported!\n");
172  return AVERROR_INVALIDDATA;
173  }
174  pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2;
175  pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2;
176 
177  /* decode subdivision of the planes */
178  pic_conf.luma_bands = decode_plane_subdivision(&ctx->gb);
179  pic_conf.chroma_bands = 0;
180  if (pic_conf.luma_bands)
181  pic_conf.chroma_bands = decode_plane_subdivision(&ctx->gb);
182 
183  if (av_image_check_size2(pic_conf.pic_width, pic_conf.pic_height, avctx->max_pixels, AV_PIX_FMT_YUV410P, 0, avctx) < 0) {
184  av_log(avctx, AV_LOG_ERROR, "picture dimensions %d %d cannot be decoded\n",
185  pic_conf.pic_width, pic_conf.pic_height);
186  return AVERROR_INVALIDDATA;
187  }
188 
189  ctx->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;
190  if (ctx->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {
191  av_log(avctx, AV_LOG_ERROR, "Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n",
192  pic_conf.luma_bands, pic_conf.chroma_bands);
193  return AVERROR_INVALIDDATA;
194  }
195 
196  /* check if picture layout was changed and reallocate buffers */
197  if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf)) {
198  if (ff_ivi_init_planes(avctx, ctx->planes, &pic_conf, 1)) {
199  av_log(avctx, AV_LOG_ERROR, "Couldn't reallocate color planes!\n");
200  ctx->pic_conf.luma_bands = 0;
201  return AVERROR(ENOMEM);
202  }
203 
204  ctx->pic_conf = pic_conf;
205 
206  /* set default macroblock/block dimensions */
207  for (p = 0; p <= 2; p++) {
208  for (i = 0; i < (!p ? pic_conf.luma_bands : pic_conf.chroma_bands); i++) {
209  ctx->planes[p].bands[i].mb_size = !p ? (!ctx->is_scalable ? 16 : 8) : 4;
210  ctx->planes[p].bands[i].blk_size = !p ? 8 : 4;
211  }
212  }
213 
214  if (ff_ivi_init_tiles(ctx->planes, ctx->pic_conf.tile_width,
215  ctx->pic_conf.tile_height)) {
216  av_log(avctx, AV_LOG_ERROR,
217  "Couldn't reallocate internal structures!\n");
218  return AVERROR(ENOMEM);
219  }
220  }
221 
222  ctx->frame_num = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 20) : 0;
223 
224  /* skip decTimeEst field if present */
225  if (get_bits1(&ctx->gb))
226  skip_bits(&ctx->gb, 8);
227 
228  /* decode macroblock and block huffman codebooks */
229  if (ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_MB_HUFF, &ctx->mb_vlc, avctx) ||
230  ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_BLK_HUFF, &ctx->blk_vlc, avctx))
231  return AVERROR_INVALIDDATA;
232 
233  ctx->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8;
234 
235  ctx->in_imf = get_bits1(&ctx->gb);
236  ctx->in_q = get_bits1(&ctx->gb);
237 
238  ctx->pic_glob_quant = get_bits(&ctx->gb, 5);
239 
240  /* TODO: ignore this parameter if unused */
241  ctx->unknown1 = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 0;
242 
243  ctx->checksum = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 16) : 0;
244 
245  /* skip picture header extension if any */
246  while (get_bits1(&ctx->gb)) {
247  ff_dlog(avctx, "Pic hdr extension encountered!\n");
248  if (get_bits_left(&ctx->gb) < 10)
249  return AVERROR_INVALIDDATA;
250  skip_bits(&ctx->gb, 8);
251  }
252 
253  if (get_bits1(&ctx->gb)) {
254  av_log(avctx, AV_LOG_ERROR, "Bad blocks bits encountered!\n");
255  }
256 
257  align_get_bits(&ctx->gb);
258 
259  return 0;
260 }
261 
262 
263 /**
264  * Decode Indeo 4 band header.
265  *
266  * @param[in,out] ctx pointer to the decoder context
267  * @param[in,out] band pointer to the band descriptor
268  * @param[in] avctx pointer to the AVCodecContext
269  * @return result code: 0 = OK, negative number = error
270  */
272  AVCodecContext *avctx)
273 {
274  int plane, band_num, indx, transform_id, scan_indx;
275  int i;
276  int quant_mat;
277  IVIBandDesc temp_band, *band = &temp_band;
278  memcpy(&temp_band, arg_band, sizeof(temp_band));
279 
280  plane = get_bits(&ctx->gb, 2);
281  band_num = get_bits(&ctx->gb, 4);
282  if (band->plane != plane || band->band_num != band_num) {
283  av_log(avctx, AV_LOG_ERROR, "Invalid band header sequence!\n");
284  return AVERROR_INVALIDDATA;
285  }
286 
287  band->is_empty = get_bits1(&ctx->gb);
288  if (!band->is_empty) {
289  int old_blk_size = band->blk_size;
290  /* skip header size
291  * If header size is not given, header size is 4 bytes. */
292  if (get_bits1(&ctx->gb))
293  skip_bits(&ctx->gb, 16);
294 
295  band->is_halfpel = get_bits(&ctx->gb, 2);
296  if (band->is_halfpel >= 2) {
297  av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported mv resolution: %d!\n",
298  band->is_halfpel);
299  return AVERROR_INVALIDDATA;
300  }
301  if (!band->is_halfpel)
302  ctx->uses_fullpel = 1;
303 
304  band->checksum_present = get_bits1(&ctx->gb);
305  if (band->checksum_present)
306  band->checksum = get_bits(&ctx->gb, 16);
307 
308  indx = get_bits(&ctx->gb, 2);
309  if (indx == 3) {
310  av_log(avctx, AV_LOG_ERROR, "Invalid block size!\n");
311  return AVERROR_INVALIDDATA;
312  }
313  band->mb_size = 16 >> indx;
314  band->blk_size = 8 >> (indx >> 1);
315 
316  band->inherit_mv = get_bits1(&ctx->gb);
317  band->inherit_qdelta = get_bits1(&ctx->gb);
318 
319  band->glob_quant = get_bits(&ctx->gb, 5);
320 
321  if (!get_bits1(&ctx->gb) || ctx->frame_type == IVI4_FRAMETYPE_INTRA) {
322  transform_id = get_bits(&ctx->gb, 5);
323  if (transform_id >= FF_ARRAY_ELEMS(transforms) ||
324  !transforms[transform_id].inv_trans) {
325  avpriv_request_sample(avctx, "Transform %d", transform_id);
326  return AVERROR_PATCHWELCOME;
327  }
328  if ((transform_id >= 7 && transform_id <= 9) ||
329  transform_id == 17) {
330  avpriv_request_sample(avctx, "DCT transform");
331  return AVERROR_PATCHWELCOME;
332  }
333 
334  if (transform_id < 10 && band->blk_size < 8) {
335  av_log(avctx, AV_LOG_ERROR, "wrong transform size!\n");
336  return AVERROR_INVALIDDATA;
337  }
338  if ((transform_id >= 0 && transform_id <= 2) || transform_id == 10)
339  ctx->uses_haar = 1;
340 
341  band->inv_transform = transforms[transform_id].inv_trans;
342  band->dc_transform = transforms[transform_id].dc_trans;
343  band->is_2d_trans = transforms[transform_id].is_2d_trans;
344 
345  if (transform_id < 10)
346  band->transform_size = 8;
347  else
348  band->transform_size = 4;
349 
350  if (band->blk_size != band->transform_size) {
351  av_log(avctx, AV_LOG_ERROR, "transform and block size mismatch (%d != %d)\n", band->transform_size, band->blk_size);
352  return AVERROR_INVALIDDATA;
353  }
354 
355  scan_indx = get_bits(&ctx->gb, 4);
356  if (scan_indx == 15) {
357  av_log(avctx, AV_LOG_ERROR, "Custom scan pattern encountered!\n");
358  return AVERROR_INVALIDDATA;
359  }
360  if (scan_indx > 4 && scan_indx < 10) {
361  if (band->blk_size != 4) {
362  av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n");
363  return AVERROR_INVALIDDATA;
364  }
365  } else if (band->blk_size != 8) {
366  av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n");
367  return AVERROR_INVALIDDATA;
368  }
369 
370  band->scan = scan_index_to_tab[scan_indx];
371  band->scan_size = band->blk_size;
372 
373  quant_mat = get_bits(&ctx->gb, 5);
374  if (quant_mat == 31) {
375  av_log(avctx, AV_LOG_ERROR, "Custom quant matrix encountered!\n");
376  return AVERROR_INVALIDDATA;
377  }
378  if (quant_mat >= FF_ARRAY_ELEMS(quant_index_to_tab)) {
379  avpriv_request_sample(avctx, "Quantization matrix %d",
380  quant_mat);
381  return AVERROR_INVALIDDATA;
382  }
383  band->quant_mat = quant_mat;
384  } else {
385  if (old_blk_size != band->blk_size) {
386  av_log(avctx, AV_LOG_ERROR,
387  "The band block size does not match the configuration "
388  "inherited\n");
389  return AVERROR_INVALIDDATA;
390  }
391  }
392  if (quant_index_to_tab[band->quant_mat] > 4 && band->blk_size == 4) {
393  av_log(avctx, AV_LOG_ERROR, "Invalid quant matrix for 4x4 block encountered!\n");
394  band->quant_mat = 0;
395  return AVERROR_INVALIDDATA;
396  }
397  if (band->scan_size != band->blk_size) {
398  av_log(avctx, AV_LOG_ERROR, "mismatching scan table!\n");
399  return AVERROR_INVALIDDATA;
400  }
401  if (band->transform_size == 8 && band->blk_size < 8) {
402  av_log(avctx, AV_LOG_ERROR, "mismatching transform_size!\n");
403  return AVERROR_INVALIDDATA;
404  }
405 
406  /* decode block huffman codebook */
407  if (!get_bits1(&ctx->gb))
408  arg_band->blk_vlc.tab = ctx->blk_vlc.tab;
409  else
411  &arg_band->blk_vlc, avctx))
412  return AVERROR_INVALIDDATA;
413 
414  /* select appropriate rvmap table for this band */
415  band->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8;
416 
417  /* decode rvmap probability corrections if any */
418  band->num_corr = 0; /* there is no corrections */
419  if (get_bits1(&ctx->gb)) {
420  band->num_corr = get_bits(&ctx->gb, 8); /* get number of correction pairs */
421  if (band->num_corr > 61) {
422  av_log(avctx, AV_LOG_ERROR, "Too many corrections: %d\n",
423  band->num_corr);
424  return AVERROR_INVALIDDATA;
425  }
426 
427  /* read correction pairs */
428  for (i = 0; i < band->num_corr * 2; i++)
429  band->corr[i] = get_bits(&ctx->gb, 8);
430  }
431  }
432 
433  if (band->blk_size == 8) {
436  } else {
439  }
440 
441  /* Indeo 4 doesn't use scale tables */
442  band->intra_scale = NULL;
443  band->inter_scale = NULL;
444 
445  align_get_bits(&ctx->gb);
446 
447  if (!band->scan) {
448  av_log(avctx, AV_LOG_ERROR, "band->scan not set\n");
449  return AVERROR_INVALIDDATA;
450  }
451 
452  band->blk_vlc = arg_band->blk_vlc;
453  memcpy(arg_band, band, sizeof(*arg_band));
454 
455  return 0;
456 }
457 
458 
459 /**
460  * Decode information (block type, cbp, quant delta, motion vector)
461  * for all macroblocks in the current tile.
462  *
463  * @param[in,out] ctx pointer to the decoder context
464  * @param[in,out] band pointer to the band descriptor
465  * @param[in,out] tile pointer to the tile descriptor
466  * @param[in] avctx pointer to the AVCodecContext
467  * @return result code: 0 = OK, negative number = error
468  */
470  IVITile *tile, AVCodecContext *avctx)
471 {
472  int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, blks_per_mb,
473  mv_scale, mb_type_bits, s;
474  IVIMbInfo *mb, *ref_mb;
475  int row_offset = band->mb_size * band->pitch;
476 
477  mb = tile->mbs;
478  ref_mb = tile->ref_mbs;
479  offs = tile->ypos * band->pitch + tile->xpos;
480 
481  blks_per_mb = band->mb_size != band->blk_size ? 4 : 1;
482  mb_type_bits = ctx->frame_type == IVI4_FRAMETYPE_BIDIR ? 2 : 1;
483 
484  /* scale factor for motion vectors */
485  mv_scale = (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3);
486  mv_x = mv_y = 0;
487 
488  if (((tile->width + band->mb_size-1)/band->mb_size) * ((tile->height + band->mb_size-1)/band->mb_size) != tile->num_MBs) {
489  av_log(avctx, AV_LOG_ERROR, "num_MBs mismatch %d %d %d %d\n", tile->width, tile->height, band->mb_size, tile->num_MBs);
490  return -1;
491  }
492 
493  for (y = tile->ypos; y < tile->ypos + tile->height; y += band->mb_size) {
494  mb_offset = offs;
495 
496  for (x = tile->xpos; x < tile->xpos + tile->width; x += band->mb_size) {
497  mb->xpos = x;
498  mb->ypos = y;
499  mb->buf_offs = mb_offset;
500  mb->b_mv_x =
501  mb->b_mv_y = 0;
502 
503  if (get_bits_left(&ctx->gb) < 1) {
504  av_log(avctx, AV_LOG_ERROR, "Insufficient input for mb info\n");
505  return AVERROR_INVALIDDATA;
506  }
507 
508  if (get_bits1(&ctx->gb)) {
509  if (ctx->frame_type == IVI4_FRAMETYPE_INTRA) {
510  av_log(avctx, AV_LOG_ERROR, "Empty macroblock in an INTRA picture!\n");
511  return AVERROR_INVALIDDATA;
512  }
513  mb->type = 1; /* empty macroblocks are always INTER */
514  mb->cbp = 0; /* all blocks are empty */
515 
516  mb->q_delta = 0;
517  if (!band->plane && !band->band_num && ctx->in_q) {
518  mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
519  IVI_VLC_BITS, 1);
520  mb->q_delta = IVI_TOSIGNED(mb->q_delta);
521  }
522 
523  mb->mv_x = mb->mv_y = 0; /* no motion vector coded */
524  if (band->inherit_mv && ref_mb) {
525  /* motion vector inheritance */
526  if (mv_scale) {
527  mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
528  mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
529  } else {
530  mb->mv_x = ref_mb->mv_x;
531  mb->mv_y = ref_mb->mv_y;
532  }
533  }
534  } else {
535  if (band->inherit_mv) {
536  /* copy mb_type from corresponding reference mb */
537  if (!ref_mb) {
538  av_log(avctx, AV_LOG_ERROR, "ref_mb unavailable\n");
539  return AVERROR_INVALIDDATA;
540  }
541  mb->type = ref_mb->type;
542  } else if (ctx->frame_type == IVI4_FRAMETYPE_INTRA ||
543  ctx->frame_type == IVI4_FRAMETYPE_INTRA1) {
544  mb->type = 0; /* mb_type is always INTRA for intra-frames */
545  } else {
546  mb->type = get_bits(&ctx->gb, mb_type_bits);
547  }
548 
549  mb->cbp = get_bits(&ctx->gb, blks_per_mb);
550 
551  mb->q_delta = 0;
552  if (band->inherit_qdelta) {
553  if (ref_mb) mb->q_delta = ref_mb->q_delta;
554  } else if (mb->cbp || (!band->plane && !band->band_num &&
555  ctx->in_q)) {
556  mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
557  IVI_VLC_BITS, 1);
558  mb->q_delta = IVI_TOSIGNED(mb->q_delta);
559  }
560 
561  if (!mb->type) {
562  mb->mv_x = mb->mv_y = 0; /* there is no motion vector in intra-macroblocks */
563  } else {
564  if (band->inherit_mv) {
565  if (ref_mb)
566  /* motion vector inheritance */
567  if (mv_scale) {
568  mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
569  mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
570  } else {
571  mb->mv_x = ref_mb->mv_x;
572  mb->mv_y = ref_mb->mv_y;
573  }
574  } else {
575  /* decode motion vector deltas */
576  mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
577  IVI_VLC_BITS, 1);
578  mv_y += IVI_TOSIGNED(mv_delta);
579  mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
580  IVI_VLC_BITS, 1);
581  mv_x += IVI_TOSIGNED(mv_delta);
582  mb->mv_x = mv_x;
583  mb->mv_y = mv_y;
584  if (mb->type == 3) {
585  mv_delta = get_vlc2(&ctx->gb,
586  ctx->mb_vlc.tab->table,
587  IVI_VLC_BITS, 1);
588  mv_y += IVI_TOSIGNED(mv_delta);
589  mv_delta = get_vlc2(&ctx->gb,
590  ctx->mb_vlc.tab->table,
591  IVI_VLC_BITS, 1);
592  mv_x += IVI_TOSIGNED(mv_delta);
593  mb->b_mv_x = -mv_x;
594  mb->b_mv_y = -mv_y;
595  }
596  }
597  if (mb->type == 2) {
598  mb->b_mv_x = -mb->mv_x;
599  mb->b_mv_y = -mb->mv_y;
600  mb->mv_x = 0;
601  mb->mv_y = 0;
602  }
603  }
604  }
605 
606  s= band->is_halfpel;
607  if (mb->type)
608  if ( x + (mb->mv_x >>s) + (y+ (mb->mv_y >>s))*band->pitch < 0 ||
609  x + ((mb->mv_x+s)>>s) + band->mb_size - 1
610  + (y+band->mb_size - 1 +((mb->mv_y+s)>>s))*band->pitch > band->bufsize -1) {
611  av_log(avctx, AV_LOG_ERROR, "motion vector %d %d outside reference\n", x*s + mb->mv_x, y*s + mb->mv_y);
612  return AVERROR_INVALIDDATA;
613  }
614 
615  mb++;
616  if (ref_mb)
617  ref_mb++;
618  mb_offset += band->mb_size;
619  }
620 
621  offs += row_offset;
622  }
623 
624  align_get_bits(&ctx->gb);
625 
626  return 0;
627 }
628 
629 
630 /**
631  * Rearrange decoding and reference buffers.
632  *
633  * @param[in,out] ctx pointer to the decoder context
634  */
636 {
637  int is_prev_ref = 0, is_ref = 0;
638 
639  switch (ctx->prev_frame_type) {
643  is_prev_ref = 1;
644  break;
645  }
646 
647  switch (ctx->frame_type) {
651  is_ref = 1;
652  break;
653  }
654 
655  if (is_prev_ref && is_ref) {
656  FFSWAP(int, ctx->dst_buf, ctx->ref_buf);
657  } else if (is_prev_ref) {
658  FFSWAP(int, ctx->ref_buf, ctx->b_ref_buf);
659  FFSWAP(int, ctx->dst_buf, ctx->ref_buf);
660  }
661 }
662 
663 
665 {
666  return ctx->frame_type < IVI4_FRAMETYPE_NULL_FIRST;
667 }
668 
669 
671 {
672  IVI45DecContext *ctx = avctx->priv_data;
673 
675 
676  /* copy rvmap tables in our context so we can apply changes to them */
677  memcpy(ctx->rvmap_tabs, ff_ivi_rvmap_tabs, sizeof(ff_ivi_rvmap_tabs));
678 
679  /* Force allocation of the internal buffers */
680  /* during picture header decoding. */
681  ctx->pic_conf.pic_width = 0;
682  ctx->pic_conf.pic_height = 0;
683 
684  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
685 
686  ctx->decode_pic_hdr = decode_pic_hdr;
687  ctx->decode_band_hdr = decode_band_hdr;
688  ctx->decode_mb_info = decode_mb_info;
689  ctx->switch_buffers = switch_buffers;
690  ctx->is_nonnull_frame = is_nonnull_frame;
691 
692  ctx->is_indeo4 = 1;
693  ctx->show_indeo4_info = 1;
694 
695  ctx->dst_buf = 0;
696  ctx->ref_buf = 1;
697  ctx->b_ref_buf = 3; /* buffer 2 is used for scalability mode */
698  ctx->p_frame = av_frame_alloc();
699  if (!ctx->p_frame)
700  return AVERROR(ENOMEM);
701 
702  return 0;
703 }
704 
705 
707  .p.name = "indeo4",
708  CODEC_LONG_NAME("Intel Indeo Video Interactive 4"),
709  .p.type = AVMEDIA_TYPE_VIDEO,
710  .p.id = AV_CODEC_ID_INDEO4,
711  .priv_data_size = sizeof(IVI45DecContext),
712  .init = decode_init,
713  .close = ff_ivi_decode_close,
715  .p.capabilities = AV_CODEC_CAP_DR1,
716 };
IVI4_FRAMETYPE_NULL_FIRST
@ IVI4_FRAMETYPE_NULL_FIRST
empty frame with no data
Definition: ivi.h:45
ff_ivi_inverse_haar_4x4
void ff_ivi_inverse_haar_4x4(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
two-dimensional inverse Haar 4x4 transform for Indeo 4
Definition: ivi_dsp.c:380
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
IVITile::height
int height
Definition: ivi.h:130
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
quant_index_to_tab
static const uint8_t quant_index_to_tab[22]
Table for mapping quant matrix index from the bitstream into internal quant table number.
Definition: indeo4data.h:345
IVI4_FRAMETYPE_BIDIR
@ IVI4_FRAMETYPE_BIDIR
bidirectional frame
Definition: ivi.h:43
IVIBandDesc::inter_scale
const uint8_t * inter_scale
quantization coefficient for inter blocks
Definition: ivi.h:186
ff_ivi_row_haar4
void ff_ivi_row_haar4(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
one-dimensional inverse 4-point Haar transform on rows for Indeo 4
Definition: ivi_dsp.c:427
ff_ivi_col_haar8
void ff_ivi_col_haar8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
one-dimensional inverse 8-point Haar transform on columns for Indeo 4
Definition: ivi_dsp.c:351
ff_ivi_init_static_vlc
av_cold void ff_ivi_init_static_vlc(void)
Initialize static codes used for macroblock and block decoding.
Definition: ivi.c:178
IVIPicConfig::pic_width
uint16_t pic_width
Definition: ivi.h:202
ff_ivi_put_pixels_8x8
void ff_ivi_put_pixels_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
Copy the pixels into the frame buffer.
Definition: ivi_dsp.c:752
IVIBandDesc::inv_transform
InvTransformPtr * inv_transform
Definition: ivi.h:176
IVI_MB_HUFF
@ IVI_MB_HUFF
Huffman table is used for coding macroblocks.
Definition: ivi.h:73
scan_index_to_tab
static const uint8_t *const scan_index_to_tab[15]
Definition: indeo4data.h:63
FFCodec
Definition: codec_internal.h:127
IVIBandDesc::rvmap_sel
int rvmap_sel
rvmap table selector
Definition: ivi.h:172
inv_trans
InvTransformPtr * inv_trans
Definition: indeo4.c:43
is_nonnull_frame
static int is_nonnull_frame(IVI45DecContext *ctx)
Definition: indeo4.c:664
IVIBandDesc::dc_transform
DCTransformPtr * dc_transform
Definition: ivi.h:178
IVIHuffTab::tab
VLC * tab
pointer to the table associated with tab_sel
Definition: ivi.h:65
ivi_scale_mv
static int ivi_scale_mv(int mv, int mv_scale)
scale motion vector
Definition: ivi.h:292
ff_ivi_col_haar4
void ff_ivi_col_haar4(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
one-dimensional inverse 4-point Haar transform on columns for Indeo 4
Definition: ivi_dsp.c:449
IVIMbInfo::type
uint8_t type
macroblock type: 0 - INTRA, 1 - INTER
Definition: ivi.h:113
ivi_dsp.h
ff_ivi_dc_row_slant
void ff_ivi_dc_row_slant(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size)
DC-only inverse row slant transform.
Definition: ivi_dsp.c:650
IVITile::num_MBs
int num_MBs
number of macroblocks in this tile
Definition: ivi.h:134
IVIPicConfig::luma_bands
uint8_t luma_bands
Definition: ivi.h:208
IVI4_PIC_SIZE_ESC
#define IVI4_PIC_SIZE_ESC
Definition: indeo4.c:39
IVI_TOSIGNED
#define IVI_TOSIGNED(val)
convert unsigned values into signed ones (the sign is in the LSB)
Definition: ivi.h:289
DCTransformPtr
void() DCTransformPtr(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size)
Definition: ivi.h:90
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
ivi.h
ivi_pic_config_cmp
static int ivi_pic_config_cmp(IVIPicConfig *str1, IVIPicConfig *str2)
compare some properties of two pictures
Definition: ivi.h:273
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
decode_band_hdr
static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *arg_band, AVCodecContext *avctx)
Decode Indeo 4 band header.
Definition: indeo4.c:271
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
IVIBandDesc::num_corr
int num_corr
number of correction entries
Definition: ivi.h:170
IVIBandDesc
information for Indeo wavelet band
Definition: ivi.h:143
ff_ivi_decode_close
av_cold int ff_ivi_decode_close(AVCodecContext *avctx)
Close Indeo5 decoder and clean up its context.
Definition: ivi.c:1211
GetBitContext
Definition: get_bits.h:108
IVITile::width
int width
Definition: ivi.h:129
decode_pic_hdr
static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)
Decode Indeo 4 picture header.
Definition: indeo4.c:106
IVIBandDesc::intra_base
const uint16_t * intra_base
quantization matrix for intra blocks
Definition: ivi.h:183
av_image_check_size2
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:289
dc_trans
DCTransformPtr * dc_trans
Definition: indeo4.c:44
ff_ivi_col_slant8
void ff_ivi_col_slant8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
inverse 1D column slant transform
Definition: ivi_dsp.c:668
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:76
IVIMbInfo
information for Indeo macroblock (16x16, 8x8 or 4x4)
Definition: ivi.h:109
ivi4_quant_8x8_intra
static const uint16_t ivi4_quant_8x8_intra[9][64]
Indeo 4 dequant tables.
Definition: indeo4data.h:89
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
IVI_VLC_BITS
#define IVI_VLC_BITS
max number of bits of the ivi's huffman codes
Definition: ivi.h:49
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:287
IVITile::ypos
int ypos
Definition: ivi.h:128
s
#define s(width, name)
Definition: cbs_vp9.c:198
IVIBandDesc::checksum_present
int checksum_present
Definition: ivi.h:181
IVIMbInfo::mv_x
int8_t mv_x
motion vector (x component)
Definition: ivi.h:116
ff_ivi_row_slant8
void ff_ivi_row_slant8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
inverse 1D row slant transform
Definition: ivi_dsp.c:630
IVIPicConfig::chroma_bands
uint8_t chroma_bands
Definition: ivi.h:209
IVIPicConfig
Definition: ivi.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
is_2d_trans
int is_2d_trans
Definition: indeo4.c:45
IVIBandDesc::scan
const uint8_t * scan
ptr to the scan pattern
Definition: ivi.h:165
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1934
IVIBandDesc::inter_base
const uint16_t * inter_base
quantization matrix for inter blocks
Definition: ivi.h:184
ff_ivi_col_slant4
void ff_ivi_col_slant4(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
inverse 1D column slant transform
Definition: ivi_dsp.c:729
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
IVI4_FRAMETYPE_INTER
@ IVI4_FRAMETYPE_INTER
non-droppable P-frame
Definition: ivi.h:42
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
ff_ivi_init_tiles
av_cold int ff_ivi_init_tiles(IVIPlaneDesc *planes, int tile_width, int tile_height)
Initialize tile and macroblock descriptors.
Definition: ivi.c:395
IVI4_FRAMETYPE_INTRA
@ IVI4_FRAMETYPE_INTRA
Definition: ivi.h:40
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
ivi4_common_pic_sizes
static const uint16_t ivi4_common_pic_sizes[14]
standard picture dimensions
Definition: indeo4data.h:37
IVIBandDesc::inherit_mv
int inherit_mv
tells if motion vector is inherited from reference macroblock
Definition: ivi.h:160
IVIBandDesc::band_num
int band_num
band number
Definition: ivi.h:145
IVIPicConfig::pic_height
uint16_t pic_height
Definition: ivi.h:203
IVI45DecContext
Definition: ivi.h:212
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
IVIPicConfig::tile_height
uint16_t tile_height
Definition: ivi.h:207
mv_scale
static av_always_inline void mv_scale(Mv *dst, const Mv *src, int td, int tb)
Definition: hevc_mvs.c:116
IVIPicConfig::chroma_width
uint16_t chroma_width
Definition: ivi.h:204
ivi4_quant_4x4_inter
static const uint16_t ivi4_quant_4x4_inter[5][16]
Definition: indeo4data.h:308
ff_dlog
#define ff_dlog(a,...)
Definition: tableprint_vlc.h:28
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
ff_ivi_rvmap_tabs
const RVMapDesc ff_ivi_rvmap_tabs[9]
Run-value (RLE) tables.
Definition: ivi.c:1262
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
codec_internal.h
IVIPicConfig::tile_width
uint16_t tile_width
Definition: ivi.h:206
IVIBandDesc::checksum
int32_t checksum
for debug purposes
Definition: ivi.h:180
transforms
static const struct @97 transforms[18]
ff_ivi_inverse_haar_8x8
void ff_ivi_inverse_haar_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
two-dimensional inverse Haar 8x8 transform for Indeo 4
Definition: ivi_dsp.c:271
ff_ivi_init_planes
av_cold int ff_ivi_init_planes(AVCodecContext *avctx, IVIPlaneDesc *planes, const IVIPicConfig *cfg, int is_indeo4)
Initialize planes (prepares descriptors, allocates buffers etc).
Definition: ivi.c:291
IVIBandDesc::plane
int plane
plane number this band belongs to
Definition: ivi.h:144
IVIBandDesc::transform_size
int transform_size
Definition: ivi.h:177
ff_ivi_inverse_slant_8x8
void ff_ivi_inverse_slant_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
two-dimensional inverse slant 8x8 transform
Definition: ivi_dsp.c:537
IVIBandDesc::mb_size
int mb_size
macroblock size
Definition: ivi.h:157
AV_CODEC_ID_INDEO4
@ AV_CODEC_ID_INDEO4
Definition: codec_id.h:163
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: indeo4.c:670
mb
#define mb
Definition: vf_colormatrix.c:99
IVITile
information for Indeo tile
Definition: ivi.h:126
ff_ivi_row_slant4
void ff_ivi_row_slant4(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
inverse 1D row slant transform
Definition: ivi_dsp.c:709
IVIBandDesc::scan_size
int scan_size
size of the scantable
Definition: ivi.h:166
IVIBandDesc::intra_scale
const uint8_t * intra_scale
quantization coefficient for intra blocks
Definition: ivi.h:185
IVITile::mbs
IVIMbInfo * mbs
array of macroblock descriptors
Definition: ivi.h:135
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
IVIBandDesc::bufsize
int bufsize
band buffer size in bytes
Definition: ivi.h:182
IVITile::ref_mbs
IVIMbInfo * ref_mbs
ptr to the macroblock descriptors of the reference tile
Definition: ivi.h:136
decode_plane_subdivision
static int decode_plane_subdivision(GetBitContext *gb)
Decode subdivision of a plane.
Definition: indeo4.c:77
ff_indeo4_decoder
const FFCodec ff_indeo4_decoder
Definition: indeo4.c:706
switch_buffers
static void switch_buffers(IVI45DecContext *ctx)
Rearrange decoding and reference buffers.
Definition: indeo4.c:635
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
ivi4_quant_8x8_inter
static const uint16_t ivi4_quant_8x8_inter[9][64]
Definition: indeo4data.h:182
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
ff_ivi_dc_slant_2d
void ff_ivi_dc_slant_2d(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size)
DC-only two-dimensional inverse slant transform.
Definition: ivi_dsp.c:617
IVIMbInfo::q_delta
int8_t q_delta
quant delta
Definition: ivi.h:115
avcodec.h
ff_ivi_put_dc_pixel_8x8
void ff_ivi_put_dc_pixel_8x8(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size)
Copy the DC coefficient into the first pixel of the block and zero all others.
Definition: ivi_dsp.c:762
scale_tile_size
static int scale_tile_size(int def_size, int size_factor)
Definition: indeo4.c:94
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:561
IVIBandDesc::is_2d_trans
int is_2d_trans
1 indicates that the two-dimensional inverse transform is used
Definition: ivi.h:179
IVIPicConfig::chroma_height
uint16_t chroma_height
Definition: ivi.h:205
decode_mb_info
static int decode_mb_info(IVI45DecContext *ctx, IVIBandDesc *band, IVITile *tile, AVCodecContext *avctx)
Decode information (block type, cbp, quant delta, motion vector) for all macroblocks in the current t...
Definition: indeo4.c:469
ff_ivi_dc_haar_2d
void ff_ivi_dc_haar_2d(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size)
DC-only two-dimensional inverse Haar transform for Indeo 4.
Definition: ivi_dsp.c:473
ff_ivi_decode_frame
int ff_ivi_decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: ivi.c:1068
IVIBandDesc::is_empty
int is_empty
= 1 if this band doesn't contain any data
Definition: ivi.h:156
AVCodecContext
main external API structure.
Definition: avcodec.h:445
IVI_BLK_HUFF
@ IVI_BLK_HUFF
Huffman table is used for coding blocks.
Definition: ivi.h:74
IVIBandDesc::blk_size
int blk_size
block size
Definition: ivi.h:158
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
IVIBandDesc::blk_vlc
IVIHuffTab blk_vlc
vlc table for decoding block data
Definition: ivi.h:168
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
ff_ivi_dec_huff_desc
int ff_ivi_dec_huff_desc(GetBitContext *gb, int desc_coded, int which_tab, IVIHuffTab *huff_tab, AVCodecContext *avctx)
Decode a huffman codebook descriptor from the bitstream and select specified huffman table.
Definition: ivi.c:210
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
IVIBandDesc::inherit_qdelta
int inherit_qdelta
tells if quantiser delta is inherited from reference macroblock
Definition: ivi.h:161
IVIBandDesc::corr
uint8_t corr[61 *2]
rvmap correction pairs
Definition: ivi.h:171
IVI4_FRAMETYPE_INTRA1
@ IVI4_FRAMETYPE_INTRA1
intra frame with slightly different bitstream coding
Definition: ivi.h:41
imgutils.h
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:79
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_ivi_row_haar8
void ff_ivi_row_haar8(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
one-dimensional inverse 8-point Haar transform on rows for Indeo 4
Definition: ivi_dsp.c:326
IVITile::xpos
int xpos
Definition: ivi.h:127
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
IVIBandDesc::is_halfpel
int is_halfpel
precision of the motion compensation: 0 - fullpel, 1 - halfpel
Definition: ivi.h:159
ivi4_quant_4x4_intra
static const uint16_t ivi4_quant_4x4_intra[5][16]
Definition: indeo4data.h:275
IVIBandDesc::glob_quant
int glob_quant
quant base for this band
Definition: ivi.h:164
ff_ivi_dc_col_slant
void ff_ivi_dc_col_slant(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size)
DC-only inverse column slant transform.
Definition: ivi_dsp.c:695
IVIBandDesc::quant_mat
int quant_mat
dequant matrix index
Definition: ivi.h:163
IVIBandDesc::pitch
ptrdiff_t pitch
pitch associated with the buffers above
Definition: ivi.h:155
ff_ivi_inverse_slant_4x4
void ff_ivi_inverse_slant_4x4(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
two-dimensional inverse slant 4x4 transform
Definition: ivi_dsp.c:577
InvTransformPtr
void() InvTransformPtr(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
Declare inverse transform function types.
Definition: ivi.h:89
indeo4data.h
IVIMbInfo::mv_y
int8_t mv_y
motion vector (y component)
Definition: ivi.h:117