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 "thread.h"
  34
  35 typedef struct Slice {
  36     uint32_t start;
  37     uint32_t size;
  38 } Slice;
  39
  40 typedef enum Prediction {
  41     LEFT = 1,
  42     GRADIENT,
  43     MEDIAN,
  44 } Prediction;
  45
  46 typedef struct HuffEntry {
  47     uint8_t  sym;
  48     uint8_t  len;
  49     uint32_t code;
  50 } HuffEntry;
  51
  52 typedef struct MagicYUVContext {
  53     AVFrame          *p;
  54     int               slice_height;
  55     int               nb_slices;
  56     int               planes;         // number of encoded planes in bitstream
  57     int               decorrelate;    // postprocessing work
  58     int               interlaced;     // video is interlaced
  59     uint8_t          *buf;            // pointer to AVPacket->data
  60     int               hshift[4];
  61     int               vshift[4];
  62     Slice            *slices[4];      // slice bitstream positions for each plane
  63     unsigned int      slices_size[4]; // slice sizes for each plane
  64     uint8_t           len[4][256];    // table of code lengths for each plane
  65     VLC               vlc[4];         // VLC for each plane
  66     HuffYUVDSPContext hdsp;
  67 } MagicYUVContext;
  68
  69 static int huff_cmp_len(const void *a, const void *b)
  70 {
  71     const HuffEntry *aa = a, *bb = b;
  72     return (aa->len - bb->len) * 256 + aa->sym - bb->sym;
  73 }
  74
  75 static int huff_build(VLC *vlc, uint8_t *len)
  76 {
  77     HuffEntry he[256];
  78     uint32_t codes[256];
  79     uint8_t bits[256];
  80     uint8_t syms[256];
  81     uint32_t code;
  82     int i;
  83
  84     for (i = 0; i < 256; i++) {
  85         he[i].sym = 255 - i;
  86         he[i].len = len[i];
  87     }
  88     AV_QSORT(he, 256, HuffEntry, huff_cmp_len);
  89
  90     code = 1;
  91     for (i = 255; i >= 0; i--) {
  92         codes[i] = code >> (32 - he[i].len);
  93         bits[i]  = he[i].len;
  94         syms[i]  = he[i].sym;
  95         code += 0x80000000u >> (he[i].len - 1);
  96     }
  97
  98     ff_free_vlc(vlc);
  99     return ff_init_vlc_sparse(vlc, FFMIN(he[255].len, 12), 256,
 100                               bits,  sizeof(*bits),  sizeof(*bits),
 101                               codes, sizeof(*codes), sizeof(*codes),
 102                               syms,  sizeof(*syms),  sizeof(*syms), 0);
 103 }
 104
 105 static int magy_decode_slice(AVCodecContext *avctx, void *tdata,
 106                              int j, int threadnr)
 107 {
 108     MagicYUVContext *s = avctx->priv_data;
 109     int interlaced = s->interlaced;
 110     AVFrame *p = s->p;
 111     int i, k, x;
 112     GetBitContext gb;
 113     uint8_t *dst;
 114
 115     for (i = 0; i < s->planes; i++) {
 116         int left, lefttop, top;
 117         int height = AV_CEIL_RSHIFT(FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height), s->vshift[i]);
 118         int width = AV_CEIL_RSHIFT(avctx->coded_width, s->hshift[i]);
 119         int sheight = AV_CEIL_RSHIFT(s->slice_height, s->vshift[i]);
 120         ptrdiff_t fake_stride = p->linesize[i] * (1 + interlaced);
 121         ptrdiff_t stride = p->linesize[i];
 122         int flags, pred;
 123         int ret = init_get_bits8(&gb, s->buf + s->slices[i][j].start,
 124                                  s->slices[i][j].size);
 125
 126         if (ret < 0)
 127             return ret;
 128
 129         flags = get_bits(&gb, 8);
 130         pred  = get_bits(&gb, 8);
 131
 132         dst = p->data[i] + j * sheight * stride;
 133         if (flags & 1) {
 134             for (k = 0; k < height; k++) {
 135                 for (x = 0; x < width; x++)
 136                     dst[x] = get_bits(&gb, 8);
 137
 138                 dst += stride;
 139             }
 140         } else {
 141             for (k = 0; k < height; k++) {
 142                 for (x = 0; x < width; x++) {
 143                     int pix;
 144                     if (get_bits_left(&gb) <= 0)
 145                         return AVERROR_INVALIDDATA;
 146
 147                     pix = get_vlc2(&gb, s->vlc[i].table, s->vlc[i].bits, 3);
 148                     if (pix < 0)
 149                         return AVERROR_INVALIDDATA;
 150
 151                     dst[x] = 255 - pix;
 152                 }
 153                 dst += stride;
 154             }
 155         }
 156
 157         switch (pred) {
 158         case LEFT:
 159             dst = p->data[i] + j * sheight * stride;
 160             s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
 161             dst += stride;
 162             if (interlaced) {
 163                 s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
 164                 dst += stride;
 165             }
 166             for (k = 1 + interlaced; k < height; k++) {
 167                 s->hdsp.add_hfyu_left_pred(dst, dst, width, dst[-fake_stride]);
 168                 dst += stride;
 169             }
 170             break;
 171         case GRADIENT:
 172             dst = p->data[i] + j * sheight * stride;
 173             s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
 174             left = lefttop = 0;
 175             dst += stride;
 176             if (interlaced) {
 177                 s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
 178                 left = lefttop = 0;
 179                 dst += stride;
 180             }
 181             for (k = 1 + interlaced; k < height; k++) {
 182                 top = dst[-fake_stride];
 183                 left = top + dst[0];
 184                 dst[0] = left;
 185                 for (x = 1; x < width; x++) {
 186                     top = dst[x - fake_stride];
 187                     lefttop = dst[x - (fake_stride + 1)];
 188                     left += top - lefttop + dst[x];
 189                     dst[x] = left;
 190                 }
 191                 dst += stride;
 192             }
 193             break;
 194         case MEDIAN:
 195             dst = p->data[i] + j * sheight * stride;
 196             lefttop = left = dst[0];
 197             s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
 198             dst += stride;
 199             if (interlaced) {
 200                 lefttop = left = dst[0];
 201                 s->hdsp.add_hfyu_left_pred(dst, dst, width, 0);
 202                 dst += stride;
 203             }
 204             for (k = 1 + interlaced; k < height; k++) {
 205                 s->hdsp.add_hfyu_median_pred(dst, dst - fake_stride,
 206                                              dst, width, &left, &lefttop);
 207                 lefttop = left = dst[0];
 208                 dst += stride;
 209             }
 210             break;
 211         default:
 212             avpriv_request_sample(avctx, "Unknown prediction: %d", pred);
 213         }
 214     }
 215
 216     if (s->decorrelate) {
 217         int height = FFMIN(s->slice_height, avctx->coded_height - j * s->slice_height);
 218         int width = avctx->coded_width;
 219         uint8_t *b = p->data[0] + j * s->slice_height * p->linesize[0];
 220         uint8_t *g = p->data[1] + j * s->slice_height * p->linesize[1];
 221         uint8_t *r = p->data[2] + j * s->slice_height * p->linesize[2];
 222
 223         for (i = 0; i < height; i++) {
 224             s->hdsp.add_bytes(b, g, width);
 225             s->hdsp.add_bytes(r, g, width);
 226             b += p->linesize[0];
 227             g += p->linesize[1];
 228             r += p->linesize[2];
 229         }
 230     }
 231
 232     return 0;
 233 }
 234
 235 static int magy_decode_frame(AVCodecContext *avctx, void *data,
 236                              int *got_frame, AVPacket *avpkt)
 237 {
 238     MagicYUVContext *s = avctx->priv_data;
 239     ThreadFrame frame = { .f = data };
 240     AVFrame *p = data;
 241     GetByteContext gbyte;
 242     GetBitContext gbit;
 243     uint32_t first_offset, offset, next_offset, header_size, slice_width;
 244     int width, height, format, version, table_size;
 245     int ret, i, j, k;
 246
 247     bytestream2_init(&gbyte, avpkt->data, avpkt->size);
 248     if (bytestream2_get_le32(&gbyte) != MKTAG('M', 'A', 'G', 'Y'))
 249         return AVERROR_INVALIDDATA;
 250
 251     header_size = bytestream2_get_le32(&gbyte);
 252     if (header_size < 32 || header_size >= avpkt->size) {
 253         av_log(avctx, AV_LOG_ERROR,
 254                "header or packet too small %"PRIu32"\n", header_size);
 255         return AVERROR_INVALIDDATA;
 256     }
 257
 258     version = bytestream2_get_byte(&gbyte);
 259     if (version != 7) {
 260         avpriv_request_sample(avctx, "Version %d", version);
 261         return AVERROR_PATCHWELCOME;
 262     }
 263
 264     s->hshift[1] =
 265     s->vshift[1] =
 266     s->hshift[2] =
 267     s->vshift[2] = 0;
 268     s->decorrelate = 0;
 269
 270     format = bytestream2_get_byte(&gbyte);
 271     switch (format) {
 272     case 0x65:
 273         avctx->pix_fmt = AV_PIX_FMT_GBRP;
 274         s->decorrelate = 1;
 275         break;
 276     case 0x66:
 277         avctx->pix_fmt = AV_PIX_FMT_GBRAP;
 278         s->decorrelate = 1;
 279         break;
 280     case 0x67:
 281         avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 282         break;
 283     case 0x68:
 284         avctx->pix_fmt = AV_PIX_FMT_YUV422P;
 285         s->hshift[1] =
 286         s->hshift[2] = 1;
 287         break;
 288     case 0x69:
 289         avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 290         s->hshift[1] =
 291         s->vshift[1] =
 292         s->hshift[2] =
 293         s->vshift[2] = 1;
 294         break;
 295     case 0x6a:
 296         avctx->pix_fmt = AV_PIX_FMT_YUVA444P;
 297         break;
 298     case 0x6b:
 299         avctx->pix_fmt = AV_PIX_FMT_GRAY8;
 300         break;
 301     default:
 302         avpriv_request_sample(avctx, "Format 0x%X", format);
 303         return AVERROR_PATCHWELCOME;
 304     }
 305     s->planes = av_pix_fmt_count_planes(avctx->pix_fmt);
 306
 307     bytestream2_skip(&gbyte, 2);
 308     s->interlaced = !!(bytestream2_get_byte(&gbyte) & 2);
 309     bytestream2_skip(&gbyte, 3);
 310
 311     width  = bytestream2_get_le32(&gbyte);
 312     height = bytestream2_get_le32(&gbyte);
 313     ret = ff_set_dimensions(avctx, width, height);
 314     if (ret < 0)
 315         return ret;
 316
 317     slice_width = bytestream2_get_le32(&gbyte);
 318     if (slice_width != avctx->coded_width) {
 319         avpriv_request_sample(avctx, "Slice width %"PRIu32, slice_width);
 320         return AVERROR_PATCHWELCOME;
 321     }
 322     s->slice_height = bytestream2_get_le32(&gbyte);
 323     if (s->slice_height <= 0 || s->slice_height > INT_MAX - avctx->coded_height) {
 324         av_log(avctx, AV_LOG_ERROR,
 325                "invalid slice height: %d\n", s->slice_height);
 326         return AVERROR_INVALIDDATA;
 327     }
 328
 329     bytestream2_skip(&gbyte, 4);
 330
 331     s->nb_slices = (avctx->coded_height + s->slice_height - 1) / s->slice_height;
 332     if (s->nb_slices > INT_MAX / sizeof(Slice)) {
 333         av_log(avctx, AV_LOG_ERROR,
 334                "invalid number of slices: %d\n", s->nb_slices);
 335         return AVERROR_INVALIDDATA;
 336     }
 337
 338     for (i = 0; i < s->planes; i++) {
 339         av_fast_malloc(&s->slices[i], &s->slices_size[i], s->nb_slices * sizeof(Slice));
 340         if (!s->slices[i])
 341             return AVERROR(ENOMEM);
 342
 343         offset = bytestream2_get_le32(&gbyte);
 344         if (offset >= avpkt->size - header_size)
 345             return AVERROR_INVALIDDATA;
 346
 347         if (i == 0)
 348             first_offset = offset;
 349
 350         for (j = 0; j < s->nb_slices - 1; j++) {
 351             s->slices[i][j].start = offset + header_size;
 352
 353             next_offset = bytestream2_get_le32(&gbyte);
 354             if (next_offset <= offset || next_offset >= avpkt->size - header_size)
 355                 return AVERROR_INVALIDDATA;
 356
 357             s->slices[i][j].size = next_offset - offset;
 358             offset = next_offset;
 359         }
 360
 361         s->slices[i][j].start = offset + header_size;
 362         s->slices[i][j].size  = avpkt->size - s->slices[i][j].start;
 363     }
 364
 365     if (bytestream2_get_byte(&gbyte) != s->planes)
 366         return AVERROR_INVALIDDATA;
 367
 368     bytestream2_skip(&gbyte, s->nb_slices * s->planes);
 369
 370     table_size = header_size + first_offset - bytestream2_tell(&gbyte);
 371     if (table_size < 2)
 372         return AVERROR_INVALIDDATA;
 373
 374     ret = init_get_bits8(&gbit, avpkt->data + bytestream2_tell(&gbyte), table_size);
 375     if (ret < 0)
 376         return ret;
 377
 378     memset(s->len, 0, sizeof(s->len));
 379     j = i = 0;
 380     while (get_bits_left(&gbit) >= 8) {
 381         int b = get_bits(&gbit, 4);
 382         int x = get_bits(&gbit, 4);
 383         int l = get_bitsz(&gbit, b) + 1;
 384
 385         for (k = 0; k < l; k++)
 386             if (j + k < 256)
 387                 s->len[i][j + k] = x;
 388
 389         j += l;
 390         if (j == 256) {
 391             j = 0;
 392             if (huff_build(&s->vlc[i], s->len[i])) {
 393                 av_log(avctx, AV_LOG_ERROR, "Cannot build Huffman codes\n");
 394                 return AVERROR_INVALIDDATA;
 395             }
 396             i++;
 397             if (i == s->planes) {
 398                 break;
 399             }
 400         } else if (j > 256) {
 401             return AVERROR_INVALIDDATA;
 402         }
 403     }
 404
 405     if (i != s->planes) {
 406         av_log(avctx, AV_LOG_ERROR, "Huffman tables too short\n");
 407         return AVERROR_INVALIDDATA;
 408     }
 409
 410     p->pict_type = AV_PICTURE_TYPE_I;
 411     p->key_frame = 1;
 412
 413     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
 414         return ret;
 415
 416     s->buf = avpkt->data;
 417     s->p = p;
 418     avctx->execute2(avctx, magy_decode_slice, NULL, NULL, s->nb_slices);
 419
 420     if (avctx->pix_fmt == AV_PIX_FMT_GBRP ||
 421         avctx->pix_fmt == AV_PIX_FMT_GBRAP) {
 422         FFSWAP(uint8_t*, p->data[0], p->data[1]);
 423         FFSWAP(int, p->linesize[0], p->linesize[1]);
 424     }
 425
 426     *got_frame = 1;
 427
 428     return avpkt->size;
 429 }
 430
 431 #if HAVE_THREADS
 432 static int magy_init_thread_copy(AVCodecContext *avctx)
 433 {
 434     MagicYUVContext *s = avctx->priv_data;
 435     int i;
 436
 437     for (i = 0; i < FF_ARRAY_ELEMS(s->slices); i++) {
 438         s->slices[i] = NULL;
 439         s->slices_size[i] = 0;
 440     }
 441
 442     return 0;
 443 }
 444 #endif
 445
 446 static av_cold int magy_decode_init(AVCodecContext *avctx)
 447 {
 448     MagicYUVContext *s = avctx->priv_data;
 449     ff_huffyuvdsp_init(&s->hdsp);
 450     return 0;
 451 }
 452
 453 static av_cold int magy_decode_end(AVCodecContext *avctx)
 454 {
 455     MagicYUVContext * const s = avctx->priv_data;
 456     int i;
 457
 458     for (i = 0; i < FF_ARRAY_ELEMS(s->slices); i++) {
 459         av_freep(&s->slices[i]);
 460         s->slices_size[i] = 0;
 461         ff_free_vlc(&s->vlc[i]);
 462     }
 463
 464     return 0;
 465 }
 466
 467 AVCodec ff_magicyuv_decoder = {
 468     .name             = "magicyuv",
 469     .long_name        = NULL_IF_CONFIG_SMALL("MagicYUV video"),
 470     .type             = AVMEDIA_TYPE_VIDEO,
 471     .id               = AV_CODEC_ID_MAGICYUV,
 472     .priv_data_size   = sizeof(MagicYUVContext),
 473     .init             = magy_decode_init,
 474     .init_thread_copy = ONLY_IF_THREADS_ENABLED(magy_init_thread_copy),
 475     .close            = magy_decode_end,
 476     .decode           = magy_decode_frame,
 477     .capabilities     = AV_CODEC_CAP_DR1 |
 478                         AV_CODEC_CAP_FRAME_THREADS |
 479                         AV_CODEC_CAP_SLICE_THREADS,
 480     .caps_internal    = FF_CODEC_CAP_INIT_THREADSAFE,
 481 };