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);
211  ff_llvidencdsp_init(&s->llvidencdsp);
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 
310  avctx->bits_per_coded_sample = s->bitstream_bpp;
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) {
320  if (s->flags & (AV_CODEC_FLAG_PASS1 | AV_CODEC_FLAG_PASS2)) {
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 
354  if (s->version > 3 && avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
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 
411  ret = store_huffman_tables(s, s->avctx->extradata + s->avctx->extradata_size);
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  }
468  if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT)
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  }
554  if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT)
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  }
590  if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT)
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  }
625  if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT)
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  }
683  if (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT)
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) &&
732  (s->avctx->flags2 & AV_CODEC_FLAG2_NO_OUTPUT)) {
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) {
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 
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 
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);
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 
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  }
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 
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  }
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);
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  }
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 
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 
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 
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 
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;
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
AV_CODEC_CAP_INTRA_ONLY
#define AV_CODEC_CAP_INTRA_ONLY
Codec is intra only.
Definition: avcodec.h:1067
STATEND_16
#define STATEND_16
AV_PIX_FMT_YUVA422P16
#define AV_PIX_FMT_YUVA422P16
Definition: pixfmt.h:430
HYuvContext
Definition: huffyuv.h:55
AVCodec
AVCodec.
Definition: avcodec.h:3481
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:85
stride
int stride
Definition: mace.c:144
FF_CODEC_CAP_INIT_THREADSAFE
#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
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
sub_median_prediction
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
r
const char * r
Definition: vf_curves.c:114
AVERROR
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
opt.h
ff_huffyuvencdsp_init
av_cold void ff_huffyuvencdsp_init(HuffYUVEncDSPContext *c, AVCodecContext *avctx)
Definition: huffyuvencdsp.c:71
WRITE2_16
#define WRITE2_16
AV_CODEC_ID_HUFFYUV
@ AV_CODEC_ID_HUFFYUV
Definition: avcodec.h:243
FF_COMPLIANCE_EXPERIMENTAL
#define FF_COMPLIANCE_EXPERIMENTAL
Allow nonstandardized experimental things.
Definition: avcodec.h:2633
n
int n
Definition: avisynth_c.h:760
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:252
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2522
MAX_VLC_N
#define MAX_VLC_N
Definition: huffyuv.h:47
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:48
OFFSET
#define OFFSET(x)
Definition: huffyuvenc.c:1048
count
void INT64 INT64 count
Definition: avisynth_c.h:767
encode_init
static av_cold int encode_init(AVCodecContext *avctx)
Definition: huffyuvenc.c:202
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
AV_PIX_FMT_YUVA422P9
#define AV_PIX_FMT_YUVA422P9
Definition: pixfmt.h:422
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:208
pixdesc.h
AV_PIX_FMT_YUVA420P16
#define AV_PIX_FMT_YUVA420P16
Definition: pixfmt.h:429
w
uint8_t w
Definition: llviddspenc.c:38
ff_class
static const AVClass ff_class
Definition: huffyuvenc.c:1078
R
#define R
Definition: huffyuvdsp.h:34
internal.h
AVPacket::data
uint8_t * data
Definition: avcodec.h:1477
AV_PIX_FMT_YUVA420P10
#define AV_PIX_FMT_YUVA420P10
Definition: pixfmt.h:424
AVOption
AVOption.
Definition: opt.h:246
b
#define b
Definition: input.c:41
encode_gray_bitstream
static int encode_gray_bitstream(HYuvContext *s, int count)
Definition: huffyuvenc.c:656
data
const char data[16]
Definition: mxf.c:91
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:387
STATS_OUT_SIZE
#define STATS_OUT_SIZE
MEDIAN
@ MEDIAN
Definition: huffyuv.h:52
WRITEEND_16
#define WRITEEND_16
AV_PIX_FMT_YUV440P
@ AV_PIX_FMT_YUV440P
planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
Definition: pixfmt.h:99
AV_CODEC_FLAG_INTERLACED_ME
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:917
AV_PIX_FMT_YUVA422P10
#define AV_PIX_FMT_YUVA422P10
Definition: pixfmt.h:425
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1509
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
ff_huffyuv_alloc_temp
av_cold int ff_huffyuv_alloc_temp(HYuvContext *s)
Definition: huffyuv.c:58
LOADEND_14
#define LOADEND_14
STAT2_16
#define STAT2_16
A
#define A(x)
Definition: vp56_arith.h:28
AV_PIX_FMT_YUVA420P9
#define AV_PIX_FMT_YUVA420P9
Definition: pixfmt.h:421
AVCodecContext::prediction_method
attribute_deprecated int prediction_method
Definition: avcodec.h:1924
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:405
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:215
v0
#define v0
Definition: regdef.h:26
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:1574
sub_left_prediction
static int sub_left_prediction(HYuvContext *s, uint8_t *dst, const uint8_t *src, int w, int left)
Definition: huffyuvenc.c:51
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:403
AV_PIX_FMT_YUVA444P16
#define AV_PIX_FMT_YUVA444P16
Definition: pixfmt.h:431
plane
int plane
Definition: avisynth_c.h:384
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:385
LOAD2
#define LOAD2
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1645
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:373
av_pix_fmt_get_chroma_sub_sample
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
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:371
AV_CODEC_FLAG2_NO_OUTPUT
#define AV_CODEC_FLAG2_NO_OUTPUT
Skip bitstream encoding.
Definition: avcodec.h:927
src
#define src
Definition: vp8dsp.c:254
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:390
store_table
static int store_table(HYuvContext *s, const uint8_t *len, uint8_t *buf)
Definition: huffyuvenc.c:155
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
buf
void * buf
Definition: avisynth_c.h:766
av_cold
#define av_cold
Definition: attributes.h:84
AV_PIX_FMT_YUV422P16
#define AV_PIX_FMT_YUV422P16
Definition: pixfmt.h:399
mask
static const uint16_t mask[17]
Definition: lzw.c:38
sub_left_prediction_bgr32
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
STATEND
#define STATEND
WRITE2
#define WRITE2
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2592
AV_PIX_FMT_YUVA420P
@ AV_PIX_FMT_YUVA420P
planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
Definition: pixfmt.h:101
AV_PIX_FMT_YUV444P16
#define AV_PIX_FMT_YUV444P16
Definition: pixfmt.h:400
g
const char * g
Definition: vf_curves.c:115
sub_left_prediction_rgb24
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
STAT2
#define STAT2
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
normal_class
static const AVClass normal_class
Definition: huffyuvenc.c:1071
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:384
AV_PIX_FMT_YUV420P16
#define AV_PIX_FMT_YUV420P16
Definition: pixfmt.h:398
AV_PIX_FMT_FLAG_ALPHA
#define AV_PIX_FMT_FLAG_ALPHA
The pixel format has an alpha channel.
Definition: pixdesc.h:177
AV_INPUT_BUFFER_MIN_SIZE
#define AV_INPUT_BUFFER_MIN_SIZE
Definition: avcodec.h:797
huffyuvencdsp.h
AV_CODEC_ID_FFVHUFF
@ AV_CODEC_ID_FFVHUFF
Definition: avcodec.h:285
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
WRITE_GBRA
#define WRITE_GBRA
MAX_N
#define MAX_N
Definition: huffyuv.h:46
LOADEND_16
#define LOADEND_16
ff_huffyuv_common_end
av_cold void ff_huffyuv_common_end(HYuvContext *s)
Definition: huffyuv.c:86
context
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 context
Definition: writing_filters.txt:91
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1037
AV_PIX_FMT_GBRP16
#define AV_PIX_FMT_GBRP16
Definition: pixfmt.h:406
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
LOADEND
#define LOADEND
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
NULL
#define NULL
Definition: coverity.c:32
store_huffman_tables
static int store_huffman_tables(HYuvContext *s, uint8_t *buf)
Definition: huffyuvenc.c:180
WRITEEND
#define WRITEEND
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
ff_huff_gen_len_table
int ff_huff_gen_len_table(uint8_t *dst, const uint64_t *stats, int stats_size, int skip0)
Definition: huffman.c:58
ff_huffyuv_generate_bits_table
int ff_huffyuv_generate_bits_table(uint32_t *dst, const uint8_t *len_table, int n)
Definition: huffyuv.c:39
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:388
AVCodecContext::context_model
attribute_deprecated int context_model
Definition: avcodec.h:2488
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:402
diff_bytes
static void diff_bytes(HYuvContext *s, uint8_t *dst, const uint8_t *src0, const uint8_t *src1, int w)
Definition: huffyuvenc.c:41
index
int index
Definition: gxfenc.c:89
encode_end
static av_cold int encode_end(AVCodecContext *avctx)
Definition: huffyuvenc.c:1036
ff_llvidencdsp_init
av_cold void ff_llvidencdsp_init(LLVidEncDSPContext *c)
Definition: lossless_videoencdsp.c:91
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
LOAD2_16
#define LOAD2_16
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2584
desc
const char * desc
Definition: nvenc.c:68
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:378
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
planes
static const struct @314 planes[]
AVPacket::size
int size
Definition: avcodec.h:1478
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:188
LOAD4
#define LOAD4
AV_PIX_FMT_FLAG_RGB
#define AV_PIX_FMT_FLAG_RGB
The pixel format contains RGB-like data (as opposed to YUV/grayscale).
Definition: pixdesc.h:148
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:392
size
int size
Definition: twinvq_data.h:11134
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:394
val
const char const char void * val
Definition: avisynth_c.h:863
AV_CODEC_FLAG_PASS2
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:875
height
#define height
AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:360
a
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:41
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
AV_PIX_FMT_YUVA444P
@ AV_PIX_FMT_YUVA444P
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:177
AV_PIX_FMT_YUVA444P10
#define AV_PIX_FMT_YUVA444P10
Definition: pixfmt.h:426
offset
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
Definition: writing_filters.txt:86
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1483
COMMON_OPTIONS
#define COMMON_OPTIONS
Definition: huffyuvenc.c:1051
src0
#define src0
Definition: h264pred.c:138
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
VE
#define VE
Definition: huffyuvenc.c:1049
AVCodec::id
enum AVCodecID id
Definition: avcodec.h:3495
lossless_videoencdsp.h
src1
#define src1
Definition: h264pred.c:139
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2789
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:259
put_bits_count
static int put_bits_count(PutBitContext *s)
Definition: put_bits.h:85
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1666
encode_422_bitstream
static int encode_422_bitstream(HYuvContext *s, int offset, int count)
Definition: huffyuvenc.c:439
FF_CODEC_CAP_INIT_CLEANUP
#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
normal_options
static const AVOption normal_options[]
Definition: huffyuvenc.c:1060
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:404
uint8_t
uint8_t
Definition: audio_convert.c:194
av_mallocz
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
AVCodec::name
const char * name
Name of the codec implementation.
Definition: avcodec.h:3488
len
int len
Definition: vorbis_enc_data.h:452
PLANE
@ PLANE
Definition: huffyuv.h:51
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1775
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:386
avcodec.h
G
#define G
Definition: huffyuvdsp.h:33
ret
ret
Definition: filter_design.txt:187
AVClass::class_name
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
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:2628
AV_PIX_FMT_YUVA444P9
#define AV_PIX_FMT_YUVA444P9
Definition: pixfmt.h:423
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:391
left
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:386
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:396
B
#define B
Definition: huffyuvdsp.h:32
AVCodecContext::coded_frame
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2815
AVCodecContext
main external API structure.
Definition: avcodec.h:1565
LOAD_GBRA
#define LOAD_GBRA
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Definition: opt.h:223
huffman.h
temp
else temp
Definition: vf_mcdeint.c:256
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:144
ff_options
static const AVOption ff_options[]
Definition: huffyuvenc.c:1065
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
encode_frame
static int encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
Definition: huffyuvenc.c:752
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:84
ff_huffyuv_encoder
AVCodec ff_huffyuv_encoder
Definition: huffyuvenc.c:1085
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
LOAD2_14
#define LOAD2_14
ff_ffvhuff_encoder
AVCodec ff_ffvhuff_encoder
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:101
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
alpha
static const int16_t alpha[]
Definition: ilbcdata.h:55
ff_huffyuv_common_init
av_cold void ff_huffyuv_common_init(AVCodecContext *avctx)
Definition: huffyuv.c:71
AVPacket
This structure stores compressed data.
Definition: avcodec.h:1454
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:1592
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
AV_PIX_FMT_YUV411P
@ AV_PIX_FMT_YUV411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
Definition: pixfmt.h:73
encode_bgra_bitstream
static int encode_bgra_bitstream(HYuvContext *s, int count, int planes)
Definition: huffyuvenc.c:701
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:326
AV_PIX_FMT_YUV410P
@ AV_PIX_FMT_YUV410P
planar YUV 4:1:0, 9bpp, (1 Cr & Cb sample per 4x4 Y samples)
Definition: pixfmt.h:72
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
h
h
Definition: vp9dsp_template.c:2038
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:397
huffyuv.h
ff_alloc_packet2
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
put_bits.h
snprintf
#define snprintf
Definition: snprintf.h:34
encode_plane_bitstream
static int encode_plane_bitstream(HYuvContext *s, int width, int plane)
Definition: huffyuvenc.c:494
AV_PIX_FMT_YUVA422P
@ AV_PIX_FMT_YUVA422P
planar YUV 4:2:2 24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
Definition: pixfmt.h:176
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:395
STAT_BGRA
#define STAT_BGRA
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:871