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

881 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_RGB555LE:

  66.     case AV_PIX_FMT_RGB565LE:

  67.     case AV_PIX_FMT_BGR24:

  68.     case AV_PIX_FMT_RGB24:

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

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

  71.         break;

  72.     case AV_PIX_FMT_YUV410P:

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

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

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

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

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

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

  79.         break;

  80.     case AV_PIX_FMT_YUV420P:

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

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

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

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

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

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

  87.         break;

  88.     }

  89. }

  90. 

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

  92.                                 const uint8_t *src, int src_size,

  93.                                 int id, int bpp, uint32_t vflipped)

  94. {

  95.     int h;

  96.     uint8_t *dst;

  97.     int ret;

  98. 

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

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

  101.         return AVERROR_INVALIDDATA;

  102.     }

  103. 

  104.     avctx->pix_fmt = id;

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

  106.         return ret;

  107. 

  108.     do_vflip(avctx, pic, vflipped);

  109. 

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

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

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

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

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

  115.     }

  116. 

  117.     do_vflip(avctx, pic, vflipped);

  118. 

  119.     return 0;

  120. }

  121. 

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

  123.                                 const uint8_t *src, int src_size,

  124.                                 uint32_t vflipped)

  125. {

  126.     int h, w;

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

  128.     int height, width, hmargin, vmargin;

  129.     int huvborder;

  130.     int ret;

  131. 

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

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

  134.         return AVERROR_INVALIDDATA;

  135.     }

  136. 

  137.     avctx->pix_fmt = AV_PIX_FMT_YUV410P;

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

  139.         return ret;

  140. 

  141.     do_vflip(avctx, pic, vflipped);

  142. 

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

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

  145.     hmargin = avctx->width  - width;

  146.     vmargin = avctx->height - height;

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

  148. 

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

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

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

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

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

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

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

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

  157.             AV_COPY32U(Y1 + w, src);

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

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

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

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

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

  163.             src += 18;

  164.         }

  165.         if (hmargin) {

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

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

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

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

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

  171.             }

  172.             src += 4 * hmargin;

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

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

  175.             src += 2;

  176.         }

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

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

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

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

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

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

  183.     }

  184. 

  185.     if (vmargin) {

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

  187.             AV_COPY32U(Y1 + w, src);

  188.             if (vmargin > 1)

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

  190.             if (vmargin > 2)

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

  192.             src += 4 * vmargin;

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

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

  195.             src += 2;

  196.         }

  197.         if (hmargin) {

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

  199.                 AV_COPY32U(Y1 + w, src);

  200.                 if (vmargin > 1)

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

  202.                 if (vmargin > 2)

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

  204.                 src += 4 * vmargin;

  205.             }

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

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

  208.             src += 2;

  209.         }

  210.     }

  211. 

  212.     do_vflip(avctx, pic, vflipped);

  213. 

  214.     return 0;

  215. }

  216. 

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

  218.                                 const uint8_t *src, int src_size,

  219.                                 uint32_t vflipped)

  220. {

  221.     int h, w;

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

  223.     int height, width, hmargin, vmargin;

  224.     int huvborder;

  225.     int ret;

  226. 

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

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

  229.         return AVERROR_INVALIDDATA;

  230.     }

  231. 

  232.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;

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

  234.         return ret;

  235. 

  236.     do_vflip(avctx, pic, vflipped);

  237. 

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

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

  240.     hmargin = avctx->width  - width;

  241.     vmargin = avctx->height - height;

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

  243. 

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

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

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

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

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

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

  250.             AV_COPY16(Y1 + w, src);

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

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

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

  254.             src += 6;

  255.         }

  256.         if (hmargin) {

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

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

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

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

  261.             src += 4;

  262.         }

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

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

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

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

  267.     }

  268. 

  269.     if (vmargin) {

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

  271.             AV_COPY16U(Y1 + w, src);

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

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

  274.             src += 4;

  275.         }

  276.         if (hmargin) {

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

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

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

  280.             src += 3;

  281.         }

  282.     }

  283. 

  284.     do_vflip(avctx, pic, vflipped);

  285. 

  286.     return 0;

  287. }

  288. 

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

  290.                                 const uint8_t *src, int src_size,

  291.                                 uint32_t vflipped)

  292. {

  293.     int h, w;

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

  295.     int ret;

  296. 

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

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

  299.         return AVERROR_INVALIDDATA;

  300.     }

  301. 

  302.     avctx->pix_fmt = AV_PIX_FMT_YUV444P;

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

  304.         return ret;

  305. 

  306.     do_vflip(avctx, pic, vflipped);

  307. 

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

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

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

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

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

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

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

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

  316.         }

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

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

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

  320.     }

  321. 

  322.     do_vflip(avctx, pic, vflipped);

  323. 

  324.     return 0;

  325. }

  326. 

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

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

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

  330. 

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

  332. {

  333.     uint8_t c, val;

  334. 

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

  336.     if (!c) {

  337.         val = get_bits(gb, 8);

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

  339.     } else {

  340.         val = lru[c - 1];

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

  342.     }

  343.     lru[0] = val;

  344. 

  345.     return val;

  346. }

  347. 

  348. static int check_slice_size(AVCodecContext *avctx,

  349.                             const uint8_t *src, int src_size,

  350.                             int slice_size, int off)

  351. {

  352.     int cur_slice_size;

  353. 

  354.     if (slice_size > src_size - off) {

  355.         av_log(avctx, AV_LOG_ERROR,

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

  357.                slice_size, src_size - off);

  358.         return AVERROR_INVALIDDATA;

  359.     }

  360.     if (slice_size <= 16) {

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

  362.                slice_size);

  363.         return AVERROR_INVALIDDATA;

  364.     }

  365. 

  366.     cur_slice_size = AV_RL32(src + off);

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

  368.         av_log(avctx, AV_LOG_ERROR,

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

  370.                cur_slice_size, slice_size - 16);

  371.     }

  372. 

  373.     return 0;

  374. }

  375. 

  376. static int load_buffer(AVCodecContext *avctx,

  377.                        const uint8_t *src, int src_size,

  378.                        GetByteContext *gb,

  379.                        int *nslices, int *off)

  380. {

  381.     bytestream2_init(gb, src, src_size);

  382.     *nslices = bytestream2_get_le16(gb);

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

  384.     if (src_size < *off) {

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

  386.         return AVERROR_INVALIDDATA;

  387.     }

  388. 

  389.     if (!*nslices) {

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

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

  392.         return AVERROR_PATCHWELCOME;

  393.     }

  394. 

  395.     return 0;

  396. }

  397. 

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

  399.                                      int bits)

  400. {

  401.     uint8_t c, val;

  402. 

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

  404.     if (!c) {

  405.         val = get_bits(gb, bits);

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

  407.     } else {

  408.         val = lru[c - 1];

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

  410.     }

  411.     lru[0] = val;

  412. 

  413.     return val;

  414. }

  415. 

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

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

  418. 

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

  420. 

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

  422.                             const uint8_t *src, int src_size,

  423.                             decode_slice_func decode_slice,

  424.                             setup_lru_func setup_lru,

  425.                             enum AVPixelFormat fmt,

  426.                             uint32_t vflipped)

  427. {

  428.     GetByteContext gb, gb_check;

  429.     GetBitContext  gb2;

  430.     int nslices, slice, line = 0;

  431.     uint32_t off, slice_size;

  432.     uint64_t off_check;

  433.     uint8_t lru[3][8];

  434.     int ret;

  435. 

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

  437.     if (ret < 0)

  438.         return ret;

  439. 

  440.     off_check = off;

  441.     gb_check = gb;

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

  443.         slice_size = bytestream2_get_le32(&gb_check);

  444. 

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

  446.             return AVERROR_INVALIDDATA;

  447.         off_check += slice_size;

  448.     }

  449. 

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

  451.         return AVERROR_INVALIDDATA;

  452. 

  453.     avctx->pix_fmt = fmt;

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

  455.         return ret;

  456. 

  457.     do_vflip(avctx, pic, vflipped);

  458. 

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

  460.         slice_size = bytestream2_get_le32(&gb);

  461. 

  462.         setup_lru(lru);

  463. 

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

  465.         if (ret < 0)

  466.             return ret;

  467. 

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

  469.             return ret;

  470. 

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

  472. 

  473.         off += slice_size;

  474.     }

  475. 

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

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

  478.     }

  479. 

  480.     do_vflip(avctx, pic, vflipped);

  481. 

  482.     return 0;

  483. }

  484. 

  485. av_always_inline

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

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

  488.                                 int is_565)

  489. {

  490.     int x, y;

  491.     int r, g, b;

  492.     int width    = frame->width;

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

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

  495. 

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

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

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

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

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

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

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

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

  504.         }

  505. 

  506.         dst += stride;

  507.     }

  508. 

  509.     return y;

  510. }

  511. 

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

  513. {

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

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

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

  517. }

  518. 

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

  520. {

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

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

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

  524. }

  525. 

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

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

  528. {

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

  530. }

  531. 

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

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

  534. {

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

  536. }

  537. 

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

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

  540.                                 uint32_t vflipped)

  541. {

  542.     enum AVPixelFormat fmt = AV_PIX_FMT_RGB24;

  543.     if (is_565)

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

  545.                                 dx2_decode_slice_565,

  546.                                 setup_lru_565,

  547.                                 fmt, vflipped);

  548.     else

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

  550.                                 dx2_decode_slice_555,

  551.                                 setup_lru_555,

  552.                                 fmt, vflipped);

  553. }

  554. 

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

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

  557. {

  558.     int x, y;

  559.     int width    = frame->width;

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

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

  562. 

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

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

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

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

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

  568.         }

  569. 

  570.         dst += stride;

  571.     }

  572. 

  573.     return y;

  574. }

  575. 

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

  577. {

  578.     int i;

  579. 

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

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

  582. }

  583. 

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

  585.                                 const uint8_t *src, int src_size,

  586.                                 uint32_t vflipped)

  587. {

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

  589.                             dx2_decode_slice_rgb,

  590.                             default_setup_lru,

  591.                             AV_PIX_FMT_BGR24, vflipped);

  592. }

  593. 

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

  595.                                 int line, int left,

  596.                                 uint8_t lru[3][8])

  597. {

  598.     int x, y, i, j;

  599.     int width   = frame->width;

  600. 

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

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

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

  604. 

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

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

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

  608. 

  609.     int h, w, hmargin, vmargin;

  610.     int huvborder;

  611. 

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

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

  614.     hmargin = frame->width  - w;

  615.     vmargin = frame->height - h;

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

  617. 

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

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

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

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

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

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

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

  625.         }

  626.         if (hmargin) {

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

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

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

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

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

  632.         }

  633. 

  634.         Y += ystride << 2;

  635.         U += ustride;

  636.         V += vstride;

  637.     }

  638. 

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

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

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

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

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

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

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

  646.         }

  647.         if (hmargin) {

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

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

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

  651.             }

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

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

  654.         }

  655. 

  656.         y += vmargin;

  657.     }

  658. 

  659.     return y;

  660. }

  661. 

  662. 

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

  664.                                 const uint8_t *src, int src_size,

  665.                                 uint32_t vflipped)

  666. {

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

  668.                             dx2_decode_slice_410,

  669.                             default_setup_lru,

  670.                             AV_PIX_FMT_YUV410P, vflipped);

  671. }

  672. 

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

  674.                                 int line, int left,

  675.                                 uint8_t lru[3][8])

  676. {

  677.     int x, y;

  678. 

  679.     int width    = frame->width;

  680. 

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

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

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

  684. 

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

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

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

  688. 

  689.     int h, w, hmargin, vmargin;

  690.     int huvborder;

  691. 

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

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

  694.     hmargin = frame->width  - w;

  695.     vmargin = frame->height - h;

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

  697. 

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

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

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

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

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

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

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

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

  706.         }

  707.         if (hmargin) {

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

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

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

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

  712.         }

  713. 

  714.         Y += ystride << 1;

  715.         U += ustride;

  716.         V += vstride;

  717.     }

  718. 

  719.     if (vmargin) {

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

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

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

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

  724.         }

  725.         if (hmargin) {

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

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

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

  729.         }

  730.     }

  731. 

  732.     return y;

  733. }

  734. 

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

  736.                                 const uint8_t *src, int src_size,

  737.                                 uint32_t vflipped)

  738. {

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

  740.                             dx2_decode_slice_420,

  741.                             default_setup_lru,

  742.                             AV_PIX_FMT_YUV420P, vflipped);

  743. }

  744. 

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

  746.                                 int line, int left,

  747.                                 uint8_t lru[3][8])

  748. {

  749.     int x, y;

  750. 

  751.     int width   = frame->width;

  752. 

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

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

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

  756. 

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

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

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

  760. 

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

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

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

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

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

  766.         }

  767. 

  768.         Y += ystride;

  769.         U += ustride;

  770.         V += vstride;

  771.     }

  772. 

  773.     return y;

  774. }

  775. 

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

  777.                                 const uint8_t *src, int src_size,

  778.                                 uint32_t vflipped)

  779. {

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

  781.                             dx2_decode_slice_444,

  782.                             default_setup_lru,

  783.                             AV_PIX_FMT_YUV444P, vflipped);

  784. }

  785. 

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

  787.                         AVPacket *avpkt)

  788. {

  789.     AVFrame *pic = data;

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

  791.     uint32_t type;

  792.     int vflipped, ret;

  793. 

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

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

  796.         return AVERROR_INVALIDDATA;

  797.     }

  798. 

  799.     type = AV_RB32(src);

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

  801. 

  802.     switch (type) {

  803.     case 0x01000021:

  804.     case 0x01000001:

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

  806.                                    AV_PIX_FMT_BGR24, 3, vflipped);

  807.         break;

  808.     case 0x01000029:

  809.     case 0x01000009:

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

  811.         break;

  812.     case 0x02000021:

  813.     case 0x02000001:

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

  815.         break;

  816.     case 0x02000029:

  817.     case 0x02000009:

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

  819.         break;

  820.     case 0x03000021:

  821.     case 0x03000001:

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

  823.         break;

  824.     case 0x03000029:

  825.     case 0x03000009:

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

  827.         break;

  828.     case 0x04000021:

  829.     case 0x04000001:

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

  831.         break;

  832.     case 0x04000029:

  833.     case 0x04000009:

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

  835.         break;

  836.     case 0x17000021:

  837.     case 0x17000001:

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

  839.                                    AV_PIX_FMT_RGB565LE, 2, vflipped);

  840.         break;

  841.     case 0x17000029:

  842.     case 0x17000009:

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

  844.         break;

  845.     case 0x18000021:

  846.     case 0x19000021:

  847.     case 0x18000001:

  848.     case 0x19000001:

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

  850.                                    AV_PIX_FMT_RGB555LE, 2, vflipped);

  851.         break;

  852.     case 0x18000029:

  853.     case 0x19000029:

  854.     case 0x18000009:

  855.     case 0x19000009:

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

  857.         break;

  858.     default:

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

  860.         return AVERROR_PATCHWELCOME;

  861.     }

  862. 

  863.     if (ret)

  864.         return ret;

  865. 

  866.     pic->pict_type = AV_PICTURE_TYPE_I;

  867.     pic->key_frame = 1;

  868.     *got_frame = 1;

  869. 

  870.     return avpkt->size;

  871. }

  872. 

  873. AVCodec ff_dxtory_decoder = {

  874.     .name           = "dxtory",

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

  876.     .type           = AVMEDIA_TYPE_VIDEO,

  877.     .id             = AV_CODEC_ID_DXTORY,

  878.     .decode         = decode_frame,

  879.     .capabilities   = AV_CODEC_CAP_DR1,

  880. };