interplayvideo.c 43.1 KB
Newer Older
1 2
/*
 * Interplay MVE Video Decoder
3
 * Copyright (C) 2003 The FFmpeg project
4
 *
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
 */

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

41
#include "libavutil/intreadwrite.h"
42

43
#define BITSTREAM_READER_LE
44
#include "avcodec.h"
45
#include "bytestream.h"
46
#include "get_bits.h"
47
#include "hpeldsp.h"
48
#include "internal.h"
49

50 51
#define PALETTE_COUNT 256

52 53 54
typedef struct IpvideoContext {

    AVCodecContext *avctx;
55
    HpelDSPContext hdsp;
56 57
    AVFrame *second_last_frame;
    AVFrame *last_frame;
58 59 60 61 62

    /* For format 0x10 */
    AVFrame *cur_decode_frame;
    AVFrame *prev_decode_frame;

Michael Niedermayer's avatar
Michael Niedermayer committed
63
    const unsigned char *decoding_map;
64
    int decoding_map_size;
65 66
    const unsigned char *skip_map;
    int skip_map_size;
67

68
    int is_16bpp;
69
    GetByteContext stream_ptr, mv_ptr;
70 71 72 73 74
    unsigned char *pixel_ptr;
    int line_inc;
    int stride;
    int upper_motion_limit_offset;

75
    uint32_t pal[256];
76 77
} IpvideoContext;

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

100
static int ipvideo_decode_block_opcode_0x0(IpvideoContext *s, AVFrame *frame)
101
{
102
    return copy_from(s, s->last_frame, frame, 0, 0);
103
}
104

105
static int ipvideo_decode_block_opcode_0x1(IpvideoContext *s, AVFrame *frame)
106
{
107
    return copy_from(s, s->second_last_frame, frame, 0, 0);
108 109
}

110
static int ipvideo_decode_block_opcode_0x2(IpvideoContext *s, AVFrame *frame)
111 112 113 114
{
    unsigned char B;
    int x, y;

115
    /* copy block from 2 frames ago using a motion vector; need 1 more byte */
116
    if (!s->is_16bpp) {
117
        B = bytestream2_get_byte(&s->stream_ptr);
118
    } else {
119
        B = bytestream2_get_byte(&s->mv_ptr);
120
    }
121 122 123 124 125 126 127 128 129

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

130
    ff_tlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
131
    return copy_from(s, s->second_last_frame, frame, x, y);
132 133
}

134
static int ipvideo_decode_block_opcode_0x3(IpvideoContext *s, AVFrame *frame)
135 136 137 138 139 140 141
{
    unsigned char B;
    int x, y;

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

    /* need 1 more byte for motion */
142
    if (!s->is_16bpp) {
143
        B = bytestream2_get_byte(&s->stream_ptr);
144
    } else {
145
        B = bytestream2_get_byte(&s->mv_ptr);
146
    }
147 148 149 150 151 152 153 154 155

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

156
    ff_tlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
157
    return copy_from(s, frame, frame, x, y);
158 159
}

160
static int ipvideo_decode_block_opcode_0x4(IpvideoContext *s, AVFrame *frame)
161 162 163 164 165
{
    int x, y;
    unsigned char B, BL, BH;

    /* copy a block from the previous frame; need 1 more byte */
166
    if (!s->is_16bpp) {
167
        B = bytestream2_get_byte(&s->stream_ptr);
168
    } else {
169
        B = bytestream2_get_byte(&s->mv_ptr);
170
    }
171 172 173 174 175 176

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

177
    ff_tlog(s->avctx, "motion byte = %d, (x, y) = (%d, %d)\n", B, x, y);
178
    return copy_from(s, s->last_frame, frame, x, y);
179 180
}

181
static int ipvideo_decode_block_opcode_0x5(IpvideoContext *s, AVFrame *frame)
182 183 184 185 186
{
    signed char x, y;

    /* copy a block from the previous frame using an expanded range;
     * need 2 more bytes */
187 188
    x = bytestream2_get_byte(&s->stream_ptr);
    y = bytestream2_get_byte(&s->stream_ptr);
189

190
    ff_tlog(s->avctx, "motion bytes = %d, %d\n", x, y);
191
    return copy_from(s, s->last_frame, frame, x, y);
192 193
}

194
static int ipvideo_decode_block_opcode_0x6(IpvideoContext *s, AVFrame *frame)
195 196
{
    /* mystery opcode? skip multiple blocks? */
197
    av_log(s->avctx, AV_LOG_ERROR, "Help! Mystery opcode 0x6 seen\n");
198 199 200 201 202

    /* report success */
    return 0;
}

203
static int ipvideo_decode_block_opcode_0x7(IpvideoContext *s, AVFrame *frame)
204 205
{
    int x, y;
206
    unsigned char P[2];
207 208
    unsigned int flags;

209 210 211 212 213
    if (bytestream2_get_bytes_left(&s->stream_ptr) < 4) {
        av_log(s->avctx, AV_LOG_ERROR, "too little data for opcode 0x7\n");
        return AVERROR_INVALIDDATA;
    }

214
    /* 2-color encoding */
215 216
    P[0] = bytestream2_get_byte(&s->stream_ptr);
    P[1] = bytestream2_get_byte(&s->stream_ptr);
217

218
    if (P[0] <= P[1]) {
219 220 221

        /* need 8 more bytes from the stream */
        for (y = 0; y < 8; y++) {
222
            flags = bytestream2_get_byte(&s->stream_ptr) | 0x100;
223
            for (; flags != 1; flags >>= 1)
224
                *s->pixel_ptr++ = P[flags & 1];
225
            s->pixel_ptr += s->line_inc;
226 227 228 229 230
        }

    } else {

        /* need 2 more bytes from the stream */
231
        flags = bytestream2_get_le16(&s->stream_ptr);
232
        for (y = 0; y < 8; y += 2) {
233
            for (x = 0; x < 8; x += 2, flags >>= 1) {
Reimar Döffinger's avatar
Reimar Döffinger committed
234 235 236 237
                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];
238
            }
239
            s->pixel_ptr += s->stride * 2;
240 241 242 243 244 245 246
        }
    }

    /* report success */
    return 0;
}

