flashsv.c 18.9 KB
Newer Older
1 2 3 4 5
/*
 * Flash Screen Video decoder
 * Copyright (C) 2004 Alex Beregszaszi
 * Copyright (C) 2006 Benjamin Larsson
 *
6 7 8
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
9 10
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
11
 * version 2.1 of the License, or (at your option) any later version.
12
 *
13
 * FFmpeg is distributed in the hope that it will be useful,
14 15 16 17 18
 * 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
19
 * License along with FFmpeg; if not, write to the Free Software
20 21 22 23
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
24
 * @file
25 26 27
 * Flash Screen Video decoder
 * @author Alex Beregszaszi
 * @author Benjamin Larsson
28 29
 * @author Daniel Verkamp
 * @author Konstantin Shishkov
30
 *
31 32 33
 * A description of the bitstream format for Flash Screen Video version 1/2
 * is part of the SWF File Format Specification (version 10), which can be
 * downloaded from http://www.adobe.com/devnet/swf.html.
34 35 36 37
 */

#include <stdio.h>
#include <stdlib.h>
38
#include <zlib.h>
39

40
#include "libavutil/intreadwrite.h"
41
#include "avcodec.h"
42
#include "bytestream.h"
43
#include "get_bits.h"
44
#include "internal.h"
45

46 47 48 49 50
typedef struct BlockInfo {
    uint8_t *pos;
    int      size;
} BlockInfo;

51 52
typedef struct FlashSVContext {
    AVCodecContext *avctx;
53 54 55 56 57 58
    AVFrame         frame;
    int             image_width, image_height;
    int             block_width, block_height;
    uint8_t        *tmpblock;
    int             block_size;
    z_stream        zstream;
59 60 61 62 63 64 65 66 67 68 69
    int             ver;
    const uint32_t *pal;
    int             is_keyframe;
    uint8_t        *keyframedata;
    uint8_t        *keyframe;
    BlockInfo      *blocks;
    uint8_t        *deflate_block;
    int             deflate_block_size;
    int             color_depth;
    int             zlibprime_curr, zlibprime_prev;
    int             diff_start, diff_height;
70 71 72
} FlashSVContext;


73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102
static int decode_hybrid(const uint8_t *sptr, uint8_t *dptr, int dx, int dy,
                         int h, int w, int stride, const uint32_t *pal)
{
    int x, y;
    const uint8_t *orig_src = sptr;

    for (y = dx+h; y > dx; y--) {
        uint8_t *dst = dptr + (y * stride) + dy * 3;
        for (x = 0; x < w; x++) {
            if (*sptr & 0x80) {
                /* 15-bit color */
                unsigned c = AV_RB16(sptr) & ~0x8000;
                unsigned b =  c        & 0x1F;
                unsigned g = (c >>  5) & 0x1F;
                unsigned r =  c >> 10;
                /* 000aaabb -> aaabbaaa  */
                *dst++ = (b << 3) | (b >> 2);
                *dst++ = (g << 3) | (g >> 2);
                *dst++ = (r << 3) | (r >> 2);
                sptr += 2;
            } else {
                /* palette index */
                uint32_t c = pal[*sptr++];
                bytestream_put_le24(&dst, c);
            }
        }
    }
    return sptr - orig_src;
}

103
static av_cold int flashsv_decode_init(AVCodecContext *avctx)
104
{
105
    FlashSVContext *s = avctx->priv_data;
106 107
    int zret; // Zlib return code

108
    s->avctx          = avctx;
109
    s->zstream.zalloc = Z_NULL;
110
    s->zstream.zfree  = Z_NULL;
111
    s->zstream.opaque = Z_NULL;
112
    zret = inflateInit(&s->zstream);
113 114 115 116
    if (zret != Z_OK) {
        av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
        return 1;
    }
117
    avctx->pix_fmt = AV_PIX_FMT_BGR24;
118
    avcodec_get_frame_defaults(&s->frame);
119 120 121 122 123

    return 0;
}


