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