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 "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 };