← Back to branch summary

~ubuntu-branches/ubuntu/utopic/libav/utopic-proposed

« back to all changes in this revision

Viewing changes to libavcodec/bmvvideo.c

  • Committer: Package Import Robot
  • Author(s): Reinhard Tartler, Reinhard Tartler, Rico Tzschichholz
  • Date: 2014-08-30 11:02:45 UTC
  • mfrom: (1.3.47 sid)
  • Revision ID: package-import@ubuntu.com-20140830110245-io3dg7q85wfr7125
Tags: 6:11~beta1-2
[ Reinhard Tartler ]
* Make libavcodec-dev depend on libavresample-dev

[ Rico Tzschichholz ]
* Some fixes and leftovers from soname bumps

Show diffs side-by-side

added added

removed removed

Lines of Context:
libavcodec/bmvvideo.c
 
1
/*
 
2
 * Discworld II BMV video decoder
 
3
 * Copyright (c) 2011 Konstantin Shishkov
 
4
 *
 
5
 * This file is part of Libav.
 
6
 *
 
7
 * Libav 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
 * Libav 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 Libav; if not, write to the Free Software
 
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 
20
 */
 
21
 
 
22
#include "libavutil/common.h"
 
23
 
 
24
#include "avcodec.h"
 
25
#include "bytestream.h"
 
26
#include "internal.h"
 
27
 
 
28
enum BMVFlags{
 
29
    BMV_NOP = 0,
 
30
    BMV_END,
 
31
    BMV_DELTA,
 
32
    BMV_INTRA,
 
33
 
 
34
    BMV_SCROLL  = 0x04,
 
35
    BMV_PALETTE = 0x08,
 
36
    BMV_COMMAND = 0x10,
 
37
    BMV_AUDIO   = 0x20,
 
38
    BMV_EXT     = 0x40,
 
39
    BMV_PRINT   = 0x80
 
40
};
 
41
 
 
42
#define SCREEN_WIDE 640
 
43
#define SCREEN_HIGH 429
 
44
 
 
45
typedef struct BMVDecContext {
 
46
    AVCodecContext *avctx;
 
47
 
 
48
    uint8_t *frame, frame_base[SCREEN_WIDE * (SCREEN_HIGH + 1)];
 
49
    uint32_t pal[256];
 
50
    const uint8_t *stream;
 
51
} BMVDecContext;
 
52
 
 
53
#define NEXT_BYTE(v) v = forward ? v + 1 : v - 1;
 
54
 
 
55
static int decode_bmv_frame(const uint8_t *source, int src_len, uint8_t *frame, int frame_off)
 