124
static int flashsv2_prime(FlashSVContext *s, uint8_t *src, int size)
125 126
{
    z_stream zs;
127
    int zret; // Zlib return code
128

129 130 131
    if (!src)
        return AVERROR_INVALIDDATA;

132 133 134 135 136 137 138 139 140 141
    zs.zalloc = NULL;
    zs.zfree  = NULL;
    zs.opaque = NULL;

    s->zstream.next_in   = src;
    s->zstream.avail_in  = size;
    s->zstream.next_out  = s->tmpblock;
    s->zstream.avail_out = s->block_size * 3;
    inflate(&s->zstream, Z_SYNC_FLUSH);

142 143
    if (deflateInit(&zs, 0) != Z_OK)
        return -1;
144 145 146 147 148 149 150
    zs.next_in   = s->tmpblock;
    zs.avail_in  = s->block_size * 3 - s->zstream.avail_out;
    zs.next_out  = s->deflate_block;
    zs.avail_out = s->deflate_block_size;
    deflate(&zs, Z_SYNC_FLUSH);
    deflateEnd(&zs);

151 152 153 154
    if ((zret = inflateReset(&s->zstream)) != Z_OK) {
        av_log(s->avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
        return AVERROR_UNKNOWN;
    }
155 156 157 158 159 160

    s->zstream.next_in   = s->deflate_block;
    s->zstream.avail_in  = s->deflate_block_size - zs.avail_out;
    s->zstream.next_out  = s->tmpblock;
    s->zstream.avail_out = s->block_size * 3;
    inflate(&s->zstream, Z_SYNC_FLUSH);
161 162

    return 0;
163 164
}

165 166
static int flashsv_decode_block(AVCodecContext *avctx, AVPacket *avpkt,
                                GetBitContext *gb, int block_size,
167 168
                                int width, int height, int x_pos, int y_pos,
                                int blk_idx)
169 170 171 172 173 174
{
    struct FlashSVContext *s = avctx->priv_data;
    uint8_t *line = s->tmpblock;
    int k;
    int ret = inflateReset(&s->zstream);
    if (ret != Z_OK) {
175 176
        av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
        return AVERROR_UNKNOWN;
177
    }
178
    if (s->zlibprime_curr || s->zlibprime_prev) {
179 180 181
        ret = flashsv2_prime(s,
                             s->blocks[blk_idx].pos,
                             s->blocks[blk_idx].size);
182 183
        if (ret < 0)
            return ret;
184
    }
185 186 187 188 189 190 191 192 193 194 195 196 197 198
    s->zstream.next_in   = avpkt->data + get_bits_count(gb) / 8;
    s->zstream.avail_in  = block_size;
    s->zstream.next_out  = s->tmpblock;
    s->zstream.avail_out = s->block_size * 3;
    ret = inflate(&s->zstream, Z_FINISH);
    if (ret == Z_DATA_ERROR) {
        av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");
        inflateSync(&s->zstream);
        ret = inflate(&s->zstream, Z_FINISH);
    }

    if (ret != Z_OK && ret != Z_STREAM_END) {
        //return -1;
    }
199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219

    if (s->is_keyframe) {
        s->blocks[blk_idx].pos      = s->keyframedata + (get_bits_count(gb) / 8);
        s->blocks[blk_idx].size     = block_size;
    }
    if (!s->color_depth) {
        /* Flash Screen Video stores the image upside down, so copy
         * lines to destination in reverse order. */
        for (k = 1; k <= s->diff_height; k++) {
            memcpy(s->frame.data[0] + x_pos * 3 +
                   (s->image_height - y_pos - s->diff_start - k) * s->frame.linesize[0],
                   line, width * 3);
            /* advance source pointer to next line */
            line += width * 3;
        }
    } else {
        /* hybrid 15-bit/palette mode */
        decode_hybrid(s->tmpblock, s->frame.data[0],
                      s->image_height - (y_pos + 1 + s->diff_start + s->diff_height),
                      x_pos, s->diff_height, width,
                      s->frame.linesize[0], s->pal);
220 221 222 223 224
    }
    skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */
    return 0;
}

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239
static int calc_deflate_block_size(int tmpblock_size)
{
    z_stream zstream;
    int size;

    zstream.zalloc = Z_NULL;
    zstream.zfree  = Z_NULL;
    zstream.opaque = Z_NULL;
    if (deflateInit(&zstream, 0) != Z_OK)
        return -1;
    size = deflateBound(&zstream, tmpblock_size);
    deflateEnd(&zstream);

    return size;
}
240

241
static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
242
                                int *got_frame, AVPacket *avpkt)
