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 
155 static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf)
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 (put_bytes_left(&s->pb, 0) < 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 
494 static int encode_plane_bitstream(HYuvContext *s, int width, int plane)
495 {
496  int i, count = width/2;
497 
498  if (put_bytes_left(&s->pb, 0) < 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 (put_bytes_left(&s->pb, 0) < 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 (put_bytes_left(&s->pb, 0) < 4 * planes * count) {
706  av_log(s->avctx, AV_LOG_ERROR, "encoded frame too large\n");
707  return -1;
708  }
709 
710 #define LOAD_GBRA \
711  int g = s->temp[0][planes == 3 ? 3 * i + 1 : 4 * i + G]; \
712  int b =(s->temp[0][planes == 3 ? 3 * i + 2 : 4 * i + B] - g) & 0xFF;\
713  int r =(s->temp[0][planes == 3 ? 3 * i + 0 : 4 * i + R] - g) & 0xFF;\
714  int a = s->temp[0][planes * i + A];
715 
716 #define STAT_BGRA \
717  s->stats[0][b]++; \
718  s->stats[1][g]++; \
719  s->stats[2][r]++; \
720  if (planes == 4) \
721  s->stats[2][a]++;
722 
723 #define WRITE_GBRA \
724  put_bits(&s->pb, s->len[1][g], s->bits[1][g]); \
725  put_bits(&s->pb, s->len[0][b], s->bits[0][b]); \
726  put_bits(&s->pb, s->len[2][r], s->bits[2][r]); \
727  if (planes == 4) \
728  put_bits(&s->pb, s->len[2][a], s->bits[2][a]);
729 
730  if ((s->flags & AV_CODEC_FLAG_PASS1) &&
732  for (i = 0; i < count; i++) {
733  LOAD_GBRA;
734  STAT_BGRA;
735  }
736  } else if (s->context || (s->flags & AV_CODEC_FLAG_PASS1)) {
737  for (i = 0; i < count; i++) {
738  LOAD_GBRA;
739  STAT_BGRA;
740  WRITE_GBRA;
741  }
742  } else {
743  for (i = 0; i < count; i++) {
744  LOAD_GBRA;
745  WRITE_GBRA;
746  }
747  }
748  return 0;
749 }
750 
752  const AVFrame *pict, int *got_packet)
753 {
754  HYuvContext *s = avctx->priv_data;
755  const int width = s->width;
756  const int width2 = s->width>>1;
757  const int height = s->height;
758  const int fake_ystride = s->interlaced ? pict->linesize[0]*2 : pict->linesize[0];
759  const int fake_ustride = s->interlaced ? pict->linesize[1]*2 : pict->linesize[1];
760  const int fake_vstride = s->interlaced ? pict->linesize[2]*2 : pict->linesize[2];
761  const AVFrame * const p = pict;
762  int i, j, size = 0, ret;
763 
764  if ((ret = ff_alloc_packet2(avctx, pkt, width * height * 3 * 4 + AV_INPUT_BUFFER_MIN_SIZE, 0)) < 0)
765  return ret;
766 
767  if (s->context) {
768  size = store_huffman_tables(s, pkt->data);
769  if (size < 0)
770  return size;
771 
772  for (i = 0; i < 4; i++)
773  for (j = 0; j < s->vlc_n; j++)
774  s->stats[i][j] >>= 1;
775  }
776 
777  init_put_bits(&s->pb, pkt->data + size, pkt->size - size);
778 
779  if (avctx->pix_fmt == AV_PIX_FMT_YUV422P ||
780  avctx->pix_fmt == AV_PIX_FMT_YUV420P) {
781  int lefty, leftu, leftv, y, cy;
782 
783  put_bits(&s->pb, 8, leftv = p->data[2][0]);
784  put_bits(&s->pb, 8, lefty = p->data[0][1]);
785  put_bits(&s->pb, 8, leftu = p->data[1][0]);
786  put_bits(&s->pb, 8, p->data[0][0]);
787 
788  lefty = sub_left_prediction(s, s->temp[0], p->data[0], width , 0);
789  leftu = sub_left_prediction(s, s->temp[1], p->data[1], width2, 0);
790  leftv = sub_left_prediction(s, s->temp[2], p->data[2], width2, 0);
791 
792  encode_422_bitstream(s, 2, width-2);
793 
794  if (s->predictor==MEDIAN) {
795  int lefttopy, lefttopu, lefttopv;
796  cy = y = 1;
797  if (s->interlaced) {
798  lefty = sub_left_prediction(s, s->temp[0], p->data[0] + p->linesize[0], width , lefty);
799  leftu = sub_left_prediction(s, s->temp[1], p->data[1] + p->linesize[1], width2, leftu);
800  leftv = sub_left_prediction(s, s->temp[2], p->data[2] + p->linesize[2], width2, leftv);
801 
802  encode_422_bitstream(s, 0, width);
803  y++; cy++;
804  }
805 
806  lefty = sub_left_prediction(s, s->temp[0], p->data[0] + fake_ystride, 4, lefty);
807  leftu = sub_left_prediction(s, s->temp[1], p->data[1] + fake_ustride, 2, leftu);
808  leftv = sub_left_prediction(s, s->temp[2], p->data[2] + fake_vstride, 2, leftv);
809 
810  encode_422_bitstream(s, 0, 4);
811 
812  lefttopy = p->data[0][3];
813  lefttopu = p->data[1][1];
814  lefttopv = p->data[2][1];
815  s->llvidencdsp.sub_median_pred(s->temp[0], p->data[0] + 4, p->data[0] + fake_ystride + 4, width - 4, &lefty, &lefttopy);
816  s->llvidencdsp.sub_median_pred(s->temp[1], p->data[1] + 2, p->data[1] + fake_ustride + 2, width2 - 2, &leftu, &lefttopu);
817  s->llvidencdsp.sub_median_pred(s->temp[2], p->data[2] + 2, p->data[2] + fake_vstride + 2, width2 - 2, &leftv, &lefttopv);
818  encode_422_bitstream(s, 0, width - 4);
819  y++; cy++;
820 
821  for (; y < height; y++,cy++) {
822  uint8_t *ydst, *udst, *vdst;
823 
824  if (s->bitstream_bpp == 12) {
825  while (2 * cy > y) {
826  ydst = p->data[0] + p->linesize[0] * y;
827  s->llvidencdsp.sub_median_pred(s->temp[0], ydst - fake_ystride, ydst, width, &lefty, &lefttopy);
828  encode_gray_bitstream(s, width);
829  y++;
830  }
831  if (y >= height) break;
832  }
833  ydst = p->data[0] + p->linesize[0] * y;
834  udst = p->data[1] + p->linesize[1] * cy;
835  vdst = p->data[2] + p->linesize[2] * cy;
836 
837  s->llvidencdsp.sub_median_pred(s->temp[0], ydst - fake_ystride, ydst, width, &lefty, &lefttopy);
838  s->llvidencdsp.sub_median_pred(s->temp[1], udst - fake_ustride, udst, width2, &leftu, &lefttopu);
839  s->llvidencdsp.sub_median_pred(s->temp[2], vdst - fake_vstride, vdst, width2, &leftv, &lefttopv);
840 
841  encode_422_bitstream(s, 0, width);
842  }
843  } else {
844  for (cy = y = 1; y < height; y++, cy++) {
845  uint8_t *ydst, *udst, *vdst;
846 
847  /* encode a luma only line & y++ */
848  if (s->bitstream_bpp == 12) {
849  ydst = p->data[0] + p->linesize[0] * y;
850 
851  if (s->predictor == PLANE && s->interlaced < y) {
852  s->llvidencdsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
853 
854  lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
855  } else {
856  lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
857  }
858  encode_gray_bitstream(s, width);
859  y++;
860  if (y >= height) break;
861  }
862 
863  ydst = p->data[0] + p->linesize[0] * y;
864  udst = p->data[1] + p->linesize[1] * cy;
865  vdst = p->data[2] + p->linesize[2] * cy;
866 
867  if (s->predictor == PLANE && s->interlaced < cy) {
868  s->llvidencdsp.diff_bytes(s->temp[1], ydst, ydst - fake_ystride, width);
869  s->llvidencdsp.diff_bytes(s->temp[2], udst, udst - fake_ustride, width2);
870  s->llvidencdsp.diff_bytes(s->temp[2] + width2, vdst, vdst - fake_vstride, width2);
871 
872  lefty = sub_left_prediction(s, s->temp[0], s->temp[1], width , lefty);
873  leftu = sub_left_prediction(s, s->temp[1], s->temp[2], width2, leftu);
874  leftv = sub_left_prediction(s, s->temp[2], s->temp[2] + width2, width2, leftv);
875  } else {
876  lefty = sub_left_prediction(s, s->temp[0], ydst, width , lefty);
877  leftu = sub_left_prediction(s, s->temp[1], udst, width2, leftu);
878  leftv = sub_left_prediction(s, s->temp[2], vdst, width2, leftv);
879  }
880 
881  encode_422_bitstream(s, 0, width);
882  }
883  }
884  } else if(avctx->pix_fmt == AV_PIX_FMT_RGB32) {
885  uint8_t *data = p->data[0] + (height - 1) * p->linesize[0];
886  const int stride = -p->linesize[0];
887  const int fake_stride = -fake_ystride;
888  int y;
889  int leftr, leftg, leftb, lefta;
890 
891  put_bits(&s->pb, 8, lefta = data[A]);
892  put_bits(&s->pb, 8, leftr = data[R]);
893  put_bits(&s->pb, 8, leftg = data[G]);
894  put_bits(&s->pb, 8, leftb = data[B]);
895 
896  sub_left_prediction_bgr32(s, s->temp[0], data + 4, width - 1,
897  &leftr, &leftg, &leftb, &lefta);
898  encode_bgra_bitstream(s, width - 1, 4);
899 
900  for (y = 1; y < s->height; y++) {
901  uint8_t *dst = data + y*stride;
902  if (s->predictor == PLANE && s->interlaced < y) {
903  s->llvidencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride, width * 4);
904  sub_left_prediction_bgr32(s, s->temp[0], s->temp[1], width,
905  &leftr, &leftg, &leftb, &lefta);
906  } else {
907  sub_left_prediction_bgr32(s, s->temp[0], dst, width,
908  &leftr, &leftg, &leftb, &lefta);
909  }
910  encode_bgra_bitstream(s, width, 4);
911  }
912  } else if (avctx->pix_fmt == AV_PIX_FMT_RGB24) {
913  uint8_t *data = p->data[0] + (height - 1) * p->linesize[0];
914  const int stride = -p->linesize[0];
915  const int fake_stride = -fake_ystride;
916  int y;
917  int leftr, leftg, leftb;
918 
919  put_bits(&s->pb, 8, leftr = data[0]);
920  put_bits(&s->pb, 8, leftg = data[1]);
921  put_bits(&s->pb, 8, leftb = data[2]);
922  put_bits(&s->pb, 8, 0);
923 
924  sub_left_prediction_rgb24(s, s->temp[0], data + 3, width - 1,
925  &leftr, &leftg, &leftb);
926  encode_bgra_bitstream(s, width-1, 3);
927 
928  for (y = 1; y < s->height; y++) {
929  uint8_t *dst = data + y * stride;
930  if (s->predictor == PLANE && s->interlaced < y) {
931  s->llvidencdsp.diff_bytes(s->temp[1], dst, dst - fake_stride,
932  width * 3);
933  sub_left_prediction_rgb24(s, s->temp[0], s->temp[1], width,
934  &leftr, &leftg, &leftb);
935  } else {
936  sub_left_prediction_rgb24(s, s->temp[0], dst, width,
937  &leftr, &leftg, &leftb);
938  }
939  encode_bgra_bitstream(s, width, 3);
940  }
941  } else if (s->version > 2) {
942  int plane;
943  for (plane = 0; plane < 1 + 2*s->chroma + s->alpha; plane++) {
944  int left, y;
945  int w = width;
946  int h = height;
947  int fake_stride = fake_ystride;
948 
949  if (s->chroma && (plane == 1 || plane == 2)) {
950  w >>= s->chroma_h_shift;
951  h >>= s->chroma_v_shift;
952  fake_stride = plane == 1 ? fake_ustride : fake_vstride;
953  }
954 
955  left = sub_left_prediction(s, s->temp[0], p->data[plane], w , 0);
956 
957  encode_plane_bitstream(s, w, plane);
958 
959  if (s->predictor==MEDIAN) {
960  int lefttop;
961  y = 1;
962  if (s->interlaced) {
963  left = sub_left_prediction(s, s->temp[0], p->data[plane] + p->linesize[plane], w , left);
964 
965  encode_plane_bitstream(s, w, plane);
966  y++;
967  }
968 
969  lefttop = p->data[plane][0];
970 
971  for (; y < h; y++) {
972  uint8_t *dst = p->data[plane] + p->linesize[plane] * y;
973 
974  sub_median_prediction(s, s->temp[0], dst - fake_stride, dst, w , &left, &lefttop);
975 
976  encode_plane_bitstream(s, w, plane);
977  }
978  } else {
979  for (y = 1; y < h; y++) {
980  uint8_t *dst = p->data[plane] + p->linesize[plane] * y;
981 
982  if (s->predictor == PLANE && s->interlaced < y) {
983  diff_bytes(s, s->temp[1], dst, dst - fake_stride, w);
984 
985  left = sub_left_prediction(s, s->temp[0], s->temp[1], w , left);
986  } else {
987  left = sub_left_prediction(s, s->temp[0], dst, w , left);
988  }
989 
990  encode_plane_bitstream(s, w, plane);
991  }
992  }
993  }
994  } else {
995  av_log(avctx, AV_LOG_ERROR, "Format not supported!\n");
996  }
997  emms_c();
998 
999  size += (put_bits_count(&s->pb) + 31) / 8;
1000  put_bits(&s->pb, 16, 0);
1001  put_bits(&s->pb, 15, 0);
1002  size /= 4;
1003 
1004  if ((s->flags & AV_CODEC_FLAG_PASS1) && (s->picture_number & 31) == 0) {
1005  int j;
1006  char *p = avctx->stats_out;
1007  char *end = p + STATS_OUT_SIZE;
1008  for (i = 0; i < 4; i++) {
1009  for (j = 0; j < s->vlc_n; j++) {
1010  snprintf(p, end-p, "%"PRIu64" ", s->stats[i][j]);
1011  p += strlen(p);
1012  s->stats[i][j]= 0;
1013  }
1014  snprintf(p, end-p, "\n");
1015  p++;
1016  if (end <= p)
1017  return AVERROR(ENOMEM);
1018  }
1019  } else if (avctx->stats_out)
1020  avctx->stats_out[0] = '\0';
1021  if (!(s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT)) {
1022  flush_put_bits(&s->pb);
1023  s->bdsp.bswap_buf((uint32_t *) pkt->data, (uint32_t *) pkt->data, size);
1024  }
1025 
1026  s->picture_number++;
1027 
1028  pkt->size = size * 4;
1029  pkt->flags |= AV_PKT_FLAG_KEY;
1030  *got_packet = 1;
1031 
1032  return 0;
1033 }
1034 
1036 {
1037  HYuvContext *s = avctx->priv_data;
1038 
1040 
1041  av_freep(&avctx->extradata);
1042  av_freep(&avctx->stats_out);
1043 
1044  return 0;
1045 }
1046 
1047 #define OFFSET(x) offsetof(HYuvContext, x)
1048 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1049 
1050 #define COMMON_OPTIONS \
1051  { "non_deterministic", "Allow multithreading for e.g. context=1 at the expense of determinism", \
1052  OFFSET(non_determ), AV_OPT_TYPE_BOOL, { .i64 = 1 }, \
1053  0, 1, VE }, \
1054  { "pred", "Prediction method", OFFSET(predictor), AV_OPT_TYPE_INT, { .i64 = LEFT }, LEFT, MEDIAN, VE, "pred" }, \
1055  { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LEFT }, INT_MIN, INT_MAX, VE, "pred" }, \
1056  { "plane", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = PLANE }, INT_MIN, INT_MAX, VE, "pred" }, \
1057  { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MEDIAN }, INT_MIN, INT_MAX, VE, "pred" }, \
1058 
1059 static const AVOption normal_options[] = {
1061  { NULL },
1062 };
1063 
1064 static const AVOption ff_options[] = {
1066  { "context", "Set per-frame huffman tables", OFFSET(context), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VE },
1067  { NULL },
1068 };
1069 
1070 static const AVClass normal_class = {
1071  .class_name = "huffyuv",
1072  .item_name = av_default_item_name,
1073  .option = normal_options,
1074  .version = LIBAVUTIL_VERSION_INT,
1075 };
1076 
1077 static const AVClass ff_class = {
1078  .class_name = "ffvhuff",
1079  .item_name = av_default_item_name,
1080  .option = ff_options,
1081  .version = LIBAVUTIL_VERSION_INT,
1082 };
1083 
1085  .name = "huffyuv",
1086  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv / HuffYUV"),
1087  .type = AVMEDIA_TYPE_VIDEO,
1088  .id = AV_CODEC_ID_HUFFYUV,
1089  .priv_data_size = sizeof(HYuvContext),
1090  .init = encode_init,
1091  .encode2 = encode_frame,
1092  .close = encode_end,
1093  .capabilities = AV_CODEC_CAP_FRAME_THREADS,
1094  .priv_class = &normal_class,
1095  .pix_fmts = (const enum AVPixelFormat[]){
1098  },
1099  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1101 };
1102 
1103 #if CONFIG_FFVHUFF_ENCODER
1105  .name = "ffvhuff",
1106  .long_name = NULL_IF_CONFIG_SMALL("Huffyuv FFmpeg variant"),
1107  .type = AVMEDIA_TYPE_VIDEO,
1108  .id = AV_CODEC_ID_FFVHUFF,
1109  .priv_data_size = sizeof(HYuvContext),
1110  .init = encode_init,
1111  .encode2 = encode_frame,
1112  .close = encode_end,
1113  .capabilities = AV_CODEC_CAP_FRAME_THREADS,
1114  .priv_class = &ff_class,
1115  .pix_fmts = (const enum AVPixelFormat[]){
1131  },
1132  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE |
1134 };
1135 #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:49
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:342
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:1606
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:545
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:442
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:434
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2573
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
static av_cold int encode_init(AVCodecContext *avctx)
Definition: huffyuvenc.c:202
AVOption.
Definition: opt.h:248
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:100
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:436
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:409
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:437
const char * desc
Definition: libsvtav1.c:79
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:218
#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:259
const char * g
Definition: vf_curves.c:117
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
int size
Definition: packet.h:370
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
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:746
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:403
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1565
#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:237
GLfloat v0
Definition: opengl_enc.c:106
AVPacket * pkt
Definition: movenc.c:59
fg index
LLVidEncDSPContext llvidencdsp
Definition: huffyuv.h:93
AVCodec.
Definition: codec.h:197
static const struct @322 planes[]
int height
Definition: huffyuv.h:75
#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:33
#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:41
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:88
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:179
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
int bps
Definition: huffyuv.h:67
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:637
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:433
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:414
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: packet.h:369
attribute_deprecated int context_model
Definition: avcodec.h:1461
#define STATS_OUT_SIZE
int vlc_n
Definition: huffyuv.h:69
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:412
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:1740
#define LOAD2
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1557
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:441
#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:222
#define av_log(a,...)
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:410
uint8_t len[4][MAX_VLC_N]
Definition: huffyuv.h:83
#define src
Definition: vp8dsp.c:255
#define MAX_N
Definition: huffyuv.h:46
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: huffyuvenc.c:751
#define LOAD2_14
av_cold int ff_huffyuv_alloc_temp(HYuvContext *s)
Definition: huffyuv.c:58
enum AVCodecID id
Definition: codec.h:211
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
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:2601
#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:117
const char * r
Definition: vf_curves.c:116
static const AVClass ff_class
Definition: huffyuvenc.c:1077
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:443
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:616
const char * name
Name of the codec implementation.
Definition: codec.h:204
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
static const AVClass normal_class
Definition: huffyuvenc.c:1070
int chroma
Definition: huffyuv.h:71
GLsizei count
Definition: opengl_enc.c:108
#define COMMON_OPTIONS
Definition: huffyuvenc.c:1050
huffyuv codec for libavcodec.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:375
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:84
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:397
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:401
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:418
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:383
#define FFMIN(a, b)
Definition: common.h:105
int width
Definition: huffyuv.h:75
AVCodec ff_huffyuv_encoder
Definition: huffyuvenc.c:1084
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:39
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:296
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
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:438
uint8_t * temp[3]
Definition: huffyuv.h:80
static av_cold int encode_end(AVCodecContext *avctx)
Definition: huffyuvenc.c:1035
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:417
int alpha
Definition: huffyuv.h:70
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:410
#define src1
Definition: h264pred.c:140
#define AV_LOG_INFO
Standard information.
Definition: log.h:205
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:407
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:895
int yuv
Definition: huffyuv.h:72
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
static const AVOption ff_options[]
Definition: huffyuvenc.c:1064
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:536
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:372
#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
int interlaced
Definition: huffyuv.h:61
int extradata_size
Definition: avcodec.h:638
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
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
#define WRITEEND
huffman tree builder and VLC generator
#define STAT2_16
#define src0
Definition: h264pred.c:139
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:396
#define snprintf
Definition: snprintf.h:34
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:303
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:408
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
HuffYUVEncDSPContext hencdsp
Definition: huffyuv.h:91
int version
Definition: huffyuv.h:64
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
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:1047
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:83
common internal api header.
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:147
static int store_huffman_tables(HYuvContext *s, uint8_t *buf)
Definition: huffyuvenc.c:180
#define VE
Definition: huffyuvenc.c:1048
#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:352
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:435
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:1764
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:66
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:300
void * priv_data
Definition: avcodec.h:563
static int put_bytes_left(const PutBitContext *s, int round_up)
Definition: put_bits.h:139
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
int len
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:623
#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:1059
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
static double val(void *priv, double ch)
Definition: aeval.c:76
This structure stores compressed data.
Definition: packet.h:346
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:1601
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:411
for(j=16;j >0;--j)
int i
Definition: input.c:407
bitstream writer API