avcodec/idctdsp: Transmit studio_profile to init instead of using AVCodecContext...
[ffmpeg.git] / libavcodec / magicyuv.c
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,
43     GRADIENT,
44     MEDIAN,
45 } Prediction;
46
47 typedef struct HuffEntry {
48     uint16_t sym;
49     uint8_t  len;
50     uint32_t code;
51 } HuffEntry;
52
53 typedef struct MagicYUVContext {
54     AVFrame          *p;
55     int               max;
56     int               bps;
57     int               slice_height;
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
71     int (*huff_build)(VLC *vlc, uint8_t *len);
72     int (*magy_decode_slice)(AVCodecContext *avctx, void *tdata,
73                              int j, int threadnr);
74     LLVidDSPContext   llviddsp;
75 } MagicYUVContext;
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             for (k = 0; k < height; k++) {
244                 for (x = 0; x < width; x++)
245                     dst[x] = get_bits(&gb, bps);
246
247                 dst += stride;
248             }
249         } else {
250             for (k = 0; k < height; k++) {
251                 for (x = 0; x < width; x++) {
252                     int pix;
253                     if (get_bits_left(&gb) <= 0)
254                         return AVERROR_INVALIDDATA;
255
256                     pix = get_vlc2(&gb, s->vlc[i].table, s->vlc[i].bits, 3);
257                     if (pix < 0)
258                         return AVERROR_INVALIDDATA;
259
260                     dst[x] = max - pix;
261                 }
262                 dst += stride;
263             }
264         }
265
266         switch (pred) {
267         case LEFT:
268             dst = (uint16_t *)p->data[i] + j * sheight * stride;
269             s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
270             dst += stride;
271             if (interlaced) {
272                 s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
273                 dst += stride;
274             }
275             for (k = 1 + interlaced; k < height; k++) {
276                 s->llviddsp.add_left_pred_int16(dst, dst, max, width, dst[-fake_stride]);
277                 dst += stride;
278             }
279             break;
280         case GRADIENT:
281             dst = (uint16_t *)p->data[i] + j * sheight * stride;
282             s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
283             dst += stride;
284             if (interlaced) {
285                 s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
286                 dst += stride;
287             }
288             for (k = 1 + interlaced; k < height; k++) {
289                 top = dst[-fake_stride];
290                 left = top + dst[0];
291                 dst[0] = left & max;
292                 for (x = 1; x < width; x++) {
293                     top = dst[x - fake_stride];
294                     lefttop = dst[x - (fake_stride + 1)];
295                     left += top - lefttop + dst[x];
296                     dst[x] = left & max;
297                 }
298                 dst += stride;
299             }
300             break;
301         case MEDIAN:
302             dst = (uint16_t *)p->data[i] + j * sheight * stride;
303             s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
304             dst += stride;
305             if (interlaced) {
306                 s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
307                 dst += stride;
308             }
309             lefttop = left = dst[0];
310             for (k = 1 + interlaced; k < height; k++) {
311                 magicyuv_median_pred16(dst, dst - fake_stride, dst, width, &left, &lefttop, max);
312                 lefttop = left = dst[0];
313                 dst += stride;
314             }
315             break;
316         default:
317             avpriv_request_sample(avctx, "Unknown prediction: %d", pred);
318         }
319     }
320
321     if (s->decorrelate) {
322         int height = FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height);
323         int width = avctx->coded_width;
324         uint16_t *r = (uint16_t *)p->data[0] + j * s->slice_height * p->linesize[0] / 2;
325         uint16_t *g = (uint16_t *)p->data[1] + j * s->slice_height * p->linesize[1] / 2;
326         uint16_t *b = (uint16_t *)p->data[2] + j * s->slice_height * p->linesize[2] / 2;
327
328         for (i = 0; i < height; i++) {
329             for (k = 0; k < width; k++) {
330                 b[k] = (b[k] + g[k]) & max;
331                 r[k] = (r[k] + g[k]) & max;
332             }
333             b += p->linesize[0] / 2;
334             g += p->linesize[1] / 2;
335             r += p->linesize[2] / 2;
336         }
337     }
338
339     return 0;
340 }
341
342 static int magy_decode_slice(AVCodecContext *avctx, void *tdata,
343                              int j, int threadnr)
344 {
345     MagicYUVContext *s = avctx->priv_data;
346     int interlaced = s->interlaced;
347     AVFrame *p = s->p;
348     int i, k, x, min_width;
349     GetBitContext gb;
350     uint8_t *dst;
351
352     for (i = 0; i < s->planes; i++) {
353         int left, lefttop, top;
354         int height = AV_CEIL_RSHIFT(FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height), s->vshift[i]);
355         int width = AV_CEIL_RSHIFT(avctx->coded_width, s->hshift[i]);
356         int sheight = AV_CEIL_RSHIFT(s->slice_height, s->vshift[i]);
357         ptrdiff_t fake_stride = p->linesize[i] * (1 + interlaced);
358         ptrdiff_t stride = p->linesize[i];
359         int flags, pred;
360         int ret = init_get_bits8(&gb, s->buf + s->slices[i][j].start,
361                                  s->slices[i][j].size);
362
363         if (ret < 0)
364             return ret;
365
366         flags = get_bits(&gb, 8);
367         pred  = get_bits(&gb, 8);
368
369         dst = p->data[i] + j * sheight * stride;
370         if (flags & 1) {
371             for (k = 0; k < height; k++) {
372                 for (x = 0; x < width; x++)
373                     dst[x] = get_bits(&gb, 8);
374
375                 dst += stride;
376             }
377         } else {
378             for (k = 0; k < height; k++) {
379                 for (x = 0; x < width; x++) {
380                     int pix;
381                     if (get_bits_left(&gb) <= 0)
382                         return AVERROR_INVALIDDATA;
383
384                     pix = get_vlc2(&gb, s->vlc[i].table, s->vlc[i].bits, 3);
385                     if (pix < 0)
386                         return AVERROR_INVALIDDATA;
387
388                     dst[x] = 255 - pix;
389                 }
390                 dst += stride;
391             }
392         }
393
394         switch (pred) {
395         case LEFT:
396             dst = p->data[i] + j * sheight * stride;
397             s->llviddsp.add_left_pred(dst, dst, width, 0);
398             dst += stride;
399             if (interlaced) {
400                 s->llviddsp.add_left_pred(dst, dst, width, 0);
401                 dst += stride;
402             }
403             for (k = 1 + interlaced; k < height; k++) {
404                 s->llviddsp.add_left_pred(dst, dst, width, dst[-fake_stride]);
405                 dst += stride;
406             }
407             break;
408         case GRADIENT:
409             dst = p->data[i] + j * sheight * stride;
410             s->llviddsp.add_left_pred(dst, dst, width, 0);
411             dst += stride;
412             if (interlaced) {
413                 s->llviddsp.add_left_pred(dst, dst, width, 0);
414                 dst += stride;
415             }
416             min_width = FFMIN(width, 32);
417             for (k = 1 + interlaced; k < height; k++) {
418                 top = dst[-fake_stride];
419                 left = top + dst[0];
420                 dst[0] = left;
421                 for (x = 1; x < min_width; x++) { /* dsp need aligned 32 */
422                     top = dst[x - fake_stride];
423                     lefttop = dst[x - (fake_stride + 1)];
424                     left += top - lefttop + dst[x];
425                     dst[x] = left;
426                 }
427                 if (width > 32)
428                     s->llviddsp.add_gradient_pred(dst + 32, fake_stride, width - 32);
429                 dst += stride;
430             }
431             break;
432         case MEDIAN:
433             dst = p->data[i] + j * sheight * stride;
434             s->llviddsp.add_left_pred(dst, dst, width, 0);
435             dst += stride;
436             if (interlaced) {
437                 s->llviddsp.add_left_pred(dst, dst, width, 0);
438                 dst += stride;
439             }
440             lefttop = left = dst[0];
441             for (k = 1 + interlaced; k < height; k++) {
442                 s->llviddsp.add_median_pred(dst, dst - fake_stride,
443                                              dst, width, &left, &lefttop);
444                 lefttop = left = dst[0];
445                 dst += stride;
446             }
447             break;
448         default:
449             avpriv_request_sample(avctx, "Unknown prediction: %d", pred);
450         }
451     }
452
453     if (s->decorrelate) {
454         int height = FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height);
455         int width = avctx->coded_width;
456         uint8_t *b = p->data[0] + j * s->slice_height * p->linesize[0];
457         uint8_t *g = p->data[1] + j * s->slice_height * p->linesize[1];
458         uint8_t *r = p->data[2] + j * s->slice_height * p->linesize[2];
459
460         for (i = 0; i < height; i++) {
461             s->llviddsp.add_bytes(b, g, width);
462             s->llviddsp.add_bytes(r, g, width);
463             b += p->linesize[0];
464             g += p->linesize[1];
465             r += p->linesize[2];
466         }
467     }
468
469     return 0;
470 }
471
472 static int build_huffman(AVCodecContext *avctx, GetBitContext *gbit, int max)
473 {
474     MagicYUVContext *s = avctx->priv_data;
475     int i = 0, j = 0, k;
476
477     memset(s->len, 0, sizeof(s->len));
478     while (get_bits_left(gbit) >= 8) {
479         int b = get_bits(gbit, 1);
480         int x = get_bits(gbit, 7);
481         int l = get_bitsz(gbit, b * 8) + 1;
482
483         for (k = 0; k < l; k++)
484             if (j + k < max)
485                 s->len[i][j + k] = x;
486
487         j += l;
488         if (j == max) {
489             j = 0;
490             if (s->huff_build(&s->vlc[i], s->len[i])) {
491                 av_log(avctx, AV_LOG_ERROR, "Cannot build Huffman codes\n");
492                 return AVERROR_INVALIDDATA;
493             }
494             i++;
495             if (i == s->planes) {
496                 break;
497             }
498         } else if (j > max) {
499             av_log(avctx, AV_LOG_ERROR, "Invalid Huffman codes\n");
500             return AVERROR_INVALIDDATA;
501         }
502     }
503
504     if (i != s->planes) {
505         av_log(avctx, AV_LOG_ERROR, "Huffman tables too short\n");
506         return AVERROR_INVALIDDATA;
507     }
508
509     return 0;
510 }
511
512 static int magy_decode_frame(AVCodecContext *avctx, void *data,
513                              int *got_frame, AVPacket *avpkt)
514 {
515     MagicYUVContext *s = avctx->priv_data;
516     ThreadFrame frame = { .f = data };
517     AVFrame *p = data;
518     GetByteContext gbyte;
519     GetBitContext gbit;
520     uint32_t first_offset, offset, next_offset, header_size, slice_width;
521     int width, height, format, version, table_size;
522     int ret, i, j;
523
524     bytestream2_init(&gbyte, avpkt->data, avpkt->size);
525     if (bytestream2_get_le32(&gbyte) != MKTAG('M', 'A', 'G', 'Y'))
526         return AVERROR_INVALIDDATA;
527
528     header_size = bytestream2_get_le32(&gbyte);
529     if (header_size < 32 || header_size >= avpkt->size) {
530         av_log(avctx, AV_LOG_ERROR,
531                "header or packet too small %"PRIu32"\n", header_size);
532         return AVERROR_INVALIDDATA;
533     }
534
535     version = bytestream2_get_byte(&gbyte);
536     if (version != 7) {
537         avpriv_request_sample(avctx, "Version %d", version);
538         return AVERROR_PATCHWELCOME;
539     }
540
541     s->hshift[1] =
542     s->vshift[1] =
543     s->hshift[2] =
544     s->vshift[2] = 0;
545     s->decorrelate = 0;
546     s->max = 256;
547     s->bps = 8;
548     s->huff_build = huff_build;
549     s->magy_decode_slice = magy_decode_slice;
550
551     format = bytestream2_get_byte(&gbyte);
552     switch (format) {
553     case 0x65:
554         avctx->pix_fmt = AV_PIX_FMT_GBRP;
555         s->decorrelate = 1;
556         break;
557     case 0x66:
558         avctx->pix_fmt = AV_PIX_FMT_GBRAP;
559         s->decorrelate = 1;
560         break;
561     case 0x67:
562         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
563         break;
564     case 0x68:
565         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
566         s->hshift[1] =
567         s->hshift[2] = 1;
568         break;
569     case 0x69:
570         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
571         s->hshift[1] =
572         s->vshift[1] =
573         s->hshift[2] =
574         s->vshift[2] = 1;
575         break;
576     case 0x6a:
577         avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
578         break;
579     case 0x6b:
580         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
581         break;
582     case 0x6c:
583         avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
584         s->hshift[1] =
585         s->hshift[2] = 1;
586         s->max = 1024;
587         s->huff_build = huff_build10;
588         s->magy_decode_slice = magy_decode_slice10;
589         s->bps = 10;
590         break;
591     case 0x6d:
592         avctx->pix_fmt = AV_PIX_FMT_GBRP10;
593         s->decorrelate = 1;
594         s->max = 1024;
595         s->huff_build = huff_build10;
596         s->magy_decode_slice = magy_decode_slice10;
597         s->bps = 10;
598         break;
599     case 0x6e:
600         avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
601         s->decorrelate = 1;
602         s->max = 1024;
603         s->huff_build = huff_build10;
604         s->magy_decode_slice = magy_decode_slice10;
605         s->bps = 10;
606         break;
607     case 0x6f:
608         avctx->pix_fmt = AV_PIX_FMT_GBRP12;
609         s->decorrelate = 1;
610         s->max = 4096;
611         s->huff_build = huff_build12;
612         s->magy_decode_slice = magy_decode_slice10;
613         s->bps = 12;
614         break;
615     case 0x70:
616         avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
617         s->decorrelate = 1;
618         s->max = 4096;
619         s->huff_build = huff_build12;
620         s->magy_decode_slice = magy_decode_slice10;
621         s->bps = 12;
622         break;
623     case 0x73:
624         avctx->pix_fmt = AV_PIX_FMT_GRAY10;
625         s->max = 1024;
626         s->huff_build = huff_build10;
627         s->magy_decode_slice = magy_decode_slice10;
628         s->bps = 10;
629         break;
630     default:
631         avpriv_request_sample(avctx, "Format 0x%X", format);
632         return AVERROR_PATCHWELCOME;
633     }
634     s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
635
636     bytestream2_skip(&gbyte, 1);
637     s->color_matrix = bytestream2_get_byte(&gbyte);
638     s->flags        = bytestream2_get_byte(&gbyte);
639     s->interlaced   = !!(s->flags & 2);
640     bytestream2_skip(&gbyte, 3);
641
642     width  = bytestream2_get_le32(&gbyte);
643     height = bytestream2_get_le32(&gbyte);
644     ret = ff_set_dimensions(avctx, width, height);
645     if (ret < 0)
646         return ret;
647
648     slice_width = bytestream2_get_le32(&gbyte);
649     if (slice_width != avctx->coded_width) {
650         avpriv_request_sample(avctx, "Slice width %"PRIu32, slice_width);
651         return AVERROR_PATCHWELCOME;
652     }
653     s->slice_height = bytestream2_get_le32(&gbyte);
654     if (s->slice_height <= 0 || s->slice_height > INT_MAX - avctx->coded_height) {
655         av_log(avctx, AV_LOG_ERROR,
656                "invalid slice height: %d\n", s->slice_height);
657         return AVERROR_INVALIDDATA;
658     }
659
660     bytestream2_skip(&gbyte, 4);
661
662     s->nb_slices = (avctx->coded_height + s->slice_height - 1) / s->slice_height;
663     if (s->nb_slices > INT_MAX / sizeof(Slice)) {
664         av_log(avctx, AV_LOG_ERROR,
665                "invalid number of slices: %d\n", s->nb_slices);
666         return AVERROR_INVALIDDATA;
667     }
668
669     for (i = 0; i < s->planes; i++) {
670         av_fast_malloc(&s->slices[i], &s->slices_size[i], s->nb_slices * sizeof(Slice));
671         if (!s->slices[i])
672             return AVERROR(ENOMEM);
673
674         offset = bytestream2_get_le32(&gbyte);
675         if (offset >= avpkt->size - header_size)
676             return AVERROR_INVALIDDATA;
677
678         if (i == 0)
679             first_offset = offset;
680
681         for (j = 0; j < s->nb_slices - 1; j++) {
682             s->slices[i][j].start = offset + header_size;
683
684             next_offset = bytestream2_get_le32(&gbyte);
685             if (next_offset <= offset || next_offset >= avpkt->size - header_size)
686                 return AVERROR_INVALIDDATA;
687
688             s->slices[i][j].size = next_offset - offset;
689             offset = next_offset;
690         }
691
692         s->slices[i][j].start = offset + header_size;
693         s->slices[i][j].size  = avpkt->size - s->slices[i][j].start;
694     }
695
696     if (bytestream2_get_byte(&gbyte) != s->planes)
697         return AVERROR_INVALIDDATA;
698
699     bytestream2_skip(&gbyte, s->nb_slices * s->planes);
700
701     table_size = header_size + first_offset - bytestream2_tell(&gbyte);
702     if (table_size < 2)
703         return AVERROR_INVALIDDATA;
704
705     ret = init_get_bits8(&gbit, avpkt->data + bytestream2_tell(&gbyte), table_size);
706     if (ret < 0)
707         return ret;
708
709     ret = build_huffman(avctx, &gbit, s->max);
710     if (ret < 0)
711         return ret;
712
713     p->pict_type = AV_PICTURE_TYPE_I;
714     p->key_frame = 1;
715
716     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
717         return ret;
718
719     s->buf = avpkt->data;
720     s->p = p;
721     avctx->execute2(avctx, s->magy_decode_slice, NULL, NULL, s->nb_slices);
722
723     if (avctx->pix_fmt == AV_PIX_FMT_GBRP   ||
724         avctx->pix_fmt == AV_PIX_FMT_GBRAP  ||
725         avctx->pix_fmt == AV_PIX_FMT_GBRP10 ||
726         avctx->pix_fmt == AV_PIX_FMT_GBRAP10||
727         avctx->pix_fmt == AV_PIX_FMT_GBRAP12||
728         avctx->pix_fmt == AV_PIX_FMT_GBRP12) {
729         FFSWAP(uint8_t*, p->data[0], p->data[1]);
730         FFSWAP(int, p->linesize[0], p->linesize[1]);
731     } else {
732         switch (s->color_matrix) {
733         case 1:
734             p->colorspace = AVCOL_SPC_BT470BG;
735             break;
736         case 2:
737             p->colorspace = AVCOL_SPC_BT709;
738             break;
739         }
740         p->color_range = (s->flags & 4) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
741     }
742
743     *got_frame = 1;
744
745     return avpkt->size;
746 }
747
748 #if HAVE_THREADS
749 static int magy_init_thread_copy(AVCodecContext *avctx)
750 {
751     MagicYUVContext *s = avctx->priv_data;
752     int i;
753
754     for (i = 0; i < FF_ARRAY_ELEMS(s->slices); i++) {
755         s->slices[i] = NULL;
756         s->slices_size[i] = 0;
757     }
758
759     return 0;
760 }
761 #endif
762
763 static av_cold int magy_decode_init(AVCodecContext *avctx)
764 {
765     MagicYUVContext *s = avctx->priv_data;
766     ff_llviddsp_init(&s->llviddsp);
767     return 0;
768 }
769
770 static av_cold int magy_decode_end(AVCodecContext *avctx)
771 {
772     MagicYUVContext * const s = avctx->priv_data;
773     int i;
774
775     for (i = 0; i < FF_ARRAY_ELEMS(s->slices); i++) {
776         av_freep(&s->slices[i]);
777         s->slices_size[i] = 0;
778         ff_free_vlc(&s->vlc[i]);
779     }
780
781     return 0;
782 }
783
784 AVCodec ff_magicyuv_decoder = {
785     .name             = "magicyuv",
786     .long_name        = NULL_IF_CONFIG_SMALL("MagicYUV video"),
787     .type             = AVMEDIA_TYPE_VIDEO,
788     .id               = AV_CODEC_ID_MAGICYUV,
789     .priv_data_size   = sizeof(MagicYUVContext),
790     .init             = magy_decode_init,
791     .init_thread_copy = ONLY_IF_THREADS_ENABLED(magy_init_thread_copy),
792     .close            = magy_decode_end,
793     .decode           = magy_decode_frame,
794     .capabilities     = AV_CODEC_CAP_DR1 |
795                         AV_CODEC_CAP_FRAME_THREADS |
796                         AV_CODEC_CAP_SLICE_THREADS,
797     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE,
798 };