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

887 lines
27KB
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. #include "thread.h"

  35. 

  36. static int64_t get_raw_size(enum AVPixelFormat fmt, int width, int height)

  37. {

  38.     switch (fmt) {

  39.     case AV_PIX_FMT_RGB555LE:

  40.     case AV_PIX_FMT_RGB565LE:

  41.         return width * height * 2LL;

  42.     case AV_PIX_FMT_RGB24:

  43.     case AV_PIX_FMT_BGR24:

  44.     case AV_PIX_FMT_YUV444P:

  45.         return width * height * 3LL;

  46.     case AV_PIX_FMT_YUV420P:

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

  48.     case AV_PIX_FMT_YUV410P:

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

  50.     }

  51. 

  52.     return 0;

  53. }

  54. 

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

  56. {

  57.     if (!vflip)

  58.         return;

  59. 

  60.     switch (pic->format) {

  61.     case AV_PIX_FMT_YUV444P:

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

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

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

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

  66.     case AV_PIX_FMT_RGB555LE:

  67.     case AV_PIX_FMT_RGB565LE:

  68.     case AV_PIX_FMT_BGR24:

  69.     case AV_PIX_FMT_RGB24:

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

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

  72.         break;

  73.     case AV_PIX_FMT_YUV410P:

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

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

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

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

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

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

  80.         break;

  81.     case AV_PIX_FMT_YUV420P:

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

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

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

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

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

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

  88.         break;

  89.     }

  90. }

  91. 

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

  93.                                 const uint8_t *src, int src_size,

  94.                                 int id, int bpp, uint32_t vflipped)

  95. {

  96.     ThreadFrame frame = { .f = pic };

  97.     int h;

  98.     uint8_t *dst;

  99.     int ret;

  100. 

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

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

  103.         return AVERROR_INVALIDDATA;

  104.     }

  105. 

  106.     avctx->pix_fmt = id;

  107.     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

  108.         return ret;

  109. 

  110.     do_vflip(avctx, pic, vflipped);

  111. 

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

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

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

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

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

  117.     }

  118. 

  119.     do_vflip(avctx, pic, vflipped);

  120. 

  121.     return 0;

  122. }

  123. 

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

  125.                                 const uint8_t *src, int src_size,

  126.                                 uint32_t vflipped)

  127. {

  128.     ThreadFrame frame = { .f = pic };

  129.     int h, w;

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

  131.     int height, width, hmargin, vmargin;

  132.     int huvborder;

  133.     int ret;

  134. 

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

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

  137.         return AVERROR_INVALIDDATA;

  138.     }

  139. 

  140.     avctx->pix_fmt = AV_PIX_FMT_YUV410P;

  141.     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

  142.         return ret;

  143. 

  144.     do_vflip(avctx, pic, vflipped);

  145. 

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

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

  148.     hmargin = avctx->width  - width;

  149.     vmargin = avctx->height - height;

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

  151. 

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

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

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

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

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

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

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

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

  160.             AV_COPY32U(Y1 + w, src);

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

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

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

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

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

  166.             src += 18;

  167.         }

  168.         if (hmargin) {

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

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

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

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

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

  174.             }

  175.             src += 4 * hmargin;

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

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

  178.             src += 2;

  179.         }

  180.         Y1 += pic->linesize[0] * 4;

  181.         Y2 += pic->linesize[0] * 4;

  182.         Y3 += pic->linesize[0] * 4;

  183.         Y4 += pic->linesize[0] * 4;

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

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

  186.     }

  187. 

  188.     if (vmargin) {

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

  190.             AV_COPY32U(Y1 + w, src);

  191.             if (vmargin > 1)

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

  193.             if (vmargin > 2)

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

  195.             src += 4 * vmargin;

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

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

  198.             src += 2;

  199.         }

  200.         if (hmargin) {

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

  202.                 AV_COPY32U(Y1 + w, src);

  203.                 if (vmargin > 1)

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

  205.                 if (vmargin > 2)

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

  207.                 src += 4 * vmargin;

  208.             }

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

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

  211.             src += 2;

  212.         }

  213.     }

  214. 

  215.     do_vflip(avctx, pic, vflipped);

  216. 

  217.     return 0;

  218. }

  219. 

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

  221.                                 const uint8_t *src, int src_size,

  222.                                 uint32_t vflipped)

  223. {

  224.     ThreadFrame frame = { .f = pic };

  225.     int h, w;

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

  227.     int height, width, hmargin, vmargin;

  228.     int huvborder;

  229.     int ret;

  230. 

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

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

  233.         return AVERROR_INVALIDDATA;

  234.     }

  235. 

  236.     avctx->pix_fmt = AV_PIX_FMT_YUV420P;

  237.     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

  238.         return ret;

  239. 

  240.     do_vflip(avctx, pic, vflipped);

  241. 

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

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

  244.     hmargin = avctx->width  - width;

  245.     vmargin = avctx->height - height;

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

  247. 

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

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

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

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

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

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

  254.             AV_COPY16(Y1 + w, src);

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

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

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

  258.             src += 6;

  259.         }

  260.         if (hmargin) {

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

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

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

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

  265.             src += 4;

  266.         }

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

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

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

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

  271.     }

  272. 

  273.     if (vmargin) {

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

  275.             AV_COPY16U(Y1 + w, src);

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

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

  278.             src += 4;

  279.         }

  280.         if (hmargin) {

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

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

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

  284.             src += 3;

  285.         }

  286.     }

  287. 

  288.     do_vflip(avctx, pic, vflipped);

  289. 

  290.     return 0;

  291. }

  292. 

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

  294.                                 const uint8_t *src, int src_size,

  295.                                 uint32_t vflipped)

  296. {

  297.     ThreadFrame frame = { .f = pic };

  298.     int h, w;

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

  300.     int ret;

  301. 

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

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

  304.         return AVERROR_INVALIDDATA;

  305.     }

  306. 

  307.     avctx->pix_fmt = AV_PIX_FMT_YUV444P;

  308.     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

  309.         return ret;

  310. 

  311.     do_vflip(avctx, pic, vflipped);

  312. 

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

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

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

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

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

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

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

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

  321.         }

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

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

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

  325.     }

  326. 

  327.     do_vflip(avctx, pic, vflipped);

  328. 

  329.     return 0;

  330. }

  331. 

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

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

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

  335. 

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

  337. {

  338.     uint8_t c, val;

  339. 

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

  341.     if (!c) {

  342.         val = get_bits(gb, 8);

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

  344.     } else {

  345.         val = lru[c - 1];

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

  347.     }

  348.     lru[0] = val;

  349. 

  350.     return val;

  351. }

  352. 

  353. static int check_slice_size(AVCodecContext *avctx,

  354.                             const uint8_t *src, int src_size,

  355.                             int slice_size, int off)

  356. {

  357.     int cur_slice_size;

  358. 

  359.     if (slice_size > src_size - off) {

  360.         av_log(avctx, AV_LOG_ERROR,

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

  362.                slice_size, src_size - off);

  363.         return AVERROR_INVALIDDATA;

  364.     }

  365.     if (slice_size <= 16) {

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

  367.                slice_size);

  368.         return AVERROR_INVALIDDATA;

  369.     }

  370. 

  371.     cur_slice_size = AV_RL32(src + off);

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

  373.         av_log(avctx, AV_LOG_ERROR,

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

  375.                cur_slice_size, slice_size - 16);

  376.     }

  377. 

  378.     return 0;

  379. }

  380. 

  381. static int load_buffer(AVCodecContext *avctx,

  382.                        const uint8_t *src, int src_size,

  383.                        GetByteContext *gb,

  384.                        int *nslices, int *off)

  385. {

  386.     bytestream2_init(gb, src, src_size);

  387.     *nslices = bytestream2_get_le16(gb);

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

  389.     if (src_size < *off) {

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

  391.         return AVERROR_INVALIDDATA;

  392.     }

  393. 

  394.     if (!*nslices) {

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

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

  397.         return AVERROR_PATCHWELCOME;

  398.     }

  399. 

  400.     return 0;

  401. }

  402. 

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

  404.                                      int bits)

  405. {

  406.     uint8_t c, val;

  407. 

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

  409.     if (!c) {

  410.         val = get_bits(gb, bits);

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

  412.     } else {

  413.         val = lru[c - 1];

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

  415.     }

  416.     lru[0] = val;

  417. 

  418.     return val;

  419. }

  420. 

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

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

  423. 

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

  425. 

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

  427.                             const uint8_t *src, int src_size,

  428.                             decode_slice_func decode_slice,

  429.                             setup_lru_func setup_lru,

  430.                             enum AVPixelFormat fmt,

  431.                             uint32_t vflipped)

  432. {

  433.     ThreadFrame frame = { .f = pic };

  434.     GetByteContext gb, gb_check;

  435.     GetBitContext  gb2;

  436.     int nslices, slice, line = 0;

  437.     uint32_t off, slice_size;

  438.     uint64_t off_check;

  439.     uint8_t lru[3][8];

  440.     int ret;

  441. 

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

  443.     if (ret < 0)

  444.         return ret;

  445. 

  446.     off_check = off;

  447.     gb_check = gb;

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

  449.         slice_size = bytestream2_get_le32(&gb_check);

  450. 

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

  452.             return AVERROR_INVALIDDATA;

  453.         off_check += slice_size;

  454.     }

  455. 

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

  457.         return AVERROR_INVALIDDATA;

  458. 

  459.     avctx->pix_fmt = fmt;

  460.     if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)

  461.         return ret;

  462. 

  463.     do_vflip(avctx, pic, vflipped);

  464. 

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

  466.         slice_size = bytestream2_get_le32(&gb);

  467. 

  468.         setup_lru(lru);

  469. 

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

  471.         if (ret < 0)

  472.             return ret;

  473. 

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

  475.             return ret;

  476. 

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

  478. 

  479.         off += slice_size;

  480.     }

  481. 

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

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

  484.     }

  485. 

  486.     do_vflip(avctx, pic, vflipped);

  487. 

  488.     return 0;

  489. }

  490. 

  491. av_always_inline

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

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

  494.                                 int is_565)

  495. {

  496.     int x, y;

  497.     int r, g, b;

  498.     int width    = frame->width;

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

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

  501. 

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

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

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

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

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

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

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

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

  510.         }

  511. 

  512.         dst += stride;

  513.     }

  514. 

  515.     return y;

  516. }

  517. 

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

  519. {

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

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

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

  523. }

  524. 

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

  526. {

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

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

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

  530. }

  531. 

  532. static int dx2_decode_slice_555(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, 0);

  536. }

  537. 

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

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

  540. {

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

  542. }

  543. 

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

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

  546.                                 uint32_t vflipped)

  547. {

  548.     enum AVPixelFormat fmt = AV_PIX_FMT_RGB24;

  549.     if (is_565)

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

  551.                                 dx2_decode_slice_565,

  552.                                 setup_lru_565,

  553.                                 fmt, vflipped);

  554.     else

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

  556.                                 dx2_decode_slice_555,

  557.                                 setup_lru_555,

  558.                                 fmt, vflipped);

  559. }

  560. 

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

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

  563. {

  564.     int x, y;

  565.     int width    = frame->width;

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

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

  568. 

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

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

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

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

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

  574.         }

  575. 

  576.         dst += stride;

  577.     }

  578. 

  579.     return y;

  580. }

  581. 

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

  583. {

  584.     int i;

  585. 

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

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

  588. }

  589. 

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

  591.                                 const uint8_t *src, int src_size,

  592.                                 uint32_t vflipped)

  593. {

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

  595.                             dx2_decode_slice_rgb,

  596.                             default_setup_lru,

  597.                             AV_PIX_FMT_BGR24, vflipped);

  598. }

  599. 

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

  601.                                 int line, int left,

  602.                                 uint8_t lru[3][8])

  603. {

  604.     int x, y, i, j;

  605.     int width   = frame->width;

  606. 

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

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

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

  610. 

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

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

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

  614. 

  615.     int h, w, hmargin, vmargin;

  616.     int huvborder;

  617. 

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

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

  620.     hmargin = frame->width  - w;

  621.     vmargin = frame->height - h;

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

  623. 

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

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

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

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

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

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

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

  631.         }

  632.         if (hmargin) {

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

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

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

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

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

  638.         }

  639. 

  640.         Y += ystride * 4;

  641.         U += ustride;

  642.         V += vstride;

  643.     }

  644. 

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

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

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

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

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

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

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

  652.         }

  653.         if (hmargin) {

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

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

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

  657.             }

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

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

  660.         }

  661. 

  662.         y += vmargin;

  663.     }

  664. 

  665.     return y;

  666. }

  667. 

  668. 

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

  670.                                 const uint8_t *src, int src_size,

  671.                                 uint32_t vflipped)

  672. {

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

  674.                             dx2_decode_slice_410,

  675.                             default_setup_lru,

  676.                             AV_PIX_FMT_YUV410P, vflipped);

  677. }

  678. 

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

  680.                                 int line, int left,

  681.                                 uint8_t lru[3][8])

  682. {

  683.     int x, y;

  684. 

  685.     int width    = frame->width;

  686. 

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

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

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

  690. 

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

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

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

  694. 

  695.     int h, w, hmargin, vmargin;

  696.     int huvborder;

  697. 

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

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

  700.     hmargin = frame->width  - w;

  701.     vmargin = frame->height - h;

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

  703. 

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

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

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

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

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

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

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

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

  712.         }

  713.         if (hmargin) {

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

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

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

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

  718.         }

  719. 

  720.         Y += ystride << 1;

  721.         U += ustride;

  722.         V += vstride;

  723.     }

  724. 

  725.     if (vmargin) {

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

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

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

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

  730.         }

  731.         if (hmargin) {

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

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

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

  735.         }

  736.     }

  737. 

  738.     return y;

  739. }

  740. 

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

  742.                                 const uint8_t *src, int src_size,

  743.                                 uint32_t vflipped)

  744. {

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

  746.                             dx2_decode_slice_420,

  747.                             default_setup_lru,

  748.                             AV_PIX_FMT_YUV420P, vflipped);

  749. }

  750. 

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

  752.                                 int line, int left,

  753.                                 uint8_t lru[3][8])

  754. {

  755.     int x, y;

  756. 

  757.     int width   = frame->width;

  758. 

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

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

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

  762. 

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

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

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

  766. 

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

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

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

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

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

  772.         }

  773. 

  774.         Y += ystride;

  775.         U += ustride;

  776.         V += vstride;

  777.     }

  778. 

  779.     return y;

  780. }

  781. 

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

  783.                                 const uint8_t *src, int src_size,

  784.                                 uint32_t vflipped)

  785. {

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

  787.                             dx2_decode_slice_444,

  788.                             default_setup_lru,

  789.                             AV_PIX_FMT_YUV444P, vflipped);

  790. }

  791. 

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

  793.                         AVPacket *avpkt)

  794. {

  795.     AVFrame *pic = data;

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

  797.     uint32_t type;

  798.     int vflipped, ret;

  799. 

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

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

  802.         return AVERROR_INVALIDDATA;

  803.     }

  804. 

  805.     type = AV_RB32(src);

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

  807. 

  808.     switch (type) {

  809.     case 0x01000021:

  810.     case 0x01000001:

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

  812.                                    AV_PIX_FMT_BGR24, 3, vflipped);

  813.         break;

  814.     case 0x01000029:

  815.     case 0x01000009:

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

  817.         break;

  818.     case 0x02000021:

  819.     case 0x02000001:

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

  821.         break;

  822.     case 0x02000029:

  823.     case 0x02000009:

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

  825.         break;

  826.     case 0x03000021:

  827.     case 0x03000001:

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

  829.         break;

  830.     case 0x03000029:

  831.     case 0x03000009:

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

  833.         break;

  834.     case 0x04000021:

  835.     case 0x04000001:

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

  837.         break;

  838.     case 0x04000029:

  839.     case 0x04000009:

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

  841.         break;

  842.     case 0x17000021:

  843.     case 0x17000001:

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

  845.                                    AV_PIX_FMT_RGB565LE, 2, vflipped);

  846.         break;

  847.     case 0x17000029:

  848.     case 0x17000009:

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

  850.         break;

  851.     case 0x18000021:

  852.     case 0x19000021:

  853.     case 0x18000001:

  854.     case 0x19000001:

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

  856.                                    AV_PIX_FMT_RGB555LE, 2, vflipped);

  857.         break;

  858.     case 0x18000029:

  859.     case 0x19000029:

  860.     case 0x18000009:

  861.     case 0x19000009:

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

  863.         break;

  864.     default:

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

  866.         return AVERROR_PATCHWELCOME;

  867.     }

  868. 

  869.     if (ret)

  870.         return ret;

  871. 

  872.     pic->pict_type = AV_PICTURE_TYPE_I;

  873.     pic->key_frame = 1;

  874.     *got_frame = 1;

  875. 

  876.     return avpkt->size;

  877. }

  878. 

  879. AVCodec ff_dxtory_decoder = {

  880.     .name           = "dxtory",

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

  882.     .type           = AVMEDIA_TYPE_VIDEO,

  883.     .id             = AV_CODEC_ID_DXTORY,

  884.     .decode         = decode_frame,

  885.     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

  886. };