FFmpeg
magicyuvenc.c
Go to the documentation of this file.
1 /*
2  * MagicYUV encoder
3  * Copyright (c) 2017 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdlib.h>
23 #include <string.h>
24 
25 #include "libavutil/cpu.h"
26 #include "libavutil/mem.h"
27 #include "libavutil/opt.h"
28 #include "libavutil/pixdesc.h"
29 #include "libavutil/qsort.h"
30 
31 #include "avcodec.h"
32 #include "bytestream.h"
33 #include "codec_internal.h"
34 #include "encode.h"
35 #include "put_bits.h"
36 #include "lossless_videoencdsp.h"
37 
38 #define MAGICYUV_EXTRADATA_SIZE 32
39 
40 typedef enum Prediction {
41  LEFT = 1,
44 } Prediction;
45 
46 typedef struct HuffEntry {
47  uint8_t len;
48  uint32_t code;
49 } HuffEntry;
50 
51 typedef struct PTable {
52  int value; ///< input value
53  int64_t prob; ///< number of occurences of this value in input
54 } PTable;
55 
56 typedef struct Slice {
57  int width;
58  int height;
60  unsigned pos;
61  unsigned size;
62  uint8_t *slice;
63  uint8_t *dst;
65 } Slice;
66 
67 typedef struct MagicYUVContext {
68  const AVClass *class;
70  int planes;
71  uint8_t format;
72  int slice_height;
73  int nb_slices;
74  int correlate;
75  int hshift[4];
76  int vshift[4];
77  uint8_t *decorrelate_buf[2];
78  Slice *slices;
79  HuffEntry he[4][256];
81  void (*predict)(struct MagicYUVContext *s, const uint8_t *src, uint8_t *dst,
82  ptrdiff_t stride, int width, int height);
84 
86  const uint8_t *src, uint8_t *dst, ptrdiff_t stride,
87  int width, int height)
88 {
89  uint8_t prev = 0;
90  int i, j;
91 
92  for (i = 0; i < width; i++) {
93  dst[i] = src[i] - prev;
94  prev = src[i];
95  }
96  dst += width;
97  src += stride;
98  for (j = 1; j < height; j++) {
99  prev = src[-stride];
100  for (i = 0; i < width; i++) {
101  dst[i] = src[i] - prev;
102  prev = src[i];
103  }
104  dst += width;
105  src += stride;
106  }
107 }
108 
110  const uint8_t *src, uint8_t *dst, ptrdiff_t stride,
111  int width, int height)
112 {
113  int left = 0, top, lefttop;
114  int i, j;
115 
116  for (i = 0; i < width; i++) {
117  dst[i] = src[i] - left;
118  left = src[i];
119  }
120  dst += width;
121  src += stride;
122  for (j = 1; j < height; j++) {
123  top = src[-stride];
124  left = src[0] - top;
125  dst[0] = left;
126  for (i = 1; i < width; i++) {
127  top = src[i - stride];
128  lefttop = src[i - (stride + 1)];
129  left = src[i-1];
130  dst[i] = (src[i] - top) - left + lefttop;
131  }
132  dst += width;
133  src += stride;
134  }
135 }
136 
138  const uint8_t *src, uint8_t *dst, ptrdiff_t stride,
139  int width, int height)
140 {
141  int left = 0, lefttop;
142  int i, j;
143 
144  for (i = 0; i < width; i++) {
145  dst[i] = src[i] - left;
146  left = src[i];
147  }
148  dst += width;
149  src += stride;
150  for (j = 1; j < height; j++) {
151  left = lefttop = src[-stride];
152  s->llvidencdsp.sub_median_pred(dst, src - stride, src, width, &left, &lefttop);
153  dst += width;
154  src += stride;
155  }
156 }
157 
159 {
160  MagicYUVContext *s = avctx->priv_data;
161  PutByteContext pb;
162 
163  switch (avctx->pix_fmt) {
164  case AV_PIX_FMT_GBRP:
165  avctx->codec_tag = MKTAG('M', '8', 'R', 'G');
166  s->correlate = 1;
167  s->format = 0x65;
168  break;
169  case AV_PIX_FMT_GBRAP:
170  avctx->codec_tag = MKTAG('M', '8', 'R', 'A');
171  s->correlate = 1;
172  s->format = 0x66;
173  break;
174  case AV_PIX_FMT_YUV420P:
175  avctx->codec_tag = MKTAG('M', '8', 'Y', '0');
176  s->hshift[1] =
177  s->vshift[1] =
178  s->hshift[2] =
179  s->vshift[2] = 1;
180  s->format = 0x69;
181  break;
182  case AV_PIX_FMT_YUV422P:
183  avctx->codec_tag = MKTAG('M', '8', 'Y', '2');
184  s->hshift[1] =
185  s->hshift[2] = 1;
186  s->format = 0x68;
187  break;
188  case AV_PIX_FMT_YUV444P:
189  avctx->codec_tag = MKTAG('M', '8', 'Y', '4');
190  s->format = 0x67;
191  break;
192  case AV_PIX_FMT_YUVA444P:
193  avctx->codec_tag = MKTAG('M', '8', 'Y', 'A');
194  s->format = 0x6a;
195  break;
196  case AV_PIX_FMT_GRAY8:
197  avctx->codec_tag = MKTAG('M', '8', 'G', '0');
198  s->format = 0x6b;
199  break;
200  }
201 
202  ff_llvidencdsp_init(&s->llvidencdsp);
203 
204  s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
205 
206  s->nb_slices = avctx->slices > 0 ? avctx->slices : avctx->thread_count;
207  s->nb_slices = FFMIN(s->nb_slices, avctx->height >> s->vshift[1]);
208  s->nb_slices = FFMAX(1, s->nb_slices);
209  s->slice_height = FFALIGN((avctx->height + s->nb_slices - 1) / s->nb_slices, 1 << s->vshift[1]);
210  s->nb_slices = (avctx->height + s->slice_height - 1) / s->slice_height;
211  s->nb_slices = FFMIN(256U / s->planes, s->nb_slices);
212  s->slices = av_calloc(s->nb_slices * s->planes, sizeof(*s->slices));
213  if (!s->slices)
214  return AVERROR(ENOMEM);
215 
216  if (s->correlate) {
217  size_t max_align = av_cpu_max_align();
218  size_t aligned_width = FFALIGN(avctx->width, max_align);
219  s->decorrelate_buf[0] = av_calloc(2U * (s->nb_slices * s->slice_height),
220  aligned_width);
221  if (!s->decorrelate_buf[0])
222  return AVERROR(ENOMEM);
223  s->decorrelate_buf[1] = s->decorrelate_buf[0] + (s->nb_slices * s->slice_height) * aligned_width;
224  }
225 
226  for (int n = 0; n < s->nb_slices; n++) {
227  for (int i = 0; i < s->planes; i++) {
228  Slice *sl = &s->slices[n * s->planes + i];
229 
230  sl->height = n == s->nb_slices - 1 ? avctx->height - n * s->slice_height : s->slice_height;
231  sl->height = AV_CEIL_RSHIFT(sl->height, s->vshift[i]);
232  sl->width = AV_CEIL_RSHIFT(avctx->width, s->hshift[i]);
233 
234  sl->slice = av_malloc(avctx->width * (s->slice_height + 2) +
236  if (!sl->slice)
237  return AVERROR(ENOMEM);
238  }
239  }
240 
241  switch (s->frame_pred) {
242  case LEFT: s->predict = left_predict; break;
243  case GRADIENT: s->predict = gradient_predict; break;
244  case MEDIAN: s->predict = median_predict; break;
245  }
246 
248 
249  avctx->extradata = av_mallocz(avctx->extradata_size +
251  if (!avctx->extradata)
252  return AVERROR(ENOMEM);
253 
255  bytestream2_put_le32u(&pb, MKTAG('M', 'A', 'G', 'Y'));
256  bytestream2_put_le32u(&pb, 32);
257  bytestream2_put_byteu(&pb, 7);
258  bytestream2_put_byteu(&pb, s->format);
259  bytestream2_put_byteu(&pb, 12);
260  bytestream2_put_byteu(&pb, 0);
261 
262  bytestream2_put_byteu(&pb, 0);
263  bytestream2_put_byteu(&pb, 0);
264  bytestream2_put_byteu(&pb, 32);
265  bytestream2_put_byteu(&pb, 0);
266 
267  bytestream2_put_le32u(&pb, avctx->width);
268  bytestream2_put_le32u(&pb, avctx->height);
269  bytestream2_put_le32u(&pb, avctx->width);
270  bytestream2_put_le32u(&pb, avctx->height);
271 
272  return 0;
273 }
274 
275 static void calculate_codes(HuffEntry *he, uint16_t codes_count[33])
276 {
277  for (unsigned i = 32, nb_codes = 0; i > 0; i--) {
278  uint16_t curr = codes_count[i]; // # of leafs of length i
279  codes_count[i] = nb_codes / 2; // # of non-leaf nodes on level i
280  nb_codes = codes_count[i] + curr; // # of nodes on level i
281  }
282 
283  for (unsigned i = 0; i < 256; i++) {
284  he[i].code = codes_count[he[i].len];
285  codes_count[he[i].len]++;
286  }
287 }
288 
289 static void count_usage(const uint8_t *src, int width,
290  int height, int64_t *counts)
291 {
292  for (int j = 0; j < height; j++) {
293  for (int i = 0; i < width; i++)
294  counts[src[i]]++;
295  src += width;
296  }
297 }
298 
299 typedef struct PackageMergerList {
300  int nitems; ///< number of items in the list and probability ex. 4
301  int item_idx[515]; ///< index range for each item in items 0, 2, 5, 9, 13
302  int probability[514]; ///< probability of each item 3, 8, 18, 46
303  int items[257 * 16]; ///< chain of all individual values that make up items A, B, A, B, C, A, B, C, D, C, D, D, E
305 
306 static int compare_by_prob(const void *a, const void *b)
307 {
308  const PTable *a2 = a;
309  const PTable *b2 = b;
310  return a2->prob - b2->prob;
311 }
312 
313 static void magy_huffman_compute_bits(PTable *prob_table, HuffEntry *distincts,
314  uint16_t codes_counts[33],
315  int size, int max_length)
316 {
317  PackageMergerList list_a, list_b, *to = &list_a, *from = &list_b, *temp;
318  int times, i, j, k;
319  int nbits[257] = {0};
320  int min;
321 
322  av_assert0(max_length > 0);
323 
324  to->nitems = 0;
325  from->nitems = 0;
326  to->item_idx[0] = 0;
327  from->item_idx[0] = 0;
328  AV_QSORT(prob_table, size, PTable, compare_by_prob);
329 
330  for (times = 0; times <= max_length; times++) {
331  to->nitems = 0;
332  to->item_idx[0] = 0;
333 
334  j = 0;
335  k = 0;
336 
337  if (times < max_length) {
338  i = 0;
339  }
340  while (i < size || j + 1 < from->nitems) {
341  to->nitems++;
342  to->item_idx[to->nitems] = to->item_idx[to->nitems - 1];
343  if (i < size &&
344  (j + 1 >= from->nitems ||
345  prob_table[i].prob <
346  from->probability[j] + from->probability[j + 1])) {
347  to->items[to->item_idx[to->nitems]++] = prob_table[i].value;
348  to->probability[to->nitems - 1] = prob_table[i].prob;
349  i++;
350  } else {
351  for (k = from->item_idx[j]; k < from->item_idx[j + 2]; k++) {
352  to->items[to->item_idx[to->nitems]++] = from->items[k];
353  }
354  to->probability[to->nitems - 1] =
355  from->probability[j] + from->probability[j + 1];
356  j += 2;
357  }
358  }
359  temp = to;
360  to = from;
361  from = temp;
362  }
363 
364  min = (size - 1 < from->nitems) ? size - 1 : from->nitems;
365  for (i = 0; i < from->item_idx[min]; i++) {
366  nbits[from->items[i]]++;
367  }
368 
369  for (i = 0; i < size; i++) {
370  distincts[i].len = nbits[i];
371  codes_counts[nbits[i]]++;
372  }
373 }
374 
375 static int count_plane_slice(AVCodecContext *avctx, int n, int plane)
376 {
377  MagicYUVContext *s = avctx->priv_data;
378  Slice *sl = &s->slices[n * s->planes + plane];
379  const uint8_t *dst = sl->slice;
380  int64_t *counts = sl->counts;
381 
382  memset(counts, 0, sizeof(sl->counts));
383 
384  count_usage(dst, sl->width, sl->height, counts);
385 
386  return 0;
387 }
388 
389 static void generate_codes(AVCodecContext *avctx,
390  HuffEntry *he, int plane)
391 {
392  MagicYUVContext *s = avctx->priv_data;
393  PTable counts[256];
394  uint16_t codes_counts[33] = { 0 };
395 
396  for (size_t i = 0; i < FF_ARRAY_ELEMS(counts); i++) {
397  counts[i].prob = 1;
398  counts[i].value = i;
399  }
400 
401  for (int n = 0; n < s->nb_slices; n++) {
402  Slice *sl = &s->slices[n * s->planes + plane];
403  int64_t *slice_counts = sl->counts;
404 
405  for (int i = 0; i < 256; i++)
406  counts[i].prob += slice_counts[i];
407  }
408 
409  magy_huffman_compute_bits(counts, he, codes_counts, 256, 12);
410 
411  calculate_codes(he, codes_counts);
412 }
413 
414 static void output_codes(PutByteContext *pb, const HuffEntry he[256])
415 {
416  for (int i = 0; i < 256; i++) {
417  // The seven low bits are len; the top bit means the run of
418  // codes of this length has length one.
419  bytestream2_put_byteu(pb, he[i].len);
420  }
421 }
422 
423 static void encode_plane_slice_raw(const uint8_t *src, uint8_t *dst,
424  int width, int height, int prediction)
425 {
426  unsigned count = width * height;
427 
428  dst[0] = 1;
429  dst[1] = prediction;
430 
431  memcpy(dst + 2, src, count);
432 }
433 
434 static void encode_plane_slice(const uint8_t *src, uint8_t *dst, unsigned dst_size,
435  int width, int height, HuffEntry *he, int prediction)
436 {
437  PutBitContext pb;
438 
439  init_put_bits(&pb, dst, dst_size);
440 
441  put_bits(&pb, 8, 0);
442  put_bits(&pb, 8, prediction);
443 
444  for (int j = 0; j < height; j++) {
445  for (int i = 0; i < width; i++) {
446  const int idx = src[i];
447  const int len = he[idx].len;
448  put_bits(&pb, len, he[idx].code);
449  }
450 
451  src += width;
452  }
453 
454  flush_put_bits(&pb);
455  av_assert1(put_bytes_left(&pb, 0) <= 3);
456 }
457 
458 static int encode_slice(AVCodecContext *avctx, void *tdata,
459  int n, int threadnr)
460 {
461  MagicYUVContext *s = avctx->priv_data;
462 
463  for (int i = 0; i < s->planes; i++) {
464  Slice *sl = &s->slices[n * s->planes + i];
465 
466  // Zero the padding now
467  AV_WN32(sl->dst + sl->size - 4, 0);
468 
469  if (sl->encode_raw)
471  sl->width, sl->height, s->frame_pred);
472  else
474  sl->dst,
475  sl->size,
476  sl->width, sl->height,
477  s->he[i], s->frame_pred);
478  }
479 
480  return 0;
481 }
482 
483 static int predict_slice(AVCodecContext *avctx, void *tdata,
484  int n, int threadnr)
485 {
486  size_t max_align = av_cpu_max_align();
487  const int aligned_width = FFALIGN(avctx->width, max_align);
488  MagicYUVContext *s = avctx->priv_data;
489  const int slice_height = s->slice_height;
490  const int last_height = FFMIN(slice_height, avctx->height - n * slice_height);
491  const int height = (n < (s->nb_slices - 1)) ? slice_height : last_height;
492  const int width = avctx->width;
493  AVFrame *frame = tdata;
494 
495  if (s->correlate) {
496  uint8_t *decorrelated[2] = { s->decorrelate_buf[0] + n * slice_height * aligned_width,
497  s->decorrelate_buf[1] + n * slice_height * aligned_width };
498  const int decorrelate_linesize = aligned_width;
499  const uint8_t *const data[4] = { decorrelated[0], frame->data[0] + n * slice_height * frame->linesize[0],
500  decorrelated[1], s->planes == 4 ? frame->data[3] + n * slice_height * frame->linesize[3] : NULL };
501  const uint8_t *r, *g, *b;
502  const int linesize[4] = { decorrelate_linesize, frame->linesize[0],
503  decorrelate_linesize, frame->linesize[3] };
504 
505  g = frame->data[0] + n * slice_height * frame->linesize[0];
506  b = frame->data[1] + n * slice_height * frame->linesize[1];
507  r = frame->data[2] + n * slice_height * frame->linesize[2];
508 
509  for (int i = 0; i < height; i++) {
510  s->llvidencdsp.diff_bytes(decorrelated[0], b, g, width);
511  s->llvidencdsp.diff_bytes(decorrelated[1], r, g, width);
512  g += frame->linesize[0];
513  b += frame->linesize[1];
514  r += frame->linesize[2];
515  decorrelated[0] += decorrelate_linesize;
516  decorrelated[1] += decorrelate_linesize;
517  }
518 
519  for (int i = 0; i < s->planes; i++) {
520  Slice *sl = &s->slices[n * s->planes + i];
521 
522  s->predict(s, data[i], sl->slice, linesize[i],
523  frame->width, height);
524  }
525  } else {
526  for (int i = 0; i < s->planes; i++) {
527  Slice *sl = &s->slices[n * s->planes + i];
528 
529  s->predict(s, frame->data[i] + n * (slice_height >> s->vshift[i]) * frame->linesize[i],
530  sl->slice,
531  frame->linesize[i],
532  sl->width, sl->height);
533  }
534  }
535 
536  for (int p = 0; p < s->planes; p++)
537  count_plane_slice(avctx, n, p);
538 
539  return 0;
540 }
541 
543  const AVFrame *frame, int *got_packet)
544 {
545  MagicYUVContext *s = avctx->priv_data;
546  PutByteContext pb;
547  int header_size = 32 + (4 + 1) * (s->planes * s->nb_slices + 1)
548  + 256 * s->planes /* Hufftables */;
549  int64_t pkt_size = header_size;
550  int ret;
551 
552  avctx->execute2(avctx, predict_slice, (void *)frame, NULL, s->nb_slices);
553 
554  for (int i = 0; i < s->planes; i++)
555  generate_codes(avctx, s->he[i], i);
556 
557  for (int i = 0; i < s->nb_slices; ++i) {
558  for (int j = 0; j < s->planes; ++j) {
559  Slice *const sl = &s->slices[i * s->planes + j];
560  int64_t size = 0;
561 
562  for (size_t k = 0; k < FF_ARRAY_ELEMS(sl->counts); ++k)
563  size += sl->counts[k] * s->he[j][k].len;
564  size = AV_CEIL_RSHIFT(size, 3);
565  sl->encode_raw = size >= sl->width * sl->height;
566  if (sl->encode_raw)
567  size = sl->width * sl->height;
568  sl->size = FFALIGN(size + 2, 4);
569  sl->pos = pkt_size;
570  pkt_size += sl->size;
571  }
572  }
573 
574  ret = ff_get_encode_buffer(avctx, pkt, pkt_size, 0);
575  if (ret < 0)
576  return ret;
577 
579  bytestream2_put_le32u(&pb, MKTAG('M', 'A', 'G', 'Y'));
580  bytestream2_put_le32u(&pb, 32); // header size
581  bytestream2_put_byteu(&pb, 7); // version
582  bytestream2_put_byteu(&pb, s->format);
583  bytestream2_put_byteu(&pb, 12); // max huffman length
584  bytestream2_put_byteu(&pb, 0);
585 
586  bytestream2_put_byteu(&pb, 0);
587  bytestream2_put_byteu(&pb, 0);
588  bytestream2_put_byteu(&pb, 32); // coder type
589  bytestream2_put_byteu(&pb, 0);
590 
591  bytestream2_put_le32u(&pb, avctx->width);
592  bytestream2_put_le32u(&pb, avctx->height);
593  bytestream2_put_le32u(&pb, avctx->width);
594  bytestream2_put_le32u(&pb, s->slice_height);
595 
596  // Slice position is relative to the current position (i.e. 32)
597  bytestream2_put_le32u(&pb, header_size - 32);
598 
599  for (int i = 0; i < s->planes; ++i) {
600  for (int j = 0; j < s->nb_slices; ++j) {
601  Slice *const sl = &s->slices[j * s->planes + i];
602  bytestream2_put_le32u(&pb, sl->pos - 32);
603  sl->dst = pkt->data + sl->pos;
604  }
605  }
606 
607  bytestream2_put_byteu(&pb, s->planes);
608 
609  for (int i = 0; i < s->planes; i++) {
610  for (int n = 0; n < s->nb_slices; n++)
611  bytestream2_put_byteu(&pb, n * s->planes + i);
612  }
613 
614  for (int i = 0; i < s->planes; ++i)
615  output_codes(&pb, s->he[i]);
616 
617  avctx->execute2(avctx, encode_slice, NULL, NULL, s->nb_slices);
618 
619  *got_packet = 1;
620 
621  return 0;
622 }
623 
625 {
626  MagicYUVContext *s = avctx->priv_data;
627 
628  if (s->slices) {
629  for (int i = 0; i < s->planes * s->nb_slices; i++) {
630  Slice *sl = &s->slices[i];
631 
632  av_freep(&sl->slice);
633  }
634  av_freep(&s->slices);
635  }
636  av_freep(&s->decorrelate_buf);
637 
638  return 0;
639 }
640 
641 #define OFFSET(x) offsetof(MagicYUVContext, x)
642 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
643 static const AVOption options[] = {
644  { "pred", "Prediction method", OFFSET(frame_pred), AV_OPT_TYPE_INT, {.i64=LEFT}, LEFT, MEDIAN, VE, .unit = "pred" },
645  { "left", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = LEFT }, 0, 0, VE, .unit = "pred" },
646  { "gradient", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = GRADIENT }, 0, 0, VE, .unit = "pred" },
647  { "median", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = MEDIAN }, 0, 0, VE, .unit = "pred" },
648  { NULL},
649 };
650 
651 static const AVClass magicyuv_class = {
652  .class_name = "magicyuv",
653  .item_name = av_default_item_name,
654  .option = options,
655  .version = LIBAVUTIL_VERSION_INT,
656 };
657 
659  .p.name = "magicyuv",
660  CODEC_LONG_NAME("MagicYUV video"),
661  .p.type = AVMEDIA_TYPE_VIDEO,
662  .p.id = AV_CODEC_ID_MAGICYUV,
663  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
666  .priv_data_size = sizeof(MagicYUVContext),
667  .p.priv_class = &magicyuv_class,
668  .init = magy_encode_init,
669  .close = magy_encode_close,
674  .color_ranges = AVCOL_RANGE_MPEG, /* FIXME: implement tagging */
675  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP,
676 };
Slice::encode_raw
int encode_raw
Definition: magicyuvenc.c:59
CODEC_PIXFMTS
#define CODEC_PIXFMTS(...)
Definition: codec_internal.h:386
GRADIENT
@ GRADIENT
Definition: magicyuvenc.c:42
generate_codes
static void generate_codes(AVCodecContext *avctx, HuffEntry *he, int plane)
Definition: magicyuvenc.c:389
VE
#define VE
Definition: magicyuvenc.c:642
Slice::counts
int64_t counts[256]
Definition: magicyuvenc.c:64
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: codec_internal.h:42
r
const char * r
Definition: vf_curves.c:127
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
Prediction
Definition: aptx.h:70
Slice::dst
uint8_t * dst
Definition: magicyuvenc.c:63
HuffEntry::len
uint8_t len
Definition: exr.c:97
MagicYUVContext::nb_slices
int nb_slices
Definition: magicyuv.c:61
ff_magicyuv_encoder
const FFCodec ff_magicyuv_encoder
Definition: magicyuvenc.c:658
compare_by_prob
static int compare_by_prob(const void *a, const void *b)
Definition: magicyuvenc.c:306
MagicYUVContext::hshift
int hshift[4]
Definition: magicyuv.c:68
left_predict
static void left_predict(MagicYUVContext *s, const uint8_t *src, uint8_t *dst, ptrdiff_t stride, int width, int height)
Definition: magicyuvenc.c:85
int64_t
long long int64_t
Definition: coverity.c:34
init_put_bits
static void init_put_bits(PutBitContext *s, uint8_t *buffer, int buffer_size)
Initialize the PutBitContext s.
Definition: put_bits.h:62
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:410
put_bits
static void put_bits(Jpeg2000EncoderContext *s, int val, int n)
put n times val bit
Definition: j2kenc.c:223
pixdesc.h
Slice::slice
uint8_t * slice
Definition: magicyuvenc.c:62
AVPacket::data
uint8_t * data
Definition: packet.h:535
AVOption
AVOption.
Definition: opt.h:429
encode.h
b
#define b
Definition: input.c:42
PackageMergerList::item_idx
int item_idx[515]
index range for each item in items 0, 2, 5, 9, 13
Definition: magicyuvenc.c:301
data
const char data[16]
Definition: mxf.c:149
FFCodec
Definition: codec_internal.h:127
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
Slice::size
uint32_t size
Definition: magicyuv.c:42
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
MagicYUVContext
Definition: magicyuv.c:56
output_codes
static void output_codes(PutByteContext *pb, const HuffEntry he[256])
Definition: magicyuvenc.c:414
av_pix_fmt_count_planes
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3381
MagicYUVContext::llvidencdsp
LLVidEncDSPContext llvidencdsp
Definition: magicyuvenc.c:80
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AV_PIX_FMT_GBRAP
@ AV_PIX_FMT_GBRAP
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:212
magy_encode_frame
static int magy_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet)
Definition: magicyuvenc.c:542
AVCodecContext::thread_count
int thread_count
thread count is used to decide how many independent tasks should be passed to execute()
Definition: avcodec.h:1561
calculate_codes
static void calculate_codes(HuffEntry *he, uint16_t codes_count[33])
Definition: magicyuvenc.c:275
count_plane_slice
static int count_plane_slice(AVCodecContext *avctx, int n, int plane)
Definition: magicyuvenc.c:375
MagicYUVContext::predict
void(* predict)(struct MagicYUVContext *s, const uint8_t *src, uint8_t *dst, ptrdiff_t stride, int width, int height)
Definition: magicyuvenc.c:81
a2
static double a2(void *priv, double x, double y)
Definition: vf_xfade.c:2030
FF_CODEC_ENCODE_CB
#define FF_CODEC_ENCODE_CB(func)
Definition: codec_internal.h:353
put_bytes_left
static int put_bytes_left(const PutBitContext *s, int round_up)
Definition: put_bits.h:135
magicyuv_class
static const AVClass magicyuv_class
Definition: magicyuvenc.c:651
Slice::width
int width
Definition: magicyuvenc.c:57
OFFSET
#define OFFSET(x)
Definition: magicyuvenc.c:641
pkt
AVPacket * pkt
Definition: movenc.c:60
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
av_cold
#define av_cold
Definition: attributes.h:90
bytestream2_init_writer
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:515
MEDIAN
@ MEDIAN
Definition: magicyuvenc.c:43
Prediction
Prediction
Definition: magicyuvenc.c:40
Slice::size
unsigned size
Definition: magicyuvenc.c:61
s
#define s(width, name)
Definition: cbs_vp9.c:198
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
g
const char * g
Definition: vf_curves.c:128
PackageMergerList::nitems
int nitems
number of items in the list and probability ex. 4
Definition: magicyuvenc.c:300
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:144
from
const char * from
Definition: jacosubdec.c:66
to
const char * to
Definition: webvttdec.c:35
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
Slice
Definition: magicyuv.c:40
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:73
PTable::prob
int64_t prob
number of occurences of this value in input
Definition: magicyuvenc.c:53
median_predict
static void median_predict(MagicYUVContext *s, const uint8_t *src, uint8_t *dst, ptrdiff_t stride, int width, int height)
Definition: magicyuvenc.c:137
PutBitContext
Definition: put_bits.h:50
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:326
Slice::height
int height
Definition: magicyuvenc.c:58
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:95
count_usage
static void count_usage(const uint8_t *src, int width, int height, int64_t *counts)
Definition: magicyuvenc.c:289
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
MagicYUVContext::vshift
int vshift[4]
Definition: magicyuv.c:69
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:76
PTable
Used to assign a occurrence count or "probability" to an input value.
Definition: magicyuvenc.c:51
NULL
#define NULL
Definition: coverity.c:32
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:240
options
Definition: swscale.c:43
av_cpu_max_align
size_t av_cpu_max_align(void)
Get the maximum data alignment that may be required by FFmpeg.
Definition: cpu.c:280
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:81
MagicYUVContext::slices
Slice * slices[4]
Definition: magicyuv.c:70
MagicYUVContext::correlate
int correlate
Definition: magicyuvenc.c:74
AV_CODEC_ID_MAGICYUV
@ AV_CODEC_ID_MAGICYUV
Definition: codec_id.h:274
Slice::pos
unsigned pos
Definition: magicyuvenc.c:60
ff_llvidencdsp_init
av_cold void ff_llvidencdsp_init(LLVidEncDSPContext *c)
Definition: lossless_videoencdsp.c:100
MagicYUVContext::he
HuffEntry he[1<< 14]
Definition: magicyuv.c:77
PutByteContext
Definition: bytestream.h:37
qsort.h
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
PackageMergerList
Used to store intermediate lists in the package merge algorithm.
Definition: magicyuvenc.c:299
AVPacket::size
int size
Definition: packet.h:536
height
#define height
Definition: dsp.h:85
codec_internal.h
AV_WN32
#define AV_WN32(p, v)
Definition: intreadwrite.h:372
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
cpu.h
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
options
static const AVOption options[]
Definition: magicyuvenc.c:643
size
int size
Definition: twinvq_data.h:10344
prediction
static int64_t prediction(int delta, ChannelContext *c)
Definition: misc4.c:78
b2
static double b2(void *priv, double x, double y)
Definition: vf_xfade.c:2035
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
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:174
MagicYUVContext::slice_height
int slice_height
Definition: magicyuv.c:60
AV_CODEC_CAP_SLICE_THREADS
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: codec.h:99
PTable::value
int value
input value
Definition: magicyuvenc.c:52
magy_encode_close
static av_cold int magy_encode_close(AVCodecContext *avctx)
Definition: magicyuvenc.c:624
lossless_videoencdsp.h
MagicYUVContext::frame_pred
int frame_pred
Definition: magicyuvenc.c:69
encode_plane_slice
static void encode_plane_slice(const uint8_t *src, uint8_t *dst, unsigned dst_size, int width, int height, HuffEntry *he, int prediction)
Definition: magicyuvenc.c:434
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
AV_QSORT
#define AV_QSORT(p, num, type, cmp)
Quicksort This sort is fast, and fully inplace but not stable and it is possible to construct input t...
Definition: qsort.h:33
AVCodecContext::extradata
uint8_t * extradata
Out-of-band global headers that may be used by some codecs.
Definition: avcodec.h:514
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:179
PackageMergerList::items
int items[257 *16]
chain of all individual values that make up items A, B, A, B, C, A, B, C, D, C, D,...
Definition: magicyuvenc.c:303
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:592
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:631
LLVidEncDSPContext
Definition: lossless_videoencdsp.h:25
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:733
av_calloc
void * av_calloc(size_t nmemb, size_t size)
Definition: mem.c:264
LEFT
@ LEFT
Definition: magicyuvenc.c:41
avcodec.h
stride
#define stride
Definition: h264pred_template.c:536
MAGICYUV_EXTRADATA_SIZE
#define MAGICYUV_EXTRADATA_SIZE
Definition: magicyuvenc.c:38
ret
ret
Definition: filter_design.txt:187
MagicYUVContext::decorrelate_buf
uint8_t * decorrelate_buf[2]
Definition: magicyuvenc.c:77
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:81
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
encode_slice
static int encode_slice(AVCodecContext *avctx, void *tdata, int n, int threadnr)
Definition: magicyuvenc.c:458
prob
#define prob(name, subs,...)
Definition: cbs_vp9.c:325
HuffEntry::code
uint32_t code
Definition: exr.c:99
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
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
U
#define U(x)
Definition: vpx_arith.h:37
AVCodecContext
main external API structure.
Definition: avcodec.h:431
predict_slice
static int predict_slice(AVCodecContext *avctx, void *tdata, int n, int threadnr)
Definition: magicyuvenc.c:483
magy_encode_init
static av_cold int magy_encode_init(AVCodecContext *avctx)
Definition: magicyuvenc.c:158
PackageMergerList::probability
int probability[514]
probability of each item 3, 8, 18, 46
Definition: magicyuvenc.c:302
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:106
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
HuffEntry
Definition: exr.c:96
temp
else temp
Definition: vf_mcdeint.c:263
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:78
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
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:77
mem.h
flush_put_bits
static void flush_put_bits(PutBitContext *s)
Pad the end of the output stream with zeros.
Definition: put_bits.h:143
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:456
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVCodecContext::slices
int slices
Number of slices.
Definition: avcodec.h:1021
AVPacket
This structure stores compressed data.
Definition: packet.h:512
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:458
MagicYUVContext::planes
int planes
Definition: magicyuv.c:62
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
encode_plane_slice_raw
static void encode_plane_slice_raw(const uint8_t *src, uint8_t *dst, int width, int height, int prediction)
Definition: magicyuvenc.c:423
gradient_predict
static void gradient_predict(MagicYUVContext *s, const uint8_t *src, uint8_t *dst, ptrdiff_t stride, int width, int height)
Definition: magicyuvenc.c:109
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:592
bytestream.h
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
width
#define width
Definition: dsp.h:85
put_bits.h
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
AVCodecContext::execute2
int(* execute2)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg, int jobnr, int threadnr), void *arg2, int *ret, int count)
The codec may call this to execute several independent things.
Definition: avcodec.h:1610
src
#define src
Definition: vp8dsp.c:248
magy_huffman_compute_bits
static void magy_huffman_compute_bits(PTable *prob_table, HuffEntry *distincts, uint16_t codes_counts[33], int size, int max_length)
Definition: magicyuvenc.c:313
MagicYUVContext::format
uint8_t format
Definition: magicyuvenc.c:71
min
float min
Definition: vorbis_enc_data.h:429