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

   1 /*
   2  * Copyright (C) 2005  Ole André Vadla Ravnås <oleavr@gmail.com>
   3  * Copyright (C) 2008  Ramiro Polla
   4  *
   5  * This file is part of Libav.
   6  *
   7  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <stdint.h>
  25
  26 #include "avcodec.h"
  27 #include "blockdsp.h"
  28 #include "internal.h"
  29 #include "get_bits.h"
  30 #include "bytestream.h"
  31 #include "bswapdsp.h"
  32 #include "hpeldsp.h"
  33 #include "idctdsp.h"
  34 #include "thread.h"
  35
  36 #define MIMIC_HEADER_SIZE   20
  37
  38 typedef struct MimicContext {
  39     AVCodecContext *avctx;
  40
  41     int             num_vblocks[3];
  42     int             num_hblocks[3];
  43
  44     void           *swap_buf;
  45     int             swap_buf_size;
  46
  47     int             cur_index;
  48     int             prev_index;
  49
  50     ThreadFrame     frames     [16];
  51     AVPicture       flipped_ptrs[16];
  52
  53     DECLARE_ALIGNED(16, int16_t, dct_block)[64];
  54
  55     GetBitContext   gb;
  56     ScanTable       scantable;
  57     BlockDSPContext bdsp;
  58     BswapDSPContext bbdsp;
  59     HpelDSPContext  hdsp;
  60     IDCTDSPContext  idsp;
  61     VLC             vlc;
  62
  63     /* Kept in the context so multithreading can have a constant to read from */
  64     int             next_cur_index;
  65     int             next_prev_index;
  66 } MimicContext;
  67
  68 static const uint32_t huffcodes[] = {
  69     0x0000000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
  70     0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
  71     0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000000b,
  72     0x0000001b, 0x00000038, 0x00000078, 0x00000079, 0x0000007a, 0x000000f9,
  73     0x000000fa, 0x000003fb, 0x000007f8, 0x000007f9, 0x000007fa, 0x000007fb,
  74     0x00000ff8, 0x00000ff9, 0x00000001, 0x00000039, 0x0000007b, 0x000000fb,
  75     0x000001f8, 0x000001f9, 0x00000ffa, 0x00000ffb, 0x00001ff8, 0x00001ff9,
  76     0x00001ffa, 0x00001ffb, 0x00003ff8, 0x00003ff9, 0x00003ffa, 0x00000000,
  77     0x00000004, 0x0000003a, 0x000001fa, 0x00003ffb, 0x00007ff8, 0x00007ff9,
  78     0x00007ffa, 0x00007ffb, 0x0000fff8, 0x0000fff9, 0x0000fffa, 0x0000fffb,
  79     0x0001fff8, 0x0001fff9, 0x0001fffa, 0x00000000, 0x0000000c, 0x000000f8,
  80     0x000001fb, 0x0001fffb, 0x0003fff8, 0x0003fff9, 0x0003fffa, 0x0003fffb,
  81     0x0007fff8, 0x0007fff9, 0x0007fffa, 0x0007fffb, 0x000ffff8, 0x000ffff9,
  82     0x000ffffa, 0x00000000, 0x0000001a, 0x000003f8, 0x000ffffb, 0x001ffff8,
  83     0x001ffff9, 0x001ffffa, 0x001ffffb, 0x003ffff8, 0x003ffff9, 0x003ffffa,
  84     0x003ffffb, 0x007ffff8, 0x007ffff9, 0x007ffffa, 0x007ffffb, 0x00000000,
  85     0x0000003b, 0x000003f9, 0x00fffff8, 0x00fffff9, 0x00fffffa, 0x00fffffb,
  86     0x01fffff8, 0x01fffff9, 0x01fffffa, 0x01fffffb, 0x03fffff8, 0x03fffff9,
  87     0x03fffffa, 0x03fffffb, 0x07fffff8, 0x00000000, 0x000003fa, 0x07fffff9,
  88     0x07fffffa, 0x07fffffb, 0x0ffffff8, 0x0ffffff9, 0x0ffffffa, 0x0ffffffb,
  89     0x1ffffff8, 0x1ffffff9, 0x1ffffffa, 0x1ffffffb, 0x3ffffff8, 0x3ffffff9,
  90     0x3ffffffa,
  91 };
  92
  93 static const uint8_t huffbits[] = {
  94      4,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  95      0,  0,  0,  0,  2,  4,  5,  6,  7,  7,  7,  8,
  96      8, 10, 11, 11, 11, 11, 12, 12,  2,  6,  7,  8,
  97      9,  9, 12, 12, 13, 13, 13, 13, 14, 14, 14,  0,
  98      3,  6,  9, 14, 15, 15, 15, 15, 16, 16, 16, 16,
  99     17, 17, 17,  0,  4,  8,  9, 17, 18, 18, 18, 18,
 100     19, 19, 19, 19, 20, 20, 20,  0,  5, 10, 20, 21,
 101     21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23,  0,
 102      6, 10, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,
 103     26, 26, 27,  0, 10, 27, 27, 27, 28, 28, 28, 28,
 104     29, 29, 29, 29, 30, 30, 30,
 105 };
 106
 107 static const uint8_t col_zag[64] = {
 108      0,  8,  1,  2,  9, 16, 24, 17,
 109     10,  3,  4, 11, 18, 25, 32, 40,
 110     33, 26, 19, 12,  5,  6, 13, 20,
 111     27, 34, 41, 48, 56, 49, 42, 35,
 112     28, 21, 14,  7, 15, 22, 29, 36,
 113     43, 50, 57, 58, 51, 44, 37, 30,
 114     23, 31, 38, 45, 52, 59, 39, 46,
 115     53, 60, 61, 54, 47, 55, 62, 63,
 116 };
 117
 118 static av_cold int mimic_decode_end(AVCodecContext *avctx)
 119 {
 120     MimicContext *ctx = avctx->priv_data;
 121     int i;
 122
 123     av_free(ctx->swap_buf);
 124
 125     for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
 126         if (ctx->frames[i].f)
 127             ff_thread_release_buffer(avctx, &ctx->frames[i]);
 128         av_frame_free(&ctx->frames[i].f);
 129     }
 130
 131     if (!avctx->internal->is_copy)
 132         ff_free_vlc(&ctx->vlc);
 133
 134     return 0;
 135 }
 136
 137 static av_cold int mimic_decode_init(AVCodecContext *avctx)
 138 {
 139     MimicContext *ctx = avctx->priv_data;
 140     int ret, i;
 141
 142     avctx->internal->allocate_progress = 1;
 143
 144     ctx->prev_index = 0;
 145     ctx->cur_index  = 15;
 146
 147     if ((ret = init_vlc(&ctx->vlc, 11, FF_ARRAY_ELEMS(huffbits),
 148                         huffbits, 1, 1, huffcodes, 4, 4, 0)) < 0) {
 149         av_log(avctx, AV_LOG_ERROR, "error initializing vlc table\n");
 150         return ret;
 151     }
 152     ff_blockdsp_init(&ctx->bdsp, avctx);
 153     ff_bswapdsp_init(&ctx->bbdsp);
 154     ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
 155     ff_idctdsp_init(&ctx->idsp, avctx);
 156     ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, col_zag);
 157
 158     for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
 159         ctx->frames[i].f = av_frame_alloc();
 160         if (!ctx->frames[i].f) {
 161             mimic_decode_end(avctx);
 162             return AVERROR(ENOMEM);
 163         }
 164     }
 165
 166     return 0;
 167 }
 168
 169 static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
 170 {
 171     MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
 172     int i, ret;
 173
 174     if (avctx == avctx_from)
 175         return 0;
 176
 177     dst->cur_index  = src->next_cur_index;
 178     dst->prev_index = src->next_prev_index;
 179
 180     memcpy(dst->flipped_ptrs, src->flipped_ptrs, sizeof(src->flipped_ptrs));
 181
 182     for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
 183         ff_thread_release_buffer(avctx, &dst->frames[i]);
 184         if (src->frames[i].f->data[0]) {
 185             ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
 186             if (ret < 0)
 187                 return ret;
 188         }
 189     }
 190
 191     return 0;
 192 }
 193
 194 static const int8_t vlcdec_lookup[9][64] = {
 195     {    0, },
 196     {   -1,   1, },
 197     {   -3,   3,   -2,   2, },
 198     {   -7,   7,   -6,   6,   -5,   5,   -4,   4, },
 199     {  -15,  15,  -14,  14,  -13,  13,  -12,  12,
 200        -11,  11,  -10,  10,   -9,   9,   -8,   8, },
 201     {  -31,  31,  -30,  30,  -29,  29,  -28,  28,
 202        -27,  27,  -26,  26,  -25,  25,  -24,  24,
 203        -23,  23,  -22,  22,  -21,  21,  -20,  20,
 204        -19,  19,  -18,  18,  -17,  17,  -16,  16, },
 205     {  -63,  63,  -62,  62,  -61,  61,  -60,  60,
 206        -59,  59,  -58,  58,  -57,  57,  -56,  56,
 207        -55,  55,  -54,  54,  -53,  53,  -52,  52,
 208        -51,  51,  -50,  50,  -49,  49,  -48,  48,
 209        -47,  47,  -46,  46,  -45,  45,  -44,  44,
 210        -43,  43,  -42,  42,  -41,  41,  -40,  40,
 211        -39,  39,  -38,  38,  -37,  37,  -36,  36,
 212        -35,  35,  -34,  34,  -33,  33,  -32,  32, },
 213     { -127, 127, -126, 126, -125, 125, -124, 124,
 214       -123, 123, -122, 122, -121, 121, -120, 120,
 215       -119, 119, -118, 118, -117, 117, -116, 116,
 216       -115, 115, -114, 114, -113, 113, -112, 112,
 217       -111, 111, -110, 110, -109, 109, -108, 108,
 218       -107, 107, -106, 106, -105, 105, -104, 104,
 219       -103, 103, -102, 102, -101, 101, -100, 100,
 220        -99,  99,  -98,  98,  -97,  97,  -96,  96, },
 221     {  -95,  95,  -94,  94,  -93,  93,  -92,  92,
 222        -91,  91,  -90,  90,  -89,  89,  -88,  88,
 223        -87,  87,  -86,  86,  -85,  85,  -84,  84,
 224        -83,  83,  -82,  82,  -81,  81,  -80,  80,
 225        -79,  79,  -78,  78,  -77,  77,  -76,  76,
 226        -75,  75,  -74,  74,  -73,  73,  -72,  72,
 227        -71,  71,  -70,  70,  -69,  69,  -68,  68,
 228        -67,  67,  -66,  66,  -65,  65,  -64,  64, },
 229 };
 230
 231 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
 232 {
 233     int16_t *block = ctx->dct_block;
 234     unsigned int pos;
 235
 236     ctx->bdsp.clear_block(block);
 237
 238     block[0] = get_bits(&ctx->gb, 8) << 3;
 239
 240     for (pos = 1; pos < num_coeffs; pos++) {
 241         uint32_t vlc, num_bits;
 242         int value;
 243         int coeff;
 244
 245         vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3);
 246         if (!vlc) /* end-of-block code */
 247             return 0;
 248         if (vlc == -1)
 249             return AVERROR_INVALIDDATA;
 250
 251         /* pos_add and num_bits are coded in the vlc code */
 252         pos     += vlc & 15; // pos_add
 253         num_bits = vlc >> 4; // num_bits
 254
 255         if (pos >= 64)
 256             return AVERROR_INVALIDDATA;
 257
 258         value = get_bits(&ctx->gb, num_bits);
 259
 260         /* Libav's IDCT behaves somewhat different from the original code, so
 261          * a factor of 4 was added to the input */
 262
 263         coeff = vlcdec_lookup[num_bits][value];
 264         if (pos < 3)
 265             coeff <<= 4;
 266         else /* TODO Use >> 10 instead of / 1001 */
 267             coeff = (coeff * qscale) / 1001;
 268
 269         block[ctx->scantable.permutated[pos]] = coeff;
 270     }
 271
 272     return 0;
 273 }
 274
 275 static int decode(MimicContext *ctx, int quality, int num_coeffs,
 276                   int is_iframe)
 277 {
 278     int ret, y, x, plane, cur_row = 0;
 279
 280     for (plane = 0; plane < 3; plane++) {
 281         const int is_chroma = !!plane;
 282         const int qscale    = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
 283                                       10000) << 2;
 284         const int stride    = ctx->flipped_ptrs[ctx->cur_index ].linesize[plane];
 285         const uint8_t *src  = ctx->flipped_ptrs[ctx->prev_index].data[plane];
 286         uint8_t       *dst  = ctx->flipped_ptrs[ctx->cur_index ].data[plane];
 287
 288         for (y = 0; y < ctx->num_vblocks[plane]; y++) {
 289             for (x = 0; x < ctx->num_hblocks[plane]; x++) {
 290                 /* Check for a change condition in the current block.
 291                  * - iframes always change.
 292                  * - Luma plane changes on get_bits1 == 0
 293                  * - Chroma planes change on get_bits1 == 1 */
 294                 if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
 295                     /* Luma planes may use a backreference from the 15 last
 296                      * frames preceding the previous. (get_bits1 == 1)
 297                      * Chroma planes don't use backreferences. */
 298                     if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
 299                         if ((ret = vlc_decode_block(ctx, num_coeffs,
 300                                                     qscale)) < 0) {
 301                             av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
 302                                    "block.\n");
 303                             return ret;
 304                         }
 305                         ctx->idsp.idct_put(dst, stride, ctx->dct_block);
 306                     } else {
 307                         unsigned int backref = get_bits(&ctx->gb, 4);
 308                         int index            = (ctx->cur_index + backref) & 15;
 309                         uint8_t *p           = ctx->flipped_ptrs[index].data[0];
 310
 311                         if (index != ctx->cur_index && p) {
 312                             ff_thread_await_progress(&ctx->frames[index],
 313                                                      cur_row, 0);
 314                             p += src -
 315                                  ctx->flipped_ptrs[ctx->prev_index].data[plane];
 316                             ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
 317                         } else {
 318                             av_log(ctx->avctx, AV_LOG_ERROR,
 319                                      "No such backreference! Buggy sample.\n");
 320                         }
 321                     }
 322                 } else {
 323                     ff_thread_await_progress(&ctx->frames[ctx->prev_index],
 324                                              cur_row, 0);
 325                     ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
 326                 }
 327                 src += 8;
 328                 dst += 8;
 329             }
 330             src += (stride - ctx->num_hblocks[plane]) << 3;
 331             dst += (stride - ctx->num_hblocks[plane]) << 3;
 332
 333             ff_thread_report_progress(&ctx->frames[ctx->cur_index],
 334                                       cur_row++, 0);
 335         }
 336     }
 337
 338     return 0;
 339 }
 340
 341 /**
 342  * Flip the buffer upside-down and put it in the YVU order to match the
 343  * way Mimic encodes frames.
 344  */
 345 static void prepare_avpic(MimicContext *ctx, AVPicture *dst, AVFrame *src)
 346 {
 347     int i;
 348     dst->data[0] = src->data[0] + ( ctx->avctx->height       - 1) * src->linesize[0];
 349     dst->data[1] = src->data[2] + ((ctx->avctx->height >> 1) - 1) * src->linesize[2];
 350     dst->data[2] = src->data[1] + ((ctx->avctx->height >> 1) - 1) * src->linesize[1];
 351     for (i = 0; i < 3; i++)
 352         dst->linesize[i] = -src->linesize[i];
 353 }
 354
 355 static int mimic_decode_frame(AVCodecContext *avctx, void *data,
 356                               int *got_frame, AVPacket *avpkt)
 357 {
 358     const uint8_t *buf = avpkt->data;
 359     int buf_size       = avpkt->size;
 360     int swap_buf_size  = buf_size - MIMIC_HEADER_SIZE;
 361     MimicContext *ctx  = avctx->priv_data;
 362     GetByteContext gb;
 363     int is_pframe;
 364     int width, height;
 365     int quality, num_coeffs;
 366     int res;
 367
 368     if (buf_size <= MIMIC_HEADER_SIZE) {
 369         av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
 370         return AVERROR_INVALIDDATA;
 371     }
 372
 373     bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);
 374     bytestream2_skip(&gb, 2); /* some constant (always 256) */
 375     quality    = bytestream2_get_le16u(&gb);
 376     width      = bytestream2_get_le16u(&gb);
 377     height     = bytestream2_get_le16u(&gb);
 378     bytestream2_skip(&gb, 4); /* some constant */
 379     is_pframe  = bytestream2_get_le32u(&gb);
 380     num_coeffs = bytestream2_get_byteu(&gb);
 381     bytestream2_skip(&gb, 3); /* some constant */
 382
 383     if (!ctx->avctx) {
 384         int i;
 385
 386         if (!(width == 160 && height == 120) &&
 387             !(width == 320 && height == 240)) {
 388             av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
 389             return AVERROR_INVALIDDATA;
 390         }
 391
 392         ctx->avctx     = avctx;
 393         avctx->width   = width;
 394         avctx->height  = height;
 395         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 396         for (i = 0; i < 3; i++) {
 397             ctx->num_vblocks[i] = -((-height) >> (3 + !!i));
 398             ctx->num_hblocks[i] =     width   >> (3 + !!i);
 399         }
 400     } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
 401         avpriv_request_sample(avctx, "Resolution changing");
 402         return AVERROR_PATCHWELCOME;
 403     }
 404
 405     if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
 406         av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
 407         return AVERROR_INVALIDDATA;
 408     }
 409
 410     ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
 411     ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
 412                                                            AV_PICTURE_TYPE_I;
 413     if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
 414                                     AV_GET_BUFFER_FLAG_REF)) < 0) {
 415         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 416         return res;
 417     }
 418
 419     ctx->next_prev_index = ctx->cur_index;
 420     ctx->next_cur_index  = (ctx->cur_index - 1) & 15;
 421
 422     prepare_avpic(ctx, &ctx->flipped_ptrs[ctx->cur_index],
 423                   ctx->frames[ctx->cur_index].f);
 424
 425     ff_thread_finish_setup(avctx);
 426
 427     av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
 428     if (!ctx->swap_buf)
 429         return AVERROR(ENOMEM);
 430
 431     ctx->bbdsp.bswap_buf(ctx->swap_buf,
 432                          (const uint32_t *) (buf + MIMIC_HEADER_SIZE),
 433                          swap_buf_size >> 2);
 434     init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
 435
 436     res = decode(ctx, quality, num_coeffs, !is_pframe);
 437     ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
 438     if (res < 0) {
 439         if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
 440             ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
 441             return res;
 442         }
 443     }
 444
 445     if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0)
 446         return res;
 447     *got_frame      = 1;
 448
 449     ctx->prev_index = ctx->next_prev_index;
 450     ctx->cur_index  = ctx->next_cur_index;
 451
 452     /* Only release frames that aren't used for backreferences anymore */
 453     ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
 454
 455     return buf_size;
 456 }
 457
 458 static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
 459 {
 460     MimicContext *ctx = avctx->priv_data;
 461     int i;
 462
 463     for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
 464         ctx->frames[i].f = av_frame_alloc();
 465         if (!ctx->frames[i].f) {
 466             mimic_decode_end(avctx);
 467             return AVERROR(ENOMEM);
 468         }
 469     }
 470
 471     return 0;
 472 }
 473
 474 AVCodec ff_mimic_decoder = {
 475     .name                  = "mimic",
 476     .long_name             = NULL_IF_CONFIG_SMALL("Mimic"),
 477     .type                  = AVMEDIA_TYPE_VIDEO,
 478     .id                    = AV_CODEC_ID_MIMIC,
 479     .priv_data_size        = sizeof(MimicContext),
 480     .init                  = mimic_decode_init,
 481     .close                 = mimic_decode_end,
 482     .decode                = mimic_decode_frame,
 483     .capabilities          = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
 484     .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context),
 485     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy),
 486 };