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

503 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) & ((1U << 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.             unsigned 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.             if (nd >= UINT32_MAX - st) {

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

  138.                 return AVERROR_INVALIDDATA;

  139.             }

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

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

  142.             nodes[cur_node].n0 = cur_node;

  143.             nodes[cur_node].l = first_node;

  144.             nodes[cur_node].r = second_node;

  145.             cur_node++;

  146.         }

  147.         j++;

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

  149. 

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

  151. 

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

  153. }

  154. 

  155. static const uint8_t table_y1[] = {

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

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

  158.     0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE, 0xFE,

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

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

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

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

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

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

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

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

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

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

  169.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

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

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

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

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

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

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

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

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

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

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

  180.     0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,

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

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

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

  184.     0x02, 0x00,

  185. };

  186. 

  187. static const uint8_t table_u[] = {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  211.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

  212.     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00, 0x00,

  213.     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,

  214.     0x00, 0x00, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  215.     0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,

  216.     0x01, 0x00,

  217. };

  218. 

  219. static const uint8_t table_y2[] = {

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

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

  222.     0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE,

  223.     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFC, 0xFC,

  224.     0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE, 0xFF,

  225.     0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFD, 0xFD, 0xFD,

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

  227.     0x00, 0x01, 0x01, 0x01, 0xFD, 0xFD, 0xFD, 0xFE,

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

  229.     0x01, 0x01, 0x01, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE,

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

  231.     0x01, 0x01, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF,

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

  233.     0x02, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00,

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

  235.     0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00,

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

  237.     0xFF, 0xFF, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,

  238.     0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0xFF, 0xFF,

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

  240.     0x02, 0x02, 0x03, 0x03, 0x03, 0xFF, 0xFF, 0xFF,

  241.     0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02,

  242.     0x02, 0x03, 0x03, 0x03, 0x00, 0x00, 0x00, 0x01,

  243.     0x01, 0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03,

  244.     0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01,

  245.     0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04,

  246.     0x04, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,

  247.     0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04,

  248.     0x04, 0x00,

  249. };

  250. 

  251. static const uint8_t table_v[] = {

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

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

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

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

  281. };

  282. 

  283. static int decode_frame(AVCodecContext *avctx,

  284.                         void *data, int *got_frame,

  285.                         AVPacket *avpkt)

  286. {

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

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

  289.     YLCContext *s = avctx->priv_data;

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

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

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

  293.     AVFrame * const p = data;

  294.     GetBitContext gb;

  295.     uint8_t *dst;

  296. 

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

  298.         return AVERROR_INVALIDDATA;

  299. 

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

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

  302.         return AVERROR_INVALIDDATA;

  303. 

  304.     toffset = AV_RL32(buf + 8);

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

  306.         return AVERROR_INVALIDDATA;

  307. 

  308.     boffset = AV_RL32(buf + 12);

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

  310.         return AVERROR_INVALIDDATA;

  311. 

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

  313.         return ret;

  314. 

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

  316.                    boffset - toffset + AV_INPUT_BUFFER_PADDING_SIZE);

  317.     if (!s->table_bits)

  318.         return AVERROR(ENOMEM);

  319. 

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

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

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

  323.                       (uint32_t *) s->table_bits,

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

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

  326.         return ret;

  327. 

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

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

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

  331. 

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

  333.     }

  334. 

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

  336.     if (ret < 0)

  337.         return ret;

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

  339.     if (ret < 0)

  340.         return ret;

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

  342.     if (ret < 0)

  343.         return ret;

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

  345.     if (ret < 0)

  346.         return ret;

  347. 

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

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

  350.     if (!s->bitstream_bits)

  351.         return AVERROR(ENOMEM);

  352. 

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

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

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

  356.                       (uint32_t *) s->bitstream_bits,

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

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

  359.         return ret;

  360. 

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

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

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

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

  365.     }

  366. 

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

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

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

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

  371.                 return AVERROR_INVALIDDATA;

  372. 

  373.             if (get_bits1(&gb)) {

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

  375.                 if (val < 0) {

  376.                     return AVERROR_INVALIDDATA;

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

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

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

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

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

  382.                     x += 4;

  383.                 } else {

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

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

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

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

  388.                         y += iy;

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

  390.                     } else {

  391.                         x += incr;

  392.                     }

  393.                 }

  394.             } else {

  395.                 int y1, y2, u, v;

  396. 

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

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

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

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

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

  402.                     return AVERROR_INVALIDDATA;

  403.                 dst[x    ] = y1;

  404.                 dst[x + 1] = u;

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

  406.                 dst[x + 3] = v;

  407.                 x += 4;

  408.             }

  409.         }

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

  411.     }

  412. 

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

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

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

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

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

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

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

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

  421.     }

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

  423. 

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

  425.         x = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  445.         }

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

  447.     }

  448. 

  449.     p->pict_type = AV_PICTURE_TYPE_I;

  450.     p->key_frame = 1;

  451.     *got_frame   = 1;

  452. 

  453.     return avpkt->size;

  454. }

  455. 

  456. #if HAVE_THREADS

  457. static int init_thread_copy(AVCodecContext *avctx)

  458. {

  459.     YLCContext *s = avctx->priv_data;

  460. 

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

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

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

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

  465.     s->table_bits = NULL;

  466.     s->table_bits_size = 0;

  467.     s->bitstream_bits = NULL;

  468.     s->bitstream_bits_size = 0;

  469. 

  470.     return 0;

  471. }

  472. #endif

  473. 

  474. static av_cold int decode_end(AVCodecContext *avctx)

  475. {

  476.     YLCContext *s = avctx->priv_data;

  477. 

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

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

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

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

  482.     av_freep(&s->table_bits);

  483.     s->table_bits_size = 0;

  484.     av_freep(&s->bitstream_bits);

  485.     s->bitstream_bits_size = 0;

  486. 

  487.     return 0;

  488. }

  489. 

  490. AVCodec ff_ylc_decoder = {

  491.     .name           = "ylc",

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

  493.     .type           = AVMEDIA_TYPE_VIDEO,

  494.     .id             = AV_CODEC_ID_YLC,

  495.     .priv_data_size = sizeof(YLCContext),

  496.     .init           = decode_init,

  497.     .init_thread_copy = ONLY_IF_THREADS_ENABLED(init_thread_copy),

  498.     .close          = decode_end,

  499.     .decode         = decode_frame,

  500.     .capabilities   = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,

  501.     .caps_internal  = FF_CODEC_CAP_INIT_THREADSAFE,

  502. };