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.
99010 Commits
32 Branches
1.2GB
Tree: 4562d8e8d6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4562d8e8d6'
${ noResults }
FFmpeg/libavcodec/dxtory.c

879 lines
26KB
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 int64_t get_raw_size(enum AVPixelFormat fmt, int width, int height)

  36. {

  37.     switch (fmt) {

  38.     case AV_PIX_FMT_RGB555LE:

  39.     case AV_PIX_FMT_RGB565LE:

  40.         return width * height * 2LL;

  41.     case AV_PIX_FMT_RGB24:

  42.     case AV_PIX_FMT_BGR24:

  43.     case AV_PIX_FMT_YUV444P:

  44.         return width * height * 3LL;

  45.     case AV_PIX_FMT_YUV420P:

  46.         return (int64_t)(width * height) + AV_CEIL_RSHIFT(width, 1) * AV_CEIL_RSHIFT(height, 1);

  47.     case AV_PIX_FMT_YUV410P:

  48.         return (int64_t)(width * height) + AV_CEIL_RSHIFT(width, 2) * AV_CEIL_RSHIFT(height, 2);

  49.     }

  50. 

  51.     return 0;

  52. }

  53. 

  54. static void do_vflip(AVCodecContext *avctx, AVFrame *pic, int vflip)

  55. {

  56.     if (!vflip)

  57.         return;

  58. 

  59.     switch (pic->format) {

  60.     case AV_PIX_FMT_YUV444P:

  61.         pic->data[1] += (avctx->height - 1) * pic->linesize[1];

  62.         pic->linesize[1] = -pic->linesize[1];

  63.         pic->data[2] += (avctx->height - 1) * pic->linesize[2];

  64.         pic->linesize[2] = -pic->linesize[2];

  65.     case AV_PIX_FMT_BGR24:

  66.     case AV_PIX_FMT_RGB24:

  67.         pic->data[0] += (avctx->height - 1) * pic->linesize[0];

  68.         pic->linesize[0] = -pic->linesize[0];

  69.         break;

  70.     case AV_PIX_FMT_YUV410P:

  71.         pic->data[0] += (avctx->height - 1) * pic->linesize[0];

  72.         pic->linesize[0] = -pic->linesize[0];

  73.         pic->data[1] += (AV_CEIL_RSHIFT(avctx->height, 2) - 1) * pic->linesize[1];

  74.         pic->linesize[1] = -pic->linesize[1];

  75.         pic->data[2] += (AV_CEIL_RSHIFT(avctx->height, 2) - 1) * pic->linesize[2];

  76.         pic->linesize[2] = -pic->linesize[2];

  77.         break;

  78.     case AV_PIX_FMT_YUV420P:

  79.         pic->data[0] += (avctx->height - 1) * pic->linesize[0];

  80.         pic->linesize[0] = -pic->linesize[0];

  81.         pic->data[1] += (AV_CEIL_RSHIFT(avctx->height, 1) - 1) * pic->linesize[1];

  82.         pic->linesize[1] = -pic->linesize[1];

  83.         pic->data[2] += (AV_CEIL_RSHIFT(avctx->height, 1) - 1) * pic->linesize[2];

  84.         pic->linesize[2] = -pic->linesize[2];

  85.         break;

  86.     }

  87. }

  88. 

  89. static int dxtory_decode_v1_rgb(AVCodecContext *avctx, AVFrame *pic,

  90.                                 const uint8_t *src, int src_size,

  91.                                 int id, int bpp, uint32_t vflipped)

  92. {

  93.     int h;

  94.     uint8_t *dst;

  95.     int ret;

  96. 

  97.     if (src_size < get_raw_size(id, avctx->width, avctx->height)) {

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

  99.         return AVERROR_INVALIDDATA;

  100.     }

  101. 

  102.     avctx->pix_fmt = id;

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

  104.         return ret;

  105. 

  106.     do_vflip(avctx, pic, vflipped);

  107. 

  108.     dst = pic->data[0];

  109.     for (h = 0; h < avctx->height; h++) {

  110.         memcpy(dst, src, avctx->width * bpp);

  111.         src += avctx->width * bpp;

  112.         dst += pic->linesize[0];

  113.     }

  114. 

  115.     do_vflip(avctx, pic, vflipped);

  116. 

  117.     return 0;

  118. }

  119. 

  120. static int dxtory_decode_v1_410(AVCodecContext *avctx, AVFrame *pic,

  121.                                 const uint8_t *src, int src_size,

  122.                                 uint32_t vflipped)

  123. {

  124.     int h, w;

  125.     uint8_t *Y1, *Y2, *Y3, *Y4, *U, *V;

  126.     int height, width, hmargin, vmargin;

  127.     int huvborder;

  128.     int ret;

  129. 

  130.     if (src_size < get_raw_size(AV_PIX_FMT_YUV410P, avctx->width, avctx->height)) {

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

  132.         return AVERROR_INVALIDDATA;

  133.     }

  134. 

  135.     avctx->pix_fmt = AV_PIX_FMT_YUV410P;

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

  137.         return ret;

  138. 

  139.     do_vflip(avctx, pic, vflipped);

  140. 

  141.     height = avctx->height & ~3;

  142.     width  = avctx->width  & ~3;

  143.     hmargin = avctx->width  - width;

  144.     vmargin = avctx->height - height;

  145.     huvborder = AV_CEIL_RSHIFT(avctx->width, 2) - 1;

  146. 

  147.     Y1 = pic->data[0];

  148.     Y2 = pic->data[0] + pic->linesize[0];

  149.     Y3 = pic->data[0] + pic->linesize[0] * 2;

  150.     Y4 = pic->data[0] + pic->linesize[0] * 3;

  151.     U  = pic->data[1];

  152.     V  = pic->data[2];

  153.     for (h = 0; h < height; h += 4) {

  154.         for (w = 0; w < width; w += 4) {

  155.             AV_COPY32U(Y1 + w, src);

  156.             AV_COPY32U(Y2 + w, src + 4);

  157.             AV_COPY32U(Y3 + w, src + 8);

  158.             AV_COPY32U(Y4 + w, src + 12);

  159.             U[w >> 2] = src[16] + 0x80;

  160.             V[w >> 2] = src[17] + 0x80;

  161.             src += 18;

  162.         }

  163.         if (hmargin) {

  164.             for (w = 0; w < hmargin; w++) {

  165.                 Y1[width + w] = src[w];

  166.                 Y2[width + w] = src[w + hmargin * 1];

  167.                 Y3[width + w] = src[w + hmargin * 2];

  168.                 Y4[width + w] = src[w + hmargin * 3];

  169.             }

  170.             src += 4 * hmargin;

  171.             U[huvborder] = src[0] + 0x80;

  172.             V[huvborder] = src[1] + 0x80;

  173.             src += 2;

  174.         }

  175.         Y1 += pic->linesize[0] << 2;

  176.         Y2 += pic->linesize[0] << 2;

  177.         Y3 += pic->linesize[0] << 2;

  178.         Y4 += pic->linesize[0] << 2;

  179.         U  += pic->linesize[1];

  180.         V  += pic->linesize[2];

  181.     }

  182. 

  183.     if (vmargin) {

  184.         for (w = 0; w < width; w += 4) {

  185.             AV_COPY32U(Y1 + w, src);

  186.             if (vmargin > 1)

  187.                 AV_COPY32U(Y2 + w, src + 4);

  188.             if (vmargin > 2)

  189.                 AV_COPY32U(Y3 + w, src + 8);

  190.             src += 4 * vmargin;

  191.             U[w >> 2] = src[0] + 0x80;

  192.             V[w >> 2] = src[1] + 0x80;

  193.             src += 2;

  194.         }

  195.         if (hmargin) {

  196.             for (w = 0; w < hmargin; w++) {

  197.                 AV_COPY32U(Y1 + w, src);

  198.                 if (vmargin > 1)

  199.                     AV_COPY32U(Y2 + w, src + 4);

  200.                 if (vmargin > 2)

  201.                     AV_COPY32U(Y3 + w, src + 8);

  202.                 src += 4 * vmargin;

  203.             }

  204.             U[huvborder] = src[0] + 0x80;

  205.             V[huvborder] = src[1] + 0x80;

  206.             src += 2;

  207.         }

  208.     }

  209. 

  210.     do_vflip(avctx, pic, vflipped);

  211. 

  212.     return 0;

  213. }

  214. 

  215. static int dxtory_decode_v1_420(AVCodecContext *avctx, AVFrame *pic,

  216.                                 const uint8_t *src, int src_size,

  217.                                 uint32_t vflipped)

  218. {

  219.     int h, w;

  220.     uint8_t *Y1, *Y2, *U, *V;

  221.     int height, width, hmargin, vmargin;

  222.     int huvborder;

  223.     int ret;

  224. 

  225.     if (src_size < get_raw_size(AV_PIX_FMT_YUV420P, avctx->width, avctx->height)) {

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

  227.         return AVERROR_INVALIDDATA;

  228.     }

  229. 

  230.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;

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

  232.         return ret;

  233. 

  234.     do_vflip(avctx, pic, vflipped);

  235. 

  236.     height = avctx->height & ~1;

  237.     width  = avctx->width  & ~1;

  238.     hmargin = avctx->width  - width;

  239.     vmargin = avctx->height - height;

  240.     huvborder = AV_CEIL_RSHIFT(avctx->width, 1) - 1;

  241. 

  242.     Y1 = pic->data[0];

  243.     Y2 = pic->data[0] + pic->linesize[0];

  244.     U  = pic->data[1];

  245.     V  = pic->data[2];

  246.     for (h = 0; h < height; h += 2) {

  247.         for (w = 0; w < width; w += 2) {

  248.             AV_COPY16(Y1 + w, src);

  249.             AV_COPY16(Y2 + w, src + 2);

  250.             U[w >> 1] = src[4] + 0x80;

  251.             V[w >> 1] = src[5] + 0x80;

  252.             src += 6;

  253.         }

  254.         if (hmargin) {

  255.             Y1[width + 1] = src[0];

  256.             Y2[width + 1] = src[1];

  257.             U[huvborder] = src[2] + 0x80;

  258.             V[huvborder] = src[3] + 0x80;

  259.             src += 4;

  260.         }

  261.         Y1 += pic->linesize[0] << 1;

  262.         Y2 += pic->linesize[0] << 1;

  263.         U  += pic->linesize[1];

  264.         V  += pic->linesize[2];

  265.     }

  266. 

  267.     if (vmargin) {

  268.         for (w = 0; w < width; w += 2) {

  269.             AV_COPY16U(Y1 + w, src);

  270.             U[w >> 1] = src[0] + 0x80;

  271.             V[w >> 1] = src[1] + 0x80;

  272.             src += 4;

  273.         }

  274.         if (hmargin) {

  275.             Y1[w] = src[0];

  276.             U[huvborder] = src[1] + 0x80;

  277.             V[huvborder] = src[2] + 0x80;

  278.             src += 3;

  279.         }

  280.     }

  281. 

  282.     do_vflip(avctx, pic, vflipped);

  283. 

  284.     return 0;

  285. }

  286. 

  287. static int dxtory_decode_v1_444(AVCodecContext *avctx, AVFrame *pic,

  288.                                 const uint8_t *src, int src_size,

  289.                                 uint32_t vflipped)

  290. {

  291.     int h, w;

  292.     uint8_t *Y, *U, *V;

  293.     int ret;

  294. 

  295.     if (src_size < get_raw_size(AV_PIX_FMT_YUV444P, avctx->width, avctx->height)) {

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

  297.         return AVERROR_INVALIDDATA;

  298.     }

  299. 

  300.     avctx->pix_fmt = AV_PIX_FMT_YUV444P;

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

  302.         return ret;

  303. 

  304.     do_vflip(avctx, pic, vflipped);

  305. 

  306.     Y = pic->data[0];

  307.     U = pic->data[1];

  308.     V = pic->data[2];

  309.     for (h = 0; h < avctx->height; h++) {

  310.         for (w = 0; w < avctx->width; w++) {

  311.             Y[w] = *src++;

  312.             U[w] = *src++ ^ 0x80;

  313.             V[w] = *src++ ^ 0x80;

  314.         }

  315.         Y += pic->linesize[0];

  316.         U += pic->linesize[1];

  317.         V += pic->linesize[2];

  318.     }

  319. 

  320.     do_vflip(avctx, pic, vflipped);

  321. 

  322.     return 0;

  323. }

  324. 

  325. static const uint8_t def_lru[8] = { 0x00, 0x20, 0x40, 0x60, 0x80, 0xA0, 0xC0, 0xFF };

  326. static const uint8_t def_lru_555[8] = { 0x00, 0x08, 0x10, 0x18, 0x1F };

  327. static const uint8_t def_lru_565[8] = { 0x00, 0x08, 0x10, 0x20, 0x30, 0x3F };

  328. 

  329. static inline uint8_t decode_sym(GetBitContext *gb, uint8_t lru[8])

  330. {

  331.     uint8_t c, val;

  332. 

  333.     c = get_unary(gb, 0, 8);

  334.     if (!c) {

  335.         val = get_bits(gb, 8);

  336.         memmove(lru + 1, lru, sizeof(*lru) * (8 - 1));

  337.     } else {

  338.         val = lru[c - 1];

  339.         memmove(lru + 1, lru, sizeof(*lru) * (c - 1));

  340.     }

  341.     lru[0] = val;

  342. 

  343.     return val;

  344. }

  345. 

  346. static int check_slice_size(AVCodecContext *avctx,

  347.                             const uint8_t *src, int src_size,

  348.                             int slice_size, int off)

  349. {

  350.     int cur_slice_size;

  351. 

  352.     if (slice_size > src_size - off) {

  353.         av_log(avctx, AV_LOG_ERROR,

  354.                "invalid slice size %d (only %d bytes left)\n",

  355.                slice_size, src_size - off);

  356.         return AVERROR_INVALIDDATA;

  357.     }

  358.     if (slice_size <= 16) {

  359.         av_log(avctx, AV_LOG_ERROR, "invalid slice size %d\n",

  360.                slice_size);

  361.         return AVERROR_INVALIDDATA;

  362.     }

  363. 

  364.     cur_slice_size = AV_RL32(src + off);

  365.     if (cur_slice_size != slice_size - 16) {

  366.         av_log(avctx, AV_LOG_ERROR,

  367.                "Slice sizes mismatch: got %d instead of %d\n",

  368.                cur_slice_size, slice_size - 16);

  369.     }

  370. 

  371.     return 0;

  372. }

  373. 

  374. static int load_buffer(AVCodecContext *avctx,

  375.                        const uint8_t *src, int src_size,

  376.                        GetByteContext *gb,

  377.                        int *nslices, int *off)

  378. {

  379.     bytestream2_init(gb, src, src_size);

  380.     *nslices = bytestream2_get_le16(gb);

  381.     *off = FFALIGN(*nslices * 4 + 2, 16);

  382.     if (src_size < *off) {

  383.         av_log(avctx, AV_LOG_ERROR, "no slice data\n");

  384.         return AVERROR_INVALIDDATA;

  385.     }

  386. 

  387.     if (!*nslices) {

  388.         avpriv_request_sample(avctx, "%d slices for %dx%d", *nslices,

  389.                               avctx->width, avctx->height);

  390.         return AVERROR_PATCHWELCOME;

  391.     }

  392. 

  393.     return 0;

  394. }

  395. 

  396. static inline uint8_t decode_sym_565(GetBitContext *gb, uint8_t lru[8],

  397.                                      int bits)

  398. {

  399.     uint8_t c, val;

  400. 

  401.     c = get_unary(gb, 0, bits);

  402.     if (!c) {

  403.         val = get_bits(gb, bits);

  404.         memmove(lru + 1, lru, sizeof(*lru) * (6 - 1));

  405.     } else {

  406.         val = lru[c - 1];

  407.         memmove(lru + 1, lru, sizeof(*lru) * (c - 1));

  408.     }

  409.     lru[0] = val;

  410. 

  411.     return val;

  412. }

  413. 

  414. typedef int (*decode_slice_func)(GetBitContext *gb, AVFrame *frame,

  415.                                  int line, int height, uint8_t lru[3][8]);

  416. 

  417. typedef void (*setup_lru_func)(uint8_t lru[3][8]);

  418. 

  419. static int dxtory_decode_v2(AVCodecContext *avctx, AVFrame *pic,

  420.                             const uint8_t *src, int src_size,

  421.                             decode_slice_func decode_slice,

  422.                             setup_lru_func setup_lru,

  423.                             enum AVPixelFormat fmt,

  424.                             uint32_t vflipped)

  425. {

  426.     GetByteContext gb, gb_check;

  427.     GetBitContext  gb2;

  428.     int nslices, slice, line = 0;

  429.     uint32_t off, slice_size;

  430.     uint64_t off_check;

  431.     uint8_t lru[3][8];

  432.     int ret;

  433. 

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

  435.     if (ret < 0)

  436.         return ret;

  437. 

  438.     off_check = off;

  439.     gb_check = gb;

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

  441.         slice_size = bytestream2_get_le32(&gb_check);

  442. 

  443.         if (slice_size <= 16 + (avctx->height * avctx->width / (8 * nslices)))

  444.             return AVERROR_INVALIDDATA;

  445.         off_check += slice_size;

  446.     }

  447. 

  448.     if (off_check - avctx->discard_damaged_percentage*off_check/100 > src_size)

  449.         return AVERROR_INVALIDDATA;

  450. 

  451.     avctx->pix_fmt = fmt;

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

  453.         return ret;

  454. 

  455.     do_vflip(avctx, pic, vflipped);

  456. 

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

  458.         slice_size = bytestream2_get_le32(&gb);

  459. 

  460.         setup_lru(lru);

  461. 

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

  463.         if (ret < 0)

  464.             return ret;

  465. 

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

  467.             return ret;

  468. 

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

  470. 

  471.         off += slice_size;

  472.     }

  473. 

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

  475.         avpriv_request_sample(avctx, "Not enough slice data available");

  476.     }

  477. 

  478.     do_vflip(avctx, pic, vflipped);

  479. 

  480.     return 0;

  481. }

  482. 

  483. av_always_inline

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

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

  486.                                 int is_565)

  487. {

  488.     int x, y;

  489.     int r, g, b;

  490.     int width    = frame->width;

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

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

  493. 

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

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

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

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

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

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

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

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

  502.         }

  503. 

  504.         dst += stride;

  505.     }

  506. 

  507.     return y;

  508. }

  509. 

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

  511. {

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

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

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

  515. }

  516. 

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

  518. {

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

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

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

  522. }

  523. 

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

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

  526. {

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

  528. }

  529. 

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

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

  532. {

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

  534. }

  535. 

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

  537.                                 const uint8_t *src, int src_size, int is_565,

  538.                                 uint32_t vflipped)

  539. {

  540.     enum AVPixelFormat fmt = AV_PIX_FMT_RGB24;

  541.     if (is_565)

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

  543.                                 dx2_decode_slice_565,

  544.                                 setup_lru_565,

  545.                                 fmt, vflipped);

  546.     else

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

  548.                                 dx2_decode_slice_555,

  549.                                 setup_lru_555,

  550.                                 fmt, vflipped);

  551. }

  552. 

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

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

  555. {

  556.     int x, y;

  557.     int width    = frame->width;

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

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

  560. 

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

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

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

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

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

  566.         }

  567. 

  568.         dst += stride;

  569.     }

  570. 

  571.     return y;

  572. }

  573. 

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

  575. {

  576.     int i;

  577. 

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

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

  580. }

  581. 

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

  583.                                 const uint8_t *src, int src_size,

  584.                                 uint32_t vflipped)

  585. {

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

  587.                             dx2_decode_slice_rgb,

  588.                             default_setup_lru,

  589.                             AV_PIX_FMT_BGR24, vflipped);

  590. }

  591. 

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

  593.                                 int line, int left,

  594.                                 uint8_t lru[3][8])

  595. {

  596.     int x, y, i, j;

  597.     int width   = frame->width;

  598. 

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

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

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

  602. 

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

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

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

  606. 

  607.     int h, w, hmargin, vmargin;

  608.     int huvborder;

  609. 

  610.     h = frame->height & ~3;

  611.     w = frame->width  & ~3;

  612.     hmargin = frame->width  - w;

  613.     vmargin = frame->height - h;

  614.     huvborder = AV_CEIL_RSHIFT(frame->width, 2) - 1;

  615. 

  616.     for (y = 0; y < left - 3 && get_bits_left(gb) >= 18 * w / 4 + hmargin * 4 + (!!hmargin * 2); y += 4) {

  617.         for (x = 0; x < w; x += 4) {

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

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

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

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

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

  623.         }

  624.         if (hmargin) {

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

  626.                 for (i = 0; i < hmargin; i++)

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

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

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

  630.         }

  631. 

  632.         Y += ystride << 2;

  633.         U += ustride;

  634.         V += vstride;

  635.     }

  636. 

  637.     if (vmargin && y + vmargin == left) {

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

  639.             for (j = 0; j < vmargin; j++)

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

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

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

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

  644.         }

  645.         if (hmargin) {

  646.             for (j = 0; j < vmargin; j++) {

  647.                 for (i = 0; i < hmargin; i++)

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

  649.             }

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

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

  652.         }

  653. 

  654.         y += vmargin;

  655.     }

  656. 

  657.     return y;

  658. }

  659. 

  660. 

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

  662.                                 const uint8_t *src, int src_size,

  663.                                 uint32_t vflipped)

  664. {

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

  666.                             dx2_decode_slice_410,

  667.                             default_setup_lru,

  668.                             AV_PIX_FMT_YUV410P, vflipped);

  669. }

  670. 

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

  672.                                 int line, int left,

  673.                                 uint8_t lru[3][8])

  674. {

  675.     int x, y;

  676. 

  677.     int width    = frame->width;

  678. 

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

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

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

  682. 

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

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

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

  686. 

  687.     int h, w, hmargin, vmargin;

  688.     int huvborder;

  689. 

  690.     h = frame->height & ~1;

  691.     w = frame->width  & ~1;

  692.     hmargin = frame->width  - w;

  693.     vmargin = frame->height - h;

  694.     huvborder = AV_CEIL_RSHIFT(frame->width, 1) - 1;

  695. 

  696.     for (y = 0; y < left - 1 && get_bits_left(gb) >= 3 * w + hmargin * 4; y += 2) {

  697.         for (x = 0; x < w; x += 2) {

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

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

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

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

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

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

  704.         }

  705.         if (hmargin) {

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

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

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

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

  710.         }

  711. 

  712.         Y += ystride << 1;

  713.         U += ustride;

  714.         V += vstride;

  715.     }

  716. 

  717.     if (vmargin) {

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

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

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

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

  722.         }

  723.         if (hmargin) {

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

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

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

  727.         }

  728.     }

  729. 

  730.     return y;

  731. }

  732. 

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

  734.                                 const uint8_t *src, int src_size,

  735.                                 uint32_t vflipped)

  736. {

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

  738.                             dx2_decode_slice_420,

  739.                             default_setup_lru,

  740.                             AV_PIX_FMT_YUV420P, vflipped);

  741. }

  742. 

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

  744.                                 int line, int left,

  745.                                 uint8_t lru[3][8])

  746. {

  747.     int x, y;

  748. 

  749.     int width   = frame->width;

  750. 

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

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

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

  754. 

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

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

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

  758. 

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

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

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

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

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

  764.         }

  765. 

  766.         Y += ystride;

  767.         U += ustride;

  768.         V += vstride;

  769.     }

  770. 

  771.     return y;

  772. }

  773. 

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

  775.                                 const uint8_t *src, int src_size,

  776.                                 uint32_t vflipped)

  777. {

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

  779.                             dx2_decode_slice_444,

  780.                             default_setup_lru,

  781.                             AV_PIX_FMT_YUV444P, vflipped);

  782. }

  783. 

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

  785.                         AVPacket *avpkt)

  786. {

  787.     AVFrame *pic = data;

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

  789.     uint32_t type;

  790.     int vflipped, ret;

  791. 

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

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

  794.         return AVERROR_INVALIDDATA;

  795.     }

  796. 

  797.     type = AV_RB32(src);

  798.     vflipped = !!(type & 0x20);

  799. 

  800.     switch (type) {

  801.     case 0x01000021:

  802.     case 0x01000001:

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

  804.                                    AV_PIX_FMT_BGR24, 3, vflipped);

  805.         break;

  806.     case 0x01000029:

  807.     case 0x01000009:

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

  809.         break;

  810.     case 0x02000021:

  811.     case 0x02000001:

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

  813.         break;

  814.     case 0x02000029:

  815.     case 0x02000009:

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

  817.         break;

  818.     case 0x03000021:

  819.     case 0x03000001:

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

  821.         break;

  822.     case 0x03000029:

  823.     case 0x03000009:

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

  825.         break;

  826.     case 0x04000021:

  827.     case 0x04000001:

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

  829.         break;

  830.     case 0x04000029:

  831.     case 0x04000009:

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

  833.         break;

  834.     case 0x17000021:

  835.     case 0x17000001:

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

  837.                                    AV_PIX_FMT_RGB565LE, 2, vflipped);

  838.         break;

  839.     case 0x17000029:

  840.     case 0x17000009:

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

  842.         break;

  843.     case 0x18000021:

  844.     case 0x19000021:

  845.     case 0x18000001:

  846.     case 0x19000001:

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

  848.                                    AV_PIX_FMT_RGB555LE, 2, vflipped);

  849.         break;

  850.     case 0x18000029:

  851.     case 0x19000029:

  852.     case 0x18000009:

  853.     case 0x19000009:

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

  855.         break;

  856.     default:

  857.         avpriv_request_sample(avctx, "Frame header %"PRIX32, type);

  858.         return AVERROR_PATCHWELCOME;

  859.     }

  860. 

  861.     if (ret)

  862.         return ret;

  863. 

  864.     pic->pict_type = AV_PICTURE_TYPE_I;

  865.     pic->key_frame = 1;

  866.     *got_frame = 1;

  867. 

  868.     return avpkt->size;

  869. }

  870. 

  871. AVCodec ff_dxtory_decoder = {

  872.     .name           = "dxtory",

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

  874.     .type           = AVMEDIA_TYPE_VIDEO,

  875.     .id             = AV_CODEC_ID_DXTORY,

  876.     .decode         = decode_frame,

  877.     .capabilities   = AV_CODEC_CAP_DR1,

  878. };