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 
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,
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:291
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static const uint8_t col_zag[64]
Definition: mimic.c:107
int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
Definition: avcodec.h:3746
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
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:260
AVFrame * f
Definition: thread.h:36
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int next_cur_index
Definition: mimic.c:64
ScanTable scantable
Definition: mimic.c:56
Scantable.
Definition: idctdsp.h:29
int size
Definition: avcodec.h:1423
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:53
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1721
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:126
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.
Picture data structure.
Definition: avcodec.h:3744
int prev_index
Definition: mimic.c:48
AVCodec.
Definition: avcodec.h:3473
AVPicture flipped_ptrs[16]
Definition: mimic.c:51
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:276
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:60
#define av_cold
Definition: attributes.h:74
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:135
uint8_t * data[AV_NUM_DATA_POINTERS]
pointers to the image data planes
Definition: avcodec.h:3745
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:363
uint8_t * data
Definition: avcodec.h:1422
GetBitContext gb
Definition: mimic.c:55
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:3756
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.
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
Definition: internal.h:106
#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:148
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:175
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:3053
BswapDSPContext bbdsp
Definition: mimic.c:58
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1596
const char * name
Name of the codec implementation.
Definition: avcodec.h:3480
static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
Definition: mimic.c:457
Libavcodec external API header.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:919
static const int8_t vlcdec_lookup[9][64]
Definition: mimic.c:195
Definition: get_bits.h:63
static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
Definition: mimic.c:232
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:214
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
static int update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: ffv1dec.c:1058
Half-pel DSP context.
Definition: hpeldsp.h:45
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:242
float y
static av_cold int mimic_decode_end(AVCodecContext *avctx)
Definition: mimic.c:118
ret
Definition: avfilter.c:974
int width
picture width / height.
Definition: avcodec.h:1680
GLsizei GLboolean const GLfloat * value
Definition: opengl_enc.c:109
#define FF_CEIL_RSHIFT(a, b)
Definition: common.h:57
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
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:555
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:94
static const uint8_t huffbits[]
Definition: mimic.c:93
#define FF_ARRAY_ELEMS(a)
int bits
Definition: get_bits.h:64
#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:138
static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
Definition: mimic.c:170
Half-pel DSP functions.
AVS_Value src
Definition: avisynth_c.h:482
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:199
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:53
main external API structure.
Definition: avcodec.h:1501
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:457
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:553
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:304
BYTE int const BYTE int int int height
Definition: avisynth_c.h:676
int cur_index
Definition: mimic.c:47
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:3045
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:410
int next_prev_index
Definition: mimic.c:65
static const uint32_t huffcodes[]
Definition: mimic.c:68
int allocate_progress
Whether to allocate progress for frame threading.
Definition: internal.h:121
int num_vblocks[3]
Definition: mimic.c:41
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:105
static void prepare_avpic(MimicContext *ctx, AVPicture *dst, AVFrame *src)
Flip the buffer upside-down and put it in the YVU order to match the way Mimic encodes frames...
Definition: mimic.c:346
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:63
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:1543
#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:1551
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:65
VLC vlc
Definition: mimic.c:61
static const double coeff[2][5]
Definition: vf_owdenoise.c:71
int swap_buf_size
Definition: mimic.c:45
#define av_freep(p)
#define stride
BlockDSPContext bdsp
Definition: mimic.c:57
void * swap_buf
Definition: mimic.c:44
This structure stores compressed data.
Definition: avcodec.h:1399
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1215
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:856
for(j=16;j >0;--j)
HpelDSPContext hdsp
Definition: mimic.c:59
Predicted.
Definition: avutil.h:275
static int width
static int16_t block[64]
Definition: dct-test.c:110