motionpixels.c 11 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
/*
 * Motion Pixels Video Decoder
 * Copyright (c) 2008 Gregory Montoir (cyx@users.sourceforge.net)
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "avcodec.h"
23
#include "get_bits.h"
24
#include "bswapdsp.h"
25
#include "internal.h"
26 27 28

#define MAX_HUFF_CODES 16

29
#include "motionpixels_tablegen.h"
30 31 32 33 34 35 36 37 38

typedef struct HuffCode {
    int code;
    uint8_t size;
    uint8_t delta;
} HuffCode;

typedef struct MotionPixelsContext {
    AVCodecContext *avctx;
39
    AVFrame *frame;
40
    BswapDSPContext bdsp;
41 42 43 44 45 46 47 48 49 50 51 52
    uint8_t *changes_map;
    int offset_bits_len;
    int codes_count, current_codes_count;
    int max_codes_bits;
    HuffCode codes[MAX_HUFF_CODES];
    VLC vlc;
    YuvPixel *vpt, *hpt;
    uint8_t gradient_scale[3];
    uint8_t *bswapbuf;
    int bswapbuf_size;
} MotionPixelsContext;

53 54 55 56 57 58 59 60 61 62 63 64 65
static av_cold int mp_decode_end(AVCodecContext *avctx)
{
    MotionPixelsContext *mp = avctx->priv_data;

    av_freep(&mp->changes_map);
    av_freep(&mp->vpt);
    av_freep(&mp->hpt);
    av_freep(&mp->bswapbuf);
    av_frame_free(&mp->frame);

    return 0;
}

66 67 68
static av_cold int mp_decode_init(AVCodecContext *avctx)
{
    MotionPixelsContext *mp = avctx->priv_data;
69 70
    int w4 = (avctx->width  + 3) & ~3;
    int h4 = (avctx->height + 3) & ~3;
71

72 73 74 75 76
    if(avctx->extradata_size < 2){
        av_log(avctx, AV_LOG_ERROR, "extradata too small\n");
        return AVERROR_INVALIDDATA;
    }

77
    motionpixels_tableinit();
78
    mp->avctx = avctx;
79
    ff_bswapdsp_init(&mp->bdsp);
80
    mp->changes_map = av_mallocz_array(avctx->width, h4);
81
    mp->offset_bits_len = av_log2(avctx->width * avctx->height) + 1;
82 83
    mp->vpt = av_mallocz_array(avctx->height, sizeof(YuvPixel));
    mp->hpt = av_mallocz_array(h4 / 4, w4 / 4 * sizeof(YuvPixel));
84 85 86 87
    if (!mp->changes_map || !mp->vpt || !mp->hpt) {
        av_freep(&mp->changes_map);
        av_freep(&mp->vpt);
        av_freep(&mp->hpt);
88
        return AVERROR(ENOMEM);
89
    }
90
    avctx->pix_fmt = AV_PIX_FMT_RGB555;
91 92 93 94 95 96 97

    mp->frame = av_frame_alloc();
    if (!mp->frame) {
        mp_decode_end(avctx);
        return AVERROR(ENOMEM);
    }

98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117
    return 0;
}

static void mp_read_changes_map(MotionPixelsContext *mp, GetBitContext *gb, int count, int bits_len, int read_color)
{
    uint16_t *pixels;
    int offset, w, h, color = 0, x, y, i;

    while (count--) {
        offset = get_bits_long(gb, mp->offset_bits_len);
        w      = get_bits(gb, bits_len) + 1;
        h      = get_bits(gb, bits_len) + 1;
        if (read_color)
            color = get_bits(gb, 15);
        x = offset % mp->avctx->width;
        y = offset / mp->avctx->width;
        if (y >= mp->avctx->height)
            continue;
        w = FFMIN(w, mp->avctx->width  - x);
        h = FFMIN(h, mp->avctx->height - y);
118
        pixels = (uint16_t *)&mp->frame->data[0][y * mp->frame->linesize[0] + x * 2];
119 120 121 122 123 124
        while (h--) {
            mp->changes_map[offset] = w;
            if (read_color)
                for (i = 0; i < w; ++i)
                    pixels[i] = color;
            offset += mp->avctx->width;
125
            pixels += mp->frame->linesize[0] / 2;
126 127 128 129
        }
    }
}

130
static int mp_get_code(MotionPixelsContext *mp, GetBitContext *gb, int size, int code)
131 132 133 134 135
{
    while (get_bits1(gb)) {
        ++size;
        if (size > mp->max_codes_bits) {
            av_log(mp->avctx, AV_LOG_ERROR, "invalid code size %d/%d\n", size, mp->max_codes_bits);
136
            return AVERROR_INVALIDDATA;
137 138
        }
        code <<= 1;
139 140
        if (mp_get_code(mp, gb, size, code + 1) < 0)
            return AVERROR_INVALIDDATA;
141 142 143
    }
    if (mp->current_codes_count >= MAX_HUFF_CODES) {
        av_log(mp->avctx, AV_LOG_ERROR, "too many codes\n");
144
        return AVERROR_INVALIDDATA;
145
    }
146

147 148
    mp->codes[mp->current_codes_count  ].code = code;
    mp->codes[mp->current_codes_count++].size = size;
149
    return 0;
150 151
}

152
static int mp_read_codes_table(MotionPixelsContext *mp, GetBitContext *gb)
153 154 155 156 157
{
    if (mp->codes_count == 1) {
        mp->codes[0].delta = get_bits(gb, 4);
    } else {
        int i;
158
        int ret;
159 160 161 162 163

        mp->max_codes_bits = get_bits(gb, 4);
        for (i = 0; i < mp->codes_count; ++i)
            mp->codes[i].delta = get_bits(gb, 4);
        mp->current_codes_count = 0;
164 165
        if ((ret = mp_get_code(mp, gb, 0, 0)) < 0)
            return ret;
166 167 168 169
        if (mp->current_codes_count < mp->codes_count) {
            av_log(mp->avctx, AV_LOG_ERROR, "too few codes\n");
            return AVERROR_INVALIDDATA;
        }
170
   }
171
   return 0;
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
}

static int mp_gradient(MotionPixelsContext *mp, int component, int v)
{
    int delta;

    delta = (v - 7) * mp->gradient_scale[component];
    mp->gradient_scale[component] = (v == 0 || v == 14) ? 2 : 1;
    return delta;
}

static YuvPixel mp_get_yuv_from_rgb(MotionPixelsContext *mp, int x, int y)
{
    int color;

187
    color = *(uint16_t *)&mp->frame->data[0][y * mp->frame->linesize[0] + x * 2];
188 189 190 191 192 193 194 195
    return mp_rgb_yuv_table[color];
}

static void mp_set_rgb_from_yuv(MotionPixelsContext *mp, int x, int y, const YuvPixel *p)
{
    int color;

    color = mp_yuv_to_rgb(p->y, p->v, p->u, 1);
196
    *(uint16_t *)&mp->frame->data[0][y * mp->frame->linesize[0] + x * 2] = color;
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234
}

static int mp_get_vlc(MotionPixelsContext *mp, GetBitContext *gb)
{
    int i;

    i = (mp->codes_count == 1) ? 0 : get_vlc2(gb, mp->vlc.table, mp->max_codes_bits, 1);
    return mp->codes[i].delta;
}

static void mp_decode_line(MotionPixelsContext *mp, GetBitContext *gb, int y)
{
    YuvPixel p;
    const int y0 = y * mp->avctx->width;
    int w, i, x = 0;

    p = mp->vpt[y];
    if (mp->changes_map[y0 + x] == 0) {
        memset(mp->gradient_scale, 1, sizeof(mp->gradient_scale));
        ++x;
    }
    while (x < mp->avctx->width) {
        w = mp->changes_map[y0 + x];
        if (w != 0) {
            if ((y & 3) == 0) {
                if (mp->changes_map[y0 + x + mp->avctx->width] < w ||
                    mp->changes_map[y0 + x + mp->avctx->width * 2] < w ||
                    mp->changes_map[y0 + x + mp->avctx->width * 3] < w) {
                    for (i = (x + 3) & ~3; i < x + w; i += 4) {
                        mp->hpt[((y / 4) * mp->avctx->width + i) / 4] = mp_get_yuv_from_rgb(mp, i, y);
                    }
                }
            }
            x += w;
            memset(mp->gradient_scale, 1, sizeof(mp->gradient_scale));
            p = mp_get_yuv_from_rgb(mp, x - 1, y);
        } else {
            p.y += mp_gradient(mp, 0, mp_get_vlc(mp, gb));
235
            p.y = av_clip_uintp2(p.y, 5);
236 237 238
            if ((x & 3) == 0) {
                if ((y & 3) == 0) {
                    p.v += mp_gradient(mp, 1, mp_get_vlc(mp, gb));
239
                    p.v = av_clip_intp2(p.v, 5);
240
                    p.u += mp_gradient(mp, 2, mp_get_vlc(mp, gb));
241
                    p.u = av_clip_intp2(p.u, 5);
242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
                    mp->hpt[((y / 4) * mp->avctx->width + x) / 4] = p;
                } else {
                    p.v = mp->hpt[((y / 4) * mp->avctx->width + x) / 4].v;
                    p.u = mp->hpt[((y / 4) * mp->avctx->width + x) / 4].u;
                }
            }
            mp_set_rgb_from_yuv(mp, x, y, &p);
            ++x;
        }
    }
}

static void mp_decode_frame_helper(MotionPixelsContext *mp, GetBitContext *gb)
{
    YuvPixel p;
    int y, y0;

259 260
    av_assert1(mp->changes_map[0]);

261 262 263 264 265 266
    for (y = 0; y < mp->avctx->height; ++y) {
        if (mp->changes_map[y * mp->avctx->width] != 0) {
            memset(mp->gradient_scale, 1, sizeof(mp->gradient_scale));
            p = mp_get_yuv_from_rgb(mp, 0, y);
        } else {
            p.y += mp_gradient(mp, 0, mp_get_vlc(mp, gb));
267
            p.y = av_clip_uintp2(p.y, 5);
268 269
            if ((y & 3) == 0) {
                p.v += mp_gradient(mp, 1, mp_get_vlc(mp, gb));
270
                p.v = av_clip_intp2(p.v, 5);
271
                p.u += mp_gradient(mp, 2, mp_get_vlc(mp, gb));
272
                p.u = av_clip_intp2(p.u, 5);
273 274 275 276 277 278 279 280 281 282 283
            }
            mp->vpt[y] = p;
            mp_set_rgb_from_yuv(mp, 0, y, &p);
        }
    }
    for (y0 = 0; y0 < 2; ++y0)
        for (y = y0; y < mp->avctx->height; y += 2)
            mp_decode_line(mp, gb, y);
}

static int mp_decode_frame(AVCodecContext *avctx,
284
                                 void *data, int *got_frame,
285
                                 AVPacket *avpkt)
286
{
287 288
    const uint8_t *buf = avpkt->data;
    int buf_size = avpkt->size;
289 290
    MotionPixelsContext *mp = avctx->priv_data;
    GetBitContext gb;
291
    int i, count1, count2, sz, ret;
292

293
    if ((ret = ff_reget_buffer(avctx, mp->frame)) < 0)
294
        return ret;
295 296

    /* le32 bitstream msb first */
