FFmpeg  2.1.1
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 "raw.h"
29 #include "libavutil/avassert.h"
30 #include "libavutil/buffer.h"
31 #include "libavutil/common.h"
32 #include "libavutil/intreadwrite.h"
33 #include "libavutil/imgutils.h"
34 #include "libavutil/opt.h"
35 
36 typedef struct RawVideoContext {
39  int frame_size; /* size of the frame in bytes */
40  int flip;
41  int is_2_4_bpp; // 2 or 4 bpp raw in avi/mov
42  int is_yuv2;
43  int tff;
45 
46 static const AVOption options[]={
47 {"top", "top field first", offsetof(RawVideoContext, tff), AV_OPT_TYPE_INT, {.i64 = -1}, -1, 1, AV_OPT_FLAG_DECODING_PARAM|AV_OPT_FLAG_VIDEO_PARAM},
48 {NULL}
49 };
50 
51 static const AVClass rawdec_class = {
52  .class_name = "rawdec",
53  .option = options,
54  .version = LIBAVUTIL_VERSION_INT,
55 };
56 
57 static const PixelFormatTag pix_fmt_bps_avi[] = {
58  { AV_PIX_FMT_MONOWHITE, 1 },
59  { AV_PIX_FMT_PAL8, 2 },
60  { AV_PIX_FMT_PAL8, 4 },
61  { AV_PIX_FMT_PAL8, 8 },
62  { AV_PIX_FMT_RGB444LE, 12 },
63  { AV_PIX_FMT_RGB555LE, 15 },
64  { AV_PIX_FMT_RGB555LE, 16 },
65  { AV_PIX_FMT_BGR24, 24 },
66  { AV_PIX_FMT_BGRA, 32 },
67  { AV_PIX_FMT_NONE, 0 },
68 };
69 
70 static const PixelFormatTag pix_fmt_bps_mov[] = {
71  { AV_PIX_FMT_MONOWHITE, 1 },
72  { AV_PIX_FMT_PAL8, 2 },
73  { AV_PIX_FMT_PAL8, 4 },
74  { AV_PIX_FMT_PAL8, 8 },
75  // FIXME swscale does not support 16 bit in .mov, sample 16bit.mov
76  // http://developer.apple.com/documentation/QuickTime/QTFF/QTFFChap3/qtff3.html
77  { AV_PIX_FMT_RGB555BE, 16 },
78  { AV_PIX_FMT_RGB24, 24 },
79  { AV_PIX_FMT_ARGB, 32 },
80  { AV_PIX_FMT_MONOWHITE,33 },
81  { AV_PIX_FMT_NONE, 0 },
82 };
83 
85  unsigned int fourcc)
86 {
87  while (tags->pix_fmt >= 0) {
88  if (tags->fourcc == fourcc)
89  return tags->pix_fmt;
90  tags++;
91  }
92  return AV_PIX_FMT_NONE;
93 }
94 
95 #if LIBAVCODEC_VERSION_MAJOR < 55
96 enum AVPixelFormat ff_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
97 {
98  return avpriv_find_pix_fmt(tags, fourcc);
99 }
100 #endif
101 
103 {
104  RawVideoContext *context = avctx->priv_data;
105  const AVPixFmtDescriptor *desc;
106 
107  if ( avctx->codec_tag == MKTAG('r','a','w',' ')
108  || avctx->codec_tag == MKTAG('N','O','1','6'))
109  avctx->pix_fmt = avpriv_find_pix_fmt(pix_fmt_bps_mov,
110  avctx->bits_per_coded_sample);
111  else if (avctx->codec_tag == MKTAG('W', 'R', 'A', 'W'))
112  avctx->pix_fmt = avpriv_find_pix_fmt(pix_fmt_bps_avi,
113  avctx->bits_per_coded_sample);
114  else if (avctx->codec_tag)
116  else if (avctx->pix_fmt == AV_PIX_FMT_NONE && avctx->bits_per_coded_sample)
117  avctx->pix_fmt = avpriv_find_pix_fmt(pix_fmt_bps_avi,
118  avctx->bits_per_coded_sample);
119 
120  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
121  if (!desc) {
122  av_log(avctx, AV_LOG_ERROR, "Invalid pixel format.\n");
123  return AVERROR(EINVAL);
124  }
125 
128  if (!context->palette)
129  return AVERROR(ENOMEM);
130  if (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
131  avpriv_set_systematic_pal2((uint32_t*)context->palette->data, avctx->pix_fmt);
132  else
133  memset(context->palette->data, 0, AVPALETTE_SIZE);
134  }
135 
136  if ((avctx->bits_per_coded_sample == 4 || avctx->bits_per_coded_sample == 2) &&
137  avctx->pix_fmt == AV_PIX_FMT_PAL8 &&
138  (!avctx->codec_tag || avctx->codec_tag == MKTAG('r','a','w',' '))) {
139  context->is_2_4_bpp = 1;
140  context->frame_size = avpicture_get_size(avctx->pix_fmt,
141  FFALIGN(avctx->width, 16),
142  avctx->height);
143  } else {
144  context->frame_size = avpicture_get_size(avctx->pix_fmt, avctx->width,
145  avctx->height);
146  }
147 
148  if ((avctx->extradata_size >= 9 &&
149  !memcmp(avctx->extradata + avctx->extradata_size - 9, "BottomUp", 9)) ||
150  avctx->codec_tag == MKTAG('c','y','u','v') ||
151  avctx->codec_tag == MKTAG(3, 0, 0, 0) ||
152  avctx->codec_tag == MKTAG('W','R','A','W'))
153  context->flip = 1;
154 
155  if (avctx->codec_tag == AV_RL32("yuv2") &&
156  avctx->pix_fmt == AV_PIX_FMT_YUYV422)
157  context->is_yuv2 = 1;
158 
159  return 0;
160 }
161 
162 static void flip(AVCodecContext *avctx, AVPicture *picture)
163 {
164  picture->data[0] += picture->linesize[0] * (avctx->height - 1);
165  picture->linesize[0] *= -1;
166 }
167 
168 static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame,
169  AVPacket *avpkt)
170 {
171  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
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 res, len;
177  int need_copy = !avpkt->buf || context->is_2_4_bpp || context->is_yuv2;
178 
179  AVFrame *frame = data;
180  AVPicture *picture = data;
181 
182  frame->pict_type = AV_PICTURE_TYPE_I;
183  frame->key_frame = 1;
184  frame->reordered_opaque = avctx->reordered_opaque;
185  frame->pkt_pts = avctx->pkt->pts;
186  av_frame_set_pkt_pos (frame, avctx->pkt->pos);
187  av_frame_set_pkt_duration(frame, avctx->pkt->duration);
188 
189  if (context->tff >= 0) {
190  frame->interlaced_frame = 1;
191  frame->top_field_first = context->tff;
192  }
193 
194  if ((res = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
195  return res;
196 
197  if (need_copy)
198  frame->buf[0] = av_buffer_alloc(FFMAX(context->frame_size, buf_size));
199  else
200  frame->buf[0] = av_buffer_ref(avpkt->buf);
201  if (!frame->buf[0])
202  return AVERROR(ENOMEM);
203 
204  //2bpp and 4bpp raw in avi and mov (yes this is ugly ...)
205  if (context->is_2_4_bpp) {
206  int i;
207  uint8_t *dst = frame->buf[0]->data;
208  buf_size = context->frame_size - AVPALETTE_SIZE;
209  if (avctx->bits_per_coded_sample == 4) {
210  for (i = 0; 2 * i + 1 < buf_size && i<avpkt->size; i++) {
211  dst[2 * i + 0] = buf[i] >> 4;
212  dst[2 * i + 1] = buf[i] & 15;
213  }
214  linesize_align = 8;
215  } else {
216  av_assert0(avctx->bits_per_coded_sample == 2);
217  for (i = 0; 4 * i + 3 < buf_size && i<avpkt->size; i++) {
218  dst[4 * i + 0] = buf[i] >> 6;
219  dst[4 * i + 1] = buf[i] >> 4 & 3;
220  dst[4 * i + 2] = buf[i] >> 2 & 3;
221  dst[4 * i + 3] = buf[i] & 3;
222  }
223  linesize_align = 16;
224  }
225  buf = dst;
226  } else if (need_copy) {
227  memcpy(frame->buf[0]->data, buf, buf_size);
228  buf = frame->buf[0]->data;
229  }
230 
231  if (avctx->codec_tag == MKTAG('A', 'V', '1', 'x') ||
232  avctx->codec_tag == MKTAG('A', 'V', 'u', 'p'))
233  buf += buf_size - context->frame_size;
234 
235  len = context->frame_size - (avctx->pix_fmt==AV_PIX_FMT_PAL8 ? AVPALETTE_SIZE : 0);
236  if (buf_size < len) {
237  av_log(avctx, AV_LOG_ERROR, "Invalid buffer size, packet size %d < expected frame_size %d\n", buf_size, len);
238  av_buffer_unref(&frame->buf[0]);
239  return AVERROR(EINVAL);
240  }
241 
242  if ((res = avpicture_fill(picture, buf, avctx->pix_fmt,
243  avctx->width, avctx->height)) < 0) {
244  av_buffer_unref(&frame->buf[0]);
245  return res;
246  }
247 
248  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
250  NULL);
251 
252  if (pal) {
253  av_buffer_unref(&context->palette);
255  if (!context->palette) {
256  av_buffer_unref(&frame->buf[0]);
257  return AVERROR(ENOMEM);
258  }
259  memcpy(context->palette->data, pal, AVPALETTE_SIZE);
260  frame->palette_has_changed = 1;
261  }
262  }
263 
264  if ((avctx->pix_fmt==AV_PIX_FMT_BGR24 ||
265  avctx->pix_fmt==AV_PIX_FMT_GRAY8 ||
266  avctx->pix_fmt==AV_PIX_FMT_RGB555LE ||
267  avctx->pix_fmt==AV_PIX_FMT_RGB555BE ||
268  avctx->pix_fmt==AV_PIX_FMT_RGB565LE ||
269  avctx->pix_fmt==AV_PIX_FMT_MONOWHITE ||
270  avctx->pix_fmt==AV_PIX_FMT_PAL8) &&
271  FFALIGN(frame->linesize[0], linesize_align) * avctx->height <= buf_size)
272  frame->linesize[0] = FFALIGN(frame->linesize[0], linesize_align);
273 
274  if (avctx->pix_fmt == AV_PIX_FMT_NV12 && avctx->codec_tag == MKTAG('N', 'V', '1', '2') &&
275  FFALIGN(frame->linesize[0], linesize_align) * avctx->height +
276  FFALIGN(frame->linesize[1], linesize_align) * ((avctx->height + 1) / 2) <= buf_size) {
277  int la0 = FFALIGN(frame->linesize[0], linesize_align);
278  frame->data[1] += (la0 - frame->linesize[0]) * avctx->height;
279  frame->linesize[0] = la0;
280  frame->linesize[1] = FFALIGN(frame->linesize[1], linesize_align);
281  }
282 
283  if ((avctx->pix_fmt == AV_PIX_FMT_PAL8 && buf_size < context->frame_size) ||
284  (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)) {
285  frame->buf[1] = av_buffer_ref(context->palette);
286  if (!frame->buf[1]) {
287  av_buffer_unref(&frame->buf[0]);
288  return AVERROR(ENOMEM);
289  }
290  frame->data[1] = frame->buf[1]->data;
291  }
292 
293  if (avctx->pix_fmt == AV_PIX_FMT_BGR24 &&
294  ((frame->linesize[0] + 3) & ~3) * avctx->height <= buf_size)
295  frame->linesize[0] = (frame->linesize[0] + 3) & ~3;
296 
297  if (context->flip)
298  flip(avctx, picture);
299 
300  if (avctx->codec_tag == MKTAG('Y', 'V', '1', '2') ||
301  avctx->codec_tag == MKTAG('Y', 'V', '1', '6') ||
302  avctx->codec_tag == MKTAG('Y', 'V', '2', '4') ||
303  avctx->codec_tag == MKTAG('Y', 'V', 'U', '9'))
304  FFSWAP(uint8_t *, picture->data[1], picture->data[2]);
305 
306  if (avctx->codec_tag == AV_RL32("I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
307  picture->data[1] = picture->data[1] + (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
308  picture->data[2] = picture->data[2] + ((avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height)*5/4;
309  }
310 
311  if (avctx->codec_tag == AV_RL32("yuv2") &&
312  avctx->pix_fmt == AV_PIX_FMT_YUYV422) {
313  int x, y;
314  uint8_t *line = picture->data[0];
315  for (y = 0; y < avctx->height; y++) {
316  for (x = 0; x < avctx->width; x++)
317  line[2 * x + 1] ^= 0x80;
318  line += picture->linesize[0];
319  }
320  }
321  if (avctx->codec_tag == AV_RL32("YVYU") &&
322  avctx->pix_fmt == AV_PIX_FMT_YUYV422) {
323  int x, y;
324  uint8_t *line = picture->data[0];
325  for(y = 0; y < avctx->height; y++) {
326  for(x = 0; x < avctx->width - 1; x += 2)
327  FFSWAP(uint8_t, line[2*x + 1], line[2*x + 3]);
328  line += picture->linesize[0];
329  }
330  }
331 
332  if (avctx->field_order > AV_FIELD_PROGRESSIVE) { /* we have interlaced material flagged in container */
333  frame->interlaced_frame = 1;
334  if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
335  frame->top_field_first = 1;
336  }
337 
338  *got_frame = 1;
339  return buf_size;
340 }
341 
343 {
344  RawVideoContext *context = avctx->priv_data;
345 
346  av_buffer_unref(&context->palette);
347  return 0;
348 }
349 
351  .name = "rawvideo",
352  .long_name = NULL_IF_CONFIG_SMALL("raw video"),
353  .type = AVMEDIA_TYPE_VIDEO,
354  .id = AV_CODEC_ID_RAWVIDEO,
355  .priv_data_size = sizeof(RawVideoContext),
358  .decode = raw_decode,
359  .priv_class = &rawdec_class,
360 };
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:105
unsigned int fourcc
Definition: raw.h:35
This structure describes decoded (raw) audio or video data.
Definition: frame.h:96
AVCodec ff_rawvideo_decoder
Definition: rawdec.c:350
AVOption.
Definition: opt.h:253
int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
Definition: avcodec.h:3123
#define LIBAVUTIL_VERSION_INT
Definition: avcodec.h:820
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1092
packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), big-endian, most significant bit to 0 ...
Definition: avcodec.h:4584
static av_cold int init(AVCodecContext *avctx)
Definition: avrndec.c:35
enum AVPixelFormat ff_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: rawdec.c:96
int is_2_4_bpp
Definition: rawdec.c:41
packed RGB 8:8:8, 24bpp, RGBRGB...
Definition: avcodec.h:4536
int size
Definition: avcodec.h:1064
void av_log(void *avcl, int level, const char *fmt,...) av_printf_format(3
Send the specified message to the log if the level is less than or equal to the current av_log_level...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1342
enum AVPixelFormat pix_fmt
Definition: raw.h:34
void av_frame_set_pkt_duration(AVFrame *frame, int64_t val)
Pixel format.
Definition: avcodec.h:4533
Picture data structure.
Definition: avcodec.h:3121
int frame_size
Definition: rawdec.c:39
AVCodec.
Definition: avcodec.h:2922
#define av_cold
Definition: avcodec.h:653
int avpicture_fill(AVPicture *picture, const uint8_t *ptr, enum AVPixelFormat pix_fmt, int width, int height)
Setup the picture fields based on the specified image parameters and the provided image data buffer...
Definition: avpicture.c:34
Y , 8bpp.
Definition: avcodec.h:4542
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1254
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1046
packed ARGB 8:8:8:8, 32bpp, ARGBARGB...
Definition: avcodec.h:4562
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: avcodec.h:4537
static uint8_t * res
Definition: ffhash.c:43
uint8_t
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:55
const PixelFormatTag ff_raw_pix_fmt_tags[]
Definition: raw.c:31
const char * name
Name of the codec implementation.
Definition: avcodec.h:2929
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:98
static const PixelFormatTag pix_fmt_bps_avi[]
Definition: rawdec.c:57
const char data[16]
Definition: mxf.c:68
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:287
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:293
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2563
#define FFSWAP(type, a, b)
Definition: avcodec.h:928
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: avcodec.h:4583
uint8_t * data[AV_NUM_DATA_POINTERS]
pointers to the image data planes
Definition: avcodec.h:3122
int duration
Duration of this packet in AVStream-&gt;time_base units, 0 if unknown.
Definition: avcodec.h:1085
const OptionDef options[]
Definition: ffserver.c:4682
static AVFrame * frame
Definition: demuxing.c:51
#define AV_PIX_FMT_FLAG_PSEUDOPAL
The pixel format is &quot;pseudo-paletted&quot;.
Definition: pixdesc.h:120
static const uint8_t frame_size[4]
Definition: g723_1_data.h:58
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: avcodec.h:4147
AVBufferRef * palette
Definition: rawdec.c:38
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:151
Definition: graph2dot.c:48
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:150
static const PixelFormatTag pix_fmt_bps_mov[]
Definition: rawdec.c:70
Libavcodec external API header.
AVPixelFormat
Pixel format.
Definition: pixfmt.h:66
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:231
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:167
uint8_t * data
The data buffer.
Definition: buffer.h:89
Raw Video Codec.
float y
uint8_t * av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:323
int width
picture width / height.
Definition: avcodec.h:1314
static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: rawdec.c:168
#define AVPALETTE_SIZE
Definition: avcodec.h:4499
int64_t reordered_opaque
opaque 64bit number (generally a PTS) that will be reordered and output in AVFrame.reordered_opaque
Definition: avcodec.h:2494
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:1938
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: rawdec.c:84
AVBufferRef * av_buffer_alloc(int size)
Allocate an AVBuffer of the given size using av_malloc().
Definition: buffer.c:65
#define FFMAX(a, b)
Definition: avcodec.h:923
uint8_t flags
Definition: pixdesc.h:78
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:57
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: avcodec.h:4535
main external API structure.
Definition: avcodec.h:1146
static void close(AVCodecParserContext *s)
Definition: h264_parser.c:538
unsigned int codec_tag
fourcc (LSB first, so &quot;ABCD&quot; -&gt; (&#39;D&#39;&lt;&lt;24) + (&#39;C&#39;&lt;&lt;16) + (&#39;B&#39;&lt;&lt;8) + &#39;A&#39;).
Definition: avcodec.h:1172
void av_frame_set_pkt_pos(AVFrame *frame, int64_t val)
void * buf
Definition: avisynth_c.h:594
int extradata_size
Definition: avcodec.h:1255
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:366
packed RGB 4:4:4, 16bpp, (msb)4A 4R 4G 4B(lsb), little-endian, most significant bits to 0 ...
Definition: avcodec.h:4607
int64_t reordered_opaque
reordered opaque 64bit (generally an integer or a double precision float PTS but can be anything)...
Definition: frame.h:325
Describe the class of an AVClass context structure.
Definition: log.h:50
#define MKTAG(a, b, c, d)
static av_cold int raw_close_decoder(AVCodecContext *avctx)
Definition: rawdec.c:342
uint8_t * data
Definition: avcodec.h:1063
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:303
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:124
int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
Definition: frame.h:187
AVClass * av_class
Definition: rawdec.c:37
void * priv_data
Definition: avcodec.h:1182
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:284
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb...
Definition: avcodec.h:4543
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: avcodec.h:4559
A reference to a data buffer.
Definition: buffer.h:81
packed BGRA 8:8:8:8, 32bpp, BGRABGRA...
Definition: avcodec.h:4565
static void flip(AVCodecContext *avctx, AVPicture *picture)
Definition: rawdec.c:162
static av_cold int raw_init_decoder(AVCodecContext *avctx)
Definition: rawdec.c:102
#define FFALIGN(x, a)
Definition: avcodec.h:930
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:91
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:298
#define AV_RL32(x)
Definition: intreadwrite.h:275
int len
int avpicture_get_size(enum AVPixelFormat pix_fmt, int width, int height)
Calculate the size in bytes that a picture of the given width and height would occupy if stored in th...
Definition: avpicture.c:49
int key_frame
1 -&gt; keyframe, 0-&gt; not
Definition: frame.h:162
#define AVERROR(e)
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:1870
static int decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: crystalhd.c:868
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
8 bit with PIX_FMT_RGB32 palette
Definition: avcodec.h:4545
AVPacket * pkt
Current packet as passed into the decoder, to avoid having to pass the packet into every function...
Definition: avcodec.h:2805
packed RGB 5:5:5, 16bpp, (msb)1A 5R 5G 5B(lsb), little-endian, most significant bit to 0 ...
Definition: avcodec.h:4585
This structure stores compressed data.
Definition: avcodec.h:1040
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:107
int64_t pts
Presentation timestamp in AVStream-&gt;time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1056
static const AVClass rawdec_class
Definition: rawdec.c:51