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