FFmpeg
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
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 "get_bits.h"
30 #include "internal.h"
31 #include "raw.h"
32 #include "libavutil/avassert.h"
33 #include "libavutil/buffer.h"
34 #include "libavutil/common.h"
35 #include "libavutil/intreadwrite.h"
36 #include "libavutil/imgutils.h"
37 #include "libavutil/opt.h"
38 
39 typedef struct RawVideoContext {
42  int frame_size; /* size of the frame in bytes */
43  int flip;
44  int is_1_2_4_8_bpp; // 1, 2, 4 and 8 bpp in avi/mov, 1 and 8 bpp in nut
45  int is_mono;
46  int is_pal8;
49  int is_yuv2;
50  int is_lt_16bpp; // 16bpp pixfmt and bits_per_coded_sample < 16
51  int tff;
52 
55  unsigned int bitstream_buf_size;
57 
58 static const AVOption options[]={
59 {"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},
60 {NULL}
61 };
62 
63 static const AVClass rawdec_class = {
64  .class_name = "rawdec",
65  .option = options,
66  .version = LIBAVUTIL_VERSION_INT,
67 };
68 
70 {
71  RawVideoContext *context = avctx->priv_data;
72  const AVPixFmtDescriptor *desc;
73 
74  ff_bswapdsp_init(&context->bbdsp);
75 
76  if ( avctx->codec_tag == MKTAG('r','a','w',' ')
77  || avctx->codec_tag == MKTAG('N','O','1','6'))
79  avctx->bits_per_coded_sample);
80  else if (avctx->codec_tag == MKTAG('W', 'R', 'A', 'W'))
82  avctx->bits_per_coded_sample);
83  else if (avctx->codec_tag && (avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0))
85  else if (avctx->pix_fmt == AV_PIX_FMT_NONE && avctx->bits_per_coded_sample)
87  avctx->bits_per_coded_sample);
88 
89  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
90  if (!desc) {
91  av_log(avctx, AV_LOG_ERROR, "Invalid pixel format.\n");
92  return AVERROR(EINVAL);
93  }
94 
97  if (!context->palette)
98  return AVERROR(ENOMEM);
99  if (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
100  avpriv_set_systematic_pal2((uint32_t*)context->palette->data, avctx->pix_fmt);
101  else {
102  memset(context->palette->data, 0, AVPALETTE_SIZE);
103  if (avctx->bits_per_coded_sample == 1)
104  memset(context->palette->data, 0xff, 4);
105  }
106  }
107 
108  if ((avctx->extradata_size >= 9 &&
109  !memcmp(avctx->extradata + avctx->extradata_size - 9, "BottomUp", 9)) ||
110  avctx->codec_tag == MKTAG('c','y','u','v') ||
111  avctx->codec_tag == MKTAG(3, 0, 0, 0) ||
112  avctx->codec_tag == MKTAG('W','R','A','W'))
113  context->flip = 1;
114 
115  if (avctx->pix_fmt == AV_PIX_FMT_MONOWHITE ||
116  avctx->pix_fmt == AV_PIX_FMT_MONOBLACK)
117  context->is_mono = 1;
118  else if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
119  context->is_pal8 = 1;
120 
121  if (avctx->codec_tag == MKTAG('B','1','W','0') ||
122  avctx->codec_tag == MKTAG('B','0','W','1'))
123  context->is_nut_mono = 1;
124  else if (avctx->codec_tag == MKTAG('P','A','L',8))
125  context->is_nut_pal8 = 1;
126 
127  if (avctx->codec_tag == AV_RL32("yuv2") &&
128  avctx->pix_fmt == AV_PIX_FMT_YUYV422)
129  context->is_yuv2 = 1;
130 
131  return 0;
132 }
133 
134 static void flip(AVCodecContext *avctx, AVFrame *frame)
135 {
136  frame->data[0] += frame->linesize[0] * (avctx->height - 1);
137  frame->linesize[0] *= -1;
138 }
139 
140 /*
141  * Scale sample to 16-bit resolution
142  */
143 #define SCALE16(x, bits) (((x) << (16 - (bits))) | ((x) >> (2 * (bits) - 16)))
144 
145 /**
146  * Scale buffer to 16 bits per coded sample resolution
147  */
148 #define MKSCALE16(name, r16, w16) \
149 static void name(AVCodecContext *avctx, uint8_t * dst, const uint8_t *buf, int buf_size, int packed) \
150 { \
151  int i; \
152  if (!packed) { \
153  for (i = 0; i + 1 < buf_size; i += 2) \
154  w16(dst + i, SCALE16(r16(buf + i), avctx->bits_per_coded_sample)); \
155  } else { \
156  GetBitContext gb; \
157  init_get_bits(&gb, buf, buf_size * 8); \
158  for (i = 0; i < avctx->width * avctx->height; i++) { \
159  int sample = get_bits(&gb, avctx->bits_per_coded_sample); \
160  w16(dst + i*2, SCALE16(sample, avctx->bits_per_coded_sample)); \
161  } \
162  } \
163 }
164 
165 MKSCALE16(scale16be, AV_RB16, AV_WB16)
166 MKSCALE16(scale16le, AV_RL16, AV_WL16)
167 
168 static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame,
169  AVPacket *avpkt)
170 {
171  const AVPixFmtDescriptor *desc;
172  RawVideoContext *context = avctx->priv_data;
173  const uint8_t *buf = avpkt->data;
174  int buf_size = avpkt->size;
175  int linesize_align = 4;
176  int stride;
177  int res, len;
178  int need_copy;
179 
180  AVFrame *frame = data;
181 
182  if (avctx->width <= 0) {
183  av_log(avctx, AV_LOG_ERROR, "width is not set\n");
184  return AVERROR_INVALIDDATA;
185  }
186  if (avctx->height <= 0) {
187  av_log(avctx, AV_LOG_ERROR, "height is not set\n");
188  return AVERROR_INVALIDDATA;
189  }
190 
191  if (context->is_nut_mono)
192  stride = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
193  else if (context->is_nut_pal8)
194  stride = avctx->width;
195  else
196  stride = avpkt->size / avctx->height;
197 
198  av_log(avctx, AV_LOG_DEBUG, "PACKET SIZE: %d, STRIDE: %d\n", avpkt->size, stride);
199 
200  if (stride == 0 || avpkt->size < stride * avctx->height) {
201  av_log(avctx, AV_LOG_ERROR, "Packet too small (%d)\n", avpkt->size);
202  return AVERROR_INVALIDDATA;
203  }
204 
205  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
206 
207  if ((avctx->bits_per_coded_sample == 8 || avctx->bits_per_coded_sample == 4
208  || avctx->bits_per_coded_sample <= 2) &&
209  (context->is_mono || context->is_pal8) &&
210  (!avctx->codec_tag || avctx->codec_tag == MKTAG('r','a','w',' ') ||
211  context->is_nut_mono || context->is_nut_pal8)) {
212  context->is_1_2_4_8_bpp = 1;
213  if (context->is_mono) {
214  int row_bytes = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
215  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt,
216  FFALIGN(row_bytes, 16) * 8,
217  avctx->height, 1);
218  } else
219  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt,
220  FFALIGN(avctx->width, 16),
221  avctx->height, 1);
222  } else {
223  context->is_lt_16bpp = av_get_bits_per_pixel(desc) == 16 && avctx->bits_per_coded_sample && avctx->bits_per_coded_sample < 16;
224  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt, avctx->width,
225  avctx->height, 1);
226  }
227  if (context->frame_size < 0)
228  return context->frame_size;
229 
230  need_copy = !avpkt->buf || context->is_1_2_4_8_bpp || context->is_yuv2 || context->is_lt_16bpp;
231 
232  frame->pict_type = AV_PICTURE_TYPE_I;
233  frame->key_frame = 1;
234 
235  res = ff_decode_frame_props(avctx, frame);
236  if (res < 0)
237  return res;
238 
239  av_frame_set_pkt_pos (frame, avctx->internal->pkt->pos);
240  av_frame_set_pkt_duration(frame, avctx->internal->pkt->duration);
241 
242  if (context->tff >= 0) {
243  frame->interlaced_frame = 1;
244  frame->top_field_first = context->tff;
245  }
246 
247  if ((res = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
248  return res;
249 
250  if (need_copy)
251  frame->buf[0] = av_buffer_alloc(FFMAX(context->frame_size, buf_size));
252  else
253  frame->buf[0] = av_buffer_ref(avpkt->buf);
254  if (!frame->buf[0])
255  return AVERROR(ENOMEM);
256 
257  // 1, 2, 4 and 8 bpp in avi/mov, 1 and 8 bpp in nut
258  if (context->is_1_2_4_8_bpp) {
259  int i, j, row_pix = 0;
260  uint8_t *dst = frame->buf[0]->data;
261  buf_size = context->frame_size - (context->is_pal8 ? AVPALETTE_SIZE : 0);
262  if (avctx->bits_per_coded_sample == 8 || context->is_nut_pal8 || context->is_mono) {
263  int pix_per_byte = context->is_mono ? 8 : 1;
264  for (i = 0, j = 0; j < buf_size && i<avpkt->size; i++, j++) {
265  dst[j] = buf[i];
266  row_pix += pix_per_byte;
267  if (row_pix >= avctx->width) {
268  i += stride - (i % stride) - 1;
269  j += 16 - (j % 16) - 1;
270  row_pix = 0;
271  }
272  }
273  } else if (avctx->bits_per_coded_sample == 4) {
274  for (i = 0, j = 0; 2 * j + 1 < buf_size && i<avpkt->size; i++, j++) {
275  dst[2 * j + 0] = buf[i] >> 4;
276  dst[2 * j + 1] = buf[i] & 15;
277  row_pix += 2;
278  if (row_pix >= avctx->width) {
279  i += stride - (i % stride) - 1;
280  j += 8 - (j % 8) - 1;
281  row_pix = 0;
282  }
283  }
284  } else if (avctx->bits_per_coded_sample == 2) {
285  for (i = 0, j = 0; 4 * j + 3 < buf_size && i<avpkt->size; i++, j++) {
286  dst[4 * j + 0] = buf[i] >> 6;
287  dst[4 * j + 1] = buf[i] >> 4 & 3;
288  dst[4 * j + 2] = buf[i] >> 2 & 3;
289  dst[4 * j + 3] = buf[i] & 3;
290  row_pix += 4;
291  if (row_pix >= avctx->width) {
292  i += stride - (i % stride) - 1;
293  j += 4 - (j % 4) - 1;
294  row_pix = 0;
295  }
296  }
297  } else {
298  av_assert0(avctx->bits_per_coded_sample == 1);
299  for (i = 0, j = 0; 8 * j + 7 < buf_size && i<avpkt->size; i++, j++) {
300  dst[8 * j + 0] = buf[i] >> 7;
301  dst[8 * j + 1] = buf[i] >> 6 & 1;
302  dst[8 * j + 2] = buf[i] >> 5 & 1;
303  dst[8 * j + 3] = buf[i] >> 4 & 1;
304  dst[8 * j + 4] = buf[i] >> 3 & 1;
305  dst[8 * j + 5] = buf[i] >> 2 & 1;
306  dst[8 * j + 6] = buf[i] >> 1 & 1;
307  dst[8 * j + 7] = buf[i] & 1;
308  row_pix += 8;
309  if (row_pix >= avctx->width) {
310  i += stride - (i % stride) - 1;
311  j += 2 - (j % 2) - 1;
312  row_pix = 0;
313  }
314  }
315  }
316  linesize_align = 16;
317  buf = dst;
318  } else if (context->is_lt_16bpp) {
319  uint8_t *dst = frame->buf[0]->data;
320  int packed = (avctx->codec_tag & 0xFFFFFF) == MKTAG('B','I','T', 0);
321  int swap = avctx->codec_tag >> 24;
322 
323  if (packed && swap) {
324  av_fast_padded_malloc(&context->bitstream_buf, &context->bitstream_buf_size, buf_size);
325  if (!context->bitstream_buf)
326  return AVERROR(ENOMEM);
327  if (swap == 16)
328  context->bbdsp.bswap16_buf(context->bitstream_buf, (const uint16_t*)buf, buf_size / 2);
329  else if (swap == 32)
330  context->bbdsp.bswap_buf(context->bitstream_buf, (const uint32_t*)buf, buf_size / 4);
331  else
332  return AVERROR_INVALIDDATA;
333  buf = context->bitstream_buf;
334  }
335 
336  if (desc->flags & AV_PIX_FMT_FLAG_BE)
337  scale16be(avctx, dst, buf, buf_size, packed);
338  else
339  scale16le(avctx, dst, buf, buf_size, packed);
340 
341  buf = dst;
342  } else if (need_copy) {
343  memcpy(frame->buf[0]->data, buf, buf_size);
344  buf = frame->buf[0]->data;
345  }
346 
347  if (avctx->codec_tag == MKTAG('A', 'V', '1', 'x') ||
348  avctx->codec_tag == MKTAG('A', 'V', 'u', 'p'))
349  buf += buf_size - context->frame_size;
350 
351  len = context->frame_size - (avctx->pix_fmt==AV_PIX_FMT_PAL8 ? AVPALETTE_SIZE : 0);
352  if (buf_size < len && ((avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0) || !need_copy)) {
353  av_log(avctx, AV_LOG_ERROR, "Invalid buffer size, packet size %d < expected frame_size %d\n", buf_size, len);
354  av_buffer_unref(&frame->buf[0]);
355  return AVERROR(EINVAL);
356  }
357 
358  if ((res = av_image_fill_arrays(frame->data, frame->linesize,
359  buf, avctx->pix_fmt,
360  avctx->width, avctx->height, 1)) < 0) {
361  av_buffer_unref(&frame->buf[0]);
362  return res;
363  }
364 
365  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
367  NULL);
368  if (pal) {
369  av_buffer_unref(&context->palette);
371  if (!context->palette) {
372  av_buffer_unref(&frame->buf[0]);
373  return AVERROR(ENOMEM);
374  }
375  memcpy(context->palette->data, pal, AVPALETTE_SIZE);
376  frame->palette_has_changed = 1;
377  } else if (context->is_nut_pal8) {
378  int vid_size = avctx->width * avctx->height;
379  if (avpkt->size - vid_size) {
380  pal = avpkt->data + vid_size;
381  memcpy(context->palette->data, pal, avpkt->size - vid_size);
382  frame->palette_has_changed = 1;
383  }
384  }
385  }
386 
387  if ((avctx->pix_fmt==AV_PIX_FMT_RGB24 ||
388  avctx->pix_fmt==AV_PIX_FMT_BGR24 ||
389  avctx->pix_fmt==AV_PIX_FMT_GRAY8 ||
390  avctx->pix_fmt==AV_PIX_FMT_RGB555LE ||
391  avctx->pix_fmt==AV_PIX_FMT_RGB555BE ||
392  avctx->pix_fmt==AV_PIX_FMT_RGB565LE ||
393  avctx->pix_fmt==AV_PIX_FMT_MONOWHITE ||
394  avctx->pix_fmt==AV_PIX_FMT_MONOBLACK ||
395  avctx->pix_fmt==AV_PIX_FMT_PAL8) &&
396  FFALIGN(frame->linesize[0], linesize_align) * avctx->height <= buf_size)
397  frame->linesize[0] = FFALIGN(frame->linesize[0], linesize_align);
398 
399  if (avctx->pix_fmt == AV_PIX_FMT_NV12 && avctx->codec_tag == MKTAG('N', 'V', '1', '2') &&
400  FFALIGN(frame->linesize[0], linesize_align) * avctx->height +
401  FFALIGN(frame->linesize[1], linesize_align) * ((avctx->height + 1) / 2) <= buf_size) {
402  int la0 = FFALIGN(frame->linesize[0], linesize_align);
403  frame->data[1] += (la0 - frame->linesize[0]) * avctx->height;
404  frame->linesize[0] = la0;
405  frame->linesize[1] = FFALIGN(frame->linesize[1], linesize_align);
406  }
407 
408  if ((avctx->pix_fmt == AV_PIX_FMT_PAL8 && buf_size < context->frame_size) ||
409  (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)) {
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->field_order > AV_FIELD_PROGRESSIVE) { /* we have interlaced material flagged in container */
448  frame->interlaced_frame = 1;
449  if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
450  frame->top_field_first = 1;
451  }
452 
453  *got_frame = 1;
454  return buf_size;
455 }
456 
458 {
459  RawVideoContext *context = avctx->priv_data;
460 
461  av_buffer_unref(&context->palette);
462  return 0;
463 }
464 
466  .name = "rawvideo",
467  .long_name = NULL_IF_CONFIG_SMALL("raw video"),
468  .type = AVMEDIA_TYPE_VIDEO,
469  .id = AV_CODEC_ID_RAWVIDEO,
470  .priv_data_size = sizeof(RawVideoContext),
472  .close = raw_close_decoder,
473  .decode = raw_decode,
474  .priv_class = &rawdec_class,
475  .capabilities = AV_CODEC_CAP_PARAM_CHANGE,
476 };
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:132
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
Definition: bswapdsp.h:25
#define NULL
Definition: coverity.c:32
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
int is_nut_mono
Definition: rawdec.c:47
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:124
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2222
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
AVCodec ff_rawvideo_decoder
Definition: rawdec.c:465
AVOption.
Definition: opt.h:245
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
misc image utilities
#define LIBAVUTIL_VERSION_INT
Definition: version.h:70
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: pixfmt.h:64
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:363
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: bswapdsp.h:26
const char * desc
Definition: nvenc.c:89
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
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:2174
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:116
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:341
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1876
void av_frame_set_pkt_duration(AVFrame *frame, int64_t val)
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:120
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:87
static const AVOption options[]
Definition: rawdec.c:58
int frame_size
Definition: rawdec.c:42
AVCodec.
Definition: avcodec.h:3541
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:114
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:72
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
uint8_t
#define av_cold
Definition: attributes.h:82
8 bits with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:73
AVOptions.
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:151
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: utils.c:851
const PixelFormatTag ff_raw_pix_fmt_tags[]
Definition: raw.c:31
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1763
BswapDSPContext bbdsp
Definition: rawdec.c:53
static AVFrame * frame
unsigned int bitstream_buf_size
Definition: rawdec.c:55
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:318
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:3041
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
#define FFALIGN(x, a)
Definition: macros.h:48
#define av_log(a,...)
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:361
int is_lt_16bpp
Definition: rawdec.c:50
int is_1_2_4_8_bpp
Definition: rawdec.c:44
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void * bitstream_buf
Definition: rawdec.c:54
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:134
#define AVERROR(e)
Definition: error.h:43
AVBufferRef * palette
Definition: rawdec.c:41
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:90
Definition: graph2dot.c:48
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
Definition: avcodec.h:3548
#define FFMAX(a, b)
Definition: common.h:94
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
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:251
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:258
Raw Video Codec.
static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: rawdec.c:168
#define AV_PIX_FMT_FLAG_PSEUDOPAL
The pixel format is "pseudo-paletted".
Definition: pixdesc.h:158
void av_frame_set_pkt_pos(AVFrame *frame, int64_t val)
int is_nut_pal8
Definition: rawdec.c:48
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:65
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:1009
int frame_size
Definition: mxfenc.c:1821
Libavcodec external API header.
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:66
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:215
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:281
main external API structure.
Definition: avcodec.h:1648
uint8_t * data
The data buffer.
Definition: buffer.h:89
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1680
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:63
void * buf
Definition: avisynth_c.h:553
int extradata_size
Definition: avcodec.h:1764
Describe the class of an AVClass context structure.
Definition: log.h:67
static av_cold int raw_close_decoder(AVCodecContext *avctx)
Definition: rawdec.c:457
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:276
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:328
refcounted data buffer API
AVClass * av_class
Definition: rawdec.c:40
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
Definition: pixfmt.h:115
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198
#define MKSCALE16(name, r16, w16)
Scale buffer to 16 bits per coded sample resolution.
Definition: rawdec.c:148
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:722
A reference to a data buffer.
Definition: buffer.h:81
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:72
Y , 8bpp.
Definition: pixfmt.h:70
common internal api header.
common internal and external API header
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb...
Definition: pixfmt.h:71
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: avcodec.h:1026
static av_cold int raw_init_decoder(AVCodecContext *avctx)
Definition: rawdec.c:69
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:92
#define AV_WL16(p, v)
Definition: intreadwrite.h:412
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
Definition: pixdesc.h:128
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1690
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:323
int len
const PixelFormatTag avpriv_pix_fmt_bps_avi[]
Definition: raw.c:285
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:253
const PixelFormatTag avpriv_pix_fmt_bps_mov[]
Definition: raw.c:298
uint8_t * av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:334
#define FFSWAP(type, a, b)
Definition: common.h:99
#define stride
#define MKTAG(a, b, c, d)
Definition: common.h:342
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1556
static const AVClass rawdec_class
Definition: rawdec.c:63