243
{
244 245
    int buf_size       = avpkt->size;
    FlashSVContext *s  = avctx->priv_data;
246
    int h_blocks, v_blocks, h_part, v_part, i, j, ret;
247
    GetBitContext gb;
248 249
    int last_blockwidth = s->block_width;
    int last_blockheight= s->block_height;
250 251 252 253

    /* no supplementary picture */
    if (buf_size == 0)
        return 0;
254 255
    if (buf_size < 4)
        return -1;
256

257
    init_get_bits(&gb, avpkt->data, buf_size * 8);
258 259

    /* start to parse the bitstream */
260 261 262 263
    s->block_width  = 16 * (get_bits(&gb,  4) + 1);
    s->image_width  =       get_bits(&gb, 12);
    s->block_height = 16 * (get_bits(&gb,  4) + 1);
    s->image_height =       get_bits(&gb, 12);
264

265 266 267 268
    if (   last_blockwidth != s->block_width
        || last_blockheight!= s->block_height)
        av_freep(&s->blocks);

269 270 271
    if (s->ver == 2) {
        skip_bits(&gb, 6);
        if (get_bits1(&gb)) {
272
            avpriv_request_sample(avctx, "iframe");
273 274 275
            return AVERROR_PATCHWELCOME;
        }
        if (get_bits1(&gb)) {
276
            avpriv_request_sample(avctx, "Custom palette");
277 278 279 280
            return AVERROR_PATCHWELCOME;
        }
    }

281
    /* calculate number of blocks and size of border (partial) blocks */
282 283
    h_blocks = s->image_width  / s->block_width;
    h_part   = s->image_width  % s->block_width;
284
    v_blocks = s->image_height / s->block_height;
285
    v_part   = s->image_height % s->block_height;
286 287 288

    /* the block size could change between frames, make sure the buffer
     * is large enough, if not, get a larger one */
289
    if (s->block_size < s->block_width * s->block_height) {
290 291 292 293
        int tmpblock_size = 3 * s->block_width * s->block_height;

        s->tmpblock = av_realloc(s->tmpblock, tmpblock_size);
        if (!s->tmpblock) {
294
            av_log(avctx, AV_LOG_ERROR, "Can't allocate decompression buffer.\n");
295
            return AVERROR(ENOMEM);
296
        }
297 298 299 300 301 302 303 304 305 306 307 308
        if (s->ver == 2) {
            s->deflate_block_size = calc_deflate_block_size(tmpblock_size);
            if (s->deflate_block_size <= 0) {
                av_log(avctx, AV_LOG_ERROR, "Can't determine deflate buffer size.\n");
                return -1;
            }
            s->deflate_block = av_realloc(s->deflate_block, s->deflate_block_size);
            if (!s->deflate_block) {
                av_log(avctx, AV_LOG_ERROR, "Can't allocate deflate buffer.\n");
                return AVERROR(ENOMEM);
            }
        }
309
    }
310
    s->block_size = s->block_width * s->block_height;
311

312
    /* initialize the image size once */
313
    if (avctx->width == 0 && avctx->height == 0) {
314
        avcodec_set_dimensions(avctx, s->image_width, s->image_height);
315 316 317
    }

    /* check for changes of image width and image height */
318
    if (avctx->width != s->image_width || avctx->height != s->image_height) {
319
        av_log(avctx, AV_LOG_ERROR,
320
               "Frame width or height differs from first frame!\n");
321 322
        av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d  vs  ch = %d, cv = %d\n",
               avctx->height, avctx->width, s->image_height, s->image_width);
323
        return AVERROR_INVALIDDATA;
324 325
    }

