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 "bitstream.h"
  28 #include "blockdsp.h"
  29 #include "internal.h"
  30 #include "bytestream.h"
  31 #include "bswapdsp.h"
  32 #include "hpeldsp.h"
  33 #include "idctdsp.h"
  34 #include "thread.h"
  35 #include "vlc.h"
  36
  37 #define MIMIC_HEADER_SIZE   20
  38
  39 typedef struct MimicContext {
  40     AVCodecContext *avctx;
  41
  42     int             num_vblocks[3];
  43     int             num_hblocks[3];
  44
  45     void           *swap_buf;
  46     int             swap_buf_size;
  47
  48     int             cur_index;
  49     int             prev_index;
  50
  51     ThreadFrame     frames     [16];
  52
  53     DECLARE_ALIGNED(16, int16_t, dct_block)[64];
  54
  55     BitstreamContext bc;
  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);
 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     for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
 181         ff_thread_release_buffer(avctx, &dst->frames[i]);
 182         if (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] = bitstream_read(&ctx->bc, 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 = bitstream_read_vlc(&ctx->bc, 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 = bitstream_read(&ctx->bc, num_bits);
 257
 258         /* Libav'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->frames[ctx->cur_index ].f->linesize[plane];
 283         const uint8_t *src  = ctx->frames[ctx->prev_index].f->data[plane];
 284         uint8_t       *dst  = ctx->frames[ctx->cur_index ].f->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 bitstream_read_bit == 0
 291                  * - Chroma planes change on bitstream_read_bit == 1 */
 292                 if (is_iframe || bitstream_read_bit(&ctx->bc) == is_chroma) {
 293                     /* Luma planes may use a backreference from the 15 last
 294                      * frames preceding the previous. (bitstream_read_bit == 1)
 295                      * Chroma planes don't use backreferences. */
 296                     if (is_chroma || is_iframe || !bitstream_read_bit(&ctx->bc)) {
 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->idsp.idct_put(dst, stride, ctx->dct_block);
 304                     } else {
 305                         unsigned int backref = bitstream_read(&ctx->bc, 4);
 306                         int index            = (ctx->cur_index + backref) & 15;
 307                         uint8_t *p           = ctx->frames[index].f->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->frames[ctx->prev_index].f->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 revert the
 341  * way Mimic encodes frames.
 342  */
 343 static void flip_swap_frame(AVFrame *f)
 344 {
 345     int i;
 346     uint8_t *data_1 = f->data[1];
 347     f->data[0] = f->data[0] + ( f->height       - 1) * f->linesize[0];
 348     f->data[1] = f->data[2] + ((f->height >> 1) - 1) * f->linesize[2];
 349     f->data[2] = data_1     + ((f->height >> 1) - 1) * f->linesize[1];
 350     for (i = 0; i < 3; i++)
 351         f->linesize[i] *= -1;
 352 }
 353
 354 static int mimic_decode_frame(AVCodecContext *avctx, void *data,
 355                               int *got_frame, AVPacket *avpkt)
 356 {
 357     const uint8_t *buf = avpkt->data;
 358     int buf_size       = avpkt->size;
 359     int swap_buf_size  = buf_size - MIMIC_HEADER_SIZE;
 360     MimicContext *ctx  = avctx->priv_data;
 361     GetByteContext gb;
 362     int is_pframe;
 363     int width, height;
 364     int quality, num_coeffs;
 365     int res;
 366
 367     if (buf_size <= MIMIC_HEADER_SIZE) {
 368         av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
 369         return AVERROR_INVALIDDATA;
 370     }
 371
 372     bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);
 373     bytestream2_skip(&gb, 2); /* some constant (always 256) */
 374     quality    = bytestream2_get_le16u(&gb);
 375     width      = bytestream2_get_le16u(&gb);
 376     height     = bytestream2_get_le16u(&gb);
 377     bytestream2_skip(&gb, 4); /* some constant */
 378     is_pframe  = bytestream2_get_le32u(&gb);
 379     num_coeffs = bytestream2_get_byteu(&gb);
 380     bytestream2_skip(&gb, 3); /* some constant */
 381
 382     if (!ctx->avctx) {
 383         int i;
 384
 385         if (!(width == 160 && height == 120) &&
 386             !(width == 320 && height == 240)) {
 387             av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
 388             return AVERROR_INVALIDDATA;
 389         }
 390
 391         ctx->avctx     = avctx;
 392         avctx->width   = width;
 393         avctx->height  = height;
 394         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 395         for (i = 0; i < 3; i++) {
 396             ctx->num_vblocks[i] = AV_CEIL_RSHIFT(height,   3 + !!i);
 397             ctx->num_hblocks[i] =                width >> (3 + !!i);
 398         }
 399     } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
 400         avpriv_request_sample(avctx, "Resolution changing");
 401         return AVERROR_PATCHWELCOME;
 402     }
 403
 404     if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
 405         av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
 406         return AVERROR_INVALIDDATA;
 407     }
 408
 409     ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
 410     ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
 411                                                            AV_PICTURE_TYPE_I;
 412     if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
 413                                     AV_GET_BUFFER_FLAG_REF)) < 0) {
 414         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 415         return res;
 416     }
 417
 418     ctx->next_prev_index = ctx->cur_index;
 419     ctx->next_cur_index  = (ctx->cur_index - 1) & 15;
 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->bbdsp.bswap_buf(ctx->swap_buf,
 428                          (const uint32_t *) (buf + MIMIC_HEADER_SIZE),
 429                          swap_buf_size >> 2);
 430     bitstream_init8(&ctx->bc, ctx->swap_buf, swap_buf_size);
 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     if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0)
 441         return res;
 442     *got_frame      = 1;
 443
 444     flip_swap_frame(data);
 445
 446     ctx->prev_index = ctx->next_prev_index;
 447     ctx->cur_index  = ctx->next_cur_index;
 448
 449     return buf_size;
 450 }
 451
 452 static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
 453 {
 454     MimicContext *ctx = avctx->priv_data;
 455     int i;
 456
 457     for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
 458         ctx->frames[i].f = av_frame_alloc();
 459         if (!ctx->frames[i].f) {
 460             mimic_decode_end(avctx);
 461             return AVERROR(ENOMEM);
 462         }
 463     }
 464
 465     return 0;
 466 }
 467
 468 AVCodec ff_mimic_decoder = {
 469     .name                  = "mimic",
 470     .long_name             = NULL_IF_CONFIG_SMALL("Mimic"),
 471     .type                  = AVMEDIA_TYPE_VIDEO,
 472     .id                    = AV_CODEC_ID_MIMIC,
 473     .priv_data_size        = sizeof(MimicContext),
 474     .init                  = mimic_decode_init,
 475     .close                 = mimic_decode_end,
 476     .decode                = mimic_decode_frame,
 477     .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
 478     .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context),
 479     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy),
 480 };