Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | RSS feed

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