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.
90089 Commits
32 Branches
979MB
Tree: 3748746a4d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '3748746a4d'
${ noResults }
FFmpeg/libavcodec/dxtory.c

624 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 %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;

  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.         avpriv_request_sample(avctx, "Not enough slice data available");

  309.     }

  310. 

  311.     return 0;

  312. }

  313. 

  314. av_always_inline

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

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

  317.                                 int is_565)

  318. {

  319.     int x, y;

  320.     int r, g, b;

  321.     int width    = frame->width;

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

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

  324. 

  325.     for (y = 0; y < left && get_bits_left(gb) > 6 * width; y++) {

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

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

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

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

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

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

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

  333.         }

  334. 

  335.         dst += stride;

  336.     }

  337. 

  338.     return y;

  339. }

  340. 

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

  342. {

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

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

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

  346. }

  347. 

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

  349. {

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

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

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

  353. }

  354. 

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

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

  357. {

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

  359. }

  360. 

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

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

  363. {

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

  365. }

  366. 

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

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

  369. {

  370.     enum AVPixelFormat fmt = AV_PIX_FMT_RGB24;

  371.     if (is_565)

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

  373.                                 dx2_decode_slice_565,

  374.                                 setup_lru_565,

  375.                                 fmt);

  376.     else

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

  378.                                 dx2_decode_slice_555,

  379.                                 setup_lru_555,

  380.                                 fmt);

  381. }

  382. 

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

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

  385. {

  386.     int x, y;

  387.     int width    = frame->width;

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

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

  390. 

  391.     for (y = 0; y < left && get_bits_left(gb) > 6 * width; y++) {

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

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

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

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

  396.         }

  397. 

  398.         dst += stride;

  399.     }

  400. 

  401.     return y;

  402. }

  403. 

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

  405. {

  406.     int i;

  407. 

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

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

  410. }

  411. 

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

  413.                                 const uint8_t *src, int src_size)

  414. {

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

  416.                             dx2_decode_slice_rgb,

  417.                             default_setup_lru,

  418.                             AV_PIX_FMT_BGR24);

  419. }

  420. 

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

  422.                                 int line, int left,

  423.                                 uint8_t lru[3][8])

  424. {

  425.     int x, y, i, j;

  426.     int width   = frame->width;

  427. 

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

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

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

  431. 

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

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

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

  435. 

  436.     for (y = 0; y < left - 3 && get_bits_left(gb) > 9 * width; y += 4) {

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

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

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

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

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

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

  443.         }

  444. 

  445.         Y += ystride << 2;

  446.         U += ustride;

  447.         V += vstride;

  448.     }

  449. 

  450.     return y;

  451. }

  452. 

  453. 

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

  455.                                 const uint8_t *src, int src_size)

  456. {

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

  458.                             dx2_decode_slice_410,

  459.                             default_setup_lru,

  460.                             AV_PIX_FMT_YUV410P);

  461. }

  462. 

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

  464.                                 int line, int left,

  465.                                 uint8_t lru[3][8])

  466. {

  467.     int x, y;

  468. 

  469.     int width    = frame->width;

  470. 

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

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

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

  474. 

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

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

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

  478. 

  479. 

  480.     for (y = 0; y < left - 1 && get_bits_left(gb) > 6 * width; y += 2) {

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

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

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

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

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

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

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

  488.         }

  489. 

  490.         Y += ystride << 1;

  491.         U += ustride;

  492.         V += vstride;

  493.     }

  494. 

  495.     return y;

  496. }

  497. 

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

  499.                                 const uint8_t *src, int src_size)

  500. {

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

  502.                             dx2_decode_slice_420,

  503.                             default_setup_lru,

  504.                             AV_PIX_FMT_YUV420P);

  505. }

  506. 

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

  508.                                 int line, int left,

  509.                                 uint8_t lru[3][8])

  510. {

  511.     int x, y;

  512. 

  513.     int width   = frame->width;

  514. 

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

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

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

  518. 

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

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

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

  522. 

  523.     for (y = 0; y < left && get_bits_left(gb) > 6 * width; y++) {

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

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

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

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

  528.         }

  529. 

  530.         Y += ystride;

  531.         U += ustride;

  532.         V += vstride;

  533.     }

  534. 

  535.     return y;

  536. }

  537. 

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

  539.                                 const uint8_t *src, int src_size)

  540. {

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

  542.                             dx2_decode_slice_444,

  543.                             default_setup_lru,

  544.                             AV_PIX_FMT_YUV444P);

  545. }

  546. 

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

  548.                         AVPacket *avpkt)

  549. {

  550.     AVFrame *pic = data;

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

  552.     int ret;

  553. 

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

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

  556.         return AVERROR_INVALIDDATA;

  557.     }

  558. 

  559.     switch (AV_RB32(src)) {

  560.     case 0x01000001:

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

  562.                                    AV_PIX_FMT_BGR24, 3);

  563.         break;

  564.     case 0x01000009:

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

  566.         break;

  567.     case 0x02000001:

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

  569.         break;

  570.     case 0x02000009:

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

  572.         break;

  573.     case 0x03000001:

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

  575.         break;

  576.     case 0x03000009:

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

  578.         break;

  579.     case 0x04000001:

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

  581.         break;

  582.     case 0x04000009:

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

  584.         break;

  585.     case 0x17000001:

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

  587.                                    AV_PIX_FMT_RGB565LE, 2);

  588.         break;

  589.     case 0x17000009:

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

  591.         break;

  592.     case 0x18000001:

  593.     case 0x19000001:

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

  595.                                    AV_PIX_FMT_RGB555LE, 2);

  596.         break;

  597.     case 0x18000009:

  598.     case 0x19000009:

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

  600.         break;

  601.     default:

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

  603.         return AVERROR_PATCHWELCOME;

  604.     }

  605. 

  606.     if (ret)

  607.         return ret;

  608. 

  609.     pic->pict_type = AV_PICTURE_TYPE_I;

  610.     pic->key_frame = 1;

  611.     *got_frame = 1;

  612. 

  613.     return avpkt->size;

  614. }

  615. 

  616. AVCodec ff_dxtory_decoder = {

  617.     .name           = "dxtory",

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

  619.     .type           = AVMEDIA_TYPE_VIDEO,

  620.     .id             = AV_CODEC_ID_DXTORY,

  621.     .decode         = decode_frame,

  622.     .capabilities   = AV_CODEC_CAP_DR1,

  623. };