FFmpeg  4.3.9
huffyuvdec.c
Go to the documentation of this file.
1 /*
2  * huffyuv decoder
3  *
4  * Copyright (c) 2002-2014 Michael Niedermayer <michaelni@gmx.at>
5  *
6  * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
7  * the algorithm used
8  *
9  * This file is part of FFmpeg.
10  *
11  * FFmpeg is free software; you can redistribute it and/or
12  * modify it under the terms of the GNU Lesser General Public
13  * License as published by the Free Software Foundation; either
14  * version 2.1 of the License, or (at your option) any later version.
15  *
16  * FFmpeg is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19  * Lesser General Public License for more details.
20  *
21  * You should have received a copy of the GNU Lesser General Public
22  * License along with FFmpeg; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  *
25  * yuva, gray, 4:4:4, 4:1:1, 4:1:0 and >8 bit per sample support sponsored by NOA
26  */
27 
28 /**
29  * @file
30  * huffyuv decoder
31  */
32 
33 #define UNCHECKED_BITSTREAM_READER 1
34 
35 #include "avcodec.h"
36 #include "get_bits.h"
37 #include "huffyuv.h"
38 #include "huffyuvdsp.h"
39 #include "lossless_videodsp.h"
40 #include "thread.h"
41 #include "libavutil/imgutils.h"
42 #include "libavutil/pixdesc.h"
43 
44 #define classic_shift_luma_table_size 42
46  34, 36, 35, 69, 135, 232, 9, 16, 10, 24, 11, 23, 12, 16, 13, 10,
47  14, 8, 15, 8, 16, 8, 17, 20, 16, 10, 207, 206, 205, 236, 11, 8,
48  10, 21, 9, 23, 8, 8, 199, 70, 69, 68, 0,
49  0,0,0,0,0,0,0,0,
50 };
51 
52 #define classic_shift_chroma_table_size 59
54  66, 36, 37, 38, 39, 40, 41, 75, 76, 77, 110, 239, 144, 81, 82, 83,
55  84, 85, 118, 183, 56, 57, 88, 89, 56, 89, 154, 57, 58, 57, 26, 141,
56  57, 56, 58, 57, 58, 57, 184, 119, 214, 245, 116, 83, 82, 49, 80, 79,
57  78, 77, 44, 75, 41, 40, 39, 38, 37, 36, 34, 0,
58  0,0,0,0,0,0,0,0,
59 };
60 
61 static const unsigned char classic_add_luma[256] = {
62  3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
63  73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
64  68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
65  35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
66  37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
67  35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
68  27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
69  15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
70  12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
71  12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
72  18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
73  28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
74  28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
75  62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
76  54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
77  46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
78 };
79 
80 static const unsigned char classic_add_chroma[256] = {
81  3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
82  7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
83  11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
84  43, 45, 76, 81, 46, 82, 75, 55, 56, 144, 58, 80, 60, 74, 147, 63,
85  143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
86  80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
87  17, 14, 5, 6, 100, 54, 47, 50, 51, 53, 106, 107, 108, 109, 110, 111,
88  112, 113, 114, 115, 4, 117, 118, 92, 94, 121, 122, 3, 124, 103, 2, 1,
89  0, 129, 130, 131, 120, 119, 126, 125, 136, 137, 138, 139, 140, 141, 142, 134,
90  135, 132, 133, 104, 64, 101, 62, 57, 102, 95, 93, 59, 61, 28, 97, 96,
91  52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
92  19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
93  7, 128, 127, 105, 123, 116, 35, 34, 33, 145, 31, 79, 42, 146, 78, 26,
94  83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
95  14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
96  6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
97 };
98 
99 static int read_len_table(uint8_t *dst, GetBitContext *gb, int n)
100 {
101  int i, val, repeat;
102 
103  for (i = 0; i < n;) {
104  repeat = get_bits(gb, 3);
105  val = get_bits(gb, 5);
106  if (repeat == 0)
107  repeat = get_bits(gb, 8);
108  if (i + repeat > n || get_bits_left(gb) < 0) {
109  av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
110  return AVERROR_INVALIDDATA;
111  }
112  while (repeat--)
113  dst[i++] = val;
114  }
115  return 0;
116 }
117 
119 {
120  int ret;
121  uint16_t *symbols = av_mallocz(5 << VLC_BITS);
122  uint16_t *bits;
123  uint8_t *len;
124  if (!symbols)
125  return AVERROR(ENOMEM);
126  bits = symbols + (1 << VLC_BITS);
127  len = (uint8_t *)(bits + (1 << VLC_BITS));
128 
129  if (s->bitstream_bpp < 24 || s->version > 2) {
130  int p, i, y, u;
131  for (p = 0; p < 4; p++) {
132  int p0 = s->version > 2 ? p : 0;
133  for (i = y = 0; y < s->vlc_n; y++) {
134  int len0 = s->len[p0][y];
135  int limit = VLC_BITS - len0;
136  if (limit <= 0 || !len0)
137  continue;
138  if ((sign_extend(y, 8) & (s->vlc_n-1)) != y)
139  continue;
140  for (u = 0; u < s->vlc_n; u++) {
141  int len1 = s->len[p][u];
142  if (len1 > limit || !len1)
143  continue;
144  if ((sign_extend(u, 8) & (s->vlc_n-1)) != u)
145  continue;
146  av_assert0(i < (1 << VLC_BITS));
147  len[i] = len0 + len1;
148  bits[i] = (s->bits[p0][y] << len1) + s->bits[p][u];
149  symbols[i] = (y << 8) + (u & 0xFF);
150  i++;
151  }
152  }
153  ff_free_vlc(&s->vlc[4 + p]);
154  if ((ret = ff_init_vlc_sparse(&s->vlc[4 + p], VLC_BITS, i, len, 1, 1,
155  bits, 2, 2, symbols, 2, 2, 0)) < 0)
156  goto out;
157  }
158  } else {
159  uint8_t (*map)[4] = (uint8_t(*)[4]) s->pix_bgr_map;
160  int i, b, g, r, code;
161  int p0 = s->decorrelate;
162  int p1 = !s->decorrelate;
163  /* Restrict the range to +/-16 because that's pretty much guaranteed
164  * to cover all the combinations that fit in 11 bits total, and it
165  * does not matter if we miss a few rare codes. */
166  for (i = 0, g = -16; g < 16; g++) {
167  int len0 = s->len[p0][g & 255];
168  int limit0 = VLC_BITS - len0;
169  if (limit0 < 2 || !len0)
170  continue;
171  for (b = -16; b < 16; b++) {
172  int len1 = s->len[p1][b & 255];
173  int limit1 = limit0 - len1;
174  if (limit1 < 1 || !len1)
175  continue;
176  code = (s->bits[p0][g & 255] << len1) + s->bits[p1][b & 255];
177  for (r = -16; r < 16; r++) {
178  int len2 = s->len[2][r & 255];
179  if (len2 > limit1 || !len2)
180  continue;
181  av_assert0(i < (1 << VLC_BITS));
182  len[i] = len0 + len1 + len2;
183  bits[i] = (code << len2) + s->bits[2][r & 255];
184  if (s->decorrelate) {
185  map[i][G] = g;
186  map[i][B] = g + b;
187  map[i][R] = g + r;
188  } else {
189  map[i][B] = g;
190  map[i][G] = b;
191  map[i][R] = r;
192  }
193  i++;
194  }
195  }
196  }
197  ff_free_vlc(&s->vlc[4]);
198  if ((ret = init_vlc(&s->vlc[4], VLC_BITS, i, len, 1, 1,
199  bits, 2, 2, 0)) < 0)
200  goto out;
201  }
202  ret = 0;
203 out:
204  av_freep(&symbols);
205  return ret;
206 }
207 
208 static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length)
209 {
210  GetBitContext gb;
211  int i, ret;
212  int count = 3;
213 
214  if ((ret = init_get_bits(&gb, src, length * 8)) < 0)
215  return ret;
216 
217  if (s->version > 2)
218  count = 1 + s->alpha + 2*s->chroma;
219 
220  for (i = 0; i < count; i++) {
221  if ((ret = read_len_table(s->len[i], &gb, s->vlc_n)) < 0)
222  return ret;
223  if ((ret = ff_huffyuv_generate_bits_table(s->bits[i], s->len[i], s->vlc_n)) < 0)
224  return ret;
225  ff_free_vlc(&s->vlc[i]);
226  if ((ret = init_vlc(&s->vlc[i], VLC_BITS, s->vlc_n, s->len[i], 1, 1,
227  s->bits[i], 4, 4, 0)) < 0)
228  return ret;
229  }
230 
231  if ((ret = generate_joint_tables(s)) < 0)
232  return ret;
233 
234  return (get_bits_count(&gb) + 7) / 8;
235 }
236 
238 {
239  GetBitContext gb;
240  int i, ret;
241 
244  if ((ret = read_len_table(s->len[0], &gb, 256)) < 0)
245  return ret;
246 
249  if ((ret = read_len_table(s->len[1], &gb, 256)) < 0)
250  return ret;
251 
252  for (i = 0; i < 256; i++)
253  s->bits[0][i] = classic_add_luma[i];
254  for (i = 0; i < 256; i++)
255  s->bits[1][i] = classic_add_chroma[i];
256 
257  if (s->bitstream_bpp >= 24) {
258  memcpy(s->bits[1], s->bits[0], 256 * sizeof(uint32_t));
259  memcpy(s->len[1], s->len[0], 256 * sizeof(uint8_t));
260  }
261  memcpy(s->bits[2], s->bits[1], 256 * sizeof(uint32_t));
262  memcpy(s->len[2], s->len[1], 256 * sizeof(uint8_t));
263 
264  for (i = 0; i < 4; i++) {
265  ff_free_vlc(&s->vlc[i]);
266  if ((ret = init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
267  s->bits[i], 4, 4, 0)) < 0)
268  return ret;
269  }
270 
271  if ((ret = generate_joint_tables(s)) < 0)
272  return ret;
273 
274  return 0;
275 }
276 
278 {
279  HYuvContext *s = avctx->priv_data;
280  int i;
281 
284 
285  for (i = 0; i < 8; i++)
286  ff_free_vlc(&s->vlc[i]);
287 
288  return 0;
289 }
290 
292 {
293  HYuvContext *s = avctx->priv_data;
294  int ret;
295 
296  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
297  if (ret < 0)
298  return ret;
299 
300  ff_huffyuvdsp_init(&s->hdsp, avctx->pix_fmt);
302  memset(s->vlc, 0, 4 * sizeof(VLC));
303 
304  s->interlaced = avctx->height > 288;
305  s->bgr32 = 1;
306 
307  if (avctx->extradata_size) {
308  if ((avctx->bits_per_coded_sample & 7) &&
309  avctx->bits_per_coded_sample != 12)
310  s->version = 1; // do such files exist at all?
311  else if (avctx->extradata_size > 3 && avctx->extradata[3] == 0)
312  s->version = 2;
313  else
314  s->version = 3;
315  } else
316  s->version = 0;
317 
318  s->bps = 8;
319  s->n = 1<<s->bps;
320  s->vlc_n = FFMIN(s->n, MAX_VLC_N);
321  s->chroma = 1;
322  if (s->version >= 2) {
323  int method, interlace;
324 
325  if (avctx->extradata_size < 4)
326  return AVERROR_INVALIDDATA;
327 
328  method = avctx->extradata[0];
329  s->decorrelate = method & 64 ? 1 : 0;
330  s->predictor = method & 63;
331  if (s->version == 2) {
332  s->bitstream_bpp = avctx->extradata[1];
333  if (s->bitstream_bpp == 0)
334  s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
335  } else {
336  s->bps = (avctx->extradata[1] >> 4) + 1;
337  s->n = 1<<s->bps;
338  s->vlc_n = FFMIN(s->n, MAX_VLC_N);
339  s->chroma_h_shift = avctx->extradata[1] & 3;
340  s->chroma_v_shift = (avctx->extradata[1] >> 2) & 3;
341  s->yuv = !!(avctx->extradata[2] & 1);
342  s->chroma= !!(avctx->extradata[2] & 3);
343  s->alpha = !!(avctx->extradata[2] & 4);
344  }
345  interlace = (avctx->extradata[2] & 0x30) >> 4;
346  s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 : s->interlaced;
347  s->context = avctx->extradata[2] & 0x40 ? 1 : 0;
348 
349  if ((ret = read_huffman_tables(s, avctx->extradata + 4,
350  avctx->extradata_size - 4)) < 0)
351  goto error;
352  } else {
353  switch (avctx->bits_per_coded_sample & 7) {
354  case 1:
355  s->predictor = LEFT;
356  s->decorrelate = 0;
357  break;
358  case 2:
359  s->predictor = LEFT;
360  s->decorrelate = 1;
361  break;
362  case 3:
363  s->predictor = PLANE;
364  s->decorrelate = avctx->bits_per_coded_sample >= 24;
365  break;
366  case 4:
367  s->predictor = MEDIAN;
368  s->decorrelate = 0;
369  break;
370  default:
371  s->predictor = LEFT; // OLD
372  s->decorrelate = 0;
373  break;
374  }
375  s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
376  s->context = 0;
377 
378  if ((ret = read_old_huffman_tables(s)) < 0)
379  goto error;
380  }
381 
382  if (s->version <= 2) {
383  switch (s->bitstream_bpp) {
384  case 12:
385  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
386  s->yuv = 1;
387  break;
388  case 16:
389  if (s->yuy2)
390  avctx->pix_fmt = AV_PIX_FMT_YUYV422;
391  else
392  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
393  s->yuv = 1;
394  break;
395  case 24:
396  if (s->bgr32)
397  avctx->pix_fmt = AV_PIX_FMT_0RGB32;
398  else
399  avctx->pix_fmt = AV_PIX_FMT_BGR24;
400  break;
401  case 32:
402  av_assert0(s->bgr32);
403  avctx->pix_fmt = AV_PIX_FMT_RGB32;
404  s->alpha = 1;
405  break;
406  default:
407  ret = AVERROR_INVALIDDATA;
408  goto error;
409  }
411  &s->chroma_h_shift,
412  &s->chroma_v_shift);
413  } else {
414  switch ( (s->chroma<<10) | (s->yuv<<9) | (s->alpha<<8) | ((s->bps-1)<<4) | s->chroma_h_shift | (s->chroma_v_shift<<2)) {
415  case 0x070:
416  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
417  break;
418  case 0x0F0:
419  avctx->pix_fmt = AV_PIX_FMT_GRAY16;
420  break;
421  case 0x470:
422  avctx->pix_fmt = AV_PIX_FMT_GBRP;
423  break;
424  case 0x480:
425  avctx->pix_fmt = AV_PIX_FMT_GBRP9;
426  break;
427  case 0x490:
428  avctx->pix_fmt = AV_PIX_FMT_GBRP10;
429  break;
430  case 0x4B0:
431  avctx->pix_fmt = AV_PIX_FMT_GBRP12;
432  break;
433  case 0x4D0:
434  avctx->pix_fmt = AV_PIX_FMT_GBRP14;
435  break;
436  case 0x4F0:
437  avctx->pix_fmt = AV_PIX_FMT_GBRP16;
438  break;
439  case 0x570:
440  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
441  break;
442  case 0x670:
443  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
444  break;
445  case 0x680:
446  avctx->pix_fmt = AV_PIX_FMT_YUV444P9;
447  break;
448  case 0x690:
449  avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
450  break;
451  case 0x6B0:
452  avctx->pix_fmt = AV_PIX_FMT_YUV444P12;
453  break;
454  case 0x6D0:
455  avctx->pix_fmt = AV_PIX_FMT_YUV444P14;
456  break;
457  case 0x6F0:
458  avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
459  break;
460  case 0x671:
461  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
462  break;
463  case 0x681:
464  avctx->pix_fmt = AV_PIX_FMT_YUV422P9;
465  break;
466  case 0x691:
467  avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
468  break;
469  case 0x6B1:
470  avctx->pix_fmt = AV_PIX_FMT_YUV422P12;
471  break;
472  case 0x6D1:
473  avctx->pix_fmt = AV_PIX_FMT_YUV422P14;
474  break;
475  case 0x6F1:
476  avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
477  break;
478  case 0x672:
479  avctx->pix_fmt = AV_PIX_FMT_YUV411P;
480  break;
481  case 0x674:
482  avctx->pix_fmt = AV_PIX_FMT_YUV440P;
483  break;
484  case 0x675:
485  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
486  break;
487  case 0x685:
488  avctx->pix_fmt = AV_PIX_FMT_YUV420P9;
489  break;
490  case 0x695:
491  avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
492  break;
493  case 0x6B5:
494  avctx->pix_fmt = AV_PIX_FMT_YUV420P12;
495  break;
496  case 0x6D5:
497  avctx->pix_fmt = AV_PIX_FMT_YUV420P14;
498  break;
499  case 0x6F5:
500  avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
501  break;
502  case 0x67A:
503  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
504  break;
505  case 0x770:
506  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
507  break;
508  case 0x780:
509  avctx->pix_fmt = AV_PIX_FMT_YUVA444P9;
510  break;
511  case 0x790:
513  break;
514  case 0x7F0:
516  break;
517  case 0x771:
518  avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
519  break;
520  case 0x781:
521  avctx->pix_fmt = AV_PIX_FMT_YUVA422P9;
522  break;
523  case 0x791:
525  break;
526  case 0x7F1:
528  break;
529  case 0x775:
530  avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
531  break;
532  case 0x785:
533  avctx->pix_fmt = AV_PIX_FMT_YUVA420P9;
534  break;
535  case 0x795:
537  break;
538  case 0x7F5:
540  break;
541  default:
542  ret = AVERROR_INVALIDDATA;
543  goto error;
544  }
545  }
546 
547  ff_huffyuv_common_init(avctx);
548 
549  if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV420P) && avctx->width & 1) {
550  av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");
551  ret = AVERROR_INVALIDDATA;
552  goto error;
553  }
554  if (s->predictor == MEDIAN && avctx->pix_fmt == AV_PIX_FMT_YUV422P &&
555  avctx->width % 4) {
556  av_log(avctx, AV_LOG_ERROR, "width must be a multiple of 4 "
557  "for this combination of colorspace and predictor type.\n");
558  ret = AVERROR_INVALIDDATA;
559  goto error;
560  }
561 
562  if ((ret = ff_huffyuv_alloc_temp(s)) < 0) {
564  goto error;
565  }
566 
567  return 0;
568  error:
569  decode_end(avctx);
570  return ret;
571 }
572 
573 /** Subset of GET_VLC for use in hand-roller VLC code */
574 #define VLC_INTERN(dst, table, gb, name, bits, max_depth) \
575  code = table[index][0]; \
576  n = table[index][1]; \
577  if (max_depth > 1 && n < 0) { \
578  LAST_SKIP_BITS(name, gb, bits); \
579  UPDATE_CACHE(name, gb); \
580  \
581  nb_bits = -n; \
582  index = SHOW_UBITS(name, gb, nb_bits) + code; \
583  code = table[index][0]; \
584  n = table[index][1]; \
585  if (max_depth > 2 && n < 0) { \
586  LAST_SKIP_BITS(name, gb, nb_bits); \
587  UPDATE_CACHE(name, gb); \
588  \
589  nb_bits = -n; \
590  index = SHOW_UBITS(name, gb, nb_bits) + code; \
591  code = table[index][0]; \
592  n = table[index][1]; \
593  } \
594  } \
595  dst = code; \
596  LAST_SKIP_BITS(name, gb, n)
597 
598 
599 #define GET_VLC_DUAL(dst0, dst1, name, gb, dtable, table1, table2, \
600  bits, max_depth, OP) \
601  do { \
602  unsigned int index = SHOW_UBITS(name, gb, bits); \
603  int code, n = dtable[index][1]; \
604  \
605  if (n<=0) { \
606  int nb_bits; \
607  VLC_INTERN(dst0, table1, gb, name, bits, max_depth); \
608  \
609  UPDATE_CACHE(re, gb); \
610  index = SHOW_UBITS(name, gb, bits); \
611  VLC_INTERN(dst1, table2, gb, name, bits, max_depth); \
612  } else { \
613  code = dtable[index][0]; \
614  OP(dst0, dst1, code); \
615  LAST_SKIP_BITS(name, gb, n); \
616  } \
617  } while (0)
618 
619 #define OP8bits(dst0, dst1, code) dst0 = code>>8; dst1 = code
620 
621 #define READ_2PIX(dst0, dst1, plane1) \
622  UPDATE_CACHE(re, &s->gb); \
623  GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane1].table, \
624  s->vlc[0].table, s->vlc[plane1].table, VLC_BITS, 3, OP8bits)
625 
626 static void decode_422_bitstream(HYuvContext *s, int count)
627 {
628  int i, icount;
629  OPEN_READER(re, &s->gb);
630  count /= 2;
631 
632  icount = get_bits_left(&s->gb) / (32 * 4);
633  if (count >= icount) {
634  for (i = 0; i < icount; i++) {
635  READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1);
636  READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
637  }
638  for (; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
639  READ_2PIX(s->temp[0][2 * i ], s->temp[1][i], 1);
640  if (BITS_LEFT(re, &s->gb) <= 0) break;
641  READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
642  }
643  for (; i < count; i++)
644  s->temp[0][2 * i ] = s->temp[1][i] =
645  s->temp[0][2 * i + 1] = s->temp[2][i] = 0;
646  } else {
647  for (i = 0; i < count; i++) {
648  READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1);
649  READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
650  }
651  }
652  CLOSE_READER(re, &s->gb);
653 }
654 
655 #define READ_2PIX_PLANE(dst0, dst1, plane, OP) \
656  UPDATE_CACHE(re, &s->gb); \
657  GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane].table, \
658  s->vlc[plane].table, s->vlc[plane].table, VLC_BITS, 3, OP)
659 
660 #define OP14bits(dst0, dst1, code) dst0 = code>>8; dst1 = sign_extend(code, 8)
661 
662 /* TODO instead of restarting the read when the code isn't in the first level
663  * of the joint table, jump into the 2nd level of the individual table. */
664 #define READ_2PIX_PLANE16(dst0, dst1, plane){\
665  dst0 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\
666  dst0 += get_bits(&s->gb, 2);\
667  dst1 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\
668  dst1 += get_bits(&s->gb, 2);\
669 }
670 static void decode_plane_bitstream(HYuvContext *s, int width, int plane)
671 {
672  int i, count = width/2;
673 
674  if (s->bps <= 8) {
675  OPEN_READER(re, &s->gb);
676  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
677  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
678  READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits);
679  }
680  } else {
681  for(i=0; i<count; i++){
682  READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits);
683  }
684  }
685  if( width&1 && BITS_LEFT(re, &s->gb)>0 ) {
686  unsigned int index;
687  int nb_bits, code, n;
688  UPDATE_CACHE(re, &s->gb);
689  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
690  VLC_INTERN(s->temp[0][width-1], s->vlc[plane].table,
691  &s->gb, re, VLC_BITS, 3);
692  }
693  CLOSE_READER(re, &s->gb);
694  } else if (s->bps <= 14) {
695  OPEN_READER(re, &s->gb);
696  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
697  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
698  READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits);
699  }
700  } else {
701  for(i=0; i<count; i++){
702  READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits);
703  }
704  }
705  if( width&1 && BITS_LEFT(re, &s->gb)>0 ) {
706  unsigned int index;
707  int nb_bits, code, n;
708  UPDATE_CACHE(re, &s->gb);
709  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
710  VLC_INTERN(s->temp16[0][width-1], s->vlc[plane].table,
711  &s->gb, re, VLC_BITS, 3);
712  }
713  CLOSE_READER(re, &s->gb);
714  } else {
715  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
716  for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
717  READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane);
718  }
719  } else {
720  for(i=0; i<count; i++){
721  READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane);
722  }
723  }
724  if( width&1 && get_bits_left(&s->gb)>0 ) {
725  int dst = (unsigned)get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)<<2;
726  s->temp16[0][width-1] = dst + get_bits(&s->gb, 2);
727  }
728  }
729 }
730 
731 static void decode_gray_bitstream(HYuvContext *s, int count)
732 {
733  int i;
734  OPEN_READER(re, &s->gb);
735  count /= 2;
736 
737  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
738  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
739  READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
740  }
741  for (; i < count; i++)
742  s->temp[0][2 * i] = s->temp[0][2 * i + 1] = 0;
743  } else {
744  for (i = 0; i < count; i++) {
745  READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
746  }
747  }
748  CLOSE_READER(re, &s->gb);
749 }
750 
751 static av_always_inline void decode_bgr_1(HYuvContext *s, int count,
752  int decorrelate, int alpha)
753 {
754  int i;
755  OPEN_READER(re, &s->gb);
756 
757  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
758  unsigned int index;
759  int code, n, nb_bits;
760 
761  UPDATE_CACHE(re, &s->gb);
762  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
763  n = s->vlc[4].table[index][1];
764 
765  if (n>0) {
766  code = s->vlc[4].table[index][0];
767  *(uint32_t *) &s->temp[0][4 * i] = s->pix_bgr_map[code];
768  LAST_SKIP_BITS(re, &s->gb, n);
769  } else {
770  if (decorrelate) {
771  VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table,
772  &s->gb, re, VLC_BITS, 3);
773 
774  UPDATE_CACHE(re, &s->gb);
775  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
776  VLC_INTERN(code, s->vlc[0].table, &s->gb, re, VLC_BITS, 3);
777  s->temp[0][4 * i + B] = code + s->temp[0][4 * i + G];
778 
779  UPDATE_CACHE(re, &s->gb);
780  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
781  VLC_INTERN(code, s->vlc[2].table, &s->gb, re, VLC_BITS, 3);
782  s->temp[0][4 * i + R] = code + s->temp[0][4 * i + G];
783  } else {
784  VLC_INTERN(s->temp[0][4 * i + B], s->vlc[0].table,
785  &s->gb, re, VLC_BITS, 3);
786 
787  UPDATE_CACHE(re, &s->gb);
788  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
789  VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table,
790  &s->gb, re, VLC_BITS, 3);
791 
792  UPDATE_CACHE(re, &s->gb);
793  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
794  VLC_INTERN(s->temp[0][4 * i + R], s->vlc[2].table,
795  &s->gb, re, VLC_BITS, 3);
796  }
797  }
798  if (alpha) {
799  UPDATE_CACHE(re, &s->gb);
800  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
801  VLC_INTERN(s->temp[0][4 * i + A], s->vlc[2].table,
802  &s->gb, re, VLC_BITS, 3);
803  } else
804  s->temp[0][4 * i + A] = 0;
805  }
806  CLOSE_READER(re, &s->gb);
807 }
808 
809 static void decode_bgr_bitstream(HYuvContext *s, int count)
810 {
811  if (s->decorrelate) {
812  if (s->bitstream_bpp == 24)
813  decode_bgr_1(s, count, 1, 0);
814  else
815  decode_bgr_1(s, count, 1, 1);
816  } else {
817  if (s->bitstream_bpp == 24)
818  decode_bgr_1(s, count, 0, 0);
819  else
820  decode_bgr_1(s, count, 0, 1);
821  }
822 }
823 
824 static void draw_slice(HYuvContext *s, AVFrame *frame, int y)
825 {
826  int h, cy, i;
828 
829  if (!s->avctx->draw_horiz_band)
830  return;
831 
832  h = y - s->last_slice_end;
833  y -= h;
834 
835  if (s->bitstream_bpp == 12)
836  cy = y >> 1;
837  else
838  cy = y;
839 
840  offset[0] = frame->linesize[0] * y;
841  offset[1] = frame->linesize[1] * cy;
842  offset[2] = frame->linesize[2] * cy;
843  for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
844  offset[i] = 0;
845  emms_c();
846 
847  s->avctx->draw_horiz_band(s->avctx, frame, offset, y, 3, h);
848 
849  s->last_slice_end = y + h;
850 }
851 
852 static int left_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int acc)
853 {
854  if (s->bps <= 8) {
855  return s->llviddsp.add_left_pred(dst, src, w, acc);
856  } else {
857  return s->llviddsp.add_left_pred_int16(( uint16_t *)dst, (const uint16_t *)src, s->n-1, w, acc);
858  }
859 }
860 
861 static void add_bytes(HYuvContext *s, uint8_t *dst, uint8_t *src, int w)
862 {
863  if (s->bps <= 8) {
864  s->llviddsp.add_bytes(dst, src, w);
865  } else {
866  s->hdsp.add_int16((uint16_t*)dst, (const uint16_t*)src, s->n - 1, w);
867  }
868 }
869 
870 static void add_median_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, const uint8_t *diff, int w, int *left, int *left_top)
871 {
872  if (s->bps <= 8) {
873  s->llviddsp.add_median_pred(dst, src, diff, w, left, left_top);
874  } else {
875  s->hdsp.add_hfyu_median_pred_int16((uint16_t *)dst, (const uint16_t *)src, (const uint16_t *)diff, s->n-1, w, left, left_top);
876  }
877 }
878 
879 static int decode_slice(AVCodecContext *avctx, AVFrame *p, int height,
880  int buf_size, int y_offset, int table_size)
881 {
882  HYuvContext *s = avctx->priv_data;
883  int fake_ystride, fake_ustride, fake_vstride;
884  const int width = s->width;
885  const int width2 = s->width >> 1;
886  int ret;
887 
888  if ((ret = init_get_bits8(&s->gb, s->bitstream_buffer + table_size, buf_size - table_size)) < 0)
889  return ret;
890 
891  fake_ystride = s->interlaced ? p->linesize[0] * 2 : p->linesize[0];
892  fake_ustride = s->interlaced ? p->linesize[1] * 2 : p->linesize[1];
893  fake_vstride = s->interlaced ? p->linesize[2] * 2 : p->linesize[2];
894 
895  if (s->version > 2) {
896  int plane;
897  for(plane = 0; plane < 1 + 2*s->chroma + s->alpha; plane++) {
898  int left, lefttop, y;
899  int w = width;
900  int h = height;
901  int fake_stride = fake_ystride;
902 
903  if (s->chroma && (plane == 1 || plane == 2)) {
904  w >>= s->chroma_h_shift;
905  h >>= s->chroma_v_shift;
906  fake_stride = plane == 1 ? fake_ustride : fake_vstride;
907  }
908 
909  switch (s->predictor) {
910  case LEFT:
911  case PLANE:
912  decode_plane_bitstream(s, w, plane);
913  left = left_prediction(s, p->data[plane], s->temp[0], w, 0);
914 
915  for (y = 1; y < h; y++) {
916  uint8_t *dst = p->data[plane] + p->linesize[plane]*y;
917 
918  decode_plane_bitstream(s, w, plane);
919  left = left_prediction(s, dst, s->temp[0], w, left);
920  if (s->predictor == PLANE) {
921  if (y > s->interlaced) {
922  add_bytes(s, dst, dst - fake_stride, w);
923  }
924  }
925  }
926 
927  break;
928  case MEDIAN:
929  decode_plane_bitstream(s, w, plane);
930  left= left_prediction(s, p->data[plane], s->temp[0], w, 0);
931 
932  y = 1;
933  if (y >= h)
934  break;
935 
936  /* second line is left predicted for interlaced case */
937  if (s->interlaced) {
938  decode_plane_bitstream(s, w, plane);
939  left = left_prediction(s, p->data[plane] + p->linesize[plane], s->temp[0], w, left);
940  y++;
941  if (y >= h)
942  break;
943  }
944 
945  lefttop = p->data[plane][0];
946  decode_plane_bitstream(s, w, plane);
947  add_median_prediction(s, p->data[plane] + fake_stride, p->data[plane], s->temp[0], w, &left, &lefttop);
948  y++;
949 
950  for (; y<h; y++) {
951  uint8_t *dst;
952 
953  decode_plane_bitstream(s, w, plane);
954 
955  dst = p->data[plane] + p->linesize[plane] * y;
956 
957  add_median_prediction(s, dst, dst - fake_stride, s->temp[0], w, &left, &lefttop);
958  }
959 
960  break;
961  }
962  }
963  draw_slice(s, p, height);
964  } else if (s->bitstream_bpp < 24) {
965  int y, cy;
966  int lefty, leftu, leftv;
967  int lefttopy, lefttopu, lefttopv;
968 
969  if (s->yuy2) {
970  p->data[0][3] = get_bits(&s->gb, 8);
971  p->data[0][2] = get_bits(&s->gb, 8);
972  p->data[0][1] = get_bits(&s->gb, 8);
973  p->data[0][0] = get_bits(&s->gb, 8);
974 
975  av_log(avctx, AV_LOG_ERROR,
976  "YUY2 output is not implemented yet\n");
977  return AVERROR_PATCHWELCOME;
978  } else {
979  leftv =
980  p->data[2][0 + y_offset * p->linesize[2]] = get_bits(&s->gb, 8);
981  lefty =
982  p->data[0][1 + y_offset * p->linesize[0]] = get_bits(&s->gb, 8);
983  leftu =
984  p->data[1][0 + y_offset * p->linesize[1]] = get_bits(&s->gb, 8);
985  p->data[0][0 + y_offset * p->linesize[0]] = get_bits(&s->gb, 8);
986 
987  switch (s->predictor) {
988  case LEFT:
989  case PLANE:
990  decode_422_bitstream(s, width - 2);
991  lefty = s->llviddsp.add_left_pred(p->data[0] + p->linesize[0] * y_offset + 2, s->temp[0],
992  width - 2, lefty);
993  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
994  leftu = s->llviddsp.add_left_pred(p->data[1] + p->linesize[1] * y_offset + 1, s->temp[1], width2 - 1, leftu);
995  leftv = s->llviddsp.add_left_pred(p->data[2] + p->linesize[2] * y_offset + 1, s->temp[2], width2 - 1, leftv);
996  }
997 
998  for (cy = y = 1; y < height; y++, cy++) {
999  uint8_t *ydst, *udst, *vdst;
1000 
1001  if (s->bitstream_bpp == 12) {
1002  decode_gray_bitstream(s, width);
1003 
1004  ydst = p->data[0] + p->linesize[0] * (y + y_offset);
1005 
1006  lefty = s->llviddsp.add_left_pred(ydst, s->temp[0],
1007  width, lefty);
1008  if (s->predictor == PLANE) {
1009  if (y > s->interlaced)
1010  s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width);
1011  }
1012  y++;
1013  if (y >= height)
1014  break;
1015  }
1016 
1017  draw_slice(s, p, y);
1018 
1019  ydst = p->data[0] + p->linesize[0] * (y + y_offset);
1020  udst = p->data[1] + p->linesize[1] * (cy + y_offset);
1021  vdst = p->data[2] + p->linesize[2] * (cy + y_offset);
1022 
1023  decode_422_bitstream(s, width);
1024  lefty = s->llviddsp.add_left_pred(ydst, s->temp[0],
1025  width, lefty);
1026  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1027  leftu = s->llviddsp.add_left_pred(udst, s->temp[1], width2, leftu);
1028  leftv = s->llviddsp.add_left_pred(vdst, s->temp[2], width2, leftv);
1029  }
1030  if (s->predictor == PLANE) {
1031  if (cy > s->interlaced) {
1032  s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width);
1033  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1034  s->llviddsp.add_bytes(udst, udst - fake_ustride, width2);
1035  s->llviddsp.add_bytes(vdst, vdst - fake_vstride, width2);
1036  }
1037  }
1038  }
1039  }
1040  draw_slice(s, p, height);
1041 
1042  break;
1043  case MEDIAN:
1044  /* first line except first 2 pixels is left predicted */
1045  decode_422_bitstream(s, width - 2);
1046  lefty = s->llviddsp.add_left_pred(p->data[0] + 2, s->temp[0],
1047  width - 2, lefty);
1048  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1049  leftu = s->llviddsp.add_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
1050  leftv = s->llviddsp.add_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
1051  }
1052 
1053  cy = y = 1;
1054  if (y >= height)
1055  break;
1056 
1057  /* second line is left predicted for interlaced case */
1058  if (s->interlaced) {
1059  decode_422_bitstream(s, width);
1060  lefty = s->llviddsp.add_left_pred(p->data[0] + p->linesize[0],
1061  s->temp[0], width, lefty);
1062  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1063  leftu = s->llviddsp.add_left_pred(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1064  leftv = s->llviddsp.add_left_pred(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1065  }
1066  y++;
1067  cy++;
1068  if (y >= height)
1069  break;
1070  }
1071 
1072  /* next 4 pixels are left predicted too */
1073  decode_422_bitstream(s, 4);
1074  lefty = s->llviddsp.add_left_pred(p->data[0] + fake_ystride,
1075  s->temp[0], 4, lefty);
1076  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1077  leftu = s->llviddsp.add_left_pred(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1078  leftv = s->llviddsp.add_left_pred(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1079  }
1080 
1081  /* next line except the first 4 pixels is median predicted */
1082  lefttopy = p->data[0][3];
1083  decode_422_bitstream(s, width - 4);
1084  s->llviddsp.add_median_pred(p->data[0] + fake_ystride + 4,
1085  p->data[0] + 4, s->temp[0],
1086  width - 4, &lefty, &lefttopy);
1087  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1088  lefttopu = p->data[1][1];
1089  lefttopv = p->data[2][1];
1090  s->llviddsp.add_median_pred(p->data[1] + fake_ustride + 2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
1091  s->llviddsp.add_median_pred(p->data[2] + fake_vstride + 2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
1092  }
1093  y++;
1094  cy++;
1095 
1096  for (; y < height; y++, cy++) {
1097  uint8_t *ydst, *udst, *vdst;
1098 
1099  if (s->bitstream_bpp == 12) {
1100  while (2 * cy > y) {
1101  decode_gray_bitstream(s, width);
1102  ydst = p->data[0] + p->linesize[0] * y;
1103  s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
1104  s->temp[0], width,
1105  &lefty, &lefttopy);
1106  y++;
1107  }
1108  if (y >= height)
1109  break;
1110  }
1111  draw_slice(s, p, y);
1112 
1113  decode_422_bitstream(s, width);
1114 
1115  ydst = p->data[0] + p->linesize[0] * y;
1116  udst = p->data[1] + p->linesize[1] * cy;
1117  vdst = p->data[2] + p->linesize[2] * cy;
1118 
1119  s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
1120  s->temp[0], width,
1121  &lefty, &lefttopy);
1122  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1123  s->llviddsp.add_median_pred(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1124  s->llviddsp.add_median_pred(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1125  }
1126  }
1127 
1128  draw_slice(s, p, height);
1129  break;
1130  }
1131  }
1132  } else {
1133  int y;
1134  uint8_t left[4];
1135  const int last_line = (y_offset + height - 1) * p->linesize[0];
1136 
1137  if (s->bitstream_bpp == 32) {
1138  left[A] = p->data[0][last_line + A] = get_bits(&s->gb, 8);
1139  left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8);
1140  left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8);
1141  left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8);
1142  } else {
1143  left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8);
1144  left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8);
1145  left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8);
1146  left[A] = p->data[0][last_line + A] = 255;
1147  skip_bits(&s->gb, 8);
1148  }
1149 
1150  if (s->bgr32) {
1151  switch (s->predictor) {
1152  case LEFT:
1153  case PLANE:
1154  decode_bgr_bitstream(s, width - 1);
1155  s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + last_line + 4,
1156  s->temp[0], width - 1, left);
1157 
1158  for (y = height - 2; y >= 0; y--) { // Yes it is stored upside down.
1159  decode_bgr_bitstream(s, width);
1160 
1161  s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + p->linesize[0] * (y + y_offset),
1162  s->temp[0], width, left);
1163  if (s->predictor == PLANE) {
1164  if (s->bitstream_bpp != 32)
1165  left[A] = 0;
1166  if (y < height - 1 - s->interlaced) {
1167  s->llviddsp.add_bytes(p->data[0] + p->linesize[0] * (y + y_offset),
1168  p->data[0] + p->linesize[0] * (y + y_offset) +
1169  fake_ystride, 4 * width);
1170  }
1171  }
1172  }
1173  // just 1 large slice as this is not possible in reverse order
1174  draw_slice(s, p, height);
1175  break;
1176  default:
1177  av_log(avctx, AV_LOG_ERROR,
1178  "prediction type not supported!\n");
1179  }
1180  } else {
1181  av_log(avctx, AV_LOG_ERROR,
1182  "BGR24 output is not implemented yet\n");
1183  return AVERROR_PATCHWELCOME;
1184  }
1185  }
1186 
1187  return 0;
1188 }
1189 
1190 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
1191  AVPacket *avpkt)
1192 {
1193  const uint8_t *buf = avpkt->data;
1194  int buf_size = avpkt->size;
1195  HYuvContext *s = avctx->priv_data;
1196  const int width = s->width;
1197  const int height = s->height;
1198  ThreadFrame frame = { .f = data };
1199  AVFrame *const p = data;
1200  int slice, table_size = 0, ret, nb_slices;
1201  unsigned slices_info_offset;
1202  int slice_height;
1203 
1204  if (buf_size < (width * height + 7)/8)
1205  return AVERROR_INVALIDDATA;
1206 
1209  buf_size);
1210  if (!s->bitstream_buffer)
1211  return AVERROR(ENOMEM);
1212 
1213  s->bdsp.bswap_buf((uint32_t *) s->bitstream_buffer,
1214  (const uint32_t *) buf, buf_size / 4);
1215 
1216  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
1217  return ret;
1218 
1219  if (s->context) {
1220  table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
1221  if (table_size < 0)
1222  return table_size;
1223  }
1224 
1225  if ((unsigned) (buf_size - table_size) >= INT_MAX / 8)
1226  return AVERROR_INVALIDDATA;
1227 
1228  s->last_slice_end = 0;
1229 
1230  if (avctx->codec_id == AV_CODEC_ID_HYMT &&
1231  (buf_size > 32 && AV_RL32(avpkt->data + buf_size - 16) == 0)) {
1232  slices_info_offset = AV_RL32(avpkt->data + buf_size - 4);
1233  slice_height = AV_RL32(avpkt->data + buf_size - 8);
1234  nb_slices = AV_RL32(avpkt->data + buf_size - 12);
1235  if (nb_slices * 8LL + slices_info_offset > buf_size - 16 ||
1236  s->chroma_v_shift ||
1237  slice_height <= 0 || nb_slices * (uint64_t)slice_height > height)
1238  return AVERROR_INVALIDDATA;
1239  } else {
1240  slice_height = height;
1241  nb_slices = 1;
1242  }
1243 
1244  for (slice = 0; slice < nb_slices; slice++) {
1245  int y_offset, slice_offset, slice_size;
1246 
1247  if (nb_slices > 1) {
1248  slice_offset = AV_RL32(avpkt->data + slices_info_offset + slice * 8);
1249  slice_size = AV_RL32(avpkt->data + slices_info_offset + slice * 8 + 4);
1250 
1251  if (slice_offset < 0 || slice_size <= 0 || (slice_offset&3) ||
1252  slice_offset + (int64_t)slice_size > buf_size)
1253  return AVERROR_INVALIDDATA;
1254 
1255  y_offset = height - (slice + 1) * slice_height;
1256  s->bdsp.bswap_buf((uint32_t *)s->bitstream_buffer,
1257  (const uint32_t *)(buf + slice_offset), slice_size / 4);
1258  } else {
1259  y_offset = 0;
1260  slice_offset = 0;
1261  slice_size = buf_size;
1262  }
1263 
1264  ret = decode_slice(avctx, p, slice_height, slice_size, y_offset, table_size);
1265  emms_c();
1266  if (ret < 0)
1267  return ret;
1268  }
1269 
1270  *got_frame = 1;
1271 
1272  return (get_bits_count(&s->gb) + 31) / 32 * 4 + table_size;
1273 }
1274 
1276  .name = "huffyuv",
1277  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1278  .type = AVMEDIA_TYPE_VIDEO,
1279  .id = AV_CODEC_ID_HUFFYUV,
1280  .priv_data_size = sizeof(HYuvContext),
1281  .init = decode_init,
1282  .close = decode_end,
1283  .decode = decode_frame,
1286 };
1287 
1288 #if CONFIG_FFVHUFF_DECODER
1290  .name = "ffvhuff",
1291  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1292  .type = AVMEDIA_TYPE_VIDEO,
1293  .id = AV_CODEC_ID_FFVHUFF,
1294  .priv_data_size = sizeof(HYuvContext),
1295  .init = decode_init,
1296  .close = decode_end,
1297  .decode = decode_frame,
1300 };
1301 #endif /* CONFIG_FFVHUFF_DECODER */
1302 
1303 #if CONFIG_HYMT_DECODER
1305  .name = "hymt",
1306  .long_name = NULL_IF_CONFIG_SMALL("HuffYUV MT"),
1307  .type = AVMEDIA_TYPE_VIDEO,
1308  .id = AV_CODEC_ID_HYMT,
1309  .priv_data_size = sizeof(HYuvContext),
1310  .init = decode_init,
1311  .close = decode_end,
1312  .decode = decode_frame,
1315 };
1316 #endif /* CONFIG_HYMT_DECODER */
static void add_median_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, const uint8_t *diff, int w, int *left, int *left_top)
Definition: huffyuvdec.c:870
#define OP14bits(dst0, dst1, code)
Definition: huffyuvdec.c:660
#define NULL
Definition: coverity.c:32
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:440
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int(* add_left_pred)(uint8_t *dst, const uint8_t *src, ptrdiff_t w, int left)
#define AV_NUM_DATA_POINTERS
Definition: frame.h:301
static void decode_plane_bitstream(HYuvContext *s, int width, int plane)
Definition: huffyuvdec.c:670
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:432
#define READ_2PIX_PLANE(dst0, dst1, plane, OP)
Definition: huffyuvdec.c:655
This structure describes decoded (raw) audio or video data.
Definition: frame.h:300
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:434
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:407
float re
Definition: fft.c:82
int yuy2
Definition: huffyuv.h:65
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:435
int bitstream_bpp
Definition: huffyuv.h:63
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
misc image utilities
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
const char * g
Definition: vf_curves.c:115
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int acc
Definition: yuv2rgb.c:555
static void decode_422_bitstream(HYuvContext *s, int count)
Definition: huffyuvdec.c:626
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:273
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
int size
Definition: packet.h:356
const char * b
Definition: vf_curves.c:116
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:413
static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha)
Definition: huffyuvdec.c:751
#define VLC_BITS
Definition: asvdec.c:37
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
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
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:401
#define MAX_VLC_N
Definition: huffyuv.h:47
int context
Definition: huffyuv.h:77
#define READ_2PIX_PLANE16(dst0, dst1, plane)
Definition: huffyuvdec.c:664
unsigned int bitstream_buffer_size
Definition: huffyuv.h:88
static void error(const char *err)
#define init_vlc(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:38
static int generate_joint_tables(HYuvContext *s)
Definition: huffyuvdec.c:118
AVCodec.
Definition: codec.h:190
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
int height
Definition: huffyuv.h:75
void(* draw_horiz_band)(struct AVCodecContext *s, const AVFrame *src, int offset[AV_NUM_DATA_POINTERS], int y, int type, int height)
If non NULL, &#39;draw_horiz_band&#39; is called by the libavcodec decoder to draw a horizontal band...
Definition: avcodec.h:761
#define READ_2PIX(dst0, dst1, plane1)
Definition: huffyuvdec.c:621
static int read_old_huffman_tables(HYuvContext *s)
Definition: huffyuvdec.c:237
static void draw_slice(HYuvContext *s, AVFrame *frame, int y)
Definition: huffyuvdec.c:824
void(* add_int16)(uint16_t *dst, const uint16_t *src, unsigned mask, int w)
Definition: huffyuvdsp.h:39
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint32_t pix_bgr_map[1<< VLC_BITS]
Definition: huffyuv.h:85
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
uint8_t
#define av_cold
Definition: attributes.h:88
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
static void decode_bgr_bitstream(HYuvContext *s, int count)
Definition: huffyuvdec.c:809
int bps
Definition: huffyuv.h:67
Multithreading support functions.
#define emms_c()
Definition: internal.h:55
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:627
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:431
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:412
static AVFrame * frame
const char data[16]
Definition: mxf.c:91
#define height
uint8_t * data
Definition: packet.h:355
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
void(* add_median_pred)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, ptrdiff_t w, int *left, int *left_top)
bitstream reader API header.
int vlc_n
Definition: huffyuv.h:69
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:410
int chroma_h_shift
Definition: huffyuv.h:73
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1754
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:402
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:439
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
#define A(x)
Definition: vp56_arith.h:28
uint16_t * temp16[3]
identical to temp but 16bit type
Definition: huffyuv.h:81
#define av_log(a,...)
uint8_t len[4][MAX_VLC_N]
Definition: huffyuv.h:83
#define src
Definition: vp8dsp.c:254
av_cold int ff_huffyuv_alloc_temp(HYuvContext *s)
Definition: huffyuv.c:58
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:178
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define R
Definition: huffyuvdsp.h:34
int chroma_v_shift
Definition: huffyuv.h:74
Definition: huffyuv.h:51
av_cold void ff_huffyuv_common_end(HYuvContext *s)
Definition: huffyuv.c:86
static const unsigned char classic_add_luma[256]
Definition: huffyuvdec.c:61
AVCodec ff_hymt_decoder
uint8_t * bitstream_buffer
Definition: huffyuv.h:87
#define AVERROR(e)
Definition: error.h:43
int flags
Definition: huffyuv.h:76
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2577
#define B
Definition: huffyuvdsp.h:32
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:188
const uint8_t * code
Definition: spdifenc.c:413
const char * r
Definition: vf_curves.c:114
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:441
int bgr32
Definition: huffyuv.h:66
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:237
const char * name
Name of the codec implementation.
Definition: codec.h:197
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:400
uint8_t bits
Definition: vp3data.h:202
int chroma
Definition: huffyuv.h:71
VLC vlc[8]
Definition: huffyuv.h:86
static const uint8_t offset[127][2]
Definition: vf_spp.c:93
#define CLOSE_READER(name, gb)
Definition: get_bits.h:149
huffyuv codec for libavcodec.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
#define classic_shift_chroma_table_size
Definition: huffyuvdec.c:52
Definition: vlc.h:26
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:395
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:282
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
int decorrelate
Definition: huffyuv.h:62
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:416
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:381
#define FFMIN(a, b)
Definition: common.h:96
int width
Definition: huffyuv.h:75
int last_slice_end
Definition: huffyuv.h:79
uint8_t interlaced
Definition: mxfenc.c:2139
#define VLC_INTERN(dst, table, gb, name, bits, max_depth)
Subset of GET_VLC for use in hand-roller VLC code.
Definition: huffyuvdec.c:574
#define width
int width
picture width / height.
Definition: avcodec.h:699
static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size+AV_INPUT_BUFFER_PADDING_SIZE]
Definition: huffyuvdec.c:53
uint8_t w
Definition: llviddspenc.c:38
int ff_huffyuv_generate_bits_table(uint32_t *dst, const uint8_t *len_table, int n)
Definition: huffyuv.c:39
#define s(width, name)
Definition: cbs_vp9.c:257
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:199
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
#define AV_RL32
Definition: intreadwrite.h:146
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:436
uint8_t * temp[3]
Definition: huffyuv.h:80
AVCodec ff_ffvhuff_decoder
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:396
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:415
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:211
int alpha
Definition: huffyuv.h:70
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:408
static void add_bytes(HYuvContext *s, uint8_t *dst, uint8_t *src, int w)
Definition: huffyuvdec.c:861
int(* add_left_pred_int16)(uint16_t *dst, const uint16_t *src, unsigned mask, ptrdiff_t w, unsigned left)
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:405
AVCodec ff_huffyuv_decoder
Definition: huffyuvdec.c:1275
Libavcodec external API header.
enum AVCodecID codec_id
Definition: avcodec.h:536
int yuv
Definition: huffyuv.h:72
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
LLVidDSPContext llviddsp
Definition: huffyuv.h:92
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
HuffYUVDSPContext hdsp
Definition: huffyuv.h:90
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:526
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:370
long long int64_t
Definition: coverity.c:34
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
#define OPEN_READER(name, gb)
Definition: get_bits.h:138
int interlaced
Definition: huffyuv.h:61
int extradata_size
Definition: avcodec.h:628
void ff_llviddsp_init(LLVidDSPContext *c)
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:397
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:467
int index
Definition: gxfenc.c:89
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:659
av_cold void ff_huffyuvdsp_init(HuffYUVDSPContext *c, enum AVPixelFormat pix_fmt)
Definition: huffyuvdsp.c:83
static void decode_gray_bitstream(HYuvContext *s, int count)
Definition: huffyuvdec.c:731
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:394
#define classic_shift_luma_table_size
Definition: huffyuvdec.c:44
const VDPAUPixFmtMap * map
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:130
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:406
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:414
int version
Definition: huffyuv.h:64
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:398
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:404
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
Predictor predictor
Definition: huffyuv.h:58
static av_cold int decode_init(AVCodecContext *avctx)
Definition: huffyuvdec.c:291
void(* add_hfyu_left_pred_bgr32)(uint8_t *dst, const uint8_t *src, intptr_t w, uint8_t *left)
Definition: huffyuvdsp.h:45
AVCodecContext * avctx
Definition: huffyuv.h:57
GetBitContext gb
Definition: huffyuv.h:59
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
Definition: huffyuv.h:52
if(ret< 0)
Definition: vf_mcdeint.c:279
#define G
Definition: huffyuvdsp.h:33
#define BITS_LEFT(name, gb)
Definition: get_bits.h:191
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
void(* add_hfyu_median_pred_int16)(uint16_t *dst, const uint16_t *top, const uint16_t *diff, unsigned mask, int w, int *left, int *left_top)
Definition: huffyuvdsp.h:42
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:433
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: huffyuvdec.c:1190
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
av_cold void ff_huffyuv_common_init(AVCodecContext *avctx)
Definition: huffyuv.c:71
static av_cold int decode_end(AVCodecContext *avctx)
Definition: huffyuvdec.c:277
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:215
void * priv_data
Definition: avcodec.h:553
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int len
static const unsigned char classic_add_chroma[256]
Definition: huffyuvdec.c:80
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
static int left_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int acc)
Definition: huffyuvdec.c:852
static const unsigned char classic_shift_luma[classic_shift_luma_table_size+AV_INPUT_BUFFER_PADDING_SIZE]
Definition: huffyuvdec.c:45
FILE * out
Definition: movenc.c:54
#define av_freep(p)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
static int decode_slice(AVCodecContext *avctx, AVFrame *p, int height, int buf_size, int y_offset, int table_size)
Definition: huffyuvdec.c:879
#define av_always_inline
Definition: attributes.h:45
uint32_t bits[4][MAX_VLC_N]
Definition: huffyuv.h:84
#define LEFT
Definition: cdgraphics.c:166
void(* add_bytes)(uint8_t *dst, uint8_t *src, ptrdiff_t w)
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:332
static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
Definition: snowenc.c:1336
BswapDSPContext bdsp
Definition: huffyuv.h:89
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
static int read_len_table(uint8_t *dst, GetBitContext *gb, int n)
Definition: huffyuvdec.c:99
#define OP8bits(dst0, dst1, code)
Definition: huffyuvdec.c:619
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:409
static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length)
Definition: huffyuvdec.c:208
for(j=16;j >0;--j)
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:374