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