FFmpeg
huffyuvenc.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2002-2014 Michael Niedermayer <michaelni@gmx.at>
3  *
4  * see http://www.pcisys.net/~melanson/codecs/huffyuv.txt for a description of
5  * the algorithm used
6  *
7  * This file is part of FFmpeg.
8  *
9  * FFmpeg is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * FFmpeg is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with FFmpeg; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22  *
23  * yuva, gray, 4:4:4, 4:1:1, 4:1:0 and >8 bit per sample support sponsored by NOA
24  */
25 
26 /**
27  * @file
28  * huffyuv encoder
29  */
30 
31 #include "avcodec.h"
32 #include "huffyuv.h"
33 #include "huffman.h"
34 #include "huffyuvencdsp.h"
35 #include "internal.h"
36 #include "lossless_videoencdsp.h"
37 #include "put_bits.h"
38 #include "libavutil/opt.h"
39 #include "libavutil/pixdesc.h"
40 
41 static inline void diff_bytes(HYuvContext *s, uint8_t *dst,
42  const uint8_t *src0, const uint8_t *src1, int w)
43 {
44  if (s->bps <= 8) {
45  s->llvidencdsp.diff_bytes(dst, src0, src1, w);
46  } else {
47  s->hencdsp.diff_int16((uint16_t *)dst, (const uint16_t *)src0, (const uint16_t *)src1, s->n - 1, w);
48  }
49 }
50 
51 static inline int sub_left_prediction(HYuvContext *s, uint8_t *dst,
52  const uint8_t *src, int w, int left)
53 {
54  int i;
55  int min_width = FFMIN(w, 32);
56 
57  if (s->bps <= 8) {
58  for (i = 0; i < min_width; i++) { /* scalar loop before dsp call */
59  const int temp = src[i];
60  dst[i] = temp - left;
61  left = temp;
62  }
63  if (w < 32)
64  return left;
65  s->llvidencdsp.diff_bytes(dst + 32, src + 32, src + 31, w - 32);
66  return src[w-1];
67  } else {
68  const uint16_t *src16 = (const uint16_t *)src;
69  uint16_t *dst16 = ( uint16_t *)dst;
70  for (i = 0; i < min_width; i++) { /* scalar loop before dsp call */
71  const int temp = src16[i];
72  dst16[i] = temp - left;
73  left = temp;
74  }
75  if (w < 32)
76  return left;
77  s->hencdsp.diff_int16(dst16 + 32, src16 + 32, src16 + 31, s->n - 1, w - 32);
78  return src16[w-1];
79  }
80 }
81 
82 static inline void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst,
83  const uint8_t *src, int w,
84  int *red, int *green, int *blue,
85  int *alpha)
86 {
87  int i;
88  int r, g, b, a;
89  int min_width = FFMIN(w, 8);
90  r = *red;
91  g = *green;
92  b = *blue;
93  a = *alpha;
94 
95  for (i = 0; i < min_width; i++) {
96  const int rt = src[i * 4 + R];
97  const int gt = src[i * 4 + G];
98  const int bt = src[i * 4 + B];
99  const int at = src[i * 4 + A];
100  dst[i * 4 + R] = rt - r;
101  dst[i * 4 + G] = gt - g;
102  dst[i * 4 + B] = bt - b;
103  dst[i * 4 + A] = at - a;
104  r = rt;
105  g = gt;
106  b = bt;
107  a = at;
108  }
109 
110  s->llvidencdsp.diff_bytes(dst + 32, src + 32, src + 32 - 4, w * 4 - 32);
111 
112  *red = src[(w - 1) * 4 + R];
113  *green = src[(w - 1) * 4 + G];
114  *blue = src[(w - 1) * 4 + B];
115  *alpha = src[(w - 1) * 4 + A];
116 }
117 
118 static inline void sub_left_prediction_rgb24(HYuvContext *s, uint8_t *dst,
119  uint8_t *src, int w,
120  int *red, int *green, int *blue)
121 {
122  int i;
123  int r, g, b;
124  r = *red;
125  g = *green;
126  b = *blue;
127  for (i = 0; i < FFMIN(w, 16); i++) {
128  const int rt = src[i * 3 + 0];
129  const int gt = src[i * 3 + 1];
130  const int bt = src[i * 3 + 2];
131  dst[i * 3 + 0] = rt - r;
132  dst[i * 3 + 1] = gt - g;
133  dst[i * 3 + 2] = bt - b;
134  r = rt;
135  g = gt;
136  b = bt;
137  }
138 
139  s->llvidencdsp.diff_bytes(dst + 48, src + 48, src + 48 - 3, w * 3 - 48);
140 
141  *red = src[(w - 1) * 3 + 0];
142  *green = src[(w - 1) * 3 + 1];
143  *blue = src[(w - 1) * 3 + 2];
144 }
145 
146 static void sub_median_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w, int *left, int *left_top)
147 {
148  if (s->bps <= 8) {
149  s->llvidencdsp.sub_median_pred(dst, src1, src2, w , left, left_top);
150  } else {
151  s->hencdsp.sub_hfyu_median_pred_int16((uint16_t *)dst, (const uint16_t *)src1, (const uint16_t *)src2, s->n - 1, w , left, left_top);
152  }
153 }
154 
156 {
157  int i;
158  int index = 0;
159  int n = s->vlc_n;
160 
161  for (i = 0; i < n;) {
162  int val = len[i];
163  int repeat = 0;
164 
165  for (; i < n && len[i] == val && repeat < 255; i++)
166  repeat++;
167 
168  av_assert0(val < 32 && val >0 && repeat < 256 && repeat>0);
169  if (repeat > 7) {
170  buf[index++] = val;
171  buf[index++] = repeat;
172  } else {
173  buf[index++] = val | (repeat << 5);
174  }
175  }
176 
177  return index;
178 }
179 
181 {
182  int i, ret;
183  int size = 0;
184  int count = 3;
185 
186  if (s->version > 2)
187  count = 1 + s->alpha + 2*s->chroma;
188 
189  for (i = 0; i < count; i++) {
190  if ((ret = ff_huff_gen_len_table(s->len[i], s->stats[i], s->vlc_n, 0)) < 0)
191  return ret;
192 
193  if (ff_huffyuv_generate_bits_table(s->bits[i], s->len[i], s->vlc_n) < 0) {
194  return -1;
195  }
196 
197  size += store_table(s, s->len[i], buf + size);
198  }
199  return size;
200 }
201 
203 {
204  HYuvContext *s = avctx->priv_data;
205  int i, j;
206  int ret;
208 
209  ff_huffyuv_common_init(avctx);
210  ff_huffyuvencdsp_init(&s->hencdsp, avctx);
212 
213  avctx->extradata = av_mallocz(3*MAX_N + 4);
214  if (s->flags&AV_CODEC_FLAG_PASS1) {
215 #define STATS_OUT_SIZE 21*MAX_N*3 + 4
216  avctx->stats_out = av_mallocz(STATS_OUT_SIZE); // 21*256*3(%llu ) + 3(\n) + 1(0) = 16132
217  if (!avctx->stats_out)
218  return AVERROR(ENOMEM);
219  }
220  s->version = 2;
221 
222  if (!avctx->extradata)
223  return AVERROR(ENOMEM);
224 
225 #if FF_API_CODED_FRAME
228  avctx->coded_frame->key_frame = 1;
230 #endif
231 #if FF_API_PRIVATE_OPT
233  if (avctx->context_model == 1)
234  s->context = avctx->context_model;
236 #endif
237 
238  s->bps = desc->comp[0].depth;
239  s->yuv = !(desc->flags & AV_PIX_FMT_FLAG_RGB) && desc->nb_components >= 2;
240  s->chroma = desc->nb_components > 2;
241  s->alpha = !!(desc->flags & AV_PIX_FMT_FLAG_ALPHA);
243  &s->chroma_h_shift,
244  &s->chroma_v_shift);
245 
246  switch (avctx->pix_fmt) {
247  case AV_PIX_FMT_YUV420P:
248  case AV_PIX_FMT_YUV422P:
249  if (s->width & 1) {
250  av_log(avctx, AV_LOG_ERROR, "Width must be even for this colorspace.\n");
251  return AVERROR(EINVAL);
252  }
253  s->bitstream_bpp = avctx->pix_fmt == AV_PIX_FMT_YUV420P ? 12 : 16;
254  break;
255  case AV_PIX_FMT_YUV444P:
256  case AV_PIX_FMT_YUV410P:
257  case AV_PIX_FMT_YUV411P:
258  case AV_PIX_FMT_YUV440P:
259  case AV_PIX_FMT_GBRP:
260  case AV_PIX_FMT_GBRP9:
261  case AV_PIX_FMT_GBRP10:
262  case AV_PIX_FMT_GBRP12:
263  case AV_PIX_FMT_GBRP14:
264  case AV_PIX_FMT_GBRP16:
265  case AV_PIX_FMT_GRAY8:
266  case AV_PIX_FMT_GRAY16:
267  case AV_PIX_FMT_YUVA444P:
268  case AV_PIX_FMT_YUVA420P:
269  case AV_PIX_FMT_YUVA422P:
270  case AV_PIX_FMT_GBRAP:
271  case AV_PIX_FMT_GRAY8A:
272  case AV_PIX_FMT_YUV420P9:
277  case AV_PIX_FMT_YUV422P9:
282  case AV_PIX_FMT_YUV444P9:
296  s->version = 3;
297  break;
298  case AV_PIX_FMT_RGB32:
299  s->bitstream_bpp = 32;
300  break;
301  case AV_PIX_FMT_RGB24:
302  s->bitstream_bpp = 24;
303  break;
304  default:
305  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
306  return AVERROR(EINVAL);
307  }
308  s->n = 1<<s->bps;
309  s->vlc_n = FFMIN(s->n, MAX_VLC_N);
310 
312  s->decorrelate = s->bitstream_bpp >= 24 && !s->yuv && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
313 #if FF_API_PRIVATE_OPT
315  if (avctx->prediction_method)
316  s->predictor = avctx->prediction_method;
318 #endif
319  s->interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_ME ? 1 : 0;
320  if (s->context) {
322  av_log(avctx, AV_LOG_ERROR,
323  "context=1 is not compatible with "
324  "2 pass huffyuv encoding\n");
325  return AVERROR(EINVAL);
326  }
327  }
328 
329  if (avctx->codec->id == AV_CODEC_ID_HUFFYUV) {
330  if (avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
331  av_log(avctx, AV_LOG_ERROR,
332  "Error: YV12 is not supported by huffyuv; use "
333  "vcodec=ffvhuff or format=422p\n");
334  return AVERROR(EINVAL);
335  }
336 #if FF_API_PRIVATE_OPT
337  if (s->context) {
338  av_log(avctx, AV_LOG_ERROR,
339  "Error: per-frame huffman tables are not supported "
340  "by huffyuv; use vcodec=ffvhuff\n");
341  return AVERROR(EINVAL);
342  }
343  if (s->version > 2) {
344  av_log(avctx, AV_LOG_ERROR,
345  "Error: ver>2 is not supported "
346  "by huffyuv; use vcodec=ffvhuff\n");
347  return AVERROR(EINVAL);
348  }
349 #endif
350  if (s->interlaced != ( s->height > 288 ))
351  av_log(avctx, AV_LOG_INFO,
352  "using huffyuv 2.2.0 or newer interlacing flag\n");
353  }
354 
356  av_log(avctx, AV_LOG_ERROR, "Ver > 3 is under development, files encoded with it may not be decodable with future versions!!!\n"
357  "Use vstrict=-2 / -strict -2 to use it anyway.\n");
358  return AVERROR(EINVAL);
359  }
360 
361  if (s->bitstream_bpp >= 24 && s->predictor == MEDIAN && s->version <= 2) {
362  av_log(avctx, AV_LOG_ERROR,
363  "Error: RGB is incompatible with median predictor\n");
364  return AVERROR(EINVAL);
365  }
366 
367  ((uint8_t*)avctx->extradata)[0] = s->predictor | (s->decorrelate << 6);
368  ((uint8_t*)avctx->extradata)[2] = s->interlaced ? 0x10 : 0x20;
369  if (s->context)
370  ((uint8_t*)avctx->extradata)[2] |= 0x40;
371  if (s->version < 3) {
372  ((uint8_t*)avctx->extradata)[1] = s->bitstream_bpp;
373  ((uint8_t*)avctx->extradata)[3] = 0;
374  } else {
375  ((uint8_t*)avctx->extradata)[1] = ((s->bps-1)<<4) | s->chroma_h_shift | (s->chroma_v_shift<<2);
376  if (s->chroma)
377  ((uint8_t*)avctx->extradata)[2] |= s->yuv ? 1 : 2;
378  if (s->alpha)
379  ((uint8_t*)avctx->extradata)[2] |= 4;
380  ((uint8_t*)avctx->extradata)[3] = 1;
381  }
382  s->avctx->extradata_size = 4;
383 
384  if (avctx->stats_in) {
385  char *p = avctx->stats_in;
386 
387  for (i = 0; i < 4; i++)
388  for (j = 0; j < s->vlc_n; j++)
389  s->stats[i][j] = 1;
390 
391  for (;;) {
392  for (i = 0; i < 4; i++) {
393  char *next;
394 
395  for (j = 0; j < s->vlc_n; j++) {
396  s->stats[i][j] += strtol(p, &next, 0);
397  if (next == p) return -1;
398  p = next;
399  }
400  }
401  if (p[0] == 0 || p[1] == 0 || p[2] == 0) break;
402  }
403  } else {
404  for (i = 0; i < 4; i++)
405  for (j = 0; j < s->vlc_n; j++) {
406  int d = FFMIN(j, s->vlc_n - j);
407 
408  s->stats[i][j] = 100000000 / (d*d + 1);
409  }
410  }
411 
413  if (ret < 0)
414  return ret;
415  s->avctx->extradata_size += ret;
416 
417  if (s->context) {
418  for (i = 0; i < 4; i++) {
419  int pels = s->width * s->height / (i ? 40 : 10);
420  for (j = 0; j < s->vlc_n; j++) {
421  int d = FFMIN(j, s->vlc_n - j);
422  s->stats[i][j] = pels/(d*d + 1);
423  }
424  }
425  } else {
426  for (i = 0; i < 4; i++)
427  for (j = 0; j < s->vlc_n; j++)
428  s->stats[i][j]= 0;
429  }
430 
431  if (ff_huffyuv_alloc_temp(s)) {
433  return AVERROR(ENOMEM);
434  }
435 
436  s->picture_number=0;
437 
438  return 0;
439 }
441 {
442  int i;
443  const uint8_t *y = s->temp[0] + offset;
444  const uint8_t *u = s->temp[1] + offset / 2;
445  const uint8_t *v = s->temp[2] + offset / 2;
446 
447  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 2 * 4 * count) {
448  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
449  return -1;
450  }
451 
452 #define LOAD4\
453  int y0 = y[2 * i];\
454  int y1 = y[2 * i + 1];\
455  int u0 = u[i];\
456  int v0 = v[i];
457 
458  count /= 2;
459 
460  if (s->flags & AV_CODEC_FLAG_PASS1) {
461  for(i = 0; i < count; i++) {
462  LOAD4;
463  s->stats[0][y0]++;
464  s->stats[1][u0]++;
465  s->stats[0][y1]++;
466  s->stats[2][v0]++;
467  }
468  }
470  return 0;
471  if (s->context) {
472  for (i = 0; i < count; i++) {
473  LOAD4;
474  s->stats[0][y0]++;
475  put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
476  s->stats[1][u0]++;
477  put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
478  s->stats[0][y1]++;
479  put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
480  s->stats[2][v0]++;
481  put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
482  }
483  } else {
484  for(i = 0; i < count; i++) {
485  LOAD4;
486  put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
487  put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
488  put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
489  put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
490  }
491  }
492  return 0;
493 }
494 
496 {
497  int i, count = width/2;
498 
499  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < count * s->bps / 2) {
500  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
501  return -1;
502  }
503 
504 #define LOADEND\
505  int y0 = s->temp[0][width-1];
506 #define LOADEND_14\
507  int y0 = s->temp16[0][width-1] & mask;
508 #define LOADEND_16\
509  int y0 = s->temp16[0][width-1];
510 #define STATEND\
511  s->stats[plane][y0]++;
512 #define STATEND_16\
513  s->stats[plane][y0>>2]++;
514 #define WRITEEND\
515  put_bits(&s->pb, s->len[plane][y0], s->bits[plane][y0]);
516 #define WRITEEND_16\
517  put_bits(&s->pb, s->len[plane][y0>>2], s->bits[plane][y0>>2]);\
518  put_bits(&s->pb, 2, y0&3);
519 
520 #define LOAD2\
521  int y0 = s->temp[0][2 * i];\
522  int y1 = s->temp[0][2 * i + 1];
523 #define LOAD2_14\
524  int y0 = s->temp16[0][2 * i] & mask;\
525  int y1 = s->temp16[0][2 * i + 1] & mask;
526 #define LOAD2_16\
527  int y0 = s->temp16[0][2 * i];\
528  int y1 = s->temp16[0][2 * i + 1];
529 #define STAT2\
530  s->stats[plane][y0]++;\
531  s->stats[plane][y1]++;
532 #define STAT2_16\
533  s->stats[plane][y0>>2]++;\
534  s->stats[plane][y1>>2]++;
535 #define WRITE2\
536  put_bits(&s->pb, s->len[plane][y0], s->bits[plane][y0]);\
537  put_bits(&s->pb, s->len[plane][y1], s->bits[plane][y1]);
538 #define WRITE2_16\
539  put_bits(&s->pb, s->len[plane][y0>>2], s->bits[plane][y0>>2]);\
540  put_bits(&s->pb, 2, y0&3);\
541  put_bits(&s->pb, s->len[plane][y1>>2], s->bits[plane][y1>>2]);\
542  put_bits(&s->pb, 2, y1&3);
543 
544  if (s->bps <= 8) {
545  if (s->flags & AV_CODEC_FLAG_PASS1) {
546  for (i = 0; i < count; i++) {
547  LOAD2;
548  STAT2;
549  }
550  if (width&1) {
551  LOADEND;
552  STATEND;
553  }
554  }
556  return 0;
557 
558  if (s->context) {
559  for (i = 0; i < count; i++) {
560  LOAD2;
561  STAT2;
562  WRITE2;
563  }
564  if (width&1) {
565  LOADEND;
566  STATEND;
567  WRITEEND;
568  }
569  } else {
570  for (i = 0; i < count; i++) {
571  LOAD2;
572  WRITE2;
573  }
574  if (width&1) {
575  LOADEND;
576  WRITEEND;
577  }
578  }
579  } else if (s->bps <= 14) {
580  int mask = s->n - 1;
581  if (s->flags & AV_CODEC_FLAG_PASS1) {
582  for (i = 0; i < count; i++) {
583  LOAD2_14;
584  STAT2;
585  }
586  if (width&1) {
587  LOADEND_14;
588  STATEND;
589  }
590  }
592  return 0;
593 
594  if (s->context) {
595  for (i = 0; i < count; i++) {
596  LOAD2_14;
597  STAT2;
598  WRITE2;
599  }
600  if (width&1) {
601  LOADEND_14;
602  STATEND;
603  WRITEEND;
604  }
605  } else {
606  for (i = 0; i < count; i++) {
607  LOAD2_14;
608  WRITE2;
609  }
610  if (width&1) {
611  LOADEND_14;
612  WRITEEND;
613  }
614  }
615  } else {
616  if (s->flags & AV_CODEC_FLAG_PASS1) {
617  for (i = 0; i < count; i++) {
618  LOAD2_16;
619  STAT2_16;
620  }
621  if (width&1) {
622  LOADEND_16;
623  STATEND_16;
624  }
625  }
627  return 0;
628 
629  if (s->context) {
630  for (i = 0; i < count; i++) {
631  LOAD2_16;
632  STAT2_16;
633  WRITE2_16;
634  }
635  if (width&1) {
636  LOADEND_16;
637  STATEND_16;
638  WRITEEND_16;
639  }
640  } else {
641  for (i = 0; i < count; i++) {
642  LOAD2_16;
643  WRITE2_16;
644  }
645  if (width&1) {
646  LOADEND_16;
647  WRITEEND_16;
648  }
649  }
650  }
651 #undef LOAD2
652 #undef STAT2
653 #undef WRITE2
654  return 0;
655 }
656 
658 {
659  int i;
660 
661  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 4 * count) {
662  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
663  return -1;
664  }
665 
666 #define LOAD2\
667  int y0 = s->temp[0][2 * i];\
668  int y1 = s->temp[0][2 * i + 1];
669 #define STAT2\
670  s->stats[0][y0]++;\
671  s->stats[0][y1]++;
672 #define WRITE2\
673  put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
674  put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
675 
676  count /= 2;
677 
678  if (s->flags & AV_CODEC_FLAG_PASS1) {
679  for (i = 0; i < count; i++) {
680  LOAD2;
681  STAT2;
682  }
683  }
685  return 0;
686 
687  if (s->context) {
688  for (i = 0; i < count; i++) {
689  LOAD2;
690  STAT2;
691  WRITE2;
692  }
693  } else {
694  for (i = 0; i < count; i++) {
695  LOAD2;
696  WRITE2;
697  }
698  }
699  return 0;
700 }
701 
702 static inline int encode_bgra_bitstream(HYuvContext *s, int count, int planes)
703 {
704  int i;
705 
706  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
707  4 * planes * count) {
708  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
709  return -1;
710  }
711 
712 #define LOAD_GBRA \
713  int g = s->temp[0][planes == 3 ? 3 * i + 1 : 4 * i + G]; \
714  int b =(s->temp[0][planes == 3 ? 3 * i + 2 : 4 * i + B] - g) & 0xFF;\
715  int r =(s->temp[0][planes == 3 ? 3 * i + 0 : 4 * i + R] - g) & 0xFF;\
716  int a = s->temp[0][planes * i + A];
717 
718 #define STAT_BGRA \
719  s->stats[0][b]++; \
720  s->stats[1][g]++; \
721  s->stats[2][r]++; \
722  if (planes == 4) \
723  s->stats[2][a]++;
724 
725 #define WRITE_GBRA \
726  put_bits(&s->pb, s->len[1][g], s->bits[1][g]); \
727  put_bits(&s->pb, s->len[0][b], s->bits[0][b]); \
728  put_bits(&s->pb, s->len[2][r], s->bits[2][r]); \
729  if (planes == 4) \
730  put_bits(&s->pb, s->len[2][a], s->bits[2][a]);
731 
732  if ((s->flags & AV_CODEC_FLAG_PASS1) &&
734  for (i = 0; i < count; i++) {
735  LOAD_GBRA;
736  STAT_BGRA;
737  }
738  } else if (s->context || (s->flags & AV_CODEC_FLAG_PASS1)) {
739  for (i = 0; i < count; i++) {
740  LOAD_GBRA;
741  STAT_BGRA;
742  WRITE_GBRA;
743  }
744  } else {
745  for (i = 0; i < count; i++) {
746  LOAD_GBRA;
747  WRITE_GBRA;
748  }
749  }
750  return 0;
751 }
752 
754  const AVFrame *pict, int *got_packet)
755 {
756  HYuvContext *s = avctx->priv_data;
757  const int width = s->width;
758  const int width2 = s->width>>1;
759  const int height = s->height;
760  const int fake_ystride = s->interlaced ? pict->linesize[0]*2 : pict->linesize[0];
761  const int fake_ustride = s->interlaced ? pict->linesize[1]*2 : pict->linesize[1];
762  const int fake_vstride = s->interlaced ? pict->linesize[2]*2 : pict->linesize[2];
763  const AVFrame * const p = pict;
764  int i, j, size = 0, ret;
765 
766  if ((ret = ff_alloc_packet2(avctx, pkt, width * height * 3 * 4 + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
767  return ret;
768 
769  if (s->context) {
770  size = store_huffman_tables(s, pkt->data);
771  if (size < 0)
772  return size;
773 
774  for (i = 0; i < 4; i++)
775  for (j = 0; j < s->vlc_n; j++)
776  s->stats[i][j] >>= 1;
777  }
778 
779  init_put_bits(&s->pb, pkt->data + size, pkt->size - size);
780 
781  if (avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
782  avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
783  int lefty, leftu, leftv, y, cy;
784 
785  put_bits(&s->pb, 8, leftv = p->data[2][0]);
786  put_bits(&s->pb, 8, lefty = p->data[0][1]);
787  put_bits(&s->pb, 8, leftu = p->data[1][0]);
788  put_bits(&s->pb, 8, p->data[0][0]);
789 
790  lefty = sub_left_prediction(s, s->temp[0], p->data[0], width , 0);
791  leftu = sub_left_prediction(s, s->temp[1], p->data[1], width2, 0);
792  leftv = sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);
793 
794  encode_422_bitstream(s, 2, width-2);
795 
796  if (s->predictor==MEDIAN) {
797  int lefttopy, lefttopu, lefttopv;
798  cy = y = 1;
799  if (s->interlaced) {
800  lefty = sub_left_prediction(s, s->temp[0], p->data[0] + p->linesize[0], width , lefty);
801  leftu = sub_left_prediction(s, s->temp[1], p->data[1] + p->linesize[1], width2, leftu);
802  leftv = sub_left_prediction(s, s->temp[2], p->data[2] + p->linesize[2], width2, leftv);
803 
804  encode_422_bitstream(s, 0, width);
805  y++; cy++;
806  }
807 
808  lefty = sub_left_prediction(s, s->temp[0], p->data[0] + fake_ystride, 4, lefty);
809  leftu = sub_left_prediction(s, s->temp[1], p->data[1] + fake_ustride, 2, leftu);
810  leftv = sub_left_prediction(s, s->temp[2], p->data[2] + fake_vstride, 2, leftv);
811 
812  encode_422_bitstream(s, 0, 4);
813 
814  lefttopy = p->data[0][3];
815  lefttopu = p->data[1][1];
816  lefttopv = p->data[2][1];
817  s->llvidencdsp.sub_median_pred(s->temp[0], p->data[0] + 4, p->data[0] + fake_ystride + 4, width - 4, &lefty, &lefttopy);
818  s->llvidencdsp.sub_median_pred(s->temp[1], p->data[1] + 2, p->data[1] + fake_ustride + 2, width2 - 2, &leftu, &lefttopu);
819  s->llvidencdsp.sub_median_pred(s->temp[2], p->data[2] + 2, p->data[2] + fake_vstride + 2, width2 - 2, &leftv, &lefttopv);
820  encode_422_bitstream(s, 0, width - 4);
821  y++; cy++;
822 
823  for (; y < height; y++,cy++) {
824  uint8_t *ydst, *udst, *vdst;
825 
826  if (s->bitstream_bpp == 12) {
827  while (2 * cy > y) {
828  ydst = p->data[0] + p->linesize[0] * y;
829  s->llvidencdsp.sub_median_pred(s->temp[0], ydst - fake_ystride, ydst, width, &lefty, &lefttopy);
830  encode_gray_bitstream(s, width);
831  y++;
832  }
833  if (y >= height) break;
834  }
835  ydst = p->data[0] + p->linesize[0] * y;
836  udst = p->data[1] + p->linesize[1] * cy;
837  vdst = p->data[2] + p->linesize[2] * cy;
838 
839  s->llvidencdsp.sub_median_pred(s->temp[0], ydst - fake_ystride, ydst, width, &lefty, &lefttopy);
840  s->llvidencdsp.sub_median_pred(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
841  s->llvidencdsp.sub_median_pred(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
842 
843  encode_422_bitstream(s, 0, width);
844  }
845  } else {
846  for (cy = y = 1; y < height; y++, cy++) {
847  uint8_t *ydst, *udst, *vdst;
848 
849  /* encode a luma only line & y++ */
850  if (s->bitstream_bpp == 12) {
851  ydst = p->data[0] + p->linesize[0] * y;
852 
853  if (s->predictor == PLANE && s->interlaced < y) {
854  s->llvidencdsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
855 
856  lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
857  } else {
858  lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
859  }
860  encode_gray_bitstream(s, width);
861  y++;
862  if (y >= height) break;
863  }
864 
865  ydst = p->data[0] + p->linesize[0] * y;
866  udst = p->data[1] + p->linesize[1] * cy;
867  vdst = p->data[2] + p->linesize[2] * cy;
868 
869  if (s->predictor == PLANE && s->interlaced < cy) {
870  s->llvidencdsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
871  s->llvidencdsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
872  s->llvidencdsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
873 
874  lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
875  leftu = sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
876  leftv = sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
877  } else {
878  lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
879  leftu = sub_left_prediction(s, s->temp[1], udst, width2, leftu);
880  leftv = sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
881  }
882 
883  encode_422_bitstream(s, 0, width);
884  }
885  }
886  } else if(avctx->pix_fmt == AV_PIX_FMT_RGB32) {
887  uint8_t *data = p->data[0] + (height - 1) * p->linesize[0];
888  const int stride = -p->linesize[0];
889  const int fake_stride = -fake_ystride;
890  int y;
891  int leftr, leftg, leftb, lefta;
892 
893  put_bits(&s->pb, 8, lefta = data[A]);
894  put_bits(&s->pb, 8, leftr = data[R]);
895  put_bits(&s->pb, 8, leftg = data[G]);
896  put_bits(&s->pb, 8, leftb = data[B]);
897 
898  sub_left_prediction_bgr32(s, s->temp[0], data + 4, width - 1,
899  &leftr, &leftg, &leftb, &lefta);
900  encode_bgra_bitstream(s, width - 1, 4);
901 
902  for (y = 1; y < s->height; y++) {
903  uint8_t *dst = data + y*stride;
904  if (s->predictor == PLANE && s->interlaced < y) {
905  s->llvidencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width * 4);
906  sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width,
907  &leftr, &leftg, &leftb, &lefta);
908  } else {
909  sub_left_prediction_bgr32(s, s->temp[0], dst, width,
910  &leftr, &leftg, &leftb, &lefta);
911  }
912  encode_bgra_bitstream(s, width, 4);
913  }
914  } else if (avctx->pix_fmt == AV_PIX_FMT_RGB24) {
915  uint8_t *data = p->data[0] + (height - 1) * p->linesize[0];
916  const int stride = -p->linesize[0];
917  const int fake_stride = -fake_ystride;
918  int y;
919  int leftr, leftg, leftb;
920 
921  put_bits(&s->pb, 8, leftr = data[0]);
922  put_bits(&s->pb, 8, leftg = data[1]);
923  put_bits(&s->pb, 8, leftb = data[2]);
924  put_bits(&s->pb, 8, 0);
925 
926  sub_left_prediction_rgb24(s, s->temp[0], data + 3, width - 1,
927  &leftr, &leftg, &leftb);
928  encode_bgra_bitstream(s, width-1, 3);
929 
930  for (y = 1; y < s->height; y++) {
931  uint8_t *dst = data + y * stride;
932  if (s->predictor == PLANE && s->interlaced < y) {
933  s->llvidencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride,
934  width * 3);
935  sub_left_prediction_rgb24(s, s->temp[0], s->temp[1], width,
936  &leftr, &leftg, &leftb);
937  } else {
938  sub_left_prediction_rgb24(s, s->temp[0], dst, width,
939  &leftr, &leftg, &leftb);
940  }
941  encode_bgra_bitstream(s, width, 3);
942  }
943  } else if (s->version > 2) {
944  int plane;
945  for (plane = 0; plane < 1 + 2*s->chroma + s->alpha; plane++) {
946  int left, y;
947  int w = width;
948  int h = height;
949  int fake_stride = fake_ystride;
950 
951  if (s->chroma && (plane == 1 || plane == 2)) {
952  w >>= s->chroma_h_shift;
953  h >>= s->chroma_v_shift;
954  fake_stride = plane == 1 ? fake_ustride : fake_vstride;
955  }
956 
957  left = sub_left_prediction(s, s->temp[0], p->data[plane], w , 0);
958 
959  encode_plane_bitstream(s, w, plane);
960 
961  if (s->predictor==MEDIAN) {
962  int lefttop;
963  y = 1;
964  if (s->interlaced) {
965  left = sub_left_prediction(s, s->temp[0], p->data[plane] + p->linesize[plane], w , left);
966 
967  encode_plane_bitstream(s, w, plane);
968  y++;
969  }
970 
971  lefttop = p->data[plane][0];
972 
973  for (; y < h; y++) {
974  uint8_t *dst = p->data[plane] + p->linesize[plane] * y;
975 
976  sub_median_prediction(s, s->temp[0], dst - fake_stride, dst, w , &left, &lefttop);
977 
978  encode_plane_bitstream(s, w, plane);
979  }
980  } else {
981  for (y = 1; y < h; y++) {
982  uint8_t *dst = p->data[plane] + p->linesize[plane] * y;
983 
984  if (s->predictor == PLANE && s->interlaced < y) {
985  diff_bytes(s, s->temp[1], dst, dst - fake_stride, w);
986 
987  left = sub_left_prediction(s, s->temp[0], s->temp[1], w , left);
988  } else {
989  left = sub_left_prediction(s, s->temp[0], dst, w , left);
990  }
991 
992  encode_plane_bitstream(s, w, plane);
993  }
994  }
995  }
996  } else {
997  av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
998  }
999  emms_c();
1000 
1001  size += (put_bits_count(&s->pb) + 31) / 8;
1002  put_bits(&s->pb, 16, 0);
1003  put_bits(&s->pb, 15, 0);
1004  size /= 4;
1005 
1006  if ((s->flags & AV_CODEC_FLAG_PASS1) && (s->picture_number & 31) == 0) {
1007  int j;
1008  char *p = avctx->stats_out;
1009  char *end = p + STATS_OUT_SIZE;
1010  for (i = 0; i < 4; i++) {
1011  for (j = 0; j < s->vlc_n; j++) {
1012  snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1013  p += strlen(p);
1014  s->stats[i][j]= 0;
1015  }
1016  snprintf(p, end-p, "\n");
1017  p++;
1018  if (end <= p)
1019  return AVERROR(ENOMEM);
1020  }
1021  } else if (avctx->stats_out)
1022  avctx->stats_out[0] = '\0';
1023  if (!(s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT)) {
1024  flush_put_bits(&s->pb);
1025  s->bdsp.bswap_buf((uint32_t *) pkt->data, (uint32_t *) pkt->data, size);
1026  }
1027 
1028  s->picture_number++;
1029 
1030  pkt->size = size * 4;
1031  pkt->flags |= AV_PKT_FLAG_KEY;
1032  *got_packet = 1;
1033 
1034  return 0;
1035 }
1036 
1038 {
1039  HYuvContext *s = avctx->priv_data;
1040 
1042 
1043  av_freep(&avctx->extradata);
1044  av_freep(&avctx->stats_out);
1045 
1046  return 0;
1047 }
1048 
1049 #define OFFSET(x) offsetof(HYuvContext, x)
1050 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1051 
1052 #define COMMON_OPTIONS \
1053  { "non_deterministic", "Allow multithreading for e.g. context=1 at the expense of determinism", \
1054  OFFSET(non_determ), AV_OPT_TYPE_BOOL, { .i64 = 1 }, \
1055  0, 1, VE }, \
1056  { "pred", "Prediction method", OFFSET(predictor), AV_OPT_TYPE_INT, { .i64 = LEFT }, LEFT, MEDIAN, VE, "pred" }, \
1057  { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LEFT }, INT_MIN, INT_MAX, VE, "pred" }, \
1058  { "plane", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PLANE }, INT_MIN, INT_MAX, VE, "pred" }, \
1059  { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MEDIAN }, INT_MIN, INT_MAX, VE, "pred" }, \
1060 
1061 static const AVOption normal_options[] = {
1063  { NULL },
1064 };
1065 
1066 static const AVOption ff_options[] = {
1068  { "context", "Set per-frame huffman tables", OFFSET(context), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
1069  { NULL },
1070 };
1071 
1072 static const AVClass normal_class = {
1073  .class_name = "huffyuv",
1074  .item_name = av_default_item_name,
1075  .option = normal_options,
1076  .version = LIBAVUTIL_VERSION_INT,
1077 };
1078 
1079 static const AVClass ff_class = {
1080  .class_name = "ffvhuff",
1081  .item_name = av_default_item_name,
1082  .option = ff_options,
1083  .version = LIBAVUTIL_VERSION_INT,
1084 };
1085 
1087  .name = "huffyuv",
1088  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1089  .type = AVMEDIA_TYPE_VIDEO,
1090  .id = AV_CODEC_ID_HUFFYUV,
1091  .priv_data_size = sizeof(HYuvContext),
1092  .init = encode_init,
1093  .encode2 = encode_frame,
1094  .close = encode_end,
1096  .priv_class = &normal_class,
1097  .pix_fmts = (const enum AVPixelFormat[]){
1100  },
1101  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1103 };
1104 
1105 #if CONFIG_FFVHUFF_ENCODER
1107  .name = "ffvhuff",
1108  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1109  .type = AVMEDIA_TYPE_VIDEO,
1110  .id = AV_CODEC_ID_FFVHUFF,
1111  .priv_data_size = sizeof(HYuvContext),
1112  .init = encode_init,
1113  .encode2 = encode_frame,
1114  .close = encode_end,
1116  .priv_class = &ff_class,
1117  .pix_fmts = (const enum AVPixelFormat[]){
1134  },
1135  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1137 };
1138 #endif
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:48
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:917
int plane
Definition: avisynth_c.h:384
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2629
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:1574
const char const char void * val
Definition: avisynth_c.h:863
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:430
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:422
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
This structure describes decoded (raw) audio or video data.
Definition: frame.h:268
static av_cold int encode_init(AVCodecContext *avctx)
Definition: huffyuvenc.c:202
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:424
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:397
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:425
int bitstream_bpp
Definition: huffyuv.h:63
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
#define STATEND
else temp
Definition: vf_mcdeint.c:256
const char * g
Definition: vf_curves.c:115
const char * desc
Definition: nvenc.c:68
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
int size
Definition: avcodec.h:1478
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:403
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
static int encode_plane_bitstream(HYuvContext *s, int width, int plane)
Definition: huffyuvenc.c:495
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2588
#define MAX_VLC_N
Definition: huffyuv.h:47
int context
Definition: huffyuv.h:77
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
GLfloat v0
Definition: opengl_enc.c:106
static AVPacket pkt
#define src
Definition: vp8dsp.c:254
LLVidEncDSPContext llvidencdsp
Definition: huffyuv.h:93
AVCodec.
Definition: avcodec.h:3477
int height
Definition: huffyuv.h:75
#define AV_CODEC_CAP_INTRA_ONLY
Codec is intra only.
Definition: avcodec.h:1067
#define LOAD_GBRA
av_cold void ff_huffyuvencdsp_init(HuffYUVEncDSPContext *c, AVCodecContext *avctx)
Definition: huffyuvencdsp.c:71
av_cold void ff_llvidencdsp_init(LLVidEncDSPContext *c)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:40
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
uint8_t
#define av_cold
Definition: attributes.h:82
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:177
AVOptions.
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
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
#define STATEND_16
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int bps
Definition: huffyuv.h:67
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:253
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:421
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:402
static void sub_median_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src1, const uint8_t *src2, int w, int *left, int *left_top)
Definition: huffyuvenc.c:146
void(* diff_bytes)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, intptr_t w)
#define height
uint8_t * data
Definition: avcodec.h:1477
attribute_deprecated int context_model
Definition: avcodec.h:2484
#define STATS_OUT_SIZE
int vlc_n
Definition: huffyuv.h:69
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:400
static void sub_left_prediction_rgb24(HYuvContext *s, uint8_t *dst, uint8_t *src, int w, int *red, int *green, int *blue)
Definition: huffyuvenc.c:118
void(* sub_hfyu_median_pred_int16)(uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w, int *left, int *left_top)
Definition: huffyuvencdsp.h:32
ptrdiff_t size
Definition: opengl_enc.c:100
int chroma_h_shift
Definition: huffyuv.h:73
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2785
#define LOAD2
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2580
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:429
#define A(x)
Definition: vp56_arith.h:28
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
Definition: avcodec.h:797
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
static const struct @309 planes[]
uint8_t len[4][MAX_VLC_N]
Definition: huffyuv.h:83
#define MAX_N
Definition: huffyuv.h:46
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: huffyuvenc.c:753
#define LOAD2_14
av_cold int ff_huffyuv_alloc_temp(HYuvContext *s)
Definition: huffyuv.c:58
enum AVCodecID id
Definition: avcodec.h:3491
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:260
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void(* sub_median_pred)(uint8_t *dst, const uint8_t *src1, const uint8_t *src2, intptr_t w, int *left, int *left_top)
Subtract HuffYUV&#39;s variant of median prediction.
#define R
Definition: huffyuvdsp.h:34
int chroma_v_shift
Definition: huffyuv.h:74
Definition: huffyuv.h:51
av_cold void ff_huffyuv_common_end(HYuvContext *s)
Definition: huffyuv.c:86
AVCodec ff_ffvhuff_encoder
static const uint16_t mask[17]
Definition: lzw.c:38
int flags
Definition: huffyuv.h:76
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:148
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:2550
#define B
Definition: huffyuvdsp.h:32
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:186
const char * r
Definition: vf_curves.c:114
static const AVClass ff_class
Definition: huffyuvenc.c:1079
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:431
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
uint8_t * buf
Definition: put_bits.h:38
const char * name
Name of the codec implementation.
Definition: avcodec.h:3484
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
static const AVClass normal_class
Definition: huffyuvenc.c:1072
int chroma
Definition: huffyuv.h:71
GLsizei count
Definition: opengl_enc.c:108
#define COMMON_OPTIONS
Definition: huffyuvenc.c:1052
huffyuv codec for libavcodec.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1037
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define WRITE_GBRA
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:385
uint8_t nb_components
The number of components each pixel has, (1-4)
Definition: pixdesc.h:83
#define b
Definition: input.c:41
#define WRITE2
int decorrelate
Definition: huffyuv.h:62
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:351
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:406
alias for AV_PIX_FMT_YA8
Definition: pixfmt.h:146
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:371
#define FFMIN(a, b)
Definition: common.h:96
int width
Definition: huffyuv.h:75
AVCodec ff_huffyuv_encoder
Definition: huffyuvenc.c:1086
void(* diff_int16)(uint16_t *dst, const uint16_t *src1, const uint16_t *src2, unsigned mask, int w)
Definition: huffyuvencdsp.h:27
#define width
uint8_t w
Definition: llviddspenc.c:38
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:871
int ff_huffyuv_generate_bits_table(uint32_t *dst, const uint8_t *len_table, int n)
Definition: huffyuv.c:39
#define s(width, name)
Definition: cbs_vp9.c:257
int n
Definition: avisynth_c.h:760
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:426
uint8_t * temp[3]
Definition: huffyuv.h:80
static av_cold int encode_end(AVCodecContext *avctx)
Definition: huffyuvenc.c:1037
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:405
int alpha
Definition: huffyuv.h:70
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:398
#define src1
Definition: h264pred.c:139
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:395
int picture_number
Definition: huffyuv.h:78
int ff_huff_gen_len_table(uint8_t *dst, const uint64_t *stats, int stats_size, int skip0)
Definition: huffman.c:58
static int sub_left_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int left)
Definition: huffyuvenc.c:51
Libavcodec external API header.
static int encode_422_bitstream(HYuvContext *s, int offset, int count)
Definition: huffyuvenc.c:440
attribute_deprecated int prediction_method
Definition: avcodec.h:1924
int yuv
Definition: huffyuv.h:72
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:299
static const AVOption ff_options[]
Definition: huffyuvenc.c:1066
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
static const int16_t alpha[]
Definition: ilbcdata.h:55
main external API structure.
Definition: avcodec.h:1565
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:360
#define STAT2
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:206
uint8_t * buf_end
Definition: put_bits.h:38
void * buf
Definition: avisynth_c.h:766
int interlaced
Definition: huffyuv.h:61
int extradata_size
Definition: avcodec.h:1667
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
Describe the class of an AVClass context structure.
Definition: log.h:67
int index
Definition: gxfenc.c:89
#define WRITEEND
huffman tree builder and VLC generator
#define STAT2_16
#define src0
Definition: h264pred.c:138
static int encode_bgra_bitstream(HYuvContext *s, int count, int planes)
Definition: huffyuvenc.c:702
#define LOAD4
#define STAT_BGRA
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:384
#define snprintf
Definition: snprintf.h:34
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:396
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:404
HuffYUVEncDSPContext hencdsp
Definition: huffyuv.h:91
int version
Definition: huffyuv.h:64
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:394
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:282
Predictor predictor
Definition: huffyuv.h:58
static void diff_bytes(HYuvContext *s, uint8_t *dst, const uint8_t *src0, const uint8_t *src1, int w)
Definition: huffyuvenc.c:41
AVCodecContext * avctx
Definition: huffyuv.h:57
#define WRITE2_16
GLint GLenum GLboolean GLsizei stride
Definition: opengl_enc.c:104
PutBitContext pb
Definition: huffyuv.h:60
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
Definition: huffyuv.h:52
#define OFFSET(x)
Definition: huffyuvenc.c:1049
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
static int store_huffman_tables(HYuvContext *s, uint8_t *buf)
Definition: huffyuvenc.c:180
#define VE
Definition: huffyuvenc.c:1050
#define G
Definition: huffyuvdsp.h:33
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf)
Definition: huffyuvenc.c:155
#define LOAD2_16
#define AV_CODEC_FLAG2_NO_OUTPUT
Skip bitstream encoding.
Definition: avcodec.h:927
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:423
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2811
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
static int encode_gray_bitstream(HYuvContext *s, int count)
Definition: huffyuvenc.c:657
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
static void sub_left_prediction_bgr32(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int *red, int *green, int *blue, int *alpha)
Definition: huffyuvenc.c:82
av_cold void ff_huffyuv_common_init(AVCodecContext *avctx)
Definition: huffyuv.c:71
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:875
void * priv_data
Definition: avcodec.h:1592
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int len
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:346
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1652
#define WRITEEND_16
#define LOADEND_16
#define av_freep(p)
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
#define LOADEND
uint32_t bits[4][MAX_VLC_N]
Definition: huffyuv.h:84
uint64_t stats[4][MAX_VLC_N]
Definition: huffyuv.h:82
#define stride
static const AVOption normal_options[]
Definition: huffyuvenc.c:1061
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
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 default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your local context
int depth
Number of bits in the component.
Definition: pixdesc.h:58
#define LOADEND_14
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
This structure stores compressed data.
Definition: avcodec.h:1454
BswapDSPContext bdsp
Definition: huffyuv.h:89
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:144
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2624
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:399
for(j=16;j >0;--j)
bitstream writer API