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

752 lines
23KB
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. #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_COPY32(Y1 + w, src);

  86.             AV_COPY32(Y2 + w, src + 4);

  87.             AV_COPY32(Y3 + w, src + 8);

  88.             AV_COPY32(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. };