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_2_4_bpp; // 2 or 4 bpp raw in avi/mov
45  int is_yuv2;
46  int is_lt_16bpp; // 16bpp pixfmt and bits_per_coded_sample < 16
47  int tff;
48 
51  unsigned int bitstream_buf_size;
53 
54 static const AVOption options[]={
55 {"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},
56 {NULL}
57 };
58 
59 static const AVClass rawdec_class = {
60  .class_name = "rawdec",
61  .option = options,
62  .version = LIBAVUTIL_VERSION_INT,
63 };
64 
66 {
67  RawVideoContext *context = avctx->priv_data;
68  const AVPixFmtDescriptor *desc;
69 
70  ff_bswapdsp_init(&context->bbdsp);
71 
72  if ( avctx->codec_tag == MKTAG('r','a','w',' ')
73  || avctx->codec_tag == MKTAG('N','O','1','6'))
75  avctx->bits_per_coded_sample);
76  else if (avctx->codec_tag == MKTAG('W', 'R', 'A', 'W'))
78  avctx->bits_per_coded_sample);
79  else if (avctx->codec_tag && (avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0))
81  else if (avctx->pix_fmt == AV_PIX_FMT_NONE && avctx->bits_per_coded_sample)
83  avctx->bits_per_coded_sample);
84 
85  desc = av_pix_fmt_desc_get(avctx->pix_fmt);
86  if (!desc) {
87  av_log(avctx, AV_LOG_ERROR, "Invalid pixel format.\n");
88  return AVERROR(EINVAL);
89  }
90 
93  if (!context->palette)
94  return AVERROR(ENOMEM);
95  if (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)
96  avpriv_set_systematic_pal2((uint32_t*)context->palette->data, avctx->pix_fmt);
97  else
98  memset(context->palette->data, 0, AVPALETTE_SIZE);
99  }
100 
101  if ((avctx->extradata_size >= 9 &&
102  !memcmp(avctx->extradata + avctx->extradata_size - 9, "BottomUp", 9)) ||
103  avctx->codec_tag == MKTAG('c','y','u','v') ||
104  avctx->codec_tag == MKTAG(3, 0, 0, 0) ||
105  avctx->codec_tag == MKTAG('W','R','A','W'))
106  context->flip = 1;
107 
108  if (avctx->codec_tag == AV_RL32("yuv2") &&
109  avctx->pix_fmt == AV_PIX_FMT_YUYV422)
110  context->is_yuv2 = 1;
111 
112  return 0;
113 }
114 
115 static void flip(AVCodecContext *avctx, AVPicture *picture)
116 {
117  picture->data[0] += picture->linesize[0] * (avctx->height - 1);
118  picture->linesize[0] *= -1;
119 }
120 
121 /*
122  * Scale sample to 16-bit resolution
123  */
124 #define SCALE16(x, bits) (((x) << (16 - (bits))) | ((x) >> (2 * (bits) - 16)))
125 
126 /**
127  * Scale buffer to 16 bits per coded sample resolution
128  */
129 #define MKSCALE16(name, r16, w16) \
130 static void name(AVCodecContext *avctx, uint8_t * dst, const uint8_t *buf, int buf_size, int packed) \
131 { \
132  int i; \
133  if (!packed) { \
134  for (i = 0; i + 1 < buf_size; i += 2) \
135  w16(dst + i, SCALE16(r16(buf + i), avctx->bits_per_coded_sample)); \
136  } else { \
137  GetBitContext gb; \
138  init_get_bits(&gb, buf, buf_size * 8); \
139  for (i = 0; i < avctx->width * avctx->height; i++) { \
140  int sample = get_bits(&gb, avctx->bits_per_coded_sample); \
141  w16(dst + i*2, SCALE16(sample, avctx->bits_per_coded_sample)); \
142  } \
143  } \
144 }
145 
146 MKSCALE16(scale16be, AV_RB16, AV_WB16)
147 MKSCALE16(scale16le, AV_RL16, AV_WL16)
148 
149 static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame,
150  AVPacket *avpkt)
151 {
152  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
153  RawVideoContext *context = avctx->priv_data;
154  const uint8_t *buf = avpkt->data;
155  int buf_size = avpkt->size;
156  int linesize_align = 4;
157  int res, len;
158  int need_copy;
159 
160  AVFrame *frame = data;
161  AVPicture *picture = data;
162 
163  if ((avctx->bits_per_coded_sample == 4 || avctx->bits_per_coded_sample == 2) &&
164  avctx->pix_fmt == AV_PIX_FMT_PAL8 &&
165  (!avctx->codec_tag || avctx->codec_tag == MKTAG('r','a','w',' '))) {
166  context->is_2_4_bpp = 1;
167  context->frame_size = avpicture_get_size(avctx->pix_fmt,
168  FFALIGN(avctx->width, 16),
169  avctx->height);
170  } else {
171  context->is_lt_16bpp = av_get_bits_per_pixel(desc) == 16 && avctx->bits_per_coded_sample && avctx->bits_per_coded_sample < 16;
172  context->frame_size = avpicture_get_size(avctx->pix_fmt, avctx->width,
173  avctx->height);
174  }
175  if (context->frame_size < 0)
176  return context->frame_size;
177 
178  need_copy = !avpkt->buf || context->is_2_4_bpp || context->is_yuv2 || context->is_lt_16bpp;
179 
180  frame->pict_type = AV_PICTURE_TYPE_I;
181  frame->key_frame = 1;
182 
183  res = ff_decode_frame_props(avctx, frame);
184  if (res < 0)
185  return res;
186 
187  av_frame_set_pkt_pos (frame, avctx->internal->pkt->pos);
188  av_frame_set_pkt_duration(frame, avctx->internal->pkt->duration);
189 
190  if (context->tff >= 0) {
191  frame->interlaced_frame = 1;
192  frame->top_field_first = context->tff;
193  }
194 
195  if ((res = av_image_check_size(avctx->width, avctx->height, 0, avctx)) < 0)
196  return res;
197 
198  if (need_copy)
199  frame->buf[0] = av_buffer_alloc(FFMAX(context->frame_size, buf_size));
200  else
201  frame->buf[0] = av_buffer_ref(avpkt->buf);
202  if (!frame->buf[0])
203  return AVERROR(ENOMEM);
204 
205  //2bpp and 4bpp raw in avi and mov (yes this is ugly ...)
206  if (context->is_2_4_bpp) {
207  int i;
208  uint8_t *dst = frame->buf[0]->data;
209  buf_size = context->frame_size - AVPALETTE_SIZE;
210  if (avctx->bits_per_coded_sample == 4) {
211  for (i = 0; 2 * i + 1 < buf_size && i<avpkt->size; i++) {
212  dst[2 * i + 0] = buf[i] >> 4;
213  dst[2 * i + 1] = buf[i] & 15;
214  }
215  linesize_align = 8;
216  } else {
217  av_assert0(avctx->bits_per_coded_sample == 2);
218  for (i = 0; 4 * i + 3 < buf_size && i<avpkt->size; i++) {
219  dst[4 * i + 0] = buf[i] >> 6;
220  dst[4 * i + 1] = buf[i] >> 4 & 3;
221  dst[4 * i + 2] = buf[i] >> 2 & 3;
222  dst[4 * i + 3] = buf[i] & 3;
223  }
224  linesize_align = 16;
225  }
226  buf = dst;
227  } else if (context->is_lt_16bpp) {
228  uint8_t *dst = frame->buf[0]->data;
229  int packed = (avctx->codec_tag & 0xFFFFFF) == MKTAG('B','I','T', 0);
230  int swap = avctx->codec_tag >> 24;
231 
232  if (packed && swap) {
233  av_fast_padded_malloc(&context->bitstream_buf, &context->bitstream_buf_size, buf_size);
234  if (!context->bitstream_buf)
235  return AVERROR(ENOMEM);
236  if (swap == 16)
237  context->bbdsp.bswap16_buf(context->bitstream_buf, (const uint16_t*)buf, buf_size / 2);
238  else if (swap == 32)
239  context->bbdsp.bswap_buf(context->bitstream_buf, (const uint32_t*)buf, buf_size / 4);
240  else
241  return AVERROR_INVALIDDATA;
242  buf = context->bitstream_buf;
243  }
244 
245  if (desc->flags & AV_PIX_FMT_FLAG_BE)
246  scale16be(avctx, dst, buf, buf_size, packed);
247  else
248  scale16le(avctx, dst, buf, buf_size, packed);
249 
250  buf = dst;
251  } else if (need_copy) {
252  memcpy(frame->buf[0]->data, buf, buf_size);
253  buf = frame->buf[0]->data;
254  }
255 
256  if (avctx->codec_tag == MKTAG('A', 'V', '1', 'x') ||
257  avctx->codec_tag == MKTAG('A', 'V', 'u', 'p'))
258  buf += buf_size - context->frame_size;
259 
260  len = context->frame_size - (avctx->pix_fmt==AV_PIX_FMT_PAL8 ? AVPALETTE_SIZE : 0);
261  if (buf_size < len && (avctx->codec_tag & 0xFFFFFF) != MKTAG('B','I','T', 0)) {
262  av_log(avctx, AV_LOG_ERROR, "Invalid buffer size, packet size %d < expected frame_size %d\n", buf_size, len);
263  av_buffer_unref(&frame->buf[0]);
264  return AVERROR(EINVAL);
265  }
266 
267  if ((res = avpicture_fill(picture, buf, avctx->pix_fmt,
268  avctx->width, avctx->height)) < 0) {
269  av_buffer_unref(&frame->buf[0]);
270  return res;
271  }
272 
273  if (avctx->pix_fmt == AV_PIX_FMT_PAL8) {
275  NULL);
276 
277  if (pal) {
278  av_buffer_unref(&context->palette);
280  if (!context->palette) {
281  av_buffer_unref(&frame->buf[0]);
282  return AVERROR(ENOMEM);
283  }
284  memcpy(context->palette->data, pal, AVPALETTE_SIZE);
285  frame->palette_has_changed = 1;
286  }
287  }
288 
289  if ((avctx->pix_fmt==AV_PIX_FMT_BGR24 ||
290  avctx->pix_fmt==AV_PIX_FMT_GRAY8 ||
291  avctx->pix_fmt==AV_PIX_FMT_RGB555LE ||
292  avctx->pix_fmt==AV_PIX_FMT_RGB555BE ||
293  avctx->pix_fmt==AV_PIX_FMT_RGB565LE ||
294  avctx->pix_fmt==AV_PIX_FMT_MONOWHITE ||
295  avctx->pix_fmt==AV_PIX_FMT_PAL8) &&
296  FFALIGN(frame->linesize[0], linesize_align) * avctx->height <= buf_size)
297  frame->linesize[0] = FFALIGN(frame->linesize[0], linesize_align);
298 
299  if (avctx->pix_fmt == AV_PIX_FMT_NV12 && avctx->codec_tag == MKTAG('N', 'V', '1', '2') &&
300  FFALIGN(frame->linesize[0], linesize_align) * avctx->height +
301  FFALIGN(frame->linesize[1], linesize_align) * ((avctx->height + 1) / 2) <= buf_size) {
302  int la0 = FFALIGN(frame->linesize[0], linesize_align);
303  frame->data[1] += (la0 - frame->linesize[0]) * avctx->height;
304  frame->linesize[0] = la0;
305  frame->linesize[1] = FFALIGN(frame->linesize[1], linesize_align);
306  }
307 
308  if ((avctx->pix_fmt == AV_PIX_FMT_PAL8 && buf_size < context->frame_size) ||
309  (desc->flags & AV_PIX_FMT_FLAG_PSEUDOPAL)) {
310  frame->buf[1] = av_buffer_ref(context->palette);
311  if (!frame->buf[1]) {
312  av_buffer_unref(&frame->buf[0]);
313  return AVERROR(ENOMEM);
314  }
315  frame->data[1] = frame->buf[1]->data;
316  }
317 
318  if (avctx->pix_fmt == AV_PIX_FMT_BGR24 &&
319  ((frame->linesize[0] + 3) & ~3) * avctx->height <= buf_size)
320  frame->linesize[0] = (frame->linesize[0] + 3) & ~3;
321 
322  if (context->flip)
323  flip(avctx, picture);
324 
325  if (avctx->codec_tag == MKTAG('Y', 'V', '1', '2') ||
326  avctx->codec_tag == MKTAG('Y', 'V', '1', '6') ||
327  avctx->codec_tag == MKTAG('Y', 'V', '2', '4') ||
328  avctx->codec_tag == MKTAG('Y', 'V', 'U', '9'))
329  FFSWAP(uint8_t *, picture->data[1], picture->data[2]);
330 
331  if (avctx->codec_tag == AV_RL32("I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
332  picture->data[1] = picture->data[1] + (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
333  picture->data[2] = picture->data[2] + ((avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height)*5/4;
334  }
335 
336  if (avctx->codec_tag == AV_RL32("yuv2") &&
337  avctx->pix_fmt == AV_PIX_FMT_YUYV422) {
338  int x, y;
339  uint8_t *line = picture->data[0];
340  for (y = 0; y < avctx->height; y++) {
341  for (x = 0; x < avctx->width; x++)
342  line[2 * x + 1] ^= 0x80;
343  line += picture->linesize[0];
344  }
345  }
346 
347  if (avctx->field_order > AV_FIELD_PROGRESSIVE) { /* we have interlaced material flagged in container */
348  frame->interlaced_frame = 1;
349  if (avctx->field_order == AV_FIELD_TT || avctx->field_order == AV_FIELD_TB)
350  frame->top_field_first = 1;
351  }
352 
353  *got_frame = 1;
354  return buf_size;
355 }
356 
358 {
359  RawVideoContext *context = avctx->priv_data;
360 
361  av_buffer_unref(&context->palette);
362  return 0;
363 }
364 
366  .name = "rawvideo",
367  .long_name = NULL_IF_CONFIG_SMALL("raw video"),
368  .type = AVMEDIA_TYPE_VIDEO,
369  .id = AV_CODEC_ID_RAWVIDEO,
370  .priv_data_size = sizeof(RawVideoContext),
372  .close = raw_close_decoder,
373  .decode = raw_decode,
374  .priv_class = &rawdec_class,
375  .capabilities = AV_CODEC_CAP_PARAM_CHANGE,
376 };
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
Definition: pixdesc.h:115
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
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
int linesize[AV_NUM_DATA_POINTERS]
number of bytes per line
Definition: avcodec.h:3746
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2116
This structure describes decoded (raw) audio or video data.
Definition: frame.h:171
AVCodec ff_rawvideo_decoder
Definition: rawdec.c:365
AVOption.
Definition: opt.h:255
ptrdiff_t const GLvoid * data
Definition: opengl_enc.c:101
misc image utilities
#define LIBAVUTIL_VERSION_INT
Definition: version.h:62
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:441
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
Definition: bswapdsp.h:26
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:2068
int is_2_4_bpp
Definition: rawdec.c:44
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
Definition: pixfmt.h:117
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1721
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:126
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
Picture data structure.
Definition: avcodec.h:3744
static const AVOption options[]
Definition: rawdec.c:54
int frame_size
Definition: rawdec.c:42
AVCodec.
Definition: avcodec.h:3473
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
Definition: bytestream.h:87
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
#define FFALIGN(x, a)
Definition: common.h:71
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
Definition: pixfmt.h:115
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:74
8 bit with AV_PIX_FMT_RGB32 palette
Definition: pixfmt.h:74
AVOptions.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointers to the image data planes
Definition: avcodec.h:3745
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
Definition: imgutils.c:152
#define AVPALETTE_SIZE
Definition: pixfmt.h:33
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
Definition: utils.c:875
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:1616
BswapDSPContext bbdsp
Definition: rawdec.c:49
static AVFrame * frame
unsigned int bitstream_buf_size
Definition: rawdec.c:51
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:367
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
Definition: avcodec.h:2997
#define AV_WB16(p, v)
Definition: intreadwrite.h:405
#define av_log(a,...)
int is_lt_16bpp
Definition: rawdec.c:46
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
void * bitstream_buf
Definition: rawdec.c:50
#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:175
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
Definition: pixfmt.h:91
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:3480
#define FFMAX(a, b)
Definition: common.h:64
Libavcodec external API header.
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:241
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:242
Raw Video Codec.
float y
static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
Definition: rawdec.c:149
#define AV_PIX_FMT_FLAG_PSEUDOPAL
The pixel format is "pseudo-paletted".
Definition: pixdesc.h:141
void av_frame_set_pkt_pos(AVFrame *frame, int64_t val)
packed RGB 8:8:8, 24bpp, BGRBGR...
Definition: pixfmt.h:66
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Definition: utils.c:1134
int frame_size
Definition: mxfenc.c:1803
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:199
uint8_t flags
Definition: pixdesc.h:90
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
#define AV_OPT_FLAG_VIDEO_PARAM
Definition: opt.h:291
main external API structure.
Definition: avcodec.h:1501
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:1533
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Definition: pixfmt.h:64
void * buf
Definition: avisynth_c.h:553
int extradata_size
Definition: avcodec.h:1617
Describe the class of an AVClass context structure.
Definition: log.h:67
static av_cold int raw_close_decoder(AVCodecContext *avctx)
Definition: rawdec.c:357
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
Definition: opt.h:286
int palette_has_changed
Tell user application that palette has changed from previous frame.
Definition: frame.h:377
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:116
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:182
#define MKSCALE16(name, r16, w16)
Scale buffer to 16 bits per coded sample resolution.
Definition: rawdec.c:129
static int decode(AVCodecContext *avctx, void *data, int *got_sub, AVPacket *avpkt)
Definition: ccaption_dec.c:522
A reference to a data buffer.
Definition: buffer.h:81
Y , 8bpp.
Definition: pixfmt.h:71
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:72
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: avcodec.h:927
static void flip(AVCodecContext *avctx, AVPicture *picture)
Definition: rawdec.c:115
static av_cold int raw_init_decoder(AVCodecContext *avctx)
Definition: rawdec.c:65
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:111
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
Definition: bswapdsp.c:49
void * priv_data
Definition: avcodec.h:1543
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:372
int len
const PixelFormatTag avpriv_pix_fmt_bps_avi[]
Definition: raw.c:243
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 -> keyframe, 0-> not
Definition: frame.h:237
const PixelFormatTag avpriv_pix_fmt_bps_mov[]
Definition: raw.c:256
uint8_t * av_packet_get_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:324
#define FFSWAP(type, a, b)
Definition: common.h:69
#define MKTAG(a, b, c, d)
Definition: common.h:315
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:87
This structure stores compressed data.
Definition: avcodec.h:1399
static const AVClass rawdec_class
Definition: rawdec.c:59