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