wav_writer.h File Reference

Simple WAV file writer for audio debugging. More...

Go to the source code of this file.

Data Structures
struct	wav_writer_t
	WAV file writer context. More...

Functions
wav_writer_t *	wav_writer_open (const char *filepath, int sample_rate, int channels)
	Open WAV file for writing.
int	wav_writer_write (wav_writer_t *writer, const float *samples, int num_samples)
	Write audio samples to WAV file.
void	wav_writer_close (wav_writer_t *writer)
	Close WAV file and finalize header.
bool	wav_dump_enabled (void)
	Check if audio dumping is enabled via environment.

Detailed Description

Simple WAV file writer for audio debugging.

Provides utilities to dump audio buffers to WAV files for debugging. Enable with environment variable: ASCIICHAT_DUMP_AUDIO=1

Definition in file wav_writer.h.

Function Documentation

wav_dump_enabled()

bool wav_dump_enabled

(

void

)

Check if audio dumping is enabled via environment.

Returns

true if ASCIICHAT_DUMP_AUDIO=1

Definition at line 138 of file wav_writer.c.

                            {
  const char *env = SAFE_GETENV("ASCIICHAT_DUMP_AUDIO");
  return env && (strcmp(env, "1") == 0 || strcmp(env, "true") == 0);
}

References SAFE_GETENV.

Referenced by audio_analysis_init(), and audio_client_init().

wav_writer_close()

void wav_writer_close

(

wav_writer_t *

writer

)

Close WAV file and finalize header.

Parameters

writer

WAV writer context

Definition at line 112 of file wav_writer.c.

                                            {
  if (!writer) {
    return;
  }
 
  if (writer->file) {
    // Update file size and data size in header
    uint32_t data_size = (uint32_t)(writer->samples_written * sizeof(float));
    uint32_t file_size = data_size + 36; // 36 = header size without RIFF chunk
 
    // Seek to file size field (offset 4)
    fseek(writer->file, 4, SEEK_SET);
    fwrite(&file_size, sizeof(uint32_t), 1, writer->file);
 
    // Seek to data size field (offset 40)
    fseek(writer->file, 40, SEEK_SET);
    fwrite(&data_size, sizeof(uint32_t), 1, writer->file);
 
    // Flush all buffered data to ensure headers are written before closing
    fflush(writer->file);
    fclose(writer->file);
  }
 
  SAFE_FREE(writer);
}

References wav_writer_t::file, SAFE_FREE, and wav_writer_t::samples_written.

Referenced by audio_analysis_destroy(), audio_cleanup(), audio_client_init(), and client_audio_pipeline_destroy().

wav_writer_open()

wav_writer_t * wav_writer_open	(	const char *	filepath,
		int	sample_rate,
		int	channels
	)

Open WAV file for writing.

Parameters

filepath	Path to WAV file to create
sample_rate	Sample rate (e.g., 44100)
channels	Number of channels (1=mono, 2=stereo)

Returns

WAV writer context or NULL on error

Definition at line 48 of file wav_writer.c.

                                                                                   {
  if (!filepath || sample_rate <= 0 || channels <= 0 || channels > 2) {
    return NULL;
  }
 
  wav_writer_t *writer = SAFE_MALLOC(sizeof(wav_writer_t), wav_writer_t *);
  if (!writer) {
    return NULL;
  }
 
  writer->file = platform_fopen("file_stream", filepath, "wb");
  if (!writer->file) {
    SAFE_FREE(writer);
    return NULL;
  }
 
  writer->samples_written = 0;
  writer->sample_rate = sample_rate;
  writer->channels = channels;
 
  // Write WAV header (we'll update sizes when closing)
  wav_riff_header_t riff = {.riff = {'R', 'I', 'F', 'F'},
                            .file_size = 0, // Will update on close
                            .wave = {'W', 'A', 'V', 'E'}};
 
  wav_fmt_chunk_t fmt = {.fmt = {'f', 'm', 't', ' '},
                         .chunk_size = 16,
                         .audio_format = 3, // IEEE float
                         .num_channels = (uint16_t)channels,
                         .sample_rate = (uint32_t)sample_rate,
                         .byte_rate = (uint32_t)(sample_rate * channels * sizeof(float)),
                         .block_align = (uint16_t)(channels * sizeof(float)),
                         .bits_per_sample = 32};
 
  wav_data_header_t data = {
      .data = {'d', 'a', 't', 'a'},
      .data_size = 0 // Will update on close
  };
 
  fwrite(&riff, sizeof(riff), 1, writer->file);
  fwrite(&fmt, sizeof(fmt), 1, writer->file);
  fwrite(&data, sizeof(data), 1, writer->file);
 
  return writer;
}

References wav_writer_t::channels, wav_data_header_t::data, wav_writer_t::file, wav_fmt_chunk_t::fmt, platform_fopen(), wav_riff_header_t::riff, SAFE_FREE, SAFE_MALLOC, wav_writer_t::sample_rate, and wav_writer_t::samples_written.

Referenced by audio_analysis_init(), audio_client_init(), and client_audio_pipeline_create().

wav_writer_write()

int wav_writer_write	(	wav_writer_t *	writer,
		const float *	samples,
		int	num_samples
	)

Write audio samples to WAV file.

Parameters

writer	WAV writer context
samples	Float samples in range [-1.0, 1.0]
num_samples	Number of samples to write

Returns

0 on success, -1 on error

Definition at line 94 of file wav_writer.c.

                                                                                  {
  if (!writer || !writer->file || !samples || num_samples <= 0) {
    return -1;
  }
 
  size_t written = fwrite(samples, sizeof(float), num_samples, writer->file);
  if (written != (size_t)num_samples) {
    return -1;
  }
 
  writer->samples_written += num_samples;
 
  // Flush immediately to ensure data is written to disk (critical for real-time analysis)
  fflush(writer->file);
 
  return 0;
}

References wav_writer_t::file, and wav_writer_t::samples_written.

Referenced by audio_analysis_track_received_sample(), audio_analysis_track_sent_sample(), audio_process_received_samples(), and client_audio_pipeline_process_duplex().