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