avidec: avoid infinite loop due to negative ast->sample_size
[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 (!s->keyframe) {
417                         av_log(avctx, AV_LOG_ERROR,
418                                "Inter frame without keyframe\n");
419                         return AVERROR_INVALIDDATA;
420                     }
421                     s->diff_start  = get_bits(&gb, 8);
422                     s->diff_height = get_bits(&gb, 8);
423                     if (s->diff_start + s->diff_height > cur_blk_height) {
424                         av_log(avctx, AV_LOG_ERROR,
425                                "Block parameters invalid: %d + %d > %d\n",
426                                s->diff_start, s->diff_height, cur_blk_height);
427                         return AVERROR_INVALIDDATA;
428                     }
429                     av_log(avctx, AV_LOG_DEBUG,
430                            "%dx%d diff start %d height %d\n",
431                            i, j, s->diff_start, s->diff_height);
432                     size -= 2;
433                 }
434
435                 if (s->zlibprime_prev)
436                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_prev\n", i, j);
437
438                 if (s->zlibprime_curr) {
439                     int col = get_bits(&gb, 8);
440                     int row = get_bits(&gb, 8);
441                     av_log(avctx, AV_LOG_DEBUG, "%dx%d zlibprime_curr %dx%d\n",
442                            i, j, col, row);
443                     size -= 2;
444                     avpriv_request_sample(avctx, "zlibprime_curr");
445                     return AVERROR_PATCHWELCOME;
446                 }
447                 if (!s->blocks && (s->zlibprime_curr || s->zlibprime_prev)) {
448                     av_log(avctx, AV_LOG_ERROR,
449                            "no data available for zlib priming\n");
450                     return AVERROR_INVALIDDATA;
451                 }
452                 size--; // account for flags byte
453             }
454
455             if (has_diff) {
456                 int k;
457                 int off = (s->image_height - y_pos - 1) * s->frame->linesize[0];
458
459                 for (k = 0; k < cur_blk_height; k++) {
460                     int x = off - k * s->frame->linesize[0] + x_pos * 3;
461                     memcpy(s->frame->data[0] + x, s->keyframe + x,
462                            cur_blk_width * 3);
463                 }
464             }
465
466             /* skip unchanged blocks, which have size 0 */
467             if (size) {
468                 if (flashsv_decode_block(avctx, avpkt, &gb, size,
469                                          cur_blk_width, cur_blk_height,
470                                          x_pos, y_pos,
471                                          i + j * (h_blocks + !!h_part)))
472                     av_log(avctx, AV_LOG_ERROR,
473                            "error in decompression of block %dx%d\n", i, j);
474             }
475         }
476     }
477     if (s->is_keyframe && s->ver == 2) {
478         if (!s->keyframe) {
479             s->keyframe = av_malloc(s->frame->linesize[0] * avctx->height);
480             if (!s->keyframe) {
481                 av_log(avctx, AV_LOG_ERROR, "Cannot allocate image data\n");
482                 return AVERROR(ENOMEM);
483             }
484         }
485         memcpy(s->keyframe, s->frame->data[0],
486                s->frame->linesize[0] * avctx->height);
487     }
488
489     if ((ret = av_frame_ref(data, s->frame)) < 0)
490         return ret;
491
492     *got_frame = 1;
493
494     if ((get_bits_count(&gb) / 8) != buf_size)
495         av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
496                buf_size, (get_bits_count(&gb) / 8));
497
498     /* report that the buffer was completely consumed */
499     return buf_size;
500 }
501
502 #if CONFIG_FLASHSV_DECODER
503 AVCodec ff_flashsv_decoder = {
504     .name           = "flashsv",
505     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v1"),
506     .type           = AVMEDIA_TYPE_VIDEO,
507     .id             = AV_CODEC_ID_FLASHSV,
508     .priv_data_size = sizeof(FlashSVContext),
509     .init           = flashsv_decode_init,
510     .close          = flashsv_decode_end,
511     .decode         = flashsv_decode_frame,
512     .capabilities   = CODEC_CAP_DR1,
513     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
514 };
515 #endif /* CONFIG_FLASHSV_DECODER */
516
517 #if CONFIG_FLASHSV2_DECODER
518 static const uint32_t ff_flashsv2_default_palette[128] = {
519     0x000000, 0x333333, 0x666666, 0x999999, 0xCCCCCC, 0xFFFFFF,
520     0x330000, 0x660000, 0x990000, 0xCC0000, 0xFF0000, 0x003300,
521     0x006600, 0x009900, 0x00CC00, 0x00FF00, 0x000033, 0x000066,
522     0x000099, 0x0000CC, 0x0000FF, 0x333300, 0x666600, 0x999900,
523     0xCCCC00, 0xFFFF00, 0x003333, 0x006666, 0x009999, 0x00CCCC,
524     0x00FFFF, 0x330033, 0x660066, 0x990099, 0xCC00CC, 0xFF00FF,
525     0xFFFF33, 0xFFFF66, 0xFFFF99, 0xFFFFCC, 0xFF33FF, 0xFF66FF,
526     0xFF99FF, 0xFFCCFF, 0x33FFFF, 0x66FFFF, 0x99FFFF, 0xCCFFFF,
527     0xCCCC33, 0xCCCC66, 0xCCCC99, 0xCCCCFF, 0xCC33CC, 0xCC66CC,
528     0xCC99CC, 0xCCFFCC, 0x33CCCC, 0x66CCCC, 0x99CCCC, 0xFFCCCC,
529     0x999933, 0x999966, 0x9999CC, 0x9999FF, 0x993399, 0x996699,
530     0x99CC99, 0x99FF99, 0x339999, 0x669999, 0xCC9999, 0xFF9999,
531     0x666633, 0x666699, 0x6666CC, 0x6666FF, 0x663366, 0x669966,
532     0x66CC66, 0x66FF66, 0x336666, 0x996666, 0xCC6666, 0xFF6666,
533     0x333366, 0x333399, 0x3333CC, 0x3333FF, 0x336633, 0x339933,
534     0x33CC33, 0x33FF33, 0x663333, 0x993333, 0xCC3333, 0xFF3333,
535     0x003366, 0x336600, 0x660033, 0x006633, 0x330066, 0x663300,
536     0x336699, 0x669933, 0x993366, 0x339966, 0x663399, 0x996633,
537     0x6699CC, 0x99CC66, 0xCC6699, 0x66CC99, 0x9966CC, 0xCC9966,
538     0x99CCFF, 0xCCFF99, 0xFF99CC, 0x99FFCC, 0xCC99FF, 0xFFCC99,
539     0x111111, 0x222222, 0x444444, 0x555555, 0xAAAAAA, 0xBBBBBB,
540     0xDDDDDD, 0xEEEEEE
541 };
542
543 static av_cold int flashsv2_decode_init(AVCodecContext *avctx)
544 {
545     FlashSVContext *s = avctx->priv_data;
546     flashsv_decode_init(avctx);
547     s->pal = ff_flashsv2_default_palette;
548     s->ver = 2;
549
550     return 0;
551 }
552
553 static av_cold int flashsv2_decode_end(AVCodecContext *avctx)
554 {
555     FlashSVContext *s = avctx->priv_data;
556
557     av_freep(&s->keyframedata);
558     av_freep(&s->blocks);
559     av_freep(&s->keyframe);
560     av_freep(&s->deflate_block);
561     flashsv_decode_end(avctx);
562
563     return 0;
564 }
565
566 AVCodec ff_flashsv2_decoder = {
567     .name           = "flashsv2",
568     .long_name      = NULL_IF_CONFIG_SMALL("Flash Screen Video v2"),
569     .type           = AVMEDIA_TYPE_VIDEO,
570     .id             = AV_CODEC_ID_FLASHSV2,
571     .priv_data_size = sizeof(FlashSVContext),
572     .init           = flashsv2_decode_init,
573     .close          = flashsv2_decode_end,
574     .decode         = flashsv_decode_frame,
575     .capabilities   = CODEC_CAP_DR1,
576     .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_BGR24, AV_PIX_FMT_NONE },
577 };
578 #endif /* CONFIG_FLASHSV2_DECODER */