mimic: cosmetics, reformat
[libav.git] / libavcodec / mimic.c
CommitLineData
a7129de5 1/*
6d27d8b1 2 * Copyright (C) 2005 Ole André Vadla Ravnås <oleavr@gmail.com>
cbf5d22d 3 * Copyright (C) 2008 Ramiro Polla
a7129de5 4 *
2912e87a 5 * This file is part of Libav.
a7129de5 6 *
2912e87a 7 * Libav is free software; you can redistribute it and/or
a7129de5
RP
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 *
2912e87a 12 * Libav is distributed in the hope that it will be useful,
a7129de5
RP
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
2912e87a 18 * License along with Libav; if not, write to the Free Software
a7129de5
RP
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"
f3a29b75 27#include "internal.h"
9106a698 28#include "get_bits.h"
fc22c009 29#include "bytestream.h"
a7129de5 30#include "dsputil.h"
a75529e8 31#include "thread.h"
a7129de5
RP
32
33#define MIMIC_HEADER_SIZE 20
34
35typedef struct {
36 AVCodecContext *avctx;
37
38 int num_vblocks[3];
39 int num_hblocks[3];
40
9bf993a5 41 void *swap_buf;
a7129de5
RP
42 int swap_buf_size;
43
44 int cur_index;
45 int prev_index;
46
47 AVFrame buf_ptrs [16];
48 AVPicture flipped_ptrs[16];
49
88bd7fdc 50 DECLARE_ALIGNED(16, int16_t, dct_block)[64];
a7129de5
RP
51
52 GetBitContext gb;
53 ScanTable scantable;
54 DSPContext dsp;
c9108634 55 VLC vlc;
a75529e8
AS
56
57 /* Kept in the context so multithreading can have a constant to read from */
58 int next_cur_index;
59 int next_prev_index;
a7129de5
RP
60} MimicContext;
61
62static const uint32_t huffcodes[] = {
63 0x0000000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
64 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
65 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000000b,
66 0x0000001b, 0x00000038, 0x00000078, 0x00000079, 0x0000007a, 0x000000f9,
67 0x000000fa, 0x000003fb, 0x000007f8, 0x000007f9, 0x000007fa, 0x000007fb,
68 0x00000ff8, 0x00000ff9, 0x00000001, 0x00000039, 0x0000007b, 0x000000fb,
69 0x000001f8, 0x000001f9, 0x00000ffa, 0x00000ffb, 0x00001ff8, 0x00001ff9,
70 0x00001ffa, 0x00001ffb, 0x00003ff8, 0x00003ff9, 0x00003ffa, 0x00000000,
71 0x00000004, 0x0000003a, 0x000001fa, 0x00003ffb, 0x00007ff8, 0x00007ff9,
72 0x00007ffa, 0x00007ffb, 0x0000fff8, 0x0000fff9, 0x0000fffa, 0x0000fffb,
73 0x0001fff8, 0x0001fff9, 0x0001fffa, 0x00000000, 0x0000000c, 0x000000f8,
74 0x000001fb, 0x0001fffb, 0x0003fff8, 0x0003fff9, 0x0003fffa, 0x0003fffb,
75 0x0007fff8, 0x0007fff9, 0x0007fffa, 0x0007fffb, 0x000ffff8, 0x000ffff9,
76 0x000ffffa, 0x00000000, 0x0000001a, 0x000003f8, 0x000ffffb, 0x001ffff8,
77 0x001ffff9, 0x001ffffa, 0x001ffffb, 0x003ffff8, 0x003ffff9, 0x003ffffa,
78 0x003ffffb, 0x007ffff8, 0x007ffff9, 0x007ffffa, 0x007ffffb, 0x00000000,
79 0x0000003b, 0x000003f9, 0x00fffff8, 0x00fffff9, 0x00fffffa, 0x00fffffb,
80 0x01fffff8, 0x01fffff9, 0x01fffffa, 0x01fffffb, 0x03fffff8, 0x03fffff9,
81 0x03fffffa, 0x03fffffb, 0x07fffff8, 0x00000000, 0x000003fa, 0x07fffff9,
82 0x07fffffa, 0x07fffffb, 0x0ffffff8, 0x0ffffff9, 0x0ffffffa, 0x0ffffffb,
83 0x1ffffff8, 0x1ffffff9, 0x1ffffffa, 0x1ffffffb, 0x3ffffff8, 0x3ffffff9,
84 0x3ffffffa,
85};
86
87static const uint8_t huffbits[] = {
88 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
89 0, 0, 0, 0, 2, 4, 5, 6, 7, 7, 7, 8,
90 8, 10, 11, 11, 11, 11, 12, 12, 2, 6, 7, 8,
91 9, 9, 12, 12, 13, 13, 13, 13, 14, 14, 14, 0,
92 3, 6, 9, 14, 15, 15, 15, 15, 16, 16, 16, 16,
93 17, 17, 17, 0, 4, 8, 9, 17, 18, 18, 18, 18,
94 19, 19, 19, 19, 20, 20, 20, 0, 5, 10, 20, 21,
95 21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 0,
96 6, 10, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,
97 26, 26, 27, 0, 10, 27, 27, 27, 28, 28, 28, 28,
98 29, 29, 29, 29, 30, 30, 30,
99};
100
101static const uint8_t col_zag[64] = {
102 0, 8, 1, 2, 9, 16, 24, 17,
103 10, 3, 4, 11, 18, 25, 32, 40,
104 33, 26, 19, 12, 5, 6, 13, 20,
105 27, 34, 41, 48, 56, 49, 42, 35,
106 28, 21, 14, 7, 15, 22, 29, 36,
107 43, 50, 57, 58, 51, 44, 37, 30,
108 23, 31, 38, 45, 52, 59, 39, 46,
399e4652 109 53, 60, 61, 54, 47, 55, 62, 63,
a7129de5
RP
110};
111
98a6fff9 112static av_cold int mimic_decode_init(AVCodecContext *avctx)
a7129de5
RP
113{
114 MimicContext *ctx = avctx->priv_data;
115
116 ctx->prev_index = 0;
a0cabd0a 117 ctx->cur_index = 15;
a7129de5 118
a0cabd0a 119 if (init_vlc(&ctx->vlc, 11, FF_ARRAY_ELEMS(huffbits),
a7129de5
RP
120 huffbits, 1, 1, huffcodes, 4, 4, 0)) {
121 av_log(avctx, AV_LOG_ERROR, "error initializing vlc table\n");
122 return -1;
123 }
9cf0841e 124 ff_dsputil_init(&ctx->dsp, avctx);
a7129de5
RP
125 ff_init_scantable(ctx->dsp.idct_permutation, &ctx->scantable, col_zag);
126
127 return 0;
128}
129
a75529e8
AS
130static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
131{
132 MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
133
a0cabd0a
AK
134 if (avctx == avctx_from)
135 return 0;
a75529e8
AS
136
137 dst->cur_index = src->next_cur_index;
138 dst->prev_index = src->next_prev_index;
139
140 memcpy(dst->buf_ptrs, src->buf_ptrs, sizeof(src->buf_ptrs));
141 memcpy(dst->flipped_ptrs, src->flipped_ptrs, sizeof(src->flipped_ptrs));
142
143 memset(&dst->buf_ptrs[dst->cur_index], 0, sizeof(AVFrame));
144
145 return 0;
146}
147
1bf6e565 148static const int8_t vlcdec_lookup[9][64] = {
a7129de5
RP
149 { 0, },
150 { -1, 1, },
151 { -3, 3, -2, 2, },
152 { -7, 7, -6, 6, -5, 5, -4, 4, },
153 { -15, 15, -14, 14, -13, 13, -12, 12,
154 -11, 11, -10, 10, -9, 9, -8, 8, },
155 { -31, 31, -30, 30, -29, 29, -28, 28,
156 -27, 27, -26, 26, -25, 25, -24, 24,
157 -23, 23, -22, 22, -21, 21, -20, 20,
158 -19, 19, -18, 18, -17, 17, -16, 16, },
159 { -63, 63, -62, 62, -61, 61, -60, 60,
160 -59, 59, -58, 58, -57, 57, -56, 56,
161 -55, 55, -54, 54, -53, 53, -52, 52,
162 -51, 51, -50, 50, -49, 49, -48, 48,
163 -47, 47, -46, 46, -45, 45, -44, 44,
164 -43, 43, -42, 42, -41, 41, -40, 40,
165 -39, 39, -38, 38, -37, 37, -36, 36,
166 -35, 35, -34, 34, -33, 33, -32, 32, },
167 { -127, 127, -126, 126, -125, 125, -124, 124,
168 -123, 123, -122, 122, -121, 121, -120, 120,
169 -119, 119, -118, 118, -117, 117, -116, 116,
170 -115, 115, -114, 114, -113, 113, -112, 112,
171 -111, 111, -110, 110, -109, 109, -108, 108,
172 -107, 107, -106, 106, -105, 105, -104, 104,
173 -103, 103, -102, 102, -101, 101, -100, 100,
174 -99, 99, -98, 98, -97, 97, -96, 96, },
175 { -95, 95, -94, 94, -93, 93, -92, 92,
176 -91, 91, -90, 90, -89, 89, -88, 88,
177 -87, 87, -86, 86, -85, 85, -84, 84,
178 -83, 83, -82, 82, -81, 81, -80, 80,
179 -79, 79, -78, 78, -77, 77, -76, 76,
180 -75, 75, -74, 74, -73, 73, -72, 72,
181 -71, 71, -70, 70, -69, 69, -68, 68,
182 -67, 67, -66, 66, -65, 65, -64, 64, },
183};
184
bebfc16a 185static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
a7129de5 186{
88bd7fdc 187 int16_t *block = ctx->dct_block;
a7129de5
RP
188 unsigned int pos;
189
5fecfb7d 190 ctx->dsp.clear_block(block);
a7129de5
RP
191
192 block[0] = get_bits(&ctx->gb, 8) << 3;
193
a0cabd0a 194 for (pos = 1; pos < num_coeffs; pos++) {
a7129de5
RP
195 uint32_t vlc, num_bits;
196 int value;
197 int coeff;
198
630e1b27 199 vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3);
a0cabd0a 200 if (!vlc) /* end-of-block code */
a7129de5 201 return 1;
a0cabd0a 202 if (vlc == -1)
a7129de5
RP
203 return 0;
204
205 /* pos_add and num_bits are coded in the vlc code */
a0cabd0a
AK
206 pos += vlc & 15; // pos_add
207 num_bits = vlc >> 4; // num_bits
a7129de5 208
a0cabd0a 209 if (pos >= 64)
a7129de5
RP
210 return 0;
211
212 value = get_bits(&ctx->gb, num_bits);
213
6001dad6 214 /* Libav's IDCT behaves somewhat different from the original code, so
a7129de5
RP
215 * a factor of 4 was added to the input */
216
217 coeff = vlcdec_lookup[num_bits][value];
a0cabd0a 218 if (pos < 3)
a7129de5
RP
219 coeff <<= 4;
220 else /* TODO Use >> 10 instead of / 1001 */
221 coeff = (coeff * qscale) / 1001;
222
223 block[ctx->scantable.permutated[pos]] = coeff;
224 }
225
226 return 1;
227}
228
229static int decode(MimicContext *ctx, int quality, int num_coeffs,
230 int is_iframe)
231{
a75529e8 232 int y, x, plane, cur_row = 0;
a7129de5 233
a0cabd0a 234 for (plane = 0; plane < 3; plane++) {
a7129de5 235 const int is_chroma = !!plane;
a0cabd0a
AK
236 const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
237 10000) << 2;
238 const int stride = ctx->flipped_ptrs[ctx->cur_index ].linesize[plane];
239 const uint8_t *src = ctx->flipped_ptrs[ctx->prev_index].data[plane];
240 uint8_t *dst = ctx->flipped_ptrs[ctx->cur_index ].data[plane];
241
242 for (y = 0; y < ctx->num_vblocks[plane]; y++) {
243 for (x = 0; x < ctx->num_hblocks[plane]; x++) {
a7129de5
RP
244 /* Check for a change condition in the current block.
245 * - iframes always change.
246 * - Luma plane changes on get_bits1 == 0
247 * - Chroma planes change on get_bits1 == 1 */
a0cabd0a 248 if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
a7129de5
RP
249 /* Luma planes may use a backreference from the 15 last
250 * frames preceding the previous. (get_bits1 == 1)
251 * Chroma planes don't use backreferences. */
a0cabd0a
AK
252 if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
253 if (!vlc_decode_block(ctx, num_coeffs, qscale))
a7129de5
RP
254 return 0;
255 ctx->dsp.idct_put(dst, stride, ctx->dct_block);
256 } else {
257 unsigned int backref = get_bits(&ctx->gb, 4);
a0cabd0a
AK
258 int index = (ctx->cur_index + backref) & 15;
259 uint8_t *p = ctx->flipped_ptrs[index].data[0];
a7129de5 260
80387f0e 261 if (index != ctx->cur_index && p) {
a0cabd0a
AK
262 ff_thread_await_progress(&ctx->buf_ptrs[index],
263 cur_row, 0);
a7129de5 264 p += src -
a0cabd0a 265 ctx->flipped_ptrs[ctx->prev_index].data[plane];
a7129de5
RP
266 ctx->dsp.put_pixels_tab[1][0](dst, p, stride, 8);
267 } else {
268 av_log(ctx->avctx, AV_LOG_ERROR,
269 "No such backreference! Buggy sample.\n");
270 }
271 }
272 } else {
a0cabd0a
AK
273 ff_thread_await_progress(&ctx->buf_ptrs[ctx->prev_index],
274 cur_row, 0);
a7129de5
RP
275 ctx->dsp.put_pixels_tab[1][0](dst, src, stride, 8);
276 }
277 src += 8;
278 dst += 8;
279 }
a0cabd0a
AK
280 src += (stride - ctx->num_hblocks[plane]) << 3;
281 dst += (stride - ctx->num_hblocks[plane]) << 3;
a75529e8 282
a0cabd0a
AK
283 ff_thread_report_progress(&ctx->buf_ptrs[ctx->cur_index],
284 cur_row++, 0);
a7129de5
RP
285 }
286 }
287
288 return 1;
289}
290
291/**
292 * Flip the buffer upside-down and put it in the YVU order to match the
293 * way Mimic encodes frames.
294 */
295static void prepare_avpic(MimicContext *ctx, AVPicture *dst, AVPicture *src)
296{
297 int i;
a0cabd0a
AK
298 dst->data[0] = src->data[0] + ( ctx->avctx->height - 1) * src->linesize[0];
299 dst->data[1] = src->data[2] + ((ctx->avctx->height >> 1) - 1) * src->linesize[2];
300 dst->data[2] = src->data[1] + ((ctx->avctx->height >> 1) - 1) * src->linesize[1];
301 for (i = 0; i < 3; i++)
a7129de5
RP
302 dst->linesize[i] = -src->linesize[i];
303}
304
305static int mimic_decode_frame(AVCodecContext *avctx, void *data,
df9b9567 306 int *got_frame, AVPacket *avpkt)
a7129de5 307{
7a00bbad 308 const uint8_t *buf = avpkt->data;
a0cabd0a
AK
309 int buf_size = avpkt->size;
310 int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;
311 MimicContext *ctx = avctx->priv_data;
dba425ad 312 GetByteContext gb;
a7129de5
RP
313 int is_pframe;
314 int width, height;
315 int quality, num_coeffs;
80387f0e 316 int res;
a7129de5 317
33c5c3ad 318 if (buf_size <= MIMIC_HEADER_SIZE) {
a7129de5
RP
319 av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
320 return -1;
321 }
322
dba425ad
PM
323 bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);
324 bytestream2_skip(&gb, 2); /* some constant (always 256) */
325 quality = bytestream2_get_le16u(&gb);
326 width = bytestream2_get_le16u(&gb);
327 height = bytestream2_get_le16u(&gb);
328 bytestream2_skip(&gb, 4); /* some constant */
329 is_pframe = bytestream2_get_le32u(&gb);
330 num_coeffs = bytestream2_get_byteu(&gb);
331 bytestream2_skip(&gb, 3); /* some constant */
a7129de5 332
a0cabd0a 333 if (!ctx->avctx) {
a7129de5
RP
334 int i;
335
a0cabd0a
AK
336 if (!(width == 160 && height == 120) &&
337 !(width == 320 && height == 240)) {
a7129de5
RP
338 av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
339 return -1;
340 }
341
342 ctx->avctx = avctx;
343 avctx->width = width;
344 avctx->height = height;
716d413c 345 avctx->pix_fmt = AV_PIX_FMT_YUV420P;
a0cabd0a 346 for (i = 0; i < 3; i++) {
a7129de5 347 ctx->num_vblocks[i] = -((-height) >> (3 + !!i));
a0cabd0a 348 ctx->num_hblocks[i] = width >> (3 + !!i);
a7129de5 349 }
a0cabd0a 350 } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
a7129de5
RP
351 av_log(avctx, AV_LOG_ERROR, "resolution changing is not supported\n");
352 return -1;
353 }
354
a0cabd0a 355 if (is_pframe && !ctx->buf_ptrs[ctx->prev_index].data[0]) {
a7129de5
RP
356 av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
357 return -1;
358 }
359
360 ctx->buf_ptrs[ctx->cur_index].reference = 1;
a0cabd0a
AK
361 ctx->buf_ptrs[ctx->cur_index].pict_type = is_pframe ? AV_PICTURE_TYPE_P :
362 AV_PICTURE_TYPE_I;
363 if (ff_thread_get_buffer(avctx, &ctx->buf_ptrs[ctx->cur_index])) {
a7129de5
RP
364 av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
365 return -1;
366 }
367
a75529e8
AS
368 ctx->next_prev_index = ctx->cur_index;
369 ctx->next_cur_index = (ctx->cur_index - 1) & 15;
370
a7129de5
RP
371 prepare_avpic(ctx, &ctx->flipped_ptrs[ctx->cur_index],
372 (AVPicture*) &ctx->buf_ptrs[ctx->cur_index]);
373
a75529e8
AS
374 ff_thread_finish_setup(avctx);
375
c15fea79 376 av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
a0cabd0a 377 if (!ctx->swap_buf)
55775b09 378 return AVERROR(ENOMEM);
a7129de5 379
9bf993a5 380 ctx->dsp.bswap_buf(ctx->swap_buf,
a0cabd0a
AK
381 (const uint32_t*) (buf + MIMIC_HEADER_SIZE),
382 swap_buf_size >> 2);
a7129de5
RP
383 init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
384
80387f0e
RB
385 res = decode(ctx, quality, num_coeffs, !is_pframe);
386 ff_thread_report_progress(&ctx->buf_ptrs[ctx->cur_index], INT_MAX, 0);
387 if (!res) {
388 if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
a75529e8
AS
389 ff_thread_release_buffer(avctx, &ctx->buf_ptrs[ctx->cur_index]);
390 return -1;
391 }
a7129de5
RP
392 }
393
a7129de5 394 *(AVFrame*)data = ctx->buf_ptrs[ctx->cur_index];
df9b9567 395 *got_frame = 1;
a7129de5 396
a75529e8
AS
397 ctx->prev_index = ctx->next_prev_index;
398 ctx->cur_index = ctx->next_cur_index;
a7129de5
RP
399
400 /* Only release frames that aren't used for backreferences anymore */
a0cabd0a 401 if (ctx->buf_ptrs[ctx->cur_index].data[0])
a75529e8 402 ff_thread_release_buffer(avctx, &ctx->buf_ptrs[ctx->cur_index]);
a7129de5
RP
403
404 return buf_size;
405}
406
98a6fff9 407static av_cold int mimic_decode_end(AVCodecContext *avctx)
a7129de5
RP
408{
409 MimicContext *ctx = avctx->priv_data;
410 int i;
411
412 av_free(ctx->swap_buf);
a75529e8 413
f3a29b75
JR
414 if (avctx->internal->is_copy)
415 return 0;
a75529e8 416
a0cabd0a
AK
417 for (i = 0; i < 16; i++)
418 if (ctx->buf_ptrs[i].data[0])
a75529e8 419 ff_thread_release_buffer(avctx, &ctx->buf_ptrs[i]);
e96b4a53 420 ff_free_vlc(&ctx->vlc);
a7129de5
RP
421
422 return 0;
423}
424
d36beb3f 425AVCodec ff_mimic_decoder = {
00c3b67b
MS
426 .name = "mimic",
427 .type = AVMEDIA_TYPE_VIDEO,
36ef5369 428 .id = AV_CODEC_ID_MIMIC,
00c3b67b
MS
429 .priv_data_size = sizeof(MimicContext),
430 .init = mimic_decode_init,
431 .close = mimic_decode_end,
432 .decode = mimic_decode_frame,
433 .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
434 .long_name = NULL_IF_CONFIG_SMALL("Mimic"),
a75529e8 435 .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context)
a7129de5 436};