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