FFmpeg  2.6.9
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 "thread.h"
40 #include "libavutil/imgutils.h"
41 #include "libavutil/pixdesc.h"
42 
43 #define classic_shift_luma_table_size 42
45  34, 36, 35, 69, 135, 232, 9, 16, 10, 24, 11, 23, 12, 16, 13, 10,
46  14, 8, 15, 8, 16, 8, 17, 20, 16, 10, 207, 206, 205, 236, 11, 8,
47  10, 21, 9, 23, 8, 8, 199, 70, 69, 68, 0,
48  0,0,0,0,0,0,0,0,
49 };
50 
51 #define classic_shift_chroma_table_size 59
53  66, 36, 37, 38, 39, 40, 41, 75, 76, 77, 110, 239, 144, 81, 82, 83,
54  84, 85, 118, 183, 56, 57, 88, 89, 56, 89, 154, 57, 58, 57, 26, 141,
55  57, 56, 58, 57, 58, 57, 184, 119, 214, 245, 116, 83, 82, 49, 80, 79,
56  78, 77, 44, 75, 41, 40, 39, 38, 37, 36, 34, 0,
57  0,0,0,0,0,0,0,0,
58 };
59 
60 static const unsigned char classic_add_luma[256] = {
61  3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
62  73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
63  68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
64  35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
65  37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
66  35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
67  27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
68  15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
69  12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
70  12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
71  18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
72  28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
73  28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
74  62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
75  54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
76  46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
77 };
78 
79 static const unsigned char classic_add_chroma[256] = {
80  3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
81  7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
82  11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
83  43, 45, 76, 81, 46, 82, 75, 55, 56, 144, 58, 80, 60, 74, 147, 63,
84  143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
85  80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
86  17, 14, 5, 6, 100, 54, 47, 50, 51, 53, 106, 107, 108, 109, 110, 111,
87  112, 113, 114, 115, 4, 117, 118, 92, 94, 121, 122, 3, 124, 103, 2, 1,
88  0, 129, 130, 131, 120, 119, 126, 125, 136, 137, 138, 139, 140, 141, 142, 134,
89  135, 132, 133, 104, 64, 101, 62, 57, 102, 95, 93, 59, 61, 28, 97, 96,
90  52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
91  19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
92  7, 128, 127, 105, 123, 116, 35, 34, 33, 145, 31, 79, 42, 146, 78, 26,
93  83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
94  14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
95  6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
96 };
97 
98 static int read_len_table(uint8_t *dst, GetBitContext *gb, int n)
99 {
100  int i, val, repeat;
101 
102  for (i = 0; i < n;) {
103  repeat = get_bits(gb, 3);
104  val = get_bits(gb, 5);
105  if (repeat == 0)
106  repeat = get_bits(gb, 8);
107  if (i + repeat > n || get_bits_left(gb) < 0) {
108  av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
109  return AVERROR_INVALIDDATA;
110  }
111  while (repeat--)
112  dst[i++] = val;
113  }
114  return 0;
115 }
116 
118 {
119  int ret;
120  uint16_t *symbols = av_mallocz(5 << VLC_BITS);
121  uint16_t *bits;
122  uint8_t *len;
123  if (!symbols)
124  return AVERROR(ENOMEM);
125  bits = symbols + (1 << VLC_BITS);
126  len = (uint8_t *)(bits + (1 << VLC_BITS));
127 
128  if (s->bitstream_bpp < 24 || s->version > 2) {
129  int p, i, y, u;
130  for (p = 0; p < 4; p++) {
131  int p0 = s->version > 2 ? p : 0;
132  for (i = y = 0; y < s->vlc_n; y++) {
133  int len0 = s->len[p0][y];
134  int limit = VLC_BITS - len0;
135  if (limit <= 0 || !len0)
136  continue;
137  if ((sign_extend(y, 8) & (s->vlc_n-1)) != y)
138  continue;
139  for (u = 0; u < s->vlc_n; u++) {
140  int len1 = s->len[p][u];
141  if (len1 > limit || !len1)
142  continue;
143  if ((sign_extend(u, 8) & (s->vlc_n-1)) != u)
144  continue;
145  av_assert0(i < (1 << VLC_BITS));
146  len[i] = len0 + len1;
147  bits[i] = (s->bits[p0][y] << len1) + s->bits[p][u];
148  symbols[i] = (y << 8) + (u & 0xFF);
149  i++;
150  }
151  }
152  ff_free_vlc(&s->vlc[4 + p]);
153  if ((ret = ff_init_vlc_sparse(&s->vlc[4 + p], VLC_BITS, i, len, 1, 1,
154  bits, 2, 2, symbols, 2, 2, 0)) < 0)
155  goto out;
156  }
157  } else {
158  uint8_t (*map)[4] = (uint8_t(*)[4]) s->pix_bgr_map;
159  int i, b, g, r, code;
160  int p0 = s->decorrelate;
161  int p1 = !s->decorrelate;
162  /* Restrict the range to +/-16 because that's pretty much guaranteed
163  * to cover all the combinations that fit in 11 bits total, and it
164  * does not matter if we miss a few rare codes. */
165  for (i = 0, g = -16; g < 16; g++) {
166  int len0 = s->len[p0][g & 255];
167  int limit0 = VLC_BITS - len0;
168  if (limit0 < 2 || !len0)
169  continue;
170  for (b = -16; b < 16; b++) {
171  int len1 = s->len[p1][b & 255];
172  int limit1 = limit0 - len1;
173  if (limit1 < 1 || !len1)
174  continue;
175  code = (s->bits[p0][g & 255] << len1) + s->bits[p1][b & 255];
176  for (r = -16; r < 16; r++) {
177  int len2 = s->len[2][r & 255];
178  if (len2 > limit1 || !len2)
179  continue;
180  av_assert0(i < (1 << VLC_BITS));
181  len[i] = len0 + len1 + len2;
182  bits[i] = (code << len2) + s->bits[2][r & 255];
183  if (s->decorrelate) {
184  map[i][G] = g;
185  map[i][B] = g + b;
186  map[i][R] = g + r;
187  } else {
188  map[i][B] = g;
189  map[i][G] = b;
190  map[i][R] = r;
191  }
192  i++;
193  }
194  }
195  }
196  ff_free_vlc(&s->vlc[4]);
197  if ((ret = init_vlc(&s->vlc[4], VLC_BITS, i, len, 1, 1,
198  bits, 2, 2, 0)) < 0)
199  goto out;
200  }
201  ret = 0;
202 out:
203  av_freep(&symbols);
204  return ret;
205 }
206 
208 {
209  GetBitContext gb;
210  int i, ret;
211  int count = 3;
212 
213  if ((ret = init_get_bits(&gb, src, length * 8)) < 0)
214  return ret;
215 
216  if (s->version > 2)
217  count = 1 + s->alpha + 2*s->chroma;
218 
219  for (i = 0; i < count; i++) {
220  if ((ret = read_len_table(s->len[i], &gb, s->vlc_n)) < 0)
221  return ret;
222  if ((ret = ff_huffyuv_generate_bits_table(s->bits[i], s->len[i], s->vlc_n)) < 0)
223  return ret;
224  ff_free_vlc(&s->vlc[i]);
225  if ((ret = init_vlc(&s->vlc[i], VLC_BITS, s->vlc_n, s->len[i], 1, 1,
226  s->bits[i], 4, 4, 0)) < 0)
227  return ret;
228  }
229 
230  if ((ret = generate_joint_tables(s)) < 0)
231  return ret;
232 
233  return (get_bits_count(&gb) + 7) / 8;
234 }
235 
237 {
238  GetBitContext gb;
239  int i, ret;
240 
243  if ((ret = read_len_table(s->len[0], &gb, 256)) < 0)
244  return ret;
245 
248  if ((ret = read_len_table(s->len[1], &gb, 256)) < 0)
249  return ret;
250 
251  for (i = 0; i < 256; i++)
252  s->bits[0][i] = classic_add_luma[i];
253  for (i = 0; i < 256; i++)
254  s->bits[1][i] = classic_add_chroma[i];
255 
256  if (s->bitstream_bpp >= 24) {
257  memcpy(s->bits[1], s->bits[0], 256 * sizeof(uint32_t));
258  memcpy(s->len[1], s->len[0], 256 * sizeof(uint8_t));
259  }
260  memcpy(s->bits[2], s->bits[1], 256 * sizeof(uint32_t));
261  memcpy(s->len[2], s->len[1], 256 * sizeof(uint8_t));
262 
263  for (i = 0; i < 4; i++) {
264  ff_free_vlc(&s->vlc[i]);
265  if ((ret = init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
266  s->bits[i], 4, 4, 0)) < 0)
267  return ret;
268  }
269 
270  if ((ret = generate_joint_tables(s)) < 0)
271  return ret;
272 
273  return 0;
274 }
275 
277 {
278  HYuvContext *s = avctx->priv_data;
279  int i;
280 
283 
284  for (i = 0; i < 8; i++)
285  ff_free_vlc(&s->vlc[i]);
286 
287  return 0;
288 }
289 
291 {
292  HYuvContext *s = avctx->priv_data;
293  int ret;
294 
295  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
296  if (ret < 0)
297  return ret;
298 
300  memset(s->vlc, 0, 4 * sizeof(VLC));
301 
302  s->interlaced = avctx->height > 288;
303  s->bgr32 = 1;
304 
305  if (avctx->extradata_size) {
306  if ((avctx->bits_per_coded_sample & 7) &&
307  avctx->bits_per_coded_sample != 12)
308  s->version = 1; // do such files exist at all?
309  else if (avctx->extradata_size > 3 && avctx->extradata[3] == 0)
310  s->version = 2;
311  else
312  s->version = 3;
313  } else
314  s->version = 0;
315 
316  s->bps = 8;
317  s->n = 1<<s->bps;
318  s->vlc_n = FFMIN(s->n, MAX_VLC_N);
319  s->chroma = 1;
320  if (s->version >= 2) {
321  int method, interlace;
322 
323  if (avctx->extradata_size < 4)
324  return AVERROR_INVALIDDATA;
325 
326  method = avctx->extradata[0];
327  s->decorrelate = method & 64 ? 1 : 0;
328  s->predictor = method & 63;
329  if (s->version == 2) {
330  s->bitstream_bpp = avctx->extradata[1];
331  if (s->bitstream_bpp == 0)
332  s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
333  } else {
334  s->bps = (avctx->extradata[1] >> 4) + 1;
335  s->n = 1<<s->bps;
336  s->vlc_n = FFMIN(s->n, MAX_VLC_N);
337  s->chroma_h_shift = avctx->extradata[1] & 3;
338  s->chroma_v_shift = (avctx->extradata[1] >> 2) & 3;
339  s->yuv = !!(avctx->extradata[2] & 1);
340  s->chroma= !!(avctx->extradata[2] & 3);
341  s->alpha = !!(avctx->extradata[2] & 4);
342  }
343  interlace = (avctx->extradata[2] & 0x30) >> 4;
344  s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 : s->interlaced;
345  s->context = avctx->extradata[2] & 0x40 ? 1 : 0;
346 
347  if ((ret = read_huffman_tables(s, avctx->extradata + 4,
348  avctx->extradata_size - 4)) < 0)
349  goto error;
350  } else {
351  switch (avctx->bits_per_coded_sample & 7) {
352  case 1:
353  s->predictor = LEFT;
354  s->decorrelate = 0;
355  break;
356  case 2:
357  s->predictor = LEFT;
358  s->decorrelate = 1;
359  break;
360  case 3:
361  s->predictor = PLANE;
362  s->decorrelate = avctx->bits_per_coded_sample >= 24;
363  break;
364  case 4:
365  s->predictor = MEDIAN;
366  s->decorrelate = 0;
367  break;
368  default:
369  s->predictor = LEFT; // OLD
370  s->decorrelate = 0;
371  break;
372  }
373  s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
374  s->context = 0;
375 
376  if ((ret = read_old_huffman_tables(s)) < 0)
377  goto error;
378  }
379 
380  if (s->version <= 2) {
381  switch (s->bitstream_bpp) {
382  case 12:
383  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
384  s->yuv = 1;
385  break;
386  case 16:
387  if (s->yuy2)
388  avctx->pix_fmt = AV_PIX_FMT_YUYV422;
389  else
390  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
391  s->yuv = 1;
392  break;
393  case 24:
394  if (s->bgr32)
395  avctx->pix_fmt = AV_PIX_FMT_0RGB32;
396  else
397  avctx->pix_fmt = AV_PIX_FMT_BGR24;
398  break;
399  case 32:
400  av_assert0(s->bgr32);
401  avctx->pix_fmt = AV_PIX_FMT_RGB32;
402  s->alpha = 1;
403  break;
404  default:
405  ret = AVERROR_INVALIDDATA;
406  goto error;
407  }
409  &s->chroma_h_shift,
410  &s->chroma_v_shift);
411  } else {
412  switch ( (s->chroma<<10) | (s->yuv<<9) | (s->alpha<<8) | ((s->bps-1)<<4) | s->chroma_h_shift | (s->chroma_v_shift<<2)) {
413  case 0x070:
414  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
415  break;
416  case 0x0F0:
417  avctx->pix_fmt = AV_PIX_FMT_GRAY16;
418  break;
419  case 0x170:
420  avctx->pix_fmt = AV_PIX_FMT_GRAY8A;
421  break;
422  case 0x470:
423  avctx->pix_fmt = AV_PIX_FMT_GBRP;
424  break;
425  case 0x480:
426  avctx->pix_fmt = AV_PIX_FMT_GBRP9;
427  break;
428  case 0x490:
429  avctx->pix_fmt = AV_PIX_FMT_GBRP10;
430  break;
431  case 0x4B0:
432  avctx->pix_fmt = AV_PIX_FMT_GBRP12;
433  break;
434  case 0x4D0:
435  avctx->pix_fmt = AV_PIX_FMT_GBRP14;
436  break;
437  case 0x4F0:
438  avctx->pix_fmt = AV_PIX_FMT_GBRP16;
439  break;
440  case 0x570:
441  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
442  break;
443  case 0x670:
444  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
445  break;
446  case 0x680:
447  avctx->pix_fmt = AV_PIX_FMT_YUV444P9;
448  break;
449  case 0x690:
450  avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
451  break;
452  case 0x6B0:
453  avctx->pix_fmt = AV_PIX_FMT_YUV444P12;
454  break;
455  case 0x6D0:
456  avctx->pix_fmt = AV_PIX_FMT_YUV444P14;
457  break;
458  case 0x6F0:
459  avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
460  break;
461  case 0x671:
462  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
463  break;
464  case 0x681:
465  avctx->pix_fmt = AV_PIX_FMT_YUV422P9;
466  break;
467  case 0x691:
468  avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
469  break;
470  case 0x6B1:
471  avctx->pix_fmt = AV_PIX_FMT_YUV422P12;
472  break;
473  case 0x6D1:
474  avctx->pix_fmt = AV_PIX_FMT_YUV422P14;
475  break;
476  case 0x6F1:
477  avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
478  break;
479  case 0x672:
480  avctx->pix_fmt = AV_PIX_FMT_YUV411P;
481  break;
482  case 0x674:
483  avctx->pix_fmt = AV_PIX_FMT_YUV440P;
484  break;
485  case 0x675:
486  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
487  break;
488  case 0x685:
489  avctx->pix_fmt = AV_PIX_FMT_YUV420P9;
490  break;
491  case 0x695:
492  avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
493  break;
494  case 0x6B5:
495  avctx->pix_fmt = AV_PIX_FMT_YUV420P12;
496  break;
497  case 0x6D5:
498  avctx->pix_fmt = AV_PIX_FMT_YUV420P14;
499  break;
500  case 0x6F5:
501  avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
502  break;
503  case 0x67A:
504  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
505  break;
506  case 0x770:
507  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
508  break;
509  case 0x780:
510  avctx->pix_fmt = AV_PIX_FMT_YUVA444P9;
511  break;
512  case 0x790:
514  break;
515  case 0x7F0:
517  break;
518  case 0x771:
519  avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
520  break;
521  case 0x781:
522  avctx->pix_fmt = AV_PIX_FMT_YUVA422P9;
523  break;
524  case 0x791:
526  break;
527  case 0x7F1:
529  break;
530  case 0x775:
531  avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
532  break;
533  case 0x785:
534  avctx->pix_fmt = AV_PIX_FMT_YUVA420P9;
535  break;
536  case 0x795:
538  break;
539  case 0x7F5:
541  break;
542  default:
543  ret = AVERROR_INVALIDDATA;
544  goto error;
545  }
546  }
547 
548  ff_huffyuv_common_init(avctx);
549 
550  if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV420P) && avctx->width & 1) {
551  av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");
552  ret = AVERROR_INVALIDDATA;
553  goto error;
554  }
555  if (s->predictor == MEDIAN && avctx->pix_fmt == AV_PIX_FMT_YUV422P &&
556  avctx->width % 4) {
557  av_log(avctx, AV_LOG_ERROR, "width must be a multiple of 4 "
558  "for this combination of colorspace and predictor type.\n");
559  ret = AVERROR_INVALIDDATA;
560  goto error;
561  }
562 
563  if ((ret = ff_huffyuv_alloc_temp(s)) < 0) {
565  goto error;
566  }
567 
568  return 0;
569  error:
570  decode_end(avctx);
571  return ret;
572 }
573 
575 {
576  HYuvContext *s = avctx->priv_data;
577  int i, ret;
578 
579  if ((ret = ff_huffyuv_alloc_temp(s)) < 0) {
581  return ret;
582  }
583 
584  for (i = 0; i < 8; i++)
585  s->vlc[i].table = NULL;
586 
587  if (s->version >= 2) {
588  if ((ret = read_huffman_tables(s, avctx->extradata + 4,
589  avctx->extradata_size)) < 0)
590  return ret;
591  } else {
592  if ((ret = read_old_huffman_tables(s)) < 0)
593  return ret;
594  }
595 
596  return 0;
597 }
598 
599 /** Subset of GET_VLC for use in hand-roller VLC code */
600 #define VLC_INTERN(dst, table, gb, name, bits, max_depth) \
601  code = table[index][0]; \
602  n = table[index][1]; \
603  if (max_depth > 1 && n < 0) { \
604  LAST_SKIP_BITS(name, gb, bits); \
605  UPDATE_CACHE(name, gb); \
606  \
607  nb_bits = -n; \
608  index = SHOW_UBITS(name, gb, nb_bits) + code; \
609  code = table[index][0]; \
610  n = table[index][1]; \
611  if (max_depth > 2 && n < 0) { \
612  LAST_SKIP_BITS(name, gb, nb_bits); \
613  UPDATE_CACHE(name, gb); \
614  \
615  nb_bits = -n; \
616  index = SHOW_UBITS(name, gb, nb_bits) + code; \
617  code = table[index][0]; \
618  n = table[index][1]; \
619  } \
620  } \
621  dst = code; \
622  LAST_SKIP_BITS(name, gb, n)
623 
624 
625 #define GET_VLC_DUAL(dst0, dst1, name, gb, dtable, table1, table2, \
626  bits, max_depth, OP) \
627  do { \
628  unsigned int index = SHOW_UBITS(name, gb, bits); \
629  int code, n = dtable[index][1]; \
630  \
631  if (n<=0) { \
632  int nb_bits; \
633  VLC_INTERN(dst0, table1, gb, name, bits, max_depth); \
634  \
635  UPDATE_CACHE(re, gb); \
636  index = SHOW_UBITS(name, gb, bits); \
637  VLC_INTERN(dst1, table2, gb, name, bits, max_depth); \
638  } else { \
639  code = dtable[index][0]; \
640  OP(dst0, dst1, code); \
641  LAST_SKIP_BITS(name, gb, n); \
642  } \
643  } while (0)
644 
645 #define OP8bits(dst0, dst1, code) dst0 = code>>8; dst1 = code
646 
647 #define READ_2PIX(dst0, dst1, plane1) \
648  UPDATE_CACHE(re, &s->gb); \
649  GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane1].table, \
650  s->vlc[0].table, s->vlc[plane1].table, VLC_BITS, 3, OP8bits)
651 
653 {
654  int i, icount;
655  OPEN_READER(re, &s->gb);
656  count /= 2;
657 
658  icount = get_bits_left(&s->gb) / (32 * 4);
659  if (count >= icount) {
660  for (i = 0; i < icount; i++) {
661  READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1);
662  READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
663  }
664  for (; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
665  READ_2PIX(s->temp[0][2 * i ], s->temp[1][i], 1);
666  if (BITS_LEFT(re, &s->gb) <= 0) break;
667  READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
668  }
669  for (; i < count; i++)
670  s->temp[0][2 * i ] = s->temp[1][i] =
671  s->temp[0][2 * i + 1] = s->temp[2][i] = 0;
672  } else {
673  for (i = 0; i < count; i++) {
674  READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1);
675  READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
676  }
677  }
678  CLOSE_READER(re, &s->gb);
679 }
680 
681 #define READ_2PIX_PLANE(dst0, dst1, plane, OP) \
682  UPDATE_CACHE(re, &s->gb); \
683  GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane].table, \
684  s->vlc[plane].table, s->vlc[plane].table, VLC_BITS, 3, OP)
685 
686 #define OP14bits(dst0, dst1, code) dst0 = code>>8; dst1 = sign_extend(code, 8)
687 
688 /* TODO instead of restarting the read when the code isn't in the first level
689  * of the joint table, jump into the 2nd level of the individual table. */
690 #define READ_2PIX_PLANE16(dst0, dst1, plane){\
691  dst0 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)<<2;\
692  dst0 += get_bits(&s->gb, 2);\
693  dst1 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)<<2;\
694  dst1 += get_bits(&s->gb, 2);\
695 }
696 static void decode_plane_bitstream(HYuvContext *s, int width, int plane)
697 {
698  int i, count = width/2;
699 
700  if (s->bps <= 8) {
701  OPEN_READER(re, &s->gb);
702  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
703  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
704  READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits);
705  }
706  } else {
707  for(i=0; i<count; i++){
708  READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits);
709  }
710  }
711  if( width&1 && BITS_LEFT(re, &s->gb)>0 ) {
712  unsigned int index;
713  int nb_bits, code, n;
714  UPDATE_CACHE(re, &s->gb);
715  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
716  VLC_INTERN(s->temp[0][width-1], s->vlc[plane].table,
717  &s->gb, re, VLC_BITS, 3);
718  }
719  CLOSE_READER(re, &s->gb);
720  } else if (s->bps <= 14) {
721  OPEN_READER(re, &s->gb);
722  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
723  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
724  READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits);
725  }
726  } else {
727  for(i=0; i<count; i++){
728  READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits);
729  }
730  }
731  if( width&1 && BITS_LEFT(re, &s->gb)>0 ) {
732  unsigned int index;
733  int nb_bits, code, n;
734  UPDATE_CACHE(re, &s->gb);
735  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
736  VLC_INTERN(s->temp16[0][width-1], s->vlc[plane].table,
737  &s->gb, re, VLC_BITS, 3);
738  }
739  CLOSE_READER(re, &s->gb);
740  } else {
741  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
742  for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
743  READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane);
744  }
745  } else {
746  for(i=0; i<count; i++){
747  READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane);
748  }
749  }
750  if( width&1 && get_bits_left(&s->gb)>0 ) {
751  int dst = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)<<2;
752  s->temp16[0][width-1] = dst + get_bits(&s->gb, 2);
753  }
754  }
755 }
756 
758 {
759  int i;
760  OPEN_READER(re, &s->gb);
761  count /= 2;
762 
763  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
764  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
765  READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
766  }
767  } else {
768  for (i = 0; i < count; i++) {
769  READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
770  }
771  }
772  CLOSE_READER(re, &s->gb);
773 }
774 
776  int decorrelate, int alpha)
777 {
778  int i;
779  OPEN_READER(re, &s->gb);
780 
781  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
782  unsigned int index;
783  int code, n, nb_bits;
784 
785  UPDATE_CACHE(re, &s->gb);
786  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
787  n = s->vlc[4].table[index][1];
788 
789  if (n>0) {
790  code = s->vlc[4].table[index][0];
791  *(uint32_t *) &s->temp[0][4 * i] = s->pix_bgr_map[code];
792  LAST_SKIP_BITS(re, &s->gb, n);
793  } else {
794  if (decorrelate) {
795  VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table,
796  &s->gb, re, VLC_BITS, 3);
797 
798  UPDATE_CACHE(re, &s->gb);
799  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
800  VLC_INTERN(code, s->vlc[0].table, &s->gb, re, VLC_BITS, 3);
801  s->temp[0][4 * i + B] = code + s->temp[0][4 * i + G];
802 
803  UPDATE_CACHE(re, &s->gb);
804  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
805  VLC_INTERN(code, s->vlc[2].table, &s->gb, re, VLC_BITS, 3);
806  s->temp[0][4 * i + R] = code + s->temp[0][4 * i + G];
807  } else {
808  VLC_INTERN(s->temp[0][4 * i + B], s->vlc[0].table,
809  &s->gb, re, VLC_BITS, 3);
810 
811  UPDATE_CACHE(re, &s->gb);
812  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
813  VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table,
814  &s->gb, re, VLC_BITS, 3);
815 
816  UPDATE_CACHE(re, &s->gb);
817  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
818  VLC_INTERN(s->temp[0][4 * i + R], s->vlc[2].table,
819  &s->gb, re, VLC_BITS, 3);
820  }
821  }
822  if (alpha) {
823  UPDATE_CACHE(re, &s->gb);
824  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
825  VLC_INTERN(s->temp[0][4 * i + A], s->vlc[2].table,
826  &s->gb, re, VLC_BITS, 3);
827  } else
828  s->temp[0][4 * i + A] = 0;
829  }
830  CLOSE_READER(re, &s->gb);
831 }
832 
834 {
835  if (s->decorrelate) {
836  if (s->bitstream_bpp == 24)
837  decode_bgr_1(s, count, 1, 0);
838  else
839  decode_bgr_1(s, count, 1, 1);
840  } else {
841  if (s->bitstream_bpp == 24)
842  decode_bgr_1(s, count, 0, 0);
843  else
844  decode_bgr_1(s, count, 0, 1);
845  }
846 }
847 
848 static void draw_slice(HYuvContext *s, AVFrame *frame, int y)
849 {
850  int h, cy, i;
852 
853  if (!s->avctx->draw_horiz_band)
854  return;
855 
856  h = y - s->last_slice_end;
857  y -= h;
858 
859  if (s->bitstream_bpp == 12)
860  cy = y >> 1;
861  else
862  cy = y;
863 
864  offset[0] = frame->linesize[0] * y;
865  offset[1] = frame->linesize[1] * cy;
866  offset[2] = frame->linesize[2] * cy;
867  for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
868  offset[i] = 0;
869  emms_c();
870 
871  s->avctx->draw_horiz_band(s->avctx, frame, offset, y, 3, h);
872 
873  s->last_slice_end = y + h;
874 }
875 
876 static int left_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int acc)
877 {
878  if (s->bps <= 8) {
879  return s->hdsp.add_hfyu_left_pred(dst, src, w, acc);
880  } else {
881  return s->llviddsp.add_hfyu_left_pred_int16(( uint16_t *)dst, (const uint16_t *)src, s->n-1, w, acc);
882  }
883 }
884 
885 static void add_bytes(HYuvContext *s, uint8_t *dst, uint8_t *src, int w)
886 {
887  if (s->bps <= 8) {
888  s->hdsp.add_bytes(dst, src, w);
889  } else {
890  s->llviddsp.add_int16((uint16_t*)dst, (const uint16_t*)src, s->n - 1, w);
891  }
892 }
893 
894 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)
895 {
896  if (s->bps <= 8) {
897  s->hdsp.add_hfyu_median_pred(dst, src, diff, w, left, left_top);
898  } else {
899  s->llviddsp.add_hfyu_median_pred_int16((uint16_t *)dst, (const uint16_t *)src, (const uint16_t *)diff, s->n-1, w, left, left_top);
900  }
901 }
902 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
903  AVPacket *avpkt)
904 {
905  const uint8_t *buf = avpkt->data;
906  int buf_size = avpkt->size;
907  HYuvContext *s = avctx->priv_data;
908  const int width = s->width;
909  const int width2 = s->width >> 1;
910  const int height = s->height;
911  int fake_ystride, fake_ustride, fake_vstride;
912  ThreadFrame frame = { .f = data };
913  AVFrame *const p = data;
914  int table_size = 0, ret;
915 
918  buf_size);
919  if (!s->bitstream_buffer)
920  return AVERROR(ENOMEM);
921 
922  s->bdsp.bswap_buf((uint32_t *) s->bitstream_buffer,
923  (const uint32_t *) buf, buf_size / 4);
924 
925  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
926  return ret;
927 
928  if (s->context) {
929  table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
930  if (table_size < 0)
931  return table_size;
932  }
933 
934  if ((unsigned) (buf_size - table_size) >= INT_MAX / 8)
935  return AVERROR_INVALIDDATA;
936 
937  if ((ret = init_get_bits(&s->gb, s->bitstream_buffer + table_size,
938  (buf_size - table_size) * 8)) < 0)
939  return ret;
940 
941  fake_ystride = s->interlaced ? p->linesize[0] * 2 : p->linesize[0];
942  fake_ustride = s->interlaced ? p->linesize[1] * 2 : p->linesize[1];
943  fake_vstride = s->interlaced ? p->linesize[2] * 2 : p->linesize[2];
944 
945  s->last_slice_end = 0;
946 
947  if (s->version > 2) {
948  int plane;
949  for(plane = 0; plane < 1 + 2*s->chroma + s->alpha; plane++) {
950  int left, lefttop, y;
951  int w = width;
952  int h = height;
953  int fake_stride = fake_ystride;
954 
955  if (s->chroma && (plane == 1 || plane == 2)) {
956  w >>= s->chroma_h_shift;
957  h >>= s->chroma_v_shift;
958  fake_stride = plane == 1 ? fake_ustride : fake_vstride;
959  }
960 
961  switch (s->predictor) {
962  case LEFT:
963  case PLANE:
964  decode_plane_bitstream(s, w, plane);
965  left = left_prediction(s, p->data[plane], s->temp[0], w, 0);
966 
967  for (y = 1; y < h; y++) {
968  uint8_t *dst = p->data[plane] + p->linesize[plane]*y;
969 
970  decode_plane_bitstream(s, w, plane);
971  left = left_prediction(s, dst, s->temp[0], w, left);
972  if (s->predictor == PLANE) {
973  if (y > s->interlaced) {
974  add_bytes(s, dst, dst - fake_stride, w);
975  }
976  }
977  }
978 
979  break;
980  case MEDIAN:
981  decode_plane_bitstream(s, w, plane);
982  left= left_prediction(s, p->data[plane], s->temp[0], w, 0);
983 
984  y = 1;
985 
986  /* second line is left predicted for interlaced case */
987  if (s->interlaced) {
988  decode_plane_bitstream(s, w, plane);
989  left = left_prediction(s, p->data[plane] + p->linesize[plane], s->temp[0], w, left);
990  y++;
991  }
992 
993  lefttop = p->data[plane][0];
994  decode_plane_bitstream(s, w, plane);
995  add_median_prediction(s, p->data[plane] + fake_stride, p->data[plane], s->temp[0], w, &left, &lefttop);
996  y++;
997 
998  for (; y<h; y++) {
999  uint8_t *dst;
1000 
1001  decode_plane_bitstream(s, w, plane);
1002 
1003  dst = p->data[plane] + p->linesize[plane] * y;
1004 
1005  add_median_prediction(s, dst, dst - fake_stride, s->temp[0], w, &left, &lefttop);
1006  }
1007 
1008  break;
1009  }
1010  }
1011  draw_slice(s, p, height);
1012  } else if (s->bitstream_bpp < 24) {
1013  int y, cy;
1014  int lefty, leftu, leftv;
1015  int lefttopy, lefttopu, lefttopv;
1016 
1017  if (s->yuy2) {
1018  p->data[0][3] = get_bits(&s->gb, 8);
1019  p->data[0][2] = get_bits(&s->gb, 8);
1020  p->data[0][1] = get_bits(&s->gb, 8);
1021  p->data[0][0] = get_bits(&s->gb, 8);
1022 
1023  av_log(avctx, AV_LOG_ERROR,
1024  "YUY2 output is not implemented yet\n");
1025  return AVERROR_PATCHWELCOME;
1026  } else {
1027  leftv =
1028  p->data[2][0] = get_bits(&s->gb, 8);
1029  lefty =
1030  p->data[0][1] = get_bits(&s->gb, 8);
1031  leftu =
1032  p->data[1][0] = get_bits(&s->gb, 8);
1033  p->data[0][0] = get_bits(&s->gb, 8);
1034 
1035  switch (s->predictor) {
1036  case LEFT:
1037  case PLANE:
1038  decode_422_bitstream(s, width - 2);
1039  lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + 2, s->temp[0],
1040  width - 2, lefty);
1041  if (!(s->flags & CODEC_FLAG_GRAY)) {
1042  leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
1043  leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
1044  }
1045 
1046  for (cy = y = 1; y < s->height; y++, cy++) {
1047  uint8_t *ydst, *udst, *vdst;
1048 
1049  if (s->bitstream_bpp == 12) {
1050  decode_gray_bitstream(s, width);
1051 
1052  ydst = p->data[0] + p->linesize[0] * y;
1053 
1054  lefty = s->hdsp.add_hfyu_left_pred(ydst, s->temp[0],
1055  width, lefty);
1056  if (s->predictor == PLANE) {
1057  if (y > s->interlaced)
1058  s->hdsp.add_bytes(ydst, ydst - fake_ystride, width);
1059  }
1060  y++;
1061  if (y >= s->height)
1062  break;
1063  }
1064 
1065  draw_slice(s, p, y);
1066 
1067  ydst = p->data[0] + p->linesize[0] * y;
1068  udst = p->data[1] + p->linesize[1] * cy;
1069  vdst = p->data[2] + p->linesize[2] * cy;
1070 
1071  decode_422_bitstream(s, width);
1072  lefty = s->hdsp.add_hfyu_left_pred(ydst, s->temp[0],
1073  width, lefty);
1074  if (!(s->flags & CODEC_FLAG_GRAY)) {
1075  leftu = s->hdsp.add_hfyu_left_pred(udst, s->temp[1], width2, leftu);
1076  leftv = s->hdsp.add_hfyu_left_pred(vdst, s->temp[2], width2, leftv);
1077  }
1078  if (s->predictor == PLANE) {
1079  if (cy > s->interlaced) {
1080  s->hdsp.add_bytes(ydst, ydst - fake_ystride, width);
1081  if (!(s->flags & CODEC_FLAG_GRAY)) {
1082  s->hdsp.add_bytes(udst, udst - fake_ustride, width2);
1083  s->hdsp.add_bytes(vdst, vdst - fake_vstride, width2);
1084  }
1085  }
1086  }
1087  }
1088  draw_slice(s, p, height);
1089 
1090  break;
1091  case MEDIAN:
1092  /* first line except first 2 pixels is left predicted */
1093  decode_422_bitstream(s, width - 2);
1094  lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + 2, s->temp[0],
1095  width - 2, lefty);
1096  if (!(s->flags & CODEC_FLAG_GRAY)) {
1097  leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
1098  leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
1099  }
1100 
1101  cy = y = 1;
1102 
1103  /* second line is left predicted for interlaced case */
1104  if (s->interlaced) {
1105  decode_422_bitstream(s, width);
1106  lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + p->linesize[0],
1107  s->temp[0], width, lefty);
1108  if (!(s->flags & CODEC_FLAG_GRAY)) {
1109  leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1110  leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1111  }
1112  y++;
1113  cy++;
1114  }
1115 
1116  /* next 4 pixels are left predicted too */
1117  decode_422_bitstream(s, 4);
1118  lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + fake_ystride,
1119  s->temp[0], 4, lefty);
1120  if (!(s->flags & CODEC_FLAG_GRAY)) {
1121  leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1122  leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1123  }
1124 
1125  /* next line except the first 4 pixels is median predicted */
1126  lefttopy = p->data[0][3];
1127  decode_422_bitstream(s, width - 4);
1128  s->hdsp.add_hfyu_median_pred(p->data[0] + fake_ystride + 4,
1129  p->data[0] + 4, s->temp[0],
1130  width - 4, &lefty, &lefttopy);
1131  if (!(s->flags & CODEC_FLAG_GRAY)) {
1132  lefttopu = p->data[1][1];
1133  lefttopv = p->data[2][1];
1134  s->hdsp.add_hfyu_median_pred(p->data[1] + fake_ustride + 2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
1135  s->hdsp.add_hfyu_median_pred(p->data[2] + fake_vstride + 2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
1136  }
1137  y++;
1138  cy++;
1139 
1140  for (; y < height; y++, cy++) {
1141  uint8_t *ydst, *udst, *vdst;
1142 
1143  if (s->bitstream_bpp == 12) {
1144  while (2 * cy > y) {
1145  decode_gray_bitstream(s, width);
1146  ydst = p->data[0] + p->linesize[0] * y;
1147  s->hdsp.add_hfyu_median_pred(ydst, ydst - fake_ystride,
1148  s->temp[0], width,
1149  &lefty, &lefttopy);
1150  y++;
1151  }
1152  if (y >= height)
1153  break;
1154  }
1155  draw_slice(s, p, y);
1156 
1157  decode_422_bitstream(s, width);
1158 
1159  ydst = p->data[0] + p->linesize[0] * y;
1160  udst = p->data[1] + p->linesize[1] * cy;
1161  vdst = p->data[2] + p->linesize[2] * cy;
1162 
1163  s->hdsp.add_hfyu_median_pred(ydst, ydst - fake_ystride,
1164  s->temp[0], width,
1165  &lefty, &lefttopy);
1166  if (!(s->flags & CODEC_FLAG_GRAY)) {
1167  s->hdsp.add_hfyu_median_pred(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1168  s->hdsp.add_hfyu_median_pred(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1169  }
1170  }
1171 
1172  draw_slice(s, p, height);
1173  break;
1174  }
1175  }
1176  } else {
1177  int y;
1178  uint8_t left[4];
1179  const int last_line = (height - 1) * p->linesize[0];
1180 
1181  if (s->bitstream_bpp == 32) {
1182  left[A] = p->data[0][last_line + A] = get_bits(&s->gb, 8);
1183  left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8);
1184  left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8);
1185  left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8);
1186  } else {
1187  left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8);
1188  left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8);
1189  left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8);
1190  left[A] = p->data[0][last_line + A] = 255;
1191  skip_bits(&s->gb, 8);
1192  }
1193 
1194  if (s->bgr32) {
1195  switch (s->predictor) {
1196  case LEFT:
1197  case PLANE:
1198  decode_bgr_bitstream(s, width - 1);
1199  s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + last_line + 4,
1200  s->temp[0], width - 1, left);
1201 
1202  for (y = s->height - 2; y >= 0; y--) { // Yes it is stored upside down.
1203  decode_bgr_bitstream(s, width);
1204 
1205  s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + p->linesize[0] * y,
1206  s->temp[0], width, left);
1207  if (s->predictor == PLANE) {
1208  if (s->bitstream_bpp != 32)
1209  left[A] = 0;
1210  if (y < s->height - 1 - s->interlaced) {
1211  s->hdsp.add_bytes(p->data[0] + p->linesize[0] * y,
1212  p->data[0] + p->linesize[0] * y +
1213  fake_ystride, 4 * width);
1214  }
1215  }
1216  }
1217  // just 1 large slice as this is not possible in reverse order
1218  draw_slice(s, p, height);
1219  break;
1220  default:
1221  av_log(avctx, AV_LOG_ERROR,
1222  "prediction type not supported!\n");
1223  }
1224  } else {
1225  av_log(avctx, AV_LOG_ERROR,
1226  "BGR24 output is not implemented yet\n");
1227  return AVERROR_PATCHWELCOME;
1228  }
1229  }
1230  emms_c();
1231 
1232  *got_frame = 1;
1233 
1234  return (get_bits_count(&s->gb) + 31) / 32 * 4 + table_size;
1235 }
1236 
1238  .name = "huffyuv",
1239  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1240  .type = AVMEDIA_TYPE_VIDEO,
1241  .id = AV_CODEC_ID_HUFFYUV,
1242  .priv_data_size = sizeof(HYuvContext),
1243  .init = decode_init,
1244  .close = decode_end,
1245  .decode = decode_frame,
1246  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |
1249 };
1250 
1251 #if CONFIG_FFVHUFF_DECODER
1252 AVCodec ff_ffvhuff_decoder = {
1253  .name = "ffvhuff",
1254  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1255  .type = AVMEDIA_TYPE_VIDEO,
1256  .id = AV_CODEC_ID_FFVHUFF,
1257  .priv_data_size = sizeof(HYuvContext),
1258  .init = decode_init,
1259  .close = decode_end,
1260  .decode = decode_frame,
1261  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |
1264 };
1265 #endif /* CONFIG_FFVHUFF_DECODER */