1/* 2 * Copyright (C) 2005 Ole Andr�� Vadla Ravn��s <oleavr@gmail.com> 3 * Copyright (C) 2008 Ramiro Polla 4 * 5 * This file is part of FFmpeg. 6 * 7 * FFmpeg is free software; you can redistribute it and/or 8 * modify it under the terms of the GNU Lesser General Public 9 * License as published by the Free Software Foundation; either 10 * version 2.1 of the License, or (at your option) any later version. 11 * 12 * FFmpeg is distributed in the hope that it will be useful, 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with FFmpeg; if not, write to the Free Software 19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA 20 */ 21 22#include <stdlib.h> 23#include <string.h> 24#include <stdint.h> 25 26#include "avcodec.h" 27#include "blockdsp.h" 28#include "internal.h" 29#include "get_bits.h" 30#include "bytestream.h" 31#include "bswapdsp.h" 32#include "hpeldsp.h" 33#include "idctdsp.h" 34#include "thread.h" 35 36#define MIMIC_HEADER_SIZE 20 37 38typedef struct { 39 AVCodecContext *avctx; 40 41 int num_vblocks[3]; 42 int num_hblocks[3]; 43 44 void *swap_buf; 45 int swap_buf_size; 46 47 int cur_index; 48 int prev_index; 49 50 ThreadFrame frames [16]; 51 AVPicture flipped_ptrs[16]; 52 53 DECLARE_ALIGNED(16, int16_t, dct_block)[64]; 54 55 GetBitContext gb; 56 ScanTable scantable; 57 BlockDSPContext bdsp; 58 BswapDSPContext bbdsp; 59 HpelDSPContext hdsp; 60 IDCTDSPContext idsp; 61 VLC vlc; 62 63 /* Kept in the context so multithreading can have a constant to read from */ 64 int next_cur_index; 65 int next_prev_index; 66} MimicContext; 67 68static const uint32_t huffcodes[] = { 69 0x0000000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 70 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 71 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000000b, 72 0x0000001b, 0x00000038, 0x00000078, 0x00000079, 0x0000007a, 0x000000f9, 73 0x000000fa, 0x000003fb, 0x000007f8, 0x000007f9, 0x000007fa, 0x000007fb, 74 0x00000ff8, 0x00000ff9, 0x00000001, 0x00000039, 0x0000007b, 0x000000fb, 75 0x000001f8, 0x000001f9, 0x00000ffa, 0x00000ffb, 0x00001ff8, 0x00001ff9, 76 0x00001ffa, 0x00001ffb, 0x00003ff8, 0x00003ff9, 0x00003ffa, 0x00000000, 77 0x00000004, 0x0000003a, 0x000001fa, 0x00003ffb, 0x00007ff8, 0x00007ff9, 78 0x00007ffa, 0x00007ffb, 0x0000fff8, 0x0000fff9, 0x0000fffa, 0x0000fffb, 79 0x0001fff8, 0x0001fff9, 0x0001fffa, 0x00000000, 0x0000000c, 0x000000f8, 80 0x000001fb, 0x0001fffb, 0x0003fff8, 0x0003fff9, 0x0003fffa, 0x0003fffb, 81 0x0007fff8, 0x0007fff9, 0x0007fffa, 0x0007fffb, 0x000ffff8, 0x000ffff9, 82 0x000ffffa, 0x00000000, 0x0000001a, 0x000003f8, 0x000ffffb, 0x001ffff8, 83 0x001ffff9, 0x001ffffa, 0x001ffffb, 0x003ffff8, 0x003ffff9, 0x003ffffa, 84 0x003ffffb, 0x007ffff8, 0x007ffff9, 0x007ffffa, 0x007ffffb, 0x00000000, 85 0x0000003b, 0x000003f9, 0x00fffff8, 0x00fffff9, 0x00fffffa, 0x00fffffb, 86 0x01fffff8, 0x01fffff9, 0x01fffffa, 0x01fffffb, 0x03fffff8, 0x03fffff9, 87 0x03fffffa, 0x03fffffb, 0x07fffff8, 0x00000000, 0x000003fa, 0x07fffff9, 88 0x07fffffa, 0x07fffffb, 0x0ffffff8, 0x0ffffff9, 0x0ffffffa, 0x0ffffffb, 89 0x1ffffff8, 0x1ffffff9, 0x1ffffffa, 0x1ffffffb, 0x3ffffff8, 0x3ffffff9, 90 0x3ffffffa, 91}; 92 93static const uint8_t huffbits[] = { 94 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 95 0, 0, 0, 0, 2, 4, 5, 6, 7, 7, 7, 8, 96 8, 10, 11, 11, 11, 11, 12, 12, 2, 6, 7, 8, 97 9, 9, 12, 12, 13, 13, 13, 13, 14, 14, 14, 0, 98 3, 6, 9, 14, 15, 15, 15, 15, 16, 16, 16, 16, 99 17, 17, 17, 0, 4, 8, 9, 17, 18, 18, 18, 18, 100 19, 19, 19, 19, 20, 20, 20, 0, 5, 10, 20, 21, 101 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 0, 102 6, 10, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26, 103 26, 26, 27, 0, 10, 27, 27, 27, 28, 28, 28, 28, 104 29, 29, 29, 29, 30, 30, 30, 105}; 106 107static const uint8_t col_zag[64] = { 108 0, 8, 1, 2, 9, 16, 24, 17, 109 10, 3, 4, 11, 18, 25, 32, 40, 110 33, 26, 19, 12, 5, 6, 13, 20, 111 27, 34, 41, 48, 56, 49, 42, 35, 112 28, 21, 14, 7, 15, 22, 29, 36, 113 43, 50, 57, 58, 51, 44, 37, 30, 114 23, 31, 38, 45, 52, 59, 39, 46, 115 53, 60, 61, 54, 47, 55, 62, 63, 116}; 117 118static av_cold int mimic_decode_end(AVCodecContext *avctx) 119{ 120 MimicContext *ctx = avctx->priv_data; 121 int i; 122 123 av_freep(&ctx->swap_buf); 124 ctx->swap_buf_size = 0; 125 126 for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) { 127 if (ctx->frames[i].f) 128 ff_thread_release_buffer(avctx, &ctx->frames[i]); 129 av_frame_free(&ctx->frames[i].f); 130 } 131 132 if (!avctx->internal->is_copy) 133 ff_free_vlc(&ctx->vlc); 134 135 return 0; 136} 137 138static av_cold int mimic_decode_init(AVCodecContext *avctx) 139{ 140 MimicContext *ctx = avctx->priv_data; 141 int ret, i; 142 143 avctx->internal->allocate_progress = 1; 144 145 ctx->prev_index = 0; 146 ctx->cur_index = 15; 147 148 if ((ret = init_vlc(&ctx->vlc, 11, FF_ARRAY_ELEMS(huffbits), 149 huffbits, 1, 1, huffcodes, 4, 4, 0)) < 0) { 150 av_log(avctx, AV_LOG_ERROR, "error initializing vlc table\n"); 151 return ret; 152 } 153 ff_blockdsp_init(&ctx->bdsp, avctx); 154 ff_bswapdsp_init(&ctx->bbdsp); 155 ff_hpeldsp_init(&ctx->hdsp, avctx->flags); 156 ff_idctdsp_init(&ctx->idsp, avctx); 157 ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, col_zag); 158 159 for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) { 160 ctx->frames[i].f = av_frame_alloc(); 161 if (!ctx->frames[i].f) { 162 mimic_decode_end(avctx); 163 return AVERROR(ENOMEM); 164 } 165 } 166 167 return 0; 168} 169 170static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from) 171{ 172 MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data; 173 int i, ret; 174 175 if (avctx == avctx_from) 176 return 0; 177 178 dst->cur_index = src->next_cur_index; 179 dst->prev_index = src->next_prev_index; 180 181 memcpy(dst->flipped_ptrs, src->flipped_ptrs, sizeof(src->flipped_ptrs)); 182 183 for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) { 184 ff_thread_release_buffer(avctx, &dst->frames[i]); 185 if (i != src->next_cur_index && src->frames[i].f->data[0]) { 186 ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]); 187 if (ret < 0) 188 return ret; 189 } 190 } 191 192 return 0; 193} 194 195static const int8_t vlcdec_lookup[9][64] = { 196 { 0, }, 197 { -1, 1, }, 198 { -3, 3, -2, 2, }, 199 { -7, 7, -6, 6, -5, 5, -4, 4, }, 200 { -15, 15, -14, 14, -13, 13, -12, 12, 201 -11, 11, -10, 10, -9, 9, -8, 8, }, 202 { -31, 31, -30, 30, -29, 29, -28, 28, 203 -27, 27, -26, 26, -25, 25, -24, 24, 204 -23, 23, -22, 22, -21, 21, -20, 20, 205 -19, 19, -18, 18, -17, 17, -16, 16, }, 206 { -63, 63, -62, 62, -61, 61, -60, 60, 207 -59, 59, -58, 58, -57, 57, -56, 56, 208 -55, 55, -54, 54, -53, 53, -52, 52, 209 -51, 51, -50, 50, -49, 49, -48, 48, 210 -47, 47, -46, 46, -45, 45, -44, 44, 211 -43, 43, -42, 42, -41, 41, -40, 40, 212 -39, 39, -38, 38, -37, 37, -36, 36, 213 -35, 35, -34, 34, -33, 33, -32, 32, }, 214 { -127, 127, -126, 126, -125, 125, -124, 124, 215 -123, 123, -122, 122, -121, 121, -120, 120, 216 -119, 119, -118, 118, -117, 117, -116, 116, 217 -115, 115, -114, 114, -113, 113, -112, 112, 218 -111, 111, -110, 110, -109, 109, -108, 108, 219 -107, 107, -106, 106, -105, 105, -104, 104, 220 -103, 103, -102, 102, -101, 101, -100, 100, 221 -99, 99, -98, 98, -97, 97, -96, 96, }, 222 { -95, 95, -94, 94, -93, 93, -92, 92, 223 -91, 91, -90, 90, -89, 89, -88, 88, 224 -87, 87, -86, 86, -85, 85, -84, 84, 225 -83, 83, -82, 82, -81, 81, -80, 80, 226 -79, 79, -78, 78, -77, 77, -76, 76, 227 -75, 75, -74, 74, -73, 73, -72, 72, 228 -71, 71, -70, 70, -69, 69, -68, 68, 229 -67, 67, -66, 66, -65, 65, -64, 64, }, 230}; 231 232static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale) 233{ 234 int16_t *block = ctx->dct_block; 235 unsigned int pos; 236 237 ctx->bdsp.clear_block(block); 238 239 block[0] = get_bits(&ctx->gb, 8) << 3; 240 241 for (pos = 1; pos < num_coeffs; pos++) { 242 uint32_t vlc, num_bits; 243 int value; 244 int coeff; 245 246 vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3); 247 if (!vlc) /* end-of-block code */ 248 return 0; 249 if (vlc == -1) 250 return AVERROR_INVALIDDATA; 251 252 /* pos_add and num_bits are coded in the vlc code */ 253 pos += vlc & 15; // pos_add 254 num_bits = vlc >> 4; // num_bits 255 256 if (pos >= 64) 257 return AVERROR_INVALIDDATA; 258 259 value = get_bits(&ctx->gb, num_bits); 260 261 /* FFmpeg's IDCT behaves somewhat different from the original code, so 262 * a factor of 4 was added to the input */ 263 264 coeff = vlcdec_lookup[num_bits][value]; 265 if (pos < 3) 266 coeff <<= 4; 267 else /* TODO Use >> 10 instead of / 1001 */ 268 coeff = (coeff * qscale) / 1001; 269 270 block[ctx->scantable.permutated[pos]] = coeff; 271 } 272 273 return 0; 274} 275 276static int decode(MimicContext *ctx, int quality, int num_coeffs, 277 int is_iframe) 278{ 279 int ret, y, x, plane, cur_row = 0; 280 281 for (plane = 0; plane < 3; plane++) { 282 const int is_chroma = !!plane; 283 const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000, 284 10000) << 2; 285 const int stride = ctx->flipped_ptrs[ctx->cur_index ].linesize[plane]; 286 const uint8_t *src = ctx->flipped_ptrs[ctx->prev_index].data[plane]; 287 uint8_t *dst = ctx->flipped_ptrs[ctx->cur_index ].data[plane]; 288 289 for (y = 0; y < ctx->num_vblocks[plane]; y++) { 290 for (x = 0; x < ctx->num_hblocks[plane]; x++) { 291 /* Check for a change condition in the current block. 292 * - iframes always change. 293 * - Luma plane changes on get_bits1 == 0 294 * - Chroma planes change on get_bits1 == 1 */ 295 if (is_iframe || get_bits1(&ctx->gb) == is_chroma) { 296 /* Luma planes may use a backreference from the 15 last 297 * frames preceding the previous. (get_bits1 == 1) 298 * Chroma planes don't use backreferences. */ 299 if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) { 300 if ((ret = vlc_decode_block(ctx, num_coeffs, 301 qscale)) < 0) { 302 av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding " 303 "block.\n"); 304 return ret; 305 } 306 ctx->idsp.idct_put(dst, stride, ctx->dct_block); 307 } else { 308 unsigned int backref = get_bits(&ctx->gb, 4); 309 int index = (ctx->cur_index + backref) & 15; 310 uint8_t *p = ctx->flipped_ptrs[index].data[0]; 311 312 if (index != ctx->cur_index && p) { 313 ff_thread_await_progress(&ctx->frames[index], 314 cur_row, 0); 315 p += src - 316 ctx->flipped_ptrs[ctx->prev_index].data[plane]; 317 ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8); 318 } else { 319 av_log(ctx->avctx, AV_LOG_ERROR, 320 "No such backreference! Buggy sample.\n"); 321 } 322 } 323 } else { 324 ff_thread_await_progress(&ctx->frames[ctx->prev_index], 325 cur_row, 0); 326 ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8); 327 } 328 src += 8; 329 dst += 8; 330 } 331 src += (stride - ctx->num_hblocks[plane]) << 3; 332 dst += (stride - ctx->num_hblocks[plane]) << 3; 333 334 ff_thread_report_progress(&ctx->frames[ctx->cur_index], 335 cur_row++, 0); 336 } 337 } 338 339 return 0; 340} 341 342/** 343 * Flip the buffer upside-down and put it in the YVU order to match the 344 * way Mimic encodes frames. 345 */ 346static void prepare_avpic(MimicContext *ctx, AVPicture *dst, AVFrame *src) 347{ 348 int i; 349 dst->data[0] = src->data[0] + ( ctx->avctx->height - 1) * src->linesize[0]; 350 dst->data[1] = src->data[2] + ((ctx->avctx->height >> 1) - 1) * src->linesize[2]; 351 dst->data[2] = src->data[1] + ((ctx->avctx->height >> 1) - 1) * src->linesize[1]; 352 for (i = 0; i < 3; i++) 353 dst->linesize[i] = -src->linesize[i]; 354} 355 356static int mimic_decode_frame(AVCodecContext *avctx, void *data, 357 int *got_frame, AVPacket *avpkt) 358{ 359 const uint8_t *buf = avpkt->data; 360 int buf_size = avpkt->size; 361 int swap_buf_size = buf_size - MIMIC_HEADER_SIZE; 362 MimicContext *ctx = avctx->priv_data; 363 GetByteContext gb; 364 int is_pframe; 365 int width, height; 366 int quality, num_coeffs; 367 int res; 368 369 if (buf_size <= MIMIC_HEADER_SIZE) { 370 av_log(avctx, AV_LOG_ERROR, "insufficient data\n"); 371 return AVERROR_INVALIDDATA; 372 } 373 374 bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE); 375 bytestream2_skip(&gb, 2); /* some constant (always 256) */ 376 quality = bytestream2_get_le16u(&gb); 377 width = bytestream2_get_le16u(&gb); 378 height = bytestream2_get_le16u(&gb); 379 bytestream2_skip(&gb, 4); /* some constant */ 380 is_pframe = bytestream2_get_le32u(&gb); 381 num_coeffs = bytestream2_get_byteu(&gb); 382 bytestream2_skip(&gb, 3); /* some constant */ 383 384 if (!ctx->avctx) { 385 int i; 386 387 if (!(width == 160 && height == 120) && 388 !(width == 320 && height == 240)) { 389 av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n"); 390 return AVERROR_INVALIDDATA; 391 } 392 393 ctx->avctx = avctx; 394 avctx->width = width; 395 avctx->height = height; 396 avctx->pix_fmt = AV_PIX_FMT_YUV420P; 397 for (i = 0; i < 3; i++) { 398 ctx->num_vblocks[i] = FF_CEIL_RSHIFT(height, 3 + !!i); 399 ctx->num_hblocks[i] = width >> (3 + !!i); 400 } 401 } else if (width != ctx->avctx->width || height != ctx->avctx->height) { 402 avpriv_request_sample(avctx, "Resolution changing"); 403 return AVERROR_PATCHWELCOME; 404 } 405 406 if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) { 407 av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n"); 408 return AVERROR_INVALIDDATA; 409 } 410 411 ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]); 412 ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P : 413 AV_PICTURE_TYPE_I; 414 if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index], 415 AV_GET_BUFFER_FLAG_REF)) < 0) 416 return res; 417 418 ctx->next_prev_index = ctx->cur_index; 419 ctx->next_cur_index = (ctx->cur_index - 1) & 15; 420 421 prepare_avpic(ctx, &ctx->flipped_ptrs[ctx->cur_index], 422 ctx->frames[ctx->cur_index].f); 423 424 ff_thread_finish_setup(avctx); 425 426 av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size); 427 if (!ctx->swap_buf) 428 return AVERROR(ENOMEM); 429 430 ctx->bbdsp.bswap_buf(ctx->swap_buf, 431 (const uint32_t *) (buf + MIMIC_HEADER_SIZE), 432 swap_buf_size >> 2); 433 init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3); 434 435 res = decode(ctx, quality, num_coeffs, !is_pframe); 436 ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0); 437 if (res < 0) { 438 if (!(avctx->active_thread_type & FF_THREAD_FRAME)) { 439 ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]); 440 return res; 441 } 442 } 443 444 if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0) 445 return res; 446 *got_frame = 1; 447 448 ctx->prev_index = ctx->next_prev_index; 449 ctx->cur_index = ctx->next_cur_index; 450 451 /* Only release frames that aren't used for backreferences anymore */ 452 ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]); 453 454 return buf_size; 455} 456 457static av_cold int mimic_init_thread_copy(AVCodecContext *avctx) 458{ 459 MimicContext *ctx = avctx->priv_data; 460 int i; 461 462 for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) { 463 ctx->frames[i].f = av_frame_alloc(); 464 if (!ctx->frames[i].f) { 465 mimic_decode_end(avctx); 466 return AVERROR(ENOMEM); 467 } 468 } 469 470 return 0; 471} 472 473AVCodec ff_mimic_decoder = { 474 .name = "mimic", 475 .long_name = NULL_IF_CONFIG_SMALL("Mimic"), 476 .type = AVMEDIA_TYPE_VIDEO, 477 .id = AV_CODEC_ID_MIMIC, 478 .priv_data_size = sizeof(MimicContext), 479 .init = mimic_decode_init, 480 .close = mimic_decode_end, 481 .decode = mimic_decode_frame, 482 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS, 483 .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context), 484 .init_thread_copy = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy), 485}; 486