libavcodec/interplayvideo.c

   1 /*
   2  * Interplay MVE Video Decoder
   3  * Copyright (C) 2003 the ffmpeg project
   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 libavcodec/interplayvideo.c
  24  * Interplay MVE Video Decoder by Mike Melanson (melanson@pcisys.net)
  25  * For more information about the Interplay MVE format, visit:
  26  *   http://www.pcisys.net/~melanson/codecs/interplay-mve.txt
  27  * This code is written in such a way that the identifiers match up
  28  * with the encoding descriptions in the document.
  29  *
  30  * This decoder presently only supports a PAL8 output colorspace.
  31  *
  32  * An Interplay video frame consists of 2 parts: The decoding map and
  33  * the video data. A demuxer must load these 2 parts together in a single
  34  * buffer before sending it through the stream to this decoder.
  35  */
  36
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41
  42 #include "avcodec.h"
  43 #include "bytestream.h"
  44 #include "dsputil.h"
  45
  46 #define PALETTE_COUNT 256
  47
  48 /* debugging support */
  49 #define DEBUG_INTERPLAY 0
  50 #if DEBUG_INTERPLAY
  51 #define debug_interplay(x,...) av_log(NULL, AV_LOG_DEBUG, x, __VA_ARGS__)
  52 #else
  53 static inline void debug_interplay(const char *format, ...) { }
  54 #endif
  55
  56 typedef struct IpvideoContext {
  57
  58     AVCodecContext *avctx;
  59     DSPContext dsp;
  60     AVFrame second_last_frame;
  61     AVFrame last_frame;
  62     AVFrame current_frame;
  63     const unsigned char *decoding_map;
  64     int decoding_map_size;
  65
  66     const unsigned char *buf;
  67     int size;
  68
  69     const unsigned char *stream_ptr;
  70     const unsigned char *stream_end;
  71     unsigned char *pixel_ptr;
  72     int line_inc;
  73     int stride;
  74     int upper_motion_limit_offset;
  75
  76 } IpvideoContext;
  77
  78 #define CHECK_STREAM_PTR(n) \
  79   if (s->stream_end - s->stream_ptr < n) { \
  80     av_log(s->avctx, AV_LOG_ERROR, "Interplay video warning: stream_ptr out of bounds (%p >= %p)\n", \
  81       s->stream_ptr + n, s->stream_end); \
  82     return -1; \
  83   }
  84
  85 static int copy_from(IpvideoContext *s, AVFrame *src, int delta_x, int delta_y)
  86 {
  87     int current_offset = s->pixel_ptr - s->current_frame.data[0];
  88     int motion_offset = current_offset + delta_y * s->stride + delta_x;
  89     if (motion_offset < 0) {
  90         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset);
  91         return -1;
  92     } else if (motion_offset > s->upper_motion_limit_offset) {
  93         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n",
  94             motion_offset, s->upper_motion_limit_offset);
  95         return -1;
  96     }
  97     s->dsp.put_pixels_tab[1][0](s->pixel_ptr, src->data[0] + motion_offset, s->stride, 8);
  98     return 0;
  99 }
 100
 101 static int ipvideo_decode_block_opcode_0x0(IpvideoContext *s)
 102 {
 103     return copy_from(s, &s->last_frame, 0, 0);
 104 }
 105
 106 static int ipvideo_decode_block_opcode_0x1(IpvideoContext *s)
 107 {
 108     return copy_from(s, &s->second_last_frame, 0, 0);
 109 }
 110
 111 static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s)
 112 {
 113     unsigned char B;
 114     int x, y;
 115
 116     /* copy block from 2 frames ago using a motion vector; need 1 more byte */
 117     CHECK_STREAM_PTR(1);
 118     B = *s->stream_ptr++;
 119
 120     if (B < 56) {
 121         x = 8 + (B % 7);
 122         y = B / 7;
 123     } else {
 124         x = -14 + ((B - 56) % 29);
 125         y =   8 + ((B - 56) / 29);
 126     }
 127
 128     debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
 129     return copy_from(s, &s->second_last_frame, x, y);
 130 }
 131
 132 static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s)
 133 {
 134     unsigned char B;
 135     int x, y;
 136
 137     /* copy 8x8 block from current frame from an up/left block */
 138
 139     /* need 1 more byte for motion */
 140     CHECK_STREAM_PTR(1);
 141     B = *s->stream_ptr++;
 142
 143     if (B < 56) {
 144         x = -(8 + (B % 7));
 145         y = -(B / 7);
 146     } else {
 147         x = -(-14 + ((B - 56) % 29));
 148         y = -(  8 + ((B - 56) / 29));
 149     }
 150
 151     debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
 152     return copy_from(s, &s->current_frame, x, y);
 153 }
 154
 155 static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s)
 156 {
 157     int x, y;
 158     unsigned char B, BL, BH;
 159
 160     /* copy a block from the previous frame; need 1 more byte */
 161     CHECK_STREAM_PTR(1);
 162
 163     B = *s->stream_ptr++;
 164     BL = B & 0x0F;
 165     BH = (B >> 4) & 0x0F;
 166     x = -8 + BL;
 167     y = -8 + BH;
 168
 169     debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
 170     return copy_from(s, &s->last_frame, x, y);
 171 }
 172
 173 static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s)
 174 {
 175     signed char x, y;
 176
 177     /* copy a block from the previous frame using an expanded range;
 178      * need 2 more bytes */
 179     CHECK_STREAM_PTR(2);
 180
 181     x = *s->stream_ptr++;
 182     y = *s->stream_ptr++;
 183
 184     debug_interplay ("    motion bytes = %d, %d\n", x, y);
 185     return copy_from(s, &s->last_frame, x, y);
 186 }
 187
 188 static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s)
 189 {
 190     /* mystery opcode? skip multiple blocks? */
 191     av_log(s->avctx, AV_LOG_ERROR, "  Interplay video: Help! Mystery opcode 0x6 seen\n");
 192
 193     /* report success */
 194     return 0;
 195 }
 196
 197 static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)
 198 {
 199     int x, y;
 200     unsigned char P[2];
 201     unsigned int flags;
 202
 203     /* 2-color encoding */
 204     CHECK_STREAM_PTR(2);
 205
 206     P[0] = *s->stream_ptr++;
 207     P[1] = *s->stream_ptr++;
 208
 209     if (P[0] <= P[1]) {
 210
 211         /* need 8 more bytes from the stream */
 212         CHECK_STREAM_PTR(8);
 213
 214         for (y = 0; y < 8; y++) {
 215             flags = *s->stream_ptr++ | 0x100;
 216             for (; flags != 1; flags >>= 1)
 217                 *s->pixel_ptr++ = P[flags & 1];
 218             s->pixel_ptr += s->line_inc;
 219         }
 220
 221     } else {
 222
 223         /* need 2 more bytes from the stream */
 224         CHECK_STREAM_PTR(2);
 225
 226         flags = bytestream_get_le16(&s->stream_ptr);
 227         for (y = 0; y < 8; y += 2) {
 228             for (x = 0; x < 8; x += 2, flags >>= 1) {
 229                 s->pixel_ptr[x                ] =
 230                 s->pixel_ptr[x + 1            ] =
 231                 s->pixel_ptr[x +     s->stride] =
 232                 s->pixel_ptr[x + 1 + s->stride] = P[flags & 1];
 233             }
 234             s->pixel_ptr += s->stride * 2;
 235         }
 236     }
 237
 238     /* report success */
 239     return 0;
 240 }
 241
 242 static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
 243 {
 244     int x, y;
 245     unsigned char P[2];
 246     unsigned int flags = 0;
 247
 248     /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
 249      * either top and bottom or left and right halves */
 250     CHECK_STREAM_PTR(2);
 251
 252     P[0] = *s->stream_ptr++;
 253     P[1] = *s->stream_ptr++;
 254
 255     if (P[0] <= P[1]) {
 256
 257         CHECK_STREAM_PTR(14);
 258         s->stream_ptr -= 2;
 259
 260         for (y = 0; y < 16; y++) {
 261             // new values for each 4x4 block
 262             if (!(y & 3)) {
 263                 P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
 264                 flags = bytestream_get_le16(&s->stream_ptr);
 265             }
 266
 267             for (x = 0; x < 4; x++, flags >>= 1)
 268                 *s->pixel_ptr++ = P[flags & 1];
 269             s->pixel_ptr += s->stride - 4;
 270             // switch to right half
 271             if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
 272         }
 273
 274     } else {
 275
 276         /* need 10 more bytes */
 277         CHECK_STREAM_PTR(10);
 278
 279         if (s->stream_ptr[4] <= s->stream_ptr[5]) {
 280
 281             flags = bytestream_get_le32(&s->stream_ptr);
 282
 283             /* vertical split; left & right halves are 2-color encoded */
 284
 285             for (y = 0; y < 16; y++) {
 286                 for (x = 0; x < 4; x++, flags >>= 1)
 287                     *s->pixel_ptr++ = P[flags & 1];
 288                 s->pixel_ptr += s->stride - 4;
 289                 // switch to right half
 290                 if (y == 7) {
 291                     s->pixel_ptr -= 8 * s->stride - 4;
 292                     P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
 293                     flags = bytestream_get_le32(&s->stream_ptr);
 294                 }
 295             }
 296
 297         } else {
 298
 299             /* horizontal split; top & bottom halves are 2-color encoded */
 300
 301             for (y = 0; y < 8; y++) {
 302                 if (y == 4) {
 303                     P[0] = *s->stream_ptr++;
 304                     P[1] = *s->stream_ptr++;
 305                 }
 306                 flags = *s->stream_ptr++ | 0x100;
 307
 308                 for (; flags != 1; flags >>= 1)
 309                     *s->pixel_ptr++ = P[flags & 1];
 310                 s->pixel_ptr += s->line_inc;
 311             }
 312         }
 313     }
 314
 315     /* report success */
 316     return 0;
 317 }
 318
 319 static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
 320 {
 321     int x, y;
 322     unsigned char P[4];
 323
 324     /* 4-color encoding */
 325     CHECK_STREAM_PTR(4);
 326
 327     memcpy(P, s->stream_ptr, 4);
 328     s->stream_ptr += 4;
 329
 330     if (P[0] <= P[1]) {
 331         if (P[2] <= P[3]) {
 332
 333             /* 1 of 4 colors for each pixel, need 16 more bytes */
 334             CHECK_STREAM_PTR(16);
 335
 336             for (y = 0; y < 8; y++) {
 337                 /* get the next set of 8 2-bit flags */
 338                 int flags = bytestream_get_le16(&s->stream_ptr);
 339                 for (x = 0; x < 8; x++, flags >>= 2)
 340                     *s->pixel_ptr++ = P[flags & 0x03];
 341                 s->pixel_ptr += s->line_inc;
 342             }
 343
 344         } else {
 345             uint32_t flags;
 346
 347             /* 1 of 4 colors for each 2x2 block, need 4 more bytes */
 348             CHECK_STREAM_PTR(4);
 349
 350             flags = bytestream_get_le32(&s->stream_ptr);
 351
 352             for (y = 0; y < 8; y += 2) {
 353                 for (x = 0; x < 8; x += 2, flags >>= 2) {
 354                     s->pixel_ptr[x                ] =
 355                     s->pixel_ptr[x + 1            ] =
 356                     s->pixel_ptr[x +     s->stride] =
 357                     s->pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];
 358                 }
 359                 s->pixel_ptr += s->stride * 2;
 360             }
 361
 362         }
 363     } else {
 364         uint64_t flags;
 365
 366         /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */
 367         CHECK_STREAM_PTR(8);
 368
 369         flags = bytestream_get_le64(&s->stream_ptr);
 370         if (P[2] <= P[3]) {
 371             for (y = 0; y < 8; y++) {
 372                 for (x = 0; x < 8; x += 2, flags >>= 2) {
 373                     s->pixel_ptr[x    ] =
 374                     s->pixel_ptr[x + 1] = P[flags & 0x03];
 375                 }
 376                 s->pixel_ptr += s->stride;
 377             }
 378         } else {
 379             for (y = 0; y < 8; y += 2) {
 380                 for (x = 0; x < 8; x++, flags >>= 2) {
 381                     s->pixel_ptr[x            ] =
 382                     s->pixel_ptr[x + s->stride] = P[flags & 0x03];
 383                 }
 384                 s->pixel_ptr += s->stride * 2;
 385             }
 386         }
 387     }
 388
 389     /* report success */
 390     return 0;
 391 }
 392
 393 static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)
 394 {
 395     int x, y;
 396     unsigned char P[4];
 397     int flags = 0;
 398
 399     /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
 400      * either top and bottom or left and right halves */
 401     CHECK_STREAM_PTR(24);
 402
 403     if (s->stream_ptr[0] <= s->stream_ptr[1]) {
 404
 405         /* 4-color encoding for each quadrant; need 32 bytes */
 406         CHECK_STREAM_PTR(32);
 407
 408         for (y = 0; y < 16; y++) {
 409             // new values for each 4x4 block
 410             if (!(y & 3)) {
 411                 memcpy(P, s->stream_ptr, 4);
 412                 s->stream_ptr += 4;
 413                 flags = bytestream_get_le32(&s->stream_ptr);
 414             }
 415
 416             for (x = 0; x < 4; x++, flags >>= 2)
 417                 *s->pixel_ptr++ = P[flags & 0x03];
 418
 419             s->pixel_ptr += s->stride - 4;
 420             // switch to right half
 421             if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
 422         }
 423
 424     } else {
 425         // vertical split?
 426         int vert = s->stream_ptr[12] <= s->stream_ptr[13];
 427         uint64_t flags = 0;
 428
 429         /* 4-color encoding for either left and right or top and bottom
 430          * halves */
 431
 432         for (y = 0; y < 16; y++) {
 433             // load values for each half
 434             if (!(y & 7)) {
 435                 memcpy(P, s->stream_ptr, 4);
 436                 s->stream_ptr += 4;
 437                 flags = bytestream_get_le64(&s->stream_ptr);
 438             }
 439
 440             for (x = 0; x < 4; x++, flags >>= 2)
 441                 *s->pixel_ptr++ = P[flags & 0x03];
 442
 443             if (vert) {
 444                 s->pixel_ptr += s->stride - 4;
 445                 // switch to right half
 446                 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
 447             } else if (y & 1) s->pixel_ptr += s->line_inc;
 448         }
 449     }
 450
 451     /* report success */
 452     return 0;
 453 }
 454
 455 static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s)
 456 {
 457     int y;
 458
 459     /* 64-color encoding (each pixel in block is a different color) */
 460     CHECK_STREAM_PTR(64);
 461
 462     for (y = 0; y < 8; y++) {
 463         memcpy(s->pixel_ptr, s->stream_ptr, 8);
 464         s->stream_ptr += 8;
 465         s->pixel_ptr  += s->stride;
 466     }
 467
 468     /* report success */
 469     return 0;
 470 }
 471
 472 static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s)
 473 {
 474     int x, y;
 475
 476     /* 16-color block encoding: each 2x2 block is a different color */
 477     CHECK_STREAM_PTR(16);
 478
 479     for (y = 0; y < 8; y += 2) {
 480         for (x = 0; x < 8; x += 2) {
 481             s->pixel_ptr[x                ] =
 482             s->pixel_ptr[x + 1            ] =
 483             s->pixel_ptr[x +     s->stride] =
 484             s->pixel_ptr[x + 1 + s->stride] = *s->stream_ptr++;
 485         }
 486         s->pixel_ptr += s->stride * 2;
 487     }
 488
 489     /* report success */
 490     return 0;
 491 }
 492
 493 static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s)
 494 {
 495     int y;
 496     unsigned char P[2];
 497
 498     /* 4-color block encoding: each 4x4 block is a different color */
 499     CHECK_STREAM_PTR(4);
 500
 501     for (y = 0; y < 8; y++) {
 502         if (!(y & 3)) {
 503             P[0] = *s->stream_ptr++;
 504             P[1] = *s->stream_ptr++;
 505         }
 506         memset(s->pixel_ptr,     P[0], 4);
 507         memset(s->pixel_ptr + 4, P[1], 4);
 508         s->pixel_ptr += s->stride;
 509     }
 510
 511     /* report success */
 512     return 0;
 513 }
 514
 515 static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s)
 516 {
 517     int y;
 518     unsigned char pix;
 519
 520     /* 1-color encoding: the whole block is 1 solid color */
 521     CHECK_STREAM_PTR(1);
 522     pix = *s->stream_ptr++;
 523
 524     for (y = 0; y < 8; y++) {
 525         memset(s->pixel_ptr, pix, 8);
 526         s->pixel_ptr += s->stride;
 527     }
 528
 529     /* report success */
 530     return 0;
 531 }
 532
 533 static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s)
 534 {
 535     int x, y;
 536     unsigned char sample[2];
 537
 538     /* dithered encoding */
 539     CHECK_STREAM_PTR(2);
 540     sample[0] = *s->stream_ptr++;
 541     sample[1] = *s->stream_ptr++;
 542
 543     for (y = 0; y < 8; y++) {
 544         for (x = 0; x < 8; x += 2) {
 545             *s->pixel_ptr++ = sample[  y & 1 ];
 546             *s->pixel_ptr++ = sample[!(y & 1)];
 547         }
 548         s->pixel_ptr += s->line_inc;
 549     }
 550
 551     /* report success */
 552     return 0;
 553 }
 554
 555 static int (* const ipvideo_decode_block[])(IpvideoContext *s) = {
 556     ipvideo_decode_block_opcode_0x0, ipvideo_decode_block_opcode_0x1,
 557     ipvideo_decode_block_opcode_0x2, ipvideo_decode_block_opcode_0x3,
 558     ipvideo_decode_block_opcode_0x4, ipvideo_decode_block_opcode_0x5,
 559     ipvideo_decode_block_opcode_0x6, ipvideo_decode_block_opcode_0x7,
 560     ipvideo_decode_block_opcode_0x8, ipvideo_decode_block_opcode_0x9,
 561     ipvideo_decode_block_opcode_0xA, ipvideo_decode_block_opcode_0xB,
 562     ipvideo_decode_block_opcode_0xC, ipvideo_decode_block_opcode_0xD,
 563     ipvideo_decode_block_opcode_0xE, ipvideo_decode_block_opcode_0xF,
 564 };
 565
 566 static void ipvideo_decode_opcodes(IpvideoContext *s)
 567 {
 568     int x, y;
 569     int index = 0;
 570     unsigned char opcode;
 571     int ret;
 572     int code_counts[16] = {0};
 573     static int frame = 0;
 574
 575     debug_interplay("------------------ frame %d\n", frame);
 576     frame++;
 577
 578     /* this is PAL8, so make the palette available */
 579     memcpy(s->current_frame.data[1], s->avctx->palctrl->palette, PALETTE_COUNT * 4);
 580
 581     s->stride = s->current_frame.linesize[0];
 582     s->stream_ptr = s->buf + 14;  /* data starts 14 bytes in */
 583     s->stream_end = s->buf + s->size;
 584     s->line_inc = s->stride - 8;
 585     s->upper_motion_limit_offset = (s->avctx->height - 8) * s->stride
 586         + s->avctx->width - 8;
 587
 588     for (y = 0; y < (s->stride * s->avctx->height); y += s->stride * 8) {
 589         for (x = y; x < y + s->avctx->width; x += 8) {
 590             /* bottom nibble first, then top nibble (which makes it
 591              * hard to use a GetBitcontext) */
 592             if (index & 1)
 593                 opcode = s->decoding_map[index >> 1] >> 4;
 594             else
 595                 opcode = s->decoding_map[index >> 1] & 0xF;
 596             index++;
 597
 598             debug_interplay("  block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",
 599                 x - y, y / s->stride, opcode, s->stream_ptr);
 600             code_counts[opcode]++;
 601
 602             s->pixel_ptr = s->current_frame.data[0] + x;
 603             ret = ipvideo_decode_block[opcode](s);
 604             if (ret != 0) {
 605                 av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode problem on frame %d, @ block (%d, %d)\n",
 606                     frame, x - y, y / s->stride);
 607                 return;
 608             }
 609         }
 610     }
 611     if (s->stream_end - s->stream_ptr > 1) {
 612         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode finished with %td bytes left over\n",
 613             s->stream_end - s->stream_ptr);
 614     }
 615 }
 616
 617 static av_cold int ipvideo_decode_init(AVCodecContext *avctx)
 618 {
 619     IpvideoContext *s = avctx->priv_data;
 620
 621     s->avctx = avctx;
 622
 623     if (s->avctx->palctrl == NULL) {
 624         av_log(avctx, AV_LOG_ERROR, " Interplay video: palette expected.\n");
 625         return -1;
 626     }
 627
 628     avctx->pix_fmt = PIX_FMT_PAL8;
 629     dsputil_init(&s->dsp, avctx);
 630
 631     /* decoding map contains 4 bits of information per 8x8 block */
 632     s->decoding_map_size = avctx->width * avctx->height / (8 * 8 * 2);
 633
 634     s->current_frame.data[0] = s->last_frame.data[0] =
 635     s->second_last_frame.data[0] = NULL;
 636
 637     return 0;
 638 }
 639
 640 static int ipvideo_decode_frame(AVCodecContext *avctx,
 641                                 void *data, int *data_size,
 642                                 AVPacket *avpkt)
 643 {
 644     const uint8_t *buf = avpkt->data;
 645     int buf_size = avpkt->size;
 646     IpvideoContext *s = avctx->priv_data;
 647     AVPaletteControl *palette_control = avctx->palctrl;
 648
 649     /* compressed buffer needs to be large enough to at least hold an entire
 650      * decoding map */
 651     if (buf_size < s->decoding_map_size)
 652         return buf_size;
 653
 654     s->decoding_map = buf;
 655     s->buf = buf + s->decoding_map_size;
 656     s->size = buf_size - s->decoding_map_size;
 657
 658     s->current_frame.reference = 3;
 659     if (avctx->get_buffer(avctx, &s->current_frame)) {
 660         av_log(avctx, AV_LOG_ERROR, "  Interplay Video: get_buffer() failed\n");
 661         return -1;
 662     }
 663
 664     ipvideo_decode_opcodes(s);
 665
 666     if (palette_control->palette_changed) {
 667         palette_control->palette_changed = 0;
 668         s->current_frame.palette_has_changed = 1;
 669     }
 670
 671     *data_size = sizeof(AVFrame);
 672     *(AVFrame*)data = s->current_frame;
 673
 674     /* shuffle frames */
 675     if (s->second_last_frame.data[0])
 676         avctx->release_buffer(avctx, &s->second_last_frame);
 677     s->second_last_frame = s->last_frame;
 678     s->last_frame = s->current_frame;
 679     s->current_frame.data[0] = NULL;  /* catch any access attempts */
 680
 681     /* report that the buffer was completely consumed */
 682     return buf_size;
 683 }
 684
 685 static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
 686 {
 687     IpvideoContext *s = avctx->priv_data;
 688
 689     /* release the last frame */
 690     if (s->last_frame.data[0])
 691         avctx->release_buffer(avctx, &s->last_frame);
 692     if (s->second_last_frame.data[0])
 693         avctx->release_buffer(avctx, &s->second_last_frame);
 694
 695     return 0;
 696 }
 697
 698 AVCodec interplay_video_decoder = {
 699     "interplayvideo",
 700     CODEC_TYPE_VIDEO,
 701     CODEC_ID_INTERPLAY_VIDEO,
 702     sizeof(IpvideoContext),
 703     ipvideo_decode_init,
 704     NULL,
 705     ipvideo_decode_end,
 706     ipvideo_decode_frame,
 707     CODEC_CAP_DR1,
 708     .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"),
 709 };