56
{
 
57
    unsigned val, saved_val = 0;
 
58
    int tmplen = src_len;
 
59
    const uint8_t *src, *source_end = source + src_len;
 
60
    uint8_t *frame_end = frame + SCREEN_WIDE * SCREEN_HIGH;
 
61
    uint8_t *dst, *dst_end;
 
62
    int len, mask;
 
63
    int forward = (frame_off <= -SCREEN_WIDE) || (frame_off >= 0);
 
64
    int read_two_nibbles, flag;
 
65
    int advance_mode;
 
66
    int mode = 0;
 
67
    int i;
 
68
 
 
69
    if (src_len <= 0)
 
70
        return AVERROR_INVALIDDATA;
 
71
 
 
72
    if (forward) {
 
73
        src = source;
 
74
        dst = frame;
 
75
        dst_end = frame_end;
 
76
    } else {
 
77
        src = source + src_len - 1;
 
78
        dst = frame_end - 1;
 
79
        dst_end = frame - 1;
 
80
    }
 
81
    for (;;) {
 
82
        int shift = 0;
 
83
        flag = 0;
 
84
 
 
85
        /* The mode/len decoding is a bit strange:
 
86
         * values are coded as variable-length codes with nibble units,
 
87
         * code end is signalled by two top bits in the nibble being nonzero.
 
88
         * And since data is bytepacked and we read two nibbles at a time,
 
89
         * we may get a nibble belonging to the next code.
 
90
         * Hence this convoluted loop.
 
91
         */
 
92
        if (!mode || (tmplen == 4)) {
 
93
            if (src < source || src >= source_end)
 
94
                return AVERROR_INVALIDDATA;
 
95
            val = *src;
 
96
            read_two_nibbles = 1;
 
97
        } else {
 
98
            val = saved_val;
 
99
            read_two_nibbles = 0;
 
100
        }
 
101
        if (!(val & 0xC)) {
 
102
            for (;;) {
 
103
                if (!read_two_nibbles) {
 
104
                    if (src < source || src >= source_end)
 
105
                        return AVERROR_INVALIDDATA;
 
106
                    shift += 2;
 
107
                    val |= *src << shift;
 
108
                    if (*src & 0xC)
 
109
                        break;
 
110
                }
 
111
                // two upper bits of the nibble is zero,
 
112
                // so shift top nibble value down into their place
 
113
                read_two_nibbles = 0;
 
114
                shift += 2;
 
115
                mask = (1 << shift) - 1;
 
116
                val = ((val >> 2) & ~mask) | (val & mask);
 
117
                NEXT_BYTE(src);
 
118
                if ((val & (0xC << shift))) {
 
119
                    flag = 1;
 
120
                    break;
 
121
                }
 
122
            }
 
123
        } else if (mode) {
 
124
            flag = tmplen != 4;
 
125
        }
 
126
        if (flag) {
 
127
            tmplen = 4;
 
128
        } else {
 
129
            saved_val = val >> (4 + shift);
 
130
            tmplen = 0;
 
131
            val &= (1 << (shift + 4)) - 1;
 
132
            NEXT_BYTE(src);
 
133
        }
 
134
        advance_mode = val & 1;
 
135
        len = (val >> 1) - 1;
 
136
        mode += 1 + advance_mode;
 
137
        if (mode >= 4)
 
138
            mode -= 3;
 
139
        if (len <= 0 || FFABS(dst_end - dst) < len)
 
140
            return AVERROR_INVALIDDATA;
 
141
        switch (mode) {
 
142
        case 1:
 
143
            if (forward) {
 
144
                if (dst - frame + SCREEN_WIDE < frame_off ||
 
145
                        dst - frame + SCREEN_WIDE + frame_off < 0 ||
 
146
                        frame_end - dst < frame_off + len ||
 
147
                        frame_end - dst < len)
 
148
                    return AVERROR_INVALIDDATA;
 
149
                for (i = 0; i < len; i++)
 
150
                    dst[i] = dst[frame_off + i];
 
151
                dst += len;
 
152
            } else {
 
153
                dst -= len;
 
154
                if (dst - frame + SCREEN_WIDE < frame_off ||
 
155
                        dst - frame + SCREEN_WIDE + frame_off < 0 ||
 
156
                        frame_end - dst < frame_off + len ||
 
157
                        frame_end - dst < len)
 
158
                    return AVERROR_INVALIDDATA;
 
159
                for (i = len - 1; i >= 0; i--)
 
160
                    dst[i] = dst[frame_off + i];
 
161
            }
 
162
            break;
 
163
        case 2:
 
164
            if (forward) {
 
165
                if (source + src_len - src < len)
 
166
                    return AVERROR_INVALIDDATA;
 
167
                memcpy(dst, src, len);
 
168
                dst += len;
 
169
                src += len;
 
170
            } else {
 
171
                if (src - source < len)
 
172
                    return AVERROR_INVALIDDATA;
 
173
                dst -= len;
 
174
                src -= len;
 
175
                memcpy(dst, src, len);
 
176
            }
 
177
            break;
 
178
        case 3:
 
179
            val = forward ? dst[-1] : dst[1];
 
180
            if (forward) {
 
181
                memset(dst, val, len);
 
182
                dst += len;
 
183
            } else {
 
184
                dst -= len;
 
185
                memset(dst, val, len);
 
186
            }
 
187
            break;
 
188
        default:
 
189
            break;
 
190
        }
 
191
        if (dst == dst_end)
 
192
            return 0;
 
193
    }
 
194
    return 0;
 
195
}
 
196
 
 
197
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 
198
                        AVPacket *pkt)
 
