Go to the documentation of this file.
103 memset(
context->palette->data, 0xff, 4);
135 frame->linesize[0] *= -1;
141 #define SCALE16(x, bits) (((x) << (16 - (bits))) | ((x) >> (2 * (bits) - 16)))
146 #define MKSCALE16(name, r16, w16) \
147 static void name(AVCodecContext *avctx, uint8_t * dst, const uint8_t *buf, int buf_size, int packed) \
151 for (i = 0; i + 1 < buf_size; i += 2) \
152 w16(dst + i, SCALE16(r16(buf + i), avctx->bits_per_coded_sample)); \
155 init_get_bits(&gb, buf, buf_size * 8); \
156 for (i = 0; i < avctx->width * avctx->height; i++) { \
157 int sample = get_bits(&gb, avctx->bits_per_coded_sample); \
158 w16(dst + i*2, SCALE16(sample, avctx->bits_per_coded_sample)); \
171 const uint8_t *buf = avpkt->data;
172 int buf_size = avpkt->size;
173 int linesize_align = 4;
178 if (avctx->width <= 0) {
182 if (avctx->height <= 0) {
188 stride = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
192 stride = avpkt->size / avctx->height;
196 if (
stride == 0 || avpkt->size <
stride * avctx->height) {
203 if ((avctx->bits_per_coded_sample == 8 || avctx->bits_per_coded_sample == 4 ||
204 avctx->bits_per_coded_sample == 2 || avctx->bits_per_coded_sample == 1 ||
205 (avctx->bits_per_coded_sample == 0 && (
context->is_nut_pal8 ||
context->is_mono)) ) &&
207 (!avctx->codec_tag || avctx->codec_tag ==
MKTAG(
'r',
'a',
'w',
' ') ||
211 int row_bytes = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
254 int i, j, row_pix = 0;
255 uint8_t *dst =
frame->buf[0]->data;
257 if (avctx->bits_per_coded_sample == 8 ||
context->is_nut_pal8 ||
context->is_mono) {
258 int pix_per_byte =
context->is_mono ? 8 : 1;
259 for (
i = 0, j = 0; j < buf_size &&
i<avpkt->size;
i++, j++) {
261 row_pix += pix_per_byte;
262 if (row_pix >= avctx->width) {
264 j += 16 - (j % 16) - 1;
268 }
else if (avctx->bits_per_coded_sample == 4) {
269 for (
i = 0, j = 0; 2 * j + 1 < buf_size &&
i<avpkt->size;
i++, j++) {
270 dst[2 * j + 0] = buf[
i] >> 4;
271 dst[2 * j + 1] = buf[
i] & 15;
273 if (row_pix >= avctx->width) {
275 j += 8 - (j % 8) - 1;
279 }
else if (avctx->bits_per_coded_sample == 2) {
280 for (
i = 0, j = 0; 4 * j + 3 < buf_size &&
i<avpkt->size;
i++, j++) {
281 dst[4 * j + 0] = buf[
i] >> 6;
282 dst[4 * j + 1] = buf[
i] >> 4 & 3;
283 dst[4 * j + 2] = buf[
i] >> 2 & 3;
284 dst[4 * j + 3] = buf[
i] & 3;
286 if (row_pix >= avctx->width) {
288 j += 4 - (j % 4) - 1;
293 av_assert0(avctx->bits_per_coded_sample == 1);
294 for (
i = 0, j = 0; 8 * j + 7 < buf_size &&
i<avpkt->size;
i++, j++) {
295 dst[8 * j + 0] = buf[
i] >> 7;
296 dst[8 * j + 1] = buf[
i] >> 6 & 1;
297 dst[8 * j + 2] = buf[
i] >> 5 & 1;
298 dst[8 * j + 3] = buf[
i] >> 4 & 1;
299 dst[8 * j + 4] = buf[
i] >> 3 & 1;
300 dst[8 * j + 5] = buf[
i] >> 2 & 1;
301 dst[8 * j + 6] = buf[
i] >> 1 & 1;
302 dst[8 * j + 7] = buf[
i] & 1;
304 if (row_pix >= avctx->width) {
306 j += 2 - (j % 2) - 1;
313 }
else if (
context->is_lt_16bpp) {
314 uint8_t *dst =
frame->buf[0]->data;
315 int packed = (avctx->codec_tag & 0xFFFFFF) ==
MKTAG(
'B',
'I',
'T', 0);
316 int swap = avctx->codec_tag >> 24;
318 if (packed && swap) {
323 context->bbdsp.bswap16_buf(
context->bitstream_buf, (
const uint16_t*)buf, buf_size / 2);
325 context->bbdsp.bswap_buf(
context->bitstream_buf, (
const uint32_t*)buf, buf_size / 4);
332 scale16be(avctx, dst, buf, buf_size, packed);
334 scale16le(avctx, dst, buf, buf_size, packed);
337 }
else if (need_copy) {
338 memcpy(
frame->buf[0]->data, buf, buf_size);
339 buf =
frame->buf[0]->data;
342 if (avctx->codec_tag ==
MKTAG(
'A',
'V',
'1',
'x') ||
343 avctx->codec_tag ==
MKTAG(
'A',
'V',
'u',
'p'))
344 buf += buf_size -
context->frame_size;
347 if (buf_size <
len && ((avctx->codec_tag & 0xFFFFFF) !=
MKTAG(
'B',
'I',
'T', 0) || !need_copy)) {
348 av_log(avctx,
AV_LOG_ERROR,
"Invalid buffer size, packet size %d < expected frame_size %d\n", buf_size,
len);
355 avctx->width, avctx->height, 1)) < 0) {
376 #if FF_API_PALETTE_HAS_CHANGED
378 frame->palette_has_changed = 1;
381 }
else if (
context->is_nut_pal8) {
382 int vid_size = avctx->width * avctx->height;
383 int pal_size = avpkt->size - vid_size;
386 const uint8_t *pal = avpkt->data + vid_size;
387 memcpy(
context->palette->data, pal, pal_size);
388 #if FF_API_PALETTE_HAS_CHANGED
390 frame->palette_has_changed = 1;
406 FFALIGN(
frame->linesize[0], linesize_align) * avctx->height <= buf_size)
410 FFALIGN(
frame->linesize[0], linesize_align) * avctx->height +
411 FFALIGN(
frame->linesize[1], linesize_align) * ((avctx->height + 1) / 2) <= buf_size) {
413 frame->data[1] += (la0 -
frame->linesize[0]) * avctx->height;
414 frame->linesize[0] = la0;
420 if (!
frame->buf[1]) {
428 ((
frame->linesize[0] + 3) & ~3) * avctx->height <= buf_size)
429 frame->linesize[0] = (
frame->linesize[0] + 3) & ~3;
434 if (avctx->codec_tag ==
MKTAG(
'Y',
'V',
'1',
'2') ||
435 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'1',
'6') ||
436 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'2',
'4') ||
437 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'U',
'9'))
440 if (avctx->codec_tag ==
AV_RL32(
"I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
441 frame->data[1] =
frame->data[1] + (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
442 frame->data[2] =
frame->data[2] + ((avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height)*5/4;
445 if (avctx->codec_tag ==
AV_RL32(
"yuv2") &&
449 for (y = 0; y < avctx->height; y++) {
450 for (x = 0; x < avctx->width; x++)
451 line[2 * x + 1] ^= 0x80;
456 if (avctx->codec_tag ==
AV_RL32(
"b64a") &&
458 uint8_t *dst =
frame->data[0];
461 for (y = 0; y < avctx->height; y++) {
462 for (x = 0; x >> 3 < avctx->width; x += 8) {
464 AV_WB64(&dst[x], v << 16 | v >> 48);
466 dst +=
frame->linesize[0];
490 .
p.
name =
"rawvideo",
static av_cold int raw_init_decoder(AVCodecContext *avctx)
#define FF_ENABLE_DEPRECATION_WARNINGS
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
#define AV_OPT_FLAG_VIDEO_PARAM
static int raw_decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
@ AV_PIX_FMT_RGBA64BE
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
unsigned int bitstream_buf_size
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
@ AV_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
AVCodec p
The public AVCodec.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
static const AVOption options[]
#define FF_CODEC_DECODE_CB(func)
int(* init)(AVBSFContext *ctx)
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
#define CODEC_LONG_NAME(str)
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option keep it simple and lowercase description are in without and describe what they for example set the foo of the bar offset is the offset of the field in your context
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
#define LIBAVUTIL_VERSION_INT
Describe the class of an AVClass context structure.
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
@ AV_PIX_FMT_MONOBLACK
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb.
@ AV_PICTURE_TYPE_I
Intra.
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
static void flip(AVCodecContext *avctx, AVFrame *frame)
enum AVPixelFormat avpriv_pix_fmt_find(enum PixelFormatTagLists list, unsigned fourcc)
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.
int av_buffer_make_writable(AVBufferRef **pbuf)
Create a writable reference from a given buffer reference, avoiding data copy if possible.
#define MKSCALE16(name, r16, w16)
Scale buffer to 16 bits per coded sample resolution.
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.
@ AV_FIELD_TT
Top coded_first, top displayed first.
AVBufferRef * av_buffer_alloc(size_t size)
Allocate an AVBuffer of the given size using av_malloc().
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
#define i(width, name, range_min, range_max)
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
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...
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
const char * name
Name of the codec implementation.
const FFCodec ff_rawvideo_decoder
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
@ AV_PIX_FMT_NV12
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
#define FFSWAP(type, a, b)
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
static av_cold int raw_close_decoder(AVCodecContext *avctx)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
main external API structure.
static const AVClass rawdec_class
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
#define FF_DISABLE_DEPRECATION_WARNINGS
A reference to a data buffer.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
This structure stores compressed data.
@ AV_FIELD_TB
Top coded first, bottom displayed first.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define MKTAG(a, b, c, d)
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...
int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
Check whether the side-data of src contains a palette of size AVPALETTE_SIZE; if so,...
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
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
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