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 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 <inttypes.h>
  24
  25 #include "avcodec.h"
  26 #include "bytestream.h"
  27 #include "dsputil.h"
  28 #include "internal.h"
  29 #include "get_bits.h"
  30 #include "golomb.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     DSPContext     dsp;
 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     DECLARE_ALIGNED(16, uint8_t, quant_matrix)[64];
 156 } AICContext;
 157
 158 static int aic_decode_header(AICContext *ctx, const uint8_t *src, int size)
 159 {
 160     uint32_t frame_size;
 161     int width, height;
 162
 163     if (src[0] != 1) {
 164         av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
 165         return AVERROR_INVALIDDATA;
 166     }
 167     if (src[1] != AIC_HDR_SIZE - 2) {
 168         av_log(ctx->avctx, AV_LOG_ERROR, "Invalid header size %d\n", src[1]);
 169         return AVERROR_INVALIDDATA;
 170     }
 171     frame_size = AV_RB32(src + 2);
 172     width      = AV_RB16(src + 6);
 173     height     = AV_RB16(src + 8);
 174     if (frame_size > size) {
 175         av_log(ctx->avctx, AV_LOG_ERROR, "Frame size should be %"PRIu32" got %d\n",
 176                frame_size, size);
 177         return AVERROR_INVALIDDATA;
 178     }
 179     if (width != ctx->avctx->width || height != ctx->avctx->height) {
 180         av_log(ctx->avctx, AV_LOG_ERROR,
 181                "Picture dimension changed: old: %d x %d, new: %d x %d\n",
 182                ctx->avctx->width, ctx->avctx->height, width, height);
 183         return AVERROR_INVALIDDATA;
 184     }
 185     ctx->quant      = src[15];
 186     ctx->interlaced = ((src[16] >> 4) == 3);
 187
 188     return 0;
 189 }
 190
 191 #define GET_CODE(val, type, add_bits)                         \
 192     do {                                                      \
 193         if (type)                                             \
 194             val = get_ue_golomb(gb);                          \
 195         else                                                  \
 196             val = get_unary(gb, 1, 31);                       \
 197         if (add_bits)                                         \
 198             val = (val << add_bits) + get_bits(gb, add_bits); \
 199     } while (0)
 200
 201 static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
 202                              int band, int slice_width, int force_chroma)
 203 {
 204     int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
 205     const int num_coeffs = aic_num_band_coeffs[band];
 206     const uint8_t *scan = aic_scan[band | force_chroma];
 207     int mb, idx;
 208     unsigned val;
 209
 210     has_skips  = get_bits1(gb);
 211     coeff_type = get_bits1(gb);
 212     coeff_bits = get_bits(gb, 3);
 213
 214     if (has_skips) {
 215         skip_type = get_bits1(gb);
 216         skip_bits = get_bits(gb, 3);
 217
 218         for (mb = 0; mb < slice_width; mb++) {
 219             idx = -1;
 220             do {
 221                 GET_CODE(val, skip_type, skip_bits);
 222                 if (val >= 0x10000)
 223                     return AVERROR_INVALIDDATA;
 224                 idx += val + 1;
 225                 if (idx >= num_coeffs)
 226                     break;
 227                 GET_CODE(val, coeff_type, coeff_bits);
 228                 val++;
 229                 if (val >= 0x10000)
 230                     return AVERROR_INVALIDDATA;
 231                 dst[scan[idx]] = val;
 232             } while (idx < num_coeffs - 1);
 233             dst += num_coeffs;
 234         }
 235     } else {
 236         for (mb = 0; mb < slice_width; mb++) {
 237             for (idx = 0; idx < num_coeffs; idx++) {
 238                 GET_CODE(val, coeff_type, coeff_bits);
 239                 if (val >= 0x10000)
 240                     return AVERROR_INVALIDDATA;
 241                 dst[scan[idx]] = val;
 242             }
 243             dst += num_coeffs;
 244         }
 245     }
 246     return 0;
 247 }
 248
 249 static void recombine_block(int16_t *dst, const uint8_t *scan,
 250                             int16_t **base, int16_t **ext)
 251 {
 252     int i, j;
 253
 254     for (i = 0; i < 4; i++) {
 255         for (j = 0; j < 4; j++)
 256             dst[scan[i * 8 + j]]     = (*base)[j];
 257         for (j = 0; j < 4; j++)
 258             dst[scan[i * 8 + j + 4]] = (*ext)[j];
 259         *base += 4;
 260         *ext  += 4;
 261     }
 262     for (; i < 8; i++) {
 263         for (j = 0; j < 8; j++)
 264             dst[scan[i * 8 + j]] = (*ext)[j];
 265         *ext  += 8;
 266     }
 267 }
 268
 269 static void recombine_block_il(int16_t *dst, const uint8_t *scan,
 270                                int16_t **base, int16_t **ext,
 271                                int block_no)
 272 {
 273     int i, j;
 274
 275     if (block_no < 2) {
 276         for (i = 0; i < 8; i++) {
 277             for (j = 0; j < 4; j++)
 278                 dst[scan[i * 8 + j]]     = (*base)[j];
 279             for (j = 0; j < 4; j++)
 280                 dst[scan[i * 8 + j + 4]] = (*ext)[j];
 281             *base += 4;
 282             *ext  += 4;
 283         }
 284     } else {
 285         for (i = 0; i < 64; i++)
 286             dst[scan[i]] = (*ext)[i];
 287         *ext += 64;
 288     }
 289 }
 290
 291 static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
 292 {
 293     int i;
 294
 295     for (i = 0; i < 64; i++) {
 296         int val  = (uint16_t)block[i];
 297         int sign = val & 1;
 298
 299         block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
 300                    + sign;
 301     }
 302 }
 303
 304 static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
 305                             const uint8_t *src, int src_size)
 306 {
 307     GetBitContext gb;
 308     int ret, i, mb, blk;
 309     int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
 310     uint8_t *Y, *C[2];
 311     uint8_t *dst;
 312     int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
 313     int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
 314     int16_t *ext_y  = ctx->data_ptr[COEFF_LUMA_EXT];
 315     int16_t *ext_c  = ctx->data_ptr[COEFF_CHROMA_EXT];
 316     const int ystride = ctx->frame->linesize[0];
 317
 318     Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
 319     for (i = 0; i < 2; i++)
 320         C[i] = ctx->frame->data[i + 1] + mb_x * 8
 321                + mb_y * 8 * ctx->frame->linesize[i + 1];
 322     init_get_bits(&gb, src, src_size * 8);
 323
 324     memset(ctx->slice_data, 0,
 325            sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
 326     for (i = 0; i < NUM_BANDS; i++)
 327         if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
 328                                      i, slice_width,
 329                                      !ctx->interlaced)) < 0)
 330             return ret;
 331
 332     for (mb = 0; mb < slice_width; mb++) {
 333         for (blk = 0; blk < 4; blk++) {
 334             if (!ctx->interlaced)
 335                 recombine_block(ctx->block, ctx->scantable.permutated,
 336                                 &base_y, &ext_y);
 337             else
 338                 recombine_block_il(ctx->block, ctx->scantable.permutated,
 339                                    &base_y, &ext_y, blk);
 340             unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
 341             ctx->dsp.idct(ctx->block);
 342
 343             if (!ctx->interlaced) {
 344                 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
 345                 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
 346                                                    ystride);
 347             } else {
 348                 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
 349                 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
 350                                                    ystride * 2);
 351             }
 352         }
 353         Y += 16;
 354
 355         for (blk = 0; blk < 2; blk++) {
 356             recombine_block(ctx->block, ctx->scantable.permutated,
 357                             &base_c, &ext_c);
 358             unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
 359             ctx->dsp.idct(ctx->block);
 360             ctx->dsp.put_signed_pixels_clamped(ctx->block, C[blk],
 361                                                ctx->frame->linesize[blk + 1]);
 362             C[blk] += 8;
 363         }
 364     }
 365
 366     return 0;
 367 }
 368
 369 static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 370                             AVPacket *avpkt)
 371 {
 372     AICContext *ctx    = avctx->priv_data;
 373     const uint8_t *buf = avpkt->data;
 374     int buf_size       = avpkt->size;
 375     GetByteContext gb;
 376     uint32_t off;
 377     int x, y, ret;
 378     int slice_size;
 379
 380     ctx->frame            = data;
 381     ctx->frame->pict_type = AV_PICTURE_TYPE_I;
 382     ctx->frame->key_frame = 1;
 383
 384     off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
 385
 386     if (buf_size < off) {
 387         av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
 388         return AVERROR_INVALIDDATA;
 389     }
 390
 391     if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
 392         return ret;
 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, "Incorrect slice size\n");
 405                 return AVERROR_INVALIDDATA;
 406             }
 407
 408             if ((ret = aic_decode_slice(ctx, x, y,
 409                                         buf + off, slice_size)) < 0)
 410                 return ret;
 411
 412             off += slice_size;
 413         }
 414     }
 415
 416     *got_frame = 1;
 417
 418     return avpkt->size;
 419 }
 420
 421 static av_cold int aic_decode_init(AVCodecContext *avctx)
 422 {
 423     AICContext *ctx = avctx->priv_data;
 424     int i;
 425     uint8_t scan[64];
 426
 427     ctx->avctx = avctx;
 428
 429     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 430
 431     ff_dsputil_init(&ctx->dsp, avctx);
 432
 433     for (i = 0; i < 64; i++)
 434         scan[i] = i;
 435     ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, scan);
 436     for (i = 0; i < 64; i++)
 437         ctx->quant_matrix[ctx->dsp.idct_permutation[i]] = aic_quant_matrix[i];
 438
 439     ctx->mb_width  = FFALIGN(avctx->width,  16) >> 4;
 440     ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
 441
 442     ctx->num_x_slices = 16;
 443     ctx->slice_width  = ctx->mb_width / 16;
 444     for (i = 1; i < 32; i++) {
 445         if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
 446             ctx->slice_width  = ctx->mb_width / i;
 447             ctx->num_x_slices = i;
 448             break;
 449         }
 450     }
 451
 452     ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
 453                                 * sizeof(*ctx->slice_data));
 454     if (!ctx->slice_data) {
 455         av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
 456
 457         return AVERROR(ENOMEM);
 458     }
 459
 460     for (i = 0; i < NUM_BANDS; i++)
 461         ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
 462                                              * aic_band_off[i];
 463
 464     return 0;
 465 }
 466
 467 static av_cold int aic_decode_close(AVCodecContext *avctx)
 468 {
 469     AICContext *ctx = avctx->priv_data;
 470
 471     av_freep(&ctx->slice_data);
 472
 473     return 0;
 474 }
 475
 476 AVCodec ff_aic_decoder = {
 477     .name           = "aic",
 478     .long_name      = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
 479     .type           = AVMEDIA_TYPE_VIDEO,
 480     .id             = AV_CODEC_ID_AIC,
 481     .priv_data_size = sizeof(AICContext),
 482     .init           = aic_decode_init,
 483     .close          = aic_decode_close,
 484     .decode         = aic_decode_frame,
 485     .capabilities   = CODEC_CAP_DR1,
 486 };