git.sesse.net Git - ffmpeg/blob - libavcodec/imx.c

   1 /*
   2  * Copyright (c) 2021 Paul B Mahol
   3  *
   4  * This file is part of FFmpeg.
   5  *
   6  * FFmpeg is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * FFmpeg is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with FFmpeg; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  19  */
  20
  21 #include "libavutil/common.h"
  22 #include "avcodec.h"
  23 #include "bytestream.h"
  24 #include "internal.h"
  25
  26 typedef struct SimbiosisIMXContext {
  27     AVFrame *frame;
  28     uint32_t pal[256];
  29     uint8_t history[32768];
  30     int pos;
  31 } SimbiosisIMXContext;
  32
  33 static av_cold int imx_decode_init(AVCodecContext *avctx)
  34 {
  35     SimbiosisIMXContext *imx = avctx->priv_data;
  36
  37     avctx->pix_fmt = AV_PIX_FMT_PAL8;
  38     avctx->width   = 320;
  39     avctx->height  = 160;
  40
  41     imx->frame = av_frame_alloc();
  42     if (!imx->frame)
  43         return AVERROR(ENOMEM);
  44
  45     return 0;
  46 }
  47
  48 static int imx_decode_frame(AVCodecContext *avctx, void *data,
  49                             int *got_frame, AVPacket *avpkt)
  50 {
  51     SimbiosisIMXContext *imx = avctx->priv_data;
  52     int ret, x, y;
  53     buffer_size_t pal_size;
  54     const uint8_t *pal = av_packet_get_side_data(avpkt, AV_PKT_DATA_PALETTE, &pal_size);
  55     AVFrame *frame = imx->frame;
  56     GetByteContext gb;
  57
  58     if ((ret = ff_reget_buffer(avctx, frame, 0)) < 0)
  59         return ret;
  60
  61     if (pal && pal_size == AVPALETTE_SIZE) {
  62         memcpy(imx->pal, pal, pal_size);
  63         frame->palette_has_changed = 1;
  64         frame->key_frame = 1;
  65     } else {
  66         frame->key_frame = 0;
  67         frame->palette_has_changed = 0;
  68     }
  69
  70     bytestream2_init(&gb, avpkt->data, avpkt->size);
  71
  72     memcpy(frame->data[1], imx->pal, AVPALETTE_SIZE);
  73
  74     x = 0, y = 0;
  75     while (bytestream2_get_bytes_left(&gb) > 0 &&
  76            x < 320 && y < 160) {
  77         int b = bytestream2_get_byte(&gb);
  78         int len = b & 0x3f;
  79         int op = b >> 6;
  80         int fill;
  81
  82         switch (op) {
  83         case 3:
  84             len = len * 64 + bytestream2_get_byte(&gb);
  85         case 0:
  86             while (len > 0) {
  87                 x++;
  88                 len--;
  89                 if (x >= 320) {
  90                     x = 0;
  91                     y++;
  92                 }
  93                 if (y >= 160)
  94                     break;
  95             }
  96
  97             frame->key_frame = 0;
  98             break;
  99         case 1:
 100             if (len == 0) {
 101                 int offset = bytestream2_get_le16(&gb);
 102
 103                 if (offset < 0 || offset >= 32768)
 104                     return AVERROR_INVALIDDATA;
 105
 106                 len = bytestream2_get_byte(&gb);
 107                 while (len > 0 && offset < 32768) {
 108                     frame->data[0][x + y * frame->linesize[0]] = imx->history[offset++];
 109                     x++;
 110                     len--;
 111                     if (x >= 320) {
 112                         x = 0;
 113                         y++;
 114                     }
 115                     if (y >= 160)
 116                         break;
 117                 }
 118
 119                 frame->key_frame = 0;
 120             } else {
 121                 while (len > 0) {
 122                     fill = bytestream2_get_byte(&gb);
 123                     frame->data[0][x + y * frame->linesize[0]] = fill;
 124                     if (imx->pos < 32768)
 125                         imx->history[imx->pos++] = fill;
 126                     x++;
 127                     len--;
 128                     if (x >= 320) {
 129                         x = 0;
 130                         y++;
 131                     }
 132                     if (y >= 160)
 133                         break;
 134                 }
 135             }
 136             break;
 137         case 2:
 138             fill = bytestream2_get_byte(&gb);
 139
 140             while (len > 0) {
 141                 frame->data[0][x + y * frame->linesize[0]] = fill;
 142                 x++;
 143                 len--;
 144                 if (x >= 320) {
 145                     x = 0;
 146                     y++;
 147                 }
 148                 if (y >= 160)
 149                     break;
 150             }
 151             break;
 152         }
 153     }
 154
 155     frame->pict_type = frame->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
 156
 157     if ((ret = av_frame_ref(data, frame)) < 0)
 158         return ret;
 159
 160     *got_frame = 1;
 161
 162     return avpkt->size;
 163 }
 164
 165 static void imx_decode_flush(AVCodecContext *avctx)
 166 {
 167     SimbiosisIMXContext *imx = avctx->priv_data;
 168
 169     av_frame_unref(imx->frame);
 170     imx->pos = 0;
 171     memset(imx->pal, 0, sizeof(imx->pal));
 172     memset(imx->history, 0, sizeof(imx->history));
 173 }
 174
 175 static int imx_decode_close(AVCodecContext *avctx)
 176 {
 177     SimbiosisIMXContext *imx = avctx->priv_data;
 178
 179     av_frame_free(&imx->frame);
 180
 181     return 0;
 182 }
 183
 184 AVCodec ff_simbiosis_imx_decoder = {
 185     .name           = "simbiosis_imx",
 186     .long_name      = NULL_IF_CONFIG_SMALL("Simbiosis Interactive IMX Video"),
 187     .type           = AVMEDIA_TYPE_VIDEO,
 188     .id             = AV_CODEC_ID_SIMBIOSIS_IMX,
 189     .priv_data_size = sizeof(SimbiosisIMXContext),
 190     .init           = imx_decode_init,
 191     .decode         = imx_decode_frame,
 192     .close          = imx_decode_close,
 193     .flush          = imx_decode_flush,
 194     .capabilities   = AV_CODEC_CAP_DR1,
 195     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
 196                       FF_CODEC_CAP_INIT_CLEANUP,
 197 };