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 inline uint8_t decode_sym_565(GetBitContext *gb, uint8_t lru[8],
 196                                      int bits)
 197 {
 198     uint8_t c, val;
 199
 200     c = get_unary(gb, 0, bits);
 201     if (!c) {
 202         val = get_bits(gb, bits);
 203         memmove(lru + 1, lru, sizeof(*lru) * (6 - 1));
 204     } else {
 205         val = lru[c - 1];
 206         memmove(lru + 1, lru, sizeof(*lru) * (c - 1));
 207     }
 208     lru[0] = val;
 209
 210     return val;
 211 }
 212
 213 static int dx2_decode_slice_565(GetBitContext *gb, int width, int height,
 214                                 uint8_t *dst, int stride, int is_565)
 215 {
 216     int x, y;
 217     int r, g, b;
 218     uint8_t lru[3][8];
 219
 220     memcpy(lru[0], def_lru_555, 8 * sizeof(*def_lru));
 221     memcpy(lru[1], is_565 ? def_lru_565 : def_lru_555, 8 * sizeof(*def_lru));
 222     memcpy(lru[2], def_lru_555, 8 * sizeof(*def_lru));
 223
 224     for (y = 0; y < height; y++) {
 225         for (x = 0; x < width; x++) {
 226             b = decode_sym_565(gb, lru[0], 5);
 227             g = decode_sym_565(gb, lru[1], is_565 ? 6 : 5);
 228             r = decode_sym_565(gb, lru[2], 5);
 229             dst[x * 3 + 0] = (r << 3) | (r >> 2);
 230             dst[x * 3 + 1] = is_565 ? (g << 2) | (g >> 4) : (g << 3) | (g >> 2);
 231             dst[x * 3 + 2] = (b << 3) | (b >> 2);
 232         }
 233
 234         dst += stride;
 235     }
 236
 237     return 0;
 238 }
 239
 240 static int dxtory_decode_v2_565(AVCodecContext *avctx, AVFrame *pic,
 241                                 const uint8_t *src, int src_size, int is_565)
 242 {
 243     GetByteContext gb;
 244     GetBitContext  gb2;
 245     int nslices, slice, slice_height;
 246     uint32_t off, slice_size;
 247     uint8_t *dst;
 248     int ret;
 249
 250     bytestream2_init(&gb, src, src_size);
 251     nslices = bytestream2_get_le16(&gb);
 252     off = FFALIGN(nslices * 4 + 2, 16);
 253     if (src_size < off) {
 254         av_log(avctx, AV_LOG_ERROR, "no slice data\n");
 255         return AVERROR_INVALIDDATA;
 256     }
 257
 258     if (!nslices || avctx->height % nslices) {
 259         avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,
 260                               avctx->width, avctx->height);
 261         return AVERROR_PATCHWELCOME;
 262     }
 263
 264     slice_height = avctx->height / nslices;
 265     avctx->pix_fmt = AV_PIX_FMT_RGB24;
 266     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 267         return ret;
 268
 269     dst = pic->data[0];
 270     for (slice = 0; slice < nslices; slice++) {
 271         slice_size = bytestream2_get_le32(&gb);
 272         if (slice_size > src_size - off) {
 273             av_log(avctx, AV_LOG_ERROR,
 274                    "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
 275                    slice_size, src_size - off);
 276             return AVERROR_INVALIDDATA;
 277         }
 278         if (slice_size <= 16) {
 279             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
 280             return AVERROR_INVALIDDATA;
 281         }
 282
 283         if (AV_RL32(src + off) != slice_size - 16) {
 284             av_log(avctx, AV_LOG_ERROR,
 285                    "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
 286                    AV_RL32(src + off), slice_size - 16);
 287         }
 288         init_get_bits(&gb2, src + off + 16, (slice_size - 16) * 8);
 289         dx2_decode_slice_565(&gb2, avctx->width, slice_height, dst,
 290                              pic->linesize[0], is_565);
 291
 292         dst += pic->linesize[0] * slice_height;
 293         off += slice_size;
 294     }
 295
 296     return 0;
 297 }
 298
 299 static int dx2_decode_slice_rgb(GetBitContext *gb, int width, int height,
 300                                 uint8_t *dst, int stride)
 301 {
 302     int x, y, i;
 303     uint8_t lru[3][8];
 304
 305     for (i = 0; i < 3; i++)
 306         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
 307
 308     for (y = 0; y < height; y++) {
 309         for (x = 0; x < width; x++) {
 310             dst[x * 3 + 0] = decode_sym(gb, lru[0]);
 311             dst[x * 3 + 1] = decode_sym(gb, lru[1]);
 312             dst[x * 3 + 2] = decode_sym(gb, lru[2]);
 313         }
 314
 315         dst += stride;
 316     }
 317
 318     return 0;
 319 }
 320
 321 static int dxtory_decode_v2_rgb(AVCodecContext *avctx, AVFrame *pic,
 322                                 const uint8_t *src, int src_size)
 323 {
 324     GetByteContext gb;
 325     GetBitContext  gb2;
 326     int nslices, slice, slice_height;
 327     uint32_t off, slice_size;
 328     uint8_t *dst;
 329     int ret;
 330
 331     bytestream2_init(&gb, src, src_size);
 332     nslices = bytestream2_get_le16(&gb);
 333     off = FFALIGN(nslices * 4 + 2, 16);
 334     if (src_size < off) {
 335         av_log(avctx, AV_LOG_ERROR, "no slice data\n");
 336         return AVERROR_INVALIDDATA;
 337     }
 338
 339     if (!nslices || avctx->height % nslices) {
 340         avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,
 341                               avctx->width, avctx->height);
 342         return AVERROR_PATCHWELCOME;
 343     }
 344
 345     slice_height = avctx->height / nslices;
 346     avctx->pix_fmt = AV_PIX_FMT_BGR24;
 347     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 348         return ret;
 349
 350     dst = pic->data[0];
 351     for (slice = 0; slice < nslices; slice++) {
 352         slice_size = bytestream2_get_le32(&gb);
 353         if (slice_size > src_size - off) {
 354             av_log(avctx, AV_LOG_ERROR,
 355                    "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
 356                    slice_size, src_size - off);
 357             return AVERROR_INVALIDDATA;
 358         }
 359         if (slice_size <= 16) {
 360             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n",
 361                    slice_size);
 362             return AVERROR_INVALIDDATA;
 363         }
 364
 365         if (AV_RL32(src + off) != slice_size - 16) {
 366             av_log(avctx, AV_LOG_ERROR,
 367                    "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
 368                    AV_RL32(src + off), slice_size - 16);
 369         }
 370         init_get_bits(&gb2, src + off + 16, (slice_size - 16) * 8);
 371         dx2_decode_slice_rgb(&gb2, avctx->width, slice_height, dst,
 372                              pic->linesize[0]);
 373
 374         dst += pic->linesize[0] * slice_height;
 375         off += slice_size;
 376     }
 377
 378     return 0;
 379 }
 380
 381 static int dx2_decode_slice_410(GetBitContext *gb, int width, int height,
 382                                 uint8_t *Y, uint8_t *U, uint8_t *V,
 383                                 int ystride, int ustride, int vstride)
 384 {
 385     int x, y, i, j;
 386     uint8_t lru[3][8];
 387
 388     for (i = 0; i < 3; i++)
 389         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
 390
 391     for (y = 0; y < height; y += 4) {
 392         for (x = 0; x < width; x += 4) {
 393             for (j = 0; j < 4; j++)
 394                 for (i = 0; i < 4; i++)
 395                     Y[x + i + j * ystride] = decode_sym(gb, lru[0]);
 396             U[x >> 2] = decode_sym(gb, lru[1]) ^ 0x80;
 397             V[x >> 2] = decode_sym(gb, lru[2]) ^ 0x80;
 398         }
 399
 400         Y += ystride << 2;
 401         U += ustride;
 402         V += vstride;
 403     }
 404
 405     return 0;
 406 }
 407
 408 static int dxtory_decode_v2_410(AVCodecContext *avctx, AVFrame *pic,
 409                                 const uint8_t *src, int src_size)
 410 {
 411     GetByteContext gb;
 412     GetBitContext  gb2;
 413     int nslices, slice, slice_height, ref_slice_height;
 414     int cur_y, next_y;
 415     uint32_t off, slice_size;
 416     uint8_t *Y, *U, *V;
 417     int ret;
 418
 419     bytestream2_init(&gb, src, src_size);
 420     nslices = bytestream2_get_le16(&gb);
 421     off = FFALIGN(nslices * 4 + 2, 16);
 422     if (src_size < off) {
 423         av_log(avctx, AV_LOG_ERROR, "no slice data\n");
 424         return AVERROR_INVALIDDATA;
 425     }
 426
 427     if (!nslices || avctx->height % nslices) {
 428         avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,
 429                               avctx->width, avctx->height);
 430         return AVERROR_PATCHWELCOME;
 431     }
 432
 433     ref_slice_height = avctx->height / nslices;
 434     if ((avctx->width & 3) || (avctx->height & 3)) {
 435         avpriv_request_sample(avctx, "Frame dimensions %dx%d",
 436                               avctx->width, avctx->height);
 437     }
 438
 439     avctx->pix_fmt = AV_PIX_FMT_YUV410P;
 440     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 441         return ret;
 442
 443     Y = pic->data[0];
 444     U = pic->data[1];
 445     V = pic->data[2];
 446
 447     cur_y  = 0;
 448     next_y = ref_slice_height;
 449     for (slice = 0; slice < nslices; slice++) {
 450         slice_size   = bytestream2_get_le32(&gb);
 451         slice_height = (next_y & ~3) - (cur_y & ~3);
 452         if (slice_size > src_size - off) {
 453             av_log(avctx, AV_LOG_ERROR,
 454                    "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
 455                    slice_size, src_size - off);
 456             return AVERROR_INVALIDDATA;
 457         }
 458         if (slice_size <= 16) {
 459             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
 460             return AVERROR_INVALIDDATA;
 461         }
 462
 463         if (AV_RL32(src + off) != slice_size - 16) {
 464             av_log(avctx, AV_LOG_ERROR,
 465                    "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
 466                    AV_RL32(src + off), slice_size - 16);
 467         }
 468         init_get_bits(&gb2, src + off + 16, (slice_size - 16) * 8);
 469         dx2_decode_slice_410(&gb2, avctx->width, slice_height, Y, U, V,
 470                              pic->linesize[0], pic->linesize[1],
 471                              pic->linesize[2]);
 472
 473         Y += pic->linesize[0] *  slice_height;
 474         U += pic->linesize[1] * (slice_height >> 2);
 475         V += pic->linesize[2] * (slice_height >> 2);
 476         off += slice_size;
 477         cur_y   = next_y;
 478         next_y += ref_slice_height;
 479     }
 480
 481     return 0;
 482 }
 483
 484 static int dx2_decode_slice_420(GetBitContext *gb, int width, int height,
 485                                 uint8_t *Y, uint8_t *U, uint8_t *V,
 486                                 int ystride, int ustride, int vstride)
 487 {
 488     int x, y, i;
 489     uint8_t lru[3][8];
 490
 491     for (i = 0; i < 3; i++)
 492         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
 493
 494     for (y = 0; y < height; y+=2) {
 495         for (x = 0; x < width; x += 2) {
 496             Y[x + 0 + 0 * ystride] = decode_sym(gb, lru[0]);
 497             Y[x + 1 + 0 * ystride] = decode_sym(gb, lru[0]);
 498             Y[x + 0 + 1 * ystride] = decode_sym(gb, lru[0]);
 499             Y[x + 1 + 1 * ystride] = decode_sym(gb, lru[0]);
 500             U[x >> 1] = decode_sym(gb, lru[1]) ^ 0x80;
 501             V[x >> 1] = decode_sym(gb, lru[2]) ^ 0x80;
 502         }
 503
 504         Y += ystride << 1;
 505         U += ustride;
 506         V += vstride;
 507     }
 508
 509     return 0;
 510 }
 511
 512 static int dxtory_decode_v2_420(AVCodecContext *avctx, AVFrame *pic,
 513                                 const uint8_t *src, int src_size)
 514 {
 515     GetByteContext gb;
 516     GetBitContext  gb2;
 517     int nslices, slice, slice_height, ref_slice_height;
 518     int cur_y, next_y;
 519     uint32_t off, slice_size;
 520     uint8_t *Y, *U, *V;
 521     int ret;
 522
 523     bytestream2_init(&gb, src, src_size);
 524     nslices = bytestream2_get_le16(&gb);
 525     off = FFALIGN(nslices * 4 + 2, 16);
 526     if (src_size < off) {
 527         av_log(avctx, AV_LOG_ERROR, "no slice data\n");
 528         return AVERROR_INVALIDDATA;
 529     }
 530
 531     if (!nslices || avctx->height % nslices) {
 532         avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,
 533                               avctx->width, avctx->height);
 534         return AVERROR_PATCHWELCOME;
 535     }
 536
 537     ref_slice_height = avctx->height / nslices;
 538     if ((avctx->width & 1) || (avctx->height & 1)) {
 539         avpriv_request_sample(avctx, "Frame dimensions %dx%d",
 540                               avctx->width, avctx->height);
 541     }
 542
 543     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 544     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 545         return ret;
 546
 547     Y = pic->data[0];
 548     U = pic->data[1];
 549     V = pic->data[2];
 550
 551     cur_y  = 0;
 552     next_y = ref_slice_height;
 553     for (slice = 0; slice < nslices; slice++) {
 554         slice_size   = bytestream2_get_le32(&gb);
 555         slice_height = (next_y & ~1) - (cur_y & ~1);
 556         if (slice_size > src_size - off) {
 557             av_log(avctx, AV_LOG_ERROR,
 558                    "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
 559                    slice_size, src_size - off);
 560             return AVERROR_INVALIDDATA;
 561         }
 562         if (slice_size <= 16) {
 563             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
 564             return AVERROR_INVALIDDATA;
 565         }
 566
 567         if (AV_RL32(src + off) != slice_size - 16) {
 568             av_log(avctx, AV_LOG_ERROR,
 569                    "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
 570                    AV_RL32(src + off), slice_size - 16);
 571         }
 572         init_get_bits(&gb2, src + off + 16, (slice_size - 16) * 8);
 573         dx2_decode_slice_420(&gb2, avctx->width, slice_height, Y, U, V,
 574                              pic->linesize[0], pic->linesize[1],
 575                              pic->linesize[2]);
 576
 577         Y += pic->linesize[0] *  slice_height;
 578         U += pic->linesize[1] * (slice_height >> 1);
 579         V += pic->linesize[2] * (slice_height >> 1);
 580         off += slice_size;
 581         cur_y   = next_y;
 582         next_y += ref_slice_height;
 583     }
 584
 585     return 0;
 586 }
 587
 588 static int dx2_decode_slice_444(GetBitContext *gb, int width, int height,
 589                                 uint8_t *Y, uint8_t *U, uint8_t *V,
 590                                 int ystride, int ustride, int vstride)
 591 {
 592     int x, y, i;
 593     uint8_t lru[3][8];
 594
 595     for (i = 0; i < 3; i++)
 596         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
 597
 598     for (y = 0; y < height; y++) {
 599         for (x = 0; x < width; x++) {
 600             Y[x] = decode_sym(gb, lru[0]);
 601             U[x] = decode_sym(gb, lru[1]) ^ 0x80;
 602             V[x] = decode_sym(gb, lru[2]) ^ 0x80;
 603         }
 604
 605         Y += ystride;
 606         U += ustride;
 607         V += vstride;
 608     }
 609
 610     return 0;
 611 }
 612
 613 static int dxtory_decode_v2_444(AVCodecContext *avctx, AVFrame *pic,
 614                                 const uint8_t *src, int src_size)
 615 {
 616     GetByteContext gb;
 617     GetBitContext  gb2;
 618     int nslices, slice, slice_height;
 619     uint32_t off, slice_size;
 620     uint8_t *Y, *U, *V;
 621     int ret;
 622
 623     bytestream2_init(&gb, src, src_size);
 624     nslices = bytestream2_get_le16(&gb);
 625     off = FFALIGN(nslices * 4 + 2, 16);
 626     if (src_size < off) {
 627         av_log(avctx, AV_LOG_ERROR, "no slice data\n");
 628         return AVERROR_INVALIDDATA;
 629     }
 630
 631     if (!nslices || avctx->height % nslices) {
 632         avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,
 633                               avctx->width, avctx->height);
 634         return AVERROR_PATCHWELCOME;
 635     }
 636
 637     slice_height = avctx->height / nslices;
 638
 639     avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 640     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 641         return ret;
 642
 643     Y = pic->data[0];
 644     U = pic->data[1];
 645     V = pic->data[2];
 646
 647     for (slice = 0; slice < nslices; slice++) {
 648         slice_size = bytestream2_get_le32(&gb);
 649         if (slice_size > src_size - off) {
 650             av_log(avctx, AV_LOG_ERROR,
 651                    "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
 652                    slice_size, src_size - off);
 653             return AVERROR_INVALIDDATA;
 654         }
 655         if (slice_size <= 16) {
 656             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
 657             return AVERROR_INVALIDDATA;
 658         }
 659
 660         if (AV_RL32(src + off) != slice_size - 16) {
 661             av_log(avctx, AV_LOG_ERROR,
 662                    "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
 663                    AV_RL32(src + off), slice_size - 16);
 664         }
 665         init_get_bits(&gb2, src + off + 16, (slice_size - 16) * 8);
 666         dx2_decode_slice_444(&gb2, avctx->width, slice_height, Y, U, V,
 667                              pic->linesize[0], pic->linesize[1],
 668                              pic->linesize[2]);
 669
 670         Y += pic->linesize[0] * slice_height;
 671         U += pic->linesize[1] * slice_height;
 672         V += pic->linesize[2] * slice_height;
 673         off += slice_size;
 674     }
 675
 676     return 0;
 677 }
 678
 679 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 680                         AVPacket *avpkt)
 681 {
 682     AVFrame *pic = data;
 683     const uint8_t *src = avpkt->data;
 684     int ret;
 685
 686     if (avpkt->size < 16) {
 687         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
 688         return AVERROR_INVALIDDATA;
 689     }
 690
 691     switch (AV_RB32(src)) {
 692     case 0x01000001:
 693         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 694                                    AV_PIX_FMT_BGR24, 3);
 695         break;
 696     case 0x01000009:
 697         ret = dxtory_decode_v2_rgb(avctx, pic, src + 16, avpkt->size - 16);
 698         break;
 699     case 0x02000001:
 700         ret = dxtory_decode_v1_420(avctx, pic, src + 16, avpkt->size - 16);
 701         break;
 702     case 0x02000009:
 703         ret = dxtory_decode_v2_420(avctx, pic, src + 16, avpkt->size - 16);
 704         break;
 705     case 0x03000001:
 706         ret = dxtory_decode_v1_410(avctx, pic, src + 16, avpkt->size - 16);
 707         break;
 708     case 0x03000009:
 709         ret = dxtory_decode_v2_410(avctx, pic, src + 16, avpkt->size - 16);
 710         break;
 711     case 0x04000001:
 712         ret = dxtory_decode_v1_444(avctx, pic, src + 16, avpkt->size - 16);
 713         break;
 714     case 0x04000009:
 715         ret = dxtory_decode_v2_444(avctx, pic, src + 16, avpkt->size - 16);
 716         break;
 717     case 0x17000001:
 718         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 719                                    AV_PIX_FMT_RGB565LE, 2);
 720         break;
 721     case 0x17000009:
 722         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 1);
 723         break;
 724     case 0x18000001:
 725     case 0x19000001:
 726         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 727                                    AV_PIX_FMT_RGB555LE, 2);
 728         break;
 729     case 0x18000009:
 730     case 0x19000009:
 731         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 0);
 732         break;
 733     default:
 734         avpriv_request_sample(avctx, "Frame header %"PRIX32, AV_RB32(src));
 735         return AVERROR_PATCHWELCOME;
 736     }
 737
 738     if (ret)
 739         return ret;
 740
 741     pic->pict_type = AV_PICTURE_TYPE_I;
 742     pic->key_frame = 1;
 743     *got_frame = 1;
 744
 745     return avpkt->size;
 746 }
 747
 748 AVCodec ff_dxtory_decoder = {
 749     .name           = "dxtory",
 750     .long_name      = NULL_IF_CONFIG_SMALL("Dxtory"),
 751     .type           = AVMEDIA_TYPE_VIDEO,
 752     .id             = AV_CODEC_ID_DXTORY,
 753     .decode         = decode_frame,
 754     .capabilities   = CODEC_CAP_DR1,
 755 };