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