326 327 328 329 330 331
    /* we care for keyframes only in Screen Video v2 */
    s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2);
    if (s->is_keyframe) {
        s->keyframedata = av_realloc(s->keyframedata, avpkt->size);
        memcpy(s->keyframedata, avpkt->data, avpkt->size);
    }
332 333
    if(s->ver == 2 && !s->blocks)
        s->blocks = av_mallocz((v_blocks + !!v_part) * (h_blocks + !!h_part)
334
                                * sizeof(s->blocks[0]));
335

336 337 338
    av_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
            s->image_width, s->image_height, s->block_width, s->block_height,
            h_blocks, v_blocks, h_part, v_part);
339

340
    if ((ret = ff_reget_buffer(avctx, &s->frame)) < 0)
341
        return ret;
342 343

    /* loop over all block columns */
344
    for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
345

346 347
        int y_pos  = j * s->block_height; // vertical position in frame
        int cur_blk_height = (j < v_blocks) ? s->block_height : v_part;
348 349

        /* loop over all block rows */
350
        for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
351 352
            int x_pos = i * s->block_width; // horizontal position in frame
            int cur_blk_width = (i < h_blocks) ? s->block_width : h_part;
353
            int has_diff = 0;
354 355 356

            /* get the size of the compressed zlib chunk */
            int size = get_bits(&gb, 16);
357 358 359 360 361 362 363

            s->color_depth    = 0;
            s->zlibprime_curr = 0;
            s->zlibprime_prev = 0;
            s->diff_start     = 0;
            s->diff_height    = cur_blk_height;

364
            if (8 * size > get_bits_left(&gb)) {
365
                av_frame_unref(&s->frame);
366
                return AVERROR_INVALIDDATA;
367
            }
368

369 370 371 372 373 374 375 376 377 378
            if (s->ver == 2 && size) {
                skip_bits(&gb, 3);
                s->color_depth    = get_bits(&gb, 2);
                has_diff          = get_bits1(&gb);
                s->zlibprime_curr = get_bits1(&gb);
                s->zlibprime_prev = get_bits1(&gb);

                if (s->color_depth != 0 && s->color_depth != 2) {
                    av_log(avctx, AV_LOG_ERROR,
                           "%dx%d invalid color depth %d\n", i, j, s->color_depth);
379
                    return AVERROR_INVALIDDATA;
380 381 382
                }

                if (has_diff) {
383 384 385 386 387
                    if (!s->keyframe) {
                        av_log(avctx, AV_LOG_ERROR,
                               "inter frame without keyframe\n");
                        return AVERROR_INVALIDDATA;
                    }
388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403
                    s->diff_start  = get_bits(&gb, 8);
                    s->diff_height = get_bits(&gb, 8);
                    av_log(avctx, AV_LOG_DEBUG,
                           "%dx%d diff start %d height %d\n",
                           i, j, s->diff_start, s->diff_height);
                    size -= 2;
                }

                if (s->zlibprime_prev)
                    av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);

                if (s->zlibprime_curr) {
                    int col = get_bits(&gb, 8);
                    int row = get_bits(&gb, 8);
                    av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n", i, j, col, row);
                    size -= 2;
404
                    avpriv_request_sample(avctx, "zlibprime_curr");
405 406
                    return AVERROR_PATCHWELCOME;
                }
407 408 409 410 411
                if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
                    av_log(avctx, AV_LOG_ERROR, "no data available for zlib "
                           "priming\n");
                    return AVERROR_INVALIDDATA;
                }
412 413 414 415 416 417 418 419 420 421 422 423 424
                size--; // account for flags byte
            }

            if (has_diff) {
                int k;
                int off = (s->image_height - y_pos - 1) * s->frame.linesize[0];

                for (k = 0; k < cur_blk_height; k++)
                    memcpy(s->frame.data[0] + off - k*s->frame.linesize[0] + x_pos*3,
                           s->keyframe + off - k*s->frame.linesize[0] + x_pos*3,
                           cur_blk_width * 3);
            }

