38 #define IOBUF_SIZE 4096
83 int bits_per_pixel,
int pass,
86 int x,
mask, dst_x, j,
b, bpp;
89 static const int masks[] = {0x80, 0x08, 0x88, 0x22, 0xaa, 0x55, 0xff};
92 switch (bits_per_pixel) {
94 memset(dst, 0, row_size);
96 for (x = 0; x <
width; x++) {
98 if ((
mask << j) & 0x80) {
99 b = (
src[x >> 3] >> (7 - j)) & 1;
100 dst[dst_x >> 3] |=
b << (7 - (dst_x & 7));
106 bpp = bits_per_pixel >> 3;
109 for (x = 0; x <
width; x++) {
111 if ((
mask << j) & 0x80) {
125 for (
i = 0;
i <
w;
i++) {
126 int a,
b,
c, p, pa, pb, pc;
139 if (pa <= pb && pa <= pc)
155 memcpy(dst,
src, bpp);
159 for (x = 0; x < unaligned_w; x++)
160 *dst++ = *
src1++ - *src2++;
162 c->llvidencdsp.diff_bytes(dst,
src1, src2,
size);
170 switch (filter_type) {
178 c->llvidencdsp.diff_bytes(dst,
src, top,
size);
181 for (
i = 0;
i < bpp;
i++)
182 dst[
i] =
src[
i] - (top[
i] >> 1);
184 dst[
i] =
src[
i] - ((
src[
i - bpp] + top[
i]) >> 1);
187 for (
i = 0;
i < bpp;
i++)
197 int pred =
s->filter_type;
203 int cost, bcost = INT_MAX;
210 cost +=
abs((int8_t) buf1[
i]);
225 const uint8_t *buf,
int length)
231 bytestream_put_be32(
f, length);
233 crc =
av_crc(crc_table, crc, tagbuf, 4);
236 crc =
av_crc(crc_table, crc, buf, length);
237 memcpy(*
f, buf, length);
240 bytestream_put_be32(
f, ~crc);
244 const uint8_t *buf,
int length)
255 bytestream_put_be32(&
s->bytestream, length + 4);
257 bytestream_put_be32(&
s->bytestream,
MKBETAG(
'f',
'd',
'A',
'T'));
258 bytestream_put_be32(&
s->bytestream,
s->sequence_number);
259 crc =
av_crc(crc_table, crc,
s->bytestream - 8, 8);
261 crc =
av_crc(crc_table, crc, buf, length);
262 memcpy(
s->bytestream, buf, length);
263 s->bytestream += length;
265 bytestream_put_be32(&
s->bytestream, ~crc);
267 ++
s->sequence_number;
276 s->zstream.avail_in =
size;
277 s->zstream.next_in =
data;
278 while (
s->zstream.avail_in > 0) {
279 ret =
deflate(&
s->zstream, Z_NO_FLUSH);
282 if (
s->zstream.avail_out == 0) {
283 if (
s->bytestream_end -
s->bytestream >
IOBUF_SIZE + 100)
286 s->zstream.next_out =
s->buf;
292 #define AV_WB32_PNG(buf, n) AV_WB32(buf, lrint((n) * 100000))
295 double rx, ry, gx, gy, bx, by, wx = 0.3127, wy = 0.3290;
298 rx = 0.640; ry = 0.330;
299 gx = 0.300; gy = 0.600;
300 bx = 0.150; by = 0.060;
303 rx = 0.670; ry = 0.330;
304 gx = 0.210; gy = 0.710;
305 bx = 0.140; by = 0.080;
306 wx = 0.310; wy = 0.316;
309 rx = 0.640; ry = 0.330;
310 gx = 0.290; gy = 0.600;
311 bx = 0.150; by = 0.060;
315 rx = 0.630; ry = 0.340;
316 gx = 0.310; gy = 0.595;
317 bx = 0.155; by = 0.070;
320 rx = 0.708; ry = 0.292;
321 gx = 0.170; gy = 0.797;
322 bx = 0.131; by = 0.046;
353 s->buf[8] =
s->bit_depth;
354 s->buf[9] =
s->color_type;
357 s->buf[12] =
s->is_progressive;
376 switch (stereo3d->
type) {
384 av_log(avctx,
AV_LOG_WARNING,
"Only side-by-side stereo3d flag can be defined within sTER chunk\n");
408 palette = (uint32_t *)pict->
data[1];
410 alpha_ptr =
s->buf + 256 * 3;
412 for (
i = 0;
i < 256;
i++) {
417 *alpha_ptr++ =
alpha;
418 bytestream_put_be24(&ptr, v);
421 MKTAG(
'P',
'L',
'T',
'E'),
s->buf, 256 * 3);
424 MKTAG(
't',
'R',
'N',
'S'),
s->buf + 256 * 3, 256);
436 int row_size, pass_row_size;
437 uint8_t *ptr, *top, *crow_buf, *crow;
442 row_size = (pict->
width *
s->bits_per_pixel + 7) >> 3;
450 crow_buf = crow_base + 15;
451 if (
s->is_progressive) {
452 progressive_buf =
av_malloc(row_size + 1);
454 if (!progressive_buf || !top_buf) {
462 s->zstream.next_out =
s->buf;
463 if (
s->is_progressive) {
470 if (pass_row_size > 0) {
472 for (y = 0; y < pict->
height; y++)
477 s->bits_per_pixel,
pass,
480 top, pass_row_size,
s->bits_per_pixel >> 3);
482 top = progressive_buf;
488 for (y = 0; y < pict->
height; y++) {
491 row_size,
s->bits_per_pixel >> 3);
498 ret =
deflate(&
s->zstream, Z_FINISH);
499 if (ret == Z_OK || ret == Z_STREAM_END) {
501 if (
len > 0 &&
s->bytestream_end -
s->bytestream >
len + 100) {
505 s->zstream.next_out =
s->buf;
506 if (ret == Z_STREAM_END)
520 deflateReset(&
s->zstream);
525 const AVFrame *pict,
int *got_packet)
530 size_t max_packet_size;
532 enc_row_size = deflateBound(&
s->zstream, (avctx->
width *
s->bits_per_pixel + 7) >> 3);
539 if (max_packet_size > INT_MAX)
545 s->bytestream_start =
562 pkt->
size =
s->bytestream -
s->bytestream_start;
576 unsigned int leftmost_x = input->
width;
577 unsigned int rightmost_x = 0;
578 unsigned int topmost_y = input->
height;
579 unsigned int bottommost_y = 0;
582 ptrdiff_t input_linesize = input->
linesize[0];
583 ptrdiff_t output_linesize = output->
linesize[0];
586 for (y = 0; y < input->
height; ++y) {
587 for (x = 0; x < input->
width; ++x) {
593 if (x >= rightmost_x)
597 if (y >= bottommost_y)
598 bottommost_y = y + 1;
605 if (leftmost_x == input->
width && rightmost_x == 0) {
608 leftmost_x = topmost_y = 0;
609 rightmost_x = bottommost_y = 1;
615 for (y = topmost_y; y < bottommost_y; ++y) {
617 input->
data[0] + input_linesize * y + bpp * leftmost_x,
618 bpp * (rightmost_x - leftmost_x));
622 size_t transparent_palette_index;
633 palette = (uint32_t*)input->
data[1];
634 for (transparent_palette_index = 0; transparent_palette_index < 256; ++transparent_palette_index)
635 if (palette[transparent_palette_index] >> 24 == 0)
644 for (y = topmost_y; y < bottommost_y; ++y) {
645 uint8_t *foreground = input->
data[0] + input_linesize * y + bpp * leftmost_x;
646 uint8_t *background = output->
data[0] + output_linesize * y + bpp * leftmost_x;
648 for (x = leftmost_x; x < rightmost_x; ++x, foreground += bpp, background += bpp,
output_data += bpp) {
649 if (!memcmp(foreground, background, bpp)) {
651 if (transparent_palette_index == 256) {
669 if (((uint16_t*)foreground)[3] == 0xffff ||
670 ((uint16_t*)background)[3] == 0)
675 if (((uint16_t*)foreground)[1] == 0xffff ||
676 ((uint16_t*)background)[1] == 0)
681 if (foreground[3] == 0xff || background[3] == 0)
686 if (foreground[1] == 0xff || background[1] == 0)
691 if (palette[*foreground] >> 24 == 0xff ||
692 palette[*background] >> 24 == 0)
702 output->
width = rightmost_x - leftmost_x;
703 output->
height = bottommost_y - topmost_y;
719 uint8_t bpp = (
s->bits_per_pixel + 7) >> 3;
720 uint8_t *original_bytestream, *original_bytestream_end;
721 uint8_t *temp_bytestream = 0, *temp_bytestream_end;
722 uint32_t best_sequence_number;
724 size_t best_bytestream_size = SIZE_MAX;
747 original_bytestream =
s->bytestream;
748 original_bytestream_end =
s->bytestream_end;
750 temp_bytestream =
av_malloc(original_bytestream_end - original_bytestream);
751 if (!temp_bytestream) {
755 temp_bytestream_end = temp_bytestream + (original_bytestream_end - original_bytestream);
766 uint32_t original_sequence_number =
s->sequence_number, sequence_number;
767 uint8_t *bytestream_start =
s->bytestream;
768 size_t bytestream_size;
780 size_t row_start = diffFrame->
linesize[0] * y + bpp * last_fctl_chunk.
x_offset;
781 memset(diffFrame->
data[0] + row_start, 0, bpp * last_fctl_chunk.
width);
801 sequence_number =
s->sequence_number;
802 s->sequence_number = original_sequence_number;
803 bytestream_size =
s->bytestream - bytestream_start;
804 s->bytestream = bytestream_start;
808 if (bytestream_size < best_bytestream_size) {
809 *best_fctl_chunk = fctl_chunk;
810 *best_last_fctl_chunk = last_fctl_chunk;
812 best_sequence_number = sequence_number;
813 best_bytestream =
s->bytestream;
814 best_bytestream_size = bytestream_size;
816 if (best_bytestream == original_bytestream) {
817 s->bytestream = temp_bytestream;
818 s->bytestream_end = temp_bytestream_end;
820 s->bytestream = original_bytestream;
821 s->bytestream_end = original_bytestream_end;
827 s->sequence_number = best_sequence_number;
828 s->bytestream = original_bytestream + best_bytestream_size;
829 s->bytestream_end = original_bytestream_end;
830 if (best_bytestream != original_bytestream)
831 memcpy(original_bytestream, best_bytestream, best_bytestream_size);
842 const AVFrame *pict,
int *got_packet)
847 size_t max_packet_size;
855 }
else if (
checksum !=
s->palette_checksum) {
857 "Input contains more than one unique palette. APNG does not support multiple palettes.\n");
862 enc_row_size = deflateBound(&
s->zstream, (avctx->
width *
s->bits_per_pixel + 7) >> 3);
869 if (max_packet_size > INT_MAX)
884 s->extra_data_size =
s->bytestream -
s->extra_data;
886 s->last_frame_packet =
av_malloc(max_packet_size);
887 if (!
s->last_frame_packet)
889 }
else if (
s->last_frame) {
894 memcpy(
pkt->
data,
s->last_frame_packet,
s->last_frame_packet_size);
895 pkt->
size =
s->last_frame_packet_size;
900 s->bytestream_start =
901 s->bytestream =
s->last_frame_packet;
902 s->bytestream_end =
s->bytestream + max_packet_size;
907 ++
s->sequence_number;
908 s->bytestream += 26 + 12;
923 if (!
s->extra_data_updated) {
927 memcpy(side_data,
s->extra_data,
s->extra_data_size);
928 s->extra_data_updated = 1;
931 AV_WB32(buf + 0,
s->last_frame_fctl.sequence_number);
932 AV_WB32(buf + 4,
s->last_frame_fctl.width);
933 AV_WB32(buf + 8,
s->last_frame_fctl.height);
934 AV_WB32(buf + 12,
s->last_frame_fctl.x_offset);
935 AV_WB32(buf + 16,
s->last_frame_fctl.y_offset);
936 AV_WB16(buf + 20,
s->last_frame_fctl.delay_num);
937 AV_WB16(buf + 22,
s->last_frame_fctl.delay_den);
938 buf[24] =
s->last_frame_fctl.dispose_op;
939 buf[25] =
s->last_frame_fctl.blend_op;
946 if (!
s->last_frame) {
951 if (!
s->prev_frame) {
956 s->prev_frame->format = pict->
format;
957 s->prev_frame->width = pict->
width;
958 s->prev_frame->height = pict->
height;
967 uint8_t bpp = (
s->bits_per_pixel + 7) >> 3;
968 for (y =
s->last_frame_fctl.y_offset; y < s->last_frame_fctl.y_offset +
s->last_frame_fctl.height; ++y) {
969 size_t row_start =
s->prev_frame->linesize[0] * y + bpp *
s->last_frame_fctl.x_offset;
970 memset(
s->prev_frame->data[0] + row_start, 0, bpp *
s->last_frame_fctl.width);
980 s->last_frame_fctl = fctl_chunk;
981 s->last_frame_packet_size =
s->bytestream -
s->bytestream_start;
992 int compression_level;
1011 #if FF_API_CODED_FRAME
1020 #if FF_API_PRIVATE_OPT
1032 if (
s->dpi &&
s->dpm) {
1035 }
else if (
s->dpi) {
1036 s->dpm =
s->dpi * 10000 / 254;
1088 s->zstream.opaque =
NULL;
1090 ? Z_DEFAULT_COMPRESSION
1092 if (deflateInit2(&
s->zstream, compression_level, Z_DEFLATED, 15, 8, Z_DEFAULT_STRATEGY) != Z_OK)
1102 deflateEnd(&
s->zstream);
1107 s->extra_data_size = 0;
1111 #define OFFSET(x) offsetof(PNGEncContext, x)
1112 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1115 {
"dpm",
"Set image resolution (in dots per meter)",
OFFSET(dpm),
AV_OPT_TYPE_INT, {.i64 = 0}, 0, 0x10000,
VE},
@ APNG_DISPOSE_OP_BACKGROUND
@ APNG_DISPOSE_OP_PREVIOUS
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.
#define FF_COMPRESSION_DEFAULT
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, buffer_size_t size)
static av_cold int init(AVCodecContext *avctx)
double avpriv_get_gamma_from_trc(enum AVColorTransferCharacteristic trc)
Determine a suitable 'gamma' value to match the supplied AVColorTransferCharacteristic.
#define FFSWAP(type, a, b)
#define MKTAG(a, b, c, d)
#define MKBETAG(a, b, c, d)
Public header for CRC hash function implementation.
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
#define AV_CODEC_CAP_FRAME_THREADS
Codec supports frame-level multithreading.
#define AV_INPUT_BUFFER_MIN_SIZE
minimum encoding buffer size Used to avoid some checks during header writing.
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
@ AV_PKT_DATA_NEW_EXTRADATA
The AV_PKT_DATA_NEW_EXTRADATA is used to notify the codec or the format that the extradata buffer was...
const AVCRC * av_crc_get_table(AVCRCId crc_id)
Get an initialized standard CRC table.
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length)
Calculate the CRC of a block.
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
int av_frame_copy(AVFrame *dst, const AVFrame *src)
Copy the frame data from src to dst.
@ AV_FRAME_DATA_STEREO3D
Stereoscopic 3d metadata.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
@ AV_PICTURE_TYPE_I
Intra.
#define LIBAVUTIL_VERSION_INT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
@ AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
@ AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
static const int16_t alpha[]
static int output_data(MLPDecodeContext *m, unsigned int substr, AVFrame *frame, int *got_frame_ptr)
Write the audio data into the output buffer.
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
#define FF_DISABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
static enum AVPixelFormat pix_fmts[]
Replacements for frequently missing libm functions.
av_cold void ff_llvidencdsp_init(LLVidEncDSPContext *c)
static const uint16_t mask[17]
static void input_data(MLPEncodeContext *ctx, void *samples)
Wrapper function for inputting data in two different bit-depths.
AVPixelFormat
Pixel format.
@ AV_PIX_FMT_GRAY16BE
Y , 16bpp, big-endian.
@ AV_PIX_FMT_RGB24
packed RGB 8:8:8, 24bpp, RGBRGB...
@ AV_PIX_FMT_YA16BE
16 bits gray, 16 bits alpha (big-endian)
@ 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_GRAY8A
alias for AV_PIX_FMT_YA8
@ AV_PIX_FMT_GRAY8
Y , 8bpp.
@ AV_PIX_FMT_RGB48BE
packed RGB 16:16:16, 48bpp, 16R, 16G, 16B, the 2-byte value for each R/G/B component is stored as big...
@ 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_RGBA
packed RGBA 8:8:8:8, 32bpp, RGBARGBA...
@ AV_PIX_FMT_PAL8
8 bits with AV_PIX_FMT_RGB32 palette
AVColorPrimaries
Chromaticity coordinates of the source primaries.
@ AVCOL_PRI_BT470BG
also ITU-R BT601-6 625 / ITU-R BT1358 625 / ITU-R BT1700 625 PAL & SECAM
@ AVCOL_PRI_BT709
also ITU-R BT1361 / IEC 61966-2-4 / SMPTE RP177 Annex B
@ AVCOL_PRI_SMPTE240M
functionally identical to above
@ AVCOL_PRI_SMPTE170M
also ITU-R BT601-6 525 / ITU-R BT1358 525 / ITU-R BT1700 NTSC
@ AVCOL_PRI_BT2020
ITU-R BT2020.
@ AVCOL_PRI_BT470M
also FCC Title 47 Code of Federal Regulations 73.682 (a)(20)
AVColorTransferCharacteristic
Color Transfer Characteristic.
@ AVCOL_TRC_IEC61966_2_1
IEC 61966-2-1 (sRGB or sYCC)
const uint8_t ff_png_pass_ymask[NB_PASSES]
int ff_png_pass_row_size(int pass, int bits_per_pixel, int width)
int ff_png_get_nb_channels(int color_type)
void * ff_png_zalloc(void *opaque, unsigned int items, unsigned int size)
void ff_png_zfree(void *opaque, void *ptr)
#define PNG_COLOR_TYPE_RGB
#define PNG_FILTER_VALUE_MIXED
#define PNG_COLOR_TYPE_RGB_ALPHA
#define PNG_COLOR_TYPE_GRAY_ALPHA
#define PNG_FILTER_VALUE_AVG
#define PNG_FILTER_VALUE_UP
#define PNG_COLOR_TYPE_GRAY
#define PNG_COLOR_TYPE_PALETTE
#define PNG_FILTER_VALUE_PAETH
#define PNG_FILTER_VALUE_NONE
#define PNG_FILTER_VALUE_SUB
static void png_filter_row(PNGEncContext *c, uint8_t *dst, int filter_type, uint8_t *src, uint8_t *top, int size, int bpp)
static av_cold int png_enc_init(AVCodecContext *avctx)
static int apng_encode_frame(AVCodecContext *avctx, const AVFrame *pict, APNGFctlChunk *best_fctl_chunk, APNGFctlChunk *best_last_fctl_chunk)
static int encode_apng(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
static const AVClass apngenc_class
static void sub_left_prediction(PNGEncContext *c, uint8_t *dst, const uint8_t *src, int bpp, int size)
static uint8_t * png_choose_filter(PNGEncContext *s, uint8_t *dst, uint8_t *src, uint8_t *top, int size, int bpp)
static void png_write_chunk(uint8_t **f, uint32_t tag, const uint8_t *buf, int length)
static const AVOption options[]
static int encode_headers(AVCodecContext *avctx, const AVFrame *pict)
static int encode_png(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *pict, int *got_packet)
static int encode_frame(AVCodecContext *avctx, const AVFrame *pict)
static int apng_do_inverse_blend(AVFrame *output, const AVFrame *input, APNGFctlChunk *fctl_chunk, uint8_t bpp)
static int png_get_chrm(enum AVColorPrimaries prim, uint8_t *buf)
static const AVClass pngenc_class
static int png_get_gama(enum AVColorTransferCharacteristic trc, uint8_t *buf)
static int png_write_row(AVCodecContext *avctx, const uint8_t *data, int size)
static av_cold int png_enc_close(AVCodecContext *avctx)
static void sub_png_paeth_prediction(uint8_t *dst, uint8_t *src, uint8_t *top, int w, int bpp)
static void png_write_image_data(AVCodecContext *avctx, const uint8_t *buf, int length)
#define AV_WB32_PNG(buf, n)
static void png_get_interlaced_row(uint8_t *dst, int row_size, int bits_per_pixel, int pass, const uint8_t *src, int width)
static const float pred[4]
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.
int width
picture width / height.
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
int bits_per_coded_sample
bits per sample/pixel from the demuxer (needed for huffyuv).
attribute_deprecated AVFrame * coded_frame
the picture in the bitstream
int frame_number
Frame counter, set by libavcodec.
int flags
AV_CODEC_FLAG_*.
attribute_deprecated int prediction_method
const char * name
Name of the codec implementation.
Structure to hold side data for an AVFrame.
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
enum AVColorPrimaries color_primaries
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
enum AVColorTransferCharacteristic color_trc
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
enum AVPictureType pict_type
Picture type of the frame.
This structure stores compressed data.
int flags
A combination of AV_PKT_FLAG values.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Stereo 3D type: this structure describes how two videos are packed within a single video surface,...
enum AVStereo3DType type
How views are packed within the video.
int flags
Additional information about the frame packing.
uint32_t palette_checksum
uint8_t * last_frame_packet
int dpm
Physical pixel density, in dots per meter, if set.
size_t last_frame_packet_size
int dpi
Physical pixel density, in dots per inch, if set.
uint8_t * bytestream_start
APNGFctlChunk last_frame_fctl
LLVidEncDSPContext llvidencdsp
static volatile int checksum
static void deflate(uint8_t *dst, const uint8_t *p1, int width, int threshold, const uint8_t *coordinates[], int coord, int maxc)