interplayvideo.c 28 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21
/*
 * Interplay MVE Video Decoder
 * Copyright (C) 2003 the ffmpeg project
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

/**
22 23
 * @file interplayvideo.c
 * Interplay MVE Video Decoder by Mike Melanson (melanson@pcisys.net)
24
 * For more information about the Interplay MVE format, visit:
25 26 27 28 29 30 31 32 33
 *   http://www.pcisys.net/~melanson/codecs/interplay-mve.txt
 * This code is written in such a way that the identifiers match up
 * with the encoding descriptions in the document.
 *
 * This decoder presently only supports a PAL8 output colorspace.
 *
 * An Interplay video frame consists of 2 parts: The decoding map and
 * the video data. A demuxer must load these 2 parts together in a single
 * buffer before sending it through the stream to this decoder.
34 35 36 37 38 39 40 41 42 43 44
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "common.h"
#include "avcodec.h"
#include "dsputil.h"

45 46 47 48 49
#define PALETTE_COUNT 256

/* debugging support */
#define DEBUG_INTERPLAY 0
#if DEBUG_INTERPLAY
Alex Beregszaszi's avatar
Alex Beregszaszi committed
50
#define debug_interplay(x,...) av_log(NULL, AV_LOG_DEBUG, x, __VA_ARGS__)
51 52 53 54
#else
static inline void debug_interplay(const char *format, ...) { }
#endif

55 56 57 58
typedef struct IpvideoContext {

    AVCodecContext *avctx;
    DSPContext dsp;
59
    AVFrame second_last_frame;
60 61 62 63 64 65 66 67
    AVFrame last_frame;
    AVFrame current_frame;
    unsigned char *decoding_map;
    int decoding_map_size;

    unsigned char *buf;
    int size;

68 69 70 71 72 73 74
    unsigned char *stream_ptr;
    unsigned char *stream_end;
    unsigned char *pixel_ptr;
    int line_inc;
    int stride;
    int upper_motion_limit_offset;

75 76
} IpvideoContext;

77
#define CHECK_STREAM_PTR(n) \
78
  if ((s->stream_ptr + n) > s->stream_end) { \
79
    av_log(s->avctx, AV_LOG_ERROR, "Interplay video warning: stream_ptr out of bounds (%p >= %p)\n", \
80
      s->stream_ptr + n, s->stream_end); \
81 82 83 84 85
    return -1; \
  }

#define COPY_FROM_CURRENT() \
    motion_offset = current_offset; \
86
    motion_offset += y * s->stride; \
87 88
    motion_offset += x; \
    if (motion_offset < 0) { \
89
        av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset); \
90
        return -1; \
91
    } else if (motion_offset > s->upper_motion_limit_offset) { \
92
        av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n", \
93
            motion_offset, s->upper_motion_limit_offset); \
94 95
        return -1; \
    } \
96 97
    s->dsp.put_pixels_tab[0][0](s->pixel_ptr, \
        s->current_frame.data[0] + motion_offset, s->stride, 8);
98 99 100

#define COPY_FROM_PREVIOUS() \
    motion_offset = current_offset; \
101
    motion_offset += y * s->stride; \
102 103
    motion_offset += x; \
    if (motion_offset < 0) { \
104
        av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset); \
105
        return -1; \
106
    } else if (motion_offset > s->upper_motion_limit_offset) { \
107
        av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n", \
108
            motion_offset, s->upper_motion_limit_offset); \
109 110
        return -1; \
    } \
111 112
    s->dsp.put_pixels_tab[0][0](s->pixel_ptr, \
        s->last_frame.data[0] + motion_offset, s->stride, 8);
113

114 115
#define COPY_FROM_SECOND_LAST() \
    motion_offset = current_offset; \
116
    motion_offset += y * s->stride; \
117 118
    motion_offset += x; \
    if (motion_offset < 0) { \
119
        av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset); \
120
        return -1; \
121
    } else if (motion_offset > s->upper_motion_limit_offset) { \
122
        av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n", \
123
            motion_offset, s->upper_motion_limit_offset); \
124 125
        return -1; \
    } \
126 127 128 129 130 131 132 133 134 135 136 137
    s->dsp.put_pixels_tab[0][0](s->pixel_ptr, \
        s->second_last_frame.data[0] + motion_offset, s->stride, 8);

