* Moved general multi_audio functions into their own file MultiAudioUtility.cpp;
they don't really belong to the MultiAudioDevice class. * Major coding style cleanup, part I - no functional change, I hope :-) git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24578 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler
@@ -12,6 +12,7 @@ Addon hmulti_audio.media_addon :
|
||||
MultiAudioAddOn.cpp
|
||||
MultiAudioDevice.cpp
|
||||
MultiAudioNode.cpp
|
||||
MultiAudioUtility.cpp
|
||||
: be media
|
||||
;
|
||||
|
||||
|
||||
@@ -26,15 +26,18 @@
|
||||
|
||||
#define MULTI_SAVE
|
||||
|
||||
// instantiation function
|
||||
extern "C" _EXPORT BMediaAddOn * make_media_addon(image_id image) {
|
||||
|
||||
//! instantiation function
|
||||
extern "C" BMediaAddOn*
|
||||
make_media_addon(image_id image)
|
||||
{
|
||||
CALLED();
|
||||
return new MultiAudioAddOn(image);
|
||||
}
|
||||
|
||||
// -------------------------------------------------------- //
|
||||
// ctor/dtor
|
||||
// -------------------------------------------------------- //
|
||||
|
||||
// #pragma mark -
|
||||
|
||||
|
||||
MultiAudioAddOn::~MultiAudioAddOn()
|
||||
{
|
||||
@@ -47,8 +50,9 @@ MultiAudioAddOn::~MultiAudioAddOn()
|
||||
SaveSettings();
|
||||
}
|
||||
|
||||
MultiAudioAddOn::MultiAudioAddOn(image_id image) :
|
||||
BMediaAddOn(image),
|
||||
|
||||
MultiAudioAddOn::MultiAudioAddOn(image_id image)
|
||||
: BMediaAddOn(image),
|
||||
fDevices()
|
||||
{
|
||||
CALLED();
|
||||
@@ -66,80 +70,78 @@ MultiAudioAddOn::MultiAudioAddOn(image_id image) :
|
||||
// BMediaAddOn impl
|
||||
// -------------------------------------------------------- //
|
||||
|
||||
status_t MultiAudioAddOn::InitCheck(
|
||||
const char ** out_failure_text)
|
||||
status_t
|
||||
MultiAudioAddOn::InitCheck(const char** _failureText)
|
||||
{
|
||||
CALLED();
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
int32 MultiAudioAddOn::CountFlavors()
|
||||
|
||||
int32
|
||||
MultiAudioAddOn::CountFlavors()
|
||||
{
|
||||
CALLED();
|
||||
return fDevices.CountItems();
|
||||
}
|
||||
|
||||
status_t MultiAudioAddOn::GetFlavorAt(
|
||||
int32 n,
|
||||
const flavor_info ** out_info)
|
||||
|
||||
status_t
|
||||
MultiAudioAddOn::GetFlavorAt(int32 n, const flavor_info** _info)
|
||||
{
|
||||
CALLED();
|
||||
if (out_info == 0) {
|
||||
fprintf(stderr, "<- B_BAD_VALUE\n");
|
||||
return B_BAD_VALUE; // we refuse to crash because you were stupid
|
||||
}
|
||||
if (n < 0 || n > fDevices.CountItems() - 1) {
|
||||
fprintf(stderr, "<- B_BAD_INDEX\n");
|
||||
if (_info == NULL)
|
||||
return B_BAD_VALUE;
|
||||
|
||||
MultiAudioDevice* device = (MultiAudioDevice*)fDevices.ItemAt(n);
|
||||
if (device == NULL)
|
||||
return B_BAD_INDEX;
|
||||
}
|
||||
|
||||
MultiAudioDevice *device = (MultiAudioDevice *) fDevices.ItemAt(n);
|
||||
flavor_info* info = new (std::nothrow) flavor_info;
|
||||
if (info == NULL)
|
||||
return B_NO_MEMORY;
|
||||
|
||||
flavor_info * infos = new flavor_info[1];
|
||||
MultiAudioNode::GetFlavor(&infos[0], n);
|
||||
infos[0].name = device->MD.friendly_name;
|
||||
(*out_info) = infos;
|
||||
MultiAudioNode::GetFlavor(info, n);
|
||||
info->name = (char*)device->Description().friendly_name;
|
||||
|
||||
*_info = info;
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
BMediaNode * MultiAudioAddOn::InstantiateNodeFor(
|
||||
const flavor_info * info,
|
||||
BMessage * config,
|
||||
status_t * out_error)
|
||||
|
||||
BMediaNode*
|
||||
MultiAudioAddOn::InstantiateNodeFor(const flavor_info* info, BMessage* config,
|
||||
status_t* _error)
|
||||
{
|
||||
CALLED();
|
||||
if (out_error == 0) {
|
||||
fprintf(stderr, "<- NULL\n");
|
||||
return 0; // we refuse to crash because you were stupid
|
||||
}
|
||||
if (_error == NULL)
|
||||
return NULL;
|
||||
|
||||
MultiAudioDevice *device = (MultiAudioDevice*)fDevices.ItemAt(info->internal_id);
|
||||
MultiAudioDevice* device = (MultiAudioDevice*)fDevices.ItemAt(
|
||||
info->internal_id);
|
||||
if (device == NULL) {
|
||||
*out_error = B_ERROR;
|
||||
*_error = B_ERROR;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
#ifdef MULTI_SAVE
|
||||
if (fSettings.FindMessage(device->MD.friendly_name, config) == B_OK) {
|
||||
fSettings.RemoveData(device->MD.friendly_name);
|
||||
if (fSettings.FindMessage(device->Description().friendly_name, config)
|
||||
== B_OK) {
|
||||
fSettings.RemoveData(device->Description().friendly_name);
|
||||
}
|
||||
#endif
|
||||
|
||||
MultiAudioNode * node =
|
||||
new MultiAudioNode(this,
|
||||
device->MD.friendly_name,
|
||||
device,
|
||||
info->internal_id,
|
||||
config);
|
||||
if (node == 0) {
|
||||
*out_error = B_NO_MEMORY;
|
||||
fprintf(stderr, "<- B_NO_MEMORY\n");
|
||||
} else {
|
||||
*out_error = node->InitCheck();
|
||||
}
|
||||
MultiAudioNode* node = new (std::nothrow) MultiAudioNode(this,
|
||||
device->Description().friendly_name, device, info->internal_id, config);
|
||||
if (node == NULL)
|
||||
*_error = B_NO_MEMORY;
|
||||
else
|
||||
*_error = node->InitCheck();
|
||||
|
||||
return node;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
MultiAudioAddOn::GetConfigurationFor(BMediaNode * your_node, BMessage * into_message)
|
||||
{
|
||||
@@ -172,47 +174,48 @@ MultiAudioAddOn::GetConfigurationFor(BMediaNode * your_node, BMessage * into_mes
|
||||
}
|
||||
|
||||
|
||||
bool MultiAudioAddOn::WantsAutoStart()
|
||||
bool
|
||||
MultiAudioAddOn::WantsAutoStart()
|
||||
{
|
||||
CALLED();
|
||||
return false;
|
||||
}
|
||||
|
||||
status_t MultiAudioAddOn::AutoStart(
|
||||
int in_count,
|
||||
BMediaNode ** out_node,
|
||||
int32 * out_internal_id,
|
||||
bool * out_has_more)
|
||||
|
||||
status_t
|
||||
MultiAudioAddOn::AutoStart(int count, BMediaNode** _node, int32* _internalID,
|
||||
bool* _hasMore)
|
||||
{
|
||||
CALLED();
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
MultiAudioAddOn::RecursiveScan(char* rootPath, BEntry *rootEntry)
|
||||
MultiAudioAddOn::RecursiveScan(char* rootPath, BEntry* rootEntry)
|
||||
{
|
||||
CALLED();
|
||||
|
||||
BDirectory root;
|
||||
if (rootEntry != NULL)
|
||||
root.SetTo(rootEntry);
|
||||
else if (rootPath != NULL) {
|
||||
else if (rootPath != NULL)
|
||||
root.SetTo(rootPath);
|
||||
} else {
|
||||
PRINT(("Error in MultiAudioAddOn::RecursiveScan null params\n"));
|
||||
else {
|
||||
PRINT(("Error in MultiAudioAddOn::RecursiveScan() null params\n"));
|
||||
return B_ERROR;
|
||||
}
|
||||
|
||||
BEntry entry;
|
||||
|
||||
while (root.GetNextEntry(&entry) > B_ERROR) {
|
||||
|
||||
if (entry.IsDirectory()) {
|
||||
RecursiveScan(rootPath, &entry);
|
||||
} else {
|
||||
BPath path;
|
||||
entry.GetPath(&path);
|
||||
MultiAudioDevice *device = new MultiAudioDevice(path.Path() + strlen(rootPath), path.Path());
|
||||
MultiAudioDevice *device = new MultiAudioDevice(path.Path()
|
||||
+ strlen(rootPath), path.Path());
|
||||
if (device) {
|
||||
if (device->InitCheck() == B_OK)
|
||||
fDevices.AddItem(device);
|
||||
@@ -227,7 +230,7 @@ MultiAudioAddOn::RecursiveScan(char* rootPath, BEntry *rootEntry)
|
||||
|
||||
|
||||
void
|
||||
MultiAudioAddOn::SaveSettings(void)
|
||||
MultiAudioAddOn::SaveSettings()
|
||||
{
|
||||
CALLED();
|
||||
BPath path;
|
||||
@@ -241,7 +244,7 @@ MultiAudioAddOn::SaveSettings(void)
|
||||
|
||||
|
||||
void
|
||||
MultiAudioAddOn::LoadSettings(void)
|
||||
MultiAudioAddOn::LoadSettings()
|
||||
{
|
||||
CALLED();
|
||||
fSettings.MakeEmpty();
|
||||
|
||||
@@ -3,343 +3,232 @@
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
|
||||
#include "MultiAudioDevice.h"
|
||||
#include "debug.h"
|
||||
#include "driver_io.h"
|
||||
#include <MediaDefs.h>
|
||||
|
||||
#include <errno.h>
|
||||
#include <string.h>
|
||||
|
||||
float SAMPLE_RATES[] = {
|
||||
8000.0, 11025.0, 12000.0, 16000.0, 22050.0, 24000.0, 32000.0, 44100.0,
|
||||
48000.0, 64000.0, 88200.0, 96000.0, 176400.0, 192000.0, 384000.0, 1536000.0
|
||||
};
|
||||
#include <MediaDefs.h>
|
||||
|
||||
#include "debug.h"
|
||||
#include "MultiAudioUtility.h"
|
||||
|
||||
|
||||
float MultiAudioDevice::convert_multiaudio_rate_to_media_rate(uint32 rate)
|
||||
using namespace MultiAudio;
|
||||
|
||||
|
||||
MultiAudioDevice::MultiAudioDevice(const char* name, const char* path)
|
||||
{
|
||||
uint8 count = 0;
|
||||
uint8 size = sizeof(SAMPLE_RATES) / sizeof(SAMPLE_RATES[0]);
|
||||
while (count < size) {
|
||||
if (rate & 1)
|
||||
return SAMPLE_RATES[count];
|
||||
count++;
|
||||
rate >>= 1;
|
||||
}
|
||||
return 0.0;
|
||||
CALLED();
|
||||
|
||||
strlcpy(fPath, path, B_PATH_NAME_LENGTH);
|
||||
PRINT(("name: %s, path: %s\n", name, fPath));
|
||||
|
||||
fInitStatus = _InitDriver();
|
||||
}
|
||||
|
||||
|
||||
uint32 MultiAudioDevice::convert_media_rate_to_multiaudio_rate(float rate)
|
||||
{
|
||||
uint8 count = 0;
|
||||
uint size = sizeof(SAMPLE_RATES) / sizeof(SAMPLE_RATES[0]);
|
||||
while (count < size) {
|
||||
if (rate <= SAMPLE_RATES[count])
|
||||
return (0x1 << count);
|
||||
count++;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
uint32 MultiAudioDevice::convert_multiaudio_format_to_media_format(uint32 fmt)
|
||||
{
|
||||
switch (fmt) {
|
||||
case B_FMT_FLOAT:
|
||||
return media_raw_audio_format::B_AUDIO_FLOAT;
|
||||
case B_FMT_18BIT:
|
||||
case B_FMT_20BIT:
|
||||
case B_FMT_24BIT:
|
||||
case B_FMT_32BIT:
|
||||
return media_raw_audio_format::B_AUDIO_INT;
|
||||
case B_FMT_16BIT:
|
||||
return media_raw_audio_format::B_AUDIO_SHORT;
|
||||
case B_FMT_8BIT_S:
|
||||
return media_raw_audio_format::B_AUDIO_CHAR;
|
||||
case B_FMT_8BIT_U:
|
||||
return media_raw_audio_format::B_AUDIO_UCHAR;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int16 MultiAudioDevice::convert_multiaudio_format_to_valid_bits(uint32 fmt)
|
||||
{
|
||||
switch (fmt) {
|
||||
case B_FMT_18BIT:
|
||||
return 18;
|
||||
case B_FMT_20BIT:
|
||||
return 20;
|
||||
case B_FMT_24BIT:
|
||||
return 24;
|
||||
case B_FMT_32BIT:
|
||||
return 32;
|
||||
default: {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
uint32 MultiAudioDevice::convert_media_format_to_multiaudio_format(uint32 fmt)
|
||||
{
|
||||
switch (fmt) {
|
||||
case media_raw_audio_format::B_AUDIO_FLOAT:
|
||||
return B_FMT_FLOAT;
|
||||
case media_raw_audio_format::B_AUDIO_INT:
|
||||
return B_FMT_32BIT;
|
||||
case media_raw_audio_format::B_AUDIO_SHORT:
|
||||
return B_FMT_16BIT;
|
||||
case media_raw_audio_format::B_AUDIO_CHAR:
|
||||
return B_FMT_8BIT_S;
|
||||
case media_raw_audio_format::B_AUDIO_UCHAR:
|
||||
return B_FMT_8BIT_U;
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
uint32 MultiAudioDevice::select_multiaudio_rate(uint32 rate)
|
||||
{
|
||||
//highest rate
|
||||
uint32 crate = B_SR_1536000;
|
||||
while (crate != 0) {
|
||||
if (rate & crate)
|
||||
return crate;
|
||||
crate >>= 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
uint32 MultiAudioDevice::select_multiaudio_format(uint32 fmt)
|
||||
{
|
||||
//highest format
|
||||
if (fmt & B_FMT_FLOAT) {
|
||||
return B_FMT_FLOAT;
|
||||
} else if (fmt & B_FMT_32BIT) {
|
||||
return B_FMT_32BIT;
|
||||
} else if (fmt & B_FMT_24BIT) {
|
||||
return B_FMT_24BIT;
|
||||
} else if (fmt & B_FMT_20BIT) {
|
||||
return B_FMT_20BIT;
|
||||
} else if (fmt & B_FMT_18BIT) {
|
||||
return B_FMT_18BIT;
|
||||
} else if (fmt & B_FMT_16BIT) {
|
||||
return B_FMT_16BIT;
|
||||
} else if (fmt & B_FMT_8BIT_S) {
|
||||
return B_FMT_8BIT_S;
|
||||
} else if (fmt & B_FMT_8BIT_U) {
|
||||
return B_FMT_8BIT_U;
|
||||
} else
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
MultiAudioDevice::~MultiAudioDevice()
|
||||
{
|
||||
CALLED();
|
||||
if (fd != 0) {
|
||||
close(fd);
|
||||
}
|
||||
}
|
||||
|
||||
MultiAudioDevice::MultiAudioDevice(const char* name, const char* path)
|
||||
{
|
||||
CALLED();
|
||||
fInitCheckStatus = B_NO_INIT;
|
||||
|
||||
strcpy(fDevice_name, name);
|
||||
strcpy(fDevice_path, path);
|
||||
|
||||
PRINT(("name : %s, path : %s\n", fDevice_name, fDevice_path));
|
||||
|
||||
if (InitDriver() != B_OK)
|
||||
return;
|
||||
|
||||
fInitCheckStatus = B_OK;
|
||||
if (fDevice >= 0)
|
||||
close(fDevice);
|
||||
}
|
||||
|
||||
|
||||
status_t MultiAudioDevice::InitCheck(void) const
|
||||
status_t
|
||||
MultiAudioDevice::InitCheck() const
|
||||
{
|
||||
CALLED();
|
||||
return fInitCheckStatus;
|
||||
return fInitStatus;
|
||||
}
|
||||
|
||||
|
||||
status_t MultiAudioDevice::InitDriver()
|
||||
status_t
|
||||
MultiAudioDevice::_InitDriver()
|
||||
{
|
||||
multi_channel_enable MCE;
|
||||
uint32 mce_enable_bits;
|
||||
int rval, i, num_outputs, num_inputs, num_channels;
|
||||
int num_outputs, num_inputs, num_channels;
|
||||
|
||||
CALLED();
|
||||
|
||||
//open the device driver for output
|
||||
fd = open(fDevice_path, O_WRONLY);
|
||||
// open the device driver
|
||||
|
||||
if (fd == -1) {
|
||||
fprintf(stderr, "Failed to open %s: %s\n", fDevice_path, strerror(errno));
|
||||
fDevice = open(fPath, O_WRONLY);
|
||||
if (fDevice == -1) {
|
||||
fprintf(stderr, "Failed to open %s: %s\n", fPath, strerror(errno));
|
||||
return B_ERROR;
|
||||
}
|
||||
|
||||
//
|
||||
// Get description
|
||||
//
|
||||
MD.info_size = sizeof(MD);
|
||||
MD.request_channel_count = MAX_CHANNELS;
|
||||
MD.channels = MCI;
|
||||
rval = DRIVER_GET_DESCRIPTION(&MD, 0);
|
||||
if (B_OK != rval)
|
||||
{
|
||||
fprintf(stderr, "Failed on B_MULTI_GET_DESCRIPTION\n");
|
||||
return B_ERROR;
|
||||
|
||||
fDescription.info_size = sizeof(fDescription);
|
||||
fDescription.request_channel_count = MAX_CHANNELS;
|
||||
fDescription.channels = fChannelInfo;
|
||||
status_t status = get_description(fDevice, &fDescription);
|
||||
if (status != B_OK) {
|
||||
fprintf(stderr, "Failed on B_MULTI_GET_DESCRIPTION: %s\n",
|
||||
strerror(status));
|
||||
return status;
|
||||
}
|
||||
|
||||
PRINT(("Friendly name:\t%s\nVendor:\t\t%s\n",
|
||||
MD.friendly_name, MD.vendor_info));
|
||||
fDescription.friendly_name, fDescription.vendor_info));
|
||||
PRINT(("%ld outputs\t%ld inputs\n%ld out busses\t%ld in busses\n",
|
||||
MD.output_channel_count, MD.input_channel_count,
|
||||
MD.output_bus_channel_count, MD.input_bus_channel_count));
|
||||
fDescription.output_channel_count, fDescription.input_channel_count,
|
||||
fDescription.output_bus_channel_count,
|
||||
fDescription.input_bus_channel_count));
|
||||
PRINT(("\nChannels\n"
|
||||
"ID\tKind\tDesig\tConnectors\n"));
|
||||
|
||||
for (i = 0 ; i < (MD.output_channel_count + MD.input_channel_count); i++)
|
||||
{
|
||||
PRINT(("%ld\t%d\t0x%lx\t0x%lx\n", MD.channels[i].channel_id,
|
||||
MD.channels[i].kind,
|
||||
MD.channels[i].designations,
|
||||
MD.channels[i].connectors));
|
||||
for (int32 i = 0; i < fDescription.output_channel_count
|
||||
+ fDescription.input_channel_count; i++) {
|
||||
PRINT(("%ld\t%d\t0x%lx\t0x%lx\n", fDescription.channels[i].channel_id,
|
||||
fDescription.channels[i].kind,
|
||||
fDescription.channels[i].designations,
|
||||
fDescription.channels[i].connectors));
|
||||
}
|
||||
PRINT(("\n"));
|
||||
|
||||
PRINT(("Output rates\t\t0x%lx\n", MD.output_rates));
|
||||
PRINT(("Input rates\t\t0x%lx\n", MD.input_rates));
|
||||
PRINT(("Max CVSR\t\t%.0f\n", MD.max_cvsr_rate));
|
||||
PRINT(("Min CVSR\t\t%.0f\n", MD.min_cvsr_rate));
|
||||
PRINT(("Output formats\t\t0x%lx\n", MD.output_formats));
|
||||
PRINT(("Input formats\t\t0x%lx\n", MD.input_formats));
|
||||
PRINT(("Lock sources\t\t0x%lx\n", MD.lock_sources));
|
||||
PRINT(("Timecode sources\t0x%lx\n", MD.timecode_sources));
|
||||
PRINT(("Interface flags\t\t0x%lx\n", MD.interface_flags));
|
||||
PRINT(("Control panel string:\t\t%s\n", MD.control_panel));
|
||||
PRINT(("Output rates\t\t0x%lx\n", fDescription.output_rates));
|
||||
PRINT(("Input rates\t\t0x%lx\n", fDescription.input_rates));
|
||||
PRINT(("Max CVSR\t\t%.0f\n", fDescription.max_cvsr_rate));
|
||||
PRINT(("Min CVSR\t\t%.0f\n", fDescription.min_cvsr_rate));
|
||||
PRINT(("Output formats\t\t0x%lx\n", fDescription.output_formats));
|
||||
PRINT(("Input formats\t\t0x%lx\n", fDescription.input_formats));
|
||||
PRINT(("Lock sources\t\t0x%lx\n", fDescription.lock_sources));
|
||||
PRINT(("Timecode sources\t0x%lx\n", fDescription.timecode_sources));
|
||||
PRINT(("Interface flags\t\t0x%lx\n", fDescription.interface_flags));
|
||||
PRINT(("Control panel string:\t\t%s\n", fDescription.control_panel));
|
||||
PRINT(("\n"));
|
||||
|
||||
num_outputs = MD.output_channel_count;
|
||||
num_inputs = MD.input_channel_count;
|
||||
num_outputs = fDescription.output_channel_count;
|
||||
num_inputs = fDescription.input_channel_count;
|
||||
num_channels = num_outputs + num_inputs;
|
||||
|
||||
// Get and set enabled channels
|
||||
MCE.info_size = sizeof(MCE);
|
||||
MCE.enable_bits = (uchar *) & mce_enable_bits;
|
||||
rval = DRIVER_GET_ENABLED_CHANNELS(&MCE, sizeof(MCE));
|
||||
if (B_OK != rval)
|
||||
{
|
||||
fprintf(stderr, "Failed on B_MULTI_GET_ENABLED_CHANNELS len is 0x%lx\n", sizeof(MCE));
|
||||
return B_ERROR;
|
||||
|
||||
multi_channel_enable enable;
|
||||
uint32 enableBits;
|
||||
enable.info_size = sizeof(enable);
|
||||
enable.enable_bits = (uchar*)&enableBits;
|
||||
|
||||
status = get_enabled_channels(fDevice, &enable);
|
||||
if (status != B_OK) {
|
||||
fprintf(stderr, "Failed on B_MULTI_GET_ENABLED_CHANNELS: %s\n",
|
||||
strerror(status));
|
||||
return status;
|
||||
}
|
||||
|
||||
mce_enable_bits = (1 << num_channels) - 1;
|
||||
MCE.lock_source = B_MULTI_LOCK_INTERNAL;
|
||||
rval = DRIVER_SET_ENABLED_CHANNELS(&MCE, 0);
|
||||
if (B_OK != rval)
|
||||
{
|
||||
fprintf(stderr, "Failed on B_MULTI_SET_ENABLED_CHANNELS 0x%p 0x%x\n", MCE.enable_bits, *(MCE.enable_bits));
|
||||
return B_ERROR;
|
||||
enableBits = (1 << num_channels) - 1;
|
||||
enable.lock_source = B_MULTI_LOCK_INTERNAL;
|
||||
|
||||
status = set_enabled_channels(fDevice, &enable);
|
||||
if (status != B_OK) {
|
||||
fprintf(stderr, "Failed on B_MULTI_SET_ENABLED_CHANNELS 0x%x: %s\n",
|
||||
*enable.enable_bits, strerror(status));
|
||||
return status;
|
||||
}
|
||||
|
||||
//
|
||||
// Set the sample rate
|
||||
//
|
||||
MFI.info_size = sizeof(MFI);
|
||||
MFI.output.rate = select_multiaudio_rate(MD.output_rates);
|
||||
MFI.output.cvsr = 0;
|
||||
MFI.output.format = select_multiaudio_format(MD.output_formats);
|
||||
MFI.input.rate = MFI.output.rate;
|
||||
MFI.input.cvsr = MFI.output.cvsr;
|
||||
MFI.input.format = MFI.output.format;
|
||||
rval = DRIVER_SET_GLOBAL_FORMAT(&MFI, 0);
|
||||
if (B_OK != rval)
|
||||
{
|
||||
fprintf(stderr, "Failed on B_MULTI_SET_GLOBAL_FORMAT\n");
|
||||
return B_ERROR;
|
||||
|
||||
fFormatInfo.info_size = sizeof(multi_format_info);
|
||||
fFormatInfo.output.rate = select_sample_rate(fDescription.output_rates);
|
||||
fFormatInfo.output.cvsr = 0;
|
||||
fFormatInfo.output.format = select_format(fDescription.output_formats);
|
||||
fFormatInfo.input.rate = select_sample_rate(fDescription.input_rates);
|
||||
fFormatInfo.input.cvsr = fFormatInfo.output.cvsr;
|
||||
fFormatInfo.input.format = select_format(fDescription.input_formats);
|
||||
|
||||
status = set_global_format(fDevice, &fFormatInfo);
|
||||
if (status != B_OK) {
|
||||
fprintf(stderr, "Failed on B_MULTI_SET_GLOBAL_FORMAT: %s\n",
|
||||
strerror(status));
|
||||
#if 0
|
||||
}
|
||||
|
||||
status = get_global_format(fDevice, &fFormatInfo);
|
||||
if (status != B_OK) {
|
||||
fprintf(stderr, "Failed on B_MULTI_GET_GLOBAL_FORMAT: %s\n",
|
||||
strerror(status));
|
||||
#endif
|
||||
return status;
|
||||
}
|
||||
|
||||
//
|
||||
// Get the buffers
|
||||
//
|
||||
for (i = 0; i < NB_BUFFERS; i++) {
|
||||
play_buffer_desc[i] = &play_buffer_list[i * MAX_CHANNELS];
|
||||
record_buffer_desc[i] = &record_buffer_list[i * MAX_CHANNELS];
|
||||
|
||||
for (uint32 i = 0; i < MAX_BUFFERS; i++) {
|
||||
fPlayBuffers[i] = &fPlayBufferList[i * MAX_CHANNELS];
|
||||
fRecordBuffers[i] = &fRecordBufferList[i * MAX_CHANNELS];
|
||||
}
|
||||
MBL.info_size = sizeof(MBL);
|
||||
MBL.request_playback_buffer_size = 0; //use the default......
|
||||
MBL.request_playback_buffers = NB_BUFFERS;
|
||||
MBL.request_playback_channels = num_outputs;
|
||||
MBL.playback_buffers = (buffer_desc **) play_buffer_desc;
|
||||
MBL.request_record_buffer_size = 0; //use the default......
|
||||
MBL.request_record_buffers = NB_BUFFERS;
|
||||
MBL.request_record_channels = num_inputs;
|
||||
MBL.record_buffers = (buffer_desc **) record_buffer_desc;
|
||||
fBufferList.info_size = sizeof(multi_buffer_list);
|
||||
fBufferList.request_playback_buffer_size = 0;
|
||||
// use the default...
|
||||
fBufferList.request_playback_buffers = MAX_BUFFERS;
|
||||
fBufferList.request_playback_channels = num_outputs;
|
||||
fBufferList.playback_buffers = (buffer_desc **) fPlayBuffers;
|
||||
fBufferList.request_record_buffer_size = 0;
|
||||
// use the default...
|
||||
fBufferList.request_record_buffers = MAX_BUFFERS;
|
||||
fBufferList.request_record_channels = num_inputs;
|
||||
fBufferList.record_buffers = /*(buffer_desc **)*/ fRecordBuffers;
|
||||
|
||||
rval = DRIVER_GET_BUFFERS(&MBL, 0);
|
||||
|
||||
if (B_OK != rval)
|
||||
{
|
||||
fprintf(stderr, "Failed on B_MULTI_GET_BUFFERS\n");
|
||||
return B_ERROR;
|
||||
status = get_buffers(fDevice, &fBufferList);
|
||||
if (status != B_OK) {
|
||||
fprintf(stderr, "Failed on B_MULTI_GET_BUFFERS: %s\n",
|
||||
strerror(status));
|
||||
return status;
|
||||
}
|
||||
|
||||
for (i = 0; i < MBL.return_playback_buffers; i++)
|
||||
for (int j = 0; j < MBL.return_playback_channels; j++) {
|
||||
PRINT(("MBL.playback_buffers[%d][%d].base: %p\n",
|
||||
i, j, MBL.playback_buffers[i][j].base));
|
||||
PRINT(("MBL.playback_buffers[%d][%d].stride: %i\n",
|
||||
i, j, MBL.playback_buffers[i][j].stride));
|
||||
for (int32 i = 0; i < fBufferList.return_playback_buffers; i++) {
|
||||
for (int32 j = 0; j < fBufferList.return_playback_channels; j++) {
|
||||
PRINT(("fBufferList.playback_buffers[%d][%d].base: %p\n",
|
||||
i, j, fBufferList.playback_buffers[i][j].base));
|
||||
PRINT(("fBufferList.playback_buffers[%d][%d].stride: %i\n",
|
||||
i, j, fBufferList.playback_buffers[i][j].stride));
|
||||
}
|
||||
}
|
||||
|
||||
for (i = 0; i < MBL.return_record_buffers; i++)
|
||||
for (int j = 0; j < MBL.return_record_channels; j++) {
|
||||
PRINT(("MBL.record_buffers[%d][%d].base: %p\n",
|
||||
i, j, MBL.record_buffers[i][j].base));
|
||||
PRINT(("MBL.record_buffers[%d][%d].stride: %i\n",
|
||||
i, j, MBL.record_buffers[i][j].stride));
|
||||
for (int32 i = 0; i < fBufferList.return_record_buffers; i++) {
|
||||
for (int32 j = 0; j < fBufferList.return_record_channels; j++) {
|
||||
PRINT(("fBufferList.record_buffers[%d][%d].base: %p\n",
|
||||
i, j, fBufferList.record_buffers[i][j].base));
|
||||
PRINT(("fBufferList.record_buffers[%d][%d].stride: %i\n",
|
||||
i, j, fBufferList.record_buffers[i][j].stride));
|
||||
}
|
||||
}
|
||||
|
||||
MMCI.info_size = sizeof(MMCI);
|
||||
MMCI.control_count = MAX_CONTROLS;
|
||||
MMCI.controls = MMC;
|
||||
fMixControlInfo.info_size = sizeof(fMixControlInfo);
|
||||
fMixControlInfo.control_count = MAX_CONTROLS;
|
||||
fMixControlInfo.controls = fMixControl;
|
||||
|
||||
rval = DRIVER_LIST_MIX_CONTROLS(&MMCI, 0);
|
||||
|
||||
if (B_OK != rval)
|
||||
{
|
||||
fprintf(stderr, "Failed on DRIVER_LIST_MIX_CONTROLS\n");
|
||||
return B_ERROR;
|
||||
status = list_mix_controls(fDevice, &fMixControlInfo);
|
||||
if (status != B_OK) {
|
||||
fprintf(stderr, "Failed on DRIVER_LIST_MIX_CONTROLS: %s\n",
|
||||
strerror(status));
|
||||
return status;
|
||||
}
|
||||
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
int
|
||||
MultiAudioDevice::DoBufferExchange(multi_buffer_info *MBI)
|
||||
|
||||
status_t
|
||||
MultiAudioDevice::DoBufferExchange(multi_buffer_info *info)
|
||||
{
|
||||
return DRIVER_BUFFER_EXCHANGE(MBI, 0);
|
||||
return buffer_exchange(fDevice, info);
|
||||
}
|
||||
|
||||
int
|
||||
MultiAudioDevice::DoSetMix(multi_mix_value_info *MMVI)
|
||||
|
||||
status_t
|
||||
MultiAudioDevice::DoSetMix(multi_mix_value_info *info)
|
||||
{
|
||||
return DRIVER_SET_MIX(MMVI, 0);
|
||||
return set_mix(fDevice, info);
|
||||
}
|
||||
|
||||
int
|
||||
MultiAudioDevice::DoGetMix(multi_mix_value_info *MMVI)
|
||||
|
||||
status_t
|
||||
MultiAudioDevice::DoGetMix(multi_mix_value_info *info)
|
||||
{
|
||||
return DRIVER_GET_MIX(MMVI, 0);
|
||||
return get_mix(fDevice, info);
|
||||
}
|
||||
|
||||
@@ -2,59 +2,54 @@
|
||||
* Copyright (c) 2002-2007, Jerome Duval ([email protected])
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
#ifndef MULTI_AUDIO_DEVICE_H
|
||||
#define MULTI_AUDIO_DEVICE_H
|
||||
|
||||
#ifndef _MULTIAUDIODEVICE_H
|
||||
#define _MULTIAUDIODEVICE_H
|
||||
|
||||
#include "hmulti_audio.h"
|
||||
|
||||
|
||||
#define MAX_CONTROLS 128
|
||||
#define MAX_CHANNELS 32
|
||||
#define NB_BUFFERS 32
|
||||
#define MAX_BUFFERS 32
|
||||
|
||||
class MultiAudioDevice
|
||||
{
|
||||
public:
|
||||
explicit MultiAudioDevice(const char *name, const char* path);
|
||||
virtual ~MultiAudioDevice(void);
|
||||
|
||||
virtual status_t InitCheck(void) const;
|
||||
class MultiAudioDevice {
|
||||
public:
|
||||
MultiAudioDevice(const char* name, const char* path);
|
||||
~MultiAudioDevice();
|
||||
|
||||
static float convert_multiaudio_rate_to_media_rate(uint32 rate);
|
||||
static uint32 convert_media_rate_to_multiaudio_rate(float rate);
|
||||
static uint32 convert_multiaudio_format_to_media_format(uint32 fmt);
|
||||
static int16 convert_multiaudio_format_to_valid_bits(uint32 fmt);
|
||||
static uint32 convert_media_format_to_multiaudio_format(uint32 fmt);
|
||||
static uint32 select_multiaudio_rate(uint32 rate);
|
||||
static uint32 select_multiaudio_format(uint32 fmt);
|
||||
status_t InitCheck() const;
|
||||
|
||||
int DoBufferExchange(multi_buffer_info *MBI);
|
||||
int DoSetMix(multi_mix_value_info *MMVI);
|
||||
int DoGetMix(multi_mix_value_info *MMVI);
|
||||
const multi_description& Description() const { return fDescription; }
|
||||
const multi_format_info& FormatInfo() const { return fFormatInfo; }
|
||||
const multi_buffer_list& BufferList() const { return fBufferList; }
|
||||
const multi_mix_control_info& MixControlInfo() const
|
||||
{ return fMixControlInfo; }
|
||||
|
||||
private:
|
||||
status_t InitDriver();
|
||||
status_t DoBufferExchange(multi_buffer_info* bufferInfo);
|
||||
status_t DoSetMix(multi_mix_value_info* mixValueInfo);
|
||||
status_t DoGetMix(multi_mix_value_info* mixValueInfo);
|
||||
|
||||
int fd; //file descriptor for hw driver
|
||||
char fDevice_name[32];
|
||||
char fDevice_path[32];
|
||||
private:
|
||||
status_t _InitDriver();
|
||||
|
||||
public:
|
||||
multi_description MD;
|
||||
multi_channel_info MCI[MAX_CHANNELS];
|
||||
multi_format_info MFI;
|
||||
multi_buffer_list MBL;
|
||||
status_t fInitStatus;
|
||||
int fDevice;
|
||||
char fPath[B_PATH_NAME_LENGTH];
|
||||
|
||||
multi_mix_control_info MMCI;
|
||||
multi_mix_control MMC[MAX_CONTROLS];
|
||||
multi_description fDescription;
|
||||
multi_channel_info fChannelInfo[MAX_CHANNELS];
|
||||
multi_format_info fFormatInfo;
|
||||
multi_buffer_list fBufferList;
|
||||
|
||||
buffer_desc play_buffer_list[NB_BUFFERS * MAX_CHANNELS];
|
||||
buffer_desc record_buffer_list[NB_BUFFERS * MAX_CHANNELS];
|
||||
buffer_desc *play_buffer_desc[NB_BUFFERS];
|
||||
buffer_desc *record_buffer_desc[NB_BUFFERS];
|
||||
multi_mix_control_info fMixControlInfo;
|
||||
multi_mix_control fMixControl[MAX_CONTROLS];
|
||||
|
||||
private:
|
||||
status_t fInitCheckStatus;
|
||||
buffer_desc fPlayBufferList[MAX_BUFFERS * MAX_CHANNELS];
|
||||
buffer_desc fRecordBufferList[MAX_BUFFERS * MAX_CHANNELS];
|
||||
buffer_desc* fPlayBuffers[MAX_BUFFERS];
|
||||
buffer_desc* fRecordBuffers[MAX_BUFFERS];
|
||||
};
|
||||
|
||||
#endif
|
||||
#endif // MULTI_AUDIO_DEVICE_H
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -27,8 +27,7 @@
|
||||
const media_format & consumer_format);*/
|
||||
|
||||
|
||||
class node_input
|
||||
{
|
||||
class node_input {
|
||||
public:
|
||||
node_input(media_input &input, media_format format);
|
||||
~node_input();
|
||||
@@ -42,8 +41,7 @@ class node_input
|
||||
BBuffer *fBuffer;
|
||||
};
|
||||
|
||||
class node_output
|
||||
{
|
||||
class node_output {
|
||||
public:
|
||||
node_output(media_output &output, media_format format);
|
||||
~node_output();
|
||||
@@ -60,47 +58,38 @@ class node_output
|
||||
multi_buffer_info fOldMBI;
|
||||
};
|
||||
|
||||
class MultiAudioNode :
|
||||
public BBufferConsumer,
|
||||
public BBufferProducer,
|
||||
public BTimeSource,
|
||||
public BMediaEventLooper,
|
||||
public BControllable
|
||||
{
|
||||
protected:
|
||||
virtual ~MultiAudioNode(void);
|
||||
class MultiAudioNode : public BBufferConsumer, public BBufferProducer,
|
||||
public BTimeSource, public BMediaEventLooper, public BControllable {
|
||||
protected:
|
||||
virtual ~MultiAudioNode(void);
|
||||
|
||||
public:
|
||||
public:
|
||||
explicit MultiAudioNode(BMediaAddOn* addon, const char* name,
|
||||
MultiAudioDevice* device, int32 internalID, BMessage* config);
|
||||
|
||||
explicit MultiAudioNode(BMediaAddOn *addon, char* name, MultiAudioDevice *device,
|
||||
int32 internal_id, BMessage * config);
|
||||
|
||||
virtual status_t InitCheck(void) const;
|
||||
virtual status_t InitCheck(void) const;
|
||||
|
||||
/*************************/
|
||||
/* begin from BMediaNode */
|
||||
public:
|
||||
virtual BMediaAddOn* AddOn(
|
||||
int32 * internal_id) const; /* Who instantiated you -- or NULL for app class */
|
||||
public:
|
||||
virtual BMediaAddOn* AddOn(int32* internalID) const;
|
||||
|
||||
protected:
|
||||
/* These don't return errors; instead, they use the global error condition reporter. */
|
||||
/* A node is required to have a queue of at least one pending command (plus TimeWarp) */
|
||||
/* and is recommended to allow for at least one pending command of each type. */
|
||||
/* Allowing an arbitrary number of outstanding commands might be nice, but apps */
|
||||
/* cannot depend on that happening. */
|
||||
virtual void Preroll(void);
|
||||
protected:
|
||||
/* These don't return errors; instead, they use the global error condition reporter. */
|
||||
/* A node is required to have a queue of at least one pending command (plus TimeWarp) */
|
||||
/* and is recommended to allow for at least one pending command of each type. */
|
||||
/* Allowing an arbitrary number of outstanding commands might be nice, but apps */
|
||||
/* cannot depend on that happening. */
|
||||
virtual void Preroll(void);
|
||||
|
||||
public:
|
||||
virtual status_t HandleMessage(
|
||||
int32 message,
|
||||
const void * data,
|
||||
size_t size);
|
||||
public:
|
||||
virtual status_t HandleMessage(int32 message, const void* data,
|
||||
size_t size);
|
||||
|
||||
protected:
|
||||
virtual void NodeRegistered(void); /* reserved 2 */
|
||||
virtual status_t RequestCompleted(const media_request_info &info);
|
||||
virtual void SetTimeSource(BTimeSource *timeSource);
|
||||
protected:
|
||||
virtual void NodeRegistered();
|
||||
virtual status_t RequestCompleted(const media_request_info &info);
|
||||
virtual void SetTimeSource(BTimeSource *timeSource);
|
||||
|
||||
/* end from BMediaNode */
|
||||
/***********************/
|
||||
@@ -108,61 +97,28 @@ class MultiAudioNode :
|
||||
/******************************/
|
||||
/* begin from BBufferConsumer */
|
||||
|
||||
//included from BMediaAddOn
|
||||
//virtual status_t HandleMessage(
|
||||
// int32 message,
|
||||
// const void * data,
|
||||
// size_t size);
|
||||
virtual status_t AcceptFormat(const media_destination& dest,
|
||||
media_format* format);
|
||||
virtual status_t GetNextInput(int32* cookie, media_input* input);
|
||||
virtual void DisposeInputCookie(int32 cookie);
|
||||
virtual void BufferReceived(BBuffer* buffer);
|
||||
virtual void ProducerDataStatus(const media_destination& forWhom,
|
||||
int32 status, bigtime_t atPerformanceTime);
|
||||
virtual status_t GetLatencyFor(const media_destination& forWhom,
|
||||
bigtime_t* latency, media_node_id* timeSource);
|
||||
virtual status_t Connected(const media_source& producer,
|
||||
const media_destination& where,
|
||||
const media_format& withFormat, media_input* input);
|
||||
virtual void Disconnected(const media_source& producer,
|
||||
const media_destination& where);
|
||||
virtual status_t FormatChanged(const media_source& producer,
|
||||
const media_destination& consumer, int32 changeTag,
|
||||
const media_format& format);
|
||||
|
||||
/* Someone, probably the producer, is asking you about this format. Give */
|
||||
/* your honest opinion, possibly modifying *format. Do not ask upstream */
|
||||
/* producer about the format, since he's synchronously waiting for your */
|
||||
/* reply. */
|
||||
virtual status_t AcceptFormat(
|
||||
const media_destination & dest,
|
||||
media_format * format);
|
||||
virtual status_t GetNextInput(
|
||||
int32 * cookie,
|
||||
media_input * out_input);
|
||||
virtual void DisposeInputCookie(
|
||||
int32 cookie);
|
||||
virtual void BufferReceived(
|
||||
BBuffer * buffer);
|
||||
virtual void ProducerDataStatus(
|
||||
const media_destination & for_whom,
|
||||
int32 status,
|
||||
bigtime_t at_performance_time);
|
||||
virtual status_t GetLatencyFor(
|
||||
const media_destination & for_whom,
|
||||
bigtime_t * out_latency,
|
||||
media_node_id * out_timesource);
|
||||
virtual status_t Connected(
|
||||
const media_source & producer, /* here's a good place to request buffer group usage */
|
||||
const media_destination & where,
|
||||
const media_format & with_format,
|
||||
media_input * out_input);
|
||||
virtual void Disconnected(
|
||||
const media_source & producer,
|
||||
const media_destination & where);
|
||||
/* The notification comes from the upstream producer, so he's already cool with */
|
||||
/* the format; you should not ask him about it in here. */
|
||||
virtual status_t FormatChanged(
|
||||
const media_source & producer,
|
||||
const media_destination & consumer,
|
||||
int32 change_tag,
|
||||
const media_format & format);
|
||||
|
||||
/* Given a performance time of some previous buffer, retrieve the remembered tag */
|
||||
/* of the closest (previous or exact) performance time. Set *out_flags to 0; the */
|
||||
/* idea being that flags can be added later, and the understood flags returned in */
|
||||
/* *out_flags. */
|
||||
virtual status_t SeekTagRequested(
|
||||
const media_destination & destination,
|
||||
bigtime_t in_target_time,
|
||||
uint32 in_flags,
|
||||
media_seek_tag * out_seek_tag,
|
||||
bigtime_t * out_tagged_time,
|
||||
uint32 * out_flags);
|
||||
virtual status_t SeekTagRequested(const media_destination& destination,
|
||||
bigtime_t targetTime, uint32 flags,
|
||||
media_seek_tag* _seekTag, bigtime_t* _taggedTime,
|
||||
uint32* _flags);
|
||||
|
||||
/* end from BBufferConsumer */
|
||||
/****************************/
|
||||
|
||||
@@ -0,0 +1,235 @@
|
||||
/*
|
||||
* Copyright 2008, Axel Dörfler, [email protected].
|
||||
* Copyright (c) 2002-2007, Jerome Duval ([email protected])
|
||||
*
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
|
||||
|
||||
#include "MultiAudioUtility.h"
|
||||
|
||||
#include <errno.h>
|
||||
|
||||
#include <MediaDefs.h>
|
||||
|
||||
|
||||
const float kSampleRates[] = {
|
||||
8000.0, 11025.0, 12000.0, 16000.0, 22050.0, 24000.0, 32000.0, 44100.0,
|
||||
48000.0, 64000.0, 88200.0, 96000.0, 176400.0, 192000.0, 384000.0, 1536000.0
|
||||
};
|
||||
const uint32 kSampleRateCount = sizeof(kSampleRates) / sizeof(kSampleRates[0]);
|
||||
|
||||
|
||||
template<typename T> static status_t
|
||||
call_driver(int device, int32 op, T* data)
|
||||
{
|
||||
if (ioctl(device, op, data, sizeof(T)) != 0)
|
||||
return errno;
|
||||
|
||||
return B_OK;
|
||||
}
|
||||
|
||||
|
||||
namespace MultiAudio {
|
||||
|
||||
|
||||
float
|
||||
convert_to_sample_rate(uint32 rate)
|
||||
{
|
||||
for (uint32 i = 0; i < kSampleRateCount; i++) {
|
||||
if (rate & 1)
|
||||
return kSampleRates[i];
|
||||
|
||||
rate >>= 1;
|
||||
}
|
||||
|
||||
return 0.0;
|
||||
}
|
||||
|
||||
|
||||
uint32
|
||||
convert_from_sample_rate(float rate)
|
||||
{
|
||||
for (uint32 i = 0; i < kSampleRateCount; i++) {
|
||||
if (rate <= kSampleRates[i])
|
||||
return 1 << i;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
uint32
|
||||
convert_to_media_format(uint32 format)
|
||||
{
|
||||
switch (format) {
|
||||
case B_FMT_FLOAT:
|
||||
return media_raw_audio_format::B_AUDIO_FLOAT;
|
||||
case B_FMT_18BIT:
|
||||
case B_FMT_20BIT:
|
||||
case B_FMT_24BIT:
|
||||
case B_FMT_32BIT:
|
||||
return media_raw_audio_format::B_AUDIO_INT;
|
||||
case B_FMT_16BIT:
|
||||
return media_raw_audio_format::B_AUDIO_SHORT;
|
||||
case B_FMT_8BIT_S:
|
||||
return media_raw_audio_format::B_AUDIO_CHAR;
|
||||
case B_FMT_8BIT_U:
|
||||
return media_raw_audio_format::B_AUDIO_UCHAR;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
int16
|
||||
convert_to_valid_bits(uint32 format)
|
||||
{
|
||||
switch (format) {
|
||||
case B_FMT_18BIT:
|
||||
return 18;
|
||||
case B_FMT_20BIT:
|
||||
return 20;
|
||||
case B_FMT_24BIT:
|
||||
return 24;
|
||||
case B_FMT_32BIT:
|
||||
return 32;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
uint32
|
||||
convert_from_media_format(uint32 format)
|
||||
{
|
||||
switch (format) {
|
||||
case media_raw_audio_format::B_AUDIO_FLOAT:
|
||||
return B_FMT_FLOAT;
|
||||
case media_raw_audio_format::B_AUDIO_INT:
|
||||
return B_FMT_32BIT;
|
||||
case media_raw_audio_format::B_AUDIO_SHORT:
|
||||
return B_FMT_16BIT;
|
||||
case media_raw_audio_format::B_AUDIO_CHAR:
|
||||
return B_FMT_8BIT_S;
|
||||
case media_raw_audio_format::B_AUDIO_UCHAR:
|
||||
return B_FMT_8BIT_U;
|
||||
|
||||
default:
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
uint32
|
||||
select_sample_rate(uint32 rate)
|
||||
{
|
||||
// highest rate
|
||||
uint32 crate = B_SR_1536000;
|
||||
while (crate != 0) {
|
||||
if (rate & crate)
|
||||
return crate;
|
||||
crate >>= 1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
uint32
|
||||
select_format(uint32 format)
|
||||
{
|
||||
// best format
|
||||
if (format & B_FMT_FLOAT)
|
||||
return B_FMT_FLOAT;
|
||||
if (format & B_FMT_32BIT)
|
||||
return B_FMT_32BIT;
|
||||
if (format & B_FMT_24BIT)
|
||||
return B_FMT_24BIT;
|
||||
if (format & B_FMT_20BIT)
|
||||
return B_FMT_20BIT;
|
||||
if (format & B_FMT_18BIT)
|
||||
return B_FMT_18BIT;
|
||||
if (format & B_FMT_16BIT)
|
||||
return B_FMT_16BIT;
|
||||
if (format & B_FMT_8BIT_S)
|
||||
return B_FMT_8BIT_S;
|
||||
if (format & B_FMT_8BIT_U)
|
||||
return B_FMT_8BIT_U;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
get_description(int device, multi_description* description)
|
||||
{
|
||||
return call_driver(device, B_MULTI_GET_DESCRIPTION, description);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
get_enabled_channels(int device, multi_channel_enable* enable)
|
||||
{
|
||||
return call_driver(device, B_MULTI_GET_ENABLED_CHANNELS, enable);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
set_enabled_channels(int device, multi_channel_enable* enable)
|
||||
{
|
||||
return call_driver(device, B_MULTI_SET_ENABLED_CHANNELS, enable);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
get_global_format(int device, multi_format_info* info)
|
||||
{
|
||||
return call_driver(device, B_MULTI_GET_GLOBAL_FORMAT, info);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
set_global_format(int device, multi_format_info* info)
|
||||
{
|
||||
return call_driver(device, B_MULTI_SET_GLOBAL_FORMAT, info);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
get_buffers(int device, multi_buffer_list* list)
|
||||
{
|
||||
return call_driver(device, B_MULTI_GET_BUFFERS, list);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
buffer_exchange(int device, multi_buffer_info* info)
|
||||
{
|
||||
return call_driver(device, B_MULTI_BUFFER_EXCHANGE, info);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
list_mix_controls(int device, multi_mix_control_info* info)
|
||||
{
|
||||
return call_driver(device, B_MULTI_LIST_MIX_CONTROLS, info);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
get_mix(int device, multi_mix_value_info* info)
|
||||
{
|
||||
return call_driver(device, B_MULTI_GET_MIX, info);
|
||||
}
|
||||
|
||||
|
||||
status_t
|
||||
set_mix(int device, multi_mix_value_info* info)
|
||||
{
|
||||
return call_driver(device, B_MULTI_SET_MIX, info);
|
||||
}
|
||||
|
||||
|
||||
} // namespace MultiAudio
|
||||
@@ -0,0 +1,42 @@
|
||||
/*
|
||||
* Copyright 2008, Axel Dörfler, [email protected].
|
||||
* Copyright (c) 2002-2007, Jerome Duval ([email protected])
|
||||
*
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
#ifndef MULTI_AUDIO_UTILITY_H
|
||||
#define MULTI_AUDIO_UTILITY_H
|
||||
|
||||
|
||||
#include "hmulti_audio.h"
|
||||
|
||||
|
||||
namespace MultiAudio {
|
||||
|
||||
// sample rate & format conversion
|
||||
float convert_to_sample_rate(uint32 rate);
|
||||
uint32 convert_from_sample_rate(float rate);
|
||||
uint32 convert_to_media_format(uint32 format);
|
||||
int16 convert_to_valid_bits(uint32 format);
|
||||
uint32 convert_from_media_format(uint32 format);
|
||||
uint32 select_sample_rate(uint32 rate);
|
||||
uint32 select_format(uint32 format);
|
||||
|
||||
// device driver interface
|
||||
status_t get_description(int device, multi_description* description);
|
||||
|
||||
status_t get_enabled_channels(int device, multi_channel_enable* enable);
|
||||
status_t set_enabled_channels(int device, multi_channel_enable* enable);
|
||||
|
||||
status_t get_global_format(int device, multi_format_info* info);
|
||||
status_t set_global_format(int device, multi_format_info* info);
|
||||
status_t get_buffers(int device, multi_buffer_list* list);
|
||||
status_t buffer_exchange(int device, multi_buffer_info* info);
|
||||
|
||||
status_t list_mix_controls(int device, multi_mix_control_info* info);
|
||||
status_t get_mix(int device, multi_mix_value_info* info);
|
||||
status_t set_mix(int device, multi_mix_value_info* info);
|
||||
|
||||
} // namespace MultiAudio
|
||||
|
||||
#endif // MULTI_AUDIO_UTILITY_H
|
||||
@@ -1,26 +0,0 @@
|
||||
/*
|
||||
* multiaudio replacement media addon for BeOS
|
||||
*
|
||||
* Copyright (c) 2002, Jerome Duval ([email protected])
|
||||
* Distributed under the terms of the MIT License.
|
||||
*/
|
||||
#ifndef _DRIVER_IO_H
|
||||
#define _DRIVER_IO_H
|
||||
|
||||
#include <unistd.h>
|
||||
#include <fcntl.h>
|
||||
#include <Drivers.h>
|
||||
#include "hmulti_audio.h"
|
||||
|
||||
#define DRIVER_GET_DESCRIPTION(x...) ioctl( fd, B_MULTI_GET_DESCRIPTION, x )
|
||||
#define DRIVER_GET_ENABLED_CHANNELS(x...) ioctl( fd, B_MULTI_GET_ENABLED_CHANNELS, x )
|
||||
#define DRIVER_SET_ENABLED_CHANNELS(x...) ioctl( fd, B_MULTI_SET_ENABLED_CHANNELS, x )
|
||||
#define DRIVER_SET_GLOBAL_FORMAT(x...) ioctl( fd, B_MULTI_SET_GLOBAL_FORMAT, x )
|
||||
#define DRIVER_GET_BUFFERS(x...) ioctl( fd, B_MULTI_GET_BUFFERS, x )
|
||||
#define DRIVER_BUFFER_EXCHANGE(x...) ioctl( fd, B_MULTI_BUFFER_EXCHANGE, x )
|
||||
|
||||
#define DRIVER_LIST_MIX_CONTROLS(x...) ioctl( fd, B_MULTI_LIST_MIX_CONTROLS, x )
|
||||
#define DRIVER_SET_MIX(x...) ioctl( fd, B_MULTI_SET_MIX, x )
|
||||
#define DRIVER_GET_MIX(x...) ioctl( fd, B_MULTI_GET_MIX, x )
|
||||
|
||||
#endif
|
||||
Reference in New Issue
Block a user