interplayvideo.c 32.6 KB
Newer Older
1 2 3 4
/*
 * Interplay MVE Video Decoder
 * Copyright (C) 2003 the ffmpeg project
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * 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 14 15 16 17
 * 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
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
24
 * Interplay MVE Video Decoder by Mike Melanson (melanson@pcisys.net)
25
 * For more information about the Interplay MVE format, visit:
26 27 28 29 30 31 32 33 34
 *   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.
35 36 37 38 39 40 41
 */

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

#include "avcodec.h"
42
#include "bytestream.h"
43
#include "dsputil.h"
44 45
#define ALT_BITSTREAM_READER_LE
#include "get_bits.h"
46

47 48
#define PALETTE_COUNT 256

49 50 51 52
typedef struct IpvideoContext {

    AVCodecContext *avctx;
    DSPContext dsp;
53
    AVFrame second_last_frame;
54 55
    AVFrame last_frame;
    AVFrame current_frame;
Michael Niedermayer's avatar
Michael Niedermayer committed
56
    const unsigned char *decoding_map;
57 58
    int decoding_map_size;

Michael Niedermayer's avatar
Michael Niedermayer committed
59
    const unsigned char *buf;
60 61
    int size;

62
    int is_16bpp;
Michael Niedermayer's avatar
Michael Niedermayer committed
63 64
    const unsigned char *stream_ptr;
    const unsigned char *stream_end;
65 66
    const uint8_t *mv_ptr;
    const uint8_t *mv_end;
67 68 69 70 71
    unsigned char *pixel_ptr;
    int line_inc;
    int stride;
    int upper_motion_limit_offset;

72
    uint32_t pal[256];
73 74
} IpvideoContext;

75 76
#define CHECK_STREAM_PTR(stream_ptr, stream_end, n) \
    if (stream_end - stream_ptr < n) { \
Kostya Shishkov's avatar
Kostya Shishkov committed
77
        av_log(s->avctx, AV_LOG_ERROR, "Interplay video warning: stream_ptr out of bounds (%p >= %p)\n", \
78
               stream_ptr + n, stream_end); \
Kostya Shishkov's avatar
Kostya Shishkov committed
79 80
        return -1; \
    }
81

82
static int copy_from(IpvideoContext *s, AVFrame *src, int delta_x, int delta_y)
83 84
{
    int current_offset = s->pixel_ptr - s->current_frame.data[0];
85 86
    int motion_offset = current_offset + delta_y * s->current_frame.linesize[0]
                       + delta_x * (1 + s->is_16bpp);
87 88 89 90 91 92 93 94
    if (motion_offset < 0) {
        av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset < 0 (%d)\n", motion_offset);
        return -1;
    } else if (motion_offset > s->upper_motion_limit_offset) {
        av_log(s->avctx, AV_LOG_ERROR, " Interplay video: motion offset above limit (%d >= %d)\n",
            motion_offset, s->upper_motion_limit_offset);
        return -1;
    }
95 96 97 98
    if (src->data[0] == NULL) {
        av_log(s->avctx, AV_LOG_ERROR, "Invalid decode type, corrupted header?\n");
        return AVERROR(EINVAL);
    }
99 100
    s->dsp.put_pixels_tab[!s->is_16bpp][0](s->pixel_ptr, src->data[0] + motion_offset,
                                           s->current_frame.linesize[0], 8);
101 102 103
    return 0;
}

104
static int ipvideo_decode_block_opcode_0x0(IpvideoContext *s)
105
{
106 107
    return copy_from(s, &s->last_frame, 0, 0);
}
108

109 110 111
static int ipvideo_decode_block_opcode_0x1(IpvideoContext *s)
{
    return copy_from(s, &s->second_last_frame, 0, 0);
112 113 114
}

static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s)
115 116 117 118
{
    unsigned char B;
    int x, y;

119
    /* copy block from 2 frames ago using a motion vector; need 1 more byte */
120 121 122 123 124 125 126
    if (!s->is_16bpp) {
        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
        B = *s->stream_ptr++;
    } else {
        CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);
        B = *s->mv_ptr++;
    }
127 128 129 130 131 132 133 134 135

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

136
    av_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
137
    return copy_from(s, &s->second_last_frame, x, y);
138 139
}

