FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
mimic.c
Go to the documentation of this file.
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 {
40 
41  int num_vblocks[3];
42  int num_hblocks[3];
43 
44  void *swap_buf;
46 
47  int cur_index;
49 
50  ThreadFrame frames [16];
51  AVPicture flipped_ptrs[16];
52 
53  DECLARE_ALIGNED(16, int16_t, dct_block)[64];
54 
62 
63  /* Kept in the context so multithreading can have a constant to read from */
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 
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 
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);
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 
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 {
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 
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 :
414  if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
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 
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 
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),
480  .close = mimic_decode_end,
482  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
484  .init_thread_copy = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy),
485 };