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 FFmpeg.
   7  *
   8  * FFmpeg 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  * FFmpeg 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 FFmpeg; 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 * (int64_t)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 * 9LL / 8) {
  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_COPY32U(Y1 + w, src);
  86             AV_COPY32U(Y2 + w, src + 4);
  87             AV_COPY32U(Y3 + w, src + 8);
  88             AV_COPY32U(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 * 3LL / 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 * 3LL) {
 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 static const uint8_t def_lru[8] = { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xFF };
 175 static const uint8_t def_lru_555[8] = { 0x00, 0x08, 0x10, 0x18, 0x1F };
 176 static 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         if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)
 289             return ret;
 290         dx2_decode_slice_565(&gb2, avctx->width, slice_height, dst,
 291                              pic->linesize[0], is_565);
 292
 293         dst += pic->linesize[0] * slice_height;
 294         off += slice_size;
 295     }
 296
 297     return 0;
 298 }
 299
 300 static int dx2_decode_slice_rgb(GetBitContext *gb, int width, int height,
 301                                 uint8_t *dst, int stride)
 302 {
 303     int x, y, i;
 304     uint8_t lru[3][8];
 305
 306     for (i = 0; i < 3; i++)
 307         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
 308
 309     for (y = 0; y < height; y++) {
 310         for (x = 0; x < width; x++) {
 311             dst[x * 3 + 0] = decode_sym(gb, lru[0]);
 312             dst[x * 3 + 1] = decode_sym(gb, lru[1]);
 313             dst[x * 3 + 2] = decode_sym(gb, lru[2]);
 314         }
 315
 316         dst += stride;
 317     }
 318
 319     return 0;
 320 }
 321
 322 static int dxtory_decode_v2_rgb(AVCodecContext *avctx, AVFrame *pic,
 323                                 const uint8_t *src, int src_size)
 324 {
 325     GetByteContext gb;
 326     GetBitContext  gb2;
 327     int nslices, slice, slice_height;
 328     uint32_t off, slice_size;
 329     uint8_t *dst;
 330     int ret;
 331
 332     bytestream2_init(&gb, src, src_size);
 333     nslices = bytestream2_get_le16(&gb);
 334     off = FFALIGN(nslices * 4 + 2, 16);
 335     if (src_size < off) {
 336         av_log(avctx, AV_LOG_ERROR, "no slice data\n");
 337         return AVERROR_INVALIDDATA;
 338     }
 339
 340     if (!nslices || avctx->height % nslices) {
 341         avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,
 342                               avctx->width, avctx->height);
 343         return AVERROR_PATCHWELCOME;
 344     }
 345
 346     slice_height = avctx->height / nslices;
 347     avctx->pix_fmt = AV_PIX_FMT_BGR24;
 348     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 349         return ret;
 350
 351     dst = pic->data[0];
 352     for (slice = 0; slice < nslices; slice++) {
 353         slice_size = bytestream2_get_le32(&gb);
 354         if (slice_size > src_size - off) {
 355             av_log(avctx, AV_LOG_ERROR,
 356                    "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
 357                    slice_size, src_size - off);
 358             return AVERROR_INVALIDDATA;
 359         }
 360         if (slice_size <= 16) {
 361             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n",
 362                    slice_size);
 363             return AVERROR_INVALIDDATA;
 364         }
 365
 366         if (AV_RL32(src + off) != slice_size - 16) {
 367             av_log(avctx, AV_LOG_ERROR,
 368                    "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
 369                    AV_RL32(src + off), slice_size - 16);
 370         }
 371         if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)
 372             return ret;
 373         dx2_decode_slice_rgb(&gb2, avctx->width, slice_height, dst,
 374                              pic->linesize[0]);
 375
 376         dst += pic->linesize[0] * slice_height;
 377         off += slice_size;
 378     }
 379
 380     return 0;
 381 }
 382
 383 static int dx2_decode_slice_410(GetBitContext *gb, int width, int height,
 384                                 uint8_t *Y, uint8_t *U, uint8_t *V,
 385                                 int ystride, int ustride, int vstride)
 386 {
 387     int x, y, i, j;
 388     uint8_t lru[3][8];
 389
 390     for (i = 0; i < 3; i++)
 391         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
 392
 393     for (y = 0; y < height; y += 4) {
 394         for (x = 0; x < width; x += 4) {
 395             for (j = 0; j < 4; j++)
 396                 for (i = 0; i < 4; i++)
 397                     Y[x + i + j * ystride] = decode_sym(gb, lru[0]);
 398             U[x >> 2] = decode_sym(gb, lru[1]) ^ 0x80;
 399             V[x >> 2] = decode_sym(gb, lru[2]) ^ 0x80;
 400         }
 401
 402         Y += ystride << 2;
 403         U += ustride;
 404         V += vstride;
 405     }
 406
 407     return 0;
 408 }
 409
 410 static int dxtory_decode_v2_410(AVCodecContext *avctx, AVFrame *pic,
 411                                 const uint8_t *src, int src_size)
 412 {
 413     GetByteContext gb;
 414     GetBitContext  gb2;
 415     int nslices, slice, slice_height;
 416     int cur_y, next_y;
 417     uint32_t off, slice_size;
 418     uint8_t *Y, *U, *V;
 419     int ret;
 420
 421     bytestream2_init(&gb, src, src_size);
 422     nslices = bytestream2_get_le16(&gb);
 423     off = FFALIGN(nslices * 4 + 2, 16);
 424     if (src_size < off) {
 425         av_log(avctx, AV_LOG_ERROR, "no slice data\n");
 426         return AVERROR_INVALIDDATA;
 427     }
 428
 429     if (!nslices) {
 430         avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,
 431                               avctx->width, avctx->height);
 432         return AVERROR_PATCHWELCOME;
 433     }
 434
 435     if ((avctx->width & 3) || (avctx->height & 3)) {
 436         avpriv_request_sample(avctx, "Frame dimensions %dx%d",
 437                               avctx->width, avctx->height);
 438     }
 439
 440     avctx->pix_fmt = AV_PIX_FMT_YUV410P;
 441     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 442         return ret;
 443
 444     Y = pic->data[0];
 445     U = pic->data[1];
 446     V = pic->data[2];
 447
 448     cur_y  = 0;
 449     for (slice = 0; slice < nslices; slice++) {
 450         slice_size   = bytestream2_get_le32(&gb);
 451         next_y = ((slice + 1) * avctx->height) / nslices;
 452         slice_height = (next_y & ~3) - (cur_y & ~3);
 453         if (slice_size > src_size - off) {
 454             av_log(avctx, AV_LOG_ERROR,
 455                    "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
 456                    slice_size, src_size - off);
 457             return AVERROR_INVALIDDATA;
 458         }
 459         if (slice_size <= 16) {
 460             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
 461             return AVERROR_INVALIDDATA;
 462         }
 463
 464         if (AV_RL32(src + off) != slice_size - 16) {
 465             av_log(avctx, AV_LOG_ERROR,
 466                    "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
 467                    AV_RL32(src + off), slice_size - 16);
 468         }
 469         if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)
 470             return ret;
 471         dx2_decode_slice_410(&gb2, avctx->width, slice_height, Y, U, V,
 472                              pic->linesize[0], pic->linesize[1],
 473                              pic->linesize[2]);
 474
 475         Y += pic->linesize[0] *  slice_height;
 476         U += pic->linesize[1] * (slice_height >> 2);
 477         V += pic->linesize[2] * (slice_height >> 2);
 478         off += slice_size;
 479         cur_y   = next_y;
 480     }
 481
 482     return 0;
 483 }
 484
 485 static int dx2_decode_slice_420(GetBitContext *gb, int width, int height,
 486                                 uint8_t *Y, uint8_t *U, uint8_t *V,
 487                                 int ystride, int ustride, int vstride)
 488 {
 489     int x, y, i;
 490     uint8_t lru[3][8];
 491
 492     for (i = 0; i < 3; i++)
 493         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
 494
 495     for (y = 0; y < height; y+=2) {
 496         for (x = 0; x < width; x += 2) {
 497             Y[x + 0 + 0 * ystride] = decode_sym(gb, lru[0]);
 498             Y[x + 1 + 0 * ystride] = decode_sym(gb, lru[0]);
 499             Y[x + 0 + 1 * ystride] = decode_sym(gb, lru[0]);
 500             Y[x + 1 + 1 * ystride] = decode_sym(gb, lru[0]);
 501             U[x >> 1] = decode_sym(gb, lru[1]) ^ 0x80;
 502             V[x >> 1] = decode_sym(gb, lru[2]) ^ 0x80;
 503         }
 504
 505         Y += ystride << 1;
 506         U += ustride;
 507         V += vstride;
 508     }
 509
 510     return 0;
 511 }
 512
 513 static int dxtory_decode_v2_420(AVCodecContext *avctx, AVFrame *pic,
 514                                 const uint8_t *src, int src_size)
 515 {
 516     GetByteContext gb;
 517     GetBitContext  gb2;
 518     int nslices, slice, slice_height;
 519     int cur_y, next_y;
 520     uint32_t off, slice_size;
 521     uint8_t *Y, *U, *V;
 522     int ret;
 523
 524     bytestream2_init(&gb, src, src_size);
 525     nslices = bytestream2_get_le16(&gb);
 526     off = FFALIGN(nslices * 4 + 2, 16);
 527     if (src_size < off) {
 528         av_log(avctx, AV_LOG_ERROR, "no slice data\n");
 529         return AVERROR_INVALIDDATA;
 530     }
 531
 532     if (!nslices) {
 533         avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,
 534                               avctx->width, avctx->height);
 535         return AVERROR_PATCHWELCOME;
 536     }
 537
 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     for (slice = 0; slice < nslices; slice++) {
 553         slice_size   = bytestream2_get_le32(&gb);
 554         next_y = ((slice + 1) * avctx->height) / nslices;
 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         if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)
 573             return ret;
 574         dx2_decode_slice_420(&gb2, avctx->width, slice_height, Y, U, V,
 575                              pic->linesize[0], pic->linesize[1],
 576                              pic->linesize[2]);
 577
 578         Y += pic->linesize[0] *  slice_height;
 579         U += pic->linesize[1] * (slice_height >> 1);
 580         V += pic->linesize[2] * (slice_height >> 1);
 581         off += slice_size;
 582         cur_y   = next_y;
 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         if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)
 666             return ret;
 667         dx2_decode_slice_444(&gb2, avctx->width, slice_height, Y, U, V,
 668                              pic->linesize[0], pic->linesize[1],
 669                              pic->linesize[2]);
 670
 671         Y += pic->linesize[0] * slice_height;
 672         U += pic->linesize[1] * slice_height;
 673         V += pic->linesize[2] * slice_height;
 674         off += slice_size;
 675     }
 676
 677     return 0;
 678 }
 679
 680 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 681                         AVPacket *avpkt)
 682 {
 683     AVFrame *pic = data;
 684     const uint8_t *src = avpkt->data;
 685     int ret;
 686
 687     if (avpkt->size < 16) {
 688         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
 689         return AVERROR_INVALIDDATA;
 690     }
 691
 692     switch (AV_RB32(src)) {
 693     case 0x01000001:
 694         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 695                                    AV_PIX_FMT_BGR24, 3);
 696         break;
 697     case 0x01000009:
 698         ret = dxtory_decode_v2_rgb(avctx, pic, src + 16, avpkt->size - 16);
 699         break;
 700     case 0x02000001:
 701         ret = dxtory_decode_v1_420(avctx, pic, src + 16, avpkt->size - 16);
 702         break;
 703     case 0x02000009:
 704         ret = dxtory_decode_v2_420(avctx, pic, src + 16, avpkt->size - 16);
 705         break;
 706     case 0x03000001:
 707         ret = dxtory_decode_v1_410(avctx, pic, src + 16, avpkt->size - 16);
 708         break;
 709     case 0x03000009:
 710         ret = dxtory_decode_v2_410(avctx, pic, src + 16, avpkt->size - 16);
 711         break;
 712     case 0x04000001:
 713         ret = dxtory_decode_v1_444(avctx, pic, src + 16, avpkt->size - 16);
 714         break;
 715     case 0x04000009:
 716         ret = dxtory_decode_v2_444(avctx, pic, src + 16, avpkt->size - 16);
 717         break;
 718     case 0x17000001:
 719         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 720                                    AV_PIX_FMT_RGB565LE, 2);
 721         break;
 722     case 0x17000009:
 723         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 1);
 724         break;
 725     case 0x18000001:
 726     case 0x19000001:
 727         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 728                                    AV_PIX_FMT_RGB555LE, 2);
 729         break;
 730     case 0x18000009:
 731     case 0x19000009:
 732         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 0);
 733         break;
 734     default:
 735         avpriv_request_sample(avctx, "Frame header %"PRIX32, AV_RB32(src));
 736         return AVERROR_PATCHWELCOME;
 737     }
 738
 739     if (ret)
 740         return ret;
 741
 742     pic->pict_type = AV_PICTURE_TYPE_I;
 743     pic->key_frame = 1;
 744     *got_frame = 1;
 745
 746     return avpkt->size;
 747 }
 748
 749 AVCodec ff_dxtory_decoder = {
 750     .name           = "dxtory",
 751     .long_name      = NULL_IF_CONFIG_SMALL("Dxtory"),
 752     .type           = AVMEDIA_TYPE_VIDEO,
 753     .id             = AV_CODEC_ID_DXTORY,
 754     .decode         = decode_frame,
 755     .capabilities   = AV_CODEC_CAP_DR1,
 756 };