247
static int ipvideo_decode_block_opcode_0x8(IpvideoContext *s, AVFrame *frame)
248 249
{
    int x, y;
250
    unsigned char P[4];
251 252
    unsigned int flags = 0;

253 254 255 256 257
    if (bytestream2_get_bytes_left(&s->stream_ptr) < 12) {
        av_log(s->avctx, AV_LOG_ERROR, "too little data for opcode 0x8\n");
        return AVERROR_INVALIDDATA;
    }

258 259
    /* 2-color encoding for each 4x4 quadrant, or 2-color encoding on
     * either top and bottom or left and right halves */
260 261
    P[0] = bytestream2_get_byte(&s->stream_ptr);
    P[1] = bytestream2_get_byte(&s->stream_ptr);
262 263

    if (P[0] <= P[1]) {
264 265 266
        for (y = 0; y < 16; y++) {
            // new values for each 4x4 block
            if (!(y & 3)) {
267 268 269 270 271
                if (y) {
                    P[0]  = bytestream2_get_byte(&s->stream_ptr);
                    P[1]  = bytestream2_get_byte(&s->stream_ptr);
                }
                flags = bytestream2_get_le16(&s->stream_ptr);
272 273
            }

274
            for (x = 0; x < 4; x++, flags >>= 1)
275 276 277 278
                *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;
279 280 281
        }

    } else {
282 283 284
        flags = bytestream2_get_le32(&s->stream_ptr);
        P[2] = bytestream2_get_byte(&s->stream_ptr);
        P[3] = bytestream2_get_byte(&s->stream_ptr);
285

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

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

290
            for (y = 0; y < 16; y++) {
291
                for (x = 0; x < 4; x++, flags >>= 1)
292 293 294 295 296
                    *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;
297 298 299
                    P[0]  = P[2];
                    P[1]  = P[3];
                    flags = bytestream2_get_le32(&s->stream_ptr);
300 301 302 303 304 305 306 307
                }
            }

        } else {

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

            for (y = 0; y < 8; y++) {
308
                if (y == 4) {
309 310 311
                    P[0]  = P[2];
                    P[1]  = P[3];
                    flags = bytestream2_get_le32(&s->stream_ptr);
312 313
                }

314
                for (x = 0; x < 8; x++, flags >>= 1)
315
                    *s->pixel_ptr++ = P[flags & 1];
316
                s->pixel_ptr += s->line_inc;
317 318 319 320 321 322 323 324
            }
        }
    }

    /* report success */
    return 0;
}

325
static int ipvideo_decode_block_opcode_0x9(IpvideoContext *s, AVFrame *frame)
326 327 328 329
{
    int x, y;
    unsigned char P[4];

330 331 332 333 334
    if (bytestream2_get_bytes_left(&s->stream_ptr) < 8) {
        av_log(s->avctx, AV_LOG_ERROR, "too little data for opcode 0x9\n");
        return AVERROR_INVALIDDATA;
    }

335
    /* 4-color encoding */
336
    bytestream2_get_buffer(&s->stream_ptr, P, 4);
337

338 339
    if (P[0] <= P[1]) {
        if (P[2] <= P[3]) {
340

Reimar Döffinger's avatar
Reimar Döffinger committed
341 342 343
            /* 1 of 4 colors for each pixel, need 16 more bytes */
            for (y = 0; y < 8; y++) {
                /* get the next set of 8 2-bit flags */
344
                int flags = bytestream2_get_le16(&s->stream_ptr);
345
                for (x = 0; x < 8; x++, flags >>= 2)
Reimar Döffinger's avatar
Reimar Döffinger committed
346 347
                    *s->pixel_ptr++ = P[flags & 0x03];
                s->pixel_ptr += s->line_inc;
348 349
            }

350
        } else {
Reimar Döffinger's avatar
Reimar Döffinger committed
351
            uint32_t flags;
352

Reimar Döffinger's avatar
Reimar Döffinger committed
353
            /* 1 of 4 colors for each 2x2 block, need 4 more bytes */
354
            flags = bytestream2_get_le32(&s->stream_ptr);
355

Reimar Döffinger's avatar
Reimar Döffinger committed
356 357 358 359 360 361 362 363
            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;
364 365
            }

366 367
        }
    } else {
368
        uint64_t flags;
369

370
        /* 1 of 4 colors for each 2x1 or 1x2 block, need 8 more bytes */
371
        flags = bytestream2_get_le64(&s->stream_ptr);
372
        if (P[2] <= P[3]) {
Reimar Döffinger's avatar
Reimar Döffinger committed
373 374 375 376 377 378
            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;
379
            }
380
        } else {
Reimar Döffinger's avatar
Reimar Döffinger committed
381 382 383 384 385 386
            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;
387
            }
388
        }
389 390 391 392 393 394
    }

    /* report success */
    return 0;
}

