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