140
static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s)
141 142 143 144 145 146 147
{
    unsigned char B;
    int x, y;

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

    /* need 1 more byte for motion */
148 149 150 151 152 153 154
    if (!s->is_16bpp) {
        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
        B = *s->stream_ptr++;
    } else {
        CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);
        B = *s->mv_ptr++;
    }
155 156 157 158 159 160 161 162 163

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

164
    av_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
165
    return copy_from(s, &s->current_frame, x, y);
166 167
}

168
static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s)
169 170 171 172 173
{
    int x, y;
    unsigned char B, BL, BH;

    /* copy a block from the previous frame; need 1 more byte */
174 175 176 177 178 179 180
    if (!s->is_16bpp) {
        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
        B = *s->stream_ptr++;
    } else {
        CHECK_STREAM_PTR(s->mv_ptr, s->mv_end, 1);
        B = *s->mv_ptr++;
    }
181 182 183 184 185 186

    BL = B & 0x0F;
    BH = (B >> 4) & 0x0F;
    x = -8 + BL;
    y = -8 + BH;

187
    av_dlog(NULL, "    motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
188
    return copy_from(s, &s->last_frame, x, y);
189 190
}

191
static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s)
192 193 194 195 196
{
    signed char x, y;

    /* copy a block from the previous frame using an expanded range;
     * need 2 more bytes */
197
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
198

199 200
    x = *s->stream_ptr++;
    y = *s->stream_ptr++;
201

202
    av_dlog(NULL, "    motion bytes = %d, %d\n", x, y);
203
    return copy_from(s, &s->last_frame, x, y);
204 205
}

206
static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s)
207 208
{
    /* mystery opcode? skip multiple blocks? */
209
    av_log(s->avctx, AV_LOG_ERROR, "  Interplay video: Help! Mystery opcode 0x6 seen\n");
210 211 212 213 214

    /* report success */
    return 0;
}

215
static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s)
216 217
{
    int x, y;
218
    unsigned char P[2];
219 220 221
    unsigned int flags;

    /* 2-color encoding */
222
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
223

224 225
    P[0] = *s->stream_ptr++;
    P[1] = *s->stream_ptr++;
226

227
    if (P[0] <= P[1]) {
228 229

        /* need 8 more bytes from the stream */
230
        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
231 232

        for (y = 0; y < 8; y++) {
233
            flags = *s->stream_ptr++ | 0x100;
234
            for (; flags != 1; flags >>= 1)
235
                *s->pixel_ptr++ = P[flags & 1];
236
            s->pixel_ptr += s->line_inc;
237 238 239 240 241
        }

    } else {

        /* need 2 more bytes from the stream */
242
        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
243

244
        flags = bytestream_get_le16(&s->stream_ptr);
245
        for (y = 0; y < 8; y += 2) {
246
            for (x = 0; x < 8; x += 2, flags >>= 1) {
Reimar Döffinger's avatar
Reimar Döffinger committed
247 248 249 250
                s->pixel_ptr[x                ] =
                s->pixel_ptr[x + 1            ] =
                s->pixel_ptr[x +     s->stride] =
                s->pixel_ptr[x + 1 + s->stride] = P[flags & 1];
251
            }
252
            s->pixel_ptr += s->stride * 2;
253 254 255 256 257 258 259
        }
    }

    /* report success */
    return 0;
}

260
static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s)
261 262
{
    int x, y;
263
    unsigned char P[2];
264 265 266 267
    unsigned int flags = 0;

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

270 271
    P[0] = *s->stream_ptr++;
    P[1] = *s->stream_ptr++;
272 273 274

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

275
        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 14);
276
        s->stream_ptr -= 2;
277

278 279 280 281 282
        for (y = 0; y < 16; y++) {
            // new values for each 4x4 block
            if (!(y & 3)) {
                P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
                flags = bytestream_get_le16(&s->stream_ptr);
283 284
            }

285
            for (x = 0; x < 4; x++, flags >>= 1)
286 287 288 289
                *s->pixel_ptr++ = P[flags & 1];
            s->pixel_ptr += s->stride - 4;
            // switch to right half
            if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
290 291 292 293 294
        }

    } else {

        /* need 10 more bytes */
295
        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 10);
296

