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