Go to the documentation of this file.
102 memset(
context->palette->data, 0xff, 4);
134 frame->linesize[0] *= -1;
140 #define SCALE16(x, bits) (((x) << (16 - (bits))) | ((x) >> (2 * (bits) - 16)))
145 #define MKSCALE16(name, r16, w16) \
146 static void name(AVCodecContext *avctx, uint8_t * dst, const uint8_t *buf, int buf_size, int packed) \
150 for (i = 0; i + 1 < buf_size; i += 2) \
151 w16(dst + i, SCALE16(r16(buf + i), avctx->bits_per_coded_sample)); \
154 init_get_bits(&gb, buf, buf_size * 8); \
155 for (i = 0; i < avctx->width * avctx->height; i++) { \
156 int sample = get_bits(&gb, avctx->bits_per_coded_sample); \
157 w16(dst + i*2, SCALE16(sample, avctx->bits_per_coded_sample)); \
170 const uint8_t *buf = avpkt->data;
171 int buf_size = avpkt->size;
172 int linesize_align = 4;
179 if (avctx->width <= 0) {
183 if (avctx->height <= 0) {
189 stride = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
193 stride = avpkt->size / avctx->height;
197 if (
stride == 0 || avpkt->size <
stride * avctx->height) {
204 if ((avctx->bits_per_coded_sample == 8 || avctx->bits_per_coded_sample == 4 ||
205 avctx->bits_per_coded_sample == 2 || avctx->bits_per_coded_sample == 1 ||
206 (avctx->bits_per_coded_sample == 0 && (
context->is_nut_pal8 ||
context->is_mono)) ) &&
208 (!avctx->codec_tag || avctx->codec_tag ==
MKTAG(
'r',
'a',
'w',
' ') ||
212 int row_bytes = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
231 frame->key_frame = 1;
237 frame->pkt_pos = avctx->internal->last_pkt_props->pos;
238 frame->pkt_duration = avctx->internal->last_pkt_props->duration;
241 frame->interlaced_frame = 1;
257 int i, j, row_pix = 0;
258 uint8_t *dst =
frame->buf[0]->data;
260 if (avctx->bits_per_coded_sample == 8 ||
context->is_nut_pal8 ||
context->is_mono) {
261 int pix_per_byte =
context->is_mono ? 8 : 1;
262 for (
i = 0, j = 0; j < buf_size &&
i<avpkt->size;
i++, j++) {
264 row_pix += pix_per_byte;
265 if (row_pix >= avctx->width) {
267 j += 16 - (j % 16) - 1;
271 }
else if (avctx->bits_per_coded_sample == 4) {
272 for (
i = 0, j = 0; 2 * j + 1 < buf_size &&
i<avpkt->size;
i++, j++) {
273 dst[2 * j + 0] = buf[
i] >> 4;
274 dst[2 * j + 1] = buf[
i] & 15;
276 if (row_pix >= avctx->width) {
278 j += 8 - (j % 8) - 1;
282 }
else if (avctx->bits_per_coded_sample == 2) {
283 for (
i = 0, j = 0; 4 * j + 3 < buf_size &&
i<avpkt->size;
i++, j++) {
284 dst[4 * j + 0] = buf[
i] >> 6;
285 dst[4 * j + 1] = buf[
i] >> 4 & 3;
286 dst[4 * j + 2] = buf[
i] >> 2 & 3;
287 dst[4 * j + 3] = buf[
i] & 3;
289 if (row_pix >= avctx->width) {
291 j += 4 - (j % 4) - 1;
296 av_assert0(avctx->bits_per_coded_sample == 1);
297 for (
i = 0, j = 0; 8 * j + 7 < buf_size &&
i<avpkt->size;
i++, j++) {
298 dst[8 * j + 0] = buf[
i] >> 7;
299 dst[8 * j + 1] = buf[
i] >> 6 & 1;
300 dst[8 * j + 2] = buf[
i] >> 5 & 1;
301 dst[8 * j + 3] = buf[
i] >> 4 & 1;
302 dst[8 * j + 4] = buf[
i] >> 3 & 1;
303 dst[8 * j + 5] = buf[
i] >> 2 & 1;
304 dst[8 * j + 6] = buf[
i] >> 1 & 1;
305 dst[8 * j + 7] = buf[
i] & 1;
307 if (row_pix >= avctx->width) {
309 j += 2 - (j % 2) - 1;
316 }
else if (
context->is_lt_16bpp) {
317 uint8_t *dst =
frame->buf[0]->data;
318 int packed = (avctx->codec_tag & 0xFFFFFF) ==
MKTAG(
'B',
'I',
'T', 0);
319 int swap = avctx->codec_tag >> 24;
321 if (packed && swap) {
326 context->bbdsp.bswap16_buf(
context->bitstream_buf, (
const uint16_t*)buf, buf_size / 2);
328 context->bbdsp.bswap_buf(
context->bitstream_buf, (
const uint32_t*)buf, buf_size / 4);
335 scale16be(avctx, dst, buf, buf_size, packed);
337 scale16le(avctx, dst, buf, buf_size, packed);
340 }
else if (need_copy) {
341 memcpy(
frame->buf[0]->data, buf, buf_size);
342 buf =
frame->buf[0]->data;
345 if (avctx->codec_tag ==
MKTAG(
'A',
'V',
'1',
'x') ||
346 avctx->codec_tag ==
MKTAG(
'A',
'V',
'u',
'p'))
347 buf += buf_size -
context->frame_size;
350 if (buf_size <
len && ((avctx->codec_tag & 0xFFFFFF) !=
MKTAG(
'B',
'I',
'T', 0) || !need_copy)) {
351 av_log(avctx,
AV_LOG_ERROR,
"Invalid buffer size, packet size %d < expected frame_size %d\n", buf_size,
len);
358 avctx->width, avctx->height, 1)) < 0) {
379 frame->palette_has_changed = 1;
380 }
else if (
context->is_nut_pal8) {
381 int vid_size = avctx->width * avctx->height;
382 int pal_size = avpkt->size - vid_size;
385 const uint8_t *pal = avpkt->data + vid_size;
386 memcpy(
context->palette->data, pal, pal_size);
387 frame->palette_has_changed = 1;
401 FFALIGN(
frame->linesize[0], linesize_align) * avctx->height <= buf_size)
405 FFALIGN(
frame->linesize[0], linesize_align) * avctx->height +
406 FFALIGN(
frame->linesize[1], linesize_align) * ((avctx->height + 1) / 2) <= buf_size) {
408 frame->data[1] += (la0 -
frame->linesize[0]) * avctx->height;
409 frame->linesize[0] = la0;
415 if (!
frame->buf[1]) {
423 ((
frame->linesize[0] + 3) & ~3) * avctx->height <= buf_size)
424 frame->linesize[0] = (
frame->linesize[0] + 3) & ~3;
429 if (avctx->codec_tag ==
MKTAG(
'Y',
'V',
'1',
'2') ||
430 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'1',
'6') ||
431 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'2',
'4') ||
432 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'U',
'9'))
435 if (avctx->codec_tag ==
AV_RL32(
"I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
436 frame->data[1] =
frame->data[1] + (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
437 frame->data[2] =
frame->data[2] + ((avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height)*5/4;
440 if (avctx->codec_tag ==
AV_RL32(
"yuv2") &&
444 for (y = 0; y < avctx->height; y++) {
445 for (x = 0; x < avctx->width; x++)
446 line[2 * x + 1] ^= 0x80;
451 if (avctx->codec_tag ==
AV_RL32(
"b64a") &&
453 uint8_t *dst =
frame->data[0];
456 for (y = 0; y < avctx->height; y++) {
457 for (x = 0; x >> 3 < avctx->width; x += 8) {
459 AV_WB64(&dst[x], v << 16 | v >> 48);
461 dst +=
frame->linesize[0];
466 frame->interlaced_frame = 1;
468 frame->top_field_first = 1;
static av_cold int raw_init_decoder(AVCodecContext *avctx)
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
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
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_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
static const AVOption options[]
#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
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)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
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.
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.
static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
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.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
@ 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.
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.
#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.
const AVCodec ff_rawvideo_decoder
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