static int ipvideo_decode_block_opcode_0x0(IpvideoContext *s)
{
    int x, y;
    int motion_offset;
    int current_offset = s->pixel_ptr - s->current_frame.data[0];

    /* copy a block from the previous frame */
    x = y = 0;
    COPY_FROM_PREVIOUS();
138

139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
    /* report success */
    return 0;
}

static int ipvideo_decode_block_opcode_0x1(IpvideoContext *s)
{
    int x, y;
    int motion_offset;
    int current_offset = s->pixel_ptr - s->current_frame.data[0];

    /* copy block from 2 frames ago */
    x = y = 0;
    COPY_FROM_SECOND_LAST();

    /* report success */
    return 0;
}

static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s)
158 159 160 161
{
    unsigned char B;
    int x, y;
    int motion_offset;
162
    int current_offset = s->pixel_ptr - s->current_frame.data[0];
163

164
    /* copy block from 2 frames ago using a motion vector; need 1 more byte */
165
    CHECK_STREAM_PTR(1);
166
    B = *s->stream_ptr++;
167 168 169 170 171 172 173 174 175 176

    if (B < 56) {
        x = 8 + (B % 7);
        y = B / 7;
    } else {
        x = -14 + ((B - 56) % 29);
        y =   8 + ((B - 56) / 29);
    }

    debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
177
    COPY_FROM_SECOND_LAST();
178 179 180 181 182

    /* report success */
    return 0;
}

183
static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s)
184 185 186 187
{
    unsigned char B;
    int x, y;
    int motion_offset;
188
    int current_offset = s->pixel_ptr - s->current_frame.data[0];
189 190 191 192 193

    /* copy 8x8 block from current frame from an up/left block */

    /* need 1 more byte for motion */
    CHECK_STREAM_PTR(1);
194
    B = *s->stream_ptr++;
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210

    if (B < 56) {
        x = -(8 + (B % 7));
        y = -(B / 7);
    } else {
        x = -(-14 + ((B - 56) % 29));
        y = -(  8 + ((B - 56) / 29));
    }

    debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
    COPY_FROM_CURRENT();

    /* report success */
    return 0;
}

211
static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s)
212 213 214 215
{
    int x, y;
    unsigned char B, BL, BH;
    int motion_offset;
216
    int current_offset = s->pixel_ptr - s->current_frame.data[0];
217 218 219 220

    /* copy a block from the previous frame; need 1 more byte */
    CHECK_STREAM_PTR(1);

221
    B = *s->stream_ptr++;
222 223 224 225 226 227 228 229 230 231 232 233
    BL = B & 0x0F;
    BH = (B >> 4) & 0x0F;
    x = -8 + BL;
    y = -8 + BH;

    debug_interplay ("    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
    COPY_FROM_PREVIOUS();

    /* report success */
    return 0;
}

234
static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s)
235 236 237
{
    signed char x, y;
    int motion_offset;
238
    int current_offset = s->pixel_ptr - s->current_frame.data[0];
239 240 241 242 243

    /* copy a block from the previous frame using an expanded range;
     * need 2 more bytes */
    CHECK_STREAM_PTR(2);

244 245
    x = *s->stream_ptr++;
    y = *s->stream_ptr++;
246 247 248 249 250 251 252 253

    debug_interplay ("    motion bytes = %d, %d\n", x, y);
    COPY_FROM_PREVIOUS();

    /* report success */
    return 0;
}

254
static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s)
255 256
{
    /* mystery opcode? skip multiple blocks? */
257
    av_log(s->avctx, AV_LOG_ERROR, "  Interplay video: Help! Mystery opcode 0x6 seen\n");
258 259 260 261 262

    /* report success */
    return 0;
}

