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