src/third_party/ffmpeg/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 "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     IDCTDSPContext idsp;
 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->idsp.idct(ctx->block);
 342
 343             if (!ctx->interlaced) {
 344                 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
 345                 ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
 346             } else {
 347                 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
 348                 ctx->idsp.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, ctx->quant_matrix);
 358             ctx->idsp.idct(ctx->block);
 359             ctx->idsp.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_idctdsp_init(&ctx->idsp, avctx);
 431
 432     for (i = 0; i < 64; i++)
 433         scan[i] = i;
 434     ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
 435     for (i = 0; i < 64; i++)
 436         ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
 437
 438     ctx->mb_width  = FFALIGN(avctx->width,  16) >> 4;
 439     ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
 440
 441     ctx->num_x_slices = 16;
 442     ctx->slice_width  = ctx->mb_width / 16;
 443     for (i = 1; i < 32; i++) {
 444         if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
 445             ctx->slice_width  = ctx->mb_width / i;
 446             ctx->num_x_slices = i;
 447             break;
 448         }
 449     }
 450
 451     ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
 452                                 * sizeof(*ctx->slice_data));
 453     if (!ctx->slice_data) {
 454         av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
 455
 456         return AVERROR(ENOMEM);
 457     }
 458
 459     for (i = 0; i < NUM_BANDS; i++)
 460         ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
 461                                              * aic_band_off[i];
 462
 463     return 0;
 464 }
 465
 466 static av_cold int aic_decode_close(AVCodecContext *avctx)
 467 {
 468     AICContext *ctx = avctx->priv_data;
 469
 470     av_freep(&ctx->slice_data);
 471
 472     return 0;
 473 }
 474
 475 AVCodec ff_aic_decoder = {
 476     .name           = "aic",
 477     .long_name      = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
 478     .type           = AVMEDIA_TYPE_VIDEO,
 479     .id             = AV_CODEC_ID_AIC,
 480     .priv_data_size = sizeof(AICContext),
 481     .init           = aic_decode_init,
 482     .close          = aic_decode_close,
 483     .decode         = aic_decode_frame,
 484     .capabilities   = CODEC_CAP_DR1,
 485 };