libavcodec/mmvideo.c

   1 /*
   2  * American Laser Games MM Video Decoder
   3  * Copyright (c) 2006 Peter Ross
   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 St, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22 /**
  23  * @file mm.c
  24  * American Laser Games MM Video Decoder
  25  * by Peter Ross (suxen_drol at hotmail dot com)
  26  *
  27  * The MM format was used by IBM-PC ports of ALG's "arcade shooter" games,
  28  * including Mad Dog McCree and Crime Patrol.
  29  *
  30  * Technical details here:
  31  *  http://wiki.multimedia.cx/index.php?title=American_Laser_Games_MM
  32  */
  33
  34 #include "avcodec.h"
  35
  36 #define MM_PREAMBLE_SIZE    6
  37
  38 #define MM_TYPE_INTER       0x5
  39 #define MM_TYPE_INTRA       0x8
  40 #define MM_TYPE_INTRA_HH    0xc
  41 #define MM_TYPE_INTER_HH    0xd
  42 #define MM_TYPE_INTRA_HHV   0xe
  43 #define MM_TYPE_INTER_HHV   0xf
  44
  45 typedef struct MmContext {
  46     AVCodecContext *avctx;
  47     AVFrame frame;
  48 } MmContext;
  49
  50 static int mm_decode_init(AVCodecContext *avctx)
  51 {
  52     MmContext *s = avctx->priv_data;
  53
  54     s->avctx = avctx;
  55
  56     if (s->avctx->palctrl == NULL) {
  57         av_log(avctx, AV_LOG_ERROR, "mmvideo: palette expected.\n");
  58         return -1;
  59     }
  60
  61     avctx->pix_fmt = PIX_FMT_PAL8;
  62     avctx->has_b_frames = 0;
  63
  64     if (avcodec_check_dimensions(avctx, avctx->width, avctx->height))
  65         return -1;
  66
  67     s->frame.reference = 1;
  68     if (avctx->get_buffer(avctx, &s->frame)) {
  69         av_log(s->avctx, AV_LOG_ERROR, "mmvideo: get_buffer() failed\n");
  70         return -1;
  71     }
  72
  73     return 0;
  74 }
  75
  76 static void mm_decode_intra(MmContext * s, int half_horiz, int half_vert, const uint8_t *buf, int buf_size)
  77 {
  78     int i, x, y;
  79     i=0; x=0; y=0;
  80
  81     while(i<buf_size) {
  82         int run_length, color;
  83
  84         if (buf[i] & 0x80) {
  85             run_length = 1;
  86             color = buf[i];
  87             i++;
  88         }else{
  89             run_length = (buf[i] & 0x7f) + 2;
  90             color = buf[i+1];
  91             i+=2;
  92         }
  93
  94         if (half_horiz)
  95             run_length *=2;
  96
  97         if (color) {
  98             memset(s->frame.data[0] + y*s->frame.linesize[0] + x, color, run_length);
  99             if (half_vert)
 100                 memset(s->frame.data[0] + (y+1)*s->frame.linesize[0] + x, color, run_length);
 101         }
 102         x+= run_length;
 103
 104         if (x >= s->avctx->width) {
 105             x=0;
 106             y += half_vert ? 2 : 1;
 107         }
 108     }
 109 }
 110
 111 static void mm_decode_inter(MmContext * s, int half_horiz, int half_vert, const uint8_t *buf, int buf_size)
 112 {
 113     const int data_ptr = 2 + AV_RL16(&buf[0]);
 114     int d, r, y;
 115     d = data_ptr; r = 2; y = 0;
 116
 117     while(r < data_ptr) {
 118         int i, j;
 119         int length = buf[r] & 0x7f;
 120         int x = buf[r+1] + ((buf[r] & 0x80) << 1);
 121         r += 2;
 122
 123         if (length==0) {
 124             y += x;
 125             continue;
 126         }
 127
 128         for(i=0; i<length; i++) {
 129             for(j=0; j<8; j++) {
 130                 int replace = (buf[r+i] >> (7-j)) & 1;
 131                 if (replace) {
 132                     int color = buf[d];
 133                     s->frame.data[0][y*s->frame.linesize[0] + x] = color;
 134                     if (half_horiz)
 135                         s->frame.data[0][y*s->frame.linesize[0] + x + 1] = color;
 136                     if (half_vert) {
 137                         s->frame.data[0][(y+1)*s->frame.linesize[0] + x] = color;
 138                         if (half_horiz)
 139                             s->frame.data[0][(y+1)*s->frame.linesize[0] + x + 1] = color;
 140                     }
 141                     d++;
 142                 }
 143                 x += half_horiz ? 2 : 1;
 144             }
 145         }
 146
 147         r += length;
 148         y += half_vert ? 2 : 1;
 149     }
 150 }
 151
 152 static int mm_decode_frame(AVCodecContext *avctx,
 153                             void *data, int *data_size,
 154                             uint8_t *buf, int buf_size)
 155 {
 156     MmContext *s = avctx->priv_data;
 157     AVPaletteControl *palette_control = avctx->palctrl;
 158     int type;
 159
 160     if (palette_control->palette_changed) {
 161         memcpy(s->frame.data[1], palette_control->palette, AVPALETTE_SIZE);
 162         palette_control->palette_changed = 0;
 163     }
 164
 165     type = AV_RL16(&buf[0]);
 166     buf += MM_PREAMBLE_SIZE;
 167     buf_size -= MM_PREAMBLE_SIZE;
 168
 169     switch(type) {
 170     case MM_TYPE_INTRA     : mm_decode_intra(s, 0, 0, buf, buf_size); break;
 171     case MM_TYPE_INTRA_HH  : mm_decode_intra(s, 1, 0, buf, buf_size); break;
 172     case MM_TYPE_INTRA_HHV : mm_decode_intra(s, 1, 1, buf, buf_size); break;
 173     case MM_TYPE_INTER     : mm_decode_inter(s, 0, 0, buf, buf_size); break;
 174     case MM_TYPE_INTER_HH  : mm_decode_inter(s, 1, 0, buf, buf_size); break;
 175     case MM_TYPE_INTER_HHV : mm_decode_inter(s, 1, 1, buf, buf_size); break;
 176     default :
 177         return -1;
 178     }
 179
 180     *data_size = sizeof(AVFrame);
 181     *(AVFrame*)data = s->frame;
 182
 183     return buf_size;
 184 }
 185
 186 static int mm_decode_end(AVCodecContext *avctx)
 187 {
 188     MmContext *s = avctx->priv_data;
 189
 190     if(s->frame.data[0])
 191         avctx->release_buffer(avctx, &s->frame);
 192
 193     return 0;
 194 }
 195
 196 AVCodec mmvideo_decoder = {
 197     "mmvideo",
 198     CODEC_TYPE_VIDEO,
 199     CODEC_ID_MMVIDEO,
 200     sizeof(MmContext),
 201     mm_decode_init,
 202     NULL,
 203     mm_decode_end,
 204     mm_decode_frame,
 205     CODEC_CAP_DR1,
 206 };