GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/aic.c Lines: 171 196 87.2 %
Date: 2021-04-18 10:33:33 Branches: 95 116 81.9 %

Line Branch Exec Source
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
72
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
72
    if (src[0] != 1) {
167
        av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
168
        return AVERROR_INVALIDDATA;
169
    }
170
72
    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
72
    frame_size = AV_RB32(src + 2);
175
72
    width      = AV_RB16(src + 6);
176
72
    height     = AV_RB16(src + 8);
177
72
    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

72
    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
72
    ctx->quant      = src[15];
189
72
    ctx->interlaced = ((src[16] >> 4) == 3);
190
191
72
    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
15888
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
15888
    const int num_coeffs = aic_num_band_coeffs[band];
209
15888
    const uint8_t *scan = aic_scan[band | force_chroma];
210
    int mb, idx;
211
    unsigned val;
212
213
15888
    if (get_bits_left(gb) < 5)
214
        return AVERROR_INVALIDDATA;
215
216
15888
    has_skips  = get_bits1(gb);
217
15888
    coeff_type = get_bits1(gb);
218
15888
    coeff_bits = get_bits(gb, 3);
219
220
15888
    if (has_skips) {
221
13996
        skip_type = get_bits1(gb);
222
13996
        skip_bits = get_bits(gb, 3);
223
224
437433
        for (mb = 0; mb < slice_width; mb++) {
225
423437
            idx = -1;
226
            do {
227

5032630
                GET_CODE(val, skip_type, skip_bits);
228
5032630
                if (val >= 0x10000)
229
                    return AVERROR_INVALIDDATA;
230
5032630
                idx += val + 1;
231
5032630
                if (idx >= num_coeffs)
232
252068
                    break;
233

4780562
                GET_CODE(val, coeff_type, coeff_bits);
234
4780562
                val++;
235
4780562
                if (val >= 0x10000)
236
                    return AVERROR_INVALIDDATA;
237
4780562
                dst[scan[idx]] = val;
238
4780562
            } while (idx < num_coeffs - 1);
239
423437
            dst += num_coeffs;
240
        }
241
    } else {
242
58743
        for (mb = 0; mb < slice_width; mb++) {
243
10576595
            for (idx = 0; idx < num_coeffs; idx++) {
244

10519744
                GET_CODE(val, coeff_type, coeff_bits);
245
10519744
                if (val >= 0x10000)
246
                    return AVERROR_INVALIDDATA;
247
10519744
                dst[scan[idx]] = val;
248
            }
249
56851
            dst += num_coeffs;
250
        }
251
    }
252
15888
    return 0;
253
}
254
255
353232
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
1766160
    for (i = 0; i < 4; i++) {
261
7064640
        for (j = 0; j < 4; j++)
262
5651712
            dst[scan[i * 8 + j]]     = (*base)[j];
263
7064640
        for (j = 0; j < 4; j++)
264
5651712
            dst[scan[i * 8 + j + 4]] = (*ext)[j];
265
1412928
        *base += 4;
266
1412928
        *ext  += 4;
267
    }
268
1766160
    for (; i < 8; i++) {
269
12716352
        for (j = 0; j < 8; j++)
270
11303424
            dst[scan[i * 8 + j]] = (*ext)[j];
271
1412928
        *ext  += 8;
272
    }
273
353232
}
274
275
367200
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
367200
    if (block_no < 2) {
282
1652400
        for (i = 0; i < 8; i++) {
283
7344000
            for (j = 0; j < 4; j++)
284
5875200
                dst[scan[i * 8 + j]]     = (*base)[j];
285
7344000
            for (j = 0; j < 4; j++)
286
5875200
                dst[scan[i * 8 + j + 4]] = (*ext)[j];
287
1468800
            *base += 4;
288
1468800
            *ext  += 4;
289
        }
290
    } else {
291
11934000
        for (i = 0; i < 64; i++)
292
11750400
            dst[scan[i]] = (*ext)[i];
293
183600
        *ext += 64;
294
    }
295
367200
}
296
297
720432
static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
298
{
299
    int i;
300
301
46828080
    for (i = 0; i < 64; i++) {
302
46107648
        int val  = (uint16_t)block[i];
303
46107648
        int sign = val & 1;
304
305
46107648
        block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
306
46107648
                   + sign;
307
    }
308
720432
}
309
310
3972
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
3972
    int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
316

3972
    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
3972
    int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
321
3972
    int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
322
3972
    int16_t *ext_y  = ctx->data_ptr[COEFF_LUMA_EXT];
323
3972
    int16_t *ext_c  = ctx->data_ptr[COEFF_CHROMA_EXT];
324
3972
    const int ystride = ctx->frame->linesize[0];
325
326
3972
    if (last_row) {
327
102
        y_pos = (ctx->avctx->height - 16);
328
102
        c_pos = ((ctx->avctx->height+1)/2 - 8);
329
    } else {
330
3870
        y_pos = mb_y * 16;
331
3870
        c_pos = mb_y * 8;
332
    }
333
334
3972
    Y = ctx->frame->data[0] + mb_x * 16 + y_pos * ystride;
335
11916
    for (i = 0; i < 2; i++)
336
7944
        C[i] = ctx->frame->data[i + 1] + mb_x * 8
