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