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

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

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

  137.                 return AVERROR_INVALIDDATA;

  138.             }

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

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

  141.             nodes[cur_node].n0 = cur_node;

  142.             nodes[cur_node].l = first_node;

  143.             nodes[cur_node].r = second_node;

  144.             cur_node++;

  145.         }

  146.         j++;

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

  148. 

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

  150. 

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

  152. }

  153. 

  154. static const uint8_t table_y1[] = {

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

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

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

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

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

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

  184. };

  185. 

  186. static const uint8_t table_u[] = {

  187.     0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  215.     0x01, 0x00,

  216. };

  217. 

  218. static const uint8_t table_y2[] = {

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

  220.     0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFC,

  221.     0xFC, 0xFC, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE, 0xFE,

  222.     0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFC, 0xFC,

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

  224.     0xFF, 0xFF, 0x00, 0x00, 0x00, 0xFD, 0xFD, 0xFD,

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

  226.     0x00, 0x01, 0x01, 0x01, 0xFD, 0xFD, 0xFD, 0xFE,

  227.     0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00,

  228.     0x01, 0x01, 0x01, 0xFD, 0xFD, 0xFD, 0xFE, 0xFE,

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

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

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

  232.     0x02, 0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00,

  233.     0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02, 0x02,

  234.     0xFE, 0xFE, 0xFE, 0xFF, 0xFF, 0xFF, 0x00, 0x00,

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

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

  237.     0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0xFF, 0xFF,

  238.     0xFF, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02,

  239.     0x02, 0x02, 0x03, 0x03, 0x03, 0xFF, 0xFF, 0xFF,

  240.     0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x02, 0x02,

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

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

  243.     0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01,

  244.     0x01, 0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04,

  245.     0x04, 0x04, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01,

  246.     0x02, 0x02, 0x02, 0x03, 0x03, 0x03, 0x04, 0x04,

  247.     0x04, 0x00,

  248. };

  249. 

  250. static const uint8_t table_v[] = {

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

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

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

  279.     0x01, 0x00,

  280. };

  281. 

  282. static int decode_frame(AVCodecContext *avctx,

  283.                         void *data, int *got_frame,

  284.                         AVPacket *avpkt)

  285. {

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

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

  288.     YLCContext *s = avctx->priv_data;

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

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

  291.     AVFrame * const p = data;

  292.     GetBitContext gb;

  293.     uint8_t *dst;

  294. 

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

  296.         return AVERROR_INVALIDDATA;

  297. 

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

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

  300.         return AVERROR_INVALIDDATA;

  301. 

  302.     toffset = AV_RL32(buf + 8);

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

  304.         return AVERROR_INVALIDDATA;

  305. 

  306.     boffset = AV_RL32(buf + 12);

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

  308.         return AVERROR_INVALIDDATA;

  309. 

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

  311.         return ret;

  312. 

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

  314.                    boffset - toffset + AV_INPUT_BUFFER_PADDING_SIZE);

  315.     if (!s->table_bits)

  316.         return AVERROR(ENOMEM);

  317. 

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

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

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

  321.                       (uint32_t *) s->table_bits,

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

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

  324.         return ret;

  325. 

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

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

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

  329. 

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

  331.     }

  332. 

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

  334.     if (ret < 0)

  335.         return ret;

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

  337.     if (ret < 0)

  338.         return ret;

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

  340.     if (ret < 0)

  341.         return ret;

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

  343.     if (ret < 0)

  344.         return ret;

  345. 

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

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

  348.     if (!s->bitstream_bits)

  349.         return AVERROR(ENOMEM);

  350. 

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

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

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

  354.                       (uint32_t *) s->bitstream_bits,

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

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

  357.         return ret;

  358. 

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

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

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

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

  363.     }

  364. 

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

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

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

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

  369.                 return AVERROR_INVALIDDATA;

  370. 

  371.             if (get_bits1(&gb)) {

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

  373.                 if (val < 0) {

  374.                     return AVERROR_INVALIDDATA;

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

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

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

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

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

  380.                     x += 4;

  381.                 } else {

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

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

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

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

  386.                         y += iy;

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

  388.                     } else {

  389.                         x += incr;

  390.                     }

  391.                 }

  392.             } else {

  393.                 int y1, y2, u, v;

  394. 

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

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

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

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

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

  400.                     return AVERROR_INVALIDDATA;

  401.                 dst[x    ] = y1;

  402.                 dst[x + 1] = u;

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

  404.                 dst[x + 3] = v;

  405.                 x += 4;

  406.             }

  407.         }

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

  409.     }

  410. 

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

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

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

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

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

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

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

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

  419.     }

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

  421. 

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

  423.         x = 0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  443.         }

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

  445.     }

  446. 

  447.     p->pict_type = AV_PICTURE_TYPE_I;

  448.     p->key_frame = 1;

  449.     *got_frame   = 1;

  450. 

  451.     return avpkt->size;

  452. }

  453. 

  454. static av_cold int decode_end(AVCodecContext *avctx)

  455. {

  456.     YLCContext *s = avctx->priv_data;

  457. 

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

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

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

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

  462. 

  463.     return 0;

  464. }

  465. 

  466. AVCodec ff_ylc_decoder = {

  467.     .name           = "ylc",

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

  469.     .type           = AVMEDIA_TYPE_VIDEO,

  470.     .id             = AV_CODEC_ID_YLC,

  471.     .priv_data_size = sizeof(YLCContext),

  472.     .init           = decode_init,

  473.     .close          = decode_end,

  474.     .decode         = decode_frame,

  475.     .capabilities   = AV_CODEC_CAP_DR1,

  476. };