395
static int ipvideo_decode_block_opcode_0xA(IpvideoContext *s, AVFrame *frame)
396 397
{
    int x, y;
398
    unsigned char P[8];
399 400
    int flags = 0;

401 402 403 404 405
    if (bytestream2_get_bytes_left(&s->stream_ptr) < 16) {
        av_log(s->avctx, AV_LOG_ERROR, "too little data for opcode 0xA\n");
        return AVERROR_INVALIDDATA;
    }

406 407
    bytestream2_get_buffer(&s->stream_ptr, P, 4);

408 409
    /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
     * either top and bottom or left and right halves */
410
    if (P[0] <= P[1]) {
411

412
        /* 4-color encoding for each quadrant; need 32 bytes */
413 414 415
        for (y = 0; y < 16; y++) {
            // new values for each 4x4 block
            if (!(y & 3)) {
416 417
                if (y) bytestream2_get_buffer(&s->stream_ptr, P, 4);
                flags = bytestream2_get_le32(&s->stream_ptr);
418
            }
419

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

423 424 425
            s->pixel_ptr += s->stride - 4;
            // switch to right half
            if (y == 7) s->pixel_ptr -= 8 * s->stride - 4;
426 427 428
        }

    } else {
429
        // vertical split?
430 431 432 433 434
        int vert;
        uint64_t flags = bytestream2_get_le64(&s->stream_ptr);

        bytestream2_get_buffer(&s->stream_ptr, P + 4, 4);
        vert = P[4] <= P[5];
435 436

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

439 440 441
        for (y = 0; y < 16; y++) {
            for (x = 0; x < 4; x++, flags >>= 2)
                *s->pixel_ptr++ = P[flags & 0x03];
442

443 444 445 446 447
            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;
448 449 450 451 452 453

            // load values for second half
            if (y == 7) {
                memcpy(P, P + 4, 4);
                flags = bytestream2_get_le64(&s->stream_ptr);
            }
454 455 456 457 458 459 460
        }
    }

    /* report success */
    return 0;
}

461
static int ipvideo_decode_block_opcode_0xB(IpvideoContext *s, AVFrame *frame)
462
{
463
    int y;
464 465 466

    /* 64-color encoding (each pixel in block is a different color) */
    for (y = 0; y < 8; y++) {
467
        bytestream2_get_buffer(&s->stream_ptr, s->pixel_ptr, 8);
468
        s->pixel_ptr  += s->stride;
469 470 471 472 473 474
    }

    /* report success */
    return 0;
}

475
static int ipvideo_decode_block_opcode_0xC(IpvideoContext *s, AVFrame *frame)
476 477 478 479 480 481
{
    int x, y;

    /* 16-color block encoding: each 2x2 block is a different color */
    for (y = 0; y < 8; y += 2) {
        for (x = 0; x < 8; x += 2) {
482 483 484
            s->pixel_ptr[x                ] =
            s->pixel_ptr[x + 1            ] =
            s->pixel_ptr[x +     s->stride] =
485
            s->pixel_ptr[x + 1 + s->stride] = bytestream2_get_byte(&s->stream_ptr);
486
        }
487
        s->pixel_ptr += s->stride * 2;
488 489 490 491 492 493
    }

    /* report success */
    return 0;
}

494
static int ipvideo_decode_block_opcode_0xD(IpvideoContext *s, AVFrame *frame)
495
{
496
    int y;
497
    unsigned char P[2];
498

499 500 501 502 503
    if (bytestream2_get_bytes_left(&s->stream_ptr) < 4) {
        av_log(s->avctx, AV_LOG_ERROR, "too little data for opcode 0xD\n");
        return AVERROR_INVALIDDATA;
    }

504
    /* 4-color block encoding: each 4x4 block is a different color */
505 506
    for (y = 0; y < 8; y++) {
        if (!(y & 3)) {
507 508
            P[0] = bytestream2_get_byte(&s->stream_ptr);
            P[1] = bytestream2_get_byte(&s->stream_ptr);
509 510 511
        }
        memset(s->pixel_ptr,     P[0], 4);
        memset(s->pixel_ptr + 4, P[1], 4);
512
        s->pixel_ptr += s->stride;
513 514 515 516 517 518
    }

    /* report success */
    return 0;
}

519
static int ipvideo_decode_block_opcode_0xE(IpvideoContext *s, AVFrame *frame)
520
{
521
    int y;
522 523 524
    unsigned char pix;

    /* 1-color encoding: the whole block is 1 solid color */
525
    pix = bytestream2_get_byte(&s->stream_ptr);
526 527

    for (y = 0; y < 8; y++) {
528 529
        memset(s->pixel_ptr, pix, 8);
        s->pixel_ptr += s->stride;
530 531 532 533 534 535
    }

    /* report success */
    return 0;
}

536
static int ipvideo_decode_block_opcode_0xF(IpvideoContext *s, AVFrame *frame)
537 538
{
    int x, y;
539
    unsigned char sample[2];
540 541

    /* dithered encoding */
542 543
    sample[0] = bytestream2_get_byte(&s->stream_ptr);
    sample[1] = bytestream2_get_byte(&s->stream_ptr);
544 545 546

    for (y = 0; y < 8; y++) {
        for (x = 0; x < 8; x += 2) {
547 548
            *s->pixel_ptr++ = sample[  y & 1 ];
            *s->pixel_ptr++ = sample[!(y & 1)];
549
        }
550
        s->pixel_ptr += s->line_inc;
551 552 553 554 555 556
    }

    /* report success */
    return 0;
}

557
static int ipvideo_decode_block_opcode_0x6_16(IpvideoContext *s, AVFrame *frame)
558 559 560 561
{
    signed char x, y;

    /* copy a block from the second last frame using an expanded range */
562 563
    x = bytestream2_get_byte(&s->stream_ptr);
    y = bytestream2_get_byte(&s->stream_ptr);
564

565
    ff_tlog(s->avctx, "motion bytes = %d, %d\n", x, y);
566
    return copy_from(s, s->second_last_frame, frame, x, y);
567 568
}