297
    av_fast_padded_malloc(&mp->bswapbuf, &mp->bswapbuf_size, buf_size);
298
    if (!mp->bswapbuf)
299
        return AVERROR(ENOMEM);
300 301
    mp->bdsp.bswap_buf((uint32_t *) mp->bswapbuf, (const uint32_t *) buf,
                       buf_size / 4);
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318
    if (buf_size & 3)
        memcpy(mp->bswapbuf + (buf_size & ~3), buf + (buf_size & ~3), buf_size & 3);
    init_get_bits(&gb, mp->bswapbuf, buf_size * 8);

    memset(mp->changes_map, 0, avctx->width * avctx->height);
    for (i = !(avctx->extradata[1] & 2); i < 2; ++i) {
        count1 = get_bits(&gb, 12);
        count2 = get_bits(&gb, 12);
        mp_read_changes_map(mp, &gb, count1, 8, i);
        mp_read_changes_map(mp, &gb, count2, 4, i);
    }

    mp->codes_count = get_bits(&gb, 4);
    if (mp->codes_count == 0)
        goto end;

    if (mp->changes_map[0] == 0) {
319
        *(uint16_t *)mp->frame->data[0] = get_bits(&gb, 15);
320 321
        mp->changes_map[0] = 1;
    }
322 323
    if (mp_read_codes_table(mp, &gb) < 0)
        goto end;
