FFmpeg
cri.c
Go to the documentation of this file.
1 /*
2  * CRI image decoder
3  *
4  * Copyright (c) 2020 Paul B Mahol
5  *
6  * This file is part of FFmpeg.
7  *
8  * FFmpeg is free software; you can redistribute it and/or
9  * modify it under the terms of the GNU Lesser General Public
10  * License as published by the Free Software Foundation; either
11  * version 2.1 of the License, or (at your option) any later version.
12  *
13  * FFmpeg is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  * Lesser General Public License for more details.
17  *
18  * You should have received a copy of the GNU Lesser General Public
19  * License along with FFmpeg; if not, write to the Free Software
20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
21  */
22 
23 /**
24  * @file
25  * Cintel RAW image decoder
26  */
27 
28 #define BITSTREAM_READER_LE
29 
30 #include "libavutil/intfloat.h"
31 #include "libavutil/display.h"
32 #include "avcodec.h"
33 #include "bytestream.h"
34 #include "get_bits.h"
35 #include "internal.h"
36 #include "thread.h"
37 
38 typedef struct CRIContext {
39  AVCodecContext *jpeg_avctx; // wrapper context for MJPEG
40  AVPacket *jpkt; // encoded JPEG tile
41  AVFrame *jpgframe; // decoded JPEG tile
42 
45  const uint8_t *data;
46  unsigned data_size;
47  uint64_t tile_size[4];
48 } CRIContext;
49 
51 {
52  CRIContext *s = avctx->priv_data;
53  const AVCodec *codec;
54  int ret;
55 
56  s->jpgframe = av_frame_alloc();
57  if (!s->jpgframe)
58  return AVERROR(ENOMEM);
59 
60  s->jpkt = av_packet_alloc();
61  if (!s->jpkt)
62  return AVERROR(ENOMEM);
63 
65  if (!codec)
66  return AVERROR_BUG;
67  s->jpeg_avctx = avcodec_alloc_context3(codec);
68  if (!s->jpeg_avctx)
69  return AVERROR(ENOMEM);
70  s->jpeg_avctx->flags = avctx->flags;
71  s->jpeg_avctx->flags2 = avctx->flags2;
72  s->jpeg_avctx->dct_algo = avctx->dct_algo;
73  s->jpeg_avctx->idct_algo = avctx->idct_algo;
74  ret = avcodec_open2(s->jpeg_avctx, codec, NULL);
75  if (ret < 0)
76  return ret;
77 
78  return 0;
79 }
80 
81 static void unpack_10bit(GetByteContext *gb, uint16_t *dst, int shift,
82  int w, int h, ptrdiff_t stride)
83 {
84  int count = w * h;
85  int pos = 0;
86 
87  while (count > 0) {
88  uint32_t a0, a1, a2, a3;
89  if (bytestream2_get_bytes_left(gb) < 4)
90  break;
91  a0 = bytestream2_get_le32(gb);
92  a1 = bytestream2_get_le32(gb);
93  a2 = bytestream2_get_le32(gb);
94  a3 = bytestream2_get_le32(gb);
95  dst[pos] = (((a0 >> 1) & 0xE00) | (a0 & 0x1FF)) << shift;
96  pos++;
97  if (pos >= w) {
98  if (count == 1)
99  break;
100  dst += stride;
101  pos = 0;
102  }
103  dst[pos] = (((a0 >> 13) & 0x3F) | ((a0 >> 14) & 0xFC0)) << shift;
104  pos++;
105  if (pos >= w) {
106  if (count == 2)
107  break;
108  dst += stride;
109  pos = 0;
110  }
111  dst[pos] = (((a0 >> 26) & 7) | ((a1 & 0x1FF) << 3)) << shift;
112  pos++;
113  if (pos >= w) {
114  if (count == 3)
115  break;
116  dst += stride;
117  pos = 0;
118  }
119  dst[pos] = (((a1 >> 10) & 0x1FF) | ((a1 >> 11) & 0xE00)) << shift;
120  pos++;
121  if (pos >= w) {
122  if (count == 4)
123  break;
124  dst += stride;
125  pos = 0;
126  }
127  dst[pos] = (((a1 >> 23) & 0x3F) | ((a2 & 0x3F) << 6)) << shift;
128  pos++;
129  if (pos >= w) {
130  if (count == 5)
131  break;
132  dst += stride;
133  pos = 0;
134  }
135  dst[pos] = (((a2 >> 7) & 0xFF8) | ((a2 >> 6) & 7)) << shift;
136  pos++;
137  if (pos >= w) {
138  if (count == 6)
139  break;
140  dst += stride;
141  pos = 0;
142  }
143  dst[pos] = (((a3 & 7) << 9) | ((a2 >> 20) & 0x1FF)) << shift;
144  pos++;
145  if (pos >= w) {
146  if (count == 7)
147  break;
148  dst += stride;
149  pos = 0;
150  }
151  dst[pos] = (((a3 >> 4) & 0xFC0) | ((a3 >> 3) & 0x3F)) << shift;
152  pos++;
153  if (pos >= w) {
154  if (count == 8)
155  break;
156  dst += stride;
157  pos = 0;
158  }
159  dst[pos] = (((a3 >> 16) & 7) | ((a3 >> 17) & 0xFF8)) << shift;
160  pos++;
161  if (pos >= w) {
162  if (count == 9)
163  break;
164  dst += stride;
165  pos = 0;
166  }
167 
168  count -= 9;
169  }
170 }
171 
172 static int cri_decode_frame(AVCodecContext *avctx, void *data,
173  int *got_frame, AVPacket *avpkt)
174 {
175  CRIContext *s = avctx->priv_data;
176  GetByteContext *gb = &s->gb;
177  ThreadFrame frame = { .f = data };
178  int ret, bps, hflip = 0, vflip = 0;
179  AVFrameSideData *rotation;
180  int compressed = 0;
181  AVFrame *p = data;
182 
183  s->data = NULL;
184  s->data_size = 0;
185 
186  bytestream2_init(gb, avpkt->data, avpkt->size);
187 
188  while (bytestream2_get_bytes_left(gb) > 8) {
189  char codec_name[1024];
190  uint32_t key, length;
191  float framerate;
192  int width, height;
193 
194  key = bytestream2_get_le32(gb);
195  length = bytestream2_get_le32(gb);
196 
197  switch (key) {
198  case 1:
199  if (length != 4)
200  return AVERROR_INVALIDDATA;
201 
202  if (bytestream2_get_le32(gb) != MKTAG('D', 'V', 'C', 'C'))
203  return AVERROR_INVALIDDATA;
204  break;
205  case 100:
206  if (length < 16)
207  return AVERROR_INVALIDDATA;
208  width = bytestream2_get_le32(gb);
209  height = bytestream2_get_le32(gb);
210  s->color_model = bytestream2_get_le32(gb);
211  if (bytestream2_get_le32(gb) != 1)
212  return AVERROR_INVALIDDATA;
213  ret = ff_set_dimensions(avctx, width, height);
214  if (ret < 0)
215  return ret;
216  length -= 16;
217  goto skip;
218  case 101:
219  if (length != 4)
220  return AVERROR_INVALIDDATA;
221 
222  if (bytestream2_get_le32(gb) != 0)
223  return AVERROR_INVALIDDATA;
224  break;
225  case 102:
226  bytestream2_get_buffer(gb, codec_name, FFMIN(length, sizeof(codec_name) - 1));
227  length -= FFMIN(length, sizeof(codec_name) - 1);
228  if (strncmp(codec_name, "cintel_craw", FFMIN(length, sizeof(codec_name) - 1)))
229  return AVERROR_INVALIDDATA;
230  compressed = 1;
231  goto skip;
232  case 103:
233  if (bytestream2_get_bytes_left(gb) < length)
234  return AVERROR_INVALIDDATA;
235  s->data = gb->buffer;
236  s->data_size = length;
237  goto skip;
238  case 105:
239  hflip = bytestream2_get_byte(gb) != 0;
240  length--;
241  goto skip;
242  case 106:
243  vflip = bytestream2_get_byte(gb) != 0;
244  length--;
245  goto skip;
246  case 107:
247  if (length != 4)
248  return AVERROR_INVALIDDATA;
249  framerate = av_int2float(bytestream2_get_le32(gb));
250  avctx->framerate.num = framerate * 1000;
251  avctx->framerate.den = 1000;
252  break;
253  case 119:
254  if (length != 32)
255  return AVERROR_INVALIDDATA;
256 
257  for (int i = 0; i < 4; i++)
258  s->tile_size[i] = bytestream2_get_le64(gb);
259  break;
260  default:
261  av_log(avctx, AV_LOG_DEBUG, "skipping unknown key %u of length %u\n", key, length);
262 skip:
263  bytestream2_skip(gb, length);
264  }
265  }
266 
267  switch (s->color_model) {
268  case 76:
269  case 88:
271  break;
272  case 77:
273  case 89:
275  break;
276  case 78:
277  case 90:
279  break;
280  case 45:
281  case 79:
282  case 91:
284  break;
285  }
286 
287  switch (s->color_model) {
288  case 45:
289  bps = 10;
290  break;
291  case 76:
292  case 77:
293  case 78:
294  case 79:
295  bps = 12;
296  break;
297  case 88:
298  case 89:
299  case 90:
300  case 91:
301  bps = 16;
302  break;
303  default:
304  return AVERROR_INVALIDDATA;
305  }
306 
307  if (compressed) {
308  for (int i = 0; i < 4; i++) {
309  if (s->tile_size[i] >= s->data_size)
310  return AVERROR_INVALIDDATA;
311  }
312 
313  if (s->tile_size[0] + s->tile_size[1] + s->tile_size[2] + s->tile_size[3] !=
314  s->data_size)
315  return AVERROR_INVALIDDATA;
316  }
317 
318  if (!s->data || !s->data_size)
319  return AVERROR_INVALIDDATA;
320 
321  if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
322  return ret;
323 
324  avctx->bits_per_raw_sample = bps;
325 
326  if (!compressed && s->color_model == 45) {
327  uint16_t *dst = (uint16_t *)p->data[0];
328  GetByteContext gb;
329 
330  bytestream2_init(&gb, s->data, s->data_size);
331  unpack_10bit(&gb, dst, 4, avctx->width, avctx->height, p->linesize[0] / 2);
332  } else if (!compressed) {
333  GetBitContext gbit;
334  const int shift = 16 - bps;
335 
336  ret = init_get_bits8(&gbit, s->data, s->data_size);
337  if (ret < 0)
338  return ret;
339 
340  for (int y = 0; y < avctx->height; y++) {
341  uint16_t *dst = (uint16_t *)(p->data[0] + y * p->linesize[0]);
342 
343  if (get_bits_left(&gbit) < avctx->width * bps)
344  break;
345 
346  for (int x = 0; x < avctx->width; x++)
347  dst[x] = get_bits(&gbit, bps) << shift;
348  }
349  } else {
350  unsigned offset = 0;
351 
352  for (int tile = 0; tile < 4; tile++) {
353  av_packet_unref(s->jpkt);
354  s->jpkt->data = (uint8_t *)s->data + offset;
355  s->jpkt->size = s->tile_size[tile];
356 
357  ret = avcodec_send_packet(s->jpeg_avctx, s->jpkt);
358  if (ret < 0) {
359  av_log(avctx, AV_LOG_ERROR, "Error submitting a packet for decoding\n");
360  return ret;
361  }
362 
363  ret = avcodec_receive_frame(s->jpeg_avctx, s->jpgframe);
364  if (ret < 0 || s->jpgframe->format != AV_PIX_FMT_GRAY16 ||
365  s->jpeg_avctx->width * 2 != avctx->width ||
366  s->jpeg_avctx->height * 2 != avctx->height) {
367  if (ret < 0) {
368  av_log(avctx, AV_LOG_ERROR,
369  "JPEG decoding error (%d).\n", ret);
370  } else {
371  av_log(avctx, AV_LOG_ERROR,
372  "JPEG invalid format.\n");
374  }
375 
376  /* Normally skip, if error explode */
377  if (avctx->err_recognition & AV_EF_EXPLODE)
378  return ret;
379  else
380  return 0;
381  }
382 
383  for (int y = 0; y < s->jpeg_avctx->height; y++) {
384  const int hw = s->jpgframe->width / 2;
385  uint16_t *dst = (uint16_t *)(p->data[0] + (y * 2) * p->linesize[0] + tile * hw * 2);
386  const uint16_t *src = (const uint16_t *)(s->jpgframe->data[0] + y * s->jpgframe->linesize[0]);
387 
388  memcpy(dst, src, hw * 2);
389  src += hw;
390  dst += p->linesize[0] / 2;
391  memcpy(dst, src, hw * 2);
392  }
393 
394  av_frame_unref(s->jpgframe);
395  offset += s->tile_size[tile];
396  }
397  }
398 
399  if (hflip || vflip) {
401  sizeof(int32_t) * 9);
402  if (rotation) {
403  av_display_rotation_set((int32_t *)rotation->data, 0.f);
404  av_display_matrix_flip((int32_t *)rotation->data, hflip, vflip);
405  }
406  }
407 
409  p->key_frame = 1;
410 
411  *got_frame = 1;
412 
413  return 0;
414 }
415 
417 {
418  CRIContext *s = avctx->priv_data;
419 
420  av_frame_free(&s->jpgframe);
421  av_packet_free(&s->jpkt);
422  avcodec_free_context(&s->jpeg_avctx);
423 
424  return 0;
425 }
426 
428  .name = "cri",
429  .type = AVMEDIA_TYPE_VIDEO,
430  .id = AV_CODEC_ID_CRI,
431  .priv_data_size = sizeof(CRIContext),
434  .close = cri_decode_close,
437  .long_name = NULL_IF_CONFIG_SMALL("Cintel RAW"),
438 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:403
AVCodec
AVCodec.
Definition: codec.h:197
stride
int stride
Definition: mace.c:144
FF_CODEC_CAP_INIT_THREADSAFE
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
Definition: internal.h:41
init
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:31
CRIContext::data
const uint8_t * data
Definition: cri.c:45
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:850
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
ff_cri_decoder
const AVCodec ff_cri_decoder
Definition: cri.c:427
av_frame_new_side_data
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, size_t size)
Add a new side data to a frame.
Definition: frame.c:604
GetByteContext
Definition: bytestream.h:33
CRIContext
Definition: cri.c:38
MKTAG
#define MKTAG(a, b, c, d)
Definition: common.h:478
unpack_10bit
static void unpack_10bit(GetByteContext *gb, uint16_t *dst, int shift, int w, int h, ptrdiff_t stride)
Definition: cri.c:81
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1313
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:111
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:303
w
uint8_t w
Definition: llviddspenc.c:39
av_display_matrix_flip
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
Flip the input matrix horizontally and/or vertically.
Definition: display.c:65
internal.h
AVPacket::data
uint8_t * data
Definition: packet.h:365
data
const char data[16]
Definition: mxf.c:142
av_display_rotation_set
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure counterclockwise rotation by the specified angle...
Definition: display.c:50
AV_FRAME_DATA_DISPLAYMATRIX
@ AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:84
CRIContext::jpkt
AVPacket * jpkt
Definition: cri.c:40
intfloat.h
AV_PIX_FMT_BAYER_GRBG16
#define AV_PIX_FMT_BAYER_GRBG16
Definition: pixfmt.h:416
thread.h
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:70
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:317
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1699
framerate
int framerate
Definition: h264_levels.c:65
bytestream2_skip
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
Definition: bytestream.h:168
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:380
av_int2float
static av_always_inline float av_int2float(uint32_t i)
Reinterpret a 32-bit integer as a float.
Definition: intfloat.h:40
GetBitContext
Definition: get_bits.h:62
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames. The frames must then be freed with ff_thread_release_buffer(). Otherwise decode directly into the user-supplied frames. Call ff_thread_report_progress() after some part of the current picture has decoded. A good place to put this is where draw_horiz_band() is called - add this if it isn 't called anywhere
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:381
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:464
AVCodecContext::dct_algo
int dct_algo
DCT algorithm, see FF_DCT_* below.
Definition: avcodec.h:1373
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:373
AVRational::num
int num
Numerator.
Definition: rational.h:59
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:98
a1
#define a1
Definition: regdef.h:47
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:181
av_cold
#define av_cold
Definition: attributes.h:90
init_get_bits8
static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)
Initialize GetBitContext.
Definition: get_bits.h:678
decode
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:71
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:141
width
#define width
s
#define s(width, name)
Definition: cbs_vp9.c:257
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
CRIContext::tile_size
uint64_t tile_size[4]
Definition: cri.c:47
avcodec_receive_frame
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:628
cri_decode_init
static av_cold int cri_decode_init(AVCodecContext *avctx)
Definition: cri.c:50
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1414
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:202
get_bits.h
key
const char * key
Definition: hwcontext_opencl.c:168
AV_PIX_FMT_BAYER_BGGR16
#define AV_PIX_FMT_BAYER_BGGR16
Definition: pixfmt.h:413
CRIContext::jpeg_avctx
AVCodecContext * jpeg_avctx
Definition: cri.c:39
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:108
NULL
#define NULL
Definition: coverity.c:32
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:156
CRIContext::jpgframe
AVFrame * jpgframe
Definition: cri.c:41
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
src
#define src
Definition: vp8dsp.c:255
AV_PIX_FMT_BAYER_GBRG16
#define AV_PIX_FMT_BAYER_GBRG16
Definition: pixfmt.h:415
bytestream2_get_buffer
static av_always_inline unsigned int bytestream2_get_buffer(GetByteContext *g, uint8_t *dst, unsigned int size)
Definition: bytestream.h:267
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:135
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1324
cri_decode_frame
static int cri_decode_frame(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: cri.c:172
bytestream2_get_bytes_left
static av_always_inline int bytestream2_get_bytes_left(GetByteContext *g)
Definition: bytestream.h:158
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:911
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:471
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:386
AV_CODEC_CAP_DR1
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.
Definition: codec.h:52
AVPacket::size
int size
Definition: packet.h:366
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:117
bps
unsigned bps
Definition: movenc.c:1595
AVFrameSideData::data
uint8_t * data
Definition: frame.h:211
height
#define height
FFMIN
#define FFMIN(a, b)
Definition: common.h:105
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.c:59
a0
#define a0
Definition: regdef.h:46
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:57
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:565
i
int i
Definition: input.c:407
AV_CODEC_ID_CRI
@ AV_CODEC_ID_CRI
Definition: codec_id.h:307
CRIContext::data_size
unsigned data_size
Definition: cri.c:46
FF_CODEC_CAP_INIT_CLEANUP
#define FF_CODEC_CAP_INIT_CLEANUP
The codec allows calling the close function for deallocation even if the init function returned a fai...
Definition: internal.h:49
display.h
a2
#define a2
Definition: regdef.h:48
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:436
AVCodecContext::idct_algo
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1386
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:204
AVCodecContext::height
int height
Definition: avcodec.h:557
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:594
avcodec.h
ret
ret
Definition: filter_design.txt:187
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:264
pos
unsigned int pos
Definition: spdifenc.c:412
AVCodecContext
main external API structure.
Definition: avcodec.h:384
ThreadFrame
Definition: thread.h:34
AVRational::den
int den
Denominator.
Definition: rational.h:60
shift
static int shift(int a, int b)
Definition: sonic.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
ff_set_dimensions
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:86
CRIContext::color_model
int color_model
Definition: cri.c:44
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:209
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:411
AVPacket
This structure stores compressed data.
Definition: packet.h:342
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:557
int32_t
int32_t
Definition: audioconvert.c:56
bytestream.h
bytestream2_init
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
Definition: bytestream.h:137
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:50
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:334
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
h
h
Definition: vp9dsp_template.c:2038
AV_PIX_FMT_BAYER_RGGB16
#define AV_PIX_FMT_BAYER_RGGB16
Definition: pixfmt.h:414
CRIContext::gb
GetByteContext gb
Definition: cri.c:43
a3
#define a3
Definition: regdef.h:49
cri_decode_close
static av_cold int cri_decode_close(AVCodecContext *avctx)
Definition: cri.c:416