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.
101359 Commits
32 Branches
1.9GB
Tree: ee50f72715
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'ee50f72715'
${ noResults }
FFmpeg/libavcodec/ylc.c

487 lines
17KB
Raw Blame History 

  1. /*

  2.  * YUY2 Lossless Codec

  3.  *

  4.  * This file is part of FFmpeg.

  5.  *

  6.  * FFmpeg is free software; you can redistribute it and/or

  7.  * modify it under the terms of the GNU Lesser General Public

  8.  * License as published by the Free Software Foundation; either

  9.  * version 2.1 of the License, or (at your option) any later version.

  10.  *

  11.  * FFmpeg is distributed in the hope that it will be useful,

  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of

  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  14.  * Lesser General Public License for more details.

  15.  *

  16.  * You should have received a copy of the GNU Lesser General Public

  17.  * License along with FFmpeg; if not, write to the Free Software

  18.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

  19.  */

  20. 

  21. #include <stdio.h>

  22. #include <stdlib.h>

  23. #include <string.h>

  24. 

  25. #define YLC_VLC_BITS 10

  26. 

  27. #include "libavutil/imgutils.h"

  28. #include "libavutil/internal.h"

  29. #include "libavutil/intreadwrite.h"

  30. #include "libavutil/mem.h"

  31. #include "avcodec.h"

  32. #include "bswapdsp.h"

  33. #include "get_bits.h"

  34. #include "huffyuvdsp.h"

  35. #include "internal.h"

  36. #include "thread.h"

  37. #include "unary.h"

  38. 

  39. typedef struct YLCContext {

  40.     VLC vlc[4];

  41.     uint32_t table[1024];

  42.     uint8_t *table_bits;

  43.     uint8_t *bitstream_bits;

  44.     int table_bits_size;

  45.     int bitstream_bits_size;

  46.     BswapDSPContext bdsp;

  47. } YLCContext;

  48. 

  49. static av_cold int decode_init(AVCodecContext *avctx)

  50. {

  51.     YLCContext *s = avctx->priv_data;

  52. 

  53.     avctx->pix_fmt = AV_PIX_FMT_YUYV422;

  54.     ff_bswapdsp_init(&s->bdsp);

  55. 

  56.     return 0;

  57. }

  58. 

  59. typedef struct Node {

  60.     int16_t  sym;

  61.     int16_t  n0;

  62.     uint32_t count;

  63.     int16_t  l, r;

  64. } Node;

  65. 

  66. static void get_tree_codes(uint32_t *bits, int16_t *lens, uint8_t *xlat,

  67.                            Node *nodes, int node,

  68.                            uint32_t pfx, int pl, int *pos)

  69. {

  70.     int s;

  71. 

  72.     s = nodes[node].sym;

  73.     if (s != -1) {

  74.         bits[*pos] = (~pfx) & ((1ULL << FFMAX(pl, 1)) - 1);

  75.         lens[*pos] = FFMAX(pl, 1);

  76.         xlat[*pos] = s + (pl == 0);

  77.         (*pos)++;

  78.     } else {

  79.         pfx <<= 1;

  80.         pl++;

  81.         get_tree_codes(bits, lens, xlat, nodes, nodes[node].l, pfx, pl,

  82.                        pos);

  83.         pfx |= 1;

  84.         get_tree_codes(bits, lens, xlat, nodes, nodes[node].r, pfx, pl,

  85.                        pos);

  86.     }

  87. }

  88. 

  89. static int build_vlc(AVCodecContext *avctx, VLC *vlc, const uint32_t *table)

  90. {

  91.     Node nodes[512];

  92.     uint32_t bits[256];

  93.     int16_t lens[256];

  94.     uint8_t xlat[256];

  95.     int cur_node, i, j, pos = 0;

  96. 

  97.     ff_free_vlc(vlc);

  98. 

  99.     for (i = 0; i < 256; i++) {

  100.         nodes[i].count = table[i];

  101.         nodes[i].sym   = i;

  102.         nodes[i].n0    = -2;

  103.         nodes[i].l     = i;

  104.         nodes[i].r     = i;

  105.     }

  106. 

  107.     cur_node = 256;

  108.     j = 0;

  109.     do {

  110.         for (i = 0; ; i++) {

  111.             int new_node = j;

  112.             int first_node = cur_node;

  113.             int second_node = cur_node;

  114.             unsigned nd, st;

  115. 

  116.             nodes[cur_node].count = -1;

  117. 

  118.             do {

  119.                 int val = nodes[new_node].count;

  120.                 if (val && (val < nodes[first_node].count)) {

  121.                     if (val >= nodes[second_node].count) {

  122.                         first_node = new_node;

  123.                     } else {

  124.                         first_node = second_node;

  125.                         second_node = new_node;

  126.                     }

  127.                 }

  128.                 new_node += 1;

  129.             } while (new_node != cur_node);

  130. 

  131.             if (first_node == cur_node)

  132.                 break;

  133. 

  134.             nd = nodes[second_node].count;

  135.             st = nodes[first_node].count;

  136.             nodes[second_node].count = 0;

  137.             nodes[first_node].count  = 0;

  138.             if (nd >= UINT32_MAX - st) {

  139.                 av_log(avctx, AV_LOG_ERROR, "count overflow\n");

  140.                 return AVERROR_INVALIDDATA;

  141.             }

  142.             nodes[cur_node].count = nd + st;

  143.             nodes[cur_node].sym = -1;

  144.             nodes[cur_node].n0 = cur_node;

  145.             nodes[cur_node].l = first_node;

  146.             nodes[cur_node].r = second_node;

  147.             cur_node++;

  148.         }

  149.         j++;

  150.     } while (cur_node - 256 == j);

  151. 

  152.     get_tree_codes(bits, lens, xlat, nodes, cur_node - 1, 0, 0, &pos);

  153. 

  154.     return ff_init_vlc_sparse(vlc, YLC_VLC_BITS, pos, lens, 2, 2,

  155.                               bits, 4, 4, xlat, 1, 1, 0);

  156. }

  157. 

  158. static const uint8_t table_y1[] = {

  159.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

  160.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

  161.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

  162.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

  163.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

  164.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF,

  165.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  166.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  167.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  168.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  169.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  170.     0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  171.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  172.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  173.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  174.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  175.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,

  176.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  177.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  178.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  179.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  180.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  181.     0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02,

  182.     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,

  183.     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,

  184.     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,

  185.     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,

  186.     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,

  187.     0x02, 0x00,

  188. };

  189. 

  190. static const uint8_t table_u[] = {

  191.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  192.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,

  193.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  194.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,

  195.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  196.     0x01, 0x01, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0xFF,

  197.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  198.     0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00,

  199.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  200.     0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01,

  201.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  202.     0x01, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  203.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  204.     0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  205.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  206.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  207.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xFF,

  208.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  209.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,

  210.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  211.     0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,

  212.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  213.     0x01, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0xFF, 0xFF,

  214.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  215.     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,

  216.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  217.     0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  218.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  219.     0x01, 0x00,

  220. };

  221. 

  222. static const uint8_t table_y2[] = {

  223.     0xFC, 0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE,

  224.     0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFC,

  225.     0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE,

  226.     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFC, 0xFC,

  227.     0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFF,

  228.     0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFD, 0xFD, 0xFD,

  229.     0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00,

  230.     0x00, 0x01, 0x01, 0x01, 0xFD, 0xFD, 0xFD, 0xFE,

  231.     0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,

  232.     0x01, 0x01, 0x01, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE,

  233.     0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01,

  234.     0x01, 0x01, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF,

  235.     0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02,

  236.     0x02, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00,

  237.     0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02,

  238.     0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00,

  239.     0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0xFF,

  240.     0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,

  241.     0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0xFF, 0xFF,

  242.     0xFF, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02,

  243.     0x02, 0x02, 0x03, 0x03, 0x03, 0xFF, 0xFF, 0xFF,

  244.     0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02,

  245.     0x02, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x01,

  246.     0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03,

  247.     0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01,

  248.     0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04,

  249.     0x04, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,

  250.     0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04,

  251.     0x04, 0x00,

  252. };

  253. 

  254. static const uint8_t table_v[] = {

  255.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  256.     0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF,

  257.     0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01,

  258.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  259.     0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF,

  260.     0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01,

  261.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  262.     0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF,

  263.     0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01,

  264.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  265.     0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF,

  266.     0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01,

  267.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  268.     0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF,

  269.     0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01,

  270.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  271.     0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF,

  272.     0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01,

  273.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  274.     0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF,

  275.     0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01,

  276.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  277.     0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF,

  278.     0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01,

  279.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  280.     0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF,

  281.     0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01,

  282.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  283.     0x01, 0x00,

  284. };

  285. 

  286. static int decode_frame(AVCodecContext *avctx,

  287.                         void *data, int *got_frame,

  288.                         AVPacket *avpkt)

  289. {

  290.     int TL[4] = { 128, 128, 128, 128 };

  291.     int L[4]  = { 128, 128, 128, 128 };

  292.     YLCContext *s = avctx->priv_data;

  293.     ThreadFrame frame = { .f = data };

  294.     const uint8_t *buf = avpkt->data;

  295.     int ret, x, y, toffset, boffset;

  296.     AVFrame * const p = data;

  297.     GetBitContext gb;

  298.     uint8_t *dst;

  299. 

  300.     if (avpkt->size <= 16)

  301.         return AVERROR_INVALIDDATA;

  302. 

  303.     if (AV_RL32(buf) != MKTAG('Y', 'L', 'C', '0') ||

  304.         AV_RL32(buf + 4) != 0)

  305.         return AVERROR_INVALIDDATA;

  306. 

  307.     toffset = AV_RL32(buf + 8);

  308.     if (toffset < 16 || toffset >= avpkt->size)

  309.         return AVERROR_INVALIDDATA;

  310. 

  311.     boffset = AV_RL32(buf + 12);

  312.     if (toffset >= boffset || boffset >= avpkt->size)

  313.         return AVERROR_INVALIDDATA;

  314. 

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

  316.         return ret;

  317. 

  318.     av_fast_malloc(&s->table_bits, &s->table_bits_size,

  319.                    boffset - toffset + AV_INPUT_BUFFER_PADDING_SIZE);

  320.     if (!s->table_bits)

  321.         return AVERROR(ENOMEM);

  322. 

  323.     memcpy(s->table_bits, avpkt->data + toffset, boffset - toffset);

  324.     memset(s->table_bits + boffset - toffset, 0, AV_INPUT_BUFFER_PADDING_SIZE);

  325.     s->bdsp.bswap_buf((uint32_t *) s->table_bits,

  326.                       (uint32_t *) s->table_bits,

  327.                       (boffset - toffset + 3) >> 2);

  328.     if ((ret = init_get_bits8(&gb, s->table_bits, boffset - toffset)) < 0)

  329.         return ret;

  330. 

  331.     for (x = 0; x < 1024; x++) {

  332.         unsigned len = get_unary(&gb, 1, 31);

  333.         uint32_t val = ((1U << len) - 1) + get_bits_long(&gb, len);

  334. 

  335.         s->table[x] = val;

  336.     }

  337. 

  338.     ret = build_vlc(avctx, &s->vlc[0], &s->table[0  ]);

  339.     if (ret < 0)

  340.         return ret;

  341.     ret = build_vlc(avctx, &s->vlc[1], &s->table[256]);

  342.     if (ret < 0)

  343.         return ret;

  344.     ret = build_vlc(avctx, &s->vlc[2], &s->table[512]);

  345.     if (ret < 0)

  346.         return ret;

  347.     ret = build_vlc(avctx, &s->vlc[3], &s->table[768]);

  348.     if (ret < 0)

  349.         return ret;

  350. 

  351.     av_fast_malloc(&s->bitstream_bits, &s->bitstream_bits_size,

  352.                    avpkt->size - boffset + AV_INPUT_BUFFER_PADDING_SIZE);

  353.     if (!s->bitstream_bits)

  354.         return AVERROR(ENOMEM);

  355. 

  356.     memcpy(s->bitstream_bits, avpkt->data + boffset, avpkt->size - boffset);

  357.     memset(s->bitstream_bits + avpkt->size - boffset, 0, AV_INPUT_BUFFER_PADDING_SIZE);

  358.     s->bdsp.bswap_buf((uint32_t *) s->bitstream_bits,

  359.                       (uint32_t *) s->bitstream_bits,

  360.                       (avpkt->size - boffset) >> 2);

  361.     if ((ret = init_get_bits8(&gb, s->bitstream_bits, avpkt->size - boffset)) < 0)

  362.         return ret;

  363. 

  364.     dst = p->data[0];

  365.     for (y = 0; y < avctx->height; y++) {

  366.         memset(dst, 0, avctx->width * 2);

  367.         dst += p->linesize[0];

  368.     }

  369. 

  370.     dst = p->data[0];

  371.     for (y = 0; y < avctx->height; y++) {

  372.         for (x = 0; x < avctx->width * 2 && y < avctx->height;) {

  373.             if (get_bits_left(&gb) <= 0)

  374.                 return AVERROR_INVALIDDATA;

  375. 

  376.             if (get_bits1(&gb)) {

  377.                 int val = get_vlc2(&gb, s->vlc[0].table, YLC_VLC_BITS, 3);

  378.                 if (val < 0) {

  379.                     return AVERROR_INVALIDDATA;

  380.                 } else if (val < 0xE1) {

  381.                     dst[x    ] = table_y1[val];

  382.                     dst[x + 1] = table_u[val];

  383.                     dst[x + 2] = table_y2[val];

  384.                     dst[x + 3] = table_v[val];

  385.                     x += 4;

  386.                 } else {

  387.                     int incr = (val - 0xDF) * 4;

  388.                     if (x + incr >= avctx->width * 2) {

  389.                         int iy = ((x + incr) / (avctx->width * 2));

  390.                         x  = (x + incr) % (avctx->width * 2);

  391.                         y += iy;

  392.                         dst += iy * p->linesize[0];

  393.                     } else {

  394.                         x += incr;

  395.                     }

  396.                 }

  397.             } else {

  398.                 int y1, y2, u, v;

  399. 

  400.                 y1 = get_vlc2(&gb, s->vlc[1].table, YLC_VLC_BITS, 3);

  401.                 u  = get_vlc2(&gb, s->vlc[2].table, YLC_VLC_BITS, 3);

  402.                 y2 = get_vlc2(&gb, s->vlc[1].table, YLC_VLC_BITS, 3);

  403.                 v  = get_vlc2(&gb, s->vlc[3].table, YLC_VLC_BITS, 3);

  404.                 if (y1 < 0 || y2 < 0 || u < 0 || v < 0)

  405.                     return AVERROR_INVALIDDATA;

  406.                 dst[x    ] = y1;

  407.                 dst[x + 1] = u;

  408.                 dst[x + 2] = y1 + y2;

  409.                 dst[x + 3] = v;

  410.                 x += 4;

  411.             }

  412.         }

  413.         dst += p->linesize[0];

  414.     }

  415. 

  416.     dst = p->data[0];

  417.     for (x = 0; x < avctx->width * 2; x += 4) {

  418.         dst[x    ] =        dst[x    ] + L[0];

  419.         dst[x + 2] = L[0] = dst[x + 2] + L[0];

  420.         L[1] = dst[x + 1] + L[1];

  421.         dst[x + 1] = L[1];

  422.         L[2] = dst[x + 3] + L[2];

  423.         dst[x + 3] = L[2];

  424.     }

  425.     dst += p->linesize[0];

  426. 

  427.     for (y = 1; y < avctx->height; y++) {

  428.         x = 0;

  429.         dst[x    ] =        dst[x    ] + L[0] + dst[x + 0 - p->linesize[0]] - TL[0];

  430.         dst[x + 2] = L[0] = dst[x + 2] + L[0] + dst[x + 2 - p->linesize[0]] - TL[0];

  431.         TL[0] = dst[x + 2 - p->linesize[0]];

  432.         L[1] = dst[x + 1] + L[1] + dst[x + 1 - p->linesize[0]] - TL[1];

  433.         dst[x + 1] = L[1];

  434.         TL[1] = dst[x + 1 - p->linesize[0]];

  435.         L[2] = dst[x + 3] + L[2] + dst[x + 3 - p->linesize[0]] - TL[2];

  436.         dst[x + 3] = L[2];

  437.         TL[2] = dst[x + 3 - p->linesize[0]];

  438.         for (x = 4; x < avctx->width * 2; x += 4) {

  439.             dst[x    ] =        dst[x    ] + L[0] + dst[x + 0 - p->linesize[0]] - TL[0];

  440.             dst[x + 2] = L[0] = dst[x + 2] + L[0] + dst[x + 2 - p->linesize[0]] - TL[0];

  441.             TL[0] = dst[x + 2 - p->linesize[0]];

  442.             L[1] = dst[x + 1] + L[1] + dst[x + 1 - p->linesize[0]] - TL[1];

  443.             dst[x + 1] = L[1];

  444.             TL[1] = dst[x + 1 - p->linesize[0]];

  445.             L[2] = dst[x + 3] + L[2] + dst[x + 3 - p->linesize[0]] - TL[2];

  446.             dst[x + 3] = L[2];

  447.             TL[2] = dst[x + 3 - p->linesize[0]];

  448.         }

  449.         dst += p->linesize[0];

  450.     }

  451. 

  452.     p->pict_type = AV_PICTURE_TYPE_I;

  453.     p->key_frame = 1;

  454.     *got_frame   = 1;

  455. 

  456.     return avpkt->size;

  457. }

  458. 

  459. static av_cold int decode_end(AVCodecContext *avctx)

  460. {

  461.     YLCContext *s = avctx->priv_data;

  462. 

  463.     ff_free_vlc(&s->vlc[0]);

  464.     ff_free_vlc(&s->vlc[1]);

  465.     ff_free_vlc(&s->vlc[2]);

  466.     ff_free_vlc(&s->vlc[3]);

  467.     av_freep(&s->table_bits);

  468.     s->table_bits_size = 0;

  469.     av_freep(&s->bitstream_bits);

  470.     s->bitstream_bits_size = 0;

  471. 

  472.     return 0;

  473. }

  474. 

  475. AVCodec ff_ylc_decoder = {

  476.     .name           = "ylc",

  477.     .long_name      = NULL_IF_CONFIG_SMALL("YUY2 Lossless Codec"),

  478.     .type           = AVMEDIA_TYPE_VIDEO,

  479.     .id             = AV_CODEC_ID_YLC,

  480.     .priv_data_size = sizeof(YLCContext),

  481.     .init           = decode_init,

  482.     .close          = decode_end,

  483.     .decode         = decode_frame,

  484.     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

  485.     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,

  486. };