2 * Copyright (C) 2005 Ole André Vadla Ravnås <oleavr@gmail.com>
3 * Copyright (C) 2008 Ramiro Polla
5 * This file is part of FFmpeg.
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.
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.
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
30 #include "bytestream.h"
35 #define MIMIC_HEADER_SIZE 20
38 AVCodecContext *avctx;
49 ThreadFrame frames [16];
50 AVPicture flipped_ptrs[16];
52 DECLARE_ALIGNED(16, int16_t, dct_block)[64];
61 /* Kept in the context so multithreading can have a constant to read from */
66 static const uint32_t huffcodes[] = {
67 0x0000000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
68 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
69 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000000b,
70 0x0000001b, 0x00000038, 0x00000078, 0x00000079, 0x0000007a, 0x000000f9,
71 0x000000fa, 0x000003fb, 0x000007f8, 0x000007f9, 0x000007fa, 0x000007fb,
72 0x00000ff8, 0x00000ff9, 0x00000001, 0x00000039, 0x0000007b, 0x000000fb,
73 0x000001f8, 0x000001f9, 0x00000ffa, 0x00000ffb, 0x00001ff8, 0x00001ff9,
74 0x00001ffa, 0x00001ffb, 0x00003ff8, 0x00003ff9, 0x00003ffa, 0x00000000,
75 0x00000004, 0x0000003a, 0x000001fa, 0x00003ffb, 0x00007ff8, 0x00007ff9,
76 0x00007ffa, 0x00007ffb, 0x0000fff8, 0x0000fff9, 0x0000fffa, 0x0000fffb,
77 0x0001fff8, 0x0001fff9, 0x0001fffa, 0x00000000, 0x0000000c, 0x000000f8,
78 0x000001fb, 0x0001fffb, 0x0003fff8, 0x0003fff9, 0x0003fffa, 0x0003fffb,
79 0x0007fff8, 0x0007fff9, 0x0007fffa, 0x0007fffb, 0x000ffff8, 0x000ffff9,
80 0x000ffffa, 0x00000000, 0x0000001a, 0x000003f8, 0x000ffffb, 0x001ffff8,
81 0x001ffff9, 0x001ffffa, 0x001ffffb, 0x003ffff8, 0x003ffff9, 0x003ffffa,
82 0x003ffffb, 0x007ffff8, 0x007ffff9, 0x007ffffa, 0x007ffffb, 0x00000000,
83 0x0000003b, 0x000003f9, 0x00fffff8, 0x00fffff9, 0x00fffffa, 0x00fffffb,
84 0x01fffff8, 0x01fffff9, 0x01fffffa, 0x01fffffb, 0x03fffff8, 0x03fffff9,
85 0x03fffffa, 0x03fffffb, 0x07fffff8, 0x00000000, 0x000003fa, 0x07fffff9,
86 0x07fffffa, 0x07fffffb, 0x0ffffff8, 0x0ffffff9, 0x0ffffffa, 0x0ffffffb,
87 0x1ffffff8, 0x1ffffff9, 0x1ffffffa, 0x1ffffffb, 0x3ffffff8, 0x3ffffff9,
91 static const uint8_t huffbits[] = {
92 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
93 0, 0, 0, 0, 2, 4, 5, 6, 7, 7, 7, 8,
94 8, 10, 11, 11, 11, 11, 12, 12, 2, 6, 7, 8,
95 9, 9, 12, 12, 13, 13, 13, 13, 14, 14, 14, 0,
96 3, 6, 9, 14, 15, 15, 15, 15, 16, 16, 16, 16,
97 17, 17, 17, 0, 4, 8, 9, 17, 18, 18, 18, 18,
98 19, 19, 19, 19, 20, 20, 20, 0, 5, 10, 20, 21,
99 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 0,
100 6, 10, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,
101 26, 26, 27, 0, 10, 27, 27, 27, 28, 28, 28, 28,
102 29, 29, 29, 29, 30, 30, 30,
105 static const uint8_t col_zag[64] = {
106 0, 8, 1, 2, 9, 16, 24, 17,
107 10, 3, 4, 11, 18, 25, 32, 40,
108 33, 26, 19, 12, 5, 6, 13, 20,
109 27, 34, 41, 48, 56, 49, 42, 35,
110 28, 21, 14, 7, 15, 22, 29, 36,
111 43, 50, 57, 58, 51, 44, 37, 30,
112 23, 31, 38, 45, 52, 59, 39, 46,
113 53, 60, 61, 54, 47, 55, 62, 63,
116 static av_cold int mimic_decode_end(AVCodecContext *avctx)
118 MimicContext *ctx = avctx->priv_data;
121 av_freep(&ctx->swap_buf);
122 ctx->swap_buf_size = 0;
124 for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
125 if (ctx->frames[i].f)
126 ff_thread_release_buffer(avctx, &ctx->frames[i]);
127 av_frame_free(&ctx->frames[i].f);
130 if (!avctx->internal->is_copy)
131 ff_free_vlc(&ctx->vlc);
136 static av_cold int mimic_decode_init(AVCodecContext *avctx)
138 MimicContext *ctx = avctx->priv_data;
141 avctx->internal->allocate_progress = 1;
146 if ((ret = init_vlc(&ctx->vlc, 11, FF_ARRAY_ELEMS(huffbits),
147 huffbits, 1, 1, huffcodes, 4, 4, 0)) < 0) {
148 av_log(avctx, AV_LOG_ERROR, "error initializing vlc table\n");
151 ff_blockdsp_init(&ctx->bdsp, avctx);
152 ff_dsputil_init(&ctx->dsp, avctx);
153 ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
154 ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, col_zag);
156 for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
157 ctx->frames[i].f = av_frame_alloc();
158 if (!ctx->frames[i].f) {
159 mimic_decode_end(avctx);
160 return AVERROR(ENOMEM);
167 static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
169 MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
172 if (avctx == avctx_from)
175 dst->cur_index = src->next_cur_index;
176 dst->prev_index = src->next_prev_index;
178 memcpy(dst->flipped_ptrs, src->flipped_ptrs, sizeof(src->flipped_ptrs));
180 for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
181 ff_thread_release_buffer(avctx, &dst->frames[i]);
182 if (i != src->next_cur_index && src->frames[i].f->data[0]) {
183 ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
192 static const int8_t vlcdec_lookup[9][64] = {
196 { -7, 7, -6, 6, -5, 5, -4, 4, },
197 { -15, 15, -14, 14, -13, 13, -12, 12,
198 -11, 11, -10, 10, -9, 9, -8, 8, },
199 { -31, 31, -30, 30, -29, 29, -28, 28,
200 -27, 27, -26, 26, -25, 25, -24, 24,
201 -23, 23, -22, 22, -21, 21, -20, 20,
202 -19, 19, -18, 18, -17, 17, -16, 16, },
203 { -63, 63, -62, 62, -61, 61, -60, 60,
204 -59, 59, -58, 58, -57, 57, -56, 56,
205 -55, 55, -54, 54, -53, 53, -52, 52,
206 -51, 51, -50, 50, -49, 49, -48, 48,
207 -47, 47, -46, 46, -45, 45, -44, 44,
208 -43, 43, -42, 42, -41, 41, -40, 40,
209 -39, 39, -38, 38, -37, 37, -36, 36,
210 -35, 35, -34, 34, -33, 33, -32, 32, },
211 { -127, 127, -126, 126, -125, 125, -124, 124,
212 -123, 123, -122, 122, -121, 121, -120, 120,
213 -119, 119, -118, 118, -117, 117, -116, 116,
214 -115, 115, -114, 114, -113, 113, -112, 112,
215 -111, 111, -110, 110, -109, 109, -108, 108,
216 -107, 107, -106, 106, -105, 105, -104, 104,
217 -103, 103, -102, 102, -101, 101, -100, 100,
218 -99, 99, -98, 98, -97, 97, -96, 96, },
219 { -95, 95, -94, 94, -93, 93, -92, 92,
220 -91, 91, -90, 90, -89, 89, -88, 88,
221 -87, 87, -86, 86, -85, 85, -84, 84,
222 -83, 83, -82, 82, -81, 81, -80, 80,
223 -79, 79, -78, 78, -77, 77, -76, 76,
224 -75, 75, -74, 74, -73, 73, -72, 72,
225 -71, 71, -70, 70, -69, 69, -68, 68,
226 -67, 67, -66, 66, -65, 65, -64, 64, },
229 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
231 int16_t *block = ctx->dct_block;
234 ctx->bdsp.clear_block(block);
236 block[0] = get_bits(&ctx->gb, 8) << 3;
238 for (pos = 1; pos < num_coeffs; pos++) {
239 uint32_t vlc, num_bits;
243 vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3);
244 if (!vlc) /* end-of-block code */
247 return AVERROR_INVALIDDATA;
249 /* pos_add and num_bits are coded in the vlc code */
250 pos += vlc & 15; // pos_add
251 num_bits = vlc >> 4; // num_bits
254 return AVERROR_INVALIDDATA;
256 value = get_bits(&ctx->gb, num_bits);
258 /* FFmpeg's IDCT behaves somewhat different from the original code, so
259 * a factor of 4 was added to the input */
261 coeff = vlcdec_lookup[num_bits][value];
264 else /* TODO Use >> 10 instead of / 1001 */
265 coeff = (coeff * qscale) / 1001;
267 block[ctx->scantable.permutated[pos]] = coeff;
273 static int decode(MimicContext *ctx, int quality, int num_coeffs,
276 int ret, y, x, plane, cur_row = 0;
278 for (plane = 0; plane < 3; plane++) {
279 const int is_chroma = !!plane;
280 const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
282 const int stride = ctx->flipped_ptrs[ctx->cur_index ].linesize[plane];
283 const uint8_t *src = ctx->flipped_ptrs[ctx->prev_index].data[plane];
284 uint8_t *dst = ctx->flipped_ptrs[ctx->cur_index ].data[plane];
286 for (y = 0; y < ctx->num_vblocks[plane]; y++) {
287 for (x = 0; x < ctx->num_hblocks[plane]; x++) {
288 /* Check for a change condition in the current block.
289 * - iframes always change.
290 * - Luma plane changes on get_bits1 == 0
291 * - Chroma planes change on get_bits1 == 1 */
292 if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
293 /* Luma planes may use a backreference from the 15 last
294 * frames preceding the previous. (get_bits1 == 1)
295 * Chroma planes don't use backreferences. */
296 if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
297 if ((ret = vlc_decode_block(ctx, num_coeffs,
299 av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
303 ctx->dsp.idct_put(dst, stride, ctx->dct_block);
305 unsigned int backref = get_bits(&ctx->gb, 4);
306 int index = (ctx->cur_index + backref) & 15;
307 uint8_t *p = ctx->flipped_ptrs[index].data[0];
309 if (index != ctx->cur_index && p) {
310 ff_thread_await_progress(&ctx->frames[index],
313 ctx->flipped_ptrs[ctx->prev_index].data[plane];
314 ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
316 av_log(ctx->avctx, AV_LOG_ERROR,
317 "No such backreference! Buggy sample.\n");
321 ff_thread_await_progress(&ctx->frames[ctx->prev_index],
323 ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
328 src += (stride - ctx->num_hblocks[plane]) << 3;
329 dst += (stride - ctx->num_hblocks[plane]) << 3;
331 ff_thread_report_progress(&ctx->frames[ctx->cur_index],
340 * Flip the buffer upside-down and put it in the YVU order to match the
341 * way Mimic encodes frames.
343 static void prepare_avpic(MimicContext *ctx, AVPicture *dst, AVFrame *src)
346 dst->data[0] = src->data[0] + ( ctx->avctx->height - 1) * src->linesize[0];
347 dst->data[1] = src->data[2] + ((ctx->avctx->height >> 1) - 1) * src->linesize[2];
348 dst->data[2] = src->data[1] + ((ctx->avctx->height >> 1) - 1) * src->linesize[1];
349 for (i = 0; i < 3; i++)
350 dst->linesize[i] = -src->linesize[i];
353 static int mimic_decode_frame(AVCodecContext *avctx, void *data,
354 int *got_frame, AVPacket *avpkt)
356 const uint8_t *buf = avpkt->data;
357 int buf_size = avpkt->size;
358 int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;
359 MimicContext *ctx = avctx->priv_data;
363 int quality, num_coeffs;
366 if (buf_size <= MIMIC_HEADER_SIZE) {
367 av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
368 return AVERROR_INVALIDDATA;
371 bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);
372 bytestream2_skip(&gb, 2); /* some constant (always 256) */
373 quality = bytestream2_get_le16u(&gb);
374 width = bytestream2_get_le16u(&gb);
375 height = bytestream2_get_le16u(&gb);
376 bytestream2_skip(&gb, 4); /* some constant */
377 is_pframe = bytestream2_get_le32u(&gb);
378 num_coeffs = bytestream2_get_byteu(&gb);
379 bytestream2_skip(&gb, 3); /* some constant */
384 if (!(width == 160 && height == 120) &&
385 !(width == 320 && height == 240)) {
386 av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
387 return AVERROR_INVALIDDATA;
391 avctx->width = width;
392 avctx->height = height;
393 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
394 for (i = 0; i < 3; i++) {
395 ctx->num_vblocks[i] = FF_CEIL_RSHIFT(height, 3 + !!i);
396 ctx->num_hblocks[i] = width >> (3 + !!i);
398 } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
399 avpriv_request_sample(avctx, "Resolution changing");
400 return AVERROR_PATCHWELCOME;
403 if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
404 av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
405 return AVERROR_INVALIDDATA;
408 ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
409 ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
411 if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
412 AV_GET_BUFFER_FLAG_REF)) < 0)
415 ctx->next_prev_index = ctx->cur_index;
416 ctx->next_cur_index = (ctx->cur_index - 1) & 15;
418 prepare_avpic(ctx, &ctx->flipped_ptrs[ctx->cur_index],
419 ctx->frames[ctx->cur_index].f);
421 ff_thread_finish_setup(avctx);
423 av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
425 return AVERROR(ENOMEM);
427 ctx->dsp.bswap_buf(ctx->swap_buf,
428 (const uint32_t*) (buf + MIMIC_HEADER_SIZE),
430 init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
432 res = decode(ctx, quality, num_coeffs, !is_pframe);
433 ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
435 if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
436 ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
441 if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0)
445 ctx->prev_index = ctx->next_prev_index;
446 ctx->cur_index = ctx->next_cur_index;
448 /* Only release frames that aren't used for backreferences anymore */
449 ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
454 static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
456 MimicContext *ctx = avctx->priv_data;
459 for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
460 ctx->frames[i].f = av_frame_alloc();
461 if (!ctx->frames[i].f) {
462 mimic_decode_end(avctx);
463 return AVERROR(ENOMEM);
470 AVCodec ff_mimic_decoder = {
472 .long_name = NULL_IF_CONFIG_SMALL("Mimic"),
473 .type = AVMEDIA_TYPE_VIDEO,
474 .id = AV_CODEC_ID_MIMIC,
475 .priv_data_size = sizeof(MimicContext),
476 .init = mimic_decode_init,
477 .close = mimic_decode_end,
478 .decode = mimic_decode_frame,
479 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
480 .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context),
481 .init_thread_copy = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy),