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

   1 /*
   2  * TechSmith Screen Codec 2 (aka Dora) 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  * TechSmith Screen Codec 2 decoder
  25  */
  26
  27 #include <inttypes.h>
  28
  29 #include "libavutil/thread.h"
  30
  31 #define BITSTREAM_READER_LE
  32 #include "avcodec.h"
  33 #include "bytestream.h"
  34 #include "get_bits.h"
  35 #include "internal.h"
  36 #include "mathops.h"
  37 #include "tscc2data.h"
  38
  39 #define TSCC2_VLC_BITS 9
  40
  41 typedef struct TSCC2Context {
  42     AVCodecContext *avctx;
  43     AVFrame       *pic;
  44     int            mb_width, mb_height;
  45     uint8_t        *slice_quants;
  46     int            quant[2];
  47     int            q[2][3];
  48     GetBitContext  gb;
  49
  50     int            block[16];
  51 } TSCC2Context;
  52
  53 static VLC dc_vlc, nc_vlc[NUM_VLC_SETS], ac_vlc[NUM_VLC_SETS];
  54
  55 static av_cold void tscc2_init_vlc(VLC *vlc, int *offset, int nb_codes,
  56                                    const uint8_t *lens, const void *syms,
  57                                    int sym_length)
  58 {
  59     static VLC_TYPE vlc_buf[15442][2];
  60
  61     vlc->table           = &vlc_buf[*offset];
  62     vlc->table_allocated = FF_ARRAY_ELEMS(vlc_buf) - *offset;
  63     ff_init_vlc_from_lengths(vlc, TSCC2_VLC_BITS, nb_codes,
  64                              lens, 1, syms, sym_length, sym_length, 0,
  65                              INIT_VLC_STATIC_OVERLONG | INIT_VLC_OUTPUT_LE, NULL);
  66     *offset += vlc->table_size;
  67 }
  68
  69 static av_cold void tscc2_init_vlcs(void)
  70 {
  71     const uint16_t *ac_vlc_syms = tscc2_ac_vlc_syms;
  72     const uint8_t  *ac_vlc_lens = tscc2_ac_vlc_lens;
  73     int i, offset = 0;
  74
  75     tscc2_init_vlc(&dc_vlc, &offset, DC_VLC_COUNT,
  76                    tscc2_dc_vlc_lens, tscc2_dc_vlc_syms, 2);
  77
  78     for (i = 0; i < NUM_VLC_SETS; i++) {
  79         tscc2_init_vlc(&nc_vlc[i], &offset, 16,
  80                        tscc2_nc_vlc_lens[i], tscc2_nc_vlc_syms[i], 1);
  81
  82         tscc2_init_vlc(&ac_vlc[i], &offset, tscc2_ac_vlc_sizes[i],
  83                        ac_vlc_lens, ac_vlc_syms, 2);
  84         ac_vlc_lens += tscc2_ac_vlc_sizes[i];
  85         ac_vlc_syms += tscc2_ac_vlc_sizes[i];
  86     }
  87 }
  88
  89 #define DEQUANT(val, q) (((q) * (val) + 0x80) >> 8)
  90 #define DCT1D(d0, d1, d2, d3, s0, s1, s2, s3, OP) \
  91     OP(d0, 5 * ((s0) + (s1) + (s2)) + 2 * (s3));  \
  92     OP(d1, 5 * ((s0) - (s2) - (s3)) + 2 * (s1));  \
  93     OP(d2, 5 * ((s0) - (s2) + (s3)) - 2 * (s1));  \
  94     OP(d3, 5 * ((s0) - (s1) + (s2)) - 2 * (s3));  \
  95
  96 #define COL_OP(a, b)  a = (b)
  97 #define ROW_OP(a, b)  a = ((b) + 0x20) >> 6
  98
  99 static void tscc2_idct4_put(int *in, int q[3], uint8_t *dst, int stride)
 100 {
 101     int i;
 102     int tblk[4 * 4];
 103     int t0, t1, t2, t3;
 104
 105     for (i = 0; i < 4; i++) {
 106         t0 = DEQUANT(q[0 + (i & 1)], in[0 * 4 + i]);
 107         t1 = DEQUANT(q[1 + (i & 1)], in[1 * 4 + i]);
 108         t2 = DEQUANT(q[0 + (i & 1)], in[2 * 4 + i]);
 109         t3 = DEQUANT(q[1 + (i & 1)], in[3 * 4 + i]);
 110         DCT1D(tblk[0 * 4 + i], tblk[1 * 4 + i],
 111               tblk[2 * 4 + i], tblk[3 * 4 + i],
 112               t0, t1, t2, t3, COL_OP);
 113     }
 114     for (i = 0; i < 4; i++) {
 115         DCT1D(dst[0], dst[1], dst[2], dst[3],
 116               tblk[i * 4 + 0], tblk[i * 4 + 1],
 117               tblk[i * 4 + 2], tblk[i * 4 + 3], ROW_OP);
 118         dst += stride;
 119     }
 120 }
 121
 122 static int tscc2_decode_mb(TSCC2Context *c, int *q, int vlc_set,
 123                            uint8_t *dst, int stride, int plane)
 124 {
 125     GetBitContext *gb = &c->gb;
 126     int prev_dc, dc, nc, ac, bpos, val;
 127     int i, j, k, l;
 128
 129     if (get_bits1(gb)) {
 130         if (get_bits1(gb)) {
 131             val = get_bits(gb, 8);
 132             for (i = 0; i < 8; i++, dst += stride)
 133                 memset(dst, val, 16);
 134         } else {
 135             if (get_bits_left(gb) < 16 * 8 * 8)
 136                 return AVERROR_INVALIDDATA;
 137             for (i = 0; i < 8; i++) {
 138                 for (j = 0; j < 16; j++)
 139                     dst[j] = get_bits(gb, 8);
 140                 dst += stride;
 141             }
 142         }
 143         return 0;
 144     }
 145
 146     prev_dc = 0;
 147     for (j = 0; j < 2; j++) {
 148         for (k = 0; k < 4; k++) {
 149             if (!(j | k)) {
 150                 dc = get_bits(gb, 8);
 151             } else {
 152                 dc = get_vlc2(gb, dc_vlc.table, TSCC2_VLC_BITS, 2);
 153                 if (dc == 0x100)
 154                     dc = get_bits(gb, 8);
 155             }
 156             dc          = (dc + prev_dc) & 0xFF;
 157             prev_dc     = dc;
 158             c->block[0] = dc;
 159
 160             nc = get_vlc2(gb, nc_vlc[vlc_set].table, TSCC2_VLC_BITS, 1);
 161
 162             bpos = 1;
 163             memset(c->block + 1, 0, 15 * sizeof(*c->block));
 164             for (l = 0; l < nc; l++) {
 165                 ac = get_vlc2(gb, ac_vlc[vlc_set].table, TSCC2_VLC_BITS, 2);
 166                 if (ac == 0x1000)
 167                     ac = get_bits(gb, 12);
 168                 bpos += ac & 0xF;
 169                 if (bpos >= 16)
 170                     return AVERROR_INVALIDDATA;
 171                 val = sign_extend(ac >> 4, 8);
 172                 c->block[ff_zigzag_scan[bpos++]] = val;
 173             }
 174             tscc2_idct4_put(c->block, q, dst + k * 4, stride);
 175         }
 176         dst += 4 * stride;
 177     }
 178     return 0;
 179 }
 180
 181 static int tscc2_decode_slice(TSCC2Context *c, int mb_y,
 182                               const uint8_t *buf, int buf_size)
 183 {
 184     int i, mb_x, q, ret;
 185     int off;
 186
 187     if ((ret = init_get_bits8(&c->gb, buf, buf_size)) < 0)
 188         return ret;
 189
 190     for (mb_x = 0; mb_x < c->mb_width; mb_x++) {
 191         q = c->slice_quants[mb_x + c->mb_width * mb_y];
 192
 193         if (q == 0 || q == 3) // skip block
 194             continue;
 195         for (i = 0; i < 3; i++) {
 196             off = mb_x * 16 + mb_y * 8 * c->pic->linesize[i];
 197             ret = tscc2_decode_mb(c, c->q[q - 1], c->quant[q - 1] - 2,
 198                                   c->pic->data[i] + off, c->pic->linesize[i], i);
 199             if (ret)
 200                 return ret;
 201         }
 202     }
 203
 204     return 0;
 205 }
 206
 207 static int tscc2_decode_frame(AVCodecContext *avctx, void *data,
 208                               int *got_frame, AVPacket *avpkt)
 209 {
 210     const uint8_t *buf = avpkt->data;
 211     int buf_size = avpkt->size;
 212     TSCC2Context *c = avctx->priv_data;
 213     GetByteContext gb;
 214     uint32_t frame_type, size;
 215     int i, val, len, pos = 0;
 216     int num_mb = c->mb_width * c->mb_height;
 217     int ret;
 218
 219     bytestream2_init(&gb, buf, buf_size);
 220     frame_type = bytestream2_get_byte(&gb);
 221     if (frame_type > 1) {
 222         av_log(avctx, AV_LOG_ERROR, "Incorrect frame type %"PRIu32"\n",
 223                frame_type);
 224         return AVERROR_INVALIDDATA;
 225     }
 226
 227     if (frame_type == 0) {
 228         // Skip duplicate frames
 229         return buf_size;
 230     }
 231
 232     if ((ret = ff_reget_buffer(avctx, c->pic, 0)) < 0) {
 233         return ret;
 234     }
 235
 236     if (bytestream2_get_bytes_left(&gb) < 4) {
 237         av_log(avctx, AV_LOG_ERROR, "Frame is too short\n");
 238         return AVERROR_INVALIDDATA;
 239     }
 240
 241     c->quant[0] = bytestream2_get_byte(&gb);
 242     c->quant[1] = bytestream2_get_byte(&gb);
 243     if (c->quant[0] < 2 || c->quant[0] > NUM_VLC_SETS + 1 ||
 244         c->quant[1] < 2 || c->quant[1] > NUM_VLC_SETS + 1) {
 245         av_log(avctx, AV_LOG_ERROR, "Invalid quantisers %d / %d\n",
 246                c->quant[0], c->quant[1]);
 247         return AVERROR_INVALIDDATA;
 248     }
 249
 250     for (i = 0; i < 3; i++) {
 251         c->q[0][i] = tscc2_quants[c->quant[0] - 2][i];
 252         c->q[1][i] = tscc2_quants[c->quant[1] - 2][i];
 253     }
 254
 255     bytestream2_skip(&gb, 1);
 256
 257     size = bytestream2_get_le32(&gb);
 258     if (size > bytestream2_get_bytes_left(&gb)) {
 259         av_log(avctx, AV_LOG_ERROR, "Slice properties chunk is too large\n");
 260         return AVERROR_INVALIDDATA;
 261     }
 262
 263     for (i = 0; i < size; i++) {
 264         val   = bytestream2_get_byte(&gb);
 265         len   = val & 0x3F;
 266         val >>= 6;
 267         if (pos + len > num_mb) {
 268             av_log(avctx, AV_LOG_ERROR, "Too many slice properties\n");
 269             return AVERROR_INVALIDDATA;
 270         }
 271         memset(c->slice_quants + pos, val, len);
 272         pos += len;
 273     }
 274     if (pos < num_mb) {
 275         av_log(avctx, AV_LOG_ERROR, "Too few slice properties (%d / %d)\n",
 276                pos, num_mb);
 277         return AVERROR_INVALIDDATA;
 278     }
 279
 280     for (i = 0; i < c->mb_height; i++) {
 281         size = bytestream2_peek_byte(&gb);
 282         if (size & 1) {
 283             size = bytestream2_get_byte(&gb) - 1;
 284         } else {
 285             size = bytestream2_get_le32(&gb) >> 1;
 286         }
 287         if (!size) {
 288             int skip_row = 1, j, off = i * c->mb_width;
 289             for (j = 0; j < c->mb_width; j++) {
 290                 if (c->slice_quants[off + j] == 1 ||
 291                     c->slice_quants[off + j] == 2) {
 292                     skip_row = 0;
 293                     break;
 294                 }
 295             }
 296             if (!skip_row) {
 297                 av_log(avctx, AV_LOG_ERROR, "Non-skip row with zero size\n");
 298                 return AVERROR_INVALIDDATA;
 299             }
 300         }
 301         if (bytestream2_get_bytes_left(&gb) < size) {
 302             av_log(avctx, AV_LOG_ERROR, "Invalid slice size (%"PRIu32"/%u)\n",
 303                    size, bytestream2_get_bytes_left(&gb));
 304             return AVERROR_INVALIDDATA;
 305         }
 306         ret = tscc2_decode_slice(c, i, buf + bytestream2_tell(&gb), size);
 307         if (ret) {
 308             av_log(avctx, AV_LOG_ERROR, "Error decoding slice %d\n", i);
 309             return ret;
 310         }
 311         bytestream2_skip(&gb, size);
 312     }
 313
 314     *got_frame      = 1;
 315     if ((ret = av_frame_ref(data, c->pic)) < 0)
 316         return ret;
 317
 318     /* always report that the buffer was completely consumed */
 319     return buf_size;
 320 }
 321
 322 static av_cold int tscc2_decode_end(AVCodecContext *avctx)
 323 {
 324     TSCC2Context * const c = avctx->priv_data;
 325
 326     av_frame_free(&c->pic);
 327     av_freep(&c->slice_quants);
 328
 329     return 0;
 330 }
 331
 332 static av_cold int tscc2_decode_init(AVCodecContext *avctx)
 333 {
 334     TSCC2Context * const c = avctx->priv_data;
 335     static AVOnce init_static_once = AV_ONCE_INIT;
 336
 337     c->avctx = avctx;
 338
 339     avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 340
 341     c->mb_width     = FFALIGN(avctx->width,  16) >> 4;
 342     c->mb_height    = FFALIGN(avctx->height,  8) >> 3;
 343     c->slice_quants = av_malloc(c->mb_width * c->mb_height);
 344     if (!c->slice_quants) {
 345         av_log(avctx, AV_LOG_ERROR, "Cannot allocate slice information\n");
 346         return AVERROR(ENOMEM);
 347     }
 348
 349     c->pic = av_frame_alloc();
 350     if (!c->pic)
 351         return AVERROR(ENOMEM);
 352
 353     ff_thread_once(&init_static_once, tscc2_init_vlcs);
 354
 355     return 0;
 356 }
 357
 358 const AVCodec ff_tscc2_decoder = {
 359     .name           = "tscc2",
 360     .long_name      = NULL_IF_CONFIG_SMALL("TechSmith Screen Codec 2"),
 361     .type           = AVMEDIA_TYPE_VIDEO,
 362     .id             = AV_CODEC_ID_TSCC2,
 363     .priv_data_size = sizeof(TSCC2Context),
 364     .init           = tscc2_decode_init,
 365     .close          = tscc2_decode_end,
 366     .decode         = tscc2_decode_frame,
 367     .capabilities   = AV_CODEC_CAP_DR1,
 368     .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_INIT_THREADSAFE,
 369 };