+/**
+ * Decode an Indeo 4 or 5 band.
+ *
+ * @param[in,out] ctx ptr to the decoder context
+ * @param[in,out] band ptr to the band descriptor
+ * @param[in] avctx ptr to the AVCodecContext
+ * @return result code: 0 = OK, -1 = error
+ */
+static int decode_band(IVI45DecContext *ctx,
+ IVIBandDesc *band, AVCodecContext *avctx)
+{
+ int result, i, t, idx1, idx2, pos;
+ IVITile *tile;
+
+ band->buf = band->bufs[ctx->dst_buf];
+ if (!band->buf) {
+ av_log(avctx, AV_LOG_ERROR, "Band buffer points to no data!\n");
+ return AVERROR_INVALIDDATA;
+ }
+ band->ref_buf = band->bufs[ctx->ref_buf];
+ band->data_ptr = ctx->frame_data + (get_bits_count(&ctx->gb) >> 3);
+
+ result = ctx->decode_band_hdr(ctx, band, avctx);
+ if (result) {
+ av_log(avctx, AV_LOG_ERROR, "Error while decoding band header: %d\n",
+ result);
+ return result;
+ }
+
+ if (band->is_empty) {
+ av_log(avctx, AV_LOG_ERROR, "Empty band encountered!\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ band->rv_map = &ctx->rvmap_tabs[band->rvmap_sel];
+
+ /* apply corrections to the selected rvmap table if present */
+ for (i = 0; i < band->num_corr; i++) {
+ idx1 = band->corr[i * 2];
+ idx2 = band->corr[i * 2 + 1];
+ FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
+ FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
+ }
+
+ pos = get_bits_count(&ctx->gb);
+
+ for (t = 0; t < band->num_tiles; t++) {
+ tile = &band->tiles[t];
+
+ if (tile->mb_size != band->mb_size) {
+ av_log(avctx, AV_LOG_ERROR, "MB sizes mismatch: %d vs. %d\n",
+ band->mb_size, tile->mb_size);
+ return AVERROR_INVALIDDATA;
+ }
+ tile->is_empty = get_bits1(&ctx->gb);
+ if (tile->is_empty) {
+ result = ivi_process_empty_tile(avctx, band, tile,
+ (ctx->planes[0].bands[0].mb_size >> 3) - (band->mb_size >> 3));
+ if (result < 0)
+ break;
+ av_dlog(avctx, "Empty tile encountered!\n");
+ } else {
+ tile->data_size = ivi_dec_tile_data_size(&ctx->gb);
+ if (!tile->data_size) {
+ av_log(avctx, AV_LOG_ERROR, "Tile data size is zero!\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ result = ctx->decode_mb_info(ctx, band, tile, avctx);
+ if (result < 0)
+ break;
+
+ result = ivi_decode_blocks(&ctx->gb, band, tile, avctx);
+ if (result < 0) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Corrupted tile data encountered!\n");
+ break;
+ }
+
+ if (((get_bits_count(&ctx->gb) - pos) >> 3) != tile->data_size) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Tile data_size mismatch!\n");
+ result = AVERROR_INVALIDDATA;
+ break;
+ }
+
+ pos += tile->data_size << 3; // skip to next tile
+ }
+ }
+
+ /* restore the selected rvmap table by applying its corrections in
+ * reverse order */
+ for (i = band->num_corr-1; i >= 0; i--) {
+ idx1 = band->corr[i*2];
+ idx2 = band->corr[i*2+1];
+ FFSWAP(uint8_t, band->rv_map->runtab[idx1], band->rv_map->runtab[idx2]);
+ FFSWAP(int16_t, band->rv_map->valtab[idx1], band->rv_map->valtab[idx2]);
+ }
+
+#ifdef DEBUG
+ if (band->checksum_present) {
+ uint16_t chksum = ivi_calc_band_checksum(band);
+ if (chksum != band->checksum) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Band checksum mismatch! Plane %d, band %d, "
+ "received: %"PRIx32", calculated: %"PRIx16"\n",
+ band->plane, band->band_num, band->checksum, chksum);
+ }
+ }
+#endif
+
+ align_get_bits(&ctx->gb);
+
+ return result;
+}
+
+int ff_ivi_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
+ AVPacket *avpkt)
+{
+ IVI45DecContext *ctx = avctx->priv_data;
+ const uint8_t *buf = avpkt->data;
+ AVFrame *frame = data;
+ int buf_size = avpkt->size;
+ int result, p, b;
+
+ init_get_bits(&ctx->gb, buf, buf_size * 8);
+ ctx->frame_data = buf;
+ ctx->frame_size = buf_size;
+
+ result = ctx->decode_pic_hdr(ctx, avctx);
+ if (result) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Error while decoding picture header: %d\n", result);
+ return result;
+ }
+ if (ctx->gop_invalid)
+ return AVERROR_INVALIDDATA;
+
+ if (ctx->gop_flags & IVI5_IS_PROTECTED) {
+ avpriv_report_missing_feature(avctx, "Password-protected clip!\n");
+ return AVERROR_PATCHWELCOME;
+ }
+
+ if (!ctx->planes[0].bands) {
+ av_log(avctx, AV_LOG_ERROR, "Color planes not initialized yet\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ ctx->switch_buffers(ctx);
+
+ //{ START_TIMER;
+
+ if (ctx->is_nonnull_frame(ctx)) {
+ for (p = 0; p < 3; p++) {
+ for (b = 0; b < ctx->planes[p].num_bands; b++) {
+ result = decode_band(ctx, &ctx->planes[p].bands[b], avctx);
+ if (result < 0) {
+ av_log(avctx, AV_LOG_ERROR,
+ "Error while decoding band: %d, plane: %d\n", b, p);
+ return result;
+ }
+ }
+ }
+ } else {
+ if (ctx->is_scalable)
+ return AVERROR_INVALIDDATA;
+
+ for (p = 0; p < 3; p++) {
+ if (!ctx->planes[p].bands[0].buf)
+ return AVERROR_INVALIDDATA;
+ }
+ }
+
+ //STOP_TIMER("decode_planes"); }
+
+ /* If the bidirectional mode is enabled, next I and the following P
+ * frame will be sent together. Unfortunately the approach below seems
+ * to be the only way to handle the B-frames mode.
+ * That's exactly the same Intel decoders do.
+ */
+ if (avctx->codec_id == AV_CODEC_ID_INDEO4 &&
+ ctx->frame_type == 0/*FRAMETYPE_INTRA*/) {
+ while (get_bits(&ctx->gb, 8)); // skip version string
+ skip_bits_long(&ctx->gb, 64); // skip padding, TODO: implement correct 8-bytes alignment
+ if (get_bits_left(&ctx->gb) > 18 && show_bits(&ctx->gb, 18) == 0x3FFF8)
+ av_log(avctx, AV_LOG_ERROR, "Buffer contains IP frames!\n");
+ }
+
+ result = ff_set_dimensions(avctx, ctx->planes[0].width, ctx->planes[0].height);
+ if (result < 0)
+ return result;
+
+ if ((result = ff_get_buffer(avctx, frame, 0)) < 0) {
+ av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
+ return result;
+ }
+
+ if (ctx->is_scalable) {
+ if (avctx->codec_id == AV_CODEC_ID_INDEO4)
+ ff_ivi_recompose_haar(&ctx->planes[0], frame->data[0], frame->linesize[0]);
+ else
+ ff_ivi_recompose53 (&ctx->planes[0], frame->data[0], frame->linesize[0]);
+ } else {
+ ivi_output_plane(&ctx->planes[0], frame->data[0], frame->linesize[0]);
+ }
+
+ ivi_output_plane(&ctx->planes[2], frame->data[1], frame->linesize[1]);
+ ivi_output_plane(&ctx->planes[1], frame->data[2], frame->linesize[2]);
+
+ *got_frame = 1;
+
+ return buf_size;
+}