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