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]) * (1 << dshift)) + bias;  \
 189     const int t7 = ((blk[0 * step] - blk[4 * step]) * (1 << dshift)) + bias;  \
 190     const int t8 = t0 + t2;                                             \
 191     const int t9 = t0 - t2;                                             \
 192     const int tA = (int)(181U * (t9 + (t1 - t3)) + 0x80) >> 8;          \
 193     const int tB = (int)(181U * (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     int mb_ret = 0;
 285
 286     bytestream2_init(&gb, buf, buf_size);
 287     if (avctx->codec_tag == MKTAG('C','L','V','1')) {
 288         int skip = bytestream2_get_byte(&gb);
 289         bytestream2_skip(&gb, (skip + 1) * 8);
 290     }
 291
 292     frame_type = bytestream2_get_byte(&gb);
 293
 294     if (frame_type & 0x2) {
 295         if (buf_size < c->mb_width * c->mb_height) {
 296             av_log(avctx, AV_LOG_ERROR, "Packet too small\n");
 297             return AVERROR_INVALIDDATA;
 298         }
 299
 300         if ((ret = ff_reget_buffer(avctx, c->pic)) < 0)
 301             return ret;
 302
 303         c->pic->key_frame = frame_type & 0x20 ? 1 : 0;
 304         c->pic->pict_type = frame_type & 0x20 ? AV_PICTURE_TYPE_I : AV_PICTURE_TYPE_P;
 305
 306         bytestream2_get_be32(&gb); // frame size;
 307         c->ac_quant        = bytestream2_get_byte(&gb);
 308         c->luma_dc_quant   = 32;
 309         c->chroma_dc_quant = 32;
 310
 311         if ((ret = init_get_bits8(&c->gb, buf + bytestream2_tell(&gb),
 312                                   (buf_size - bytestream2_tell(&gb)))) < 0)
 313             return ret;
 314
 315         for (i = 0; i < 3; i++)
 316             c->top_dc[i] = 32;
 317         for (i = 0; i < 4; i++)
 318             c->left_dc[i] = 32;
 319
 320         for (j = 0; j < c->mb_height; j++) {
 321             for (i = 0; i < c->mb_width; i++) {
 322                 ret = decode_mb(c, i, j);
 323                 if (ret < 0)
 324                     mb_ret = ret;
 325             }
 326         }
 327
 328         if ((ret = av_frame_ref(data, c->pic)) < 0)
 329             return ret;
 330
 331         *got_frame = 1;
 332     } else {
 333     }
 334
 335     return mb_ret < 0 ? mb_ret : buf_size;
 336 }
 337
 338 static av_cold int clv_decode_init(AVCodecContext *avctx)
 339 {
 340     CLVContext * const c = avctx->priv_data;
 341     int ret;
 342
 343     c->avctx = avctx;
 344
 345     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 346
 347     c->pic = av_frame_alloc();
 348     if (!c->pic)
 349         return AVERROR(ENOMEM);
 350
 351     c->mb_width  = FFALIGN(avctx->width,  16) >> 4;
 352     c->mb_height = FFALIGN(avctx->height, 16) >> 4;
 353
 354     ff_idctdsp_init(&c->idsp, avctx);
 355     ret = init_vlc(&c->dc_vlc, 9, NUM_DC_CODES,
 356                    clv_dc_bits,  1, 1,
 357                    clv_dc_codes, 1, 1, 0);
 358     if (ret) {
 359         av_log(avctx, AV_LOG_ERROR, "Error initialising DC VLC\n");
 360         return ret;
 361     }
 362     ret = ff_init_vlc_sparse(&c->ac_vlc, 9, NUM_AC_CODES,
 363                              clv_ac_bits,  1, 1,
 364                              clv_ac_codes, 1, 1,
 365                              clv_ac_syms,  2, 2, 0);
 366     if (ret) {
 367         av_log(avctx, AV_LOG_ERROR, "Error initialising AC VLC\n");
 368         return ret;
 369     }
 370
 371     return 0;
 372 }
 373
 374 static av_cold int clv_decode_end(AVCodecContext *avctx)
 375 {
 376     CLVContext * const c = avctx->priv_data;
 377
 378     av_frame_free(&c->pic);
 379
 380     ff_free_vlc(&c->dc_vlc);
 381     ff_free_vlc(&c->ac_vlc);
 382
 383     return 0;
 384 }
 385
 386 AVCodec ff_clearvideo_decoder = {
 387     .name           = "clearvideo",
 388     .type           = AVMEDIA_TYPE_VIDEO,
 389     .id             = AV_CODEC_ID_CLEARVIDEO,
 390     .priv_data_size = sizeof(CLVContext),
 391     .init           = clv_decode_init,
 392     .close          = clv_decode_end,
 393     .decode         = clv_decode_frame,
 394     .capabilities   = AV_CODEC_CAP_DR1,
 395     .long_name      = NULL_IF_CONFIG_SMALL("Iterated Systems ClearVideo"),
 396 };