263
static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)
264 265 266 267 268 269 270 271 272 273
{
    int x, y;
    unsigned char P0, P1;
    unsigned char B[8];
    unsigned int flags;
    int bitmask;

    /* 2-color encoding */
    CHECK_STREAM_PTR(2);

274 275
    P0 = *s->stream_ptr++;
    P1 = *s->stream_ptr++;
276 277 278 279 280 281

    if (P0 <= P1) {

        /* need 8 more bytes from the stream */
        CHECK_STREAM_PTR(8);
        for (y = 0; y < 8; y++)
282
            B[y] = *s->stream_ptr++;
283 284 285

        for (y = 0; y < 8; y++) {
            flags = B[y];
286
            for (x = 0x01; x <= 0x80; x <<= 1) {
287
                if (flags & x)
288
                    *s->pixel_ptr++ = P1;
289
                else
290
                    *s->pixel_ptr++ = P0;
291
            }
292
            s->pixel_ptr += s->line_inc;
293 294 295 296 297 298
        }

    } else {

        /* need 2 more bytes from the stream */
        CHECK_STREAM_PTR(2);
299 300
        B[0] = *s->stream_ptr++;
        B[1] = *s->stream_ptr++;
301

302 303
        flags = (B[1] << 8) | B[0];
        bitmask = 0x0001;
304
        for (y = 0; y < 8; y += 2) {
305
            for (x = 0; x < 8; x += 2, bitmask <<= 1) {
306
                if (flags & bitmask) {
307 308 309 310
                    *(s->pixel_ptr + x) = P1;
                    *(s->pixel_ptr + x + 1) = P1;
                    *(s->pixel_ptr + s->stride + x) = P1;
                    *(s->pixel_ptr + s->stride + x + 1) = P1;
311
                } else {
312 313 314 315
                    *(s->pixel_ptr + x) = P0;
                    *(s->pixel_ptr + x + 1) = P0;
                    *(s->pixel_ptr + s->stride + x) = P0;
                    *(s->pixel_ptr + s->stride + x + 1) = P0;
316 317
                }
            }
318
            s->pixel_ptr += s->stride * 2;
319 320 321 322 323 324 325
        }
    }

    /* report success */
    return 0;
}

