avcodec: use HAVE_THREADS header guards to silence -Wunused-function
[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 #if HAVE_THREADS
171 static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
172 {
173     MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
174     int i, ret;
175
176     if (avctx == avctx_from)
177         return 0;
178
179     dst->cur_index  = src->next_cur_index;
180     dst->prev_index = src->next_prev_index;
181
182     memcpy(dst->flipped_ptrs, src->flipped_ptrs, sizeof(src->flipped_ptrs));
183
184     for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
185         ff_thread_release_buffer(avctx, &dst->frames[i]);
186         if (i != src->next_cur_index && src->frames[i].f->data[0]) {
187             ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
188             if (ret < 0)
189                 return ret;
190         }
191     }
192
193     return 0;
194 }
195 #endif
196
197 static const int8_t vlcdec_lookup[9][64] = {
198     {    0, },
199     {   -1,   1, },
200     {   -3,   3,   -2,   2, },
201     {   -7,   7,   -6,   6,   -5,   5,   -4,   4, },
202     {  -15,  15,  -14,  14,  -13,  13,  -12,  12,
203        -11,  11,  -10,  10,   -9,   9,   -8,   8, },
204     {  -31,  31,  -30,  30,  -29,  29,  -28,  28,
205        -27,  27,  -26,  26,  -25,  25,  -24,  24,
206        -23,  23,  -22,  22,  -21,  21,  -20,  20,
207        -19,  19,  -18,  18,  -17,  17,  -16,  16, },
208     {  -63,  63,  -62,  62,  -61,  61,  -60,  60,
209        -59,  59,  -58,  58,  -57,  57,  -56,  56,
210        -55,  55,  -54,  54,  -53,  53,  -52,  52,
211        -51,  51,  -50,  50,  -49,  49,  -48,  48,
212        -47,  47,  -46,  46,  -45,  45,  -44,  44,
213        -43,  43,  -42,  42,  -41,  41,  -40,  40,
214        -39,  39,  -38,  38,  -37,  37,  -36,  36,
215        -35,  35,  -34,  34,  -33,  33,  -32,  32, },
216     { -127, 127, -126, 126, -125, 125, -124, 124,
217       -123, 123, -122, 122, -121, 121, -120, 120,
218       -119, 119, -118, 118, -117, 117, -116, 116,
219       -115, 115, -114, 114, -113, 113, -112, 112,
220       -111, 111, -110, 110, -109, 109, -108, 108,
221       -107, 107, -106, 106, -105, 105, -104, 104,
222       -103, 103, -102, 102, -101, 101, -100, 100,
223        -99,  99,  -98,  98,  -97,  97,  -96,  96, },
224     {  -95,  95,  -94,  94,  -93,  93,  -92,  92,
225        -91,  91,  -90,  90,  -89,  89,  -88,  88,
226        -87,  87,  -86,  86,  -85,  85,  -84,  84,
227        -83,  83,  -82,  82,  -81,  81,  -80,  80,
228        -79,  79,  -78,  78,  -77,  77,  -76,  76,
229        -75,  75,  -74,  74,  -73,  73,  -72,  72,
230        -71,  71,  -70,  70,  -69,  69,  -68,  68,
231        -67,  67,  -66,  66,  -65,  65,  -64,  64, },
232 };
233
234 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
235 {
236     int16_t *block = ctx->dct_block;
237     unsigned int pos;
238
239     ctx->bdsp.clear_block(block);
240
241     block[0] = get_bits(&ctx->gb, 8) << 3;
242
243     for (pos = 1; pos < num_coeffs; pos++) {
244         uint32_t vlc, num_bits;
245         int value;
246         int coeff;
247
248         vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3);
249         if (!vlc) /* end-of-block code */
250             return 0;
251         if (vlc == -1)
252             return AVERROR_INVALIDDATA;
253
254         /* pos_add and num_bits are coded in the vlc code */
255         pos     += vlc & 15; // pos_add
256         num_bits = vlc >> 4; // num_bits
257
258         if (pos >= 64)
259             return AVERROR_INVALIDDATA;
260
261         value = get_bits(&ctx->gb, num_bits);
262
263         /* FFmpeg's IDCT behaves somewhat different from the original code, so
264          * a factor of 4 was added to the input */
265
266         coeff = vlcdec_lookup[num_bits][value];
267         if (pos < 3)
268             coeff <<= 4;
269         else /* TODO Use >> 10 instead of / 1001 */
270             coeff = (coeff * qscale) / 1001;
271
272         block[ctx->scantable.permutated[pos]] = coeff;
273     }
274
275     return 0;
276 }
277
278 static int decode(MimicContext *ctx, int quality, int num_coeffs,
279                   int is_iframe)
280 {
281     int ret, y, x, plane, cur_row = 0;
282
283     for (plane = 0; plane < 3; plane++) {
284         const int is_chroma = !!plane;
285         const int qscale    = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
286                                       10000) << 2;
287         const int stride    = ctx->flipped_ptrs[ctx->cur_index ].linesize[plane];
288         const uint8_t *src  = ctx->flipped_ptrs[ctx->prev_index].data[plane];
289         uint8_t       *dst  = ctx->flipped_ptrs[ctx->cur_index ].data[plane];
290
291         for (y = 0; y < ctx->num_vblocks[plane]; y++) {
292             for (x = 0; x < ctx->num_hblocks[plane]; x++) {
293                 /* Check for a change condition in the current block.
294                  * - iframes always change.
295                  * - Luma plane changes on get_bits1 == 0
296                  * - Chroma planes change on get_bits1 == 1 */
297                 if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
298                     /* Luma planes may use a backreference from the 15 last
299                      * frames preceding the previous. (get_bits1 == 1)
300                      * Chroma planes don't use backreferences. */
301                     if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
302                         if ((ret = vlc_decode_block(ctx, num_coeffs,
303                                                     qscale)) < 0) {
304                             av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
305                                    "block.\n");
306                             return ret;
307                         }
308                         ctx->idsp.idct_put(dst, stride, ctx->dct_block);
309                     } else {
310                         unsigned int backref = get_bits(&ctx->gb, 4);
311                         int index            = (ctx->cur_index + backref) & 15;
312                         uint8_t *p           = ctx->flipped_ptrs[index].data[0];
313
314                         if (index != ctx->cur_index && p) {
315                             ff_thread_await_progress(&ctx->frames[index],
316                                                      cur_row, 0);
317                             p += src -
318                                  ctx->flipped_ptrs[ctx->prev_index].data[plane];
319                             ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
320                         } else {
321                             av_log(ctx->avctx, AV_LOG_ERROR,
322                                      "No such backreference! Buggy sample.\n");
323                         }
324                     }
325                 } else {
326                     ff_thread_await_progress(&ctx->frames[ctx->prev_index],
327                                              cur_row, 0);
328                     ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
329                 }
330                 src += 8;
331                 dst += 8;
332             }
333             src += (stride - ctx->num_hblocks[plane]) << 3;
334             dst += (stride - ctx->num_hblocks[plane]) << 3;
335
336             ff_thread_report_progress(&ctx->frames[ctx->cur_index],
337                                       cur_row++, 0);
338         }
339     }
340
341     return 0;
342 }
343
344 /**
345  * Flip the buffer upside-down and put it in the YVU order to match the
346  * way Mimic encodes frames.
347  */
348 static void prepare_avpic(MimicContext *ctx, AVPicture *dst, AVFrame *src)
349 {
350     int i;
351     dst->data[0] = src->data[0] + ( ctx->avctx->height       - 1) * src->linesize[0];
352     dst->data[1] = src->data[2] + ((ctx->avctx->height >> 1) - 1) * src->linesize[2];
353     dst->data[2] = src->data[1] + ((ctx->avctx->height >> 1) - 1) * src->linesize[1];
354     for (i = 0; i < 3; i++)
355         dst->linesize[i] = -src->linesize[i];
356 }
357
358 static int mimic_decode_frame(AVCodecContext *avctx, void *data,
359                               int *got_frame, AVPacket *avpkt)
360 {
361     const uint8_t *buf = avpkt->data;
362     int buf_size       = avpkt->size;
363     int swap_buf_size  = buf_size - MIMIC_HEADER_SIZE;
364     MimicContext *ctx  = avctx->priv_data;
365     GetByteContext gb;
366     int is_pframe;
367     int width, height;
368     int quality, num_coeffs;
369     int res;
370
371     if (buf_size <= MIMIC_HEADER_SIZE) {
372         av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
373         return AVERROR_INVALIDDATA;
374     }
375
376     bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);
377     bytestream2_skip(&gb, 2); /* some constant (always 256) */
378     quality    = bytestream2_get_le16u(&gb);
379     width      = bytestream2_get_le16u(&gb);
380     height     = bytestream2_get_le16u(&gb);
381     bytestream2_skip(&gb, 4); /* some constant */
382     is_pframe  = bytestream2_get_le32u(&gb);
383     num_coeffs = bytestream2_get_byteu(&gb);
384     bytestream2_skip(&gb, 3); /* some constant */
385
386     if (!ctx->avctx) {
387         int i;
388
389         if (!(width == 160 && height == 120) &&
390             !(width == 320 && height == 240)) {
391             av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
392             return AVERROR_INVALIDDATA;
393         }
394
395         ctx->avctx     = avctx;
396         avctx->width   = width;
397         avctx->height  = height;
398         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
399         for (i = 0; i < 3; i++) {
400             ctx->num_vblocks[i] = FF_CEIL_RSHIFT(height,   3 + !!i);
401             ctx->num_hblocks[i] =                width >> (3 + !!i);
402         }
403     } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
404         avpriv_request_sample(avctx, "Resolution changing");
405         return AVERROR_PATCHWELCOME;
406     }
407
408     if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
409         av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
410         return AVERROR_INVALIDDATA;
411     }
412
413     ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
414     ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
415                                                            AV_PICTURE_TYPE_I;
416     if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
417                                     AV_GET_BUFFER_FLAG_REF)) < 0)
418         return res;
419
420     ctx->next_prev_index = ctx->cur_index;
421     ctx->next_cur_index  = (ctx->cur_index - 1) & 15;
422
423     prepare_avpic(ctx, &ctx->flipped_ptrs[ctx->cur_index],
424                   ctx->frames[ctx->cur_index].f);
425
426     ff_thread_finish_setup(avctx);
427
428     av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
429     if (!ctx->swap_buf)
430         return AVERROR(ENOMEM);
431
432     ctx->bbdsp.bswap_buf(ctx->swap_buf,
433                          (const uint32_t *) (buf + MIMIC_HEADER_SIZE),
434                          swap_buf_size >> 2);
435     init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
436
437     res = decode(ctx, quality, num_coeffs, !is_pframe);
438     ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
439     if (res < 0) {
440         if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
441             ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
442             return res;
443         }
444     }
445
446     if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0)
447         return res;
448     *got_frame      = 1;
449
450     ctx->prev_index = ctx->next_prev_index;
451     ctx->cur_index  = ctx->next_cur_index;
452
453     /* Only release frames that aren't used for backreferences anymore */
454     ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
455
456     return buf_size;
457 }
458
459 #if HAVE_THREADS
460 static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
461 {
462     MimicContext *ctx = avctx->priv_data;
463     int i;
464
465     for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
466         ctx->frames[i].f = av_frame_alloc();
467         if (!ctx->frames[i].f) {
468             mimic_decode_end(avctx);
469             return AVERROR(ENOMEM);
470         }
471     }
472
473     return 0;
474 }
475 #endif
476
477 AVCodec ff_mimic_decoder = {
478     .name                  = "mimic",
479     .long_name             = NULL_IF_CONFIG_SMALL("Mimic"),
480     .type                  = AVMEDIA_TYPE_VIDEO,
481     .id                    = AV_CODEC_ID_MIMIC,
482     .priv_data_size        = sizeof(MimicContext),
483     .init                  = mimic_decode_init,
484     .close                 = mimic_decode_end,
485     .decode                = mimic_decode_frame,
486     .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
487     .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context),
488     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy),
489 };