git.sesse.net Git - ffmpeg/blob - libavcodec/dxtory.c

   1 /*
   2  * Dxtory decoder
   3  *
   4  * Copyright (c) 2011 Konstantin Shishkov
   5  *
   6  * This file is part of Libav.
   7  *
   8  * Libav is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * Libav is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with Libav; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  21  */
  22
  23 #include <inttypes.h>
  24
  25 #define BITSTREAM_READER_LE
  26 #include "avcodec.h"
  27 #include "bytestream.h"
  28 #include "get_bits.h"
  29 #include "internal.h"
  30 #include "unary.h"
  31 #include "libavutil/common.h"
  32 #include "libavutil/intreadwrite.h"
  33
  34 static int dxtory_decode_v1_rgb(AVCodecContext *avctx, AVFrame *pic,
  35                                 const uint8_t *src, int src_size,
  36                                 int id, int bpp)
  37 {
  38     int h;
  39     uint8_t *dst;
  40     int ret;
  41
  42     if (src_size < avctx->width * avctx->height * bpp) {
  43         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
  44         return AVERROR_INVALIDDATA;
  45     }
  46
  47     avctx->pix_fmt = id;
  48     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
  49         return ret;
  50
  51     dst = pic->data[0];
  52     for (h = 0; h < avctx->height; h++) {
  53         memcpy(dst, src, avctx->width * bpp);
  54         src += avctx->width * bpp;
  55         dst += pic->linesize[0];
  56     }
  57
  58     return 0;
  59 }
  60
  61 static int dxtory_decode_v1_410(AVCodecContext *avctx, AVFrame *pic,
  62                                 const uint8_t *src, int src_size)
  63 {
  64     int h, w;
  65     uint8_t *Y1, *Y2, *Y3, *Y4, *U, *V;
  66     int ret;
  67
  68     if (src_size < avctx->width * avctx->height * 18 / 16) {
  69         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
  70         return AVERROR_INVALIDDATA;
  71     }
  72
  73     avctx->pix_fmt = AV_PIX_FMT_YUV410P;
  74     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
  75         return ret;
  76
  77     Y1 = pic->data[0];
  78     Y2 = pic->data[0] + pic->linesize[0];
  79     Y3 = pic->data[0] + pic->linesize[0] * 2;
  80     Y4 = pic->data[0] + pic->linesize[0] * 3;
  81     U  = pic->data[1];
  82     V  = pic->data[2];
  83     for (h = 0; h < avctx->height; h += 4) {
  84         for (w = 0; w < avctx->width; w += 4) {
  85             AV_COPY32(Y1 + w, src);
  86             AV_COPY32(Y2 + w, src + 4);
  87             AV_COPY32(Y3 + w, src + 8);
  88             AV_COPY32(Y4 + w, src + 12);
  89             U[w >> 2] = src[16] + 0x80;
  90             V[w >> 2] = src[17] + 0x80;
  91             src += 18;
  92         }
  93         Y1 += pic->linesize[0] << 2;
  94         Y2 += pic->linesize[0] << 2;
  95         Y3 += pic->linesize[0] << 2;
  96         Y4 += pic->linesize[0] << 2;
  97         U  += pic->linesize[1];
  98         V  += pic->linesize[2];
  99     }
 100
 101     return 0;
 102 }
 103
 104 static int dxtory_decode_v1_420(AVCodecContext *avctx, AVFrame *pic,
 105                                 const uint8_t *src, int src_size)
 106 {
 107     int h, w;
 108     uint8_t *Y1, *Y2, *U, *V;
 109     int ret;
 110
 111     if (src_size < avctx->width * avctx->height * 3 / 2) {
 112         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
 113         return AVERROR_INVALIDDATA;
 114     }
 115
 116     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 117     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 118         return ret;
 119
 120     Y1 = pic->data[0];
 121     Y2 = pic->data[0] + pic->linesize[0];
 122     U  = pic->data[1];
 123     V  = pic->data[2];
 124     for (h = 0; h < avctx->height; h += 2) {
 125         for (w = 0; w < avctx->width; w += 2) {
 126             AV_COPY16(Y1 + w, src);
 127             AV_COPY16(Y2 + w, src + 2);
 128             U[w >> 1] = src[4] + 0x80;
 129             V[w >> 1] = src[5] + 0x80;
 130             src += 6;
 131         }
 132         Y1 += pic->linesize[0] << 1;
 133         Y2 += pic->linesize[0] << 1;
 134         U  += pic->linesize[1];
 135         V  += pic->linesize[2];
 136     }
 137
 138     return 0;
 139 }
 140
 141 static int dxtory_decode_v1_444(AVCodecContext *avctx, AVFrame *pic,
 142                                 const uint8_t *src, int src_size)
 143 {
 144     int h, w;
 145     uint8_t *Y, *U, *V;
 146     int ret;
 147
 148     if (src_size < avctx->width * avctx->height * 3) {
 149         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
 150         return AVERROR_INVALIDDATA;
 151     }
 152
 153     avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 154     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 155         return ret;
 156
 157     Y = pic->data[0];
 158     U = pic->data[1];
 159     V = pic->data[2];
 160     for (h = 0; h < avctx->height; h++) {
 161         for (w = 0; w < avctx->width; w++) {
 162             Y[w] = *src++;
 163             U[w] = *src++ ^ 0x80;
 164             V[w] = *src++ ^ 0x80;
 165         }
 166         Y += pic->linesize[0];
 167         U += pic->linesize[1];
 168         V += pic->linesize[2];
 169     }
 170
 171     return 0;
 172 }
 173
 174 const uint8_t def_lru[8] = { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xFF };
 175 const uint8_t def_lru_555[8] = { 0x00, 0x08, 0x10, 0x18, 0x1F };
 176 const uint8_t def_lru_565[8] = { 0x00, 0x08, 0x10, 0x20, 0x30, 0x3F };
 177
 178 static inline uint8_t decode_sym(GetBitContext *gb, uint8_t lru[8])
 179 {
 180     uint8_t c, val;
 181
 182     c = get_unary(gb, 0, 8);
 183     if (!c) {
 184         val = get_bits(gb, 8);
 185         memmove(lru + 1, lru, sizeof(*lru) * (8 - 1));
 186     } else {
 187         val = lru[c - 1];
 188         memmove(lru + 1, lru, sizeof(*lru) * (c - 1));
 189     }
 190     lru[0] = val;
 191
 192     return val;
 193 }
 194
 195 static int check_slice_size(AVCodecContext *avctx,
 196                             const uint8_t *src, int src_size,
 197                             int slice_size, int off)
 198 {
 199     int cur_slice_size;
 200
 201     if (slice_size > src_size - off) {
 202         av_log(avctx, AV_LOG_ERROR,
 203                "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
 204                slice_size, src_size - off);
 205         return AVERROR_INVALIDDATA;
 206     }
 207     if (slice_size <= 16) {
 208         av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n",
 209                slice_size);
 210         return AVERROR_INVALIDDATA;
 211     }
 212
 213     cur_slice_size = AV_RL32(src + off);
 214     if (cur_slice_size != slice_size - 16) {
 215         av_log(avctx, AV_LOG_ERROR,
 216                "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
 217                cur_slice_size, slice_size - 16);
 218     }
 219
 220     return 0;
 221 }
 222
 223 static int load_buffer(AVCodecContext *avctx,
 224                        const uint8_t *src, int src_size,
 225                        GetByteContext *gb,
 226                        int *nslices, int *off)
 227 {
 228     bytestream2_init(gb, src, src_size);
 229     *nslices = bytestream2_get_le16(gb);
 230     *off = FFALIGN(*nslices * 4 + 2, 16);
 231     if (src_size < *off) {
 232         av_log(avctx, AV_LOG_ERROR, "no slice data\n");
 233         return AVERROR_INVALIDDATA;
 234     }
 235
 236     if (!*nslices) {
 237         avpriv_request_sample(avctx, "%d slices for %dx%d", *nslices,
 238                               avctx->width, avctx->height);
 239         return AVERROR_PATCHWELCOME;
 240     }
 241
 242     return 0;
 243 }
 244
 245 static inline uint8_t decode_sym_565(GetBitContext *gb, uint8_t lru[8],
 246                                      int bits)
 247 {
 248     uint8_t c, val;
 249
 250     c = get_unary(gb, 0, bits);
 251     if (!c) {
 252         val = get_bits(gb, bits);
 253         memmove(lru + 1, lru, sizeof(*lru) * (6 - 1));
 254     } else {
 255         val = lru[c - 1];
 256         memmove(lru + 1, lru, sizeof(*lru) * (c - 1));
 257     }
 258     lru[0] = val;
 259
 260     return val;
 261 }
 262
 263 typedef int (*decode_slice_func)(GetBitContext *gb, AVFrame *frame,
 264                                  int line, int height, uint8_t lru[3][8]);
 265
 266 typedef void (*setup_lru_func)(uint8_t lru[3][8]);
 267
 268 static int dxtory_decode_v2(AVCodecContext *avctx, AVFrame *pic,
 269                             const uint8_t *src, int src_size,
 270                             decode_slice_func decode_slice,
 271                             setup_lru_func setup_lru,
 272                             enum AVPixelFormat fmt)
 273 {
 274     GetByteContext gb;
 275     GetBitContext  gb2;
 276     int nslices, slice, line = 0;
 277     uint32_t off, slice_size;
 278     uint8_t lru[3][8];
 279     int ret;
 280
 281     ret = load_buffer(avctx, src, src_size, &gb, &nslices, &off);
 282     if (ret < 0)
 283         return ret;
 284
 285     avctx->pix_fmt = fmt;
 286     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 287         return ret;
 288
 289     for (slice = 0; slice < nslices; slice++) {
 290         slice_size = bytestream2_get_le32(&gb);
 291
 292         setup_lru(lru);
 293
 294         ret = check_slice_size(avctx, src, src_size, slice_size, off);
 295         if (ret < 0)
 296             return ret;
 297
 298         init_get_bits(&gb2, src + off + 16, (slice_size - 16) * 8);
 299
 300         line += decode_slice(&gb2, pic, line, avctx->height - line, lru);
 301
 302         off += slice_size;
 303     }
 304
 305     if (avctx->height - line) {
 306         av_log(avctx, AV_LOG_VERBOSE,
 307                "Not enough slice data available, "
 308                "cropping the frame by %d pixels\n",
 309                 avctx->height - line);
 310         avctx->height = line;
 311     }
 312
 313     return 0;
 314 }
 315
 316 av_always_inline
 317 static int dx2_decode_slice_5x5(GetBitContext *gb, AVFrame *frame,
 318                                 int line, int left, uint8_t lru[3][8],
 319                                 int is_565)
 320 {
 321     int x, y;
 322     int r, g, b;
 323     int width    = frame->width;
 324     int stride   = frame->linesize[0];
 325     uint8_t *dst = frame->data[0] + stride * line;
 326
 327     for (y = 0; y < left && get_bits_left(gb) > 16; y++) {
 328         for (x = 0; x < width; x++) {
 329             b = decode_sym_565(gb, lru[0], 5);
 330             g = decode_sym_565(gb, lru[1], is_565 ? 6 : 5);
 331             r = decode_sym_565(gb, lru[2], 5);
 332             dst[x * 3 + 0] = (r << 3) | (r >> 2);
 333             dst[x * 3 + 1] = is_565 ? (g << 2) | (g >> 4) : (g << 3) | (g >> 2);
 334             dst[x * 3 + 2] = (b << 3) | (b >> 2);
 335         }
 336
 337         dst += stride;
 338     }
 339
 340     return y;
 341 }
 342
 343 static void setup_lru_555(uint8_t lru[3][8])
 344 {
 345     memcpy(lru[0], def_lru_555, 8 * sizeof(*def_lru));
 346     memcpy(lru[1], def_lru_555, 8 * sizeof(*def_lru));
 347     memcpy(lru[2], def_lru_555, 8 * sizeof(*def_lru));
 348 }
 349
 350 static void setup_lru_565(uint8_t lru[3][8])
 351 {
 352     memcpy(lru[0], def_lru_555, 8 * sizeof(*def_lru));
 353     memcpy(lru[1], def_lru_565, 8 * sizeof(*def_lru));
 354     memcpy(lru[2], def_lru_555, 8 * sizeof(*def_lru));
 355 }
 356
 357 static int dx2_decode_slice_555(GetBitContext *gb, AVFrame *frame,
 358                                 int line, int left, uint8_t lru[3][8])
 359 {
 360     return dx2_decode_slice_5x5(gb, frame, line, left, lru, 0);
 361 }
 362
 363 static int dx2_decode_slice_565(GetBitContext *gb, AVFrame *frame,
 364                                 int line, int left, uint8_t lru[3][8])
 365 {
 366     return dx2_decode_slice_5x5(gb, frame, line, left, lru, 1);
 367 }
 368
 369 static int dxtory_decode_v2_565(AVCodecContext *avctx, AVFrame *pic,
 370                                 const uint8_t *src, int src_size, int is_565)
 371 {
 372     enum AVPixelFormat fmt = AV_PIX_FMT_RGB24;
 373     if (is_565)
 374         return dxtory_decode_v2(avctx, pic, src, src_size,
 375                                 dx2_decode_slice_565,
 376                                 setup_lru_565,
 377                                 fmt);
 378     else
 379         return dxtory_decode_v2(avctx, pic, src, src_size,
 380                                 dx2_decode_slice_555,
 381                                 setup_lru_555,
 382                                 fmt);
 383 }
 384
 385 static int dx2_decode_slice_rgb(GetBitContext *gb, AVFrame *frame,
 386                                 int line, int left, uint8_t lru[3][8])
 387 {
 388     int x, y;
 389     int width    = frame->width;
 390     int stride   = frame->linesize[0];
 391     uint8_t *dst = frame->data[0] + stride * line;
 392
 393     for (y = 0; y < left && get_bits_left(gb) > 16; y++) {
 394         for (x = 0; x < width; x++) {
 395             dst[x * 3 + 0] = decode_sym(gb, lru[0]);
 396             dst[x * 3 + 1] = decode_sym(gb, lru[1]);
 397             dst[x * 3 + 2] = decode_sym(gb, lru[2]);
 398         }
 399
 400         dst += stride;
 401     }
 402
 403     return y;
 404 }
 405
 406 static void default_setup_lru(uint8_t lru[3][8])
 407 {
 408     int i;
 409
 410     for (i = 0; i < 3; i++)
 411         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
 412 }
 413
 414 static int dxtory_decode_v2_rgb(AVCodecContext *avctx, AVFrame *pic,
 415                                 const uint8_t *src, int src_size)
 416 {
 417     return dxtory_decode_v2(avctx, pic, src, src_size,
 418                             dx2_decode_slice_rgb,
 419                             default_setup_lru,
 420                             AV_PIX_FMT_BGR24);
 421 }
 422
 423 static int dx2_decode_slice_410(GetBitContext *gb, AVFrame *frame,
 424                                 int line, int left,
 425                                 uint8_t lru[3][8])
 426 {
 427     int x, y, i, j;
 428     int width   = frame->width;
 429
 430     int ystride = frame->linesize[0];
 431     int ustride = frame->linesize[1];
 432     int vstride = frame->linesize[2];
 433
 434     uint8_t *Y  = frame->data[0] + ystride * line;
 435     uint8_t *U  = frame->data[1] + (ustride >> 2) * line;
 436     uint8_t *V  = frame->data[2] + (vstride >> 2) * line;
 437
 438     for (y = 0; y < left - 3 && get_bits_left(gb) > 16; y += 4) {
 439         for (x = 0; x < width; x += 4) {
 440             for (j = 0; j < 4; j++)
 441                 for (i = 0; i < 4; i++)
 442                     Y[x + i + j * ystride] = decode_sym(gb, lru[0]);
 443             U[x >> 2] = decode_sym(gb, lru[1]) ^ 0x80;
 444             V[x >> 2] = decode_sym(gb, lru[2]) ^ 0x80;
 445         }
 446
 447         Y += ystride << 2;
 448         U += ustride;
 449         V += vstride;
 450     }
 451
 452     return y;
 453 }
 454
 455
 456 static int dxtory_decode_v2_410(AVCodecContext *avctx, AVFrame *pic,
 457                                 const uint8_t *src, int src_size)
 458 {
 459     return dxtory_decode_v2(avctx, pic, src, src_size,
 460                             dx2_decode_slice_410,
 461                             default_setup_lru,
 462                             AV_PIX_FMT_YUV410P);
 463 }
 464
 465 static int dx2_decode_slice_420(GetBitContext *gb, AVFrame *frame,
 466                                 int line, int left,
 467                                 uint8_t lru[3][8])
 468 {
 469     int x, y;
 470
 471     int width    = frame->width;
 472
 473     int ystride = frame->linesize[0];
 474     int ustride = frame->linesize[1];
 475     int vstride = frame->linesize[2];
 476
 477     uint8_t *Y  = frame->data[0] + ystride * line;
 478     uint8_t *U  = frame->data[1] + (ustride >> 1) * line;
 479     uint8_t *V  = frame->data[2] + (vstride >> 1) * line;
 480
 481
 482     for (y = 0; y < left - 1 && get_bits_left(gb) > 16; y += 2) {
 483         for (x = 0; x < width; x += 2) {
 484             Y[x + 0 + 0 * ystride] = decode_sym(gb, lru[0]);
 485             Y[x + 1 + 0 * ystride] = decode_sym(gb, lru[0]);
 486             Y[x + 0 + 1 * ystride] = decode_sym(gb, lru[0]);
 487             Y[x + 1 + 1 * ystride] = decode_sym(gb, lru[0]);
 488             U[x >> 1] = decode_sym(gb, lru[1]) ^ 0x80;
 489             V[x >> 1] = decode_sym(gb, lru[2]) ^ 0x80;
 490         }
 491
 492         Y += ystride << 1;
 493         U += ustride;
 494         V += vstride;
 495     }
 496
 497     return y;
 498 }
 499
 500 static int dxtory_decode_v2_420(AVCodecContext *avctx, AVFrame *pic,
 501                                 const uint8_t *src, int src_size)
 502 {
 503     return dxtory_decode_v2(avctx, pic, src, src_size,
 504                             dx2_decode_slice_420,
 505                             default_setup_lru,
 506                             AV_PIX_FMT_YUV420P);
 507 }
 508
 509 static int dx2_decode_slice_444(GetBitContext *gb, AVFrame *frame,
 510                                 int line, int left,
 511                                 uint8_t lru[3][8])
 512 {
 513     int x, y;
 514
 515     int width   = frame->width;
 516
 517     int ystride = frame->linesize[0];
 518     int ustride = frame->linesize[1];
 519     int vstride = frame->linesize[2];
 520
 521     uint8_t *Y  = frame->data[0] + ystride * line;
 522     uint8_t *U  = frame->data[1] + ustride * line;
 523     uint8_t *V  = frame->data[2] + vstride * line;
 524
 525     for (y = 0; y < left && get_bits_left(gb) > 16; y++) {
 526         for (x = 0; x < width; x++) {
 527             Y[x] = decode_sym(gb, lru[0]);
 528             U[x] = decode_sym(gb, lru[1]) ^ 0x80;
 529             V[x] = decode_sym(gb, lru[2]) ^ 0x80;
 530         }
 531
 532         Y += ystride;
 533         U += ustride;
 534         V += vstride;
 535     }
 536
 537     return y;
 538 }
 539
 540 static int dxtory_decode_v2_444(AVCodecContext *avctx, AVFrame *pic,
 541                                 const uint8_t *src, int src_size)
 542 {
 543     return dxtory_decode_v2(avctx, pic, src, src_size,
 544                             dx2_decode_slice_444,
 545                             default_setup_lru,
 546                             AV_PIX_FMT_YUV444P);
 547 }
 548
 549 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 550                         AVPacket *avpkt)
 551 {
 552     AVFrame *pic = data;
 553     const uint8_t *src = avpkt->data;
 554     int ret;
 555
 556     if (avpkt->size < 16) {
 557         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
 558         return AVERROR_INVALIDDATA;
 559     }
 560
 561     switch (AV_RB32(src)) {
 562     case 0x01000001:
 563         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 564                                    AV_PIX_FMT_BGR24, 3);
 565         break;
 566     case 0x01000009:
 567         ret = dxtory_decode_v2_rgb(avctx, pic, src + 16, avpkt->size - 16);
 568         break;
 569     case 0x02000001:
 570         ret = dxtory_decode_v1_420(avctx, pic, src + 16, avpkt->size - 16);
 571         break;
 572     case 0x02000009:
 573         ret = dxtory_decode_v2_420(avctx, pic, src + 16, avpkt->size - 16);
 574         break;
 575     case 0x03000001:
 576         ret = dxtory_decode_v1_410(avctx, pic, src + 16, avpkt->size - 16);
 577         break;
 578     case 0x03000009:
 579         ret = dxtory_decode_v2_410(avctx, pic, src + 16, avpkt->size - 16);
 580         break;
 581     case 0x04000001:
 582         ret = dxtory_decode_v1_444(avctx, pic, src + 16, avpkt->size - 16);
 583         break;
 584     case 0x04000009:
 585         ret = dxtory_decode_v2_444(avctx, pic, src + 16, avpkt->size - 16);
 586         break;
 587     case 0x17000001:
 588         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 589                                    AV_PIX_FMT_RGB565LE, 2);
 590         break;
 591     case 0x17000009:
 592         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 1);
 593         break;
 594     case 0x18000001:
 595     case 0x19000001:
 596         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 597                                    AV_PIX_FMT_RGB555LE, 2);
 598         break;
 599     case 0x18000009:
 600     case 0x19000009:
 601         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 0);
 602         break;
 603     default:
 604         avpriv_request_sample(avctx, "Frame header %"PRIX32, AV_RB32(src));
 605         return AVERROR_PATCHWELCOME;
 606     }
 607
 608     if (ret)
 609         return ret;
 610
 611     pic->pict_type = AV_PICTURE_TYPE_I;
 612     pic->key_frame = 1;
 613     *got_frame = 1;
 614
 615     return avpkt->size;
 616 }
 617
 618 AVCodec ff_dxtory_decoder = {
 619     .name           = "dxtory",
 620     .long_name      = NULL_IF_CONFIG_SMALL("Dxtory"),
 621     .type           = AVMEDIA_TYPE_VIDEO,
 622     .id             = AV_CODEC_ID_DXTORY,
 623     .decode         = decode_frame,
 624     .capabilities   = AV_CODEC_CAP_DR1,
 625 };