FFmpeg  3.4.9
magicyuv.c
Go to the documentation of this file.
1 /*
2  * MagicYUV decoder
3  * Copyright (c) 2016 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/pixdesc.h"
26 #include "libavutil/qsort.h"
27 
28 #include "avcodec.h"
29 #include "bytestream.h"
30 #include "get_bits.h"
31 #include "huffyuvdsp.h"
32 #include "internal.h"
33 #include "lossless_videodsp.h"
34 #include "thread.h"
35 
36 typedef struct Slice {
37  uint32_t start;
38  uint32_t size;
39 } Slice;
40 
41 typedef enum Prediction {
42  LEFT = 1,
45 } Prediction;
46 
47 typedef struct HuffEntry {
48  uint16_t sym;
50  uint32_t code;
51 } HuffEntry;
52 
53 typedef struct MagicYUVContext {
55  int max;
56  int bps;
58  int nb_slices;
59  int planes; // number of encoded planes in bitstream
60  int decorrelate; // postprocessing work
61  int color_matrix; // video color matrix
62  int flags;
63  int interlaced; // video is interlaced
64  uint8_t *buf; // pointer to AVPacket->data
65  int hshift[4];
66  int vshift[4];
67  Slice *slices[4]; // slice bitstream positions for each plane
68  unsigned int slices_size[4]; // slice sizes for each plane
69  uint8_t len[4][4096]; // table of code lengths for each plane
70  VLC vlc[4]; // VLC for each plane
72  int (*magy_decode_slice)(AVCodecContext *avctx, void *tdata,
73  int j, int threadnr);
76 
77 static int huff_cmp_len(const void *a, const void *b)
78 {
79  const HuffEntry *aa = a, *bb = b;
80  return (aa->len - bb->len) * 256 + aa->sym - bb->sym;
81 }
82 
83 static int huff_cmp_len10(const void *a, const void *b)
84 {
85  const HuffEntry *aa = a, *bb = b;
86  return (aa->len - bb->len) * 1024 + aa->sym - bb->sym;
87 }
88 
89 static int huff_cmp_len12(const void *a, const void *b)
90 {
91  const HuffEntry *aa = a, *bb = b;
92  return (aa->len - bb->len) * 4096 + aa->sym - bb->sym;
93 }
94 
95 static int huff_build10(VLC *vlc, uint8_t *len)
96 {
97  HuffEntry he[1024];
98  uint32_t codes[1024];
99  uint8_t bits[1024];
100  uint16_t syms[1024];
101  uint32_t code;
102  int i;
103 
104  for (i = 0; i < 1024; i++) {
105  he[i].sym = 1023 - i;
106  he[i].len = len[i];
107  if (len[i] == 0 || len[i] > 32)
108  return AVERROR_INVALIDDATA;
109  }
110  AV_QSORT(he, 1024, HuffEntry, huff_cmp_len10);
111 
112  code = 1;
113  for (i = 1023; i >= 0; i--) {
114  codes[i] = code >> (32 - he[i].len);
115  bits[i] = he[i].len;
116  syms[i] = he[i].sym;
117  code += 0x80000000u >> (he[i].len - 1);
118  }
119 
120  ff_free_vlc(vlc);
121  return ff_init_vlc_sparse(vlc, FFMIN(he[1023].len, 12), 1024,
122  bits, sizeof(*bits), sizeof(*bits),
123  codes, sizeof(*codes), sizeof(*codes),
124  syms, sizeof(*syms), sizeof(*syms), 0);
125 }
126 
127 static int huff_build12(VLC *vlc, uint8_t *len)
128 {
129  HuffEntry he[4096];
130  uint32_t codes[4096];
131  uint8_t bits[4096];
132  uint16_t syms[4096];
133  uint32_t code;
134  int i;
135 
136  for (i = 0; i < 4096; i++) {
137  he[i].sym = 4095 - i;
138  he[i].len = len[i];
139  if (len[i] == 0 || len[i] > 32)
140  return AVERROR_INVALIDDATA;
141  }
142  AV_QSORT(he, 4096, HuffEntry, huff_cmp_len12);
143 
144  code = 1;
145  for (i = 4095; i >= 0; i--) {
146  codes[i] = code >> (32 - he[i].len);
147  bits[i] = he[i].len;
148  syms[i] = he[i].sym;
149  code += 0x80000000u >> (he[i].len - 1);
150  }
151 
152  ff_free_vlc(vlc);
153  return ff_init_vlc_sparse(vlc, FFMIN(he[4095].len, 14), 4096,
154  bits, sizeof(*bits), sizeof(*bits),
155  codes, sizeof(*codes), sizeof(*codes),
156  syms, sizeof(*syms), sizeof(*syms), 0);
157 }
158 
159 static int huff_build(VLC *vlc, uint8_t *len)
160 {
161  HuffEntry he[256];
162  uint32_t codes[256];
163  uint8_t bits[256];
164  uint8_t syms[256];
165  uint32_t code;
166  int i;
167 
168  for (i = 0; i < 256; i++) {
169  he[i].sym = 255 - i;
170  he[i].len = len[i];
171  if (len[i] == 0 || len[i] > 32)
172  return AVERROR_INVALIDDATA;
173  }
174  AV_QSORT(he, 256, HuffEntry, huff_cmp_len);
175 
176  code = 1;
177  for (i = 255; i >= 0; i--) {
178  codes[i] = code >> (32 - he[i].len);
179  bits[i] = he[i].len;
180  syms[i] = he[i].sym;
181  code += 0x80000000u >> (he[i].len - 1);
182  }
183 
184  ff_free_vlc(vlc);
185  return ff_init_vlc_sparse(vlc, FFMIN(he[255].len, 12), 256,
186  bits, sizeof(*bits), sizeof(*bits),
187  codes, sizeof(*codes), sizeof(*codes),
188  syms, sizeof(*syms), sizeof(*syms), 0);
189 }
190 
191 static void magicyuv_median_pred16(uint16_t *dst, const uint16_t *src1,
192  const uint16_t *diff, intptr_t w,
193  int *left, int *left_top, int max)
194 {
195  int i;
196  uint16_t l, lt;
197 
198  l = *left;
199  lt = *left_top;
200 
201  for (i = 0; i < w; i++) {
202  l = mid_pred(l, src1[i], (l + src1[i] - lt)) + diff[i];
203  l &= max;
204  lt = src1[i];
205  dst[i] = l;
206  }
207 
208  *left = l;
209  *left_top = lt;
210 }
211 
212 static int magy_decode_slice10(AVCodecContext *avctx, void *tdata,
213  int j, int threadnr)
214 {
215  MagicYUVContext *s = avctx->priv_data;
216  int interlaced = s->interlaced;
217  const int bps = s->bps;
218  const int max = s->max - 1;
219  AVFrame *p = s->p;
220  int i, k, x;
221  GetBitContext gb;
222  uint16_t *dst;
223 
224  for (i = 0; i < s->planes; i++) {
225  int left, lefttop, top;
226  int height = AV_CEIL_RSHIFT(FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height), s->vshift[i]);
227  int width = AV_CEIL_RSHIFT(avctx->coded_width, s->hshift[i]);
228  int sheight = AV_CEIL_RSHIFT(s->slice_height, s->vshift[i]);
229  ptrdiff_t fake_stride = (p->linesize[i] / 2) * (1 + interlaced);
230  ptrdiff_t stride = p->linesize[i] / 2;
231  int flags, pred;
232  int ret = init_get_bits8(&gb, s->buf + s->slices[i][j].start,
233  s->slices[i][j].size);
234 
235  if (ret < 0)
236  return ret;
237 
238  flags = get_bits(&gb, 8);
239  pred = get_bits(&gb, 8);
240 
241  dst = (uint16_t *)p->data[i] + j * sheight * stride;
242  if (flags & 1) {
243  if (get_bits_left(&gb) < bps * width * height)
244  return AVERROR_INVALIDDATA;
245  for (k = 0; k < height; k++) {
246  for (x = 0; x < width; x++)
247  dst[x] = get_bits(&gb, bps);
248 
249  dst += stride;
250  }
251  } else {
252  for (k = 0; k < height; k++) {
253  for (x = 0; x < width; x++) {
254  int pix;
255  if (get_bits_left(&gb) <= 0)
256  return AVERROR_INVALIDDATA;
257 
258  pix = get_vlc2(&gb, s->vlc[i].table, s->vlc[i].bits, 3);
259  if (pix < 0)
260  return AVERROR_INVALIDDATA;
261 
262  dst[x] = max - pix;
263  }
264  dst += stride;
265  }
266  }
267 
268  switch (pred) {
269  case LEFT:
270  dst = (uint16_t *)p->data[i] + j * sheight * stride;
271  s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
272  dst += stride;
273  if (interlaced) {
274  s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
275  dst += stride;
276  }
277  for (k = 1 + interlaced; k < height; k++) {
278  s->llviddsp.add_left_pred_int16(dst, dst, max, width, dst[-fake_stride]);
279  dst += stride;
280  }
281  break;
282  case GRADIENT:
283  dst = (uint16_t *)p->data[i] + j * sheight * stride;
284  s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
285  left = lefttop = 0;
286  dst += stride;
287  if (interlaced) {
288  s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
289  left = lefttop = 0;
290  dst += stride;
291  }
292  for (k = 1 + interlaced; k < height; k++) {
293  top = dst[-fake_stride];
294  left = top + dst[0];
295  dst[0] = left & max;
296  for (x = 1; x < width; x++) {
297  top = dst[x - fake_stride];
298  lefttop = dst[x - (fake_stride + 1)];
299  left += top - lefttop + dst[x];
300  dst[x] = left & max;
301  }
302  dst += stride;
303  }
304  break;
305  case MEDIAN:
306  dst = (uint16_t *)p->data[i] + j * sheight * stride;
307  lefttop = left = dst[0];
308  s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
309  dst += stride;
310  if (interlaced) {
311  lefttop = left = dst[0];
312  s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
313  dst += stride;
314  }
315  for (k = 1 + interlaced; k < height; k++) {
316  magicyuv_median_pred16(dst, dst - fake_stride, dst, width, &left, &lefttop, max);
317  lefttop = left = dst[0];
318  dst += stride;
319  }
320  break;
321  default:
322  avpriv_request_sample(avctx, "Unknown prediction: %d", pred);
323  }
324  }
325 
326  if (s->decorrelate) {
327  int height = FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height);
328  int width = avctx->coded_width;
329  uint16_t *r = (uint16_t *)p->data[0] + j * s->slice_height * p->linesize[0] / 2;
330  uint16_t *g = (uint16_t *)p->data[1] + j * s->slice_height * p->linesize[1] / 2;
331  uint16_t *b = (uint16_t *)p->data[2] + j * s->slice_height * p->linesize[2] / 2;
332 
333  for (i = 0; i < height; i++) {
334  for (k = 0; k < width; k++) {
335  b[k] = (b[k] + g[k]) & max;
336  r[k] = (r[k] + g[k]) & max;
337  }
338  b += p->linesize[0] / 2;
339  g += p->linesize[1] / 2;
340  r += p->linesize[2] / 2;
341  }
342  }
343 
344  return 0;
345 }
346 
347 static int magy_decode_slice(AVCodecContext *avctx, void *tdata,
348  int j, int threadnr)
349 {
350  MagicYUVContext *s = avctx->priv_data;
351  int interlaced = s->interlaced;
352  AVFrame *p = s->p;
353  int i, k, x;
354  GetBitContext gb;
355  uint8_t *dst;
356 
357  for (i = 0; i < s->planes; i++) {
358  int left, lefttop, top;
359  int height = AV_CEIL_RSHIFT(FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height), s->vshift[i]);
360  int width = AV_CEIL_RSHIFT(avctx->coded_width, s->hshift[i]);
361  int sheight = AV_CEIL_RSHIFT(s->slice_height, s->vshift[i]);
362  ptrdiff_t fake_stride = p->linesize[i] * (1 + interlaced);
363  ptrdiff_t stride = p->linesize[i];
364  int flags, pred;
365  int ret = init_get_bits8(&gb, s->buf + s->slices[i][j].start,
366  s->slices[i][j].size);
367 
368  if (ret < 0)
369  return ret;
370 
371  flags = get_bits(&gb, 8);
372  pred = get_bits(&gb, 8);
373 
374  dst = p->data[i] + j * sheight * stride;
375  if (flags & 1) {
376  if (get_bits_left(&gb) < 8* width * height)
377  return AVERROR_INVALIDDATA;
378  for (k = 0; k < height; k++) {
379  for (x = 0; x < width; x++)
380  dst[x] = get_bits(&gb, 8);
381 
382  dst += stride;
383  }
384  } else {
385  for (k = 0; k < height; k++) {
386  for (x = 0; x < width; x++) {
387  int pix;
388  if (get_bits_left(&gb) <= 0)
389  return AVERROR_INVALIDDATA;
390 
391  pix = get_vlc2(&gb, s->vlc[i].table, s->vlc[i].bits, 3);
392  if (pix < 0)
393  return AVERROR_INVALIDDATA;
394 
395  dst[x] = 255 - pix;
396  }
397  dst += stride;
398  }
399  }
400 
401  switch (pred) {
402  case LEFT:
403  dst = p->data[i] + j * sheight * stride;
404  s->llviddsp.add_left_pred(dst, dst, width, 0);
405  dst += stride;
406  if (interlaced) {
407  s->llviddsp.add_left_pred(dst, dst, width, 0);
408  dst += stride;
409  }
410  for (k = 1 + interlaced; k < height; k++) {
411  s->llviddsp.add_left_pred(dst, dst, width, dst[-fake_stride]);
412  dst += stride;
413  }
414  break;
415  case GRADIENT:
416  dst = p->data[i] + j * sheight * stride;
417  s->llviddsp.add_left_pred(dst, dst, width, 0);
418  left = lefttop = 0;
419  dst += stride;
420  if (interlaced) {
421  s->llviddsp.add_left_pred(dst, dst, width, 0);
422  left = lefttop = 0;
423  dst += stride;
424  }
425  for (k = 1 + interlaced; k < height; k++) {
426  top = dst[-fake_stride];
427  left = top + dst[0];
428  dst[0] = left;
429  for (x = 1; x < width; x++) {
430  top = dst[x - fake_stride];
431  lefttop = dst[x - (fake_stride + 1)];
432  left += top - lefttop + dst[x];
433  dst[x] = left;
434  }
435  dst += stride;
436  }
437  break;
438  case MEDIAN:
439  dst = p->data[i] + j * sheight * stride;
440  lefttop = left = dst[0];
441  s->llviddsp.add_left_pred(dst, dst, width, 0);
442  dst += stride;
443  if (interlaced) {
444  lefttop = left = dst[0];
445  s->llviddsp.add_left_pred(dst, dst, width, 0);
446  dst += stride;
447  }
448  for (k = 1 + interlaced; k < height; k++) {
449  s->llviddsp.add_median_pred(dst, dst - fake_stride,
450  dst, width, &left, &lefttop);
451  lefttop = left = dst[0];
452  dst += stride;
453  }
454  break;
455  default:
456  avpriv_request_sample(avctx, "Unknown prediction: %d", pred);
457  }
458  }
459 
460  if (s->decorrelate) {
461  int height = FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height);
462  int width = avctx->coded_width;
463  uint8_t *b = p->data[0] + j * s->slice_height * p->linesize[0];
464  uint8_t *g = p->data[1] + j * s->slice_height * p->linesize[1];
465  uint8_t *r = p->data[2] + j * s->slice_height * p->linesize[2];
466 
467  for (i = 0; i < height; i++) {
468  s->llviddsp.add_bytes(b, g, width);
469  s->llviddsp.add_bytes(r, g, width);
470  b += p->linesize[0];
471  g += p->linesize[1];
472  r += p->linesize[2];
473  }
474  }
475 
476  return 0;
477 }
478 
479 static int build_huffman(AVCodecContext *avctx, GetBitContext *gbit, int max)
480 {
481  MagicYUVContext *s = avctx->priv_data;
482  int i = 0, j = 0, k;
483 
484  memset(s->len, 0, sizeof(s->len));
485  while (get_bits_left(gbit) >= 8) {
486  int b = get_bits(gbit, 1);
487  int x = get_bits(gbit, 7);
488  int l = get_bitsz(gbit, b * 8) + 1;
489 
490  for (k = 0; k < l; k++)
491  if (j + k < max)
492  s->len[i][j + k] = x;
493 
494  j += l;
495  if (j == max) {
496  j = 0;
497  if (s->huff_build(&s->vlc[i], s->len[i])) {
498  av_log(avctx, AV_LOG_ERROR, "Cannot build Huffman codes\n");
499  return AVERROR_INVALIDDATA;
500  }
501  i++;
502  if (i == s->planes) {
503  break;
504  }
505  } else if (j > max) {
506  av_log(avctx, AV_LOG_ERROR, "Invalid Huffman codes\n");
507  return AVERROR_INVALIDDATA;
508  }
509  }
510 
511  if (i != s->planes) {
512  av_log(avctx, AV_LOG_ERROR, "Huffman tables too short\n");
513  return AVERROR_INVALIDDATA;
514  }
515 
516  return 0;
517 }
518 
519 static int magy_decode_frame(AVCodecContext *avctx, void *data,
520  int *got_frame, AVPacket *avpkt)
521 {
522  MagicYUVContext *s = avctx->priv_data;
523  ThreadFrame frame = { .f = data };
524  AVFrame *p = data;
525  GetByteContext gbyte;
526  GetBitContext gbit;
527  uint32_t first_offset, offset, next_offset, header_size, slice_width;
528  int width, height, format, version, table_size;
529  int ret, i, j;
530 
531  bytestream2_init(&gbyte, avpkt->data, avpkt->size);
532  if (bytestream2_get_le32(&gbyte) != MKTAG('M', 'A', 'G', 'Y'))
533  return AVERROR_INVALIDDATA;
534 
535  header_size = bytestream2_get_le32(&gbyte);
536  if (header_size < 32 || header_size >= avpkt->size) {
537  av_log(avctx, AV_LOG_ERROR,
538  "header or packet too small %"PRIu32"\n", header_size);
539  return AVERROR_INVALIDDATA;
540  }
541 
542  version = bytestream2_get_byte(&gbyte);
543  if (version != 7) {
544  avpriv_request_sample(avctx, "Version %d", version);
545  return AVERROR_PATCHWELCOME;
546  }
547 
548  s->hshift[1] =
549  s->vshift[1] =
550  s->hshift[2] =
551  s->vshift[2] = 0;
552  s->decorrelate = 0;
553  s->max = 256;
554  s->bps = 8;
555  s->huff_build = huff_build;
557 
558  format = bytestream2_get_byte(&gbyte);
559  switch (format) {
560  case 0x65:
561  avctx->pix_fmt = AV_PIX_FMT_GBRP;
562  s->decorrelate = 1;
563  break;
564  case 0x66:
565  avctx->pix_fmt = AV_PIX_FMT_GBRAP;
566  s->decorrelate = 1;
567  break;
568  case 0x67:
569  avctx->pix_fmt = AV_PIX_FMT_YUV444P;
570  break;
571  case 0x68:
572  avctx->pix_fmt = AV_PIX_FMT_YUV422P;
573  s->hshift[1] =
574  s->hshift[2] = 1;
575  break;
576  case 0x69:
577  avctx->pix_fmt = AV_PIX_FMT_YUV420P;
578  s->hshift[1] =
579  s->vshift[1] =
580  s->hshift[2] =
581  s->vshift[2] = 1;
582  break;
583  case 0x6a:
584  avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
585  break;
586  case 0x6b:
587  avctx->pix_fmt = AV_PIX_FMT_GRAY8;
588  break;
589  case 0x6c:
590  avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
591  s->hshift[1] =
592  s->hshift[2] = 1;
593  s->max = 1024;
596  s->bps = 10;
597  break;
598  case 0x6d:
599  avctx->pix_fmt = AV_PIX_FMT_GBRP10;
600  s->decorrelate = 1;
601  s->max = 1024;
604  s->bps = 10;
605  break;
606  case 0x6e:
607  avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
608  s->decorrelate = 1;
609  s->max = 1024;
612  s->bps = 10;
613  break;
614  case 0x6f:
615  avctx->pix_fmt = AV_PIX_FMT_GBRP12;
616  s->decorrelate = 1;
617  s->max = 4096;
620  s->bps = 12;
621  break;
622  case 0x70:
623  avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
624  s->decorrelate = 1;
625  s->max = 4096;
628  s->bps = 12;
629  break;
630  case 0x73:
631  avctx->pix_fmt = AV_PIX_FMT_GRAY10;
632  s->max = 1024;
635  s->bps = 10;
636  break;
637  default:
638  avpriv_request_sample(avctx, "Format 0x%X", format);
639  return AVERROR_PATCHWELCOME;
640  }
642 
643  bytestream2_skip(&gbyte, 1);
644  s->color_matrix = bytestream2_get_byte(&gbyte);
645  s->flags = bytestream2_get_byte(&gbyte);
646  s->interlaced = !!(s->flags & 2);
647  bytestream2_skip(&gbyte, 3);
648 
649  width = bytestream2_get_le32(&gbyte);
650  height = bytestream2_get_le32(&gbyte);
651  ret = ff_set_dimensions(avctx, width, height);
652  if (ret < 0)
653  return ret;
654 
655  slice_width = bytestream2_get_le32(&gbyte);
656  if (slice_width != avctx->coded_width) {
657  avpriv_request_sample(avctx, "Slice width %"PRIu32, slice_width);
658  return AVERROR_PATCHWELCOME;
659  }
660  s->slice_height = bytestream2_get_le32(&gbyte);
661  if (s->slice_height <= 0 || s->slice_height > INT_MAX - avctx->coded_height) {
662  av_log(avctx, AV_LOG_ERROR,
663  "invalid slice height: %d\n", s->slice_height);
664  return AVERROR_INVALIDDATA;
665  }
666 
667  bytestream2_skip(&gbyte, 4);
668 
669  s->nb_slices = (avctx->coded_height + s->slice_height - 1) / s->slice_height;
670  if (s->nb_slices > INT_MAX / sizeof(Slice)) {
671  av_log(avctx, AV_LOG_ERROR,
672  "invalid number of slices: %d\n", s->nb_slices);
673  return AVERROR_INVALIDDATA;
674  }
675 
676  if (s->interlaced) {
677  if ((s->slice_height >> s->vshift[1]) < 2) {
678  av_log(avctx, AV_LOG_ERROR, "impossible slice height\n");
679  return AVERROR_INVALIDDATA;
680  }
681  if ((avctx->coded_height % s->slice_height) && ((avctx->coded_height % s->slice_height) >> s->vshift[1]) < 2) {
682  av_log(avctx, AV_LOG_ERROR, "impossible height\n");
683  return AVERROR_INVALIDDATA;
684  }
685  }
686 
687  for (i = 0; i < s->planes; i++) {
688  av_fast_malloc(&s->slices[i], &s->slices_size[i], s->nb_slices * sizeof(Slice));
689  if (!s->slices[i])
690  return AVERROR(ENOMEM);
691 
692  offset = bytestream2_get_le32(&gbyte);
693  if (offset >= avpkt->size - header_size)
694  return AVERROR_INVALIDDATA;
695 
696  if (i == 0)
697  first_offset = offset;
698 
699  for (j = 0; j < s->nb_slices - 1; j++) {
700  s->slices[i][j].start = offset + header_size;
701 
702  next_offset = bytestream2_get_le32(&gbyte);
703  if (next_offset <= offset || next_offset >= avpkt->size - header_size)
704  return AVERROR_INVALIDDATA;
705 
706  s->slices[i][j].size = next_offset - offset;
707  offset = next_offset;
708  }
709 
710  s->slices[i][j].start = offset + header_size;
711  s->slices[i][j].size = avpkt->size - s->slices[i][j].start;
712 
713  if (s->slices[i][j].size < 2)
714  return AVERROR_INVALIDDATA;
715  }
716 
717  if (bytestream2_get_byte(&gbyte) != s->planes)
718  return AVERROR_INVALIDDATA;
719 
720  bytestream2_skip(&gbyte, s->nb_slices * s->planes);
721 
722  table_size = header_size + first_offset - bytestream2_tell(&gbyte);
723  if (table_size < 2)
724  return AVERROR_INVALIDDATA;
725 
726  ret = init_get_bits8(&gbit, avpkt->data + bytestream2_tell(&gbyte), table_size);
727  if (ret < 0)
728  return ret;
729 
730  ret = build_huffman(avctx, &gbit, s->max);
731  if (ret < 0)
732  return ret;
733 
735  p->key_frame = 1;
736 
737  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
738  return ret;
739 
740  s->buf = avpkt->data;
741  s->p = p;
742  avctx->execute2(avctx, s->magy_decode_slice, NULL, NULL, s->nb_slices);
743 
744  if (avctx->pix_fmt == AV_PIX_FMT_GBRP ||
745  avctx->pix_fmt == AV_PIX_FMT_GBRAP ||
746  avctx->pix_fmt == AV_PIX_FMT_GBRP10 ||
747  avctx->pix_fmt == AV_PIX_FMT_GBRAP10||
748  avctx->pix_fmt == AV_PIX_FMT_GBRAP12||
749  avctx->pix_fmt == AV_PIX_FMT_GBRP12) {
750  FFSWAP(uint8_t*, p->data[0], p->data[1]);
751  FFSWAP(int, p->linesize[0], p->linesize[1]);
752  } else {
753  switch (s->color_matrix) {
754  case 1:
756  break;
757  case 2:
759  break;
760  }
762  }
763 
764  *got_frame = 1;
765 
766  return avpkt->size;
767 }
768 
769 #if HAVE_THREADS
770 static int magy_init_thread_copy(AVCodecContext *avctx)
771 {
772  MagicYUVContext *s = avctx->priv_data;
773  int i;
774 
775  for (i = 0; i < FF_ARRAY_ELEMS(s->slices); i++) {
776  s->slices[i] = NULL;
777  s->slices_size[i] = 0;
778  }
779 
780  return 0;
781 }
782 #endif
783 
785 {
786  MagicYUVContext *s = avctx->priv_data;
788  return 0;
789 }
790 
792 {
793  MagicYUVContext * const s = avctx->priv_data;
794  int i;
795 
796  for (i = 0; i < FF_ARRAY_ELEMS(s->slices); i++) {
797  av_freep(&s->slices[i]);
798  s->slices_size[i] = 0;
799  ff_free_vlc(&s->vlc[i]);
800  }
801 
802  return 0;
803 }
804 
806  .name = "magicyuv",
807  .long_name = NULL_IF_CONFIG_SMALL("MagicYUV video"),
808  .type = AVMEDIA_TYPE_VIDEO,
809  .id = AV_CODEC_ID_MAGICYUV,
810  .priv_data_size = sizeof(MagicYUVContext),
812  .init_thread_copy = ONLY_IF_THREADS_ENABLED(magy_init_thread_copy),
813  .close = magy_decode_end,
814  .decode = magy_decode_frame,
815  .capabilities = AV_CODEC_CAP_DR1 |
818  .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
819 };
also ITU-R BT1361 / IEC 61966-2-4 xvYCC709 / SMPTE RP177 Annex B
Definition: pixfmt.h:490
#define NULL
Definition: coverity.c:32
static int build_huffman(AVCodecContext *avctx, GetBitContext *gbit, int max)
Definition: magicyuv.c:479
const char * s
Definition: avisynth_c.h:768
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int(* add_left_pred)(uint8_t *dst, const uint8_t *src, ptrdiff_t w, int left)
int vshift[4]
Definition: magicyuv.c:66
This structure describes decoded (raw) audio or video data.
Definition: frame.h:201
int hshift[4]
Definition: magicyuv.c:65
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:1963
#define AV_PIX_FMT_GBRAP10
Definition: pixfmt.h:403
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:262
static int init_thread_copy(AVCodecContext *avctx)
Definition: tta.c:392
int av_pix_fmt_count_planes(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2459
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:211
const char * g
Definition: vf_curves.c:112
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM / IEC 61966-2-4 xvYCC601 ...
Definition: pixfmt.h:494
#define avpriv_request_sample(...)
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:273
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:184
int size
Definition: avcodec.h:1680
const char * b
Definition: vf_curves.c:113
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:399
static int huff_build10(VLC *vlc, uint8_t *len)
Definition: magicyuv.c:95
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1989
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
int version
Definition: avisynth_c.h:766
unsigned int slices_size[4]
Definition: magicyuv.c:68
uint8_t len[4][4096]
Definition: magicyuv.c:69
int stride
Definition: mace.c:144
AVCodec.
Definition: avcodec.h:3739
LLVidDSPContext llviddsp
Definition: magicyuv.c:74
#define AV_PIX_FMT_GRAY10
Definition: pixfmt.h:365
#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
uint8_t bits
Definition: crc.c:296
uint8_t
#define av_cold
Definition: attributes.h:82
Multithreading support functions.
static AVFrame * frame
Prediction
Definition: magicyuv.c:41
const char data[16]
Definition: mxf.c:90
#define height
uint8_t * data
Definition: avcodec.h:1679
static int flags
Definition: log.c:57
void(* add_median_pred)(uint8_t *dst, const uint8_t *top, const uint8_t *diff, ptrdiff_t w, int *left, int *left_top)
bitstream reader API header.
uint32_t code
Definition: magicyuv.c:50
static int huff_cmp_len12(const void *a, const void *b)
Definition: magicyuv.c:89
#define av_log(a,...)
static int magy_decode_slice(AVCodecContext *avctx, void *tdata, int j, int threadnr)
Definition: magicyuv.c:347
static int huff_cmp_len(const void *a, const void *b)
Definition: magicyuv.c:77
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:589
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int slice_height
Definition: magicyuv.c:57
#define AVERROR(e)
Definition: error.h:43
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:164
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:181
const char * r
Definition: vf_curves.c:111
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: frame.h:446
enum AVColorSpace colorspace
YUV colorspace type.
Definition: frame.h:457
uint16_t width
Definition: gdv.c:47
#define AV_PIX_FMT_GBRAP12
Definition: pixfmt.h:404
const char * name
Name of the codec implementation.
Definition: avcodec.h:3746
static const uint8_t offset[127][2]
Definition: vf_spp.c:92
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: avcodec.h:1065
Definition: vlc.h:26
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
Definition: internal.h:220
Slice * slices[4]
Definition: magicyuv.c:67
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:481
static int huff_build12(VLC *vlc, uint8_t *len)
Definition: magicyuv.c:127
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:284
#define FFMIN(a, b)
Definition: common.h:96
uint8_t interlaced
Definition: mxfenc.c:1898
static int huff_cmp_len10(const void *a, const void *b)
Definition: magicyuv.c:83
Definition: magicyuv.c:36
AVFrame * p
Definition: magicyuv.c:54
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:556
int(* huff_build)(VLC *vlc, uint8_t *len)
Definition: magicyuv.c:71
if(ret< 0)
Definition: vf_mcdeint.c:279
#define FF_ARRAY_ELEMS(a)
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:514
int bits
Definition: vlc.h:27
static const float pred[4]
Definition: siprdata.h:259
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AV_CODEC_CAP_SLICE_THREADS
Codec supports slice-based (or partition-based) multithreading.
Definition: avcodec.h:1069
static av_cold int magy_decode_init(AVCodecContext *avctx)
Definition: magicyuv.c:784
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
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:3252
int(* add_left_pred_int16)(uint16_t *dst, const uint16_t *src, unsigned mask, ptrdiff_t w, unsigned left)
#define src1
Definition: h264pred.c:139
uint8_t len
Definition: magicyuv.c:49
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:232
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:457
planar YUV 4:4:4 32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
Definition: pixfmt.h:193
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
Definition: avcodec.h:1761
static int magy_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: magicyuv.c:519
uint32_t size
Definition: magicyuv.c:38
void ff_llviddsp_init(LLVidDSPContext *c)
uint32_t start
Definition: magicyuv.c:37
int coded_height
Definition: avcodec.h:1963
static const char * format
Definition: movenc.c:47
AVCodec ff_magicyuv_decoder
Definition: magicyuv.c:805
Definition: magicyuv.c:42
#define mid_pred
Definition: mathops.h:97
#define u(width,...)
VLC vlc[4]
Definition: magicyuv.c:70
static int magy_decode_slice10(AVCodecContext *avctx, void *tdata, int j, int threadnr)
Definition: magicyuv.c:212
uint8_t * buf
Definition: magicyuv.c:64
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:400
int(* magy_decode_slice)(AVCodecContext *avctx, void *tdata, int j, int threadnr)
Definition: magicyuv.c:72
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:384
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:215
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:513
static av_cold int magy_decode_end(AVCodecContext *avctx)
Definition: magicyuv.c:791
int
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
Y , 8bpp.
Definition: pixfmt.h:74
common internal api header.
planar GBRA 4:4:4:4 32bpp
Definition: pixfmt.h:233
uint16_t sym
Definition: magicyuv.c:48
unsigned bps
Definition: movenc.c:1415
void * priv_data
Definition: avcodec.h:1803
static int huff_build(VLC *vlc, uint8_t *len)
Definition: magicyuv.c:159
static av_always_inline int diff(const uint32_t a, const uint32_t b)
int len
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:279
static void magicyuv_median_pred16(uint16_t *dst, const uint16_t *src1, const uint16_t *diff, intptr_t w, int *left, int *left_top, int max)
Definition: magicyuv.c:191
#define av_freep(p)
#define FFSWAP(type, a, b)
Definition: common.h:99
void(* add_bytes)(uint8_t *dst, uint8_t *src, ptrdiff_t w)
#define MKTAG(a, b, c, d)
Definition: common.h:342
This structure stores compressed data.
Definition: avcodec.h:1656
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:359
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:1002
#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
for(j=16;j >0;--j)
static av_always_inline int get_bitsz(GetBitContext *s, int n)
Read 0-25 bits.
Definition: get_bits.h:277
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
int color_matrix
Definition: magicyuv.c:61