Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

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