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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
30 #define BITSTREAM_READER_LE
31 #include "avcodec.h"
32 #include "get_bits.h"
33 #include "dsputil.h"
34 #include "ivi_dsp.h"
35 #include "ivi_common.h"
36 #include "indeo4data.h"
37 
38 #define IVI4_STREAM_ANALYSER 0
39 #define IVI4_DEBUG_CHECKSUM 0
40 
44 enum {
52 };
53 
54 #define IVI4_PIC_SIZE_ESC 7
55 
56 
57 typedef struct {
60  RVMapDesc rvmap_tabs[9];
61 
62  uint32_t frame_num;
65  uint32_t data_size;
68 
70  IVIPlaneDesc planes[3];
71 
72  int buf_switch;
73  int dst_buf;
74  int ref_buf;
75 
78 
79  uint16_t checksum;
80 
81  uint8_t rvmap_sel;
82  uint8_t in_imf;
83  uint8_t in_q;
84  uint8_t pic_glob_quant;
85  uint8_t unknown1;
86 
87 #if IVI4_STREAM_ANALYSER
88  uint8_t has_b_frames;
89  uint8_t has_transp;
90  uint8_t uses_tiling;
91  uint8_t uses_haar;
92  uint8_t uses_fullpel;
93 #endif
95 
96 
97 static const struct {
101 } transforms[18] = {
103  { NULL, NULL, 0 }, /* inverse Haar 8x1 */
104  { NULL, NULL, 0 }, /* inverse Haar 1x8 */
109  { NULL, NULL, 0 }, /* inverse DCT 8x8 */
110  { NULL, NULL, 0 }, /* inverse DCT 8x1 */
111  { NULL, NULL, 0 }, /* inverse DCT 1x8 */
112  { NULL, NULL, 0 }, /* inverse Haar 4x4 */
114  { NULL, NULL, 0 }, /* no transform 4x4 */
115  { NULL, NULL, 0 }, /* inverse Haar 1x4 */
116  { NULL, NULL, 0 }, /* inverse Haar 4x1 */
117  { NULL, NULL, 0 }, /* inverse slant 1x4 */
118  { NULL, NULL, 0 }, /* inverse slant 4x1 */
119  { NULL, NULL, 0 }, /* inverse DCT 4x4 */
120 };
121 
133 {
134  int i;
135 
136  switch (get_bits(gb, 2)) {
137  case 3:
138  return 1;
139  case 2:
140  for (i = 0; i < 4; i++)
141  if (get_bits(gb, 2) != 3)
142  return 0;
143  return 4;
144  default:
145  return 0;
146  }
147 }
148 
149 static inline int scale_tile_size(int def_size, int size_factor)
150 {
151  return size_factor == 15 ? def_size : (size_factor + 1) << 5;
152 }
153 
162 {
163  int pic_size_indx, i, p;
164  IVIPicConfig pic_conf;
165 
166  if (get_bits(&ctx->gb, 18) != 0x3FFF8) {
167  av_log(avctx, AV_LOG_ERROR, "Invalid picture start code!\n");
168  return AVERROR_INVALIDDATA;
169  }
170 
171  ctx->prev_frame_type = ctx->frame_type;
172  ctx->frame_type = get_bits(&ctx->gb, 3);
173  if (ctx->frame_type == 7) {
174  av_log(avctx, AV_LOG_ERROR, "Invalid frame type: %d\n", ctx->frame_type);
175  return AVERROR_INVALIDDATA;
176  }
177 
178 #if IVI4_STREAM_ANALYSER
179  if ( ctx->frame_type == FRAMETYPE_BIDIR1
180  || ctx->frame_type == FRAMETYPE_BIDIR)
181  ctx->has_b_frames = 1;
182 #endif
183 
184  ctx->transp_status = get_bits1(&ctx->gb);
185 #if IVI4_STREAM_ANALYSER
186  if (ctx->transp_status) {
187  ctx->has_transp = 1;
188  }
189 #endif
190 
191  /* unknown bit: Mac decoder ignores this bit, XANIM returns error */
192  if (get_bits1(&ctx->gb)) {
193  av_log(avctx, AV_LOG_ERROR, "Sync bit is set!\n");
194  return AVERROR_INVALIDDATA;
195  }
196 
197  ctx->data_size = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 24) : 0;
198 
199  /* null frames don't contain anything else so we just return */
200  if (ctx->frame_type >= FRAMETYPE_NULL_FIRST) {
201  av_dlog(avctx, "Null frame encountered!\n");
202  return 0;
203  }
204 
205  /* Check key lock status. If enabled - ignore lock word. */
206  /* Usually we have to prompt the user for the password, but */
207  /* we don't do that because Indeo 4 videos can be decoded anyway */
208  if (get_bits1(&ctx->gb)) {
209  skip_bits_long(&ctx->gb, 32);
210  av_dlog(avctx, "Password-protected clip!\n");
211  }
212 
213  pic_size_indx = get_bits(&ctx->gb, 3);
214  if (pic_size_indx == IVI4_PIC_SIZE_ESC) {
215  pic_conf.pic_height = get_bits(&ctx->gb, 16);
216  pic_conf.pic_width = get_bits(&ctx->gb, 16);
217  } else {
218  pic_conf.pic_height = ivi4_common_pic_sizes[pic_size_indx * 2 + 1];
219  pic_conf.pic_width = ivi4_common_pic_sizes[pic_size_indx * 2 ];
220  }
221 
222  /* Decode tile dimensions. */
223  if (get_bits1(&ctx->gb)) {
224  pic_conf.tile_height = scale_tile_size(pic_conf.pic_height, get_bits(&ctx->gb, 4));
225  pic_conf.tile_width = scale_tile_size(pic_conf.pic_width, get_bits(&ctx->gb, 4));
226 #if IVI4_STREAM_ANALYSER
227  ctx->uses_tiling = 1;
228 #endif
229  } else {
230  pic_conf.tile_height = pic_conf.pic_height;
231  pic_conf.tile_width = pic_conf.pic_width;
232  }
233 
234  /* Decode chroma subsampling. We support only 4:4 aka YVU9. */
235  if (get_bits(&ctx->gb, 2)) {
236  av_log(avctx, AV_LOG_ERROR, "Only YVU9 picture format is supported!\n");
237  return AVERROR_INVALIDDATA;
238  }
239  pic_conf.chroma_height = (pic_conf.pic_height + 3) >> 2;
240  pic_conf.chroma_width = (pic_conf.pic_width + 3) >> 2;
241 
242  /* decode subdivision of the planes */
243  pic_conf.luma_bands = decode_plane_subdivision(&ctx->gb);
244  if (pic_conf.luma_bands)
245  pic_conf.chroma_bands = decode_plane_subdivision(&ctx->gb);
246  ctx->is_scalable = pic_conf.luma_bands != 1 || pic_conf.chroma_bands != 1;
247  if (ctx->is_scalable && (pic_conf.luma_bands != 4 || pic_conf.chroma_bands != 1)) {
248  av_log(avctx, AV_LOG_ERROR, "Scalability: unsupported subdivision! Luma bands: %d, chroma bands: %d\n",
249  pic_conf.luma_bands, pic_conf.chroma_bands);
250  return AVERROR_INVALIDDATA;
251  }
252 
253  /* check if picture layout was changed and reallocate buffers */
254  if (ivi_pic_config_cmp(&pic_conf, &ctx->pic_conf)) {
255  if (ff_ivi_init_planes(ctx->planes, &pic_conf)) {
256  av_log(avctx, AV_LOG_ERROR, "Couldn't reallocate color planes!\n");
257  return AVERROR(ENOMEM);
258  }
259 
260  ctx->pic_conf = pic_conf;
261 
262  /* set default macroblock/block dimensions */
263  for (p = 0; p <= 2; p++) {
264  for (i = 0; i < (!p ? pic_conf.luma_bands : pic_conf.chroma_bands); i++) {
265  ctx->planes[p].bands[i].mb_size = !p ? (!ctx->is_scalable ? 16 : 8) : 4;
266  ctx->planes[p].bands[i].blk_size = !p ? 8 : 4;
267  }
268  }
269 
271  ctx->pic_conf.tile_height)) {
272  av_log(avctx, AV_LOG_ERROR,
273  "Couldn't reallocate internal structures!\n");
274  return AVERROR(ENOMEM);
275  }
276  }
277 
278  ctx->frame_num = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 20) : 0;
279 
280  /* skip decTimeEst field if present */
281  if (get_bits1(&ctx->gb))
282  skip_bits(&ctx->gb, 8);
283 
284  /* decode macroblock and block huffman codebooks */
285  if (ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_MB_HUFF, &ctx->mb_vlc, avctx) ||
286  ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_BLK_HUFF, &ctx->blk_vlc, avctx))
287  return AVERROR_INVALIDDATA;
288 
289  ctx->rvmap_sel = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 8;
290 
291  ctx->in_imf = get_bits1(&ctx->gb);
292  ctx->in_q = get_bits1(&ctx->gb);
293 
294  ctx->pic_glob_quant = get_bits(&ctx->gb, 5);
295 
296  /* TODO: ignore this parameter if unused */
297  ctx->unknown1 = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 3) : 0;
298 
299  ctx->checksum = get_bits1(&ctx->gb) ? get_bits(&ctx->gb, 16) : 0;
300 
301  /* skip picture header extension if any */
302  while (get_bits1(&ctx->gb)) {
303  av_dlog(avctx, "Pic hdr extension encountered!\n");
304  skip_bits(&ctx->gb, 8);
305  }
306 
307  if (get_bits1(&ctx->gb)) {
308  av_log(avctx, AV_LOG_ERROR, "Bad blocks bits encountered!\n");
309  }
310 
311  align_get_bits(&ctx->gb);
312 
313  return 0;
314 }
315 
316 
326  AVCodecContext *avctx)
327 {
328  int plane, band_num, indx, transform_id, scan_indx;
329  int i;
330 
331  plane = get_bits(&ctx->gb, 2);
332  band_num = get_bits(&ctx->gb, 4);
333  if (band->plane != plane || band->band_num != band_num) {
334  av_log(avctx, AV_LOG_ERROR, "Invalid band header sequence!\n");
335  return AVERROR_INVALIDDATA;
336  }
337 
338  band->is_empty = get_bits1(&ctx->gb);
339  if (!band->is_empty) {
340  /* skip header size
341  * If header size is not given, header size is 4 bytes. */
342  if (get_bits1(&ctx->gb))
343  skip_bits(&ctx->gb, 16);
344 
345  band->is_halfpel = get_bits(&ctx->gb, 2);
346  if (band->is_halfpel >= 2) {
347  av_log(avctx, AV_LOG_ERROR, "Invalid/unsupported mv resolution: %d!\n",
348  band->is_halfpel);
349  return AVERROR_INVALIDDATA;
350  }
351 #if IVI4_STREAM_ANALYSER
352  if (!band->is_halfpel)
353  ctx->uses_fullpel = 1;
354 #endif
355 
356  band->checksum_present = get_bits1(&ctx->gb);
357  if (band->checksum_present)
358  band->checksum = get_bits(&ctx->gb, 16);
359 
360  indx = get_bits(&ctx->gb, 2);
361  if (indx == 3) {
362  av_log(avctx, AV_LOG_ERROR, "Invalid block size!\n");
363  return AVERROR_INVALIDDATA;
364  }
365  band->mb_size = 16 >> indx;
366  band->blk_size = 8 >> (indx >> 1);
367 
368  band->inherit_mv = get_bits1(&ctx->gb);
369  band->inherit_qdelta = get_bits1(&ctx->gb);
370 
371  band->glob_quant = get_bits(&ctx->gb, 5);
372 
373  if (!get_bits1(&ctx->gb) || ctx->frame_type == FRAMETYPE_INTRA) {
374  transform_id = get_bits(&ctx->gb, 5);
375  if (transform_id >= FF_ARRAY_ELEMS(transforms) ||
376  !transforms[transform_id].inv_trans) {
377  av_log_ask_for_sample(avctx, "Unimplemented transform: %d!\n", transform_id);
378  return AVERROR_PATCHWELCOME;
379  }
380  if ((transform_id >= 7 && transform_id <= 9) ||
381  transform_id == 17) {
382  av_log_ask_for_sample(avctx, "DCT transform not supported yet!\n");
383  return AVERROR_PATCHWELCOME;
384  }
385 
386 #if IVI4_STREAM_ANALYSER
387  if ((transform_id >= 0 && transform_id <= 2) || transform_id == 10)
388  ctx->uses_haar = 1;
389 #endif
390 
391  band->inv_transform = transforms[transform_id].inv_trans;
392  band->dc_transform = transforms[transform_id].dc_trans;
393  band->is_2d_trans = transforms[transform_id].is_2d_trans;
394 
395  scan_indx = get_bits(&ctx->gb, 4);
396  if (scan_indx == 15) {
397  av_log(avctx, AV_LOG_ERROR, "Custom scan pattern encountered!\n");
398  return AVERROR_INVALIDDATA;
399  }
400  band->scan = scan_index_to_tab[scan_indx];
401 
402  band->quant_mat = get_bits(&ctx->gb, 5);
403  if (band->quant_mat == 31) {
404  av_log(avctx, AV_LOG_ERROR, "Custom quant matrix encountered!\n");
405  return AVERROR_INVALIDDATA;
406  }
407  }
408 
409  /* decode block huffman codebook */
410  if (ff_ivi_dec_huff_desc(&ctx->gb, get_bits1(&ctx->gb), IVI_BLK_HUFF,
411  &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  return 0;
448 }
449 
450 
462  IVITile *tile, AVCodecContext *avctx)
463 {
464  int x, y, mv_x, mv_y, mv_delta, offs, mb_offset, blks_per_mb,
465  mv_scale, mb_type_bits;
466  IVIMbInfo *mb, *ref_mb;
467  int row_offset = band->mb_size * band->pitch;
468 
469  mb = tile->mbs;
470  ref_mb = tile->ref_mbs;
471  offs = tile->ypos * band->pitch + tile->xpos;
472 
473  blks_per_mb = band->mb_size != band->blk_size ? 4 : 1;
474  mb_type_bits = ctx->frame_type == FRAMETYPE_BIDIR ? 2 : 1;
475 
476  /* scale factor for motion vectors */
477  mv_scale = (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3);
478  mv_x = mv_y = 0;
479 
480  for (y = tile->ypos; y < tile->ypos + tile->height; y += band->mb_size) {
481  mb_offset = offs;
482 
483  for (x = tile->xpos; x < tile->xpos + tile->width; x += band->mb_size) {
484  mb->xpos = x;
485  mb->ypos = y;
486  mb->buf_offs = mb_offset;
487 
488  if (get_bits1(&ctx->gb)) {
489  if (ctx->frame_type == FRAMETYPE_INTRA) {
490  av_log(avctx, AV_LOG_ERROR, "Empty macroblock in an INTRA picture!\n");
491  return AVERROR_INVALIDDATA;
492  }
493  mb->type = 1; /* empty macroblocks are always INTER */
494  mb->cbp = 0; /* all blocks are empty */
495 
496  mb->q_delta = 0;
497  if (!band->plane && !band->band_num && ctx->in_q) {
498  mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
499  IVI_VLC_BITS, 1);
500  mb->q_delta = IVI_TOSIGNED(mb->q_delta);
501  }
502 
503  mb->mv_x = mb->mv_y = 0; /* no motion vector coded */
504  if (band->inherit_mv) {
505  /* motion vector inheritance */
506  if (mv_scale) {
507  mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
508  mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
509  } else {
510  mb->mv_x = ref_mb->mv_x;
511  mb->mv_y = ref_mb->mv_y;
512  }
513  }
514  } else {
515  if (band->inherit_mv) {
516  mb->type = ref_mb->type; /* copy mb_type from corresponding reference mb */
517  } else if (ctx->frame_type == FRAMETYPE_INTRA) {
518  mb->type = 0; /* mb_type is always INTRA for intra-frames */
519  } else {
520  mb->type = get_bits(&ctx->gb, mb_type_bits);
521  }
522 
523  mb->cbp = get_bits(&ctx->gb, blks_per_mb);
524 
525  mb->q_delta = 0;
526  if (band->inherit_qdelta) {
527  if (ref_mb) mb->q_delta = ref_mb->q_delta;
528  } else if (mb->cbp || (!band->plane && !band->band_num &&
529  ctx->in_q)) {
530  mb->q_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
531  IVI_VLC_BITS, 1);
532  mb->q_delta = IVI_TOSIGNED(mb->q_delta);
533  }
534 
535  if (!mb->type) {
536  mb->mv_x = mb->mv_y = 0; /* there is no motion vector in intra-macroblocks */
537  } else {
538  if (band->inherit_mv) {
539  /* motion vector inheritance */
540  if (mv_scale) {
541  mb->mv_x = ivi_scale_mv(ref_mb->mv_x, mv_scale);
542  mb->mv_y = ivi_scale_mv(ref_mb->mv_y, mv_scale);
543  } else {
544  mb->mv_x = ref_mb->mv_x;
545  mb->mv_y = ref_mb->mv_y;
546  }
547  } else {
548  /* decode motion vector deltas */
549  mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
550  IVI_VLC_BITS, 1);
551  mv_y += IVI_TOSIGNED(mv_delta);
552  mv_delta = get_vlc2(&ctx->gb, ctx->mb_vlc.tab->table,
553  IVI_VLC_BITS, 1);
554  mv_x += IVI_TOSIGNED(mv_delta);
555  mb->mv_x = mv_x;
556  mb->mv_y = mv_y;
557  }
558  }
559  }
560 
561  mb++;
562  if (ref_mb)
563  ref_mb++;
564  mb_offset += band->mb_size;
565  }
566 
567  offs += row_offset;
568  }
569 
570  align_get_bits(&ctx->gb);
571 
572  return 0;
573 }
574 
575 
584 static int decode_band(IVI4DecContext *ctx, int plane_num,
585  IVIBandDesc *band, AVCodecContext *avctx)
586 {
587  int result, i, t, pos, idx1, idx2;
588  IVITile *tile;
589 
590  band->buf = band->bufs[ctx->dst_buf];
591  band->ref_buf = band->bufs[ctx->ref_buf];
592 
593  result = decode_band_hdr(ctx, band, avctx);
594  if (result) {
595  av_log(avctx, AV_LOG_ERROR, "Error decoding band header\n");
596  return result;
597  }
598 
599  if (band->is_empty) {
600  av_log(avctx, AV_LOG_ERROR, "Empty band encountered!\n");
601  return AVERROR_INVALIDDATA;
602  }
603 
604  band->rv_map = &ctx->rvmap_tabs[band->rvmap_sel];
605 
606  /* apply corrections to the selected rvmap table if present */
607  for (i = 0; i < band->num_corr; i++) {
608  idx1 = band->corr[i * 2];
609  idx2 = band->corr[i * 2 + 1];
610  FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
611  FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
612  }
613 
614  pos = get_bits_count(&ctx->gb);
615 
616  for (t = 0; t < band->num_tiles; t++) {
617  tile = &band->tiles[t];
618 
619  tile->is_empty = get_bits1(&ctx->gb);
620  if (tile->is_empty) {
621  ff_ivi_process_empty_tile(avctx, band, tile,
622  (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3));
623  av_dlog(avctx, "Empty tile encountered!\n");
624  } else {
625  tile->data_size = ff_ivi_dec_tile_data_size(&ctx->gb);
626  if (!tile->data_size) {
627  av_log(avctx, AV_LOG_ERROR, "Tile data size is zero!\n");
628  return AVERROR_INVALIDDATA;
629  }
630 
631  result = decode_mb_info(ctx, band, tile, avctx);
632  if (result < 0)
633  break;
634 
635  result = ff_ivi_decode_blocks(&ctx->gb, band, tile);
636  if (result < 0 || ((get_bits_count(&ctx->gb) - pos) >> 3) != tile->data_size) {
637  av_log(avctx, AV_LOG_ERROR, "Corrupted tile data encountered!\n");
638  break;
639  }
640 
641  pos += tile->data_size << 3; // skip to next tile
642  }
643  }
644 
645  /* restore the selected rvmap table by applying its corrections in reverse order */
646  for (i = band->num_corr - 1; i >= 0; i--) {
647  idx1 = band->corr[i * 2];
648  idx2 = band->corr[i * 2 + 1];
649  FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
650  FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
651  }
652 
653 #if defined(DEBUG) && IVI4_DEBUG_CHECKSUM
654  if (band->checksum_present) {
655  uint16_t chksum = ivi_calc_band_checksum(band);
656  if (chksum != band->checksum) {
657  av_log(avctx, AV_LOG_ERROR,
658  "Band checksum mismatch! Plane %d, band %d, received: %x, calculated: %x\n",
659  band->plane, band->band_num, band->checksum, chksum);
660  }
661  }
662 #endif
663 
664  align_get_bits(&ctx->gb);
665 
666  return 0;
667 }
668 
669 
671 {
672  IVI4DecContext *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 = PIX_FMT_YUV410P;
685 
686  return 0;
687 }
688 
689 
696 {
697  switch (ctx->prev_frame_type) {
698  case FRAMETYPE_INTRA:
699  case FRAMETYPE_INTER:
700  ctx->buf_switch ^= 1;
701  ctx->dst_buf = ctx->buf_switch;
702  ctx->ref_buf = ctx->buf_switch ^ 1;
703  break;
705  break;
706  }
707 
708  switch (ctx->frame_type) {
709  case FRAMETYPE_INTRA:
710  ctx->buf_switch = 0;
711  /* FALLTHROUGH */
712  case FRAMETYPE_INTER:
713  ctx->dst_buf = ctx->buf_switch;
714  ctx->ref_buf = ctx->buf_switch ^ 1;
715  break;
718  case FRAMETYPE_NULL_LAST:
719  break;
720  }
721 }
722 
723 
724 static int decode_frame(AVCodecContext *avctx, void *data, int *data_size,
725  AVPacket *avpkt)
726 {
727  IVI4DecContext *ctx = avctx->priv_data;
728  const uint8_t *buf = avpkt->data;
729  int buf_size = avpkt->size;
730  int result, p, b;
731 
732  init_get_bits(&ctx->gb, buf, buf_size * 8);
733 
734  result = decode_pic_hdr(ctx, avctx);
735  if (result) {
736  av_log(avctx, AV_LOG_ERROR, "Error decoding picture header\n");
737  return result;
738  }
739 
740  switch_buffers(ctx);
741 
742  if (ctx->frame_type < FRAMETYPE_NULL_FIRST) {
743  for (p = 0; p < 3; p++) {
744  for (b = 0; b < ctx->planes[p].num_bands; b++) {
745  result = decode_band(ctx, p, &ctx->planes[p].bands[b], avctx);
746  if (result) {
747  av_log(avctx, AV_LOG_ERROR,
748  "Error decoding band: %d, plane: %d\n", b, p);
749  return result;
750  }
751  }
752  }
753  }
754 
755  /* If the bidirectional mode is enabled, next I and the following P frame will */
756  /* be sent together. Unfortunately the approach below seems to be the only way */
757  /* to handle the B-frames mode. That's exactly the same Intel decoders do. */
758  if (ctx->frame_type == FRAMETYPE_INTRA) {
759  while (get_bits(&ctx->gb, 8)); // skip version string
760  skip_bits_long(&ctx->gb, 64); // skip padding, TODO: implement correct 8-bytes alignment
761  if (get_bits_left(&ctx->gb) > 18 && show_bits(&ctx->gb, 18) == 0x3FFF8)
762  av_log(avctx, AV_LOG_ERROR, "Buffer contains IP frames!\n");
763  }
764 
765  if (ctx->frame.data[0])
766  avctx->release_buffer(avctx, &ctx->frame);
767 
768  ctx->frame.reference = 0;
769  if ((result = avctx->get_buffer(avctx, &ctx->frame)) < 0) {
770  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
771  return result;
772  }
773 
774  if (ctx->is_scalable) {
775  ff_ivi_recompose_haar(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0], 4);
776  } else {
777  ff_ivi_output_plane(&ctx->planes[0], ctx->frame.data[0], ctx->frame.linesize[0]);
778  }
779 
780  ff_ivi_output_plane(&ctx->planes[2], ctx->frame.data[1], ctx->frame.linesize[1]);
781  ff_ivi_output_plane(&ctx->planes[1], ctx->frame.data[2], ctx->frame.linesize[2]);
782 
783  *data_size = sizeof(AVFrame);
784  *(AVFrame*)data = ctx->frame;
785 
786  return buf_size;
787 }
788 
789 
791 {
792  IVI4DecContext *ctx = avctx->priv_data;
793 
794  ff_ivi_free_buffers(&ctx->planes[0]);
795 
796  if (ctx->frame.data[0])
797  avctx->release_buffer(avctx, &ctx->frame);
798 
799 #if IVI4_STREAM_ANALYSER
800  if (ctx->is_scalable)
801  av_log(avctx, AV_LOG_ERROR, "This video uses scalability mode!\n");
802  if (ctx->uses_tiling)
803  av_log(avctx, AV_LOG_ERROR, "This video uses local decoding!\n");
804  if (ctx->has_b_frames)
805  av_log(avctx, AV_LOG_ERROR, "This video contains B-frames!\n");
806  if (ctx->has_transp)
807  av_log(avctx, AV_LOG_ERROR, "Transparency mode is enabled!\n");
808  if (ctx->uses_haar)
809  av_log(avctx, AV_LOG_ERROR, "This video uses Haar transform!\n");
810  if (ctx->uses_fullpel)
811  av_log(avctx, AV_LOG_ERROR, "This video uses fullpel motion vectors!\n");
812 #endif
813 
814  return 0;
815 }
816 
817 
819  .name = "indeo4",
820  .type = AVMEDIA_TYPE_VIDEO,
821  .id = CODEC_ID_INDEO4,
822  .priv_data_size = sizeof(IVI4DecContext),
823  .init = decode_init,
824  .close = decode_close,
825  .decode = decode_frame,
826  .long_name = NULL_IF_CONFIG_SMALL("Intel Indeo Video Interactive 4"),
827 };