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