569
static int ipvideo_decode_block_opcode_0x7_16(IpvideoContext *s, AVFrame *frame)
570 571 572 573 574 575 576
{
    int x, y;
    uint16_t P[2];
    unsigned int flags;
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

    /* 2-color encoding */
577 578
    P[0] = bytestream2_get_le16(&s->stream_ptr);
    P[1] = bytestream2_get_le16(&s->stream_ptr);
579 580 581 582

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

        for (y = 0; y < 8; y++) {
583
            flags = bytestream2_get_byte(&s->stream_ptr) | 0x100;
584 585 586 587 588 589 590
            for (; flags != 1; flags >>= 1)
                *pixel_ptr++ = P[flags & 1];
            pixel_ptr += s->line_inc;
        }

    } else {

591
        flags = bytestream2_get_le16(&s->stream_ptr);
592 593 594 595 596 597 598 599 600 601 602 603 604 605
        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;
}

606
static int ipvideo_decode_block_opcode_0x8_16(IpvideoContext *s, AVFrame *frame)
607 608
{
    int x, y;
609
    uint16_t P[4];
610 611 612 613 614
    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 */
615 616
    P[0] = bytestream2_get_le16(&s->stream_ptr);
    P[1] = bytestream2_get_le16(&s->stream_ptr);
617 618 619 620 621 622

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

        for (y = 0; y < 16; y++) {
            // new values for each 4x4 block
            if (!(y & 3)) {
623 624 625 626 627
                if (y) {
                    P[0] = bytestream2_get_le16(&s->stream_ptr);
                    P[1] = bytestream2_get_le16(&s->stream_ptr);
                }
                flags = bytestream2_get_le16(&s->stream_ptr);
628 629 630 631 632 633 634 635 636 637 638
            }

            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 {

639 640 641
        flags = bytestream2_get_le32(&s->stream_ptr);
        P[2]  = bytestream2_get_le16(&s->stream_ptr);
        P[3]  = bytestream2_get_le16(&s->stream_ptr);
642

643
        if (!(P[2] & 0x8000)) {
644 645 646 647 648 649 650 651 652 653

            /* 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;
654 655 656
                    P[0]  = P[2];
                    P[1]  = P[3];
                    flags = bytestream2_get_le32(&s->stream_ptr);
657 658 659 660 661 662 663 664 665
                }
            }

        } else {

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

            for (y = 0; y < 8; y++) {
                if (y == 4) {
666 667 668
                    P[0]  = P[2];
                    P[1]  = P[3];
                    flags = bytestream2_get_le32(&s->stream_ptr);
669 670
                }

671
                for (x = 0; x < 8; x++, flags >>= 1)
672 673 674 675 676 677 678 679 680 681
                    *pixel_ptr++ = P[flags & 1];
                pixel_ptr += s->line_inc;
            }
        }
    }

    /* report success */
    return 0;
}

682
static int ipvideo_decode_block_opcode_0x9_16(IpvideoContext *s, AVFrame *frame)
683 684 685 686 687 688 689
{
    int x, y;
    uint16_t P[4];
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

    /* 4-color encoding */
    for (x = 0; x < 4; x++)
690
        P[x] = bytestream2_get_le16(&s->stream_ptr);
691 692 693 694 695 696 697

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

            /* 1 of 4 colors for each pixel */
            for (y = 0; y < 8; y++) {
                /* get the next set of 8 2-bit flags */
698
                int flags = bytestream2_get_le16(&s->stream_ptr);
699 700 701 702 703 704 705 706 707
                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 */
708
            flags = bytestream2_get_le32(&s->stream_ptr);
709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724

            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 */
725
        flags = bytestream2_get_le64(&s->stream_ptr);
726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
        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;
}

749
static int ipvideo_decode_block_opcode_0xA_16(IpvideoContext *s, AVFrame *frame)
750 751
{
    int x, y;
752
    uint16_t P[8];
753 754 755
    int flags = 0;
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

756 757 758
    for (x = 0; x < 4; x++)
        P[x] = bytestream2_get_le16(&s->stream_ptr);

759 760
    /* 4-color encoding for each 4x4 quadrant, or 4-color encoding on
     * either top and bottom or left and right halves */
761
    if (!(P[0] & 0x8000)) {
762 763 764 765 766

        /* 4-color encoding for each quadrant */
        for (y = 0; y < 16; y++) {
            // new values for each 4x4 block
            if (!(y & 3)) {
767 768 769 770
                if (y)
                    for (x = 0; x < 4; x++)
                        P[x] = bytestream2_get_le16(&s->stream_ptr);
                flags = bytestream2_get_le32(&s->stream_ptr);
771 772 773 774 775 776 777 778 779 780 781 782
            }

            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?
783 784 785 786 787 788
        int vert;
        uint64_t flags = bytestream2_get_le64(&s->stream_ptr);

        for (x = 4; x < 8; x++)
            P[x] = bytestream2_get_le16(&s->stream_ptr);
        vert = !(P[4] & 0x8000);
789 790 791 792 793 794 795 796 797 798 799 800 801

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

        for (y = 0; y < 16; y++) {
            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;
802 803 804 805 806 807

            // load values for second half
            if (y == 7) {
                memcpy(P, P + 4, 8);
                flags = bytestream2_get_le64(&s->stream_ptr);
            }
808 809 810 811 812 813 814
        }
    }

    /* report success */
    return 0;
}

815
static int ipvideo_decode_block_opcode_0xB_16(IpvideoContext *s, AVFrame *frame)
816 817 818 819 820 821 822
{
    int x, y;
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

    /* 64-color encoding (each pixel in block is a different color) */
    for (y = 0; y < 8; y++) {
        for (x = 0; x < 8; x++)
823
            pixel_ptr[x] = bytestream2_get_le16(&s->stream_ptr);
824 825 826 827 828 829 830
        pixel_ptr  += s->stride;
    }

    /* report success */
    return 0;
}

831
static int ipvideo_decode_block_opcode_0xC_16(IpvideoContext *s, AVFrame *frame)
832 833 834 835 836 837 838 839 840 841
{
    int x, y;
    uint16_t *pixel_ptr = (uint16_t*)s->pixel_ptr;

    /* 16-color block encoding: each 2x2 block is a different color */
    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] =
842
            pixel_ptr[x + 1 + s->stride] = bytestream2_get_le16(&s->stream_ptr);
843 844 845 846 847 848 849 850
        }
        pixel_ptr += s->stride * 2;
    }

    /* report success */
    return 0;
}

851
static int ipvideo_decode_block_opcode_0xD_16(IpvideoContext *s, AVFrame *frame)
852 853 854 855 856 857 858 859
{
    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 */
    for (y = 0; y < 8; y++) {
        if (!(y & 3)) {
860 861
            P[0] = bytestream2_get_le16(&s->stream_ptr);
            P[1] = bytestream2_get_le16(&s->stream_ptr);
862 863 864 865 866 867 868 869 870 871
        }
        for (x = 0; x < 8; x++)
            pixel_ptr[x] = P[x >> 2];
        pixel_ptr += s->stride;
    }

    /* report success */
    return 0;
}

872
static int ipvideo_decode_block_opcode_0xE_16(IpvideoContext *s, AVFrame *frame)
873 874 875 876 877 878
{
    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 */
879
    pix = bytestream2_get_le16(&s->stream_ptr);
880 881 882 883 884 885 886 887 888 889 890

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

    /* report success */
    return 0;
}

891
static int (* const ipvideo_decode_block[])(IpvideoContext *s, AVFrame *frame) = {
892 893 894 895 896 897 898 899 900
    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,
};
901

902
static int (* const ipvideo_decode_block16[])(IpvideoContext *s, AVFrame *frame) = {
903 904 905 906 907 908 909 910 911 912
    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,
};

913
static void ipvideo_format_06_firstpass(IpvideoContext *s, AVFrame *frame, int16_t opcode)
914 915 916 917 918 919 920 921 922 923 924 925 926 927 928
{
    int line;

    if (!opcode) {
        for (line = 0; line < 8; ++line) {
            bytestream2_get_buffer(&s->stream_ptr, s->pixel_ptr, 8);
            s->pixel_ptr += s->stride;
        }
    } else {
        /* Don't try to copy second_last_frame data on the first frames */
        if (s->avctx->frame_number > 2)
            copy_from(s, s->second_last_frame, frame, 0, 0);
    }
}

929
static void ipvideo_format_06_secondpass(IpvideoContext *s, AVFrame *frame, int16_t opcode)
930 931 932 933
{
    int off_x, off_y;

    if (opcode < 0) {
934 935
        off_x = ((uint16_t)opcode - 0xC000) % frame->linesize[0];
        off_y = ((uint16_t)opcode - 0xC000) / frame->linesize[0];
936 937
        copy_from(s, s->last_frame, frame, off_x, off_y);
    } else if (opcode > 0) {
938 939
        off_x = ((uint16_t)opcode - 0x4000) % frame->linesize[0];
        off_y = ((uint16_t)opcode - 0x4000) / frame->linesize[0];
940 941 942 943
        copy_from(s, frame, frame, off_x, off_y);
    }
}

944
static void (* const ipvideo_format_06_passes[])(IpvideoContext *s, AVFrame *frame, int16_t op) = {
945 946 947 948 949 950
    ipvideo_format_06_firstpass, ipvideo_format_06_secondpass,
};

static void ipvideo_decode_format_06_opcodes(IpvideoContext *s, AVFrame *frame)
{
    int pass, x, y;
951
    int16_t opcode;
952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986
    GetByteContext decoding_map_ptr;

    /* this is PAL8, so make the palette available */
    memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);
    s->stride = frame->linesize[0];

    s->line_inc = s->stride - 8;
    s->upper_motion_limit_offset = (s->avctx->height - 8) * frame->linesize[0]
                                  + (s->avctx->width - 8) * (1 + s->is_16bpp);

    bytestream2_init(&decoding_map_ptr, s->decoding_map, s->decoding_map_size);

    for (pass = 0; pass < 2; ++pass) {
        bytestream2_seek(&decoding_map_ptr, 0, SEEK_SET);
        for (y = 0; y < s->avctx->height; y += 8) {
            for (x = 0; x < s->avctx->width; x += 8) {
                opcode = bytestream2_get_le16(&decoding_map_ptr);

                ff_tlog(s->avctx,
                        "  block @ (%3d, %3d): opcode 0x%X, data ptr offset %d\n",
                        x, y, opcode, bytestream2_tell(&s->stream_ptr));

                s->pixel_ptr = frame->data[0] + x + y * frame->linesize[0];
                ipvideo_format_06_passes[pass](s, frame, opcode);
            }
        }
    }

    if (bytestream2_get_bytes_left(&s->stream_ptr) > 1) {
        av_log(s->avctx, AV_LOG_DEBUG,
               "decode finished with %d bytes left over\n",
               bytestream2_get_bytes_left(&s->stream_ptr));
    }
}

987
static void ipvideo_format_10_firstpass(IpvideoContext *s, AVFrame *frame, int16_t opcode)
988 989 990 991 992 993 994 995 996 997 998
{
    int line;

    if (!opcode) {
        for (line = 0; line < 8; ++line) {
            bytestream2_get_buffer(&s->stream_ptr, s->pixel_ptr, 8);
            s->pixel_ptr += s->stride;
        }
    }
}

999
static void ipvideo_format_10_secondpass(IpvideoContext *s, AVFrame *frame, int16_t opcode)
1000 1001 1002 1003
{
    int off_x, off_y;

    if (opcode < 0) {
1004 1005
        off_x = ((uint16_t)opcode - 0xC000) % s->cur_decode_frame->linesize[0];
        off_y = ((uint16_t)opcode - 0xC000) / s->cur_decode_frame->linesize[0];
1006 1007
        copy_from(s, s->prev_decode_frame, s->cur_decode_frame, off_x, off_y);
    } else if (opcode > 0) {
1008 1009
        off_x = ((uint16_t)opcode - 0x4000) % s->cur_decode_frame->linesize[0];
        off_y = ((uint16_t)opcode - 0x4000) / s->cur_decode_frame->linesize[0];
1010 1011 1012 1013
        copy_from(s, s->cur_decode_frame, s->cur_decode_frame, off_x, off_y);
    }
}

1014
static void (* const ipvideo_format_10_passes[])(IpvideoContext *s, AVFrame *frame, int16_t op) = {
1015 1016 1017 1018 1019 1020
    ipvideo_format_10_firstpass, ipvideo_format_10_secondpass,
};

static void ipvideo_decode_format_10_opcodes(IpvideoContext *s, AVFrame *frame)
{
    int pass, x, y, changed_block;
1021
    int16_t opcode, skip;
1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
    GetByteContext decoding_map_ptr;
    GetByteContext skip_map_ptr;

    bytestream2_skip(&s->stream_ptr, 14); /* data starts 14 bytes in */

    /* this is PAL8, so make the palette available */
    memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);
    s->stride = frame->linesize[0];

    s->line_inc = s->stride - 8;
    s->upper_motion_limit_offset = (s->avctx->height - 8) * frame->linesize[0]
                                  + (s->avctx->width - 8) * (1 + s->is_16bpp);

    bytestream2_init(&decoding_map_ptr, s->decoding_map, s->decoding_map_size);
    bytestream2_init(&skip_map_ptr, s->skip_map, s->skip_map_size);

    for (pass = 0; pass < 2; ++pass) {
        bytestream2_seek(&decoding_map_ptr, 0, SEEK_SET);
        bytestream2_seek(&skip_map_ptr, 0, SEEK_SET);
        skip = bytestream2_get_le16(&skip_map_ptr);

        for (y = 0; y < s->avctx->height; y += 8) {
            for (x = 0; x < s->avctx->width; x += 8) {
                s->pixel_ptr = s->cur_decode_frame->data[0] + x + y * s->cur_decode_frame->linesize[0];

1047
                while (skip <= 0)  {
1048 1049 1050 1051 1052
                    if (skip != -0x8000 && skip) {
                        opcode = bytestream2_get_le16(&decoding_map_ptr);
                        ipvideo_format_10_passes[pass](s, frame, opcode);
                        break;
                    }
1053 1054
                    if (bytestream2_get_bytes_left(&skip_map_ptr) < 2)
                        return;
1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073
                    skip = bytestream2_get_le16(&skip_map_ptr);
                }
                skip *= 2;
            }
        }
    }

    bytestream2_seek(&skip_map_ptr, 0, SEEK_SET);
    skip = bytestream2_get_le16(&skip_map_ptr);
    for (y = 0; y < s->avctx->height; y += 8) {
        for (x = 0; x < s->avctx->width; x += 8) {
            changed_block = 0;
            s->pixel_ptr = frame->data[0] + x + y*frame->linesize[0];

            while (skip <= 0)  {
                if (skip != -0x8000 && skip) {
                    changed_block = 1;
                    break;
                }
1074
                if (bytestream2_get_bytes_left(&skip_map_ptr) < 2)
1075
                    return;
1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098
                skip = bytestream2_get_le16(&skip_map_ptr);
            }

            if (changed_block) {
                copy_from(s, s->cur_decode_frame, frame, 0, 0);
            } else {
                /* Don't try to copy last_frame data on the first frame */
                if (s->avctx->frame_number)
                    copy_from(s, s->last_frame, frame, 0, 0);
            }
            skip *= 2;
        }
    }

    FFSWAP(AVFrame*, s->prev_decode_frame, s->cur_decode_frame);

    if (bytestream2_get_bytes_left(&s->stream_ptr) > 1) {
        av_log(s->avctx, AV_LOG_DEBUG,
               "decode finished with %d bytes left over\n",
               bytestream2_get_bytes_left(&s->stream_ptr));
    }
}

