FFmpeg  4.3.8
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 uv_count_size;
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,
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 (pos + num_literals < HISTORY_SIZE) {
96  bytestream2_get_buffer(gb, history + pos, num_literals);
97  pos += num_literals;
98  } else {
99  while (num_literals-- > 0) {
100  history[pos++] = bytestream2_get_byte(gb);
101  if (pos == HISTORY_SIZE) {
102  bytestream2_put_buffer(pb, history, HISTORY_SIZE);
103  pos = 0;
104  }
105  }
106  }
107 
108  if (bytestream2_get_bytes_left(gb) <= 0)
109  break;
110 
111  delta = bytestream2_get_byte(gb);
112  delta |= (unsigned)bytestream2_get_byte(gb) << 8;
113  if (delta == 0)
114  return 0;
115  match_length = 4 + (token & 0x0F);
116  if (match_length == 4 + 0x0F) {
117  uint8_t current;
118 
119  do {
120  current = bytestream2_get_byte(gb);
121  match_length += current;
122  } while (current == 255);
123  }
124  reference_pos = (pos >= delta) ? (pos - delta) : (HISTORY_SIZE + pos - delta);
125  if (pos + match_length < HISTORY_SIZE && reference_pos + match_length < HISTORY_SIZE) {
126  if (pos >= reference_pos + match_length || reference_pos >= pos + match_length) {
127  memcpy(history + pos, history + reference_pos, match_length);
128  pos += match_length;
129  } else {
130  while (match_length-- > 0)
131  history[pos++] = history[reference_pos++];
132  }
133  } else {
134  while (match_length-- > 0) {
135  history[pos++] = history[reference_pos++];
136  if (pos == HISTORY_SIZE) {
137  bytestream2_put_buffer(pb, history, HISTORY_SIZE);
138  pos = 0;
139  }
140  reference_pos %= HISTORY_SIZE;
141  }
142  }
143  }
144 
145  bytestream2_put_buffer(pb, history, pos);
146 
147  return bytestream2_tell_p(pb);
148 }
149 
151  unsigned uncompressed_size)
152 {
153  NotchLCContext *s = avctx->priv_data;
154  GetByteContext rgb, dgb, *gb = &s->gb;
156  int ylinesize, ulinesize, vlinesize, alinesize;
157  uint16_t *dsty, *dstu, *dstv, *dsta;
158  int ret;
159 
160  s->texture_size_x = bytestream2_get_le32(gb);
161  s->texture_size_y = bytestream2_get_le32(gb);
162 
163  ret = ff_set_dimensions(avctx, s->texture_size_x, s->texture_size_y);
164  if (ret < 0)
165  return ret;
166 
167  s->uv_offset_data_offset = bytestream2_get_le32(gb);
168  if (s->uv_offset_data_offset >= UINT_MAX / 4)
169  return AVERROR_INVALIDDATA;
170  s->uv_offset_data_offset *= 4;
171  if (s->uv_offset_data_offset >= uncompressed_size)
172  return AVERROR_INVALIDDATA;
173 
174  s->y_control_data_offset = bytestream2_get_le32(gb);
175  if (s->y_control_data_offset >= UINT_MAX / 4)
176  return AVERROR_INVALIDDATA;
177  s->y_control_data_offset *= 4;
178  if (s->y_control_data_offset >= uncompressed_size)
179  return AVERROR_INVALIDDATA;
180 
181  s->a_control_word_offset = bytestream2_get_le32(gb);
182  if (s->a_control_word_offset >= UINT_MAX / 4)
183  return AVERROR_INVALIDDATA;
184  s->a_control_word_offset *= 4;
185  if (s->a_control_word_offset >= uncompressed_size)
186  return AVERROR_INVALIDDATA;
187 
188  s->uv_data_offset = bytestream2_get_le32(gb);
189  if (s->uv_data_offset >= UINT_MAX / 4)
190  return AVERROR_INVALIDDATA;
191  s->uv_data_offset *= 4;
192  if (s->uv_data_offset >= uncompressed_size)
193  return AVERROR_INVALIDDATA;
194 
195  s->y_data_size = bytestream2_get_le32(gb);
196  if (s->y_data_size >= UINT_MAX / 4)
197  return AVERROR_INVALIDDATA;
198 
199  s->uv_count_size = bytestream2_get_le32(gb);
200  if (s->uv_count_size >= UINT_MAX / 4)
201  return AVERROR_INVALIDDATA;
202  s->uv_count_size *= 4;
203  if (s->uv_count_size >= uncompressed_size)
204  return AVERROR_INVALIDDATA;
205 
206  s->a_count_size = bytestream2_get_le32(gb);
207  if (s->a_count_size >= UINT_MAX / 4)
208  return AVERROR_INVALIDDATA;
209  s->a_count_size *= 4;
210  if (s->a_count_size >= uncompressed_size)
211  return AVERROR_INVALIDDATA;
212 
213  s->data_end = bytestream2_get_le32(gb);
214  if (s->data_end > uncompressed_size)
215  return AVERROR_INVALIDDATA;
216 
218  if (s->data_end <= s->y_data_size)
219  return AVERROR_INVALIDDATA;
220  s->y_data_offset = s->data_end - s->y_data_size;
221  if (s->y_data_offset <= s->uv_count_size)
222  return AVERROR_INVALIDDATA;
224 
225  if ((ret = ff_thread_get_buffer(avctx, frame, 0)) < 0)
226  return ret;
227 
228  rgb = *gb;
229  dgb = *gb;
230  bytestream2_seek(&rgb, s->y_data_row_offsets, SEEK_SET);
231  bytestream2_seek(gb, s->y_control_data_offset, SEEK_SET);
232 
233  dsty = (uint16_t *)p->data[0];
234  dsta = (uint16_t *)p->data[3];
235  ylinesize = p->linesize[0] / 2;
236  alinesize = p->linesize[3] / 2;
237 
238  for (int y = 0; y < avctx->height; y += 4) {
239  const unsigned row_offset = bytestream2_get_le32(&rgb);
240 
241  bytestream2_seek(&dgb, s->y_data_offset + row_offset, SEEK_SET);
242 
243  ret = init_get_bits8(&bit, dgb.buffer, bytestream2_get_bytes_left(&dgb));
244  if (ret < 0)
245  return ret;
246  for (int x = 0; x < avctx->width; x += 4) {
247  unsigned item = bytestream2_get_le32(gb);
248  unsigned y_min = item & 4095;
249  unsigned y_max = (item >> 12) & 4095;
250  unsigned y_diff = y_max - y_min;
251  unsigned control[4];
252 
253  control[0] = (item >> 24) & 3;
254  control[1] = (item >> 26) & 3;
255  control[2] = (item >> 28) & 3;
256  control[3] = (item >> 30) & 3;
257 
258  for (int i = 0; i < 4; i++) {
259  const int nb_bits = control[i] + 1;
260  const int div = (1 << nb_bits) - 1;
261  const int add = div - 1;
262 
263  dsty[x + i * ylinesize + 0] = av_clip_uintp2(y_min + ((y_diff * get_bits(&bit, nb_bits) + add) / div), 12);
264  dsty[x + i * ylinesize + 1] = av_clip_uintp2(y_min + ((y_diff * get_bits(&bit, nb_bits) + add) / div), 12);
265  dsty[x + i * ylinesize + 2] = av_clip_uintp2(y_min + ((y_diff * get_bits(&bit, nb_bits) + add) / div), 12);
266  dsty[x + i * ylinesize + 3] = av_clip_uintp2(y_min + ((y_diff * get_bits(&bit, nb_bits) + add) / div), 12);
267  }
268  }
269 
270  dsty += 4 * ylinesize;
271  dsta += 4 * alinesize;
272  }
273 
274  rgb = *gb;
275  dgb = *gb;
276  bytestream2_seek(&rgb, s->uv_offset_data_offset, SEEK_SET);
277  bytestream2_seek(gb, s->a_control_word_offset, SEEK_SET);
278 
279  dstu = (uint16_t *)p->data[1];
280  dstv = (uint16_t *)p->data[2];
281  ulinesize = p->linesize[1] / 2;
282  vlinesize = p->linesize[2] / 2;
283 
284  for (int y = 0; y < avctx->height; y += 16) {
285  for (int x = 0; x < avctx->width; x += 16) {
286  unsigned offset = bytestream2_get_le32(&rgb) * 4;
287  int u[16][16] = { 0 }, v[16][16] = { 0 };
288  int u0, v0, u1, v1, udif, vdif;
289  unsigned escape, is8x8, loc;
290 
291  bytestream2_seek(&dgb, s->uv_data_offset + offset, SEEK_SET);
292 
293  is8x8 = bytestream2_get_le16(&dgb);
294  escape = bytestream2_get_le16(&dgb);
295 
296  if (escape == 0 && is8x8 == 0) {
297  u0 = bytestream2_get_byte(&dgb);
298  v0 = bytestream2_get_byte(&dgb);
299  u1 = bytestream2_get_byte(&dgb);
300  v1 = bytestream2_get_byte(&dgb);
301  loc = bytestream2_get_le32(&dgb);
302  u0 = (u0 << 4) | (u0 & 0xF);
303  v0 = (v0 << 4) | (v0 & 0xF);
304  u1 = (u1 << 4) | (u1 & 0xF);
305  v1 = (v1 << 4) | (v1 & 0xF);
306  udif = u1 - u0;
307  vdif = v1 - v0;
308 
309  for (int i = 0; i < 16; i += 4) {
310  for (int j = 0; j < 16; j += 4) {
311  for (int ii = 0; ii < 4; ii++) {
312  for (int jj = 0; jj < 4; jj++) {
313  u[i + ii][j + jj] = u0 + ((udif * (int)(loc & 3) + 2) / 3);
314  v[i + ii][j + jj] = v0 + ((vdif * (int)(loc & 3) + 2) / 3);
315  }
316  }
317 
318  loc >>= 2;
319  }
320  }
321  } else {
322  for (int i = 0; i < 16; i += 8) {
323  for (int j = 0; j < 16; j += 8) {
324  if (is8x8 & 1) {
325  u0 = bytestream2_get_byte(&dgb);
326  v0 = bytestream2_get_byte(&dgb);
327  u1 = bytestream2_get_byte(&dgb);
328  v1 = bytestream2_get_byte(&dgb);
329  loc = bytestream2_get_le32(&dgb);
330  u0 = (u0 << 4) | (u0 & 0xF);
331  v0 = (v0 << 4) | (v0 & 0xF);
332  u1 = (u1 << 4) | (u1 & 0xF);
333  v1 = (v1 << 4) | (v1 & 0xF);
334  udif = u1 - u0;
335  vdif = v1 - v0;
336 
337  for (int ii = 0; ii < 8; ii += 2) {
338  for (int jj = 0; jj < 8; jj += 2) {
339  for (int iii = 0; iii < 2; iii++) {
340  for (int jjj = 0; jjj < 2; jjj++) {
341  u[i + ii + iii][j + jj + jjj] = u0 + ((udif * (int)(loc & 3) + 2) / 3);
342  v[i + ii + iii][j + jj + jjj] = v0 + ((vdif * (int)(loc & 3) + 2) / 3);
343  }
344  }
345 
346  loc >>= 2;
347  }
348  }
349  } else if (escape) {
350  for (int ii = 0; ii < 8; ii += 4) {
351  for (int jj = 0; jj < 8; jj += 4) {
352  u0 = bytestream2_get_byte(&dgb);
353  v0 = bytestream2_get_byte(&dgb);
354  u1 = bytestream2_get_byte(&dgb);
355  v1 = bytestream2_get_byte(&dgb);
356  loc = bytestream2_get_le32(&dgb);
357  u0 = (u0 << 4) | (u0 & 0xF);
358  v0 = (v0 << 4) | (v0 & 0xF);
359  u1 = (u1 << 4) | (u1 & 0xF);
360  v1 = (v1 << 4) | (v1 & 0xF);
361  udif = u1 - u0;
362  vdif = v1 - v0;
363 
364  for (int iii = 0; iii < 4; iii++) {
365  for (int jjj = 0; jjj < 4; jjj++) {
366  u[i + ii + iii][j + jj + jjj] = u0 + ((udif * (int)(loc & 3) + 2) / 3);
367  v[i + ii + iii][j + jj + jjj] = v0 + ((vdif * (int)(loc & 3) + 2) / 3);
368 
369  loc >>= 2;
370  }
371  }
372  }
373  }
374  }
375 
376  is8x8 >>= 1;
377  }
378  }
379  }
380 
381  for (int i = 0; i < 16; i++) {
382  for (int j = 0; j < 16; j++) {
383  dstu[x + i * ulinesize + j] = u[i][j];
384  dstv[x + i * vlinesize + j] = v[i][j];
385  }
386  }
387  }
388 
389  dstu += 16 * ulinesize;
390  dstv += 16 * vlinesize;
391  }
392 
393  return 0;
394 }
395 
396 static int decode_frame(AVCodecContext *avctx,
397  void *data, int *got_frame,
398  AVPacket *avpkt)
399 {
400  NotchLCContext *s = avctx->priv_data;
401  ThreadFrame frame = { .f = data };
402  GetByteContext *gb = &s->gb;
403  PutByteContext *pb = &s->pb;
404  unsigned uncompressed_size;
405  AVFrame *p = data;
406  int ret;
407 
408  if (avpkt->size <= 40)
409  return AVERROR_INVALIDDATA;
410 
411  bytestream2_init(gb, avpkt->data, avpkt->size);
412 
413  if (bytestream2_get_le32(gb) != MKBETAG('N','L','C','1'))
414  return AVERROR_INVALIDDATA;
415 
416  uncompressed_size = bytestream2_get_le32(gb);
417  s->compressed_size = bytestream2_get_le32(gb);
418  s->format = bytestream2_get_le32(gb);
419 
420  if (s->format > 2)
421  return AVERROR_PATCHWELCOME;
422 
423  if (s->format == 0) {
424  ret = ff_lzf_uncompress(gb, &s->lzf_buffer, &s->lzf_size);
425  if (ret < 0)
426  return ret;
427 
428  if (uncompressed_size > s->lzf_size)
429  return AVERROR_INVALIDDATA;
430 
431  bytestream2_init(gb, s->lzf_buffer, uncompressed_size);
432  } else if (s->format == 1) {
434  uncompressed_size);
435  if (!s->uncompressed_buffer)
436  return AVERROR(ENOMEM);
437 
439 
440  ret = lz4_decompress(avctx, gb, pb);
441  if (ret != uncompressed_size)
442  return AVERROR_INVALIDDATA;
443 
444  bytestream2_init(gb, s->uncompressed_buffer, uncompressed_size);
445  }
446 
447  ret = decode_blocks(avctx, p, &frame, uncompressed_size);
448  if (ret < 0)
449  return ret;
450 
452  p->key_frame = 1;
453 
454  *got_frame = 1;
455 
456  return avpkt->size;
457 }
458 
460 {
461  NotchLCContext *s = avctx->priv_data;
462 
464  s->uncompressed_size = 0;
465  av_freep(&s->lzf_buffer);
466  s->lzf_size = 0;
467 
468  return 0;
469 }
470 
472  .name = "notchlc",
473  .long_name = NULL_IF_CONFIG_SMALL("NotchLC"),
474  .type = AVMEDIA_TYPE_VIDEO,
475  .id = AV_CODEC_ID_NOTCHLC,
476  .priv_data_size = sizeof(NotchLCContext),
477  .init = decode_init,
478  .close = decode_end,
479  .decode = decode_frame,
481 };
int64_t lzf_size
Definition: notchlc.c:43
#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:300
unsigned a_control_word_offset
Definition: notchlc.c:50
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
unsigned uv_count_size
Definition: notchlc.c:54
unsigned uncompressed_size
Definition: notchlc.c:40
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:104
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
unsigned uv_count_offset
Definition: notchlc.c:55
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
uint8_t * lzf_buffer
Definition: notchlc.c:42
int size
Definition: packet.h:356
static av_always_inline void bytestream2_init_writer(PutByteContext *p, uint8_t *buf, int buf_size)
Definition: bytestream.h:143
unsigned y_data_row_offsets
Definition: notchlc.c:47
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:133
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:70
static av_cold int decode_init(AVCodecContext *avctx)
Definition: notchlc.c:63
AVCodec.
Definition: codec.h:190
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:510
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
unsigned uv_data_offset
Definition: notchlc.c:52
PutByteContext pb
Definition: notchlc.c:60
unsigned y_data_size
Definition: notchlc.c:53
uint8_t
#define av_cold
Definition: attributes.h:88
float delta
AVCodec ff_notchlc_decoder
Definition: notchlc.c:471
Multithreading support functions.
static int decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: notchlc.c:396
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:262
static AVFrame * frame
const char data[16]
Definition: mxf.c:91
uint8_t * data
Definition: packet.h:355
const uint8_t * buffer
Definition: bytestream.h:34
unsigned y_control_data_offset
Definition: notchlc.c:49
bitstream reader API header.
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:154
int ff_lzf_uncompress(GetByteContext *gb, uint8_t **buf, int64_t *size)
Definition: lzf.c:40
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
#define AVERROR(e)
Definition: error.h:43
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:188
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:263
unsigned int pos
Definition: spdifenc.c:412
unsigned format
Definition: notchlc.c:37
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
Definition: pixfmt.h:457
const char * name
Name of the codec implementation.
Definition: codec.h:197
static const uint8_t offset[127][2]
Definition: vf_spp.c:93
static av_always_inline int bytestream2_tell_p(PutByteContext *p)
Definition: bytestream.h:193
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:106
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:383
static int decode_blocks(AVCodecContext *avctx, AVFrame *p, ThreadFrame *frame, unsigned uncompressed_size)
Definition: notchlc.c:150
int width
picture width / height.
Definition: avcodec.h:699
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
#define s(width, name)
Definition: cbs_vp9.c:257
GetByteContext gb
Definition: notchlc.c:59
static av_always_inline unsigned int bytestream2_put_buffer(PutByteContext *p, const uint8_t *src, unsigned int size)
Definition: bytestream.h:282
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:535
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
static av_always_inline int bytestream2_tell(GetByteContext *g)
Definition: bytestream.h:188
Libavcodec external API header.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:331
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:677
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
Definition: avcodec.h:526
long long int64_t
Definition: coverity.c:34
unsigned a_count_size
Definition: notchlc.c:56
unsigned data_end
Definition: notchlc.c:57
static av_cold int decode_end(AVCodecContext *avctx)
Definition: notchlc.c:459
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
#define HISTORY_SIZE
Definition: notchlc.c:74
uint8_t * uncompressed_buffer
Definition: notchlc.c:39
unsigned compressed_size
Definition: notchlc.c:36
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:404
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:314
#define v0
Definition: regdef.h:26
int
IEC 61966-2-1 (sRGB or sYCC)
Definition: pixfmt.h:494
common internal api header.
static int lz4_decompress(AVCodecContext *avctx, GetByteContext *gb, PutByteContext *pb)
Definition: notchlc.c:76
#define bit(string, value)
Definition: cbs_mpeg2.c:58
unsigned uv_offset_data_offset
Definition: notchlc.c:48
#define MKBETAG(a, b, c, d)
Definition: common.h:407
void * priv_data
Definition: avcodec.h:553
unsigned y_data_offset
Definition: notchlc.c:51
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:378
static av_always_inline int bytestream2_seek(GetByteContext *g, int offset, int whence)
Definition: bytestream.h:208
unsigned texture_size_y
Definition: notchlc.c:46
#define av_freep(p)
unsigned texture_size_x
Definition: notchlc.c:45
This structure stores compressed data.
Definition: packet.h:332
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:50