git.sesse.net Git - ffmpeg/blob - 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 #define CACHED_BITSTREAM_READER !ARCH_X86_32
  26
  27 #include "libavutil/pixdesc.h"
  28 #include "libavutil/qsort.h"
  29
  30 #include "avcodec.h"
  31 #include "bytestream.h"
  32 #include "get_bits.h"
  33 #include "huffyuvdsp.h"
  34 #include "internal.h"
  35 #include "lossless_videodsp.h"
  36 #include "thread.h"
  37
  38 typedef struct Slice {
  39     uint32_t start;
  40     uint32_t size;
  41 } Slice;
  42
  43 typedef enum Prediction {
  44     LEFT = 1,
  45     GRADIENT,
  46     MEDIAN,
  47 } Prediction;
  48
  49 typedef struct HuffEntry {
  50     uint16_t sym;
  51     uint8_t  len;
  52     uint32_t code;
  53 } HuffEntry;
  54
  55 typedef struct MagicYUVContext {
  56     AVFrame          *p;
  57     int               max;
  58     int               bps;
  59     int               slice_height;
  60     int               nb_slices;
  61     int               planes;         // number of encoded planes in bitstream
  62     int               decorrelate;    // postprocessing work
  63     int               color_matrix;   // video color matrix
  64     int               flags;
  65     int               interlaced;     // video is interlaced
  66     const uint8_t    *buf;            // pointer to AVPacket->data
  67     int               hshift[4];
  68     int               vshift[4];
  69     Slice            *slices[4];      // slice bitstream positions for each plane
  70     unsigned int      slices_size[4]; // slice sizes for each plane
  71     VLC               vlc[4];         // VLC for each plane
  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 (bb->len - aa->len) * 4096 + aa->sym - bb->sym;
  81 }
  82
  83 static int huff_build(HuffEntry he[], VLC *vlc, int nb_elems)
  84 {
  85     uint32_t code;
  86
  87     AV_QSORT(he, nb_elems, HuffEntry, huff_cmp_len);
  88
  89     code = 1;
  90     for (unsigned i = 0; i < nb_elems; i++) {
  91         he[i].code = code >> (32 - he[i].len);
  92         code += 0x80000000u >> (he[i].len - 1);
  93     }
  94
  95     ff_free_vlc(vlc);
  96     return ff_init_vlc_sparse(vlc, FFMIN(he[0].len, 12), nb_elems,
  97                               &he[0].len,  sizeof(he[0]), sizeof(he[0].len),
  98                               &he[0].code, sizeof(he[0]), sizeof(he[0].code),
  99                               &he[0].sym,  sizeof(he[0]), sizeof(he[0].sym),  0);
 100 }
 101
 102 static void magicyuv_median_pred16(uint16_t *dst, const uint16_t *src1,
 103                                    const uint16_t *diff, intptr_t w,
 104                                    int *left, int *left_top, int max)
 105 {
 106     int i;
 107     uint16_t l, lt;
 108
 109     l  = *left;
 110     lt = *left_top;
 111
 112     for (i = 0; i < w; i++) {
 113         l      = mid_pred(l, src1[i], (l + src1[i] - lt)) + diff[i];
 114         l     &= max;
 115         lt     = src1[i];
 116         dst[i] = l;
 117     }
 118
 119     *left     = l;
 120     *left_top = lt;
 121 }
 122
 123 static int magy_decode_slice10(AVCodecContext *avctx, void *tdata,
 124                                int j, int threadnr)
 125 {
 126     MagicYUVContext *s = avctx->priv_data;
 127     int interlaced = s->interlaced;
 128     const int bps = s->bps;
 129     const int max = s->max - 1;
 130     AVFrame *p = s->p;
 131     int i, k, x;
 132     GetBitContext gb;
 133     uint16_t *dst;
 134
 135     for (i = 0; i < s->planes; i++) {
 136         int left, lefttop, top;
 137         int height = AV_CEIL_RSHIFT(FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height), s->vshift[i]);
 138         int width = AV_CEIL_RSHIFT(avctx->coded_width, s->hshift[i]);
 139         int sheight = AV_CEIL_RSHIFT(s->slice_height, s->vshift[i]);
 140         ptrdiff_t fake_stride = (p->linesize[i] / 2) * (1 + interlaced);
 141         ptrdiff_t stride = p->linesize[i] / 2;
 142         int flags, pred;
 143         int ret = init_get_bits8(&gb, s->buf + s->slices[i][j].start,
 144                                  s->slices[i][j].size);
 145
 146         if (ret < 0)
 147             return ret;
 148
 149         flags = get_bits(&gb, 8);
 150         pred  = get_bits(&gb, 8);
 151
 152         dst = (uint16_t *)p->data[i] + j * sheight * stride;
 153         if (flags & 1) {
 154             if (get_bits_left(&gb) < bps * width * height)
 155                 return AVERROR_INVALIDDATA;
 156             for (k = 0; k < height; k++) {
 157                 for (x = 0; x < width; x++)
 158                     dst[x] = get_bits(&gb, bps);
 159
 160                 dst += stride;
 161             }
 162         } else {
 163             for (k = 0; k < height; k++) {
 164                 for (x = 0; x < width; x++) {
 165                     int pix;
 166                     if (get_bits_left(&gb) <= 0)
 167                         return AVERROR_INVALIDDATA;
 168
 169                     pix = get_vlc2(&gb, s->vlc[i].table, s->vlc[i].bits, 3);
 170                     if (pix < 0)
 171                         return AVERROR_INVALIDDATA;
 172
 173                     dst[x] = pix;
 174                 }
 175                 dst += stride;
 176             }
 177         }
 178
 179         switch (pred) {
 180         case LEFT:
 181             dst = (uint16_t *)p->data[i] + j * sheight * stride;
 182             s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
 183             dst += stride;
 184             if (interlaced) {
 185                 s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
 186                 dst += stride;
 187             }
 188             for (k = 1 + interlaced; k < height; k++) {
 189                 s->llviddsp.add_left_pred_int16(dst, dst, max, width, dst[-fake_stride]);
 190                 dst += stride;
 191             }
 192             break;
 193         case GRADIENT:
 194             dst = (uint16_t *)p->data[i] + j * sheight * stride;
 195             s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
 196             dst += stride;
 197             if (interlaced) {
 198                 s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
 199                 dst += stride;
 200             }
 201             for (k = 1 + interlaced; k < height; k++) {
 202                 top = dst[-fake_stride];
 203                 left = top + dst[0];
 204                 dst[0] = left & max;
 205                 for (x = 1; x < width; x++) {
 206                     top = dst[x - fake_stride];
 207                     lefttop = dst[x - (fake_stride + 1)];
 208                     left += top - lefttop + dst[x];
 209                     dst[x] = left & max;
 210                 }
 211                 dst += stride;
 212             }
 213             break;
 214         case MEDIAN:
 215             dst = (uint16_t *)p->data[i] + j * sheight * stride;
 216             s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
 217             dst += stride;
 218             if (interlaced) {
 219                 s->llviddsp.add_left_pred_int16(dst, dst, max, width, 0);
 220                 dst += stride;
 221             }
 222             lefttop = left = dst[0];
 223             for (k = 1 + interlaced; k < height; k++) {
 224                 magicyuv_median_pred16(dst, dst - fake_stride, dst, width, &left, &lefttop, max);
 225                 lefttop = left = dst[0];
 226                 dst += stride;
 227             }
 228             break;
 229         default:
 230             avpriv_request_sample(avctx, "Unknown prediction: %d", pred);
 231         }
 232     }
 233
 234     if (s->decorrelate) {
 235         int height = FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height);
 236         int width = avctx->coded_width;
 237         uint16_t *r = (uint16_t *)p->data[0] + j * s->slice_height * p->linesize[0] / 2;
 238         uint16_t *g = (uint16_t *)p->data[1] + j * s->slice_height * p->linesize[1] / 2;
 239         uint16_t *b = (uint16_t *)p->data[2] + j * s->slice_height * p->linesize[2] / 2;
 240
 241         for (i = 0; i < height; i++) {
 242             for (k = 0; k < width; k++) {
 243                 b[k] = (b[k] + g[k]) & max;
 244                 r[k] = (r[k] + g[k]) & max;
 245             }
 246             b += p->linesize[0] / 2;
 247             g += p->linesize[1] / 2;
 248             r += p->linesize[2] / 2;
 249         }
 250     }
 251
 252     return 0;
 253 }
 254
 255 static int magy_decode_slice(AVCodecContext *avctx, void *tdata,
 256                              int j, int threadnr)
 257 {
 258     MagicYUVContext *s = avctx->priv_data;
 259     int interlaced = s->interlaced;
 260     AVFrame *p = s->p;
 261     int i, k, x, min_width;
 262     GetBitContext gb;
 263     uint8_t *dst;
 264
 265     for (i = 0; i < s->planes; i++) {
 266         int left, lefttop, top;
 267         int height = AV_CEIL_RSHIFT(FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height), s->vshift[i]);
 268         int width = AV_CEIL_RSHIFT(avctx->coded_width, s->hshift[i]);
 269         int sheight = AV_CEIL_RSHIFT(s->slice_height, s->vshift[i]);
 270         ptrdiff_t fake_stride = p->linesize[i] * (1 + interlaced);
 271         ptrdiff_t stride = p->linesize[i];
 272         const uint8_t *slice = s->buf + s->slices[i][j].start;
 273         int flags, pred;
 274
 275         flags = bytestream_get_byte(&slice);
 276         pred  = bytestream_get_byte(&slice);
 277
 278         dst = p->data[i] + j * sheight * stride;
 279         if (flags & 1) {
 280             if (s->slices[i][j].size - 2 < width * height)
 281                 return AVERROR_INVALIDDATA;
 282             for (k = 0; k < height; k++) {
 283                 bytestream_get_buffer(&slice, dst, width);
 284                 dst += stride;
 285             }
 286         } else {
 287             int ret = init_get_bits8(&gb, slice, s->slices[i][j].size - 2);
 288
 289             if (ret < 0)
 290                 return ret;
 291
 292             for (k = 0; k < height; k++) {
 293                 for (x = 0; x < width; x++) {
 294                     int pix;
 295                     if (get_bits_left(&gb) <= 0)
 296                         return AVERROR_INVALIDDATA;
 297
 298                     pix = get_vlc2(&gb, s->vlc[i].table, s->vlc[i].bits, 3);
 299                     if (pix < 0)
 300                         return AVERROR_INVALIDDATA;
 301
 302                     dst[x] = pix;
 303                 }
 304                 dst += stride;
 305             }
 306         }
 307
 308         switch (pred) {
 309         case LEFT:
 310             dst = p->data[i] + j * sheight * stride;
 311             s->llviddsp.add_left_pred(dst, dst, width, 0);
 312             dst += stride;
 313             if (interlaced) {
 314                 s->llviddsp.add_left_pred(dst, dst, width, 0);
 315                 dst += stride;
 316             }
 317             for (k = 1 + interlaced; k < height; k++) {
 318                 s->llviddsp.add_left_pred(dst, dst, width, dst[-fake_stride]);
 319                 dst += stride;
 320             }
 321             break;
 322         case GRADIENT:
 323             dst = p->data[i] + j * sheight * stride;
 324             s->llviddsp.add_left_pred(dst, dst, width, 0);
 325             dst += stride;
 326             if (interlaced) {
 327                 s->llviddsp.add_left_pred(dst, dst, width, 0);
 328                 dst += stride;
 329             }
 330             min_width = FFMIN(width, 32);
 331             for (k = 1 + interlaced; k < height; k++) {
 332                 top = dst[-fake_stride];
 333                 left = top + dst[0];
 334                 dst[0] = left;
 335                 for (x = 1; x < min_width; x++) { /* dsp need aligned 32 */
 336                     top = dst[x - fake_stride];
 337                     lefttop = dst[x - (fake_stride + 1)];
 338                     left += top - lefttop + dst[x];
 339                     dst[x] = left;
 340                 }
 341                 if (width > 32)
 342                     s->llviddsp.add_gradient_pred(dst + 32, fake_stride, width - 32);
 343                 dst += stride;
 344             }
 345             break;
 346         case MEDIAN:
 347             dst = p->data[i] + j * sheight * stride;
 348             s->llviddsp.add_left_pred(dst, dst, width, 0);
 349             dst += stride;
 350             if (interlaced) {
 351                 s->llviddsp.add_left_pred(dst, dst, width, 0);
 352                 dst += stride;
 353             }
 354             lefttop = left = dst[0];
 355             for (k = 1 + interlaced; k < height; k++) {
 356                 s->llviddsp.add_median_pred(dst, dst - fake_stride,
 357                                              dst, width, &left, &lefttop);
 358                 lefttop = left = dst[0];
 359                 dst += stride;
 360             }
 361             break;
 362         default:
 363             avpriv_request_sample(avctx, "Unknown prediction: %d", pred);
 364         }
 365     }
 366
 367     if (s->decorrelate) {
 368         int height = FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height);
 369         int width = avctx->coded_width;
 370         uint8_t *b = p->data[0] + j * s->slice_height * p->linesize[0];
 371         uint8_t *g = p->data[1] + j * s->slice_height * p->linesize[1];
 372         uint8_t *r = p->data[2] + j * s->slice_height * p->linesize[2];
 373
 374         for (i = 0; i < height; i++) {
 375             s->llviddsp.add_bytes(b, g, width);
 376             s->llviddsp.add_bytes(r, g, width);
 377             b += p->linesize[0];
 378             g += p->linesize[1];
 379             r += p->linesize[2];
 380         }
 381     }
 382
 383     return 0;
 384 }
 385
 386 static int build_huffman(AVCodecContext *avctx, const uint8_t *table,
 387                          int table_size, int max)
 388 {
 389     MagicYUVContext *s = avctx->priv_data;
 390     GetByteContext gb;
 391     HuffEntry he[4096];
 392     int i = 0, j = 0, k;
 393
 394     bytestream2_init(&gb, table, table_size);
 395
 396     while (bytestream2_get_bytes_left(&gb) > 0) {
 397         int b = bytestream2_peek_byteu(&gb) &  0x80;
 398         int x = bytestream2_get_byteu(&gb)  & ~0x80;
 399         int l = 1;
 400
 401         if (b) {
 402             if (bytestream2_get_bytes_left(&gb) <= 0)
 403                 break;
 404             l += bytestream2_get_byteu(&gb);
 405         }
 406         k = j + l;
 407         if (k > max || x == 0 || x > 32) {
 408             av_log(avctx, AV_LOG_ERROR, "Invalid Huffman codes\n");
 409             return AVERROR_INVALIDDATA;
 410         }
 411
 412         for (; j < k; j++) {
 413             he[j].sym = j;
 414             he[j].len = x;
 415         }
 416
 417         if (j == max) {
 418             j = 0;
 419             if (huff_build(he, &s->vlc[i], max)) {
 420                 av_log(avctx, AV_LOG_ERROR, "Cannot build Huffman codes\n");
 421                 return AVERROR_INVALIDDATA;
 422             }
 423             i++;
 424             if (i == s->planes) {
 425                 break;
 426             }
 427         }
 428     }
 429
 430     if (i != s->planes) {
 431         av_log(avctx, AV_LOG_ERROR, "Huffman tables too short\n");
 432         return AVERROR_INVALIDDATA;
 433     }
 434
 435     return 0;
 436 }
 437
 438 static int magy_decode_frame(AVCodecContext *avctx, void *data,
 439                              int *got_frame, AVPacket *avpkt)
 440 {
 441     MagicYUVContext *s = avctx->priv_data;
 442     ThreadFrame frame = { .f = data };
 443     AVFrame *p = data;
 444     GetByteContext gb;
 445     uint32_t first_offset, offset, next_offset, header_size, slice_width;
 446     int width, height, format, version, table_size;
 447     int ret, i, j;
 448
 449     if (avpkt->size < 36)
 450         return AVERROR_INVALIDDATA;
 451
 452     bytestream2_init(&gb, avpkt->data, avpkt->size);
 453     if (bytestream2_get_le32u(&gb) != MKTAG('M', 'A', 'G', 'Y'))
 454         return AVERROR_INVALIDDATA;
 455
 456     header_size = bytestream2_get_le32u(&gb);
 457     if (header_size < 32 || header_size >= avpkt->size) {
 458         av_log(avctx, AV_LOG_ERROR,
 459                "header or packet too small %"PRIu32"\n", header_size);
 460         return AVERROR_INVALIDDATA;
 461     }
 462
 463     version = bytestream2_get_byteu(&gb);
 464     if (version != 7) {
 465         avpriv_request_sample(avctx, "Version %d", version);
 466         return AVERROR_PATCHWELCOME;
 467     }
 468
 469     s->hshift[1] =
 470     s->vshift[1] =
 471     s->hshift[2] =
 472     s->vshift[2] = 0;
 473     s->decorrelate = 0;
 474     s->bps = 8;
 475
 476     format = bytestream2_get_byteu(&gb);
 477     switch (format) {
 478     case 0x65:
 479         avctx->pix_fmt = AV_PIX_FMT_GBRP;
 480         s->decorrelate = 1;
 481         break;
 482     case 0x66:
 483         avctx->pix_fmt = AV_PIX_FMT_GBRAP;
 484         s->decorrelate = 1;
 485         break;
 486     case 0x67:
 487         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 488         break;
 489     case 0x68:
 490         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 491         s->hshift[1] =
 492         s->hshift[2] = 1;
 493         break;
 494     case 0x69:
 495         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 496         s->hshift[1] =
 497         s->vshift[1] =
 498         s->hshift[2] =
 499         s->vshift[2] = 1;
 500         break;
 501     case 0x6a:
 502         avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
 503         break;
 504     case 0x6b:
 505         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 506         break;
 507     case 0x6c:
 508         avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
 509         s->hshift[1] =
 510         s->hshift[2] = 1;
 511         s->bps = 10;
 512         break;
 513     case 0x76:
 514         avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
 515         s->bps = 10;
 516         break;
 517     case 0x6d:
 518         avctx->pix_fmt = AV_PIX_FMT_GBRP10;
 519         s->decorrelate = 1;
 520         s->bps = 10;
 521         break;
 522     case 0x6e:
 523         avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
 524         s->decorrelate = 1;
 525         s->bps = 10;
 526         break;
 527     case 0x6f:
 528         avctx->pix_fmt = AV_PIX_FMT_GBRP12;
 529         s->decorrelate = 1;
 530         s->bps = 12;
 531         break;
 532     case 0x70:
 533         avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
 534         s->decorrelate = 1;
 535         s->bps = 12;
 536         break;
 537     case 0x73:
 538         avctx->pix_fmt = AV_PIX_FMT_GRAY10;
 539         s->bps = 10;
 540         break;
 541     case 0x7b:
 542         avctx->pix_fmt = AV_PIX_FMT_YUV420P10;
 543         s->hshift[1] =
 544         s->vshift[1] =
 545         s->hshift[2] =
 546         s->vshift[2] = 1;
 547         s->bps = 10;
 548         break;
 549     default:
 550         avpriv_request_sample(avctx, "Format 0x%X", format);
 551         return AVERROR_PATCHWELCOME;
 552     }
 553     s->max = 1 << s->bps;
 554     s->magy_decode_slice = s->bps == 8 ? magy_decode_slice : magy_decode_slice10;
 555     s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
 556
 557     bytestream2_skipu(&gb, 1);
 558     s->color_matrix = bytestream2_get_byteu(&gb);
 559     s->flags        = bytestream2_get_byteu(&gb);
 560     s->interlaced   = !!(s->flags & 2);
 561     bytestream2_skipu(&gb, 3);
 562
 563     width  = bytestream2_get_le32u(&gb);
 564     height = bytestream2_get_le32u(&gb);
 565     ret = ff_set_dimensions(avctx, width, height);
 566     if (ret < 0)
 567         return ret;
 568
 569     slice_width = bytestream2_get_le32u(&gb);
 570     if (slice_width != avctx->coded_width) {
 571         avpriv_request_sample(avctx, "Slice width %"PRIu32, slice_width);
 572         return AVERROR_PATCHWELCOME;
 573     }
 574     s->slice_height = bytestream2_get_le32u(&gb);
 575     if (s->slice_height <= 0 || s->slice_height > INT_MAX - avctx->coded_height) {
 576         av_log(avctx, AV_LOG_ERROR,
 577                "invalid slice height: %d\n", s->slice_height);
 578         return AVERROR_INVALIDDATA;
 579     }
 580
 581     bytestream2_skipu(&gb, 4);
 582
 583     s->nb_slices = (avctx->coded_height + s->slice_height - 1) / s->slice_height;
 584     if (s->nb_slices > INT_MAX / FFMAX(sizeof(Slice), 4 * 5)) {
 585         av_log(avctx, AV_LOG_ERROR,
 586                "invalid number of slices: %d\n", s->nb_slices);
 587         return AVERROR_INVALIDDATA;
 588     }
 589
 590     if (s->interlaced) {
 591         if ((s->slice_height >> s->vshift[1]) < 2) {
 592             av_log(avctx, AV_LOG_ERROR, "impossible slice height\n");
 593             return AVERROR_INVALIDDATA;
 594         }
 595         if ((avctx->coded_height % s->slice_height) && ((avctx->coded_height % s->slice_height) >> s->vshift[1]) < 2) {
 596             av_log(avctx, AV_LOG_ERROR, "impossible height\n");
 597             return AVERROR_INVALIDDATA;
 598         }
 599     }
 600
 601     if (bytestream2_get_bytes_left(&gb) <= s->nb_slices * s->planes * 5)
 602         return AVERROR_INVALIDDATA;
 603     for (i = 0; i < s->planes; i++) {
 604         av_fast_malloc(&s->slices[i], &s->slices_size[i], s->nb_slices * sizeof(Slice));
 605         if (!s->slices[i])
 606             return AVERROR(ENOMEM);
 607
 608         offset = bytestream2_get_le32u(&gb);
 609         if (offset >= avpkt->size - header_size)
 610             return AVERROR_INVALIDDATA;
 611
 612         if (i == 0)
 613             first_offset = offset;
 614
 615         for (j = 0; j < s->nb_slices - 1; j++) {
 616             s->slices[i][j].start = offset + header_size;
 617
 618             next_offset = bytestream2_get_le32u(&gb);
 619             if (next_offset <= offset || next_offset >= avpkt->size - header_size)
 620                 return AVERROR_INVALIDDATA;
 621
 622             s->slices[i][j].size = next_offset - offset;
 623             if (s->slices[i][j].size < 2)
 624                 return AVERROR_INVALIDDATA;
 625             offset = next_offset;
 626         }
 627
 628         s->slices[i][j].start = offset + header_size;
 629         s->slices[i][j].size  = avpkt->size - s->slices[i][j].start;
 630     }
 631
 632     if (bytestream2_get_byteu(&gb) != s->planes)
 633         return AVERROR_INVALIDDATA;
 634
 635     bytestream2_skipu(&gb, s->nb_slices * s->planes);
 636
 637     table_size = header_size + first_offset - bytestream2_tell(&gb);
 638     if (table_size < 2)
 639         return AVERROR_INVALIDDATA;
 640
 641     ret = build_huffman(avctx, avpkt->data + bytestream2_tell(&gb),
 642                         table_size, s->max);
 643     if (ret < 0)
 644         return ret;
 645
 646     p->pict_type = AV_PICTURE_TYPE_I;
 647     p->key_frame = 1;
 648
 649     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
 650         return ret;
 651
 652     s->buf = avpkt->data;
 653     s->p = p;
 654     avctx->execute2(avctx, s->magy_decode_slice, NULL, NULL, s->nb_slices);
 655
 656     if (avctx->pix_fmt == AV_PIX_FMT_GBRP   ||
 657         avctx->pix_fmt == AV_PIX_FMT_GBRAP  ||
 658         avctx->pix_fmt == AV_PIX_FMT_GBRP10 ||
 659         avctx->pix_fmt == AV_PIX_FMT_GBRAP10||
 660         avctx->pix_fmt == AV_PIX_FMT_GBRAP12||
 661         avctx->pix_fmt == AV_PIX_FMT_GBRP12) {
 662         FFSWAP(uint8_t*, p->data[0], p->data[1]);
 663         FFSWAP(int, p->linesize[0], p->linesize[1]);
 664     } else {
 665         switch (s->color_matrix) {
 666         case 1:
 667             p->colorspace = AVCOL_SPC_BT470BG;
 668             break;
 669         case 2:
 670             p->colorspace = AVCOL_SPC_BT709;
 671             break;
 672         }
 673         p->color_range = (s->flags & 4) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
 674     }
 675
 676     *got_frame = 1;
 677
 678     return avpkt->size;
 679 }
 680
 681 static av_cold int magy_decode_init(AVCodecContext *avctx)
 682 {
 683     MagicYUVContext *s = avctx->priv_data;
 684     ff_llviddsp_init(&s->llviddsp);
 685     return 0;
 686 }
 687
 688 static av_cold int magy_decode_end(AVCodecContext *avctx)
 689 {
 690     MagicYUVContext * const s = avctx->priv_data;
 691     int i;
 692
 693     for (i = 0; i < FF_ARRAY_ELEMS(s->slices); i++) {
 694         av_freep(&s->slices[i]);
 695         s->slices_size[i] = 0;
 696         ff_free_vlc(&s->vlc[i]);
 697     }
 698
 699     return 0;
 700 }
 701
 702 AVCodec ff_magicyuv_decoder = {
 703     .name             = "magicyuv",
 704     .long_name        = NULL_IF_CONFIG_SMALL("MagicYUV video"),
 705     .type             = AVMEDIA_TYPE_VIDEO,
 706     .id               = AV_CODEC_ID_MAGICYUV,
 707     .priv_data_size   = sizeof(MagicYUVContext),
 708     .init             = magy_decode_init,
 709     .close            = magy_decode_end,
 710     .decode           = magy_decode_frame,
 711     .capabilities     = AV_CODEC_CAP_DR1 |
 712                         AV_CODEC_CAP_FRAME_THREADS |
 713                         AV_CODEC_CAP_SLICE_THREADS,
 714     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE,
 715 };