GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/imx.c Lines: 0 97 0.0 %
Date: 2021-04-20 15:25:36 Branches: 0 55 0.0 %

Line Branch Exec Source
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 "decode.h"
25
#include "internal.h"
26
27
typedef struct SimbiosisIMXContext {
28
    AVFrame *frame;
29
    uint32_t pal[256];
30
    uint8_t history[32768];
31
    int pos;
32
} SimbiosisIMXContext;
33
34
static av_cold int imx_decode_init(AVCodecContext *avctx)
35
{
36
    SimbiosisIMXContext *imx = avctx->priv_data;
37
38
    avctx->pix_fmt = AV_PIX_FMT_PAL8;
39
    avctx->width   = 320;
40
    avctx->height  = 160;
41
42
    imx->frame = av_frame_alloc();
43
    if (!imx->frame)
44
        return AVERROR(ENOMEM);
45
46
    return 0;
47
}
48
49
static int imx_decode_frame(AVCodecContext *avctx, void *data,
50
                            int *got_frame, AVPacket *avpkt)
51
{
52
    SimbiosisIMXContext *imx = avctx->priv_data;
53
    int ret, x, y;
54
    AVFrame *frame = imx->frame;
55
    GetByteContext gb;
56
57
    if ((ret = ff_reget_buffer(avctx, frame, 0)) < 0)
58
        return ret;
59
60
    if (ff_copy_palette(imx->pal, avpkt, avctx)) {
61
        frame->palette_has_changed = 1;
62
        frame->key_frame = 1;
63
    } else {
64
        frame->key_frame = 0;
65
        frame->palette_has_changed = 0;
66
    }
67
68
    bytestream2_init(&gb, avpkt->data, avpkt->size);
69
70
    memcpy(frame->data[1], imx->pal, AVPALETTE_SIZE);
71
72
    x = 0, y = 0;
73
    while (bytestream2_get_bytes_left(&gb) > 0 &&
74
           x < 320 && y < 160) {
75
        int b = bytestream2_get_byte(&gb);
76
        int len = b & 0x3f;
77
        int op = b >> 6;
78
        int fill;
79
80
        switch (op) {
81
        case 3:
82
            len = len * 64 + bytestream2_get_byte(&gb);
83
        case 0:
84
            while (len > 0) {
85
                x++;
86
                len--;
87
                if (x >= 320) {
88
                    x = 0;
89
                    y++;
90
                }
91
                if (y >= 160)
92
                    break;
93
            }
94
95
            frame->key_frame = 0;
96
            break;
97
        case 1:
98
            if (len == 0) {
99
                int offset = bytestream2_get_le16(&gb);
100
101
                if (offset < 0 || offset >= 32768)
102
                    return AVERROR_INVALIDDATA;
103
104
                len = bytestream2_get_byte(&gb);
105
                while (len > 0 && offset < 32768) {
106
                    frame->data[0][x + y * frame->linesize[0]] = imx->history[offset++];
107
                    x++;
108
                    len--;
109
                    if (x >= 320) {
110
                        x = 0;
111
                        y++;
112
                    }
113
                    if (y >= 160)
114
                        break;
115
                }
116
117
                frame->key_frame = 0;
118
            } else {
119
                while (len > 0) {
120
                    fill = bytestream2_get_byte(&gb);
121
                    frame->data[0][x + y * frame->linesize[0]] = fill;
122
                    if (imx->pos < 32768)
123
                        imx->history[imx->pos++] = fill;
124
                    x++;
125
                    len--;
126
                    if (x >= 320) {
127
                        x = 0;
128
                        y++;
129
                    }
130
                    if (y >= 160)
131
                        break;
132
                }
133
            }
134
            break;
135
        case 2:
136
            fill = bytestream2_get_byte(&gb);
137
138
            while (len > 0) {
139
                frame->data[0][x + y * frame->linesize[0]] = fill;
140
                x++;
141
                len--;
142
                if (x >= 320) {
143
                    x = 0;
144
                    y++;
145
                }
146
                if (y >= 160)
147
                    break;
148
            }
149
            break;
150
        }
151
    }
152
153
    frame->pict_type = frame->key_frame ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
154
155
    if ((ret = av_frame_ref(data, frame)) < 0)
156
        return ret;
157
158
    *got_frame = 1;
159
160
    return avpkt->size;
161
}
162
163
static void imx_decode_flush(AVCodecContext *avctx)
164
{
165
    SimbiosisIMXContext *imx = avctx->priv_data;
166
167
    av_frame_unref(imx->frame);
168
    imx->pos = 0;
169
    memset(imx->pal, 0, sizeof(imx->pal));
170
    memset(imx->history, 0, sizeof(imx->history));
171
}
172
173
static int imx_decode_close(AVCodecContext *avctx)
174
{
175
    SimbiosisIMXContext *imx = avctx->priv_data;
176
177
    av_frame_free(&imx->frame);
178
179
    return 0;
180
}
181
182
AVCodec ff_simbiosis_imx_decoder = {
183
    .name           = "simbiosis_imx",
184
    .long_name      = NULL_IF_CONFIG_SMALL("Simbiosis Interactive IMX Video"),
185
    .type           = AVMEDIA_TYPE_VIDEO,
186
    .id             = AV_CODEC_ID_SIMBIOSIS_IMX,
187
    .priv_data_size = sizeof(SimbiosisIMXContext),
188
    .init           = imx_decode_init,
189
    .decode         = imx_decode_frame,
190
    .close          = imx_decode_close,
191
    .flush          = imx_decode_flush,
192
    .capabilities   = AV_CODEC_CAP_DR1,
193
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE |
194
                      FF_CODEC_CAP_INIT_CLEANUP,
195
};