git.sesse.net Git - ffmpeg/blob - 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 "get_bits.h"
  28 #include "avcodec.h"
  29 #include "internal.h"
  30
  31 typedef struct CLLCContext {
  32     AVCodecContext *avctx;
  33     BswapDSPContext bdsp;
  34
  35     uint8_t *swapped_buf;
  36     int      swapped_buf_size;
  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
  60             av_log(ctx->avctx, AV_LOG_ERROR,
  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
 153 static int read_rgb24_component_line(CLLCContext *ctx, GetBitContext *gb,
 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
 183 static int read_yuv_component_line(CLLCContext *ctx, GetBitContext *gb,
 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
 211 static int decode_argb_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic)
 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
 255 static int decode_rgb24_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic)
 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
 299 static int decode_yuv_frame(CLLCContext *ctx, GetBitContext *gb, AVFrame *pic)
 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 */
 386     av_fast_padded_malloc(&ctx->swapped_buf,
 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     if ((ret = init_get_bits8(&gb, ctx->swapped_buf, data_size)) < 0)
 398         return ret;
 399
 400     /*
 401      * Read in coding type. The types are as follows:
 402      *
 403      * 0 - YUY2
 404      * 1 - BGR24 (Triples)
 405      * 2 - BGR24 (Quads)
 406      * 3 - BGRA
 407      */
 408     coding_type = (AV_RL32(src) >> 8) & 0xFF;
 409     av_log(avctx, AV_LOG_DEBUG, "Frame coding type: %d\n", coding_type);
 410
 411     switch (coding_type) {
 412     case 0:
 413         avctx->pix_fmt             = AV_PIX_FMT_YUV422P;
 414         avctx->bits_per_raw_sample = 8;
 415
 416         if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 417             return ret;
 418
 419         ret = decode_yuv_frame(ctx, &gb, pic);
 420         if (ret < 0)
 421             return ret;
 422
 423         break;
 424     case 1:
 425     case 2:
 426         avctx->pix_fmt             = AV_PIX_FMT_RGB24;
 427         avctx->bits_per_raw_sample = 8;
 428
 429         if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 430             return ret;
 431
 432         ret = decode_rgb24_frame(ctx, &gb, pic);
 433         if (ret < 0)
 434             return ret;
 435
 436         break;
 437     case 3:
 438         avctx->pix_fmt             = AV_PIX_FMT_ARGB;
 439         avctx->bits_per_raw_sample = 8;
 440
 441         if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 442             return ret;
 443
 444         ret = decode_argb_frame(ctx, &gb, pic);
 445         if (ret < 0)
 446             return ret;
 447
 448         break;
 449     default:
 450         av_log(avctx, AV_LOG_ERROR, "Unknown coding type: %d.\n", coding_type);
 451         return AVERROR_INVALIDDATA;
 452     }
 453
 454     pic->key_frame = 1;
 455     pic->pict_type = AV_PICTURE_TYPE_I;
 456
 457     *got_picture_ptr = 1;
 458
 459     return avpkt->size;
 460 }
 461
 462 static av_cold int cllc_decode_close(AVCodecContext *avctx)
 463 {
 464     CLLCContext *ctx = avctx->priv_data;
 465
 466     av_freep(&ctx->swapped_buf);
 467
 468     return 0;
 469 }
 470
 471 static av_cold int cllc_decode_init(AVCodecContext *avctx)
 472 {
 473     CLLCContext *ctx = avctx->priv_data;
 474
 475     /* Initialize various context values */
 476     ctx->avctx            = avctx;
 477     ctx->swapped_buf      = NULL;
 478     ctx->swapped_buf_size = 0;
 479
 480     ff_bswapdsp_init(&ctx->bdsp);
 481
 482     return 0;
 483 }
 484
 485 AVCodec ff_cllc_decoder = {
 486     .name           = "cllc",
 487     .long_name      = NULL_IF_CONFIG_SMALL("Canopus Lossless Codec"),
 488     .type           = AVMEDIA_TYPE_VIDEO,
 489     .id             = AV_CODEC_ID_CLLC,
 490     .priv_data_size = sizeof(CLLCContext),
 491     .init           = cllc_decode_init,
 492     .decode         = cllc_decode_frame,
 493     .close          = cllc_decode_close,
 494     .capabilities   = CODEC_CAP_DR1,
 495 };