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 "internal.h"
28 #include "get_bits.h"
29 #include "bytestream.h"
30 #include "dsputil.h"
31 #include "hpeldsp.h"
32 #include "thread.h"
33 
34 #define MIMIC_HEADER_SIZE 20
35 
36 typedef struct {
38 
39  int num_vblocks[3];
40  int num_hblocks[3];
41 
42  void *swap_buf;
44 
45  int cur_index;
47 
48  ThreadFrame frames [16];
49  AVPicture flipped_ptrs[16];
50 
51  DECLARE_ALIGNED(16, int16_t, dct_block)[64];
52 
58 
59  /* Kept in the context so multithreading can have a constant to read from */
62 } MimicContext;
63 
64 static const uint32_t huffcodes[] = {
65  0x0000000a, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
66  0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000,
67  0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x0000000b,
68  0x0000001b, 0x00000038, 0x00000078, 0x00000079, 0x0000007a, 0x000000f9,
69  0x000000fa, 0x000003fb, 0x000007f8, 0x000007f9, 0x000007fa, 0x000007fb,
70  0x00000ff8, 0x00000ff9, 0x00000001, 0x00000039, 0x0000007b, 0x000000fb,
71  0x000001f8, 0x000001f9, 0x00000ffa, 0x00000ffb, 0x00001ff8, 0x00001ff9,
72  0x00001ffa, 0x00001ffb, 0x00003ff8, 0x00003ff9, 0x00003ffa, 0x00000000,
73  0x00000004, 0x0000003a, 0x000001fa, 0x00003ffb, 0x00007ff8, 0x00007ff9,
74  0x00007ffa, 0x00007ffb, 0x0000fff8, 0x0000fff9, 0x0000fffa, 0x0000fffb,
75  0x0001fff8, 0x0001fff9, 0x0001fffa, 0x00000000, 0x0000000c, 0x000000f8,
76  0x000001fb, 0x0001fffb, 0x0003fff8, 0x0003fff9, 0x0003fffa, 0x0003fffb,
77  0x0007fff8, 0x0007fff9, 0x0007fffa, 0x0007fffb, 0x000ffff8, 0x000ffff9,
78  0x000ffffa, 0x00000000, 0x0000001a, 0x000003f8, 0x000ffffb, 0x001ffff8,
79  0x001ffff9, 0x001ffffa, 0x001ffffb, 0x003ffff8, 0x003ffff9, 0x003ffffa,
80  0x003ffffb, 0x007ffff8, 0x007ffff9, 0x007ffffa, 0x007ffffb, 0x00000000,
81  0x0000003b, 0x000003f9, 0x00fffff8, 0x00fffff9, 0x00fffffa, 0x00fffffb,
82  0x01fffff8, 0x01fffff9, 0x01fffffa, 0x01fffffb, 0x03fffff8, 0x03fffff9,
83  0x03fffffa, 0x03fffffb, 0x07fffff8, 0x00000000, 0x000003fa, 0x07fffff9,
84  0x07fffffa, 0x07fffffb, 0x0ffffff8, 0x0ffffff9, 0x0ffffffa, 0x0ffffffb,
85  0x1ffffff8, 0x1ffffff9, 0x1ffffffa, 0x1ffffffb, 0x3ffffff8, 0x3ffffff9,
86  0x3ffffffa,
87 };
88 
89 static const uint8_t huffbits[] = {
90  4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
91  0, 0, 0, 0, 2, 4, 5, 6, 7, 7, 7, 8,
92  8, 10, 11, 11, 11, 11, 12, 12, 2, 6, 7, 8,
93  9, 9, 12, 12, 13, 13, 13, 13, 14, 14, 14, 0,
94  3, 6, 9, 14, 15, 15, 15, 15, 16, 16, 16, 16,
95  17, 17, 17, 0, 4, 8, 9, 17, 18, 18, 18, 18,
96  19, 19, 19, 19, 20, 20, 20, 0, 5, 10, 20, 21,
97  21, 21, 21, 22, 22, 22, 22, 23, 23, 23, 23, 0,
98  6, 10, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,
99  26, 26, 27, 0, 10, 27, 27, 27, 28, 28, 28, 28,
100  29, 29, 29, 29, 30, 30, 30,
101 };
102 
103 static const uint8_t col_zag[64] = {
104  0, 8, 1, 2, 9, 16, 24, 17,
105  10, 3, 4, 11, 18, 25, 32, 40,
106  33, 26, 19, 12, 5, 6, 13, 20,
107  27, 34, 41, 48, 56, 49, 42, 35,
108  28, 21, 14, 7, 15, 22, 29, 36,
109  43, 50, 57, 58, 51, 44, 37, 30,
110  23, 31, 38, 45, 52, 59, 39, 46,
111  53, 60, 61, 54, 47, 55, 62, 63,
112 };
113 
115 {
116  MimicContext *ctx = avctx->priv_data;
117  int i;
118 
119  av_free(ctx->swap_buf);
120 
121  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
122  if (ctx->frames[i].f)
123  ff_thread_release_buffer(avctx, &ctx->frames[i]);
124  av_frame_free(&ctx->frames[i].f);
125  }
126 
127  if (!avctx->internal->is_copy)
128  ff_free_vlc(&ctx->vlc);
129 
130  return 0;
131 }
132 
134 {
135  MimicContext *ctx = avctx->priv_data;
136  int ret, i;
137 
138  avctx->internal->allocate_progress = 1;
139 
140  ctx->prev_index = 0;
141  ctx->cur_index = 15;
142 
143  if ((ret = init_vlc(&ctx->vlc, 11, FF_ARRAY_ELEMS(huffbits),
144  huffbits, 1, 1, huffcodes, 4, 4, 0)) < 0) {
145  av_log(avctx, AV_LOG_ERROR, "error initializing vlc table\n");
146  return ret;
147  }
148  ff_dsputil_init(&ctx->dsp, avctx);
149  ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
151 
152  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
153  ctx->frames[i].f = av_frame_alloc();
154  if (!ctx->frames[i].f) {
155  mimic_decode_end(avctx);
156  return AVERROR(ENOMEM);
157  }
158  }
159 
160  return 0;
161 }
162 
164 {
165  MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
166  int i, ret;
167 
168  if (avctx == avctx_from)
169  return 0;
170 
171  dst->cur_index = src->next_cur_index;
172  dst->prev_index = src->next_prev_index;
173 
174  memcpy(dst->flipped_ptrs, src->flipped_ptrs, sizeof(src->flipped_ptrs));
175 
176  for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
177  ff_thread_release_buffer(avctx, &dst->frames[i]);
178  if (src->frames[i].f->data[0]) {
179  ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
180  if (ret < 0)
181  return ret;
182  }
183  }
184 
185  return 0;
186 }
187 
188 static const int8_t vlcdec_lookup[9][64] = {
189  { 0, },
190  { -1, 1, },
191  { -3, 3, -2, 2, },
192  { -7, 7, -6, 6, -5, 5, -4, 4, },
193  { -15, 15, -14, 14, -13, 13, -12, 12,
194  -11, 11, -10, 10, -9, 9, -8, 8, },
195  { -31, 31, -30, 30, -29, 29, -28, 28,
196  -27, 27, -26, 26, -25, 25, -24, 24,
197  -23, 23, -22, 22, -21, 21, -20, 20,
198  -19, 19, -18, 18, -17, 17, -16, 16, },
199  { -63, 63, -62, 62, -61, 61, -60, 60,
200  -59, 59, -58, 58, -57, 57, -56, 56,
201  -55, 55, -54, 54, -53, 53, -52, 52,
202  -51, 51, -50, 50, -49, 49, -48, 48,
203  -47, 47, -46, 46, -45, 45, -44, 44,
204  -43, 43, -42, 42, -41, 41, -40, 40,
205  -39, 39, -38, 38, -37, 37, -36, 36,
206  -35, 35, -34, 34, -33, 33, -32, 32, },
207  { -127, 127, -126, 126, -125, 125, -124, 124,
208  -123, 123, -122, 122, -121, 121, -120, 120,
209  -119, 119, -118, 118, -117, 117, -116, 116,
210  -115, 115, -114, 114, -113, 113, -112, 112,
211  -111, 111, -110, 110, -109, 109, -108, 108,
212  -107, 107, -106, 106, -105, 105, -104, 104,
213  -103, 103, -102, 102, -101, 101, -100, 100,
214  -99, 99, -98, 98, -97, 97, -96, 96, },
215  { -95, 95, -94, 94, -93, 93, -92, 92,
216  -91, 91, -90, 90, -89, 89, -88, 88,
217  -87, 87, -86, 86, -85, 85, -84, 84,
218  -83, 83, -82, 82, -81, 81, -80, 80,
219  -79, 79, -78, 78, -77, 77, -76, 76,
220  -75, 75, -74, 74, -73, 73, -72, 72,
221  -71, 71, -70, 70, -69, 69, -68, 68,
222  -67, 67, -66, 66, -65, 65, -64, 64, },
223 };
224 
225 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
226 {
227  int16_t *block = ctx->dct_block;
228  unsigned int pos;
229 
230  ctx->dsp.clear_block(block);
231 
232  block[0] = get_bits(&ctx->gb, 8) << 3;
233 
234  for (pos = 1; pos < num_coeffs; pos++) {
235  uint32_t vlc, num_bits;
236  int value;
237  int coeff;
238 
239  vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3);
240  if (!vlc) /* end-of-block code */
241  return 0;
242  if (vlc == -1)
243  return AVERROR_INVALIDDATA;
244 
245  /* pos_add and num_bits are coded in the vlc code */
246  pos += vlc & 15; // pos_add
247  num_bits = vlc >> 4; // num_bits
248 
249  if (pos >= 64)
250  return AVERROR_INVALIDDATA;
251 
252  value = get_bits(&ctx->gb, num_bits);
253 
254  /* Libav's IDCT behaves somewhat different from the original code, so
255  * a factor of 4 was added to the input */
256 
257  coeff = vlcdec_lookup[num_bits][value];
258  if (pos < 3)
259  coeff <<= 4;
260  else /* TODO Use >> 10 instead of / 1001 */
261  coeff = (coeff * qscale) / 1001;
262 
263  block[ctx->scantable.permutated[pos]] = coeff;
264  }
265 
266  return 0;
267 }
268 
269 static int decode(MimicContext *ctx, int quality, int num_coeffs,
270  int is_iframe)
271 {
272  int ret, y, x, plane, cur_row = 0;
273 
274  for (plane = 0; plane < 3; plane++) {
275  const int is_chroma = !!plane;
276  const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
277  10000) << 2;
278  const int stride = ctx->flipped_ptrs[ctx->cur_index ].linesize[plane];
279  const uint8_t *src = ctx->flipped_ptrs[ctx->prev_index].data[plane];
280  uint8_t *dst = ctx->flipped_ptrs[ctx->cur_index ].data[plane];
281 
282  for (y = 0; y < ctx->num_vblocks[plane]; y++) {
283  for (x = 0; x < ctx->num_hblocks[plane]; x++) {
284  /* Check for a change condition in the current block.
285  * - iframes always change.
286  * - Luma plane changes on get_bits1 == 0
287  * - Chroma planes change on get_bits1 == 1 */
288  if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
289  /* Luma planes may use a backreference from the 15 last
290  * frames preceding the previous. (get_bits1 == 1)
291  * Chroma planes don't use backreferences. */
292  if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
293  if ((ret = vlc_decode_block(ctx, num_coeffs,
294  qscale)) < 0) {
295  av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
296  "block.\n");
297  return ret;
298  }
299  ctx->dsp.idct_put(dst, stride, ctx->dct_block);
300  } else {
301  unsigned int backref = get_bits(&ctx->gb, 4);
302  int index = (ctx->cur_index + backref) & 15;
303  uint8_t *p = ctx->flipped_ptrs[index].data[0];
304 
305  if (index != ctx->cur_index && p) {
306  ff_thread_await_progress(&ctx->frames[index],
307  cur_row, 0);
308  p += src -
309  ctx->flipped_ptrs[ctx->prev_index].data[plane];
310  ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
311  } else {
312  av_log(ctx->avctx, AV_LOG_ERROR,
313  "No such backreference! Buggy sample.\n");
314  }
315  }
316  } else {
318  cur_row, 0);
319  ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
320  }
321  src += 8;
322  dst += 8;
323  }
324  src += (stride - ctx->num_hblocks[plane]) << 3;
325  dst += (stride - ctx->num_hblocks[plane]) << 3;
326 
328  cur_row++, 0);
329  }
330  }
331 
332  return 0;
333 }
334 
339 static void prepare_avpic(MimicContext *ctx, AVPicture *dst, AVFrame *src)
340 {
341  int i;
342  dst->data[0] = src->data[0] + ( ctx->avctx->height - 1) * src->linesize[0];
343  dst->data[1] = src->data[2] + ((ctx->avctx->height >> 1) - 1) * src->linesize[2];
344  dst->data[2] = src->data[1] + ((ctx->avctx->height >> 1) - 1) * src->linesize[1];
345  for (i = 0; i < 3; i++)
346  dst->linesize[i] = -src->linesize[i];
347 }
348 
349 static int mimic_decode_frame(AVCodecContext *avctx, void *data,
350  int *got_frame, AVPacket *avpkt)
351 {
352  const uint8_t *buf = avpkt->data;
353  int buf_size = avpkt->size;
354  int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;
355  MimicContext *ctx = avctx->priv_data;
356  GetByteContext gb;
357  int is_pframe;
358  int width, height;
359  int quality, num_coeffs;
360  int res;
361 
362  if (buf_size <= MIMIC_HEADER_SIZE) {
363  av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
364  return AVERROR_INVALIDDATA;
365  }
366 
367  bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);
368  bytestream2_skip(&gb, 2); /* some constant (always 256) */
369  quality = bytestream2_get_le16u(&gb);
370  width = bytestream2_get_le16u(&gb);
371  height = bytestream2_get_le16u(&gb);
372  bytestream2_skip(&gb, 4); /* some constant */
373  is_pframe = bytestream2_get_le32u(&gb);
374  num_coeffs = bytestream2_get_byteu(&gb);
375  bytestream2_skip(&gb, 3); /* some constant */
376 
377  if (!ctx->avctx) {
378  int i;
379 
380  if (!(width == 160 && height == 120) &&
381  !(width == 320 && height == 240)) {
382  av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
383  return AVERROR_INVALIDDATA;
384  }
385 
386  ctx->avctx = avctx;
387  avctx->width = width;
388  avctx->height = height;
389  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
390  for (i = 0; i < 3; i++) {
391  ctx->num_vblocks[i] = -((-height) >> (3 + !!i));
392  ctx->num_hblocks[i] = width >> (3 + !!i);
393  }
394  } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
395  avpriv_request_sample(avctx, "Resolution changing");
396  return AVERROR_PATCHWELCOME;
397  }
398 
399  if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
400  av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
401  return AVERROR_INVALIDDATA;
402  }
403 
404  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
405  ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
407  if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
408  AV_GET_BUFFER_FLAG_REF)) < 0) {
409  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
410  return res;
411  }
412 
413  ctx->next_prev_index = ctx->cur_index;
414  ctx->next_cur_index = (ctx->cur_index - 1) & 15;
415 
416  prepare_avpic(ctx, &ctx->flipped_ptrs[ctx->cur_index],
417  ctx->frames[ctx->cur_index].f);
418 
419  ff_thread_finish_setup(avctx);
420 
421  av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
422  if (!ctx->swap_buf)
423  return AVERROR(ENOMEM);
424 
425  ctx->dsp.bswap_buf(ctx->swap_buf,
426  (const uint32_t*) (buf + MIMIC_HEADER_SIZE),
427  swap_buf_size >> 2);
428  init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
429 
430  res = decode(ctx, quality, num_coeffs, !is_pframe);
431  ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
432  if (res < 0) {
433  if (!(avctx->active_thread_type & FF_THREAD_FRAME)) {
434  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
435  return res;
436  }
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  ctx->prev_index = ctx->next_prev_index;
444  ctx->cur_index = ctx->next_cur_index;
445 
446  /* Only release frames that aren't used for backreferences anymore */
447  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
448 
449  return buf_size;
450 }
451 
453 {
454  MimicContext *ctx = avctx->priv_data;
455  int i;
456 
457  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
458  ctx->frames[i].f = av_frame_alloc();
459  if (!ctx->frames[i].f) {
460  mimic_decode_end(avctx);
461  return AVERROR(ENOMEM);
462  }
463  }
464 
465  return 0;
466 }
467 
469  .name = "mimic",
470  .long_name = NULL_IF_CONFIG_SMALL("Mimic"),
471  .type = AVMEDIA_TYPE_VIDEO,
472  .id = AV_CODEC_ID_MIMIC,
473  .priv_data_size = sizeof(MimicContext),
477  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
479  .init_thread_copy = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy),
480 };
av_cold void ff_dsputil_init(DSPContext *c, AVCodecContext *avctx)
Definition: dsputil.c:2440
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
static const uint8_t col_zag[64]
Definition: mimic.c:103
int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
Definition: avcodec.h:2952
This structure describes decoded (raw) audio or video data.
Definition: frame.h:107
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
AVFrame * f
Definition: thread.h:36
int next_cur_index
Definition: mimic.c:60
ScanTable scantable
Definition: mimic.c:54
Scantable.
Definition: dsputil.h:111
int size
Definition: avcodec.h:974
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:58
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1247
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:130
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:70
#define FF_ARRAY_ELEMS(a)
uint8_t permutated[64]
Definition: dsputil.h:113
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
four components are given, that's all.
Definition: avcodec.h:2950
int prev_index
Definition: mimic.c:46
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:2755
AVPicture flipped_ptrs[16]
Definition: mimic.c:49
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:269
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: dsputil.h:220
uint8_t
#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:43
uint8_t * data[AV_NUM_DATA_POINTERS]
Definition: avcodec.h:2951
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:174
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:711
const char data[16]
Definition: mxf.c:66
uint8_t * data
Definition: avcodec.h:973
GetBitContext gb
Definition: mimic.c:53
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:2237
bitstream reader API header.
uint8_t idct_permutation[64]
idct input permutation.
Definition: dsputil.h:240
ThreadFrame frames[16]
Definition: mimic.c:48
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_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:186
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: dsputil.h:202
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
Definition: internal.h:64
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:159
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:55
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:142
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2533
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1142
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:148
const char * name
Name of the codec implementation.
Definition: avcodec.h:2762
static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
Definition: mimic.c:452
static const int8_t vlcdec_lookup[9][64]
Definition: mimic.c:188
Definition: get_bits.h:64
static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
Definition: mimic.c:225
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:182
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:37
Half-pel DSP context.
Definition: hpeldsp.h:45
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:168
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2525
static av_cold int mimic_decode_end(AVCodecContext *avctx)
Definition: mimic.c:114
int width
picture width / height.
Definition: avcodec.h:1217
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:522
static const uint8_t huffbits[]
Definition: mimic.c:89
int bits
Definition: get_bits.h:65
#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:133
static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
Definition: mimic.c:163
Half-pel DSP functions.
static int width
Definition: utils.c:156
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:125
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:51
main external API structure.
Definition: avcodec.h:1054
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:489
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: dsputil.c:107
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:424
op_pixels_func put_pixels_tab[4][4]
Halfpel motion compensation with rounding (a+b+1)>>1.
Definition: hpeldsp.h:56
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:271
int cur_index
Definition: mimic.c:45
int index
Definition: gxfenc.c:72
AVCodecContext * avctx
Definition: mimic.c:37
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:375
int next_prev_index
Definition: mimic.c:61
static const uint32_t huffcodes[]
Definition: mimic.c:64
int allocate_progress
Whether to allocate progress for frame threading.
Definition: internal.h:79
int num_vblocks[3]
Definition: mimic.c:39
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:113
int height
Definition: gxfenc.c:72
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:339
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
common internal api header.
AVCodec ff_mimic_decoder
Definition: mimic.c:468
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:782
void(* clear_block)(int16_t *block)
Definition: dsputil.h:142
static int mimic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mimic.c:349
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:498
DSP utils.
void * priv_data
Definition: avcodec.h:1090
#define MIMIC_HEADER_SIZE
Definition: mimic.c:34
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1098
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:66
VLC vlc
Definition: mimic.c:57
int swap_buf_size
Definition: mimic.c:43
void * swap_buf
Definition: mimic.c:42
This structure stores compressed data.
Definition: avcodec.h:950
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:333
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:877
int num_hblocks[3]
Definition: mimic.c:40
for(j=16;j >0;--j)
HpelDSPContext hdsp
Definition: mimic.c:56
Predicted.
Definition: avutil.h:254
DSPContext.
Definition: dsputil.h:124
DSPContext dsp
Definition: mimic.c:55
static int16_t block[64]
Definition: dct-test.c:170