326
static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
327 328 329 330 331 332 333 334 335 336 337 338 339
{
    int x, y;
    unsigned char P[8];
    unsigned char B[8];
    unsigned int flags = 0;
    unsigned int bitmask = 0;
    unsigned char P0 = 0, P1 = 0;
    int lower_half = 0;

    /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
     * either top and bottom or left and right halves */
    CHECK_STREAM_PTR(2);

340 341
    P[0] = *s->stream_ptr++;
    P[1] = *s->stream_ptr++;
342 343 344 345 346

    if (P[0] <= P[1]) {

        /* need 12 more bytes */
        CHECK_STREAM_PTR(12);
347 348 349 350 351 352 353
        B[0] = *s->stream_ptr++;  B[1] = *s->stream_ptr++;
        P[2] = *s->stream_ptr++;  P[3] = *s->stream_ptr++;
        B[2] = *s->stream_ptr++;  B[3] = *s->stream_ptr++;
        P[4] = *s->stream_ptr++;  P[5] = *s->stream_ptr++;
        B[4] = *s->stream_ptr++;  B[5] = *s->stream_ptr++;
        P[6] = *s->stream_ptr++;  P[7] = *s->stream_ptr++;
        B[6] = *s->stream_ptr++;  B[7] = *s->stream_ptr++;
354 355 356 357 358 359

        for (y = 0; y < 8; y++) {

            /* time to reload flags? */
            if (y == 0) {
                flags =
360 361 362 363 364
                    ((B[0] & 0xF0) <<  4) | ((B[4] & 0xF0) <<  8) |
                    ((B[0] & 0x0F)      ) | ((B[4] & 0x0F) <<  4) |
                    ((B[1] & 0xF0) << 20) | ((B[5] & 0xF0) << 24) |
                    ((B[1] & 0x0F) << 16) | ((B[5] & 0x0F) << 20);
                bitmask = 0x00000001;
365 366 367
                lower_half = 0;  /* still on top half */
            } else if (y == 4) {
                flags =
368 369 370 371 372
                    ((B[2] & 0xF0) <<  4) | ((B[6] & 0xF0) <<  8) |
                    ((B[2] & 0x0F)      ) | ((B[6] & 0x0F) <<  4) |
                    ((B[3] & 0xF0) << 20) | ((B[7] & 0xF0) << 24) |
                    ((B[3] & 0x0F) << 16) | ((B[7] & 0x0F) << 20);
                bitmask = 0x00000001;
373
                lower_half = 2;
374 375
            }

376
            for (x = 0; x < 8; x++, bitmask <<= 1) {
377 378 379 380 381
                /* get the pixel values ready for this quadrant */
                if (x == 0) {
                    P0 = P[lower_half + 0];
                    P1 = P[lower_half + 1];
                } else if (x == 4) {
382 383
                    P0 = P[lower_half + 4];
                    P1 = P[lower_half + 5];
384 385 386
                }

                if (flags & bitmask)
387
                    *s->pixel_ptr++ = P1;
388
                else
389
                    *s->pixel_ptr++ = P0;
390
            }
391
            s->pixel_ptr += s->line_inc;
392 393 394 395 396 397
        }

    } else {

        /* need 10 more bytes */
        CHECK_STREAM_PTR(10);
398 399 400 401 402
        B[0] = *s->stream_ptr++;  B[1] = *s->stream_ptr++;
        B[2] = *s->stream_ptr++;  B[3] = *s->stream_ptr++;
        P[2] = *s->stream_ptr++;  P[3] = *s->stream_ptr++;
        B[4] = *s->stream_ptr++;  B[5] = *s->stream_ptr++;
        B[6] = *s->stream_ptr++;  B[7] = *s->stream_ptr++;
403 404 405 406 407 408 409 410 411 412

        if (P[2] <= P[3]) {

            /* vertical split; left & right halves are 2-color encoded */

            for (y = 0; y < 8; y++) {

                /* time to reload flags? */
                if (y == 0) {
                    flags =
413 414 415 416 417
                        ((B[0] & 0xF0) <<  4) | ((B[4] & 0xF0) <<  8) |
                        ((B[0] & 0x0F)      ) | ((B[4] & 0x0F) <<  4) |
                        ((B[1] & 0xF0) << 20) | ((B[5] & 0xF0) << 24) |
                        ((B[1] & 0x0F) << 16) | ((B[5] & 0x0F) << 20);
                    bitmask = 0x00000001;
418 419
                } else if (y == 4) {
                    flags =
420 421 422 423 424
                        ((B[2] & 0xF0) <<  4) | ((B[6] & 0xF0) <<  8) |
                        ((B[2] & 0x0F)      ) | ((B[6] & 0x0F) <<  4) |
                        ((B[3] & 0xF0) << 20) | ((B[7] & 0xF0) << 24) |
                        ((B[3] & 0x0F) << 16) | ((B[7] & 0x0F) << 20);
                    bitmask = 0x00000001;
425 426
                }

427
                for (x = 0; x < 8; x++, bitmask <<= 1) {
428 429 430 431 432 433 434 435 436 437
                    /* get the pixel values ready for this half */
                    if (x == 0) {
                        P0 = P[0];
                        P1 = P[1];
                    } else if (x == 4) {
                        P0 = P[2];
                        P1 = P[3];
                    }

                    if (flags & bitmask)
438
                        *s->pixel_ptr++ = P1;
439
                    else
440
                        *s->pixel_ptr++ = P0;
441
                }
442
                s->pixel_ptr += s->line_inc;
443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
            }

        } else {

            /* horizontal split; top & bottom halves are 2-color encoded */

            for (y = 0; y < 8; y++) {

                flags = B[y];
                if (y == 0) {
                    P0 = P[0];
                    P1 = P[1];
                } else if (y == 4) {
                    P0 = P[2];
                    P1 = P[3];
                }

460
                for (bitmask = 0x01; bitmask <= 0x80; bitmask <<= 1) {
461 462

                    if (flags & bitmask)
463
                        *s->pixel_ptr++ = P1;
464
                    else
465
                        *s->pixel_ptr++ = P0;
466
                }
467
                s->pixel_ptr += s->line_inc;
468 469 470 471 472 473 474 475
            }
        }
    }

    /* report success */
    return 0;
}

