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