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