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 <stdio.h>
24 #include <stdlib.h>
25 #include <string.h>
26 
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 "copy_block.h"
34 #include "get_bits.h"
35 #include "idctdsp.h"
36 #include "internal.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];
58 } IMM4Context;
59 
60 static const uint8_t intra_cb[] = {
61  24, 18, 12
62 };
63 
64 static const uint8_t inter_cb[] = {
65  30, 20, 15
66 };
67 
68 static const uint8_t cbplo[][2] = {
69  { 0,-6 }, { 0x01, 6 }, { 0x02, 6 }, { 0x03, 6 }, { 0x00, 4 },
70  { 0x01, 3 }, { 0x02, 3 }, { 0x03, 3 }, { 0x00, 1 },
71 };
72 
73 static const uint8_t cbphi_bits[] = {
74  4, 5, 5, 4, 5, 4, 6, 4, 5, 6, 4, 4, 4, 4, 4, 2
75 };
76 
77 static const uint8_t cbphi_codes[] = {
78  3, 5, 4, 9, 3, 7, 2, 11, 2, 3, 5, 10, 4, 8, 6, 3
79 };
80 
81 static const uint8_t blktype[][2] = {
82  { 0,-8 }, { 0x34, 9 }, { 0,-9 }, { 0x14, 9 }, { 0,-9 },
83  { 0x23, 8 }, { 0x13, 8 }, { 0x32, 8 }, { 0x33, 7 }, { 0x22, 7 },
84  { 0x12, 7 }, { 0x21, 7 }, { 0x11, 7 }, { 0x04, 6 }, { 0x30, 6 },
85  { 0x03, 5 }, { 0x20, 4 }, { 0x10, 4 }, { 0x02, 3 }, { 0x01, 3 },
86  { 0x00, 1 },
87 };
88 
89 static const uint16_t block_symbols[] = {
90  0, 0x4082, 0x4003, 0x000B, 0x000A, 0x4E01, 0x4D81, 0x4D01, 0x4C81,
91  0x0482, 0x0402, 0x0382, 0x0302, 0x0282, 0x0183, 0x0103, 0x0084, 0x000C,
92  0x0085, 0x0B81, 0x0C01, 0x4E81, 0x4F01, 0x4F81, 0x5001, 0x0086, 0x0104,
93  0x0203, 0x0283, 0x0303, 0x0502, 0x0C81, 0x0D01, 0x5081, 0x5101, 0x5181,
94  0x5201, 0x5281, 0x5301, 0x5381, 0x5401, 0x0000, 0x0009, 0x0008, 0x4C01,
95  0x4B81, 0x4B01, 0x4A81, 0x4A01, 0x4981, 0x4901, 0x4881, 0x4002, 0x0B01,
96  0x0A81, 0x0A01, 0x0981, 0x0901, 0x0881, 0x0801, 0x0781, 0x0202, 0x0182,
97  0x0007, 0x0006, 0x4801, 0x4781, 0x4701, 0x4681, 0x4601, 0x4581, 0x4501,
98  0x4481, 0x0701, 0x0681, 0x0102, 0x0083, 0x0005, 0x4401, 0x4381, 0x4301,
99  0x4281, 0x0601, 0x0581, 0x0501, 0x0004, 0x4201, 0x4181, 0x4101, 0x4081,
100  0x0481, 0x0401, 0x0381, 0x0301, 0x0082, 0x0003, 0x0281, 0x0201, 0x0181,
101  0x4001, 0x0001, 0x0081, 0x0101, 0x0002,
102 };
103 
104 static const uint8_t block_bits[] = {
105  -9, 11, 11, 11, 11, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 11,
106  11, 11, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
107  12, 12, 12, 7, 10, 10, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,
108  9, 9, 9, 9, 9, 9, 9, 9, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,
109  8, 8, 7, 7, 7, 7, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, 6, 6, 6,
110  6, 5, 5, 5, 4, 2, 3, 4, 4,
111 };
112 
113 static VLC cbplo_tab;
114 static VLC cbphi_tab;
116 static VLC block_tab;
117 
118 static int get_cbphi(GetBitContext *gb, int x)
119 {
120  int value;
121 
123  if (value < 0)
124  return AVERROR_INVALIDDATA;
125 
126  return x ? value : 15 - value;
127 }
128 
130  int block, int factor, int flag, int offset, int flag2)
131 {
132  IMM4Context *s = avctx->priv_data;
133  const uint8_t *scantable = s->intra_scantable.permutated;
134  int i, last, len, factor2;
135 
136  for (i = !flag; i < 64; i++) {
137  int value;
138 
140  if (value < 0)
141  return AVERROR_INVALIDDATA;
142  if (value == 0) {
143  last = get_bits1(gb);
144  len = get_bits(gb, 6);
145  factor2 = get_sbits(gb, 8);
146  } else {
147  factor2 = value & 0x7F;
148  last = (value >> 14) & 1;
149  len = (value >> 7) & 0x3F;
150  if (get_bits1(gb))
151  factor2 = -factor2;
152  }
153  i += len;
154  if (i >= 64)
155  break;
156  s->block[block][scantable[i]] = offset * (factor2 < 0 ? -1 : 1) + factor * factor2;
157  if (last)
158  break;
159  }
160 
161  if (s->hi == 2 && flag2 && block < 4) {
162  if (flag)
163  s->block[block][scantable[0]] *= 2;
164  s->block[block][scantable[1]] *= 2;
165  s->block[block][scantable[8]] *= 2;
166  s->block[block][scantable[16]] *= 2;
167  }
168 
169  return 0;
170 }
171 
173  unsigned cbp, int flag, int offset, unsigned flag2)
174 {
175  IMM4Context *s = avctx->priv_data;
176  const uint8_t *scantable = s->intra_scantable.permutated;
177  int ret, i;
178 
179  memset(s->block, 0, sizeof(s->block));
180 
181  for (i = 0; i < 6; i++) {
182  if (!flag) {
183  int x = get_bits(gb, 8);
184 
185  if (x == 255)
186  x = 128;
187  x *= 8;
188 
189  s->block[i][scantable[0]] = x;
190  }
191 
192  if (cbp & (1 << (5 - i))) {
193  ret = decode_block(avctx, gb, i, s->factor, flag, offset, flag2);
194  if (ret < 0)
195  return ret;
196  }
197  }
198 
199  return 0;
200 }
201 
203 {
204  IMM4Context *s = avctx->priv_data;
205  int ret, x, y, offset = 0;
206 
207  if (s->hi == 0) {
208  if (s->lo > 2)
209  return AVERROR_INVALIDDATA;
210  s->factor = intra_cb[s->lo];
211  } else {
212  s->factor = s->lo * 2;
213  }
214 
215  if (s->hi) {
216  offset = s->factor;
217  offset >>= 1;
218  if (!(offset & 1))
219  offset--;
220  }
221 
222  for (y = 0; y < avctx->height; y += 16) {
223  for (x = 0; x < avctx->width; x += 16) {
224  unsigned flag, cbphi, cbplo;
225 
227  flag = get_bits1(gb);
228 
229  cbphi = get_cbphi(gb, 1);
230 
231  ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag);
232  if (ret < 0)
233  return ret;
234 
235  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
236  frame->linesize[0], s->block[0]);
237  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
238  frame->linesize[0], s->block[1]);
239  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
240  frame->linesize[0], s->block[2]);
241  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
242  frame->linesize[0], s->block[3]);
243  s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
244  frame->linesize[1], s->block[4]);
245  s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
246  frame->linesize[2], s->block[5]);
247  }
248  }
249 
250  return 0;
251 }
252 
254  AVFrame *frame, AVFrame *prev)
255 {
256  IMM4Context *s = avctx->priv_data;
257  int ret, x, y, offset = 0;
258 
259  if (s->hi == 0) {
260  if (s->lo > 2)
261  return AVERROR_INVALIDDATA;
262  s->factor = inter_cb[s->lo];
263  } else {
264  s->factor = s->lo * 2;
265  }
266 
267  if (s->hi) {
268  offset = s->factor;
269  offset >>= 1;
270  if (!(offset & 1))
271  offset--;
272  }
273 
274  for (y = 0; y < avctx->height; y += 16) {
275  for (x = 0; x < avctx->width; x += 16) {
276  int reverse, intra_block, value;
277  unsigned cbphi, cbplo, flag2 = 0;
278 
279  if (get_bits1(gb)) {
280  copy_block16(frame->data[0] + y * frame->linesize[0] + x,
281  prev->data[0] + y * prev->linesize[0] + x,
282  frame->linesize[0], prev->linesize[0], 16);
283  copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
284  prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
285  frame->linesize[1], prev->linesize[1], 8);
286  copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
287  prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
288  frame->linesize[2], prev->linesize[2], 8);
289  continue;
290  }
291 
293  if (value < 0)
294  return AVERROR_INVALIDDATA;
295 
296  intra_block = value & 0x07;
297  reverse = intra_block == 3;
298  if (reverse)
299  flag2 = get_bits1(gb);
300 
301  cbplo = value >> 4;
302  cbphi = get_cbphi(gb, reverse);
303  if (intra_block) {
304  ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag2);
305  if (ret < 0)
306  return ret;
307 
308  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
309  frame->linesize[0], s->block[0]);
310  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
311  frame->linesize[0], s->block[1]);
312  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
313  frame->linesize[0], s->block[2]);
314  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
315  frame->linesize[0], s->block[3]);
316  s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
317  frame->linesize[1], s->block[4]);
318  s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
319  frame->linesize[2], s->block[5]);
320  } else {
321  flag2 = get_bits1(gb);
322  skip_bits1(gb);
323  ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 1, offset, flag2);
324  if (ret < 0)
325  return ret;
326 
327  copy_block16(frame->data[0] + y * frame->linesize[0] + x,
328  prev->data[0] + y * prev->linesize[0] + x,
329  frame->linesize[0], prev->linesize[0], 16);
330  copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
331  prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
332  frame->linesize[1], prev->linesize[1], 8);
333  copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
334  prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
335  frame->linesize[2], prev->linesize[2], 8);
336 
337  s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x,
338  frame->linesize[0], s->block[0]);
339  s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x + 8,
340  frame->linesize[0], s->block[1]);
341  s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x,
342  frame->linesize[0], s->block[2]);
343  s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
344  frame->linesize[0], s->block[3]);
345  s->idsp.idct_add(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
346  frame->linesize[1], s->block[4]);
347  s->idsp.idct_add(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
348  frame->linesize[2], s->block[5]);
349  }
350  }
351  }
352 
353  return 0;
354 }
355 
357  int *got_frame, AVPacket *avpkt)
358 {
359  IMM4Context *s = avctx->priv_data;
360  GetBitContext *gb = &s->gb;
361  int width, height;
362  unsigned type;
363  int ret, scaled;
364 
365  if (avpkt->size <= 32)
366  return AVERROR_INVALIDDATA;
367 
368  av_fast_padded_malloc(&s->bitstream, &s->bitstream_size,
369  FFALIGN(avpkt->size, 4));
370  if (!s->bitstream)
371  return AVERROR(ENOMEM);
372 
373  s->bdsp.bswap_buf((uint32_t *)s->bitstream,
374  (uint32_t *)avpkt->data,
375  (avpkt->size + 3) >> 2);
376 
377  if ((ret = init_get_bits8(gb, s->bitstream, FFALIGN(avpkt->size, 4))) < 0)
378  return ret;
379 
380  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
381  avctx->color_range = AVCOL_RANGE_JPEG;
382 
383  width = avctx->width;
384  height = avctx->height;
385 
386  scaled = avpkt->data[8];
387  if (scaled < 2) {
388  int mode = avpkt->data[10];
389 
390  switch (mode) {
391  case 1:
392  width = 352;
393  height = 240;
394  break;
395  case 2:
396  width = 704;
397  height = 240;
398  break;
399  case 4:
400  width = 480;
401  height = 704;
402  break;
403  case 17:
404  width = 352;
405  height = 288;
406  break;
407  case 18:
408  width = 704;
409  height = 288;
410  break;
411  default:
412  width = 704;
413  height = 576;
414  break;
415  }
416  }
417 
418  skip_bits_long(gb, 24 * 8);
419  type = get_bits_long(gb, 32);
420  s->hi = get_bits(gb, 16);
421  s->lo = get_bits(gb, 16);
422 
423  switch (type) {
424  case 0x19781977:
425  frame->key_frame = 1;
426  frame->pict_type = AV_PICTURE_TYPE_I;
427  break;
428  case 0x12250926:
429  frame->key_frame = 0;
430  frame->pict_type = AV_PICTURE_TYPE_P;
431  break;
432  default:
433  avpriv_request_sample(avctx, "type %X", type);
434  return AVERROR_PATCHWELCOME;
435  }
436 
437  if (avctx->width != width ||
438  avctx->height != height) {
439  if (!frame->key_frame) {
440  av_log(avctx, AV_LOG_ERROR, "Frame size change is unsupported.\n");
441  return AVERROR_INVALIDDATA;
442  }
443  av_frame_unref(s->prev_frame);
444  }
445 
446  ret = ff_set_dimensions(avctx, width, height);
447  if (ret < 0)
448  return ret;
449 
450  if ((ret = ff_get_buffer(avctx, frame, frame->key_frame ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
451  return ret;
452 
453  if (frame->key_frame) {
454  ret = decode_intra(avctx, gb, frame);
455  if (ret < 0)
456  return ret;
457 
458  av_frame_unref(s->prev_frame);
459  if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
460  return ret;
461  } else {
462  if (!s->prev_frame->data[0]) {
463  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
464  return AVERROR_INVALIDDATA;
465  }
466 
467  ret = decode_inter(avctx, gb, frame, s->prev_frame);
468  if (ret < 0)
469  return ret;
470  }
471 
472  *got_frame = 1;
473 
474  return avpkt->size;
475 }
476 
478 {
480  &cbplo[0][1], 2, &cbplo[0][0], 2, 1,
481  0, 0, 1 << CBPLO_VLC_BITS);
482 
484  cbphi_bits, 1, 1, cbphi_codes, 1, 1, NULL, 0, 0, 64);
485 
487  &blktype[0][1], 2, &blktype[0][0], 2, 1,
488  0, 0, 1 << BLKTYPE_VLC_BITS);
489 
491  block_bits, 1, block_symbols, 2, 2,
492  0, 0, 1 << BLOCK_VLC_BITS);
493 }
494 
496 {
497  static AVOnce init_static_once = AV_ONCE_INIT;
498  IMM4Context *s = avctx->priv_data;
499  uint8_t table[64];
500 
501  for (int i = 0; i < 64; i++)
502  table[i] = i;
503 
504  ff_bswapdsp_init(&s->bdsp);
505  ff_idctdsp_init(&s->idsp, avctx);
506  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, table);
507 
508  s->prev_frame = av_frame_alloc();
509  if (!s->prev_frame)
510  return AVERROR(ENOMEM);
511 
512  ff_thread_once(&init_static_once, imm4_init_static_data);
513 
514  return 0;
515 }
516 
517 static void decode_flush(AVCodecContext *avctx)
518 {
519  IMM4Context *s = avctx->priv_data;
520 
521  av_frame_unref(s->prev_frame);
522 }
523 
525 {
526  IMM4Context *s = avctx->priv_data;
527 
528  av_frame_free(&s->prev_frame);
529  av_freep(&s->bitstream);
530  s->bitstream_size = 0;
531 
532  return 0;
533 }
534 
536  .p.name = "imm4",
537  .p.long_name = NULL_IF_CONFIG_SMALL("Infinity IMM4"),
538  .p.type = AVMEDIA_TYPE_VIDEO,
539  .p.id = AV_CODEC_ID_IMM4,
540  .priv_data_size = sizeof(IMM4Context),
541  .init = decode_init,
542  .close = decode_close,
544  .flush = decode_flush,
545  .p.capabilities = AV_CODEC_CAP_DR1,
546  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
547 };
imm4_init_static_data
static av_cold void imm4_init_static_data(void)
Definition: imm4.c:477
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:291
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
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
mem_internal.h
get_cbphi
static int get_cbphi(GetBitContext *gb, int x)
Definition: imm4.c:118
thread.h
block_bits
static const uint8_t block_bits[]
Definition: imm4.c:104
get_bits_long
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:546
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
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:606
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:374
table
static const uint16_t table[]
Definition: prosumer.c:206
FFCodec
Definition: codec_internal.h:118
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:356
intra_cb
static const uint8_t intra_cb[]
Definition: imm4.c:60
ff_idctdsp_init
av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)
Definition: idctdsp.c:240
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: imm4.c:524
IMM4Context::intra_scantable
ScanTable intra_scantable
Definition: imm4.c:55
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:346
init
static int init
Definition: av_tx.c:47
block_tab
static VLC block_tab
Definition: imm4.c:116
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
cbplo
static const uint8_t cbplo[][2]
Definition: imm4.c:68
GetBitContext
Definition: get_bits.h:61
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:202
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
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:180
cbplo_tab
static VLC cbplo_tab
Definition: imm4.c:113
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:667
INIT_VLC_SPARSE_STATIC
#define INIT_VLC_SPARSE_STATIC(vlc, bits, a, b, c, d, e, f, g, h, i, j, static_size)
Definition: vlc.h:113
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:260
decode_block
static int decode_block(AVCodecContext *avctx, GetBitContext *gb, int block, int factor, int flag, int offset, int flag2)
Definition: imm4.c:129
s
#define s(width, name)
Definition: cbs_vp9.c:256
blktype
static const uint8_t blktype[][2]
Definition: imm4.c:81
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:376
get_sbits
static int get_sbits(GetBitContext *s, int n)
Definition: get_bits.h:359
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: imm4.c:495
cbphi_codes
static const uint8_t cbphi_codes[]
Definition: imm4.c:77
get_bits.h
blktype_tab
static VLC blktype_tab
Definition: imm4.c:115
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
IMM4Context::hi
unsigned hi
Definition: imm4.c:53
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:177
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
NULL
#define NULL
Definition: coverity.c:32
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:982
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
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
cbphi_bits
static const uint8_t cbphi_bits[]
Definition: imm4.c:73
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:787
AVOnce
#define AVOnce
Definition: thread.h:176
inter_cb
static const uint8_t inter_cb[]
Definition: imm4.c:64
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:1462
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
block_symbols
static const uint16_t block_symbols[]
Definition: imm4.c:89
decode_inter
static int decode_inter(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame, AVFrame *prev)
Definition: imm4.c:253
height
#define height
AV_CODEC_ID_IMM4
@ AV_CODEC_ID_IMM4
Definition: codec_id.h:286
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:538
IMM4Context::prev_frame
AVFrame * prev_frame
Definition: imm4.c:47
flag
#define flag(name)
Definition: cbs_av1.c:553
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:116
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
copy_block.h
ff_init_scantable
av_cold void ff_init_scantable(const uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:30
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
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:487
IMM4Context::bitstream
uint8_t * bitstream
Definition: imm4.c:48
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:211
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:571
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:608
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:53
ff_imm4_decoder
const FFCodec ff_imm4_decoder
Definition: imm4.c:535
AVCodecContext
main external API structure.
Definition: avcodec.h:398
IMM4Context::gb
GetBitContext gb
Definition: imm4.c:45
mode
mode
Definition: ebur128.h:83
VLC
Definition: vlc.h:31
VLC::table
VLCElem * table
Definition: vlc.h:33
factor
static const int factor[16]
Definition: vf_pp7.c:76
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
BLOCK_VLC_BITS
#define BLOCK_VLC_BITS
Definition: imm4.c:41
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:36
ScanTable
Scantable.
Definition: idctdsp.h:31
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
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
IMM4Context
Definition: imm4.c:43
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:571
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:370
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:517
cbphi_tab
static VLC cbphi_tab
Definition: imm4.c:114
decode_blocks
static int decode_blocks(AVCodecContext *avctx, GetBitContext *gb, unsigned cbp, int flag, int offset, unsigned flag2)
Definition: imm4.c:172
IMM4Context::idsp
IDCTDSPContext idsp
Definition: imm4.c:57
IMM4Context::lo
unsigned lo
Definition: imm4.c:52