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/thread.h"
28 
29 #include "avcodec.h"
30 #include "bswapdsp.h"
31 #include "copy_block.h"
32 #include "get_bits.h"
33 #include "idctdsp.h"
34 #include "internal.h"
35 
36 typedef struct IMM4Context {
39 
43 
44  int factor;
45  unsigned lo;
46  unsigned hi;
47 
49  DECLARE_ALIGNED(32, int16_t, block)[6][64];
51 } IMM4Context;
52 
53 static const uint8_t intra_cb[] = {
54  24, 18, 12
55 };
56 
57 static const uint8_t inter_cb[] = {
58  30, 20, 15
59 };
60 
61 static const uint8_t cbplo_symbols[] = {
62  3, 4, 19, 20, 35, 36, 51, 52
63 };
64 
65 static const uint8_t cbplo_bits[] = {
66  1, 4, 3, 6, 3, 6, 3, 6
67 };
68 
69 static const uint8_t cbplo_codes[] = {
70  1, 1, 1, 1, 2, 2, 3, 3
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_symbols[] = {
82  0, 1, 2, 3, 4, 16, 17, 18, 19, 20, 32, 33, 34, 35, 48, 50, 51, 52
83 };
84 
85 static const uint8_t blktype_bits[] = {
86  1, 3, 3, 5, 6, 4, 7, 7, 8, 9, 4, 7, 7, 8, 6, 8, 7, 9
87 };
88 
89 static const uint8_t blktype_codes[] = {
90  1, 3, 2, 3, 4, 3, 7, 5, 4, 4, 2, 6, 4, 3, 5, 5, 3, 2
91 };
92 
93 static const uint16_t block_symbols[] = {
94  0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7, 0x8, 0x9, 0xA, 0xB, 0xC, 0x81, 0x82, 0x83,
95  0x84, 0x85, 0x86, 0x101, 0x102, 0x103, 0x104, 0x181, 0x182, 0x183, 0x201, 0x202,
96  0x203, 0x281, 0x282, 0x283, 0x301, 0x302, 0x303, 0x381, 0x382, 0x401, 0x402,
97  0x481, 0x482, 0x501, 0x502, 0x581, 0x601, 0x681, 0x701, 0x781, 0x801, 0x881,
98  0x901, 0x981, 0xA01, 0xA81, 0xB01, 0xB81, 0xC01, 0xC81, 0xD01, 0x4001, 0x4002,
99  0x4003, 0x4081, 0x4082, 0x4101, 0x4181, 0x4201, 0x4281, 0x4301, 0x4381, 0x4401,
100  0x4481, 0x4501, 0x4581, 0x4601, 0x4681, 0x4701, 0x4781, 0x4801, 0x4881, 0x4901,
101  0x4981, 0x4A01, 0x4A81, 0x4B01, 0x4B81, 0x4C01, 0x4C81, 0x4D01, 0x4D81, 0x4E01,
102  0x4E81, 0x4F01, 0x4F81, 0x5001, 0x5081, 0x5101, 0x5181, 0x5201, 0x5281, 0x5301,
103  0x5381, 0x5401
104 };
105 
106 static const uint8_t block_bits[] = {
107  7, 2, 4, 6, 7, 8, 9, 9, 10, 10, 11, 11, 11, 3, 6, 8, 10, 11, 12, 4, 8,
108  10, 12, 5, 9, 10, 5, 9, 12, 5, 10, 12, 6, 10, 12, 6, 10, 6, 10, 6,
109  10, 7, 12, 7, 7, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 11, 11, 12, 12, 4, 9,
110  11, 6, 11, 6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9,
111  9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 12, 12, 12,
112  12, 12
113 };
114 
115 static const uint8_t block_codes[] = {
116  3, 2, 15, 21, 23, 31, 37, 36, 33, 32, 7, 6, 32, 6, 20, 30, 15, 33, 80,
117  14, 29, 14, 81, 13, 35, 13, 12, 34, 82, 11, 12, 83, 19, 11, 84, 18,
118  10, 17, 9, 16, 8, 22, 85, 21, 20, 28, 27, 33, 32, 31, 30, 29, 28,
119  27, 26, 34, 35, 86, 87, 7, 25, 5, 15, 4, 14, 13, 12, 19, 18, 17, 16,
120  26, 25, 24, 23, 22, 21, 20, 19, 24, 23, 22, 21, 20, 19, 18, 17, 7,
121  6, 5, 4, 36, 37, 38, 39, 88, 89, 90, 91, 92, 93, 94, 95
122 };
123 
124 static VLC cbplo_tab;
125 static VLC cbphi_tab;
127 static VLC block_tab;
128 
129 static int get_cbphi(GetBitContext *gb, int x)
130 {
131  int value;
132 
134  if (value < 0)
135  return AVERROR_INVALIDDATA;
136 
137  return x ? value : 15 - value;
138 }
139 
141  int block, int factor, int flag, int offset, int flag2)
142 {
143  IMM4Context *s = avctx->priv_data;
144  const uint8_t *scantable = s->intra_scantable.permutated;
145  int i, last, len, factor2;
146 
147  for (i = !flag; i < 64; i++) {
148  int value;
149 
151  if (value < 0)
152  return AVERROR_INVALIDDATA;
153  if (value == 0) {
154  last = get_bits1(gb);
155  len = get_bits(gb, 6);
156  factor2 = get_sbits(gb, 8);
157  } else {
158  factor2 = value & 0x7F;
159  last = (value >> 14) & 1;
160  len = (value >> 7) & 0x3F;
161  if (get_bits1(gb))
162  factor2 = -factor2;
163  }
164  i += len;
165  if (i >= 64)
166  break;
167  s->block[block][scantable[i]] = offset * (factor2 < 0 ? -1 : 1) + factor * factor2;
168  if (last)
169  break;
170  }
171 
172  if (s->hi == 2 && flag2 && block < 4) {
173  if (flag)
174  s->block[block][scantable[0]] *= 2;
175  s->block[block][scantable[1]] *= 2;
176  s->block[block][scantable[8]] *= 2;
177  s->block[block][scantable[16]] *= 2;
178  }
179 
180  return 0;
181 }
182 
184  unsigned cbp, int flag, int offset, unsigned flag2)
185 {
186  IMM4Context *s = avctx->priv_data;
187  const uint8_t *scantable = s->intra_scantable.permutated;
188  int ret, i;
189 
190  memset(s->block, 0, sizeof(s->block));
191 
192  for (i = 0; i < 6; i++) {
193  if (!flag) {
194  int x = get_bits(gb, 8);
195 
196  if (x == 255)
197  x = 128;
198  x *= 8;
199 
200  s->block[i][scantable[0]] = x;
201  }
202 
203  if (cbp & (1 << (5 - i))) {
204  ret = decode_block(avctx, gb, i, s->factor, flag, offset, flag2);
205  if (ret < 0)
206  return ret;
207  }
208  }
209 
210  return 0;
211 }
212 
214 {
215  IMM4Context *s = avctx->priv_data;
216  int ret, x, y, offset = 0;
217 
218  if (s->hi == 0) {
219  if (s->lo > 2)
220  return AVERROR_INVALIDDATA;
221  s->factor = intra_cb[s->lo];
222  } else {
223  s->factor = s->lo * 2;
224  }
225 
226  if (s->hi) {
227  offset = s->factor;
228  offset >>= 1;
229  if (!(offset & 1))
230  offset--;
231  }
232 
233  for (y = 0; y < avctx->height; y += 16) {
234  for (x = 0; x < avctx->width; x += 16) {
235  unsigned flag, cbphi, cbplo;
236 
237  cbplo = get_vlc2(gb, cbplo_tab.table, cbplo_tab.bits, 1) >> 4;
238  flag = get_bits1(gb);
239 
240  cbphi = get_cbphi(gb, 1);
241 
242  ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag);
243  if (ret < 0)
244  return ret;
245 
246  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
247  frame->linesize[0], s->block[0]);
248  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
249  frame->linesize[0], s->block[1]);
250  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
251  frame->linesize[0], s->block[2]);
252  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
253  frame->linesize[0], s->block[3]);
254  s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
255  frame->linesize[1], s->block[4]);
256  s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
257  frame->linesize[2], s->block[5]);
258  }
259  }
260 
261  return 0;
262 }
263 
265  AVFrame *frame, AVFrame *prev)
266 {
267  IMM4Context *s = avctx->priv_data;
268  int ret, x, y, offset = 0;
269 
270  if (s->hi == 0) {
271  if (s->lo > 2)
272  return AVERROR_INVALIDDATA;
273  s->factor = inter_cb[s->lo];
274  } else {
275  s->factor = s->lo * 2;
276  }
277 
278  if (s->hi) {
279  offset = s->factor;
280  offset >>= 1;
281  if (!(offset & 1))
282  offset--;
283  }
284 
285  for (y = 0; y < avctx->height; y += 16) {
286  for (x = 0; x < avctx->width; x += 16) {
287  int reverse, intra_block, value;
288  unsigned cbphi, cbplo, flag2 = 0;
289 
290  if (get_bits1(gb)) {
291  copy_block16(frame->data[0] + y * frame->linesize[0] + x,
292  prev->data[0] + y * prev->linesize[0] + x,
293  frame->linesize[0], prev->linesize[0], 16);
294  copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
295  prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
296  frame->linesize[1], prev->linesize[1], 8);
297  copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
298  prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
299  frame->linesize[2], prev->linesize[2], 8);
300  continue;
301  }
302 
304  if (value < 0)
305  return AVERROR_INVALIDDATA;
306 
307  intra_block = value & 0x07;
308  reverse = intra_block == 3;
309  if (reverse)
310  flag2 = get_bits1(gb);
311 
312  cbplo = value >> 4;
313  cbphi = get_cbphi(gb, reverse);
314  if (intra_block) {
315  ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 0, offset, flag2);
316  if (ret < 0)
317  return ret;
318 
319  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x,
320  frame->linesize[0], s->block[0]);
321  s->idsp.idct_put(frame->data[0] + y * frame->linesize[0] + x + 8,
322  frame->linesize[0], s->block[1]);
323  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x,
324  frame->linesize[0], s->block[2]);
325  s->idsp.idct_put(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
326  frame->linesize[0], s->block[3]);
327  s->idsp.idct_put(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
328  frame->linesize[1], s->block[4]);
329  s->idsp.idct_put(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
330  frame->linesize[2], s->block[5]);
331  } else {
332  flag2 = get_bits1(gb);
333  skip_bits1(gb);
334  ret = decode_blocks(avctx, gb, cbplo | (cbphi << 2), 1, offset, flag2);
335  if (ret < 0)
336  return ret;
337 
338  copy_block16(frame->data[0] + y * frame->linesize[0] + x,
339  prev->data[0] + y * prev->linesize[0] + x,
340  frame->linesize[0], prev->linesize[0], 16);
341  copy_block8(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
342  prev->data[1] + (y >> 1) * prev->linesize[1] + (x >> 1),
343  frame->linesize[1], prev->linesize[1], 8);
344  copy_block8(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
345  prev->data[2] + (y >> 1) * prev->linesize[2] + (x >> 1),
346  frame->linesize[2], prev->linesize[2], 8);
347 
348  s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x,
349  frame->linesize[0], s->block[0]);
350  s->idsp.idct_add(frame->data[0] + y * frame->linesize[0] + x + 8,
351  frame->linesize[0], s->block[1]);
352  s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x,
353  frame->linesize[0], s->block[2]);
354  s->idsp.idct_add(frame->data[0] + (y + 8) * frame->linesize[0] + x + 8,
355  frame->linesize[0], s->block[3]);
356  s->idsp.idct_add(frame->data[1] + (y >> 1) * frame->linesize[1] + (x >> 1),
357  frame->linesize[1], s->block[4]);
358  s->idsp.idct_add(frame->data[2] + (y >> 1) * frame->linesize[2] + (x >> 1),
359  frame->linesize[2], s->block[5]);
360  }
361  }
362  }
363 
364  return 0;
365 }
366 
367 static int decode_frame(AVCodecContext *avctx, void *data,
368  int *got_frame, AVPacket *avpkt)
369 {
370  IMM4Context *s = avctx->priv_data;
371  GetBitContext *gb = &s->gb;
372  AVFrame *frame = data;
373  int width, height;
374  unsigned type;
375  int ret, scaled;
376 
377  if (avpkt->size <= 32)
378  return AVERROR_INVALIDDATA;
379 
380  av_fast_padded_malloc(&s->bitstream, &s->bitstream_size,
381  FFALIGN(avpkt->size, 4));
382  if (!s->bitstream)
383  return AVERROR(ENOMEM);
384 
385  s->bdsp.bswap_buf((uint32_t *)s->bitstream,
386  (uint32_t *)avpkt->data,
387  (avpkt->size + 3) >> 2);
388 
389  if ((ret = init_get_bits8(gb, s->bitstream, FFALIGN(avpkt->size, 4))) < 0)
390  return ret;
391 
392  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
393  avctx->color_range = AVCOL_RANGE_JPEG;
394 
395  width = avctx->width;
396  height = avctx->height;
397 
398  scaled = avpkt->data[8];
399  if (scaled < 2) {
400  int mode = avpkt->data[10];
401 
402  switch (mode) {
403  case 1:
404  width = 352;
405  height = 240;
406  break;
407  case 2:
408  width = 704;
409  height = 240;
410  break;
411  case 4:
412  width = 480;
413  height = 704;
414  break;
415  case 17:
416  width = 352;
417  height = 288;
418  break;
419  case 18:
420  width = 704;
421  height = 288;
422  break;
423  default:
424  width = 704;
425  height = 576;
426  break;
427  }
428  }
429 
430  skip_bits_long(gb, 24 * 8);
431  type = get_bits_long(gb, 32);
432  s->hi = get_bits(gb, 16);
433  s->lo = get_bits(gb, 16);
434 
435  switch (type) {
436  case 0x19781977:
437  frame->key_frame = 1;
438  frame->pict_type = AV_PICTURE_TYPE_I;
439  break;
440  case 0x12250926:
441  frame->key_frame = 0;
442  frame->pict_type = AV_PICTURE_TYPE_P;
443  break;
444  default:
445  avpriv_request_sample(avctx, "type %X", type);
446  return AVERROR_PATCHWELCOME;
447  }
448 
449  if (avctx->width != width ||
450  avctx->height != height) {
451  if (!frame->key_frame) {
452  av_log(avctx, AV_LOG_ERROR, "Frame size change is unsupported.\n");
453  return AVERROR_INVALIDDATA;
454  }
455  av_frame_unref(s->prev_frame);
456  }
457 
458  ret = ff_set_dimensions(avctx, width, height);
459  if (ret < 0)
460  return ret;
461 
462  if ((ret = ff_get_buffer(avctx, frame, frame->key_frame ? AV_GET_BUFFER_FLAG_REF : 0)) < 0)
463  return ret;
464 
465  if (frame->key_frame) {
466  ret = decode_intra(avctx, gb, frame);
467  if (ret < 0)
468  return ret;
469 
470  av_frame_unref(s->prev_frame);
471  if ((ret = av_frame_ref(s->prev_frame, frame)) < 0)
472  return ret;
473  } else {
474  if (!s->prev_frame->data[0]) {
475  av_log(avctx, AV_LOG_ERROR, "Missing reference frame.\n");
476  return AVERROR_INVALIDDATA;
477  }
478 
479  ret = decode_inter(avctx, gb, frame, s->prev_frame);
480  if (ret < 0)
481  return ret;
482  }
483 
484  *got_frame = 1;
485 
486  return avpkt->size;
487 }
488 
490 {
492  cbplo_bits, 1, 1, cbplo_codes, 1, 1, cbplo_symbols, 1, 1, 512);
493 
495  cbphi_bits, 1, 1, cbphi_codes, 1, 1, NULL, 0, 0, 64);
496 
498  blktype_bits, 1, 1, blktype_codes, 1, 1, blktype_symbols, 1, 1, 512);
499 
501  block_bits, 1, 1, block_codes, 1, 1, block_symbols, 2, 2, 4096);
502 }
503 
505 {
506  static AVOnce init_static_once = AV_ONCE_INIT;
507  IMM4Context *s = avctx->priv_data;
508  uint8_t table[64];
509 
510  for (int i = 0; i < 64; i++)
511  table[i] = i;
512 
513  ff_bswapdsp_init(&s->bdsp);
514  ff_idctdsp_init(&s->idsp, avctx);
515  ff_init_scantable(s->idsp.idct_permutation, &s->intra_scantable, table);
516 
517  s->prev_frame = av_frame_alloc();
518  if (!s->prev_frame)
519  return AVERROR(ENOMEM);
520 
521  ff_thread_once(&init_static_once, imm4_init_static_data);
522 
523  return 0;
524 }
525 
526 static void decode_flush(AVCodecContext *avctx)
527 {
528  IMM4Context *s = avctx->priv_data;
529 
530  av_frame_unref(s->prev_frame);
531 }
532 
534 {
535  IMM4Context *s = avctx->priv_data;
536 
537  av_frame_free(&s->prev_frame);
538  av_freep(&s->bitstream);
539  s->bitstream_size = 0;
540 
541  return 0;
542 }
543 
545  .name = "imm4",
546  .long_name = NULL_IF_CONFIG_SMALL("Infinity IMM4"),
547  .type = AVMEDIA_TYPE_VIDEO,
548  .id = AV_CODEC_ID_IMM4,
549  .priv_data_size = sizeof(IMM4Context),
550  .init = decode_init,
551  .close = decode_close,
552  .decode = decode_frame,
553  .flush = decode_flush,
554  .capabilities = AV_CODEC_CAP_DR1,
555  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
557 };
cbplo_bits
static const uint8_t cbplo_bits[]
Definition: imm4.c:65
imm4_init_static_data
static av_cold void imm4_init_static_data(void)
Definition: imm4.c:489
AVCodec
AVCodec.
Definition: codec.h:190
bswapdsp.h
IMM4Context::factor
int factor
Definition: imm4.c:44
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_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:40
ff_init_scantable
av_cold void ff_init_scantable(uint8_t *permutation, ScanTable *st, const uint8_t *src_scantable)
Definition: idctdsp.c:29
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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
get_cbphi
static int get_cbphi(GetBitContext *gb, int x)
Definition: imm4.c:129
thread.h
cbplo_codes
static const uint8_t cbplo_codes[]
Definition: imm4.c:69
block_bits
static const uint8_t block_bits[]
Definition: imm4.c:106
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:203
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
cbplo_symbols
static const uint8_t cbplo_symbols[]
Definition: imm4.c:61
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:535
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:355
table
static const uint16_t table[]
Definition: prosumer.c:206
data
const char data[16]
Definition: mxf.c:91
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:797
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
reverse
static uint32_t reverse(uint32_t num, int bits)
Definition: speedhq.c:565
intra_cb
static const uint8_t intra_cb[]
Definition: imm4.c:53
decode_close
static av_cold int decode_close(AVCodecContext *avctx)
Definition: imm4.c:533
IMM4Context::intra_scantable
ScanTable intra_scantable
Definition: imm4.c:48
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
block_tab
static VLC block_tab
Definition: imm4.c:127
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
GetBitContext
Definition: get_bits.h:61
blktype_symbols
static const uint8_t blktype_symbols[]
Definition: imm4.c:81
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:213
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:190
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:176
cbplo_tab
static VLC cbplo_tab
Definition: imm4.c:124
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:677
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:57
ff_imm4_decoder
AVCodec ff_imm4_decoder
Definition: imm4.c:544
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
width
#define width
decode_block
static int decode_block(AVCodecContext *avctx, GetBitContext *gb, int block, int factor, int flag, int offset, int flag2)
Definition: imm4.c:140
s
#define s(width, name)
Definition: cbs_vp9.c:257
IMM4Context::bdsp
BswapDSPContext bdsp
Definition: imm4.c:37
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:509
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:504
cbphi_codes
static const uint8_t cbphi_codes[]
Definition: imm4.c:77
get_bits.h
blktype_tab
static VLC blktype_tab
Definition: imm4.c:126
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:46
AV_ONCE_INIT
#define AV_ONCE_INIT
Definition: thread.h:173
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
flush
static void flush(AVCodecContext *avctx)
Definition: aacdec_template.c:500
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
blktype_bits
static const uint8_t blktype_bits[]
Definition: imm4.c:85
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
block_codes
static const uint8_t block_codes[]
Definition: imm4.c:115
blktype_codes
static const uint8_t blktype_codes[]
Definition: imm4.c:89
AVOnce
#define AVOnce
Definition: thread.h:172
inter_cb
static const uint8_t inter_cb[]
Definition: imm4.c:57
IMM4Context::bitstream_size
int bitstream_size
Definition: imm4.c:42
ff_get_buffer
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: decode.c:1854
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
AVPacket::size
int size
Definition: packet.h:356
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:188
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:444
block_symbols
static const uint16_t block_symbols[]
Definition: imm4.c:93
decode_inter
static int decode_inter(AVCodecContext *avctx, GetBitContext *gb, AVFrame *frame, AVFrame *prev)
Definition: imm4.c:264
height
#define height
AV_CODEC_ID_IMM4
@ AV_CODEC_ID_IMM4
Definition: codec_id.h:281
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:40
flag
#define flag(name)
Definition: cbs_av1.c:557
DECLARE_ALIGNED
#define DECLARE_ALIGNED(n, t, v)
Definition: mem.h:112
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
copy_block.h
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:48
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:70
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
uint8_t
uint8_t
Definition: audio_convert.c:194
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:554
IMM4Context::bitstream
uint8_t * bitstream
Definition: imm4.c:41
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:197
len
int len
Definition: vorbis_enc_data.h:452
AVCodecContext::height
int height
Definition: avcodec.h:699
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
IMM4Context::block
int16_t block[6][64]
Definition: imm4.c:49
idctdsp.h
avcodec.h
VLC::bits
int bits
Definition: vlc.h:27
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_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
AVCodecContext
main external API structure.
Definition: avcodec.h:526
IMM4Context::gb
GetBitContext gb
Definition: imm4.c:38
mode
mode
Definition: ebur128.h:83
VLC
Definition: vlc.h:26
factor
static const int factor[16]
Definition: vf_pp7.c:75
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:104
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
ScanTable
Scantable.
Definition: idctdsp.h:31
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
AVPacket
This structure stores compressed data.
Definition: packet.h:332
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
IMM4Context
Definition: imm4.c:36
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
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:59
BswapDSPContext
Definition: bswapdsp.h:24
decode_flush
static void decode_flush(AVCodecContext *avctx)
Definition: imm4.c:526
cbphi_tab
static VLC cbphi_tab
Definition: imm4.c:125
decode_blocks
static int decode_blocks(AVCodecContext *avctx, GetBitContext *gb, unsigned cbp, int flag, int offset, unsigned flag2)
Definition: imm4.c:183
VLC::table
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
decode_frame
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: imm4.c:367
IMM4Context::idsp
IDCTDSPContext idsp
Definition: imm4.c:50
IMM4Context::lo
unsigned lo
Definition: imm4.c:45