Merge commit '8b8899ac3233b4f7af83ded0dc032fad8902d714'
[ffmpeg.git] / libavcodec / flashsv.c
1 /*
2  * Flash Screen Video decoder
3  * Copyright (C) 2004 Alex Beregszaszi
4  * Copyright (C) 2006 Benjamin Larsson
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * 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  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16  * Lesser General Public License for more details.
17  *
18  * 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  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22
23 /**
24  * @file
25  * Flash Screen Video decoder
26  * @author Alex Beregszaszi
27  * @author Benjamin Larsson
28  * @author Daniel Verkamp
29  * @author Konstantin Shishkov
30  *
31  * A description of the bitstream format for Flash Screen Video version 1/2
32  * is part of the SWF File Format Specification (version 10), which can be
33  * downloaded from http://www.adobe.com/devnet/swf.html.
34  */
35
36 #include <stdio.h>
37 #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
45 typedef struct BlockInfo {
46     uint8_t *pos;
47     int      size;
48     int      unp_size;
49 } BlockInfo;
50
51 typedef struct FlashSVContext {
52     AVCodecContext *avctx;
53     AVFrame         frame;
54     int             image_width, image_height;
55     int             block_width, block_height;
56     uint8_t        *tmpblock;
57     int             block_size;
58     z_stream        zstream;
59     int             ver;
60     const uint32_t *pal;
61     int             is_keyframe;
62     uint8_t        *keyframedata;
63     uint8_t        *keyframe;
64     BlockInfo      *blocks;
65     uint8_t        *deflate_block;
66     int             deflate_block_size;
67     int             color_depth;
68     int             zlibprime_curr, zlibprime_prev;
69     int             diff_start, diff_height;
70 } FlashSVContext;
71
72
73 static int decode_hybrid(const uint8_t *sptr, uint8_t *dptr, int dx, int dy,
74                          int h, int w, int stride, const uint32_t *pal)
75 {
76     int x, y;
77     const uint8_t *orig_src = sptr;
78
79     for (y = dx+h; y > dx; y--) {
80         uint8_t *dst = dptr + (y * stride) + dy * 3;
81         for (x = 0; x < w; x++) {
82             if (*sptr & 0x80) {
83                 /* 15-bit color */
84                 unsigned c = AV_RB16(sptr) & ~0x8000;
85                 unsigned b =  c        & 0x1F;
86                 unsigned g = (c >>  5) & 0x1F;
87                 unsigned r =  c >> 10;
88                 /* 000aaabb -> aaabbaaa  */
89                 *dst++ = (b << 3) | (b >> 2);
90                 *dst++ = (g << 3) | (g >> 2);
91                 *dst++ = (r << 3) | (r >> 2);
92                 sptr += 2;
93             } else {
94                 /* palette index */
95                 uint32_t c = pal[*sptr++];
96                 bytestream_put_le24(&dst, c);
97             }
98         }
99     }
100     return sptr - orig_src;
101 }
102
103 static av_cold int flashsv_decode_init(AVCodecContext *avctx)
104 {
105     FlashSVContext *s = avctx->priv_data;
106     int zret; // Zlib return code
107
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     if (zret != Z_OK) {
114         av_log(avctx, AV_LOG_ERROR, "Inflate init error: %d\n", zret);
115         return 1;
116     }
117     avctx->pix_fmt = AV_PIX_FMT_BGR24;
118     avcodec_get_frame_defaults(&s->frame);
119     s->frame.data[0] = NULL;
120
121     return 0;
122 }
123
124
125 static int flashsv2_prime(FlashSVContext *s, uint8_t *src,
126                           int size, int unp_size)
127 {
128     z_stream zs;
129     int zret; // Zlib return code
130
131     zs.zalloc = NULL;
132     zs.zfree  = NULL;
133     zs.opaque = NULL;
134
135     s->zstream.next_in   = src;
136     s->zstream.avail_in  = size;
137     s->zstream.next_out  = s->tmpblock;
138     s->zstream.avail_out = s->block_size * 3;
139     inflate(&s->zstream, Z_SYNC_FLUSH);
140
141     if (deflateInit(&zs, 0) != Z_OK)
142         return -1;
143     zs.next_in   = s->tmpblock;
144     zs.avail_in  = s->block_size * 3 - s->zstream.avail_out;
145     zs.next_out  = s->deflate_block;
146     zs.avail_out = s->deflate_block_size;
147     deflate(&zs, Z_SYNC_FLUSH);
148     deflateEnd(&zs);
149
150     if ((zret = inflateReset(&s->zstream)) != Z_OK) {
151         av_log(s->avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", zret);
152         return AVERROR_UNKNOWN;
153     }
154
155     s->zstream.next_in   = s->deflate_block;
156     s->zstream.avail_in  = s->deflate_block_size - zs.avail_out;
157     s->zstream.next_out  = s->tmpblock;
158     s->zstream.avail_out = s->block_size * 3;
159     inflate(&s->zstream, Z_SYNC_FLUSH);
160
161     return 0;
162 }
163
164 static int flashsv_decode_block(AVCodecContext *avctx, AVPacket *avpkt,
165                                 GetBitContext *gb, int block_size,
166                                 int width, int height, int x_pos, int y_pos,
167                                 int blk_idx)
168 {
169     struct FlashSVContext *s = avctx->priv_data;
170     uint8_t *line = s->tmpblock;
171     int k;
172     int ret = inflateReset(&s->zstream);
173     if (ret != Z_OK) {
174         av_log(avctx, AV_LOG_ERROR, "Inflate reset error: %d\n", ret);
175         return AVERROR_UNKNOWN;
176     }
177     if (s->zlibprime_curr || s->zlibprime_prev) {
178         ret = flashsv2_prime(s, s->blocks[blk_idx].pos, s->blocks[blk_idx].size,
179                        s->blocks[blk_idx].unp_size);
180         if (ret < 0)
181             return ret;
182     }
183     s->zstream.next_in   = avpkt->data + get_bits_count(gb) / 8;
184     s->zstream.avail_in  = block_size;
185     s->zstream.next_out  = s->tmpblock;
186     s->zstream.avail_out = s->block_size * 3;
187     ret = inflate(&s->zstream, Z_FINISH);
188     if (ret == Z_DATA_ERROR) {
189         av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");
190         inflateSync(&s->zstream);
191         ret = inflate(&s->zstream, Z_FINISH);
192     }
193
194     if (ret != Z_OK && ret != Z_STREAM_END) {
195         //return -1;
196     }
197
198     if (s->is_keyframe) {
199         s->blocks[blk_idx].pos      = s->keyframedata + (get_bits_count(gb) / 8);
200         s->blocks[blk_idx].size     = block_size;
201         s->blocks[blk_idx].unp_size = s->block_size * 3 - s->zstream.avail_out;
202     }
203     if (!s->color_depth) {
204         /* Flash Screen Video stores the image upside down, so copy
205          * lines to destination in reverse order. */
206         for (k = 1; k <= s->diff_height; k++) {
207             memcpy(s->frame.data[0] + x_pos * 3 +
208                    (s->image_height - y_pos - s->diff_start - k) * s->frame.linesize[0],
209                    line, width * 3);
210             /* advance source pointer to next line */
211             line += width * 3;
212         }
213     } else {
214         /* hybrid 15-bit/palette mode */
215         decode_hybrid(s->tmpblock, s->frame.data[0],
216                       s->image_height - (y_pos + 1 + s->diff_start + s->diff_height),
217                       x_pos, s->diff_height, width,
218                       s->frame.linesize[0], s->pal);
219     }
220     skip_bits_long(gb, 8 * block_size); /* skip the consumed bits */
221     return 0;
222 }
223
224 static int calc_deflate_block_size(int tmpblock_size)
225 {
226     z_stream zstream;
227     int size;
228
229     zstream.zalloc = Z_NULL;
230     zstream.zfree  = Z_NULL;
231     zstream.opaque = Z_NULL;
232     if (deflateInit(&zstream, 0) != Z_OK)
233         return -1;
234     size = deflateBound(&zstream, tmpblock_size);
235     deflateEnd(&zstream);
236
237     return size;
238 }
239
240 static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
241                                 int *data_size, AVPacket *avpkt)
242 {
243     int buf_size       = avpkt->size;
244     FlashSVContext *s  = avctx->priv_data;
245     int h_blocks, v_blocks, h_part, v_part, i, j;
246     GetBitContext gb;
247
248     /* no supplementary picture */
249     if (buf_size == 0)
250         return 0;
251     if (buf_size < 4)
252         return -1;
253
254     init_get_bits(&gb, avpkt->data, buf_size * 8);
255
256     /* start to parse the bitstream */
257     s->block_width  = 16 * (get_bits(&gb,  4) + 1);
258     s->image_width  =       get_bits(&gb, 12);
259     s->block_height = 16 * (get_bits(&gb,  4) + 1);
260     s->image_height =       get_bits(&gb, 12);
261
262     if (s->ver == 2) {
263         skip_bits(&gb, 6);
264         if (get_bits1(&gb)) {
265             av_log_missing_feature(avctx, "iframe", 1);
266             return AVERROR_PATCHWELCOME;
267         }
268         if (get_bits1(&gb)) {
269             av_log_missing_feature(avctx, "Custom palette", 1);
270             return AVERROR_PATCHWELCOME;
271         }
272     }
273
274     /* calculate number of blocks and size of border (partial) blocks */
275     h_blocks = s->image_width  / s->block_width;
276     h_part   = s->image_width  % s->block_width;
277     v_blocks = s->image_height / s->block_height;
278     v_part   = s->image_height % s->block_height;
279
280     /* the block size could change between frames, make sure the buffer
281      * is large enough, if not, get a larger one */
282     if (s->block_size < s->block_width * s->block_height) {
283         int tmpblock_size = 3 * s->block_width * s->block_height;
284
285         s->tmpblock = av_realloc(s->tmpblock, tmpblock_size);
286         if (!s->tmpblock) {
287             av_log(avctx, AV_LOG_ERROR, "Can't allocate decompression buffer.\n");
288             return AVERROR(ENOMEM);
289         }
290         if (s->ver == 2) {
291             s->deflate_block_size = calc_deflate_block_size(tmpblock_size);
292             if (s->deflate_block_size <= 0) {
293                 av_log(avctx, AV_LOG_ERROR, "Can't determine deflate buffer size.\n");
294                 return -1;
295             }
296             s->deflate_block = av_realloc(s->deflate_block, s->deflate_block_size);
297             if (!s->deflate_block) {
298                 av_log(avctx, AV_LOG_ERROR, "Can't allocate deflate buffer.\n");
299                 return AVERROR(ENOMEM);
300             }
301         }
302     }
303     s->block_size = s->block_width * s->block_height;
304
305     /* initialize the image size once */
306     if (avctx->width == 0 && avctx->height == 0) {
307         avctx->width  = s->image_width;
308         avctx->height = s->image_height;
309     }
310
311     /* check for changes of image width and image height */
312     if (avctx->width != s->image_width || avctx->height != s->image_height) {
313         av_log(avctx, AV_LOG_ERROR,
314                "Frame width or height differs from first frame!\n");
315         av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d  vs  ch = %d, cv = %d\n",
316                avctx->height, avctx->width, s->image_height, s->image_width);
317         return AVERROR_INVALIDDATA;
318     }
319
320     /* we care for keyframes only in Screen Video v2 */
321     s->is_keyframe = (avpkt->flags & AV_PKT_FLAG_KEY) && (s->ver == 2);
322     if (s->is_keyframe) {
323         s->keyframedata = av_realloc(s->keyframedata, avpkt->size);
324         memcpy(s->keyframedata, avpkt->data, avpkt->size);
325         s->blocks = av_realloc(s->blocks,
326                                (v_blocks + !!v_part) * (h_blocks + !!h_part)
327                                * sizeof(s->blocks[0]));
328     }
329
330     av_dlog(avctx, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
331             s->image_width, s->image_height, s->block_width, s->block_height,
332             h_blocks, v_blocks, h_part, v_part);
333
334     s->frame.reference    = 3;
335     s->frame.buffer_hints = FF_BUFFER_HINTS_VALID    |
336                             FF_BUFFER_HINTS_PRESERVE |
337                             FF_BUFFER_HINTS_REUSABLE;
338     if (avctx->reget_buffer(avctx, &s->frame) < 0) {
339         av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
340         return -1;
341     }
342
343     /* loop over all block columns */
344     for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
345
346         int y_pos  = j * s->block_height; // vertical position in frame
347         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             int x_pos = i * s->block_width; // horizontal position in frame
352             int cur_blk_width = (i < h_blocks) ? s->block_width : h_part;
353             int has_diff = 0;
354
355             /* get the size of the compressed zlib chunk */
356             int size = get_bits(&gb, 16);
357
358             s->color_depth    = 0;
359             s->zlibprime_curr = 0;
360             s->zlibprime_prev = 0;
361             s->diff_start     = 0;
362             s->diff_height    = cur_blk_height;
363
364             if (8 * size > get_bits_left(&gb)) {
365                 avctx->release_buffer(avctx, &s->frame);
366                 s->frame.data[0] = NULL;
367                 return AVERROR_INVALIDDATA;
368             }
369
370             if (s->ver == 2 && size) {
371                 skip_bits(&gb, 3);
372                 s->color_depth    = get_bits(&gb, 2);
373                 has_diff          = get_bits1(&gb);
374                 s->zlibprime_curr = get_bits1(&gb);
375                 s->zlibprime_prev = get_bits1(&gb);
376
377                 if (s->color_depth != 0 && s->color_depth != 2) {
378                     av_log(avctx, AV_LOG_ERROR,
379                            "%dx%d invalid color depth %d\n", i, j, s->color_depth);
380                     return AVERROR_INVALIDDATA;
381                 }
382
383                 if (has_diff) {
384                     s->diff_start  = get_bits(&gb, 8);
385                     s->diff_height = get_bits(&gb, 8);
386                     av_log(avctx, AV_LOG_DEBUG,
387                            "%dx%d diff start %d height %d\n",
388                            i, j, s->diff_start, s->diff_height);
389                     size -= 2;
390                 }
391
392                 if (s->zlibprime_prev)
393                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
394
395                 if (s->zlibprime_curr) {
396                     int col = get_bits(&gb, 8);
397                     int row = get_bits(&gb, 8);
398                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n", i, j, col, row);
399                     size -= 2;
400                     av_log_missing_feature(avctx, "zlibprime_curr", 1);
401                     return AVERROR_PATCHWELCOME;
402                 }
403                 size--; // account for flags byte
404             }
405
406             if (has_diff) {
407                 int k;
408                 int off = (s->image_height - y_pos - 1) * s->frame.linesize[0];
409
410                 for (k = 0; k < cur_blk_height; k++)
411                     memcpy(s->frame.data[0] + off - k*s->frame.linesize[0] + x_pos*3,
412                            s->keyframe + off - k*s->frame.linesize[0] + x_pos*3,
413                            cur_blk_width * 3);
414             }
415
416             /* skip unchanged blocks, which have size 0 */
417             if (size) {
418                 if (flashsv_decode_block(avctx, avpkt, &gb, size,
419                                          cur_blk_width, cur_blk_height,
420                                          x_pos, y_pos,
421                                          i + j * (h_blocks + !!h_part)))
422                     av_log(avctx, AV_LOG_ERROR,
423                            "error in decompression of block %dx%d\n", i, j);
424             }
425         }
426     }
427     if (s->is_keyframe && s->ver == 2) {
428         if (!s->keyframe) {
429             s->keyframe = av_malloc(s->frame.linesize[0] * avctx->height);
430             if (!s->keyframe) {
431                 av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
432                 return AVERROR(ENOMEM);
433             }
434         }
435         memcpy(s->keyframe, s->frame.data[0], s->frame.linesize[0] * avctx->height);
436     }
437
438     *data_size = sizeof(AVFrame);
439     *(AVFrame*)data = s->frame;
440
441     if ((get_bits_count(&gb) / 8) != buf_size)
442         av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
443                buf_size, (get_bits_count(&gb) / 8));
444
445     /* report that the buffer was completely consumed */
446     return buf_size;
447 }
448
449
450 static av_cold int flashsv_decode_end(AVCodecContext *avctx)
451 {
452     FlashSVContext *s = avctx->priv_data;
453     inflateEnd(&s->zstream);
454     /* release the frame if needed */
455     if (s->frame.data[0])
456         avctx->release_buffer(avctx, &s->frame);
457
458     /* free the tmpblock */
459     av_free(s->tmpblock);
460
461     return 0;
462 }
463
464
465 #if CONFIG_FLASHSV_DECODER
466 AVCodec ff_flashsv_decoder = {
467     .name           = "flashsv",
468     .type           = AVMEDIA_TYPE_VIDEO,
469     .id             = AV_CODEC_ID_FLASHSV,
470     .priv_data_size = sizeof(FlashSVContext),
471     .init           = flashsv_decode_init,
472     .close          = flashsv_decode_end,
473     .decode         = flashsv_decode_frame,
474     .capabilities   = CODEC_CAP_DR1,
475     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
476     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
477 };
478 #endif /* CONFIG_FLASHSV_DECODER */
479
480 #if CONFIG_FLASHSV2_DECODER
481 static const uint32_t ff_flashsv2_default_palette[128] = {
482     0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF,
483     0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300,
484     0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066,
485     0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900,
486     0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC,
487     0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF,
488     0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF,
489     0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF,
490     0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC,
491     0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC,
492     0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699,
493     0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999,
494     0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966,
495     0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666,
496     0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933,
497     0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333,
498     0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300,
499     0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633,
500     0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966,
501     0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99,
502     0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB,
503     0xDDDDDD, 0xEEEEEE
504 };
505
506 static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
507 {
508     FlashSVContext *s = avctx->priv_data;
509     flashsv_decode_init(avctx);
510     s->pal = ff_flashsv2_default_palette;
511     s->ver = 2;
512
513     return 0;
514 }
515
516 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
517 {
518     FlashSVContext *s = avctx->priv_data;
519
520     av_freep(&s->keyframedata);
521     av_freep(&s->blocks);
522     av_freep(&s->keyframe);
523     av_freep(&s->deflate_block);
524     flashsv_decode_end(avctx);
525
526     return 0;
527 }
528
529 AVCodec ff_flashsv2_decoder = {
530     .name           = "flashsv2",
531     .type           = AVMEDIA_TYPE_VIDEO,
532     .id             = AV_CODEC_ID_FLASHSV2,
533     .priv_data_size = sizeof(FlashSVContext),
534     .init           = flashsv2_decode_init,
535     .close          = flashsv2_decode_end,
536     .decode         = flashsv_decode_frame,
537     .capabilities   = CODEC_CAP_DR1,
538     .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
539     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
540 };
541 #endif /* CONFIG_FLASHSV2_DECODER */