1099
static void ipvideo_decode_format_11_opcodes(IpvideoContext *s, AVFrame *frame)
1100 1101 1102 1103
{
    int x, y;
    unsigned char opcode;
    int ret;
1104
    GetBitContext gb;
1105

1106
    bytestream2_skip(&s->stream_ptr, 14); /* data starts 14 bytes in */
1107
    if (!s->is_16bpp) {
1108
        /* this is PAL8, so make the palette available */
1109
        memcpy(frame->data[1], s->pal, AVPALETTE_SIZE);
1110

1111
        s->stride = frame->linesize[0];
1112
    } else {
1113
        s->stride = frame->linesize[0] >> 1;
1114 1115
        s->mv_ptr = s->stream_ptr;
        bytestream2_skip(&s->mv_ptr, bytestream2_get_le16(&s->stream_ptr));
1116
    }
1117
    s->line_inc = s->stride - 8;
1118
    s->upper_motion_limit_offset = (s->avctx->height - 8) * frame->linesize[0]
1119
                                  + (s->avctx->width - 8) * (1 + s->is_16bpp);
1120

1121
    init_get_bits(&gb, s->decoding_map, s->decoding_map_size * 8);
1122 1123
    for (y = 0; y < s->avctx->height; y += 8) {
        for (x = 0; x < s->avctx->width; x += 8) {
1124 1125
            if (get_bits_left(&gb) < 4)
                return;
1126
            opcode = get_bits(&gb, 4);
1127

1128
            ff_tlog(s->avctx,
1129 1130
                    "  block @ (%3d, %3d): encoding 0x%X, data ptr offset %d\n",
                    x, y, opcode, bytestream2_tell(&s->stream_ptr));
1131

1132
            if (!s->is_16bpp) {
1133 1134 1135
                s->pixel_ptr = frame->data[0] + x
                              + y*frame->linesize[0];
                ret = ipvideo_decode_block[opcode](s, frame);
1136
            } else {
1137 1138 1139
                s->pixel_ptr = frame->data[0] + x*2
                              + y*frame->linesize[0];
                ret = ipvideo_decode_block16[opcode](s, frame);
1140
            }
1141
            if (ret != 0) {
1142
                av_log(s->avctx, AV_LOG_ERROR, "decode problem on frame %d, @ block (%d, %d)\n",
1143
                       s->avctx->frame_number, x, y);
1144
                return;
1145 1146 1147
            }
        }
    }
1148
    if (bytestream2_get_bytes_left(&s->stream_ptr) > 1) {
1149
        av_log(s->avctx, AV_LOG_DEBUG,
1150
               "decode finished with %d bytes left over\n",
1151
               bytestream2_get_bytes_left(&s->stream_ptr));
1152
    }
1153 1154
}

