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