324 325 326 327 328 329 330

    sz = get_bits(&gb, 18);
    if (avctx->extradata[0] != 5)
        sz += get_bits(&gb, 18);
    if (sz == 0)
        goto end;

331 332
    if (mp->max_codes_bits <= 0)
        goto end;
333 334
    if (init_vlc(&mp->vlc, mp->max_codes_bits, mp->codes_count, &mp->codes[0].size, sizeof(HuffCode), 1, &mp->codes[0].code, sizeof(HuffCode), 4, 0))
        goto end;
335
    mp_decode_frame_helper(mp, &gb);
336
    ff_free_vlc(&mp->vlc);
337 338

end:
339
    if ((ret = av_frame_ref(data, mp->frame)) < 0)
340
        return ret;
341
    *got_frame       = 1;
342 343 344
    return buf_size;
}

345
AVCodec ff_motionpixels_decoder = {
346
    .name           = "motionpixels",
347
    .long_name      = NULL_IF_CONFIG_SMALL("Motion Pixels video"),
348
    .type           = AVMEDIA_TYPE_VIDEO,
349
    .id             = AV_CODEC_ID_MOTIONPIXELS,
350 351 352 353
    .priv_data_size = sizeof(MotionPixelsContext),
    .init           = mp_decode_init,
    .close          = mp_decode_end,
    .decode         = mp_decode_frame,
354
    .capabilities   = AV_CODEC_CAP_DR1,
355
};