GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/aic.c Lines: 171 196 87.2 %
Date: 2019-11-18 18:00:01 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 "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 uint8_t aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
46
47
static const uint16_t 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
72
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
72
    if (src[0] != 1) {
165
        av_log(ctx->avctx, AV_LOG_ERROR, "Invalid version %d\n", src[0]);
166
        return AVERROR_INVALIDDATA;
167
    }
168
72
    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
72
    frame_size = AV_RB32(src + 2);
173
72
    width      = AV_RB16(src + 6);
174
72
    height     = AV_RB16(src + 8);
175
72
    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

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

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

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

10519744
                GET_CODE(val, coeff_type, coeff_bits);
243
10519744
                if (val >= 0x10000)
244
                    return AVERROR_INVALIDDATA;
245
10519744
                dst[scan[idx]] = val;
246
            }
247
56851
            dst += num_coeffs;
248
        }
249
    }
250
15888
    return 0;
251
}
252
253
353232
static void recombine_block(int16_t *dst, const uint8_t *scan,
254
                            int16_t **base, int16_t **ext)
255
{
256
    int i, j;
257
258
1766160
    for (i = 0; i < 4; i++) {
259
7064640
        for (j = 0; j < 4; j++)
260
5651712
            dst[scan[i * 8 + j]]     = (*base)[j];
261
7064640
        for (j = 0; j < 4; j++)
262
5651712
            dst[scan[i * 8 + j + 4]] = (*ext)[j];
263
1412928
        *base += 4;
264
1412928
        *ext  += 4;
265
    }
266
1766160
    for (; i < 8; i++) {
267
12716352
        for (j = 0; j < 8; j++)
268
11303424
            dst[scan[i * 8 + j]] = (*ext)[j];
269
1412928
        *ext  += 8;
270
    }
271
353232
}
272
273
367200
static void recombine_block_il(int16_t *dst, const uint8_t *scan,
274
                               int16_t **base, int16_t **ext,
275
                               int block_no)
276
{
277
    int i, j;
278
279
367200
    if (block_no < 2) {
280
1652400
        for (i = 0; i < 8; i++) {
281
7344000
            for (j = 0; j < 4; j++)
282
5875200
                dst[scan[i * 8 + j]]     = (*base)[j];
283
7344000
            for (j = 0; j < 4; j++)
284
5875200
                dst[scan[i * 8 + j + 4]] = (*ext)[j];
285
1468800
            *base += 4;
286
1468800
            *ext  += 4;
287
        }
288
    } else {
289
11934000
        for (i = 0; i < 64; i++)
290
11750400
            dst[scan[i]] = (*ext)[i];
291
183600
        *ext += 64;
292
    }
293
367200
}
294
295
720432
static void unquant_block(int16_t *block, int q, uint8_t *quant_matrix)
296
{
297
    int i;
298
299
46828080
    for (i = 0; i < 64; i++) {
300
46107648
        int val  = (uint16_t)block[i];
301
46107648
        int sign = val & 1;
302
303
46107648
        block[i] = (((val >> 1) ^ -sign) * q * quant_matrix[i] >> 4)
304
46107648
                   + sign;
305
    }
306
720432
}
307
308
3972
static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
309
                            const uint8_t *src, int src_size)
310
{
311
    GetBitContext gb;
312
    int ret, i, mb, blk;
313
3972
    int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
314

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

3972
            if (slice_size + off > buf_size || !slice_size) {
421
                av_log(avctx, AV_LOG_ERROR,
422
                       "Incorrect slice size %d at %d.%d\n", slice_size, x, y);
423
                return AVERROR_INVALIDDATA;
424
            }
425
426
3972
            ret = aic_decode_slice(ctx, x, y, buf + off, slice_size);
427
3972
            if (ret < 0) {
428
                av_log(avctx, AV_LOG_ERROR,
429
                       "Error decoding slice at %d.%d\n", x, y);
430
                return ret;
431
            }
432
433
3972
            off += slice_size;
434
        }
435
    }
436
437
72
    *got_frame = 1;
438
439
72
    return avpkt->size;
440
}
441
442
4
static av_cold int aic_decode_init(AVCodecContext *avctx)
443
{
444
4
    AICContext *ctx = avctx->priv_data;
445
    int i;
446
    uint8_t scan[64];
447
448
4
    ctx->avctx = avctx;
449
450
4
    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
451
452
4
    ff_idctdsp_init(&ctx->idsp, avctx);
453
454
260
    for (i = 0; i < 64; i++)
455
256
        scan[i] = i;
456
4
    ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan);
457
260
    for (i = 0; i < 64; i++)
458
256
        ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i];
459
460
4
    ctx->mb_width  = FFALIGN(avctx->width,  16) >> 4;
461
4
    ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
462
463
4
    ctx->num_x_slices = (ctx->mb_width + 15) >> 4;
464
4
    ctx->slice_width  = 16;
465
8
    for (i = 1; i < ctx->mb_width; i++) {
466

8
        if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) {
467
4
            ctx->slice_width  = ctx->mb_width / i;
468
4
            ctx->num_x_slices = i;
469
4
            break;
470
        }
471
    }
472
473
4
    ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS
474
                                * sizeof(*ctx->slice_data));
475
4
    if (!ctx->slice_data) {
476
        av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
477
478
        return AVERROR(ENOMEM);
479
    }
480
481
20
    for (i = 0; i < NUM_BANDS; i++)
482
16
        ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
483
16
                                             * aic_band_off[i];
484
485
4
    return 0;
486
}
487
488
4
static av_cold int aic_decode_close(AVCodecContext *avctx)
489
{
490
4
    AICContext *ctx = avctx->priv_data;
491
492
4
    av_freep(&ctx->slice_data);
493
494
4
    return 0;
495
}
496
497
AVCodec ff_aic_decoder = {
498
    .name           = "aic",
499
    .long_name      = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"),
500
    .type           = AVMEDIA_TYPE_VIDEO,
501
    .id             = AV_CODEC_ID_AIC,
502
    .priv_data_size = sizeof(AICContext),
503
    .init           = aic_decode_init,
504
    .close          = aic_decode_close,
505
    .decode         = aic_decode_frame,
506
    .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
507
    .init_thread_copy = ONLY_IF_THREADS_ENABLED(aic_decode_init),
508
    .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,
509
};