summaryrefslogtreecommitdiff
path: root/servers
diff options
context:
space:
mode:
Diffstat (limited to 'servers')
-rw-r--r--servers/audio/audio_driver_dummy.cpp22
-rw-r--r--servers/audio/audio_driver_dummy.h5
-rw-r--r--servers/audio/audio_stream.cpp123
-rw-r--r--servers/audio/audio_stream.h60
-rw-r--r--servers/audio_server.cpp135
-rw-r--r--servers/audio_server.h145
-rw-r--r--servers/register_server_types.cpp1
7 files changed, 490 insertions, 1 deletions
diff --git a/servers/audio/audio_driver_dummy.cpp b/servers/audio/audio_driver_dummy.cpp
index be36c3b748..7074dbca3a 100644
--- a/servers/audio/audio_driver_dummy.cpp
+++ b/servers/audio/audio_driver_dummy.cpp
@@ -125,6 +125,28 @@ void AudioDriverDummy::finish() {
thread = NULL;
};
+bool AudioDriverDummy::capture_device_start(StringName p_name) {
+
+ return false;
+}
+
+bool AudioDriverDummy::capture_device_stop(StringName p_name) {
+
+ return false;
+}
+
+PoolStringArray AudioDriverDummy::capture_device_get_names() {
+
+ PoolStringArray names;
+
+ return names;
+}
+
+StringName AudioDriverDummy::capture_device_get_default_name() {
+
+ return "";
+}
+
AudioDriverDummy::AudioDriverDummy() {
mutex = NULL;
diff --git a/servers/audio/audio_driver_dummy.h b/servers/audio/audio_driver_dummy.h
index ba4f69edf4..48e8c731ea 100644
--- a/servers/audio/audio_driver_dummy.h
+++ b/servers/audio/audio_driver_dummy.h
@@ -68,6 +68,11 @@ public:
virtual void unlock();
virtual void finish();
+ virtual bool capture_device_start(StringName p_name);
+ virtual bool capture_device_stop(StringName p_name);
+ virtual PoolStringArray capture_device_get_names();
+ virtual StringName capture_device_get_default_name();
+
AudioDriverDummy();
~AudioDriverDummy();
};
diff --git a/servers/audio/audio_stream.cpp b/servers/audio/audio_stream.cpp
index 113f23f8f2..8efcb5bf07 100644
--- a/servers/audio/audio_stream.cpp
+++ b/servers/audio/audio_stream.cpp
@@ -99,6 +99,129 @@ void AudioStream::_bind_methods() {
////////////////////////////////
+Ref<AudioStreamPlayback> AudioStreamMicrophone::instance_playback() {
+ Ref<AudioStreamPlaybackMicrophone> playback;
+ playback.instance();
+
+ playbacks.insert(playback.ptr());
+
+ playback->microphone = Ref<AudioStreamMicrophone>((AudioStreamMicrophone *)this);
+ playback->active = false;
+
+ return playback;
+}
+
+String AudioStreamMicrophone::get_stream_name() const {
+
+ //if (audio_stream.is_valid()) {
+ //return "Random: " + audio_stream->get_name();
+ //}
+ return "Microphone";
+}
+
+void AudioStreamMicrophone::set_microphone_name(const String &p_name) {
+ if (microphone_name != p_name) {
+ microphone_name = p_name;
+
+ for (Set<AudioStreamPlaybackMicrophone *>::Element *E = playbacks.front(); E; E = E->next()) {
+ if (E->get()->active) {
+ // Is this the right thing to do?
+ E->get()->stop();
+ E->get()->start();
+ }
+ }
+ }
+}
+
+StringName AudioStreamMicrophone::get_microphone_name() const {
+ return microphone_name;
+}
+
+float AudioStreamMicrophone::get_length() const {
+ return 0;
+}
+
+void AudioStreamMicrophone::_bind_methods() {
+ ClassDB::bind_method(D_METHOD("set_microphone_name", "name"), &AudioStreamMicrophone::set_microphone_name);
+ ClassDB::bind_method(D_METHOD("get_microphone_name"), &AudioStreamMicrophone::get_microphone_name);
+
+ ADD_PROPERTY(PropertyInfo(Variant::STRING, "microphone_name"), "set_microphone_name", "get_microphone_name");
+}
+
+AudioStreamMicrophone::AudioStreamMicrophone() {
+}
+
+void AudioStreamPlaybackMicrophone::_mix_internal(AudioFrame *p_buffer, int p_frames) {
+
+ AudioDriver::MicrophoneDeviceOutput *microphone_device_output = reciever->owner;
+ const Vector<AudioFrame> &source_buffer = microphone_device_output->get_buffer();
+
+ if (microphone_device_output->get_read_index() >= 0) {
+ for (int i = 0; i < p_frames; i++) {
+ p_buffer[i] = source_buffer[internal_mic_offset + microphone_device_output->get_read_index() + i];
+ }
+ }
+
+ internal_mic_offset += p_frames;
+}
+
+void AudioStreamPlaybackMicrophone::mix(AudioFrame *p_buffer, float p_rate_scale, int p_frames) {
+ AudioStreamPlaybackResampled::mix(p_buffer, p_rate_scale, p_frames);
+ internal_mic_offset = 0; // Reset
+}
+
+float AudioStreamPlaybackMicrophone::get_stream_sampling_rate() {
+ return reciever->owner->get_mix_rate();
+}
+
+void AudioStreamPlaybackMicrophone::start(float p_from_pos) {
+ active = true;
+
+ // note: can this be called twice?
+ reciever = AudioServer::get_singleton()->create_microphone_reciever(microphone->get_microphone_name());
+ if (reciever == NULL) {
+ active = false;
+ }
+
+ _begin_resample();
+}
+
+void AudioStreamPlaybackMicrophone::stop() {
+ active = false;
+ if (reciever != NULL) {
+ AudioServer::get_singleton()->destroy_microphone_reciever(reciever);
+ reciever = NULL;
+ }
+}
+
+bool AudioStreamPlaybackMicrophone::is_playing() const {
+ return active;
+}
+
+int AudioStreamPlaybackMicrophone::get_loop_count() const {
+ return 0;
+}
+
+float AudioStreamPlaybackMicrophone::get_playback_position() const {
+ return 0;
+}
+
+void AudioStreamPlaybackMicrophone::seek(float p_time) {
+ return; // Can't seek a microphone input
+}
+
+AudioStreamPlaybackMicrophone::~AudioStreamPlaybackMicrophone() {
+ microphone->playbacks.erase(this);
+ stop();
+}
+
+AudioStreamPlaybackMicrophone::AudioStreamPlaybackMicrophone() {
+ internal_mic_offset = 0;
+ reciever = NULL;
+}
+
+////////////////////////////////
+
void AudioStreamRandomPitch::set_audio_stream(const Ref<AudioStream> &p_audio_stream) {
audio_stream = p_audio_stream;
diff --git a/servers/audio/audio_stream.h b/servers/audio/audio_stream.h
index 3312ce1ff6..cb3b999ceb 100644
--- a/servers/audio/audio_stream.h
+++ b/servers/audio/audio_stream.h
@@ -94,6 +94,66 @@ public:
virtual float get_length() const = 0; //if supported, otherwise return 0
};
+// Microphone
+
+class AudioStreamPlaybackMicrophone;
+
+class AudioStreamMicrophone : public AudioStream {
+
+ GDCLASS(AudioStreamMicrophone, AudioStream)
+ friend class AudioStreamPlaybackMicrophone;
+
+ Set<AudioStreamPlaybackMicrophone *> playbacks;
+ StringName microphone_name;
+
+protected:
+ static void _bind_methods();
+
+public:
+ virtual Ref<AudioStreamPlayback> instance_playback();
+ virtual String get_stream_name() const;
+
+ void set_microphone_name(const String &p_name);
+ StringName get_microphone_name() const;
+
+ virtual float get_length() const; //if supported, otherwise return 0
+
+ AudioStreamMicrophone();
+};
+
+class AudioStreamPlaybackMicrophone : public AudioStreamPlaybackResampled {
+
+ GDCLASS(AudioStreamPlaybackMicrophone, AudioStreamPlayback)
+ friend class AudioStreamMicrophone;
+
+ bool active;
+ uint64_t internal_mic_offset;
+
+ Ref<AudioStreamMicrophone> microphone;
+ AudioDriver::MicrophoneReciever *reciever;
+
+protected:
+ virtual void _mix_internal(AudioFrame *p_buffer, int p_frames);
+ virtual float get_stream_sampling_rate();
+
+public:
+ virtual void mix(AudioFrame *p_buffer, float p_rate_scale, int p_frames);
+
+ virtual void start(float p_from_pos = 0.0);
+ virtual void stop();
+ virtual bool is_playing() const;
+
+ virtual int get_loop_count() const; //times it looped
+
+ virtual float get_playback_position() const;
+ virtual void seek(float p_time);
+
+ ~AudioStreamPlaybackMicrophone();
+ AudioStreamPlaybackMicrophone();
+};
+
+//
+
class AudioStreamPlaybackRandomPitch;
class AudioStreamRandomPitch : public AudioStream {
diff --git a/servers/audio_server.cpp b/servers/audio_server.cpp
index 2eaa2ce8e7..10fa69a12e 100644
--- a/servers/audio_server.cpp
+++ b/servers/audio_server.cpp
@@ -33,6 +33,7 @@
#include "os/file_access.h"
#include "os/os.h"
#include "project_settings.h"
+#include "scene/resources/audio_stream_sample.h"
#include "servers/audio/audio_driver_dummy.h"
#include "servers/audio/effects/audio_effect_compressor.h"
#ifdef TOOLS_ENABLED
@@ -72,6 +73,42 @@ void AudioDriver::update_mix_time(int p_frames) {
_last_mix_time = OS::get_singleton()->get_ticks_usec();
}
+void AudioDriver::update_microphone_default(StringName p_device_name) {
+ if (default_microphone_device_output != NULL) {
+ MicrophoneDeviceOutput *output = default_microphone_device_output->owner;
+ output->remove_reciever(default_microphone_device_output);
+
+ while (output != NULL) {
+ MicrophoneDeviceOutput *owner = output->owner;
+ if (output->recievers.size() == 0) {
+ if (owner == NULL) {
+ if (output->active == true) {
+ capture_device_stop(output->name);
+ output->active == false;
+ }
+ } else {
+ owner->remove_reciever(output);
+ memdelete(output);
+ }
+ output = owner;
+ }
+ }
+
+ if (microphone_device_output_map.has(p_device_name)) {
+
+ Map<StringName, MicrophoneDeviceOutput *>::Element *e = microphone_device_output_map.find(p_device_name);
+ MicrophoneDeviceOutput *new_output = e->get();
+ new_output->add_reciever(default_microphone_device_output);
+ if (new_output->active == false) {
+ capture_device_start(p_device_name);
+ new_output->active = true;
+ }
+ }
+
+ output = default_microphone_device_output->owner;
+ }
+}
+
double AudioDriver::get_mix_time() const {
double total = (OS::get_singleton()->get_ticks_usec() - _last_mix_time) / 1000000.0;
@@ -101,6 +138,74 @@ int AudioDriver::get_total_channels_by_speaker_mode(AudioDriver::SpeakerMode p_m
ERR_FAIL_V(2);
}
+AudioDriver::MicrophoneReciever *AudioDriver::create_microphone_reciever(const StringName &p_device_name) {
+
+ MicrophoneReciever *microphone_reciever = NULL;
+ MicrophoneDeviceOutput *reciever_output = NULL;
+ MicrophoneDeviceOutput *device_output = NULL;
+
+ StringName device_name = capture_device_get_default_name();
+
+ if (microphone_device_output_map.has(device_name)) {
+
+ Map<StringName, MicrophoneDeviceOutput *>::Element *e = microphone_device_output_map.find(device_name);
+ device_output = e->get();
+ }
+
+ if (device_output) {
+ if (p_device_name == "") {
+ if (default_microphone_device_output != NULL) {
+ reciever_output = default_microphone_device_output;
+ } else {
+ // Default reciever does not exist, create it and connect it
+ default_microphone_device_output = memnew(MicrophoneDeviceOutputIndirect);
+ reciever_output = default_microphone_device_output;
+ device_output->add_reciever(reciever_output);
+ }
+ } else {
+ if (microphone_device_output_map.has(p_device_name)) {
+ reciever_output = device_output;
+ }
+ }
+
+ if (reciever_output) {
+ microphone_reciever = memnew(MicrophoneReciever);
+ reciever_output->add_reciever(microphone_reciever);
+ if (device_output->active == false) {
+ capture_device_start(device_name);
+ device_output->active = true;
+ }
+ }
+ }
+
+ return microphone_reciever;
+}
+
+void AudioDriver::destroy_microphone_reciever(AudioDriver::MicrophoneReciever *p_microphone_reciever) {
+
+ if (p_microphone_reciever != NULL) {
+ MicrophoneDeviceOutput *output = p_microphone_reciever->owner;
+ output->remove_reciever(p_microphone_reciever);
+
+ while (output != NULL) {
+ MicrophoneDeviceOutput *owner = output->owner;
+ if (output->recievers.size() == 0) {
+ if (owner == NULL) {
+ if (output->active == true) {
+ capture_device_stop(output->name);
+ output->active == false;
+ }
+ } else {
+ owner->remove_reciever(output);
+ memdelete(output);
+ }
+ output = owner;
+ }
+ }
+ memdelete(p_microphone_reciever);
+ }
+}
+
Array AudioDriver::get_device_list() {
Array list;
@@ -118,6 +223,8 @@ AudioDriver::AudioDriver() {
_last_mix_time = 0;
_mix_amount = 0;
+ default_microphone_device_output = NULL;
+
#ifdef DEBUG_ENABLED
prof_time = 0;
#endif
@@ -1201,6 +1308,34 @@ void AudioServer::set_device(String device) {
AudioDriver::get_singleton()->set_device(device);
}
+PoolStringArray AudioServer::audio_in_get_device_names() {
+
+ lock();
+ PoolStringArray device_names = AudioDriver::get_singleton()->capture_device_get_names();
+ unlock();
+
+ return device_names;
+}
+
+AudioDriver::MicrophoneReciever *AudioServer::create_microphone_reciever(const StringName &p_device_name) {
+ AudioDriver::MicrophoneReciever *microphone_reciever = NULL;
+
+ lock();
+ microphone_reciever = AudioDriver::get_singleton()->create_microphone_reciever(p_device_name);
+ unlock();
+
+ return microphone_reciever;
+}
+
+void AudioServer::destroy_microphone_reciever(AudioDriver::MicrophoneReciever *p_microphone_reciever) {
+ lock();
+ AudioDriver::get_singleton()->destroy_microphone_reciever(p_microphone_reciever);
+ unlock();
+}
+
+void AudioServer::_change_default_device(StringName p_recording_device_default_name) {
+}
+
void AudioServer::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_bus_count", "amount"), &AudioServer::set_bus_count);
diff --git a/servers/audio_server.h b/servers/audio_server.h
index 258fd1d9b0..f2c3aa0a6f 100644
--- a/servers/audio_server.h
+++ b/servers/audio_server.h
@@ -38,6 +38,8 @@
#include "variant.h"
class AudioDriverDummy;
+class AudioStream;
+class AudioStreamSample;
class AudioDriver {
@@ -53,6 +55,7 @@ class AudioDriver {
protected:
void audio_server_process(int p_frames, int32_t *p_buffer, bool p_update_mix_time = true);
void update_mix_time(int p_frames);
+ void update_microphone_default(StringName p_device_name);
#ifdef DEBUG_ENABLED
_FORCE_INLINE_ void start_counting_ticks() { prof_ticks = OS::get_singleton()->get_ticks_usec(); }
@@ -65,6 +68,121 @@ protected:
public:
double get_mix_time() const; //useful for video -> audio sync
+ class MicrophoneDeviceOutput;
+
+ class MicrophoneReciever {
+ public:
+ MicrophoneDeviceOutput *owner;
+
+ MicrophoneReciever() {
+ owner = NULL;
+ }
+
+ ~MicrophoneReciever() {
+ }
+ };
+
+ class MicrophoneDeviceOutput : public MicrophoneReciever {
+ public:
+ StringName name;
+ bool active;
+ Vector<MicrophoneReciever *> recievers;
+
+ virtual unsigned int get_mix_rate() = 0;
+ virtual Vector<AudioFrame> &get_buffer() = 0;
+ virtual int get_read_index() = 0;
+ virtual void set_read_index(int p_temp_index) = 0;
+
+ void add_reciever(MicrophoneReciever *p_reciever) {
+ if (p_reciever == NULL) {
+ ERR_PRINT("Attempted to add NULL reciever")
+ return;
+ }
+ if (recievers.find(p_reciever) == -1) {
+ recievers.push_back(p_reciever);
+ p_reciever->owner = this;
+ } else {
+ ERR_PRINT("Duplicate reciever added")
+ }
+ }
+
+ void remove_reciever(MicrophoneReciever *p_reciever) {
+ if (p_reciever == NULL) {
+ ERR_PRINT("Attempted to remove NULL reciever")
+ return;
+ }
+
+ int index = recievers.find(p_reciever);
+
+ if (index != -1) {
+ recievers.remove(index);
+ p_reciever->owner = NULL;
+ } else {
+ ERR_PRINT("Attempted to remove invalid reciever")
+ }
+ }
+ };
+
+ class MicrophoneDeviceOutputDirect : public MicrophoneDeviceOutput {
+ public:
+ enum MicrophoneFormat {
+ FORMAT_FLOAT,
+ FORMAT_PCM
+ };
+
+ MicrophoneFormat microphone_format;
+ unsigned short bits_per_sample;
+ unsigned int channels;
+ unsigned int mix_rate;
+ unsigned short frame_size;
+ int read_index = -2048;
+
+ unsigned int current_capture_index;
+ Vector<AudioFrame> buffer;
+
+ unsigned int get_mix_rate() {
+ return mix_rate;
+ };
+
+ Vector<AudioFrame> &get_buffer() {
+ return buffer;
+ };
+
+ int get_read_index() {
+ return read_index;
+ }
+
+ void set_read_index(int p_read_index) {
+ read_index = p_read_index;
+ }
+ };
+
+ class MicrophoneDeviceOutputIndirect : public MicrophoneDeviceOutput {
+ public:
+ unsigned int get_mix_rate() {
+ return owner->get_mix_rate();
+ };
+
+ Vector<AudioFrame> &get_buffer() {
+ return owner->get_buffer();
+ };
+
+ int get_read_index() {
+ return owner->get_read_index();
+ }
+
+ void set_read_index(int p_read_index) {
+ owner->set_read_index(p_read_index);
+ }
+ };
+
+ MicrophoneDeviceOutputIndirect *default_microphone_device_output;
+
+ Vector<MicrophoneDeviceOutput *> microphone_device_outputs;
+ Map<StringName, MicrophoneDeviceOutput *> microphone_device_output_map;
+
+ Vector<MicrophoneReciever *> direct_recievers;
+
enum SpeakerMode {
SPEAKER_MODE_STEREO,
SPEAKER_SURROUND_31,
@@ -91,11 +209,19 @@ public:
virtual void unlock() = 0;
virtual void finish() = 0;
+ virtual bool capture_device_start(StringName p_name) = 0;
+ virtual bool capture_device_stop(StringName p_name) = 0;
+ virtual PoolStringArray capture_device_get_names() = 0;
+ virtual StringName capture_device_get_default_name() = 0;
+
virtual float get_latency() { return 0; }
SpeakerMode get_speaker_mode_by_total_channels(int p_channels) const;
int get_total_channels_by_speaker_mode(SpeakerMode) const;
+ AudioDriver::MicrophoneReciever *create_microphone_reciever(const StringName &p_device_name);
+ void destroy_microphone_reciever(AudioDriver::MicrophoneReciever *p_microphone_reciever);
+
#ifdef DEBUG_ENABLED
uint64_t get_profiling_time() const { return prof_time; }
void reset_profiling_time() { prof_time = 0; }
@@ -222,6 +348,18 @@ private:
void _mix_step();
+#if 0
+ struct AudioInBlock {
+
+ Ref<AudioStreamSample> audio_stream;
+ int current_position;
+ bool loops;
+ };
+
+ Map<StringName, AudioInBlock *> audio_in_block_map;
+ Vector<AudioInBlock *> audio_in_blocks;
+#endif
+
struct CallbackItem {
AudioCallback callback;
@@ -236,6 +374,7 @@ private:
friend class AudioDriver;
void _driver_process(int p_frames, int32_t *p_buffer);
+ void _change_default_device(StringName p_recording_device_default_name);
protected:
static void _bind_methods();
@@ -335,8 +474,12 @@ public:
String get_device();
void set_device(String device);
- float get_output_latency() { return output_latency; }
+ AudioDriver::MicrophoneReciever *create_microphone_reciever(const StringName &p_device_name);
+ void destroy_microphone_reciever(AudioDriver::MicrophoneReciever *p_microphone_reciever);
+
+ PoolStringArray audio_in_get_device_names();
+ float get_output_latency() { return output_latency; }
AudioServer();
virtual ~AudioServer();
};
diff --git a/servers/register_server_types.cpp b/servers/register_server_types.cpp
index aa0e5c289b..1dcfdb2174 100644
--- a/servers/register_server_types.cpp
+++ b/servers/register_server_types.cpp
@@ -104,6 +104,7 @@ void register_server_types() {
ClassDB::register_virtual_class<AudioStream>();
ClassDB::register_virtual_class<AudioStreamPlayback>();
+ ClassDB::register_class<AudioStreamMicrophone>();
ClassDB::register_class<AudioStreamRandomPitch>();
ClassDB::register_virtual_class<AudioEffect>();
ClassDB::register_class<AudioEffectEQ>();
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-05 21:43:01 +0000