1155
static av_cold int ipvideo_decode_init(AVCodecContext *avctx)
1156 1157
{
    IpvideoContext *s = avctx->priv_data;
1158
    int ret;
1159 1160

    s->avctx = avctx;
1161

1162
    s->is_16bpp = avctx->bits_per_coded_sample == 16;
1163
    avctx->pix_fmt = s->is_16bpp ? AV_PIX_FMT_RGB555 : AV_PIX_FMT_PAL8;
1164

1165
    ff_hpeldsp_init(&s->hdsp, avctx->flags);
1166

1167 1168
    s->last_frame        = av_frame_alloc();
    s->second_last_frame = av_frame_alloc();
1169 1170 1171 1172
    s->cur_decode_frame  = av_frame_alloc();
    s->prev_decode_frame = av_frame_alloc();
    if (!s->last_frame || !s->second_last_frame ||
        !s->cur_decode_frame || !s->prev_decode_frame) {
1173 1174
        ret = AVERROR(ENOMEM);
        goto error;
1175
    }
1176

1177 1178 1179 1180 1181 1182 1183
    s->cur_decode_frame->width   = avctx->width;
    s->prev_decode_frame->width  = avctx->width;
    s->cur_decode_frame->height  = avctx->height;
    s->prev_decode_frame->height = avctx->height;
    s->cur_decode_frame->format  = avctx->pix_fmt;
    s->prev_decode_frame->format = avctx->pix_fmt;

1184 1185 1186 1187 1188 1189 1190
    ret = ff_get_buffer(avctx, s->cur_decode_frame, 0);
    if (ret < 0)
        goto error;

    ret = ff_get_buffer(avctx, s->prev_decode_frame, 0);
    if (ret < 0)
        goto error;
1191

1192
    return 0;
1193 1194 1195 1196 1197 1198
error:
    av_frame_free(&s->last_frame);
    av_frame_free(&s->second_last_frame);
    av_frame_free(&s->cur_decode_frame);
    av_frame_free(&s->prev_decode_frame);
    return ret;
1199 1200 1201
}

