f5853b5c48fad715ee5a72f806a71e666753198a
[ffmpeg.git] / libavcodec / mimic.c
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
38 typedef struct MimicContext {
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
68 static 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
93 static 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
107 static 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
118 static 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
138 static 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
170 static 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
195 static 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
232 static 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
276 static 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  */
346 static 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
356 static 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
457 static 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
473 AVCodec 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          = AV_CODEC_CAP_DR1 | AV_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 };