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