/*

* imageSpectrogram.c

*

* Convert an image (PNG or JPEG) into a WAV file spectrogram-like sound.

* Equivalent logic to imageSpectrogram.pl (Perl version).

*

* Build:

* gcc -o imageSpectrogram imageSpectrogram.c -lm -lpng -ljpeg

*

* Usage:

* ./imageSpectrogram input.png [output.wav]

*

*/

#include <stdio.h>

#include <stdlib.h>

#include <stdint.h>

#include <string.h>

#include <math.h>

#include <png.h>

#include <jpeglib.h>

#define SAMPLE_RATE 44100

#define BITS_PER_SAMPLE 16

#define NUM_CHANNELS 1

#define TWO_PI (2.0 * M_PI)

#define COLUMN_DURATION 0.2

// WAV header structure

typedef struct {

char riff[4];

uint32_t chunk_size;

char wave[4];

char fmt[4];

uint32_t subchunk1_size;

uint16_t audio_format;

uint16_t num_channels;

uint32_t sample_rate;

uint32_t byte_rate;

uint16_t block_align;

uint16_t bits_per_sample;

char data[4];

uint32_t data_size;

} WAVHeader;

// Forward declarations

int read_png(const char *filename, unsigned char **rgb, int *width, int *height);

int read_jpeg(const char *filename, unsigned char **rgb, int *width, int *height);

void write_wav_header(FILE *f, uint32_t data_size);

void finalize_wav_header(FILE *f, uint32_t total_samples);

void add_sine(FILE *f, double *freqs, double *amps, int count);

int ends_with(const char *s, const char *suffix);

int main(int argc, char **argv) {

if (argc < 2) {

fprintf(stderr, "Usage: %s input_image [output.wav]\n", argv[0]);

return 1;

}

const char *input = argv[1];

char output[256];

if (argc >= 3) {

strncpy(output, argv[2], sizeof(output));

} else {

snprintf(output, sizeof(output), "%s.wav", input);

}

unsigned char *rgb = NULL;

int width = 0, height = 0;

int ok = 0;

if (ends_with(input, ".png") || ends_with(input, ".PNG")) {

ok = read_png(input, &rgb, &width, &height);

} else if (ends_with(input, ".jpg") || ends_with(input, ".jpeg") || ends_with(input, ".JPG") || ends_with(input, ".JPEG")) {

ok = read_jpeg(input, &rgb, &width, &height);

} else {

fprintf(stderr, "Unsupported image format (PNG and JPEG only)\n");

return 1;

}

if (!ok) {

fprintf(stderr, "Failed to read image: %s\n", input);

return 1;

}

FILE *wav = fopen(output, "wb");

if (!wav) {

perror("fopen");

free(rgb);

return 1;

}

write_wav_header(wav, 0); // placeholder

int total_samples = 0;

for (int x = 0; x < width; x++) {

double freqs[2048];

double amps[2048];

int count = 0;

for (int y = 0; y < height; y++) {

int idx = (y * width + x) * 3;

double r = rgb[idx];

double g = rgb[idx + 1];

double b = rgb[idx + 2];

if (!(r > 10 || (g > 10 && b > 10)))

continue;

double c = 4.25 - 4.25 * (r + g + b) / (256.0 * 3.0);

double freq = floor(22000.0 - ((double)(y + 1) / (double)(height + 1)) * 22000.0);

freqs[count] = freq;

amps[count] = c;

count++;

}

add_sine(wav, freqs, amps, count);

total_samples += (int)(COLUMN_DURATION * SAMPLE_RATE);

fprintf(stderr, "\r%3d%%", (int)(100.0 * x / width));

}

fprintf(stderr, "\r100%%\n");

finalize_wav_header(wav, total_samples);

fclose(wav);

free(rgb);

printf("WAV file written: %s\n", output);

return 0;

}

// ---- Image loading (PNG) ----

int read_png(const char *filename, unsigned char **out, int *width, int *height) {

FILE *fp = fopen(filename, "rb");

if (!fp) return 0;

png_structp png = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);

if (!png) { fclose(fp); return 0; }

png_infop info = png_create_info_struct(png);

if (!info) { png_destroy_read_struct(&png, NULL, NULL); fclose(fp); return 0; }

if (setjmp(png_jmpbuf(png))) {

png_destroy_read_struct(&png, &info, NULL);

fclose(fp);

return 0;

}

png_init_io(png, fp);

png_read_info(png, info);

*width = png_get_image_width(png, info);

*height = png_get_image_height(png, info);

png_byte color_type = png_get_color_type(png, info);

png_byte bit_depth = png_get_bit_depth(png, info);

