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