static int ipvideo_decode_frame(AVCodecContext *avctx,
1202
                                void *data, int *got_frame,
1203
                                AVPacket *avpkt)
1204
{
1205 1206
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
1207
    IpvideoContext *s = avctx->priv_data;
1208
    AVFrame *frame = data;
1209
    int ret;
1210
    int send_buffer;
1211 1212
    int frame_format;
    int video_data_size;
1213

1214 1215 1216
    if (av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, NULL)) {
        av_frame_unref(s->last_frame);
        av_frame_unref(s->second_last_frame);
1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
        av_frame_unref(s->cur_decode_frame);
        av_frame_unref(s->prev_decode_frame);
    }

    if (!s->cur_decode_frame->data[0]) {
        ret = ff_get_buffer(avctx, s->cur_decode_frame, 0);
        if (ret < 0)
            return ret;

        ret = ff_get_buffer(avctx, s->prev_decode_frame, 0);
        if (ret < 0) {
            av_frame_unref(s->cur_decode_frame);
            return ret;
        }
1231 1232
    }

1233
    if (buf_size < 8)
1234 1235
        return AVERROR_INVALIDDATA;

1236 1237 1238 1239
    frame_format         = AV_RL8(buf);
    send_buffer          = AV_RL8(buf + 1);
    video_data_size      = AV_RL16(buf + 2);
    s->decoding_map_size = AV_RL16(buf + 4);
1240
    s->skip_map_size     = AV_RL16(buf + 6);
1241

