emote2ss

main.c (6026B)

---

 /**
  * Based on the libwebp example program "anim_dump"
  */
 
 #define _GNU_SOURCE
 
 #include <stdio.h>
 #include "webp/decode.h"
 #include "webp/encode.h"
 #include "webp/demux.h"
 #include <stdbool.h>
 #include <stdlib.h>
 #include <libgen.h>
 #include <string.h>
 #include <strings.h>
 #include <assert.h>
 
 #ifdef __OpenBSD__
 #include <sys/syslimits.h>
 #endif
 
 #ifdef __NetBSD__
 #include <sys/syslimits.h>
 #endif
 
 #ifdef __linux__
 #include <linux/limits.h>
 #endif
 
 #ifdef __APPLE__
 #include <limits.h>
 #endif
 
 #define NUM_CHANNELS 4
 
 static void print_webp_version() {
 	int dec_ver = WebPGetDecoderVersion();
 	int demux_ver = WebPGetDemuxVersion();
 	printf("---------------------------\n");
 	printf("webp decoder version: %d.%d.%d\n", (dec_ver>>16)&0xff, (dec_ver>>8)&0xff, dec_ver&0xff);
 	printf("webp demuxer version: %d.%d.%d\n", (demux_ver>>16)&0xff, (demux_ver>>8)&0xff, demux_ver&0xff);
 }
 
 typedef struct {
 	uint8_t *rgba;
 	int duration;
 	bool is_key;
 } DecodedFrame;
 
 typedef struct {
 	int width, height, bgcolor, loop_count;
 	DecodedFrame *frames;
 	uint32_t frame_count;
 	void *raw_mem;
 } AnimatedImage;
 
 void alloc_image(AnimatedImage *img, uint32_t frame_count) {
 	assert(frame_count > 0);
 	uint8_t *mem = NULL;
 	DecodedFrame *frames = NULL;
 	const uint64_t rgba_size = img->width * img->height * NUM_CHANNELS;
 	const uint64_t img_size = frame_count * rgba_size * sizeof(uint8_t);
 	const uint64_t frames_size = frame_count * sizeof(DecodedFrame);
 
 	assert(img_size == (size_t)img_size);
 	assert(frames_size == (size_t)frames_size);
 
 	printf("img mem: %" PRIu64 "\nframes mem: %" PRIu64 "\n", img_size, frames_size);
 
 	mem = malloc(img_size);
 	frames = malloc(frames_size);
 	assert(mem != NULL);
 	assert(frames != NULL);
 
 	for (uint32_t i=0; i<frame_count; ++i) {
 		frames[i].rgba = mem+i*rgba_size;
 		frames[i].duration = 0;
 		frames[i].is_key = false;
 	}
 	img->frame_count = frame_count;
 	img->frames = frames;
 	img->raw_mem = mem;
 }
 
 int read_file(const char *fname, const uint8_t **data, size_t *size) {
 	assert(data != NULL);
 	assert(size != NULL);
 
 	*data = NULL;
 	*size = 0;
 	FILE *infile = fopen(fname, "rb");
 	assert(infile != NULL);
 	fseek(infile, 0, SEEK_END);
 	size_t fsize = ftell(infile);
 	printf("%s: %zu bytes\n", fname, fsize);
 	fseek(infile, 0, SEEK_SET);
 
 	uint8_t *fdata = malloc(fsize+1);
 	assert(fdata != NULL);
 	fdata[fsize] = '\0';
 	int ok = (fread(fdata, fsize, 1, infile)==1);
 	fclose(infile);
 
 	if (!ok) {
 		fprintf(stderr, "cannot read file %s (%d)\n", fname, ok);
 		free(fdata);
 		return -1;
 	}
 	*data = fdata;
 	*size = fsize;
 	return 0;
 }
 
 int read_webp(const char *fname, AnimatedImage *anim) {
 	printf("read_webp(%s)\n", fname);
 
 	WebPData webp_data;
 	WebPDataInit(&webp_data);
 
 	if (read_file(fname, &webp_data.bytes, &webp_data.size) == -1) {
 		fprintf(stderr, "read_file error\n");
 		return -1;
 	}
 
 	if (!WebPGetInfo(webp_data.bytes, webp_data.size, NULL, NULL)) {
 		fprintf(stderr, "invalid webp\n");
 		WebPDataClear(&webp_data);
 		return -1;
 	}
 
 	WebPAnimDecoder *dec = WebPAnimDecoderNew(&webp_data, NULL);
 	assert(dec != NULL);
 
 	WebPAnimInfo anim_info;
 	if (!WebPAnimDecoderGetInfo(dec, &anim_info)) {
 		fprintf(stderr, "error decoding animation info\n");
 		// @todo cleanup
 		return -1;
 	}
 
 	anim->width = anim_info.canvas_width;
 	anim->height = anim_info.canvas_height;
 	anim->loop_count = anim_info.loop_count;
 	anim->bgcolor = anim_info.bgcolor;
 	alloc_image(anim, anim_info.frame_count);
 
 	uint32_t frame_index = 0;
 	int prev_ts = 0;
 	while (WebPAnimDecoderHasMoreFrames(dec)) {
 		DecodedFrame *frame;
 		uint8_t *curr_rgba, *frame_rgba;
 		int ts;
 		if (!WebPAnimDecoderGetNext(dec, &frame_rgba, &ts)) {
 			fprintf(stderr, "error decoding frame %d\n", frame_index);
 			return -1;
 		}
 		assert(frame_index < anim_info.frame_count);
 		frame = &anim->frames[frame_index];
 		curr_rgba = frame->rgba;
 		frame->duration = ts - prev_ts;
 		memcpy(curr_rgba, frame_rgba, anim->width * anim->height * NUM_CHANNELS);
 		// ... <- nani kore?
 		++frame_index;
 		prev_ts = ts;
 	}
 
 	WebPDataClear(&webp_data);
 	WebPAnimDecoderDelete(dec);
 	return 0;
 }
 
 void write_webp(const char *fname, AnimatedImage *img, int cols) {
 	int rows = (int)img->frame_count / cols;
 	if ((int)img->frame_count % cols > 0) {
 		++rows;
 	}
 	FILE *fp = fopen(fname, "wb");
 	assert(fp!=NULL);
 	uint8_t *out;
 	size_t frame_size = img->width * img->height * sizeof(uint32_t);
 	size_t line_size = img->width * sizeof(uint32_t);
 	size_t full_line = line_size * cols;
 	uint8_t *merged = calloc(rows * cols, frame_size);
 	assert(merged!=NULL);
 	uint8_t *merged_orig = merged;
 	for (int row = 0; row < rows; ++row) {
 		for (int y = 0; y < img->height; ++y) {
 			for (int col = 0; col < cols; ++col) {
 				uint32_t offset = row*cols+col;
 				if (offset < img->frame_count) {
 					memcpy(merged, img->frames[offset].rgba+y*line_size, line_size);
 				}
 				merged += line_size;
 			}
 		}
 	}
 	int stride = full_line;
 	printf("stride: %d\n", stride);
 	size_t encoded = WebPEncodeLosslessRGBA(merged_orig, img->width * cols, img->height * rows, stride, &out);
 	printf("size: %zu, encoded: %zu\n", img->width*img->height*sizeof(uint32_t), encoded);
 	assert(encoded!=0);
 	size_t written = fwrite(out, sizeof(uint8_t), encoded, fp);
 	assert(written==encoded);
 	WebPFree(out);
 	free(merged_orig);
 	fclose(fp);
 }
 
 int main(int argc, const char **argv) {
 	atexit(print_webp_version);
 
 	if (argc < 3) {
 		printf("Usage: %s anim_file.webp COLUMNS\n", argc>0?argv[0]:"emote2ss");
 		return 0;
 	}
 
 	AnimatedImage img = {0};
 	char out_name[PATH_MAX];
 	char *in_path = strndup(argv[1], PATH_MAX-1);
 	assert(in_path!=NULL);
 	int cols = atoi(argv[2]);
 	int r = read_webp(in_path, &img);
 	assert(r==0);
 	char *in_name = basename((char *)in_path);
 	char *in_dir = dirname((char *)in_path);
 	int n = snprintf(out_name, NAME_MAX, "atlas_%s", in_name);
 	assert(n>0);
 	printf("[path:%s][%s -> %s(%d)]\ndimensions: %dx%d\nframes: %d\n", in_dir, in_name, out_name, cols, img.width, img.height, img.frame_count);
 	write_webp(out_name, &img, cols);
 
 	return 0;
 }