recording.h File Reference

Go to the source code of this file.

Typedefs
typedef struct audio_recording	audio_recording_t

Enumerations
enum	audio_recording_source_t { AUDIO_RECORDING_MIC , AUDIO_RECORDING_MEDIA , AUDIO_RECORDING_REMOTE , AUDIO_RECORDING_SOURCE_COUNT }

Functions
asciichat_error_t	audio_recording_create (audio_recording_t **out)
void	audio_recording_destroy (audio_recording_t *recording)
void	audio_recording_start (audio_recording_t *recording, uint64_t epoch_ns)
void	audio_recording_submit (audio_recording_source_t source, const float *samples, size_t count, uint64_t start_ns)
void	audio_recording_read (audio_recording_t *recording, float *samples, size_t count)

Typedef Documentation

audio_recording_t

typedef struct audio_recording audio_recording_t

Definition at line 8 of file recording.h.

Enumeration Type Documentation

audio_recording_source_t

enum audio_recording_source_t

Enumerator
AUDIO_RECORDING_MIC
AUDIO_RECORDING_MEDIA
AUDIO_RECORDING_REMOTE
AUDIO_RECORDING_SOURCE_COUNT

Definition at line 9 of file recording.h.

             {
  AUDIO_RECORDING_MIC,
  AUDIO_RECORDING_MEDIA,
  AUDIO_RECORDING_REMOTE,
  AUDIO_RECORDING_SOURCE_COUNT
} audio_recording_source_t;

Function Documentation

audio_recording_create()

asciichat_error_t audio_recording_create

(

audio_recording_t **

out

)

Definition at line 22 of file recording.c.

                                                                  {
  if (!out)
    return SET_ERRNO(ERROR_INVALID_PARAM, "Missing recording output");
  *out = NULL;
  static_mutex_lock(&recording_mutex);
  if (active_recording) {
    static_mutex_unlock(&recording_mutex);
    return SET_ERRNO(ERROR_INVALID_STATE, "A session recording is already active");
  }
  audio_recording_t *recording = SAFE_CALLOC(1, sizeof(*recording), audio_recording_t *);
  recording->mix = SAFE_CALLOC(RECORDING_CAPACITY, sizeof(float), float *);
  active_recording = recording;
  *out = recording;
  static_mutex_unlock(&recording_mutex);
  return ASCIICHAT_OK;
}

References ASCIICHAT_OK, ERROR_INVALID_PARAM, ERROR_INVALID_STATE, audio_recording::mix, RECORDING_CAPACITY, SAFE_CALLOC, and SET_ERRNO.

Referenced by render_file_create().

audio_recording_destroy()

void audio_recording_destroy

(

audio_recording_t *

recording

)

Definition at line 39 of file recording.c.

                                                           {
  if (!recording)
    return;
  static_mutex_lock(&recording_mutex);
  if (active_recording == recording)
    active_recording = NULL;
  SAFE_FREE(recording->mix);
  SAFE_FREE(recording);
  static_mutex_unlock(&recording_mutex);
}

References audio_recording::mix, and SAFE_FREE.

Referenced by render_file_destroy().

audio_recording_read()

void audio_recording_read	(	audio_recording_t *	recording,
		float *	samples,
		size_t	count
	)

Definition at line 87 of file recording.c.

                                                                                      {
  if (!recording || !samples)
    return;
  static_mutex_lock(&recording_mutex);
  for (size_t i = 0; i < count; i++) {
    size_t slot = recording->read_position++ % RECORDING_CAPACITY;
    float sample = recording->mix[slot];
    samples[i] = fmaxf(-1.0f, fminf(1.0f, sample));
    recording->mix[slot] = 0;
  }
  static_mutex_unlock(&recording_mutex);
}

References audio_recording::mix, audio_recording::read_position, and RECORDING_CAPACITY.

Referenced by render_file_destroy(), and render_file_write_frame().

audio_recording_start()

void audio_recording_start	(	audio_recording_t *	recording,
		uint64_t	epoch_ns
	)

Definition at line 50 of file recording.c.

                                                                            {
  if (!recording)
    return;
  static_mutex_lock(&recording_mutex);
  if (!recording->started) {
    recording->epoch_ns = epoch_ns;
    recording->started = true;
  }
  static_mutex_unlock(&recording_mutex);
}

References audio_recording::epoch_ns, and audio_recording::started.

Referenced by render_file_write_frame().

audio_recording_submit()

void audio_recording_submit	(	audio_recording_source_t	source,
		const float *	samples,
		size_t	count,
		uint64_t	start_ns
	)

Definition at line 61 of file recording.c.

                                                                                                                    {
  if (!samples || source < 0 || source >= AUDIO_RECORDING_SOURCE_COUNT)
    return;
  static_mutex_lock(&recording_mutex);
  audio_recording_t *recording = active_recording;
  if (!recording || !recording->started) {
    static_mutex_unlock(&recording_mutex);
    return;
  }
  uint64_t delta = start_ns > recording->epoch_ns ? start_ns - recording->epoch_ns : 0;
  uint64_t position = delta / 1000000000ULL * RECORDING_RATE + delta % 1000000000ULL * RECORDING_RATE / 1000000000ULL;
  /* Smooth callback jitter while preserving gaps longer than 100 ms. */
  if (recording->source_started[source] && position < recording->source_position[source] + RECORDING_RATE / 10)
    position = recording->source_position[source];
  if (position < recording->read_position)
    position = recording->read_position;
  recording->source_started[source] = true;
  recording->source_position[source] = position + count;
  for (size_t i = 0; i < count; i++, position++) {
    if (position >= recording->read_position && position - recording->read_position < RECORDING_CAPACITY &&
        isfinite(samples[i]))
      recording->mix[position % RECORDING_CAPACITY] += samples[i];
  }
  static_mutex_unlock(&recording_mutex);
}

References AUDIO_RECORDING_SOURCE_COUNT, audio_recording::epoch_ns, audio_recording::mix, audio_recording::read_position, RECORDING_CAPACITY, RECORDING_RATE, audio_recording::source_position, audio_recording::source_started, and audio_recording::started.

Referenced by audio_write_samples().