476
static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
477 478 479
{
    int x, y;
    unsigned char P[4];
480
    unsigned char B[4];
481 482 483 484 485 486 487 488
    unsigned int flags = 0;
    int shifter = 0;
    unsigned char pix;

    /* 4-color encoding */
    CHECK_STREAM_PTR(4);

    for (y = 0; y < 4; y++)
489
        P[y] = *s->stream_ptr++;
490 491 492 493 494 495 496 497

    if ((P[0] <= P[1]) && (P[2] <= P[3])) {

        /* 1 of 4 colors for each pixel, need 16 more bytes */
        CHECK_STREAM_PTR(16);

        for (y = 0; y < 8; y++) {
            /* get the next set of 8 2-bit flags */
498 499
            flags = (s->stream_ptr[1] << 8) | s->stream_ptr[0];
            s->stream_ptr += 2;
500
            for (x = 0, shifter = 0; x < 8; x++, shifter += 2) {
501
                *s->pixel_ptr++ = P[(flags >> shifter) & 0x03];
502
            }
503
            s->pixel_ptr += s->line_inc;
504 505 506 507 508 509 510
        }

    } else if ((P[0] <= P[1]) && (P[2] > P[3])) {

        /* 1 of 4 colors for each 2x2 block, need 4 more bytes */
        CHECK_STREAM_PTR(4);

511 512 513 514
        B[0] = *s->stream_ptr++;
        B[1] = *s->stream_ptr++;
        B[2] = *s->stream_ptr++;
        B[3] = *s->stream_ptr++;
515 516
        flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0];
        shifter = 0;
517 518

        for (y = 0; y < 8; y += 2) {
519
            for (x = 0; x < 8; x += 2, shifter += 2) {
520
                pix = P[(flags >> shifter) & 0x03];
521 522 523 524
                *(s->pixel_ptr + x) = pix;
                *(s->pixel_ptr + x + 1) = pix;
                *(s->pixel_ptr + s->stride + x) = pix;
                *(s->pixel_ptr + s->stride + x + 1) = pix;
525
            }
526
            s->pixel_ptr += s->stride * 2;
527 528 529 530 531 532 533 534 535 536
        }

    } else if ((P[0] > P[1]) && (P[2] <= P[3])) {

        /* 1 of 4 colors for each 2x1 block, need 8 more bytes */
        CHECK_STREAM_PTR(8);

        for (y = 0; y < 8; y++) {
            /* time to reload flags? */
            if ((y == 0) || (y == 4)) {
537 538 539 540
                B[0] = *s->stream_ptr++;
                B[1] = *s->stream_ptr++;
                B[2] = *s->stream_ptr++;
                B[3] = *s->stream_ptr++;
541 542
                flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0];
                shifter = 0;
543
            }
544
            for (x = 0; x < 8; x += 2, shifter += 2) {
545
                pix = P[(flags >> shifter) & 0x03];
546 547
                *(s->pixel_ptr + x) = pix;
                *(s->pixel_ptr + x + 1) = pix;
548
            }
549
            s->pixel_ptr += s->stride;
550 551 552 553 554 555 556 557 558 559
        }

    } else {

        /* 1 of 4 colors for each 1x2 block, need 8 more bytes */
        CHECK_STREAM_PTR(8);

        for (y = 0; y < 8; y += 2) {
            /* time to reload flags? */
            if ((y == 0) || (y == 4)) {
560 561 562 563
                B[0] = *s->stream_ptr++;
                B[1] = *s->stream_ptr++;
                B[2] = *s->stream_ptr++;
                B[3] = *s->stream_ptr++;
564 565
                flags = (B[3] << 24) | (B[2] << 16) | (B[1] << 8) | B[0];
                shifter = 0;
566
            }
567
            for (x = 0; x < 8; x++, shifter += 2) {
568
                pix = P[(flags >> shifter) & 0x03];
569 570
                *(s->pixel_ptr + x) = pix;
                *(s->pixel_ptr + s->stride + x) = pix;
571
            }
572
            s->pixel_ptr += s->stride * 2;
573 574 575 576 577 578 579
        }
    }

    /* report success */
    return 0;
}

