git.sesse.net Git - ffmpeg/blob - libavcodec/aic.c

   1 /*
   2  * Apple Intermediate Codec decoder
   3  *
   4  * Copyright (c) 2013 Konstantin Shishkov
   5  *
   6  * This file is part of Libav.
   7  *
   8  * Libav 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  * Libav 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 Libav; 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, val;
 205
 206     has_skips  = get_bits1(gb);
 207     coeff_type = get_bits1(gb);
 208     coeff_bits = get_bits(gb, 3);
 209
 210     if (has_skips) {
 211         skip_type = get_bits1(gb);
 212         skip_bits = get_bits(gb, 3);
 213
 214         for (mb = 0; mb < slice_width; mb++) {
 215             idx = -1;
 216             do {
 217                 GET_CODE(val, skip_type, skip_bits);
 218                 if (val < 0)
 219                     return AVERROR_INVALIDDATA;
 220                 idx += val + 1;
 221                 if (idx >= num_coeffs)
 222                     break;
 223                 GET_CODE(val, coeff_type, coeff_bits);
 224                 val++;
 225                 if (val >= 0x10000 || val < 0)
 226                     return AVERROR_INVALIDDATA;
 227                 dst[scan[idx]] = val;
 228             } while (idx < num_coeffs - 1);
 229             dst += num_coeffs;
 230         }
 231     } else {
 232         for (mb = 0; mb < slice_width; mb++) {
 233             for (idx = 0; idx < num_coeffs; idx++) {
 234                 GET_CODE(val, coeff_type, coeff_bits);
 235                 if (val >= 0x10000 || val < 0)
 236                     return AVERROR_INVALIDDATA;
 237                 dst[scan[idx]] = val;
 238             }
 239             dst += num_coeffs;
 240         }
 241     }
 242     return 0;
 243 }
 244
 245 static void recombine_block(int16_t *dst, const uint8_t *scan,
 246                             int16_t **base, int16_t **ext)
 247 {
 248     int i, j;
 249
 250     for (i = 0; i < 4; i++) {
 251         for (j = 0; j < 4; j++)
 252             dst[scan[i * 8 + j]]     = (*base)[j];
 253         for (j = 0; j < 4; j++)
 254             dst[scan[i * 8 + j + 4]] = (*ext)[j];
 255         *base += 4;
 256         *ext  += 4;
 257     }
 258     for (; i < 8; i++) {
 259         for (j = 0; j < 8; j++)
 260             dst[scan[i * 8 + j]] = (*ext)[j];
 261         *ext  += 8;
 262     }
 263 }
 264
 265 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
 266                                int16_t **base, int16_t **ext,
 267                                int block_no)
 268 {
 269     int i, j;
 270
 271     if (block_no < 2) {
 272         for (i = 0; i < 8; i++) {
 273             for (j = 0; j < 4; j++)
 274                 dst[scan[i * 8 + j]]     = (*base)[j];
 275             for (j = 0; j < 4; j++)
 276                 dst[scan[i * 8 + j + 4]] = (*ext)[j];
 277             *base += 4;
 278             *ext  += 4;
 279         }
 280     } else {
 281         for (i = 0; i < 64; i++)
 282             dst[scan[i]] = (*ext)[i];
 283         *ext += 64;
 284     }
 285 }
 286
 287 static void unquant_block(int16_t *block, int q)
 288 {
 289     int i;
 290
 291     for (i = 0; i < 64; i++) {
 292         int val  = (uint16_t)block[i];
 293         int sign = val & 1;
 294
 295         block[i] = (((val >> 1) ^ -sign) * q * aic_quant_matrix[i] >> 4)
 296                    + sign;
 297     }
 298 }
 299
 300 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
 301                             const uint8_t *src, int src_size)
 302 {
 303     GetBitContext gb;
 304     int ret, i, mb, blk;
 305     int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
 306     uint8_t *Y, *C[2];
 307     uint8_t *dst;
 308     int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
 309     int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
 310     int16_t *ext_y  = ctx->data_ptr[COEFF_LUMA_EXT];
 311     int16_t *ext_c  = ctx->data_ptr[COEFF_CHROMA_EXT];
 312     const int ystride = ctx->frame->linesize[0];
 313
 314     Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
 315     for (i = 0; i < 2; i++)
 316         C[i] = ctx->frame->data[i + 1] + mb_x * 8
 317                + mb_y * 8 * ctx->frame->linesize[i + 1];
 318     init_get_bits(&gb, src, src_size * 8);
 319
 320     memset(ctx->slice_data, 0,
 321            sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
 322     for (i = 0; i < NUM_BANDS; i++)
 323         if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
 324                                      i, slice_width,
 325                                      !ctx->interlaced)) < 0)
 326             return ret;
 327
 328     for (mb = 0; mb < slice_width; mb++) {
 329         for (blk = 0; blk < 4; blk++) {
 330             if (!ctx->interlaced)
 331                 recombine_block(ctx->block, ctx->scantable.permutated,
 332                                 &base_y, &ext_y);
 333             else
 334                 recombine_block_il(ctx->block, ctx->scantable.permutated,
 335                                    &base_y, &ext_y, blk);
 336             unquant_block(ctx->block, ctx->quant);
 337             ctx->dsp.idct(ctx->block);
 338
 339             if (!ctx->interlaced) {
 340                 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
 341                 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
 342                                                    ystride);
 343             } else {
 344                 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
 345                 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
 346                                                    ystride * 2);
 347             }
 348         }
 349         Y += 16;
 350
 351         for (blk = 0; blk < 2; blk++) {
 352             recombine_block(ctx->block, ctx->scantable.permutated,
 353                             &base_c, &ext_c);
 354             unquant_block(ctx->block, ctx->quant);
 355             ctx->dsp.idct(ctx->block);
 356             ctx->dsp.put_signed_pixels_clamped(ctx->block, C[blk],
 357                                                ctx->frame->linesize[blk + 1]);
 358             C[blk] += 8;
 359         }
 360     }
 361
 362     return 0;
 363 }
 364
 365 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 366                             AVPacket *avpkt)
 367 {
 368     AICContext *ctx    = avctx->priv_data;
 369     const uint8_t *buf = avpkt->data;
 370     int buf_size       = avpkt->size;
 371     GetByteContext gb;
 372     uint32_t off;
 373     int x, y, ret;
 374     int slice_size;
 375
 376     ctx->frame            = data;
 377     ctx->frame->pict_type = AV_PICTURE_TYPE_I;
 378     ctx->frame->key_frame = 1;
 379
 380     off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
 381
 382     if (buf_size < off) {
 383         av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
 384         return AVERROR_INVALIDDATA;
 385     }
 386
 387     if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
 388         return ret;
 389
 390     if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
 391         return ret;
 392
 393     bytestream2_init(&gb, buf + AIC_HDR_SIZE,
 394                      ctx->num_x_slices * ctx->mb_height * 2);
 395
 396     for (y = 0; y < ctx->mb_height; y++) {
 397         for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
 398             slice_size = bytestream2_get_le16(&gb) * 4;
 399             if (slice_size + off > buf_size || !slice_size) {
 400                 av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
 401                 return AVERROR_INVALIDDATA;
 402             }
 403
 404             if ((ret = aic_decode_slice(ctx, x, y,
 405                                         buf + off, slice_size)) < 0)
 406                 return ret;
 407
 408             off += slice_size;
 409         }
 410     }
 411
 412     *got_frame = 1;
 413
 414     return avpkt->size;
 415 }
 416
 417 static av_cold int aic_decode_init(AVCodecContext *avctx)
 418 {
 419     AICContext *ctx = avctx->priv_data;
 420     int i;
 421     uint8_t scan[64];
 422
 423     ctx->avctx = avctx;
 424
 425     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 426
 427     ff_dsputil_init(&ctx->dsp, avctx);
 428
 429     for (i = 0; i < 64; i++)
 430         scan[i] = i;
 431     ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, scan);
 432
 433     ctx->mb_width  = FFALIGN(avctx->width,  16) >> 4;
 434     ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
 435
 436     ctx->num_x_slices = 16;
 437     ctx->slice_width  = ctx->mb_width / 16;
 438     for (i = 1; i < 32; i++) {
 439         if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
 440             ctx->slice_width  = ctx->mb_width / i;
 441             ctx->num_x_slices = i;
 442             break;
 443         }
 444     }
 445
 446     ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
 447                                 * sizeof(*ctx->slice_data));
 448     if (!ctx->slice_data) {
 449         av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
 450
 451         return AVERROR(ENOMEM);
 452     }
 453
 454     for (i = 0; i < NUM_BANDS; i++)
 455         ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
 456                                              * aic_band_off[i];
 457
 458     return 0;
 459 }
 460
 461 static av_cold int aic_decode_close(AVCodecContext *avctx)
 462 {
 463     AICContext *ctx = avctx->priv_data;
 464
 465     av_freep(&ctx->slice_data);
 466
 467     return 0;
 468 }
 469
 470 AVCodec ff_aic_decoder = {
 471     .name           = "aic",
 472     .type           = AVMEDIA_TYPE_VIDEO,
 473     .id             = AV_CODEC_ID_AIC,
 474     .priv_data_size = sizeof(AICContext),
 475     .init           = aic_decode_init,
 476     .close          = aic_decode_close,
 477     .decode         = aic_decode_frame,
 478     .capabilities   = CODEC_CAP_DR1,
 479     .long_name      = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec")
 480 };