FFmpeg
rawdec.c
Go to the documentation of this file.
1 /*
2  * Raw Video Decoder
3  * Copyright (c) 2001 Fabrice Bellard
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 /**
23  * @file
24  * Raw Video Decoder
25  */
26 
27 #include "avcodec.h"
28 #include "bswapdsp.h"
29 #include "codec_internal.h"
30 #include "decode.h"
31 #include "get_bits.h"
32 #include "internal.h"
33 #include "raw.h"
34 #include "libavutil/avassert.h"
35 #include "libavutil/buffer.h"
36 #include "libavutil/common.h"
37 #include "libavutil/intreadwrite.h"
38 #include "libavutil/imgutils.h"
39 #include "libavutil/opt.h"
40 
41 typedef struct RawVideoContext {
44  int frame_size; /* size of the frame in bytes */
45  int flip;
46  int is_1_2_4_8_bpp; // 1, 2, 4 and 8 bpp in avi/mov, 1 and 8 bpp in nut
47  int is_mono;
48  int is_pal8;
51  int is_yuv2;
52  int is_lt_16bpp; // 16bpp pixfmt and bits_per_coded_sample < 16
53  int tff;
54 
57  unsigned int bitstream_buf_size;
59 
60 static const AVOption options[]={
61 {"top", "top field first", offsetof(RawVideoContext, tff), AV_OPT_TYPE_BOOL, {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM|AV_OPT_FLAG_VIDEO_PARAM},
62 {NULL}
63 };
64 
65 static const AVClass rawdec_class = {
66  .class_name = "rawdec",
67  .option = options,
68  .version = LIBAVUTIL_VERSION_INT,
69 };
70 
72 {
74  const AVPixFmtDescriptor *desc;
75 
76  ff_bswapdsp_init(&context->bbdsp);
77 
78  if ( avctx->codec_tag == MKTAG('r','a','w',' ')
79  || avctx->codec_tag == MKTAG('N','O','1','6'))
81  avctx->bits_per_coded_sample);
82  else if (avctx->codec_tag == MKTAG('W', 'R', 'A', 'W'))
84  avctx->bits_per_coded_sample);
85  else if (avctx->codec_tag && (avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0))
87  else if (avctx->pix_fmt == AV_PIX_FMT_NONE && avctx->bits_per_coded_sample)
89  avctx->bits_per_coded_sample);
90 
92  if (!desc) {
93  av_log(avctx, AV_LOG_ERROR, "Invalid pixel format.\n");
94  return AVERROR(EINVAL);
95  }
96 
97  if (desc->flags & AV_PIX_FMT_FLAG_PAL) {
99  if (!context->palette)
100  return AVERROR(ENOMEM);
101  memset(context->palette->data, 0, AVPALETTE_SIZE);
102  if (avctx->bits_per_coded_sample == 1)
103  memset(context->palette->data, 0xff, 4);
104  }
105 
106  if ((avctx->extradata_size >= 9 &&
107  !memcmp(avctx->extradata + avctx->extradata_size - 9, "BottomUp", 9)) ||
108  avctx->codec_tag == MKTAG('c','y','u','v') ||
109  avctx->codec_tag == MKTAG(3, 0, 0, 0) ||
110  avctx->codec_tag == MKTAG('W','R','A','W'))
111  context->flip = 1;
112 
113  if (avctx->pix_fmt == AV_PIX_FMT_MONOWHITE ||
114  avctx->pix_fmt == AV_PIX_FMT_MONOBLACK)
115  context->is_mono = 1;
116  else if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
117  context->is_pal8 = 1;
118 
119  if (avctx->codec_tag == MKTAG('B','1','W','0') ||
120  avctx->codec_tag == MKTAG('B','0','W','1'))
121  context->is_nut_mono = 1;
122  else if (avctx->codec_tag == MKTAG('P','A','L',8))
123  context->is_nut_pal8 = 1;
124 
125  if (avctx->codec_tag == AV_RL32("yuv2") &&
126  avctx->pix_fmt == AV_PIX_FMT_YUYV422)
127  context->is_yuv2 = 1;
128 
129  return 0;
130 }
131 
132 static void flip(AVCodecContext *avctx, AVFrame *frame)
133 {
134  frame->data[0] += frame->linesize[0] * (avctx->height - 1);
135  frame->linesize[0] *= -1;
136 }
137 
138 /*
139  * Scale sample to 16-bit resolution
140  */
141 #define SCALE16(x, bits) (((x) << (16 - (bits))) | ((x) >> (2 * (bits) - 16)))
142 
143 /**
144  * Scale buffer to 16 bits per coded sample resolution
145  */
146 #define MKSCALE16(name, r16, w16) \
147 static void name(AVCodecContext *avctx, uint8_t * dst, const uint8_t *buf, int buf_size, int packed) \
148 { \
149  int i; \
150  if (!packed) { \
151  for (i = 0; i + 1 < buf_size; i += 2) \
152  w16(dst + i, SCALE16(r16(buf + i), avctx->bits_per_coded_sample)); \
153  } else { \
154  GetBitContext gb; \
155  init_get_bits(&gb, buf, buf_size * 8); \
156  for (i = 0; i < avctx->width * avctx->height; i++) { \
157  int sample = get_bits(&gb, avctx->bits_per_coded_sample); \
158  w16(dst + i*2, SCALE16(sample, avctx->bits_per_coded_sample)); \
159  } \
160  } \
161 }
162 
163 MKSCALE16(scale16be, AV_RB16, AV_WB16)
164 MKSCALE16(scale16le, AV_RL16, AV_WL16)
165 
167  int *got_frame, AVPacket *avpkt)
168 {
169  const AVPixFmtDescriptor *desc;
170  RawVideoContext *context = avctx->priv_data;
171  const uint8_t *buf = avpkt->data;
172  int buf_size = avpkt->size;
173  int linesize_align = 4;
174  int stride;
175  int res, len;
176  int need_copy;
177 
178  if (avctx->width <= 0) {
179  av_log(avctx, AV_LOG_ERROR, "width is not set\n");
180  return AVERROR_INVALIDDATA;
181  }
182  if (avctx->height <= 0) {
183  av_log(avctx, AV_LOG_ERROR, "height is not set\n");
184  return AVERROR_INVALIDDATA;
185  }
186 
187  if (context->is_nut_mono)
188  stride = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
189  else if (context->is_nut_pal8)
190  stride = avctx->width;
191  else
192  stride = avpkt->size / avctx->height;
193 
194  av_log(avctx, AV_LOG_DEBUG, "PACKET SIZE: %d, STRIDE: %d\n", avpkt->size, stride);
195 
196  if (stride == 0 || avpkt->size < stride * avctx->height) {
197  av_log(avctx, AV_LOG_ERROR, "Packet too small (%d)\n", avpkt->size);
198  return AVERROR_INVALIDDATA;
199  }
200 
201  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
202 
203  if ((avctx->bits_per_coded_sample == 8 || avctx->bits_per_coded_sample == 4 ||
204  avctx->bits_per_coded_sample == 2 || avctx->bits_per_coded_sample == 1 ||
205  (avctx->bits_per_coded_sample == 0 && (context->is_nut_pal8 || context->is_mono)) ) &&
206  (context->is_mono || context->is_pal8) &&
207  (!avctx->codec_tag || avctx->codec_tag == MKTAG('r','a','w',' ') ||
208  context->is_nut_mono || context->is_nut_pal8)) {
209  context->is_1_2_4_8_bpp = 1;
210  if (context->is_mono) {
211  int row_bytes = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
212  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt,
213  FFALIGN(row_bytes, 16) * 8,
214  avctx->height, 1);
215  } else
216  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt,
217  FFALIGN(avctx->width, 16),
218  avctx->height, 1);
219  } else {
220  context->is_lt_16bpp = av_get_bits_per_pixel(desc) == 16 && avctx->bits_per_coded_sample > 8 && avctx->bits_per_coded_sample < 16;
221  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt, avctx->width,
222  avctx->height, 1);
223  }
224  if (context->frame_size < 0)
225  return context->frame_size;
226 
227  need_copy = !avpkt->buf || context->is_1_2_4_8_bpp || context->is_yuv2 || context->is_lt_16bpp;
228 
229  frame->pict_type = AV_PICTURE_TYPE_I;
230  frame->key_frame = 1;
231 
232  res = ff_decode_frame_props(avctx, frame);
233  if (res < 0)
234  return res;
235 
236  if (context->tff >= 0) {
237  frame->interlaced_frame = 1;
238  frame->top_field_first = context->tff;
239  }
240 
241  if ((res = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
242  return res;
243 
244  if (need_copy)
245  frame->buf[0] = av_buffer_alloc(FFMAX(context->frame_size, buf_size));
246  else
247  frame->buf[0] = av_buffer_ref(avpkt->buf);
248  if (!frame->buf[0])
249  return AVERROR(ENOMEM);
250 
251  // 1, 2, 4 and 8 bpp in avi/mov, 1 and 8 bpp in nut
252  if (context->is_1_2_4_8_bpp) {
253  int i, j, row_pix = 0;
254  uint8_t *dst = frame->buf[0]->data;
255  buf_size = context->frame_size - (context->is_pal8 ? AVPALETTE_SIZE : 0);
256  if (avctx->bits_per_coded_sample == 8 || context->is_nut_pal8 || context->is_mono) {
257  int pix_per_byte = context->is_mono ? 8 : 1;
258  for (i = 0, j = 0; j < buf_size && i<avpkt->size; i++, j++) {
259  dst[j] = buf[i];
260  row_pix += pix_per_byte;
261  if (row_pix >= avctx->width) {
262  i += stride - (i % stride) - 1;
263  j += 16 - (j % 16) - 1;
264  row_pix = 0;
265  }
266  }
267  } else if (avctx->bits_per_coded_sample == 4) {
268  for (i = 0, j = 0; 2 * j + 1 < buf_size && i<avpkt->size; i++, j++) {
269  dst[2 * j + 0] = buf[i] >> 4;
270  dst[2 * j + 1] = buf[i] & 15;
271  row_pix += 2;
272  if (row_pix >= avctx->width) {
273  i += stride - (i % stride) - 1;
274  j += 8 - (j % 8) - 1;
275  row_pix = 0;
276  }
277  }
278  } else if (avctx->bits_per_coded_sample == 2) {
279  for (i = 0, j = 0; 4 * j + 3 < buf_size && i<avpkt->size; i++, j++) {
280  dst[4 * j + 0] = buf[i] >> 6;
281  dst[4 * j + 1] = buf[i] >> 4 & 3;
282  dst[4 * j + 2] = buf[i] >> 2 & 3;
283  dst[4 * j + 3] = buf[i] & 3;
284  row_pix += 4;
285  if (row_pix >= avctx->width) {
286  i += stride - (i % stride) - 1;
287  j += 4 - (j % 4) - 1;
288  row_pix = 0;
289  }
290  }
291  } else {
292  av_assert0(avctx->bits_per_coded_sample == 1);
293  for (i = 0, j = 0; 8 * j + 7 < buf_size && i<avpkt->size; i++, j++) {
294  dst[8 * j + 0] = buf[i] >> 7;
295  dst[8 * j + 1] = buf[i] >> 6 & 1;
296  dst[8 * j + 2] = buf[i] >> 5 & 1;
297  dst[8 * j + 3] = buf[i] >> 4 & 1;
298  dst[8 * j + 4] = buf[i] >> 3 & 1;
299  dst[8 * j + 5] = buf[i] >> 2 & 1;
300  dst[8 * j + 6] = buf[i] >> 1 & 1;
301  dst[8 * j + 7] = buf[i] & 1;
302  row_pix += 8;
303  if (row_pix >= avctx->width) {
304  i += stride - (i % stride) - 1;
305  j += 2 - (j % 2) - 1;
306  row_pix = 0;
307  }
308  }
309  }
310  linesize_align = 16;
311  buf = dst;
312  } else if (context->is_lt_16bpp) {
313  uint8_t *dst = frame->buf[0]->data;
314  int packed = (avctx->codec_tag & 0xFFFFFF) == MKTAG('B','I','T', 0);
315  int swap = avctx->codec_tag >> 24;
316 
317  if (packed && swap) {
318  av_fast_padded_malloc(&context->bitstream_buf, &context->bitstream_buf_size, buf_size);
319  if (!context->bitstream_buf)
320  return AVERROR(ENOMEM);
321  if (swap == 16)
322  context->bbdsp.bswap16_buf(context->bitstream_buf, (const uint16_t*)buf, buf_size / 2);
323  else if (swap == 32)
324  context->bbdsp.bswap_buf(context->bitstream_buf, (const uint32_t*)buf, buf_size / 4);
325  else
326  return AVERROR_INVALIDDATA;
327  buf = context->bitstream_buf;
328  }
329 
330  if (desc->flags & AV_PIX_FMT_FLAG_BE)
331  scale16be(avctx, dst, buf, buf_size, packed);
332  else
333  scale16le(avctx, dst, buf, buf_size, packed);
334 
335  buf = dst;
336  } else if (need_copy) {
337  memcpy(frame->buf[0]->data, buf, buf_size);
338  buf = frame->buf[0]->data;
339  }
340 
341  if (avctx->codec_tag == MKTAG('A', 'V', '1', 'x') ||
342  avctx->codec_tag == MKTAG('A', 'V', 'u', 'p'))
343  buf += buf_size - context->frame_size;
344 
345  len = context->frame_size - (avctx->pix_fmt==AV_PIX_FMT_PAL8 ? AVPALETTE_SIZE : 0);
346  if (buf_size < len && ((avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0) || !need_copy)) {
347  av_log(avctx, AV_LOG_ERROR, "Invalid buffer size, packet size %d < expected frame_size %d\n", buf_size, len);
348  av_buffer_unref(&frame->buf[0]);
349  return AVERROR(EINVAL);
350  }
351 
352  if ((res = av_image_fill_arrays(frame->data, frame->linesize,
353  buf, avctx->pix_fmt,
354  avctx->width, avctx->height, 1)) < 0) {
355  av_buffer_unref(&frame->buf[0]);
356  return res;
357  }
358 
359  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
360  int ret;
361 
362  if (!context->palette)
364  if (!context->palette) {
365  av_buffer_unref(&frame->buf[0]);
366  return AVERROR(ENOMEM);
367  }
368  ret = av_buffer_make_writable(&context->palette);
369  if (ret < 0) {
370  av_buffer_unref(&frame->buf[0]);
371  return ret;
372  }
373 
374  if (ff_copy_palette(context->palette->data, avpkt, avctx)) {
375  frame->palette_has_changed = 1;
376  } else if (context->is_nut_pal8) {
377  int vid_size = avctx->width * avctx->height;
378  int pal_size = avpkt->size - vid_size;
379 
380  if (avpkt->size > vid_size && pal_size <= AVPALETTE_SIZE) {
381  const uint8_t *pal = avpkt->data + vid_size;
382  memcpy(context->palette->data, pal, pal_size);
383  frame->palette_has_changed = 1;
384  }
385  }
386  }
387 
388  if ((avctx->pix_fmt==AV_PIX_FMT_RGB24 ||
389  avctx->pix_fmt==AV_PIX_FMT_BGR24 ||
390  avctx->pix_fmt==AV_PIX_FMT_GRAY8 ||
391  avctx->pix_fmt==AV_PIX_FMT_RGB555LE ||
392  avctx->pix_fmt==AV_PIX_FMT_RGB555BE ||
393  avctx->pix_fmt==AV_PIX_FMT_RGB565LE ||
394  avctx->pix_fmt==AV_PIX_FMT_MONOWHITE ||
395  avctx->pix_fmt==AV_PIX_FMT_MONOBLACK ||
396  avctx->pix_fmt==AV_PIX_FMT_PAL8) &&
397  FFALIGN(frame->linesize[0], linesize_align) * avctx->height <= buf_size)
398  frame->linesize[0] = FFALIGN(frame->linesize[0], linesize_align);
399 
400  if (avctx->pix_fmt == AV_PIX_FMT_NV12 && avctx->codec_tag == MKTAG('N', 'V', '1', '2') &&
401  FFALIGN(frame->linesize[0], linesize_align) * avctx->height +
402  FFALIGN(frame->linesize[1], linesize_align) * ((avctx->height + 1) / 2) <= buf_size) {
403  int la0 = FFALIGN(frame->linesize[0], linesize_align);
404  frame->data[1] += (la0 - frame->linesize[0]) * avctx->height;
405  frame->linesize[0] = la0;
406  frame->linesize[1] = FFALIGN(frame->linesize[1], linesize_align);
407  }
408 
409  if (avctx->pix_fmt == AV_PIX_FMT_PAL8 && buf_size < context->frame_size) {
410  frame->buf[1] = av_buffer_ref(context->palette);
411  if (!frame->buf[1]) {
412  av_buffer_unref(&frame->buf[0]);
413  return AVERROR(ENOMEM);
414  }
415  frame->data[1] = frame->buf[1]->data;
416  }
417 
418  if (avctx->pix_fmt == AV_PIX_FMT_BGR24 &&
419  ((frame->linesize[0] + 3) & ~3) * avctx->height <= buf_size)
420  frame->linesize[0] = (frame->linesize[0] + 3) & ~3;
421 
422  if (context->flip)
423  flip(avctx, frame);
424 
425  if (avctx->codec_tag == MKTAG('Y', 'V', '1', '2') ||
426  avctx->codec_tag == MKTAG('Y', 'V', '1', '6') ||
427  avctx->codec_tag == MKTAG('Y', 'V', '2', '4') ||
428  avctx->codec_tag == MKTAG('Y', 'V', 'U', '9'))
429  FFSWAP(uint8_t *, frame->data[1], frame->data[2]);
430 
431  if (avctx->codec_tag == AV_RL32("I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
432  frame->data[1] = frame->data[1] + (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
433  frame->data[2] = frame->data[2] + ((avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height)*5/4;
434  }
435 
436  if (avctx->codec_tag == AV_RL32("yuv2") &&
437  avctx->pix_fmt == AV_PIX_FMT_YUYV422) {
438  int x, y;
439  uint8_t *line = frame->data[0];
440  for (y = 0; y < avctx->height; y++) {
441  for (x = 0; x < avctx->width; x++)
442  line[2 * x + 1] ^= 0x80;
443  line += frame->linesize[0];
444  }
445  }
446 
447  if (avctx->codec_tag == AV_RL32("b64a") &&
448  avctx->pix_fmt == AV_PIX_FMT_RGBA64BE) {
449  uint8_t *dst = frame->data[0];
450  uint64_t v;
451  int x, y;
452  for (y = 0; y < avctx->height; y++) {
453  for (x = 0; x >> 3 < avctx->width; x += 8) {
454  v = AV_RB64(&dst[x]);
455  AV_WB64(&dst[x], v << 16 | v >> 48);
456  }
457  dst += frame->linesize[0];
458  }
459  }
460 
461  if (avctx->field_order > AV_FIELD_PROGRESSIVE) { /* we have interlaced material flagged in container */
462  frame->interlaced_frame = 1;
463  if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
464  frame->top_field_first = 1;
465  }
466 
467  *got_frame = 1;
468  return buf_size;
469 }
470 
472 {
474 
475  av_buffer_unref(&context->palette);
476  av_freep(&context->bitstream_buf);
477  return 0;
478 }
479 
481  .p.name = "rawvideo",
482  CODEC_LONG_NAME("raw video"),
483  .p.type = AVMEDIA_TYPE_VIDEO,
484  .p.id = AV_CODEC_ID_RAWVIDEO,
485  .priv_data_size = sizeof(RawVideoContext),
487  .close = raw_close_decoder,
489  .p.priv_class = &rawdec_class,
490  .p.capabilities = AV_CODEC_CAP_PARAM_CHANGE,
491 };
raw_init_decoder
static av_cold int raw_init_decoder(AVCodecContext *avctx)
Definition: rawdec.c:71
RawVideoContext::frame_size
int frame_size
Definition: rawdec.c:44
bswapdsp.h
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: codec_par.h:40
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
opt.h
AV_OPT_FLAG_VIDEO_PARAM
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:284
raw_decode
static int raw_decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
Definition: rawdec.c:166
RawVideoContext::flip
int flip
Definition: rawdec.c:45
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2888
AV_CODEC_ID_RAWVIDEO
@ AV_CODEC_ID_RAWVIDEO
Definition: codec_id.h:65
RawVideoContext::is_nut_mono
int is_nut_mono
Definition: rawdec.c:49
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:330
AV_PIX_FMT_RGBA64BE
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
Definition: pixfmt.h:195
RawVideoContext::bbdsp
BswapDSPContext bbdsp
Definition: rawdec.c:55
internal.h
RawVideoContext::bitstream_buf_size
unsigned int bitstream_buf_size
Definition: rawdec.c:57
AVOption
AVOption.
Definition: opt.h:251
AV_PIX_FMT_MONOWHITE
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:75
FFCodec
Definition: codec_internal.h:127
AV_PIX_FMT_BGR24
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:69
av_get_bits_per_pixel
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
Definition: pixdesc.c:2840
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
AV_PIX_FMT_RGB555BE
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:107
AV_WB64
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
FFCodec::p
AVCodec p
The public AVCodec.
Definition: codec_internal.h:131
raw.h
avassert.h
RawVideoContext::is_lt_16bpp
int is_lt_16bpp
Definition: rawdec.c:52
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
AVCodecContext::extradata_size
int extradata_size
Definition: avcodec.h:528
options
static const AVOption options[]
Definition: rawdec.c:60
FF_CODEC_DECODE_CB
#define FF_CODEC_DECODE_CB(func)
Definition: codec_internal.h:306
intreadwrite.h
frame_size
int frame_size
Definition: mxfenc.c:2205
init
int(* init)(AVBSFContext *ctx)
Definition: dts2pts_bsf.c:365
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
decode.h
get_bits.h
AV_RL16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:94
CODEC_LONG_NAME
#define CODEC_LONG_NAME(str)
Definition: codec_internal.h:272
context
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 default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
Definition: writing_filters.txt:91
PIX_FMT_LIST_AVI
@ PIX_FMT_LIST_AVI
Definition: raw.h:41
RawVideoContext::is_pal8
int is_pal8
Definition: rawdec.c:48
RawVideoContext
Definition: rawdec.c:41
AV_PIX_FMT_RGB565LE
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:106
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
ff_bswapdsp_init
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
NULL
#define NULL
Definition: coverity.c:32
RawVideoContext::is_1_2_4_8_bpp
int is_1_2_4_8_bpp
Definition: rawdec.c:46
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
AV_WB16
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
AV_PIX_FMT_YUYV422
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:67
RawVideoContext::palette
AVBufferRef * palette
Definition: rawdec.c:43
AV_PIX_FMT_MONOBLACK
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
Definition: pixfmt.h:76
AVPALETTE_SIZE
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AV_PIX_FMT_GRAY8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
Definition: pixfmt.h:74
RawVideoContext::is_yuv2
int is_yuv2
Definition: rawdec.c:51
AV_PIX_FMT_RGB24
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:68
RawVideoContext::bitstream_buf
void * bitstream_buf
Definition: rawdec.c:56
flip
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:132
avpriv_pix_fmt_find
enum AVPixelFormat avpriv_pix_fmt_find(enum PixelFormatTagLists list, unsigned fourcc)
Definition: raw.c:353
av_image_fill_arrays
int av_image_fill_arrays(uint8_t *dst_data[4], int dst_linesize[4], const uint8_t *src, enum AVPixelFormat pix_fmt, int width, int height, int align)
Setup the data pointers and linesizes based on the specified image parameters and the provided array.
Definition: imgutils.c:446
codec_internal.h
PIX_FMT_LIST_RAW
@ PIX_FMT_LIST_RAW
Definition: raw.h:40
av_buffer_make_writable
int av_buffer_make_writable(AVBufferRef **pbuf)
Create a writable reference from a given buffer reference, avoiding data copy if possible.
Definition: buffer.c:165
MKSCALE16
#define MKSCALE16(name, r16, w16)
Scale buffer to 16 bits per coded sample resolution.
Definition: rawdec.c:146
buffer.h
RawVideoContext::is_nut_pal8
int is_nut_pal8
Definition: rawdec.c:50
AV_WL16
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
av_image_get_buffer_size
int av_image_get_buffer_size(enum AVPixelFormat pix_fmt, int width, int height, int align)
Return the size in bytes of the amount of data required to store an image with the given parameters.
Definition: imgutils.c:466
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: codec_par.h:41
line
Definition: graph2dot.c:48
av_buffer_alloc
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:77
AVCodecContext::bits_per_coded_sample
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:1480
AV_PIX_FMT_RGB555LE
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
Definition: pixfmt.h:108
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVCodecContext::extradata
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:527
common.h
av_fast_padded_malloc
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:49
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:282
AV_PIX_FMT_FLAG_BE
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:116
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:191
ff_rawvideo_decoder
const FFCodec ff_rawvideo_decoder
Definition: rawdec.c:480
len
int len
Definition: vorbis_enc_data.h:426
AVCodecContext::height
int height
Definition: avcodec.h:598
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:635
avcodec.h
stride
#define stride
Definition: h264pred_template.c:537
AV_PIX_FMT_PAL8
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:77
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_NV12
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:89
FFSWAP
#define FFSWAP(type, a, b)
Definition: macros.h:52
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
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
raw_close_decoder
static av_cold int raw_close_decoder(AVCodecContext *avctx)
Definition: rawdec.c:471
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
ff_decode_frame_props
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: decode.c:1350
AVCodecContext
main external API structure.
Definition: avcodec.h:426
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:65
rawdec_class
static const AVClass rawdec_class
Definition: rawdec.c:65
AV_CODEC_CAP_PARAM_CHANGE
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:115
desc
const char * desc
Definition: libsvtav1.c:83
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
RawVideoContext::tff
int tff
Definition: rawdec.c:53
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVCodecContext::codec_tag
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:451
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
AVPacket
This structure stores compressed data.
Definition: packet.h:351
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:453
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:244
PIX_FMT_LIST_MOV
@ PIX_FMT_LIST_MOV
Definition: raw.h:42
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: codec_par.h:43
imgutils.h
RawVideoContext::av_class
AVClass * av_class
Definition: rawdec.c:42
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
BswapDSPContext
Definition: bswapdsp.h:24
av_image_check_size
int av_image_check_size(unsigned int w, unsigned int h, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of the image can be address...
Definition: imgutils.c:318
ff_copy_palette
int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
Check whether the side-data of src contains a palette of size AVPALETTE_SIZE; if so,...
Definition: decode.c:1674
RawVideoContext::is_mono
int is_mono
Definition: rawdec.c:47
AV_PIX_FMT_FLAG_PAL
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:120
AV_RB64
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_RB64
Definition: bytestream.h:95
AV_RB16
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_WB24 unsigned int_TMPL AV_RB16
Definition: bytestream.h:98