Libav
huffyuvdec.c
Go to the documentation of this file.
1 /*
2  * huffyuv decoder
3  *
4  * Copyright (c) 2002-2003 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 Libav.
10  *
11  * Libav 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  * Libav 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 Libav; if not, write to the Free Software
23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
24  */
25 
31 #include "avcodec.h"
32 #include "get_bits.h"
33 #include "huffyuv.h"
34 #include "huffyuvdsp.h"
35 #include "thread.h"
36 
37 #define classic_shift_luma_table_size 42
39  34, 36, 35, 69, 135, 232, 9, 16, 10, 24, 11, 23, 12, 16, 13, 10,
40  14, 8, 15, 8, 16, 8, 17, 20, 16, 10, 207, 206, 205, 236, 11, 8,
41  10, 21, 9, 23, 8, 8, 199, 70, 69, 68, 0
42 };
43 
44 #define classic_shift_chroma_table_size 59
46  66, 36, 37, 38, 39, 40, 41, 75, 76, 77, 110, 239, 144, 81, 82, 83,
47  84, 85, 118, 183, 56, 57, 88, 89, 56, 89, 154, 57, 58, 57, 26, 141,
48  57, 56, 58, 57, 58, 57, 184, 119, 214, 245, 116, 83, 82, 49, 80, 79,
49  78, 77, 44, 75, 41, 40, 39, 38, 37, 36, 34, 0
50 };
51 
52 static const unsigned char classic_add_luma[256] = {
53  3, 9, 5, 12, 10, 35, 32, 29, 27, 50, 48, 45, 44, 41, 39, 37,
54  73, 70, 68, 65, 64, 61, 58, 56, 53, 50, 49, 46, 44, 41, 38, 36,
55  68, 65, 63, 61, 58, 55, 53, 51, 48, 46, 45, 43, 41, 39, 38, 36,
56  35, 33, 32, 30, 29, 27, 26, 25, 48, 47, 46, 44, 43, 41, 40, 39,
57  37, 36, 35, 34, 32, 31, 30, 28, 27, 26, 24, 23, 22, 20, 19, 37,
58  35, 34, 33, 31, 30, 29, 27, 26, 24, 23, 21, 20, 18, 17, 15, 29,
59  27, 26, 24, 22, 21, 19, 17, 16, 14, 26, 25, 23, 21, 19, 18, 16,
60  15, 27, 25, 23, 21, 19, 17, 16, 14, 26, 25, 23, 21, 18, 17, 14,
61  12, 17, 19, 13, 4, 9, 2, 11, 1, 7, 8, 0, 16, 3, 14, 6,
62  12, 10, 5, 15, 18, 11, 10, 13, 15, 16, 19, 20, 22, 24, 27, 15,
63  18, 20, 22, 24, 26, 14, 17, 20, 22, 24, 27, 15, 18, 20, 23, 25,
64  28, 16, 19, 22, 25, 28, 32, 36, 21, 25, 29, 33, 38, 42, 45, 49,
65  28, 31, 34, 37, 40, 42, 44, 47, 49, 50, 52, 54, 56, 57, 59, 60,
66  62, 64, 66, 67, 69, 35, 37, 39, 40, 42, 43, 45, 47, 48, 51, 52,
67  54, 55, 57, 59, 60, 62, 63, 66, 67, 69, 71, 72, 38, 40, 42, 43,
68  46, 47, 49, 51, 26, 28, 30, 31, 33, 34, 18, 19, 11, 13, 7, 8,
69 };
70 
71 static const unsigned char classic_add_chroma[256] = {
72  3, 1, 2, 2, 2, 2, 3, 3, 7, 5, 7, 5, 8, 6, 11, 9,
73  7, 13, 11, 10, 9, 8, 7, 5, 9, 7, 6, 4, 7, 5, 8, 7,
74  11, 8, 13, 11, 19, 15, 22, 23, 20, 33, 32, 28, 27, 29, 51, 77,
75  43, 45, 76, 81, 46, 82, 75, 55, 56, 144, 58, 80, 60, 74, 147, 63,
76  143, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79,
77  80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 27, 30, 21, 22,
78  17, 14, 5, 6, 100, 54, 47, 50, 51, 53, 106, 107, 108, 109, 110, 111,
79  112, 113, 114, 115, 4, 117, 118, 92, 94, 121, 122, 3, 124, 103, 2, 1,
80  0, 129, 130, 131, 120, 119, 126, 125, 136, 137, 138, 139, 140, 141, 142, 134,
81  135, 132, 133, 104, 64, 101, 62, 57, 102, 95, 93, 59, 61, 28, 97, 96,
82  52, 49, 48, 29, 32, 25, 24, 46, 23, 98, 45, 44, 43, 20, 42, 41,
83  19, 18, 99, 40, 15, 39, 38, 16, 13, 12, 11, 37, 10, 9, 8, 36,
84  7, 128, 127, 105, 123, 116, 35, 34, 33, 145, 31, 79, 42, 146, 78, 26,
85  83, 48, 49, 50, 44, 47, 26, 31, 30, 18, 17, 19, 21, 24, 25, 13,
86  14, 16, 17, 18, 20, 21, 12, 14, 15, 9, 10, 6, 9, 6, 5, 8,
87  6, 12, 8, 10, 7, 9, 6, 4, 6, 2, 2, 3, 3, 3, 3, 2,
88 };
89 
90 static int read_len_table(uint8_t *dst, GetBitContext *gb)
91 {
92  int i, val, repeat;
93 
94  for (i = 0; i < 256;) {
95  repeat = get_bits(gb, 3);
96  val = get_bits(gb, 5);
97  if (repeat == 0)
98  repeat = get_bits(gb, 8);
99  if (i + repeat > 256 || get_bits_left(gb) < 0) {
100  av_log(NULL, AV_LOG_ERROR, "Error reading huffman table\n");
101  return AVERROR_INVALIDDATA;
102  }
103  while (repeat--)
104  dst[i++] = val;
105  }
106  return 0;
107 }
108 
110 {
111  uint16_t symbols[1 << VLC_BITS];
112  uint16_t bits[1 << VLC_BITS];
113  uint8_t len[1 << VLC_BITS];
114  int ret;
115 
116  if (s->bitstream_bpp < 24) {
117  int p, i, y, u;
118  for (p = 0; p < 3; p++) {
119  for (i = y = 0; y < 256; y++) {
120  int len0 = s->len[0][y];
121  int limit = VLC_BITS - len0;
122  if (limit <= 0)
123  continue;
124  for (u = 0; u < 256; u++) {
125  int len1 = s->len[p][u];
126  if (len1 > limit)
127  continue;
128  len[i] = len0 + len1;
129  bits[i] = (s->bits[0][y] << len1) + s->bits[p][u];
130  symbols[i] = (y << 8) + u;
131  if (symbols[i] != 0xffff) // reserved to mean "invalid"
132  i++;
133  }
134  }
135  ff_free_vlc(&s->vlc[3 + p]);
136  if ((ret = ff_init_vlc_sparse(&s->vlc[3 + p], VLC_BITS, i, len, 1, 1,
137  bits, 2, 2, symbols, 2, 2, 0)) < 0)
138  return ret;
139  }
140  } else {
141  uint8_t (*map)[4] = (uint8_t(*)[4]) s->pix_bgr_map;
142  int i, b, g, r, code;
143  int p0 = s->decorrelate;
144  int p1 = !s->decorrelate;
145  /* Restrict the range to +/-16 because that's pretty much guaranteed
146  * to cover all the combinations that fit in 11 bits total, and it
147  * does not matter if we miss a few rare codes. */
148  for (i = 0, g = -16; g < 16; g++) {
149  int len0 = s->len[p0][g & 255];
150  int limit0 = VLC_BITS - len0;
151  if (limit0 < 2)
152  continue;
153  for (b = -16; b < 16; b++) {
154  int len1 = s->len[p1][b & 255];
155  int limit1 = limit0 - len1;
156  if (limit1 < 1)
157  continue;
158  code = (s->bits[p0][g & 255] << len1) + s->bits[p1][b & 255];
159  for (r = -16; r < 16; r++) {
160  int len2 = s->len[2][r & 255];
161  if (len2 > limit1)
162  continue;
163  len[i] = len0 + len1 + len2;
164  bits[i] = (code << len2) + s->bits[2][r & 255];
165  if (s->decorrelate) {
166  map[i][G] = g;
167  map[i][B] = g + b;
168  map[i][R] = g + r;
169  } else {
170  map[i][B] = g;
171  map[i][G] = b;
172  map[i][R] = r;
173  }
174  i++;
175  }
176  }
177  }
178  ff_free_vlc(&s->vlc[3]);
179  if ((ret = init_vlc(&s->vlc[3], VLC_BITS, i, len, 1, 1,
180  bits, 2, 2, 0)) < 0)
181  return ret;
182  }
183  return 0;
184 }
185 
186 static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length)
187 {
188  GetBitContext gb;
189  int i, ret;
190 
191  if ((ret = init_get_bits(&gb, src, length * 8)) < 0)
192  return ret;
193 
194  for (i = 0; i < 3; i++) {
195  if ((ret = read_len_table(s->len[i], &gb)) < 0)
196  return ret;
197  if ((ret = ff_huffyuv_generate_bits_table(s->bits[i], s->len[i])) < 0)
198  return ret;
199  ff_free_vlc(&s->vlc[i]);
200  if ((ret = init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
201  s->bits[i], 4, 4, 0)) < 0)
202  return ret;
203  }
204 
205  if ((ret = generate_joint_tables(s)) < 0)
206  return ret;
207 
208  return (get_bits_count(&gb) + 7) / 8;
209 }
210 
212 {
213  GetBitContext gb;
214  int i, ret;
215 
216  if ((ret = init_get_bits(&gb, classic_shift_luma,
218  return ret;
219  if ((ret = read_len_table(s->len[0], &gb)) < 0)
220  return ret;
221 
222  if ((ret = init_get_bits(&gb, classic_shift_chroma,
224  return ret;
225  if ((ret = read_len_table(s->len[1], &gb)) < 0)
226  return ret;
227 
228  for (i = 0; i < 256; i++)
229  s->bits[0][i] = classic_add_luma[i];
230  for (i = 0; i < 256; i++)
231  s->bits[1][i] = classic_add_chroma[i];
232 
233  if (s->bitstream_bpp >= 24) {
234  memcpy(s->bits[1], s->bits[0], 256 * sizeof(uint32_t));
235  memcpy(s->len[1], s->len[0], 256 * sizeof(uint8_t));
236  }
237  memcpy(s->bits[2], s->bits[1], 256 * sizeof(uint32_t));
238  memcpy(s->len[2], s->len[1], 256 * sizeof(uint8_t));
239 
240  for (i = 0; i < 3; i++) {
241  ff_free_vlc(&s->vlc[i]);
242  if ((ret = init_vlc(&s->vlc[i], VLC_BITS, 256, s->len[i], 1, 1,
243  s->bits[i], 4, 4, 0)) < 0)
244  return ret;
245  }
246 
247  if ((ret = generate_joint_tables(s)) < 0)
248  return ret;
249 
250  return 0;
251 }
252 
254 {
255  HYuvContext *s = avctx->priv_data;
256  int ret;
257 
258  ff_huffyuv_common_init(avctx);
260  memset(s->vlc, 0, 3 * sizeof(VLC));
261 
262  s->interlaced = s->height > 288;
263  s->bgr32 = 1;
264 
265  if (avctx->extradata_size) {
266  if ((avctx->bits_per_coded_sample & 7) &&
267  avctx->bits_per_coded_sample != 12)
268  s->version = 1; // do such files exist at all?
269  else
270  s->version = 2;
271  } else
272  s->version = 0;
273 
274  if (s->version == 2) {
275  int method, interlace;
276 
277  if (avctx->extradata_size < 4)
278  return AVERROR_INVALIDDATA;
279 
280  method = avctx->extradata[0];
281  s->decorrelate = method & 64 ? 1 : 0;
282  s->predictor = method & 63;
283  s->bitstream_bpp = avctx->extradata[1];
284  if (s->bitstream_bpp == 0)
285  s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
286  interlace = (avctx->extradata[2] & 0x30) >> 4;
287  s->interlaced = (interlace == 1) ? 1 : (interlace == 2) ? 0 : s->interlaced;
288  s->context = avctx->extradata[2] & 0x40 ? 1 : 0;
289 
290  if ((ret = read_huffman_tables(s, avctx->extradata + 4,
291  avctx->extradata_size - 4)) < 0)
292  return ret;
293  } else {
294  switch (avctx->bits_per_coded_sample & 7) {
295  case 1:
296  s->predictor = LEFT;
297  s->decorrelate = 0;
298  break;
299  case 2:
300  s->predictor = LEFT;
301  s->decorrelate = 1;
302  break;
303  case 3:
304  s->predictor = PLANE;
305  s->decorrelate = avctx->bits_per_coded_sample >= 24;
306  break;
307  case 4:
308  s->predictor = MEDIAN;
309  s->decorrelate = 0;
310  break;
311  default:
312  s->predictor = LEFT; // OLD
313  s->decorrelate = 0;
314  break;
315  }
316  s->bitstream_bpp = avctx->bits_per_coded_sample & ~7;
317  s->context = 0;
318 
319  if ((ret = read_old_huffman_tables(s)) < 0)
320  return ret;
321  }
322 
323  switch (s->bitstream_bpp) {
324  case 12:
325  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
326  break;
327  case 16:
328  if (s->yuy2)
329  avctx->pix_fmt = AV_PIX_FMT_YUYV422;
330  else
331  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
332  break;
333  case 24:
334  case 32:
335  if (s->bgr32)
336  avctx->pix_fmt = AV_PIX_FMT_RGB32;
337  else
338  avctx->pix_fmt = AV_PIX_FMT_BGR24;
339  break;
340  default:
341  return AVERROR_INVALIDDATA;
342  }
343 
344  if (s->predictor == MEDIAN && avctx->pix_fmt == AV_PIX_FMT_YUV422P &&
345  avctx->width % 4) {
346  av_log(avctx, AV_LOG_ERROR, "width must be multiple of 4 "
347  "for this combination of colorspace and predictor type.\n");
348  return AVERROR_INVALIDDATA;
349  }
350 
351  if ((ret = ff_huffyuv_alloc_temp(s)) < 0)
352  return ret;
353 
354  return 0;
355 }
356 
358 {
359  HYuvContext *s = avctx->priv_data;
360  int i, ret;
361 
362  if ((ret = ff_huffyuv_alloc_temp(s)) < 0)
363  return ret;
364 
365  for (i = 0; i < 6; i++)
366  s->vlc[i].table = NULL;
367 
368  if (s->version == 2) {
369  if ((ret = read_huffman_tables(s, avctx->extradata + 4,
370  avctx->extradata_size)) < 0)
371  return ret;
372  } else {
373  if ((ret = read_old_huffman_tables(s)) < 0)
374  return ret;
375  }
376 
377  return 0;
378 }
379 
380 /* TODO instead of restarting the read when the code isn't in the first level
381  * of the joint table, jump into the 2nd level of the individual table. */
382 #define READ_2PIX(dst0, dst1, plane1) \
383  { \
384  uint16_t code = get_vlc2(&s->gb, s->vlc[3 + plane1].table, \
385  VLC_BITS, 1); \
386  if (code != 0xffff) { \
387  dst0 = code >> 8; \
388  dst1 = code; \
389  } else { \
390  dst0 = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3); \
391  dst1 = get_vlc2(&s->gb, s->vlc[plane1].table, VLC_BITS, 3); \
392  } \
393  }
394 
395 static void decode_422_bitstream(HYuvContext *s, int count)
396 {
397  int i;
398 
399  count /= 2;
400 
401  if (count >= (get_bits_left(&s->gb)) / (31 * 4)) {
402  for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
403  READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1);
404  READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
405  }
406  } else {
407  for (i = 0; i < count; i++) {
408  READ_2PIX(s->temp[0][2 * i], s->temp[1][i], 1);
409  READ_2PIX(s->temp[0][2 * i + 1], s->temp[2][i], 2);
410  }
411  }
412 }
413 
414 static void decode_gray_bitstream(HYuvContext *s, int count)
415 {
416  int i;
417 
418  count /= 2;
419 
420  if (count >= (get_bits_left(&s->gb)) / (31 * 2)) {
421  for (i = 0; i < count && get_bits_left(&s->gb) > 0; i++) {
422  READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
423  }
424  } else {
425  for (i = 0; i < count; i++) {
426  READ_2PIX(s->temp[0][2 * i], s->temp[0][2 * i + 1], 0);
427  }
428  }
429 }
430 
431 static av_always_inline void decode_bgr_1(HYuvContext *s, int count,
432  int decorrelate, int alpha)
433 {
434  int i;
435  for (i = 0; i < count; i++) {
436  int code = get_vlc2(&s->gb, s->vlc[3].table, VLC_BITS, 1);
437  if (code != -1) {
438  *(uint32_t *) &s->temp[0][4 * i] = s->pix_bgr_map[code];
439  } else if (decorrelate) {
440  s->temp[0][4 * i + G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
441  s->temp[0][4 * i + B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3) +
442  s->temp[0][4 * i + G];
443  s->temp[0][4 * i + R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3) +
444  s->temp[0][4 * i + G];
445  } else {
446  s->temp[0][4 * i + B] = get_vlc2(&s->gb, s->vlc[0].table, VLC_BITS, 3);
447  s->temp[0][4 * i + G] = get_vlc2(&s->gb, s->vlc[1].table, VLC_BITS, 3);
448  s->temp[0][4 * i + R] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
449  }
450  if (alpha)
451  s->temp[0][4 * i + A] = get_vlc2(&s->gb, s->vlc[2].table, VLC_BITS, 3);
452  }
453 }
454 
455 static void decode_bgr_bitstream(HYuvContext *s, int count)
456 {
457  if (s->decorrelate) {
458  if (s->bitstream_bpp == 24)
459  decode_bgr_1(s, count, 1, 0);
460  else
461  decode_bgr_1(s, count, 1, 1);
462  } else {
463  if (s->bitstream_bpp == 24)
464  decode_bgr_1(s, count, 0, 0);
465  else
466  decode_bgr_1(s, count, 0, 1);
467  }
468 }
469 
470 static void draw_slice(HYuvContext *s, AVFrame *frame, int y)
471 {
472  int h, cy, i;
473  int offset[AV_NUM_DATA_POINTERS];
474 
475  if (!s->avctx->draw_horiz_band)
476  return;
477 
478  h = y - s->last_slice_end;
479  y -= h;
480 
481  if (s->bitstream_bpp == 12)
482  cy = y >> 1;
483  else
484  cy = y;
485 
486  offset[0] = frame->linesize[0] * y;
487  offset[1] = frame->linesize[1] * cy;
488  offset[2] = frame->linesize[2] * cy;
489  for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
490  offset[i] = 0;
491  emms_c();
492 
493  s->avctx->draw_horiz_band(s->avctx, frame, offset, y, 3, h);
494 
495  s->last_slice_end = y + h;
496 }
497 
498 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
499  AVPacket *avpkt)
500 {
501  const uint8_t *buf = avpkt->data;
502  int buf_size = avpkt->size;
503  HYuvContext *s = avctx->priv_data;
504  const int width = s->width;
505  const int width2 = s->width >> 1;
506  const int height = s->height;
507  int fake_ystride, fake_ustride, fake_vstride;
508  ThreadFrame frame = { .f = data };
509  AVFrame *const p = data;
510  int table_size = 0, ret;
511 
514  buf_size + FF_INPUT_BUFFER_PADDING_SIZE);
515  if (!s->bitstream_buffer)
516  return AVERROR(ENOMEM);
517 
518  memset(s->bitstream_buffer + buf_size, 0, FF_INPUT_BUFFER_PADDING_SIZE);
519  s->bdsp.bswap_buf((uint32_t *) s->bitstream_buffer,
520  (const uint32_t *) buf, buf_size / 4);
521 
522  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0) {
523  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
524  return ret;
525  }
526 
527  if (s->context) {
528  table_size = read_huffman_tables(s, s->bitstream_buffer, buf_size);
529  if (table_size < 0)
530  return table_size;
531  }
532 
533  if ((unsigned) (buf_size - table_size) >= INT_MAX / 8)
534  return AVERROR_INVALIDDATA;
535 
536  if ((ret = init_get_bits(&s->gb, s->bitstream_buffer + table_size,
537  (buf_size - table_size) * 8)) < 0)
538  return ret;
539 
540  fake_ystride = s->interlaced ? p->linesize[0] * 2 : p->linesize[0];
541  fake_ustride = s->interlaced ? p->linesize[1] * 2 : p->linesize[1];
542  fake_vstride = s->interlaced ? p->linesize[2] * 2 : p->linesize[2];
543 
544  s->last_slice_end = 0;
545 
546  if (s->bitstream_bpp < 24) {
547  int y, cy;
548  int lefty, leftu, leftv;
549  int lefttopy, lefttopu, lefttopv;
550 
551  if (s->yuy2) {
552  p->data[0][3] = get_bits(&s->gb, 8);
553  p->data[0][2] = get_bits(&s->gb, 8);
554  p->data[0][1] = get_bits(&s->gb, 8);
555  p->data[0][0] = get_bits(&s->gb, 8);
556 
557  avpriv_report_missing_feature(avctx, "YUY2 output");
558  return AVERROR_PATCHWELCOME;
559  } else {
560  leftv =
561  p->data[2][0] = get_bits(&s->gb, 8);
562  lefty =
563  p->data[0][1] = get_bits(&s->gb, 8);
564  leftu =
565  p->data[1][0] = get_bits(&s->gb, 8);
566  p->data[0][0] = get_bits(&s->gb, 8);
567 
568  switch (s->predictor) {
569  case LEFT:
570  case PLANE:
571  decode_422_bitstream(s, width - 2);
572  lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + 2, s->temp[0],
573  width - 2, lefty);
574  if (!(s->flags & CODEC_FLAG_GRAY)) {
575  leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
576  leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
577  }
578 
579  for (cy = y = 1; y < s->height; y++, cy++) {
580  uint8_t *ydst, *udst, *vdst;
581 
582  if (s->bitstream_bpp == 12) {
583  decode_gray_bitstream(s, width);
584 
585  ydst = p->data[0] + p->linesize[0] * y;
586 
587  lefty = s->hdsp.add_hfyu_left_pred(ydst, s->temp[0],
588  width, lefty);
589  if (s->predictor == PLANE) {
590  if (y > s->interlaced)
591  s->hdsp.add_bytes(ydst, ydst - fake_ystride, width);
592  }
593  y++;
594  if (y >= s->height)
595  break;
596  }
597 
598  draw_slice(s, p, y);
599 
600  ydst = p->data[0] + p->linesize[0] * y;
601  udst = p->data[1] + p->linesize[1] * cy;
602  vdst = p->data[2] + p->linesize[2] * cy;
603 
604  decode_422_bitstream(s, width);
605  lefty = s->hdsp.add_hfyu_left_pred(ydst, s->temp[0],
606  width, lefty);
607  if (!(s->flags & CODEC_FLAG_GRAY)) {
608  leftu = s->hdsp.add_hfyu_left_pred(udst, s->temp[1], width2, leftu);
609  leftv = s->hdsp.add_hfyu_left_pred(vdst, s->temp[2], width2, leftv);
610  }
611  if (s->predictor == PLANE) {
612  if (cy > s->interlaced) {
613  s->hdsp.add_bytes(ydst, ydst - fake_ystride, width);
614  if (!(s->flags & CODEC_FLAG_GRAY)) {
615  s->hdsp.add_bytes(udst, udst - fake_ustride, width2);
616  s->hdsp.add_bytes(vdst, vdst - fake_vstride, width2);
617  }
618  }
619  }
620  }
621  draw_slice(s, p, height);
622 
623  break;
624  case MEDIAN:
625  /* first line except first 2 pixels is left predicted */
626  decode_422_bitstream(s, width - 2);
627  lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + 2, s->temp[0],
628  width - 2, lefty);
629  if (!(s->flags & CODEC_FLAG_GRAY)) {
630  leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + 1, s->temp[1], width2 - 1, leftu);
631  leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + 1, s->temp[2], width2 - 1, leftv);
632  }
633 
634  cy = y = 1;
635 
636  /* second line is left predicted for interlaced case */
637  if (s->interlaced) {
638  decode_422_bitstream(s, width);
639  lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + p->linesize[0],
640  s->temp[0], width, lefty);
641  if (!(s->flags & CODEC_FLAG_GRAY)) {
642  leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + p->linesize[2], s->temp[1], width2, leftu);
643  leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + p->linesize[1], s->temp[2], width2, leftv);
644  }
645  y++;
646  cy++;
647  }
648 
649  /* next 4 pixels are left predicted too */
650  decode_422_bitstream(s, 4);
651  lefty = s->hdsp.add_hfyu_left_pred(p->data[0] + fake_ystride,
652  s->temp[0], 4, lefty);
653  if (!(s->flags & CODEC_FLAG_GRAY)) {
654  leftu = s->hdsp.add_hfyu_left_pred(p->data[1] + fake_ustride, s->temp[1], 2, leftu);
655  leftv = s->hdsp.add_hfyu_left_pred(p->data[2] + fake_vstride, s->temp[2], 2, leftv);
656  }
657 
658  /* next line except the first 4 pixels is median predicted */
659  lefttopy = p->data[0][3];
660  decode_422_bitstream(s, width - 4);
661  s->hdsp.add_hfyu_median_pred(p->data[0] + fake_ystride + 4,
662  p->data[0] + 4, s->temp[0],
663  width - 4, &lefty, &lefttopy);
664  if (!(s->flags & CODEC_FLAG_GRAY)) {
665  lefttopu = p->data[1][1];
666  lefttopv = p->data[2][1];
667  s->hdsp.add_hfyu_median_pred(p->data[1] + fake_ustride + 2, p->data[1] + 2, s->temp[1], width2 - 2, &leftu, &lefttopu);
668  s->hdsp.add_hfyu_median_pred(p->data[2] + fake_vstride + 2, p->data[2] + 2, s->temp[2], width2 - 2, &leftv, &lefttopv);
669  }
670  y++;
671  cy++;
672 
673  for (; y < height; y++, cy++) {
674  uint8_t *ydst, *udst, *vdst;
675 
676  if (s->bitstream_bpp == 12) {
677  while (2 * cy > y) {
678  decode_gray_bitstream(s, width);
679  ydst = p->data[0] + p->linesize[0] * y;
680  s->hdsp.add_hfyu_median_pred(ydst, ydst - fake_ystride,
681  s->temp[0], width,
682  &lefty, &lefttopy);
683  y++;
684  }
685  if (y >= height)
686  break;
687  }
688  draw_slice(s, p, y);
689 
690  decode_422_bitstream(s, width);
691 
692  ydst = p->data[0] + p->linesize[0] * y;
693  udst = p->data[1] + p->linesize[1] * cy;
694  vdst = p->data[2] + p->linesize[2] * cy;
695 
696  s->hdsp.add_hfyu_median_pred(ydst, ydst - fake_ystride,
697  s->temp[0], width,
698  &lefty, &lefttopy);
699  if (!(s->flags & CODEC_FLAG_GRAY)) {
700  s->hdsp.add_hfyu_median_pred(udst, udst - fake_ustride, s->temp[1], width2, &leftu, &lefttopu);
701  s->hdsp.add_hfyu_median_pred(vdst, vdst - fake_vstride, s->temp[2], width2, &leftv, &lefttopv);
702  }
703  }
704 
705  draw_slice(s, p, height);
706  break;
707  }
708  }
709  } else {
710  int y;
711  int leftr, leftg, leftb, lefta;
712  const int last_line = (height - 1) * p->linesize[0];
713 
714  if (s->bitstream_bpp == 32) {
715  lefta = p->data[0][last_line + A] = get_bits(&s->gb, 8);
716  leftr = p->data[0][last_line + R] = get_bits(&s->gb, 8);
717  leftg = p->data[0][last_line + G] = get_bits(&s->gb, 8);
718  leftb = p->data[0][last_line + B] = get_bits(&s->gb, 8);
719  } else {
720  leftr = p->data[0][last_line + R] = get_bits(&s->gb, 8);
721  leftg = p->data[0][last_line + G] = get_bits(&s->gb, 8);
722  leftb = p->data[0][last_line + B] = get_bits(&s->gb, 8);
723  lefta = p->data[0][last_line + A] = 255;
724  skip_bits(&s->gb, 8);
725  }
726 
727  if (s->bgr32) {
728  switch (s->predictor) {
729  case LEFT:
730  case PLANE:
731  decode_bgr_bitstream(s, width - 1);
732  s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + last_line + 4,
733  s->temp[0], width - 1, &leftr,
734  &leftg, &leftb, &lefta);
735 
736  for (y = s->height - 2; y >= 0; y--) { // Yes it is stored upside down.
737  decode_bgr_bitstream(s, width);
738 
739  s->hdsp.add_hfyu_left_pred_bgr32(p->data[0] + p->linesize[0] * y,
740  s->temp[0], width, &leftr,
741  &leftg, &leftb, &lefta);
742  if (s->predictor == PLANE) {
743  if (s->bitstream_bpp != 32)
744  lefta = 0;
745  if ((y & s->interlaced) == 0 &&
746  y < s->height - 1 - s->interlaced) {
747  s->hdsp.add_bytes(p->data[0] + p->linesize[0] * y,
748  p->data[0] + p->linesize[0] * y +
749  fake_ystride, fake_ystride);
750  }
751  }
752  }
753  // just 1 large slice as this is not possible in reverse order
754  draw_slice(s, p, height);
755  break;
756  default:
757  av_log(avctx, AV_LOG_ERROR,
758  "prediction type not supported!\n");
759  }
760  } else {
761  avpriv_report_missing_feature(avctx, "BGR24 output");
762  return AVERROR_PATCHWELCOME;
763  }
764  }
765  emms_c();
766 
767  *got_frame = 1;
768 
769  return (get_bits_count(&s->gb) + 31) / 32 * 4 + table_size;
770 }
771 
773 {
774  HYuvContext *s = avctx->priv_data;
775  int i;
776 
779 
780  for (i = 0; i < 6; i++)
781  ff_free_vlc(&s->vlc[i]);
782 
783  return 0;
784 }
785 
787  .name = "huffyuv",
788  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
789  .type = AVMEDIA_TYPE_VIDEO,
790  .id = AV_CODEC_ID_HUFFYUV,
791  .priv_data_size = sizeof(HYuvContext),
792  .init = decode_init,
793  .close = decode_end,
794  .decode = decode_frame,
795  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |
798 };
799 
800 #if CONFIG_FFVHUFF_DECODER
801 AVCodec ff_ffvhuff_decoder = {
802  .name = "ffvhuff",
803  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
804  .type = AVMEDIA_TYPE_VIDEO,
805  .id = AV_CODEC_ID_FFVHUFF,
806  .priv_data_size = sizeof(HYuvContext),
807  .init = decode_init,
808  .close = decode_end,
809  .decode = decode_frame,
810  .capabilities = CODEC_CAP_DR1 | CODEC_CAP_DRAW_HORIZ_BAND |
813 };
814 #endif /* CONFIG_FFVHUFF_DECODER */
#define G
Definition: huffyuv.h:50
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:54
#define AV_NUM_DATA_POINTERS
Definition: frame.h:136
This structure describes decoded (raw) audio or video data.
Definition: frame.h:135
void(* add_bytes)(uint8_t *dst, uint8_t *src, int w)
Definition: huffyuvdsp.h:25
int yuy2
Definition: huffyuv.h:70
int bitstream_bpp
Definition: huffyuv.h:68
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:240
AVFrame * f
Definition: thread.h:36
#define R
Definition: huffyuv.h:51
static void decode_422_bitstream(HYuvContext *s, int count)
Definition: huffyuvdec.c:395
int size
Definition: avcodec.h:974
static av_always_inline void decode_bgr_1(HYuvContext *s, int count, int decorrelate, int alpha)
Definition: huffyuvdec.c:431
#define VLC_BITS
Definition: asvdec.c:38
av_cold void ff_huffyuvdsp_init(HuffYUVDSPContext *c)
Definition: huffyuvdsp.c:123
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1254
static int read_len_table(uint8_t *dst, GetBitContext *gb)
Definition: huffyuvdec.c:90
static av_cold int decode_init_thread_copy(AVCodecContext *avctx)
Definition: huffyuvdec.c:357
int context
Definition: huffyuv.h:74
unsigned int bitstream_buffer_size
Definition: huffyuv.h:84
void ff_huffyuv_common_end(HYuvContext *s)
Definition: huffyuv.c:90
static int generate_joint_tables(HYuvContext *s)
Definition: huffyuvdec.c:109
AVCodec.
Definition: avcodec.h:2796
int height
Definition: huffyuv.h:72
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:1288
uint8_t len[3][256]
Definition: huffyuv.h:79
#define READ_2PIX(dst0, dst1, plane1)
Definition: huffyuvdec.c:382
static int read_old_huffman_tables(HYuvContext *s)
Definition: huffyuvdec.c:211
static void draw_slice(HYuvContext *s, AVFrame *frame, int y)
Definition: huffyuvdec.c:470
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
static int decode(MimicContext *ctx, int quality, int num_coeffs, int is_iframe)
Definition: mimic.c:275
uint32_t pix_bgr_map[1<< VLC_BITS]
Definition: huffyuv.h:81
int ff_init_vlc_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)
Definition: bitstream.c:266
uint8_t bits
Definition: crc.c:251
uint8_t
#define av_cold
Definition: attributes.h:66
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
static void decode_bgr_bitstream(HYuvContext *s, int count)
Definition: huffyuvdec.c:455
Multithreading support functions.
#define b
Definition: input.c:52
#define emms_c()
Definition: internal.h:47
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1164
void(* add_hfyu_median_pred)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, int w, int *left, int *left_top)
Definition: huffyuvdsp.h:27
VLC vlc[6]
Definition: huffyuv.h:82
#define CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:684
const char data[16]
Definition: mxf.c:70
uint8_t * data
Definition: avcodec.h:973
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:194
bitstream reader API header.
#define B
Definition: huffyuv.h:49
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2507
#define r
Definition: input.c:51
av_cold int ff_huffyuv_alloc_temp(HYuvContext *s)
Definition: huffyuv.c:58
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:555
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
Definition: huffyuv.h:57
static const unsigned char classic_add_luma[256]
Definition: huffyuvdec.c:52
#define AVERROR(e)
Definition: error.h:43
uint8_t * bitstream_buffer
Definition: huffyuv.h:83
int flags
Definition: huffyuv.h:73
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:150
g
Definition: yuv2rgb.c:535
int bgr32
Definition: huffyuv.h:71
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:169
const char * name
Name of the codec implementation.
Definition: avcodec.h:2803
huffyuv codec for libavcodec.
#define classic_shift_chroma_table_size
Definition: huffyuvdec.c:44
Definition: get_bits.h:64
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:69
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:190
uint32_t bits[3][256]
Definition: huffyuv.h:80
static const unsigned char classic_shift_luma[classic_shift_luma_table_size+FF_INPUT_BUFFER_PADDING_SIZE]
Definition: huffyuvdec.c:38
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:531
int decorrelate
Definition: huffyuv.h:67
#define CODEC_CAP_DRAW_HORIZ_BAND
Decoder can use draw_horiz_band callback.
Definition: avcodec.h:678
int width
Definition: huffyuv.h:72
int last_slice_end
Definition: huffyuv.h:76
int width
picture width / height.
Definition: avcodec.h:1224
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:522
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:68
uint8_t * temp[3]
Definition: huffyuv.h:77
int(* add_hfyu_left_pred)(uint8_t *dst, const uint8_t *src, int w, int left)
Definition: huffyuvdsp.h:30
static const unsigned char classic_shift_chroma[classic_shift_chroma_table_size+FF_INPUT_BUFFER_PADDING_SIZE]
Definition: huffyuvdec.c:45
static int decorrelate(TAKDecContext *s, int c1, int c2, int length)
Definition: takdec.c:555
Definition: vf_drawbox.c:37
if(ac->has_optimized_func)
#define AVERROR_PATCHWELCOME
Not yet implemented in Libav, patches welcome.
Definition: error.h:57
NULL
Definition: eval.c:55
static int width
Definition: utils.c:156
AVCodec ff_huffyuv_decoder
Definition: huffyuvdec.c:786
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:153
HuffYUVDSPContext hdsp
Definition: huffyuv.h:86
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:1050
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:490
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:222
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:66
#define init_vlc(vlc, nb_bits, nb_codes,bits, bits_wrap, bits_size,codes, codes_wrap, codes_size,flags)
Definition: get_bits.h:424
int interlaced
Definition: huffyuv.h:66
int extradata_size
Definition: avcodec.h:1165
static void skip_bits(GetBitContext *s, int n)
Definition: get_bits.h:263
static int init_get_bits(GetBitContext *s, const uint8_t *buffer, int bit_size)
Initialize GetBitContext.
Definition: get_bits.h:375
static void decode_gray_bitstream(HYuvContext *s, int count)
Definition: huffyuvdec.c:414
#define classic_shift_luma_table_size
Definition: huffyuvdec.c:37
void avpriv_report_missing_feature(void *avc, const char *msg,...) av_printf_format(2
Log a generic warning message about a missing feature.
int version
Definition: huffyuv.h:69
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:141
Predictor predictor
Definition: huffyuv.h:63
static av_cold int decode_init(AVCodecContext *avctx)
Definition: huffyuvdec.c:253
int height
Definition: gxfenc.c:72
AVCodecContext * avctx
Definition: huffyuv.h:62
GetBitContext gb
Definition: huffyuv.h:64
void(* add_hfyu_left_pred_bgr32)(uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue, int *alpha)
Definition: huffyuvdsp.h:32
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:388
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:65
Definition: huffyuv.h:58
#define CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:755
#define CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:637
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: huffyuvdec.c:498
static av_cold int init(AVCodecParserContext *s)
Definition: h264_parser.c:499
av_cold void ff_huffyuv_common_init(AVCodecContext *avctx)
Definition: huffyuv.c:76
static av_cold int decode_end(AVCodecContext *avctx)
Definition: huffyuvdec.c:772
void * priv_data
Definition: avcodec.h:1092
int len
static const unsigned char classic_add_chroma[256]
Definition: huffyuvdec.c:71
VLC_TYPE(* table)[2]
code, bits
Definition: get_bits.h:66
#define av_always_inline
Definition: attributes.h:40
#define LEFT
Definition: cdgraphics.c:163
This structure stores compressed data.
Definition: avcodec.h:950
BswapDSPContext bdsp
Definition: huffyuv.h:85
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:333
static int read_huffman_tables(HYuvContext *s, const uint8_t *src, int length)
Definition: huffyuvdec.c:186
for(j=16;j >0;--j)
int ff_huffyuv_generate_bits_table(uint32_t *dst, const uint8_t *len_table)
Definition: huffyuv.c:39