297
        if (s->stream_ptr[4] <= s->stream_ptr[5]) {
298

299
            flags = bytestream_get_le32(&s->stream_ptr);
300

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

303
            for (y = 0; y < 16; y++) {
304
                for (x = 0; x < 4; x++, flags >>= 1)
305 306 307 308 309 310 311
                    *s->pixel_ptr++ = P[flags & 1];
                s->pixel_ptr += s->stride - 4;
                // switch to right half
                if (y == 7) {
                    s->pixel_ptr -= 8 * s->stride - 4;
                    P[0] = *s->stream_ptr++; P[1] = *s->stream_ptr++;
                    flags = bytestream_get_le32(&s->stream_ptr);
312 313 314 315 316 317 318 319
                }
            }

        } else {

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

            for (y = 0; y < 8; y++) {
320 321 322
                if (y == 4) {
                    P[0] = *s->stream_ptr++;
                    P[1] = *s->stream_ptr++;
323
                }
324
                flags = *s->stream_ptr++ | 0x100;
325

326
                for (; flags != 1; flags >>= 1)
327
                    *s->pixel_ptr++ = P[flags & 1];
328
                s->pixel_ptr += s->line_inc;
329 330 331 332 333 334 335 336
            }
        }
    }

    /* report success */
    return 0;
}

337
static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s)
338 339 340 341 342
{
    int x, y;
    unsigned char P[4];

    /* 4-color encoding */
343
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
344

345 346
    memcpy(P, s->stream_ptr, 4);
    s->stream_ptr += 4;
347

348 349
    if (P[0] <= P[1]) {
        if (P[2] <= P[3]) {
350

Reimar Döffinger's avatar
Reimar Döffinger committed
351
            /* 1 of 4 colors for each pixel, need 16 more bytes */
352
            CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);
353

Reimar Döffinger's avatar
Reimar Döffinger committed
354 355 356
            for (y = 0; y < 8; y++) {
                /* get the next set of 8 2-bit flags */
                int flags = bytestream_get_le16(&s->stream_ptr);
357
                for (x = 0; x < 8; x++, flags >>= 2)
Reimar Döffinger's avatar
Reimar Döffinger committed
358 359
                    *s->pixel_ptr++ = P[flags & 0x03];
                s->pixel_ptr += s->line_inc;
360 361
            }

362
        } else {
Reimar Döffinger's avatar
Reimar Döffinger committed
363
            uint32_t flags;
364

Reimar Döffinger's avatar
Reimar Döffinger committed
365
            /* 1 of 4 colors for each 2x2 block, need 4 more bytes */
366
            CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
367

Reimar Döffinger's avatar
Reimar Döffinger committed
368
            flags = bytestream_get_le32(&s->stream_ptr);
369

Reimar Döffinger's avatar
Reimar Döffinger committed
370 371 372 373 374 375 376 377
            for (y = 0; y < 8; y += 2) {
                for (x = 0; x < 8; x += 2, flags >>= 2) {
                    s->pixel_ptr[x                ] =
                    s->pixel_ptr[x + 1            ] =
                    s->pixel_ptr[x +     s->stride] =
                    s->pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];
                }
                s->pixel_ptr += s->stride * 2;
378 379
            }

380 381
        }
    } else {
382
        uint64_t flags;
383

384
        /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */
385
        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);
386

387
        flags = bytestream_get_le64(&s->stream_ptr);
388
        if (P[2] <= P[3]) {
Reimar Döffinger's avatar
Reimar Döffinger committed
389 390 391 392 393 394
            for (y = 0; y < 8; y++) {
                for (x = 0; x < 8; x += 2, flags >>= 2) {
                    s->pixel_ptr[x    ] =
                    s->pixel_ptr[x + 1] = P[flags & 0x03];
                }
                s->pixel_ptr += s->stride;
395
            }
396
        } else {
Reimar Döffinger's avatar
Reimar Döffinger committed
397 398 399 400 401 402
            for (y = 0; y < 8; y += 2) {
                for (x = 0; x < 8; x++, flags >>= 2) {
                    s->pixel_ptr[x            ] =
                    s->pixel_ptr[x + s->stride] = P[flags & 0x03];
                }
                s->pixel_ptr += s->stride * 2;
403
            }
404
        }
405 406 407 408 409 410
    }

    /* report success */
    return 0;
}

411
static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s)
412 413
{
    int x, y;
414
    unsigned char P[4];
415 416 417 418
    int flags = 0;

    /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
     * either top and bottom or left and right halves */
419
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24);
420

421
    if (s->stream_ptr[0] <= s->stream_ptr[1]) {
422

423
        /* 4-color encoding for each quadrant; need 32 bytes */
424
        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 32);
