98 0x01, 0x01, 0x11, 0x11, 0x55, 0x55, 0xff,
103 0xff, 0xff, 0x0f, 0xff, 0x33, 0xff, 0x55,
108 0xff, 0x0f, 0xff, 0x33, 0xff, 0x55, 0xff
118 int x,
mask, dsp_mask, j, src_x,
b,
bpp;
125 switch (bits_per_pixel) {
128 for (x = 0; x <
width; x++) {
130 if ((dsp_mask << j) & 0x80) {
131 b = (src[src_x >> 3] >> (7 - (src_x & 7))) & 1;
132 dst[x >> 3] &= 0xFF7F>>j;
133 dst[x >> 3] |= b << (7 - j);
135 if ((mask << j) & 0x80)
141 for (x = 0; x <
width; x++) {
142 int j2 = 2 * (x & 3);
144 if ((dsp_mask << j) & 0x80) {
145 b = (src[src_x >> 2] >> (6 - 2*(src_x & 3))) & 3;
146 dst[x >> 2] &= 0xFF3F>>j2;
147 dst[x >> 2] |= b << (6 - j2);
149 if ((mask << j) & 0x80)
155 for (x = 0; x <
width; x++) {
158 if ((dsp_mask << j) & 0x80) {
159 b = (src[src_x >> 1] >> (4 - 4*(src_x & 1))) & 15;
160 dst[x >> 1] &= 0xFF0F>>j2;
161 dst[x >> 1] |= b << (4 - j2);
163 if ((mask << j) & 0x80)
168 bpp = bits_per_pixel >> 3;
171 for (x = 0; x <
width; x++) {
173 if ((dsp_mask << j) & 0x80) {
177 if ((mask << j) & 0x80)
188 for (i = 0; i < w; i++) {
189 int a,
b,
c, p, pa, pb, pc;
202 if (pa <= pb && pa <= pc)
212 #define UNROLL1(bpp, op) \ 221 for (; i <= size - bpp; i += bpp) { \ 222 dst[i + 0] = r = op(r, src[i + 0], last[i + 0]); \ 225 dst[i + 1] = g = op(g, src[i + 1], last[i + 1]); \ 228 dst[i + 2] = b = op(b, src[i + 2], last[i + 2]); \ 231 dst[i + 3] = a = op(a, src[i + 3], last[i + 3]); \ 235 #define UNROLL_FILTER(op) \ 238 } else if (bpp == 2) { \ 240 } else if (bpp == 3) { \ 242 } else if (bpp == 4) { \ 245 for (; i < size; i++) { \ 246 dst[i] = op(dst[i - bpp], src[i], last[i]); \ 253 int i, p,
r,
g,
b,
a;
255 switch (filter_type) {
257 memcpy(dst, src, size);
260 for (i = 0; i <
bpp; i++)
265 unsigned s = *(
int *)(src + i);
266 p = ((s & 0x7f7f7f7f) + (p & 0x7f7f7f7f)) ^ ((s ^ p) & 0x80808080);
267 *(
int *)(dst + i) = p;
270 #define OP_SUB(x, s, l) ((x) + (s)) 278 for (i = 0; i <
bpp; i++) {
282 #define OP_AVG(x, s, l) (((((x) + (l)) >> 1) + (s)) & 0xff) 286 for (i = 0; i <
bpp; i++) {
290 if (bpp > 2 && size > 4) {
293 int w = (bpp & 3) ? size - 3 : size;
307 #define YUV2RGB(NAME, TYPE) \ 308 static void deloco_ ## NAME(TYPE *dst, int size, int alpha) \ 311 for (i = 0; i < size; i += 3 + alpha) { \ 312 int g = dst [i + 1]; \ 327 if (!s->interlace_type) {
328 ptr = s->image_buf + s->image_linesize * (s->y + s->y_offset) + s->x_offset * s->bpp;
330 last_row = s->last_row;
332 last_row = ptr - s->image_linesize;
335 last_row, s->row_size, s->bpp);
338 if (s->bit_depth == 16) {
339 deloco_rgb16((uint16_t *)(ptr - s->image_linesize), s->row_size / 2,
342 deloco_rgb8(ptr - s->image_linesize, s->row_size,
347 if (s->y == s->cur_h) {
350 if (s->bit_depth == 16) {
351 deloco_rgb16((uint16_t *)ptr, s->row_size / 2,
354 deloco_rgb8(ptr, s->row_size,
362 ptr = s->image_buf + s->image_linesize * (s->y + s->y_offset) + s->x_offset * s->bpp;
368 png_filter_row(&s->dsp, s->tmp_row, s->crow_buf[0], s->crow_buf + 1,
369 s->last_row, s->pass_row_size, s->bpp);
371 FFSWAP(
unsigned int, s->last_row_size, s->tmp_row_size);
376 s->color_type, s->last_row);
379 if (s->y == s->cur_h) {
380 memset(s->last_row, 0, s->row_size);
391 s->crow_size = s->pass_row_size + 1;
392 if (s->pass_row_size != 0)
411 while (s->
zstream.avail_in > 0) {
413 if (ret != Z_OK && ret != Z_STREAM_END) {
417 if (s->
zstream.avail_out == 0) {
424 if (ret == Z_STREAM_END && s->
zstream.avail_in > 0) {
426 "%d undecompressed bytes left in buffer\n", s->
zstream.avail_in);
443 zstream.opaque =
NULL;
444 if (inflateInit(&zstream) != Z_OK)
446 zstream.next_in = (
unsigned char *)data;
447 zstream.avail_in = data_end -
data;
450 while (zstream.avail_in > 0) {
456 zstream.next_out =
buf;
457 zstream.avail_out = buf_size - 1;
458 ret =
inflate(&zstream, Z_PARTIAL_FLUSH);
459 if (ret != Z_OK && ret != Z_STREAM_END) {
463 bp->len += zstream.next_out -
buf;
464 if (ret == Z_STREAM_END)
467 inflateEnd(&zstream);
468 bp->str[bp->len] = 0;
472 inflateEnd(&zstream);
482 for (i = 0; i < size_in; i++)
483 extra += in[i] >= 0x80;
484 if (size_in == SIZE_MAX || extra > SIZE_MAX - size_in - 1)
486 q = out =
av_malloc(size_in + extra + 1);
489 for (i = 0; i < size_in; i++) {
491 *(q++) = 0xC0 | (in[i] >> 6);
492 *(q++) = 0x80 | (in[i] & 0x3F);
508 const uint8_t *keyword_end = memchr(keyword, 0, data_end - keyword);
515 data = keyword_end + 1;
518 if (data == data_end)
531 text_len = data_end - text;
538 if (!(kw_utf8 && txt_utf8)) {
590 "compression_type=%d filter_type=%d interlace_type=%d\n",
621 size_t byte_depth = s->
bit_depth > 8 ? 2 : 1;
669 "and color type %d\n",
694 "and color type %d with TRNS",
699 s->
bpp += byte_depth;
725 ff_dlog(avctx,
"row_size=%d crow_size =%d\n",
731 memcpy(p->
data[1], s->
palette, 256 *
sizeof(uint32_t));
757 s->
bpp -= byte_depth;
762 s->
bpp += byte_depth;
777 if ((length % 3) != 0 || length > 256 * 3)
781 for (i = 0; i <
n; i++) {
782 r = bytestream2_get_byte(&s->
gb);
783 g = bytestream2_get_byte(&s->
gb);
784 b = bytestream2_get_byte(&s->
gb);
785 s->
palette[i] = (0xFF
U << 24) | (r << 16) | (g << 8) | b;
814 for (i = 0; i <
length; i++) {
815 unsigned v = bytestream2_get_byte(&s->
gb);
824 for (i = 0; i < length / 2; i++) {
826 v = av_mod_uintp2(bytestream2_get_be16(&s->
gb), s->
bit_depth);
850 while ((profile_name[cnt++] = bytestream2_get_byte(&s->
gb)) && cnt < 81);
856 length =
FFMAX(length - cnt, 0);
858 if (bytestream2_get_byte(&s->
gb) != 0) {
863 length =
FFMAX(length - 1, 0);
877 memcpy(sd->
data, data, bp.len);
891 for (j = 0; j < s->
height; j++) {
893 for (k = 7; k >= 1; k--)
894 if ((s->
width&7) >= k)
895 pd[8*i + k - 1] = (pd[i]>>8-k) & 1;
896 for (i--; i >= 0; i--) {
897 pd[8*i + 7]= pd[i] & 1;
898 pd[8*i + 6]= (pd[i]>>1) & 1;
899 pd[8*i + 5]= (pd[i]>>2) & 1;
900 pd[8*i + 4]= (pd[i]>>3) & 1;
901 pd[8*i + 3]= (pd[i]>>4) & 1;
902 pd[8*i + 2]= (pd[i]>>5) & 1;
903 pd[8*i + 1]= (pd[i]>>6) & 1;
904 pd[8*i + 0]= pd[i]>>7;
911 for (j = 0; j < s->
height; j++) {
914 if ((s->
width&3) >= 3) pd[4*i + 2]= (pd[i] >> 2) & 3;
915 if ((s->
width&3) >= 2) pd[4*i + 1]= (pd[i] >> 4) & 3;
916 if ((s->
width&3) >= 1) pd[4*i + 0]= pd[i] >> 6;
917 for (i--; i >= 0; i--) {
918 pd[4*i + 3]= pd[i] & 3;
919 pd[4*i + 2]= (pd[i]>>2) & 3;
920 pd[4*i + 1]= (pd[i]>>4) & 3;
921 pd[4*i + 0]= pd[i]>>6;
924 if ((s->
width&3) >= 3) pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
925 if ((s->
width&3) >= 2) pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
926 if ((s->
width&3) >= 1) pd[4*i + 0]= ( pd[i]>>6 )*0x55;
927 for (i--; i >= 0; i--) {
928 pd[4*i + 3]= ( pd[i] & 3)*0x55;
929 pd[4*i + 2]= ((pd[i]>>2) & 3)*0x55;
930 pd[4*i + 1]= ((pd[i]>>4) & 3)*0x55;
931 pd[4*i + 0]= ( pd[i]>>6 )*0x55;
939 for (j = 0; j < s->
height; j++) {
942 if (s->
width&1) pd[2*i+0]= pd[i]>>4;
943 for (i--; i >= 0; i--) {
944 pd[2*i + 1] = pd[i] & 15;
945 pd[2*i + 0] = pd[i] >> 4;
948 if (s->
width & 1) pd[2*i + 0]= (pd[i] >> 4) * 0x11;
949 for (i--; i >= 0; i--) {
950 pd[2*i + 1] = (pd[i] & 15) * 0x11;
951 pd[2*i + 0] = (pd[i] >> 4) * 0x11;
962 uint32_t sequence_number;
984 sequence_number = bytestream2_get_be32(&s->
gb);
985 cur_w = bytestream2_get_be32(&s->
gb);
986 cur_h = bytestream2_get_be32(&s->
gb);
987 x_offset = bytestream2_get_be32(&s->
gb);
988 y_offset = bytestream2_get_be32(&s->
gb);
990 dispose_op = bytestream2_get_byte(&s->
gb);
991 blend_op = bytestream2_get_byte(&s->
gb);
994 if (sequence_number == 0 &&
995 (cur_w != s->
width ||
999 cur_w <= 0 || cur_h <= 0 ||
1000 x_offset < 0 || y_offset < 0 ||
1001 cur_w > s->
width - x_offset|| cur_h > s->
height - y_offset)
1046 for (j = 0; j < s->
height; j++) {
1047 for (i = 0; i < ls; i++)
1048 pd[i] += pd_last[i];
1056 #define FAST_DIV255(x) ((((x) + 128) * 257) >> 16) 1098 memcpy(buffer + row_start, p->
data[0] + row_start, s->
bpp * s->
cur_w);
1106 uint8_t foreground_alpha, background_alpha, output_alpha;
1115 foreground_alpha = foreground[3];
1116 background_alpha = background[3];
1120 foreground_alpha = foreground[1];
1121 background_alpha = background[1];
1125 foreground_alpha = s->
palette[foreground[0]] >> 24;
1126 background_alpha = s->
palette[background[0]] >> 24;
1130 if (foreground_alpha == 0)
1133 if (foreground_alpha == 255) {
1134 memcpy(background, foreground, s->
bpp);
1141 background[0] = foreground[0];
1145 output_alpha = foreground_alpha +
FAST_DIV255((255 - foreground_alpha) * background_alpha);
1149 for (b = 0; b < s->
bpp - 1; ++
b) {
1150 if (output_alpha == 0) {
1152 }
else if (background_alpha == 255) {
1153 output[
b] =
FAST_DIV255(foreground_alpha * foreground[b] + (255 - foreground_alpha) * background[b]);
1155 output[
b] = (255 * foreground_alpha * foreground[
b] + (255 - foreground_alpha) * background_alpha * background[b]) / (255 * output_alpha);
1158 output[
b] = output_alpha;
1159 memcpy(background, output, s->
bpp);
1176 int decode_next_dat = 0;
1202 length = bytestream2_get_be32(&s->
gb);
1208 tag = bytestream2_get_le32(&s->
gb);
1216 case MKTAG(
'I',
'H',
'D',
'R'):
1217 case MKTAG(
'p',
'H',
'Y',
's'):
1218 case MKTAG(
't',
'E',
'X',
't'):
1219 case MKTAG(
'I',
'D',
'A',
'T'):
1220 case MKTAG(
't',
'R',
'N',
'S'):
1229 case MKTAG(
'I',
'H',
'D',
'R'):
1233 case MKTAG(
'p',
'H',
'Y',
's'):
1237 case MKTAG(
'f',
'c',
'T',
'L'):
1242 decode_next_dat = 1;
1244 case MKTAG(
'f',
'd',
'A',
'T'):
1247 if (!decode_next_dat || length < 4) {
1251 bytestream2_get_be32(&s->
gb);
1254 case MKTAG(
'I',
'D',
'A',
'T'):
1260 case MKTAG(
'P',
'L',
'T',
'E'):
1264 case MKTAG(
't',
'R',
'N',
'S'):
1268 case MKTAG(
't',
'E',
'X',
't'):
1273 case MKTAG(
'z',
'T',
'X',
't'):
1278 case MKTAG(
's',
'T',
'E',
'R'): {
1279 int mode = bytestream2_get_byte(&s->
gb);
1284 if (mode == 0 || mode == 1) {
1289 "Unknown value in sTER chunk (%d)\n", mode);
1294 case MKTAG(
'i',
'C',
'C',
'P'): {
1299 case MKTAG(
'I',
'E',
'N',
'D'):
1327 size_t byte_depth = s->
bit_depth > 8 ? 2 : 1;
1328 size_t raw_bpp = s->
bpp - byte_depth;
1333 for (y = 0; y < s->
height; ++
y) {
1337 for (x = s->
width; x > 0; --x) {
1339 memmove(pixel, &row[raw_bpp * (x - 1)], raw_bpp);
1342 memset(&pixel[raw_bpp], 0, byte_depth);
1344 memset(&pixel[raw_bpp], 0xff, byte_depth);
1379 #if CONFIG_PNG_DECODER 1381 void *
data,
int *got_frame,
1386 int buf_size = avpkt->
size;
1398 sig = bytestream2_get_be64(&s->
gb);
1413 ret = inflateInit(&s->
zstream);
1441 #if CONFIG_APNG_DECODER 1443 void *
data,
int *got_frame,
1468 if ((ret = inflateInit(&s->
zstream)) != Z_OK) {
1592 #if CONFIG_APNG_DECODER 1601 .
decode = decode_frame_apng,
1609 #if CONFIG_PNG_DECODER 1618 .
decode = decode_frame_png,
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
static int decode_idat_chunk(AVCodecContext *avctx, PNGDecContext *s, uint32_t length, AVFrame *p)
static int decode_fctl_chunk(AVCodecContext *avctx, PNGDecContext *s, uint32_t length)
#define PNG_FILTER_VALUE_AVG
static void png_handle_row(PNGDecContext *s)
ThreadFrame previous_picture
int av_image_get_linesize(enum AVPixelFormat pix_fmt, int width, int plane)
Compute the size of an image line with format pix_fmt and width width for the plane plane...
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
This structure describes decoded (raw) audio or video data.
unsigned int tmp_row_size
8 bits gray, 8 bits alpha
#define AV_LOG_WARNING
Something somehow does not look correct.
static int init_thread_copy(AVCodecContext *avctx)
packed RGB 8:8:8, 24bpp, RGBRGB...
int ff_set_dimensions(AVCodecContext *s, int width, int height)
Check that the provided frame dimensions are valid and set them on the codec context.
static av_cold int init(AVCodecContext *avctx)
#define avpriv_request_sample(...)
enum AVColorRange color_range
MPEG vs JPEG YUV range.
static int decode_text_chunk(PNGDecContext *s, uint32_t length, int compressed, AVDictionary **dict)
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
static av_always_inline void bytestream2_init(GetByteContext *g, const uint8_t *buf, int buf_size)
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...
enum PNGImageState pic_state
Views are next to each other.
#define PNG_COLOR_TYPE_RGB
void(* add_bytes_l2)(uint8_t *dst, uint8_t *src1, uint8_t *src2, int w)
void ff_thread_await_progress(ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
#define PNG_COLOR_TYPE_GRAY_ALPHA
static void decode(AVCodecContext *dec_ctx, AVPacket *pkt, AVFrame *frame, FILE *outfile)
#define PNG_COLOR_TYPE_PALETTE
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
void ff_add_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp)
#define AV_DICT_DONT_STRDUP_KEY
Take ownership of a key that's been allocated with av_malloc() or another memory allocation function...
#define PNG_FILTER_VALUE_PAETH
enum AVDiscard skip_frame
Skip decoding for selected frames.
#define av_assert0(cond)
assert() equivalent, that is always enabled.
#define FF_CODEC_CAP_INIT_THREADSAFE
The codec does not modify any global variables in the init function, allowing to call the init functi...
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
#define PNG_COLOR_TYPE_RGB_ALPHA
8 bits with AV_PIX_FMT_RGB32 palette
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
#define FF_DEBUG_PICT_INFO
static av_cold int end(AVCodecContext *avctx)
Multithreading support functions.
packed RGBA 16:16:16:16, 64bpp, 16R, 16G, 16B, 16A, the 2-byte value for each R/G/B/A component is st...
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
static int decode_phys_chunk(AVCodecContext *avctx, PNGDecContext *s)
Structure to hold side data for an AVFrame.
static void inflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord)
int ff_thread_ref_frame(ThreadFrame *dst, ThreadFrame *src)
AVDictionary * metadata
metadata.
static int decode_iccp_chunk(PNGDecContext *s, int length, AVFrame *f)
int interlaced_frame
The content of the picture is interlaced.
unsigned int last_row_size
void ff_thread_finish_setup(AVCodecContext *avctx)
If the codec defines update_thread_context(), call this when they are ready for the next thread to st...
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
static int decode_plte_chunk(AVCodecContext *avctx, PNGDecContext *s, uint32_t length)
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
static const uint8_t png_pass_dsp_mask[NB_PASSES]
int flags
Additional information about the frame packing.
16 bits gray, 16 bits alpha (big-endian)
void ff_thread_release_buffer(AVCodecContext *avctx, ThreadFrame *f)
Wrapper around release_buffer() frame-for multithreaded codecs.
static int decode_frame_common(AVCodecContext *avctx, PNGDecContext *s, AVFrame *p, AVPacket *avpkt)
static const uint16_t mask[17]
int is_copy
Whether the parent AVCodecContext is a copy of the context which had init() called on it...
static av_always_inline void bytestream2_skip(GetByteContext *g, unsigned int size)
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
static void handle_p_frame_png(PNGDecContext *s, AVFrame *p)
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
#define CONFIG_APNG_DECODER
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
int ff_png_get_nb_channels(int color_type)
#define av_fourcc2str(fourcc)
static av_always_inline unsigned int bytestream2_get_bytes_left(GetByteContext *g)
simple assert() macros that are a bit more flexible than ISO C assert().
const char * name
Name of the codec implementation.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
int flags
A combination of AV_PKT_FLAG values.
#define ONLY_IF_THREADS_ENABLED(x)
Define a function with only the non-default version specified.
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
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.
#define PNG_FILTER_VALUE_SUB
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
#define PNG_COLOR_TYPE_GRAY
static void png_filter_row(PNGDSPContext *dsp, uint8_t *dst, int filter_type, uint8_t *src, uint8_t *last, int size, int bpp)
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
void av_bprint_get_buffer(AVBPrint *buf, unsigned size, unsigned char **mem, unsigned *actual_size)
Allocate bytes in the buffer for external use.
av_cold void ff_pngdsp_init(PNGDSPContext *dsp)
static int decode_zbuf(AVBPrint *bp, const uint8_t *data, const uint8_t *data_end)
static void error(const char *err)
the normal 2^n-1 "JPEG" YUV ranges
static int decode_ihdr_chunk(AVCodecContext *avctx, PNGDecContext *s, uint32_t length)
static uint8_t * iso88591_to_utf8(const uint8_t *in, size_t size_in)
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
static av_always_inline int bytestream2_tell(GetByteContext *g)
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
static av_cold int png_dec_init(AVCodecContext *avctx)
enum AVStereo3DType type
How views are packed within the video.
Libavcodec external API header.
enum PNGHeaderState hdr_state
static int skip_tag(AVIOContext *in, int32_t tag_name)
#define PNG_FILTER_VALUE_UP
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
#define PNG_FILTER_TYPE_LOCO
int ff_thread_get_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
main external API structure.
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
const uint8_t ff_png_pass_ymask[NB_PASSES]
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(const int16_t *) pi >> 8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(const int32_t *) pi >> 24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) #define SET_CONV_FUNC_GROUP(ofmt, ifmt) static void set_generic_function(AudioConvert *ac) { } void ff_audio_convert_free(AudioConvert **ac) { if(! *ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);} AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, int sample_rate, int apply_map) { AudioConvert *ac;int in_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) return NULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method !=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt) > 2) { ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc) { av_free(ac);return NULL;} return ac;} in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar) { ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar ? ac->channels :1;} else if(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;else ac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);return ac;} int ff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in) { int use_generic=1;int len=in->nb_samples;int p;if(ac->dc) { av_log(ac->avr, AV_LOG_TRACE, "%d samples - audio_convert: %s to %s (dithered)\", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));return ff_convert_dither(ac-> in
AVFrameSideData * av_frame_new_side_data(AVFrame *frame, enum AVFrameSideDataType type, int size)
Add a new side data to a frame.
#define FF_COMPLIANCE_NORMAL
Rational number (pair of numerator and denominator).
#define CONFIG_PNG_DECODER
uint8_t transparent_color_be[6]
int allocate_progress
Whether to allocate progress for frame threading.
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
static int handle_p_frame_apng(AVCodecContext *avctx, PNGDecContext *s, AVFrame *p)
#define YUV2RGB(NAME, TYPE)
static const uint8_t png_pass_mask[NB_PASSES]
Y , 1bpp, 0 is black, 1 is white, in each byte pixels are ordered from the msb to the lsb...
static av_cold int png_dec_end(AVCodecContext *avctx)
void(* add_paeth_prediction)(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp)
common internal api header.
static void handle_small_bpp(PNGDecContext *s, AVFrame *p)
#define FF_CODEC_CAP_SKIP_FRAME_FILL_PARAM
The decoder extracts and fills its parameters even if the frame is skipped due to the skip_frame sett...
#define PNG_FILTER_VALUE_NONE
static int decode_trns_chunk(AVCodecContext *avctx, PNGDecContext *s, uint32_t length)
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
void av_fast_padded_mallocz(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_padded_malloc except that buffer will always be 0-initialized after call...
static const uint8_t png_pass_dsp_ymask[NB_PASSES]
void ff_png_zfree(void *opaque, void *ptr)
static int png_decode_idat(PNGDecContext *s, int length)
#define FF_DEBUG_STARTCODE
struct AVCodecInternal * internal
Private context used for internal data.
int key_frame
1 -> keyframe, 0-> not
int ff_png_pass_row_size(int pass, int bits_per_pixel, int width)
#define av_malloc_array(a, b)
static void png_put_interlaced_row(uint8_t *dst, int width, int bits_per_pixel, int pass, int color_type, const uint8_t *src)
#define FFSWAP(type, a, b)
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
#define MKTAG(a, b, c, d)
void * ff_png_zalloc(void *opaque, unsigned int items, unsigned int size)
#define AVERROR_EXTERNAL
Generic error in an external library.
This structure stores compressed data.
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
mode
Use these values in ebur128_init (or'ed).
#define AV_CODEC_CAP_DR1
Codec uses get_buffer() for allocating buffers and supports custom allocators.
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
#define UNROLL_FILTER(op)