wav_writer.c File Reference

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

Go to the source code of this file.

Data Structures
struct	wav_riff_header_t
	WAV RIFF header (first 12 bytes of WAV file) More...
struct	wav_fmt_chunk_t
	WAV format chunk describing audio format parameters. More...
struct	wav_data_header_t
	WAV data chunk header preceding audio samples. 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 implementation for audio debugging.

Definition in file wav_writer.c.

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().