425

426 427 428 429 430 431 432
        for (y = 0; y < 16; y++) {
            // new values for each 4x4 block
            if (!(y & 3)) {
                memcpy(P, s->stream_ptr, 4);
                s->stream_ptr += 4;
                flags = bytestream_get_le32(&s->stream_ptr);
            }
433

434
            for (x = 0; x < 4; x++, flags >>= 2)
435
                *s->pixel_ptr++ = P[flags & 0x03];
436

437 438 439
            s->pixel_ptr += s->stride - 4;
            // switch to right half
            if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
440 441 442
        }

    } else {
443 444 445
        // vertical split?
        int vert = s->stream_ptr[12] <= s->stream_ptr[13];
        uint64_t flags = 0;
446 447

        /* 4-color encoding for either left and right or top and bottom
448
         * halves */
449

450 451 452 453 454 455
        for (y = 0; y < 16; y++) {
            // load values for each half
            if (!(y & 7)) {
                memcpy(P, s->stream_ptr, 4);
                s->stream_ptr += 4;
                flags = bytestream_get_le64(&s->stream_ptr);
456 457
            }

458 459
            for (x = 0; x < 4; x++, flags >>= 2)
                *s->pixel_ptr++ = P[flags & 0x03];
460

461 462 463 464 465
            if (vert) {
                s->pixel_ptr += s->stride - 4;
                // switch to right half
                if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
            } else if (y & 1) s->pixel_ptr += s->line_inc;
466 467 468 469 470 471 472
        }
    }

    /* report success */
    return 0;
}

473
static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s)
474
{
475
    int y;
476 477

    /* 64-color encoding (each pixel in block is a different color) */
478
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 64);
479 480

    for (y = 0; y < 8; y++) {
481 482 483
        memcpy(s->pixel_ptr, s->stream_ptr, 8);
        s->stream_ptr += 8;
        s->pixel_ptr  += s->stride;
484 485 486 487 488 489
    }

    /* report success */
    return 0;
}

490
static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s)
491 492 493 494
{
    int x, y;

    /* 16-color block encoding: each 2x2 block is a different color */
495
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);
496 497 498

    for (y = 0; y < 8; y += 2) {
        for (x = 0; x < 8; x += 2) {
499 500 501
            s->pixel_ptr[x                ] =
            s->pixel_ptr[x + 1            ] =
            s->pixel_ptr[x +     s->stride] =
502
            s->pixel_ptr[x + 1 + s->stride] = *s->stream_ptr++;
503
        }
504
        s->pixel_ptr += s->stride * 2;
505 506 507 508 509 510
    }

    /* report success */
    return 0;
}

511
static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s)
512
{
513
    int y;
514
    unsigned char P[2];
515 516

    /* 4-color block encoding: each 4x4 block is a different color */
517
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);
518

519 520 521 522 523 524 525
    for (y = 0; y < 8; y++) {
        if (!(y & 3)) {
            P[0] = *s->stream_ptr++;
            P[1] = *s->stream_ptr++;
        }
        memset(s->pixel_ptr,     P[0], 4);
        memset(s->pixel_ptr + 4, P[1], 4);
526
        s->pixel_ptr += s->stride;
527 528 529 530 531 532
    }

    /* report success */
    return 0;
}

533
static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s)
534
{
535
    int y;
536 537 538
    unsigned char pix;

    /* 1-color encoding: the whole block is 1 solid color */
539
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 1);
540
    pix = *s->stream_ptr++;
541 542

    for (y = 0; y < 8; y++) {
543 544
        memset(s->pixel_ptr, pix, 8);
        s->pixel_ptr += s->stride;
545 546 547 548 549 550
    }

    /* report success */
    return 0;
}

551
static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s)
552 553
{
    int x, y;
554
    unsigned char sample[2];
555 556

    /* dithered encoding */
557
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
558 559
    sample[0] = *s->stream_ptr++;
    sample[1] = *s->stream_ptr++;
560 561 562

    for (y = 0; y < 8; y++) {
        for (x = 0; x < 8; x += 2) {
563 564
            *s->pixel_ptr++ = sample[  y & 1 ];
            *s->pixel_ptr++ = sample[!(y & 1)];
565
        }
566
        s->pixel_ptr += s->line_inc;
567 568 569 570 571 572
    }

    /* report success */
    return 0;
}

