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 * 9L / 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 * 3L / 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 * 3L) {
 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         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;
 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) {
 428         avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,
 429                               avctx->width, avctx->height);
 430         return AVERROR_PATCHWELCOME;
 431     }
 432
 433     if ((avctx->width & 3) || (avctx->height & 3)) {
 434         avpriv_request_sample(avctx, "Frame dimensions %dx%d",
 435                               avctx->width, avctx->height);
 436     }
 437
 438     avctx->pix_fmt = AV_PIX_FMT_YUV410P;
 439     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 440         return ret;
 441
 442     Y = pic->data[0];
 443     U = pic->data[1];
 444     V = pic->data[2];
 445
 446     cur_y  = 0;
 447     for (slice = 0; slice < nslices; slice++) {
 448         slice_size   = bytestream2_get_le32(&gb);
 449         next_y = ((slice + 1) * avctx->height) / nslices;
 450         slice_height = (next_y & ~3) - (cur_y & ~3);
 451         if (slice_size > src_size - off) {
 452             av_log(avctx, AV_LOG_ERROR,
 453                    "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
 454                    slice_size, src_size - off);
 455             return AVERROR_INVALIDDATA;
 456         }
 457         if (slice_size <= 16) {
 458             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
 459             return AVERROR_INVALIDDATA;
 460         }
 461
 462         if (AV_RL32(src + off) != slice_size - 16) {
 463             av_log(avctx, AV_LOG_ERROR,
 464                    "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
 465                    AV_RL32(src + off), slice_size - 16);
 466         }
 467         init_get_bits(&gb2, src + off + 16, (slice_size - 16) * 8);
 468         dx2_decode_slice_410(&gb2, avctx->width, slice_height, Y, U, V,
 469                              pic->linesize[0], pic->linesize[1],
 470                              pic->linesize[2]);
 471
 472         Y += pic->linesize[0] *  slice_height;
 473         U += pic->linesize[1] * (slice_height >> 2);
 474         V += pic->linesize[2] * (slice_height >> 2);
 475         off += slice_size;
 476         cur_y   = next_y;
 477     }
 478
 479     return 0;
 480 }
 481
 482 static int dx2_decode_slice_420(GetBitContext *gb, int width, int height,
 483                                 uint8_t *Y, uint8_t *U, uint8_t *V,
 484                                 int ystride, int ustride, int vstride)
 485 {
 486     int x, y, i;
 487     uint8_t lru[3][8];
 488
 489     for (i = 0; i < 3; i++)
 490         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
 491
 492     for (y = 0; y < height; y+=2) {
 493         for (x = 0; x < width; x += 2) {
 494             Y[x + 0 + 0 * ystride] = decode_sym(gb, lru[0]);
 495             Y[x + 1 + 0 * ystride] = decode_sym(gb, lru[0]);
 496             Y[x + 0 + 1 * ystride] = decode_sym(gb, lru[0]);
 497             Y[x + 1 + 1 * ystride] = decode_sym(gb, lru[0]);
 498             U[x >> 1] = decode_sym(gb, lru[1]) ^ 0x80;
 499             V[x >> 1] = decode_sym(gb, lru[2]) ^ 0x80;
 500         }
 501
 502         Y += ystride << 1;
 503         U += ustride;
 504         V += vstride;
 505     }
 506
 507     return 0;
 508 }
 509
 510 static int dxtory_decode_v2_420(AVCodecContext *avctx, AVFrame *pic,
 511                                 const uint8_t *src, int src_size)
 512 {
 513     GetByteContext gb;
 514     GetBitContext  gb2;
 515     int nslices, slice, slice_height;
 516     int cur_y, next_y;
 517     uint32_t off, slice_size;
 518     uint8_t *Y, *U, *V;
 519     int ret;
 520
 521     bytestream2_init(&gb, src, src_size);
 522     nslices = bytestream2_get_le16(&gb);
 523     off = FFALIGN(nslices * 4 + 2, 16);
 524     if (src_size < off) {
 525         av_log(avctx, AV_LOG_ERROR, "no slice data\n");
 526         return AVERROR_INVALIDDATA;
 527     }
 528
 529     if (!nslices) {
 530         avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,
 531                               avctx->width, avctx->height);
 532         return AVERROR_PATCHWELCOME;
 533     }
 534
 535     if ((avctx->width & 1) || (avctx->height & 1)) {
 536         avpriv_request_sample(avctx, "Frame dimensions %dx%d",
 537                               avctx->width, avctx->height);
 538     }
 539
 540     avctx->pix_fmt = AV_PIX_FMT_YUV420P;
 541     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 542         return ret;
 543
 544     Y = pic->data[0];
 545     U = pic->data[1];
 546     V = pic->data[2];
 547
 548     cur_y  = 0;
 549     for (slice = 0; slice < nslices; slice++) {
 550         slice_size   = bytestream2_get_le32(&gb);
 551         next_y = ((slice + 1) * avctx->height) / nslices;
 552         slice_height = (next_y & ~1) - (cur_y & ~1);
 553         if (slice_size > src_size - off) {
 554             av_log(avctx, AV_LOG_ERROR,
 555                    "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
 556                    slice_size, src_size - off);
 557             return AVERROR_INVALIDDATA;
 558         }
 559         if (slice_size <= 16) {
 560             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
 561             return AVERROR_INVALIDDATA;
 562         }
 563
 564         if (AV_RL32(src + off) != slice_size - 16) {
 565             av_log(avctx, AV_LOG_ERROR,
 566                    "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
 567                    AV_RL32(src + off), slice_size - 16);
 568         }
 569         init_get_bits(&gb2, src + off + 16, (slice_size - 16) * 8);
 570         dx2_decode_slice_420(&gb2, avctx->width, slice_height, Y, U, V,
 571                              pic->linesize[0], pic->linesize[1],
 572                              pic->linesize[2]);
 573
 574         Y += pic->linesize[0] *  slice_height;
 575         U += pic->linesize[1] * (slice_height >> 1);
 576         V += pic->linesize[2] * (slice_height >> 1);
 577         off += slice_size;
 578         cur_y   = next_y;
 579     }
 580
 581     return 0;
 582 }
 583
 584 static int dx2_decode_slice_444(GetBitContext *gb, int width, int height,
 585                                 uint8_t *Y, uint8_t *U, uint8_t *V,
 586                                 int ystride, int ustride, int vstride)
 587 {
 588     int x, y, i;
 589     uint8_t lru[3][8];
 590
 591     for (i = 0; i < 3; i++)
 592         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));
 593
 594     for (y = 0; y < height; y++) {
 595         for (x = 0; x < width; x++) {
 596             Y[x] = decode_sym(gb, lru[0]);
 597             U[x] = decode_sym(gb, lru[1]) ^ 0x80;
 598             V[x] = decode_sym(gb, lru[2]) ^ 0x80;
 599         }
 600
 601         Y += ystride;
 602         U += ustride;
 603         V += vstride;
 604     }
 605
 606     return 0;
 607 }
 608
 609 static int dxtory_decode_v2_444(AVCodecContext *avctx, AVFrame *pic,
 610                                 const uint8_t *src, int src_size)
 611 {
 612     GetByteContext gb;
 613     GetBitContext  gb2;
 614     int nslices, slice, slice_height;
 615     uint32_t off, slice_size;
 616     uint8_t *Y, *U, *V;
 617     int ret;
 618
 619     bytestream2_init(&gb, src, src_size);
 620     nslices = bytestream2_get_le16(&gb);
 621     off = FFALIGN(nslices * 4 + 2, 16);
 622     if (src_size < off) {
 623         av_log(avctx, AV_LOG_ERROR, "no slice data\n");
 624         return AVERROR_INVALIDDATA;
 625     }
 626
 627     if (!nslices || avctx->height % nslices) {
 628         avpriv_request_sample(avctx, "%d slices for %dx%d", nslices,
 629                               avctx->width, avctx->height);
 630         return AVERROR_PATCHWELCOME;
 631     }
 632
 633     slice_height = avctx->height / nslices;
 634
 635     avctx->pix_fmt = AV_PIX_FMT_YUV444P;
 636     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)
 637         return ret;
 638
 639     Y = pic->data[0];
 640     U = pic->data[1];
 641     V = pic->data[2];
 642
 643     for (slice = 0; slice < nslices; slice++) {
 644         slice_size = bytestream2_get_le32(&gb);
 645         if (slice_size > src_size - off) {
 646             av_log(avctx, AV_LOG_ERROR,
 647                    "invalid slice size %"PRIu32" (only %"PRIu32" bytes left)\n",
 648                    slice_size, src_size - off);
 649             return AVERROR_INVALIDDATA;
 650         }
 651         if (slice_size <= 16) {
 652             av_log(avctx, AV_LOG_ERROR, "invalid slice size %"PRIu32"\n", slice_size);
 653             return AVERROR_INVALIDDATA;
 654         }
 655
 656         if (AV_RL32(src + off) != slice_size - 16) {
 657             av_log(avctx, AV_LOG_ERROR,
 658                    "Slice sizes mismatch: got %"PRIu32" instead of %"PRIu32"\n",
 659                    AV_RL32(src + off), slice_size - 16);
 660         }
 661         init_get_bits(&gb2, src + off + 16, (slice_size - 16) * 8);
 662         dx2_decode_slice_444(&gb2, avctx->width, slice_height, Y, U, V,
 663                              pic->linesize[0], pic->linesize[1],
 664                              pic->linesize[2]);
 665
 666         Y += pic->linesize[0] * slice_height;
 667         U += pic->linesize[1] * slice_height;
 668         V += pic->linesize[2] * slice_height;
 669         off += slice_size;
 670     }
 671
 672     return 0;
 673 }
 674
 675 static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,
 676                         AVPacket *avpkt)
 677 {
 678     AVFrame *pic = data;
 679     const uint8_t *src = avpkt->data;
 680     int ret;
 681
 682     if (avpkt->size < 16) {
 683         av_log(avctx, AV_LOG_ERROR, "packet too small\n");
 684         return AVERROR_INVALIDDATA;
 685     }
 686
 687     switch (AV_RB32(src)) {
 688     case 0x01000001:
 689         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 690                                    AV_PIX_FMT_BGR24, 3);
 691         break;
 692     case 0x01000009:
 693         ret = dxtory_decode_v2_rgb(avctx, pic, src + 16, avpkt->size - 16);
 694         break;
 695     case 0x02000001:
 696         ret = dxtory_decode_v1_420(avctx, pic, src + 16, avpkt->size - 16);
 697         break;
 698     case 0x02000009:
 699         ret = dxtory_decode_v2_420(avctx, pic, src + 16, avpkt->size - 16);
 700         break;
 701     case 0x03000001:
 702         ret = dxtory_decode_v1_410(avctx, pic, src + 16, avpkt->size - 16);
 703         break;
 704     case 0x03000009:
 705         ret = dxtory_decode_v2_410(avctx, pic, src + 16, avpkt->size - 16);
 706         break;
 707     case 0x04000001:
 708         ret = dxtory_decode_v1_444(avctx, pic, src + 16, avpkt->size - 16);
 709         break;
 710     case 0x04000009:
 711         ret = dxtory_decode_v2_444(avctx, pic, src + 16, avpkt->size - 16);
 712         break;
 713     case 0x17000001:
 714         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 715                                    AV_PIX_FMT_RGB565LE, 2);
 716         break;
 717     case 0x17000009:
 718         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 1);
 719         break;
 720     case 0x18000001:
 721     case 0x19000001:
 722         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,
 723                                    AV_PIX_FMT_RGB555LE, 2);
 724         break;
 725     case 0x18000009:
 726     case 0x19000009:
 727         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 0);
 728         break;
 729     default:
 730         avpriv_request_sample(avctx, "Frame header %"PRIX32, AV_RB32(src));
 731         return AVERROR_PATCHWELCOME;
 732     }
 733
 734     if (ret)
 735         return ret;
 736
 737     pic->pict_type = AV_PICTURE_TYPE_I;
 738     pic->key_frame = 1;
 739     *got_frame = 1;
 740
 741     return avpkt->size;
 742 }
 743
 744 AVCodec ff_dxtory_decoder = {
 745     .name           = "dxtory",
 746     .long_name      = NULL_IF_CONFIG_SMALL("Dxtory"),
 747     .type           = AVMEDIA_TYPE_VIDEO,
 748     .id             = AV_CODEC_ID_DXTORY,
 749     .decode         = decode_frame,
 750     .capabilities   = CODEC_CAP_DR1,
 751 };