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_YUV420P9:
276  case AV_PIX_FMT_YUV422P9:
281  case AV_PIX_FMT_YUV444P9:
295  s->version = 3;
296  break;
297  case AV_PIX_FMT_RGB32:
298  s->bitstream_bpp = 32;
299  break;
300  case AV_PIX_FMT_RGB24:
301  s->bitstream_bpp = 24;
302  break;
303  default:
304  av_log(avctx, AV_LOG_ERROR, "format not supported\n");
305  return AVERROR(EINVAL);
306  }
307  s->n = 1<<s->bps;
308  s->vlc_n = FFMIN(s->n, MAX_VLC_N);
309 
311  s->decorrelate = s->bitstream_bpp >= 24 && !s->yuv && !(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
312 #if FF_API_PRIVATE_OPT
314  if (avctx->prediction_method)
315  s->predictor = avctx->prediction_method;
317 #endif
318  s->interlaced = avctx->flags & AV_CODEC_FLAG_INTERLACED_ME ? 1 : 0;
319  if (s->context) {
321  av_log(avctx, AV_LOG_ERROR,
322  "context=1 is not compatible with "
323  "2 pass huffyuv encoding\n");
324  return AVERROR(EINVAL);
325  }
326  }
327 
328  if (avctx->codec->id == AV_CODEC_ID_HUFFYUV) {
329  if (avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
330  av_log(avctx, AV_LOG_ERROR,
331  "Error: YV12 is not supported by huffyuv; use "
332  "vcodec=ffvhuff or format=422p\n");
333  return AVERROR(EINVAL);
334  }
335 #if FF_API_PRIVATE_OPT
336  if (s->context) {
337  av_log(avctx, AV_LOG_ERROR,
338  "Error: per-frame huffman tables are not supported "
339  "by huffyuv; use vcodec=ffvhuff\n");
340  return AVERROR(EINVAL);
341  }
342  if (s->version > 2) {
343  av_log(avctx, AV_LOG_ERROR,
344  "Error: ver>2 is not supported "
345  "by huffyuv; use vcodec=ffvhuff\n");
346  return AVERROR(EINVAL);
347  }
348 #endif
349  if (s->interlaced != ( s->height > 288 ))
350  av_log(avctx, AV_LOG_INFO,
351  "using huffyuv 2.2.0 or newer interlacing flag\n");
352  }
353 
355  av_log(avctx, AV_LOG_ERROR, "Ver > 3 is under development, files encoded with it may not be decodable with future versions!!!\n"
356  "Use vstrict=-2 / -strict -2 to use it anyway.\n");
357  return AVERROR(EINVAL);
358  }
359 
360  if (s->bitstream_bpp >= 24 && s->predictor == MEDIAN && s->version <= 2) {
361  av_log(avctx, AV_LOG_ERROR,
362  "Error: RGB is incompatible with median predictor\n");
363  return AVERROR(EINVAL);
364  }
365 
366  ((uint8_t*)avctx->extradata)[0] = s->predictor | (s->decorrelate << 6);
367  ((uint8_t*)avctx->extradata)[2] = s->interlaced ? 0x10 : 0x20;
368  if (s->context)
369  ((uint8_t*)avctx->extradata)[2] |= 0x40;
370  if (s->version < 3) {
371  ((uint8_t*)avctx->extradata)[1] = s->bitstream_bpp;
372  ((uint8_t*)avctx->extradata)[3] = 0;
373  } else {
374  ((uint8_t*)avctx->extradata)[1] = ((s->bps-1)<<4) | s->chroma_h_shift | (s->chroma_v_shift<<2);
375  if (s->chroma)
376  ((uint8_t*)avctx->extradata)[2] |= s->yuv ? 1 : 2;
377  if (s->alpha)
378  ((uint8_t*)avctx->extradata)[2] |= 4;
379  ((uint8_t*)avctx->extradata)[3] = 1;
380  }
381  s->avctx->extradata_size = 4;
382 
383  if (avctx->stats_in) {
384  char *p = avctx->stats_in;
385 
386  for (i = 0; i < 4; i++)
387  for (j = 0; j < s->vlc_n; j++)
388  s->stats[i][j] = 1;
389 
390  for (;;) {
391  for (i = 0; i < 4; i++) {
392  char *next;
393 
394  for (j = 0; j < s->vlc_n; j++) {
395  s->stats[i][j] += strtol(p, &next, 0);
396  if (next == p) return -1;
397  p = next;
398  }
399  }
400  if (p[0] == 0 || p[1] == 0 || p[2] == 0) break;
401  }
402  } else {
403  for (i = 0; i < 4; i++)
404  for (j = 0; j < s->vlc_n; j++) {
405  int d = FFMIN(j, s->vlc_n - j);
406 
407  s->stats[i][j] = 100000000 / (d*d + 1);
408  }
409  }
410 
412  if (ret < 0)
413  return ret;
414  s->avctx->extradata_size += ret;
415 
416  if (s->context) {
417  for (i = 0; i < 4; i++) {
418  int pels = s->width * s->height / (i ? 40 : 10);
419  for (j = 0; j < s->vlc_n; j++) {
420  int d = FFMIN(j, s->vlc_n - j);
421  s->stats[i][j] = pels/(d*d + 1);
422  }
423  }
424  } else {
425  for (i = 0; i < 4; i++)
426  for (j = 0; j < s->vlc_n; j++)
427  s->stats[i][j]= 0;
428  }
429 
430  if (ff_huffyuv_alloc_temp(s)) {
432  return AVERROR(ENOMEM);
433  }
434 
435  s->picture_number=0;
436 
437  return 0;
438 }
440 {
441  int i;
442  const uint8_t *y = s->temp[0] + offset;
443  const uint8_t *u = s->temp[1] + offset / 2;
444  const uint8_t *v = s->temp[2] + offset / 2;
445 
446  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 2 * 4 * count) {
447  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
448  return -1;
449  }
450 
451 #define LOAD4\
452  int y0 = y[2 * i];\
453  int y1 = y[2 * i + 1];\
454  int u0 = u[i];\
455  int v0 = v[i];
456 
457  count /= 2;
458 
459  if (s->flags & AV_CODEC_FLAG_PASS1) {
460  for(i = 0; i < count; i++) {
461  LOAD4;
462  s->stats[0][y0]++;
463  s->stats[1][u0]++;
464  s->stats[0][y1]++;
465  s->stats[2][v0]++;
466  }
467  }
469  return 0;
470  if (s->context) {
471  for (i = 0; i < count; i++) {
472  LOAD4;
473  s->stats[0][y0]++;
474  put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
475  s->stats[1][u0]++;
476  put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
477  s->stats[0][y1]++;
478  put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
479  s->stats[2][v0]++;
480  put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
481  }
482  } else {
483  for(i = 0; i < count; i++) {
484  LOAD4;
485  put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);
486  put_bits(&s->pb, s->len[1][u0], s->bits[1][u0]);
487  put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
488  put_bits(&s->pb, s->len[2][v0], s->bits[2][v0]);
489  }
490  }
491  return 0;
492 }
493 
495 {
496  int i, count = width/2;
497 
498  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < count * s->bps / 2) {
499  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
500  return -1;
501  }
502 
503 #define LOADEND\
504  int y0 = s->temp[0][width-1];
505 #define LOADEND_14\
506  int y0 = s->temp16[0][width-1] & mask;
507 #define LOADEND_16\
508  int y0 = s->temp16[0][width-1];
509 #define STATEND\
510  s->stats[plane][y0]++;
511 #define STATEND_16\
512  s->stats[plane][y0>>2]++;
513 #define WRITEEND\
514  put_bits(&s->pb, s->len[plane][y0], s->bits[plane][y0]);
515 #define WRITEEND_16\
516  put_bits(&s->pb, s->len[plane][y0>>2], s->bits[plane][y0>>2]);\
517  put_bits(&s->pb, 2, y0&3);
518 
519 #define LOAD2\
520  int y0 = s->temp[0][2 * i];\
521  int y1 = s->temp[0][2 * i + 1];
522 #define LOAD2_14\
523  int y0 = s->temp16[0][2 * i] & mask;\
524  int y1 = s->temp16[0][2 * i + 1] & mask;
525 #define LOAD2_16\
526  int y0 = s->temp16[0][2 * i];\
527  int y1 = s->temp16[0][2 * i + 1];
528 #define STAT2\
529  s->stats[plane][y0]++;\
530  s->stats[plane][y1]++;
531 #define STAT2_16\
532  s->stats[plane][y0>>2]++;\
533  s->stats[plane][y1>>2]++;
534 #define WRITE2\
535  put_bits(&s->pb, s->len[plane][y0], s->bits[plane][y0]);\
536  put_bits(&s->pb, s->len[plane][y1], s->bits[plane][y1]);
537 #define WRITE2_16\
538  put_bits(&s->pb, s->len[plane][y0>>2], s->bits[plane][y0>>2]);\
539  put_bits(&s->pb, 2, y0&3);\
540  put_bits(&s->pb, s->len[plane][y1>>2], s->bits[plane][y1>>2]);\
541  put_bits(&s->pb, 2, y1&3);
542 
543  if (s->bps <= 8) {
544  if (s->flags & AV_CODEC_FLAG_PASS1) {
545  for (i = 0; i < count; i++) {
546  LOAD2;
547  STAT2;
548  }
549  if (width&1) {
550  LOADEND;
551  STATEND;
552  }
553  }
555  return 0;
556 
557  if (s->context) {
558  for (i = 0; i < count; i++) {
559  LOAD2;
560  STAT2;
561  WRITE2;
562  }
563  if (width&1) {
564  LOADEND;
565  STATEND;
566  WRITEEND;
567  }
568  } else {
569  for (i = 0; i < count; i++) {
570  LOAD2;
571  WRITE2;
572  }
573  if (width&1) {
574  LOADEND;
575  WRITEEND;
576  }
577  }
578  } else if (s->bps <= 14) {
579  int mask = s->n - 1;
580  if (s->flags & AV_CODEC_FLAG_PASS1) {
581  for (i = 0; i < count; i++) {
582  LOAD2_14;
583  STAT2;
584  }
585  if (width&1) {
586  LOADEND_14;
587  STATEND;
588  }
589  }
591  return 0;
592 
593  if (s->context) {
594  for (i = 0; i < count; i++) {
595  LOAD2_14;
596  STAT2;
597  WRITE2;
598  }
599  if (width&1) {
600  LOADEND_14;
601  STATEND;
602  WRITEEND;
603  }
604  } else {
605  for (i = 0; i < count; i++) {
606  LOAD2_14;
607  WRITE2;
608  }
609  if (width&1) {
610  LOADEND_14;
611  WRITEEND;
612  }
613  }
614  } else {
615  if (s->flags & AV_CODEC_FLAG_PASS1) {
616  for (i = 0; i < count; i++) {
617  LOAD2_16;
618  STAT2_16;
619  }
620  if (width&1) {
621  LOADEND_16;
622  STATEND_16;
623  }
624  }
626  return 0;
627 
628  if (s->context) {
629  for (i = 0; i < count; i++) {
630  LOAD2_16;
631  STAT2_16;
632  WRITE2_16;
633  }
634  if (width&1) {
635  LOADEND_16;
636  STATEND_16;
637  WRITEEND_16;
638  }
639  } else {
640  for (i = 0; i < count; i++) {
641  LOAD2_16;
642  WRITE2_16;
643  }
644  if (width&1) {
645  LOADEND_16;
646  WRITEEND_16;
647  }
648  }
649  }
650 #undef LOAD2
651 #undef STAT2
652 #undef WRITE2
653  return 0;
654 }
655 
657 {
658  int i;
659 
660  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) < 4 * count) {
661  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
662  return -1;
663  }
664 
665 #define LOAD2\
666  int y0 = s->temp[0][2 * i];\
667  int y1 = s->temp[0][2 * i + 1];
668 #define STAT2\
669  s->stats[0][y0]++;\
670  s->stats[0][y1]++;
671 #define WRITE2\
672  put_bits(&s->pb, s->len[0][y0], s->bits[0][y0]);\
673  put_bits(&s->pb, s->len[0][y1], s->bits[0][y1]);
674 
675  count /= 2;
676 
677  if (s->flags & AV_CODEC_FLAG_PASS1) {
678  for (i = 0; i < count; i++) {
679  LOAD2;
680  STAT2;
681  }
682  }
684  return 0;
685 
686  if (s->context) {
687  for (i = 0; i < count; i++) {
688  LOAD2;
689  STAT2;
690  WRITE2;
691  }
692  } else {
693  for (i = 0; i < count; i++) {
694  LOAD2;
695  WRITE2;
696  }
697  }
698  return 0;
699 }
700 
701 static inline int encode_bgra_bitstream(HYuvContext *s, int count, int planes)
702 {
703  int i;
704 
705  if (s->pb.buf_end - s->pb.buf - (put_bits_count(&s->pb) >> 3) <
706  4 * planes * count) {
707  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
708  return -1;
709  }
710 
711 #define LOAD_GBRA \
712  int g = s->temp[0][planes == 3 ? 3 * i + 1 : 4 * i + G]; \
713  int b =(s->temp[0][planes == 3 ? 3 * i + 2 : 4 * i + B] - g) & 0xFF;\
714  int r =(s->temp[0][planes == 3 ? 3 * i + 0 : 4 * i + R] - g) & 0xFF;\
715  int a = s->temp[0][planes * i + A];
716 
717 #define STAT_BGRA \
718  s->stats[0][b]++; \
719  s->stats[1][g]++; \
720  s->stats[2][r]++; \
721  if (planes == 4) \
722  s->stats[2][a]++;
723 
724 #define WRITE_GBRA \
725  put_bits(&s->pb, s->len[1][g], s->bits[1][g]); \
726  put_bits(&s->pb, s->len[0][b], s->bits[0][b]); \
727  put_bits(&s->pb, s->len[2][r], s->bits[2][r]); \
728  if (planes == 4) \
729  put_bits(&s->pb, s->len[2][a], s->bits[2][a]);
730 
731  if ((s->flags & AV_CODEC_FLAG_PASS1) &&
733  for (i = 0; i < count; i++) {
734  LOAD_GBRA;
735  STAT_BGRA;
736  }
737  } else if (s->context || (s->flags & AV_CODEC_FLAG_PASS1)) {
738  for (i = 0; i < count; i++) {
739  LOAD_GBRA;
740  STAT_BGRA;
741  WRITE_GBRA;
742  }
743  } else {
744  for (i = 0; i < count; i++) {
745  LOAD_GBRA;
746  WRITE_GBRA;
747  }
748  }
749  return 0;
750 }
751 
753  const AVFrame *pict, int *got_packet)
754 {
755  HYuvContext *s = avctx->priv_data;
756  const int width = s->width;
757  const int width2 = s->width>>1;
758  const int height = s->height;
759  const int fake_ystride = s->interlaced ? pict->linesize[0]*2 : pict->linesize[0];
760  const int fake_ustride = s->interlaced ? pict->linesize[1]*2 : pict->linesize[1];
761  const int fake_vstride = s->interlaced ? pict->linesize[2]*2 : pict->linesize[2];
762  const AVFrame * const p = pict;
763  int i, j, size = 0, ret;
764 
765  if ((ret = ff_alloc_packet2(avctx, pkt, width * height * 3 * 4 + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
766  return ret;
767 
768  if (s->context) {
769  size = store_huffman_tables(s, pkt->data);
770  if (size < 0)
771  return size;
772 
773  for (i = 0; i < 4; i++)
774  for (j = 0; j < s->vlc_n; j++)
775  s->stats[i][j] >>= 1;
776  }
777 
778  init_put_bits(&s->pb, pkt->data + size, pkt->size - size);
779 
780  if (avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
781  avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
782  int lefty, leftu, leftv, y, cy;
783 
784  put_bits(&s->pb, 8, leftv = p->data[2][0]);
785  put_bits(&s->pb, 8, lefty = p->data[0][1]);
786  put_bits(&s->pb, 8, leftu = p->data[1][0]);
787  put_bits(&s->pb, 8, p->data[0][0]);
788 
789  lefty = sub_left_prediction(s, s->temp[0], p->data[0], width , 0);
790  leftu = sub_left_prediction(s, s->temp[1], p->data[1], width2, 0);
791  leftv = sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);
792 
793  encode_422_bitstream(s, 2, width-2);
794 
795  if (s->predictor==MEDIAN) {
796  int lefttopy, lefttopu, lefttopv;
797  cy = y = 1;
798  if (s->interlaced) {
799  lefty = sub_left_prediction(s, s->temp[0], p->data[0] + p->linesize[0], width , lefty);
800  leftu = sub_left_prediction(s, s->temp[1], p->data[1] + p->linesize[1], width2, leftu);
801  leftv = sub_left_prediction(s, s->temp[2], p->data[2] + p->linesize[2], width2, leftv);
802 
803  encode_422_bitstream(s, 0, width);
804  y++; cy++;
805  }
806 
807  lefty = sub_left_prediction(s, s->temp[0], p->data[0] + fake_ystride, 4, lefty);
808  leftu = sub_left_prediction(s, s->temp[1], p->data[1] + fake_ustride, 2, leftu);
809  leftv = sub_left_prediction(s, s->temp[2], p->data[2] + fake_vstride, 2, leftv);
810 
811  encode_422_bitstream(s, 0, 4);
812 
813  lefttopy = p->data[0][3];
814  lefttopu = p->data[1][1];
815  lefttopv = p->data[2][1];
816  s->llvidencdsp.sub_median_pred(s->temp[0], p->data[0] + 4, p->data[0] + fake_ystride + 4, width - 4, &lefty, &lefttopy);
817  s->llvidencdsp.sub_median_pred(s->temp[1], p->data[1] + 2, p->data[1] + fake_ustride + 2, width2 - 2, &leftu, &lefttopu);
818  s->llvidencdsp.sub_median_pred(s->temp[2], p->data[2] + 2, p->data[2] + fake_vstride + 2, width2 - 2, &leftv, &lefttopv);
819  encode_422_bitstream(s, 0, width - 4);
820  y++; cy++;
821 
822  for (; y < height; y++,cy++) {
823  uint8_t *ydst, *udst, *vdst;
824 
825  if (s->bitstream_bpp == 12) {
826  while (2 * cy > y) {
827  ydst = p->data[0] + p->linesize[0] * y;
828  s->llvidencdsp.sub_median_pred(s->temp[0], ydst - fake_ystride, ydst, width, &lefty, &lefttopy);
829  encode_gray_bitstream(s, width);
830  y++;
831  }
832  if (y >= height) break;
833  }
834  ydst = p->data[0] + p->linesize[0] * y;
835  udst = p->data[1] + p->linesize[1] * cy;
836  vdst = p->data[2] + p->linesize[2] * cy;
837 
838  s->llvidencdsp.sub_median_pred(s->temp[0], ydst - fake_ystride, ydst, width, &lefty, &lefttopy);
839  s->llvidencdsp.sub_median_pred(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
840  s->llvidencdsp.sub_median_pred(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
841 
842  encode_422_bitstream(s, 0, width);
843  }
844  } else {
845  for (cy = y = 1; y < height; y++, cy++) {
846  uint8_t *ydst, *udst, *vdst;
847 
848  /* encode a luma only line & y++ */
849  if (s->bitstream_bpp == 12) {
850  ydst = p->data[0] + p->linesize[0] * y;
851 
852  if (s->predictor == PLANE && s->interlaced < y) {
853  s->llvidencdsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
854 
855  lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
856  } else {
857  lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
858  }
859  encode_gray_bitstream(s, width);
860  y++;
861  if (y >= height) break;
862  }
863 
864  ydst = p->data[0] + p->linesize[0] * y;
865  udst = p->data[1] + p->linesize[1] * cy;
866  vdst = p->data[2] + p->linesize[2] * cy;
867 
868  if (s->predictor == PLANE && s->interlaced < cy) {
869  s->llvidencdsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
870  s->llvidencdsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
871  s->llvidencdsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
872 
873  lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
874  leftu = sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
875  leftv = sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
876  } else {
877  lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
878  leftu = sub_left_prediction(s, s->temp[1], udst, width2, leftu);
879  leftv = sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
880  }
881 
882  encode_422_bitstream(s, 0, width);
883  }
884  }
885  } else if(avctx->pix_fmt == AV_PIX_FMT_RGB32) {
886  uint8_t *data = p->data[0] + (height - 1) * p->linesize[0];
887  const int stride = -p->linesize[0];
888  const int fake_stride = -fake_ystride;
889  int y;
890  int leftr, leftg, leftb, lefta;
891 
892  put_bits(&s->pb, 8, lefta = data[A]);
893  put_bits(&s->pb, 8, leftr = data[R]);
894  put_bits(&s->pb, 8, leftg = data[G]);
895  put_bits(&s->pb, 8, leftb = data[B]);
896 
897  sub_left_prediction_bgr32(s, s->temp[0], data + 4, width - 1,
898  &leftr, &leftg, &leftb, &lefta);
899  encode_bgra_bitstream(s, width - 1, 4);
900 
901  for (y = 1; y < s->height; y++) {
902  uint8_t *dst = data + y*stride;
903  if (s->predictor == PLANE && s->interlaced < y) {
904  s->llvidencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width * 4);
905  sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width,
906  &leftr, &leftg, &leftb, &lefta);
907  } else {
908  sub_left_prediction_bgr32(s, s->temp[0], dst, width,
909  &leftr, &leftg, &leftb, &lefta);
910  }
911  encode_bgra_bitstream(s, width, 4);
912  }
913  } else if (avctx->pix_fmt == AV_PIX_FMT_RGB24) {
914  uint8_t *data = p->data[0] + (height - 1) * p->linesize[0];
915  const int stride = -p->linesize[0];
916  const int fake_stride = -fake_ystride;
917  int y;
918  int leftr, leftg, leftb;
919 
920  put_bits(&s->pb, 8, leftr = data[0]);
921  put_bits(&s->pb, 8, leftg = data[1]);
922  put_bits(&s->pb, 8, leftb = data[2]);
923  put_bits(&s->pb, 8, 0);
924 
925  sub_left_prediction_rgb24(s, s->temp[0], data + 3, width - 1,
926  &leftr, &leftg, &leftb);
927  encode_bgra_bitstream(s, width-1, 3);
928 
929  for (y = 1; y < s->height; y++) {
930  uint8_t *dst = data + y * stride;
931  if (s->predictor == PLANE && s->interlaced < y) {
932  s->llvidencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride,
933  width * 3);
934  sub_left_prediction_rgb24(s, s->temp[0], s->temp[1], width,
935  &leftr, &leftg, &leftb);
936  } else {
937  sub_left_prediction_rgb24(s, s->temp[0], dst, width,
938  &leftr, &leftg, &leftb);
939  }
940  encode_bgra_bitstream(s, width, 3);
941  }
942  } else if (s->version > 2) {
943  int plane;
944  for (plane = 0; plane < 1 + 2*s->chroma + s->alpha; plane++) {
945  int left, y;
946  int w = width;
947  int h = height;
948  int fake_stride = fake_ystride;
949 
950  if (s->chroma && (plane == 1 || plane == 2)) {
951  w >>= s->chroma_h_shift;
952  h >>= s->chroma_v_shift;
953  fake_stride = plane == 1 ? fake_ustride : fake_vstride;
954  }
955 
956  left = sub_left_prediction(s, s->temp[0], p->data[plane], w , 0);
957 
958  encode_plane_bitstream(s, w, plane);
959 
960  if (s->predictor==MEDIAN) {
961  int lefttop;
962  y = 1;
963  if (s->interlaced) {
964  left = sub_left_prediction(s, s->temp[0], p->data[plane] + p->linesize[plane], w , left);
965 
966  encode_plane_bitstream(s, w, plane);
967  y++;
968  }
969 
970  lefttop = p->data[plane][0];
971 
972  for (; y < h; y++) {
973  uint8_t *dst = p->data[plane] + p->linesize[plane] * y;
974 
975  sub_median_prediction(s, s->temp[0], dst - fake_stride, dst, w , &left, &lefttop);
976 
977  encode_plane_bitstream(s, w, plane);
978  }
979  } else {
980  for (y = 1; y < h; y++) {
981  uint8_t *dst = p->data[plane] + p->linesize[plane] * y;
982 
983  if (s->predictor == PLANE && s->interlaced < y) {
984  diff_bytes(s, s->temp[1], dst, dst - fake_stride, w);
985 
986  left = sub_left_prediction(s, s->temp[0], s->temp[1], w , left);
987  } else {
988  left = sub_left_prediction(s, s->temp[0], dst, w , left);
989  }
990 
991  encode_plane_bitstream(s, w, plane);
992  }
993  }
994  }
995  } else {
996  av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
997  }
998  emms_c();
999 
1000  size += (put_bits_count(&s->pb) + 31) / 8;
1001  put_bits(&s->pb, 16, 0);
1002  put_bits(&s->pb, 15, 0);
1003  size /= 4;
1004 
1005  if ((s->flags & AV_CODEC_FLAG_PASS1) && (s->picture_number & 31) == 0) {
1006  int j;
1007  char *p = avctx->stats_out;
1008  char *end = p + STATS_OUT_SIZE;
1009  for (i = 0; i < 4; i++) {
1010  for (j = 0; j < s->vlc_n; j++) {
1011  snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1012  p += strlen(p);
1013  s->stats[i][j]= 0;
1014  }
1015  snprintf(p, end-p, "\n");
1016  p++;
1017  if (end <= p)
1018  return AVERROR(ENOMEM);
1019  }
1020  } else if (avctx->stats_out)
1021  avctx->stats_out[0] = '\0';
1022  if (!(s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT)) {
1023  flush_put_bits(&s->pb);
1024  s->bdsp.bswap_buf((uint32_t *) pkt->data, (uint32_t *) pkt->data, size);
1025  }
1026 
1027  s->picture_number++;
1028 
1029  pkt->size = size * 4;
1030  pkt->flags |= AV_PKT_FLAG_KEY;
1031  *got_packet = 1;
1032 
1033  return 0;
1034 }
1035 
1037 {
1038  HYuvContext *s = avctx->priv_data;
1039 
1041 
1042  av_freep(&avctx->extradata);
1043  av_freep(&avctx->stats_out);
1044 
1045  return 0;
1046 }
1047 
1048 #define OFFSET(x) offsetof(HYuvContext, x)
1049 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1050 
1051 #define COMMON_OPTIONS \
1052  { "non_deterministic", "Allow multithreading for e.g. context=1 at the expense of determinism", \
1053  OFFSET(non_determ), AV_OPT_TYPE_BOOL, { .i64 = 1 }, \
1054  0, 1, VE }, \
1055  { "pred", "Prediction method", OFFSET(predictor), AV_OPT_TYPE_INT, { .i64 = LEFT }, LEFT, MEDIAN, VE, "pred" }, \
1056  { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LEFT }, INT_MIN, INT_MAX, VE, "pred" }, \
1057  { "plane", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PLANE }, INT_MIN, INT_MAX, VE, "pred" }, \
1058  { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MEDIAN }, INT_MIN, INT_MAX, VE, "pred" }, \
1059 
1060 static const AVOption normal_options[] = {
1062  { NULL },
1063 };
1064 
1065 static const AVOption ff_options[] = {
1067  { "context", "Set per-frame huffman tables", OFFSET(context), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
1068  { NULL },
1069 };
1070 
1071 static const AVClass normal_class = {
1072  .class_name = "huffyuv",
1073  .item_name = av_default_item_name,
1074  .option = normal_options,
1075  .version = LIBAVUTIL_VERSION_INT,
1076 };
1077 
1078 static const AVClass ff_class = {
1079  .class_name = "ffvhuff",
1080  .item_name = av_default_item_name,
1081  .option = ff_options,
1082  .version = LIBAVUTIL_VERSION_INT,
1083 };
1084 
1086  .name = "huffyuv",
1087  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1088  .type = AVMEDIA_TYPE_VIDEO,
1089  .id = AV_CODEC_ID_HUFFYUV,
1090  .priv_data_size = sizeof(HYuvContext),
1091  .init = encode_init,
1092  .encode2 = encode_frame,
1093  .close = encode_end,
1095  .priv_class = &normal_class,
1096  .pix_fmts = (const enum AVPixelFormat[]){
1099  },
1100  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1102 };
1103 
1104 #if CONFIG_FFVHUFF_ENCODER
1106  .name = "ffvhuff",
1107  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1108  .type = AVMEDIA_TYPE_VIDEO,
1109  .id = AV_CODEC_ID_FFVHUFF,
1110  .priv_data_size = sizeof(HYuvContext),
1111  .init = encode_init,
1112  .encode2 = encode_frame,
1113  .close = encode_end,
1115  .priv_class = &ff_class,
1116  .pix_fmts = (const enum AVPixelFormat[]){
1132  },
1133  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1135 };
1136 #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:920
int plane
Definition: avisynth_c.h:384
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2636
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:1577
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:295
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:1481
#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:494
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:1778
#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:2595
#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:3492
int height
Definition: huffyuv.h:75
#define AV_CODEC_CAP_INTRA_ONLY
Codec is intra only.
Definition: avcodec.h:1070
#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:1669
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
#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:1480
attribute_deprecated int context_model
Definition: avcodec.h:2491
#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:2792
#define LOAD2
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2587
#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:800
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
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:752
#define LOAD2_14
av_cold int ff_huffyuv_alloc_temp(HYuvContext *s)
Definition: huffyuv.c:58
enum AVCodecID id
Definition: avcodec.h:3506
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:259
#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:1078
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:431
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1648
uint8_t * buf
Definition: put_bits.h:38
const char * name
Name of the codec implementation.
Definition: avcodec.h:3499
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
static const AVClass normal_class
Definition: huffyuvenc.c:1071
int chroma
Definition: huffyuv.h:71
GLsizei count
Definition: opengl_enc.c:108
#define COMMON_OPTIONS
Definition: huffyuvenc.c:1051
huffyuv codec for libavcodec.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1040
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
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:378
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:406
#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:1085
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:874
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:1036
#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:439
attribute_deprecated int prediction_method
Definition: avcodec.h:1927
int yuv
Definition: huffyuv.h:72
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
static const AVOption ff_options[]
Definition: huffyuvenc.c:1065
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:1568
#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:1670
#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:701
#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:309
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:1048
#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:1049
#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:930
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:423
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2818
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:656
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:878
void * priv_data
Definition: avcodec.h:1595
static const struct @317 planes[]
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
int len
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:1655
#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:1060
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:1457
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:2631
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:399
for(j=16;j >0;--j)
bitstream writer API