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