1242 1243 1244 1245 1246 1247
    switch(frame_format) {
        case 0x06:
            if (s->decoding_map_size) {
                av_log(avctx, AV_LOG_ERROR, "Decoding map for format 0x06\n");
                return AVERROR_INVALIDDATA;
            }
1248

1249 1250 1251 1252 1253
            if (s->skip_map_size) {
                av_log(avctx, AV_LOG_ERROR, "Skip map for format 0x06\n");
                return AVERROR_INVALIDDATA;
            }

1254 1255 1256 1257 1258 1259 1260
            if (s->is_16bpp) {
                av_log(avctx, AV_LOG_ERROR, "Video format 0x06 does not support 16bpp movies\n");
                return AVERROR_INVALIDDATA;
            }

            /* Decoding map for 0x06 frame format is at the top of pixeldata */
            s->decoding_map_size = ((s->avctx->width / 8) * (s->avctx->height / 8)) * 2;
1261
            s->decoding_map = buf + 8 + 14; /* 14 bits of op data */
1262
            video_data_size -= s->decoding_map_size + 14;
1263 1264
            if (video_data_size <= 0)
                return AVERROR_INVALIDDATA;
1265 1266 1267 1268

            if (buf_size < 8 + s->decoding_map_size + 14 + video_data_size)
                return AVERROR_INVALIDDATA;

1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
            bytestream2_init(&s->stream_ptr, buf + 8 + s->decoding_map_size + 14, video_data_size);

            break;

        case 0x10:
            if (! s->decoding_map_size) {
                av_log(avctx, AV_LOG_ERROR, "Empty decoding map for format 0x10\n");
                return AVERROR_INVALIDDATA;
            }

            if (! s->skip_map_size) {
                av_log(avctx, AV_LOG_ERROR, "Empty skip map for format 0x10\n");
                return AVERROR_INVALIDDATA;
            }

            if (s->is_16bpp) {
                av_log(avctx, AV_LOG_ERROR, "Video format 0x10 does not support 16bpp movies\n");
                return AVERROR_INVALIDDATA;
            }

1289 1290 1291
            if (buf_size < 8 + video_data_size + s->decoding_map_size + s->skip_map_size)
                return AVERROR_INVALIDDATA;

1292 1293 1294
            bytestream2_init(&s->stream_ptr, buf + 8, video_data_size);
            s->decoding_map = buf + 8 + video_data_size;
            s->skip_map = buf + 8 + video_data_size + s->decoding_map_size;
1295

1296
            break;
1297

1298 1299 1300 1301 1302 1303
        case 0x11:
            if (! s->decoding_map_size) {
                av_log(avctx, AV_LOG_ERROR, "Empty decoding map for format 0x11\n");
                return AVERROR_INVALIDDATA;
            }

1304 1305 1306 1307 1308
            if (s->skip_map_size) {
                av_log(avctx, AV_LOG_ERROR, "Skip map for format 0x11\n");
                return AVERROR_INVALIDDATA;
            }

1309 1310 1311
            if (buf_size < 8 + video_data_size + s->decoding_map_size)
                return AVERROR_INVALIDDATA;

1312 1313
            bytestream2_init(&s->stream_ptr, buf + 8, video_data_size);
            s->decoding_map = buf + 8 + video_data_size;
1314 1315 1316 1317 1318 1319

            break;

        default:
            av_log(avctx, AV_LOG_ERROR, "Frame type 0x%02X unsupported\n", frame_format);
    }
1320 1321

    /* ensure we can't overread the packet */
1322
    if (buf_size < 8 + s->decoding_map_size + video_data_size + s->skip_map_size) {
1323 1324 1325
        av_log(avctx, AV_LOG_ERROR, "Invalid IP packet size\n");
        return AVERROR_INVALIDDATA;
    }
1326

1327
    if ((ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF)) < 0)
1328
        return ret;
1329

1330
    if (!s->is_16bpp) {
1331 1332 1333
        int size;
        const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &size);
        if (pal && size == AVPALETTE_SIZE) {
1334
            frame->palette_has_changed = 1;
1335
            memcpy(s->pal, pal, AVPALETTE_SIZE);
1336 1337
        } else if (pal) {
            av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
1338
        }
1339 1340
    }

1341 1342 1343 1344
    switch(frame_format) {
        case 0x06:
            ipvideo_decode_format_06_opcodes(s, frame);
            break;
1345 1346 1347
        case 0x10:
            ipvideo_decode_format_10_opcodes(s, frame);
            break;
1348 1349 1350 1351
        case 0x11:
            ipvideo_decode_format_11_opcodes(s, frame);
            break;
    }
1352

1353
    *got_frame = send_buffer;
1354

1355
    /* shuffle frames */
1356 1357 1358 1359
    av_frame_unref(s->second_last_frame);
    FFSWAP(AVFrame*, s->second_last_frame, s->last_frame);
    if ((ret = av_frame_ref(s->last_frame, frame)) < 0)
        return ret;
1360

1361
    /* report that the buffer was completely consumed */
1362 1363 1364
    return buf_size;
}

1365
static av_cold int ipvideo_decode_end(AVCodecContext *avctx)
1366 1367 1368
{
    IpvideoContext *s = avctx->priv_data;

1369 1370
    av_frame_free(&s->last_frame);
    av_frame_free(&s->second_last_frame);
1371 1372
    av_frame_free(&s->cur_decode_frame);
    av_frame_free(&s->prev_decode_frame);
1373 1374 1375 1376

    return 0;
}

1377
AVCodec ff_interplay_video_decoder = {
1378
    .name           = "interplayvideo",
1379
    .long_name      = NULL_IF_CONFIG_SMALL("Interplay MVE video"),
1380
    .type           = AVMEDIA_TYPE_VIDEO,
1381
    .id             = AV_CODEC_ID_INTERPLAY_VIDEO,
1382 1383 1384 1385
    .priv_data_size = sizeof(IpvideoContext),
    .init           = ipvideo_decode_init,
    .close          = ipvideo_decode_end,
    .decode         = ipvideo_decode_frame,
1386
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_PARAM_CHANGE,
1387
};