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 || avctx->bits_per_coded_sample == 1 ||
209  (avctx->bits_per_coded_sample == 0 && (context->is_nut_pal8 || context->is_mono)) ) &&
210  (context->is_mono || context->is_pal8) &&
211  (!avctx->codec_tag || avctx->codec_tag == MKTAG('r','a','w',' ') ||
212  context->is_nut_mono || context->is_nut_pal8)) {
213  context->is_1_2_4_8_bpp = 1;
214  if (context->is_mono) {
215  int row_bytes = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
216  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt,
217  FFALIGN(row_bytes, 16) * 8,
218  avctx->height, 1);
219  } else
220  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt,
221  FFALIGN(avctx->width, 16),
222  avctx->height, 1);
223  } else {
224  context->is_lt_16bpp = av_get_bits_per_pixel(desc) == 16 && avctx->bits_per_coded_sample && avctx->bits_per_coded_sample < 16;
225  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt, avctx->width,
226  avctx->height, 1);
227  }
228  if (context->frame_size < 0)
229  return context->frame_size;
230 
231  need_copy = !avpkt->buf || context->is_1_2_4_8_bpp || context->is_yuv2 || context->is_lt_16bpp;
232 
233  frame->pict_type = AV_PICTURE_TYPE_I;
234  frame->key_frame = 1;
235 
236  res = ff_decode_frame_props(avctx, frame);
237  if (res < 0)
238  return res;
239 
240  av_frame_set_pkt_pos (frame, avctx->internal->pkt->pos);
241  av_frame_set_pkt_duration(frame, avctx->internal->pkt->duration);
242 
243  if (context->tff >= 0) {
244  frame->interlaced_frame = 1;
245  frame->top_field_first = context->tff;
246  }
247 
248  if ((res = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
249  return res;
250 
251  if (need_copy)
252  frame->buf[0] = av_buffer_alloc(FFMAX(context->frame_size, buf_size));
253  else
254  frame->buf[0] = av_buffer_ref(avpkt->buf);
255  if (!frame->buf[0])
256  return AVERROR(ENOMEM);
257 
258  // 1, 2, 4 and 8 bpp in avi/mov, 1 and 8 bpp in nut
259  if (context->is_1_2_4_8_bpp) {
260  int i, j, row_pix = 0;
261  uint8_t *dst = frame->buf[0]->data;
262  buf_size = context->frame_size - (context->is_pal8 ? AVPALETTE_SIZE : 0);
263  if (avctx->bits_per_coded_sample == 8 || context->is_nut_pal8 || context->is_mono) {
264  int pix_per_byte = context->is_mono ? 8 : 1;
265  for (i = 0, j = 0; j < buf_size && i<avpkt->size; i++, j++) {
266  dst[j] = buf[i];
267  row_pix += pix_per_byte;
268  if (row_pix >= avctx->width) {
269  i += stride - (i % stride) - 1;
270  j += 16 - (j % 16) - 1;
271  row_pix = 0;
272  }
273  }
274  } else if (avctx->bits_per_coded_sample == 4) {
275  for (i = 0, j = 0; 2 * j + 1 < buf_size && i<avpkt->size; i++, j++) {
276  dst[2 * j + 0] = buf[i] >> 4;
277  dst[2 * j + 1] = buf[i] & 15;
278  row_pix += 2;
279  if (row_pix >= avctx->width) {
280  i += stride - (i % stride) - 1;
281  j += 8 - (j % 8) - 1;
282  row_pix = 0;
283  }
284  }
285  } else if (avctx->bits_per_coded_sample == 2) {
286  for (i = 0, j = 0; 4 * j + 3 < buf_size && i<avpkt->size; i++, j++) {
287  dst[4 * j + 0] = buf[i] >> 6;
288  dst[4 * j + 1] = buf[i] >> 4 & 3;
289  dst[4 * j + 2] = buf[i] >> 2 & 3;
290  dst[4 * j + 3] = buf[i] & 3;
291  row_pix += 4;
292  if (row_pix >= avctx->width) {
293  i += stride - (i % stride) - 1;
294  j += 4 - (j % 4) - 1;
295  row_pix = 0;
296  }
297  }
298  } else {
299  av_assert0(avctx->bits_per_coded_sample == 1);
300  for (i = 0, j = 0; 8 * j + 7 < buf_size && i<avpkt->size; i++, j++) {
301  dst[8 * j + 0] = buf[i] >> 7;
302  dst[8 * j + 1] = buf[i] >> 6 & 1;
303  dst[8 * j + 2] = buf[i] >> 5 & 1;
304  dst[8 * j + 3] = buf[i] >> 4 & 1;
305  dst[8 * j + 4] = buf[i] >> 3 & 1;
306  dst[8 * j + 5] = buf[i] >> 2 & 1;
307  dst[8 * j + 6] = buf[i] >> 1 & 1;
308  dst[8 * j + 7] = buf[i] & 1;
309  row_pix += 8;
310  if (row_pix >= avctx->width) {
311  i += stride - (i % stride) - 1;
312  j += 2 - (j % 2) - 1;
313  row_pix = 0;
314  }
315  }
316  }
317  linesize_align = 16;
318  buf = dst;
319  } else if (context->is_lt_16bpp) {
320  uint8_t *dst = frame->buf[0]->data;
321  int packed = (avctx->codec_tag & 0xFFFFFF) == MKTAG('B','I','T', 0);
322  int swap = avctx->codec_tag >> 24;
323 
324  if (packed && swap) {
325  av_fast_padded_malloc(&context->bitstream_buf, &context->bitstream_buf_size, buf_size);
326  if (!context->bitstream_buf)
327  return AVERROR(ENOMEM);
328  if (swap == 16)
329  context->bbdsp.bswap16_buf(context->bitstream_buf, (const uint16_t*)buf, buf_size / 2);
330  else if (swap == 32)
331  context->bbdsp.bswap_buf(context->bitstream_buf, (const uint32_t*)buf, buf_size / 4);
332  else
333  return AVERROR_INVALIDDATA;
334  buf = context->bitstream_buf;
335  }
336 
337  if (desc->flags & AV_PIX_FMT_FLAG_BE)
338  scale16be(avctx, dst, buf, buf_size, packed);
339  else
340  scale16le(avctx, dst, buf, buf_size, packed);
341 
342  buf = dst;
343  } else if (need_copy) {
344  memcpy(frame->buf[0]->data, buf, buf_size);
345  buf = frame->buf[0]->data;
346  }
347 
348  if (avctx->codec_tag == MKTAG('A', 'V', '1', 'x') ||
349  avctx->codec_tag == MKTAG('A', 'V', 'u', 'p'))
350  buf += buf_size - context->frame_size;
351 
352  len = context->frame_size - (avctx->pix_fmt==AV_PIX_FMT_PAL8 ? AVPALETTE_SIZE : 0);
353  if (buf_size < len && ((avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0) || !need_copy)) {
354  av_log(avctx, AV_LOG_ERROR, "Invalid buffer size, packet size %d < expected frame_size %d\n", buf_size, len);
355  av_buffer_unref(&frame->buf[0]);
356  return AVERROR(EINVAL);
357  }
358 
359  if ((res = av_image_fill_arrays(frame->data, frame->linesize,
360  buf, avctx->pix_fmt,
361  avctx->width, avctx->height, 1)) < 0) {
362  av_buffer_unref(&frame->buf[0]);
363  return res;
364  }
365 
366  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
367  int pal_size;
369  &pal_size);
370  int ret;
371 
372  if (pal && pal_size != AVPALETTE_SIZE) {
373  av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", pal_size);
374  pal = NULL;
375  }
376 
377  if (!context->palette)
379  if (!context->palette) {
380  av_buffer_unref(&frame->buf[0]);
381  return AVERROR(ENOMEM);
382  }
383  ret = av_buffer_make_writable(&context->palette);
384  if (ret < 0) {
385  av_buffer_unref(&frame->buf[0]);
386  return ret;
387  }
388 
389  if (pal) {
390  memcpy(context->palette->data, pal, AVPALETTE_SIZE);
391  frame->palette_has_changed = 1;
392  } else if (context->is_nut_pal8) {
393  int vid_size = avctx->width * avctx->height;
394  int pal_size = avpkt->size - vid_size;
395 
396  if (avpkt->size > vid_size && pal_size <= AVPALETTE_SIZE) {
397  pal = avpkt->data + vid_size;
398  memcpy(context->palette->data, pal, pal_size);
399  frame->palette_has_changed = 1;
400  }
401  }
402  }
403 
404  if ((avctx->pix_fmt==AV_PIX_FMT_RGB24 ||
405  avctx->pix_fmt==AV_PIX_FMT_BGR24 ||
406  avctx->pix_fmt==AV_PIX_FMT_GRAY8 ||
407  avctx->pix_fmt==AV_PIX_FMT_RGB555LE ||
408  avctx->pix_fmt==AV_PIX_FMT_RGB555BE ||
409  avctx->pix_fmt==AV_PIX_FMT_RGB565LE ||
410  avctx->pix_fmt==AV_PIX_FMT_MONOWHITE ||
411  avctx->pix_fmt==AV_PIX_FMT_MONOBLACK ||
412  avctx->pix_fmt==AV_PIX_FMT_PAL8) &&
413  FFALIGN(frame->linesize[0], linesize_align) * avctx->height <= buf_size)
414  frame->linesize[0] = FFALIGN(frame->linesize[0], linesize_align);
415 
416  if (avctx->pix_fmt == AV_PIX_FMT_NV12 && avctx->codec_tag == MKTAG('N', 'V', '1', '2') &&
417  FFALIGN(frame->linesize[0], linesize_align) * avctx->height +
418  FFALIGN(frame->linesize[1], linesize_align) * ((avctx->height + 1) / 2) <= buf_size) {
419  int la0 = FFALIGN(frame->linesize[0], linesize_align);
420  frame->data[1] += (la0 - frame->linesize[0]) * avctx->height;
421  frame->linesize[0] = la0;
422  frame->linesize[1] = FFALIGN(frame->linesize[1], linesize_align);
423  }
424 
425  if ((avctx->pix_fmt == AV_PIX_FMT_PAL8 && buf_size < context->frame_size) ||
426  (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)) {
427  frame->buf[1] = av_buffer_ref(context->palette);
428  if (!frame->buf[1]) {
429  av_buffer_unref(&frame->buf[0]);
430  return AVERROR(ENOMEM);
431  }
432  frame->data[1] = frame->buf[1]->data;
433  }
434 
435  if (avctx->pix_fmt == AV_PIX_FMT_BGR24 &&
436  ((frame->linesize[0] + 3) & ~3) * avctx->height <= buf_size)
437  frame->linesize[0] = (frame->linesize[0] + 3) & ~3;
438 
439  if (context->flip)
440  flip(avctx, frame);
441 
442  if (avctx->codec_tag == MKTAG('Y', 'V', '1', '2') ||
443  avctx->codec_tag == MKTAG('Y', 'V', '1', '6') ||
444  avctx->codec_tag == MKTAG('Y', 'V', '2', '4') ||
445  avctx->codec_tag == MKTAG('Y', 'V', 'U', '9'))
446  FFSWAP(uint8_t *, frame->data[1], frame->data[2]);
447 
448  if (avctx->codec_tag == AV_RL32("I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
449  frame->data[1] = frame->data[1] + (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
450  frame->data[2] = frame->data[2] + ((avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height)*5/4;
451  }
452 
453  if (avctx->codec_tag == AV_RL32("yuv2") &&
454  avctx->pix_fmt == AV_PIX_FMT_YUYV422) {
455  int x, y;
456  uint8_t *line = frame->data[0];
457  for (y = 0; y < avctx->height; y++) {
458  for (x = 0; x < avctx->width; x++)
459  line[2 * x + 1] ^= 0x80;
460  line += frame->linesize[0];
461  }
462  }
463 
464  if (avctx->codec_tag == AV_RL32("b64a") &&
465  avctx->pix_fmt == AV_PIX_FMT_RGBA64BE) {
466  uint8_t *dst = frame->data[0];
467  uint64_t v;
468  int x;
469  for (x = 0; x >> 3 < avctx->width * avctx->height; x += 8) {
470  v = AV_RB64(&dst[x]);
471  AV_WB64(&dst[x], v << 16 | v >> 48);
472  }
473  }
474 
475  if (avctx->field_order > AV_FIELD_PROGRESSIVE) { /* we have interlaced material flagged in container */
476  frame->interlaced_frame = 1;
477  if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
478  frame->top_field_first = 1;
479  }
480 
481  *got_frame = 1;
482  return buf_size;
483 }
484 
486 {
487  RawVideoContext *context = avctx->priv_data;
488 
489  av_buffer_unref(&context->palette);
490  return 0;
491 }
492 
494  .name = "rawvideo",
495  .long_name = NULL_IF_CONFIG_SMALL("raw video"),
496  .type = AVMEDIA_TYPE_VIDEO,
497  .id = AV_CODEC_ID_RAWVIDEO,
498  .priv_data_size = sizeof(RawVideoContext),
500  .close = raw_close_decoder,
501  .decode = raw_decode,
502  .priv_class = &rawdec_class,
503  .capabilities = AV_CODEC_CAP_PARAM_CHANGE,
504 };
#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
int av_buffer_make_writable(AVBufferRef **pbuf)
Create a writable reference from a given buffer reference, avoiding data copy if possible.
Definition: buffer.c:150
#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:2332
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184
AVCodec ff_rawvideo_decoder
Definition: rawdec.c:493
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
misc image utilities
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
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:367
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: bswapdsp.h:26
const char * desc
Definition: nvenc.c:60
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:2284
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:1904
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:3601
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
#define AV_WB64(p, v)
Definition: intreadwrite.h:433
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:870
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:217
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:1791
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:322
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:3071
#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:3608
#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:1030
int frame_size
Definition: mxfenc.c:1820
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:282
main external API structure.
Definition: avcodec.h:1676
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:1708
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:63
void * buf
Definition: avisynth_c.h:690
int extradata_size
Definition: avcodec.h:1792
Describe the class of an AVClass context structure.
Definition: log.h:67
static av_cold int raw_close_decoder(AVCodecContext *avctx)
Definition: rawdec.c:485
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:277
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:332
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
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
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:87
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:1030
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:1718
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:327
int len
const PixelFormatTag avpriv_pix_fmt_bps_avi[]
Definition: raw.c:299
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:253
const PixelFormatTag avpriv_pix_fmt_bps_mov[]
Definition: raw.c:312
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: ffmpeg.c:2045
uint8_t * av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:339
#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:1578
static const AVClass rawdec_class
Definition: rawdec.c:63