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

809 lines
20 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;
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -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
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_source_t *source;
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
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
}
mac-capture: Don't call CFRelease on null vars CFRelease is not meant to be used with null variables. Check the variables before calling CFRelease.
2015-08-03 00:08:03 -07:00
if (cf_uid)
CFRelease(cf_uid);
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 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;
mac-capture: If channels above 8, force to stereo Certain devices (particularly certain mixers and soundflower 64ch) would have an arbitrary number of channels, and wouldn't really be mappable to a specific speaker layout supported by libobs. So to fix this issue, if the channel count is above 8, force the data to stereo to ensure playback can still occur, rather than cause it to just fail.
2015-03-18 19:22:37 -07:00
/* Certain types of devices have no limit on channel count, and
* there's no way to know the actual number of channels it's using,
* so if we encounter this situation just force to stereo */
if (desc.mChannelsPerFrame > 8) {
desc.mChannelsPerFrame = 2;
desc.mBytesPerFrame = 2 * desc.mBitsPerChannel / 8;
desc.mBytesPerPacket =
desc.mFramesPerPacket * desc.mBytesPerFrame;
}
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, 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);
mac-capture: Don't call CFRelease on null vars CFRelease is not meant to be used with null variables. Check the variables before calling CFRelease.
2015-08-03 00:08:03 -07:00
if (cf_name)
CFRelease(cf_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 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;
}
/* ------------------------------------------------------------------------- */
(API Change) libobs: Pass type data to get_name callbacks API changed from: obs_source_info::get_name(void) obs_output_info::get_name(void) obs_encoder_info::get_name(void) obs_service_info::get_name(void) API changed to: obs_source_info::get_name(void *type_data) obs_output_info::get_name(void *type_data) obs_encoder_info::get_name(void *type_data) obs_service_info::get_name(void *type_data) This allows the type data to be used when getting the name of the object (useful for plugin wrappers primarily). NOTE: Though a parameter was added, this is backward-compatible with older plugins due to calling convention. The new parameter will simply be ignored by older plugins, and the stack (if used) will be cleaned up by the caller.
2015-09-16 01:30:51 -07:00
static const char *coreaudio_input_getname(void *unused)
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
{
(API Change) libobs: Pass type data to get_name callbacks API changed from: obs_source_info::get_name(void) obs_output_info::get_name(void) obs_encoder_info::get_name(void) obs_service_info::get_name(void) API changed to: obs_source_info::get_name(void *type_data) obs_output_info::get_name(void *type_data) obs_encoder_info::get_name(void *type_data) obs_service_info::get_name(void *type_data) This allows the type data to be used when getting the name of the object (useful for plugin wrappers primarily). NOTE: Though a parameter was added, this is backward-compatible with older plugins due to calling convention. The new parameter will simply be ignored by older plugins, and the stack (if used) will be cleaned up by the caller.
2015-09-16 01:30:51 -07:00
UNUSED_PARAMETER(unused);
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
}
(API Change) libobs: Pass type data to get_name callbacks API changed from: obs_source_info::get_name(void) obs_output_info::get_name(void) obs_encoder_info::get_name(void) obs_service_info::get_name(void) API changed to: obs_source_info::get_name(void *type_data) obs_output_info::get_name(void *type_data) obs_encoder_info::get_name(void *type_data) obs_service_info::get_name(void *type_data) This allows the type data to be used when getting the name of the object (useful for plugin wrappers primarily). NOTE: Though a parameter was added, this is backward-compatible with older plugins due to calling convention. The new parameter will simply be ignored by older plugins, and the stack (if used) will be cleaned up by the caller.
2015-09-16 01:30:51 -07:00
static const char *coreaudio_output_getname(void *unused)
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
{
(API Change) libobs: Pass type data to get_name callbacks API changed from: obs_source_info::get_name(void) obs_output_info::get_name(void) obs_encoder_info::get_name(void) obs_service_info::get_name(void) API changed to: obs_source_info::get_name(void *type_data) obs_output_info::get_name(void *type_data) obs_encoder_info::get_name(void *type_data) obs_service_info::get_name(void *type_data) This allows the type data to be used when getting the name of the object (useful for plugin wrappers primarily). NOTE: Though a parameter was added, this is backward-compatible with older plugins due to calling convention. The new parameter will simply be ignored by older plugins, and the stack (if used) will be cleaned up by the caller.
2015-09-16 01:30:51 -07:00
UNUSED_PARAMETER(unused);
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
}
mac-capture: Separate audio shudown code This allows the code to be used elsewhere as needed.
2015-02-20 21:49:51 -08:00
static void coreaudio_shutdown(struct coreaudio_data *ca)
{
if (ca->reconnecting) {
os_event_signal(ca->exit_event);
pthread_join(ca->reconnect_thread, NULL);
os_event_reset(ca->exit_event);
}
coreaudio_uninit(ca);
if (ca->unit)
AudioComponentInstanceDispose(ca->unit);
}
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) {
mac-capture: Separate audio shudown code This allows the code to be used elsewhere as needed.
2015-02-20 21:49:51 -08:00
coreaudio_shutdown(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
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);
}
}
mac-capture: Add update callbacks for coreaudio Somehow managed to forget to add this function at an earlier point. Allows the audio device to be changed via a simple update.
2015-02-20 21:51:00 -08:00
static void coreaudio_update(void *data, obs_data_t *settings)
{
struct coreaudio_data *ca = data;
coreaudio_shutdown(ca);
bfree(ca->device_uid);
ca->device_uid = bstrdup(obs_data_get_string(settings, "device_id"));
coreaudio_try_init(ca);
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
static void coreaudio_defaults(obs_data_t *settings)
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
{
obs_data_set_default_string(settings, "device_id", "default");
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
static void *coreaudio_create(obs_data_t *settings, 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
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;
}
(API Change) Unsquish obs_data_* names Changed: To: ----------------------------------------------- obs_data_getjson obs_data_get_json obs_data_getstring obs_data_get_string obs_data_getint obs_data_get_int obs_data_getdouble obs_data_get_double obs_data_getbool obs_data_get_bool obs_data_getobj obs_data_get_obj obs_data_getarray obs_data_get_array obs_data_setstring obs_data_set_string obs_data_setint obs_data_set_int obs_data_setdouble obs_data_set_double obs_data_setbool obs_data_set_bool obs_data_setobj obs_data_set_obj obs_data_setarray obs_data_set_array obs_data_item_getstring obs_data_item_get_string obs_data_item_getint obs_data_item_get_int obs_data_item_getdouble obs_data_item_get_double obs_data_item_getbool obs_data_item_get_bool obs_data_item_getobj obs_data_item_get_obj obs_data_item_getarray obs_data_item_get_array obs_data_item_setstring obs_data_item_set_string obs_data_item_setint obs_data_item_set_int obs_data_item_setdouble obs_data_item_set_double obs_data_item_setbool obs_data_item_set_bool obs_data_item_setobj obs_data_item_set_obj obs_data_item_setarray obs_data_item_set_array
2014-08-05 11:09:29 -07:00
ca->device_uid = bstrdup(obs_data_get_string(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;
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
static void *coreaudio_create_input_capture(obs_data_t *settings,
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
{
return coreaudio_create(settings, source, true);
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
static void *coreaudio_create_output_capture(obs_data_t *settings,
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
{
return coreaudio_create(settings, source, false);
}
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -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
{
(API Change) Remove pointers from all typedefs Typedef pointers are unsafe. If you do: typedef struct bla *bla_t; then you cannot use it as a constant, such as: const bla_t, because that constant will be to the pointer itself rather than to the underlying data. I admit this was a fundamental mistake that must be corrected. All typedefs that were pointer types will now have their pointers removed from the type itself, and the pointers will be used when they are actually used as variables/parameters/returns instead. This does not break ABI though, which is pretty nice.
2014-09-25 17:44:05 -07:00
obs_properties_t *props = obs_properties_create();
obs_property_t *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
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;
}
(API Change) Pass data to get_properties when possible
2014-09-29 08:36:13 -07:00
static obs_properties_t *coreaudio_input_properties(void *unused)
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
{
(API Change) Pass data to get_properties when possible
2014-09-29 08:36:13 -07:00
UNUSED_PARAMETER(unused);
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
}
(API Change) Pass data to get_properties when possible
2014-09-29 08:36:13 -07:00
static obs_properties_t *coreaudio_output_properties(void *unused)
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
{
(API Change) Pass data to get_properties when possible
2014-09-29 08:36:13 -07:00
UNUSED_PARAMETER(unused);
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,
libobs: Add source output flag OBS_SOURCE_DO_NOT_DUPLICATE Certain types of sources (display captures, game captures, audio device captures, video device captures) should not be duplicated. This capability flag hints that the source prefers references over full duplication.
2016-01-12 16:25:47 -08:00
.output_flags = OBS_SOURCE_AUDIO |
OBS_SOURCE_DO_NOT_DUPLICATE,
(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
.get_name = coreaudio_input_getname,
.create = coreaudio_create_input_capture,
.destroy = coreaudio_destroy,
mac-capture: Add update callbacks for coreaudio Somehow managed to forget to add this function at an earlier point. Allows the audio device to be changed via a simple update.
2015-02-20 21:51:00 -08:00
.update = coreaudio_update,
(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
.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,
libobs: Add source output flag OBS_SOURCE_DO_NOT_DUPLICATE Certain types of sources (display captures, game captures, audio device captures, video device captures) should not be duplicated. This capability flag hints that the source prefers references over full duplication.
2016-01-12 16:25:47 -08:00
.output_flags = OBS_SOURCE_AUDIO |
win-wasapi: Mark audio outputs as unmonitorable (Note: This commit also modifies mac-capture and linux-pulseaudio) This prevents outputs from being monitored, preventing a potential feedback loop.
2017-02-05 21:44:16 -08:00
OBS_SOURCE_DO_NOT_DUPLICATE |
OBS_SOURCE_DO_NOT_MONITOR,
(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
.get_name = coreaudio_output_getname,
.create = coreaudio_create_output_capture,
.destroy = coreaudio_destroy,
mac-capture: Add update callbacks for coreaudio Somehow managed to forget to add this function at an earlier point. Allows the audio device to be changed via a simple update.
2015-02-20 21:51:00 -08:00
.update = coreaudio_update,
(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
.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
};