FFmpeg
imm4.c
Go to the documentation of this file.
1 /*
2  * Infinity IMM4 decoder
3  *
4  * Copyright (c) 2018 Paul B Mahol
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 #include <stddef.h>
24 #include <string.h>
25 
26 #include "libavutil/mem.h"
27 #include "libavutil/mem_internal.h"
28 #include "libavutil/thread.h"
29 
30 #include "avcodec.h"
31 #include "bswapdsp.h"
32 #include "codec_internal.h"
33 #include "decode.h"
34 #include "copy_block.h"
35 #include "get_bits.h"
36 #include "idctdsp.h"
37 
38 #define CBPLO_VLC_BITS 6
39 #define CBPHI_VLC_BITS 6
40 #define BLKTYPE_VLC_BITS 9
41 #define BLOCK_VLC_BITS 12
42 
43 typedef struct IMM4Context {
46 
48  uint8_t *bitstream;
50 
51  int factor;
52  unsigned lo;
53  unsigned hi;
54 
56  DECLARE_ALIGNED(32, int16_t, block)[6][64];
57 } IMM4Context;
58 
59 static const uint8_t intra_cb[] = {
60  24, 18, 12
61 };
62 
63 static const uint8_t inter_cb[] = {
64  30, 20, 15
65 };
66 
67 static const uint8_t cbplo[][2] = {
68  { 0,-6 }, { 0x01, 6 }, { 0x02, 6 }, { 0x03, 6 }, { 0x00, 4 },
69  { 0x01, 3 }, { 0x02, 3 }, { 0x03, 3 }, { 0x00, 1 },
70 };
71 
72 static const uint8_t cbphi_bits[] = {
73  4, 5, 5, 4, 5, 4, 6, 4, 5, 6, 4, 4, 4, 4, 4, 2
74 };
75 
76 static const uint8_t cbphi_codes[] = {
77  3, 5, 4, 9, 3, 7, 2, 11, 2, 3, 5, 10, 4, 8, 6, 3
78 };
79 
80 static const uint8_t blktype[][2] = {
81  { 0,-8 }, { 0x34, 9 }, { 0,-9 }, { 0x14, 9 }, { 0,-9 },
82  { 0x23, 8 }, { 0x13, 8 }, { 0x32, 8 }, { 0x33, 7 }, { 0x22, 7 },
83  { 0x12, 7 }, { 0x21, 7 }, { 0x11, 7 }, { 0x04, 6 }, { 0x30, 6 },
84  { 0x03, 5 }, { 0x20, 4 }, { 0x10, 4 }, { 0x02, 3 }, { 0x01, 3 },
85  { 0x00, 1 },
86 };
87 
88 static const uint16_t block_symbols[] = {
89  0, 0x4082, 0x4003, 0x000B, 0x000A, 0x4E01, 0x4D81, 0x4D01, 0x4C81,
90  0x0482, 0x0402, 0x0382, 0x0302, 0x0282, 0x0183, 0x0103, 0x0084, 0x000C,
91  0x0085, 0x0B81, 0x0C01, 0x4E81, 0x4F01, 0x4F81, 0x5001, 0x0086, 0x0104,
92  0x0203, 0x0283, 0x0303, 0x0502, 0x0C81, 0x0D01, 0x5081, 0x5101, 0x5181,
93  0x5201, 0x5281, 0x5301, 0x5381, 0x5401, 0x0000, 0x0009, 0x0008, 0x4C01,
94  0x4B81, 0x4B01, 0x4A81, 0x4A01, 0x4981, 0x4901, 0x4881, 0x4002, 0x0B01,
95  0x0A81, 0x0A01, 0x0981, 0x0901, 0x0881, 0x0801, 0x0781, 0x0202, 0x0182,
96  0x0007, 0x0006, 0x4801, 0x4781, 0x4701, 0x4681, 0x4601, 0x4581, 0x4501,
97  0x4481, 0x0701, 0x0681, 0x0102, 0x0083, 0x0005, 0x4401, 0x4381, 0x4301,
98  0x4281, 0x0601, 0x0581, 0x0501, 0x0004, 0x4201, 0x4181, 0x4101, 0x4081,
99  0x0481, 0x0401, 0x0381, 0x0301, 0x0082, 0x0003, 0x0281, 0x0201, 0x0181,
100  0x4001, 0x0001, 0x0081, 0x0101, 0x0002,
101 };
102 
103 static const uint8_t block_bits[] = {
104  -9, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11,
105  11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
106  12, 12, 12, 7, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
107  9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
108  8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6,
109  6, 5, 5, 5, 4, 2, 3, 4, 4,
110 };
111 
116 
117 static int get_cbphi(GetBitContext *gb, int x)
118 {
119  int value;
120 
122  if (value < 0)
123  return AVERROR_INVALIDDATA;
124 
125  return x ? value : 15 - value;
126 }
127 
129  int block, int factor, int flag, int offset, int flag2)
130 {
131  IMM4Context *s = avctx->priv_data;
132  const uint8_t *idct_permutation = s->idsp.idct_permutation;
133  int i, last, len, factor2;
134 
135  for (i = !flag; i < 64; i++) {
136  int value;
137 
139  if (value < 0)
140  return AVERROR_INVALIDDATA;
141  if (value == 0) {
142  last = get_bits1(gb);
143  len = get_bits(gb, 6);
144  factor2 = get_sbits(gb, 8);
145  } else {
146  factor2 = value & 0x7F;
147  last = (value >> 14) & 1;
148  len = (value >> 7) & 0x3F;
149  if (get_bits1(gb))
150  factor2 = -factor2;
151  }
152  i += len;
153  if (i >= 64)
154  break;
155  s->block[block][idct_permutation[i]] = offset * (factor2 < 0 ? -1 : 1) + factor * factor2;
156  if (last)
157  break;
158  }
159 
160  if (s->hi == 2 && flag2 && block < 4) {
161  if (flag)
162  s->block[block][idct_permutation[0]] *= 2;
163  s->block[block][idct_permutation[1]] *= 2;
164  s->block[block][idct_permutation[8]] *= 2;
165  s->block[block][idct_permutation[16]] *= 2;
166  }
167 
168  return 0;
169 }
170 
172  unsigned cbp, int flag, int offset, unsigned flag2)
173 {
174  IMM4Context *s = avctx->priv_data;
175  const uint8_t *idct_permutation = s->idsp.idct_permutation;
176  int ret, i;
177 
178  memset(s->block, 0, sizeof(s->block));
179 
180  for (i = 0; i < 6; i++) {
181  if (!flag) {
182  int x = get_bits(gb, 8);
183 
184  if (x == 255)
185  x = 128;
186  x *= 8;
187 
188  s->block[i][idct_permutation[0]] = x;
189  }
190 
191  if (cbp & (1 << (5 - i))) {
192  ret = decode_block(avctx, gb, i, s->factor, flag, offset, flag2);
193  if (ret < 0)
194  return ret;
195  }
196  }
197 
198  return 0;
199 }
200 
202 {
203  IMM4Context *s = avctx->priv_data;
204  int ret, x, y, offset = 0;
205 
206  if (s->hi == 0) {
207  if (s->lo > 2)
208  return AVERROR_INVALIDDATA;
209  s->factor = intra_cb[s->lo];
210  } else {
211  s->factor = s->lo * 2;
212  }
213 
214  if (s->hi) {
215  offset = s->factor;
216  offset >>= 1;
217  if (!(offset & 1))
218  offset--;
219  }
220 
221  for (y = 0; y < avctx->height; y += 16) {
222  for (x = 0; x < avctx->width; x += 16) {
223  unsigned flag, cbplo;
224  int cbphi;
225 
227  flag = get_bits1(gb);
228 
229  cbphi = get_cbphi(gb, 1);
230  if (cbphi < 0)
231  return cbphi;
232 
233  ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag);
234  if (ret < 0)
235  return ret;
236 
237  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
238  frame->linesize[0], s->block[0]);
239  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
240  frame->linesize[0], s->block[1]);
241  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
242  frame->linesize[0], s->block[2]);
243  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
244  frame->linesize[0], s->block[3]);
245  s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
246  frame->linesize[1], s->block[4]);
247  s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
248  frame->linesize[2], s->block[5]);
249  }
250  }
251 
252  return 0;
253 }
254 
256  AVFrame *frame, AVFrame *prev)
257 {
258  IMM4Context *s = avctx->priv_data;
259  int ret, x, y, offset = 0;
260 
261  if (s->hi == 0) {
262  if (s->lo > 2)
263  return AVERROR_INVALIDDATA;
264  s->factor = inter_cb[s->lo];
265  } else {
266  s->factor = s->lo * 2;
267  }
268 
269  if (s->hi) {
270  offset = s->factor;
271  offset >>= 1;
272  if (!(offset & 1))
273  offset--;
274  }
275 
276  for (y = 0; y < avctx->height; y += 16) {
277  for (x = 0; x < avctx->width; x += 16) {
278  int reverse, intra_block, value;
279  unsigned cbplo, flag2 = 0;
280  int cbphi;
281 
282  if (get_bits1(gb)) {
283  copy_block16(frame->data[0] + y * frame->linesize[0] + x,
284  prev->data[0] + y * prev->linesize[0] + x,
285  frame->linesize[0], prev->linesize[0], 16);
286  copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
287  prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
288  frame->linesize[1], prev->linesize[1], 8);
289  copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
290  prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
291  frame->linesize[2], prev->linesize[2], 8);
292  continue;
293  }
294 
296  if (value < 0)
297  return AVERROR_INVALIDDATA;
298 
299  intra_block = value & 0x07;
300  reverse = intra_block == 3;
301  if (reverse)
302  flag2 = get_bits1(gb);
303 
304  cbplo = value >> 4;
305  cbphi = get_cbphi(gb, reverse);
306  if (cbphi < 0)
307  return cbphi;
308 
309  if (intra_block) {
310  ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag2);
311  if (ret < 0)
312  return ret;
313 
314  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
315  frame->linesize[0], s->block[0]);
316  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
317  frame->linesize[0], s->block[1]);
318  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
319  frame->linesize[0], s->block[2]);
320  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
321  frame->linesize[0], s->block[3]);
322  s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
323  frame->linesize[1], s->block[4]);
324  s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
325  frame->linesize[2], s->block[5]);
326  } else {
327  flag2 = get_bits1(gb);
328  skip_bits1(gb);
329  ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 1, offset, flag2);
330  if (ret < 0)
331  return ret;
332 
333  copy_block16(frame->data[0] + y * frame->linesize[0] + x,
334  prev->data[0] + y * prev->linesize[0] + x,
335  frame->linesize[0], prev->linesize[0], 16);
336  copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
337  prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
338  frame->linesize[1], prev->linesize[1], 8);
339  copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
340  prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
341  frame->linesize[2], prev->linesize[2], 8);
342 
343  s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x,
344  frame->linesize[0], s->block[0]);
345  s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x + 8,
346  frame->linesize[0], s->block[1]);
347  s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x,
348  frame->linesize[0], s->block[2]);
349  s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
350  frame->linesize[0], s->block[3]);
351  s->idsp.idct_add(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
352  frame->linesize[1], s->block[4]);
353  s->idsp.idct_add(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
354  frame->linesize[2], s->block[5]);
355  }
356  }
357  }
358 
359  return 0;
360 }
361 
363  int *got_frame, AVPacket *avpkt)
364 {
365  IMM4Context *s = avctx->priv_data;
366  GetBitContext *gb = &s->gb;
367  int width, height;
368  unsigned type;
369  int ret, scaled;
370 
371  if (avpkt->size <= 32)
372  return AVERROR_INVALIDDATA;
373 
374  av_fast_padded_malloc(&s->bitstream, &s->bitstream_size,
375  FFALIGN(avpkt->size, 4));
376  if (!s->bitstream)
377  return AVERROR(ENOMEM);
378 
379  s->bdsp.bswap_buf((uint32_t *)s->bitstream,
380  (uint32_t *)avpkt->data,
381  (avpkt->size + 3) >> 2);
382 
383  if ((ret = init_get_bits8(gb, s->bitstream, FFALIGN(avpkt->size, 4))) < 0)
384  return ret;
385 
386  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
387  avctx->color_range = AVCOL_RANGE_JPEG;
388 
389  width = avctx->width;
390  height = avctx->height;
391 
392  scaled = avpkt->data[8];
393  if (scaled < 2) {
394  int mode = avpkt->data[10];
395 
396  switch (mode) {
397  case 1:
398  width = 352;
399  height = 240;
400  break;
401  case 2:
402  width = 704;
403  height = 240;
404  break;
405  case 4:
406  width = 480;
407  height = 704;
408  break;
409  case 17:
410  width = 352;
411  height = 288;
412  break;
413  case 18:
414  width = 704;
415  height = 288;
416  break;
417  default:
418  width = 704;
419  height = 576;
420  break;
421  }
422  }
423 
424  skip_bits_long(gb, 24 * 8);
425  type = get_bits_long(gb, 32);
426  s->hi = get_bits(gb, 16);
427  s->lo = get_bits(gb, 16);
428 
429  switch (type) {
430  case 0x19781977:
431  frame->flags |= AV_FRAME_FLAG_KEY;
432  frame->pict_type = AV_PICTURE_TYPE_I;
433  break;
434  case 0x12250926:
435  frame->flags &= ~AV_FRAME_FLAG_KEY;
436  frame->pict_type = AV_PICTURE_TYPE_P;
437  break;
438  default:
439  avpriv_request_sample(avctx, "type %X", type);
440  return AVERROR_PATCHWELCOME;
441  }
442 
443  if (avctx->width != width ||
444  avctx->height != height) {
445  if (!(frame->flags & AV_FRAME_FLAG_KEY)) {
446  av_log(avctx, AV_LOG_ERROR, "Frame size change is unsupported.\n");
447  return AVERROR_INVALIDDATA;
448  }
449  av_frame_unref(s->prev_frame);
450  }
451 
452  ret = ff_set_dimensions(avctx, width, height);
453  if (ret < 0)
454  return ret;
455 
456  if (((avctx->width + 15) / 16) * ((avctx->height + 15) / 16) > get_bits_left(gb))
457  return AVERROR_INVALIDDATA;
458 
459 
460  if ((ret = ff_get_buffer(avctx, frame, (frame->flags & AV_FRAME_FLAG_KEY) ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
461  return ret;
462 
463  if (frame->flags & AV_FRAME_FLAG_KEY) {
464  ret = decode_intra(avctx, gb, frame);
465  if (ret < 0)
466  return ret;
467 
468  if ((ret = av_frame_replace(s->prev_frame, frame)) < 0)
469  return ret;
470  } else {
471  if (!s->prev_frame->data[0]) {
472  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
473  return AVERROR_INVALIDDATA;
474  }
475 
476  ret = decode_inter(avctx, gb, frame, s->prev_frame);
477  if (ret < 0)
478  return ret;
479  }
480 
481  *got_frame = 1;
482 
483  return avpkt->size;
484 }
485 
487 {
489  &cbplo[0][1], 2, &cbplo[0][0], 2, 1,
490  0, 0);
491 
493  cbphi_bits, 1, 1, cbphi_codes, 1, 1, 0);
494 
496  &blktype[0][1], 2, &blktype[0][0], 2, 1,
497  0, 0);
498 
500  block_bits, 1, block_symbols, 2, 2,
501  0, 0);
502 }
503 
505 {
506  static AVOnce init_static_once = AV_ONCE_INIT;
507  IMM4Context *s = avctx->priv_data;
508 
509  ff_bswapdsp_init(&s->bdsp);
510  ff_idctdsp_init(&s->idsp, avctx);
511 
512  s->prev_frame = av_frame_alloc();
513  if (!s->prev_frame)
514  return AVERROR(ENOMEM);
515 
516  ff_thread_once(&init_static_once, imm4_init_static_data);
517 
518  return 0;
519 }
520 
521 static void decode_flush(AVCodecContext *avctx)
522 {
523  IMM4Context *s = avctx->priv_data;
524 
525  av_frame_unref(s->prev_frame);
526 }
527 
529 {
530  IMM4Context *s = avctx->priv_data;
531 
532  av_frame_free(&s->prev_frame);
533  av_freep(&s->bitstream);
534  s->bitstream_size = 0;
535 
536  return 0;
537 }
538 
540  .p.name = "imm4",
541  CODEC_LONG_NAME("Infinity IMM4"),
542  .p.type = AVMEDIA_TYPE_VIDEO,
543  .p.id = AV_CODEC_ID_IMM4,
544  .priv_data_size = sizeof(IMM4Context),
545  .init = decode_init,
546  .close = decode_close,
548  .flush = decode_flush,
549  .p.capabilities = AV_CODEC_CAP_DR1,
550  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
551 };
imm4_init_static_data
static av_cold void imm4_init_static_data(void)
Definition: imm4.c:486
bswapdsp.h
IMM4Context::factor
int factor
Definition: imm4.c:51
skip_bits_long
static void skip_bits_long(GetBitContext *s, int n)
Skips the specified number of bits.
Definition: get_bits.h:278
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:43
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:695
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
blktype_tab
static VLCElem blktype_tab[1<< BLKTYPE_VLC_BITS]
Definition: imm4.c:114
mem_internal.h
get_cbphi
static int get_cbphi(GetBitContext *gb, int x)
Definition: imm4.c:117
thread.h
block_bits
static const uint8_t block_bits[]
Definition: imm4.c:103
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:421
cbplo_tab
static VLCElem cbplo_tab[1<< CBPLO_VLC_BITS]
Definition: imm4.c:112
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:162
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:717
AVPacket::data
uint8_t * data
Definition: packet.h:539
FFCodec
Definition: codec_internal.h:127
copy_block8
static void copy_block8(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
Definition: copy_block.h:47
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: imm4.c:362
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
intra_cb
static const uint8_t intra_cb[]
Definition: imm4.c:59
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:228
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: imm4.c:528
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:410
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:131
cbplo
static const uint8_t cbplo[][2]
Definition: imm4.c:67
GetBitContext
Definition: get_bits.h:108
type
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 type
Definition: writing_filters.txt:86
decode_intra
static int decode_intra(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame)
Definition: imm4.c:201
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
ff_thread_once
static int ff_thread_once(char *control, void(*routine)(void))
Definition: thread.h:205
CBPHI_VLC_BITS
#define CBPHI_VLC_BITS
Definition: imm4.c:39
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:640
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:311
decode_block
static int decode_block(AVCodecContext *avctx, GetBitContext *gb, int block, int factor, int flag, int offset, int flag2)
Definition: imm4.c:128
s
#define s(width, name)
Definition: cbs_vp9.c:198
blktype
static const uint8_t blktype[][2]
Definition: imm4.c:80
BLKTYPE_VLC_BITS
#define BLKTYPE_VLC_BITS
Definition: imm4.c:40
IMM4Context::bdsp
BswapDSPContext bdsp
Definition: imm4.c:44
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:431
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:320
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: imm4.c:504
decode.h
cbphi_codes
static const uint8_t cbphi_codes[]
Definition: imm4.c:76
get_bits.h
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:296
IMM4Context::hi
unsigned hi
Definition: imm4.c:53
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:203
copy_block16
static void copy_block16(uint8_t *dst, const uint8_t *src, ptrdiff_t dstStride, ptrdiff_t srcStride, int h)
Definition: copy_block.h:68
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
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:701
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
cbphi_bits
static const uint8_t cbphi_bits[]
Definition: imm4.c:72
CBPLO_VLC_BITS
#define CBPLO_VLC_BITS
Definition: imm4.c:38
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
inter_cb
static const uint8_t inter_cb[]
Definition: imm4.c:63
IMM4Context::bitstream_size
int bitstream_size
Definition: imm4.c:49
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1697
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:368
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:540
height
#define height
Definition: dsp.h:85
codec_internal.h
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem_internal.h:109
block_symbols
static const uint16_t block_symbols[]
Definition: imm4.c:88
VLCElem
Definition: vlc.h:32
decode_inter
static int decode_inter(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame, AVFrame *prev)
Definition: imm4.c:255
AV_CODEC_ID_IMM4
@ AV_CODEC_ID_IMM4
Definition: codec_id.h:291
offset
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 offset
Definition: writing_filters.txt:86
skip_bits1
static void skip_bits1(GetBitContext *s)
Definition: get_bits.h:413
IMM4Context::prev_frame
AVFrame * prev_frame
Definition: imm4.c:47
flag
#define flag(name)
Definition: cbs_av1.c:474
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
copy_block.h
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
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
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:610
cbphi_tab
static VLCElem cbphi_tab[1<< CBPHI_VLC_BITS]
Definition: imm4.c:113
IMM4Context::bitstream
uint8_t * bitstream
Definition: imm4.c:48
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:624
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
IMM4Context::block
int16_t block[6][64]
Definition: imm4.c:56
idctdsp.h
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
IDCTDSPContext
Definition: idctdsp.h:43
ff_imm4_decoder
const FFCodec ff_imm4_decoder
Definition: imm4.c:539
av_frame_replace
int av_frame_replace(AVFrame *dst, const AVFrame *src)
Ensure the destination frame refers to the same data described by the source frame,...
Definition: frame.c:487
AVCodecContext
main external API structure.
Definition: avcodec.h:451
IMM4Context::gb
GetBitContext gb
Definition: imm4.c:45
mode
mode
Definition: ebur128.h:83
VLC_INIT_STATIC_TABLE
#define VLC_INIT_STATIC_TABLE(vlc_table, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:270
factor
static const int factor[16]
Definition: vf_pp7.c:80
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
BLOCK_VLC_BITS
#define BLOCK_VLC_BITS
Definition: imm4.c:41
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
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
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:516
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:478
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
IMM4Context
Definition: imm4.c:43
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
block_tab
static VLCElem block_tab[1<< BLOCK_VLC_BITS]
Definition: imm4.c:115
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:434
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
decode_flush
static void decode_flush(AVCodecContext *avctx)
Definition: imm4.c:521
width
#define width
Definition: dsp.h:85
decode_blocks
static int decode_blocks(AVCodecContext *avctx, GetBitContext *gb, unsigned cbp, int flag, int offset, unsigned flag2)
Definition: imm4.c:171
IMM4Context::idsp
IDCTDSPContext idsp
Definition: imm4.c:55
IMM4Context::lo
unsigned lo
Definition: imm4.c:52