573 574 575 576 577 578 579 580 581 582
static int ipvideo_decode_block_opcode_0x6_16(IpvideoContext *s)
{
    signed char x, y;

    /* copy a block from the second last frame using an expanded range */
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);

    x = *s->stream_ptr++;
    y = *s->stream_ptr++;

583
    av_dlog(NULL, "    motion bytes = %d, %d\n", x, y);
584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 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 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
    return copy_from(s, &s->second_last_frame, x, y);
}

static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s)
{
    int x, y;
    uint16_t P[2];
    unsigned int flags;
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

    /* 2-color encoding */
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);

    P[0] = bytestream_get_le16(&s->stream_ptr);
    P[1] = bytestream_get_le16(&s->stream_ptr);

    if (!(P[0] & 0x8000)) {

        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);

        for (y = 0; y < 8; y++) {
            flags = *s->stream_ptr++ | 0x100;
            for (; flags != 1; flags >>= 1)
                *pixel_ptr++ = P[flags & 1];
            pixel_ptr += s->line_inc;
        }

    } else {

        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);

        flags = bytestream_get_le16(&s->stream_ptr);
        for (y = 0; y < 8; y += 2) {
            for (x = 0; x < 8; x += 2, flags >>= 1) {
                pixel_ptr[x                ] =
                pixel_ptr[x + 1            ] =
                pixel_ptr[x +     s->stride] =
                pixel_ptr[x + 1 + s->stride] = P[flags & 1];
            }
            pixel_ptr += s->stride * 2;
        }
    }

    return 0;
}

static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s)
{
    int x, y;
    uint16_t P[2];
    unsigned int flags = 0;
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

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

    P[0] = bytestream_get_le16(&s->stream_ptr);
    P[1] = bytestream_get_le16(&s->stream_ptr);

    if (!(P[0] & 0x8000)) {

        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 24);
        s->stream_ptr -= 4;

        for (y = 0; y < 16; y++) {
            // new values for each 4x4 block
            if (!(y & 3)) {
                P[0] = bytestream_get_le16(&s->stream_ptr);
                P[1] = bytestream_get_le16(&s->stream_ptr);
                flags = bytestream_get_le16(&s->stream_ptr);
            }

            for (x = 0; x < 4; x++, flags >>= 1)
                *pixel_ptr++ = P[flags & 1];
            pixel_ptr += s->stride - 4;
            // switch to right half
            if (y == 7) pixel_ptr -= 8 * s->stride - 4;
        }

    } else {

        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 12);

        if (!(AV_RL16(s->stream_ptr + 4) & 0x8000)) {

            flags = bytestream_get_le32(&s->stream_ptr);

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

            for (y = 0; y < 16; y++) {
                for (x = 0; x < 4; x++, flags >>= 1)
                    *pixel_ptr++ = P[flags & 1];
                pixel_ptr += s->stride - 4;
                // switch to right half
                if (y == 7) {
                    pixel_ptr -= 8 * s->stride - 4;
                    P[0] = bytestream_get_le16(&s->stream_ptr);
                    P[1] = bytestream_get_le16(&s->stream_ptr);
                    flags = bytestream_get_le32(&s->stream_ptr);
                }
            }

        } else {

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

            for (y = 0; y < 8; y++) {
                if (y == 4) {
                    P[0] = bytestream_get_le16(&s->stream_ptr);
                    P[1] = bytestream_get_le16(&s->stream_ptr);
                }
                flags = *s->stream_ptr++ | 0x100;

                for (; flags != 1; flags >>= 1)
                    *pixel_ptr++ = P[flags & 1];
                pixel_ptr += s->line_inc;
            }
        }
    }

    /* report success */
    return 0;
}

