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);
197 stride = avctx->width;
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);
243 frame->
pkt_pos = avctx->internal->last_pkt_props->pos;
244 frame->
pkt_duration = avctx->internal->last_pkt_props->duration;
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) {
272 i += stride - (i %
stride) - 1;
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) {
283 i += stride - (i %
stride) - 1;
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) {
296 i += stride - (i %
stride) - 1;
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) {
314 i += stride - (i %
stride) - 1;
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) {
347 memcpy(frame->
buf[0]->
data, buf, buf_size);
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) {
387 int vid_size = avctx->width * avctx->height;
388 int pal_size = avpkt->size - vid_size;
391 const uint8_t *pal = avpkt->data + vid_size;
407 FFALIGN(frame->
linesize[0], linesize_align) * avctx->height <= buf_size)
412 FFALIGN(frame->
linesize[1], linesize_align) * ((avctx->height + 1) / 2) <= buf_size) {
414 frame->
data[1] += (la0 - frame->
linesize[0]) * avctx->height;
422 if (!frame->
buf[1]) {
430 ((frame->
linesize[0] + 3) & ~3) * avctx->height <= buf_size)
436 if (avctx->codec_tag ==
MKTAG(
'Y',
'V',
'1',
'2') ||
437 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'1',
'6') ||
438 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'2',
'4') ||
439 avctx->codec_tag ==
MKTAG(
'Y',
'V',
'U',
'9'))
442 if (avctx->codec_tag ==
AV_RL32(
"I420") && (avctx->width+1)*(avctx->height+1) * 3/2 == buf_size) {
443 frame->
data[1] = frame->
data[1] + (avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height;
444 frame->
data[2] = frame->
data[2] + ((avctx->width+1)*(avctx->height+1) -avctx->width*avctx->height)*5/4;
447 if (avctx->codec_tag ==
AV_RL32(
"yuv2") &&
451 for (y = 0; y < avctx->height; y++) {
452 for (x = 0; x < avctx->width; x++)
453 line[2 * x + 1] ^= 0x80;
458 if (avctx->codec_tag ==
AV_RL32(
"b64a") &&
463 for (y = 0; y < avctx->height; y++) {
464 for (x = 0; x >> 3 < avctx->width; x += 8) {
466 AV_WB64(&dst[x], v << 16 | v >> 48);
500 .priv_class = &rawdec_class,
#define AV_PIX_FMT_FLAG_PAL
Pixel format has a palette in data[1], values are indexes in this palette.
int av_buffer_make_writable(AVBufferRef **pbuf)
Create a writable reference from a given buffer reference, avoiding data copy if possible.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
This structure describes decoded (raw) audio or video data.
void(* bswap16_buf)(uint16_t *dst, const uint16_t *src, int len)
AVCodec ff_rawvideo_decoder
ptrdiff_t const GLvoid * data
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, copy it to dst and return 1; else return 0.
int64_t pkt_pos
reordered pos from the last AVPacket that has been input into the decoder
#define LIBAVUTIL_VERSION_INT
packed RGB 8:8:8, 24bpp, RGBRGB...
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
static av_cold int init(AVCodecContext *avctx)
int av_get_bits_per_pixel(const AVPixFmtDescriptor *pixdesc)
Return the number of bits per pixel used by the pixel format described by pixdesc.
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), little-endian, X=unused/undefined ...
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...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
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...
int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame)
Set various frame properties from the codec context / packet data.
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
static const AVOption options[]
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_RL16
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
packed RGB 5:6:5, 16bpp, (msb) 5R 6G 5B(lsb), little-endian
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
#define av_assert0(cond)
assert() equivalent, that is always enabled.
8 bits with AV_PIX_FMT_RGB32 palette
void(* bswap_buf)(uint32_t *dst, const uint32_t *src, int w)
int avpriv_set_systematic_pal2(uint32_t pal[256], enum AVPixelFormat pix_fmt)
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
const PixelFormatTag ff_raw_pix_fmt_tags[]
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
unsigned int bitstream_buf_size
bitstream reader API header.
int interlaced_frame
The content of the picture is interlaced.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
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...
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
planar YUV 4:2:0, 12bpp, 1 plane for Y and 1 plane for the UV components, which are interleaved (firs...
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
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...
enum AVPictureType pict_type
Picture type of the frame.
static int raw_decode(AVCodecContext *avctx, void *data, int *got_frame, AVPacket *avpkt)
#define AV_PIX_FMT_FLAG_PSEUDOPAL
The pixel format is "pseudo-paletted".
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
packed RGB 8:8:8, 24bpp, BGRBGR...
enum AVPixelFormat avpriv_find_pix_fmt(const PixelFormatTag *tags, unsigned int fourcc)
Libavcodec external API header.
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown...
AVBufferRef * av_buffer_alloc(buffer_size_t size)
Allocate an AVBuffer of the given size using av_malloc().
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
#define AV_OPT_FLAG_VIDEO_PARAM
main external API structure.
uint8_t * data
The data buffer.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
packed YUV 4:2:2, 16bpp, Y0 Cb Y1 Cr
Describe the class of an AVClass context structure.
static av_cold int raw_close_decoder(AVCodecContext *avctx)
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
int palette_has_changed
Tell user application that palette has changed from previous frame.
refcounted data buffer API
packed RGB 5:5:5, 16bpp, (msb)1X 5R 5G 5B(lsb), big-endian , X=unused/undefined
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
#define MKSCALE16(name, r16, w16)
Scale buffer to 16 bits per coded sample resolution.
A reference to a data buffer.
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb...
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
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...
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
static av_cold int raw_init_decoder(AVCodecContext *avctx)
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
#define AV_PIX_FMT_FLAG_BE
Pixel format is big-endian.
av_cold void ff_bswapdsp_init(BswapDSPContext *c)
int top_field_first
If the content is interlaced, is top field displayed first.
const PixelFormatTag avpriv_pix_fmt_bps_avi[]
int key_frame
1 -> keyframe, 0-> not
const PixelFormatTag avpriv_pix_fmt_bps_mov[]
#define FFSWAP(type, a, b)
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
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 local context
#define MKTAG(a, b, c, d)
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
This structure stores compressed data.
static const AVClass rawdec_class