580
static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)
581 582 583 584 585 586 587 588 589 590 591 592 593 594 595
{
    int x, y;
    unsigned char P[16];
    unsigned char B[16];
    int flags = 0;
    int shifter = 0;
    int index;
    int split;
    int lower_half;

    /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
     * either top and bottom or left and right halves */
    CHECK_STREAM_PTR(4);

    for (y = 0; y < 4; y++)
596
        P[y] = *s->stream_ptr++;
597 598 599 600 601 602 603

    if (P[0] <= P[1]) {

        /* 4-color encoding for each quadrant; need 28 more bytes */
        CHECK_STREAM_PTR(28);

        for (y = 0; y < 4; y++)
604
            B[y] = *s->stream_ptr++;
605 606
        for (y = 4; y < 16; y += 4) {
            for (x = y; x < y + 4; x++)
607
                P[x] = *s->stream_ptr++;
608
            for (x = y; x < y + 4; x++)
609
                B[x] = *s->stream_ptr++;
610 611 612 613 614
        }

        for (y = 0; y < 8; y++) {

            lower_half = (y >= 4) ? 4 : 0;
615
            flags = (B[y + 8] << 8) | B[y];
616

617
            for (x = 0, shifter = 0; x < 8; x++, shifter += 2) {
618 619
                split = (x >= 4) ? 8 : 0;
                index = split + lower_half + ((flags >> shifter) & 0x03);
620
                *s->pixel_ptr++ = P[index];
621 622
            }

623
            s->pixel_ptr += s->line_inc;
624 625 626 627 628 629 630 631 632
        }

    } else {

        /* 4-color encoding for either left and right or top and bottom
         * halves; need 20 more bytes */
        CHECK_STREAM_PTR(20);

        for (y = 0; y < 8; y++)
633
            B[y] = *s->stream_ptr++;
634
        for (y = 4; y < 8; y++)
635
            P[y] = *s->stream_ptr++;
636
        for (y = 8; y < 16; y++)
637
            B[y] = *s->stream_ptr++;
638 639 640 641 642 643

        if (P[4] <= P[5]) {

            /* block is divided into left and right halves */
            for (y = 0; y < 8; y++) {

644
                flags = (B[y + 8] << 8) | B[y];
645 646
                split = 0;

647
                for (x = 0, shifter = 0; x < 8; x++, shifter += 2) {
648 649
                    if (x == 4)
                        split = 4;
650
                    *s->pixel_ptr++ = P[split + ((flags >> shifter) & 0x03)];
651 652
                }

653
                s->pixel_ptr += s->line_inc;
654 655 656 657 658 659 660 661
            }

        } else {

            /* block is divided into top and bottom halves */
            split = 0;
            for (y = 0; y < 8; y++) {

662
                flags = (B[y * 2 + 1] << 8) | B[y * 2];
663 664 665
                if (y == 4)
                    split = 4;

666
                for (x = 0, shifter = 0; x < 8; x++, shifter += 2)
667
                    *s->pixel_ptr++ = P[split + ((flags >> shifter) & 0x03)];
668

669
                s->pixel_ptr += s->line_inc;
670 671 672 673 674 675 676 677
            }
        }
    }

    /* report success */
    return 0;
}

678
static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s)
679 680 681 682 683 684 685 686
{
    int x, y;

    /* 64-color encoding (each pixel in block is a different color) */
    CHECK_STREAM_PTR(64);

    for (y = 0; y < 8; y++) {
        for (x = 0; x < 8; x++) {
687
            *s->pixel_ptr++ = *s->stream_ptr++;
688
        }
689
        s->pixel_ptr += s->line_inc;
690 691 692 693 694 695
    }

    /* report success */
    return 0;
}

696
static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s)
697 698 699 700 701 702 703 704 705
{
    int x, y;
    unsigned char pix;

    /* 16-color block encoding: each 2x2 block is a different color */
    CHECK_STREAM_PTR(16);

    for (y = 0; y < 8; y += 2) {
        for (x = 0; x < 8; x += 2) {
706 707 708 709 710
            pix = *s->stream_ptr++;
            *(s->pixel_ptr + x) = pix;
            *(s->pixel_ptr + x + 1) = pix;
            *(s->pixel_ptr + s->stride + x) = pix;
            *(s->pixel_ptr + s->stride + x + 1) = pix;
711
        }
712
        s->pixel_ptr += s->stride * 2;
713 714 715 716 717 718
    }

    /* report success */
    return 0;
}

719
static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s)
720 721 722 723 724 725 726 727 728
{
    int x, y;
    unsigned char P[4];
    unsigned char index = 0;

    /* 4-color block encoding: each 4x4 block is a different color */
    CHECK_STREAM_PTR(4);

    for (y = 0; y < 4; y++)
729
        P[y] = *s->stream_ptr++;
730 731 732 733 734 735 736 737 738 739

    for (y = 0; y < 8; y++) {
        if (y < 4)
            index = 0;
        else
            index = 2;

        for (x = 0; x < 8; x++) {
            if (x == 4)
                index++;
740
            *s->pixel_ptr++ = P[index];
741
        }
742
        s->pixel_ptr += s->line_inc;
743 744 745 746 747 748
    }

    /* report success */
    return 0;
}

