FFmpeg
mimic.c
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2005 Ole André Vadla Ravnås <oleavr@gmail.com>
3  * Copyright (C) 2008 Ramiro Polla
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdlib.h>
23 #include <string.h>
24 #include <stdint.h>
25 
26 #include "libavutil/mem_internal.h"
27 #include "libavutil/thread.h"
28 
29 #include "avcodec.h"
30 #include "blockdsp.h"
31 #include "codec_internal.h"
32 #include "internal.h"
33 #include "get_bits.h"
34 #include "bytestream.h"
35 #include "bswapdsp.h"
36 #include "hpeldsp.h"
37 #include "idctdsp.h"
38 #include "thread.h"
39 #include "threadframe.h"
40 
41 #define MIMIC_HEADER_SIZE 20
42 #define MIMIC_VLC_BITS 11
43 
44 typedef struct MimicContext {
46 
47  int num_vblocks[3];
48  int num_hblocks[3];
49 
50  void *swap_buf;
52 
53  int cur_index;
55 
57 
58  DECLARE_ALIGNED(32, int16_t, dct_block)[64];
59 
66 
67  /* Kept in the context so multithreading can have a constant to read from */
70 } MimicContext;
71 
72 static VLC block_vlc;
73 
74 static const uint8_t huffsyms[] = {
75  0x10, 0x20, 0x30, 0x00, 0x11, 0x40, 0x50, 0x12, 0x13, 0x21, 0x31, 0x60,
76  0x14, 0x15, 0x16, 0x22, 0x41, 0x17, 0x18, 0x23, 0x24, 0x25, 0x32, 0x42,
77  0x51, 0x61, 0x70, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x26, 0x27,
78  0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x33, 0x34, 0x35, 0x36, 0x37,
79  0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x43, 0x44, 0x45, 0x46, 0x47,
80  0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x52, 0x53, 0x54, 0x55, 0x56,
81  0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x62, 0x63, 0x64, 0x65,
82  0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, 0x73,
83  0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
84 };
85 
86 static const uint8_t huffbits[] = {
87  2, 2, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8,
88  8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12,
89  13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17,
90  17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21,
91  22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,
92  26, 26, 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30,
93 };
94 
95 static const uint8_t col_zag[64] = {
96  0, 8, 1, 2, 9, 16, 24, 17,
97  10, 3, 4, 11, 18, 25, 32, 40,
98  33, 26, 19, 12, 5, 6, 13, 20,
99  27, 34, 41, 48, 56, 49, 42, 35,
100  28, 21, 14, 7, 15, 22, 29, 36,
101  43, 50, 57, 58, 51, 44, 37, 30,
102  23, 31, 38, 45, 52, 59, 39, 46,
103  53, 60, 61, 54, 47, 55, 62, 63,
104 };
105 
107 {
108  MimicContext *ctx = avctx->priv_data;
109  int i;
110 
111  av_freep(&ctx->swap_buf);
112  ctx->swap_buf_size = 0;
113 
114  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
115  if (ctx->frames[i].f)
116  ff_thread_release_ext_buffer(avctx, &ctx->frames[i]);
117  av_frame_free(&ctx->frames[i].f);
118  }
119 
120  return 0;
121 }
122 
123 static av_cold void mimic_init_static(void)
124 {
126  huffbits, 1, huffsyms, 1, 1, 0, 0, 4368);
127 }
128 
130 {
131  static AVOnce init_static_once = AV_ONCE_INIT;
132  MimicContext *ctx = avctx->priv_data;
133  int i;
134 
135  ctx->prev_index = 0;
136  ctx->cur_index = 15;
137 
138  ff_blockdsp_init(&ctx->bdsp, avctx);
139  ff_bswapdsp_init(&ctx->bbdsp);
140  ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
141  ff_idctdsp_init(&ctx->idsp, avctx);
142  ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, col_zag);
143 
144  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
145  ctx->frames[i].f = av_frame_alloc();
146  if (!ctx->frames[i].f)
147  return AVERROR(ENOMEM);
148  }
149 
150  ff_thread_once(&init_static_once, mimic_init_static);
151 
152  return 0;
153 }
154 
155 #if HAVE_THREADS
156 static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
157 {
158  MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
159  int i, ret;
160 
161  if (avctx == avctx_from)
162  return 0;
163 
164  dst->cur_index = src->next_cur_index;
165  dst->prev_index = src->next_prev_index;
166 
167  for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
168  ff_thread_release_ext_buffer(avctx, &dst->frames[i]);
169  if (i != src->next_cur_index && src->frames[i].f->data[0]) {
170  ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
171  if (ret < 0)
172  return ret;
173  }
174  }
175 
176  return 0;
177 }
178 #endif
179 
180 static const int8_t vlcdec_lookup[9][64] = {
181  { 0, },
182  { -1, 1, },
183  { -3, 3, -2, 2, },
184  { -7, 7, -6, 6, -5, 5, -4, 4, },
185  { -15, 15, -14, 14, -13, 13, -12, 12,
186  -11, 11, -10, 10, -9, 9, -8, 8, },
187  { -31, 31, -30, 30, -29, 29, -28, 28,
188  -27, 27, -26, 26, -25, 25, -24, 24,
189  -23, 23, -22, 22, -21, 21, -20, 20,
190  -19, 19, -18, 18, -17, 17, -16, 16, },
191  { -63, 63, -62, 62, -61, 61, -60, 60,
192  -59, 59, -58, 58, -57, 57, -56, 56,
193  -55, 55, -54, 54, -53, 53, -52, 52,
194  -51, 51, -50, 50, -49, 49, -48, 48,
195  -47, 47, -46, 46, -45, 45, -44, 44,
196  -43, 43, -42, 42, -41, 41, -40, 40,
197  -39, 39, -38, 38, -37, 37, -36, 36,
198  -35, 35, -34, 34, -33, 33, -32, 32, },
199  { -127, 127, -126, 126, -125, 125, -124, 124,
200  -123, 123, -122, 122, -121, 121, -120, 120,
201  -119, 119, -118, 118, -117, 117, -116, 116,
202  -115, 115, -114, 114, -113, 113, -112, 112,
203  -111, 111, -110, 110, -109, 109, -108, 108,
204  -107, 107, -106, 106, -105, 105, -104, 104,
205  -103, 103, -102, 102, -101, 101, -100, 100,
206  -99, 99, -98, 98, -97, 97, -96, 96, },
207  { -95, 95, -94, 94, -93, 93, -92, 92,
208  -91, 91, -90, 90, -89, 89, -88, 88,
209  -87, 87, -86, 86, -85, 85, -84, 84,
210  -83, 83, -82, 82, -81, 81, -80, 80,
211  -79, 79, -78, 78, -77, 77, -76, 76,
212  -75, 75, -74, 74, -73, 73, -72, 72,
213  -71, 71, -70, 70, -69, 69, -68, 68,
214  -67, 67, -66, 66, -65, 65, -64, 64, },
215 };
216 
217 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
218 {
219  int16_t *block = ctx->dct_block;
220  unsigned int pos;
221 
222  ctx->bdsp.clear_block(block);
223 
224  block[0] = get_bits(&ctx->gb, 8) << 3;
225 
226  for (pos = 1; pos < num_coeffs; pos++) {
227  uint32_t vlc, num_bits;
228  int value;
229  int coeff;
230 
231  vlc = get_vlc2(&ctx->gb, block_vlc.table, MIMIC_VLC_BITS, 3);
232  if (!vlc) /* end-of-block code */
233  return 0;
234  if (vlc == -1)
235  return AVERROR_INVALIDDATA;
236 
237  /* pos_add and num_bits are coded in the vlc code */
238  pos += vlc & 15; // pos_add
239  num_bits = vlc >> 4; // num_bits
240 
241  if (pos >= 64)
242  return AVERROR_INVALIDDATA;
243 
244  value = get_bits(&ctx->gb, num_bits);
245 
246  /* FFmpeg's IDCT behaves somewhat different from the original code, so
247  * a factor of 4 was added to the input */
248 
249  coeff = ((int8_t*)vlcdec_lookup[num_bits])[value];
250  if (pos < 3)
251  coeff *= 16;
252  else /* TODO Use >> 10 instead of / 1001 */
253  coeff = (coeff * qscale) / 1001;
254 
255  block[ctx->scantable.permutated[pos]] = coeff;
256  }
257 
258  return 0;
259 }
260 
261 static int decode(MimicContext *ctx, int quality, int num_coeffs,
262  int is_iframe)
263 {
264  int ret, y, x, plane, cur_row = 0;
265 
266  for (plane = 0; plane < 3; plane++) {
267  const int is_chroma = !!plane;
268  const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
269  10000) << 2;
270  const int stride = ctx->frames[ctx->cur_index ].f->linesize[plane];
271  uint8_t *dst = ctx->frames[ctx->cur_index ].f->data[plane];
272  /* src is unused for I frames; set to avoid UB pointer arithmetic. */
273  const uint8_t *src = is_iframe ? dst : ctx->frames[ctx->prev_index].f->data[plane];
274 
275  for (y = 0; y < ctx->num_vblocks[plane]; y++) {
276  for (x = 0; x < ctx->num_hblocks[plane]; x++) {
277  /* Check for a change condition in the current block.
278  * - iframes always change.
279  * - Luma plane changes on get_bits1 == 0
280  * - Chroma planes change on get_bits1 == 1 */
281  if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
282  /* Luma planes may use a backreference from the 15 last
283  * frames preceding the previous. (get_bits1 == 1)
284  * Chroma planes don't use backreferences. */
285  if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
286  if ((ret = vlc_decode_block(ctx, num_coeffs,
287  qscale)) < 0) {
288  av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
289  "block.\n");
290  return ret;
291  }
292  ctx->idsp.idct_put(dst, stride, ctx->dct_block);
293  } else {
294  unsigned int backref = get_bits(&ctx->gb, 4);
295  int index = (ctx->cur_index + backref) & 15;
296  uint8_t *p = ctx->frames[index].f->data[0];
297 
298  if (index != ctx->cur_index && p) {
300  cur_row, 0);
301  p += src -
302  ctx->frames[ctx->prev_index].f->data[plane];
303  ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
304  } else {
305  av_log(ctx->avctx, AV_LOG_ERROR,
306  "No such backreference! Buggy sample.\n");
307  }
308  }
309  } else {
310  ff_thread_await_progress(&ctx->frames[ctx->prev_index],
311  cur_row, 0);
312  ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
313  }
314  src += 8;
315  dst += 8;
316  }
317  src += (stride - ctx->num_hblocks[plane]) << 3;
318  dst += (stride - ctx->num_hblocks[plane]) << 3;
319 
320  ff_thread_report_progress(&ctx->frames[ctx->cur_index],
321  cur_row++, 0);
322  }
323  }
324 
325  return 0;
326 }
327 
328 /**
329  * Flip the buffer upside-down and put it in the YVU order to revert the
330  * way Mimic encodes frames.
331  */
332 static void flip_swap_frame(AVFrame *f)
333 {
334  int i;
335  uint8_t *data_1 = f->data[1];
336  f->data[0] = f->data[0] + ( f->height - 1) * f->linesize[0];
337  f->data[1] = f->data[2] + ((f->height >> 1) - 1) * f->linesize[2];
338  f->data[2] = data_1 + ((f->height >> 1) - 1) * f->linesize[1];
339  for (i = 0; i < 3; i++)
340  f->linesize[i] *= -1;
341 }
342 
343 static int mimic_decode_frame(AVCodecContext *avctx, AVFrame *rframe,
344  int *got_frame, AVPacket *avpkt)
345 {
346  const uint8_t *buf = avpkt->data;
347  int buf_size = avpkt->size;
348  int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;
349  MimicContext *ctx = avctx->priv_data;
350  GetByteContext gb;
351  int is_pframe;
352  int width, height;
353  int quality, num_coeffs;
354  int res;
355 
356  if (buf_size <= MIMIC_HEADER_SIZE) {
357  av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
358  return AVERROR_INVALIDDATA;
359  }
360 
362  bytestream2_skip(&gb, 2); /* some constant (always 256) */
363  quality = bytestream2_get_le16u(&gb);
364  width = bytestream2_get_le16u(&gb);
365  height = bytestream2_get_le16u(&gb);
366  bytestream2_skip(&gb, 4); /* some constant */
367  is_pframe = bytestream2_get_le32u(&gb);
368  num_coeffs = bytestream2_get_byteu(&gb);
369  bytestream2_skip(&gb, 3); /* some constant */
370 
371  if (!ctx->avctx) {
372  int i;
373 
374  if (!(width == 160 && height == 120) &&
375  !(width == 320 && height == 240)) {
376  av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
377  return AVERROR_INVALIDDATA;
378  }
379 
380  res = ff_set_dimensions(avctx, width, height);
381  if (res < 0)
382  return res;
383 
384  ctx->avctx = avctx;
385  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
386  for (i = 0; i < 3; i++) {
387  ctx->num_vblocks[i] = AV_CEIL_RSHIFT(height, 3 + !!i);
388  ctx->num_hblocks[i] = width >> (3 + !!i);
389  }
390  } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
391  avpriv_request_sample(avctx, "Resolution changing");
392  return AVERROR_PATCHWELCOME;
393  }
394 
395  if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
396  av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
397  return AVERROR_INVALIDDATA;
398  }
399 
400  ff_thread_release_ext_buffer(avctx, &ctx->frames[ctx->cur_index]);
401  ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
403  if ((res = ff_thread_get_ext_buffer(avctx, &ctx->frames[ctx->cur_index],
405  return res;
406 
407  ctx->next_prev_index = ctx->cur_index;
408  ctx->next_cur_index = (ctx->cur_index - 1) & 15;
409 
410  ff_thread_finish_setup(avctx);
411 
412  av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
413  if (!ctx->swap_buf)
414  return AVERROR(ENOMEM);
415 
416  ctx->bbdsp.bswap_buf(ctx->swap_buf,
417  (const uint32_t *) (buf + MIMIC_HEADER_SIZE),
418  swap_buf_size >> 2);
419  init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
420 
421  res = decode(ctx, quality, num_coeffs, !is_pframe);
422  ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
423  if (res < 0) {
424  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
425  ff_thread_release_ext_buffer(avctx, &ctx->frames[ctx->cur_index]);
426  return res;
427  }
428 
429  if ((res = av_frame_ref(rframe, ctx->frames[ctx->cur_index].f)) < 0)
430  return res;
431  *got_frame = 1;
432 
433  flip_swap_frame(rframe);
434 
435  ctx->prev_index = ctx->next_prev_index;
436  ctx->cur_index = ctx->next_cur_index;
437 
438  return buf_size;
439 }
440 
442  .p.name = "mimic",
443  .p.long_name = NULL_IF_CONFIG_SMALL("Mimic"),
444  .p.type = AVMEDIA_TYPE_VIDEO,
445  .p.id = AV_CODEC_ID_MIMIC,
446  .priv_data_size = sizeof(MimicContext),
448  .close = mimic_decode_end,
450  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
451  .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context),
452  .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS |
454 };
MimicContext::hdsp
HpelDSPContext hdsp
Definition: mimic.c:64
bswapdsp.h
MimicContext::next_prev_index
int next_prev_index
Definition: mimic.c:69
MimicContext::idsp
IDCTDSPContext idsp
Definition: mimic.c:65
av_clip
#define av_clip
Definition: common.h:95
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:41
huffsyms
static const uint8_t huffsyms[]
Definition: mimic.c:74
MIMIC_HEADER_SIZE
#define MIMIC_HEADER_SIZE
Definition: mimic.c:41
blockdsp.h
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
huffbits
static const uint8_t huffbits[]
Definition: mimic.c:86
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(AVCodecContext *avctx, ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:1141
mem_internal.h
GetByteContext
Definition: bytestream.h:33
thread.h
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:116
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:325
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
FFCodec
Definition: codec_internal.h:118
mimic_init_static
static av_cold void mimic_init_static(void)
Definition: mimic.c:123
BlockDSPContext
Definition: blockdsp.h:34
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:649
thread.h
ff_thread_await_progress
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them. reget_buffer() and buffer age optimizations no longer work. *The contents of buffers must not be written to after ff_thread_report_progress() has been called on them. This includes draw_edges(). Porting codecs to frame threading
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:240
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
init
static int init
Definition: av_tx.c:47
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:122
AV_CODEC_ID_MIMIC
@ AV_CODEC_ID_MIMIC
Definition: codec_id.h:163
GetBitContext
Definition: get_bits.h:61
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:478
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:104
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:179
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
MimicContext::swap_buf_size
int swap_buf_size
Definition: mimic.c:51
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:595
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:50
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:376
ff_mimic_decoder
const FFCodec ff_mimic_decoder
Definition: mimic.c:441
MimicContext::cur_index
int cur_index
Definition: mimic.c:53
ctx
AVFormatContext * ctx
Definition: movenc.c:48
get_bits.h
flip_swap_frame
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:332
MimicContext::bbdsp
BswapDSPContext bbdsp
Definition: mimic.c:63
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:891
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:113
threadframe.h
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:177
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
INIT_VLC_STATIC_FROM_LENGTHS
#define INIT_VLC_STATIC_FROM_LENGTHS(vlc, bits, nb_codes, lens, len_wrap, symbols, symbols_wrap, symbols_size, offset, flags, static_size)
Definition: vlc.h:131
MimicContext::swap_buf
void * swap_buf
Definition: mimic.c:50
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:156
block_vlc
static VLC block_vlc
Definition: mimic.c:72
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:787
AVOnce
#define AVOnce
Definition: thread.h:176
index
int index
Definition: gxfenc.c:89
mimic_decode_end
static av_cold int mimic_decode_end(AVCodecContext *avctx)
Definition: mimic.c:106
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:45
f
f
Definition: af_crystalizer.c:122
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:375
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
av_frame_ref
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:353
codec_internal.h
MimicContext::avctx
AVCodecContext * avctx
Definition: mimic.c:45
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: codec_internal.h:68
mimic_decode_init
static av_cold int mimic_decode_init(AVCodecContext *avctx)
Definition: mimic.c:129
height
#define height
MimicContext::dct_block
int16_t dct_block[64]
Definition: mimic.c:58
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1483
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
MimicContext::num_hblocks
int num_hblocks[3]
Definition: mimic.c:48
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
ff_init_scantable
av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:30
MimicContext::next_cur_index
int next_cur_index
Definition: mimic.c:68
decode
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:261
vlcdec_lookup
static const int8_t vlcdec_lookup[9][64]
Definition: mimic.c:180
av_fast_padded_malloc
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:48
MIMIC_VLC_BITS
#define MIMIC_VLC_BITS
Definition: mimic.c:42
value
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default value
Definition: writing_filters.txt:86
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
ff_thread_get_ext_buffer
int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around ff_get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1043
idctdsp.h
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
vlc_decode_block
static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
Definition: mimic.c:217
ret
ret
Definition: filter_design.txt:187
mimic_decode_frame
static int mimic_decode_frame(AVCodecContext *avctx, AVFrame *rframe, int *got_frame, AVPacket *avpkt)
Definition: mimic.c:343
pos
unsigned int pos
Definition: spdifenc.c:412
IDCTDSPContext
Definition: idctdsp.h:53
ff_thread_finish_setup
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call ff_thread_finish_setup() afterwards. If some code can 't be moved
AVCodecContext
main external API structure.
Definition: avcodec.h:398
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1491
ThreadFrame
Definition: threadframe.h:27
MimicContext
Definition: mimic.c:44
VLC
Definition: vlc.h:31
MimicContext::frames
ThreadFrame frames[16]
Definition: mimic.c:56
VLC::table
VLCElem * table
Definition: vlc.h:33
col_zag
static const uint8_t col_zag[64]
Definition: mimic.c:95
MimicContext::prev_index
int prev_index
Definition: mimic.c:54
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_set_dimensions
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:90
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
ScanTable
Scantable.
Definition: idctdsp.h:31
MimicContext::gb
GetBitContext gb
Definition: mimic.c:60
MimicContext::scantable
ScanTable scantable
Definition: mimic.c:61
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:425
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
bytestream.h
MimicContext::bdsp
BlockDSPContext bdsp
Definition: mimic.c:62
hpeldsp.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
coeff
static const double coeff[2][5]
Definition: vf_owdenoise.c:78
block
The exact code depends on how similar the blocks are and how related they are to the block
Definition: filter_design.txt:207
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
BswapDSPContext
Definition: bswapdsp.h:24
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c, AVCodecContext *avctx)
Definition: blockdsp.c:59
MimicContext::num_vblocks
int num_vblocks[3]
Definition: mimic.c:47