FFmpeg
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 https://multimedia.cx/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 "config_components.h"
36 
37 #include "avcodec.h"
38 #include "bswapdsp.h"
39 #include "codec_internal.h"
40 #include "get_bits.h"
41 #include "huffyuv.h"
42 #include "huffyuvdsp.h"
43 #include "lossless_videodsp.h"
44 #include "thread.h"
45 #include "libavutil/emms.h"
46 #include "libavutil/imgutils.h"
47 #include "libavutil/pixdesc.h"
48 
49 #define VLC_BITS 12
50 
51 typedef struct HYuvDecContext {
52  GetBitContext gb;
53  Predictor predictor;
54  int interlaced;
55  int decorrelate;
56  int bitstream_bpp;
57  int version;
58  int yuy2; //use yuy2 instead of 422P
59  int bgr32; //use bgr32 instead of bgr24
60  int bps;
61  int n; // 1<<bps
62  int vlc_n; // number of vlc codes (FFMIN(1<<bps, MAX_VLC_N))
63  int alpha;
64  int chroma;
65  int yuv;
66  int chroma_h_shift;
67  int chroma_v_shift;
68  int flags;
69  int context;
70  int last_slice_end;
71 
72  uint8_t *temp[3];
73  uint16_t *temp16[3]; ///< identical to temp but 16bit type
74  uint8_t len[4][MAX_VLC_N];
75  uint32_t bits[4][MAX_VLC_N];
76  uint32_t pix_bgr_map[1<<VLC_BITS];
77  VLC vlc[8]; //Y,U,V,A,YY,YU,YV,AA
78  uint8_t *bitstream_buffer;
79  unsigned int bitstream_buffer_size;
80  BswapDSPContext bdsp;
81  HuffYUVDSPContext hdsp;
82  LLVidDSPContext llviddsp;
83 } HYuvDecContext;
84 
85 
86 #define classic_shift_luma_table_size 42
87 static const unsigned char classic_shift_luma[classic_shift_luma_table_size + AV_INPUT_BUFFER_PADDING_SIZE] = {
88  34, 36, 35, 69, 135, 232, 9, 16, 10, 24, 11, 23, 12, 16, 13, 10,
89  14, 8, 15, 8, 16, 8, 17, 20, 16, 10, 207, 206, 205, 236, 11, 8,
90  10, 21, 9, 23, 8, 8, 199, 70, 69, 68, 0,
91  0,0,0,0,0,0,0,0,
92 };
93 
94 #define classic_shift_chroma_table_size 59
95 static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size + AV_INPUT_BUFFER_PADDING_SIZE] = {
96  66, 36, 37, 38, 39, 40, 41, 75, 76, 77, 110, 239, 144, 81, 82, 83,
97  84, 85, 118, 183, 56, 57, 88, 89, 56, 89, 154, 57, 58, 57, 26, 141,
98  57, 56, 58, 57, 58, 57, 184, 119, 214, 245, 116, 83, 82, 49, 80, 79,
99  78, 77, 44, 75, 41, 40, 39, 38, 37, 36, 34, 0,
100  0,0,0,0,0,0,0,0,
101 };
102 
103 static const unsigned char classic_add_luma[256] = {
104  3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
105  73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
106  68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
107  35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
108  37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
109  35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
110  27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
111  15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
112  12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
113  12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
114  18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
115  28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
116  28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
117  62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
118  54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
119  46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
120 };
121 
122 static const unsigned char classic_add_chroma[256] = {
123  3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
124  7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
125  11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
126  43, 45, 76, 81, 46, 82, 75, 55, 56, 144, 58, 80, 60, 74, 147, 63,
127  143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
128  80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
129  17, 14, 5, 6, 100, 54, 47, 50, 51, 53, 106, 107, 108, 109, 110, 111,
130  112, 113, 114, 115, 4, 117, 118, 92, 94, 121, 122, 3, 124, 103, 2, 1,
131  0, 129, 130, 131, 120, 119, 126, 125, 136, 137, 138, 139, 140, 141, 142, 134,
132  135, 132, 133, 104, 64, 101, 62, 57, 102, 95, 93, 59, 61, 28, 97, 96,
133  52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
134  19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
135  7, 128, 127, 105, 123, 116, 35, 34, 33, 145, 31, 79, 42, 146, 78, 26,
136  83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
137  14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
138  6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
139 };
140 
141 static int read_len_table(uint8_t *dst, GetBitContext *gb, int n)
142 {
143  int i, val, repeat;
144 
145  for (i = 0; i < n;) {
146  repeat = get_bits(gb, 3);
147  val = get_bits(gb, 5);
148  if (repeat == 0)
149  repeat = get_bits(gb, 8);
150  if (i + repeat > n || get_bits_left(gb) < 0) {
151  av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
152  return AVERROR_INVALIDDATA;
153  }
154  while (repeat--)
155  dst[i++] = val;
156  }
157  return 0;
158 }
159 
160 static int generate_joint_tables(HYuvDecContext *s)
161 {
162  int ret;
163  uint16_t *symbols = av_mallocz(5 << VLC_BITS);
164  uint16_t *bits;
165  uint8_t *len;
166  if (!symbols)
167  return AVERROR(ENOMEM);
168  bits = symbols + (1 << VLC_BITS);
169  len = (uint8_t *)(bits + (1 << VLC_BITS));
170 
171  if (s->bitstream_bpp < 24 || s->version > 2) {
172  int count = 1 + s->alpha + 2 * s->chroma;
173  int p, i, y, u;
174  for (p = 0; p < count; p++) {
175  int p0 = s->version > 2 ? p : 0;
176  for (i = y = 0; y < s->vlc_n; y++) {
177  int len0 = s->len[p0][y];
178  int limit = VLC_BITS - len0;
179  if (limit <= 0 || !len0)
180  continue;
181  if ((sign_extend(y, 8) & (s->vlc_n-1)) != y)
182  continue;
183  for (u = 0; u < s->vlc_n; u++) {
184  int len1 = s->len[p][u];
185  if (len1 > limit || !len1)
186  continue;
187  if ((sign_extend(u, 8) & (s->vlc_n-1)) != u)
188  continue;
189  av_assert0(i < (1 << VLC_BITS));
190  len[i] = len0 + len1;
191  bits[i] = (s->bits[p0][y] << len1) + s->bits[p][u];
192  symbols[i] = (y << 8) + (u & 0xFF);
193  i++;
194  }
195  }
196  ff_vlc_free(&s->vlc[4 + p]);
197  if ((ret = ff_vlc_init_sparse(&s->vlc[4 + p], VLC_BITS, i, len, 1, 1,
198  bits, 2, 2, symbols, 2, 2, 0)) < 0)
199  goto out;
200  }
201  } else {
202  uint8_t (*map)[4] = (uint8_t(*)[4]) s->pix_bgr_map;
203  int i, b, g, r, code;
204  int p0 = s->decorrelate;
205  int p1 = !s->decorrelate;
206  /* Restrict the range to +/-16 because that's pretty much guaranteed
207  * to cover all the combinations that fit in 11 bits total, and it
208  * does not matter if we miss a few rare codes. */
209  for (i = 0, g = -16; g < 16; g++) {
210  int len0 = s->len[p0][g & 255];
211  int limit0 = VLC_BITS - len0;
212  if (limit0 < 2 || !len0)
213  continue;
214  for (b = -16; b < 16; b++) {
215  int len1 = s->len[p1][b & 255];
216  int limit1 = limit0 - len1;
217  if (limit1 < 1 || !len1)
218  continue;
219  code = (s->bits[p0][g & 255] << len1) + s->bits[p1][b & 255];
220  for (r = -16; r < 16; r++) {
221  int len2 = s->len[2][r & 255];
222  if (len2 > limit1 || !len2)
223  continue;
224  av_assert0(i < (1 << VLC_BITS));
225  len[i] = len0 + len1 + len2;
226  bits[i] = (code << len2) + s->bits[2][r & 255];
227  if (s->decorrelate) {
228  map[i][G] = g;
229  map[i][B] = g + b;
230  map[i][R] = g + r;
231  } else {
232  map[i][B] = g;
233  map[i][G] = b;
234  map[i][R] = r;
235  }
236  i++;
237  }
238  }
239  }
240  ff_vlc_free(&s->vlc[4]);
241  if ((ret = vlc_init(&s->vlc[4], VLC_BITS, i, len, 1, 1,
242  bits, 2, 2, 0)) < 0)
243  goto out;
244  }
245  ret = 0;
246 out:
247  av_freep(&symbols);
248  return ret;
249 }
250 
251 static int read_huffman_tables(HYuvDecContext *s, const uint8_t *src, int length)
252 {
253  GetBitContext gb;
254  int i, ret;
255  int count = 3;
256 
257  if ((ret = init_get_bits(&gb, src, length * 8)) < 0)
258  return ret;
259 
260  if (s->version > 2)
261  count = 1 + s->alpha + 2*s->chroma;
262 
263  for (i = 0; i < count; i++) {
264  if ((ret = read_len_table(s->len[i], &gb, s->vlc_n)) < 0)
265  return ret;
266  if ((ret = ff_huffyuv_generate_bits_table(s->bits[i], s->len[i], s->vlc_n)) < 0)
267  return ret;
268  ff_vlc_free(&s->vlc[i]);
269  if ((ret = vlc_init(&s->vlc[i], VLC_BITS, s->vlc_n, s->len[i], 1, 1,
270  s->bits[i], 4, 4, 0)) < 0)
271  return ret;
272  }
273 
274  if ((ret = generate_joint_tables(s)) < 0)
275  return ret;
276 
277  return (get_bits_count(&gb) + 7) / 8;
278 }
279 
280 static int read_old_huffman_tables(HYuvDecContext *s)
281 {
282  GetBitContext gb;
283  int i, ret;
284 
285  init_get_bits(&gb, classic_shift_luma,
286  classic_shift_luma_table_size * 8);
287  if ((ret = read_len_table(s->len[0], &gb, 256)) < 0)
288  return ret;
289 
290  init_get_bits(&gb, classic_shift_chroma,
291  classic_shift_chroma_table_size * 8);
292  if ((ret = read_len_table(s->len[1], &gb, 256)) < 0)
293  return ret;
294 
295  for (i = 0; i < 256; i++)
296  s->bits[0][i] = classic_add_luma[i];
297  for (i = 0; i < 256; i++)
298  s->bits[1][i] = classic_add_chroma[i];
299 
300  if (s->bitstream_bpp >= 24) {
301  memcpy(s->bits[1], s->bits[0], 256 * sizeof(uint32_t));
302  memcpy(s->len[1], s->len[0], 256 * sizeof(uint8_t));
303  }
304  memcpy(s->bits[2], s->bits[1], 256 * sizeof(uint32_t));
305  memcpy(s->len[2], s->len[1], 256 * sizeof(uint8_t));
306 
307  for (i = 0; i < 4; i++) {
308  ff_vlc_free(&s->vlc[i]);
309  if ((ret = vlc_init(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
310  s->bits[i], 4, 4, 0)) < 0)
311  return ret;
312  }
313 
314  if ((ret = generate_joint_tables(s)) < 0)
315  return ret;
316 
317  return 0;
318 }
319 
320 static av_cold int decode_end(AVCodecContext *avctx)
321 {
322  HYuvDecContext *s = avctx->priv_data;
323  int i;
324 
325  ff_huffyuv_common_end(s->temp, s->temp16);
326  av_freep(&s->bitstream_buffer);
327 
328  for (i = 0; i < 8; i++)
329  ff_vlc_free(&s->vlc[i]);
330 
331  return 0;
332 }
333 
334 static av_cold int decode_init(AVCodecContext *avctx)
335 {
336  HYuvDecContext *s = avctx->priv_data;
337  int ret;
338 
339  ret = av_image_check_size(avctx->width, avctx->height, 0, avctx);
340  if (ret < 0)
341  return ret;
342 
343  s->flags = avctx->flags;
344 
345  ff_bswapdsp_init(&s->bdsp);
346  ff_huffyuvdsp_init(&s->hdsp, avctx->pix_fmt);
347  ff_llviddsp_init(&s->llviddsp);
348  memset(s->vlc, 0, 4 * sizeof(VLC));
349 
350  s->interlaced = avctx->height > 288;
351  s->bgr32 = 1;
352 
353  if (avctx->extradata_size) {
354  if ((avctx->bits_per_coded_sample & 7) &&
355  avctx->bits_per_coded_sample != 12)
356  s->version = 1; // do such files exist at all?
357  else if (avctx->extradata_size > 3 && avctx->extradata[3] == 0)
358  s->version = 2;
359  else
360  s->version = 3;
361  } else
362  s->version = 0;
363 
364  s->bps = 8;
365  s->n = 1<<s->bps;
366  s->vlc_n = FFMIN(s->n, MAX_VLC_N);
367  s->chroma = 1;
368  if (s->version >= 2) {
369  int method, interlace;
370 
371  if (avctx->extradata_size < 4)
372  return AVERROR_INVALIDDATA;
373 
374  method = avctx->extradata[0];
375  s->decorrelate = method & 64 ? 1 : 0;
376  s->predictor = method & 63;
377  if (s->version == 2) {
378  s->bitstream_bpp = avctx->extradata[1];
379  if (s->bitstream_bpp == 0)
380  s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
381  } else {
382  s->bps = (avctx->extradata[1] >> 4) + 1;
383  s->n = 1<<s->bps;
384  s->vlc_n = FFMIN(s->n, MAX_VLC_N);
385  s->chroma_h_shift = avctx->extradata[1] & 3;
386  s->chroma_v_shift = (avctx->extradata[1] >> 2) & 3;
387  s->yuv = !!(avctx->extradata[2] & 1);
388  s->chroma= !!(avctx->extradata[2] & 3);
389  s->alpha = !!(avctx->extradata[2] & 4);
390  }
391  interlace = (avctx->extradata[2] & 0x30) >> 4;
392  s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 : s->interlaced;
393  s->context = avctx->extradata[2] & 0x40 ? 1 : 0;
394 
395  if ((ret = read_huffman_tables(s, avctx->extradata + 4,
396  avctx->extradata_size - 4)) < 0)
397  return ret;
398  } else {
399  switch (avctx->bits_per_coded_sample & 7) {
400  case 1:
401  s->predictor = LEFT;
402  s->decorrelate = 0;
403  break;
404  case 2:
405  s->predictor = LEFT;
406  s->decorrelate = 1;
407  break;
408  case 3:
409  s->predictor = PLANE;
410  s->decorrelate = avctx->bits_per_coded_sample >= 24;
411  break;
412  case 4:
413  s->predictor = MEDIAN;
414  s->decorrelate = 0;
415  break;
416  default:
417  s->predictor = LEFT; // OLD
418  s->decorrelate = 0;
419  break;
420  }
421  s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
422  s->context = 0;
423 
424  if ((ret = read_old_huffman_tables(s)) < 0)
425  return ret;
426  }
427 
428  if (s->version <= 2) {
429  switch (s->bitstream_bpp) {
430  case 12:
431  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
432  s->yuv = 1;
433  break;
434  case 16:
435  if (s->yuy2)
436  avctx->pix_fmt = AV_PIX_FMT_YUYV422;
437  else
438  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
439  s->yuv = 1;
440  break;
441  case 24:
442  if (s->bgr32)
443  avctx->pix_fmt = AV_PIX_FMT_0RGB32;
444  else
445  avctx->pix_fmt = AV_PIX_FMT_BGR24;
446  break;
447  case 32:
448  av_assert0(s->bgr32);
449  avctx->pix_fmt = AV_PIX_FMT_RGB32;
450  s->alpha = 1;
451  break;
452  default:
453  return AVERROR_INVALIDDATA;
454  }
455  av_pix_fmt_get_chroma_sub_sample(avctx->pix_fmt,
456  &s->chroma_h_shift,
457  &s->chroma_v_shift);
458  } else {
459  switch ( (s->chroma<<10) | (s->yuv<<9) | (s->alpha<<8) | ((s->bps-1)<<4) | s->chroma_h_shift | (s->chroma_v_shift<<2)) {
460  case 0x070:
461  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
462  break;
463  case 0x0F0:
464  avctx->pix_fmt = AV_PIX_FMT_GRAY16;
465  break;
466  case 0x470:
467  avctx->pix_fmt = AV_PIX_FMT_GBRP;
468  break;
469  case 0x480:
470  avctx->pix_fmt = AV_PIX_FMT_GBRP9;
471  break;
472  case 0x490:
473  avctx->pix_fmt = AV_PIX_FMT_GBRP10;
474  break;
475  case 0x4B0:
476  avctx->pix_fmt = AV_PIX_FMT_GBRP12;
477  break;
478  case 0x4D0:
479  avctx->pix_fmt = AV_PIX_FMT_GBRP14;
480  break;
481  case 0x4F0:
482  avctx->pix_fmt = AV_PIX_FMT_GBRP16;
483  break;
484  case 0x570:
485  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
486  break;
487  case 0x670:
488  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
489  break;
490  case 0x680:
491  avctx->pix_fmt = AV_PIX_FMT_YUV444P9;
492  break;
493  case 0x690:
494  avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
495  break;
496  case 0x6B0:
497  avctx->pix_fmt = AV_PIX_FMT_YUV444P12;
498  break;
499  case 0x6D0:
500  avctx->pix_fmt = AV_PIX_FMT_YUV444P14;
501  break;
502  case 0x6F0:
503  avctx->pix_fmt = AV_PIX_FMT_YUV444P16;
504  break;
505  case 0x671:
506  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
507  break;
508  case 0x681:
509  avctx->pix_fmt = AV_PIX_FMT_YUV422P9;
510  break;
511  case 0x691:
512  avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
513  break;
514  case 0x6B1:
515  avctx->pix_fmt = AV_PIX_FMT_YUV422P12;
516  break;
517  case 0x6D1:
518  avctx->pix_fmt = AV_PIX_FMT_YUV422P14;
519  break;
520  case 0x6F1:
521  avctx->pix_fmt = AV_PIX_FMT_YUV422P16;
522  break;
523  case 0x672:
524  avctx->pix_fmt = AV_PIX_FMT_YUV411P;
525  break;
526  case 0x674:
527  avctx->pix_fmt = AV_PIX_FMT_YUV440P;
528  break;
529  case 0x675:
530  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
531  break;
532  case 0x685:
533  avctx->pix_fmt = AV_PIX_FMT_YUV420P9;
534  break;
535  case 0x695:
536  avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
537  break;
538  case 0x6B5:
539  avctx->pix_fmt = AV_PIX_FMT_YUV420P12;
540  break;
541  case 0x6D5:
542  avctx->pix_fmt = AV_PIX_FMT_YUV420P14;
543  break;
544  case 0x6F5:
545  avctx->pix_fmt = AV_PIX_FMT_YUV420P16;
546  break;
547  case 0x67A:
548  avctx->pix_fmt = AV_PIX_FMT_YUV410P;
549  break;
550  case 0x770:
551  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
552  break;
553  case 0x780:
554  avctx->pix_fmt = AV_PIX_FMT_YUVA444P9;
555  break;
556  case 0x790:
557  avctx->pix_fmt = AV_PIX_FMT_YUVA444P10;
558  break;
559  case 0x7F0:
560  avctx->pix_fmt = AV_PIX_FMT_YUVA444P16;
561  break;
562  case 0x771:
563  avctx->pix_fmt = AV_PIX_FMT_YUVA422P;
564  break;
565  case 0x781:
566  avctx->pix_fmt = AV_PIX_FMT_YUVA422P9;
567  break;
568  case 0x791:
569  avctx->pix_fmt = AV_PIX_FMT_YUVA422P10;
570  break;
571  case 0x7F1:
572  avctx->pix_fmt = AV_PIX_FMT_YUVA422P16;
573  break;
574  case 0x775:
575  avctx->pix_fmt = AV_PIX_FMT_YUVA420P;
576  break;
577  case 0x785:
578  avctx->pix_fmt = AV_PIX_FMT_YUVA420P9;
579  break;
580  case 0x795:
581  avctx->pix_fmt = AV_PIX_FMT_YUVA420P10;
582  break;
583  case 0x7F5:
584  avctx->pix_fmt = AV_PIX_FMT_YUVA420P16;
585  break;
586  default:
587  return AVERROR_INVALIDDATA;
588  }
589  }
590 
591  if ((avctx->pix_fmt == AV_PIX_FMT_YUV422P || avctx->pix_fmt == AV_PIX_FMT_YUV420P) && avctx->width & 1) {
592  av_log(avctx, AV_LOG_ERROR, "width must be even for this colorspace\n");
593  return AVERROR_INVALIDDATA;
594  }
595  if (s->predictor == MEDIAN && avctx->pix_fmt == AV_PIX_FMT_YUV422P &&
596  avctx->width % 4) {
597  av_log(avctx, AV_LOG_ERROR, "width must be a multiple of 4 "
598  "for this combination of colorspace and predictor type.\n");
599  return AVERROR_INVALIDDATA;
600  }
601 
602  if ((ret = ff_huffyuv_alloc_temp(s->temp, s->temp16, avctx->width)) < 0)
603  return ret;
604 
605  return 0;
606 }
607 
608 /** Subset of GET_VLC for use in hand-roller VLC code */
609 #define VLC_INTERN(dst, table, gb, name, bits, max_depth) \
610  code = table[index].sym; \
611  n = table[index].len; \
612  if (max_depth > 1 && n < 0) { \
613  LAST_SKIP_BITS(name, gb, bits); \
614  UPDATE_CACHE(name, gb); \
615  \
616  nb_bits = -n; \
617  index = SHOW_UBITS(name, gb, nb_bits) + code; \
618  code = table[index].sym; \
619  n = table[index].len; \
620  if (max_depth > 2 && n < 0) { \
621  LAST_SKIP_BITS(name, gb, nb_bits); \
622  UPDATE_CACHE(name, gb); \
623  \
624  nb_bits = -n; \
625  index = SHOW_UBITS(name, gb, nb_bits) + code; \
626  code = table[index].sym; \
627  n = table[index].len; \
628  } \
629  } \
630  dst = code; \
631  LAST_SKIP_BITS(name, gb, n)
632 
633 
634 #define GET_VLC_DUAL(dst0, dst1, name, gb, dtable, table1, table2, \
635  bits, max_depth, OP) \
636  do { \
637  unsigned int index = SHOW_UBITS(name, gb, bits); \
638  int code, n = dtable[index].len; \
639  \
640  if (n<=0) { \
641  int nb_bits; \
642  VLC_INTERN(dst0, table1, gb, name, bits, max_depth); \
643  \
644  UPDATE_CACHE(re, gb); \
645  index = SHOW_UBITS(name, gb, bits); \
646  VLC_INTERN(dst1, table2, gb, name, bits, max_depth); \
647  } else { \
648  code = dtable[index].sym; \
649  OP(dst0, dst1, code); \
650  LAST_SKIP_BITS(name, gb, n); \
651  } \
652  } while (0)
653 
654 #define OP8bits(dst0, dst1, code) dst0 = code>>8; dst1 = code
655 
656 #define READ_2PIX(dst0, dst1, plane1) \
657  UPDATE_CACHE(re, &s->gb); \
658  GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane1].table, \
659  s->vlc[0].table, s->vlc[plane1].table, VLC_BITS, 3, OP8bits)
660 
661 static void decode_422_bitstream(HYuvDecContext *s, int count)
662 {
663  int i, icount;
664  OPEN_READER(re, &s->gb);
665  count /= 2;
666 
667  icount = get_bits_left(&s->gb) / (32 * 4);
668  if (count >= icount) {
669  for (i = 0; i < icount; i++) {
670  READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1);
671  READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
672  }
673  for (; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
674  READ_2PIX(s->temp[0][2 * i ], s->temp[1][i], 1);
675  if (BITS_LEFT(re, &s->gb) <= 0) break;
676  READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
677  }
678  for (; i < count; i++)
679  s->temp[0][2 * i ] = s->temp[1][i] =
680  s->temp[0][2 * i + 1] = s->temp[2][i] = 0;
681  } else {
682  for (i = 0; i < count; i++) {
683  READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1);
684  READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
685  }
686  }
687  CLOSE_READER(re, &s->gb);
688 }
689 
690 #define READ_2PIX_PLANE(dst0, dst1, plane, OP) \
691  UPDATE_CACHE(re, &s->gb); \
692  GET_VLC_DUAL(dst0, dst1, re, &s->gb, s->vlc[4+plane].table, \
693  s->vlc[plane].table, s->vlc[plane].table, VLC_BITS, 3, OP)
694 
695 #define OP14bits(dst0, dst1, code) dst0 = code>>8; dst1 = sign_extend(code, 8)
696 
697 /* TODO instead of restarting the read when the code isn't in the first level
698  * of the joint table, jump into the 2nd level of the individual table. */
699 #define READ_2PIX_PLANE16(dst0, dst1, plane){\
700  dst0 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\
701  dst0 += get_bits(&s->gb, 2);\
702  dst1 = get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)*4;\
703  dst1 += get_bits(&s->gb, 2);\
704 }
705 static void decode_plane_bitstream(HYuvDecContext *s, int width, int plane)
706 {
707  int i, count = width/2;
708 
709  if (s->bps <= 8) {
710  OPEN_READER(re, &s->gb);
711  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
712  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
713  READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits);
714  }
715  } else {
716  for(i=0; i<count; i++){
717  READ_2PIX_PLANE(s->temp[0][2 * i], s->temp[0][2 * i + 1], plane, OP8bits);
718  }
719  }
720  if( width&1 && BITS_LEFT(re, &s->gb)>0 ) {
721  unsigned int index;
722  int nb_bits, code, n;
723  UPDATE_CACHE(re, &s->gb);
724  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
725  VLC_INTERN(s->temp[0][width-1], s->vlc[plane].table,
726  &s->gb, re, VLC_BITS, 3);
727  }
728  CLOSE_READER(re, &s->gb);
729  } else if (s->bps <= 14) {
730  OPEN_READER(re, &s->gb);
731  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
732  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
733  READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits);
734  }
735  } else {
736  for(i=0; i<count; i++){
737  READ_2PIX_PLANE(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane, OP14bits);
738  }
739  }
740  if( width&1 && BITS_LEFT(re, &s->gb)>0 ) {
741  unsigned int index;
742  int nb_bits, code, n;
743  UPDATE_CACHE(re, &s->gb);
744  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
745  VLC_INTERN(s->temp16[0][width-1], s->vlc[plane].table,
746  &s->gb, re, VLC_BITS, 3);
747  }
748  CLOSE_READER(re, &s->gb);
749  } else {
750  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
751  for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
752  READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane);
753  }
754  } else {
755  for(i=0; i<count; i++){
756  READ_2PIX_PLANE16(s->temp16[0][2 * i], s->temp16[0][2 * i + 1], plane);
757  }
758  }
759  if( width&1 && get_bits_left(&s->gb)>0 ) {
760  int dst = (unsigned)get_vlc2(&s->gb, s->vlc[plane].table, VLC_BITS, 3)<<2;
761  s->temp16[0][width-1] = dst + get_bits(&s->gb, 2);
762  }
763  }
764 }
765 
766 static void decode_gray_bitstream(HYuvDecContext *s, int count)
767 {
768  int i;
769  OPEN_READER(re, &s->gb);
770  count /= 2;
771 
772  if (count >= (get_bits_left(&s->gb)) / (32 * 2)) {
773  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
774  READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
775  }
776  } else {
777  for (i = 0; i < count; i++) {
778  READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
779  }
780  }
781  CLOSE_READER(re, &s->gb);
782 }
783 
784 static av_always_inline void decode_bgr_1(HYuvDecContext *s, int count,
785  int decorrelate, int alpha)
786 {
787  int i;
788  OPEN_READER(re, &s->gb);
789 
790  for (i = 0; i < count && BITS_LEFT(re, &s->gb) > 0; i++) {
791  unsigned int index;
792  int code, n, nb_bits;
793 
794  UPDATE_CACHE(re, &s->gb);
795  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
796  n = s->vlc[4].table[index].len;
797 
798  if (n>0) {
799  code = s->vlc[4].table[index].sym;
800  *(uint32_t *) &s->temp[0][4 * i] = s->pix_bgr_map[code];
801  LAST_SKIP_BITS(re, &s->gb, n);
802  } else {
803  if (decorrelate) {
804  VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table,
805  &s->gb, re, VLC_BITS, 3);
806 
807  UPDATE_CACHE(re, &s->gb);
808  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
809  VLC_INTERN(code, s->vlc[0].table, &s->gb, re, VLC_BITS, 3);
810  s->temp[0][4 * i + B] = code + s->temp[0][4 * i + G];
811 
812  UPDATE_CACHE(re, &s->gb);
813  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
814  VLC_INTERN(code, s->vlc[2].table, &s->gb, re, VLC_BITS, 3);
815  s->temp[0][4 * i + R] = code + s->temp[0][4 * i + G];
816  } else {
817  VLC_INTERN(s->temp[0][4 * i + B], s->vlc[0].table,
818  &s->gb, re, VLC_BITS, 3);
819 
820  UPDATE_CACHE(re, &s->gb);
821  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
822  VLC_INTERN(s->temp[0][4 * i + G], s->vlc[1].table,
823  &s->gb, re, VLC_BITS, 3);
824 
825  UPDATE_CACHE(re, &s->gb);
826  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
827  VLC_INTERN(s->temp[0][4 * i + R], s->vlc[2].table,
828  &s->gb, re, VLC_BITS, 3);
829  }
830  }
831  if (alpha) {
832  UPDATE_CACHE(re, &s->gb);
833  index = SHOW_UBITS(re, &s->gb, VLC_BITS);
834  VLC_INTERN(s->temp[0][4 * i + A], s->vlc[2].table,
835  &s->gb, re, VLC_BITS, 3);
836  } else
837  s->temp[0][4 * i + A] = 0;
838  }
839  CLOSE_READER(re, &s->gb);
840 }
841 
842 static void decode_bgr_bitstream(HYuvDecContext *s, int count)
843 {
844  if (s->decorrelate) {
845  if (s->bitstream_bpp == 24)
846  decode_bgr_1(s, count, 1, 0);
847  else
848  decode_bgr_1(s, count, 1, 1);
849  } else {
850  if (s->bitstream_bpp == 24)
851  decode_bgr_1(s, count, 0, 0);
852  else
853  decode_bgr_1(s, count, 0, 1);
854  }
855 }
856 
857 static void draw_slice(HYuvDecContext *s, AVCodecContext *avctx, AVFrame *frame, int y)
858 {
859  int h, cy, i;
860  int offset[AV_NUM_DATA_POINTERS];
861 
862  if (!avctx->draw_horiz_band)
863  return;
864 
865  h = y - s->last_slice_end;
866  y -= h;
867 
868  if (s->bitstream_bpp == 12)
869  cy = y >> 1;
870  else
871  cy = y;
872 
873  offset[0] = frame->linesize[0] * y;
874  offset[1] = frame->linesize[1] * cy;
875  offset[2] = frame->linesize[2] * cy;
876  for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
877  offset[i] = 0;
878  emms_c();
879 
880  avctx->draw_horiz_band(avctx, frame, offset, y, 3, h);
881 
882  s->last_slice_end = y + h;
883 }
884 
885 static int left_prediction(HYuvDecContext *s, uint8_t *dst, const uint8_t *src, int w, int acc)
886 {
887  if (s->bps <= 8) {
888  return s->llviddsp.add_left_pred(dst, src, w, acc);
889  } else {
890  return s->llviddsp.add_left_pred_int16(( uint16_t *)dst, (const uint16_t *)src, s->n-1, w, acc);
891  }
892 }
893 
894 static void add_bytes(HYuvDecContext *s, uint8_t *dst, uint8_t *src, int w)
895 {
896  if (s->bps <= 8) {
897  s->llviddsp.add_bytes(dst, src, w);
898  } else {
899  s->hdsp.add_int16((uint16_t*)dst, (const uint16_t*)src, s->n - 1, w);
900  }
901 }
902 
903 static void add_median_prediction(HYuvDecContext *s, uint8_t *dst, const uint8_t *src, const uint8_t *diff, int w, int *left, int *left_top)
904 {
905  if (s->bps <= 8) {
906  s->llviddsp.add_median_pred(dst, src, diff, w, left, left_top);
907  } else {
908  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);
909  }
910 }
911 
912 static int decode_slice(AVCodecContext *avctx, AVFrame *p, int height,
913  int buf_size, int y_offset, int table_size)
914 {
915  HYuvDecContext *s = avctx->priv_data;
916  int fake_ystride, fake_ustride, fake_vstride;
917  const int width = avctx->width;
918  const int width2 = avctx->width >> 1;
919  int ret;
920 
921  if ((ret = init_get_bits8(&s->gb, s->bitstream_buffer + table_size, buf_size - table_size)) < 0)
922  return ret;
923 
924  fake_ystride = s->interlaced ? p->linesize[0] * 2 : p->linesize[0];
925  fake_ustride = s->interlaced ? p->linesize[1] * 2 : p->linesize[1];
926  fake_vstride = s->interlaced ? p->linesize[2] * 2 : p->linesize[2];
927 
928  if (s->version > 2) {
929  int plane;
930  for(plane = 0; plane < 1 + 2*s->chroma + s->alpha; plane++) {
931  int left, lefttop, y;
932  int w = width;
933  int h = height;
934  int fake_stride = fake_ystride;
935 
936  if (s->chroma && (plane == 1 || plane == 2)) {
937  w >>= s->chroma_h_shift;
938  h >>= s->chroma_v_shift;
939  fake_stride = plane == 1 ? fake_ustride : fake_vstride;
940  }
941 
942  switch (s->predictor) {
943  case LEFT:
944  case PLANE:
945  decode_plane_bitstream(s, w, plane);
946  left = left_prediction(s, p->data[plane], s->temp[0], w, 0);
947 
948  for (y = 1; y < h; y++) {
949  uint8_t *dst = p->data[plane] + p->linesize[plane]*y;
950 
951  decode_plane_bitstream(s, w, plane);
952  left = left_prediction(s, dst, s->temp[0], w, left);
953  if (s->predictor == PLANE) {
954  if (y > s->interlaced) {
955  add_bytes(s, dst, dst - fake_stride, w);
956  }
957  }
958  }
959 
960  break;
961  case MEDIAN:
962  decode_plane_bitstream(s, w, plane);
963  left= left_prediction(s, p->data[plane], s->temp[0], w, 0);
964 
965  y = 1;
966  if (y >= h)
967  break;
968 
969  /* second line is left predicted for interlaced case */
970  if (s->interlaced) {
971  decode_plane_bitstream(s, w, plane);
972  left = left_prediction(s, p->data[plane] + p->linesize[plane], s->temp[0], w, left);
973  y++;
974  if (y >= h)
975  break;
976  }
977 
978  lefttop = p->data[plane][0];
979  decode_plane_bitstream(s, w, plane);
980  add_median_prediction(s, p->data[plane] + fake_stride, p->data[plane], s->temp[0], w, &left, &lefttop);
981  y++;
982 
983  for (; y<h; y++) {
984  uint8_t *dst;
985 
986  decode_plane_bitstream(s, w, plane);
987 
988  dst = p->data[plane] + p->linesize[plane] * y;
989 
990  add_median_prediction(s, dst, dst - fake_stride, s->temp[0], w, &left, &lefttop);
991  }
992 
993  break;
994  }
995  }
996  draw_slice(s, avctx, p, height);
997  } else if (s->bitstream_bpp < 24) {
998  int y, cy;
999  int lefty, leftu, leftv;
1000  int lefttopy, lefttopu, lefttopv;
1001 
1002  if (s->yuy2) {
1003  p->data[0][3] = get_bits(&s->gb, 8);
1004  p->data[0][2] = get_bits(&s->gb, 8);
1005  p->data[0][1] = get_bits(&s->gb, 8);
1006  p->data[0][0] = get_bits(&s->gb, 8);
1007 
1008  av_log(avctx, AV_LOG_ERROR,
1009  "YUY2 output is not implemented yet\n");
1010  return AVERROR_PATCHWELCOME;
1011  } else {
1012  leftv =
1013  p->data[2][0 + y_offset * p->linesize[2]] = get_bits(&s->gb, 8);
1014  lefty =
1015  p->data[0][1 + y_offset * p->linesize[0]] = get_bits(&s->gb, 8);
1016  leftu =
1017  p->data[1][0 + y_offset * p->linesize[1]] = get_bits(&s->gb, 8);
1018  p->data[0][0 + y_offset * p->linesize[0]] = get_bits(&s->gb, 8);
1019 
1020  switch (s->predictor) {
1021  case LEFT:
1022  case PLANE:
1023  decode_422_bitstream(s, width - 2);
1024  lefty = s->llviddsp.add_left_pred(p->data[0] + p->linesize[0] * y_offset + 2, s->temp[0],
1025  width - 2, lefty);
1026  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1027  leftu = s->llviddsp.add_left_pred(p->data[1] + p->linesize[1] * y_offset + 1, s->temp[1], width2 - 1, leftu);
1028  leftv = s->llviddsp.add_left_pred(p->data[2] + p->linesize[2] * y_offset + 1, s->temp[2], width2 - 1, leftv);
1029  }
1030 
1031  for (cy = y = 1; y < height; y++, cy++) {
1032  uint8_t *ydst, *udst, *vdst;
1033 
1034  if (s->bitstream_bpp == 12) {
1035  decode_gray_bitstream(s, width);
1036 
1037  ydst = p->data[0] + p->linesize[0] * (y + y_offset);
1038 
1039  lefty = s->llviddsp.add_left_pred(ydst, s->temp[0],
1040  width, lefty);
1041  if (s->predictor == PLANE) {
1042  if (y > s->interlaced)
1043  s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width);
1044  }
1045  y++;
1046  if (y >= height)
1047  break;
1048  }
1049 
1050  draw_slice(s, avctx, p, y);
1051 
1052  ydst = p->data[0] + p->linesize[0] * (y + y_offset);
1053  udst = p->data[1] + p->linesize[1] * (cy + y_offset);
1054  vdst = p->data[2] + p->linesize[2] * (cy + y_offset);
1055 
1056  decode_422_bitstream(s, width);
1057  lefty = s->llviddsp.add_left_pred(ydst, s->temp[0],
1058  width, lefty);
1059  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1060  leftu = s->llviddsp.add_left_pred(udst, s->temp[1], width2, leftu);
1061  leftv = s->llviddsp.add_left_pred(vdst, s->temp[2], width2, leftv);
1062  }
1063  if (s->predictor == PLANE) {
1064  if (cy > s->interlaced) {
1065  s->llviddsp.add_bytes(ydst, ydst - fake_ystride, width);
1066  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1067  s->llviddsp.add_bytes(udst, udst - fake_ustride, width2);
1068  s->llviddsp.add_bytes(vdst, vdst - fake_vstride, width2);
1069  }
1070  }
1071  }
1072  }
1073  draw_slice(s, avctx, p, height);
1074 
1075  break;
1076  case MEDIAN:
1077  /* first line except first 2 pixels is left predicted */
1078  decode_422_bitstream(s, width - 2);
1079  lefty = s->llviddsp.add_left_pred(p->data[0] + 2, s->temp[0],
1080  width - 2, lefty);
1081  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1082  leftu = s->llviddsp.add_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
1083  leftv = s->llviddsp.add_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
1084  }
1085 
1086  cy = y = 1;
1087  if (y >= height)
1088  break;
1089 
1090  /* second line is left predicted for interlaced case */
1091  if (s->interlaced) {
1092  decode_422_bitstream(s, width);
1093  lefty = s->llviddsp.add_left_pred(p->data[0] + p->linesize[0],
1094  s->temp[0], width, lefty);
1095  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1096  leftu = s->llviddsp.add_left_pred(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
1097  leftv = s->llviddsp.add_left_pred(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
1098  }
1099  y++;
1100  cy++;
1101  if (y >= height)
1102  break;
1103  }
1104 
1105  /* next 4 pixels are left predicted too */
1106  decode_422_bitstream(s, 4);
1107  lefty = s->llviddsp.add_left_pred(p->data[0] + fake_ystride,
1108  s->temp[0], 4, lefty);
1109  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1110  leftu = s->llviddsp.add_left_pred(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
1111  leftv = s->llviddsp.add_left_pred(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
1112  }
1113 
1114  /* next line except the first 4 pixels is median predicted */
1115  lefttopy = p->data[0][3];
1116  decode_422_bitstream(s, width - 4);
1117  s->llviddsp.add_median_pred(p->data[0] + fake_ystride + 4,
1118  p->data[0] + 4, s->temp[0],
1119  width - 4, &lefty, &lefttopy);
1120  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1121  lefttopu = p->data[1][1];
1122  lefttopv = p->data[2][1];
1123  s->llviddsp.add_median_pred(p->data[1] + fake_ustride + 2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
1124  s->llviddsp.add_median_pred(p->data[2] + fake_vstride + 2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
1125  }
1126  y++;
1127  cy++;
1128 
1129  for (; y < height; y++, cy++) {
1130  uint8_t *ydst, *udst, *vdst;
1131 
1132  if (s->bitstream_bpp == 12) {
1133  while (2 * cy > y) {
1134  decode_gray_bitstream(s, width);
1135  ydst = p->data[0] + p->linesize[0] * y;
1136  s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
1137  s->temp[0], width,
1138  &lefty, &lefttopy);
1139  y++;
1140  }
1141  if (y >= height)
1142  break;
1143  }
1144  draw_slice(s, avctx, p, y);
1145 
1146  decode_422_bitstream(s, width);
1147 
1148  ydst = p->data[0] + p->linesize[0] * y;
1149  udst = p->data[1] + p->linesize[1] * cy;
1150  vdst = p->data[2] + p->linesize[2] * cy;
1151 
1152  s->llviddsp.add_median_pred(ydst, ydst - fake_ystride,
1153  s->temp[0], width,
1154  &lefty, &lefttopy);
1155  if (!(s->flags & AV_CODEC_FLAG_GRAY)) {
1156  s->llviddsp.add_median_pred(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
1157  s->llviddsp.add_median_pred(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
1158  }
1159  }
1160 
1161  draw_slice(s, avctx, p, height);
1162  break;
1163  }
1164  }
1165  } else {
1166  int y;
1167  uint8_t left[4];
1168  const int last_line = (y_offset + height - 1) * p->linesize[0];
1169 
1170  if (s->bitstream_bpp == 32) {
1171  left[A] = p->data[0][last_line + A] = get_bits(&s->gb, 8);
1172  left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8);
1173  left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8);
1174  left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8);
1175  } else {
1176  left[R] = p->data[0][last_line + R] = get_bits(&s->gb, 8);
1177  left[G] = p->data[0][last_line + G] = get_bits(&s->gb, 8);
1178  left[B] = p->data[0][last_line + B] = get_bits(&s->gb, 8);
1179  left[A] = p->data[0][last_line + A] = 255;
1180  skip_bits(&s->gb, 8);
1181  }
1182 
1183  if (s->bgr32) {
1184  switch (s->predictor) {
1185  case LEFT:
1186  case PLANE:
1187  decode_bgr_bitstream(s, width - 1);
1188  s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + last_line + 4,
1189  s->temp[0], width - 1, left);
1190 
1191  for (y = height - 2; y >= 0; y--) { // Yes it is stored upside down.
1192  decode_bgr_bitstream(s, width);
1193 
1194  s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + p->linesize[0] * (y + y_offset),
1195  s->temp[0], width, left);
1196  if (s->predictor == PLANE) {
1197  if (s->bitstream_bpp != 32)
1198  left[A] = 0;
1199  if (y < height - 1 - s->interlaced) {
1200  s->llviddsp.add_bytes(p->data[0] + p->linesize[0] * (y + y_offset),
1201  p->data[0] + p->linesize[0] * (y + y_offset) +
1202  fake_ystride, 4 * width);
1203  }
1204  }
1205  }
1206  // just 1 large slice as this is not possible in reverse order
1207  draw_slice(s, avctx, p, height);
1208  break;
1209  default:
1210  av_log(avctx, AV_LOG_ERROR,
1211  "prediction type not supported!\n");
1212  }
1213  } else {
1214  av_log(avctx, AV_LOG_ERROR,
1215  "BGR24 output is not implemented yet\n");
1216  return AVERROR_PATCHWELCOME;
1217  }
1218  }
1219 
1220  return 0;
1221 }
1222 
1223 static int decode_frame(AVCodecContext *avctx, AVFrame *p,
1224  int *got_frame, AVPacket *avpkt)
1225 {
1226  const uint8_t *buf = avpkt->data;
1227  int buf_size = avpkt->size;
1228  HYuvDecContext *s = avctx->priv_data;
1229  const int width = avctx->width;
1230  const int height = avctx->height;
1231  int slice, table_size = 0, ret, nb_slices;
1232  unsigned slices_info_offset;
1233  int slice_height;
1234 
1235  if (buf_size < (width * height + 7)/8)
1236  return AVERROR_INVALIDDATA;
1237 
1238  av_fast_padded_malloc(&s->bitstream_buffer,
1239  &s->bitstream_buffer_size,
1240  buf_size);
1241  if (!s->bitstream_buffer)
1242  return AVERROR(ENOMEM);
1243 
1244  s->bdsp.bswap_buf((uint32_t *) s->bitstream_buffer,
1245  (const uint32_t *) buf, buf_size / 4);
1246 
1247  if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0)
1248  return ret;
1249 
1250  if (s->context) {
1251  table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
1252  if (table_size < 0)
1253  return table_size;
1254  }
1255 
1256  if ((unsigned) (buf_size - table_size) >= INT_MAX / 8)
1257  return AVERROR_INVALIDDATA;
1258 
1259  s->last_slice_end = 0;
1260 
1261  if (avctx->codec_id == AV_CODEC_ID_HYMT &&
1262  (buf_size > 32 && AV_RL32(avpkt->data + buf_size - 16) == 0)) {
1263  slices_info_offset = AV_RL32(avpkt->data + buf_size - 4);
1264  slice_height = AV_RL32(avpkt->data + buf_size - 8);
1265  nb_slices = AV_RL32(avpkt->data + buf_size - 12);
1266  if (nb_slices * 8LL + slices_info_offset > buf_size - 16 ||
1267  s->chroma_v_shift ||
1268  slice_height <= 0 || nb_slices * (uint64_t)slice_height > height)
1269  return AVERROR_INVALIDDATA;
1270  } else {
1271  slice_height = height;
1272  nb_slices = 1;
1273  }
1274 
1275  for (slice = 0; slice < nb_slices; slice++) {
1276  int y_offset, slice_offset, slice_size;
1277 
1278  if (nb_slices > 1) {
1279  slice_offset = AV_RL32(avpkt->data + slices_info_offset + slice * 8);
1280  slice_size = AV_RL32(avpkt->data + slices_info_offset + slice * 8 + 4);
1281 
1282  if (slice_offset < 0 || slice_size <= 0 || (slice_offset&3) ||
1283  slice_offset + (int64_t)slice_size > buf_size)
1284  return AVERROR_INVALIDDATA;
1285 
1286  y_offset = height - (slice + 1) * slice_height;
1287  s->bdsp.bswap_buf((uint32_t *)s->bitstream_buffer,
1288  (const uint32_t *)(buf + slice_offset), slice_size / 4);
1289  } else {
1290  y_offset = 0;
1291  slice_offset = 0;
1292  slice_size = buf_size;
1293  }
1294 
1295  ret = decode_slice(avctx, p, slice_height, slice_size, y_offset, table_size);
1296  emms_c();
1297  if (ret < 0)
1298  return ret;
1299  }
1300 
1301  *got_frame = 1;
1302 
1303  return (get_bits_count(&s->gb) + 31) / 32 * 4 + table_size;
1304 }
1305 
1306 const FFCodec ff_huffyuv_decoder = {
1307  .p.name = "huffyuv",
1308  CODEC_LONG_NAME("Huffyuv / HuffYUV"),
1309  .p.type = AVMEDIA_TYPE_VIDEO,
1310  .p.id = AV_CODEC_ID_HUFFYUV,
1311  .priv_data_size = sizeof(HYuvDecContext),
1312  .init = decode_init,
1313  .close = decode_end,
1314  FF_CODEC_DECODE_CB(decode_frame),
1315  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
1316  AV_CODEC_CAP_FRAME_THREADS,
1317  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1318 };
1319 
1320 #if CONFIG_FFVHUFF_DECODER
1321 const FFCodec ff_ffvhuff_decoder = {
1322  .p.name = "ffvhuff",
1323  CODEC_LONG_NAME("Huffyuv FFmpeg variant"),
1324  .p.type = AVMEDIA_TYPE_VIDEO,
1325  .p.id = AV_CODEC_ID_FFVHUFF,
1326  .priv_data_size = sizeof(HYuvDecContext),
1327  .init = decode_init,
1328  .close = decode_end,
1329  FF_CODEC_DECODE_CB(decode_frame),
1330  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
1331  AV_CODEC_CAP_FRAME_THREADS,
1332  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1333 };
1334 #endif /* CONFIG_FFVHUFF_DECODER */
1335 
1336 #if CONFIG_HYMT_DECODER
1337 const FFCodec ff_hymt_decoder = {
1338  .p.name = "hymt",
1339  CODEC_LONG_NAME("HuffYUV MT"),
1340  .p.type = AVMEDIA_TYPE_VIDEO,
1341  .p.id = AV_CODEC_ID_HYMT,
1342  .priv_data_size = sizeof(HYuvDecContext),
1343  .init = decode_init,
1344  .close = decode_end,
1345  FF_CODEC_DECODE_CB(decode_frame),
1346  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_DRAW_HORIZ_BAND |
1347  AV_CODEC_CAP_FRAME_THREADS,
1348  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
1349 };
1350 #endif /* CONFIG_HYMT_DECODER */
HuffYUVDSPContext
Definition: huffyuvdsp.h:25
VLC_INTERN
#define VLC_INTERN(dst, table, gb, name, bits, max_depth)
Subset of GET_VLC for use in hand-roller VLC code.
Definition: huffyuvdec.c:609
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:512
A
#define A(x)
Definition: vpx_arith.h:28
decode_bgr_bitstream
static void decode_bgr_bitstream(HYuvDecContext *s, int count)
Definition: huffyuvdec.c:842
bswapdsp.h
read_old_huffman_tables
static int read_old_huffman_tables(HYuvDecContext *s)
Definition: huffyuvdec.c:280
decorrelate
static void decorrelate(SnowContext *s, SubBand *b, IDWTELEM *src, int stride, int inverse, int use_median)
Definition: snowenc.c:1507
generate_joint_tables
static int generate_joint_tables(HYuvDecContext *s)
Definition: huffyuvdec.c:160
VLC_BITS
#define VLC_BITS
Definition: huffyuvdec.c:49
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: codec_internal.h:42
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
r
const char * r
Definition: vf_curves.c:126
acc
int acc
Definition: yuv2rgb.c:554
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
HYuvDecContext::alpha
int alpha
Definition: huffyuvdec.c:63
HYuvDecContext::context
int context
Definition: huffyuvdec.c:69
AV_CODEC_ID_HUFFYUV
@ AV_CODEC_ID_HUFFYUV
Definition: codec_id.h:77
out
FILE * out
Definition: movenc.c:54
decode_bgr_1
static av_always_inline void decode_bgr_1(HYuvDecContext *s, int count, int decorrelate, int alpha)
Definition: huffyuvdec.c:784
AV_CODEC_ID_HYMT
@ AV_CODEC_ID_HYMT
Definition: codec_id.h:295
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:239
MAX_VLC_N
#define MAX_VLC_N
Definition: huffyuv.h:50
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:266
HYuvDecContext::bgr32
int bgr32
Definition: huffyuvdec.c:59
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:504
HYuvDecContext::bitstream_buffer_size
unsigned int bitstream_buffer_size
Definition: huffyuvdec.c:79
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:511
w
uint8_t w
Definition: llviddspenc.c:38
AVPacket::data
uint8_t * data
Definition: packet.h:374
huffyuvdsp.h
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:506
HYuvDecContext::n
int n
Definition: huffyuvdec.c:61
add_median_prediction
static void add_median_prediction(HYuvDecContext *s, uint8_t *dst, const uint8_t *src, const uint8_t *diff, int w, int *left, int *left_top)
Definition: huffyuvdec.c:903
b
#define b
Definition: input.c:41
READ_2PIX
#define READ_2PIX(dst0, dst1, plane1)
Definition: huffyuvdec.c:656
classic_add_luma
static const unsigned char classic_add_luma[256]
Definition: huffyuvdec.c:103
R
#define R
Definition: huffyuv.h:44
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:468
FFCodec
Definition: codec_internal.h:127
HYuvDecContext::vlc_n
int vlc_n
Definition: huffyuvdec.c:62
MEDIAN
@ MEDIAN
Definition: huffyuv.h:55
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
decode_init
static av_cold int decode_init(AVCodecContext *avctx)
Definition: huffyuvdec.c:334
UPDATE_CACHE
#define UPDATE_CACHE(name, gb)
Definition: get_bits.h:225
OP8bits
#define OP8bits(dst0, dst1, code)
Definition: huffyuvdec.c:654
OP14bits
#define OP14bits(dst0, dst1, code)
Definition: huffyuvdec.c:695
add_bytes
static void add_bytes(HYuvDecContext *s, uint8_t *dst, uint8_t *src, int w)
Definition: huffyuvdec.c:894
HYuvDecContext::version
int version
Definition: huffyuvdec.c:57
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:507
HYuvDecContext::bits
uint32_t bits[4][MAX_VLC_N]
Definition: huffyuvdec.c:75
init_get_bits
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:514
thread.h
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
skip_bits
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:381
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:503
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:335
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:486
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:205
HYuvDecContext::predictor
Predictor predictor
Definition: huffyuvdec.c:53
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:484
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:513
GetBitContext
Definition: get_bits.h:108
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:466
classic_shift_chroma_table_size
#define classic_shift_chroma_table_size
Definition: huffyuvdec.c:94
ff_huffyuv_alloc_temp
av_cold int ff_huffyuv_alloc_temp(uint8_t *temp[3], uint16_t *temp16[3], int width)
Definition: huffyuv.c:63
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:517
decode_frame
static int decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *avpkt)
Definition: huffyuvdec.c:1223
val
static double val(void *priv, double ch)
Definition: aeval.c:78
av_pix_fmt_get_chroma_sub_sample
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:2992
classic_shift_luma
static const unsigned char classic_shift_luma[classic_shift_luma_table_size+AV_INPUT_BUFFER_PADDING_SIZE]
Definition: huffyuvdec.c:87
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:452
HYuvDecContext::chroma_h_shift
int chroma_h_shift
Definition: huffyuvdec.c:66
HYuvDecContext::temp16
uint16_t * temp16[3]
identical to temp but 16bit type
Definition: huffyuvdec.c:73
LLVidDSPContext
Definition: lossless_videodsp.h:28
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:471
HYuvDecContext::chroma
int chroma
Definition: huffyuvdec.c:64
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
av_cold
#define av_cold
Definition: attributes.h:90
decode_plane_bitstream
static void decode_plane_bitstream(HYuvDecContext *s, int width, int plane)
Definition: huffyuvdec.c:705
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:480
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:545
HYuvDecContext::yuy2
int yuy2
Definition: huffyuvdec.c:58
emms_c
#define emms_c()
Definition: emms.h:63
CLOSE_READER
#define CLOSE_READER(name, gb)
Definition: get_bits.h:188
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:539
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:481
g
const char * g
Definition: vf_curves.c:127
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
bits
uint8_t bits
Definition: vp3data.h:128
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
vlc_init
#define vlc_init(vlc, nb_bits, nb_codes, bits, bits_wrap, bits_size, codes, codes_wrap, codes_size, flags)
Definition: vlc.h:56
B
#define B
Definition: huffyuv.h:42
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:465
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:479
get_bits.h
AV_CODEC_ID_FFVHUFF
@ AV_CODEC_ID_FFVHUFF
Definition: codec_id.h:119
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
ff_huffyuv_common_end
av_cold void ff_huffyuv_common_end(uint8_t *temp[3], uint16_t *temp16[3])
Definition: huffyuv.c:76
read_huffman_tables
static int read_huffman_tables(HYuvDecContext *s, const uint8_t *src, int length)
Definition: huffyuvdec.c:251
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:447
HYuvDecContext::temp
uint8_t * temp[3]
Definition: huffyuvdec.c:72
if
if(ret)
Definition: filter_design.txt:179
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
HYuvDecContext::bitstream_bpp
int bitstream_bpp
Definition: huffyuvdec.c:56
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:487
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
NULL
#define NULL
Definition: coverity.c:32
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
HYuvDecContext::gb
GetBitContext gb
Definition: huffyuvdec.c:52
HYuvDecContext::vlc
VLC vlc[8]
Definition: huffyuvdec.c:77
LAST_SKIP_BITS
#define LAST_SKIP_BITS(name, gb, num)
Definition: get_bits.h:247
ff_huffyuv_generate_bits_table
int ff_huffyuv_generate_bits_table(uint32_t *dst, const uint8_t *len_table, int n)
Definition: huffyuv.c:40
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:469
HYuvDecContext::llviddsp
LLVidDSPContext llviddsp
Definition: huffyuvdec.c:82
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
READ_2PIX_PLANE16
#define READ_2PIX_PLANE16(dst0, dst1, plane)
Definition: huffyuvdec.c:699
HYuvDecContext
Definition: huffyuvdec.c:51
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:483
get_vlc2
static av_always_inline int get_vlc2(GetBitContext *s, const VLCElem *table, int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:652
HYuvDecContext::flags
int flags
Definition: huffyuvdec.c:68
index
int index
Definition: gxfenc.c:89
READ_2PIX_PLANE
#define READ_2PIX_PLANE(dst0, dst1, plane, OP)
Definition: huffyuvdec.c:690
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:314
AVPacket::size
int size
Definition: packet.h:375
codec_internal.h
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:473
AV_NUM_DATA_POINTERS
#define AV_NUM_DATA_POINTERS
Definition: frame.h:341
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:475
decode_end
static av_cold int decode_end(AVCodecContext *avctx)
Definition: huffyuvdec.c:320
LEFT
#define LEFT
Definition: cdgraphics.c:171
diff
static av_always_inline int diff(const struct color_info *a, const struct color_info *b, const int trans_thresh)
Definition: vf_paletteuse.c:164
ff_huffyuvdsp_init
av_cold void ff_huffyuvdsp_init(HuffYUVDSPContext *c, enum AVPixelFormat pix_fmt)
Definition: huffyuvdsp.c:84
OPEN_READER
#define OPEN_READER(name, gb)
Definition: get_bits.h:177
height
#define height
Predictor
Definition: ratecontrol.h:35
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:441
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:167
classic_add_chroma
static const unsigned char classic_add_chroma[256]
Definition: huffyuvdec.c:122
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:508
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
decode_slice
static int decode_slice(AVCodecContext *avctx, AVFrame *p, int height, int buf_size, int y_offset, int table_size)
Definition: huffyuvdec.c:912
ff_vlc_init_sparse
int ff_vlc_init_sparse(VLC *vlc, 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)
Build VLC decoding tables suitable for use with get_vlc2().
Definition: vlc.c:250
HYuvDecContext::interlaced
int interlaced
Definition: huffyuvdec.c:54
HYuvDecContext::bps
int bps
Definition: huffyuvdec.c:60
draw_slice
static void draw_slice(HYuvDecContext *s, AVCodecContext *avctx, AVFrame *frame, int y)
Definition: huffyuvdec.c:857
HYuvDecContext::chroma_v_shift
int chroma_v_shift
Definition: huffyuvdec.c:67
emms.h
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1506
interlaced
uint8_t interlaced
Definition: mxfenc.c:2148
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:244
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:538
ff_hymt_decoder
const FFCodec ff_hymt_decoder
ff_huffyuv_decoder
const FFCodec ff_huffyuv_decoder
Definition: huffyuvdec.c:1306
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:485
HYuvDecContext::pix_bgr_map
uint32_t pix_bgr_map[1<< VLC_BITS]
Definition: huffyuvdec.c:76
av_fast_padded_malloc
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:49
av_always_inline
#define av_always_inline
Definition: attributes.h:49
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:254
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
len
int len
Definition: vorbis_enc_data.h:426
PLANE
@ PLANE
Definition: huffyuv.h:54
decode_gray_bitstream
static void decode_gray_bitstream(HYuvDecContext *s, int count)
Definition: huffyuvdec.c:766
AVCodecContext::height
int height
Definition: avcodec.h:617
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:654
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:467
avcodec.h
limit
static double limit(double x)
Definition: vf_pseudocolor.c:142
ff_vlc_free
void ff_vlc_free(VLC *vlc)
Definition: vlc.c:499
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
AV_PIX_FMT_0RGB32
#define AV_PIX_FMT_0RGB32
Definition: pixfmt.h:445
classic_shift_chroma
static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size+AV_INPUT_BUFFER_PADDING_SIZE]
Definition: huffyuvdec.c:95
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:505
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:472
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
classic_shift_luma_table_size
#define classic_shift_luma_table_size
Definition: huffyuvdec.c:86
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
AVCodecContext::draw_horiz_band
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, 'draw_horiz_band' is called by the libavcodec decoder to draw a horizontal band.
Definition: avcodec.h:679
BITS_LEFT
#define BITS_LEFT(name, gb)
Definition: get_bits.h:239
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:477
left_prediction
static int left_prediction(HYuvDecContext *s, uint8_t *dst, const uint8_t *src, int w, int acc)
Definition: huffyuvdec.c:885
ff_llviddsp_init
void ff_llviddsp_init(LLVidDSPContext *c)
Definition: lossless_videodsp.c:113
AVCodecContext
main external API structure.
Definition: avcodec.h:437
HYuvDecContext::yuv
int yuv
Definition: huffyuvdec.c:65
SHOW_UBITS
#define SHOW_UBITS(name, gb, num)
Definition: get_bits.h:259
HYuvDecContext::len
uint8_t len[4][MAX_VLC_N]
Definition: huffyuvdec.c:74
VLC
Definition: vlc.h:33
sign_extend
static av_const int sign_extend(int val, unsigned bits)
Definition: mathops.h:133
G
#define G
Definition: huffyuv.h:43
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:158
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
lossless_videodsp.h
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:464
decode_422_bitstream
static void decode_422_bitstream(HYuvDecContext *s, int count)
Definition: huffyuvdec.c:661
HYuvDecContext::bdsp
BswapDSPContext bdsp
Definition: huffyuvdec.c:80
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
read_len_table
static int read_len_table(uint8_t *dst, GetBitContext *gb, int n)
Definition: huffyuvdec.c:141
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:617
imgutils.h
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
AV_CODEC_CAP_DRAW_HORIZ_BAND
#define AV_CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: codec.h:44
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
ff_ffvhuff_decoder
const FFCodec ff_ffvhuff_decoder
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
BswapDSPContext
Definition: bswapdsp.h:24
h
h
Definition: vp9dsp_template.c:2038
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:478
av_image_check_size
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:318
huffyuv.h
HYuvDecContext::hdsp
HuffYUVDSPContext hdsp
Definition: huffyuvdec.c:81
HYuvDecContext::decorrelate
int decorrelate
Definition: huffyuvdec.c:55
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:166
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:476
HYuvDecContext::last_slice_end
int last_slice_end
Definition: huffyuvdec.c:70
HYuvDecContext::bitstream_buffer
uint8_t * bitstream_buffer
Definition: huffyuvdec.c:78
Generated on Mon Oct 2 2023 19:21:28 for FFmpeg by   doxygen 1.8.17