imageSpectrogram.c

/*
 * 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;
}