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 "codec_internal.h"
35 #include "decode.h"
36 #include "get_bits.h"
37 #include "thread.h"
38 
39 typedef struct CRIContext {
40  AVCodecContext *jpeg_avctx; // wrapper context for MJPEG
41  AVPacket *jpkt; // encoded JPEG tile
42  AVFrame *jpgframe; // decoded JPEG tile
43 
46  const uint8_t *data;
47  unsigned data_size;
48  uint64_t tile_size[4];
49 } CRIContext;
50 
52 {
53  CRIContext *s = avctx->priv_data;
54  const AVCodec *codec;
55  int ret;
56 
57  s->jpgframe = av_frame_alloc();
58  if (!s->jpgframe)
59  return AVERROR(ENOMEM);
60 
61  s->jpkt = av_packet_alloc();
62  if (!s->jpkt)
63  return AVERROR(ENOMEM);
64 
66  if (!codec)
67  return AVERROR_BUG;
68  s->jpeg_avctx = avcodec_alloc_context3(codec);
69  if (!s->jpeg_avctx)
70  return AVERROR(ENOMEM);
71  s->jpeg_avctx->flags = avctx->flags;
72  s->jpeg_avctx->flags2 = avctx->flags2;
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 
173  int *got_frame, AVPacket *avpkt)
174 {
175  CRIContext *s = avctx->priv_data;
176  GetByteContext *gb = &s->gb;
177  int ret, bps, hflip = 0, vflip = 0;
178  AVFrameSideData *rotation;
179  int compressed = 0;
180 
181  s->data = NULL;
182  s->data_size = 0;
183 
184  bytestream2_init(gb, avpkt->data, avpkt->size);
185 
186  while (bytestream2_get_bytes_left(gb) > 8) {
187  char codec_name[1024];
188  uint32_t key, length;
189  float framerate;
190  int width, height;
191 
192  key = bytestream2_get_le32(gb);
193  length = bytestream2_get_le32(gb);
194 
195  switch (key) {
196  case 1:
197  if (length != 4)
198  return AVERROR_INVALIDDATA;
199 
200  if (bytestream2_get_le32(gb) != MKTAG('D', 'V', 'C', 'C'))
201  return AVERROR_INVALIDDATA;
202  break;
203  case 100:
204  if (length < 16)
205  return AVERROR_INVALIDDATA;
206  width = bytestream2_get_le32(gb);
207  height = bytestream2_get_le32(gb);
208  s->color_model = bytestream2_get_le32(gb);
209  if (bytestream2_get_le32(gb) != 1)
210  return AVERROR_INVALIDDATA;
211  ret = ff_set_dimensions(avctx, width, height);
212  if (ret < 0)
213  return ret;
214  length -= 16;
215  goto skip;
216  case 101:
217  if (length != 4)
218  return AVERROR_INVALIDDATA;
219 
220  if (bytestream2_get_le32(gb) != 0)
221  return AVERROR_INVALIDDATA;
222  break;
223  case 102:
224  bytestream2_get_buffer(gb, codec_name, FFMIN(length, sizeof(codec_name) - 1));
225  length -= FFMIN(length, sizeof(codec_name) - 1);
226  if (strncmp(codec_name, "cintel_craw", FFMIN(length, sizeof(codec_name) - 1)))
227  return AVERROR_INVALIDDATA;
228  compressed = 1;
229  goto skip;
230  case 103:
231  if (bytestream2_get_bytes_left(gb) < length)
232  return AVERROR_INVALIDDATA;
233  s->data = gb->buffer;
234  s->data_size = length;
235  goto skip;
236  case 105:
237  hflip = bytestream2_get_byte(gb) != 0;
238  length--;
239  goto skip;
240  case 106:
241  vflip = bytestream2_get_byte(gb) != 0;
242  length--;
243  goto skip;
244  case 107:
245  if (length != 4)
246  return AVERROR_INVALIDDATA;
247  framerate = av_int2float(bytestream2_get_le32(gb));
248  avctx->framerate.num = framerate * 1000;
249  avctx->framerate.den = 1000;
250  break;
251  case 119:
252  if (length != 32)
253  return AVERROR_INVALIDDATA;
254 
255  for (int i = 0; i < 4; i++)
256  s->tile_size[i] = bytestream2_get_le64(gb);
257  break;
258  default:
259  av_log(avctx, AV_LOG_DEBUG, "skipping unknown key %u of length %u\n", key, length);
260 skip:
261  bytestream2_skip(gb, length);
262  }
263  }
264 
265  switch (s->color_model) {
266  case 76:
267  case 88:
269  break;
270  case 77:
271  case 89:
273  break;
274  case 78:
275  case 90:
277  break;
278  case 45:
279  case 79:
280  case 91:
282  break;
283  }
284 
285  switch (s->color_model) {
286  case 45:
287  bps = 10;
288  break;
289  case 76:
290  case 77:
291  case 78:
292  case 79:
293  bps = 12;
294  break;
295  case 88:
296  case 89:
297  case 90:
298  case 91:
299  bps = 16;
300  break;
301  default:
302  return AVERROR_INVALIDDATA;
303  }
304 
305  if (compressed) {
306  for (int i = 0; i < 4; i++) {
307  if (s->tile_size[i] >= s->data_size)
308  return AVERROR_INVALIDDATA;
309  }
310 
311  if (s->tile_size[0] + s->tile_size[1] + s->tile_size[2] + s->tile_size[3] !=
312  s->data_size)
313  return AVERROR_INVALIDDATA;
314  }
315 
316  if (!s->data || !s->data_size)
317  return AVERROR_INVALIDDATA;
318 
319  if (avctx->skip_frame >= AVDISCARD_ALL)
320  return avpkt->size;
321 
322  if ((ret = ff_thread_get_buffer(avctx, p, 0)) < 0)
323  return ret;
324 
325  avctx->bits_per_raw_sample = bps;
326 
327  if (!compressed && s->color_model == 45) {
328  uint16_t *dst = (uint16_t *)p->data[0];
329  GetByteContext gb;
330 
331  bytestream2_init(&gb, s->data, s->data_size);
332  unpack_10bit(&gb, dst, 4, avctx->width, avctx->height, p->linesize[0] / 2);
333  } else if (!compressed) {
334  GetBitContext gbit;
335  const int shift = 16 - bps;
336 
337  ret = init_get_bits8(&gbit, s->data, s->data_size);
338  if (ret < 0)
339  return ret;
340 
341  for (int y = 0; y < avctx->height; y++) {
342  uint16_t *dst = (uint16_t *)(p->data[0] + y * p->linesize[0]);
343 
344  if (get_bits_left(&gbit) < avctx->width * bps)
345  break;
346 
347  for (int x = 0; x < avctx->width; x++)
348  dst[x] = get_bits(&gbit, bps) << shift;
349  }
350  } else {
351  unsigned offset = 0;
352 
353  for (int tile = 0; tile < 4; tile++) {
354  av_packet_unref(s->jpkt);
355  s->jpkt->data = (uint8_t *)s->data + offset;
356  s->jpkt->size = s->tile_size[tile];
357 
358  ret = avcodec_send_packet(s->jpeg_avctx, s->jpkt);
359  if (ret < 0) {
360  av_log(avctx, AV_LOG_ERROR, "Error submitting a packet for decoding\n");
361  return ret;
362  }
363 
364  ret = avcodec_receive_frame(s->jpeg_avctx, s->jpgframe);
365  if (ret < 0 || s->jpgframe->format != AV_PIX_FMT_GRAY16 ||
366  s->jpeg_avctx->width * 2 != avctx->width ||
367  s->jpeg_avctx->height * 2 != avctx->height) {
368  if (ret < 0) {
369  av_log(avctx, AV_LOG_ERROR,
370  "JPEG decoding error (%d).\n", ret);
371  } else {
372  av_log(avctx, AV_LOG_ERROR,
373  "JPEG invalid format.\n");
375  }
376 
377  /* Normally skip, if error explode */
378  if (avctx->err_recognition & AV_EF_EXPLODE)
379  return ret;
380  else
381  return 0;
382  }
383 
384  for (int y = 0; y < s->jpeg_avctx->height; y++) {
385  const int hw = s->jpgframe->width / 2;
386  uint16_t *dst = (uint16_t *)(p->data[0] + (y * 2) * p->linesize[0] + tile * hw * 2);
387  const uint16_t *src = (const uint16_t *)(s->jpgframe->data[0] + y * s->jpgframe->linesize[0]);
388 
389  memcpy(dst, src, hw * 2);
390  src += hw;
391  dst += p->linesize[0] / 2;
392  memcpy(dst, src, hw * 2);
393  }
394 
395  av_frame_unref(s->jpgframe);
396  offset += s->tile_size[tile];
397  }
398  }
399 
400  if (hflip || vflip) {
402  sizeof(int32_t) * 9);
403  if (rotation) {
404  av_display_rotation_set((int32_t *)rotation->data, 0.f);
405  av_display_matrix_flip((int32_t *)rotation->data, hflip, vflip);
406  }
407  }
408 
410  p->flags |= AV_FRAME_FLAG_KEY;
411 
412  *got_frame = 1;
413 
414  return 0;
415 }
416 
418 {
419  CRIContext *s = avctx->priv_data;
420 
421  av_frame_free(&s->jpgframe);
422  av_packet_free(&s->jpkt);
423  avcodec_free_context(&s->jpeg_avctx);
424 
425  return 0;
426 }
427 
429  .p.name = "cri",
430  .p.type = AVMEDIA_TYPE_VIDEO,
431  .p.id = AV_CODEC_ID_CRI,
432  .priv_data_size = sizeof(CRIContext),
435  .close = cri_decode_close,
436  .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS,
437  .caps_internal = FF_CODEC_CAP_INIT_CLEANUP |
439  CODEC_LONG_NAME("Cintel RAW"),
440 };
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:427
AVCodec
AVCodec.
Definition: codec.h:187
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
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: codec_internal.h:42
CRIContext::data
const uint8_t * data
Definition: cri.c:46
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:694
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
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:812
GetByteContext
Definition: bytestream.h:33
CRIContext
Definition: cri.c:39
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:1416
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:100
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
w
uint8_t w
Definition: llviddspenc.c:38
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:66
AVPacket::data
uint8_t * data
Definition: packet.h:522
FFCodec
Definition: codec_internal.h:127
av_display_rotation_set
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure clockwise rotation by the specified angle (in de...
Definition: display.c:51
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:85
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:649
CRIContext::jpkt
AVPacket * jpkt
Definition: cri.c:41
intfloat.h
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:94
AV_PIX_FMT_BAYER_GRBG16
#define AV_PIX_FMT_BAYER_GRBG16
Definition: pixfmt.h:510
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:74
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:361
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 FFCodec caps_internal and use ff_thread_get_buffer() to allocate frames. 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
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:1807
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:335
ff_cri_decoder
const FFCodec ff_cri_decoder
Definition: cri.c:428
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:1770
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:108
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:525
AV_PIX_FMT_GRAY16
#define AV_PIX_FMT_GRAY16
Definition: pixfmt.h:466
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:88
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:180
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:545
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:628
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:154
width
#define width
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
s
#define s(width, name)
Definition: cbs_vp9.c:198
GetByteContext::buffer
const uint8_t * buffer
Definition: bytestream.h:34
CRIContext::tile_size
uint64_t tile_size[4]
Definition: cri.c:48
avcodec_receive_frame
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder or encoder (when the AV_CODEC_FLAG_RECON_FRAME flag is used...
Definition: avcodec.c:715
cri_decode_init
static av_cold int cri_decode_init(AVCodecContext *avctx)
Definition: cri.c:51
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1521
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
decode.h
get_bits.h
key
const char * key
Definition: hwcontext_opencl.c:174
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
AV_PIX_FMT_BAYER_BGGR16
#define AV_PIX_FMT_BAYER_BGGR16
Definition: pixfmt.h:507
CRIContext::jpeg_avctx
AVCodecContext * jpeg_avctx
Definition: cri.c:40
AV_CODEC_CAP_FRAME_THREADS
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
Definition: codec.h:110
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
framerate
float framerate
Definition: av1_levels.c:29
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:169
CRIContext::jpgframe
AVFrame * jpgframe
Definition: cri.c:42
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
AV_PIX_FMT_BAYER_GBRG16
#define AV_PIX_FMT_BAYER_GBRG16
Definition: pixfmt.h:509
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:128
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:981
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:532
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:442
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts.c:365
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:523
codec_internal.h
shift
static int shift(int a, int b)
Definition: bonk.c:262
bps
unsigned bps
Definition: movenc.c:1787
FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
Definition: codec_internal.h:54
AVFrameSideData::data
uint8_t * data
Definition: frame.h:248
height
#define height
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:63
a0
#define a0
Definition: regdef.h:46
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
avcodec_send_packet
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:709
AV_CODEC_ID_CRI
@ AV_CODEC_ID_CRI
Definition: codec_id.h:311
CRIContext::data_size
unsigned data_size
Definition: cri.c:47
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
display.h
a2
#define a2
Definition: regdef.h:48
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:622
AVCodecContext::idct_algo
int idct_algo
IDCT algorithm, see FF_IDCT_* below.
Definition: avcodec.h:1490
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::height
int height
Definition: avcodec.h:625
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:662
cri_decode_frame
static int cri_decode_frame(AVCodecContext *avctx, AVFrame *p, int *got_frame, AVPacket *avpkt)
Definition: cri.c:172
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
ret
ret
Definition: filter_design.txt:187
pos
unsigned int pos
Definition: spdifenc.c:413
AVCodecContext
main external API structure.
Definition: avcodec.h:445
AVRational::den
int den
Denominator.
Definition: rational.h:60
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
CRIContext::color_model
int color_model
Definition: cri.c:45
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:246
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:472
AVPacket
This structure stores compressed data.
Definition: packet.h:499
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:625
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:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:385
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
MKTAG
#define MKTAG(a, b, c, d)
Definition: macros.h:55
h
h
Definition: vp9dsp_template.c:2038
AV_PIX_FMT_BAYER_RGGB16
#define AV_PIX_FMT_BAYER_RGGB16
Definition: pixfmt.h:508
CRIContext::gb
GetByteContext gb
Definition: cri.c:44
a3
#define a3
Definition: regdef.h:49
cri_decode_close
static av_cold int cri_decode_close(AVCodecContext *avctx)
Definition: cri.c:417
skip
static void BS_FUNC() skip(BSCTX *bc, unsigned int n)
Skip n bits in the buffer.
Definition: bitstream_template.h:375