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 "codec_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 39enum AICBands { 40 COEFF_LUMA = 0, 41 COEFF_CHROMA, 42 COEFF_LUMA_EXT, 43 COEFF_CHROMA_EXT, 44 NUM_BANDS 45}; 46 47static const uint8_t aic_num_band_coeffs[NUM_BANDS] = { 64, 32, 192, 96 }; 48 49static const uint16_t aic_band_off[NUM_BANDS] = { 0, 64, 96, 288 }; 50 51static 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 62static 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 73static 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 100static 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 111static 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 138static 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 142typedef 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 161static 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 204static 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 255static 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 275static 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 297static 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 310static 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 384static int aic_decode_frame(AVCodecContext *avctx, AVFrame *frame, 385 int *got_frame, 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 395 ctx->frame = frame; 396 ctx->frame->pict_type = AV_PICTURE_TYPE_I; 397 ctx->frame->key_frame = 1; 398 399 off = FFALIGN(AIC_HDR_SIZE + ctx->num_x_slices * ctx->mb_height * 2, 4); 400 401 if (buf_size < off) { 402 av_log(avctx, AV_LOG_ERROR, "Too small frame\n"); 403 return AVERROR_INVALIDDATA; 404 } 405 406 ret = aic_decode_header(ctx, buf, buf_size); 407 if (ret < 0) { 408 av_log(avctx, AV_LOG_ERROR, "Invalid header\n"); 409 return ret; 410 } 411 412 if ((ret = ff_thread_get_buffer(avctx, ctx->frame, 0)) < 0) 413 return ret; 414 415 bytestream2_init(&gb, buf + AIC_HDR_SIZE, 416 ctx->num_x_slices * ctx->mb_height * 2); 417 418 for (y = 0; y < ctx->mb_height; y++) { 419 for (x = 0; x < ctx->mb_width; x += ctx->slice_width) { 420 slice_size = bytestream2_get_le16(&gb) * 4; 421 if (slice_size + off > buf_size || !slice_size) { 422 av_log(avctx, AV_LOG_ERROR, 423 "Incorrect slice size %d at %d.%d\n", slice_size, x, y); 424 return AVERROR_INVALIDDATA; 425 } 426 427 ret = aic_decode_slice(ctx, x, y, buf + off, slice_size); 428 if (ret < 0) { 429 av_log(avctx, AV_LOG_ERROR, 430 "Error decoding slice at %d.%d\n", x, y); 431 return ret; 432 } 433 434 off += slice_size; 435 } 436 } 437 438 *got_frame = 1; 439 440 return avpkt->size; 441} 442 443static av_cold int aic_decode_init(AVCodecContext *avctx) 444{ 445 AICContext *ctx = avctx->priv_data; 446 int i; 447 uint8_t scan[64]; 448 449 ctx->avctx = avctx; 450 451 avctx->pix_fmt = AV_PIX_FMT_YUV420P; 452 453 ff_idctdsp_init(&ctx->idsp, avctx); 454 455 for (i = 0; i < 64; i++) 456 scan[i] = i; 457 ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, scan); 458 for (i = 0; i < 64; i++) 459 ctx->quant_matrix[ctx->idsp.idct_permutation[i]] = aic_quant_matrix[i]; 460 461 ctx->mb_width = FFALIGN(avctx->width, 16) >> 4; 462 ctx->mb_height = FFALIGN(avctx->height, 16) >> 4; 463 464 ctx->num_x_slices = (ctx->mb_width + 15) >> 4; 465 ctx->slice_width = 16; 466 for (i = 1; i < ctx->mb_width; i++) { 467 if (!(ctx->mb_width % i) && (ctx->mb_width / i <= 32)) { 468 ctx->slice_width = ctx->mb_width / i; 469 ctx->num_x_slices = i; 470 break; 471 } 472 } 473 474 ctx->slice_data = av_malloc_array(ctx->slice_width, AIC_BAND_COEFFS 475 * sizeof(*ctx->slice_data)); 476 if (!ctx->slice_data) { 477 av_log(avctx, AV_LOG_ERROR, "Error allocating slice buffer\n"); 478 479 return AVERROR(ENOMEM); 480 } 481 482 for (i = 0; i < NUM_BANDS; i++) 483 ctx->data_ptr[i] = ctx->slice_data + ctx->slice_width 484 * aic_band_off[i]; 485 486 return 0; 487} 488 489static av_cold int aic_decode_close(AVCodecContext *avctx) 490{ 491 AICContext *ctx = avctx->priv_data; 492 493 av_freep(&ctx->slice_data); 494 495 return 0; 496} 497 498const FFCodec ff_aic_decoder = { 499 .p.name = "aic", 500 .p.long_name = NULL_IF_CONFIG_SMALL("Apple Intermediate Codec"), 501 .p.type = AVMEDIA_TYPE_VIDEO, 502 .p.id = AV_CODEC_ID_AIC, 503 .priv_data_size = sizeof(AICContext), 504 .init = aic_decode_init, 505 .close = aic_decode_close, 506 FF_CODEC_DECODE_CB(aic_decode_frame), 507 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS, 508 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE, 509}; 510