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.
82942 Commits
32 Branches
312MB
Tree: 2f347c17d6
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '2f347c17d6'
${ noResults }
FFmpeg/libavcodec/ylc.c

499 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. #include "libavutil/imgutils.h"

  26. #include "libavutil/internal.h"

  27. #include "libavutil/intreadwrite.h"

  28. #include "libavutil/mem.h"

  29. #include "avcodec.h"

  30. #include "bswapdsp.h"

  31. #include "get_bits.h"

  32. #include "huffyuvdsp.h"

  33. #include "internal.h"

  34. #include "thread.h"

  35. #include "unary.h"

  36. 

  37. typedef struct YLCContext {

  38.     VLC vlc[4];

  39.     uint32_t table[1024];

  40.     uint8_t *table_bits;

  41.     uint8_t *bitstream_bits;

  42.     int table_bits_size;

  43.     int bitstream_bits_size;

  44.     BswapDSPContext bdsp;

  45. } YLCContext;

  46. 

  47. static av_cold int decode_init(AVCodecContext *avctx)

  48. {

  49.     YLCContext *s = avctx->priv_data;

  50. 

  51.     avctx->pix_fmt = AV_PIX_FMT_YUYV422;

  52.     ff_bswapdsp_init(&s->bdsp);

  53. 

  54.     return 0;

  55. }

  56. 

  57. typedef struct Node {

  58.     int16_t  sym;

  59.     int16_t  n0;

  60.     uint32_t count;

  61.     int16_t  l, r;

  62. } Node;

  63. 

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

  65.                            Node *nodes, int node,

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

  67. {

  68.     int s;

  69. 

  70.     s = nodes[node].sym;

  71.     if (s != -1) {

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

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

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

  75.         (*pos)++;

  76.     } else {

  77.         pfx <<= 1;

  78.         pl++;

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

  80.                        pos);

  81.         pfx |= 1;

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

  83.                        pos);

  84.     }

  85. }

  86. 

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

  88. {

  89.     Node nodes[512];

  90.     uint32_t bits[256];

  91.     int16_t lens[256];

  92.     uint8_t xlat[256];

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

  94. 

  95.     ff_free_vlc(vlc);

  96. 

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

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

  99.         nodes[i].sym   = i;

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

  101.         nodes[i].l     = i;

  102.         nodes[i].r     = i;

  103.     }

  104. 

  105.     cur_node = 256;

  106.     j = 0;

  107.     do {

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

  109.             int new_node = j;

  110.             int first_node = cur_node;

  111.             int second_node = cur_node;

  112.             int nd, st;

  113. 

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

  115. 

  116.             do {

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

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

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

  120.                         first_node = new_node;

  121.                     } else {

  122.                         first_node = second_node;

  123.                         second_node = new_node;

  124.                     }

  125.                 }

  126.                 new_node += 1;

  127.             } while (new_node != cur_node);

  128. 

  129.             if (first_node == cur_node)

  130.                 break;

  131. 

  132.             nd = nodes[second_node].count;

  133.             st = nodes[first_node].count;

  134.             nodes[second_node].count = 0;

  135.             nodes[first_node].count  = 0;

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

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

  138.             nodes[cur_node].n0 = cur_node;

  139.             nodes[cur_node].l = first_node;

  140.             nodes[cur_node].r = second_node;

  141.             cur_node++;

  142.         }

  143.         j++;

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

  145. 

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

  147. 

  148.     return ff_init_vlc_sparse(vlc, 10, pos, lens, 2, 2, bits, 4, 4, xlat, 1, 1, 0);

  149. }

  150. 

  151. static const uint8_t table_y1[] = {

  152.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

  153.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

  154.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

  155.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

  156.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

  157.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF,

  158.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  159.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  160.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  161.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  162.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  163.     0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  164.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  165.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  166.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  167.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  168.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,

  169.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  170.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  171.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  172.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  173.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  174.     0x01, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0x02,

  175.     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,

  176.     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,

  177.     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,

  178.     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,

  179.     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,

  180.     0x02, 0x00,

  181. };

  182. 

  183. static const uint8_t table_u[] = {

  184.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  185.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00,

  186.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  187.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01,

  188.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  189.     0x01, 0x01, 0x01, 0x01, 0x01, 0xFF, 0xFF, 0xFF,

  190.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

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

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

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

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

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

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

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

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

  199.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  200.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0xFF,

  201.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  202.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00,

  203.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  204.     0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,

  205.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

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

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

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

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

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

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

  212.     0x01, 0x00,

  213. };

  214. 

  215. static const uint8_t table_y2[] = {

  216.     0xFC, 0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE,

  217.     0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFC,

  218.     0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE,

  219.     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFC, 0xFC,

  220.     0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFF,

  221.     0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFD, 0xFD, 0xFD,

  222.     0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00,

  223.     0x00, 0x01, 0x01, 0x01, 0xFD, 0xFD, 0xFD, 0xFE,

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

  225.     0x01, 0x01, 0x01, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE,

  226.     0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01,

  227.     0x01, 0x01, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF,

  228.     0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02,

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

  230.     0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02,

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

  232.     0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0xFF,

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

  234.     0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0xFF, 0xFF,

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

  236.     0x02, 0x02, 0x03, 0x03, 0x03, 0xFF, 0xFF, 0xFF,

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

  238.     0x02, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x01,

  239.     0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03,

  240.     0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01,

  241.     0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04,

  242.     0x04, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,

  243.     0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04,

  244.     0x04, 0x00,

  245. };

  246. 

  247. static const uint8_t table_v[] = {

  248.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  249.     0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF,

  250.     0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01,

  251.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

  252.     0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF,

  253.     0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01,

  254.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  276.     0x01, 0x00,

  277. };

  278. 

  279. static int decode_frame(AVCodecContext *avctx,

  280.                         void *data, int *got_frame,

  281.                         AVPacket *avpkt)

  282. {

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

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

  285.     YLCContext *s = avctx->priv_data;

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

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

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

  289.     AVFrame * const p = data;

  290.     GetBitContext gb;

  291.     uint8_t *dst;

  292. 

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

  294.         return AVERROR_INVALIDDATA;

  295. 

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

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

  298.         return AVERROR_INVALIDDATA;

  299. 

  300.     toffset = AV_RL32(buf + 8);

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

  302.         return AVERROR_INVALIDDATA;

  303. 

  304.     boffset = AV_RL32(buf + 12);

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

  306.         return AVERROR_INVALIDDATA;

  307. 

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

  309.         return ret;

  310. 

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

  312.                    boffset - toffset + AV_INPUT_BUFFER_PADDING_SIZE);

  313.     if (!s->table_bits)

  314.         return AVERROR(ENOMEM);

  315. 

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

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

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

  319.                       (uint32_t *) s->table_bits,

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

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

  322.         return ret;

  323. 

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

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

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

  327. 

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

  329.     }

  330. 

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

  332.     if (ret < 0)

  333.         return ret;

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

  335.     if (ret < 0)

  336.         return ret;

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

  338.     if (ret < 0)

  339.         return ret;

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

  341.     if (ret < 0)

  342.         return ret;

  343. 

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

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

  346.     if (!s->bitstream_bits)

  347.         return AVERROR(ENOMEM);

  348. 

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

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

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

  352.                       (uint32_t *) s->bitstream_bits,

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

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

  355.         return ret;

  356. 

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

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

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

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

  361.     }

  362. 

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

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

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

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

  367.                 return AVERROR_INVALIDDATA;

  368. 

  369.             if (get_bits1(&gb)) {

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

  371.                 if (val < 0) {

  372.                     return AVERROR_INVALIDDATA;

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

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

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

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

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

  378.                     x += 4;

  379.                 } else {

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

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

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

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

  384.                         y += iy;

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

  386.                     } else {

  387.                         x += incr;

  388.                     }

  389.                 }

  390.             } else {

  391.                 int y1, y2, u, v;

  392. 

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

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

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

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

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

  398.                     return AVERROR_INVALIDDATA;

  399.                 dst[x    ] = y1;

  400.                 dst[x + 1] = u;

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

  402.                 dst[x + 3] = v;

  403.                 x += 4;

  404.             }

  405.         }

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

  407.     }

  408. 

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

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

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

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

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

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

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

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

  417.     }

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

  419. 

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

  421.         x = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  441.         }

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

  443.     }

  444. 

  445.     p->pict_type = AV_PICTURE_TYPE_I;

  446.     p->key_frame = 1;

  447.     *got_frame   = 1;

  448. 

  449.     return avpkt->size;

  450. }

  451. 

  452. #if HAVE_THREADS

  453. static int init_thread_copy(AVCodecContext *avctx)

  454. {

  455.     YLCContext *s = avctx->priv_data;

  456. 

  457.     memset(&s->vlc[0], 0, sizeof(VLC));

  458.     memset(&s->vlc[1], 0, sizeof(VLC));

  459.     memset(&s->vlc[2], 0, sizeof(VLC));

  460.     memset(&s->vlc[3], 0, sizeof(VLC));

  461.     s->table_bits = NULL;

  462.     s->table_bits_size = 0;

  463.     s->bitstream_bits = NULL;

  464.     s->bitstream_bits_size = 0;

  465. 

  466.     return 0;

  467. }

  468. #endif

  469. 

  470. static av_cold int decode_end(AVCodecContext *avctx)

  471. {

  472.     YLCContext *s = avctx->priv_data;

  473. 

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

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

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

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

  478.     av_freep(&s->table_bits);

  479.     s->table_bits_size = 0;

  480.     av_freep(&s->bitstream_bits);

  481.     s->bitstream_bits_size = 0;

  482. 

  483.     return 0;

  484. }

  485. 

  486. AVCodec ff_ylc_decoder = {

  487.     .name           = "ylc",

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

  489.     .type           = AVMEDIA_TYPE_VIDEO,

  490.     .id             = AV_CODEC_ID_YLC,

  491.     .priv_data_size = sizeof(YLCContext),

  492.     .init           = decode_init,

  493.     .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),

  494.     .close          = decode_end,

  495.     .decode         = decode_frame,

  496.     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

  497.     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,

  498. };