git.sesse.net Git - ffmpeg/blob - libavcodec/clearvideo.c

   1 /*
   2  * ClearVideo decoder
   3  * Copyright (c) 2012 Konstantin Shishkov
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 /**
  23  * @file
  24  * ClearVideo decoder
  25  */
  26
  27 #include "avcodec.h"
  28 #include "idctdsp.h"
  29 #include "internal.h"
  30 #include "get_bits.h"
  31 #include "bytestream.h"
  32
  33 #define NUM_DC_CODES 127
  34 #define NUM_AC_CODES 103
  35
  36 static const uint8_t clv_dc_codes[NUM_DC_CODES] = {
  37     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
  38     0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F,
  39     0x10, 0x11, 0x12, 0x13, 0x13, 0x14, 0x07, 0x0B,
  40     0x0C, 0x08, 0x08, 0x09, 0x04, 0x06, 0x07, 0x05,
  41     0x04, 0x05, 0x04, 0x06, 0x05, 0x06, 0x07, 0x05,
  42     0x06, 0x07, 0x06, 0x07, 0x08, 0x06, 0x07, 0x08,
  43     0x09, 0x0A, 0x0B, 0x07, 0x08, 0x09, 0x07, 0x08,
  44     0x06, 0x07, 0x08, 0x06, 0x04, 0x05, 0x02, 0x01,
  45     0x03, 0x06, 0x07, 0x07, 0x09, 0x0A, 0x0B, 0x09,
  46     0x0A, 0x0B, 0x0A, 0x0B, 0x0C, 0x0D, 0x0C, 0x09,
  47     0x0D, 0x0A, 0x0B, 0x08, 0x09, 0x0A, 0x0B, 0x07,
  48     0x08, 0x09, 0x0A, 0x0B, 0x06, 0x07, 0x06, 0x08,
  49     0x07, 0x09, 0x0A, 0x0B, 0x09, 0x0A, 0x0B, 0x0C,
  50     0x14, 0x0D, 0x0D, 0x0E, 0x0F, 0x15, 0x15, 0x16,
  51     0x17, 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E,
  52     0x1F, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25,
  53 };
  54
  55 static const uint8_t clv_dc_bits[NUM_DC_CODES] = {
  56     22, 22, 22, 22, 22, 22, 22, 22,
  57     22, 22, 22, 22, 22, 22, 22, 22,
  58     22, 22, 22, 21, 22, 22, 19, 20,
  59     20, 19, 18, 18, 15, 17, 17, 16,
  60     14, 15, 12, 13, 14, 14, 14, 12,
  61     12, 12, 11, 11, 11, 10, 10, 10,
  62     10, 10, 10,  9,  9,  9,  8,  8,
  63      7,  7,  7,  6,  5,  5,  3,  1,
  64      3,  5,  5,  6,  7,  7,  7,  8,
  65      8,  8,  9,  9,  9,  9, 10, 11,
  66     10, 11, 11, 12, 12, 12, 12, 13,
  67     14, 14, 14, 14, 15, 15, 16, 17,
  68     16, 17, 18, 18, 19, 19, 19, 19,
  69     21, 19, 20, 19, 19, 21, 22, 22,
  70     22, 22, 22, 22, 22, 22, 22, 22,
  71     22, 22, 22, 22, 22, 22, 22,
  72 };
  73
  74 static const uint16_t clv_ac_syms[NUM_AC_CODES] = {
  75     0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007, 0x0008,
  76     0x0009, 0x000A, 0x000B, 0x000C, 0x0011, 0x0012, 0x0013, 0x0014,
  77     0x0015, 0x0016, 0x0021, 0x0022, 0x0023, 0x0024, 0x0031, 0x0032,
  78     0x0033, 0x0041, 0x0042, 0x0043, 0x0051, 0x0052, 0x0053, 0x0061,
  79     0x0062, 0x0063, 0x0071, 0x0072, 0x0081, 0x0082, 0x0091, 0x0092,
  80     0x00A1, 0x00A2, 0x00B1, 0x00C1, 0x00D1, 0x00E1, 0x00F1, 0x0101,
  81     0x0111, 0x0121, 0x0131, 0x0141, 0x0151, 0x0161, 0x0171, 0x0181,
  82     0x0191, 0x01A1, 0x1001, 0x1002, 0x1003, 0x1011, 0x1012, 0x1021,
  83     0x1031, 0x1041, 0x1051, 0x1061, 0x1071, 0x1081, 0x1091, 0x10A1,
  84     0x10B1, 0x10C1, 0x10D1, 0x10E1, 0x10F1, 0x1101, 0x1111, 0x1121,
  85     0x1131, 0x1141, 0x1151, 0x1161, 0x1171, 0x1181, 0x1191, 0x11A1,
  86     0x11B1, 0x11C1, 0x11D1, 0x11E1, 0x11F1, 0x1201, 0x1211, 0x1221,
  87     0x1231, 0x1241, 0x1251, 0x1261, 0x1271, 0x1281, 0x1BFF,
  88 };
  89
  90 static const uint8_t clv_ac_codes[NUM_AC_CODES] = {
  91     0x02, 0x0F, 0x15, 0x17, 0x1F, 0x25, 0x24, 0x21,
  92     0x20, 0x07, 0x06, 0x20, 0x06, 0x14, 0x1E, 0x0F,
  93     0x21, 0x50, 0x0E, 0x1D, 0x0E, 0x51, 0x0D, 0x23,
  94     0x0D, 0x0C, 0x22, 0x52, 0x0B, 0x0C, 0x53, 0x13,
  95     0x0B, 0x54, 0x12, 0x0A, 0x11, 0x09, 0x10, 0x08,
  96     0x16, 0x55, 0x15, 0x14, 0x1C, 0x1B, 0x21, 0x20,
  97     0x1F, 0x1E, 0x1D, 0x1C, 0x1B, 0x1A, 0x22, 0x23,
  98     0x56, 0x57, 0x07, 0x19, 0x05, 0x0F, 0x04, 0x0E,
  99     0x0D, 0x0C, 0x13, 0x12, 0x11, 0x10, 0x1A, 0x19,
 100     0x18, 0x17, 0x16, 0x15, 0x14, 0x13, 0x18, 0x17,
 101     0x16, 0x15, 0x14, 0x13, 0x12, 0x11, 0x07, 0x06,
 102     0x05, 0x04, 0x24, 0x25, 0x26, 0x27, 0x58, 0x59,
 103     0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, 0x03,
 104 };
 105
 106 static const uint8_t clv_ac_bits[NUM_AC_CODES] = {
 107      2,  4,  6,  7,  8,  9,  9, 10,
 108     10, 11, 11, 11,  3,  6,  8, 10,
 109     11, 12,  4,  8, 10, 12,  5,  9,
 110     10,  5,  9, 12,  5, 10, 12,  6,
 111     10, 12,  6, 10,  6, 10,  6, 10,
 112      7, 12,  7,  7,  8,  8,  9,  9,
 113      9,  9,  9,  9,  9,  9, 11, 11,
 114     12, 12,  4,  9, 11,  6, 11,  6,
 115      6,  6,  7,  7,  7,  7,  8,  8,
 116      8,  8,  8,  8,  8,  8,  9,  9,
 117      9,  9,  9,  9,  9,  9, 10, 10,
 118     10, 10, 11, 11, 11, 11, 12, 12,
 119     12, 12, 12, 12, 12, 12,  7,
 120 };
 121
 122 typedef struct CLVContext {
 123     AVCodecContext *avctx;
 124     IDCTDSPContext idsp;
 125     AVFrame        *pic;
 126     GetBitContext  gb;
 127     int            mb_width, mb_height;
 128     VLC            dc_vlc, ac_vlc;
 129     int            luma_dc_quant, chroma_dc_quant, ac_quant;
 130     DECLARE_ALIGNED(16, int16_t, block)[64];
 131     int            top_dc[3], left_dc[4];
 132 } CLVContext;
 133
 134 static inline int decode_block(CLVContext *ctx, int16_t *blk, int has_ac,
 135                                int ac_quant)
 136 {
 137     GetBitContext *gb = &ctx->gb;
 138     int idx = 1, last = 0, val, skip;
 139
 140     memset(blk, 0, sizeof(*blk) * 64);
 141     blk[0] = get_vlc2(gb, ctx->dc_vlc.table, 9, 3);
 142     if (blk[0] < 0)
 143         return AVERROR_INVALIDDATA;
 144     blk[0] -= 63;
 145
 146     if (!has_ac)
 147         return 0;
 148
 149     while (idx < 64 && !last) {
 150         val = get_vlc2(gb, ctx->ac_vlc.table, 9, 2);
 151         if (val < 0)
 152             return AVERROR_INVALIDDATA;
 153         if (val != 0x1BFF) {
 154             last =  val >> 12;
 155             skip = (val >> 4) & 0xFF;
 156             val &= 0xF;
 157             if (get_bits1(gb))
 158                 val = -val;
 159         } else {
 160             last = get_bits1(gb);
 161             skip = get_bits(gb, 6);
 162             val  = get_sbits(gb, 8);
 163         }
 164         if (val) {
 165             int aval = FFABS(val), sign = val < 0;
 166             val = ac_quant * (2 * aval + 1);
 167             if (!(ac_quant & 1))
 168                 val--;
 169             if (sign)
 170                 val = -val;
 171         }
 172         idx += skip;
 173         if (idx >= 64)
 174             return AVERROR_INVALIDDATA;
 175         blk[ff_zigzag_direct[idx++]] = val;
 176     }
 177
 178     return (idx <= 64 && last) ? 0 : -1;
 179 }
 180
 181 #define DCT_TEMPLATE(blk, step, bias, shift, dshift, OP)                \
 182     const int t0 = OP( 2841 * blk[1 * step] +  565 * blk[7 * step]);    \
 183     const int t1 = OP(  565 * blk[1 * step] - 2841 * blk[7 * step]);    \
 184     const int t2 = OP( 1609 * blk[5 * step] + 2408 * blk[3 * step]);    \
 185     const int t3 = OP( 2408 * blk[5 * step] - 1609 * blk[3 * step]);    \
 186     const int t4 = OP( 1108 * blk[2 * step] - 2676 * blk[6 * step]);    \
 187     const int t5 = OP( 2676 * blk[2 * step] + 1108 * blk[6 * step]);    \
 188     const int t6 = ((blk[0 * step] + blk[4 * step]) << dshift) + bias;  \
 189     const int t7 = ((blk[0 * step] - blk[4 * step]) << dshift) + bias;  \
 190     const int t8 = t0 + t2;                                             \
 191     const int t9 = t0 - t2;                                             \
 192     const int tA = 181 * (t9 + (t1 - t3)) + 0x80 >> 8;                  \
 193     const int tB = 181 * (t9 - (t1 - t3)) + 0x80 >> 8;                  \
 194     const int tC = t1 + t3;                                             \
 195                                                                         \
 196     blk[0 * step] = (t6 + t5 + t8) >> shift;                            \
 197     blk[1 * step] = (t7 + t4 + tA) >> shift;                            \
 198     blk[2 * step] = (t7 - t4 + tB) >> shift;                            \
 199     blk[3 * step] = (t6 - t5 + tC) >> shift;                            \
 200     blk[4 * step] = (t6 - t5 - tC) >> shift;                            \
 201     blk[5 * step] = (t7 - t4 - tB) >> shift;                            \
 202     blk[6 * step] = (t7 + t4 - tA) >> shift;                            \
 203     blk[7 * step] = (t6 + t5 - t8) >> shift;                            \
 204
 205 #define ROP(x) x
 206 #define COP(x) (((x) + 4) >> 3)
 207
 208 static void clv_dct(int16_t *block)
 209 {
 210     int i;
 211     int16_t *ptr;
 212
 213     ptr = block;
 214     for (i = 0; i < 8; i++) {
 215         DCT_TEMPLATE(ptr, 1, 0x80, 8, 11, ROP);
 216         ptr += 8;
 217     }
 218
 219     ptr = block;
 220     for (i = 0; i < 8; i++) {
 221         DCT_TEMPLATE(ptr, 8, 0x2000, 14, 8, COP);
 222         ptr++;
 223     }
 224 }
 225
 226 static int decode_mb(CLVContext *c, int x, int y)
 227 {
 228     int i;
 229     int has_ac[6];
 230     int off;
 231
 232     for (i = 0; i < 6; i++)
 233         has_ac[i] = get_bits1(&c->gb);
 234
 235     off = x * 16 + y * 16 * c->pic->linesize[0];
 236     for (i = 0; i < 4; i++) {
 237         if (decode_block(c, c->block, has_ac[i], c->ac_quant) < 0)
 238             return AVERROR_INVALIDDATA;
 239         if (!x && !(i & 1)) {
 240             c->block[0] += c->top_dc[0];
 241             c->top_dc[0] = c->block[0];
 242         } else {
 243             c->block[0] += c->left_dc[(i & 2) >> 1];
 244         }
 245         c->left_dc[(i & 2) >> 1] = c->block[0];
 246         c->block[0]             *= c->luma_dc_quant;
 247         clv_dct(c->block);
 248         if (i == 2)
 249             off += c->pic->linesize[0] * 8;
 250         c->idsp.put_pixels_clamped(c->block, c->pic->data[0] + off + (i & 1) * 8,
 251                                    c->pic->linesize[0]);
 252     }
 253
 254     off = x * 8 + y * 8 * c->pic->linesize[1];
 255     for (i = 1; i < 3; i++) {
 256         if (decode_block(c, c->block, has_ac[i + 3], c->ac_quant) < 0)
 257             return AVERROR_INVALIDDATA;
 258         if (!x) {
 259             c->block[0] += c->top_dc[i];
 260             c->top_dc[i] = c->block[0];
 261         } else {
 262             c->block[0] += c->left_dc[i + 1];
 263         }
 264         c->left_dc[i + 1] = c->block[0];
 265         c->block[0]      *= c->chroma_dc_quant;
 266         clv_dct(c->block);
 267         c->idsp.put_pixels_clamped(c->block, c->pic->data[i] + off,
 268                                    c->pic->linesize[i]);
 269     }
 270
 271     return 0;
 272 }
 273
 274 static int clv_decode_frame(AVCodecContext *avctx, void *data,
 275                             int *got_frame, AVPacket *avpkt)
 276 {
 277     const uint8_t *buf = avpkt->data;
 278     int buf_size = avpkt->size;
 279     CLVContext *c = avctx->priv_data;
 280     GetByteContext gb;
 281     uint32_t frame_type;
 282     int i, j;
 283     int ret;
 284
 285     bytestream2_init(&gb, buf, buf_size);
 286     if (avctx->codec_tag == MKTAG('C','L','V','1')) {
 287         int skip = bytestream2_get_byte(&gb);
 288         bytestream2_skip(&gb, (skip + 1) * 8);
 289     }
 290
 291     frame_type = bytestream2_get_byte(&gb);
 292     if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
 293         return ret;
 294
 295     c->pic->key_frame = frame_type & 0x20 ? 1 : 0;
 296     c->pic->pict_type = frame_type & 0x20 ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
 297
 298     if (frame_type & 0x2) {
 299         bytestream2_get_be32(&gb); // frame size;
 300         c->ac_quant        = bytestream2_get_byte(&gb);
 301         c->luma_dc_quant   = 32;
 302         c->chroma_dc_quant = 32;
 303
 304         if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
 305                                   (buf_size - bytestream2_tell(&gb)))) < 0)
 306             return ret;
 307
 308         for (i = 0; i < 3; i++)
 309             c->top_dc[i] = 32;
 310         for (i = 0; i < 4; i++)
 311             c->left_dc[i] = 32;
 312
 313         for (j = 0; j < c->mb_height; j++) {
 314             for (i = 0; i < c->mb_width; i++) {
 315                 ret |= decode_mb(c, i, j);
 316             }
 317         }
 318     } else {
 319     }
 320
 321     if ((ret = av_frame_ref(data, c->pic)) < 0)
 322         return ret;
 323
 324     *got_frame = 1;
 325
 326     return ret < 0 ? ret : buf_size;
 327 }
 328
 329 static av_cold int clv_decode_init(AVCodecContext *avctx)
 330 {
 331     CLVContext * const c = avctx->priv_data;
 332     int ret;
 333
 334     c->avctx = avctx;
 335
 336     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 337
 338     c->pic = av_frame_alloc();
 339     if (!c->pic)
 340         return AVERROR(ENOMEM);
 341
 342     c->mb_width  = FFALIGN(avctx->width,  16) >> 4;
 343     c->mb_height = FFALIGN(avctx->height, 16) >> 4;
 344
 345     ff_idctdsp_init(&c->idsp, avctx);
 346     ret = init_vlc(&c->dc_vlc, 9, NUM_DC_CODES,
 347                    clv_dc_bits,  1, 1,
 348                    clv_dc_codes, 1, 1, 0);
 349     if (ret) {
 350         av_log(avctx, AV_LOG_ERROR, "Error initialising DC VLC\n");
 351         return ret;
 352     }
 353     ret = ff_init_vlc_sparse(&c->ac_vlc, 9, NUM_AC_CODES,
 354                              clv_ac_bits,  1, 1,
 355                              clv_ac_codes, 1, 1,
 356                              clv_ac_syms,  2, 2, 0);
 357     if (ret) {
 358         av_log(avctx, AV_LOG_ERROR, "Error initialising AC VLC\n");
 359         return ret;
 360     }
 361
 362     return 0;
 363 }
 364
 365 static av_cold int clv_decode_end(AVCodecContext *avctx)
 366 {
 367     CLVContext * const c = avctx->priv_data;
 368
 369     av_frame_free(&c->pic);
 370
 371     ff_free_vlc(&c->dc_vlc);
 372     ff_free_vlc(&c->ac_vlc);
 373
 374     return 0;
 375 }
 376
 377 AVCodec ff_clearvideo_decoder = {
 378     .name           = "clearvideo",
 379     .type           = AVMEDIA_TYPE_VIDEO,
 380     .id             = AV_CODEC_ID_CLEARVIDEO,
 381     .priv_data_size = sizeof(CLVContext),
 382     .init           = clv_decode_init,
 383     .close          = clv_decode_end,
 384     .decode         = clv_decode_frame,
 385     .capabilities   = CODEC_CAP_DR1,
 386     .long_name      = NULL_IF_CONFIG_SMALL("Iterated Systems ClearVideo"),
 387 };