749
static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s)
750 751 752 753 754 755
{
    int x, y;
    unsigned char pix;

    /* 1-color encoding: the whole block is 1 solid color */
    CHECK_STREAM_PTR(1);
756
    pix = *s->stream_ptr++;
757 758 759

    for (y = 0; y < 8; y++) {
        for (x = 0; x < 8; x++) {
760
            *s->pixel_ptr++ = pix;
761
        }
762
        s->pixel_ptr += s->line_inc;
763 764 765 766 767 768
    }

    /* report success */
    return 0;
}

769
static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s)
770 771 772 773 774 775
{
    int x, y;
    unsigned char sample0, sample1;

    /* dithered encoding */
    CHECK_STREAM_PTR(2);
776 777
    sample0 = *s->stream_ptr++;
    sample1 = *s->stream_ptr++;
778 779 780 781

    for (y = 0; y < 8; y++) {
        for (x = 0; x < 8; x += 2) {
            if (y & 1) {
782 783
                *s->pixel_ptr++ = sample1;
                *s->pixel_ptr++ = sample0;
784
            } else {
785 786
                *s->pixel_ptr++ = sample0;
                *s->pixel_ptr++ = sample1;
787 788
            }
        }
789
        s->pixel_ptr += s->line_inc;
790 791 792 793 794 795
    }

    /* report success */
    return 0;
}

796
static int (*ipvideo_decode_block[16])(IpvideoContext *s);
797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813

static void ipvideo_decode_opcodes(IpvideoContext *s)
{
    int x, y;
    int index = 0;
    unsigned char opcode;
    int ret;
    int code_counts[16];
    static int frame = 0;

    debug_interplay("------------------ frame %d\n", frame);
    frame++;

    for (x = 0; x < 16; x++)
        code_counts[x] = 0;

    /* this is PAL8, so make the palette available */
814
    memcpy(s->current_frame.data[1], s->avctx->palctrl->palette, PALETTE_COUNT * 4);
815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840

    s->stride = s->current_frame.linesize[0];
    s->stream_ptr = s->buf + 14;  /* data starts 14 bytes in */
    s->stream_end = s->buf + s->size;
    s->line_inc = s->stride - 8;
    s->upper_motion_limit_offset = (s->avctx->height - 8) * s->stride
        + s->avctx->width - 8;
    s->dsp = s->dsp;

    for (y = 0; y < (s->stride * s->avctx->height); y += s->stride * 8) {
        for (x = y; x < y + s->avctx->width; x += 8) {
            /* bottom nibble first, then top nibble (which makes it
             * hard to use a GetBitcontext) */
            if (index & 1)
                opcode = s->decoding_map[index >> 1] >> 4;
            else
                opcode = s->decoding_map[index >> 1] & 0xF;
            index++;

            debug_interplay("  block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",
                x - y, y / s->stride, opcode, s->stream_ptr);
            code_counts[opcode]++;

            s->pixel_ptr = s->current_frame.data[0] + x;
            ret = ipvideo_decode_block[opcode](s);
            if (ret != 0) {
841
                av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode problem on frame %d, @ block (%d, %d)\n",
842 843
                    frame, x - y, y / s->stride);
                return;
844 845 846
            }
        }
    }
847 848
    if ((s->stream_ptr != s->stream_end) &&
        (s->stream_ptr + 1 != s->stream_end)) {
Alex Beregszaszi's avatar
Alex Beregszaszi committed
849
        av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode finished with %d bytes left over\n",
850 851
            s->stream_end - s->stream_ptr);
    }
852 853
}

