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 MimicContext {
40 
41  int num_vblocks[3];
42  int num_hblocks[3];
43 
44  void *swap_buf;
46 
47  int cur_index;
49 
51 
52  DECLARE_ALIGNED(16, int16_t, dct_block)[64];
53 
61 
62  /* Kept in the context so multithreading can have a constant to read from */
65 } MimicContext;
66 
67 static const uint32_t huffcodes[] = {
68  0x0000000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
69  0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
70  0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000000b,
71  0x0000001b, 0x00000038, 0x00000078, 0x00000079, 0x0000007a, 0x000000f9,
72  0x000000fa, 0x000003fb, 0x000007f8, 0x000007f9, 0x000007fa, 0x000007fb,
73  0x00000ff8, 0x00000ff9, 0x00000001, 0x00000039, 0x0000007b, 0x000000fb,
74  0x000001f8, 0x000001f9, 0x00000ffa, 0x00000ffb, 0x00001ff8, 0x00001ff9,
75  0x00001ffa, 0x00001ffb, 0x00003ff8, 0x00003ff9, 0x00003ffa, 0x00000000,
76  0x00000004, 0x0000003a, 0x000001fa, 0x00003ffb, 0x00007ff8, 0x00007ff9,
77  0x00007ffa, 0x00007ffb, 0x0000fff8, 0x0000fff9, 0x0000fffa, 0x0000fffb,
78  0x0001fff8, 0x0001fff9, 0x0001fffa, 0x00000000, 0x0000000c, 0x000000f8,
79  0x000001fb, 0x0001fffb, 0x0003fff8, 0x0003fff9, 0x0003fffa, 0x0003fffb,
80  0x0007fff8, 0x0007fff9, 0x0007fffa, 0x0007fffb, 0x000ffff8, 0x000ffff9,
81  0x000ffffa, 0x00000000, 0x0000001a, 0x000003f8, 0x000ffffb, 0x001ffff8,
82  0x001ffff9, 0x001ffffa, 0x001ffffb, 0x003ffff8, 0x003ffff9, 0x003ffffa,
83  0x003ffffb, 0x007ffff8, 0x007ffff9, 0x007ffffa, 0x007ffffb, 0x00000000,
84  0x0000003b, 0x000003f9, 0x00fffff8, 0x00fffff9, 0x00fffffa, 0x00fffffb,
85  0x01fffff8, 0x01fffff9, 0x01fffffa, 0x01fffffb, 0x03fffff8, 0x03fffff9,
86  0x03fffffa, 0x03fffffb, 0x07fffff8, 0x00000000, 0x000003fa, 0x07fffff9,
87  0x07fffffa, 0x07fffffb, 0x0ffffff8, 0x0ffffff9, 0x0ffffffa, 0x0ffffffb,
88  0x1ffffff8, 0x1ffffff9, 0x1ffffffa, 0x1ffffffb, 0x3ffffff8, 0x3ffffff9,
89  0x3ffffffa,
90 };
91 
92 static const uint8_t huffbits[] = {
93  4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
94  0, 0, 0, 0, 2, 4, 5, 6, 7, 7, 7, 8,
95  8, 10, 11, 11, 11, 11, 12, 12, 2, 6, 7, 8,
96  9, 9, 12, 12, 13, 13, 13, 13, 14, 14, 14, 0,
97  3, 6, 9, 14, 15, 15, 15, 15, 16, 16, 16, 16,
98  17, 17, 17, 0, 4, 8, 9, 17, 18, 18, 18, 18,
99  19, 19, 19, 19, 20, 20, 20, 0, 5, 10, 20, 21,
100  21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 0,
101  6, 10, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,
102  26, 26, 27, 0, 10, 27, 27, 27, 28, 28, 28, 28,
103  29, 29, 29, 29, 30, 30, 30,
104 };
105 
106 static const uint8_t col_zag[64] = {
107  0, 8, 1, 2, 9, 16, 24, 17,
108  10, 3, 4, 11, 18, 25, 32, 40,
109  33, 26, 19, 12, 5, 6, 13, 20,
110  27, 34, 41, 48, 56, 49, 42, 35,
111  28, 21, 14, 7, 15, 22, 29, 36,
112  43, 50, 57, 58, 51, 44, 37, 30,
113  23, 31, 38, 45, 52, 59, 39, 46,
114  53, 60, 61, 54, 47, 55, 62, 63,
115 };
116 
118 {
119  MimicContext *ctx = avctx->priv_data;
120  int i;
121 
122  av_freep(&ctx->swap_buf);
123  ctx->swap_buf_size = 0;
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 
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, avctx);
153  ff_bswapdsp_init(&ctx->bbdsp);
154  ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
155  ff_idctdsp_init(&ctx->idsp, avctx);
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 #if HAVE_THREADS
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  for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
182  ff_thread_release_buffer(avctx, &dst->frames[i]);
183  if (i != src->next_cur_index && src->frames[i].f->data[0]) {
184  ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
185  if (ret < 0)
186  return ret;
187  }
188  }
189 
190  return 0;
191 }
192 #endif
193 
194 static const int8_t vlcdec_lookup[9][64] = {
195  { 0, },
196  { -1, 1, },
197  { -3, 3, -2, 2, },
198  { -7, 7, -6, 6, -5, 5, -4, 4, },
199  { -15, 15, -14, 14, -13, 13, -12, 12,
200  -11, 11, -10, 10, -9, 9, -8, 8, },
201  { -31, 31, -30, 30, -29, 29, -28, 28,
202  -27, 27, -26, 26, -25, 25, -24, 24,
203  -23, 23, -22, 22, -21, 21, -20, 20,
204  -19, 19, -18, 18, -17, 17, -16, 16, },
205  { -63, 63, -62, 62, -61, 61, -60, 60,
206  -59, 59, -58, 58, -57, 57, -56, 56,
207  -55, 55, -54, 54, -53, 53, -52, 52,
208  -51, 51, -50, 50, -49, 49, -48, 48,
209  -47, 47, -46, 46, -45, 45, -44, 44,
210  -43, 43, -42, 42, -41, 41, -40, 40,
211  -39, 39, -38, 38, -37, 37, -36, 36,
212  -35, 35, -34, 34, -33, 33, -32, 32, },
213  { -127, 127, -126, 126, -125, 125, -124, 124,
214  -123, 123, -122, 122, -121, 121, -120, 120,
215  -119, 119, -118, 118, -117, 117, -116, 116,
216  -115, 115, -114, 114, -113, 113, -112, 112,
217  -111, 111, -110, 110, -109, 109, -108, 108,
218  -107, 107, -106, 106, -105, 105, -104, 104,
219  -103, 103, -102, 102, -101, 101, -100, 100,
220  -99, 99, -98, 98, -97, 97, -96, 96, },
221  { -95, 95, -94, 94, -93, 93, -92, 92,
222  -91, 91, -90, 90, -89, 89, -88, 88,
223  -87, 87, -86, 86, -85, 85, -84, 84,
224  -83, 83, -82, 82, -81, 81, -80, 80,
225  -79, 79, -78, 78, -77, 77, -76, 76,
226  -75, 75, -74, 74, -73, 73, -72, 72,
227  -71, 71, -70, 70, -69, 69, -68, 68,
228  -67, 67, -66, 66, -65, 65, -64, 64, },
229 };
230 
231 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
232 {
233  int16_t *block = ctx->dct_block;
234  unsigned int pos;
235 
236  ctx->bdsp.clear_block(block);
237 
238  block[0] = get_bits(&ctx->gb, 8) << 3;
239 
240  for (pos = 1; pos < num_coeffs; pos++) {
241  uint32_t vlc, num_bits;
242  int value;
243  int coeff;
244 
245  vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3);
246  if (!vlc) /* end-of-block code */
247  return 0;
248  if (vlc == -1)
249  return AVERROR_INVALIDDATA;
250 
251  /* pos_add and num_bits are coded in the vlc code */
252  pos += vlc & 15; // pos_add
253  num_bits = vlc >> 4; // num_bits
254 
255  if (pos >= 64)
256  return AVERROR_INVALIDDATA;
257 
258  value = get_bits(&ctx->gb, num_bits);
259 
260  /* FFmpeg's IDCT behaves somewhat different from the original code, so
261  * a factor of 4 was added to the input */
262 
263  coeff = vlcdec_lookup[num_bits][value];
264  if (pos < 3)
265  coeff <<= 4;
266  else /* TODO Use >> 10 instead of / 1001 */
267  coeff = (coeff * qscale) / 1001;
268 
269  block[ctx->scantable.permutated[pos]] = coeff;
270  }
271 
272  return 0;
273 }
274 
275 static int decode(MimicContext *ctx, int quality, int num_coeffs,
276  int is_iframe)
277 {
278  int ret, y, x, plane, cur_row = 0;
279 
280  for (plane = 0; plane < 3; plane++) {
281  const int is_chroma = !!plane;
282  const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
283  10000) << 2;
284  const int stride = ctx->frames[ctx->cur_index ].f->linesize[plane];
285  const uint8_t *src = ctx->frames[ctx->prev_index].f->data[plane];
286  uint8_t *dst = ctx->frames[ctx->cur_index ].f->data[plane];
287 
288  for (y = 0; y < ctx->num_vblocks[plane]; y++) {
289  for (x = 0; x < ctx->num_hblocks[plane]; x++) {
290  /* Check for a change condition in the current block.
291  * - iframes always change.
292  * - Luma plane changes on get_bits1 == 0
293  * - Chroma planes change on get_bits1 == 1 */
294  if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
295  /* Luma planes may use a backreference from the 15 last
296  * frames preceding the previous. (get_bits1 == 1)
297  * Chroma planes don't use backreferences. */
298  if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
299  if ((ret = vlc_decode_block(ctx, num_coeffs,
300  qscale)) < 0) {
301  av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
302  "block.\n");
303  return ret;
304  }
305  ctx->idsp.idct_put(dst, stride, ctx->dct_block);
306  } else {
307  unsigned int backref = get_bits(&ctx->gb, 4);
308  int index = (ctx->cur_index + backref) & 15;
309  uint8_t *p = ctx->frames[index].f->data[0];
310 
311  if (index != ctx->cur_index && p) {
312  ff_thread_await_progress(&ctx->frames[index],
313  cur_row, 0);
314  p += src -
315  ctx->frames[ctx->prev_index].f->data[plane];
316  ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
317  } else {
318  av_log(ctx->avctx, AV_LOG_ERROR,
319  "No such backreference! Buggy sample.\n");
320  }
321  }
322  } else {
324  cur_row, 0);
325  ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
326  }
327  src += 8;
328  dst += 8;
329  }
330  src += (stride - ctx->num_hblocks[plane]) << 3;
331  dst += (stride - ctx->num_hblocks[plane]) << 3;
332 
334  cur_row++, 0);
335  }
336  }
337 
338  return 0;
339 }
340 
341 /**
342  * Flip the buffer upside-down and put it in the YVU order to revert the
343  * way Mimic encodes frames.
344  */
345 static void flip_swap_frame(AVFrame *f)
346 {
347  int i;
348  uint8_t *data_1 = f->data[1];
349  f->data[0] = f->data[0] + ( f->height - 1) * f->linesize[0];
350  f->data[1] = f->data[2] + ((f->height >> 1) - 1) * f->linesize[2];
351  f->data[2] = data_1 + ((f->height >> 1) - 1) * f->linesize[1];
352  for (i = 0; i < 3; i++)
353  f->linesize[i] *= -1;
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] = AV_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  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  init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
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  /* Only release frames that aren't used for backreferences anymore */
450  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
451 
452  return buf_size;
453 }
454 
455 #if HAVE_THREADS
456 static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
457 {
458  MimicContext *ctx = avctx->priv_data;
459  int i;
460 
461  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
462  ctx->frames[i].f = av_frame_alloc();
463  if (!ctx->frames[i].f) {
464  mimic_decode_end(avctx);
465  return AVERROR(ENOMEM);
466  }
467  }
468 
469  return 0;
470 }
471 #endif
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,
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 };
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
int plane
Definition: avisynth_c.h:422
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static const uint8_t col_zag[64]
Definition: mimic.c:106
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:35
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:247
AVFrame * f
Definition: thread.h:36
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int next_cur_index
Definition: mimic.c:63
ScanTable scantable
Definition: mimic.c:55
Scantable.
Definition: idctdsp.h:29
int size
Definition: avcodec.h:1591
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1887
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:120
uint8_t permutated[64]
Definition: idctdsp.h:31
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
int prev_index
Definition: mimic.c:48
AVCodec.
Definition: avcodec.h:3573
static int16_t block[64]
Definition: dct.c:113
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:275
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t
IDCTDSPContext idsp
Definition: mimic.c:59
#define av_cold
Definition: attributes.h:82
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:140
Multithreading support functions.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:374
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:101
#define height
uint8_t * data
Definition: avcodec.h:1590
GetBitContext gb
Definition: mimic.c:54
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:3847
bitstream reader API header.
ThreadFrame frames[16]
Definition: mimic.c:50
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
#define av_log(a,...)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: vlc.h:38
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
Definition: internal.h:111
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:153
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:3109
BswapDSPContext bbdsp
Definition: mimic.c:57
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1754
const char * name
Name of the codec implementation.
Definition: avcodec.h:3580
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1021
static const int8_t vlcdec_lookup[9][64]
Definition: mimic.c:194
Definition: vlc.h:26
static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
Definition: mimic.c:231
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:215
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
Half-pel DSP context.
Definition: hpeldsp.h:45
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:258
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:3101
static av_cold int mimic_decode_end(AVCodecContext *avctx)
Definition: mimic.c:117
#define width
int width
picture width / height.
Definition: avcodec.h:1846
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
AVFormatContext * ctx
Definition: movenc.c:48
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:535
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:94
static const uint8_t huffbits[]
Definition: mimic.c:92
#define src
Definition: vp9dsp.c:530
#define FF_ARRAY_ELEMS(a)
int bits
Definition: vlc.h:27
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:70
static av_cold int mimic_decode_init(AVCodecContext *avctx)
Definition: mimic.c:137
Half-pel DSP functions.
Libavcodec external API header.
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:58
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:215
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
int16_t dct_block[64]
Definition: mimic.c:52
main external API structure.
Definition: avcodec.h:1659
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
void * buf
Definition: avisynth_c.h:690
static void flip_swap_frame(AVFrame *f)
Flip the buffer upside-down and put it in the YVU order to revert the way Mimic encodes frames...
Definition: mimic.c:345
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:299
int cur_index
Definition: mimic.c:47
int index
Definition: gxfenc.c:89
AVCodecContext * avctx
Definition: mimic.c:39
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:406
int next_prev_index
Definition: mimic.c:64
static const uint32_t huffcodes[]
Definition: mimic.c:67
int allocate_progress
Whether to allocate progress for frame threading.
Definition: internal.h:126
int num_vblocks[3]
Definition: mimic.c:41
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:62
common internal api header.
AVCodec ff_mimic_decoder
Definition: mimic.c:473
static int mimic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mimic.c:356
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1701
#define MIMIC_HEADER_SIZE
Definition: mimic.c:36
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:241
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1709
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
VLC vlc
Definition: mimic.c:60
static const double coeff[2][5]
Definition: vf_owdenoise.c:71
int swap_buf_size
Definition: mimic.c:45
int height
Definition: frame.h:236
#define av_freep(p)
#define stride
BlockDSPContext bdsp
Definition: mimic.c:56
void * swap_buf
Definition: mimic.c:44
This structure stores compressed data.
Definition: avcodec.h:1567
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:360
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1343
int num_hblocks[3]
Definition: mimic.c:42
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:958
for(j=16;j >0;--j)
HpelDSPContext hdsp
Definition: mimic.c:58
Predicted.
Definition: avutil.h:269
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58