git.sesse.net Git - ffmpeg/blob - libavcodec/interplayvideo.c

   1 /*
   2  * Interplay MVE Video Decoder
   3  * Copyright (C) 2003 the ffmpeg project
   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
  22 /**
  23  * @file
  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
  41 #include "avcodec.h"
  42 #include "bytestream.h"
  43 #include "dsputil.h"
  44 #define BITSTREAM_READER_LE
  45 #include "get_bits.h"
  46 #include "internal.h"
  47
  48 #define PALETTE_COUNT 256
  49
  50 typedef struct IpvideoContext {
  51
  52     AVCodecContext *avctx;
  53     DSPContext dsp;
  54     AVFrame second_last_frame;
  55     AVFrame last_frame;
  56     AVFrame current_frame;
  57     const unsigned char *decoding_map;
  58     int decoding_map_size;
  59
  60     int is_16bpp;
  61     GetByteContext stream_ptr, mv_ptr;
  62     unsigned char *pixel_ptr;
  63     int line_inc;
  64     int stride;
  65     int upper_motion_limit_offset;
  66
  67     uint32_t pal[256];
  68 } IpvideoContext;
  69
  70 static int copy_from(IpvideoContext *s, AVFrame *src, int delta_x, int delta_y)
  71 {
  72     int current_offset = s->pixel_ptr - s->current_frame.data[0];
  73     int motion_offset = current_offset + delta_y * s->current_frame.linesize[0]
  74                        + delta_x * (1 + s->is_16bpp);
  75     if (motion_offset < 0) {
  76         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset);
  77         return -1;
  78     } else if (motion_offset > s->upper_motion_limit_offset) {
  79         av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n",
  80             motion_offset, s->upper_motion_limit_offset);
  81         return -1;
  82     }
  83     if (src->data[0] == NULL) {
  84         av_log(s->avctx, AV_LOG_ERROR, "Invalid decode type, corrupted header?\n");
  85         return AVERROR(EINVAL);
  86     }
  87     s->dsp.put_pixels_tab[!s->is_16bpp][0](s->pixel_ptr, src->data[0] + motion_offset,
  88                                            s->current_frame.linesize[0], 8);
  89     return 0;
  90 }
  91
  92 static int ipvideo_decode_block_opcode_0x0(IpvideoContext *s)
  93 {
  94     return copy_from(s, &s->last_frame, 0, 0);
  95 }
  96
  97 static int ipvideo_decode_block_opcode_0x1(IpvideoContext *s)
  98 {
  99     return copy_from(s, &s->second_last_frame, 0, 0);
 100 }
 101
 102 static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s)
 103 {
 104     unsigned char B;
 105     int x, y;
 106
 107     /* copy block from 2 frames ago using a motion vector; need 1 more byte */
 108     if (!s->is_16bpp) {
 109         B = bytestream2_get_byte(&s->stream_ptr);
 110     } else {
 111         B = bytestream2_get_byte(&s->mv_ptr);
 112     }
 113
 114     if (B < 56) {
 115         x = 8 + (B % 7);
 116         y = B / 7;
 117     } else {
 118         x = -14 + ((B - 56) % 29);
 119         y =   8 + ((B - 56) / 29);
 120     }
 121
 122     av_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
 123     return copy_from(s, &s->second_last_frame, x, y);
 124 }
 125
 126 static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s)
 127 {
 128     unsigned char B;
 129     int x, y;
 130
 131     /* copy 8x8 block from current frame from an up/left block */
 132
 133     /* need 1 more byte for motion */
 134     if (!s->is_16bpp) {
 135         B = bytestream2_get_byte(&s->stream_ptr);
 136     } else {
 137         B = bytestream2_get_byte(&s->mv_ptr);
 138     }
 139
 140     if (B < 56) {
 141         x = -(8 + (B % 7));
 142         y = -(B / 7);
 143     } else {
 144         x = -(-14 + ((B - 56) % 29));
 145         y = -(  8 + ((B - 56) / 29));
 146     }
 147
 148     av_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
 149     return copy_from(s, &s->current_frame, x, y);
 150 }
 151
 152 static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s)
 153 {
 154     int x, y;
 155     unsigned char B, BL, BH;
 156
 157     /* copy a block from the previous frame; need 1 more byte */
 158     if (!s->is_16bpp) {
 159         B = bytestream2_get_byte(&s->stream_ptr);
 160     } else {
 161         B = bytestream2_get_byte(&s->mv_ptr);
 162     }
 163
 164     BL = B & 0x0F;
 165     BH = (B >> 4) & 0x0F;
 166     x = -8 + BL;
 167     y = -8 + BH;
 168
 169     av_dlog(NULL, "    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     x = bytestream2_get_byte(&s->stream_ptr);
 180     y = bytestream2_get_byte(&s->stream_ptr);
 181
 182     av_dlog(NULL, "    motion bytes = %d, %d\n", x, y);
 183     return copy_from(s, &s->last_frame, x, y);
 184 }
 185
 186 static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s)
 187 {
 188     /* mystery opcode? skip multiple blocks? */
 189     av_log(s->avctx, AV_LOG_ERROR, "  Interplay video: Help! Mystery opcode 0x6 seen\n");
 190
 191     /* report success */
 192     return 0;
 193 }
 194
 195 static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)
 196 {
 197     int x, y;
 198     unsigned char P[2];
 199     unsigned int flags;
 200
 201     /* 2-color encoding */
 202     P[0] = bytestream2_get_byte(&s->stream_ptr);
 203     P[1] = bytestream2_get_byte(&s->stream_ptr);
 204
 205     if (P[0] <= P[1]) {
 206
 207         /* need 8 more bytes from the stream */
 208         for (y = 0; y < 8; y++) {
 209             flags = bytestream2_get_byte(&s->stream_ptr) | 0x100;
 210             for (; flags != 1; flags >>= 1)
 211                 *s->pixel_ptr++ = P[flags & 1];
 212             s->pixel_ptr += s->line_inc;
 213         }
 214
 215     } else {
 216
 217         /* need 2 more bytes from the stream */
 218         flags = bytestream2_get_le16(&s->stream_ptr);
 219         for (y = 0; y < 8; y += 2) {
 220             for (x = 0; x < 8; x += 2, flags >>= 1) {
 221                 s->pixel_ptr[x                ] =
 222                 s->pixel_ptr[x + 1            ] =
 223                 s->pixel_ptr[x +     s->stride] =
 224                 s->pixel_ptr[x + 1 + s->stride] = P[flags & 1];
 225             }
 226             s->pixel_ptr += s->stride * 2;
 227         }
 228     }
 229
 230     /* report success */
 231     return 0;
 232 }
 233
 234 static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
 235 {
 236     int x, y;
 237     unsigned char P[4];
 238     unsigned int flags = 0;
 239
 240     /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
 241      * either top and bottom or left and right halves */
 242     P[0] = bytestream2_get_byte(&s->stream_ptr);
 243     P[1] = bytestream2_get_byte(&s->stream_ptr);
 244
 245     if (P[0] <= P[1]) {
 246         for (y = 0; y < 16; y++) {
 247             // new values for each 4x4 block
 248             if (!(y & 3)) {
 249                 if (y) {
 250                     P[0]  = bytestream2_get_byte(&s->stream_ptr);
 251                     P[1]  = bytestream2_get_byte(&s->stream_ptr);
 252                 }
 253                 flags = bytestream2_get_le16(&s->stream_ptr);
 254             }
 255
 256             for (x = 0; x < 4; x++, flags >>= 1)
 257                 *s->pixel_ptr++ = P[flags & 1];
 258             s->pixel_ptr += s->stride - 4;
 259             // switch to right half
 260             if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
 261         }
 262
 263     } else {
 264         flags = bytestream2_get_le32(&s->stream_ptr);
 265         P[2] = bytestream2_get_byte(&s->stream_ptr);
 266         P[3] = bytestream2_get_byte(&s->stream_ptr);
 267
 268         if (P[2] <= P[3]) {
 269
 270             /* vertical split; left & right halves are 2-color encoded */
 271
 272             for (y = 0; y < 16; y++) {
 273                 for (x = 0; x < 4; x++, flags >>= 1)
 274                     *s->pixel_ptr++ = P[flags & 1];
 275                 s->pixel_ptr += s->stride - 4;
 276                 // switch to right half
 277                 if (y == 7) {
 278                     s->pixel_ptr -= 8 * s->stride - 4;
 279                     P[0]  = P[2];
 280                     P[1]  = P[3];
 281                     flags = bytestream2_get_le32(&s->stream_ptr);
 282                 }
 283             }
 284
 285         } else {
 286
 287             /* horizontal split; top & bottom halves are 2-color encoded */
 288
 289             for (y = 0; y < 8; y++) {
 290                 if (y == 4) {
 291                     P[0]  = P[2];
 292                     P[1]  = P[3];
 293                     flags = bytestream2_get_le32(&s->stream_ptr);
 294                 }
 295
 296                 for (x = 0; x < 8; x++, flags >>= 1)
 297                     *s->pixel_ptr++ = P[flags & 1];
 298                 s->pixel_ptr += s->line_inc;
 299             }
 300         }
 301     }
 302
 303     /* report success */
 304     return 0;
 305 }
 306
 307 static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
 308 {
 309     int x, y;
 310     unsigned char P[4];
 311
 312     /* 4-color encoding */
 313     bytestream2_get_buffer(&s->stream_ptr, P, 4);
 314
 315     if (P[0] <= P[1]) {
 316         if (P[2] <= P[3]) {
 317
 318             /* 1 of 4 colors for each pixel, need 16 more bytes */
 319             for (y = 0; y < 8; y++) {
 320                 /* get the next set of 8 2-bit flags */
 321                 int flags = bytestream2_get_le16(&s->stream_ptr);
 322                 for (x = 0; x < 8; x++, flags >>= 2)
 323                     *s->pixel_ptr++ = P[flags & 0x03];
 324                 s->pixel_ptr += s->line_inc;
 325             }
 326
 327         } else {
 328             uint32_t flags;
 329
 330             /* 1 of 4 colors for each 2x2 block, need 4 more bytes */
 331             flags = bytestream2_get_le32(&s->stream_ptr);
 332
 333             for (y = 0; y < 8; y += 2) {
 334                 for (x = 0; x < 8; x += 2, flags >>= 2) {
 335                     s->pixel_ptr[x                ] =
 336                     s->pixel_ptr[x + 1            ] =
 337                     s->pixel_ptr[x +     s->stride] =
 338                     s->pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];
 339                 }
 340                 s->pixel_ptr += s->stride * 2;
 341             }
 342
 343         }
 344     } else {
 345         uint64_t flags;
 346
 347         /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */
 348         flags = bytestream2_get_le64(&s->stream_ptr);
 349         if (P[2] <= P[3]) {
 350             for (y = 0; y < 8; y++) {
 351                 for (x = 0; x < 8; x += 2, flags >>= 2) {
 352                     s->pixel_ptr[x    ] =
 353                     s->pixel_ptr[x + 1] = P[flags & 0x03];
 354                 }
 355                 s->pixel_ptr += s->stride;
 356             }
 357         } else {
 358             for (y = 0; y < 8; y += 2) {
 359                 for (x = 0; x < 8; x++, flags >>= 2) {
 360                     s->pixel_ptr[x            ] =
 361                     s->pixel_ptr[x + s->stride] = P[flags & 0x03];
 362                 }
 363                 s->pixel_ptr += s->stride * 2;
 364             }
 365         }
 366     }
 367
 368     /* report success */
 369     return 0;
 370 }
 371
 372 static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)
 373 {
 374     int x, y;
 375     unsigned char P[8];
 376     int flags = 0;
 377
 378     bytestream2_get_buffer(&s->stream_ptr, P, 4);
 379
 380     /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
 381      * either top and bottom or left and right halves */
 382     if (P[0] <= P[1]) {
 383
 384         /* 4-color encoding for each quadrant; need 32 bytes */
 385         for (y = 0; y < 16; y++) {
 386             // new values for each 4x4 block
 387             if (!(y & 3)) {
 388                 if (y) bytestream2_get_buffer(&s->stream_ptr, P, 4);
 389                 flags = bytestream2_get_le32(&s->stream_ptr);
 390             }
 391
 392             for (x = 0; x < 4; x++, flags >>= 2)
 393                 *s->pixel_ptr++ = P[flags & 0x03];
 394
 395             s->pixel_ptr += s->stride - 4;
 396             // switch to right half
 397             if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
 398         }
 399
 400     } else {
 401         // vertical split?
 402         int vert;
 403         uint64_t flags = bytestream2_get_le64(&s->stream_ptr);
 404
 405         bytestream2_get_buffer(&s->stream_ptr, P + 4, 4);
 406         vert = P[4] <= P[5];
 407
 408         /* 4-color encoding for either left and right or top and bottom
 409          * halves */
 410
 411         for (y = 0; y < 16; y++) {
 412             for (x = 0; x < 4; x++, flags >>= 2)
 413                 *s->pixel_ptr++ = P[flags & 0x03];
 414
 415             if (vert) {
 416                 s->pixel_ptr += s->stride - 4;
 417                 // switch to right half
 418                 if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
 419             } else if (y & 1) s->pixel_ptr += s->line_inc;
 420
 421             // load values for second half
 422             if (y == 7) {
 423                 memcpy(P, P + 4, 4);
 424                 flags = bytestream2_get_le64(&s->stream_ptr);
 425             }
 426         }
 427     }
 428
 429     /* report success */
 430     return 0;
 431 }
 432
 433 static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s)
 434 {
 435     int y;
 436
 437     /* 64-color encoding (each pixel in block is a different color) */
 438     for (y = 0; y < 8; y++) {
 439         bytestream2_get_buffer(&s->stream_ptr, s->pixel_ptr, 8);
 440         s->pixel_ptr  += s->stride;
 441     }
 442
 443     /* report success */
 444     return 0;
 445 }
 446
 447 static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s)
 448 {
 449     int x, y;
 450
 451     /* 16-color block encoding: each 2x2 block is a different color */
 452     for (y = 0; y < 8; y += 2) {
 453         for (x = 0; x < 8; x += 2) {
 454             s->pixel_ptr[x                ] =
 455             s->pixel_ptr[x + 1            ] =
 456             s->pixel_ptr[x +     s->stride] =
 457             s->pixel_ptr[x + 1 + s->stride] = bytestream2_get_byte(&s->stream_ptr);
 458         }
 459         s->pixel_ptr += s->stride * 2;
 460     }
 461
 462     /* report success */
 463     return 0;
 464 }
 465
 466 static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s)
 467 {
 468     int y;
 469     unsigned char P[2];
 470
 471     /* 4-color block encoding: each 4x4 block is a different color */
 472     for (y = 0; y < 8; y++) {
 473         if (!(y & 3)) {
 474             P[0] = bytestream2_get_byte(&s->stream_ptr);
 475             P[1] = bytestream2_get_byte(&s->stream_ptr);
 476         }
 477         memset(s->pixel_ptr,     P[0], 4);
 478         memset(s->pixel_ptr + 4, P[1], 4);
 479         s->pixel_ptr += s->stride;
 480     }
 481
 482     /* report success */
 483     return 0;
 484 }
 485
 486 static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s)
 487 {
 488     int y;
 489     unsigned char pix;
 490
 491     /* 1-color encoding: the whole block is 1 solid color */
 492     pix = bytestream2_get_byte(&s->stream_ptr);
 493
 494     for (y = 0; y < 8; y++) {
 495         memset(s->pixel_ptr, pix, 8);
 496         s->pixel_ptr += s->stride;
 497     }
 498
 499     /* report success */
 500     return 0;
 501 }
 502
 503 static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s)
 504 {
 505     int x, y;
 506     unsigned char sample[2];
 507
 508     /* dithered encoding */
 509     sample[0] = bytestream2_get_byte(&s->stream_ptr);
 510     sample[1] = bytestream2_get_byte(&s->stream_ptr);
 511
 512     for (y = 0; y < 8; y++) {
 513         for (x = 0; x < 8; x += 2) {
 514             *s->pixel_ptr++ = sample[  y & 1 ];
 515             *s->pixel_ptr++ = sample[!(y & 1)];
 516         }
 517         s->pixel_ptr += s->line_inc;
 518     }
 519
 520     /* report success */
 521     return 0;
 522 }
 523
 524 static int ipvideo_decode_block_opcode_0x6_16(IpvideoContext *s)
 525 {
 526     signed char x, y;
 527
 528     /* copy a block from the second last frame using an expanded range */
 529     x = bytestream2_get_byte(&s->stream_ptr);
 530     y = bytestream2_get_byte(&s->stream_ptr);
 531
 532     av_dlog(NULL, "    motion bytes = %d, %d\n", x, y);
 533     return copy_from(s, &s->second_last_frame, x, y);
 534 }
 535
 536 static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s)
 537 {
 538     int x, y;
 539     uint16_t P[2];
 540     unsigned int flags;
 541     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
 542
 543     /* 2-color encoding */
 544     P[0] = bytestream2_get_le16(&s->stream_ptr);
 545     P[1] = bytestream2_get_le16(&s->stream_ptr);
 546
 547     if (!(P[0] & 0x8000)) {
 548
 549         for (y = 0; y < 8; y++) {
 550             flags = bytestream2_get_byte(&s->stream_ptr) | 0x100;
 551             for (; flags != 1; flags >>= 1)
 552                 *pixel_ptr++ = P[flags & 1];
 553             pixel_ptr += s->line_inc;
 554         }
 555
 556     } else {
 557
 558         flags = bytestream2_get_le16(&s->stream_ptr);
 559         for (y = 0; y < 8; y += 2) {
 560             for (x = 0; x < 8; x += 2, flags >>= 1) {
 561                 pixel_ptr[x                ] =
 562                 pixel_ptr[x + 1            ] =
 563                 pixel_ptr[x +     s->stride] =
 564                 pixel_ptr[x + 1 + s->stride] = P[flags & 1];
 565             }
 566             pixel_ptr += s->stride * 2;
 567         }
 568     }
 569
 570     return 0;
 571 }
 572
 573 static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s)
 574 {
 575     int x, y;
 576     uint16_t P[4];
 577     unsigned int flags = 0;
 578     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
 579
 580     /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
 581      * either top and bottom or left and right halves */
 582     P[0] = bytestream2_get_le16(&s->stream_ptr);
 583     P[1] = bytestream2_get_le16(&s->stream_ptr);
 584
 585     if (!(P[0] & 0x8000)) {
 586
 587         for (y = 0; y < 16; y++) {
 588             // new values for each 4x4 block
 589             if (!(y & 3)) {
 590                 if (y) {
 591                     P[0] = bytestream2_get_le16(&s->stream_ptr);
 592                     P[1] = bytestream2_get_le16(&s->stream_ptr);
 593                 }
 594                 flags = bytestream2_get_le16(&s->stream_ptr);
 595             }
 596
 597             for (x = 0; x < 4; x++, flags >>= 1)
 598                 *pixel_ptr++ = P[flags & 1];
 599             pixel_ptr += s->stride - 4;
 600             // switch to right half
 601             if (y == 7) pixel_ptr -= 8 * s->stride - 4;
 602         }
 603
 604     } else {
 605
 606         flags = bytestream2_get_le32(&s->stream_ptr);
 607         P[2]  = bytestream2_get_le16(&s->stream_ptr);
 608         P[3]  = bytestream2_get_le16(&s->stream_ptr);
 609
 610         if (!(P[2] & 0x8000)) {
 611
 612             /* vertical split; left & right halves are 2-color encoded */
 613
 614             for (y = 0; y < 16; y++) {
 615                 for (x = 0; x < 4; x++, flags >>= 1)
 616                     *pixel_ptr++ = P[flags & 1];
 617                 pixel_ptr += s->stride - 4;
 618                 // switch to right half
 619                 if (y == 7) {
 620                     pixel_ptr -= 8 * s->stride - 4;
 621                     P[0]  = P[2];
 622                     P[1]  = P[3];
 623                     flags = bytestream2_get_le32(&s->stream_ptr);
 624                 }
 625             }
 626
 627         } else {
 628
 629             /* horizontal split; top & bottom halves are 2-color encoded */
 630
 631             for (y = 0; y < 8; y++) {
 632                 if (y == 4) {
 633                     P[0]  = P[2];
 634                     P[1]  = P[3];
 635                     flags = bytestream2_get_le32(&s->stream_ptr);
 636                 }
 637
 638                 for (x = 0; x < 8; x++, flags >>= 1)
 639                     *pixel_ptr++ = P[flags & 1];
 640                 pixel_ptr += s->line_inc;
 641             }
 642         }
 643     }
 644
 645     /* report success */
 646     return 0;
 647 }
 648
 649 static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s)
 650 {
 651     int x, y;
 652     uint16_t P[4];
 653     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
 654
 655     /* 4-color encoding */
 656     for (x = 0; x < 4; x++)
 657         P[x] = bytestream2_get_le16(&s->stream_ptr);
 658
 659     if (!(P[0] & 0x8000)) {
 660         if (!(P[2] & 0x8000)) {
 661
 662             /* 1 of 4 colors for each pixel */
 663             for (y = 0; y < 8; y++) {
 664                 /* get the next set of 8 2-bit flags */
 665                 int flags = bytestream2_get_le16(&s->stream_ptr);
 666                 for (x = 0; x < 8; x++, flags >>= 2)
 667                     *pixel_ptr++ = P[flags & 0x03];
 668                 pixel_ptr += s->line_inc;
 669             }
 670
 671         } else {
 672             uint32_t flags;
 673
 674             /* 1 of 4 colors for each 2x2 block */
 675             flags = bytestream2_get_le32(&s->stream_ptr);
 676
 677             for (y = 0; y < 8; y += 2) {
 678                 for (x = 0; x < 8; x += 2, flags >>= 2) {
 679                     pixel_ptr[x                ] =
 680                     pixel_ptr[x + 1            ] =
 681                     pixel_ptr[x +     s->stride] =
 682                     pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];
 683                 }
 684                 pixel_ptr += s->stride * 2;
 685             }
 686
 687         }
 688     } else {
 689         uint64_t flags;
 690
 691         /* 1 of 4 colors for each 2x1 or 1x2 block */
 692         flags = bytestream2_get_le64(&s->stream_ptr);
 693         if (!(P[2] & 0x8000)) {
 694             for (y = 0; y < 8; y++) {
 695                 for (x = 0; x < 8; x += 2, flags >>= 2) {
 696                     pixel_ptr[x    ] =
 697                     pixel_ptr[x + 1] = P[flags & 0x03];
 698                 }
 699                 pixel_ptr += s->stride;
 700             }
 701         } else {
 702             for (y = 0; y < 8; y += 2) {
 703                 for (x = 0; x < 8; x++, flags >>= 2) {
 704                     pixel_ptr[x            ] =
 705                     pixel_ptr[x + s->stride] = P[flags & 0x03];
 706                 }
 707                 pixel_ptr += s->stride * 2;
 708             }
 709         }
 710     }
 711
 712     /* report success */
 713     return 0;
 714 }
 715
 716 static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s)
 717 {
 718     int x, y;
 719     uint16_t P[8];
 720     int flags = 0;
 721     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
 722
 723     for (x = 0; x < 4; x++)
 724         P[x] = bytestream2_get_le16(&s->stream_ptr);
 725
 726     /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
 727      * either top and bottom or left and right halves */
 728     if (!(P[0] & 0x8000)) {
 729
 730         /* 4-color encoding for each quadrant */
 731         for (y = 0; y < 16; y++) {
 732             // new values for each 4x4 block
 733             if (!(y & 3)) {
 734                 if (y)
 735                     for (x = 0; x < 4; x++)
 736                         P[x] = bytestream2_get_le16(&s->stream_ptr);
 737                 flags = bytestream2_get_le32(&s->stream_ptr);
 738             }
 739
 740             for (x = 0; x < 4; x++, flags >>= 2)
 741                 *pixel_ptr++ = P[flags & 0x03];
 742
 743             pixel_ptr += s->stride - 4;
 744             // switch to right half
 745             if (y == 7) pixel_ptr -= 8 * s->stride - 4;
 746         }
 747
 748     } else {
 749         // vertical split?
 750         int vert;
 751         uint64_t flags = bytestream2_get_le64(&s->stream_ptr);
 752
 753         for (x = 4; x < 8; x++)
 754             P[x] = bytestream2_get_le16(&s->stream_ptr);
 755         vert = !(P[4] & 0x8000);
 756
 757         /* 4-color encoding for either left and right or top and bottom
 758          * halves */
 759
 760         for (y = 0; y < 16; y++) {
 761             for (x = 0; x < 4; x++, flags >>= 2)
 762                 *pixel_ptr++ = P[flags & 0x03];
 763
 764             if (vert) {
 765                 pixel_ptr += s->stride - 4;
 766                 // switch to right half
 767                 if (y == 7) pixel_ptr -= 8 * s->stride - 4;
 768             } else if (y & 1) pixel_ptr += s->line_inc;
 769
 770             // load values for second half
 771             if (y == 7) {
 772                 memcpy(P, P + 4, 8);
 773                 flags = bytestream2_get_le64(&s->stream_ptr);
 774             }
 775         }
 776     }
 777
 778     /* report success */
 779     return 0;
 780 }
 781
 782 static int ipvideo_decode_block_opcode_0xB_16(IpvideoContext *s)
 783 {
 784     int x, y;
 785     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
 786
 787     /* 64-color encoding (each pixel in block is a different color) */
 788     for (y = 0; y < 8; y++) {
 789         for (x = 0; x < 8; x++)
 790             pixel_ptr[x] = bytestream2_get_le16(&s->stream_ptr);
 791         pixel_ptr  += s->stride;
 792     }
 793
 794     /* report success */
 795     return 0;
 796 }
 797
 798 static int ipvideo_decode_block_opcode_0xC_16(IpvideoContext *s)
 799 {
 800     int x, y;
 801     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
 802
 803     /* 16-color block encoding: each 2x2 block is a different color */
 804     for (y = 0; y < 8; y += 2) {
 805         for (x = 0; x < 8; x += 2) {
 806             pixel_ptr[x                ] =
 807             pixel_ptr[x + 1            ] =
 808             pixel_ptr[x +     s->stride] =
 809             pixel_ptr[x + 1 + s->stride] = bytestream2_get_le16(&s->stream_ptr);
 810         }
 811         pixel_ptr += s->stride * 2;
 812     }
 813
 814     /* report success */
 815     return 0;
 816 }
 817
 818 static int ipvideo_decode_block_opcode_0xD_16(IpvideoContext *s)
 819 {
 820     int x, y;
 821     uint16_t P[2];
 822     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
 823
 824     /* 4-color block encoding: each 4x4 block is a different color */
 825     for (y = 0; y < 8; y++) {
 826         if (!(y & 3)) {
 827             P[0] = bytestream2_get_le16(&s->stream_ptr);
 828             P[1] = bytestream2_get_le16(&s->stream_ptr);
 829         }
 830         for (x = 0; x < 8; x++)
 831             pixel_ptr[x] = P[x >> 2];
 832         pixel_ptr += s->stride;
 833     }
 834
 835     /* report success */
 836     return 0;
 837 }
 838
 839 static int ipvideo_decode_block_opcode_0xE_16(IpvideoContext *s)
 840 {
 841     int x, y;
 842     uint16_t pix;
 843     uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;
 844
 845     /* 1-color encoding: the whole block is 1 solid color */
 846     pix = bytestream2_get_le16(&s->stream_ptr);
 847
 848     for (y = 0; y < 8; y++) {
 849         for (x = 0; x < 8; x++)
 850             pixel_ptr[x] = pix;
 851         pixel_ptr += s->stride;
 852     }
 853
 854     /* report success */
 855     return 0;
 856 }
 857
 858 static int (* const ipvideo_decode_block[])(IpvideoContext *s) = {
 859     ipvideo_decode_block_opcode_0x0, ipvideo_decode_block_opcode_0x1,
 860     ipvideo_decode_block_opcode_0x2, ipvideo_decode_block_opcode_0x3,
 861     ipvideo_decode_block_opcode_0x4, ipvideo_decode_block_opcode_0x5,
 862     ipvideo_decode_block_opcode_0x6, ipvideo_decode_block_opcode_0x7,
 863     ipvideo_decode_block_opcode_0x8, ipvideo_decode_block_opcode_0x9,
 864     ipvideo_decode_block_opcode_0xA, ipvideo_decode_block_opcode_0xB,
 865     ipvideo_decode_block_opcode_0xC, ipvideo_decode_block_opcode_0xD,
 866     ipvideo_decode_block_opcode_0xE, ipvideo_decode_block_opcode_0xF,
 867 };
 868
 869 static int (* const ipvideo_decode_block16[])(IpvideoContext *s) = {
 870     ipvideo_decode_block_opcode_0x0,    ipvideo_decode_block_opcode_0x1,
 871     ipvideo_decode_block_opcode_0x2,    ipvideo_decode_block_opcode_0x3,
 872     ipvideo_decode_block_opcode_0x4,    ipvideo_decode_block_opcode_0x5,
 873     ipvideo_decode_block_opcode_0x6_16, ipvideo_decode_block_opcode_0x7_16,
 874     ipvideo_decode_block_opcode_0x8_16, ipvideo_decode_block_opcode_0x9_16,
 875     ipvideo_decode_block_opcode_0xA_16, ipvideo_decode_block_opcode_0xB_16,
 876     ipvideo_decode_block_opcode_0xC_16, ipvideo_decode_block_opcode_0xD_16,
 877     ipvideo_decode_block_opcode_0xE_16, ipvideo_decode_block_opcode_0x1,
 878 };
 879
 880 static void ipvideo_decode_opcodes(IpvideoContext *s)
 881 {
 882     int x, y;
 883     unsigned char opcode;
 884     int ret;
 885     static int frame = 0;
 886     GetBitContext gb;
 887
 888     av_dlog(NULL, "------------------ frame %d\n", frame);
 889     frame++;
 890
 891     bytestream2_skip(&s->stream_ptr, 14); /* data starts 14 bytes in */
 892     if (!s->is_16bpp) {
 893         /* this is PAL8, so make the palette available */
 894         memcpy(s->current_frame.data[1], s->pal, AVPALETTE_SIZE);
 895
 896         s->stride = s->current_frame.linesize[0];
 897     } else {
 898         s->stride = s->current_frame.linesize[0] >> 1;
 899         s->mv_ptr = s->stream_ptr;
 900         bytestream2_skip(&s->mv_ptr, bytestream2_get_le16(&s->stream_ptr));
 901     }
 902     s->line_inc = s->stride - 8;
 903     s->upper_motion_limit_offset = (s->avctx->height - 8) * s->current_frame.linesize[0]
 904                                   + (s->avctx->width - 8) * (1 + s->is_16bpp);
 905
 906     init_get_bits(&gb, s->decoding_map, s->decoding_map_size * 8);
 907     for (y = 0; y < s->avctx->height; y += 8) {
 908         for (x = 0; x < s->avctx->width; x += 8) {
 909             opcode = get_bits(&gb, 4);
 910
 911             av_dlog(s->avctx,
 912                     "  block @ (%3d, %3d): encoding 0x%X, data ptr offset %d\n",
 913                     x, y, opcode, bytestream2_tell(&s->stream_ptr));
 914
 915             if (!s->is_16bpp) {
 916                 s->pixel_ptr = s->current_frame.data[0] + x
 917                               + y*s->current_frame.linesize[0];
 918                 ret = ipvideo_decode_block[opcode](s);
 919             } else {
 920                 s->pixel_ptr = s->current_frame.data[0] + x*2
 921                               + y*s->current_frame.linesize[0];
 922                 ret = ipvideo_decode_block16[opcode](s);
 923             }
 924             if (ret != 0) {
 925                 av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode problem on frame %d, @ block (%d, %d)\n",
 926                        frame, x, y);
 927                 return;
 928             }
 929         }
 930     }
 931     if (bytestream2_get_bytes_left(&s->stream_ptr) > 1) {
 932         av_log(s->avctx, AV_LOG_ERROR,
 933                "Interplay video: decode finished with %d bytes left over\n",
 934                bytestream2_get_bytes_left(&s->stream_ptr));
 935     }
 936 }
 937
 938 static av_cold int ipvideo_decode_init(AVCodecContext *avctx)
 939 {
 940     IpvideoContext *s = avctx->priv_data;
 941
 942     s->avctx = avctx;
 943
 944     s->is_16bpp = avctx->bits_per_coded_sample == 16;
 945     avctx->pix_fmt = s->is_16bpp ? AV_PIX_FMT_RGB555 : AV_PIX_FMT_PAL8;
 946
 947     ff_dsputil_init(&s->dsp, avctx);
 948
 949     s->current_frame.data[0] = s->last_frame.data[0] =
 950     s->second_last_frame.data[0] = NULL;
 951
 952     return 0;
 953 }
 954
 955 static int ipvideo_decode_frame(AVCodecContext *avctx,
 956                                 void *data, int *data_size,
 957                                 AVPacket *avpkt)
 958 {
 959     const uint8_t *buf = avpkt->data;
 960     int buf_size = avpkt->size;
 961     IpvideoContext *s = avctx->priv_data;
 962
 963     /* decoding map contains 4 bits of information per 8x8 block */
 964     s->decoding_map_size = avctx->width * avctx->height / (8 * 8 * 2);
 965
 966     /* compressed buffer needs to be large enough to at least hold an entire
 967      * decoding map */
 968     if (buf_size < s->decoding_map_size)
 969         return buf_size;
 970
 971     s->decoding_map = buf;
 972     bytestream2_init(&s->stream_ptr, buf + s->decoding_map_size,
 973                      buf_size - s->decoding_map_size);
 974
 975     s->current_frame.reference = 3;
 976     if (ff_get_buffer(avctx, &s->current_frame)) {
 977         av_log(avctx, AV_LOG_ERROR, "  Interplay Video: get_buffer() failed\n");
 978         return -1;
 979     }
 980
 981     if (!s->is_16bpp) {
 982         const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
 983         if (pal) {
 984             s->current_frame.palette_has_changed = 1;
 985             memcpy(s->pal, pal, AVPALETTE_SIZE);
 986         }
 987     }
 988
 989     ipvideo_decode_opcodes(s);
 990
 991     *data_size = sizeof(AVFrame);
 992     *(AVFrame*)data = s->current_frame;
 993
 994     /* shuffle frames */
 995     if (s->second_last_frame.data[0])
 996         avctx->release_buffer(avctx, &s->second_last_frame);
 997     s->second_last_frame = s->last_frame;
 998     s->last_frame = s->current_frame;
 999     s->current_frame.data[0] = NULL;  /* catch any access attempts */
1000
1001     /* report that the buffer was completely consumed */
1002     return buf_size;
1003 }
1004
1005 static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
1006 {
1007     IpvideoContext *s = avctx->priv_data;
1008
1009     /* release the last frame */
1010     if (s->last_frame.data[0])
1011         avctx->release_buffer(avctx, &s->last_frame);
1012     if (s->second_last_frame.data[0])
1013         avctx->release_buffer(avctx, &s->second_last_frame);
1014
1015     return 0;
1016 }
1017
1018 AVCodec ff_interplay_video_decoder = {
1019     .name           = "interplayvideo",
1020     .type           = AVMEDIA_TYPE_VIDEO,
1021     .id             = AV_CODEC_ID_INTERPLAY_VIDEO,
1022     .priv_data_size = sizeof(IpvideoContext),
1023     .init           = ipvideo_decode_init,
1024     .close          = ipvideo_decode_end,
1025     .decode         = ipvideo_decode_frame,
1026     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_PARAM_CHANGE,
1027     .long_name      = NULL_IF_CONFIG_SMALL("Interplay MVE video"),
1028 };