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