FFmpeg  4.4.6
notchlc.c
Go to the documentation of this file.
1 /*
2  * NotchLC decoder
3  * Copyright (c) 2020 Paul B Mahol
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <string.h>
25 
26 #define BITSTREAM_READER_LE
27 #include "libavutil/intreadwrite.h"
28 #include "avcodec.h"
29 #include "bytestream.h"
30 #include "get_bits.h"
31 #include "internal.h"
32 #include "lzf.h"
33 #include "thread.h"
34 
35 typedef struct NotchLCContext {
36  unsigned compressed_size;
37  unsigned format;
38 
41 
44 
45  unsigned texture_size_x;
46  unsigned texture_size_y;
51  unsigned y_data_offset;
52  unsigned uv_data_offset;
53  unsigned y_data_size;
54  unsigned a_data_offset;
55  unsigned uv_count_offset;
56  unsigned a_count_size;
57  unsigned data_end;
58 
62 
64 {
67  avctx->colorspace = AVCOL_SPC_RGB;
70 
71  return 0;
72 }
73 
74 #define HISTORY_SIZE (64 * 1024)
75 
76 static int lz4_decompress(AVCodecContext *avctx,
77  GetByteContext *gb,
78  PutByteContext *pb)
79 {
80  unsigned reference_pos, match_length, delta, pos = 0;
81  uint8_t history[64 * 1024];
82 
83  while (bytestream2_get_bytes_left(gb) > 0) {
84  uint8_t token = bytestream2_get_byte(gb);
85  unsigned num_literals = token >> 4;
86 
87  if (num_literals == 15) {
88  unsigned char current;
89  do {
90  current = bytestream2_get_byte(gb);
91  num_literals += current;
92  } while (current == 255);
93  }
94 
95  if (bytestream2_get_bytes_left(gb) < num_literals)
96  return AVERROR_INVALIDDATA;
97 
98  if (pos + num_literals < HISTORY_SIZE) {
99  bytestream2_get_buffer(gb, history + pos, num_literals);
100  pos += num_literals;
101  } else {
102  while (num_literals-- > 0) {
103  history[pos++] = bytestream2_get_byte(gb);
104  if (pos == HISTORY_SIZE) {
105  bytestream2_put_buffer(pb, history, HISTORY_SIZE);
106  pos = 0;
107  }
108  }
109  }
110 
111  if (bytestream2_get_bytes_left(gb) <= 0)
112  break;
113 
114  delta = bytestream2_get_le16(gb);
115  if (delta == 0)
116  return 0;
117  match_length = 4 + (token & 0x0F);
118  if (match_length == 4 + 0x0F) {
119  uint8_t current;
120 
121  do {
122  current = bytestream2_get_byte(gb);
123  match_length += current;
124  } while (current == 255);
125  }
126  reference_pos = (pos >= delta) ? (pos - delta) : (HISTORY_SIZE + pos - delta);
127  if (pos + match_length < HISTORY_SIZE && reference_pos + match_length < HISTORY_SIZE) {
128  if (pos >= reference_pos + match_length || reference_pos >= pos + match_length) {
129  memcpy(history + pos, history + reference_pos, match_length);
130  pos += match_length;
131  } else {
132  while (match_length-- > 0)
133  history[pos++] = history[reference_pos++];
134  }
135  } else {
136  while (match_length-- > 0) {
137  history[pos++] = history[reference_pos++];
138  if (pos == HISTORY_SIZE) {
139  bytestream2_put_buffer(pb, history, HISTORY_SIZE);
140  pos = 0;
141  }
142  reference_pos %= HISTORY_SIZE;
143  }
144  }
145  }
146 
147  bytestream2_put_buffer(pb, history, pos);
148 
149  return bytestream2_tell_p(pb);
150 }
151 
153  unsigned uncompressed_size)
154 {
155  NotchLCContext *s = avctx->priv_data;
156  GetByteContext rgb, dgb, *gb = &s->gb;
158  int ylinesize, ulinesize, vlinesize, alinesize;
159  uint16_t *dsty, *dstu, *dstv, *dsta;
160  int ret;
161 
162  s->texture_size_x = bytestream2_get_le32(gb);
163  s->texture_size_y = bytestream2_get_le32(gb);
164 
165  ret = ff_set_dimensions(avctx, s->texture_size_x, s->texture_size_y);
166  if (ret < 0)
167  return ret;
168 
169  s->uv_offset_data_offset = bytestream2_get_le32(gb);
170  if (s->uv_offset_data_offset >= UINT_MAX / 4)
171  return AVERROR_INVALIDDATA;
172  s->uv_offset_data_offset *= 4;
173  if (s->uv_offset_data_offset >= uncompressed_size)
174  return AVERROR_INVALIDDATA;
175 
176  s->y_control_data_offset = bytestream2_get_le32(gb);
177  if (s->y_control_data_offset >= UINT_MAX / 4)
178  return AVERROR_INVALIDDATA;
179  s->y_control_data_offset *= 4;
180  if (s->y_control_data_offset >= uncompressed_size)
181  return AVERROR_INVALIDDATA;
182 
183  s->a_control_word_offset = bytestream2_get_le32(gb);
184  if (s->a_control_word_offset >= UINT_MAX / 4)
185  return AVERROR_INVALIDDATA;
186  s->a_control_word_offset *= 4;
187  if (s->a_control_word_offset >= uncompressed_size)
188  return AVERROR_INVALIDDATA;
189 
190  s->uv_data_offset = bytestream2_get_le32(gb);
191  if (s->uv_data_offset >= UINT_MAX / 4)
192  return AVERROR_INVALIDDATA;
193  s->uv_data_offset *= 4;
194  if (s->uv_data_offset >= uncompressed_size)
195  return AVERROR_INVALIDDATA;
196 
197  s->y_data_size = bytestream2_get_le32(gb);
198  if (s->y_data_size >= UINT_MAX / 4)
199  return AVERROR_INVALIDDATA;
200 
201  s->a_data_offset = bytestream2_get_le32(gb);
202  if (s->a_data_offset >= UINT_MAX / 4)
203  return AVERROR_INVALIDDATA;
204  s->a_data_offset *= 4;
205  if (s->a_data_offset >= uncompressed_size)
206  return AVERROR_INVALIDDATA;
207 
208  s->a_count_size = bytestream2_get_le32(gb);
209  if (s->a_count_size >= UINT_MAX / 4)
210  return AVERROR_INVALIDDATA;
211  s->a_count_size *= 4;
212  if (s->a_count_size >= uncompressed_size)
213  return AVERROR_INVALIDDATA;
214 
215  s->data_end = bytestream2_get_le32(gb);
216  if (s->data_end > uncompressed_size)
217  return AVERROR_INVALIDDATA;
218 
219  s->y_data_row_offsets = bytestream2_tell(gb);
220  if (s->data_end <= s->y_data_size)
221  return AVERROR_INVALIDDATA;
222  s->y_data_offset = s->data_end - s->y_data_size;
223  if (s->y_data_offset <= s->a_data_offset)
224  return AVERROR_INVALIDDATA;
225  s->uv_count_offset = s->y_data_offset - s->a_data_offset;
226 
227  if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
228  return ret;
229 
230  rgb = *gb;
231  dgb = *gb;
232  bytestream2_seek(&rgb, s->y_data_row_offsets, SEEK_SET);
233  bytestream2_seek(gb, s->y_control_data_offset, SEEK_SET);
234 
235  if (bytestream2_get_bytes_left(gb) < (avctx->height + 3) / 4 * ((avctx->width + 3) / 4) * 4)
236  return AVERROR_INVALIDDATA;
237 
238  dsty = (uint16_t *)p->data[0];
239  dsta = (uint16_t *)p->data[3];
240  ylinesize = p->linesize[0] / 2;
241  alinesize = p->linesize[3] / 2;
242 
243  for (int y = 0; y < avctx->height; y += 4) {
244  const unsigned row_offset = bytestream2_get_le32(&rgb);
245 
246  bytestream2_seek(&dgb, s->y_data_offset + row_offset, SEEK_SET);
247 
249  if (ret < 0)
250  return ret;
251  for (int x = 0; x < avctx->width; x += 4) {
252  unsigned item = bytestream2_get_le32(gb);
253  unsigned y_min = item & 4095;
254  unsigned y_max = (item >> 12) & 4095;
255  unsigned y_diff = y_max - y_min;
256  unsigned control[4];
257 
258  control[0] = (item >> 24) & 3;
259  control[1] = (item >> 26) & 3;
260  control[2] = (item >> 28) & 3;
261  control[3] = (item >> 30) & 3;
262 
263  for (int i = 0; i < 4; i++) {
264  const int nb_bits = control[i] + 1;
265  const int div = (1 << nb_bits) - 1;
266  const int add = div - 1;
267 
268  dsty[x + i * ylinesize + 0] = av_clip_uintp2(y_min + ((y_diff * get_bits(&bit, nb_bits) + add) / div), 12);
269  dsty[x + i * ylinesize + 1] = av_clip_uintp2(y_min + ((y_diff * get_bits(&bit, nb_bits) + add) / div), 12);
270  dsty[x + i * ylinesize + 2] = av_clip_uintp2(y_min + ((y_diff * get_bits(&bit, nb_bits) + add) / div), 12);
271  dsty[x + i * ylinesize + 3] = av_clip_uintp2(y_min + ((y_diff * get_bits(&bit, nb_bits) + add) / div), 12);
272  }
273  }
274 
275  dsty += 4 * ylinesize;
276  }
277 
278  rgb = *gb;
279  dgb = *gb;
280  bytestream2_seek(gb, s->a_control_word_offset, SEEK_SET);
281  if (s->uv_count_offset == s->a_control_word_offset) {
282  for (int y = 0; y < avctx->height; y++) {
283  for (int x = 0; x < avctx->width; x++)
284  dsta[x] = 4095;
285  dsta += alinesize;
286  }
287  } else {
288  if (bytestream2_get_bytes_left(gb) < (avctx->height + 15) / 16 * ((avctx->width + 15) / 16) * 8)
289  return AVERROR_INVALIDDATA;
290 
291  for (int y = 0; y < avctx->height; y += 16) {
292  for (int x = 0; x < avctx->width; x += 16) {
293  unsigned m = bytestream2_get_le32(gb);
294  unsigned offset = bytestream2_get_le32(gb);
295  unsigned alpha0, alpha1;
296  uint64_t control;
297 
298  if (offset >= UINT_MAX / 4)
299  return AVERROR_INVALIDDATA;
300  offset = offset * 4 + s->uv_data_offset + s->a_data_offset;
301  if (offset >= s->data_end)
302  return AVERROR_INVALIDDATA;
303 
304  bytestream2_seek(&dgb, offset, SEEK_SET);
305  control = bytestream2_get_le64(&dgb);
306  alpha0 = control & 0xFF;
307  alpha1 = (control >> 8) & 0xFF;
308  control = control >> 16;
309 
310  for (int by = 0; by < 4; by++) {
311  for (int bx = 0; bx < 4; bx++) {
312  switch (m & 3) {
313  case 0:
314  for (int i = 0; i < 4; i++) {
315  for (int j = 0; j < 4; j++) {
316  dsta[x + (i + by * 4) * alinesize + bx * 4 + j] = 0;
317  }
318  }
319  break;
320  case 1:
321  for (int i = 0; i < 4; i++) {
322  for (int j = 0; j < 4; j++) {
323  dsta[x + (i + by * 4) * alinesize + bx * 4 + j] = 4095;
324  }
325  }
326  break;
327  case 2:
328  for (int i = 0; i < 4; i++) {
329  for (int j = 0; j < 4; j++) {
330  dsta[x + (i + by * 4) * alinesize + bx * 4 + j] = (alpha0 + (alpha1 - alpha0) * (control & 7)) << 4;
331  }
332  }
333  break;
334  default:
335  return AVERROR_INVALIDDATA;
336  }
337 
338  control >>= 3;
339  m >>= 2;
340  }
341  }
342  }
343 
344  dsta += 16 * alinesize;
345  }
346  }
347 
348  bytestream2_seek(&rgb, s->uv_offset_data_offset, SEEK_SET);
349 
350  dstu = (uint16_t *)p->data[1];
351  dstv = (uint16_t *)p->data[2];
352  ulinesize = p->linesize[1] / 2;
353  vlinesize = p->linesize[2] / 2;
354 
355  for (int y = 0; y < avctx->height; y += 16) {
356  for (int x = 0; x < avctx->width; x += 16) {
357  unsigned offset = bytestream2_get_le32(&rgb) * 4;
358  int u[16][16] = { 0 }, v[16][16] = { 0 };
359  int u0, v0, u1, v1, udif, vdif;
360  unsigned escape, is8x8, loc;
361 
362  bytestream2_seek(&dgb, s->uv_data_offset + offset, SEEK_SET);
363 
364  is8x8 = bytestream2_get_le16(&dgb);
365  escape = bytestream2_get_le16(&dgb);
366 
367  if (escape == 0 && is8x8 == 0) {
368  u0 = bytestream2_get_byte(&dgb);
369  v0 = bytestream2_get_byte(&dgb);
370  u1 = bytestream2_get_byte(&dgb);
371  v1 = bytestream2_get_byte(&dgb);
372  loc = bytestream2_get_le32(&dgb);
373  u0 = (u0 << 4) | (u0 & 0xF);
374  v0 = (v0 << 4) | (v0 & 0xF);
375  u1 = (u1 << 4) | (u1 & 0xF);
376  v1 = (v1 << 4) | (v1 & 0xF);
377  udif = u1 - u0;
378  vdif = v1 - v0;
379 
380  for (int i = 0; i < 16; i += 4) {
381  for (int j = 0; j < 16; j += 4) {
382  for (int ii = 0; ii < 4; ii++) {
383  for (int jj = 0; jj < 4; jj++) {
384  u[i + ii][j + jj] = u0 + ((udif * (int)(loc & 3) + 2) / 3);
385  v[i + ii][j + jj] = v0 + ((vdif * (int)(loc & 3) + 2) / 3);
386  }
387  }
388 
389  loc >>= 2;
390  }
391  }
392  } else {
393  for (int i = 0; i < 16; i += 8) {
394  for (int j = 0; j < 16; j += 8) {
395  if (is8x8 & 1) {
396  u0 = bytestream2_get_byte(&dgb);
397  v0 = bytestream2_get_byte(&dgb);
398  u1 = bytestream2_get_byte(&dgb);
399  v1 = bytestream2_get_byte(&dgb);
400  loc = bytestream2_get_le32(&dgb);
401  u0 = (u0 << 4) | (u0 & 0xF);
402  v0 = (v0 << 4) | (v0 & 0xF);
403  u1 = (u1 << 4) | (u1 & 0xF);
404  v1 = (v1 << 4) | (v1 & 0xF);
405  udif = u1 - u0;
406  vdif = v1 - v0;
407 
408  for (int ii = 0; ii < 8; ii += 2) {
409  for (int jj = 0; jj < 8; jj += 2) {
410  for (int iii = 0; iii < 2; iii++) {
411  for (int jjj = 0; jjj < 2; jjj++) {
412  u[i + ii + iii][j + jj + jjj] = u0 + ((udif * (int)(loc & 3) + 2) / 3);
413  v[i + ii + iii][j + jj + jjj] = v0 + ((vdif * (int)(loc & 3) + 2) / 3);
414  }
415  }
416 
417  loc >>= 2;
418  }
419  }
420  } else if (escape) {
421  for (int ii = 0; ii < 8; ii += 4) {
422  for (int jj = 0; jj < 8; jj += 4) {
423  u0 = bytestream2_get_byte(&dgb);
424  v0 = bytestream2_get_byte(&dgb);
425  u1 = bytestream2_get_byte(&dgb);
426  v1 = bytestream2_get_byte(&dgb);
427  loc = bytestream2_get_le32(&dgb);
428  u0 = (u0 << 4) | (u0 & 0xF);
429  v0 = (v0 << 4) | (v0 & 0xF);
430  u1 = (u1 << 4) | (u1 & 0xF);
431  v1 = (v1 << 4) | (v1 & 0xF);
432  udif = u1 - u0;
433  vdif = v1 - v0;
434 
435  for (int iii = 0; iii < 4; iii++) {
436  for (int jjj = 0; jjj < 4; jjj++) {
437  u[i + ii + iii][j + jj + jjj] = u0 + ((udif * (int)(loc & 3) + 2) / 3);
438  v[i + ii + iii][j + jj + jjj] = v0 + ((vdif * (int)(loc & 3) + 2) / 3);
439 
440  loc >>= 2;
441  }
442  }
443  }
444  }
445  }
446 
447  is8x8 >>= 1;
448  }
449  }
450  }
451 
452  for (int i = 0; i < 16; i++) {
453  for (int j = 0; j < 16; j++) {
454  dstu[x + i * ulinesize + j] = u[i][j];
455  dstv[x + i * vlinesize + j] = v[i][j];
456  }
457  }
458  }
459 
460  dstu += 16 * ulinesize;
461  dstv += 16 * vlinesize;
462  }
463 
464  return 0;
465 }
466 
467 static int decode_frame(AVCodecContext *avctx,
468  void *data, int *got_frame,
469  AVPacket *avpkt)
470 {
471  NotchLCContext *s = avctx->priv_data;
472  ThreadFrame frame = { .f = data };
473  GetByteContext *gb = &s->gb;
474  PutByteContext *pb = &s->pb;
475  unsigned uncompressed_size;
476  AVFrame *p = data;
477  int ret;
478 
479  if (avpkt->size <= 40)
480  return AVERROR_INVALIDDATA;
481 
482  bytestream2_init(gb, avpkt->data, avpkt->size);
483 
484  if (bytestream2_get_le32(gb) != MKBETAG('N','L','C','1'))
485  return AVERROR_INVALIDDATA;
486 
487  uncompressed_size = bytestream2_get_le32(gb);
488  s->compressed_size = bytestream2_get_le32(gb);
489  s->format = bytestream2_get_le32(gb);
490 
491  if (s->format > 2)
492  return AVERROR_PATCHWELCOME;
493 
494  if (s->format == 0) {
495  ret = ff_lzf_uncompress(gb, &s->lzf_buffer, &s->lzf_size);
496  if (ret < 0)
497  return ret;
498 
499  if (uncompressed_size > s->lzf_size)
500  return AVERROR_INVALIDDATA;
501 
502  bytestream2_init(gb, s->lzf_buffer, uncompressed_size);
503  } else if (s->format == 1) {
504  if (bytestream2_get_bytes_left(gb) < uncompressed_size / 255)
505  return AVERROR_INVALIDDATA;
506 
507  av_fast_padded_malloc(&s->uncompressed_buffer, &s->uncompressed_size,
508  uncompressed_size);
509  if (!s->uncompressed_buffer)
510  return AVERROR(ENOMEM);
511 
512  bytestream2_init_writer(pb, s->uncompressed_buffer, s->uncompressed_size);
513 
514  ret = lz4_decompress(avctx, gb, pb);
515  if (ret != uncompressed_size)
516  return AVERROR_INVALIDDATA;
517 
518  bytestream2_init(gb, s->uncompressed_buffer, uncompressed_size);
519  }
520 
521  ret = decode_blocks(avctx, p, &frame, uncompressed_size);
522  if (ret < 0)
523  return ret;
524 
526  p->key_frame = 1;
527 
528  *got_frame = 1;
529 
530  return avpkt->size;
531 }
532 
534 {
535  NotchLCContext *s = avctx->priv_data;
536 
537  av_freep(&s->uncompressed_buffer);
538  s->uncompressed_size = 0;
539  av_freep(&s->lzf_buffer);
540  s->lzf_size = 0;
541 
542  return 0;
543 }
544 
546  .name = "notchlc",
547  .long_name = NULL_IF_CONFIG_SMALL("NotchLC"),
548  .type = AVMEDIA_TYPE_VIDEO,
549  .id = AV_CODEC_ID_NOTCHLC,
550  .priv_data_size = sizeof(NotchLCContext),
551  .init = decode_init,
552  .close = decode_end,
553  .decode = decode_frame,
555 };
#define av_cold
Definition: attributes.h:88
uint8_t
Libavcodec external API header.
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:147
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
Definition: bytestream.h:197
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:212
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:192
static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p, const uint8_t *src, unsigned int size)
Definition: bytestream.h:286
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:264
#define bit(string, value)
Definition: cbs_mpeg2.c:58
#define s(width, name)
Definition: cbs_vp9.c:257
#define MKBETAG(a, b, c, d)
Definition: common.h:479
#define av_clip_uintp2
Definition: common.h:146
long long int64_t
Definition: coverity.c:34
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
static AVFrame * frame
static float add(float src0, float src1)
int
bitstream reader API header.
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
@ AV_CODEC_ID_NOTCHLC
Definition: codec_id.h:301
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:50
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
#define AVERROR(e)
Definition: error.h:43
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
int i
Definition: input.c:407
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
Definition: utils.c:84
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
int ff_lzf_uncompress(GetByteContext *gb, uint8_t **buf, int64_t *size)
Definition: lzf.c:40
const char data[16]
Definition: mxf.c:142
#define HISTORY_SIZE
Definition: notchlc.c:74
AVCodec ff_notchlc_decoder
Definition: notchlc.c:545
static int decode_blocks(AVCodecContext *avctx, AVFrame *p, ThreadFrame *frame, unsigned uncompressed_size)
Definition: notchlc.c:152
static av_cold int decode_init(AVCodecContext *avctx)
Definition: notchlc.c:63
static av_cold int decode_end(AVCodecContext *avctx)
Definition: notchlc.c:533
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: notchlc.c:467
static int lz4_decompress(AVCodecContext *avctx, GetByteContext *gb, PutByteContext *pb)
Definition: notchlc.c:76
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:586
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
Definition: pixfmt.h:460
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:497
#define AV_PIX_FMT_YUVA444P12
Definition: pixfmt.h:440
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:513
FF_ENABLE_DEPRECATION_WARNINGS int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
#define v0
Definition: regdef.h:26
static const SheerTable rgb[2]
unsigned int pos
Definition: spdifenc.c:412
main external API structure.
Definition: avcodec.h:536
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:746
int width
picture width / height.
Definition: avcodec.h:709
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1171
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1150
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1164
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1157
void * priv_data
Definition: avcodec.h:563
AVCodec.
Definition: codec.h:197
const char * name
Name of the codec implementation.
Definition: codec.h:204
This structure describes decoded (raw) audio or video data.
Definition: frame.h:318
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:332
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:396
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:349
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:401
This structure stores compressed data.
Definition: packet.h:346
int size
Definition: packet.h:370
uint8_t * data
Definition: packet.h:369
const uint8_t * buffer
Definition: bytestream.h:34
uint8_t * uncompressed_buffer
Definition: notchlc.c:39
unsigned y_data_offset
Definition: notchlc.c:51
unsigned uncompressed_size
Definition: notchlc.c:40
unsigned a_count_size
Definition: notchlc.c:56
unsigned format
Definition: notchlc.c:37
unsigned texture_size_x
Definition: notchlc.c:45
unsigned y_control_data_offset
Definition: notchlc.c:49
unsigned uv_count_offset
Definition: notchlc.c:55
uint8_t * lzf_buffer
Definition: notchlc.c:42
PutByteContext pb
Definition: notchlc.c:60
unsigned uv_data_offset
Definition: notchlc.c:52
int64_t lzf_size
Definition: notchlc.c:43
GetByteContext gb
Definition: notchlc.c:59
unsigned uv_offset_data_offset
Definition: notchlc.c:48
unsigned texture_size_y
Definition: notchlc.c:46
unsigned a_data_offset
Definition: notchlc.c:54
unsigned y_data_row_offsets
Definition: notchlc.c:47
unsigned a_control_word_offset
Definition: notchlc.c:50
unsigned data_end
Definition: notchlc.c:57
unsigned y_data_size
Definition: notchlc.c:53
unsigned compressed_size
Definition: notchlc.c:36
Definition: rpzaenc.c:58
#define av_freep(p)
static const uint8_t offset[127][2]
Definition: vf_spp.c:107
float delta