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 "get_bits.h"
33 #include "libavutil/imgutils.h"
34 #include "indeo4data.h"
35 #include "internal.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 */
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 
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
410  if (ff_ivi_dec_huff_desc(&ctx->gb, 1, IVI_BLK_HUFF,
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) {
435  band->inter_base = &ivi4_quant_8x8_inter[quant_index_to_tab[band->quant_mat]][0];
436  } else {
438  band->inter_base = &ivi4_quant_4x4_inter[quant_index_to_tab[band->quant_mat]][0];
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 ||
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 {
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 
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  .name = "indeo4",
708  .long_name = NULL_IF_CONFIG_SMALL("Intel Indeo Video Interactive 4"),
709  .type = AVMEDIA_TYPE_VIDEO,
710  .id = AV_CODEC_ID_INDEO4,
711  .priv_data_size = sizeof(IVI45DecContext),
712  .init = decode_init,
713  .close = ff_ivi_decode_close,
715  .capabilities = AV_CODEC_CAP_DR1,
716 };
int plane
Definition: avisynth_c.h:384
int is_empty
= 1 if this band doesn&#39;t contain any data
Definition: ivi.h:157
uint32_t data_size
size of the frame data in bytes from picture header
Definition: ivi.h:220
uint8_t type
macroblock type: 0 - INTRA, 1 - INTER
Definition: ivi.h:114
int num_MBs
number of macroblocks in this tile
Definition: ivi.h:135
static const uint16_t ivi4_quant_8x8_intra[9][64]
Indeo 4 dequant tables.
Definition: indeo4data.h:89
#define NULL
Definition: coverity.c:32
static int scale_tile_size(int def_size, int size_factor)
Definition: indeo4.c:94
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static av_always_inline void mv_scale(Mv *dst, Mv *src, int td, int tb)
Definition: hevc_mvs.c:115
non-droppable P-frame
Definition: ivi.h:42
This file contains data needed for the Indeo 4 decoder.
int(* is_nonnull_frame)(struct IVI45DecContext *ctx)
Definition: ivi.h:262
InvTransformPtr * inv_transform
Definition: ivi.h:177
#define IVI4_PIC_SIZE_ESC
Definition: indeo4.c:39
static int decode_pic_hdr(IVI45DecContext *ctx, AVCodecContext *avctx)
Decode Indeo 4 picture header.
Definition: indeo4.c:106
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
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:325
static int decode_plane_subdivision(GetBitContext *gb)
Decode subdivision of a plane.
Definition: indeo4.c:77
void( InvTransformPtr)(const int32_t *in, int16_t *out, ptrdiff_t pitch, const uint8_t *flags)
Declare inverse transform function types.
Definition: ivi.h:90
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:291
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
#define avpriv_request_sample(...)
int8_t b_mv_y
second motion vector (y component)
Definition: ivi.h:120
av_cold int ff_ivi_decode_close(AVCodecContext *avctx)
Close Indeo5 decoder and clean up its context.
Definition: ivi.c:1226
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:694
#define IVI_VLC_BITS
max number of bits of the ivi&#39;s huffman codes
Definition: ivi.h:49
int dst_buf
buffer index for the currently decoded frame
Definition: ivi.h:233
int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: ivi.c:1080
DSP functions (inverse transforms, motion compensations, wavelet recomposition) for Indeo Video Inter...
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:350
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1778
int is_halfpel
precision of the motion compensation: 0 - fullpel, 1 - halfpel
Definition: ivi.h:160
uint8_t chroma_bands
Definition: ivi.h:210
int(* decode_pic_hdr)(struct IVI45DecContext *ctx, AVCodecContext *avctx)
Definition: ivi.h:258
int plane
plane number this band belongs to
Definition: ivi.h:145
int bufsize
band buffer size in bytes
Definition: ivi.h:183
IVIPicConfig pic_conf
Definition: ivi.h:229
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:629
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:616
AVCodec.
Definition: avcodec.h:3492
int quant_mat
dequant matrix index
Definition: ivi.h:164
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
uint8_t has_b_frames
Definition: ivi.h:252
void(* switch_buffers)(struct IVI45DecContext *ctx)
Definition: ivi.h:261
int8_t b_mv_x
second motion vector (x component)
Definition: ivi.h:119
uint8_t uses_tiling
Definition: ivi.h:254
uint8_t luma_bands
Definition: ivi.h:209
ptrdiff_t pitch
pitch associated with the buffers above
Definition: ivi.h:156
VLC * tab
index of one of the predefined tables or "7" for custom one
Definition: ivi.h:66
#define av_cold
Definition: attributes.h:82
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:751
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
#define mb
uint8_t pic_glob_quant
Definition: ivi.h:244
const uint16_t * inter_base
quantization matrix for inter blocks
Definition: ivi.h:185
uint16_t pic_height
Definition: ivi.h:204
static const uint16_t ivi4_common_pic_sizes[14]
standard picture dimensions
Definition: indeo4data.h:37
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:379
int inherit_mv
tells if motion vector is inherited from reference macroblock
Definition: ivi.h:161
uint16_t tile_height
Definition: ivi.h:208
GetBitContext gb
Definition: ivi.h:214
uint16_t chroma_width
Definition: ivi.h:205
static const uint16_t ivi4_quant_8x8_inter[9][64]
Definition: indeo4data.h:182
uint8_t cbp
coded block pattern
Definition: ivi.h:115
#define ff_dlog(a,...)
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:728
uint16_t checksum
frame checksum
Definition: ivi.h:227
bitstream reader API header.
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:761
uint16_t pic_width
Definition: ivi.h:203
static const uint16_t ivi4_quant_4x4_inter[5][16]
Definition: indeo4data.h:308
int(* decode_band_hdr)(struct IVI45DecContext *ctx, IVIBandDesc *band, AVCodecContext *avctx)
Definition: ivi.h:259
IVIPlaneDesc planes[3]
color planes
Definition: ivi.h:230
#define av_log(a,...)
const uint16_t * intra_base
quantization matrix for intra blocks
Definition: ivi.h:184
uint8_t unknown1
Definition: ivi.h:245
empty frame with no data
Definition: ivi.h:45
void( DCTransformPtr)(const int32_t *in, int16_t *out, ptrdiff_t pitch, int blk_size)
Definition: ivi.h:91
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
int blk_size
block size
Definition: ivi.h:159
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
uint8_t corr[61 *2]
rvmap correction pairs
Definition: ivi.h:172
RVMapDesc rvmap_tabs[9]
local corrected copy of the static rvmap tables
Definition: ivi.h:215
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:270
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:649
uint8_t in_q
flag for explicitly stored quantiser delta
Definition: ivi.h:243
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
int show_indeo4_info
Definition: ivi.h:251
int is_indeo4
Definition: ivi.h:267
av_cold int ff_ivi_init_tiles(IVIPlaneDesc *planes, int tile_width, int tile_height)
Initialize tile and macroblock descriptors.
Definition: ivi.c:409
DCTransformPtr * dc_trans
Definition: indeo4.c:44
int ref_buf
inter frame reference buffer index
Definition: ivi.h:234
DCTransformPtr * dc_transform
Definition: ivi.h:179
This file contains structures and macros shared by both Indeo4 and Indeo5 decoders.
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:3295
static int ivi_pic_config_cmp(IVIPicConfig *str1, IVIPicConfig *str2)
compare some properties of two pictures
Definition: ivi.h:274
int inherit_qdelta
tells if quantiser delta is inherited from reference macroblock
Definition: ivi.h:162
Huffman table is used for coding macroblocks.
Definition: ivi.h:75
uint32_t frame_num
Definition: ivi.h:217
AVFrame * p_frame
Definition: ivi.h:269
const RVMapDesc ff_ivi_rvmap_tabs[9]
Run-value (RLE) tables.
Definition: ivi.c:1277
int is_scalable
Definition: ivi.h:221
int is_2d_trans
Definition: indeo4.c:45
IVIMbInfo * mbs
array of macroblock descriptors
Definition: ivi.h:136
AVFormatContext * ctx
Definition: movenc.c:48
#define s(width, name)
Definition: cbs_vp9.c:257
static void switch_buffers(IVI45DecContext *ctx)
Rearrange decoding and reference buffers.
Definition: indeo4.c:635
const uint8_t * inter_scale
quantization coefficient for inter blocks
Definition: ivi.h:187
static const struct @99 transforms[18]
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:797
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:667
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:226
uint16_t chroma_height
Definition: ivi.h:206
static const uint8_t *const scan_index_to_tab[15]
Definition: indeo4data.h:63
int8_t q_delta
quant delta
Definition: ivi.h:116
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
#define FF_ARRAY_ELEMS(a)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
uint16_t tile_width
Definition: ivi.h:207
int ypos
Definition: ivi.h:129
IVIHuffTab mb_vlc
current macroblock table descriptor
Definition: ivi.h:238
int is_2d_trans
1 indicates that the two-dimensional inverse transform is used
Definition: ivi.h:180
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:472
Libavcodec external API header.
int glob_quant
quant base for this band
Definition: ivi.h:165
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:426
int height
Definition: ivi.h:131
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:305
main external API structure.
Definition: avcodec.h:1568
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:448
int num_corr
number of correction entries
Definition: ivi.h:171
static int ivi_scale_mv(int mv, int mv_scale)
scale motion vector
Definition: ivi.h:293
information for Indeo tile
Definition: ivi.h:127
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
uint8_t in_imf
Definition: ivi.h:242
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
uint8_t uses_haar
Definition: ivi.h:255
static const uint16_t ivi4_quant_4x4_intra[5][16]
Definition: indeo4data.h:275
IVIBandDesc * bands
array of band descriptors
Definition: ivi.h:198
int32_t checksum
for debug purposes
Definition: ivi.h:181
int rvmap_sel
rvmap table selector
Definition: ivi.h:173
int8_t mv_x
motion vector (x component)
Definition: ivi.h:117
int8_t mv_y
motion vector (y component)
Definition: ivi.h:118
#define IVI_TOSIGNED(val)
convert unsigned values into signed ones (the sign is in the LSB)
Definition: ivi.h:290
int mb_size
macroblock size
Definition: ivi.h:158
IVIMbInfo * ref_mbs
ptr to the macroblock descriptors of the reference tile
Definition: ivi.h:137
int xpos
Definition: ivi.h:128
IVIHuffTab blk_vlc
current block table descriptor
Definition: ivi.h:239
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:576
int16_t xpos
Definition: ivi.h:111
int band_num
band number
Definition: ivi.h:146
InvTransformPtr * inv_trans
Definition: indeo4.c:43
common internal api header.
int transform_size
Definition: ivi.h:178
static int is_nonnull_frame(IVI45DecContext *ctx)
Definition: indeo4.c:664
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:536
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:253
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
const uint8_t * scan
ptr to the scan pattern
Definition: ivi.h:166
void * priv_data
Definition: avcodec.h:1595
intra frame with slightly different bitstream coding
Definition: ivi.h:41
int width
Definition: ivi.h:130
static av_cold int decode_init(AVCodecContext *avctx)
Definition: indeo4.c:670
int checksum_present
Definition: ivi.h:182
uint8_t has_transp
transparency mode status: 1 - enabled
Definition: ivi.h:253
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
int(* decode_mb_info)(struct IVI45DecContext *ctx, IVIBandDesc *band, IVITile *tile, AVCodecContext *avctx)
Definition: ivi.h:260
int16_t ypos
Definition: ivi.h:112
int prev_frame_type
frame type of the previous frame
Definition: ivi.h:219
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:708
information for Indeo macroblock (16x16, 8x8 or 4x4)
Definition: ivi.h:110
IVIHuffTab blk_vlc
vlc table for decoding block data
Definition: ivi.h:169
int scan_size
size of the scantable
Definition: ivi.h:167
bidirectional frame
Definition: ivi.h:43
av_cold void ff_ivi_init_static_vlc(void)
Initialize static codes used for macroblock and block decoding.
Definition: ivi.c:179
const uint8_t * intra_scale
quantization coefficient for intra blocks
Definition: ivi.h:186
uint8_t uses_fullpel
Definition: ivi.h:256
#define FFSWAP(type, a, b)
Definition: common.h:99
uint32_t buf_offs
address in the output buffer for this mb
Definition: ivi.h:113
int b_ref_buf
second reference frame buffer index
Definition: ivi.h:236
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
information for Indeo wavelet band
Definition: ivi.h:144
static int decode_band_hdr(IVI45DecContext *ctx, IVIBandDesc *arg_band, AVCodecContext *avctx)
Decode Indeo 4 band header.
Definition: indeo4.c:271
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:984
uint8_t rvmap_sel
Definition: ivi.h:241
AVCodec ff_indeo4_decoder
Definition: indeo4.c:706
int frame_type
Definition: ivi.h:218