199
{
 
200
    BMVDecContext * const c = avctx->priv_data;
 
201
    AVFrame *frame = data;
 
202
    int type, scr_off;
 
203
    int i, ret;
 
204
    uint8_t *srcptr, *outptr;
 
205
 
 
206
    c->stream = pkt->data;
 
207
    type = bytestream_get_byte(&c->stream);
 
208
    if (type & BMV_AUDIO) {
 
209
        int blobs = bytestream_get_byte(&c->stream);
 
210
        if (pkt->size < blobs * 65 + 2) {
 
211
            av_log(avctx, AV_LOG_ERROR, "Audio data doesn't fit in frame\n");
 
212
            return AVERROR_INVALIDDATA;
 
213
        }
 
214
        c->stream += blobs * 65;
 
215
    }
 
216
    if (type & BMV_COMMAND) {
 
217
        int command_size = (type & BMV_PRINT) ? 8 : 10;
 
218
        if (c->stream - pkt->data + command_size > pkt->size) {
 
219
            av_log(avctx, AV_LOG_ERROR, "Command data doesn't fit in frame\n");
 
220
            return AVERROR_INVALIDDATA;
 
221
        }
 
222
        c->stream += command_size;
 
223
    }
 
224
    if (type & BMV_PALETTE) {
 
225
        if (c->stream - pkt->data > pkt->size - 768) {
 
226
            av_log(avctx, AV_LOG_ERROR, "Palette data doesn't fit in frame\n");
 
227
            return AVERROR_INVALIDDATA;
 
228
        }
 
229
        for (i = 0; i < 256; i++)
 
230
            c->pal[i] = bytestream_get_be24(&c->stream);
 
231
    }
 
232
    if (type & BMV_SCROLL) {
 
233
        if (c->stream - pkt->data > pkt->size - 2) {
 
234
            av_log(avctx, AV_LOG_ERROR, "Screen offset data doesn't fit in frame\n");
 
235
            return AVERROR_INVALIDDATA;
 
236
        }
 
237
        scr_off = (int16_t)bytestream_get_le16(&c->stream);
 
238
    } else if ((type & BMV_INTRA) == BMV_INTRA) {
 
239
        scr_off = -640;
 
240
    } else {
 
241
        scr_off = 0;
 
242
    }
 
243
 
 
244
    if ((ret = ff_get_buffer(avctx, frame, 0)) < 0) {
 
245
        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 
246
        return ret;
 
247
    }
 
248
 
 
249
    if (decode_bmv_frame(c->stream, pkt->size - (c->stream - pkt->data), c->frame, scr_off)) {
 
250
        av_log(avctx, AV_LOG_ERROR, "Error decoding frame data\n");
 
251
        return AVERROR_INVALIDDATA;
 
252
    }
 
253
 
 
254
    memcpy(frame->data[1], c->pal, AVPALETTE_SIZE);
 
255
    frame->palette_has_changed = type & BMV_PALETTE;
 
256
 
 
257
    outptr = frame->data[0];
 
258
    srcptr = c->frame;
 
259
 
 
260
    for (i = 0; i < avctx->height; i++) {
 
261
        memcpy(outptr, srcptr, avctx->width);
 
262
        srcptr += avctx->width;
 
263
        outptr += frame->linesize[0];
 
264
    }
 
265
 
 
266
    *got_frame = 1;
 
267
 
 
268
    /* always report that the buffer was completely consumed */
 
269
    return pkt->size;
 
270
}
 
271
 
 
272
static av_cold int decode_init(AVCodecContext *avctx)
 
273
{
 
274
    BMVDecContext * const c = avctx->priv_data;
 
275
 
 
276
    c->avctx = avctx;
 
277
    avctx->pix_fmt = AV_PIX_FMT_PAL8;
 
278
 
 
279
    c->frame = c->frame_base + 640;
 
280
 
 
281
    return 0;
 
282
}
 
283
 
 
284
AVCodec ff_bmv_video_decoder = {
 
285
    .name           = "bmv_video",
 
286
    .long_name      = NULL_IF_CONFIG_SMALL("Discworld II BMV video"),
 
287
    .type           = AVMEDIA_TYPE_VIDEO,
 
288
    .id             = AV_CODEC_ID_BMV_VIDEO,
 
289
    .priv_data_size = sizeof(BMVDecContext),
 
290
    .init           = decode_init,
 
291
    .decode         = decode_frame,
 
292
    .capabilities   = CODEC_CAP_DR1,
 
293
};