static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s)
{
    int x, y;
    uint16_t P[4];
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

    /* 4-color encoding */
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);

    for (x = 0; x < 4; x++)
        P[x] = bytestream_get_le16(&s->stream_ptr);

    if (!(P[0] & 0x8000)) {
        if (!(P[2] & 0x8000)) {

            /* 1 of 4 colors for each pixel */
            CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 16);

            for (y = 0; y < 8; y++) {
                /* get the next set of 8 2-bit flags */
                int flags = bytestream_get_le16(&s->stream_ptr);
                for (x = 0; x < 8; x++, flags >>= 2)
                    *pixel_ptr++ = P[flags & 0x03];
                pixel_ptr += s->line_inc;
            }

        } else {
            uint32_t flags;

            /* 1 of 4 colors for each 2x2 block */
            CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 4);

            flags = bytestream_get_le32(&s->stream_ptr);

            for (y = 0; y < 8; y += 2) {
                for (x = 0; x < 8; x += 2, flags >>= 2) {
                    pixel_ptr[x                ] =
                    pixel_ptr[x + 1            ] =
                    pixel_ptr[x +     s->stride] =
                    pixel_ptr[x + 1 + s->stride] = P[flags & 0x03];
                }
                pixel_ptr += s->stride * 2;
            }

        }
    } else {
        uint64_t flags;

        /* 1 of 4 colors for each 2x1 or 1x2 block */
        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);

        flags = bytestream_get_le64(&s->stream_ptr);
        if (!(P[2] & 0x8000)) {
            for (y = 0; y < 8; y++) {
                for (x = 0; x < 8; x += 2, flags >>= 2) {
                    pixel_ptr[x    ] =
                    pixel_ptr[x + 1] = P[flags & 0x03];
                }
                pixel_ptr += s->stride;
            }
        } else {
            for (y = 0; y < 8; y += 2) {
                for (x = 0; x < 8; x++, flags >>= 2) {
                    pixel_ptr[x            ] =
                    pixel_ptr[x + s->stride] = P[flags & 0x03];
                }
                pixel_ptr += s->stride * 2;
            }
        }
    }

    /* report success */
    return 0;
}

static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s)
{
    int x, y;
    uint16_t P[4];
    int flags = 0;
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

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

    if (!(AV_RL16(s->stream_ptr) & 0x8000)) {

        /* 4-color encoding for each quadrant */
        CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 48);

        for (y = 0; y < 16; y++) {
            // new values for each 4x4 block
            if (!(y & 3)) {
                for (x = 0; x < 4; x++)
                    P[x] = bytestream_get_le16(&s->stream_ptr);
                flags = bytestream_get_le32(&s->stream_ptr);
            }

            for (x = 0; x < 4; x++, flags >>= 2)
                *pixel_ptr++ = P[flags & 0x03];

            pixel_ptr += s->stride - 4;
            // switch to right half
            if (y == 7) pixel_ptr -= 8 * s->stride - 4;
        }

    } else {
        // vertical split?
        int vert = !(AV_RL16(s->stream_ptr + 16) & 0x8000);
        uint64_t flags = 0;

        /* 4-color encoding for either left and right or top and bottom
         * halves */

        for (y = 0; y < 16; y++) {
            // load values for each half
            if (!(y & 7)) {
                for (x = 0; x < 4; x++)
                    P[x] = bytestream_get_le16(&s->stream_ptr);
                flags = bytestream_get_le64(&s->stream_ptr);
            }

            for (x = 0; x < 4; x++, flags >>= 2)
                *pixel_ptr++ = P[flags & 0x03];

            if (vert) {
                pixel_ptr += s->stride - 4;
                // switch to right half
                if (y == 7) pixel_ptr -= 8 * s->stride - 4;
            } else if (y & 1) pixel_ptr += s->line_inc;
        }
    }

    /* report success */
    return 0;
}

static int ipvideo_decode_block_opcode_0xB_16(IpvideoContext *s)
{
    int x, y;
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

    /* 64-color encoding (each pixel in block is a different color) */
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 128);

    for (y = 0; y < 8; y++) {
        for (x = 0; x < 8; x++)
            pixel_ptr[x] = bytestream_get_le16(&s->stream_ptr);
        pixel_ptr  += s->stride;
    }

    /* report success */
    return 0;
}

static int ipvideo_decode_block_opcode_0xC_16(IpvideoContext *s)
{
    int x, y;
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

    /* 16-color block encoding: each 2x2 block is a different color */
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 32);

    for (y = 0; y < 8; y += 2) {
        for (x = 0; x < 8; x += 2) {
            pixel_ptr[x                ] =
            pixel_ptr[x + 1            ] =
            pixel_ptr[x +     s->stride] =
            pixel_ptr[x + 1 + s->stride] = bytestream_get_le16(&s->stream_ptr);
        }
        pixel_ptr += s->stride * 2;
    }

    /* report success */
    return 0;
}

