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