425 426
            /* skip unchanged blocks, which have size 0 */
            if (size) {
427 428
                if (flashsv_decode_block(avctx, avpkt, &gb, size,
                                         cur_blk_width, cur_blk_height,
429 430
                                         x_pos, y_pos,
                                         i + j * (h_blocks + !!h_part)))
431
                    av_log(avctx, AV_LOG_ERROR,
432
                           "error in decompression of block %dx%d\n", i, j);
433 434 435
            }
        }
    }
436 437 438 439 440 441 442 443 444 445
    if (s->is_keyframe && s->ver == 2) {
        if (!s->keyframe) {
            s->keyframe = av_malloc(s->frame.linesize[0] * avctx->height);
            if (!s->keyframe) {
                av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
                return AVERROR(ENOMEM);
            }
        }
        memcpy(s->keyframe, s->frame.data[0], s->frame.linesize[0] * avctx->height);
    }
446

447 448 449
    if ((ret = av_frame_ref(data, &s->frame)) < 0)
        return ret;

450
    *got_frame = 1;
451

452
    if ((get_bits_count(&gb) / 8) != buf_size)
453
        av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
454
               buf_size, (get_bits_count(&gb) / 8));
455 456 457 458 459 460

    /* report that the buffer was completely consumed */
    return buf_size;
}


461
static av_cold int flashsv_decode_end(AVCodecContext *avctx)
462
{
463
    FlashSVContext *s = avctx->priv_data;
464
    inflateEnd(&s->zstream);
465
    /* release the frame if needed */
466
    av_frame_unref(&s->frame);
467 468

    /* free the tmpblock */
469
    av_free(s->tmpblock);
470 471 472 473 474

    return 0;
}


475
#if CONFIG_FLASHSV_DECODER
476
AVCodec ff_flashsv_decoder = {
477 478
    .name           = "flashsv",
    .type           = AVMEDIA_TYPE_VIDEO,
479
    .id             = AV_CODEC_ID_FLASHSV,
480 481 482 483 484
    .priv_data_size = sizeof(FlashSVContext),
    .init           = flashsv_decode_init,
    .close          = flashsv_decode_end,
    .decode         = flashsv_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
485
    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
486
    .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
487
};
488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541
#endif /* CONFIG_FLASHSV_DECODER */

#if CONFIG_FLASHSV2_DECODER
static const uint32_t ff_flashsv2_default_palette[128] = {
    0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF,
    0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300,
    0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066,
    0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900,
    0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC,
    0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF,
    0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF,
    0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF,
    0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC,
    0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC,
    0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699,
    0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999,
    0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966,
    0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666,
    0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933,
    0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333,
    0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300,
    0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633,
    0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966,
    0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99,
    0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB,
    0xDDDDDD, 0xEEEEEE
};

static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
{
    FlashSVContext *s = avctx->priv_data;
    flashsv_decode_init(avctx);
    s->pal = ff_flashsv2_default_palette;
    s->ver = 2;

    return 0;
}

static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
{
    FlashSVContext *s = avctx->priv_data;

    av_freep(&s->keyframedata);
    av_freep(&s->blocks);
    av_freep(&s->keyframe);
    av_freep(&s->deflate_block);
    flashsv_decode_end(avctx);

    return 0;
}

AVCodec ff_flashsv2_decoder = {
    .name           = "flashsv2",
    .type           = AVMEDIA_TYPE_VIDEO,
542
    .id             = AV_CODEC_ID_FLASHSV2,
543 544 545 546 547
    .priv_data_size = sizeof(FlashSVContext),
    .init           = flashsv2_decode_init,
    .close          = flashsv2_decode_end,
    .decode         = flashsv_decode_frame,
    .capabilities   = CODEC_CAP_DR1,
548
    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
549 550 551
    .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
};
#endif /* CONFIG_FLASHSV2_DECODER */