static int ipvideo_decode_block_opcode_0xD_16(IpvideoContext *s)
{
    int x, y;
    uint16_t P[2];
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

    /* 4-color block encoding: each 4x4 block is a different color */
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 8);

    for (y = 0; y < 8; y++) {
        if (!(y & 3)) {
            P[0] = bytestream_get_le16(&s->stream_ptr);
            P[1] = bytestream_get_le16(&s->stream_ptr);
        }
        for (x = 0; x < 8; x++)
            pixel_ptr[x] = P[x >> 2];
        pixel_ptr += s->stride;
    }

    /* report success */
    return 0;
}

static int ipvideo_decode_block_opcode_0xE_16(IpvideoContext *s)
{
    int x, y;
    uint16_t pix;
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

    /* 1-color encoding: the whole block is 1 solid color */
    CHECK_STREAM_PTR(s->stream_ptr, s->stream_end, 2);
    pix = bytestream_get_le16(&s->stream_ptr);

    for (y = 0; y < 8; y++) {
        for (x = 0; x < 8; x++)
            pixel_ptr[x] = pix;
        pixel_ptr += s->stride;
    }

    /* report success */
    return 0;
}

930 931 932 933 934 935 936 937 938 939
static int (* const ipvideo_decode_block[])(IpvideoContext *s) = {
    ipvideo_decode_block_opcode_0x0, ipvideo_decode_block_opcode_0x1,
    ipvideo_decode_block_opcode_0x2, ipvideo_decode_block_opcode_0x3,
    ipvideo_decode_block_opcode_0x4, ipvideo_decode_block_opcode_0x5,
    ipvideo_decode_block_opcode_0x6, ipvideo_decode_block_opcode_0x7,
    ipvideo_decode_block_opcode_0x8, ipvideo_decode_block_opcode_0x9,
    ipvideo_decode_block_opcode_0xA, ipvideo_decode_block_opcode_0xB,
    ipvideo_decode_block_opcode_0xC, ipvideo_decode_block_opcode_0xD,
    ipvideo_decode_block_opcode_0xE, ipvideo_decode_block_opcode_0xF,
};
940

941 942 943 944 945 946 947 948 949 950 951
static int (* const ipvideo_decode_block16[])(IpvideoContext *s) = {
    ipvideo_decode_block_opcode_0x0,    ipvideo_decode_block_opcode_0x1,
    ipvideo_decode_block_opcode_0x2,    ipvideo_decode_block_opcode_0x3,
    ipvideo_decode_block_opcode_0x4,    ipvideo_decode_block_opcode_0x5,
    ipvideo_decode_block_opcode_0x6_16, ipvideo_decode_block_opcode_0x7_16,
    ipvideo_decode_block_opcode_0x8_16, ipvideo_decode_block_opcode_0x9_16,
    ipvideo_decode_block_opcode_0xA_16, ipvideo_decode_block_opcode_0xB_16,
    ipvideo_decode_block_opcode_0xC_16, ipvideo_decode_block_opcode_0xD_16,
    ipvideo_decode_block_opcode_0xE_16, ipvideo_decode_block_opcode_0x1,
};

952 953 954 955 956 957
static void ipvideo_decode_opcodes(IpvideoContext *s)
{
    int x, y;
    unsigned char opcode;
    int ret;
    static int frame = 0;
958
    GetBitContext gb;
959

960
    av_dlog(NULL, "------------------ frame %d\n", frame);
961 962
    frame++;

963
    if (!s->is_16bpp) {
964
        /* this is PAL8, so make the palette available */
965
        memcpy(s->current_frame.data[1], s->pal, AVPALETTE_SIZE);
966

967 968 969
        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;
970 971
    } else {
        s->stride = s->current_frame.linesize[0] >> 1;
972 973 974 975
        s->stream_ptr = s->buf + 16;
        s->stream_end =
        s->mv_ptr = s->buf + 14 + AV_RL16(s->buf+14);
        s->mv_end = s->buf + s->size;
976
    }
977
    s->line_inc = s->stride - 8;
978
    s->upper_motion_limit_offset = (s->avctx->height - 8) * s->current_frame.linesize[0]
979
                                  + (s->avctx->width - 8) * (1 + s->is_16bpp);
980

981
    init_get_bits(&gb, s->decoding_map, s->decoding_map_size * 8);
982 983
    for (y = 0; y < s->avctx->height; y += 8) {
        for (x = 0; x < s->avctx->width; x += 8) {
984
            opcode = get_bits(&gb, 4);
985

986 987
            av_dlog(NULL, "  block @ (%3d, %3d): encoding 0x%X, data ptr @ %p\n",
                    x, y, opcode, s->stream_ptr);
988

989
            if (!s->is_16bpp) {
990 991 992
                s->pixel_ptr = s->current_frame.data[0] + x
                              + y*s->current_frame.linesize[0];
                ret = ipvideo_decode_block[opcode](s);
993
            } else {
994 995
                s->pixel_ptr = s->current_frame.data[0] + x*2
                              + y*s->current_frame.linesize[0];
996
                ret = ipvideo_decode_block16[opcode](s);
997
            }
998
            if (ret != 0) {
999
                av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode problem on frame %d, @ block (%d, %d)\n",
1000
                       frame, x, y);
1001
                return;
1002 1003 1004
            }
        }
    }
