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 {
40 
41  int num_vblocks[3];
42  int num_hblocks[3];
43 
44  void *swap_buf;
46 
47  int cur_index;
49 
50  ThreadFrame frames [16];
51  AVPicture flipped_ptrs[16];
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_free(ctx->swap_buf);
124 
125  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
126  if (ctx->frames[i].f)
127  ff_thread_release_buffer(avctx, &ctx->frames[i]);
128  av_frame_free(&ctx->frames[i].f);
129  }
130 
131  if (!avctx->internal->is_copy)
132  ff_free_vlc(&ctx->vlc);
133 
134  return 0;
135 }
136 
138 {
139  MimicContext *ctx = avctx->priv_data;
140  int ret, i;
141 
142  avctx->internal->allocate_progress = 1;
143 
144  ctx->prev_index = 0;
145  ctx->cur_index = 15;
146 
147  if ((ret = init_vlc(&ctx->vlc, 11, FF_ARRAY_ELEMS(huffbits),
148  huffbits, 1, 1, huffcodes, 4, 4, 0)) < 0) {
149  av_log(avctx, AV_LOG_ERROR, "error initializing vlc table\n");
150  return ret;
151  }
152  ff_blockdsp_init(&ctx->bdsp, avctx);
153  ff_bswapdsp_init(&ctx->bbdsp);
154  ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
155  ff_idctdsp_init(&ctx->idsp, avctx);
157 
158  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
159  ctx->frames[i].f = av_frame_alloc();
160  if (!ctx->frames[i].f) {
161  mimic_decode_end(avctx);
162  return AVERROR(ENOMEM);
163  }
164  }
165 
166  return 0;
167 }
168 
170 {
171  MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
172  int i, ret;
173 
174  if (avctx == avctx_from)
175  return 0;
176 
177  dst->cur_index = src->next_cur_index;
178  dst->prev_index = src->next_prev_index;
179 
180  memcpy(dst->flipped_ptrs, src->flipped_ptrs, sizeof(src->flipped_ptrs));
181 
182  for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
183  ff_thread_release_buffer(avctx, &dst->frames[i]);
184  if (src->frames[i].f->data[0]) {
185  ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
186  if (ret < 0)
187  return ret;
188  }
189  }
190 
191  return 0;
192 }
193 
194 static const int8_t vlcdec_lookup[9][64] = {
195  { 0, },
196  { -1, 1, },
197  { -3, 3, -2, 2, },
198  { -7, 7, -6, 6, -5, 5, -4, 4, },
199  { -15, 15, -14, 14, -13, 13, -12, 12,
200  -11, 11, -10, 10, -9, 9, -8, 8, },
201  { -31, 31, -30, 30, -29, 29, -28, 28,
202  -27, 27, -26, 26, -25, 25, -24, 24,
203  -23, 23, -22, 22, -21, 21, -20, 20,
204  -19, 19, -18, 18, -17, 17, -16, 16, },
205  { -63, 63, -62, 62, -61, 61, -60, 60,
206  -59, 59, -58, 58, -57, 57, -56, 56,
207  -55, 55, -54, 54, -53, 53, -52, 52,
208  -51, 51, -50, 50, -49, 49, -48, 48,
209  -47, 47, -46, 46, -45, 45, -44, 44,
210  -43, 43, -42, 42, -41, 41, -40, 40,
211  -39, 39, -38, 38, -37, 37, -36, 36,
212  -35, 35, -34, 34, -33, 33, -32, 32, },
213  { -127, 127, -126, 126, -125, 125, -124, 124,
214  -123, 123, -122, 122, -121, 121, -120, 120,
215  -119, 119, -118, 118, -117, 117, -116, 116,
216  -115, 115, -114, 114, -113, 113, -112, 112,
217  -111, 111, -110, 110, -109, 109, -108, 108,
218  -107, 107, -106, 106, -105, 105, -104, 104,
219  -103, 103, -102, 102, -101, 101, -100, 100,
220  -99, 99, -98, 98, -97, 97, -96, 96, },
221  { -95, 95, -94, 94, -93, 93, -92, 92,
222  -91, 91, -90, 90, -89, 89, -88, 88,
223  -87, 87, -86, 86, -85, 85, -84, 84,
224  -83, 83, -82, 82, -81, 81, -80, 80,
225  -79, 79, -78, 78, -77, 77, -76, 76,
226  -75, 75, -74, 74, -73, 73, -72, 72,
227  -71, 71, -70, 70, -69, 69, -68, 68,
228  -67, 67, -66, 66, -65, 65, -64, 64, },
229 };
230 
231 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
232 {
233  int16_t *block = ctx->dct_block;
234  unsigned int pos;
235 
236  ctx->bdsp.clear_block(block);
237 
238  block[0] = get_bits(&ctx->gb, 8) << 3;
239 
240  for (pos = 1; pos < num_coeffs; pos++) {
241  uint32_t vlc, num_bits;
242  int value;
243  int coeff;
244 
245  vlc = get_vlc2(&ctx->gb, ctx->vlc.table, ctx->vlc.bits, 3);
246  if (!vlc) /* end-of-block code */
247  return 0;
248  if (vlc == -1)
249  return AVERROR_INVALIDDATA;
250 
251  /* pos_add and num_bits are coded in the vlc code */
252  pos += vlc & 15; // pos_add
253  num_bits = vlc >> 4; // num_bits
254 
255  if (pos >= 64)
256  return AVERROR_INVALIDDATA;
257 
258  value = get_bits(&ctx->gb, num_bits);
259 
260  /* Libav's IDCT behaves somewhat different from the original code, so
261  * a factor of 4 was added to the input */
262 
263  coeff = vlcdec_lookup[num_bits][value];
264  if (pos < 3)
265  coeff <<= 4;
266  else /* TODO Use >> 10 instead of / 1001 */
267  coeff = (coeff * qscale) / 1001;
268 
269  block[ctx->scantable.permutated[pos]] = coeff;
270  }
271 
272  return 0;
273 }
274 
275 static int decode(MimicContext *ctx, int quality, int num_coeffs,
276  int is_iframe)
277 {
278  int ret, y, x, plane, cur_row = 0;
279 
280  for (plane = 0; plane < 3; plane++) {
281  const int is_chroma = !!plane;
282  const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
283  10000) << 2;
284  const int stride = ctx->flipped_ptrs[ctx->cur_index ].linesize[plane];
285  const uint8_t *src = ctx->flipped_ptrs[ctx->prev_index].data[plane];
286  uint8_t *dst = ctx->flipped_ptrs[ctx->cur_index ].data[plane];
287 
288  for (y = 0; y < ctx->num_vblocks[plane]; y++) {
289  for (x = 0; x < ctx->num_hblocks[plane]; x++) {
290  /* Check for a change condition in the current block.
291  * - iframes always change.
292  * - Luma plane changes on get_bits1 == 0
293  * - Chroma planes change on get_bits1 == 1 */
294  if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
295  /* Luma planes may use a backreference from the 15 last
296  * frames preceding the previous. (get_bits1 == 1)
297  * Chroma planes don't use backreferences. */
298  if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
299  if ((ret = vlc_decode_block(ctx, num_coeffs,
300  qscale)) < 0) {
301  av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
302  "block.\n");
303  return ret;
304  }
305  ctx->idsp.idct_put(dst, stride, ctx->dct_block);
306  } else {
307  unsigned int backref = get_bits(&ctx->gb, 4);
308  int index = (ctx->cur_index + backref) & 15;
309  uint8_t *p = ctx->flipped_ptrs[index].data[0];
310 
311  if (index != ctx->cur_index && p) {
312  ff_thread_await_progress(&ctx->frames[index],
313  cur_row, 0);
314  p += src -
315  ctx->flipped_ptrs[ctx->prev_index].data[plane];
316  ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
317  } else {
318  av_log(ctx->avctx, AV_LOG_ERROR,
319  "No such backreference! Buggy sample.\n");
320  }
321  }
322  } else {
324  cur_row, 0);
325  ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
326  }
327  src += 8;
328  dst += 8;
329  }
330  src += (stride - ctx->num_hblocks[plane]) << 3;
331  dst += (stride - ctx->num_hblocks[plane]) << 3;
332 
334  cur_row++, 0);
335  }
336  }
337 
338  return 0;
339 }
340 
345 static void prepare_avpic(MimicContext *ctx, AVPicture *dst, AVFrame *src)
346 {
347  int i;
348  dst->data[0] = src->data[0] + ( ctx->avctx->height - 1) * src->linesize[0];
349  dst->data[1] = src->data[2] + ((ctx->avctx->height >> 1) - 1) * src->linesize[2];
350  dst->data[2] = src->data[1] + ((ctx->avctx->height >> 1) - 1) * src->linesize[1];
351  for (i = 0; i < 3; i++)
352  dst->linesize[i] = -src->linesize[i];
353 }
354 
355 static int mimic_decode_frame(AVCodecContext *avctx, void *data,
356  int *got_frame, AVPacket *avpkt)
357 {
358  const uint8_t *buf = avpkt->data;
359  int buf_size = avpkt->size;
360  int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;
361  MimicContext *ctx = avctx->priv_data;
362  GetByteContext gb;
363  int is_pframe;
364  int width, height;
365  int quality, num_coeffs;
366  int res;
367 
368  if (buf_size <= MIMIC_HEADER_SIZE) {
369  av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
370  return AVERROR_INVALIDDATA;
371  }
372 
373  bytestream2_init(&gb, buf, MIMIC_HEADER_SIZE);
374  bytestream2_skip(&gb, 2); /* some constant (always 256) */
375  quality = bytestream2_get_le16u(&gb);
376  width = bytestream2_get_le16u(&gb);
377  height = bytestream2_get_le16u(&gb);
378  bytestream2_skip(&gb, 4); /* some constant */
379  is_pframe = bytestream2_get_le32u(&gb);
380  num_coeffs = bytestream2_get_byteu(&gb);
381  bytestream2_skip(&gb, 3); /* some constant */
382 
383  if (!ctx->avctx) {
384  int i;
385 
386  if (!(width == 160 && height == 120) &&
387  !(width == 320 && height == 240)) {
388  av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
389  return AVERROR_INVALIDDATA;
390  }
391 
392  ctx->avctx = avctx;
393  avctx->width = width;
394  avctx->height = height;
395  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
396  for (i = 0; i < 3; i++) {
397  ctx->num_vblocks[i] = -((-height) >> (3 + !!i));
398  ctx->num_hblocks[i] = width >> (3 + !!i);
399  }
400  } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
401  avpriv_request_sample(avctx, "Resolution changing");
402  return AVERROR_PATCHWELCOME;
403  }
404 
405  if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
406  av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
407  return AVERROR_INVALIDDATA;
408  }
409 
410  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
411  ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
413  if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
414  AV_GET_BUFFER_FLAG_REF)) < 0) {
415  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
416  return res;
417  }
418 
419  ctx->next_prev_index = ctx->cur_index;
420  ctx->next_cur_index = (ctx->cur_index - 1) & 15;
421 
422  prepare_avpic(ctx, &ctx->flipped_ptrs[ctx->cur_index],
423  ctx->frames[ctx->cur_index].f);
424 
425  ff_thread_finish_setup(avctx);
426 
427  av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
428  if (!ctx->swap_buf)
429  return AVERROR(ENOMEM);
430 
431  ctx->bbdsp.bswap_buf(ctx->swap_buf,
432  (const uint32_t *) (buf + MIMIC_HEADER_SIZE),
433  swap_buf_size >> 2);
434  init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
435 
436  res = decode(ctx, quality, num_coeffs, !is_pframe);
437  ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
438  if (res < 0) {
439  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
440  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
441  return res;
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  return buf_size;
452 }
453 
455 {
456  MimicContext *ctx = avctx->priv_data;
457  int i;
458 
459  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
460  ctx->frames[i].f = av_frame_alloc();
461  if (!ctx->frames[i].f) {
462  mimic_decode_end(avctx);
463  return AVERROR(ENOMEM);
464  }
465  }
466 
467  return 0;
468 }
469 
471  .name = "mimic",
472  .long_name = NULL_IF_CONFIG_SMALL("Mimic"),
473  .type = AVMEDIA_TYPE_VIDEO,
474  .id = AV_CODEC_ID_MIMIC,
475  .priv_data_size = sizeof(MimicContext),
479  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
481  .init_thread_copy = ONLY_IF_THREADS_ENABLED(mimic_init_thread_copy),
482 };
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
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:3044
This structure describes decoded (raw) audio or video data.
Definition: frame.h:135
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:240
AVFrame * f
Definition: thread.h:36
int next_cur_index
Definition: mimic.c:64
ScanTable scantable
Definition: mimic.c:56
Scantable.
Definition: idctdsp.h:29
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:1270
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:59
#define FF_ARRAY_ELEMS(a)
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.
four components are given, that's all.
Definition: avcodec.h:3042
int prev_index
Definition: mimic.c:48
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:2812
AVPicture flipped_ptrs[16]
Definition: mimic.c:51
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:275
void void avpriv_request_sample(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
uint8_t
IDCTDSPContext idsp
Definition: mimic.c:60
#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:57
uint8_t * data[AV_NUM_DATA_POINTERS]
Definition: avcodec.h:3043
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:188
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:684
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:973
GetBitContext gb
Definition: mimic.c:55
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
Definition: utils.c:2349
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_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.
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
Definition: internal.h:66
#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:69
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:145
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2575
BswapDSPContext bbdsp
Definition: mimic.c:58
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1144
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
const char * name
Name of the codec implementation.
Definition: avcodec.h:2819
static av_cold int mimic_init_thread_copy(AVCodecContext *avctx)
Definition: mimic.c:454
static const int8_t vlcdec_lookup[9][64]
Definition: mimic.c:194
Definition: get_bits.h:64
static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
Definition: mimic.c:231
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:185
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
Half-pel DSP context.
Definition: hpeldsp.h:45
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:196
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2567
static av_cold int mimic_decode_end(AVCodecContext *avctx)
Definition: mimic.c:118
int width
picture width / height.
Definition: avcodec.h:1229
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
uint8_t idct_permutation[64]
IDCT input permutation.
Definition: idctdsp.h:94
static const uint8_t huffbits[]
Definition: mimic.c:93
int bits
Definition: get_bits.h:65
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
void(* idct_put)(uint8_t *dest, int line_size, int16_t *block)
block -> idct -> clip to unsigned 8 bit -> dest.
Definition: idctdsp.h:70
static av_cold int mimic_decode_init(AVCodecContext *avctx)
Definition: mimic.c:137
static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
Definition: mimic.c:169
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:153
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:1050
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:490
#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: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:375
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:81
int num_vblocks[3]
Definition: mimic.c:41
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:141
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:345
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:470
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:755
static int mimic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mimic.c:355
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:499
void * priv_data
Definition: avcodec.h:1092
#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:156
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1100
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:66
VLC vlc
Definition: mimic.c:61
int swap_buf_size
Definition: mimic.c:45
BlockDSPContext bdsp
Definition: mimic.c:57
void * swap_buf
Definition: mimic.c:44
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:850
int num_hblocks[3]
Definition: mimic.c:42
for(j=16;j >0;--j)
HpelDSPContext hdsp
Definition: mimic.c:59
Predicted.
Definition: avutil.h:254
static int16_t block[64]
Definition: dct-test.c:88