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         k = j + l;
 463         if (k > max) {
 464             av_log(avctx, AV_LOG_ERROR, "Invalid Huffman codes\n");
 465             return AVERROR_INVALIDDATA;
 466         }
 467
 468         for (; j < k; j++)
 469             s->len[i][j] = x;
 470
 471         if (j == max) {
 472             j = 0;
 473             if (s->huff_build(&s->vlc[i], s->len[i])) {
 474                 av_log(avctx, AV_LOG_ERROR, "Cannot build Huffman codes\n");
 475                 return AVERROR_INVALIDDATA;
 476             }
 477             i++;
 478             if (i == s->planes) {
 479                 break;
 480             }
 481         }
 482     }
 483
 484     if (i != s->planes) {
 485         av_log(avctx, AV_LOG_ERROR, "Huffman tables too short\n");
 486         return AVERROR_INVALIDDATA;
 487     }
 488
 489     return 0;
 490 }
 491
 492 static int magy_decode_frame(AVCodecContext *avctx, void *data,
 493                              int *got_frame, AVPacket *avpkt)
 494 {
 495     MagicYUVContext *s = avctx->priv_data;
 496     ThreadFrame frame = { .f = data };
 497     AVFrame *p = data;
 498     GetByteContext gbyte;
 499     GetBitContext gbit;
 500     uint32_t first_offset, offset, next_offset, header_size, slice_width;
 501     int width, height, format, version, table_size;
 502     int ret, i, j;
 503
 504     bytestream2_init(&gbyte, avpkt->data, avpkt->size);
 505     if (bytestream2_get_le32(&gbyte) != MKTAG('M', 'A', 'G', 'Y'))
 506         return AVERROR_INVALIDDATA;
 507
 508     header_size = bytestream2_get_le32(&gbyte);
 509     if (header_size < 32 || header_size >= avpkt->size) {
 510         av_log(avctx, AV_LOG_ERROR,
 511                "header or packet too small %"PRIu32"\n", header_size);
 512         return AVERROR_INVALIDDATA;
 513     }
 514
 515     version = bytestream2_get_byte(&gbyte);
 516     if (version != 7) {
 517         avpriv_request_sample(avctx, "Version %d", version);
 518         return AVERROR_PATCHWELCOME;
 519     }
 520
 521     s->hshift[1] =
 522     s->vshift[1] =
 523     s->hshift[2] =
 524     s->vshift[2] = 0;
 525     s->decorrelate = 0;
 526     s->bps = 8;
 527
 528     format = bytestream2_get_byte(&gbyte);
 529     switch (format) {
 530     case 0x65:
 531         avctx->pix_fmt = AV_PIX_FMT_GBRP;
 532         s->decorrelate = 1;
 533         break;
 534     case 0x66:
 535         avctx->pix_fmt = AV_PIX_FMT_GBRAP;
 536         s->decorrelate = 1;
 537         break;
 538     case 0x67:
 539         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 540         break;
 541     case 0x68:
 542         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 543         s->hshift[1] =
 544         s->hshift[2] = 1;
 545         break;
 546     case 0x69:
 547         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 548         s->hshift[1] =
 549         s->vshift[1] =
 550         s->hshift[2] =
 551         s->vshift[2] = 1;
 552         break;
 553     case 0x6a:
 554         avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
 555         break;
 556     case 0x6b:
 557         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 558         break;
 559     case 0x6c:
 560         avctx->pix_fmt = AV_PIX_FMT_YUV422P10;
 561         s->hshift[1] =
 562         s->hshift[2] = 1;
 563         s->bps = 10;
 564         break;
 565     case 0x76:
 566         avctx->pix_fmt = AV_PIX_FMT_YUV444P10;
 567         s->bps = 10;
 568         break;
 569     case 0x6d:
 570         avctx->pix_fmt = AV_PIX_FMT_GBRP10;
 571         s->decorrelate = 1;
 572         s->bps = 10;
 573         break;
 574     case 0x6e:
 575         avctx->pix_fmt = AV_PIX_FMT_GBRAP10;
 576         s->decorrelate = 1;
 577         s->bps = 10;
 578         break;
 579     case 0x6f:
 580         avctx->pix_fmt = AV_PIX_FMT_GBRP12;
 581         s->decorrelate = 1;
 582         s->bps = 12;
 583         break;
 584     case 0x70:
 585         avctx->pix_fmt = AV_PIX_FMT_GBRAP12;
 586         s->decorrelate = 1;
 587         s->bps = 12;
 588         break;
 589     case 0x73:
 590         avctx->pix_fmt = AV_PIX_FMT_GRAY10;
 591         s->bps = 10;
 592         break;
 593     default:
 594         avpriv_request_sample(avctx, "Format 0x%X", format);
 595         return AVERROR_PATCHWELCOME;
 596     }
 597     s->max = 1 << s->bps;
 598     s->magy_decode_slice = s->bps == 8 ? magy_decode_slice : magy_decode_slice10;
 599     if ( s->bps == 8)
 600         s->huff_build = huff_build;
 601     else
 602         s->huff_build = s->bps == 10 ? huff_build10 : huff_build12;
 603     s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
 604
 605     bytestream2_skip(&gbyte, 1);
 606     s->color_matrix = bytestream2_get_byte(&gbyte);
 607     s->flags        = bytestream2_get_byte(&gbyte);
 608     s->interlaced   = !!(s->flags & 2);
 609     bytestream2_skip(&gbyte, 3);
 610
 611     width  = bytestream2_get_le32(&gbyte);
 612     height = bytestream2_get_le32(&gbyte);
 613     ret = ff_set_dimensions(avctx, width, height);
 614     if (ret < 0)
 615         return ret;
 616
 617     slice_width = bytestream2_get_le32(&gbyte);
 618     if (slice_width != avctx->coded_width) {
 619         avpriv_request_sample(avctx, "Slice width %"PRIu32, slice_width);
 620         return AVERROR_PATCHWELCOME;
 621     }
 622     s->slice_height = bytestream2_get_le32(&gbyte);
 623     if (s->slice_height <= 0 || s->slice_height > INT_MAX - avctx->coded_height) {
 624         av_log(avctx, AV_LOG_ERROR,
 625                "invalid slice height: %d\n", s->slice_height);
 626         return AVERROR_INVALIDDATA;
 627     }
 628
 629     bytestream2_skip(&gbyte, 4);
 630
 631     s->nb_slices = (avctx->coded_height + s->slice_height - 1) / s->slice_height;
 632     if (s->nb_slices > INT_MAX / sizeof(Slice)) {
 633         av_log(avctx, AV_LOG_ERROR,
 634                "invalid number of slices: %d\n", s->nb_slices);
 635         return AVERROR_INVALIDDATA;
 636     }
 637
 638     if (s->interlaced) {
 639         if ((s->slice_height >> s->vshift[1]) < 2) {
 640             av_log(avctx, AV_LOG_ERROR, "impossible slice height\n");
 641             return AVERROR_INVALIDDATA;
 642         }
 643         if ((avctx->coded_height % s->slice_height) && ((avctx->coded_height % s->slice_height) >> s->vshift[1]) < 2) {
 644             av_log(avctx, AV_LOG_ERROR, "impossible height\n");
 645             return AVERROR_INVALIDDATA;
 646         }
 647     }
 648
 649     for (i = 0; i < s->planes; i++) {
 650         av_fast_malloc(&s->slices[i], &s->slices_size[i], s->nb_slices * sizeof(Slice));
 651         if (!s->slices[i])
 652             return AVERROR(ENOMEM);
 653
 654         offset = bytestream2_get_le32(&gbyte);
 655         if (offset >= avpkt->size - header_size)
 656             return AVERROR_INVALIDDATA;
 657
 658         if (i == 0)
 659             first_offset = offset;
 660
 661         for (j = 0; j < s->nb_slices - 1; j++) {
 662             s->slices[i][j].start = offset + header_size;
 663
 664             next_offset = bytestream2_get_le32(&gbyte);
 665             if (next_offset <= offset || next_offset >= avpkt->size - header_size)
 666                 return AVERROR_INVALIDDATA;
 667
 668             s->slices[i][j].size = next_offset - offset;
 669             offset = next_offset;
 670         }
 671
 672         s->slices[i][j].start = offset + header_size;
 673         s->slices[i][j].size  = avpkt->size - s->slices[i][j].start;
 674     }
 675
 676     if (bytestream2_get_byte(&gbyte) != s->planes)
 677         return AVERROR_INVALIDDATA;
 678
 679     bytestream2_skip(&gbyte, s->nb_slices * s->planes);
 680
 681     table_size = header_size + first_offset - bytestream2_tell(&gbyte);
 682     if (table_size < 2)
 683         return AVERROR_INVALIDDATA;
 684
 685     ret = init_get_bits8(&gbit, avpkt->data + bytestream2_tell(&gbyte), table_size);
 686     if (ret < 0)
 687         return ret;
 688
 689     ret = build_huffman(avctx, &gbit, s->max);
 690     if (ret < 0)
 691         return ret;
 692
 693     p->pict_type = AV_PICTURE_TYPE_I;
 694     p->key_frame = 1;
 695
 696     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
 697         return ret;
 698
 699     s->buf = avpkt->data;
 700     s->p = p;
 701     avctx->execute2(avctx, s->magy_decode_slice, NULL, NULL, s->nb_slices);
 702
 703     if (avctx->pix_fmt == AV_PIX_FMT_GBRP   ||
 704         avctx->pix_fmt == AV_PIX_FMT_GBRAP  ||
 705         avctx->pix_fmt == AV_PIX_FMT_GBRP10 ||
 706         avctx->pix_fmt == AV_PIX_FMT_GBRAP10||
 707         avctx->pix_fmt == AV_PIX_FMT_GBRAP12||
 708         avctx->pix_fmt == AV_PIX_FMT_GBRP12) {
 709         FFSWAP(uint8_t*, p->data[0], p->data[1]);
 710         FFSWAP(int, p->linesize[0], p->linesize[1]);
 711     } else {
 712         switch (s->color_matrix) {
 713         case 1:
 714             p->colorspace = AVCOL_SPC_BT470BG;
 715             break;
 716         case 2:
 717             p->colorspace = AVCOL_SPC_BT709;
 718             break;
 719         }
 720         p->color_range = (s->flags & 4) ? AVCOL_RANGE_JPEG : AVCOL_RANGE_MPEG;
 721     }
 722
 723     *got_frame = 1;
 724
 725     return avpkt->size;
 726 }
 727
 728 static av_cold int magy_decode_init(AVCodecContext *avctx)
 729 {
 730     MagicYUVContext *s = avctx->priv_data;
 731     ff_llviddsp_init(&s->llviddsp);
 732     return 0;
 733 }
 734
 735 static av_cold int magy_decode_end(AVCodecContext *avctx)
 736 {
 737     MagicYUVContext * const s = avctx->priv_data;
 738     int i;
 739
 740     for (i = 0; i < FF_ARRAY_ELEMS(s->slices); i++) {
 741         av_freep(&s->slices[i]);
 742         s->slices_size[i] = 0;
 743         ff_free_vlc(&s->vlc[i]);
 744     }
 745
 746     return 0;
 747 }
 748
 749 AVCodec ff_magicyuv_decoder = {
 750     .name             = "magicyuv",
 751     .long_name        = NULL_IF_CONFIG_SMALL("MagicYUV video"),
 752     .type             = AVMEDIA_TYPE_VIDEO,
 753     .id               = AV_CODEC_ID_MAGICYUV,
 754     .priv_data_size   = sizeof(MagicYUVContext),
 755     .init             = magy_decode_init,
 756     .close            = magy_decode_end,
 757     .decode           = magy_decode_frame,
 758     .capabilities     = AV_CODEC_CAP_DR1 |
 759                         AV_CODEC_CAP_FRAME_THREADS |
 760                         AV_CODEC_CAP_SLICE_THREADS,
 761     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE,
 762 };