1005
    if (s->stream_end - s->stream_ptr > 1) {
1006
        av_log(s->avctx, AV_LOG_ERROR, " Interplay video: decode finished with %td bytes left over\n",
Kostya Shishkov's avatar
Kostya Shishkov committed
1007
               s->stream_end - s->stream_ptr);
1008
    }
1009 1010
}

1011
static av_cold int ipvideo_decode_init(AVCodecContext *avctx)
1012 1013 1014 1015
{
    IpvideoContext *s = avctx->priv_data;

    s->avctx = avctx;
1016

1017 1018
    s->is_16bpp = avctx->bits_per_coded_sample == 16;
    avctx->pix_fmt = s->is_16bpp ? PIX_FMT_RGB555 : PIX_FMT_PAL8;
1019

1020 1021 1022 1023
    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);
1024

1025 1026 1027
    avcodec_get_frame_defaults(&s->second_last_frame);
    avcodec_get_frame_defaults(&s->last_frame);
    avcodec_get_frame_defaults(&s->current_frame);
1028 1029 1030
    s->current_frame.data[0] = s->last_frame.data[0] =
    s->second_last_frame.data[0] = NULL;

1031 1032 1033 1034 1035
    return 0;
}

static int ipvideo_decode_frame(AVCodecContext *avctx,
                                void *data, int *data_size,
1036
                                AVPacket *avpkt)
1037
{
1038 1039
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
1040 1041
    IpvideoContext *s = avctx->priv_data;

1042 1043 1044 1045 1046
    /* 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;

1047 1048 1049
    s->decoding_map = buf;
    s->buf = buf + s->decoding_map_size;
    s->size = buf_size - s->decoding_map_size;
1050

1051
    s->current_frame.reference = 3;
1052
    if (avctx->get_buffer(avctx, &s->current_frame)) {
1053
        av_log(avctx, AV_LOG_ERROR, "  Interplay Video: get_buffer() failed\n");
1054 1055
        return -1;
    }
1056

1057 1058 1059 1060 1061 1062
    if (!s->is_16bpp) {
        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, NULL);
        if (pal) {
            s->current_frame.palette_has_changed = 1;
            memcpy(s->pal, pal, AVPALETTE_SIZE);
        }
1063 1064
    }

1065 1066
    ipvideo_decode_opcodes(s);

1067 1068
    *data_size = sizeof(AVFrame);
    *(AVFrame*)data = s->current_frame;
1069

1070
    /* shuffle frames */
1071 1072 1073
    if (s->second_last_frame.data[0])
        avctx->release_buffer(avctx, &s->second_last_frame);
    s->second_last_frame = s->last_frame;
1074
    s->last_frame = s->current_frame;
1075
    s->current_frame.data[0] = NULL;  /* catch any access attempts */
1076

1077
    /* report that the buffer was completely consumed */
1078 1079 1080
    return buf_size;
}

1081
static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
1082 1083 1084 1085
{
    IpvideoContext *s = avctx->priv_data;

    /* release the last frame */
1086 1087 1088 1089
    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);
1090 1091 1092 1093

    return 0;
}

1094
AVCodec ff_interplay_video_decoder = {
1095 1096 1097 1098 1099 1100 1101 1102
    .name           = "interplayvideo",
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = CODEC_ID_INTERPLAY_VIDEO,
    .priv_data_size = sizeof(IpvideoContext),
    .init           = ipvideo_decode_init,
    .close          = ipvideo_decode_end,
    .decode         = ipvideo_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
1103
    .long_name = NULL_IF_CONFIG_SMALL("Interplay MVE video"),
1104
};