146 #define SCALE16(x, bits) (((x) << (16 - (bits))) | ((x) >> (2 * (bits) - 16)))
151 #define MKSCALE16(name, r16, w16) \
152 static void name(AVCodecContext *avctx, uint8_t * dst, const uint8_t *buf, int buf_size, int packed) \
156 for (i = 0; i + 1 < buf_size; i += 2) \
157 w16(dst + i, SCALE16(r16(buf + i), avctx->bits_per_coded_sample)); \
160 init_get_bits(&gb, buf, buf_size * 8); \
161 for (i = 0; i < avctx->width * avctx->height; i++) { \
162 int sample = get_bits(&gb, avctx->bits_per_coded_sample); \
163 w16(dst + i*2, SCALE16(sample, avctx->bits_per_coded_sample)); \
176 const uint8_t *buf = avpkt->data;
177 int buf_size = avpkt->size;
178 int linesize_align = 4;
185 if (avctx->width <= 0) {
189 if (avctx->height <= 0) {
195 stride = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
199 stride = avpkt->size / avctx->height;
203 if (
stride == 0 || avpkt->size <
stride * avctx->height) {
210 if ((avctx->bits_per_coded_sample == 8 || avctx->bits_per_coded_sample == 4 ||
211 avctx->bits_per_coded_sample == 2 || avctx->bits_per_coded_sample == 1 ||
212 (avctx->bits_per_coded_sample == 0 && (context->
is_nut_pal8 || context->
is_mono)) ) &&
214 (!avctx->codec_tag || avctx->codec_tag ==
MKTAG(
'r',
'a',
'w',
' ') ||
218 int row_bytes = avctx->width / 8 + (avctx->width & 7 ? 1 : 0);
246 if (context->
tff >= 0) {
263 int i, j, row_pix = 0;
267 int pix_per_byte = context->
is_mono ? 8 : 1;
268 for (
i = 0, j = 0; j < buf_size &&
i<avpkt->size;
i++, j++) {
270 row_pix += pix_per_byte;
271 if (row_pix >= avctx->width) {
273 j += 16 - (j % 16) - 1;
277 }
else if (avctx->bits_per_coded_sample == 4) {
278 for (
i = 0, j = 0; 2 * j + 1 < buf_size &&
i<avpkt->size;
i++, j++) {
279 dst[2 * j + 0] = buf[
i] >> 4;
280 dst[2 * j + 1] = buf[
i] & 15;
282 if (row_pix >= avctx->width) {
284 j += 8 - (j % 8) - 1;
288 }
else if (avctx->bits_per_coded_sample == 2) {
289 for (
i = 0, j = 0; 4 * j + 3 < buf_size &&
i<avpkt->size;
i++, j++) {
290 dst[4 * j + 0] = buf[
i] >> 6;
291 dst[4 * j + 1] = buf[
i] >> 4 & 3;
292 dst[4 * j + 2] = buf[
i] >> 2 & 3;
293 dst[4 * j + 3] = buf[
i] & 3;
295 if (row_pix >= avctx->width) {
297 j += 4 - (j % 4) - 1;
302 av_assert0(avctx->bits_per_coded_sample == 1);
303 for (
i = 0, j = 0; 8 * j + 7 < buf_size &&
i<avpkt->size;
i++, j++) {
304 dst[8 * j + 0] = buf[
i] >> 7;
305 dst[8 * j + 1] = buf[
i] >> 6 & 1;
306 dst[8 * j + 2] = buf[
i] >> 5 & 1;
307 dst[8 * j + 3] = buf[
i] >> 4 & 1;
308 dst[8 * j + 4] = buf[
i] >> 3 & 1;
309 dst[8 * j + 5] = buf[
i] >> 2 & 1;
310 dst[8 * j + 6] = buf[
i] >> 1 & 1;
311 dst[8 * j + 7] = buf[
i] & 1;
313 if (row_pix >= avctx->width) {
315 j += 2 - (j % 2) - 1;
324 int packed = (avctx->codec_tag & 0xFFFFFF) ==
MKTAG(
'B',
'I',
'T', 0);
325 int swap = avctx->codec_tag >> 24;
327 if (packed && swap) {
341 scale16be(avctx, dst, buf, buf_size, packed);
343 scale16le(avctx, dst, buf, buf_size, packed);
346 }
else if (need_copy) {
351 if (avctx->codec_tag ==
MKTAG(
'A',
'V',
'1',
'x') ||
352 avctx->codec_tag ==
MKTAG(
'A',
'V',
'u',
'p'))
356 if (buf_size <
len && ((avctx->codec_tag & 0xFFFFFF) !=
MKTAG(
'B',
'I',
'T', 0) || !need_copy)) {
357 av_log(avctx,
AV_LOG_ERROR,
"Invalid buffer size, packet size %d < expected frame_size %d\n", buf_size,
len);
364 avctx->width, avctx->height, 1)) < 0) {
396 int vid_size = avctx->width * avctx->height;
397 int pal_size = avpkt->size - vid_size;
400 pal = avpkt->data + vid_size;
445 if (avctx->codec_tag ==
MKTAG(
'Y',
'V',
'1',
'2') ||
446 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'1',
'6') ||
447 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'2',
'4') ||
448 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'U',
'9'))
451 if (avctx->codec_tag ==
AV_RL32(
"I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
452 frame->
data[1] =
frame->
data[1] + (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
453 frame->
data[2] =
frame->
data[2] + ((avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height)*5/4;
456 if (avctx->codec_tag ==
AV_RL32(
"yuv2") &&
460 for (y = 0; y < avctx->height; y++) {
461 for (x = 0; x < avctx->width; x++)
462 line[2 * x + 1] ^= 0x80;
467 if (avctx->codec_tag ==
AV_RL32(
"b64a") &&
472 for (y = 0; y < avctx->height; y++) {
473 for (x = 0; x >> 3 < avctx->width; x += 8) {
475 AV_WB64(&dst[x], v << 16 | v >> 48);
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Libavcodec external API header.
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t *size)
static av_cold int init(AVCodecContext *avctx)
refcounted data buffer API
common internal and external API header
#define FFSWAP(type, a, b)
#define MKTAG(a, b, c, d)
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
bitstream reader API header.
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
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...
@ AV_PKT_DATA_PALETTE
An AV_PKT_DATA_PALETTE side data packet contains exactly AVPALETTE_SIZE bytes worth of palette.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
AVBufferRef * av_buffer_alloc(buffer_size_t size)
Allocate an AVBuffer of the given size using av_malloc().
int av_buffer_make_writable(AVBufferRef **pbuf)
Create a writable reference from a given buffer reference, avoiding data copy if possible.
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
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.
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 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.
@ AV_PICTURE_TYPE_I
Intra.
#define LIBAVUTIL_VERSION_INT
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
static void flip(AVCodecContext *avctx, AVFrame *frame)
static av_cold int raw_close_decoder(AVCodecContext *avctx)
static const AVOption options[]
static av_cold int raw_init_decoder(AVCodecContext *avctx)
#define MKSCALE16(name, r16, w16)
Scale buffer to 16 bits per coded sample resolution.
static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
static const AVClass rawdec_class
AVCodec ff_rawvideo_decoder
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
#define AV_OPT_FLAG_VIDEO_PARAM
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
#define AV_PIX_FMT_FLAG_PSEUDOPAL
The pixel format is "pseudo-paletted".
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this 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...
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
@ 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_PIX_FMT_RGB555BE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
@ 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...
@ AV_PIX_FMT_RGB565LE
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
@ AV_PIX_FMT_RGB555LE
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined
@ AV_PIX_FMT_YUYV422
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
@ AV_PIX_FMT_BGR24
packed RGB 8:8:8, 24bpp, BGRBGR...
@ AV_PIX_FMT_MONOWHITE
Y , 1bpp, 0 is white, 1 is black, in each byte pixels are ordered from the msb to the lsb.
const PixelFormatTag avpriv_pix_fmt_bps_avi[]
const PixelFormatTag avpriv_pix_fmt_bps_mov[]
const PixelFormatTag ff_raw_pix_fmt_tags[]
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
A reference to a data buffer.
uint8_t * data
The data buffer.
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
main external API structure.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
const char * name
Name of the codec implementation.
This structure describes decoded (raw) audio or video data.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
int key_frame
1 -> keyframe, 0-> not
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown.
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
int palette_has_changed
Tell user application that palette has changed from previous frame.
int top_field_first
If the content is interlaced, is top field displayed first.
int interlaced_frame
The content of the picture is interlaced.
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
enum AVPictureType pict_type
Picture type of the frame.
This structure stores compressed data.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
unsigned int bitstream_buf_size