FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ylc.c
Go to the documentation of this file.
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];
44 } YLCContext;
45 
47 {
48  YLCContext *s = avctx->priv_data;
49 
50  avctx->pix_fmt = AV_PIX_FMT_YUYV422;
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 
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 
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 
444  p->key_frame = 1;
445  *got_frame = 1;
446 
447  return avpkt->size;
448 }
449 
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 
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 };
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
const char const char void * val
Definition: avisynth_c.h:634
const char * s
Definition: avisynth_c.h:631
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
uint32_t table[1024]
Definition: ylc.c:38
static av_cold int decode_init(AVCodecContext *avctx)
Definition: ylc.c:46
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
static const uint8_t table_y1[]
Definition: ylc.c:150
misc image utilities
memory handling functions
static const uint8_t table_y2[]
Definition: ylc.c:214
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
int ff_init_vlc_sparse(VLC *vlc_arg, int nb_bits, int nb_codes, const void *bits, int bits_wrap, int bits_size, const void *codes, int codes_wrap, int codes_size, const void *symbols, int symbols_wrap, int symbols_size, int flags)
Definition: bitstream.c:275
int table_bits_size
Definition: ylc.c:41
int size
Definition: avcodec.h:1581
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1877
static const uint8_t table_u[]
Definition: ylc.c:182
Definition: ylc.c:36
AVCodec.
Definition: avcodec.h:3542
Definition: huffman.h:32
static const uint8_t table_v[]
Definition: ylc.c:246
uint8_t bits
Definition: crc.c:296
uint8_t
#define av_cold
Definition: attributes.h:82
static av_cold int decode_end(AVCodecContext *avctx)
Definition: ylc.c:450
uint8_t * data
Definition: avcodec.h:1580
bitstream reader API header.
uint8_t * table_bits
Definition: ylc.c:39
#define U(x)
Definition: vp56_arith.h:37
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: ylc.c:278
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:568
#define AVERROR(e)
Definition: error.h:43
static const struct endianess table[]
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
VLC vlc[4]
Definition: ylc.c:37
const char * r
Definition: vf_curves.c:107
uint8_t * bitstream_bits
Definition: ylc.c:40
const char * name
Name of the codec implementation.
Definition: avcodec.h:3549
GLsizei count
Definition: opengl_enc.c:109
#define FFMAX(a, b)
Definition: common.h:94
Definition: vlc.h:26
int16_t r
Definition: ylc.c:60
static void get_tree_codes(uint32_t *bits, int16_t *lens, uint8_t *xlat, Node *nodes, int node, uint32_t pfx, int pl, int *pos)
Definition: ylc.c:63
common internal API header
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:258
int16_t l
Definition: ylc.c:60
int width
picture width / height.
Definition: avcodec.h:1836
static av_always_inline int get_vlc2(GetBitContext *s, VLC_TYPE(*table)[2], int bits, int max_depth)
Parse a vlc code.
Definition: get_bits.h:535
#define L(x)
Definition: vp56_arith.h:36
int bits
Definition: vlc.h:27
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:215
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:437
main external API structure.
Definition: avcodec.h:1649
int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags)
Get a buffer for a frame.
Definition: utils.c:928
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:63
void * buf
Definition: avisynth_c.h:553
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:299
int16_t n0
Definition: huffman.h:34
#define u(width,...)
int16_t sym
Definition: huffman.h:33
static unsigned int get_bits_long(GetBitContext *s, int n)
Read 0-32 bits.
Definition: get_bits.h:332
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:722
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:499
BswapDSPContext bdsp
Definition: ylc.c:43
common internal api header.
static int get_unary(GetBitContext *gb, int stop, int len)
Get unary code of limited length.
Definition: unary.h:33
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:731
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1691
int len
VLC_TYPE(* table)[2]
code, bits
Definition: vlc.h:28
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:253
uint32_t count
Definition: huffman.h:35
int bitstream_bits_size
Definition: ylc.c:42
#define MKTAG(a, b, c, d)
Definition: common.h:342
AVCodec ff_ylc_decoder
Definition: ylc.c:462
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
static int build_vlc(AVCodecContext *avctx, VLC *vlc, const uint32_t *table)
Definition: ylc.c:86
This structure stores compressed data.
Definition: avcodec.h:1557
void ff_free_vlc(VLC *vlc)
Definition: bitstream.c:360
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: avcodec.h:956