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