aic: use chroma scan tables while decoding luma component in progressive mode
[libav.git] / libavcodec / aic.c
CommitLineData
1232a164
KS
1/*
2 * Apple Intermediate Codec decoder
3 *
4 * Copyright (c) 2013 Konstantin Shishkov
5 *
6 * This file is part of Libav.
7 *
8 * Libav 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 * Libav 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 Libav; 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
34enum AICBands {
35 COEFF_LUMA = 0,
36 COEFF_CHROMA,
37 COEFF_LUMA_EXT,
38 COEFF_CHROMA_EXT,
39 NUM_BANDS
40};
41
42static const int aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 };
43
44static const int aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 };
45
46static 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
57static 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
68static 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
95static 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
106static 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
133static const uint8_t *aic_scan[NUM_BANDS] = {
134 aic_y_scan, aic_c_scan, aic_y_ext_scan, aic_c_ext_scan
135};
136
137typedef 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
155static 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
198static int aic_decode_coeffs(GetBitContext *gb, int16_t *dst,
41006698 199 int band, int slice_width, int force_chroma)
1232a164
KS
200{
201 int has_skips, coeff_type, coeff_bits, skip_type, skip_bits;
202 const int num_coeffs = aic_num_band_coeffs[band];
41006698 203 const uint8_t *scan = aic_scan[band | force_chroma];
1232a164
KS
204 int mb, idx, val;
205
206 has_skips = get_bits1(gb);
207 coeff_type = get_bits1(gb);
208 coeff_bits = get_bits(gb, 3);
209
210 if (has_skips) {
211 skip_type = get_bits1(gb);
212 skip_bits = get_bits(gb, 3);
213
214 for (mb = 0; mb < slice_width; mb++) {
215 idx = -1;
216 do {
217 GET_CODE(val, skip_type, skip_bits);
218 idx += val + 1;
219 if (idx >= num_coeffs)
220 break;
221 GET_CODE(val, coeff_type, coeff_bits);
222 val++;
223 if (val >= 0x10000)
224 return AVERROR_INVALIDDATA;
225 dst[scan[idx]] = val;
226 } while (idx < num_coeffs - 1);
227 dst += num_coeffs;
228 }
229 } else {
230 for (mb = 0; mb < slice_width; mb++) {
231 for (idx = 0; idx < num_coeffs; idx++) {
232 GET_CODE(val, coeff_type, coeff_bits);
233 if (val >= 0x10000)
234 return AVERROR_INVALIDDATA;
235 dst[scan[idx]] = val;
236 }
237 dst += num_coeffs;
238 }
239 }
240 return 0;
241}
242
243static void recombine_block(int16_t *dst, const uint8_t *scan,
244 int16_t **base, int16_t **ext)
245{
246 int i, j;
247
248 for (i = 0; i < 4; i++) {
249 for (j = 0; j < 4; j++)
250 dst[scan[i * 8 + j]] = (*base)[j];
251 for (j = 0; j < 4; j++)
252 dst[scan[i * 8 + j + 4]] = (*ext)[j];
253 *base += 4;
254 *ext += 4;
255 }
256 for (; i < 8; i++) {
257 for (j = 0; j < 8; j++)
258 dst[scan[i * 8 + j]] = (*ext)[j];
259 *ext += 8;
260 }
261}
262
263static void recombine_block_il(int16_t *dst, const uint8_t *scan,
264 int16_t **base, int16_t **ext,
265 int block_no)
266{
267 int i, j;
268
269 if (block_no < 2) {
270 for (i = 0; i < 8; i++) {
271 for (j = 0; j < 4; j++)
272 dst[scan[i * 8 + j]] = (*base)[j];
273 for (j = 0; j < 4; j++)
274 dst[scan[i * 8 + j + 4]] = (*ext)[j];
275 *base += 4;
276 *ext += 4;
277 }
278 } else {
279 for (i = 0; i < 64; i++)
280 dst[scan[i]] = (*ext)[i];
281 *ext += 64;
282 }
283}
284
285static void unquant_block(int16_t *block, int q)
286{
287 int i;
288
289 for (i = 0; i < 64; i++) {
290 int val = (uint16_t)block[i];
291 int sign = val & 1;
292
293 block[i] = (((val >> 1) ^ -sign) * q * aic_quant_matrix[i] >> 4)
294 + sign;
295 }
296}
297
298static int aic_decode_slice(AICContext *ctx, int mb_x, int mb_y,
299 const uint8_t *src, int src_size)
300{
301 GetBitContext gb;
302 int ret, i, mb, blk;
303 int slice_width = FFMIN(ctx->slice_width, ctx->mb_width - mb_x);
304 uint8_t *Y, *C[2];
305 uint8_t *dst;
306 int16_t *base_y = ctx->data_ptr[COEFF_LUMA];
307 int16_t *base_c = ctx->data_ptr[COEFF_CHROMA];
308 int16_t *ext_y = ctx->data_ptr[COEFF_LUMA_EXT];
309 int16_t *ext_c = ctx->data_ptr[COEFF_CHROMA_EXT];
310 const int ystride = ctx->frame->linesize[0];
311
312 Y = ctx->frame->data[0] + mb_x * 16 + mb_y * 16 * ystride;
313 for (i = 0; i < 2; i++)
314 C[i] = ctx->frame->data[i + 1] + mb_x * 8
315 + mb_y * 8 * ctx->frame->linesize[i + 1];
316 init_get_bits(&gb, src, src_size * 8);
317
318 memset(ctx->slice_data, 0,
319 sizeof(*ctx->slice_data) * slice_width * AIC_BAND_COEFFS);
320 for (i = 0; i < NUM_BANDS; i++)
321 if ((ret = aic_decode_coeffs(&gb, ctx->data_ptr[i],
41006698
KS
322 i, slice_width,
323 !ctx->interlaced)) < 0)
1232a164
KS
324 return ret;
325
326 for (mb = 0; mb < slice_width; mb++) {
327 for (blk = 0; blk < 4; blk++) {
328 if (!ctx->interlaced)
329 recombine_block(ctx->block, ctx->scantable.permutated,
330 &base_y, &ext_y);
331 else
332 recombine_block_il(ctx->block, ctx->scantable.permutated,
333 &base_y, &ext_y, blk);
334 unquant_block(ctx->block, ctx->quant);
335 ctx->dsp.idct(ctx->block);
336
337 if (!ctx->interlaced) {
41006698 338 dst = Y + (blk >> 1) * 8 * ystride + (blk & 1) * 8;
1232a164
KS
339 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
340 ystride);
341 } else {
342 dst = Y + (blk & 1) * 8 + (blk >> 1) * ystride;
343 ctx->dsp.put_signed_pixels_clamped(ctx->block, dst,
344 ystride * 2);
345 }
346 }
347 Y += 16;
348
349 for (blk = 0; blk < 2; blk++) {
350 recombine_block(ctx->block, ctx->scantable.permutated,
351 &base_c, &ext_c);
352 unquant_block(ctx->block, ctx->quant);
353 ctx->dsp.idct(ctx->block);
354 ctx->dsp.put_signed_pixels_clamped(ctx->block, C[blk],
355 ctx->frame->linesize[blk + 1]);
356 C[blk] += 8;
357 }
358 }
359
360 return 0;
361}
362
363static int aic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
364 AVPacket *avpkt)
365{
366 AICContext *ctx = avctx->priv_data;
367 const uint8_t *buf = avpkt->data;
368 int buf_size = avpkt->size;
369 GetByteContext gb;
370 uint32_t off;
371 int x, y, ret;
372 int slice_size;
373
374 ctx->frame = data;
375 ctx->frame->pict_type = AV_PICTURE_TYPE_I;
376 ctx->frame->key_frame = 1;
377
378 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4);
379
380 if (buf_size < off) {
381 av_log(avctx, AV_LOG_ERROR, "Too small frame\n");
382 return AVERROR_INVALIDDATA;
383 }
384
385 if ((ret = aic_decode_header(ctx, buf, buf_size)) < 0)
386 return ret;
387
388 if ((ret = ff_get_buffer(avctx, ctx->frame, 0)) < 0)
389 return ret;
390
391 bytestream2_init(&gb, buf + AIC_HDR_SIZE,
392 ctx->num_x_slices * ctx->mb_height * 2);
393
394 for (y = 0; y < ctx->mb_height; y++) {
395 for (x = 0; x < ctx->mb_width; x += ctx->slice_width) {
396 slice_size = bytestream2_get_le16(&gb) * 4;
397 if (slice_size + off > buf_size || !slice_size) {
398 av_log(avctx, AV_LOG_ERROR, "Incorrect slice size\n");
399 return AVERROR_INVALIDDATA;
400 }
401
402 if ((ret = aic_decode_slice(ctx, x, y,
403 buf + off, slice_size)) < 0)
404 return ret;
405
406 off += slice_size;
407 }
408 }
409
410 *got_frame = 1;
411
412 return avpkt->size;
413}
414
415static av_cold int aic_decode_init(AVCodecContext *avctx)
416{
417 AICContext *ctx = avctx->priv_data;
418 int i;
419 uint8_t scan[64];
420
421 ctx->avctx = avctx;
422
423 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
424
425 ff_dsputil_init(&ctx->dsp, avctx);
426
427 for (i = 0; i < 64; i++)
428 scan[i] = i;
429 ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, scan);
430
431 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4;
432 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4;
433
434 ctx->num_x_slices = 16;
435 ctx->slice_width = ctx->mb_width / 16;
436 for (i = 1; i < 32; i++) {
437 if (!(ctx->mb_width % i) && (ctx->mb_width / i < 32)) {
438 ctx->slice_width = ctx->mb_width / i;
439 ctx->num_x_slices = i;
440 break;
441 }
442 }
443
444 ctx->slice_data = av_malloc(ctx->slice_width * AIC_BAND_COEFFS
445 * sizeof(*ctx->slice_data));
446 if (!ctx->slice_data) {
447 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n");
448
449 return AVERROR(ENOMEM);
450 }
451
452 for (i = 0; i < NUM_BANDS; i++)
453 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width
454 * aic_band_off[i];
455
456 return 0;
457}
458
459static av_cold int aic_decode_close(AVCodecContext *avctx)
460{
461 AICContext *ctx = avctx->priv_data;
462
463 av_freep(&ctx->slice_data);
464
465 return 0;
466}
467
468AVCodec ff_aic_decoder = {
469 .name = "aic",
470 .type = AVMEDIA_TYPE_VIDEO,
471 .id = AV_CODEC_ID_AIC,
472 .priv_data_size = sizeof(AICContext),
473 .init = aic_decode_init,
474 .close = aic_decode_close,
475 .decode = aic_decode_frame,
476 .capabilities = CODEC_CAP_DR1,
477 .long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec")
478};