FFmpeg  4.4
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 "libavutil/mem_internal.h"
27 #include "libavutil/thread.h"
28 
29 #include "avcodec.h"
30 #include "blockdsp.h"
31 #include "internal.h"
32 #include "get_bits.h"
33 #include "bytestream.h"
34 #include "bswapdsp.h"
35 #include "hpeldsp.h"
36 #include "idctdsp.h"
37 #include "thread.h"
38 
39 #define MIMIC_HEADER_SIZE 20
40 #define MIMIC_VLC_BITS 11
41 
42 typedef struct MimicContext {
44 
45  int num_vblocks[3];
46  int num_hblocks[3];
47 
48  void *swap_buf;
50 
51  int cur_index;
53 
55 
56  DECLARE_ALIGNED(32, int16_t, dct_block)[64];
57 
64 
65  /* Kept in the context so multithreading can have a constant to read from */
68 } MimicContext;
69 
70 static VLC block_vlc;
71 
72 static const uint8_t huffsyms[] = {
73  0x10, 0x20, 0x30, 0x00, 0x11, 0x40, 0x50, 0x12, 0x13, 0x21, 0x31, 0x60,
74  0x14, 0x15, 0x16, 0x22, 0x41, 0x17, 0x18, 0x23, 0x24, 0x25, 0x32, 0x42,
75  0x51, 0x61, 0x70, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x26, 0x27,
76  0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x33, 0x34, 0x35, 0x36, 0x37,
77  0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x43, 0x44, 0x45, 0x46, 0x47,
78  0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x52, 0x53, 0x54, 0x55, 0x56,
79  0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x62, 0x63, 0x64, 0x65,
80  0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, 0x73,
81  0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
82 };
83 
84 static const uint8_t huffbits[] = {
85  2, 2, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8,
86  8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12,
87  13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17,
88  17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21,
89  22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,
90  26, 26, 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30,
91 };
92 
93 static const uint8_t col_zag[64] = {
94  0, 8, 1, 2, 9, 16, 24, 17,
95  10, 3, 4, 11, 18, 25, 32, 40,
96  33, 26, 19, 12, 5, 6, 13, 20,
97  27, 34, 41, 48, 56, 49, 42, 35,
98  28, 21, 14, 7, 15, 22, 29, 36,
99  43, 50, 57, 58, 51, 44, 37, 30,
100  23, 31, 38, 45, 52, 59, 39, 46,
101  53, 60, 61, 54, 47, 55, 62, 63,
102 };
103 
105 {
106  MimicContext *ctx = avctx->priv_data;
107  int i;
108 
109  av_freep(&ctx->swap_buf);
110  ctx->swap_buf_size = 0;
111 
112  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
113  if (ctx->frames[i].f)
114  ff_thread_release_buffer(avctx, &ctx->frames[i]);
115  av_frame_free(&ctx->frames[i].f);
116  }
117 
118  return 0;
119 }
120 
121 static av_cold void mimic_init_static(void)
122 {
124  huffbits, 1, huffsyms, 1, 1, 0, 0, 4368);
125 }
126 
128 {
129  static AVOnce init_static_once = AV_ONCE_INIT;
130  MimicContext *ctx = avctx->priv_data;
131  int i;
132 
133  ctx->prev_index = 0;
134  ctx->cur_index = 15;
135 
136  ff_blockdsp_init(&ctx->bdsp, avctx);
137  ff_bswapdsp_init(&ctx->bbdsp);
138  ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
139  ff_idctdsp_init(&ctx->idsp, avctx);
140  ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, col_zag);
141 
142  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
143  ctx->frames[i].f = av_frame_alloc();
144  if (!ctx->frames[i].f)
145  return AVERROR(ENOMEM);
146  }
147 
148  ff_thread_once(&init_static_once, mimic_init_static);
149 
150  return 0;
151 }
152 
153 #if HAVE_THREADS
154 static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
155 {
156  MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
157  int i, ret;
158 
159  if (avctx == avctx_from)
160  return 0;
161 
162  dst->cur_index = src->next_cur_index;
163  dst->prev_index = src->next_prev_index;
164 
165  for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
166  ff_thread_release_buffer(avctx, &dst->frames[i]);
167  if (i != src->next_cur_index && src->frames[i].f->data[0]) {
168  ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
169  if (ret < 0)
170  return ret;
171  }
172  }
173 
174  return 0;
175 }
176 #endif
177 
178 static const int8_t vlcdec_lookup[9][64] = {
179  { 0, },
180  { -1, 1, },
181  { -3, 3, -2, 2, },
182  { -7, 7, -6, 6, -5, 5, -4, 4, },
183  { -15, 15, -14, 14, -13, 13, -12, 12,
184  -11, 11, -10, 10, -9, 9, -8, 8, },
185  { -31, 31, -30, 30, -29, 29, -28, 28,
186  -27, 27, -26, 26, -25, 25, -24, 24,
187  -23, 23, -22, 22, -21, 21, -20, 20,
188  -19, 19, -18, 18, -17, 17, -16, 16, },
189  { -63, 63, -62, 62, -61, 61, -60, 60,
190  -59, 59, -58, 58, -57, 57, -56, 56,
191  -55, 55, -54, 54, -53, 53, -52, 52,
192  -51, 51, -50, 50, -49, 49, -48, 48,
193  -47, 47, -46, 46, -45, 45, -44, 44,
194  -43, 43, -42, 42, -41, 41, -40, 40,
195  -39, 39, -38, 38, -37, 37, -36, 36,
196  -35, 35, -34, 34, -33, 33, -32, 32, },
197  { -127, 127, -126, 126, -125, 125, -124, 124,
198  -123, 123, -122, 122, -121, 121, -120, 120,
199  -119, 119, -118, 118, -117, 117, -116, 116,
200  -115, 115, -114, 114, -113, 113, -112, 112,
201  -111, 111, -110, 110, -109, 109, -108, 108,
202  -107, 107, -106, 106, -105, 105, -104, 104,
203  -103, 103, -102, 102, -101, 101, -100, 100,
204  -99, 99, -98, 98, -97, 97, -96, 96, },
205  { -95, 95, -94, 94, -93, 93, -92, 92,
206  -91, 91, -90, 90, -89, 89, -88, 88,
207  -87, 87, -86, 86, -85, 85, -84, 84,
208  -83, 83, -82, 82, -81, 81, -80, 80,
209  -79, 79, -78, 78, -77, 77, -76, 76,
210  -75, 75, -74, 74, -73, 73, -72, 72,
211  -71, 71, -70, 70, -69, 69, -68, 68,
212  -67, 67, -66, 66, -65, 65, -64, 64, },
213 };
214 
215 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
216 {
217  int16_t *block = ctx->dct_block;
218  unsigned int pos;
219 
220  ctx->bdsp.clear_block(block);
221 
222  block[0] = get_bits(&ctx->gb, 8) << 3;
223 
224  for (pos = 1; pos < num_coeffs; pos++) {
225  uint32_t vlc, num_bits;
226  int value;
227  int coeff;
228 
229  vlc = get_vlc2(&ctx->gb, block_vlc.table, MIMIC_VLC_BITS, 3);
230  if (!vlc) /* end-of-block code */
231  return 0;
232  if (vlc == -1)
233  return AVERROR_INVALIDDATA;
234 
235  /* pos_add and num_bits are coded in the vlc code */
236  pos += vlc & 15; // pos_add
237  num_bits = vlc >> 4; // num_bits
238 
239  if (pos >= 64)
240  return AVERROR_INVALIDDATA;
241 
242  value = get_bits(&ctx->gb, num_bits);
243 
244  /* FFmpeg's IDCT behaves somewhat different from the original code, so
245  * a factor of 4 was added to the input */
246 
247  coeff = ((int8_t*)vlcdec_lookup[num_bits])[value];
248  if (pos < 3)
249  coeff *= 16;
250  else /* TODO Use >> 10 instead of / 1001 */
251  coeff = (coeff * qscale) / 1001;
252 
253  block[ctx->scantable.permutated[pos]] = coeff;
254  }
255 
256  return 0;
257 }
258 
259 static int decode(MimicContext *ctx, int quality, int num_coeffs,
260  int is_iframe)
261 {
262  int ret, y, x, plane, cur_row = 0;
263 
264  for (plane = 0; plane < 3; plane++) {
265  const int is_chroma = !!plane;
266  const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
267  10000) << 2;
268  const int stride = ctx->frames[ctx->cur_index ].f->linesize[plane];
269  const uint8_t *src = ctx->frames[ctx->prev_index].f->data[plane];
270  uint8_t *dst = ctx->frames[ctx->cur_index ].f->data[plane];
271 
272  for (y = 0; y < ctx->num_vblocks[plane]; y++) {
273  for (x = 0; x < ctx->num_hblocks[plane]; x++) {
274  /* Check for a change condition in the current block.
275  * - iframes always change.
276  * - Luma plane changes on get_bits1 == 0
277  * - Chroma planes change on get_bits1 == 1 */
278  if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
279  /* Luma planes may use a backreference from the 15 last
280  * frames preceding the previous. (get_bits1 == 1)
281  * Chroma planes don't use backreferences. */
282  if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
283  if ((ret = vlc_decode_block(ctx, num_coeffs,
284  qscale)) < 0) {
285  av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
286  "block.\n");
287  return ret;
288  }
289  ctx->idsp.idct_put(dst, stride, ctx->dct_block);
290  } else {
291  unsigned int backref = get_bits(&ctx->gb, 4);
292  int index = (ctx->cur_index + backref) & 15;
293  uint8_t *p = ctx->frames[index].f->data[0];
294 
295  if (index != ctx->cur_index && p) {
297  cur_row, 0);
298  p += src -
299  ctx->frames[ctx->prev_index].f->data[plane];
300  ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
301  } else {
302  av_log(ctx->avctx, AV_LOG_ERROR,
303  "No such backreference! Buggy sample.\n");
304  }
305  }
306  } else {
307  ff_thread_await_progress(&ctx->frames[ctx->prev_index],
308  cur_row, 0);
309  ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
310  }
311  src += 8;
312  dst += 8;
313  }
314  src += (stride - ctx->num_hblocks[plane]) << 3;
315  dst += (stride - ctx->num_hblocks[plane]) << 3;
316 
317  ff_thread_report_progress(&ctx->frames[ctx->cur_index],
318  cur_row++, 0);
319  }
320  }
321 
322  return 0;
323 }
324 
325 /**
326  * Flip the buffer upside-down and put it in the YVU order to revert the
327  * way Mimic encodes frames.
328  */
329 static void flip_swap_frame(AVFrame *f)
330 {
331  int i;
332  uint8_t *data_1 = f->data[1];
333  f->data[0] = f->data[0] + ( f->height - 1) * f->linesize[0];
334  f->data[1] = f->data[2] + ((f->height >> 1) - 1) * f->linesize[2];
335  f->data[2] = data_1 + ((f->height >> 1) - 1) * f->linesize[1];
336  for (i = 0; i < 3; i++)
337  f->linesize[i] *= -1;
338 }
339 
340 static int mimic_decode_frame(AVCodecContext *avctx, void *data,
341  int *got_frame, AVPacket *avpkt)
342 {
343  const uint8_t *buf = avpkt->data;
344  int buf_size = avpkt->size;
345  int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;
346  MimicContext *ctx = avctx->priv_data;
347  GetByteContext gb;
348  int is_pframe;
349  int width, height;
350  int quality, num_coeffs;
351  int res;
352 
353  if (buf_size <= MIMIC_HEADER_SIZE) {
354  av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
355  return AVERROR_INVALIDDATA;
356  }
357 
359  bytestream2_skip(&gb, 2); /* some constant (always 256) */
360  quality = bytestream2_get_le16u(&gb);
361  width = bytestream2_get_le16u(&gb);
362  height = bytestream2_get_le16u(&gb);
363  bytestream2_skip(&gb, 4); /* some constant */
364  is_pframe = bytestream2_get_le32u(&gb);
365  num_coeffs = bytestream2_get_byteu(&gb);
366  bytestream2_skip(&gb, 3); /* some constant */
367 
368  if (!ctx->avctx) {
369  int i;
370 
371  if (!(width == 160 && height == 120) &&
372  !(width == 320 && height == 240)) {
373  av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
374  return AVERROR_INVALIDDATA;
375  }
376 
377  res = ff_set_dimensions(avctx, width, height);
378  if (res < 0)
379  return res;
380 
381  ctx->avctx = avctx;
382  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
383  for (i = 0; i < 3; i++) {
384  ctx->num_vblocks[i] = AV_CEIL_RSHIFT(height, 3 + !!i);
385  ctx->num_hblocks[i] = width >> (3 + !!i);
386  }
387  } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
388  avpriv_request_sample(avctx, "Resolution changing");
389  return AVERROR_PATCHWELCOME;
390  }
391 
392  if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
393  av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
394  return AVERROR_INVALIDDATA;
395  }
396 
397  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
398  ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
400  if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
402  return res;
403 
404  ctx->next_prev_index = ctx->cur_index;
405  ctx->next_cur_index = (ctx->cur_index - 1) & 15;
406 
407  ff_thread_finish_setup(avctx);
408 
409  av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
410  if (!ctx->swap_buf)
411  return AVERROR(ENOMEM);
412 
413  ctx->bbdsp.bswap_buf(ctx->swap_buf,
414  (const uint32_t *) (buf + MIMIC_HEADER_SIZE),
415  swap_buf_size >> 2);
416  init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
417 
418  res = decode(ctx, quality, num_coeffs, !is_pframe);
419  ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
420  if (res < 0) {
421  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
422  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
423  return res;
424  }
425 
426  if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0)
427  return res;
428  *got_frame = 1;
429 
431 
432  ctx->prev_index = ctx->next_prev_index;
433  ctx->cur_index = ctx->next_cur_index;
434 
435  return buf_size;
436 }
437 
439  .name = "mimic",
440  .long_name = NULL_IF_CONFIG_SMALL("Mimic"),
441  .type = AVMEDIA_TYPE_VIDEO,
442  .id = AV_CODEC_ID_MIMIC,
443  .priv_data_size = sizeof(MimicContext),
445  .close = mimic_decode_end,
448  .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context),
449  .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS |
451 };
#define av_cold
Definition: attributes.h:88
uint8_t
Libavcodec external API header.
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1784
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
#define f(width, name)
Definition: cbs_vp9.c:255
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
#define av_clip
Definition: common.h:122
double value
Definition: eval.c:98
bitstream reader API header.
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:797
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:514
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
@ AV_CODEC_ID_MIMIC
Definition: codec_id.h:162
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:50
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
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:443
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:203
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
#define DECLARE_ALIGNED(n, t, v)
Declare a variable that is aligned in memory.
Definition: mem.h:117
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
int index
Definition: gxfenc.c:89
for(j=16;j >0;--j)
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
int i
Definition: input.c:407
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:60
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:76
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:84
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:903
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:156
#define AVOnce
Definition: thread.h:172
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
#define AV_ONCE_INIT
Definition: thread.h:173
int stride
Definition: mace.c:144
static const uint8_t huffsyms[]
Definition: mimic.c:72
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:259
#define MIMIC_VLC_BITS
Definition: mimic.c:40
static int mimic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mimic.c:340
AVCodec ff_mimic_decoder
Definition: mimic.c:438
static const uint8_t huffbits[]
Definition: mimic.c:84
static VLC block_vlc
Definition: mimic.c:70
static const int8_t vlcdec_lookup[9][64]
Definition: mimic.c:178
static av_cold int mimic_decode_init(AVCodecContext *avctx)
Definition: mimic.c:127
static av_cold void mimic_init_static(void)
Definition: mimic.c:121
static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
Definition: mimic.c:215
#define MIMIC_HEADER_SIZE
Definition: mimic.c:39
static av_cold int mimic_decode_end(AVCodecContext *avctx)
Definition: mimic.c:104
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:329
static const uint8_t col_zag[64]
Definition: mimic.c:93
const char data[16]
Definition: mxf.c:142
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
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...
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
#define FF_ARRAY_ELEMS(a)
unsigned int pos
Definition: spdifenc.c:412
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1792
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
Half-pel DSP context.
Definition: hpeldsp.h:45
int next_cur_index
Definition: mimic.c:66
GetBitContext gb
Definition: mimic.c:58
IDCTDSPContext idsp
Definition: mimic.c:63
int num_hblocks[3]
Definition: mimic.c:46
int swap_buf_size
Definition: mimic.c:49
ThreadFrame frames[16]
Definition: mimic.c:54
int16_t dct_block[64]
Definition: mimic.c:56
ScanTable scantable
Definition: mimic.c:59
int prev_index
Definition: mimic.c:52
int next_prev_index
Definition: mimic.c:67
BswapDSPContext bbdsp
Definition: mimic.c:61
HpelDSPContext hdsp
Definition: mimic.c:62
AVCodecContext * avctx
Definition: mimic.c:43
void * swap_buf
Definition: mimic.c:48
int num_vblocks[3]
Definition: mimic.c:45
BlockDSPContext bdsp
Definition: mimic.c:60
int cur_index
Definition: mimic.c:51
Scantable.
Definition: idctdsp.h:31
Definition: vlc.h:26
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
#define avpriv_request_sample(...)
#define av_freep(p)
#define av_log(a,...)
#define src
Definition: vp8dsp.c:255
static int16_t block[64]
Definition: dct.c:116
AVFormatContext * ctx
Definition: movenc.c:48
#define height
#define width
static const double coeff[2][5]
Definition: vf_owdenoise.c:73
#define INIT_VLC_STATIC_FROM_LENGTHS(vlc, bits, nb_codes, lens, len_wrap, symbols, symbols_wrap, symbols_size, offset, flags, static_size)
Definition: vlc.h:126