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 "internal.h"
32 #include "get_bits.h"
33 #include "bytestream.h"
34 #include "bswapdsp.h"
35 #include "hpeldsp.h"
36 #include "idctdsp.h"
37 #include "thread.h"
38 
39 #define MIMIC_HEADER_SIZE 20
40 #define MIMIC_VLC_BITS 11
41 
42 typedef struct MimicContext {
44 
45  int num_vblocks[3];
46  int num_hblocks[3];
47 
48  void *swap_buf;
50 
51  int cur_index;
53 
55 
56  DECLARE_ALIGNED(32, int16_t, dct_block)[64];
57 
64 
65  /* Kept in the context so multithreading can have a constant to read from */
68 } MimicContext;
69 
70 static VLC block_vlc;
71 
72 static const uint8_t huffsyms[] = {
73  0x10, 0x20, 0x30, 0x00, 0x11, 0x40, 0x50, 0x12, 0x13, 0x21, 0x31, 0x60,
74  0x14, 0x15, 0x16, 0x22, 0x41, 0x17, 0x18, 0x23, 0x24, 0x25, 0x32, 0x42,
75  0x51, 0x61, 0x70, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x26, 0x27,
76  0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x33, 0x34, 0x35, 0x36, 0x37,
77  0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x43, 0x44, 0x45, 0x46, 0x47,
78  0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x52, 0x53, 0x54, 0x55, 0x56,
79  0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x62, 0x63, 0x64, 0x65,
80  0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, 0x73,
81  0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
82 };
83 
84 static const uint8_t huffbits[] = {
85  2, 2, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8,
86  8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12,
87  13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17,
88  17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21,
89  22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,
90  26, 26, 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30,
91 };
92 
93 static const uint8_t col_zag[64] = {
94  0, 8, 1, 2, 9, 16, 24, 17,
95  10, 3, 4, 11, 18, 25, 32, 40,
96  33, 26, 19, 12, 5, 6, 13, 20,
97  27, 34, 41, 48, 56, 49, 42, 35,
98  28, 21, 14, 7, 15, 22, 29, 36,
99  43, 50, 57, 58, 51, 44, 37, 30,
100  23, 31, 38, 45, 52, 59, 39, 46,
101  53, 60, 61, 54, 47, 55, 62, 63,
102 };
103 
105 {
106  MimicContext *ctx = avctx->priv_data;
107  int i;
108 
109  av_freep(&ctx->swap_buf);
110  ctx->swap_buf_size = 0;
111 
112  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
113  if (ctx->frames[i].f)
114  ff_thread_release_buffer(avctx, &ctx->frames[i]);
115  av_frame_free(&ctx->frames[i].f);
116  }
117 
118  return 0;
119 }
120 
121 static av_cold void mimic_init_static(void)
122 {
124  huffbits, 1, huffsyms, 1, 1, 0, 0, 4368);
125 }
126 
128 {
129  static AVOnce init_static_once = AV_ONCE_INIT;
130  MimicContext *ctx = avctx->priv_data;
131  int i;
132 
133  ctx->prev_index = 0;
134  ctx->cur_index = 15;
135 
136  ff_blockdsp_init(&ctx->bdsp, avctx);
137  ff_bswapdsp_init(&ctx->bbdsp);
138  ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
139  ff_idctdsp_init(&ctx->idsp, avctx);
140  ff_init_scantable(ctx->idsp.idct_permutation, &ctx->scantable, col_zag);
141 
142  for (i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++) {
143  ctx->frames[i].f = av_frame_alloc();
144  if (!ctx->frames[i].f)
145  return AVERROR(ENOMEM);
146  }
147 
148  ff_thread_once(&init_static_once, mimic_init_static);
149 
150  return 0;
151 }
152 
153 #if HAVE_THREADS
154 static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
155 {
156  MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
157  int i, ret;
158 
159  if (avctx == avctx_from)
160  return 0;
161 
162  dst->cur_index = src->next_cur_index;
163  dst->prev_index = src->next_prev_index;
164 
165  for (i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
166  ff_thread_release_buffer(avctx, &dst->frames[i]);
167  if (i != src->next_cur_index && src->frames[i].f->data[0]) {
168  ret = ff_thread_ref_frame(&dst->frames[i], &src->frames[i]);
169  if (ret < 0)
170  return ret;
171  }
172  }
173 
174  return 0;
175 }
176 #endif
177 
178 static const int8_t vlcdec_lookup[9][64] = {
179  { 0, },
180  { -1, 1, },
181  { -3, 3, -2, 2, },
182  { -7, 7, -6, 6, -5, 5, -4, 4, },
183  { -15, 15, -14, 14, -13, 13, -12, 12,
184  -11, 11, -10, 10, -9, 9, -8, 8, },
185  { -31, 31, -30, 30, -29, 29, -28, 28,
186  -27, 27, -26, 26, -25, 25, -24, 24,
187  -23, 23, -22, 22, -21, 21, -20, 20,
188  -19, 19, -18, 18, -17, 17, -16, 16, },
189  { -63, 63, -62, 62, -61, 61, -60, 60,
190  -59, 59, -58, 58, -57, 57, -56, 56,
191  -55, 55, -54, 54, -53, 53, -52, 52,
192  -51, 51, -50, 50, -49, 49, -48, 48,
193  -47, 47, -46, 46, -45, 45, -44, 44,
194  -43, 43, -42, 42, -41, 41, -40, 40,
195  -39, 39, -38, 38, -37, 37, -36, 36,
196  -35, 35, -34, 34, -33, 33, -32, 32, },
197  { -127, 127, -126, 126, -125, 125, -124, 124,
198  -123, 123, -122, 122, -121, 121, -120, 120,
199  -119, 119, -118, 118, -117, 117, -116, 116,
200  -115, 115, -114, 114, -113, 113, -112, 112,
201  -111, 111, -110, 110, -109, 109, -108, 108,
202  -107, 107, -106, 106, -105, 105, -104, 104,
203  -103, 103, -102, 102, -101, 101, -100, 100,
204  -99, 99, -98, 98, -97, 97, -96, 96, },
205  { -95, 95, -94, 94, -93, 93, -92, 92,
206  -91, 91, -90, 90, -89, 89, -88, 88,
207  -87, 87, -86, 86, -85, 85, -84, 84,
208  -83, 83, -82, 82, -81, 81, -80, 80,
209  -79, 79, -78, 78, -77, 77, -76, 76,
210  -75, 75, -74, 74, -73, 73, -72, 72,
211  -71, 71, -70, 70, -69, 69, -68, 68,
212  -67, 67, -66, 66, -65, 65, -64, 64, },
213 };
214 
215 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
216 {
217  int16_t *block = ctx->dct_block;
218  unsigned int pos;
219 
220  ctx->bdsp.clear_block(block);
221 
222  block[0] = get_bits(&ctx->gb, 8) << 3;
223 
224  for (pos = 1; pos < num_coeffs; pos++) {
225  uint32_t vlc, num_bits;
226  int value;
227  int coeff;
228 
229  vlc = get_vlc2(&ctx->gb, block_vlc.table, MIMIC_VLC_BITS, 3);
230  if (!vlc) /* end-of-block code */
231  return 0;
232  if (vlc == -1)
233  return AVERROR_INVALIDDATA;
234 
235  /* pos_add and num_bits are coded in the vlc code */
236  pos += vlc & 15; // pos_add
237  num_bits = vlc >> 4; // num_bits
238 
239  if (pos >= 64)
240  return AVERROR_INVALIDDATA;
241 
242  value = get_bits(&ctx->gb, num_bits);
243 
244  /* FFmpeg's IDCT behaves somewhat different from the original code, so
245  * a factor of 4 was added to the input */
246 
247  coeff = ((int8_t*)vlcdec_lookup[num_bits])[value];
248  if (pos < 3)
249  coeff *= 16;
250  else /* TODO Use >> 10 instead of / 1001 */
251  coeff = (coeff * qscale) / 1001;
252 
253  block[ctx->scantable.permutated[pos]] = coeff;
254  }
255 
256  return 0;
257 }
258 
259 static int decode(MimicContext *ctx, int quality, int num_coeffs,
260  int is_iframe)
261 {
262  int ret, y, x, plane, cur_row = 0;
263 
264  for (plane = 0; plane < 3; plane++) {
265  const int is_chroma = !!plane;
266  const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
267  10000) << 2;
268  const int stride = ctx->frames[ctx->cur_index ].f->linesize[plane];
269  const uint8_t *src = ctx->frames[ctx->prev_index].f->data[plane];
270  uint8_t *dst = ctx->frames[ctx->cur_index ].f->data[plane];
271 
272  for (y = 0; y < ctx->num_vblocks[plane]; y++) {
273  for (x = 0; x < ctx->num_hblocks[plane]; x++) {
274  /* Check for a change condition in the current block.
275  * - iframes always change.
276  * - Luma plane changes on get_bits1 == 0
277  * - Chroma planes change on get_bits1 == 1 */
278  if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
279  /* Luma planes may use a backreference from the 15 last
280  * frames preceding the previous. (get_bits1 == 1)
281  * Chroma planes don't use backreferences. */
282  if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
283  if ((ret = vlc_decode_block(ctx, num_coeffs,
284  qscale)) < 0) {
285  av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
286  "block.\n");
287  return ret;
288  }
289  ctx->idsp.idct_put(dst, stride, ctx->dct_block);
290  } else {
291  unsigned int backref = get_bits(&ctx->gb, 4);
292  int index = (ctx->cur_index + backref) & 15;
293  uint8_t *p = ctx->frames[index].f->data[0];
294 
295  if (index != ctx->cur_index && p) {
297  cur_row, 0);
298  p += src -
299  ctx->frames[ctx->prev_index].f->data[plane];
300  ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
301  } else {
302  av_log(ctx->avctx, AV_LOG_ERROR,
303  "No such backreference! Buggy sample.\n");
304  }
305  }
306  } else {
307  ff_thread_await_progress(&ctx->frames[ctx->prev_index],
308  cur_row, 0);
309  ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
310  }
311  src += 8;
312  dst += 8;
313  }
314  src += (stride - ctx->num_hblocks[plane]) << 3;
315  dst += (stride - ctx->num_hblocks[plane]) << 3;
316 
317  ff_thread_report_progress(&ctx->frames[ctx->cur_index],
318  cur_row++, 0);
319  }
320  }
321 
322  return 0;
323 }
324 
325 /**
326  * Flip the buffer upside-down and put it in the YVU order to revert the
327  * way Mimic encodes frames.
328  */
329 static void flip_swap_frame(AVFrame *f)
330 {
331  int i;
332  uint8_t *data_1 = f->data[1];
333  f->data[0] = f->data[0] + ( f->height - 1) * f->linesize[0];
334  f->data[1] = f->data[2] + ((f->height >> 1) - 1) * f->linesize[2];
335  f->data[2] = data_1 + ((f->height >> 1) - 1) * f->linesize[1];
336  for (i = 0; i < 3; i++)
337  f->linesize[i] *= -1;
338 }
339 
340 static int mimic_decode_frame(AVCodecContext *avctx, void *data,
341  int *got_frame, AVPacket *avpkt)
342 {
343  const uint8_t *buf = avpkt->data;
344  int buf_size = avpkt->size;
345  int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;
346  MimicContext *ctx = avctx->priv_data;
347  GetByteContext gb;
348  int is_pframe;
349  int width, height;
350  int quality, num_coeffs;
351  int res;
352 
353  if (buf_size <= MIMIC_HEADER_SIZE) {
354  av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
355  return AVERROR_INVALIDDATA;
356  }
357 
359  bytestream2_skip(&gb, 2); /* some constant (always 256) */
360  quality = bytestream2_get_le16u(&gb);
361  width = bytestream2_get_le16u(&gb);
362  height = bytestream2_get_le16u(&gb);
363  bytestream2_skip(&gb, 4); /* some constant */
364  is_pframe = bytestream2_get_le32u(&gb);
365  num_coeffs = bytestream2_get_byteu(&gb);
366  bytestream2_skip(&gb, 3); /* some constant */
367 
368  if (!ctx->avctx) {
369  int i;
370 
371  if (!(width == 160 && height == 120) &&
372  !(width == 320 && height == 240)) {
373  av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
374  return AVERROR_INVALIDDATA;
375  }
376 
377  res = ff_set_dimensions(avctx, width, height);
378  if (res < 0)
379  return res;
380 
381  ctx->avctx = avctx;
382  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
383  for (i = 0; i < 3; i++) {
384  ctx->num_vblocks[i] = AV_CEIL_RSHIFT(height, 3 + !!i);
385  ctx->num_hblocks[i] = width >> (3 + !!i);
386  }
387  } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
388  avpriv_request_sample(avctx, "Resolution changing");
389  return AVERROR_PATCHWELCOME;
390  }
391 
392  if (is_pframe && !ctx->frames[ctx->prev_index].f->data[0]) {
393  av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
394  return AVERROR_INVALIDDATA;
395  }
396 
397  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
398  ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
400  if ((res = ff_thread_get_buffer(avctx, &ctx->frames[ctx->cur_index],
402  return res;
403 
404  ctx->next_prev_index = ctx->cur_index;
405  ctx->next_cur_index = (ctx->cur_index - 1) & 15;
406 
407  ff_thread_finish_setup(avctx);
408 
409  av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
410  if (!ctx->swap_buf)
411  return AVERROR(ENOMEM);
412 
413  ctx->bbdsp.bswap_buf(ctx->swap_buf,
414  (const uint32_t *) (buf + MIMIC_HEADER_SIZE),
415  swap_buf_size >> 2);
416  init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
417 
418  res = decode(ctx, quality, num_coeffs, !is_pframe);
419  ff_thread_report_progress(&ctx->frames[ctx->cur_index], INT_MAX, 0);
420  if (res < 0) {
421  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
422  ff_thread_release_buffer(avctx, &ctx->frames[ctx->cur_index]);
423  return res;
424  }
425 
426  if ((res = av_frame_ref(data, ctx->frames[ctx->cur_index].f)) < 0)
427  return res;
428  *got_frame = 1;
429 
431 
432  ctx->prev_index = ctx->next_prev_index;
433  ctx->cur_index = ctx->next_cur_index;
434 
435  return buf_size;
436 }
437 
439  .name = "mimic",
440  .long_name = NULL_IF_CONFIG_SMALL("Mimic"),
441  .type = AVMEDIA_TYPE_VIDEO,
442  .id = AV_CODEC_ID_MIMIC,
443  .priv_data_size = sizeof(MimicContext),
445  .close = mimic_decode_end,
448  .update_thread_context = ONLY_IF_THREADS_ENABLED(mimic_decode_update_thread_context),
449  .caps_internal = FF_CODEC_CAP_ALLOCATE_PROGRESS |
451 };
MimicContext::hdsp
HpelDSPContext hdsp
Definition: mimic.c:62
AVCodec
AVCodec.
Definition: codec.h:197
bswapdsp.h
stride
int stride
Definition: mace.c:144
MimicContext::next_prev_index
int next_prev_index
Definition: mimic.c:67
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:42
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
MimicContext::idsp
IDCTDSPContext idsp
Definition: mimic.c:63
av_clip
#define av_clip
Definition: common.h:96
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
huffsyms
static const uint8_t huffsyms[]
Definition: mimic.c:72
MIMIC_HEADER_SIZE
#define MIMIC_HEADER_SIZE
Definition: mimic.c:39
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:84
mem_internal.h
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:877
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:112
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
index
fg index
Definition: ffmpeg_filter.c:168
mimic_decode_frame
static int mimic_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: mimic.c:340
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:373
data
const char data[16]
Definition: mxf.c:143
get_vlc2
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:798
mimic_init_static
static av_cold void mimic_init_static(void)
Definition: mimic.c:121
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:660
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
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
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:380
AV_CODEC_ID_MIMIC
@ AV_CODEC_ID_MIMIC
Definition: codec_id.h:163
GetBitContext
Definition: get_bits.h:62
ff_thread_get_buffer
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 have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:459
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:99
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:175
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:49
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:587
width
#define width
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:51
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:357
MimicContext::cur_index
int cur_index
Definition: mimic.c:51
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:329
MimicContext::bbdsp
BswapDSPContext bbdsp
Definition: mimic.c:61
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
f
#define f(width, name)
Definition: cbs_vp9.c:255
ff_hpeldsp_init
av_cold void ff_hpeldsp_init(HpelDSPContext *c, int flags)
Definition: hpeldsp.c:338
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
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:126
MimicContext::swap_buf
void * swap_buf
Definition: mimic.c:48
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:499
src
#define src
Definition: vp8dsp.c:255
ONLY_IF_THREADS_ENABLED
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:155
ff_mimic_decoder
const AVCodec ff_mimic_decoder
Definition: mimic.c:438
block_vlc
static VLC block_vlc
Definition: mimic.c:70
AVOnce
#define AVOnce
Definition: thread.h:172
mimic_decode_end
static av_cold int mimic_decode_end(AVCodecContext *avctx)
Definition: mimic.c:104
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
ff_thread_release_buffer
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
Definition: pthread_frame.c:1097
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:45
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:374
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:116
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:327
MimicContext::avctx
AVCodecContext * avctx
Definition: mimic.c:43
mimic_decode_init
static av_cold int mimic_decode_init(AVCodecContext *avctx)
Definition: mimic.c:127
height
#define height
MimicContext::dct_block
int16_t dct_block[64]
Definition: mimic.c:56
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1447
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
MimicContext::num_hblocks
int num_hblocks[3]
Definition: mimic.c:46
i
int i
Definition: input.c:406
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: internal.h:50
MimicContext::next_cur_index
int next_cur_index
Definition: mimic.c:66
decode
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:259
vlcdec_lookup
static const int8_t vlcdec_lookup[9][64]
Definition: mimic.c:178
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:50
MIMIC_VLC_BITS
#define MIMIC_VLC_BITS
Definition: mimic.c:40
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
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:238
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
update_thread_context
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 have update_thread_context() run it in the next thread. Add AV_CODEC_CAP_FRAME_THREADS to the codec capabilities. There will be very little speed gain at this point but it should work. If there are inter-frame dependencies
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:589
idctdsp.h
avcodec.h
vlc_decode_block
static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
Definition: mimic.c:215
ret
ret
Definition: filter_design.txt:187
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:379
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1455
ThreadFrame
Definition: thread.h:34
MimicContext
Definition: mimic.c:42
VLC
Definition: vlc.h:26
MimicContext::frames
ThreadFrame frames[16]
Definition: mimic.c:54
col_zag
static const uint8_t col_zag[64]
Definition: mimic.c:93
MimicContext::prev_index
int prev_index
Definition: mimic.c:52
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:86
FF_CODEC_CAP_ALLOCATE_PROGRESS
#define FF_CODEC_CAP_ALLOCATE_PROGRESS
Definition: internal.h:77
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
ScanTable
Scantable.
Definition: idctdsp.h:31
MimicContext::gb
GetBitContext gb
Definition: mimic.c:58
MimicContext::scantable
ScanTable scantable
Definition: mimic.c:59
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:406
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
bytestream.h
MimicContext::bdsp
BlockDSPContext bdsp
Definition: mimic.c:60
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:73
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:28
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
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
MimicContext::num_vblocks
int num_vblocks[3]
Definition: mimic.c:45