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