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 
95  if (desc->flags & (AV_PIX_FMT_FLAG_PAL | FF_PSEUDOPAL)) {
97  if (!context->palette)
98  return AVERROR(ENOMEM);
99 #if FF_API_PSEUDOPAL
100  if (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
101  avpriv_set_systematic_pal2((uint32_t*)context->palette->data, avctx->pix_fmt);
102 #endif
103  else {
104  memset(context->palette->data, 0, AVPALETTE_SIZE);
105  if (avctx->bits_per_coded_sample == 1)
106  memset(context->palette->data, 0xff, 4);
107  }
108  }
109 
110  if ((avctx->extradata_size >= 9 &&
111  !memcmp(avctx->extradata + avctx->extradata_size - 9, "BottomUp", 9)) ||
112  avctx->codec_tag == MKTAG('c','y','u','v') ||
113  avctx->codec_tag == MKTAG(3, 0, 0, 0) ||
114  avctx->codec_tag == MKTAG('W','R','A','W'))
115  context->flip = 1;
116 
117  if (avctx->pix_fmt == AV_PIX_FMT_MONOWHITE ||
118  avctx->pix_fmt == AV_PIX_FMT_MONOBLACK)
119  context->is_mono = 1;
120  else if (avctx->pix_fmt == AV_PIX_FMT_PAL8)
121  context->is_pal8 = 1;
122 
123  if (avctx->codec_tag == MKTAG('B','1','W','0') ||
124  avctx->codec_tag == MKTAG('B','0','W','1'))
125  context->is_nut_mono = 1;
126  else if (avctx->codec_tag == MKTAG('P','A','L',8))
127  context->is_nut_pal8 = 1;
128 
129  if (avctx->codec_tag == AV_RL32("yuv2") &&
130  avctx->pix_fmt == AV_PIX_FMT_YUYV422)
131  context->is_yuv2 = 1;
132 
133  return 0;
134 }
135 
136 static void flip(AVCodecContext *avctx, AVFrame *frame)
137 {
138  frame->data[0] += frame->linesize[0] * (avctx->height - 1);
139  frame->linesize[0] *= -1;
140 }
141 
142 /*
143  * Scale sample to 16-bit resolution
144  */
145 #define SCALE16(x, bits) (((x) << (16 - (bits))) | ((x) >> (2 * (bits) - 16)))
146 
147 /**
148  * Scale buffer to 16 bits per coded sample resolution
149  */
150 #define MKSCALE16(name, r16, w16) \
151 static void name(AVCodecContext *avctx, uint8_t * dst, const uint8_t *buf, int buf_size, int packed) \
152 { \
153  int i; \
154  if (!packed) { \
155  for (i = 0; i + 1 < buf_size; i += 2) \
156  w16(dst + i, SCALE16(r16(buf + i), avctx->bits_per_coded_sample)); \
157  } else { \
158  GetBitContext gb; \
159  init_get_bits(&gb, buf, buf_size * 8); \
160  for (i = 0; i < avctx->width * avctx->height; i++) { \
161  int sample = get_bits(&gb, avctx->bits_per_coded_sample); \
162  w16(dst + i*2, SCALE16(sample, avctx->bits_per_coded_sample)); \
163  } \
164  } \
165 }
166 
167 MKSCALE16(scale16be, AV_RB16, AV_WB16)
168 MKSCALE16(scale16le, AV_RL16, AV_WL16)
169 
170 static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame,
171  AVPacket *avpkt)
172 {
173  const AVPixFmtDescriptor *desc;
174  RawVideoContext *context = avctx->priv_data;
175  const uint8_t *buf = avpkt->data;
176  int buf_size = avpkt->size;
177  int linesize_align = 4;
178  int stride;
179  int res, len;
180  int need_copy;
181 
182  AVFrame *frame = data;
183 
184  if (avctx->width <= 0) {
185  av_log(avctx, AV_LOG_ERROR, "width is not set\n");
186  return AVERROR_INVALIDDATA;
187  }
188  if (avctx->height <= 0) {
189  av_log(avctx, AV_LOG_ERROR, "height is not set\n");
190  return AVERROR_INVALIDDATA;
191  }
192 
193  if (context->is_nut_mono)
194  stride = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
195  else if (context->is_nut_pal8)
196  stride = avctx->width;
197  else
198  stride = avpkt->size / avctx->height;
199 
200  av_log(avctx, AV_LOG_DEBUG, "PACKET SIZE: %d, STRIDE: %d\n", avpkt->size, stride);
201 
202  if (stride == 0 || avpkt->size < stride * avctx->height) {
203  av_log(avctx, AV_LOG_ERROR, "Packet too small (%d)\n", avpkt->size);
204  return AVERROR_INVALIDDATA;
205  }
206 
207  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
208 
209  if ((avctx->bits_per_coded_sample == 8 || avctx->bits_per_coded_sample == 4 ||
210  avctx->bits_per_coded_sample == 2 || avctx->bits_per_coded_sample == 1 ||
211  (avctx->bits_per_coded_sample == 0 && (context->is_nut_pal8 || context->is_mono)) ) &&
212  (context->is_mono || context->is_pal8) &&
213  (!avctx->codec_tag || avctx->codec_tag == MKTAG('r','a','w',' ') ||
214  context->is_nut_mono || context->is_nut_pal8)) {
215  context->is_1_2_4_8_bpp = 1;
216  if (context->is_mono) {
217  int row_bytes = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
218  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt,
219  FFALIGN(row_bytes, 16) * 8,
220  avctx->height, 1);
221  } else
222  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt,
223  FFALIGN(avctx->width, 16),
224  avctx->height, 1);
225  } else {
226  context->is_lt_16bpp = av_get_bits_per_pixel(desc) == 16 && avctx->bits_per_coded_sample && avctx->bits_per_coded_sample < 16;
227  context->frame_size = av_image_get_buffer_size(avctx->pix_fmt, avctx->width,
228  avctx->height, 1);
229  }
230  if (context->frame_size < 0)
231  return context->frame_size;
232 
233  need_copy = !avpkt->buf || context->is_1_2_4_8_bpp || context->is_yuv2 || context->is_lt_16bpp;
234 
235  frame->pict_type = AV_PICTURE_TYPE_I;
236  frame->key_frame = 1;
237 
238  res = ff_decode_frame_props(avctx, frame);
239  if (res < 0)
240  return res;
241 
242  frame->pkt_pos = avctx->internal->last_pkt_props->pos;
243  frame->pkt_duration = avctx->internal->last_pkt_props->duration;
244 
245  if (context->tff >= 0) {
246  frame->interlaced_frame = 1;
247  frame->top_field_first = context->tff;
248  }
249 
250  if ((res = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
251  return res;
252 
253  if (need_copy)
254  frame->buf[0] = av_buffer_alloc(FFMAX(context->frame_size, buf_size));
255  else
256  frame->buf[0] = av_buffer_ref(avpkt->buf);
257  if (!frame->buf[0])
258  return AVERROR(ENOMEM);
259 
260  // 1, 2, 4 and 8 bpp in avi/mov, 1 and 8 bpp in nut
261  if (context->is_1_2_4_8_bpp) {
262  int i, j, row_pix = 0;
263  uint8_t *dst = frame->buf[0]->data;
264  buf_size = context->frame_size - (context->is_pal8 ? AVPALETTE_SIZE : 0);
265  if (avctx->bits_per_coded_sample == 8 || context->is_nut_pal8 || context->is_mono) {
266  int pix_per_byte = context->is_mono ? 8 : 1;
267  for (i = 0, j = 0; j < buf_size && i<avpkt->size; i++, j++) {
268  dst[j] = buf[i];
269  row_pix += pix_per_byte;
270  if (row_pix >= avctx->width) {
271  i += stride - (i % stride) - 1;
272  j += 16 - (j % 16) - 1;
273  row_pix = 0;
274  }
275  }
276  } else if (avctx->bits_per_coded_sample == 4) {
277  for (i = 0, j = 0; 2 * j + 1 < buf_size && i<avpkt->size; i++, j++) {
278  dst[2 * j + 0] = buf[i] >> 4;
279  dst[2 * j + 1] = buf[i] & 15;
280  row_pix += 2;
281  if (row_pix >= avctx->width) {
282  i += stride - (i % stride) - 1;
283  j += 8 - (j % 8) - 1;
284  row_pix = 0;
285  }
286  }
287  } else if (avctx->bits_per_coded_sample == 2) {
288  for (i = 0, j = 0; 4 * j + 3 < buf_size && i<avpkt->size; i++, j++) {
289  dst[4 * j + 0] = buf[i] >> 6;
290  dst[4 * j + 1] = buf[i] >> 4 & 3;
291  dst[4 * j + 2] = buf[i] >> 2 & 3;
292  dst[4 * j + 3] = buf[i] & 3;
293  row_pix += 4;
294  if (row_pix >= avctx->width) {
295  i += stride - (i % stride) - 1;
296  j += 4 - (j % 4) - 1;
297  row_pix = 0;
298  }
299  }
300  } else {
301  av_assert0(avctx->bits_per_coded_sample == 1);
302  for (i = 0, j = 0; 8 * j + 7 < buf_size && i<avpkt->size; i++, j++) {
303  dst[8 * j + 0] = buf[i] >> 7;
304  dst[8 * j + 1] = buf[i] >> 6 & 1;
305  dst[8 * j + 2] = buf[i] >> 5 & 1;
306  dst[8 * j + 3] = buf[i] >> 4 & 1;
307  dst[8 * j + 4] = buf[i] >> 3 & 1;
308  dst[8 * j + 5] = buf[i] >> 2 & 1;
309  dst[8 * j + 6] = buf[i] >> 1 & 1;
310  dst[8 * j + 7] = buf[i] & 1;
311  row_pix += 8;
312  if (row_pix >= avctx->width) {
313  i += stride - (i % stride) - 1;
314  j += 2 - (j % 2) - 1;
315  row_pix = 0;
316  }
317  }
318  }
319  linesize_align = 16;
320  buf = dst;
321  } else if (context->is_lt_16bpp) {
322  uint8_t *dst = frame->buf[0]->data;
323  int packed = (avctx->codec_tag & 0xFFFFFF) == MKTAG('B','I','T', 0);
324  int swap = avctx->codec_tag >> 24;
325 
326  if (packed && swap) {
327  av_fast_padded_malloc(&context->bitstream_buf, &context->bitstream_buf_size, buf_size);
328  if (!context->bitstream_buf)
329  return AVERROR(ENOMEM);
330  if (swap == 16)
331  context->bbdsp.bswap16_buf(context->bitstream_buf, (const uint16_t*)buf, buf_size / 2);
332  else if (swap == 32)
333  context->bbdsp.bswap_buf(context->bitstream_buf, (const uint32_t*)buf, buf_size / 4);
334  else
335  return AVERROR_INVALIDDATA;
336  buf = context->bitstream_buf;
337  }
338 
339  if (desc->flags & AV_PIX_FMT_FLAG_BE)
340  scale16be(avctx, dst, buf, buf_size, packed);
341  else
342  scale16le(avctx, dst, buf, buf_size, packed);
343 
344  buf = dst;
345  } else if (need_copy) {
346  memcpy(frame->buf[0]->data, buf, buf_size);
347  buf = frame->buf[0]->data;
348  }
349 
350  if (avctx->codec_tag == MKTAG('A', 'V', '1', 'x') ||
351  avctx->codec_tag == MKTAG('A', 'V', 'u', 'p'))
352  buf += buf_size - context->frame_size;
353 
354  len = context->frame_size - (avctx->pix_fmt==AV_PIX_FMT_PAL8 ? AVPALETTE_SIZE : 0);
355  if (buf_size < len && ((avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0) || !need_copy)) {
356  av_log(avctx, AV_LOG_ERROR, "Invalid buffer size, packet size %d < expected frame_size %d\n", buf_size, len);
357  av_buffer_unref(&frame->buf[0]);
358  return AVERROR(EINVAL);
359  }
360 
361  if ((res = av_image_fill_arrays(frame->data, frame->linesize,
362  buf, avctx->pix_fmt,
363  avctx->width, avctx->height, 1)) < 0) {
364  av_buffer_unref(&frame->buf[0]);
365  return res;
366  }
367 
368  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
369  int pal_size;
371  &pal_size);
372  int ret;
373 
374  if (pal && pal_size != AVPALETTE_SIZE) {
375  av_log(avctx, AV_LOG_ERROR, "Palette size %d is wrong\n", pal_size);
376  pal = NULL;
377  }
378 
379  if (!context->palette)
381  if (!context->palette) {
382  av_buffer_unref(&frame->buf[0]);
383  return AVERROR(ENOMEM);
384  }
385  ret = av_buffer_make_writable(&context->palette);
386  if (ret < 0) {
387  av_buffer_unref(&frame->buf[0]);
388  return ret;
389  }
390 
391  if (pal) {
392  memcpy(context->palette->data, pal, AVPALETTE_SIZE);
393  frame->palette_has_changed = 1;
394  } else if (context->is_nut_pal8) {
395  int vid_size = avctx->width * avctx->height;
396  int pal_size = avpkt->size - vid_size;
397 
398  if (avpkt->size > vid_size && pal_size <= AVPALETTE_SIZE) {
399  pal = avpkt->data + vid_size;
400  memcpy(context->palette->data, pal, pal_size);
401  frame->palette_has_changed = 1;
402  }
403  }
404  }
405 
406  if ((avctx->pix_fmt==AV_PIX_FMT_RGB24 ||
407  avctx->pix_fmt==AV_PIX_FMT_BGR24 ||
408  avctx->pix_fmt==AV_PIX_FMT_GRAY8 ||
409  avctx->pix_fmt==AV_PIX_FMT_RGB555LE ||
410  avctx->pix_fmt==AV_PIX_FMT_RGB555BE ||
411  avctx->pix_fmt==AV_PIX_FMT_RGB565LE ||
412  avctx->pix_fmt==AV_PIX_FMT_MONOWHITE ||
413  avctx->pix_fmt==AV_PIX_FMT_MONOBLACK ||
414  avctx->pix_fmt==AV_PIX_FMT_PAL8) &&
415  FFALIGN(frame->linesize[0], linesize_align) * avctx->height <= buf_size)
416  frame->linesize[0] = FFALIGN(frame->linesize[0], linesize_align);
417 
418  if (avctx->pix_fmt == AV_PIX_FMT_NV12 && avctx->codec_tag == MKTAG('N', 'V', '1', '2') &&
419  FFALIGN(frame->linesize[0], linesize_align) * avctx->height +
420  FFALIGN(frame->linesize[1], linesize_align) * ((avctx->height + 1) / 2) <= buf_size) {
421  int la0 = FFALIGN(frame->linesize[0], linesize_align);
422  frame->data[1] += (la0 - frame->linesize[0]) * avctx->height;
423  frame->linesize[0] = la0;
424  frame->linesize[1] = FFALIGN(frame->linesize[1], linesize_align);
425  }
426 
427  if ((avctx->pix_fmt == AV_PIX_FMT_PAL8 && buf_size < context->frame_size) ||
428  (desc->flags & FF_PSEUDOPAL)) {
429  frame->buf[1] = av_buffer_ref(context->palette);
430  if (!frame->buf[1]) {
431  av_buffer_unref(&frame->buf[0]);
432  return AVERROR(ENOMEM);
433  }
434  frame->data[1] = frame->buf[1]->data;
435  }
436 
437  if (avctx->pix_fmt == AV_PIX_FMT_BGR24 &&
438  ((frame->linesize[0] + 3) & ~3) * avctx->height <= buf_size)
439  frame->linesize[0] = (frame->linesize[0] + 3) & ~3;
440 
441  if (context->flip)
442  flip(avctx, frame);
443 
444  if (avctx->codec_tag == MKTAG('Y', 'V', '1', '2') ||
445  avctx->codec_tag == MKTAG('Y', 'V', '1', '6') ||
446  avctx->codec_tag == MKTAG('Y', 'V', '2', '4') ||
447  avctx->codec_tag == MKTAG('Y', 'V', 'U', '9'))
448  FFSWAP(uint8_t *, frame->data[1], frame->data[2]);
449 
450  if (avctx->codec_tag == AV_RL32("I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
451  frame->data[1] = frame->data[1] + (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
452  frame->data[2] = frame->data[2] + ((avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height)*5/4;
453  }
454 
455  if (avctx->codec_tag == AV_RL32("yuv2") &&
456  avctx->pix_fmt == AV_PIX_FMT_YUYV422) {
457  int x, y;
458  uint8_t *line = frame->data[0];
459  for (y = 0; y < avctx->height; y++) {
460  for (x = 0; x < avctx->width; x++)
461  line[2 * x + 1] ^= 0x80;
462  line += frame->linesize[0];
463  }
464  }
465 
466  if (avctx->codec_tag == AV_RL32("b64a") &&
467  avctx->pix_fmt == AV_PIX_FMT_RGBA64BE) {
468  uint8_t *dst = frame->data[0];
469  uint64_t v;
470  int x;
471  for (x = 0; x >> 3 < avctx->width * avctx->height; x += 8) {
472  v = AV_RB64(&dst[x]);
473  AV_WB64(&dst[x], v << 16 | v >> 48);
474  }
475  }
476 
477  if (avctx->field_order > AV_FIELD_PROGRESSIVE) { /* we have interlaced material flagged in container */
478  frame->interlaced_frame = 1;
479  if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
480  frame->top_field_first = 1;
481  }
482 
483  *got_frame = 1;
484  return buf_size;
485 }
486 
488 {
489  RawVideoContext *context = avctx->priv_data;
490 
491  av_buffer_unref(&context->palette);
492  return 0;
493 }
494 
496  .name = "rawvideo",
497  .long_name = NULL_IF_CONFIG_SMALL("raw video"),
498  .type = AVMEDIA_TYPE_VIDEO,
499  .id = AV_CODEC_ID_RAWVIDEO,
500  .priv_data_size = sizeof(RawVideoContext),
502  .close = raw_close_decoder,
503  .decode = raw_decode,
504  .priv_class = &rawdec_class,
505  .capabilities = AV_CODEC_CAP_PARAM_CHANGE,
506 };
#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:151
#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:125
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2384
This structure describes decoded (raw) audio or video data.
Definition: frame.h:218
AVCodec ff_rawvideo_decoder
Definition: rawdec.c:495
AVOption.
Definition: opt.h:246
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
Definition: frame.h:490
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:410
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: bswapdsp.h:26
const char * desc
Definition: nvenc.c:65
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:2336
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:104
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:411
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1729
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:70
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: decode.c:1665
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:3410
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
Definition: decode_audio.c:42
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:102
#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:152
#define AVPALETTE_SIZE
Definition: pixfmt.h:32
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:201
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:1620
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:365
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2736
#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:431
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
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette...
Definition: avcodec.h:1151
void * bitstream_buf
Definition: rawdec.c:54
static void flip(AVCodecContext *avctx, AVFrame *frame)
Definition: rawdec.c:136
#define AVERROR(e)
Definition: error.h:43
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
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:186
#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:85
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:3417
#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:282
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:301
Raw Video Codec.
static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: rawdec.c:170
#define AV_PIX_FMT_FLAG_PSEUDOPAL
The pixel format is "pseudo-paletted".
Definition: pixdesc.h:166
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:457
int frame_size
Definition: mxfenc.c:2117
Libavcodec external API header.
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown...
Definition: frame.h:498
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:67
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:249
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:279
main external API structure.
Definition: avcodec.h:1520
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:1545
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:1621
Describe the class of an AVClass context structure.
Definition: log.h:67
static av_cold int raw_close_decoder(AVCodecContext *avctx)
Definition: rawdec.c:487
#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:375
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:103
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:232
#define MKSCALE16(name, r16, w16)
Scale buffer to 16 bits per coded sample resolution.
Definition: rawdec.c:150
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:1025
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:93
#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:1547
#define FF_PSEUDOPAL
Definition: internal.h:367
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:370
int len
const PixelFormatTag avpriv_pix_fmt_bps_avi[]
Definition: raw.c:311
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:296
const PixelFormatTag avpriv_pix_fmt_bps_mov[]
Definition: raw.c:324
#define FFSWAP(type, a, b)
Definition: common.h:99
#define stride
#define MKTAG(a, b, c, d)
Definition: common.h:366
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1409
static const AVClass rawdec_class
Definition: rawdec.c:63