falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
80817 Commits
32 Branches
305MB
Tree: ae753dbd0d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ae753dbd0d'
${ noResults }
FFmpeg/libavcodec/dxtory.c

628 lines
18KB
Raw Blame History 

  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 %"PRIu32" (only %"PRIu32" 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 %"PRIu32"\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 %"PRIu32" instead of %"PRIu32"\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;

  276.     GetBitContext  gb2;

  277.     int nslices, slice, line = 0;

  278.     uint32_t off, slice_size;

  279.     uint8_t lru[3][8];

  280.     int ret;

  281. 

  282.     ret = load_buffer(avctx, src, src_size, &gb, &nslices, &off);

  283.     if (ret < 0)

  284.         return ret;

  285. 

  286.     avctx->pix_fmt = fmt;

  287.     if ((ret = ff_get_buffer(avctx, pic, 0)) < 0)

  288.         return ret;

  289. 

  290.     for (slice = 0; slice < nslices; slice++) {

  291.         slice_size = bytestream2_get_le32(&gb);

  292. 

  293.         setup_lru(lru);

  294. 

  295.         ret = check_slice_size(avctx, src, src_size, slice_size, off);

  296.         if (ret < 0)

  297.             return ret;

  298. 

  299.         if ((ret = init_get_bits8(&gb2, src + off + 16, slice_size - 16)) < 0)

  300.             return ret;

  301. 

  302.         line += decode_slice(&gb2, pic, line, avctx->height - line, lru);

  303. 

  304.         off += slice_size;

  305.     }

  306. 

  307.     if (avctx->height - line) {

  308.         av_log(avctx, AV_LOG_VERBOSE,

  309.                "Not enough slice data available, "

  310.                "cropping the frame by %d pixels\n",

  311.                 avctx->height - line);

  312.         avctx->height = line;

  313.     }

  314. 

  315.     return 0;

  316. }

  317. 

  318. av_always_inline

  319. static int dx2_decode_slice_5x5(GetBitContext *gb, AVFrame *frame,

  320.                                 int line, int left, uint8_t lru[3][8],

  321.                                 int is_565)

  322. {

  323.     int x, y;

  324.     int r, g, b;

  325.     int width    = frame->width;

  326.     int stride   = frame->linesize[0];

  327.     uint8_t *dst = frame->data[0] + stride * line;

  328. 

  329.     for (y = 0; y < left && get_bits_left(gb) > 16; y++) {

  330.         for (x = 0; x < width; x++) {

  331.             b = decode_sym_565(gb, lru[0], 5);

  332.             g = decode_sym_565(gb, lru[1], is_565 ? 6 : 5);

  333.             r = decode_sym_565(gb, lru[2], 5);

  334.             dst[x * 3 + 0] = (r << 3) | (r >> 2);

  335.             dst[x * 3 + 1] = is_565 ? (g << 2) | (g >> 4) : (g << 3) | (g >> 2);

  336.             dst[x * 3 + 2] = (b << 3) | (b >> 2);

  337.         }

  338. 

  339.         dst += stride;

  340.     }

  341. 

  342.     return y;

  343. }

  344. 

  345. static void setup_lru_555(uint8_t lru[3][8])

  346. {

  347.     memcpy(lru[0], def_lru_555, 8 * sizeof(*def_lru));

  348.     memcpy(lru[1], def_lru_555, 8 * sizeof(*def_lru));

  349.     memcpy(lru[2], def_lru_555, 8 * sizeof(*def_lru));

  350. }

  351. 

  352. static void setup_lru_565(uint8_t lru[3][8])

  353. {

  354.     memcpy(lru[0], def_lru_555, 8 * sizeof(*def_lru));

  355.     memcpy(lru[1], def_lru_565, 8 * sizeof(*def_lru));

  356.     memcpy(lru[2], def_lru_555, 8 * sizeof(*def_lru));

  357. }

  358. 

  359. static int dx2_decode_slice_555(GetBitContext *gb, AVFrame *frame,

  360.                                 int line, int left, uint8_t lru[3][8])

  361. {

  362.     return dx2_decode_slice_5x5(gb, frame, line, left, lru, 0);

  363. }

  364. 

  365. static int dx2_decode_slice_565(GetBitContext *gb, AVFrame *frame,

  366.                                 int line, int left, uint8_t lru[3][8])

  367. {

  368.     return dx2_decode_slice_5x5(gb, frame, line, left, lru, 1);

  369. }

  370. 

  371. static int dxtory_decode_v2_565(AVCodecContext *avctx, AVFrame *pic,

  372.                                 const uint8_t *src, int src_size, int is_565)

  373. {

  374.     enum AVPixelFormat fmt = AV_PIX_FMT_RGB24;

  375.     if (is_565)

  376.         return dxtory_decode_v2(avctx, pic, src, src_size,

  377.                                 dx2_decode_slice_565,

  378.                                 setup_lru_565,

  379.                                 fmt);

  380.     else

  381.         return dxtory_decode_v2(avctx, pic, src, src_size,

  382.                                 dx2_decode_slice_555,

  383.                                 setup_lru_555,

  384.                                 fmt);

  385. }

  386. 

  387. static int dx2_decode_slice_rgb(GetBitContext *gb, AVFrame *frame,

  388.                                 int line, int left, uint8_t lru[3][8])

  389. {

  390.     int x, y;

  391.     int width    = frame->width;

  392.     int stride   = frame->linesize[0];

  393.     uint8_t *dst = frame->data[0] + stride * line;

  394. 

  395.     for (y = 0; y < left && get_bits_left(gb) > 16; y++) {

  396.         for (x = 0; x < width; x++) {

  397.             dst[x * 3 + 0] = decode_sym(gb, lru[0]);

  398.             dst[x * 3 + 1] = decode_sym(gb, lru[1]);

  399.             dst[x * 3 + 2] = decode_sym(gb, lru[2]);

  400.         }

  401. 

  402.         dst += stride;

  403.     }

  404. 

  405.     return y;

  406. }

  407. 

  408. static void default_setup_lru(uint8_t lru[3][8])

  409. {

  410.     int i;

  411. 

  412.     for (i = 0; i < 3; i++)

  413.         memcpy(lru[i], def_lru, 8 * sizeof(*def_lru));

  414. }

  415. 

  416. static int dxtory_decode_v2_rgb(AVCodecContext *avctx, AVFrame *pic,

  417.                                 const uint8_t *src, int src_size)

  418. {

  419.     return dxtory_decode_v2(avctx, pic, src, src_size,

  420.                             dx2_decode_slice_rgb,

  421.                             default_setup_lru,

  422.                             AV_PIX_FMT_BGR24);

  423. }

  424. 

  425. static int dx2_decode_slice_410(GetBitContext *gb, AVFrame *frame,

  426.                                 int line, int left,

  427.                                 uint8_t lru[3][8])

  428. {

  429.     int x, y, i, j;

  430.     int width   = frame->width;

  431. 

  432.     int ystride = frame->linesize[0];

  433.     int ustride = frame->linesize[1];

  434.     int vstride = frame->linesize[2];

  435. 

  436.     uint8_t *Y  = frame->data[0] + ystride * line;

  437.     uint8_t *U  = frame->data[1] + (ustride >> 2) * line;

  438.     uint8_t *V  = frame->data[2] + (vstride >> 2) * line;

  439. 

  440.     for (y = 0; y < left - 3 && get_bits_left(gb) > 16; y += 4) {

  441.         for (x = 0; x < width; x += 4) {

  442.             for (j = 0; j < 4; j++)

  443.                 for (i = 0; i < 4; i++)

  444.                     Y[x + i + j * ystride] = decode_sym(gb, lru[0]);

  445.             U[x >> 2] = decode_sym(gb, lru[1]) ^ 0x80;

  446.             V[x >> 2] = decode_sym(gb, lru[2]) ^ 0x80;

  447.         }

  448. 

  449.         Y += ystride << 2;

  450.         U += ustride;

  451.         V += vstride;

  452.     }

  453. 

  454.     return y;

  455. }

  456. 

  457. 

  458. static int dxtory_decode_v2_410(AVCodecContext *avctx, AVFrame *pic,

  459.                                 const uint8_t *src, int src_size)

  460. {

  461.     return dxtory_decode_v2(avctx, pic, src, src_size,

  462.                             dx2_decode_slice_410,

  463.                             default_setup_lru,

  464.                             AV_PIX_FMT_YUV410P);

  465. }

  466. 

  467. static int dx2_decode_slice_420(GetBitContext *gb, AVFrame *frame,

  468.                                 int line, int left,

  469.                                 uint8_t lru[3][8])

  470. {

  471.     int x, y;

  472. 

  473.     int width    = frame->width;

  474. 

  475.     int ystride = frame->linesize[0];

  476.     int ustride = frame->linesize[1];

  477.     int vstride = frame->linesize[2];

  478. 

  479.     uint8_t *Y  = frame->data[0] + ystride * line;

  480.     uint8_t *U  = frame->data[1] + (ustride >> 1) * line;

  481.     uint8_t *V  = frame->data[2] + (vstride >> 1) * line;

  482. 

  483. 

  484.     for (y = 0; y < left - 1 && get_bits_left(gb) > 16; y += 2) {

  485.         for (x = 0; x < width; x += 2) {

  486.             Y[x + 0 + 0 * ystride] = decode_sym(gb, lru[0]);

  487.             Y[x + 1 + 0 * ystride] = decode_sym(gb, lru[0]);

  488.             Y[x + 0 + 1 * ystride] = decode_sym(gb, lru[0]);

  489.             Y[x + 1 + 1 * ystride] = decode_sym(gb, lru[0]);

  490.             U[x >> 1] = decode_sym(gb, lru[1]) ^ 0x80;

  491.             V[x >> 1] = decode_sym(gb, lru[2]) ^ 0x80;

  492.         }

  493. 

  494.         Y += ystride << 1;

  495.         U += ustride;

  496.         V += vstride;

  497.     }

  498. 

  499.     return y;

  500. }

  501. 

  502. static int dxtory_decode_v2_420(AVCodecContext *avctx, AVFrame *pic,

  503.                                 const uint8_t *src, int src_size)

  504. {

  505.     return dxtory_decode_v2(avctx, pic, src, src_size,

  506.                             dx2_decode_slice_420,

  507.                             default_setup_lru,

  508.                             AV_PIX_FMT_YUV420P);

  509. }

  510. 

  511. static int dx2_decode_slice_444(GetBitContext *gb, AVFrame *frame,

  512.                                 int line, int left,

  513.                                 uint8_t lru[3][8])

  514. {

  515.     int x, y;

  516. 

  517.     int width   = frame->width;

  518. 

  519.     int ystride = frame->linesize[0];

  520.     int ustride = frame->linesize[1];

  521.     int vstride = frame->linesize[2];

  522. 

  523.     uint8_t *Y  = frame->data[0] + ystride * line;

  524.     uint8_t *U  = frame->data[1] + ustride * line;

  525.     uint8_t *V  = frame->data[2] + vstride * line;

  526. 

  527.     for (y = 0; y < left && get_bits_left(gb) > 16; y++) {

  528.         for (x = 0; x < width; x++) {

  529.             Y[x] = decode_sym(gb, lru[0]);

  530.             U[x] = decode_sym(gb, lru[1]) ^ 0x80;

  531.             V[x] = decode_sym(gb, lru[2]) ^ 0x80;

  532.         }

  533. 

  534.         Y += ystride;

  535.         U += ustride;

  536.         V += vstride;

  537.     }

  538. 

  539.     return y;

  540. }

  541. 

  542. static int dxtory_decode_v2_444(AVCodecContext *avctx, AVFrame *pic,

  543.                                 const uint8_t *src, int src_size)

  544. {

  545.     return dxtory_decode_v2(avctx, pic, src, src_size,

  546.                             dx2_decode_slice_444,

  547.                             default_setup_lru,

  548.                             AV_PIX_FMT_YUV444P);

  549. }

  550. 

  551. static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame,

  552.                         AVPacket *avpkt)

  553. {

  554.     AVFrame *pic = data;

  555.     const uint8_t *src = avpkt->data;

  556.     int ret;

  557. 

  558.     if (avpkt->size < 16) {

  559.         av_log(avctx, AV_LOG_ERROR, "packet too small\n");

  560.         return AVERROR_INVALIDDATA;

  561.     }

  562. 

  563.     switch (AV_RB32(src)) {

  564.     case 0x01000001:

  565.         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,

  566.                                    AV_PIX_FMT_BGR24, 3);

  567.         break;

  568.     case 0x01000009:

  569.         ret = dxtory_decode_v2_rgb(avctx, pic, src + 16, avpkt->size - 16);

  570.         break;

  571.     case 0x02000001:

  572.         ret = dxtory_decode_v1_420(avctx, pic, src + 16, avpkt->size - 16);

  573.         break;

  574.     case 0x02000009:

  575.         ret = dxtory_decode_v2_420(avctx, pic, src + 16, avpkt->size - 16);

  576.         break;

  577.     case 0x03000001:

  578.         ret = dxtory_decode_v1_410(avctx, pic, src + 16, avpkt->size - 16);

  579.         break;

  580.     case 0x03000009:

  581.         ret = dxtory_decode_v2_410(avctx, pic, src + 16, avpkt->size - 16);

  582.         break;

  583.     case 0x04000001:

  584.         ret = dxtory_decode_v1_444(avctx, pic, src + 16, avpkt->size - 16);

  585.         break;

  586.     case 0x04000009:

  587.         ret = dxtory_decode_v2_444(avctx, pic, src + 16, avpkt->size - 16);

  588.         break;

  589.     case 0x17000001:

  590.         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,

  591.                                    AV_PIX_FMT_RGB565LE, 2);

  592.         break;

  593.     case 0x17000009:

  594.         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 1);

  595.         break;

  596.     case 0x18000001:

  597.     case 0x19000001:

  598.         ret = dxtory_decode_v1_rgb(avctx, pic, src + 16, avpkt->size - 16,

  599.                                    AV_PIX_FMT_RGB555LE, 2);

  600.         break;

  601.     case 0x18000009:

  602.     case 0x19000009:

  603.         ret = dxtory_decode_v2_565(avctx, pic, src + 16, avpkt->size - 16, 0);

  604.         break;

  605.     default:

  606.         avpriv_request_sample(avctx, "Frame header %"PRIX32, AV_RB32(src));

  607.         return AVERROR_PATCHWELCOME;

  608.     }

  609. 

  610.     if (ret)

  611.         return ret;

  612. 

  613.     pic->pict_type = AV_PICTURE_TYPE_I;

  614.     pic->key_frame = 1;

  615.     *got_frame = 1;

  616. 

  617.     return avpkt->size;

  618. }

  619. 

  620. AVCodec ff_dxtory_decoder = {

  621.     .name           = "dxtory",

  622.     .long_name      = NULL_IF_CONFIG_SMALL("Dxtory"),

  623.     .type           = AVMEDIA_TYPE_VIDEO,

  624.     .id             = AV_CODEC_ID_DXTORY,

  625.     .decode         = decode_frame,

  626.     .capabilities   = AV_CODEC_CAP_DR1,

  627. };