Libav
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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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_free(ctx->swap_buf);
123 
124  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
125  if (ctx->frames[i].f)
126  ff_thread_release_buffer(avctx, &ctx->frames[i]);
127  av_frame_free(&ctx->frames[i].f);
128  }
129 
130  if (!avctx->internal->is_copy)
131  ff_free_vlc(&ctx->vlc);
132 
133  return 0;
134 }
135 
137 {
138  MimicContext *ctx = avctx->priv_data;
139  int ret, i;
140 
141  avctx->internal->allocate_progress = 1;
142 
143  ctx->prev_index = 0;
144  ctx->cur_index = 15;
145 
146  if ((ret = init_vlc(&ctx->vlc, 11, FF_ARRAY_ELEMS(huffbits),
147  huffbits, 1, 1, huffcodes, 4, 4, 0)) < 0) {
148  av_log(avctx, AV_LOG_ERROR, "error initializing vlc table\n");
149  return ret;
150  }
151  ff_blockdsp_init(&ctx->bdsp, avctx);
152  ff_bswapdsp_init(&ctx->bbdsp);
153  ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
154  ff_idctdsp_init(&ctx->idsp, avctx);
156 
157  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
158  ctx->frames[i].f = av_frame_alloc();
159  if (!ctx->frames[i].f) {
160  mimic_decode_end(avctx);
161  return AVERROR(ENOMEM);
162  }
163  }
164 
165  return 0;
166 }
167 
169 {
170  MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
171  int i, ret;
172 
173  if (avctx == avctx_from)
174  return 0;
175 
176  dst->cur_index = src->next_cur_index;
177  dst->prev_index = src->next_prev_index;
178 
179  for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
180  ff_thread_release_buffer(avctx, &dst->frames[i]);
181  if (src->frames[i].f->data[0]) {
182  ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
183  if (ret < 0)
184  return ret;
185  }
186  }
187 
188  return 0;
189 }
190 
191 static const int8_t vlcdec_lookup[9][64] = {
192  { 0, },
193  { -1, 1, },
194  { -3, 3, -2, 2, },
195  { -7, 7, -6, 6, -5, 5, -4, 4, },
196  { -15, 15, -14, 14, -13, 13, -12, 12,
197  -11, 11, -10, 10, -9, 9, -8, 8, },
198  { -31, 31, -30, 30, -29, 29, -28, 28,
199  -27, 27, -26, 26, -25, 25, -24, 24,
200  -23, 23, -22, 22, -21, 21, -20, 20,
201  -19, 19, -18, 18, -17, 17, -16, 16, },
202  { -63, 63, -62, 62, -61, 61, -60, 60,
203  -59, 59, -58, 58, -57, 57, -56, 56,
204  -55, 55, -54, 54, -53, 53, -52, 52,
205  -51, 51, -50, 50, -49, 49, -48, 48,
206  -47, 47, -46, 46, -45, 45, -44, 44,
207  -43, 43, -42, 42, -41, 41, -40, 40,
208  -39, 39, -38, 38, -37, 37, -36, 36,
209  -35, 35, -34, 34, -33, 33, -32, 32, },
210  { -127, 127, -126, 126, -125, 125, -124, 124,
211  -123, 123, -122, 122, -121, 121, -120, 120,
212  -119, 119, -118, 118, -117, 117, -116, 116,
213  -115, 115, -114, 114, -113, 113, -112, 112,
214  -111, 111, -110, 110, -109, 109, -108, 108,
215  -107, 107, -106, 106, -105, 105, -104, 104,
216  -103, 103, -102, 102, -101, 101, -100, 100,
217  -99, 99, -98, 98, -97, 97, -96, 96, },
218  { -95, 95, -94, 94, -93, 93, -92, 92,
219  -91, 91, -90, 90, -89, 89, -88, 88,
220  -87, 87, -86, 86, -85, 85, -84, 84,
221  -83, 83, -82, 82, -81, 81, -80, 80,
222  -79, 79, -78, 78, -77, 77, -76, 76,
223  -75, 75, -74, 74, -73, 73, -72, 72,
224  -71, 71, -70, 70, -69, 69, -68, 68,
225  -67, 67, -66, 66, -65, 65, -64, 64, },
226 };
227 
228 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
229 {
230  int16_t *block = ctx->dct_block;
231  unsigned int pos;
232 
233  ctx->bdsp.clear_block(block);
234 
235  block[0] = get_bits(&ctx->gb, 8) << 3;
236 
237  for (pos = 1; pos < num_coeffs; pos++) {
238  uint32_t vlc, num_bits;
239  int value;
240  int coeff;
241 
242  vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3);
243  if (!vlc) /* end-of-block code */
244  return 0;
245  if (vlc == -1)
246  return AVERROR_INVALIDDATA;
247 
248  /* pos_add and num_bits are coded in the vlc code */
249  pos += vlc & 15; // pos_add
250  num_bits = vlc >> 4; // num_bits
251 
252  if (pos >= 64)
253  return AVERROR_INVALIDDATA;
254 
255  value = get_bits(&ctx->gb, num_bits);
256 
257  /* Libav's IDCT behaves somewhat different from the original code, so
258  * a factor of 4 was added to the input */
259 
260  coeff = vlcdec_lookup[num_bits][value];
261  if (pos < 3)
262  coeff <<= 4;
263  else /* TODO Use >> 10 instead of / 1001 */
264  coeff = (coeff * qscale) / 1001;
265 
266  block[ctx->scantable.permutated[pos]] = coeff;
267  }
268 
269  return 0;
270 }
271 
272 static int decode(MimicContext *ctx, int quality, int num_coeffs,
273  int is_iframe)
274 {
275  int ret, y, x, plane, cur_row = 0;
276 
277  for (plane = 0; plane < 3; plane++) {
278  const int is_chroma = !!plane;
279  const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
280  10000) << 2;
281  const int stride = ctx->frames[ctx->cur_index ].f->linesize[plane];
282  const uint8_t *src = ctx->frames[ctx->prev_index].f->data[plane];
283  uint8_t *dst = ctx->frames[ctx->cur_index ].f->data[plane];
284 
285  for (y = 0; y < ctx->num_vblocks[plane]; y++) {
286  for (x = 0; x < ctx->num_hblocks[plane]; x++) {
287  /* Check for a change condition in the current block.
288  * - iframes always change.
289  * - Luma plane changes on get_bits1 == 0
290  * - Chroma planes change on get_bits1 == 1 */
291  if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
292  /* Luma planes may use a backreference from the 15 last
293  * frames preceding the previous. (get_bits1 == 1)
294  * Chroma planes don't use backreferences. */
295  if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
296  if ((ret = vlc_decode_block(ctx, num_coeffs,
297  qscale)) < 0) {
298  av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
299  "block.\n");
300  return ret;
301  }
302  ctx->idsp.idct_put(dst, stride, ctx->dct_block);
303  } else {
304  unsigned int backref = get_bits(&ctx->gb, 4);
305  int index = (ctx->cur_index + backref) & 15;
306  uint8_t *p = ctx->frames[index].f->data[0];
307 
308  if (index != ctx->cur_index && p) {
309  ff_thread_await_progress(&ctx->frames[index],
310  cur_row, 0);
311  p += src -
312  ctx->frames[ctx->prev_index].f->data[plane];
313  ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
314  } else {
315  av_log(ctx->avctx, AV_LOG_ERROR,
316  "No such backreference! Buggy sample.\n");
317  }
318  }
319  } else {
321  cur_row, 0);
322  ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
323  }
324  src += 8;
325  dst += 8;
326  }
327  src += (stride - ctx->num_hblocks[plane]) << 3;
328  dst += (stride - ctx->num_hblocks[plane]) << 3;
329 
331  cur_row++, 0);
332  }
333  }
334 
335  return 0;
336 }
337 
342 static void flip_swap_frame(AVFrame *f)
343 {
344  int i;
345  uint8_t *data_1 = f->data[1];
346  f->data[0] = f->data[0] + ( f->height - 1) * f->linesize[0];
347  f->data[1] = f->data[2] + ((f->height >> 1) - 1) * f->linesize[2];
348  f->data[2] = data_1 + ((f->height >> 1) - 1) * f->linesize[1];
349  for (i = 0; i < 3; i++)
350  f->linesize[i] *= -1;
351 }
352 
354  int *got_frame, AVPacket *avpkt)
355 {
356  const uint8_t *buf = avpkt->data;
357  int buf_size = avpkt->size;
358  int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;
359  MimicContext *ctx = avctx->priv_data;
361  int is_pframe;
362  int width, height;
363  int quality, num_coeffs;
364  int res;
365 
366  if (buf_size <= MIMIC_HEADER_SIZE) {
367  av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
368  return AVERROR_INVALIDDATA;
369  }
370 
371  bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);
372  bytestream2_skip(&gb, 2); /* some constant (always 256) */
373  quality = bytestream2_get_le16u(&gb);
374  width = bytestream2_get_le16u(&gb);
375  height = bytestream2_get_le16u(&gb);
376  bytestream2_skip(&gb, 4); /* some constant */
377  is_pframe = bytestream2_get_le32u(&gb);
378  num_coeffs = bytestream2_get_byteu(&gb);
379  bytestream2_skip(&gb, 3); /* some constant */
380 
381  if (!ctx->avctx) {
382  int i;
383 
384  if (!(width == 160 && height == 120) &&
385  !(width == 320 && height == 240)) {
386  av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
387  return AVERROR_INVALIDDATA;
388  }
389 
390  ctx->avctx = avctx;
391  avctx->width = width;
392  avctx->height = height;
393  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
394  for (i = 0; i < 3; i++) {
395  ctx->num_vblocks[i] = AV_CEIL_RSHIFT(height, 3 + !!i);
396  ctx->num_hblocks[i] = width >> (3 + !!i);
397  }
398  } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
399  avpriv_request_sample(avctx, "Resolution changing");
400  return AVERROR_PATCHWELCOME;
401  }
402 
403  if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
404  av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
405  return AVERROR_INVALIDDATA;
406  }
407 
408  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
409  ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
411  if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
412  AV_GET_BUFFER_FLAG_REF)) < 0) {
413  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
414  return res;
415  }
416 
417  ctx->next_prev_index = ctx->cur_index;
418  ctx->next_cur_index = (ctx->cur_index - 1) & 15;
419 
420  ff_thread_finish_setup(avctx);
421 
422  av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
423  if (!ctx->swap_buf)
424  return AVERROR(ENOMEM);
425 
426  ctx->bbdsp.bswap_buf(ctx->swap_buf,
427  (const uint32_t *) (buf + MIMIC_HEADER_SIZE),
428  swap_buf_size >> 2);
429  init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
430 
431  res = decode(ctx, quality, num_coeffs, !is_pframe);
432  ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
433  if (res < 0) {
434  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
435  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
436  return res;
437  }
438 
439  if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0)
440  return res;
441  *got_frame = 1;
442 
443  flip_swap_frame(data);
444 
445  ctx->prev_index = ctx->next_prev_index;
446  ctx->cur_index = ctx->next_cur_index;
447 
448  return buf_size;
449 }
450 
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 
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),
474  .close = mimic_decode_end,
478  .init_thread_copy = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy),
479 };
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
static const uint8_t col_zag[64]
Definition: mimic.c:106
This structure describes decoded (raw) audio or video data.
Definition: frame.h:140
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:228
AVFrame * f
Definition: thread.h:36
int next_cur_index
Definition: mimic.c:63
void(* clear_block)(int16_t *block)
Definition: blockdsp.h:35
ScanTable scantable
Definition: mimic.c:55
Scantable.
Definition: idctdsp.h:29
int size
Definition: avcodec.h:1347
av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (%s)\, len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt), use_generic ? ac->func_descr_generic :ac->func_descr)
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:58
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1621
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:132
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer with padding, reusing the given one if large enough.
Definition: utils.c:60
#define FF_ARRAY_ELEMS(a)
uint8_t permutated[64]
Definition: idctdsp.h:31
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
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
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:3120
static int16_t block[64]
Definition: dct.c:97
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:272
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:66
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:68
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
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:199
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:1346
GetBitContext gb
Definition: mimic.c:54
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:2655
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 src
Definition: vp8dsp.c:254
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:124
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:190
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:104
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:161
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:80
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:148
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2825
BswapDSPContext bbdsp
Definition: mimic.c:57
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1503
const char * name
Name of the codec implementation.
Definition: avcodec.h:3127
static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
Definition: mimic.c:451
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:893
static const int8_t vlcdec_lookup[9][64]
Definition: mimic.c:191
Definition: vlc.h:26
static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
Definition: mimic.c:228
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:188
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:70
Half-pel DSP context.
Definition: hpeldsp.h:45
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:201
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2817
static av_cold int mimic_decode_end(AVCodecContext *avctx)
Definition: mimic.c:117
int width
picture width / height.
Definition: avcodec.h:1580
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:493
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:94
static const uint8_t huffbits[]
Definition: mimic.c:92
int bits
Definition: vlc.h:27
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
static av_cold int mimic_decode_init(AVCodecContext *avctx)
Definition: mimic.c:136
static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
Definition: mimic.c:168
Half-pel DSP functions.
static int width
Definition: utils.c:156
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:158
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:1409
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
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:342
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:267
int cur_index
Definition: mimic.c:47
int index
Definition: gxfenc.c:72
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:362
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:119
int num_vblocks[3]
Definition: mimic.c:41
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:146
int height
Definition: gxfenc.c:72
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:59
common internal api header.
AVCodec ff_mimic_decoder
Definition: mimic.c:467
static int mimic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mimic.c:353
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:582
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1451
#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:28
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:147
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1459
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
VLC vlc
Definition: mimic.c:60
int swap_buf_size
Definition: mimic.c:45
int height
Definition: frame.h:179
BlockDSPContext bdsp
Definition: mimic.c:56
void * swap_buf
Definition: mimic.c:44
This structure stores compressed data.
Definition: avcodec.h:1323
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:334
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:1183
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:838
for(j=16;j >0;--j)
HpelDSPContext hdsp
Definition: mimic.c:58
Predicted.
Definition: avutil.h:261
#define AV_CEIL_RSHIFT(a, b)
Fast a / (1 << b) rounded toward +inf, assuming a >= 0 and b >= 0.
Definition: common.h:57