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

473 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 "unary.h"

  35. 

  36. typedef struct YLCContext {

  37.     VLC vlc[4];

  38.     uint32_t table[1024];

  39.     uint8_t *table_bits;

  40.     uint8_t *bitstream_bits;

  41.     int table_bits_size;

  42.     int bitstream_bits_size;

  43.     BswapDSPContext bdsp;

  44. } YLCContext;

  45. 

  46. static av_cold int decode_init(AVCodecContext *avctx)

  47. {

  48.     YLCContext *s = avctx->priv_data;

  49. 

  50.     avctx->pix_fmt = AV_PIX_FMT_YUYV422;

  51.     ff_bswapdsp_init(&s->bdsp);

  52. 

  53.     return 0;

  54. }

  55. 

  56. typedef struct Node {

  57.     int16_t  sym;

  58.     int16_t  n0;

  59.     uint32_t count;

  60.     int16_t  l, r;

  61. } Node;

  62. 

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

  64.                            Node *nodes, int node,

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

  66. {

  67.     int s;

  68. 

  69.     s = nodes[node].sym;

  70.     if (s != -1) {

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

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

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

  74.         (*pos)++;

  75.     } else {

  76.         pfx <<= 1;

  77.         pl++;

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

  79.                        pos);

  80.         pfx |= 1;

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

  82.                        pos);

  83.     }

  84. }

  85. 

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

  87. {

  88.     Node nodes[512];

  89.     uint32_t bits[256];

  90.     int16_t lens[256];

  91.     uint8_t xlat[256];

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

  93. 

  94.     ff_free_vlc(vlc);

  95. 

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

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

  98.         nodes[i].sym   = i;

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

  100.         nodes[i].l     = i;

  101.         nodes[i].r     = i;

  102.     }

  103. 

  104.     cur_node = 256;

  105.     j = 0;

  106.     do {

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

  108.             int new_node = j;

  109.             int first_node = cur_node;

  110.             int second_node = cur_node;

  111.             int nd, st;

  112. 

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

  114. 

  115.             do {

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

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

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

  119.                         first_node = new_node;

  120.                     } else {

  121.                         first_node = second_node;

  122.                         second_node = new_node;

  123.                     }

  124.                 }

  125.                 new_node += 1;

  126.             } while (new_node != cur_node);

  127. 

  128.             if (first_node == cur_node)

  129.                 break;

  130. 

  131.             nd = nodes[second_node].count;

  132.             st = nodes[first_node].count;

  133.             nodes[second_node].count = 0;

  134.             nodes[first_node].count  = 0;

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

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

  137.             nodes[cur_node].n0 = cur_node;

  138.             nodes[cur_node].l = first_node;

  139.             nodes[cur_node].r = second_node;

  140.             cur_node++;

  141.         }

  142.         j++;

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

  144. 

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

  146. 

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

  148. }

  149. 

  150. static const uint8_t table_y1[] = {

  151.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

  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, 0xFF, 0xFF, 0xFF,

  157.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 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, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  163.     0x00, 0x00, 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, 0x01,

  168.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 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, 0x02, 0x02, 0x02, 0x02,

  174.     0x02, 0x02, 0x02, 0x02, 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, 0x00,

  180. };

  181. 

  182. static const uint8_t table_u[] = {

  183.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  198.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

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

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

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

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

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

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

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

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

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

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

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

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

  211.     0x01, 0x00,

  212. };

  213. 

  214. static const uint8_t table_y2[] = {

  215.     0xFC, 0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE,

  216.     0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFC,

  217.     0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE,

  218.     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFC, 0xFC,

  219.     0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFF,

  220.     0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFD, 0xFD, 0xFD,

  221.     0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00,

  222.     0x00, 0x01, 0x01, 0x01, 0xFD, 0xFD, 0xFD, 0xFE,

  223.     0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,

  224.     0x01, 0x01, 0x01, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE,

  225.     0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01,

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

  227.     0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02,

  228.     0x02, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00,

  229.     0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02,

  230.     0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00,

  231.     0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02, 0xFF,

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

  233.     0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0xFF, 0xFF,

  234.     0xFF, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02,

  235.     0x02, 0x02, 0x03, 0x03, 0x03, 0xFF, 0xFF, 0xFF,

  236.     0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02,

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

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

  239.     0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01,

  240.     0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04,

  241.     0x04, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,

  242.     0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04,

  243.     0x04, 0x00,

  244. };

  245. 

  246. static const uint8_t table_v[] = {

  247.     0xFF, 0x00, 0x01, 0xFF, 0x00, 0x01, 0xFF, 0x00,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  275.     0x01, 0x00,

  276. };

  277. 

  278. static int decode_frame(AVCodecContext *avctx,

  279.                         void *data, int *got_frame,

  280.                         AVPacket *avpkt)

  281. {

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

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

  284.     YLCContext *s = avctx->priv_data;

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

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

  287.     AVFrame * const p = data;

  288.     GetBitContext gb;

  289.     uint8_t *dst;

  290. 

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

  292.         return AVERROR_INVALIDDATA;

  293. 

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

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

  296.         return AVERROR_INVALIDDATA;

  297. 

  298.     toffset = AV_RL32(buf + 8);

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

  300.         return AVERROR_INVALIDDATA;

  301. 

  302.     boffset = AV_RL32(buf + 12);

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

  304.         return AVERROR_INVALIDDATA;

  305. 

  306.     if ((ret = ff_get_buffer(avctx, p, 0)) < 0)

  307.         return ret;

  308. 

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

  310.                    boffset - toffset + AV_INPUT_BUFFER_PADDING_SIZE);

  311.     if (!s->table_bits)

  312.         return AVERROR(ENOMEM);

  313. 

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

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

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

  317.                       (uint32_t *) s->table_bits,

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

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

  320.         return ret;

  321. 

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

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

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

  325. 

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

  327.     }

  328. 

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

  330.     if (ret < 0)

  331.         return ret;

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

  333.     if (ret < 0)

  334.         return ret;

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

  336.     if (ret < 0)

  337.         return ret;

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

  339.     if (ret < 0)

  340.         return ret;

  341. 

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

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

  344.     if (!s->bitstream_bits)

  345.         return AVERROR(ENOMEM);

  346. 

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

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

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

  350.                       (uint32_t *) s->bitstream_bits,

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

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

  353.         return ret;

  354. 

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

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

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

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

  359.     }

  360. 

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

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

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

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

  365.                 return AVERROR_INVALIDDATA;

  366. 

  367.             if (get_bits1(&gb)) {

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

  369.                 if (val < 0) {

  370.                     return AVERROR_INVALIDDATA;

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

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

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

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

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

  376.                     x += 4;

  377.                 } else {

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

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

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

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

  382.                         y += iy;

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

  384.                     } else {

  385.                         x += incr;

  386.                     }

  387.                 }

  388.             } else {

  389.                 int y1, y2, u, v;

  390. 

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

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

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

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

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

  396.                     return AVERROR_INVALIDDATA;

  397.                 dst[x    ] = y1;

  398.                 dst[x + 1] = u;

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

  400.                 dst[x + 3] = v;

  401.                 x += 4;

  402.             }

  403.         }

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

  405.     }

  406. 

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

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

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

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

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

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

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

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

  415.     }

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

  417. 

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

  419.         x = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  439.         }

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

  441.     }

  442. 

  443.     p->pict_type = AV_PICTURE_TYPE_I;

  444.     p->key_frame = 1;

  445.     *got_frame   = 1;

  446. 

  447.     return avpkt->size;

  448. }

  449. 

  450. static av_cold int decode_end(AVCodecContext *avctx)

  451. {

  452.     YLCContext *s = avctx->priv_data;

  453. 

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

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

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

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

  458. 

  459.     return 0;

  460. }

  461. 

  462. AVCodec ff_ylc_decoder = {

  463.     .name           = "ylc",

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

  465.     .type           = AVMEDIA_TYPE_VIDEO,

  466.     .id             = AV_CODEC_ID_YLC,

  467.     .priv_data_size = sizeof(YLCContext),

  468.     .init           = decode_init,

  469.     .close          = decode_end,

  470.     .decode         = decode_frame,

  471.     .capabilities   = AV_CODEC_CAP_DR1,

  472. };