lavc: Add per-thread surfaces in get_hw_frame_parameters()
[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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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 "bitstream.h"
28 #include "blockdsp.h"
29 #include "internal.h"
30 #include "bytestream.h"
31 #include "bswapdsp.h"
32 #include "hpeldsp.h"
33 #include "idctdsp.h"
34 #include "thread.h"
35 #include "vlc.h"
36
37 #define MIMIC_HEADER_SIZE   20
38
39 typedef struct MimicContext {
40     AVCodecContext *avctx;
41
42     int             num_vblocks[3];
43     int             num_hblocks[3];
44
45     void           *swap_buf;
46     int             swap_buf_size;
47
48     int             cur_index;
49     int             prev_index;
50
51     ThreadFrame     frames     [16];
52
53     DECLARE_ALIGNED(16, int16_t, dct_block)[64];
54
55     BitstreamContext bc;
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_free(ctx->swap_buf);
124
125     for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
126         if (ctx->frames[i].f)
127             ff_thread_release_buffer(avctx, &ctx->frames[i]);
128         av_frame_free(&ctx->frames[i].f);
129     }
130
131     if (!avctx->internal->is_copy)
132         ff_free_vlc(&ctx->vlc);
133
134     return 0;
135 }
136
137 static av_cold int mimic_decode_init(AVCodecContext *avctx)
138 {
139     MimicContext *ctx = avctx->priv_data;
140     int ret, i;
141
142     avctx->internal->allocate_progress = 1;
143
144     ctx->prev_index = 0;
145     ctx->cur_index  = 15;
146
147     if ((ret = init_vlc(&ctx->vlc, 11, FF_ARRAY_ELEMS(huffbits),
148                         huffbits, 1, 1, huffcodes, 4, 4, 0)) < 0) {
149         av_log(avctx, AV_LOG_ERROR, "error initializing vlc table\n");
150         return ret;
151     }
152     ff_blockdsp_init(&ctx->bdsp);
153     ff_bswapdsp_init(&ctx->bbdsp);
154     ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
155     ff_idctdsp_init(&ctx->idsp, avctx);
156     ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, col_zag);
157
158     for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
159         ctx->frames[i].f = av_frame_alloc();
160         if (!ctx->frames[i].f) {
161             mimic_decode_end(avctx);
162             return AVERROR(ENOMEM);
163         }
164     }
165
166     return 0;
167 }
168
169 static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
170 {
171     MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
172     int i, ret;
173
174     if (avctx == avctx_from)
175         return 0;
176
177     dst->cur_index  = src->next_cur_index;
178     dst->prev_index = src->next_prev_index;
179
180     for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
181         ff_thread_release_buffer(avctx, &dst->frames[i]);
182         if (src->frames[i].f->data[0]) {
183             ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
184             if (ret < 0)
185                 return ret;
186         }
187     }
188
189     return 0;
190 }
191
192 static const int8_t vlcdec_lookup[9][64] = {
193     {    0, },
194     {   -1,   1, },
195     {   -3,   3,   -2,   2, },
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, },
227 };
228
229 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
230 {
231     int16_t *block = ctx->dct_block;
232     unsigned int pos;
233
234     ctx->bdsp.clear_block(block);
235
236     block[0] = bitstream_read(&ctx->bc, 8) << 3;
237
238     for (pos = 1; pos < num_coeffs; pos++) {
239         uint32_t vlc, num_bits;
240         int value;
241         int coeff;
242
243         vlc = bitstream_read_vlc(&ctx->bc, ctx->vlc.table, ctx->vlc.bits, 3);
244         if (!vlc) /* end-of-block code */
245             return 0;
246         if (vlc == -1)
247             return AVERROR_INVALIDDATA;
248
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
252
253         if (pos >= 64)
254             return AVERROR_INVALIDDATA;
255
256         value = bitstream_read(&ctx->bc, num_bits);
257
258         /* Libav's IDCT behaves somewhat different from the original code, so
259          * a factor of 4 was added to the input */
260
261         coeff = vlcdec_lookup[num_bits][value];
262         if (pos < 3)
263             coeff <<= 4;
264         else /* TODO Use >> 10 instead of / 1001 */
265             coeff = (coeff * qscale) / 1001;
266
267         block[ctx->scantable.permutated[pos]] = coeff;
268     }
269
270     return 0;
271 }
272
273 static int decode(MimicContext *ctx, int quality, int num_coeffs,
274                   int is_iframe)
275 {
276     int ret, y, x, plane, cur_row = 0;
277
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,
281                                       10000) << 2;
282         const int stride    = ctx->frames[ctx->cur_index ].f->linesize[plane];
283         const uint8_t *src  = ctx->frames[ctx->prev_index].f->data[plane];
284         uint8_t       *dst  = ctx->frames[ctx->cur_index ].f->data[plane];
285
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 bitstream_read_bit == 0
291                  * - Chroma planes change on bitstream_read_bit == 1 */
292                 if (is_iframe || bitstream_read_bit(&ctx->bc) == is_chroma) {
293                     /* Luma planes may use a backreference from the 15 last
294                      * frames preceding the previous. (bitstream_read_bit == 1)
295                      * Chroma planes don't use backreferences. */
296                     if (is_chroma || is_iframe || !bitstream_read_bit(&ctx->bc)) {
297                         if ((ret = vlc_decode_block(ctx, num_coeffs,
298                                                     qscale)) < 0) {
299                             av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
300                                    "block.\n");
301                             return ret;
302                         }
303                         ctx->idsp.idct_put(dst, stride, ctx->dct_block);
304                     } else {
305                         unsigned int backref = bitstream_read(&ctx->bc, 4);
306                         int index            = (ctx->cur_index + backref) & 15;
307                         uint8_t *p           = ctx->frames[index].f->data[0];
308
309                         if (index != ctx->cur_index && p) {
310                             ff_thread_await_progress(&ctx->frames[index],
311                                                      cur_row, 0);
312                             p += src -
313                                  ctx->frames[ctx->prev_index].f->data[plane];
314                             ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
315                         } else {
316                             av_log(ctx->avctx, AV_LOG_ERROR,
317                                      "No such backreference! Buggy sample.\n");
318                         }
319                     }
320                 } else {
321                     ff_thread_await_progress(&ctx->frames[ctx->prev_index],
322                                              cur_row, 0);
323                     ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
324                 }
325                 src += 8;
326                 dst += 8;
327             }
328             src += (stride - ctx->num_hblocks[plane]) << 3;
329             dst += (stride - ctx->num_hblocks[plane]) << 3;
330
331             ff_thread_report_progress(&ctx->frames[ctx->cur_index],
332                                       cur_row++, 0);
333         }
334     }
335
336     return 0;
337 }
338
339 /**
340  * Flip the buffer upside-down and put it in the YVU order to revert the
341  * way Mimic encodes frames.
342  */
343 static void flip_swap_frame(AVFrame *f)
344 {
345     int i;
346     uint8_t *data_1 = f->data[1];
347     f->data[0] = f->data[0] + ( f->height       - 1) * f->linesize[0];
348     f->data[1] = f->data[2] + ((f->height >> 1) - 1) * f->linesize[2];
349     f->data[2] = data_1     + ((f->height >> 1) - 1) * f->linesize[1];
350     for (i = 0; i < 3; i++)
351         f->linesize[i] *= -1;
352 }
353
354 static int mimic_decode_frame(AVCodecContext *avctx, void *data,
355                               int *got_frame, AVPacket *avpkt)
356 {
357     const uint8_t *buf = avpkt->data;
358     int buf_size       = avpkt->size;
359     int swap_buf_size  = buf_size - MIMIC_HEADER_SIZE;
360     MimicContext *ctx  = avctx->priv_data;
361     GetByteContext gb;
362     int is_pframe;
363     int width, height;
364     int quality, num_coeffs;
365     int res;
366
367     if (buf_size <= MIMIC_HEADER_SIZE) {
368         av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
369         return AVERROR_INVALIDDATA;
370     }
371
372     bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);
373     bytestream2_skip(&gb, 2); /* some constant (always 256) */
374     quality    = bytestream2_get_le16u(&gb);
375     width      = bytestream2_get_le16u(&gb);
376     height     = bytestream2_get_le16u(&gb);
377     bytestream2_skip(&gb, 4); /* some constant */
378     is_pframe  = bytestream2_get_le32u(&gb);
379     num_coeffs = bytestream2_get_byteu(&gb);
380     bytestream2_skip(&gb, 3); /* some constant */
381
382     if (!ctx->avctx) {
383         int i;
384
385         if (!(width == 160 && height == 120) &&
386             !(width == 320 && height == 240)) {
387             av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
388             return AVERROR_INVALIDDATA;
389         }
390
391         ctx->avctx     = avctx;
392         avctx->width   = width;
393         avctx->height  = height;
394         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
395         for (i = 0; i < 3; i++) {
396             ctx->num_vblocks[i] = AV_CEIL_RSHIFT(height,   3 + !!i);
397             ctx->num_hblocks[i] =                width >> (3 + !!i);
398         }
399     } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
400         avpriv_request_sample(avctx, "Resolution changing");
401         return AVERROR_PATCHWELCOME;
402     }
403
404     if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
405         av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
406         return AVERROR_INVALIDDATA;
407     }
408
409     ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
410     ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
411                                                            AV_PICTURE_TYPE_I;
412     if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
413                                     AV_GET_BUFFER_FLAG_REF)) < 0) {
414         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
415         return res;
416     }
417
418     ctx->next_prev_index = ctx->cur_index;
419     ctx->next_cur_index  = (ctx->cur_index - 1) & 15;
420
421     ff_thread_finish_setup(avctx);
422
423     av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
424     if (!ctx->swap_buf)
425         return AVERROR(ENOMEM);
426
427     ctx->bbdsp.bswap_buf(ctx->swap_buf,
428                          (const uint32_t *) (buf + MIMIC_HEADER_SIZE),
429                          swap_buf_size >> 2);
430     bitstream_init8(&ctx->bc, ctx->swap_buf, swap_buf_size);
431
432     res = decode(ctx, quality, num_coeffs, !is_pframe);
433     ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
434     if (res < 0) {
435         if (!(avctx->active_thread_type & FF_THREAD_FRAME))
436             ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
437         return res;
438     }
439
440     if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0)
441         return res;
442     *got_frame      = 1;
443
444     flip_swap_frame(data);
445
446     ctx->prev_index = ctx->next_prev_index;
447     ctx->cur_index  = ctx->next_cur_index;
448
449     return buf_size;
450 }
451
452 static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
453 {
454     MimicContext *ctx = avctx->priv_data;
455     int i;
456
457     for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
458         ctx->frames[i].f = av_frame_alloc();
459         if (!ctx->frames[i].f) {
460             mimic_decode_end(avctx);
461             return AVERROR(ENOMEM);
462         }
463     }
464
465     return 0;
466 }
467
468 AVCodec ff_mimic_decoder = {
469     .name                  = "mimic",
470     .long_name             = NULL_IF_CONFIG_SMALL("Mimic"),
471     .type                  = AVMEDIA_TYPE_VIDEO,
472     .id                    = AV_CODEC_ID_MIMIC,
473     .priv_data_size        = sizeof(MimicContext),
474     .init                  = mimic_decode_init,
475     .close                 = mimic_decode_end,
476     .decode                = mimic_decode_frame,
477     .capabilities          = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
478     .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context),
479     .init_thread_copy      = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy),
480 };