src/third_party/ffmpeg/libavcodec/aic.c

   1 /*
   2  * Apple Intermediate Codec decoder
   3  *
   4  * Copyright (c) 2013 Konstantin Shishkov
   5  *
   6  * This file is part of FFmpeg.
   7  *
   8  * FFmpeg is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * FFmpeg is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with FFmpeg; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include "avcodec.h"
  24 #include "bytestream.h"
  25 #include "dsputil.h"
  26 #include "internal.h"
  27 #include "get_bits.h"
  28 #include "golomb.h"
  29 #include "unary.h"
  30
  31 #define AIC_HDR_SIZE    24
  32 #define AIC_BAND_COEFFS (64 + 32 + 192 + 96)
  33
  34 enum AICBands {
  35     COEFF_LUMA = 0,
  36     COEFF_CHROMA,
  37     COEFF_LUMA_EXT,
  38     COEFF_CHROMA_EXT,
  39     NUM_BANDS
  40 };
  41
  42 static const int aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
  43
  44 static const int aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
  45
  46 static const uint8_t aic_quant_matrix[64] = {
  47      8, 16, 19, 22, 22, 26, 26, 27,
  48     16, 16, 22, 22, 26, 27, 27, 29,
  49     19, 22, 26, 26, 27, 29, 29, 35,
  50     22, 24, 27, 27, 29, 32, 34, 38,
  51     26, 27, 29, 29, 32, 35, 38, 46,
  52     27, 29, 34, 34, 35, 40, 46, 56,
  53     29, 34, 34, 37, 40, 48, 56, 69,
  54     34, 37, 38, 40, 48, 58, 69, 83,
  55 };
  56
  57 static const uint8_t aic_y_scan[64] = {
  58      0,  4,  1,  2,  5,  8, 12,  9,
  59      6,  3,  7, 10, 13, 14, 11, 15,
  60     47, 43, 46, 45, 42, 39, 35, 38,
  61     41, 44, 40, 37, 34, 33, 36, 32,
  62     16, 20, 17, 18, 21, 24, 28, 25,
  63     22, 19, 23, 26, 29, 30, 27, 31,
  64     63, 59, 62, 61, 58, 55, 51, 54,
  65     57, 60, 56, 53, 50, 49, 52, 48,
  66 };
  67
  68 static const uint8_t aic_y_ext_scan[192] = {
  69      64,  72,  65,  66,  73,  80,  88,  81,
  70      74,  67,  75,  82,  89,  90,  83,  91,
  71       0,   4,   1,   2,   5,   8,  12,   9,
  72       6,   3,   7,  10,  13,  14,  11,  15,
  73      16,  20,  17,  18,  21,  24,  28,  25,
  74      22,  19,  23,  26,  29,  30,  27,  31,
  75     155, 147, 154, 153, 146, 139, 131, 138,
  76     145, 152, 144, 137, 130, 129, 136, 128,
  77      47,  43,  46,  45,  42,  39,  35,  38,
  78      41,  44,  40,  37,  34,  33,  36,  32,
  79      63,  59,  62,  61,  58,  55,  51,  54,
  80      57,  60,  56,  53,  50,  49,  52,  48,
  81      96, 104,  97,  98, 105, 112, 120, 113,
  82     106,  99, 107, 114, 121, 122, 115, 123,
  83      68,  76,  69,  70,  77,  84,  92,  85,
  84      78,  71,  79,  86,  93,  94,  87,  95,
  85     100, 108, 101, 102, 109, 116, 124, 117,
  86     110, 103, 111, 118, 125, 126, 119, 127,
  87     187, 179, 186, 185, 178, 171, 163, 170,
  88     177, 184, 176, 169, 162, 161, 168, 160,
  89     159, 151, 158, 157, 150, 143, 135, 142,
  90     149, 156, 148, 141, 134, 133, 140, 132,
  91     191, 183, 190, 189, 182, 175, 167, 174,
  92     181, 188, 180, 173, 166, 165, 172, 164,
  93 };
  94
  95 static const uint8_t aic_c_scan[64] = {
  96      0,  4,  1,  2,  5,  8, 12,  9,
  97      6,  3,  7, 10, 13, 14, 11, 15,
  98     31, 27, 30, 29, 26, 23, 19, 22,
  99     25, 28, 24, 21, 18, 17, 20, 16,
 100     32, 36, 33, 34, 37, 40, 44, 41,
 101     38, 35, 39, 42, 45, 46, 43, 47,
 102     63, 59, 62, 61, 58, 55, 51, 54,
 103     57, 60, 56, 53, 50, 49, 52, 48,
 104 };
 105
 106 static const uint8_t aic_c_ext_scan[192] = {
 107      16,  24,  17,  18,  25,  32,  40,  33,
 108      26,  19,  27,  34,  41,  42,  35,  43,
 109       0,   4,   1,   2,   5,   8,  12,   9,
 110       6,   3,   7,  10,  13,  14,  11,  15,
 111      20,  28,  21,  22,  29,  36,  44,  37,
 112      30,  23,  31,  38,  45,  46,  39,  47,
 113      95,  87,  94,  93,  86,  79,  71,  78,
 114      85,  92,  84,  77,  70,  69,  76,  68,
 115      63,  59,  62,  61,  58,  55,  51,  54,
 116      57,  60,  56,  53,  50,  49,  52,  48,
 117      91,  83,  90,  89,  82,  75,  67,  74,
 118      81,  88,  80,  73,  66,  65,  72,  64,
 119     112, 120, 113, 114, 121, 128, 136, 129,
 120     122, 115, 123, 130, 137, 138, 131, 139,
 121      96, 100,  97,  98, 101, 104, 108, 105,
 122     102,  99, 103, 106, 109, 110, 107, 111,
 123     116, 124, 117, 118, 125, 132, 140, 133,
 124     126, 119, 127, 134, 141, 142, 135, 143,
 125     191, 183, 190, 189, 182, 175, 167, 174,
 126     181, 188, 180, 173, 166, 165, 172, 164,
 127     159, 155, 158, 157, 154, 151, 147, 150,
 128     153, 156, 152, 149, 146, 145, 148, 144,
 129     187, 179, 186, 185, 178, 171, 163, 170,
 130     177, 184, 176, 169, 162, 161, 168, 160,
 131 };
 132
 133 static const uint8_t *aic_scan[NUM_BANDS] = {
 134     aic_y_scan, aic_c_scan, aic_y_ext_scan, aic_c_ext_scan
 135 };
 136
 137 typedef struct AICContext {
 138     AVCodecContext *avctx;
 139     AVFrame        *frame;
 140     DSPContext     dsp;
 141     ScanTable      scantable;
 142
 143     int            num_x_slices;
 144     int            slice_width;
 145     int            mb_width, mb_height;
 146     int            quant;
 147     int            interlaced;
 148
 149     int16_t        *slice_data;
 150     int16_t        *data_ptr[NUM_BANDS];
 151
 152     DECLARE_ALIGNED(16, int16_t, block)[64];
 153 } AICContext;
 154
 155 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
 156 {
 157     uint32_t frame_size;
 158     int width, height;
 159
 160     if (src[0] != 1) {
 161         av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
 162         return AVERROR_INVALIDDATA;
 163     }
 164     if (src[1] != AIC_HDR_SIZE - 2) {
 165         av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
 166         return AVERROR_INVALIDDATA;
 167     }
 168     frame_size = AV_RB32(src + 2);
 169     width      = AV_RB16(src + 6);
 170     height     = AV_RB16(src + 8);
 171     if (frame_size > size) {
 172         av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %d got %d\n",
 173                frame_size, size);
 174         return AVERROR_INVALIDDATA;
 175     }
 176     if (width != ctx->avctx->width || height != ctx->avctx->height) {
 177         av_log(ctx->avctx, AV_LOG_ERROR,
 178                "Picture dimension changed: old: %d x %d, new: %d x %d\n",
 179                ctx->avctx->width, ctx->avctx->height, width, height);
 180         return AVERROR_INVALIDDATA;
 181     }
 182     ctx->quant      = src[15];
 183     ctx->interlaced = ((src[16] >> 4) == 3);
 184
 185     return 0;
 186 }
 187
 188 #define GET_CODE(val, type, add_bits)                         \
 189     do {                                                      \
 190         if (type)                                             \
 191             val = get_ue_golomb(gb);                          \
 192         else                                                  \
 193             val = get_unary(gb, 1, 31);                       \
 194         if (add_bits)                                         \
 195             val = (val << add_bits) + get_bits(gb, add_bits); \
 196     } while (0)
 197
 198 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
 199                              int band, int slice_width, int force_chroma)
 200 {
 201     int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
 202     const int num_coeffs = aic_num_band_coeffs[band];
 203     const uint8_t *scan = aic_scan[band | force_chroma];
 204     int mb, idx;
 205     unsigned val;
 206
 207     has_skips  = get_bits1(gb);
 208     coeff_type = get_bits1(gb);
 209     coeff_bits = get_bits(gb, 3);
 210
 211     if (has_skips) {
 212         skip_type = get_bits1(gb);
 213         skip_bits = get_bits(gb, 3);
 214
 215         for (mb = 0; mb < slice_width; mb++) {
 216             idx = -1;
 217             do {
 218                 GET_CODE(val, skip_type, skip_bits);
 219                 if (val >= 0x10000)
 220                     return AVERROR_INVALIDDATA;
 221                 idx += val + 1;
 222                 if (idx >= num_coeffs)
 223                     break;
 224                 GET_CODE(val, coeff_type, coeff_bits);
 225                 val++;
 226                 if (val >= 0x10000)
 227                     return AVERROR_INVALIDDATA;
 228                 dst[scan[idx]] = val;
 229             } while (idx < num_coeffs - 1);
 230             dst += num_coeffs;
 231         }
 232     } else {
 233         for (mb = 0; mb < slice_width; mb++) {
 234             for (idx = 0; idx < num_coeffs; idx++) {
 235                 GET_CODE(val, coeff_type, coeff_bits);
 236                 if (val >= 0x10000)
 237                     return AVERROR_INVALIDDATA;
 238                 dst[scan[idx]] = val;
 239             }
 240             dst += num_coeffs;
 241         }
 242     }
 243     return 0;
 244 }
 245
 246 static void recombine_block(int16_t *dst, const uint8_t *scan,
 247                             int16_t **base, int16_t **ext)
 248 {
 249     int i, j;
 250
 251     for (i = 0; i < 4; i++) {
 252         for (j = 0; j < 4; j++)
 253             dst[scan[i * 8 + j]]     = (*base)[j];
 254         for (j = 0; j < 4; j++)
 255             dst[scan[i * 8 + j + 4]] = (*ext)[j];
 256         *base += 4;
 257         *ext  += 4;
 258     }
 259     for (; i < 8; i++) {
 260         for (j = 0; j < 8; j++)
 261             dst[scan[i * 8 + j]] = (*ext)[j];
 262         *ext  += 8;
 263     }
 264 }
 265
 266 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
 267                                int16_t **base, int16_t **ext,
 268                                int block_no)
 269 {
 270     int i, j;
 271
 272     if (block_no < 2) {
 273         for (i = 0; i < 8; i++) {
 274             for (j = 0; j < 4; j++)
 275                 dst[scan[i * 8 + j]]     = (*base)[j];
 276             for (j = 0; j < 4; j++)
 277                 dst[scan[i * 8 + j + 4]] = (*ext)[j];
 278             *base += 4;
 279             *ext  += 4;
 280         }
 281     } else {
 282         for (i = 0; i < 64; i++)
 283             dst[scan[i]] = (*ext)[i];
 284         *ext += 64;
 285     }
 286 }
 287
 288 static void unquant_block(int16_t *block, int q)
 289 {
 290     int i;
 291
 292     for (i = 0; i < 64; i++) {
 293         int val  = (uint16_t)block[i];
 294         int sign = val & 1;
 295
 296         block[i] = (((val >> 1) ^ -sign) * q * aic_quant_matrix[i] >> 4)
 297                    + sign;
 298     }
 299 }
 300
 301 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
 302                             const uint8_t *src, int src_size)
 303 {
 304     GetBitContext gb;
 305     int ret, i, mb, blk;
 306     int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
 307     uint8_t *Y, *C[2];
 308     uint8_t *dst;
 309     int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
 310     int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
 311     int16_t *ext_y  = ctx->data_ptr[COEFF_LUMA_EXT];
 312     int16_t *ext_c  = ctx->data_ptr[COEFF_CHROMA_EXT];
 313     const int ystride = ctx->frame->linesize[0];
 314
 315     Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
 316     for (i = 0; i < 2; i++)
 317         C[i] = ctx->frame->data[i + 1] + mb_x * 8
 318                + mb_y * 8 * ctx->frame->linesize[i + 1];
 319     init_get_bits(&gb, src, src_size * 8);
 320
 321     memset(ctx->slice_data, 0,
 322            sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
 323     for (i = 0; i < NUM_BANDS; i++)
 324         if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
 325                                      i, slice_width,
 326                                      !ctx->interlaced)) < 0)
 327             return ret;
 328
 329     for (mb = 0; mb < slice_width; mb++) {
 330         for (blk = 0; blk < 4; blk++) {
 331             if (!ctx->interlaced)
 332                 recombine_block(ctx->block, ctx->scantable.permutated,
 333                                 &base_y, &ext_y);
 334             else
 335                 recombine_block_il(ctx->block, ctx->scantable.permutated,
 336                                    &base_y, &ext_y, blk);
 337             unquant_block(ctx->block, ctx->quant);
 338             ctx->dsp.idct(ctx->block);
 339
 340             if (!ctx->interlaced) {
 341                 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
 342                 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
 343                                                    ystride);
 344             } else {
 345                 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
 346                 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
 347                                                    ystride * 2);
 348             }
 349         }
 350         Y += 16;
 351
 352         for (blk = 0; blk < 2; blk++) {
 353             recombine_block(ctx->block, ctx->scantable.permutated,
 354                             &base_c, &ext_c);
 355             unquant_block(ctx->block, ctx->quant);
 356             ctx->dsp.idct(ctx->block);
 357             ctx->dsp.put_signed_pixels_clamped(ctx->block, C[blk],
 358                                                ctx->frame->linesize[blk + 1]);
 359             C[blk] += 8;
 360         }
 361     }
 362
 363     return 0;
 364 }
 365
 366 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 367                             AVPacket *avpkt)
 368 {
 369     AICContext *ctx    = avctx->priv_data;
 370     const uint8_t *buf = avpkt->data;
 371     int buf_size       = avpkt->size;
 372     GetByteContext gb;
 373     uint32_t off;
 374     int x, y, ret;
 375     int slice_size;
 376
 377     ctx->frame            = data;
 378     ctx->frame->pict_type = AV_PICTURE_TYPE_I;
 379     ctx->frame->key_frame = 1;
 380
 381     off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
 382
 383     if (buf_size < off) {
 384         av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
 385         return AVERROR_INVALIDDATA;
 386     }
 387
 388     if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
 389         return ret;
 390
 391     if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
 392         return ret;
 393
 394     bytestream2_init(&gb, buf + AIC_HDR_SIZE,
 395                      ctx->num_x_slices * ctx->mb_height * 2);
 396
 397     for (y = 0; y < ctx->mb_height; y++) {
 398         for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
 399             slice_size = bytestream2_get_le16(&gb) * 4;
 400             if (slice_size + off > buf_size || !slice_size) {
 401                 av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
 402                 return AVERROR_INVALIDDATA;
 403             }
 404
 405             if ((ret = aic_decode_slice(ctx, x, y,
 406                                         buf + off, slice_size)) < 0)
 407                 return ret;
 408
 409             off += slice_size;
 410         }
 411     }
 412
 413     *got_frame = 1;
 414
 415     return avpkt->size;
 416 }
 417
 418 static av_cold int aic_decode_init(AVCodecContext *avctx)
 419 {
 420     AICContext *ctx = avctx->priv_data;
 421     int i;
 422     uint8_t scan[64];
 423
 424     ctx->avctx = avctx;
 425
 426     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 427
 428     ff_dsputil_init(&ctx->dsp, avctx);
 429
 430     for (i = 0; i < 64; i++)
 431         scan[i] = i;
 432     ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, scan);
 433
 434     ctx->mb_width  = FFALIGN(avctx->width,  16) >> 4;
 435     ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
 436
 437     ctx->num_x_slices = 16;
 438     ctx->slice_width  = ctx->mb_width / 16;
 439     for (i = 1; i < 32; i++) {
 440         if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
 441             ctx->slice_width  = ctx->mb_width / i;
 442             ctx->num_x_slices = i;
 443             break;
 444         }
 445     }
 446
 447     ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
 448                                 * sizeof(*ctx->slice_data));
 449     if (!ctx->slice_data) {
 450         av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
 451
 452         return AVERROR(ENOMEM);
 453     }
 454
 455     for (i = 0; i < NUM_BANDS; i++)
 456         ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
 457                                              * aic_band_off[i];
 458
 459     return 0;
 460 }
 461
 462 static av_cold int aic_decode_close(AVCodecContext *avctx)
 463 {
 464     AICContext *ctx = avctx->priv_data;
 465
 466     av_freep(&ctx->slice_data);
 467
 468     return 0;
 469 }
 470
 471 AVCodec ff_aic_decoder = {
 472     .name           = "aic",
 473     .long_name      = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
 474     .type           = AVMEDIA_TYPE_VIDEO,
 475     .id             = AV_CODEC_ID_AIC,
 476     .priv_data_size = sizeof(AICContext),
 477     .init           = aic_decode_init,
 478     .close          = aic_decode_close,
 479     .decode         = aic_decode_frame,
 480     .capabilities   = CODEC_CAP_DR1,
 481 };