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