337
7944
               + c_pos * ctx->frame->linesize[i + 1];
338
3972
    init_get_bits(&gb, src, src_size * 8);
339
340
3972
    memset(ctx->slice_data, 0,
341
           sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
342
19860
    for (i = 0; i < NUM_BANDS; i++)
343
15888
        if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
344
                                     i, slice_width,
345
15888
                                     !ctx->interlaced)) < 0)
346
            return ret;
347
348
124044
    for (mb = 0; mb < slice_width; mb++) {
349
600360
        for (blk = 0; blk < 4; blk++) {
350
480288
            if (!ctx->interlaced)
351
113088
                recombine_block(ctx->block, ctx->scantable.permutated,
352
                                &base_y, &ext_y);
353
            else
354
367200
                recombine_block_il(ctx->block, ctx->scantable.permutated,
355
                                   &base_y, &ext_y, blk);
356
480288
            unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
357
480288
            ctx->idsp.idct(ctx->block);
358
359
480288
            if (!ctx->interlaced) {
360
113088
                dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
361
113088
                ctx->idsp.put_signed_pixels_clamped(ctx->block, dst, ystride);
362
            } else {
363
367200
                dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
364
367200
                ctx->idsp.put_signed_pixels_clamped(ctx->block, dst,
365
367200
                                                    ystride * 2);
366
            }
367
        }
368
120072
        Y += 16;
369
370
360216
        for (blk = 0; blk < 2; blk++) {
371
240144
            recombine_block(ctx->block, ctx->scantable.permutated,
372
                            &base_c, &ext_c);
373
240144
            unquant_block(ctx->block, ctx->quant, ctx->quant_matrix);
374
240144
            ctx->idsp.idct(ctx->block);
375
240144
            ctx->idsp.put_signed_pixels_clamped(ctx->block, C[blk],
376
240144
                                                ctx->frame->linesize[blk + 1]);
377
240144
            C[blk] += 8;
378
        }
379
    }
380
381
3972
    return 0;
382
}
383
384
72
static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
385
                            AVPacket *avpkt)
386
{
387
72
    AICContext *ctx    = avctx->priv_data;
388
72
    const uint8_t *buf = avpkt->data;
389
72
    int buf_size       = avpkt->size;
390
    GetByteContext gb;
391
    uint32_t off;
392
    int x, y, ret;
393
    int slice_size;
394
72
    ThreadFrame frame = { .f = data };
395
396
72
    ctx->frame            = data;
397
72
    ctx->frame->pict_type = AV_PICTURE_TYPE_I;
398
72
    ctx->frame->key_frame = 1;
399
400
72
    off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
401
402
72
    if (buf_size < off) {
403
        av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
404
        return AVERROR_INVALIDDATA;
405
    }
406
407
72
    ret = aic_decode_header(ctx, buf, buf_size);
408
72
    if (ret < 0) {
409
        av_log(avctx, AV_LOG_ERROR, "Invalid header\n");
410
        return ret;
411
    }
412
413
72
    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
414
        return ret;
415
416
72
    bytestream2_init(&gb, buf + AIC_HDR_SIZE,
417
72
                     ctx->num_x_slices * ctx->mb_height * 2);
418
419
2004
    for (y = 0; y < ctx->mb_height; y++) {
420
5904
        for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
421
3972
            slice_size = bytestream2_get_le16(&gb) * 4;
422

3972
            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
3972
            ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
429
3972
            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
3972
            off += slice_size;
436
        }
437
    }
438
439
72
    *got_frame = 1;
440
441
72
    return avpkt->size;
442
}
443
444
4
static av_cold int aic_decode_init(AVCodecContext *avctx)
445
{
446
4
    AICContext *ctx = avctx->priv_data;
447
    int i;
448
    uint8_t scan[64];
449
450
4
    ctx->avctx = avctx;
451
452
4
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
453
454
4
    ff_idctdsp_init(&ctx->idsp, avctx);
455
456
260
    for (i = 0; i < 64; i++)
457
256
        scan[i] = i;
458
4
    ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
459
260
    for (i = 0; i < 64; i++)
460
256
        ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
461
462
4
    ctx->mb_width  = FFALIGN(avctx->width,  16) >> 4;
463
4
    ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
464
465
4
    ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
466
4
    ctx->slice_width  = 16;
467
8
    for (i = 1; i < ctx->mb_width; i++) {
468

8
        if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
469
4
            ctx->slice_width  = ctx->mb_width / i;
470
4
            ctx->num_x_slices = i;
471
4
            break;
472
        }
473
    }
474
475
4
    ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS
476
                                * sizeof(*ctx->slice_data));
477
4
    if (!ctx->slice_data) {
478
        av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
479
480
        return AVERROR(ENOMEM);
481
    }
482
483
20
    for (i = 0; i < NUM_BANDS; i++)
484
16
        ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
485
16
                                             * aic_band_off[i];
486
487
4
    return 0;
488
}
489
490
4
static av_cold int aic_decode_close(AVCodecContext *avctx)
491
{
492
4
    AICContext *ctx = avctx->priv_data;
493
494
4
    av_freep(&ctx->slice_data);
495
496
4
    return 0;
497
}
498
499
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
};