avcodec/dirac_dwt: Fix integer overflow in COMPOSE_FIDELITYi*()
[ffmpeg.git] / libavcodec / cllc.c
1 /*
2  * Canopus Lossless Codec decoder
3  *
4  * Copyright (c) 2012-2013 Derek Buitenhuis
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 #include "libavutil/intreadwrite.h"
24 #include "dsputil.h"
25 #include "get_bits.h"
26 #include "avcodec.h"
27 #include "internal.h"
28
29 typedef struct CLLCContext {
30     DSPContext dsp;
31     AVCodecContext *avctx;
32
33     uint8_t *swapped_buf;
34     int      swapped_buf_size;
35 } CLLCContext;
36
37 static int read_code_table(CLLCContext *ctx, GetBitContext *gb, VLC *vlc)
38 {
39     uint8_t symbols[256];
40     uint8_t bits[256];
41     uint16_t codes[256];
42     int num_lens, num_codes, num_codes_sum, prefix;
43     int i, j, count;
44
45     prefix        = 0;
46     count         = 0;
47     num_codes_sum = 0;
48
49     num_lens = get_bits(gb, 5);
50
51     for (i = 0; i < num_lens; i++) {
52         num_codes      = get_bits(gb, 9);
53         num_codes_sum += num_codes;
54
55         if (num_codes_sum > 256) {
56             vlc->table = NULL;
57
58             av_log(ctx->avctx, AV_LOG_ERROR,
59                    "Too many VLCs (%d) to be read.\n", num_codes_sum);
60             return AVERROR_INVALIDDATA;
61         }
62
63         for (j = 0; j < num_codes; j++) {
64             symbols[count] = get_bits(gb, 8);
65             bits[count]    = i + 1;
66             codes[count]   = prefix++;
67
68             count++;
69         }
70
71         prefix <<= 1;
72     }
73
74     return ff_init_vlc_sparse(vlc, 7, count, bits, 1, 1,
75                               codes, 2, 2, symbols, 1, 1, 0);
76 }
77
78 /*
79  * Unlike the RGB24 read/restore, which reads in a component at a time,
80  * ARGB read/restore reads in ARGB quads.
81  */
82 static int read_argb_line(CLLCContext *ctx, GetBitContext *gb, int *top_left,
83                           VLC *vlc, uint8_t *outbuf)
84 {
85     uint8_t *dst;
86     int pred[4];
87     int code;
88     int i;
89
90     OPEN_READER(bits, gb);
91
92     dst     = outbuf;
93     pred[0] = top_left[0];
94     pred[1] = top_left[1];
95     pred[2] = top_left[2];
96     pred[3] = top_left[3];
97
98     for (i = 0; i < ctx->avctx->width; i++) {
99         /* Always get the alpha component */
100         UPDATE_CACHE(bits, gb);
101         GET_VLC(code, bits, gb, vlc[0].table, 7, 2);
102
103         pred[0] += code;
104         dst[0]   = pred[0];
105
106         /* Skip the components if they are  entirely transparent */
107         if (dst[0]) {
108             /* Red */
109             UPDATE_CACHE(bits, gb);
110             GET_VLC(code, bits, gb, vlc[1].table, 7, 2);
111
112             pred[1] += code;
113             dst[1]   = pred[1];
114
115             /* Green */
116             UPDATE_CACHE(bits, gb);
117             GET_VLC(code, bits, gb, vlc[2].table, 7, 2);
118
119             pred[2] += code;
120             dst[2]   = pred[2];
121
122             /* Blue */
123             UPDATE_CACHE(bits, gb);
124             GET_VLC(code, bits, gb, vlc[3].table, 7, 2);
125
126             pred[3] += code;
127             dst[3]   = pred[3];
128         } else {
129             dst[1] = 0;
130             dst[2] = 0;
131             dst[3] = 0;
132         }
133
134         dst += 4;
135     }
136
137     CLOSE_READER(bits, gb);
138
139     top_left[0]  = outbuf[0];
140
141     /* Only stash components if they are not transparent */
142     if (top_left[0]) {
143         top_left[1] = outbuf[1];
144         top_left[2] = outbuf[2];
145         top_left[3] = outbuf[3];
146     }
147
148     return 0;
149 }
150
151 static int read_rgb24_component_line(CLLCContext *ctx, GetBitContext *gb,
152                                      int *top_left, VLC *vlc, uint8_t *outbuf)
153 {
154     uint8_t *dst;
155     int pred, code;
156     int i;
157
158     OPEN_READER(bits, gb);
159
160     dst  = outbuf;
161     pred = *top_left;
162
163     /* Simultaneously read and restore the line */
164     for (i = 0; i < ctx->avctx->width; i++) {
165         UPDATE_CACHE(bits, gb);
166         GET_VLC(code, bits, gb, vlc->table, 7, 2);
167
168         pred  += code;
169         dst[0] = pred;
170         dst   += 3;
171     }
172
173     CLOSE_READER(bits, gb);
174
175     /* Stash the first pixel */
176     *top_left = outbuf[0];
177
178     return 0;
179 }
180
181 static int read_yuv_component_line(CLLCContext *ctx, GetBitContext *gb,
182                                    int *top_left, VLC *vlc, uint8_t *outbuf,
183                                    int is_chroma)
184 {
185     int pred, code;
186     int i;
187
188     OPEN_READER(bits, gb);
189
190     pred = *top_left;
191
192     /* Simultaneously read and restore the line */
193     for (i = 0; i < ctx->avctx->width >> is_chroma; i++) {
194         UPDATE_CACHE(bits, gb);
195         GET_VLC(code, bits, gb, vlc->table, 7, 2);
196
197         pred     += code;
198         outbuf[i] = pred;
199     }
200
201     CLOSE_READER(bits, gb);
202
203     /* Stash the first pixel */
204     *top_left = outbuf[0];
205
206     return 0;
207 }
208
209 static int decode_argb_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic)
210 {
211     AVCodecContext *avctx = ctx->avctx;
212     uint8_t *dst;
213     int pred[4];
214     int ret;
215     int i, j;
216     VLC vlc[4];
217
218     pred[0] = 0;
219     pred[1] = 0x80;
220     pred[2] = 0x80;
221     pred[3] = 0x80;
222
223     dst = pic->data[0];
224
225     skip_bits(gb, 16);
226
227     /* Read in code table for each plane */
228     for (i = 0; i < 4; i++) {
229         ret = read_code_table(ctx, gb, &vlc[i]);
230         if (ret < 0) {
231             for (j = 0; j <= i; j++)
232                 ff_free_vlc(&vlc[j]);
233
234             av_log(ctx->avctx, AV_LOG_ERROR,
235                    "Could not read code table %d.\n", i);
236             return ret;
237         }
238     }
239
240     /* Read in and restore every line */
241     for (i = 0; i < avctx->height; i++) {
242         read_argb_line(ctx, gb, pred, vlc, dst);
243
244         dst += pic->linesize[0];
245     }
246
247     for (i = 0; i < 4; i++)
248         ff_free_vlc(&vlc[i]);
249
250     return 0;
251 }
252
253 static int decode_rgb24_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic)
254 {
255     AVCodecContext *avctx = ctx->avctx;
256     uint8_t *dst;
257     int pred[3];
258     int ret;
259     int i, j;
260     VLC vlc[3];
261
262     pred[0] = 0x80;
263     pred[1] = 0x80;
264     pred[2] = 0x80;
265
266     dst = pic->data[0];
267
268     skip_bits(gb, 16);
269
270     /* Read in code table for each plane */
271     for (i = 0; i < 3; i++) {
272         ret = read_code_table(ctx, gb, &vlc[i]);
273         if (ret < 0) {
274             for (j = 0; j <= i; j++)
275                 ff_free_vlc(&vlc[j]);
276
277             av_log(ctx->avctx, AV_LOG_ERROR,
278                    "Could not read code table %d.\n", i);
279             return ret;
280         }
281     }
282
283     /* Read in and restore every line */
284     for (i = 0; i < avctx->height; i++) {
285         for (j = 0; j < 3; j++)
286             read_rgb24_component_line(ctx, gb, &pred[j], &vlc[j], &dst[j]);
287
288         dst += pic->linesize[0];
289     }
290
291     for (i = 0; i < 3; i++)
292         ff_free_vlc(&vlc[i]);
293
294     return 0;
295 }
296
297 static int decode_yuv_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic)
298 {
299     AVCodecContext *avctx = ctx->avctx;
300     uint8_t block;
301     uint8_t *dst[3];
302     int pred[3];
303     int ret;
304     int i, j;
305     VLC vlc[2];
306
307     pred[0] = 0x80;
308     pred[1] = 0x80;
309     pred[2] = 0x80;
310
311     dst[0] = pic->data[0];
312     dst[1] = pic->data[1];
313     dst[2] = pic->data[2];
314
315     skip_bits(gb, 8);
316
317     block = get_bits(gb, 8);
318     if (block) {
319         avpriv_request_sample(ctx->avctx, "Blocked YUV");
320         return AVERROR_PATCHWELCOME;
321     }
322
323     /* Read in code table for luma and chroma */
324     for (i = 0; i < 2; i++) {
325         ret = read_code_table(ctx, gb, &vlc[i]);
326         if (ret < 0) {
327             for (j = 0; j <= i; j++)
328                 ff_free_vlc(&vlc[j]);
329
330             av_log(ctx->avctx, AV_LOG_ERROR,
331                    "Could not read code table %d.\n", i);
332             return ret;
333         }
334     }
335
336     /* Read in and restore every line */
337     for (i = 0; i < avctx->height; i++) {
338         read_yuv_component_line(ctx, gb, &pred[0], &vlc[0], dst[0], 0); /* Y */
339         read_yuv_component_line(ctx, gb, &pred[1], &vlc[1], dst[1], 1); /* U */
340         read_yuv_component_line(ctx, gb, &pred[2], &vlc[1], dst[2], 1); /* V */
341
342         for (j = 0; j < 3; j++)
343             dst[j] += pic->linesize[j];
344     }
345
346     for (i = 0; i < 2; i++)
347         ff_free_vlc(&vlc[i]);
348
349     return 0;
350 }
351
352 static int cllc_decode_frame(AVCodecContext *avctx, void *data,
353                              int *got_picture_ptr, AVPacket *avpkt)
354 {
355     CLLCContext *ctx = avctx->priv_data;
356     AVFrame *pic = data;
357     uint8_t *src = avpkt->data;
358     uint32_t info_tag, info_offset;
359     int data_size;
360     GetBitContext gb;
361     int coding_type, ret;
362
363     /* Skip the INFO header if present */
364     info_offset = 0;
365     info_tag    = AV_RL32(src);
366     if (info_tag == MKTAG('I', 'N', 'F', 'O')) {
367         info_offset = AV_RL32(src + 4);
368         if (info_offset > UINT32_MAX - 8 || info_offset + 8 > avpkt->size) {
369             av_log(avctx, AV_LOG_ERROR,
370                    "Invalid INFO header offset: 0x%08X is too large.\n",
371                    info_offset);
372             return AVERROR_INVALIDDATA;
373         }
374
375         info_offset += 8;
376         src         += info_offset;
377
378         av_log(avctx, AV_LOG_DEBUG, "Skipping INFO chunk.\n");
379     }
380
381     data_size = (avpkt->size - info_offset) & ~1;
382
383     /* Make sure our bswap16'd buffer is big enough */
384     av_fast_padded_malloc(&ctx->swapped_buf,
385                           &ctx->swapped_buf_size, data_size);
386     if (!ctx->swapped_buf) {
387         av_log(avctx, AV_LOG_ERROR, "Could not allocate swapped buffer.\n");
388         return AVERROR(ENOMEM);
389     }
390
391     /* bswap16 the buffer since CLLC's bitreader works in 16-bit words */
392     ctx->dsp.bswap16_buf((uint16_t *) ctx->swapped_buf, (uint16_t *) src,
393                          data_size / 2);
394
395     init_get_bits(&gb, ctx->swapped_buf, data_size * 8);
396
397     /*
398      * Read in coding type. The types are as follows:
399      *
400      * 0 - YUY2
401      * 1 - BGR24 (Triples)
402      * 2 - BGR24 (Quads)
403      * 3 - BGRA
404      */
405     coding_type = (AV_RL32(src) >> 8) & 0xFF;
406     av_log(avctx, AV_LOG_DEBUG, "Frame coding type: %d\n", coding_type);
407
408     switch (coding_type) {
409     case 0:
410         avctx->pix_fmt             = AV_PIX_FMT_YUV422P;
411         avctx->bits_per_raw_sample = 8;
412
413         if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
414             return ret;
415
416         ret = decode_yuv_frame(ctx, &gb, pic);
417         if (ret < 0)
418             return ret;
419
420         break;
421     case 1:
422     case 2:
423         avctx->pix_fmt             = AV_PIX_FMT_RGB24;
424         avctx->bits_per_raw_sample = 8;
425
426         if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
427             return ret;
428
429         ret = decode_rgb24_frame(ctx, &gb, pic);
430         if (ret < 0)
431             return ret;
432
433         break;
434     case 3:
435         avctx->pix_fmt             = AV_PIX_FMT_ARGB;
436         avctx->bits_per_raw_sample = 8;
437
438         if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
439             return ret;
440
441         ret = decode_argb_frame(ctx, &gb, pic);
442         if (ret < 0)
443             return ret;
444
445         break;
446     default:
447         av_log(avctx, AV_LOG_ERROR, "Unknown coding type: %d.\n", coding_type);
448         return AVERROR_INVALIDDATA;
449     }
450
451     pic->key_frame = 1;
452     pic->pict_type = AV_PICTURE_TYPE_I;
453
454     *got_picture_ptr = 1;
455
456     return avpkt->size;
457 }
458
459 static av_cold int cllc_decode_close(AVCodecContext *avctx)
460 {
461     CLLCContext *ctx = avctx->priv_data;
462
463     av_freep(&ctx->swapped_buf);
464
465     return 0;
466 }
467
468 static av_cold int cllc_decode_init(AVCodecContext *avctx)
469 {
470     CLLCContext *ctx = avctx->priv_data;
471
472     /* Initialize various context values */
473     ctx->avctx            = avctx;
474     ctx->swapped_buf      = NULL;
475     ctx->swapped_buf_size = 0;
476
477     ff_dsputil_init(&ctx->dsp, avctx);
478
479     return 0;
480 }
481
482 AVCodec ff_cllc_decoder = {
483     .name           = "cllc",
484     .type           = AVMEDIA_TYPE_VIDEO,
485     .id             = AV_CODEC_ID_CLLC,
486     .priv_data_size = sizeof(CLLCContext),
487     .init           = cllc_decode_init,
488     .decode         = cllc_decode_frame,
489     .close          = cllc_decode_close,
490     .capabilities   = CODEC_CAP_DR1,
491     .long_name      = NULL_IF_CONFIG_SMALL("Canopus Lossless Codec"),
492 };