mirror of
https://github.com/ddidderr/wuffs.git
synced 2026-11-17 16:32:11 +01:00
194 lines
6.0 KiB
C
194 lines
6.0 KiB
C
// Copyright 2026 The Wuffs Authors.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
|
|
// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
|
|
// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
|
|
// option. This file may not be copied, modified, or distributed
|
|
// except according to those terms.
|
|
//
|
|
// SPDX-License-Identifier: Apache-2.0 OR MIT
|
|
|
|
// ----------------
|
|
|
|
// This exercises snippet/uncompng.c to write a large APNG image to stdout.
|
|
//
|
|
// It is a C port of lib/uncompng's TestAnimationEncoderLarge.
|
|
//
|
|
// Run it from the Wuffs root directory, the one that contains the
|
|
// wuffs-root-directory.txt file, so that it can find and read the
|
|
// test/data/hibiscus.regular.bmp file.
|
|
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
|
|
#define UNCOMPNG_CONFIG__STATIC_FUNCTIONS
|
|
#define UNCOMPNG_IMPLEMENTATION
|
|
#include "../snippet/uncompng.c"
|
|
|
|
#define WUFFS_CONFIG__MODULES
|
|
#define WUFFS_CONFIG__MODULE__BASE
|
|
#define WUFFS_CONFIG__MODULE__BMP
|
|
#define WUFFS_CONFIG__STATIC_FUNCTIONS
|
|
#define WUFFS_IMPLEMENTATION
|
|
#include "../release/c/wuffs-unsupported-snapshot.c"
|
|
|
|
#define IMAGE_HEIGHT 442
|
|
#define IMAGE_WIDTH 312
|
|
#define NUM_FRAMES 5
|
|
#define NUM_PLAYS 0
|
|
#define SRC_BMP_SIZE 413850
|
|
|
|
static uint8_t g_src_bmp[SRC_BMP_SIZE];
|
|
static uint8_t g_src_pixels[IMAGE_WIDTH * IMAGE_HEIGHT * 4];
|
|
|
|
bool //
|
|
load_src_bmp() {
|
|
int fd = open("test/data/hibiscus.regular.bmp", O_RDONLY, 0);
|
|
if (fd == -1) {
|
|
fprintf(stderr, "FAIL: open: %s\n", strerror(errno));
|
|
return false;
|
|
}
|
|
|
|
for (ssize_t num_read = 0; num_read < SRC_BMP_SIZE;) {
|
|
ssize_t n = read(fd, g_src_bmp + num_read, sizeof(g_src_bmp) - num_read);
|
|
if (n > 0) {
|
|
num_read += n;
|
|
} else if (n == 0) {
|
|
break;
|
|
} else if (errno == EINTR) {
|
|
// No-op.
|
|
} else {
|
|
close(fd);
|
|
fprintf(stderr, "FAIL: read: %s\n", strerror(errno));
|
|
return false;
|
|
}
|
|
}
|
|
|
|
close(fd);
|
|
return true;
|
|
}
|
|
|
|
bool //
|
|
load_src_pixels() {
|
|
static wuffs_bmp__decoder dec;
|
|
|
|
wuffs_base__io_buffer src = wuffs_base__make_io_buffer(
|
|
wuffs_base__make_slice_u8(g_src_bmp, SRC_BMP_SIZE),
|
|
wuffs_base__make_io_buffer_meta(SRC_BMP_SIZE, 0, 0, true));
|
|
|
|
wuffs_base__status status = wuffs_bmp__decoder__initialize(
|
|
&dec, sizeof dec, WUFFS_VERSION, WUFFS_INITIALIZE__DEFAULT_OPTIONS);
|
|
if (!wuffs_base__status__is_ok(&status)) {
|
|
fprintf(stderr, "FAIL: initialize: %s\n",
|
|
wuffs_base__status__message(&status));
|
|
return false;
|
|
}
|
|
|
|
wuffs_base__image_config ic;
|
|
status = wuffs_bmp__decoder__decode_image_config(&dec, &ic, &src);
|
|
if (!wuffs_base__status__is_ok(&status)) {
|
|
fprintf(stderr, "FAIL: decode_image_config: %s\n",
|
|
wuffs_base__status__message(&status));
|
|
return false;
|
|
}
|
|
|
|
uint32_t w = wuffs_base__pixel_config__width(&ic.pixcfg);
|
|
uint32_t h = wuffs_base__pixel_config__height(&ic.pixcfg);
|
|
uint32_t pixfmt = wuffs_base__pixel_config__pixel_format(&ic.pixcfg).repr;
|
|
if ((w != IMAGE_WIDTH) || (h != IMAGE_HEIGHT) ||
|
|
(pixfmt != WUFFS_BASE__PIXEL_FORMAT__BGRX)) {
|
|
fprintf(stderr, "FAIL: decode_image_config: unexpected configuration\n");
|
|
return false;
|
|
}
|
|
|
|
if ((WUFFS_BASE__PIXEL_FORMAT__BGRX != UNCOMPNG__PIXEL_FORMAT__BGRX) ||
|
|
(WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL !=
|
|
UNCOMPNG__PIXEL_FORMAT__BGRA_NONPREMUL)) {
|
|
fprintf(stderr, "FAIL: wuffs and uncompng are incompatible\n");
|
|
return false;
|
|
}
|
|
|
|
wuffs_base__pixel_config__set(&ic.pixcfg,
|
|
WUFFS_BASE__PIXEL_FORMAT__BGRA_NONPREMUL,
|
|
WUFFS_BASE__PIXEL_SUBSAMPLING__NONE, w, h);
|
|
|
|
wuffs_base__pixel_buffer pb;
|
|
status = wuffs_base__pixel_buffer__set_from_slice(
|
|
&pb, &ic.pixcfg,
|
|
wuffs_base__make_slice_u8(&g_src_pixels[0], sizeof g_src_pixels));
|
|
if (!wuffs_base__status__is_ok(&status)) {
|
|
fprintf(stderr, "FAIL: set_from_slice: %s\n",
|
|
wuffs_base__status__message(&status));
|
|
return false;
|
|
}
|
|
|
|
status = wuffs_bmp__decoder__decode_frame(&dec, &pb, &src,
|
|
WUFFS_BASE__PIXEL_BLEND__SRC,
|
|
wuffs_base__empty_slice_u8(), NULL);
|
|
if (!wuffs_base__status__is_ok(&status)) {
|
|
fprintf(stderr, "FAIL: decode_frame: %s\n",
|
|
wuffs_base__status__message(&status));
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int //
|
|
my_write_func(void* context, const uint8_t* data_ptr, size_t data_len) {
|
|
static const int stdout_fd = 1;
|
|
return (write(stdout_fd, data_ptr, data_len) < 0) ? -errno : 0;
|
|
}
|
|
|
|
int //
|
|
main(int argc, char** argv) {
|
|
if (!load_src_bmp() || !load_src_pixels()) {
|
|
return 1;
|
|
}
|
|
|
|
// Change "if (0)" to "if (1)" to write a still (not animated) PNG.
|
|
if (0) {
|
|
const int frame = 0;
|
|
return uncompng__encode( //
|
|
&my_write_func, NULL, //
|
|
UNCOMPNG__PIXEL_FORMAT__BGRA_NONPREMUL, IMAGE_WIDTH, IMAGE_HEIGHT, //
|
|
&g_src_pixels[0], sizeof(g_src_pixels), IMAGE_WIDTH * 4);
|
|
}
|
|
|
|
static uint16_t delay_millis[NUM_FRAMES] = {300, 500, 600, 400, 200};
|
|
|
|
int err0 = uncompng__encode_apng_header( //
|
|
&my_write_func, NULL, //
|
|
UNCOMPNG__PIXEL_FORMAT__BGRA_NONPREMUL, IMAGE_WIDTH, IMAGE_HEIGHT, //
|
|
NUM_FRAMES, NUM_PLAYS);
|
|
if (err0) {
|
|
return err0;
|
|
}
|
|
|
|
for (int frame = 0; frame < NUM_FRAMES; frame++) {
|
|
int err1 = uncompng__encode_apng_frame( //
|
|
&my_write_func, NULL, //
|
|
delay_millis[frame], 1000, //
|
|
&g_src_pixels[0], sizeof(g_src_pixels), IMAGE_WIDTH * 4);
|
|
if (err1) {
|
|
return err1;
|
|
}
|
|
|
|
// Over time, set the R, G, B, A channel values to 0x80.
|
|
//
|
|
// Use RGBA order, not BGRA, to match the output of lib/uncompng's
|
|
// TestAnimationEncoderLarge, in Go.
|
|
if (frame < 4) {
|
|
static size_t order[4] = {2, 1, 0, 3};
|
|
for (size_t i = order[frame]; i < sizeof(g_src_pixels); i += 4) {
|
|
g_src_pixels[i] = 0x80;
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|