854 855 856 857 858
static int ipvideo_decode_init(AVCodecContext *avctx)
{
    IpvideoContext *s = avctx->priv_data;

    s->avctx = avctx;
859

860
    if (s->avctx->palctrl == NULL) {
861
        av_log(avctx, AV_LOG_ERROR, " Interplay video: palette expected.\n");
862 863 864 865
        return -1;
    }

    avctx->pix_fmt = PIX_FMT_PAL8;
866 867 868 869 870
    avctx->has_b_frames = 0;
    dsputil_init(&s->dsp, avctx);

    /* decoding map contains 4 bits of information per 8x8 block */
    s->decoding_map_size = avctx->width * avctx->height / (8 * 8 * 2);
871 872

    /* assign block decode functions */
873 874
    ipvideo_decode_block[0x0] = ipvideo_decode_block_opcode_0x0;
    ipvideo_decode_block[0x1] = ipvideo_decode_block_opcode_0x1;
875 876 877 878 879 880 881 882 883 884 885 886 887 888
    ipvideo_decode_block[0x2] = ipvideo_decode_block_opcode_0x2;
    ipvideo_decode_block[0x3] = ipvideo_decode_block_opcode_0x3;
    ipvideo_decode_block[0x4] = ipvideo_decode_block_opcode_0x4;
    ipvideo_decode_block[0x5] = ipvideo_decode_block_opcode_0x5;
    ipvideo_decode_block[0x6] = ipvideo_decode_block_opcode_0x6;
    ipvideo_decode_block[0x7] = ipvideo_decode_block_opcode_0x7;
    ipvideo_decode_block[0x8] = ipvideo_decode_block_opcode_0x8;
    ipvideo_decode_block[0x9] = ipvideo_decode_block_opcode_0x9;
    ipvideo_decode_block[0xA] = ipvideo_decode_block_opcode_0xA;
    ipvideo_decode_block[0xB] = ipvideo_decode_block_opcode_0xB;
    ipvideo_decode_block[0xC] = ipvideo_decode_block_opcode_0xC;
    ipvideo_decode_block[0xD] = ipvideo_decode_block_opcode_0xD;
    ipvideo_decode_block[0xE] = ipvideo_decode_block_opcode_0xE;
    ipvideo_decode_block[0xF] = ipvideo_decode_block_opcode_0xF;
889

890 891 892
    s->current_frame.data[0] = s->last_frame.data[0] =
    s->second_last_frame.data[0] = NULL;

893 894 895 896 897 898 899 900
    return 0;
}

static int ipvideo_decode_frame(AVCodecContext *avctx,
                                void *data, int *data_size,
                                uint8_t *buf, int buf_size)
{
    IpvideoContext *s = avctx->priv_data;
901
    AVPaletteControl *palette_control = avctx->palctrl;
902

903 904 905 906 907
    /* compressed buffer needs to be large enough to at least hold an entire
     * decoding map */
    if (buf_size < s->decoding_map_size)
        return buf_size;

908 909 910
    s->decoding_map = buf;
    s->buf = buf + s->decoding_map_size;
    s->size = buf_size - s->decoding_map_size;
911

912
    s->current_frame.reference = 3;
913
    if (avctx->get_buffer(avctx, &s->current_frame)) {
914
        av_log(avctx, AV_LOG_ERROR, "  Interplay Video: get_buffer() failed\n");
915 916
        return -1;
    }
917

918
    ipvideo_decode_opcodes(s);
919

920 921 922 923 924
    if (palette_control->palette_changed) {
        palette_control->palette_changed = 0;
        s->current_frame.palette_has_changed = 1;
    }

925 926
    *data_size = sizeof(AVFrame);
    *(AVFrame*)data = s->current_frame;
927

928
    /* shuffle frames */
929 930 931
    if (s->second_last_frame.data[0])
        avctx->release_buffer(avctx, &s->second_last_frame);
    s->second_last_frame = s->last_frame;
932
    s->last_frame = s->current_frame;
933
    s->current_frame.data[0] = NULL;  /* catch any access attempts */
934

935
    /* report that the buffer was completely consumed */
936 937 938 939 940 941 942 943
    return buf_size;
}

static int ipvideo_decode_end(AVCodecContext *avctx)
{
    IpvideoContext *s = avctx->priv_data;

    /* release the last frame */
944 945 946 947
    if (s->last_frame.data[0])
        avctx->release_buffer(avctx, &s->last_frame);
    if (s->second_last_frame.data[0])
        avctx->release_buffer(avctx, &s->second_last_frame);
948 949 950 951 952 953 954 955 956 957 958 959 960 961 962

    return 0;
}

AVCodec interplay_video_decoder = {
    "interplayvideo",
    CODEC_TYPE_VIDEO,
    CODEC_ID_INTERPLAY_VIDEO,
    sizeof(IpvideoContext),
    ipvideo_decode_init,
    NULL,
    ipvideo_decode_end,
    ipvideo_decode_frame,
    CODEC_CAP_DR1,
};