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