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