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 <stdint.h>
23 
24 #include "libavutil/mem.h"
25 #include "libavutil/mem_internal.h"
26 #include "libavutil/thread.h"
27 
28 #include "avcodec.h"
29 #include "blockdsp.h"
30 #include "codec_internal.h"
31 #include "decode.h"
32 #include "get_bits.h"
33 #include "bytestream.h"
34 #include "bswapdsp.h"
35 #include "hpeldsp.h"
36 #include "idctdsp.h"
37 #include "progressframe.h"
38 #include "thread.h"
39 
40 #define MIMIC_HEADER_SIZE 20
41 #define MIMIC_VLC_BITS 11
42 
43 typedef struct MimicContext {
45 
46  int num_vblocks[3];
47  int num_hblocks[3];
48 
49  void *swap_buf;
51 
52  int cur_index;
54 
56 
57  DECLARE_ALIGNED(32, int16_t, dct_block)[64];
58 
60  uint8_t permutated_scantable[64];
65 
66  /* Kept in the context so multithreading can have a constant to read from */
69 } MimicContext;
70 
71 static VLCElem block_vlc[4368];
72 
73 static const uint8_t huffsyms[] = {
74  0x10, 0x20, 0x30, 0x00, 0x11, 0x40, 0x50, 0x12, 0x13, 0x21, 0x31, 0x60,
75  0x14, 0x15, 0x16, 0x22, 0x41, 0x17, 0x18, 0x23, 0x24, 0x25, 0x32, 0x42,
76  0x51, 0x61, 0x70, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x26, 0x27,
77  0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x33, 0x34, 0x35, 0x36, 0x37,
78  0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x43, 0x44, 0x45, 0x46, 0x47,
79  0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x52, 0x53, 0x54, 0x55, 0x56,
80  0x57, 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x62, 0x63, 0x64, 0x65,
81  0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x71, 0x72, 0x73,
82  0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E,
83 };
84 
85 static const uint8_t huffbits[] = {
86  2, 2, 3, 4, 4, 4, 5, 5, 6, 6, 6, 6, 7, 7, 7, 7, 8, 8,
87  8, 8, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12,
88  13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 17, 17,
89  17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21,
90  22, 22, 22, 22, 23, 23, 23, 23, 24, 24, 24, 24, 25, 25, 25, 25, 26, 26,
91  26, 26, 27, 27, 27, 27, 28, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30,
92 };
93 
94 static const uint8_t col_zag[64] = {
95  0, 8, 1, 2, 9, 16, 24, 17,
96  10, 3, 4, 11, 18, 25, 32, 40,
97  33, 26, 19, 12, 5, 6, 13, 20,
98  27, 34, 41, 48, 56, 49, 42, 35,
99  28, 21, 14, 7, 15, 22, 29, 36,
100  43, 50, 57, 58, 51, 44, 37, 30,
101  23, 31, 38, 45, 52, 59, 39, 46,
102  53, 60, 61, 54, 47, 55, 62, 63,
103 };
104 
106 {
107  MimicContext *ctx = avctx->priv_data;
108 
109  av_freep(&ctx->swap_buf);
110  ctx->swap_buf_size = 0;
111 
112  for (int i = 0; i < FF_ARRAY_ELEMS(ctx->frames); i++)
113  ff_progress_frame_unref(&ctx->frames[i]);
114 
115  return 0;
116 }
117 
118 static av_cold void mimic_init_static(void)
119 {
122  huffbits, 1, huffsyms, 1, 1, 0, 0);
123 }
124 
126 {
127  static AVOnce init_static_once = AV_ONCE_INIT;
128  MimicContext *ctx = avctx->priv_data;
129 
130  ctx->prev_index = 0;
131  ctx->cur_index = 15;
132 
133  ff_blockdsp_init(&ctx->bdsp);
134  ff_bswapdsp_init(&ctx->bbdsp);
135  ff_hpeldsp_init(&ctx->hdsp, avctx->flags);
136  ff_idctdsp_init(&ctx->idsp, avctx);
137  ff_permute_scantable(ctx->permutated_scantable, col_zag, ctx->idsp.idct_permutation);
138 
139  ff_thread_once(&init_static_once, mimic_init_static);
140 
141  return 0;
142 }
143 
144 #if HAVE_THREADS
145 static int mimic_decode_update_thread_context(AVCodecContext *avctx, const AVCodecContext *avctx_from)
146 {
147  MimicContext *dst = avctx->priv_data, *src = avctx_from->priv_data;
148 
149  if (avctx == avctx_from)
150  return 0;
151 
152  dst->cur_index = src->next_cur_index;
153  dst->prev_index = src->next_prev_index;
154 
155  for (int i = 0; i < FF_ARRAY_ELEMS(dst->frames); i++) {
157  if (i != src->next_cur_index && src->frames[i].f)
158  ff_progress_frame_ref(&dst->frames[i], &src->frames[i]);
159  }
160 
161  return 0;
162 }
163 #endif
164 
165 static const int8_t vlcdec_lookup[9][64] = {
166  { 0, },
167  { -1, 1, },
168  { -3, 3, -2, 2, },
169  { -7, 7, -6, 6, -5, 5, -4, 4, },
170  { -15, 15, -14, 14, -13, 13, -12, 12,
171  -11, 11, -10, 10, -9, 9, -8, 8, },
172  { -31, 31, -30, 30, -29, 29, -28, 28,
173  -27, 27, -26, 26, -25, 25, -24, 24,
174  -23, 23, -22, 22, -21, 21, -20, 20,
175  -19, 19, -18, 18, -17, 17, -16, 16, },
176  { -63, 63, -62, 62, -61, 61, -60, 60,
177  -59, 59, -58, 58, -57, 57, -56, 56,
178  -55, 55, -54, 54, -53, 53, -52, 52,
179  -51, 51, -50, 50, -49, 49, -48, 48,
180  -47, 47, -46, 46, -45, 45, -44, 44,
181  -43, 43, -42, 42, -41, 41, -40, 40,
182  -39, 39, -38, 38, -37, 37, -36, 36,
183  -35, 35, -34, 34, -33, 33, -32, 32, },
184  { -127, 127, -126, 126, -125, 125, -124, 124,
185  -123, 123, -122, 122, -121, 121, -120, 120,
186  -119, 119, -118, 118, -117, 117, -116, 116,
187  -115, 115, -114, 114, -113, 113, -112, 112,
188  -111, 111, -110, 110, -109, 109, -108, 108,
189  -107, 107, -106, 106, -105, 105, -104, 104,
190  -103, 103, -102, 102, -101, 101, -100, 100,
191  -99, 99, -98, 98, -97, 97, -96, 96, },
192  { -95, 95, -94, 94, -93, 93, -92, 92,
193  -91, 91, -90, 90, -89, 89, -88, 88,
194  -87, 87, -86, 86, -85, 85, -84, 84,
195  -83, 83, -82, 82, -81, 81, -80, 80,
196  -79, 79, -78, 78, -77, 77, -76, 76,
197  -75, 75, -74, 74, -73, 73, -72, 72,
198  -71, 71, -70, 70, -69, 69, -68, 68,
199  -67, 67, -66, 66, -65, 65, -64, 64, },
200 };
201 
202 static int vlc_decode_block(MimicContext *ctx, int num_coeffs, int qscale)
203 {
204  int16_t *block = ctx->dct_block;
205  unsigned int pos;
206 
207  ctx->bdsp.clear_block(block);
208 
209  block[0] = get_bits(&ctx->gb, 8) << 3;
210 
211  for (pos = 1; pos < num_coeffs; pos++) {
212  uint32_t vlc, num_bits;
213  int value;
214  int coeff;
215 
216  vlc = get_vlc2(&ctx->gb, block_vlc, MIMIC_VLC_BITS, 3);
217  if (!vlc) /* end-of-block code */
218  return 0;
219  if (vlc == -1)
220  return AVERROR_INVALIDDATA;
221 
222  /* pos_add and num_bits are coded in the vlc code */
223  pos += vlc & 15; // pos_add
224  num_bits = vlc >> 4; // num_bits
225 
226  if (pos >= 64)
227  return AVERROR_INVALIDDATA;
228 
229  value = get_bits(&ctx->gb, num_bits);
230 
231  /* FFmpeg's IDCT behaves somewhat different from the original code, so
232  * a factor of 4 was added to the input */
233 
234  coeff = ((int8_t*)vlcdec_lookup[num_bits])[value];
235  if (pos < 3)
236  coeff *= 16;
237  else /* TODO Use >> 10 instead of / 1001 */
238  coeff = (coeff * qscale) / 1001;
239 
240  block[ctx->permutated_scantable[pos]] = coeff;
241  }
242 
243  return 0;
244 }
245 
246 static int decode(MimicContext *ctx, int quality, int num_coeffs,
247  int is_iframe)
248 {
249  int ret, y, x, plane, cur_row = 0;
250 
251  for (plane = 0; plane < 3; plane++) {
252  const int is_chroma = !!plane;
253  const int qscale = av_clip(10000 - quality, is_chroma ? 1000 : 2000,
254  10000) << 2;
255  const int stride = ctx->frames[ctx->cur_index ].f->linesize[plane];
256  uint8_t *dst = ctx->frames[ctx->cur_index ].f->data[plane];
257  /* src is unused for I frames; set to avoid UB pointer arithmetic. */
258  const uint8_t *src = is_iframe ? dst : ctx->frames[ctx->prev_index].f->data[plane];
259 
260  for (y = 0; y < ctx->num_vblocks[plane]; y++) {
261  for (x = 0; x < ctx->num_hblocks[plane]; x++) {
262  /* Check for a change condition in the current block.
263  * - iframes always change.
264  * - Luma plane changes on get_bits1 == 0
265  * - Chroma planes change on get_bits1 == 1 */
266  if (is_iframe || get_bits1(&ctx->gb) == is_chroma) {
267  /* Luma planes may use a backreference from the 15 last
268  * frames preceding the previous. (get_bits1 == 1)
269  * Chroma planes don't use backreferences. */
270  if (is_chroma || is_iframe || !get_bits1(&ctx->gb)) {
271  if ((ret = vlc_decode_block(ctx, num_coeffs,
272  qscale)) < 0) {
273  av_log(ctx->avctx, AV_LOG_ERROR, "Error decoding "
274  "block.\n");
275  return ret;
276  }
277  ctx->idsp.idct_put(dst, stride, ctx->dct_block);
278  } else {
279  unsigned int backref = get_bits(&ctx->gb, 4);
280  int index = (ctx->cur_index + backref) & 15;
281 
282  if (index != ctx->cur_index && ctx->frames[index].f) {
283  const uint8_t *p = ctx->frames[index].f->data[0];
284  ff_progress_frame_await(&ctx->frames[index], cur_row);
285  p += src -
286  ctx->frames[ctx->prev_index].f->data[plane];
287  ctx->hdsp.put_pixels_tab[1][0](dst, p, stride, 8);
288  } else {
289  av_log(ctx->avctx, AV_LOG_ERROR,
290  "No such backreference! Buggy sample.\n");
291  }
292  }
293  } else {
294  ff_progress_frame_await(&ctx->frames[ctx->prev_index], cur_row);
295  ctx->hdsp.put_pixels_tab[1][0](dst, src, stride, 8);
296  }
297  src += 8;
298  dst += 8;
299  }
300  src += (stride - ctx->num_hblocks[plane]) << 3;
301  dst += (stride - ctx->num_hblocks[plane]) << 3;
302 
303  ff_progress_frame_report(&ctx->frames[ctx->cur_index], cur_row++);
304  }
305  }
306 
307  return 0;
308 }
309 
310 /**
311  * Flip the buffer upside-down and put it in the YVU order to revert the
312  * way Mimic encodes frames.
313  */
314 static void flip_swap_frame(AVFrame *f)
315 {
316  int i;
317  uint8_t *data_1 = f->data[1];
318  f->data[0] = f->data[0] + ( f->height - 1) * f->linesize[0];
319  f->data[1] = f->data[2] + ((f->height >> 1) - 1) * f->linesize[2];
320  f->data[2] = data_1 + ((f->height >> 1) - 1) * f->linesize[1];
321  for (i = 0; i < 3; i++)
322  f->linesize[i] *= -1;
323 }
324 
325 static int mimic_decode_frame(AVCodecContext *avctx, AVFrame *rframe,
326  int *got_frame, AVPacket *avpkt)
327 {
328  const uint8_t *buf = avpkt->data;
329  int buf_size = avpkt->size;
330  int swap_buf_size = buf_size - MIMIC_HEADER_SIZE;
331  MimicContext *ctx = avctx->priv_data;
332  GetByteContext gb;
333  int is_pframe;
334  int width, height;
335  int quality, num_coeffs;
336  int res;
337 
338  if (buf_size <= MIMIC_HEADER_SIZE) {
339  av_log(avctx, AV_LOG_ERROR, "insufficient data\n");
340  return AVERROR_INVALIDDATA;
341  }
342 
344  bytestream2_skip(&gb, 2); /* some constant (always 256) */
345  quality = bytestream2_get_le16u(&gb);
346  width = bytestream2_get_le16u(&gb);
347  height = bytestream2_get_le16u(&gb);
348  bytestream2_skip(&gb, 4); /* some constant */
349  is_pframe = bytestream2_get_le32u(&gb);
350  num_coeffs = bytestream2_get_byteu(&gb);
351  bytestream2_skip(&gb, 3); /* some constant */
352 
353  if (!ctx->avctx) {
354  int i;
355 
356  if (!(width == 160 && height == 120) &&
357  !(width == 320 && height == 240)) {
358  av_log(avctx, AV_LOG_ERROR, "invalid width/height!\n");
359  return AVERROR_INVALIDDATA;
360  }
361 
362  res = ff_set_dimensions(avctx, width, height);
363  if (res < 0)
364  return res;
365 
366  ctx->avctx = avctx;
367  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
368  for (i = 0; i < 3; i++) {
369  ctx->num_vblocks[i] = AV_CEIL_RSHIFT(height, 3 + !!i);
370  ctx->num_hblocks[i] = width >> (3 + !!i);
371  }
372  } else if (width != ctx->avctx->width || height != ctx->avctx->height) {
373  avpriv_request_sample(avctx, "Resolution changing");
374  return AVERROR_PATCHWELCOME;
375  }
376 
377  if (is_pframe && !ctx->frames[ctx->prev_index].f) {
378  av_log(avctx, AV_LOG_ERROR, "decoding must start with keyframe\n");
379  return AVERROR_INVALIDDATA;
380  }
381 
382  ff_progress_frame_unref(&ctx->frames[ctx->cur_index]);
383  res = ff_progress_frame_get_buffer(avctx, &ctx->frames[ctx->cur_index],
385  if (res < 0)
386  return res;
387  ctx->frames[ctx->cur_index].f->pict_type = is_pframe ? AV_PICTURE_TYPE_P :
389 
390  ctx->next_prev_index = ctx->cur_index;
391  ctx->next_cur_index = (ctx->cur_index - 1) & 15;
392 
393  ff_thread_finish_setup(avctx);
394 
395  av_fast_padded_malloc(&ctx->swap_buf, &ctx->swap_buf_size, swap_buf_size);
396  if (!ctx->swap_buf)
397  return AVERROR(ENOMEM);
398 
399  ctx->bbdsp.bswap_buf(ctx->swap_buf,
400  (const uint32_t *) (buf + MIMIC_HEADER_SIZE),
401  swap_buf_size >> 2);
402  init_get_bits(&ctx->gb, ctx->swap_buf, swap_buf_size << 3);
403 
404  res = decode(ctx, quality, num_coeffs, !is_pframe);
405  ff_progress_frame_report(&ctx->frames[ctx->cur_index], INT_MAX);
406  if (res < 0) {
407  if (!(avctx->active_thread_type & FF_THREAD_FRAME))
408  ff_progress_frame_unref(&ctx->frames[ctx->cur_index]);
409  return res;
410  }
411 
412  if ((res = av_frame_ref(rframe, ctx->frames[ctx->cur_index].f)) < 0)
413  return res;
414  *got_frame = 1;
415 
416  flip_swap_frame(rframe);
417 
418  ctx->prev_index = ctx->next_prev_index;
419  ctx->cur_index = ctx->next_cur_index;
420 
421  return buf_size;
422 }
423 
425  .p.name = "mimic",
426  CODEC_LONG_NAME("Mimic"),
427  .p.type = AVMEDIA_TYPE_VIDEO,
428  .p.id = AV_CODEC_ID_MIMIC,
429  .priv_data_size = sizeof(MimicContext),
431  .close = mimic_decode_end,
433  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
434  UPDATE_THREAD_CONTEXT(mimic_decode_update_thread_context),
435  .caps_internal = FF_CODEC_CAP_USES_PROGRESSFRAMES |
437 };
ff_progress_frame_report
void ff_progress_frame_report(ProgressFrame *f, int n)
Notify later decoding threads when part of their reference frame is ready.
Definition: decode.c:1759
MimicContext::hdsp
HpelDSPContext hdsp
Definition: mimic.c:63
block_vlc
static VLCElem block_vlc[4368]
Definition: mimic.c:71
bswapdsp.h
MimicContext::next_prev_index
int next_prev_index
Definition: mimic.c:68
MimicContext::idsp
IDCTDSPContext idsp
Definition: mimic.c:64
av_clip
#define av_clip
Definition: common.h:99
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:42
huffsyms
static const uint8_t huffsyms[]
Definition: mimic.c:73
MIMIC_HEADER_SIZE
#define MIMIC_HEADER_SIZE
Definition: mimic.c:40
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:85
mem_internal.h
GetByteContext
Definition: bytestream.h:33
thread.h
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
AVPacket::data
uint8_t * data
Definition: packet.h:524
ff_progress_frame_get_buffer
int ff_progress_frame_get_buffer(AVCodecContext *avctx, ProgressFrame *f, int flags)
This function sets up the ProgressFrame, i.e.
Definition: decode.c:1717
FFCodec
Definition: codec_internal.h:126
mimic_init_static
static av_cold void mimic_init_static(void)
Definition: mimic.c:118
BlockDSPContext
Definition: blockdsp.h:32
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:94
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
thread.h
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:228
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
ff_permute_scantable
av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])
Definition: idctdsp.c:30
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:335
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:130
AV_CODEC_ID_MIMIC
@ AV_CODEC_ID_MIMIC
Definition: codec_id.h:165
GetBitContext
Definition: get_bits.h:108
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:502
progressframe.h
MimicContext::permutated_scantable
uint8_t permutated_scantable[64]
Definition: mimic.c:60
FF_CODEC_CAP_USES_PROGRESSFRAMES
#define FF_CODEC_CAP_USES_PROGRESSFRAMES
The decoder might make use of the ProgressFrame API.
Definition: codec_internal.h:68
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
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:50
ff_progress_frame_ref
void ff_progress_frame_ref(ProgressFrame *dst, const ProgressFrame *src)
Set dst->f to src->f and make dst a co-owner of src->f.
Definition: decode.c:1734
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:286
ff_blockdsp_init
av_cold void ff_blockdsp_init(BlockDSPContext *c)
Definition: blockdsp.c:58
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:59
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:425
ff_mimic_decoder
const FFCodec ff_mimic_decoder
Definition: mimic.c:424
MimicContext::cur_index
int cur_index
Definition: mimic.c:52
ctx
AVFormatContext * ctx
Definition: movenc.c:49
ff_progress_frame_unref
void ff_progress_frame_unref(ProgressFrame *f)
Give up a reference to the underlying frame contained in a ProgressFrame and reset the ProgressFrame,...
Definition: decode.c:1742
ff_progress_frame_await
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_progress_frame_await() 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_progress_frame_report() has been called on them. This includes draw_edges(). Porting codecs to frame threading
decode.h
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:314
MimicContext::bbdsp
BswapDSPContext bbdsp
Definition: mimic.c:62
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:73
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:271
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:110
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
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
MimicContext::swap_buf
void * swap_buf
Definition: mimic.c:49
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:388
UPDATE_THREAD_CONTEXT
#define UPDATE_THREAD_CONTEXT(func)
Definition: codec_internal.h:280
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:652
AVOnce
#define AVOnce
Definition: thread.h:202
index
int index
Definition: gxfenc.c:90
mimic_decode_end
static av_cold int mimic_decode_end(AVCodecContext *avctx)
Definition: mimic.c:105
HpelDSPContext
Half-pel DSP context.
Definition: hpeldsp.h:45
f
f
Definition: af_crystalizer.c:121
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:366
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:525
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:384
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
MimicContext::avctx
AVCodecContext * avctx
Definition: mimic.c:44
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
VLCElem
Definition: vlc.h:32
mimic_decode_init
static av_cold int mimic_decode_init(AVCodecContext *avctx)
Definition: mimic.c:125
height
#define height
MimicContext::dct_block
int16_t dct_block[64]
Definition: mimic.c:57
FF_THREAD_FRAME
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:1594
MimicContext::num_hblocks
int num_hblocks[3]
Definition: mimic.c:47
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
MimicContext::next_cur_index
int next_cur_index
Definition: mimic.c:67
decode
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:246
vlcdec_lookup
static const int8_t vlcdec_lookup[9][64]
Definition: mimic.c:165
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:52
MIMIC_VLC_BITS
#define MIMIC_VLC_BITS
Definition: mimic.c:41
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:194
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:657
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:202
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:325
pos
unsigned int pos
Definition: spdifenc.c:414
IDCTDSPContext
Definition: idctdsp.h:43
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:445
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1602
MimicContext
Definition: mimic.c:43
col_zag
static const uint8_t col_zag[64]
Definition: mimic.c:94
MimicContext::prev_index
int prev_index
Definition: mimic.c:53
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:280
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
MimicContext::gb
GetBitContext gb
Definition: mimic.c:59
VLC_INIT_STATIC_TABLE_FROM_LENGTHS
#define VLC_INIT_STATIC_TABLE_FROM_LENGTHS(vlc_table, nb_bits, nb_codes, lens, lens_wrap, syms, syms_wrap, syms_size, offset, flags)
Definition: vlc.h:280
ProgressFrame
The ProgressFrame structure.
Definition: progressframe.h:73
AVPacket
This structure stores compressed data.
Definition: packet.h:501
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
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:61
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:80
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
MimicContext::frames
ProgressFrame frames[16]
Definition: mimic.c:55
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
BswapDSPContext
Definition: bswapdsp.h:24
MimicContext::num_vblocks
int num_vblocks[3]
Definition: mimic.c:46