jp9000
/
obs-studio
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
obs-studio/plugins/mac-capture/mac-audio.c

766 lines
19 KiB
C
Raw Normal View History

Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
#include <AudioUnit/AudioUnit.h>
#include <CoreFoundation/CFString.h>
#include <CoreAudio/CoreAudio.h>
#include <unistd.h>
#include <errno.h>
Add locale for modules
2014-07-09 22:12:57 -07:00
#include <obs-module.h>
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
#include <util/threading.h>
#include <util/c99defs.h>
#include "mac-helpers.h"
CoreAudio: Separate enumeration code The enumeration code being up at the top was making things quite messy, so I split that code out to a separate set of files.
2014-03-04 06:10:33 -08:00
#include "audio-device-enum.h"
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
#define PROPERTY_DEFAULT_DEVICE kAudioHardwarePropertyDefaultInputDevice
#define PROPERTY_FORMATS kAudioStreamPropertyAvailablePhysicalFormats
Add callback for device format change (CoreAudio)
2014-02-27 12:22:58 -08:00
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
#define SCOPE_OUTPUT kAudioUnitScope_Output
#define SCOPE_INPUT kAudioUnitScope_Input
#define SCOPE_GLOBAL kAudioUnitScope_Global
#define BUS_OUTPUT 0
#define BUS_INPUT 1
#define MAX_DEVICES 20
#define set_property AudioUnitSetProperty
#define get_property AudioUnitGetProperty
Add locale for modules
2014-07-09 22:12:57 -07:00
#define TEXT_AUDIO_INPUT obs_module_text("CoreAudio.InputCapture");
#define TEXT_AUDIO_OUTPUT obs_module_text("CoreAudio.OutputCapture");
#define TEXT_DEVICE obs_module_text("CoreAudio.Device")
#define TEXT_DEVICE_DEFAULT obs_module_text("CoreAudio.Device.Default")
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
struct coreaudio_data {
char *device_name;
char *device_uid;
AudioUnit unit;
AudioDeviceID device_id;
AudioBufferList *buf_list;
bool au_initialized;
bool active;
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
bool default_device;
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
bool input;
CoreAudio: Don't reconnect if no output devices Somehow this code didn't get included with the last commit.
2014-03-03 04:12:58 -08:00
bool no_devices;
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
uint32_t sample_rate;
enum audio_format format;
enum speaker_layout speakers;
pthread_t reconnect_thread;
Fix semaphore mac code and mac plugin Didn't convert the event names and didn't have the right mac includes
2014-03-10 19:24:09 -07:00
os_event_t exit_event;
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
volatile bool reconnecting;
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
unsigned long retry_time;
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
obs_source_t source;
};
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
static bool get_default_output_device(struct coreaudio_data *ca)
{
struct device_list list;
memset(&list, 0, sizeof(struct device_list));
coreaudio_enum_devices(&list, false);
if (!list.items.num)
return false;
bfree(ca->device_uid);
ca->device_uid = bstrdup(list.items.array[0].value.array);
device_list_free(&list);
return true;
}
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
static bool find_device_id_by_uid(struct coreaudio_data *ca)
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
{
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
UInt32 size = sizeof(AudioDeviceID);
CFStringRef cf_uid = NULL;
CFStringRef qual = NULL;
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
UInt32 qual_size = 0;
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
OSStatus stat;
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
bool success;
AudioObjectPropertyAddress addr = {
.mScope = kAudioObjectPropertyScopeGlobal,
.mElement = kAudioObjectPropertyElementMaster
};
CoreAudio: Set default audio settings on creation device_id would end up being null, which would mess with the functions.
2014-03-11 19:42:04 -07:00
if (!ca->device_uid)
CoreAudio: If null device id, just set to default
2014-03-11 19:45:02 -07:00
ca->device_uid = bstrdup("default");
CoreAudio: Set default audio settings on creation device_id would end up being null, which would mess with the functions.
2014-03-11 19:42:04 -07:00
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
/* have to do this because mac output devices don't actually exist */
if (astrcmpi(ca->device_uid, "default") == 0) {
CoreAudio: Fail if no output device found Also, don't have it repeat trying to reconnect if no devices are found
2014-03-03 02:21:00 -08:00
if (ca->input) {
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
ca->default_device = true;
CoreAudio: Fail if no output device found Also, don't have it repeat trying to reconnect if no devices are found
2014-03-03 02:21:00 -08:00
} else {
CoreAudio: Don't reconnect if no output devices Somehow this code didn't get included with the last commit.
2014-03-03 04:12:58 -08:00
if (!get_default_output_device(ca)) {
ca->no_devices = true;
CoreAudio: Fail if no output device found Also, don't have it repeat trying to reconnect if no devices are found
2014-03-03 02:21:00 -08:00
return false;
CoreAudio: Don't reconnect if no output devices Somehow this code didn't get included with the last commit.
2014-03-03 04:12:58 -08:00
}
CoreAudio: Fail if no output device found Also, don't have it repeat trying to reconnect if no devices are found
2014-03-03 02:21:00 -08:00
}
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
}
cf_uid = CFStringCreateWithCString(NULL, ca->device_uid,
kCFStringEncodingUTF8);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
if (ca->default_device) {
addr.mSelector = PROPERTY_DEFAULT_DEVICE;
CoreAudio: Enumerate AudioDeviceID manually Apparently, despite the fact that Apple added kAudioHardwarePropertyTranslateUIDToDevice in 10.8, it's not actually usable in 10.8, only 10.9. So, instead of being able to use it like a normal, sane person, we have to enumerate all devices manually and find the AudioDeviceID ourselves. A slight annoyance and a mark against apple's competence, but audio devices should now be working again on 10.8 at least, so whatever.
2014-06-07 06:07:51 -07:00
stat = AudioObjectGetPropertyData(kAudioObjectSystemObject,
&addr, qual_size, &qual, &size, &ca->device_id);
success = (stat == noErr);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
} else {
CoreAudio: Enumerate AudioDeviceID manually Apparently, despite the fact that Apple added kAudioHardwarePropertyTranslateUIDToDevice in 10.8, it's not actually usable in 10.8, only 10.9. So, instead of being able to use it like a normal, sane person, we have to enumerate all devices manually and find the AudioDeviceID ourselves. A slight annoyance and a mark against apple's competence, but audio devices should now be working again on 10.8 at least, so whatever.
2014-06-07 06:07:51 -07:00
success = coreaudio_get_device_id(cf_uid, &ca->device_id);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
}
CFRelease(cf_uid);
return success;
}
static inline void ca_warn(struct coreaudio_data *ca, const char *func,
const char *format, ...)
{
va_list args;
struct dstr str = {0};
va_start(args, format);
Fix a memory leak in ca_warn (CoreAudio)
2014-02-26 23:20:43 -08:00
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
dstr_printf(&str, "[%s]:[device '%s'] ", func, ca->device_name);
dstr_vcatf(&str, format, args);
blog(LOG_WARNING, "%s", str.array);
Fix a memory leak in ca_warn (CoreAudio)
2014-02-26 23:20:43 -08:00
dstr_free(&str);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
va_end(args);
}
static inline bool ca_success(OSStatus stat, struct coreaudio_data *ca,
const char *func, const char *action)
{
if (stat != noErr) {
blog(LOG_WARNING, "[%s]:[device '%s'] %s failed: %d",
func, ca->device_name, action, (int)stat);
return false;
}
return true;
}
enum coreaudio_io_type {
IO_TYPE_INPUT,
IO_TYPE_OUTPUT,
};
static inline bool enable_io(struct coreaudio_data *ca,
enum coreaudio_io_type type, bool enable)
{
UInt32 enable_int = enable;
return set_property(ca->unit, kAudioOutputUnitProperty_EnableIO,
(type == IO_TYPE_INPUT) ? SCOPE_INPUT : SCOPE_OUTPUT,
(type == IO_TYPE_INPUT) ? BUS_INPUT : BUS_OUTPUT,
&enable_int, sizeof(enable_int));
}
static inline enum audio_format convert_ca_format(UInt32 format_flags,
UInt32 bits)
{
bool planar = (format_flags & kAudioFormatFlagIsNonInterleaved) != 0;
if (format_flags & kAudioFormatFlagIsFloat)
return planar ? AUDIO_FORMAT_FLOAT_PLANAR : AUDIO_FORMAT_FLOAT;
if (!(format_flags & kAudioFormatFlagIsSignedInteger) && bits == 8)
return planar ? AUDIO_FORMAT_U8BIT_PLANAR : AUDIO_FORMAT_U8BIT;
/* not float? not signed int? no clue, fail */
if ((format_flags & kAudioFormatFlagIsSignedInteger) == 0)
return AUDIO_FORMAT_UNKNOWN;
if (bits == 16)
return planar ? AUDIO_FORMAT_16BIT_PLANAR : AUDIO_FORMAT_16BIT;
else if (bits == 32)
return planar ? AUDIO_FORMAT_32BIT_PLANAR : AUDIO_FORMAT_32BIT;
return AUDIO_FORMAT_UNKNOWN;
}
static inline enum speaker_layout convert_ca_speaker_layout(UInt32 channels)
{
/* directly map channel count to enum values */
if (channels >= 1 && channels <= 8 && channels != 7)
return (enum speaker_layout)channels;
return SPEAKERS_UNKNOWN;
}
static bool coreaudio_init_format(struct coreaudio_data *ca)
{
AudioStreamBasicDescription desc;
OSStatus stat;
UInt32 size = sizeof(desc);
stat = get_property(ca->unit, kAudioUnitProperty_StreamFormat,
SCOPE_INPUT, BUS_INPUT, &desc, &size);
if (!ca_success(stat, ca, "coreaudio_init_format", "get input format"))
return false;
stat = set_property(ca->unit, kAudioUnitProperty_StreamFormat,
SCOPE_OUTPUT, BUS_INPUT, &desc, size);
if (!ca_success(stat, ca, "coreaudio_init_format", "set output format"))
return false;
if (desc.mFormatID != kAudioFormatLinearPCM) {
ca_warn(ca, "coreaudio_init_format", "format is not PCM");
return false;
}
ca->format = convert_ca_format(desc.mFormatFlags, desc.mBitsPerChannel);
if (ca->format == AUDIO_FORMAT_UNKNOWN) {
ca_warn(ca, "coreaudio_init_format", "unknown format flags: "
"%u, bits: %u",
(unsigned int)desc.mFormatFlags,
(unsigned int)desc.mBitsPerChannel);
return false;
}
ca->sample_rate = (uint32_t)desc.mSampleRate;
ca->speakers = convert_ca_speaker_layout(desc.mChannelsPerFrame);
if (ca->speakers == SPEAKERS_UNKNOWN) {
ca_warn(ca, "coreaudio_init_format", "unknown speaker layout: "
"%u channels",
(unsigned int)desc.mChannelsPerFrame);
return false;
}
return true;
}
static bool coreaudio_init_buffer(struct coreaudio_data *ca)
{
UInt32 buf_size = 0;
UInt32 size = 0;
UInt32 frames = 0;
OSStatus stat;
AudioObjectPropertyAddress addr = {
kAudioDevicePropertyStreamConfiguration,
kAudioDevicePropertyScopeInput,
kAudioObjectPropertyElementMaster
};
stat = AudioObjectGetPropertyDataSize(ca->device_id, &addr, 0, NULL,
&buf_size);
if (!ca_success(stat, ca, "coreaudio_init_buffer", "get list size"))
return false;
size = sizeof(frames);
stat = get_property(ca->unit, kAudioDevicePropertyBufferFrameSize,
SCOPE_GLOBAL, 0, &frames, &size);
if (!ca_success(stat, ca, "coreaudio_init_buffer", "get frame size"))
return false;
/* ---------------------- */
ca->buf_list = bmalloc(buf_size);
stat = AudioObjectGetPropertyData(ca->device_id, &addr, 0, NULL,
&buf_size, ca->buf_list);
if (!ca_success(stat, ca, "coreaudio_init_buffer", "allocate")) {
bfree(ca->buf_list);
ca->buf_list = NULL;
return false;
}
for (UInt32 i = 0; i < ca->buf_list->mNumberBuffers; i++) {
size = ca->buf_list->mBuffers[i].mDataByteSize;
ca->buf_list->mBuffers[i].mData = bmalloc(size);
}
return true;
}
static void buf_list_free(AudioBufferList *buf_list)
{
if (buf_list) {
for (UInt32 i = 0; i < buf_list->mNumberBuffers; i++)
bfree(buf_list->mBuffers[i].mData);
bfree(buf_list);
}
}
static OSStatus input_callback(
void *data,
AudioUnitRenderActionFlags *action_flags,
const AudioTimeStamp *ts_data,
UInt32 bus_num,
UInt32 frames,
AudioBufferList *ignored_buffers)
{
struct coreaudio_data *ca = data;
OSStatus stat;
(API Change) Rename source_audio structure Rename source_audio to obs_source_audio to make it more consistent with the rest of the API
2014-08-02 08:42:04 -07:00
struct obs_source_audio audio;
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
stat = AudioUnitRender(ca->unit, action_flags, ts_data, bus_num, frames,
ca->buf_list);
if (!ca_success(stat, ca, "input_callback", "audio retrieval"))
return noErr;
for (UInt32 i = 0; i < ca->buf_list->mNumberBuffers; i++)
audio.data[i] = ca->buf_list->mBuffers[i].mData;
audio.frames = frames;
audio.speakers = ca->speakers;
audio.format = ca->format;
audio.samples_per_sec = ca->sample_rate;
audio.timestamp = ts_data->mHostTime;
obs_source_output_audio(ca->source, &audio);
UNUSED_PARAMETER(ignored_buffers);
return noErr;
}
static void coreaudio_stop(struct coreaudio_data *ca);
static bool coreaudio_init(struct coreaudio_data *ca);
static void coreaudio_uninit(struct coreaudio_data *ca);
static void *reconnect_thread(void *param)
{
struct coreaudio_data *ca = param;
ca->reconnecting = true;
Fix semaphore mac code and mac plugin Didn't convert the event names and didn't have the right mac includes
2014-03-10 19:24:09 -07:00
while (os_event_timedwait(ca->exit_event, ca->retry_time) == ETIMEDOUT) {
Remove redundant connect message
2014-02-26 23:32:03 -08:00
if (coreaudio_init(ca))
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
break;
}
blog(LOG_DEBUG, "coreaudio: exit the reconnect thread");
ca->reconnecting = false;
return NULL;
}
static void coreaudio_begin_reconnect(struct coreaudio_data *ca)
{
int ret;
if (ca->reconnecting)
return;
ret = pthread_create(&ca->reconnect_thread, NULL, reconnect_thread, ca);
if (ret != 0)
blog(LOG_WARNING, "[coreaudio_begin_reconnect] failed to "
"create thread, error code: %d", ret);
}
Add callback for device format change (CoreAudio)
2014-02-27 12:22:58 -08:00
static OSStatus notification_callback(
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
AudioObjectID id,
UInt32 num_addresses,
const AudioObjectPropertyAddress addresses[],
void *data)
{
struct coreaudio_data *ca = data;
Add callback for device format change (CoreAudio)
2014-02-27 12:22:58 -08:00
coreaudio_stop(ca);
coreaudio_uninit(ca);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
if (addresses[0].mSelector == PROPERTY_DEFAULT_DEVICE)
ca->retry_time = 300;
else
ca->retry_time = 2000;
blog(LOG_INFO, "coreaudio: device '%s' disconnected or changed. "
"attempting to reconnect", ca->device_name);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
Add callback for device format change (CoreAudio)
2014-02-27 12:22:58 -08:00
coreaudio_begin_reconnect(ca);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
Add callback for device format change (CoreAudio)
2014-02-27 12:22:58 -08:00
UNUSED_PARAMETER(id);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
UNUSED_PARAMETER(num_addresses);
Add callback for device format change (CoreAudio)
2014-02-27 12:22:58 -08:00
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
return noErr;
}
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
static OSStatus add_listener(struct coreaudio_data *ca, UInt32 property)
{
AudioObjectPropertyAddress addr = {
property,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
return AudioObjectAddPropertyListener(ca->device_id, &addr,
notification_callback, ca);
}
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
static bool coreaudio_init_hooks(struct coreaudio_data *ca)
{
OSStatus stat;
AURenderCallbackStruct callback_info = {
.inputProc = input_callback,
.inputProcRefCon = ca
};
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
stat = add_listener(ca, kAudioDevicePropertyDeviceIsAlive);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
if (!ca_success(stat, ca, "coreaudio_init_hooks",
"set disconnect callback"))
return false;
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
stat = add_listener(ca, PROPERTY_FORMATS);
Add callback for device format change (CoreAudio)
2014-02-27 12:22:58 -08:00
if (!ca_success(stat, ca, "coreaudio_init_hooks",
"set format change callback"))
return false;
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
if (ca->default_device) {
AudioObjectPropertyAddress addr = {
PROPERTY_DEFAULT_DEVICE,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
stat = AudioObjectAddPropertyListener(kAudioObjectSystemObject,
&addr, notification_callback, ca);
if (!ca_success(stat, ca, "coreaudio_init_hooks",
"set device change callback"))
return false;
}
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
stat = set_property(ca->unit, kAudioOutputUnitProperty_SetInputCallback,
SCOPE_GLOBAL, 0, &callback_info, sizeof(callback_info));
if (!ca_success(stat, ca, "coreaudio_init_hooks", "set input callback"))
return false;
return true;
}
static void coreaudio_remove_hooks(struct coreaudio_data *ca)
{
AURenderCallbackStruct callback_info = {
.inputProc = NULL,
.inputProcRefCon = NULL
};
Add callback for device format change (CoreAudio)
2014-02-27 12:22:58 -08:00
AudioObjectPropertyAddress addr = {
kAudioDevicePropertyDeviceIsAlive,
kAudioObjectPropertyScopeGlobal,
kAudioObjectPropertyElementMaster
};
AudioObjectRemovePropertyListener(ca->device_id, &addr,
notification_callback, ca);
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
addr.mSelector = PROPERTY_FORMATS;
Add callback for device format change (CoreAudio)
2014-02-27 12:22:58 -08:00
AudioObjectRemovePropertyListener(ca->device_id, &addr,
notification_callback, ca);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
if (ca->default_device) {
addr.mSelector = PROPERTY_DEFAULT_DEVICE;
AudioObjectRemovePropertyListener(kAudioObjectSystemObject,
&addr, notification_callback, ca);
}
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
set_property(ca->unit, kAudioOutputUnitProperty_SetInputCallback,
SCOPE_GLOBAL, 0, &callback_info, sizeof(callback_info));
}
static bool coreaudio_get_device_name(struct coreaudio_data *ca)
{
CFStringRef cf_name = NULL;
UInt32 size = sizeof(CFStringRef);
char name[1024];
const AudioObjectPropertyAddress addr = {
kAudioDevicePropertyDeviceNameCFString,
kAudioObjectPropertyScopeInput,
kAudioObjectPropertyElementMaster
};
OSStatus stat = AudioObjectGetPropertyData(ca->device_id, &addr,
0, NULL, &size, &cf_name);
if (stat != noErr) {
blog(LOG_WARNING, "[coreaudio_get_device_name] failed to "
"get name: %d", (int)stat);
return false;
}
if (!cf_to_cstr(cf_name, name, 1024)) {
blog(LOG_WARNING, "[coreaudio_get_device_name] failed to "
"convert name to cstr for some reason");
return false;
}
bfree(ca->device_name);
ca->device_name = bstrdup(name);
CFRelease(cf_name);
return true;
}
static bool coreaudio_start(struct coreaudio_data *ca)
{
OSStatus stat;
if (ca->active)
return true;
stat = AudioOutputUnitStart(ca->unit);
return ca_success(stat, ca, "coreaudio_start", "start audio");
}
static void coreaudio_stop(struct coreaudio_data *ca)
{
OSStatus stat;
if (!ca->active)
return;
ca->active = false;
stat = AudioOutputUnitStop(ca->unit);
ca_success(stat, ca, "coreaudio_stop", "stop audio");
}
static bool coreaudio_init_unit(struct coreaudio_data *ca)
{
AudioComponentDescription desc = {
.componentType = kAudioUnitType_Output,
.componentSubType = kAudioUnitSubType_HALOutput
};
AudioComponent component = AudioComponentFindNext(NULL, &desc);
if (!component) {
ca_warn(ca, "coreaudio_init_unit", "find component failed");
return false;
}
OSStatus stat = AudioComponentInstanceNew(component, &ca->unit);
if (!ca_success(stat, ca, "coreaudio_init_unit", "instance unit"))
return false;
Fix more failure handling for CoreAudio Actually, if initializing failed at all, it would never properly uninitialize because the 'initialized' variable was never set until the very end. Instead, set the "initialized" flag from the beginning to ensure initialization.
2014-02-26 23:17:35 -08:00
ca->au_initialized = true;
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
return true;
}
static bool coreaudio_init(struct coreaudio_data *ca)
{
OSStatus stat;
if (ca->au_initialized)
return true;
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
if (!find_device_id_by_uid(ca))
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
return false;
if (!coreaudio_get_device_name(ca))
return false;
if (!coreaudio_init_unit(ca))
return false;
stat = enable_io(ca, IO_TYPE_INPUT, true);
if (!ca_success(stat, ca, "coreaudio_init", "enable input io"))
goto fail;
stat = enable_io(ca, IO_TYPE_OUTPUT, false);
if (!ca_success(stat, ca, "coreaudio_init", "disable output io"))
goto fail;
stat = set_property(ca->unit, kAudioOutputUnitProperty_CurrentDevice,
SCOPE_GLOBAL, 0, &ca->device_id, sizeof(ca->device_id));
if (!ca_success(stat, ca, "coreaudio_init", "set current device"))
goto fail;
if (!coreaudio_init_format(ca))
goto fail;
if (!coreaudio_init_buffer(ca))
goto fail;
if (!coreaudio_init_hooks(ca))
goto fail;
stat = AudioUnitInitialize(ca->unit);
if (!ca_success(stat, ca, "coreaudio_initialize", "initialize"))
goto fail;
Fix audio startup (CoreAudio) Forgot to add a '!'.
2014-02-27 03:12:41 -08:00
if (!coreaudio_start(ca))
Fix a case where audio wouldn't free correctly If coreaudio_start failed, it wouldn't free the audio data properly. Fixed that issue.
2014-02-26 23:14:50 -08:00
goto fail;
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
Fix a case where audio wouldn't free correctly If coreaudio_start failed, it wouldn't free the audio data properly. Fixed that issue.
2014-02-26 23:14:50 -08:00
blog(LOG_INFO, "coreaudio: device '%s' initialized", ca->device_name);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
return ca->au_initialized;
fail:
coreaudio_uninit(ca);
return false;
}
static void coreaudio_try_init(struct coreaudio_data *ca)
{
if (!coreaudio_init(ca)) {
blog(LOG_INFO, "coreaudio: failed to find device "
"uid: %s, waiting for connection",
ca->device_uid);
CoreAudio: Detect default device change If the default device changes, set the reconnect interval to 200 milliseconds so it pretty much immediately tries to reinitialize the audio with the newly selected default device. Otherwise, use 2000 millisecond intervals, and assume disconnection. Also, reduced FFmpeg logging to just regular FFmpeg information rather than everything FFmpeg logs.
2014-02-28 20:46:22 -08:00
ca->retry_time = 2000;
CoreAudio: Don't reconnect if no output devices Somehow this code didn't get included with the last commit.
2014-03-03 04:12:58 -08:00
if (ca->no_devices)
blog(LOG_INFO, "coreaudio: no device found");
else
coreaudio_begin_reconnect(ca);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
}
}
static void coreaudio_uninit(struct coreaudio_data *ca)
{
if (!ca->au_initialized)
return;
if (ca->unit) {
coreaudio_stop(ca);
OSStatus stat = AudioUnitUninitialize(ca->unit);
ca_success(stat, ca, "coreaudio_uninit", "uninitialize");
coreaudio_remove_hooks(ca);
stat = AudioComponentInstanceDispose(ca->unit);
ca_success(stat, ca, "coreaudio_uninit", "dispose");
ca->unit = NULL;
}
ca->au_initialized = false;
buf_list_free(ca->buf_list);
ca->buf_list = NULL;
}
/* ------------------------------------------------------------------------- */
Remove 'locale' parameter from all callbacks The locale parameter was a mistake, because it puts extra needless burden upon the module developer to have to handle this variable for each and every single callback function. The parameter is being removed in favor of a single centralized module callback function that specifically updates locale information for a module only when needed.
2014-06-25 00:13:00 -07:00
static const char *coreaudio_input_getname(void)
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
{
Add locale for modules
2014-07-09 22:12:57 -07:00
return TEXT_AUDIO_INPUT;
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
}
Remove 'locale' parameter from all callbacks The locale parameter was a mistake, because it puts extra needless burden upon the module developer to have to handle this variable for each and every single callback function. The parameter is being removed in favor of a single centralized module callback function that specifically updates locale information for a module only when needed.
2014-06-25 00:13:00 -07:00
static const char *coreaudio_output_getname(void)
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
{
Add locale for modules
2014-07-09 22:12:57 -07:00
return TEXT_AUDIO_OUTPUT;
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
}
static void coreaudio_destroy(void *data)
{
struct coreaudio_data *ca = data;
if (ca) {
if (ca->reconnecting) {
Fix semaphore mac code and mac plugin Didn't convert the event names and didn't have the right mac includes
2014-03-10 19:24:09 -07:00
os_event_signal(ca->exit_event);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
pthread_join(ca->reconnect_thread, NULL);
}
coreaudio_uninit(ca);
if (ca->unit)
AudioComponentInstanceDispose(ca->unit);
Fix semaphore mac code and mac plugin Didn't convert the event names and didn't have the right mac includes
2014-03-10 19:24:09 -07:00
os_event_destroy(ca->exit_event);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
bfree(ca->device_name);
bfree(ca->device_uid);
bfree(ca);
}
}
Add a way to get default settings - Implement a means of obtaining default settings for an input/output/encoder. obs_source_defaults for example will return the default settings for a particular source type. - Because C++ doesn't have designated initializers, use functions in the WASAPI plugin to register the sources instead.
2014-03-07 05:55:21 -08:00
static void coreaudio_defaults(obs_data_t settings)
{
obs_data_set_default_string(settings, "device_id", "default");
}
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
static void *coreaudio_create(obs_data_t settings, obs_source_t source,
bool input)
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
{
struct coreaudio_data *ca = bzalloc(sizeof(struct coreaudio_data));
Fix semaphore mac code and mac plugin Didn't convert the event names and didn't have the right mac includes
2014-03-10 19:24:09 -07:00
if (os_event_init(&ca->exit_event, OS_EVENT_TYPE_MANUAL) != 0) {
CoreAudio: Set default audio settings on creation device_id would end up being null, which would mess with the functions.
2014-03-11 19:42:04 -07:00
blog(LOG_ERROR, "[coreaudio_create] failed to create "
"semephore: %d", errno);
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
bfree(ca);
return NULL;
}
ca->device_uid = bstrdup(obs_data_getstring(settings, "device_id"));
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
ca->source = source;
ca->input = input;
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
CoreAudio: If null device id, just set to default
2014-03-11 19:45:02 -07:00
if (!ca->device_uid)
ca->device_uid = bstrdup("default");
CoreAudio: Set default audio settings on creation device_id would end up being null, which would mess with the functions.
2014-03-11 19:42:04 -07:00
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
coreaudio_try_init(ca);
return ca;
}
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
static void *coreaudio_create_input_capture(obs_data_t settings,
obs_source_t source)
{
return coreaudio_create(settings, source, true);
}
static void *coreaudio_create_output_capture(obs_data_t settings,
obs_source_t source)
{
return coreaudio_create(settings, source, false);
}
Remove 'locale' parameter from all callbacks The locale parameter was a mistake, because it puts extra needless burden upon the module developer to have to handle this variable for each and every single callback function. The parameter is being removed in favor of a single centralized module callback function that specifically updates locale information for a module only when needed.
2014-06-25 00:13:00 -07:00
static obs_properties_t coreaudio_properties(bool input)
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
{
Remove 'locale' from properties Having the value stored here is somewhat pointless, so this is one step in fixing the locale handling. Locale should be handled by the modules themselves with their own loaded locale lookup information.
2014-06-24 23:54:10 -07:00
obs_properties_t props = obs_properties_create();
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
obs_property_t property;
struct device_list devices;
memset(&devices, 0, sizeof(struct device_list));
Add locale for modules
2014-07-09 22:12:57 -07:00
property = obs_properties_add_list(props, "device_id", TEXT_DEVICE,
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
OBS_COMBO_TYPE_LIST, OBS_COMBO_FORMAT_STRING);
coreaudio_enum_devices(&devices, input);
if (devices.items.num)
Add locale for modules
2014-07-09 22:12:57 -07:00
obs_property_list_add_string(property, TEXT_DEVICE_DEFAULT,
"default");
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
for (size_t i = 0; i < devices.items.num; i++) {
struct device_item *item = devices.items.array+i;
Improve properties API Improve the properties API so that it can actually respond somewhat to user input. Maybe later this might be further improved or replaced with something script-based. When creating a property, you can now add a callback to that property that notifies when the property has been changed in the user interface. Return true if you want the properties to be refreshed, or false if not. Though now that I think about it I doubt there would ever be a case where you would have this callback and *not* refresh the properties. Regardless, this allows functions to change the values of properties or settings, or enable/disable/hide other property controls from view dynamically.
2014-04-04 00:30:37 -07:00
obs_property_list_add_string(property,
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
item->name.array, item->value.array);
}
device_list_free(&devices);
return props;
}
Remove 'locale' parameter from all callbacks The locale parameter was a mistake, because it puts extra needless burden upon the module developer to have to handle this variable for each and every single callback function. The parameter is being removed in favor of a single centralized module callback function that specifically updates locale information for a module only when needed.
2014-06-25 00:13:00 -07:00
static obs_properties_t coreaudio_input_properties(void)
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
{
Remove 'locale' parameter from all callbacks The locale parameter was a mistake, because it puts extra needless burden upon the module developer to have to handle this variable for each and every single callback function. The parameter is being removed in favor of a single centralized module callback function that specifically updates locale information for a module only when needed.
2014-06-25 00:13:00 -07:00
return coreaudio_properties(true);
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
}
Remove 'locale' parameter from all callbacks The locale parameter was a mistake, because it puts extra needless burden upon the module developer to have to handle this variable for each and every single callback function. The parameter is being removed in favor of a single centralized module callback function that specifically updates locale information for a module only when needed.
2014-06-25 00:13:00 -07:00
static obs_properties_t coreaudio_output_properties(void)
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
{
Remove 'locale' parameter from all callbacks The locale parameter was a mistake, because it puts extra needless burden upon the module developer to have to handle this variable for each and every single callback function. The parameter is being removed in favor of a single centralized module callback function that specifically updates locale information for a module only when needed.
2014-06-25 00:13:00 -07:00
return coreaudio_properties(false);
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
}
struct obs_source_info coreaudio_input_capture_info = {
(API Change) Use 'get' convention: API callbacks Renamed: To: ------------------------------------------------------- obs_source_info::defaults obs_source_info::get_defaults obs_source_info::properties obs_source_info::get_properties obs_output_info::defaults obs_output_info::get_defaults obs_output_info::properties obs_output_info::get_properties obs_output_info::total_bytes obs_output_info::get_total_bytes obs_output_info::dropped_frames obs_output_info::get_dropped_frames obs_encoder_info::defaults obs_encoder_info::get_defaults obs_encoder_info::properties obs_encoder_info::get_properties obs_encoder_info::extra_data obs_encoder_info::get_extra_data obs_encoder_info::sei_data obs_encoder_info::get_sei_data obs_encoder_info::audio_info obs_encoder_info::get_audio_info obs_encoder_info::video_info obs_encoder_info::get_video_fino obs_service_info::defaults obs_service_info::get_defaults obs_service_info::properties obs_service_info::get_properties
2014-08-04 21:27:52 -07:00
.id = "coreaudio_input_capture",
.type = OBS_SOURCE_TYPE_INPUT,
.output_flags = OBS_SOURCE_AUDIO,
.get_name = coreaudio_input_getname,
.create = coreaudio_create_input_capture,
.destroy = coreaudio_destroy,
.get_defaults = coreaudio_defaults,
.get_properties = coreaudio_input_properties
Split output/input audio capture sources - Split input and output audio captures so that they're different sources. This allows easier handling and enumeration of audio devices without having to do some sort of string processing. This way the user interface code can handle this a bit more easily, and so that it doesn't confuse users either. This should be done for all audio capture sources for all operating systems. You don't have to duplicate any code, you just need to create input/output wrapper functions to designate the audio as input or output before creation. - Make it detect soundflower and wavtap devices as mac "output" devices (even though they're actually input) for the mac output capture, and make it so that users can select a default output capture and automatically use soundflower or wavtap. I'm not entirely happy about having to do this, but because mac is designed this way, this is really the only way to handle it that makes it easier for users and UI code to deal with. Note that soundflower and wavtap are still also designated as input devices, so will still show up in input device enumeration. - Remove pragma messages because they were kind polluting the other compiler messages and just getting in the way. In the future we can just do a grep for TODO to find them. - Redo list property again, this time using a safer internal array, rather than requiring sketchy array inputs. Having functions handle everything behind the scenes is much safer. - Remove the reference counter debug log code, as it was included unintentionally in a commit.
2014-03-03 01:56:54 -08:00
};
struct obs_source_info coreaudio_output_capture_info = {
(API Change) Use 'get' convention: API callbacks Renamed: To: ------------------------------------------------------- obs_source_info::defaults obs_source_info::get_defaults obs_source_info::properties obs_source_info::get_properties obs_output_info::defaults obs_output_info::get_defaults obs_output_info::properties obs_output_info::get_properties obs_output_info::total_bytes obs_output_info::get_total_bytes obs_output_info::dropped_frames obs_output_info::get_dropped_frames obs_encoder_info::defaults obs_encoder_info::get_defaults obs_encoder_info::properties obs_encoder_info::get_properties obs_encoder_info::extra_data obs_encoder_info::get_extra_data obs_encoder_info::sei_data obs_encoder_info::get_sei_data obs_encoder_info::audio_info obs_encoder_info::get_audio_info obs_encoder_info::video_info obs_encoder_info::get_video_fino obs_service_info::defaults obs_service_info::get_defaults obs_service_info::properties obs_service_info::get_properties
2014-08-04 21:27:52 -07:00
.id = "coreaudio_output_capture",
.type = OBS_SOURCE_TYPE_INPUT,
.output_flags = OBS_SOURCE_AUDIO,
.get_name = coreaudio_output_getname,
.create = coreaudio_create_output_capture,
.destroy = coreaudio_destroy,
.get_defaults = coreaudio_defaults,
.get_properties = coreaudio_output_properties
Add mac audio capture - Add CoreAudio device input capture for mac audio capturing. The code should cover just about everything for capturing mac input device audio. Because of the way mac audio is designed, users may have no choice but to obtain the open source soundflower software to capture their mac's desktop audio. It may be necessary for us to distribute it with the program as well. - Hide event backend - Use win32 events for windows - Allow timed waits for events - Fix a few warnings
2014-02-26 22:43:31 -08:00
};