if (bit_depth == 16)

png_set_strip_16(png);

if (color_type == PNG_COLOR_TYPE_PALETTE)

png_set_palette_to_rgb(png);

if (color_type == PNG_COLOR_TYPE_GRAY && bit_depth < 8)

png_set_expand_gray_1_2_4_to_8(png);

if (png_get_valid(png, info, PNG_INFO_tRNS))

png_set_tRNS_to_alpha(png);

if (color_type == PNG_COLOR_TYPE_RGB_ALPHA || color_type == PNG_COLOR_TYPE_GRAY_ALPHA)

png_set_strip_alpha(png);

png_read_update_info(png, info);

int rowbytes = png_get_rowbytes(png, info);

unsigned char *image_data = malloc(rowbytes * (*height));

if (!image_data) { fclose(fp); png_destroy_read_struct(&png, &info, NULL); return 0; }

png_bytep *row_pointers = malloc(sizeof(png_bytep) * (*height));

for (int y = 0; y < *height; y++)

row_pointers[y] = image_data + y * rowbytes;

png_read_image(png, row_pointers);

png_destroy_read_struct(&png, &info, NULL);

fclose(fp);

free(row_pointers);

*out = image_data;

return 1;

}

// ---- Image loading (JPEG) ----

int read_jpeg(const char *filename, unsigned char **out, int *width, int *height) {

FILE *fp = fopen(filename, "rb");

if (!fp) return 0;

struct jpeg_decompress_struct cinfo;

struct jpeg_error_mgr jerr;

cinfo.err = jpeg_std_error(&jerr);

jpeg_create_decompress(&cinfo);

jpeg_stdio_src(&cinfo, fp);

jpeg_read_header(&cinfo, TRUE);

jpeg_start_decompress(&cinfo);

*width = cinfo.output_width;

*height = cinfo.output_height;

int channels = cinfo.output_components;

unsigned long data_size = (*width) * (*height) * 3;

unsigned char *data = malloc(data_size);

if (!data) { jpeg_destroy_decompress(&cinfo); fclose(fp); return 0; }

unsigned char *rowptr[1];

while (cinfo.output_scanline < cinfo.output_height) {

rowptr[0] = data + 3 * (*width) * cinfo.output_scanline;

jpeg_read_scanlines(&cinfo, rowptr, 1);

}

jpeg_finish_decompress(&cinfo);

jpeg_destroy_decompress(&cinfo);

fclose(fp);

*out = data;

return 1;

}

// ---- WAV handling ----

void write_wav_header(FILE *f, uint32_t data_size) {

WAVHeader header;

memcpy(header.riff, "RIFF", 4);

header.chunk_size = 36 + data_size;

memcpy(header.wave, "WAVE", 4);

memcpy(header.fmt, "fmt ", 4);

header.subchunk1_size = 16;

header.audio_format = 1;

header.num_channels = NUM_CHANNELS;

header.sample_rate = SAMPLE_RATE;

header.bits_per_sample = BITS_PER_SAMPLE;

header.byte_rate = SAMPLE_RATE * NUM_CHANNELS * BITS_PER_SAMPLE / 8;

header.block_align = NUM_CHANNELS * BITS_PER_SAMPLE / 8;

memcpy(header.data, "data", 4);

header.data_size = data_size;

fwrite(&header, sizeof(header), 1, f);

}

void finalize_wav_header(FILE *f, uint32_t total_samples) {

uint32_t data_size = total_samples * NUM_CHANNELS * (BITS_PER_SAMPLE / 8);

fseek(f, 4, SEEK_SET);

uint32_t chunk_size = 36 + data_size;

fwrite(&chunk_size, 4, 1, f);

fseek(f, 40, SEEK_SET);

fwrite(&data_size, 4, 1, f);

}

void add_sine(FILE *f, double *freqs, double *amps, int count) {

int samples = (int)(COLUMN_DURATION * SAMPLE_RATE);

for (int pos = 0; pos < samples; pos++) {

double t = (double)pos / SAMPLE_RATE;

double val = 0.0;

for (int i = 0; i < count; i++) {

val += sin(TWO_PI * freqs[i] * t) * 10.0 / pow(10.0, amps[i]);

}

if (count > 0) val /= count;

int16_t sample = (int16_t)(val * 32767.0);

fwrite(&sample, sizeof(int16_t), 1, f);

}

}

int ends_with(const char *s, const char *suffix) {

if (!s || !suffix) return 0;

size_t lenstr = strlen(s);

size_t lensuffix = strlen(suffix);

if (lensuffix > lenstr) return 0;

return strcasecmp(s + lenstr - lensuffix, suffix) == 0;

}