/*----------------------------------------------------------------------
| DcfParser_GetPortByName
+---------------------------------------------------------------------*/
BLT_METHOD
DcfParser_GetPortByName(BLT_MediaNode* _self,
BLT_CString name,
BLT_MediaPort** port)
{
DcfParser* self = ATX_SELF_EX(DcfParser, BLT_BaseMediaNode, BLT_MediaNode);
if (ATX_StringsEqual(name, "input")) {
*port = &ATX_BASE(&self->input, BLT_MediaPort);
return BLT_SUCCESS;
} else if (ATX_StringsEqual(name, "output")) {
*port = &ATX_BASE(&self->output, BLT_MediaPort);
return BLT_SUCCESS;
} else {
*port = NULL;
return BLT_ERROR_NO_SUCH_PORT;
}
}
/*----------------------------------------------------------------------
| CrossFader_GetPortByName
+---------------------------------------------------------------------*/
BLT_METHOD
CrossFader_GetPortByName(BLT_MediaNodeInstance* instance,
BLT_CString name,
BLT_MediaPort* port)
{
CrossFader* fader = (CrossFader*)instance;
if (ATX_StringsEqual(name, "input")) {
ATX_INSTANCE(port) = (BLT_MediaPortInstance*)fader;
ATX_INTERFACE(port) = &CrossFaderInputPort_BLT_MediaPortInterface;
return BLT_SUCCESS;
} else if (ATX_StringsEqual(name, "output")) {
ATX_INSTANCE(port) = (BLT_MediaPortInstance*)fader;
ATX_INTERFACE(port) = &CrossFaderOutputPort_BLT_MediaPortInterface;
return BLT_SUCCESS;
} else {
ATX_CLEAR_OBJECT(port);
return BLT_ERROR_NO_SUCH_PORT;
}
}
/*----------------------------------------------------------------------
| ATX_HttpClient_SetOptionBool
+---------------------------------------------------------------------*/
ATX_Result
ATX_HttpClient_SetOptionBool(ATX_HttpClient* self,
ATX_CString option,
ATX_Boolean value)
{
if (ATX_StringsEqual(option, ATX_HTTP_CLIENT_OPTION_FOLLOW_REDIRECT)) {
self->options.follow_redirect = value;
} else {
return ATX_ERROR_NO_SUCH_ITEM;
}
return ATX_SUCCESS;
}
/*----------------------------------------------------------------------
| AlsaOutput_GetPortByName
+---------------------------------------------------------------------*/
BLT_METHOD
AlsaOutput_GetPortByName(BLT_MediaNode* _self,
BLT_CString name,
BLT_MediaPort** port)
{
AlsaOutput* self = ATX_SELF_EX(AlsaOutput, BLT_BaseMediaNode, BLT_MediaNode);
if (ATX_StringsEqual(name, "input")) {
*port = &ATX_BASE(self, BLT_MediaPort);
return BLT_SUCCESS;
} else {
*port = NULL;
return BLT_ERROR_NO_SUCH_PORT;
}
}
/*----------------------------------------------------------------------
| ATX_File_Create
+---------------------------------------------------------------------*/
ATX_Result
ATX_File_Create(const char* filename, ATX_File** object)
{
StdcFile* file;
/* allocate a new object */
file = (StdcFile*)ATX_AllocateZeroMemory(sizeof(StdcFile));
if (file == NULL) {
*object = NULL;
return ATX_ERROR_OUT_OF_MEMORY;
}
/* construct the object */
file->name = ATX_String_Create(filename);
/* get the size */
if (ATX_StringsEqual(filename, ATX_FILE_STANDARD_INPUT) ||
ATX_StringsEqual(filename, ATX_FILE_STANDARD_OUTPUT) ||
ATX_StringsEqual(filename, ATX_FILE_STANDARD_ERROR)) {
file->size = 0;
} else {
struct stat info;
if (stat(filename, &info) == 0) {
file->size = info.st_size;
} else {
file->size = 0;
}
}
/* setup the interfaces */
ATX_SET_INTERFACE(file, StdcFile, ATX_File);
ATX_SET_INTERFACE(file, StdcFile, ATX_Destroyable);
*object = &ATX_BASE(file, ATX_File);
return ATX_SUCCESS;
}
/*----------------------------------------------------------------------
| DebugOutputModule_Probe
+---------------------------------------------------------------------*/
BLT_METHOD
DebugOutputModule_Probe(BLT_Module* self,
BLT_Core* core,
BLT_ModuleParametersType parameters_type,
BLT_AnyConst parameters,
BLT_Cardinal* match)
{
BLT_COMPILER_UNUSED(self);
BLT_COMPILER_UNUSED(core);
switch (parameters_type) {
case BLT_MODULE_PARAMETERS_TYPE_MEDIA_NODE_CONSTRUCTOR:
{
BLT_MediaNodeConstructor* constructor = (BLT_MediaNodeConstructor*)parameters;
/* the input protocol should be PACKET and the */
/* output protocol should be NONE */
if ((constructor->spec.input.protocol != BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.input.protocol != BLT_MEDIA_PORT_PROTOCOL_PACKET) ||
(constructor->spec.output.protocol != BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.output.protocol != BLT_MEDIA_PORT_PROTOCOL_NONE)) {
return BLT_FAILURE;
}
/* the name should be 'debug' */
if (constructor->name == NULL ||
!ATX_StringsEqual(constructor->name, "debug")) {
return BLT_FAILURE;
}
/* always an exact match, since we only respond to our name */
*match = BLT_MODULE_PROBE_MATCH_EXACT;
ATX_LOG_FINE_1("DebugOutputModule::Probe - Ok [%d]", *match);
return BLT_SUCCESS;
}
break;
default:
break;
}
return BLT_FAILURE;
}
/*----------------------------------------------------------------------
| BLT_Decoder_SetOutput
+---------------------------------------------------------------------*/
BLT_Result
BLT_Decoder_SetOutput(BLT_Decoder* decoder, BLT_CString name, BLT_CString type)
{
BLT_Result result;
/* normalize the name and type */
if (name && name[0] == '\0') name = NULL;
if (type && type[0] == '\0') type = NULL;
if (name == NULL) {
/* if the name is NULL or empty, it means reset */
BLT_Decoder_OutputChanged(decoder, NULL);
return BLT_Stream_ResetOutput(decoder->stream);
} else {
if (ATX_StringsEqual(name, BLT_DECODER_DEFAULT_OUTPUT_NAME)) {
/* if the name is BLT_DECODER_DEFAULT_OUTPUT_NAME, use default */
BLT_CString default_name;
BLT_CString default_type;
BLT_Builtins_GetDefaultAudioOutput(&default_name, &default_type);
name = default_name;
if (type == NULL) type = default_type;
result = BLT_Stream_SetOutput(decoder->stream, name, type);
} else {
/* set the output of the stream by name */
result = BLT_Stream_SetOutput(decoder->stream, name, type);
}
}
if (BLT_SUCCEEDED(result)) {
BLT_MediaNode* node = NULL;
BLT_Stream_GetOutputNode(decoder->stream, &node);
BLT_Decoder_OutputChanged(decoder, node);
ATX_RELEASE_OBJECT(node);
}
return result;
}
/*----------------------------------------------------------------------
| DcfParserModule_Probe
+---------------------------------------------------------------------*/
BLT_METHOD
DcfParserModule_Probe(BLT_Module* _self,
BLT_Core* core,
BLT_ModuleParametersType parameters_type,
BLT_AnyConst parameters,
BLT_Cardinal* match)
{
DcfParserModule* self = ATX_SELF_EX(DcfParserModule, BLT_BaseModule, BLT_Module);
BLT_COMPILER_UNUSED(core);
switch (parameters_type) {
case BLT_MODULE_PARAMETERS_TYPE_MEDIA_NODE_CONSTRUCTOR:
{
BLT_MediaNodeConstructor* constructor =
(BLT_MediaNodeConstructor*)parameters;
/* we need the input protocol to be STREAM_PULL and the output */
/* protocol to be STREAM_PULL */
if ((constructor->spec.input.protocol !=
BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.input.protocol !=
BLT_MEDIA_PORT_PROTOCOL_STREAM_PULL) ||
(constructor->spec.output.protocol !=
BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.output.protocol !=
BLT_MEDIA_PORT_PROTOCOL_STREAM_PULL)) {
return BLT_FAILURE;
}
/* we need the input media type to be 'application/vnd.oma.drm.content' */
/* or 'application/vnd.oma.drm.dcf' */
if (constructor->spec.input.media_type->id != self->dcf1_type_id &&
constructor->spec.input.media_type->id != self->dcf2_type_id) {
return BLT_FAILURE;
}
/* the output type should be unknown at this point */
if (constructor->spec.output.media_type->id !=
BLT_MEDIA_TYPE_ID_UNKNOWN) {
return BLT_FAILURE;
}
/* compute the match level */
if (constructor->name != NULL) {
/* we're being probed by name */
if (ATX_StringsEqual(constructor->name, "DcfParser")) {
/* our name */
*match = BLT_MODULE_PROBE_MATCH_EXACT;
} else {
/* not out name */
return BLT_FAILURE;
}
} else {
/* we're probed by protocol/type specs only */
*match = BLT_MODULE_PROBE_MATCH_MAX - 10;
}
ATX_LOG_FINE_1("DcfParserModule::Probe - Ok [%d]", *match);
return BLT_SUCCESS;
}
break;
default:
break;
}
return BLT_FAILURE;
}
/*----------------------------------------------------------------------
| CrossFaderModule_Probe
+---------------------------------------------------------------------*/
BLT_METHOD
CrossFaderModule_Probe(BLT_ModuleInstance* instance,
BLT_Core* core,
BLT_ModuleParametersType parameters_type,
BLT_AnyConst parameters,
BLT_Cardinal* match)
{
BLT_COMPILER_UNUSED(core);
BLT_COMPILER_UNUSED(instance);
switch (parameters_type) {
case BLT_MODULE_PARAMETERS_TYPE_MEDIA_NODE_CONSTRUCTOR:
{
BLT_MediaNodeConstructor* constructor =
(BLT_MediaNodeConstructor*)parameters;
/* we need a name */
if (constructor->name == NULL ||
!ATX_StringsEqual(constructor->name, "CrossFader")) {
return BLT_FAILURE;
}
/* the input and output protocols should be PACKET */
if ((constructor->spec.input.protocol !=
BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.input.protocol !=
BLT_MEDIA_PORT_PROTOCOL_PACKET) ||
(constructor->spec.output.protocol !=
BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.output.protocol !=
BLT_MEDIA_PORT_PROTOCOL_PACKET)) {
return BLT_FAILURE;
}
/* the input type should be unspecified, or audio/pcm */
if (!(constructor->spec.input.media_type->id ==
BLT_MEDIA_TYPE_ID_AUDIO_PCM) &&
!(constructor->spec.input.media_type->id ==
BLT_MEDIA_TYPE_ID_UNKNOWN)) {
return BLT_FAILURE;
}
/* the output type should be unspecified, or audio/pcm */
if (!(constructor->spec.output.media_type->id ==
BLT_MEDIA_TYPE_ID_AUDIO_PCM) &&
!(constructor->spec.output.media_type->id ==
BLT_MEDIA_TYPE_ID_UNKNOWN)) {
return BLT_FAILURE;
}
/* match level is always exact */
*match = BLT_MODULE_PROBE_MATCH_EXACT;
ATX_LOG_FINE_1("CrossFaderModule::Probe - Ok [%d]", *match);
return BLT_SUCCESS;
}
break;
default:
break;
}
return BLT_FAILURE;
}
/*----------------------------------------------------------------------
| PcmAdapterModule_Probe
+---------------------------------------------------------------------*/
BLT_METHOD
PcmAdapterModule_Probe(BLT_Module* self,
BLT_Core* core,
BLT_ModuleParametersType parameters_type,
BLT_AnyConst parameters,
BLT_Cardinal* match)
{
BLT_COMPILER_UNUSED(self);
BLT_COMPILER_UNUSED(core);
switch (parameters_type) {
case BLT_MODULE_PARAMETERS_TYPE_MEDIA_NODE_CONSTRUCTOR:
{
BLT_MediaNodeConstructor* constructor =
(BLT_MediaNodeConstructor*)parameters;
/* compute match based on specified name */
if (constructor->name == NULL) {
*match = BLT_MODULE_PROBE_MATCH_DEFAULT;
/* the input protocol should be PACKET */
if (constructor->spec.input.protocol !=
BLT_MEDIA_PORT_PROTOCOL_PACKET) {
return BLT_FAILURE;
}
/* output protocol should be PACKET */
if (constructor->spec.output.protocol !=
BLT_MEDIA_PORT_PROTOCOL_PACKET) {
return BLT_FAILURE;
}
/* check that the in and out formats are supported */
if (!BLT_Pcm_CanConvert(constructor->spec.input.media_type,
constructor->spec.output.media_type)) {
return BLT_FAILURE;
}
} else {
/* if a name is specified, it needs to match exactly */
if (!ATX_StringsEqual(constructor->name, "PcmAdapter")) {
return BLT_FAILURE;
} else {
*match = BLT_MODULE_PROBE_MATCH_EXACT;
}
/* the input protocol should be PACKET or ANY */
if (constructor->spec.input.protocol !=
BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.input.protocol !=
BLT_MEDIA_PORT_PROTOCOL_PACKET) {
return BLT_FAILURE;
}
/* output protocol should be PACKET or ANY */
if ((constructor->spec.output.protocol !=
BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.output.protocol !=
BLT_MEDIA_PORT_PROTOCOL_PACKET)) {
return BLT_FAILURE;
}
/* check that the in and out formats are supported */
if (!BLT_Pcm_CanConvert(constructor->spec.input.media_type,
constructor->spec.output.media_type)) {
return BLT_FAILURE;
}
}
ATX_LOG_FINE_1("PcmAdapterModule::Probe - Ok [%d]", *match);
return BLT_SUCCESS;
}
break;
default:
break;
}
return BLT_FAILURE;
}
/*----------------------------------------------------------------------
| Mp4ParserModule_Probe
+---------------------------------------------------------------------*/
BLT_METHOD
Mp4ParserModule_Probe(BLT_Module* _self,
BLT_Core* core,
BLT_ModuleParametersType parameters_type,
BLT_AnyConst parameters,
BLT_Cardinal* match)
{
Mp4ParserModule* self = ATX_SELF_EX(Mp4ParserModule, BLT_BaseModule, BLT_Module);
BLT_COMPILER_UNUSED(core);
switch (parameters_type) {
case BLT_MODULE_PARAMETERS_TYPE_MEDIA_NODE_CONSTRUCTOR:
{
BLT_MediaNodeConstructor* constructor = (BLT_MediaNodeConstructor*)parameters;
/* check if we're being probed by name */
if (constructor->name != NULL) {
/* we're being probed by name */
if (ATX_StringsEqual(constructor->name, "com.bluetune.parsers.mp4")) {
/* our name */
*match = BLT_MODULE_PROBE_MATCH_EXACT;
return BLT_SUCCESS;
} else {
/* not out name */
*match = 0;
return BLT_FAILURE;
}
}
/* we need the input protocol to be STREAM_PULL and the output */
/* protocol to be PACKET */
if ((constructor->spec.input.protocol != BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.input.protocol != BLT_MEDIA_PORT_PROTOCOL_STREAM_PULL) ||
(constructor->spec.output.protocol != BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.output.protocol != BLT_MEDIA_PORT_PROTOCOL_PACKET)) {
return BLT_FAILURE;
}
/* we need the input media type to be 'audio/mp4' or 'video/mp4' */
if (constructor->spec.input.media_type->id != self->mp4_audio_type_id &&
constructor->spec.input.media_type->id != self->mp4_video_type_id) {
return BLT_FAILURE;
}
/* the output type should be unknown at this point */
if (constructor->spec.output.media_type->id != BLT_MEDIA_TYPE_ID_UNKNOWN) {
return BLT_FAILURE;
}
/* set the match level */
*match = BLT_MODULE_PROBE_MATCH_MAX - 10;
ATX_LOG_FINE_1("match %d", *match);
return BLT_SUCCESS;
}
break;
default:
break;
}
return BLT_FAILURE;
}
/*----------------------------------------------------------------------
| AacDecoderModule_Probe
+---------------------------------------------------------------------*/
BLT_METHOD
AacDecoderModule_Probe(BLT_Module* _self,
BLT_Core* core,
BLT_ModuleParametersType parameters_type,
BLT_AnyConst parameters,
BLT_Cardinal* match)
{
AacDecoderModule* self = ATX_SELF_EX(AacDecoderModule, BLT_BaseModule, BLT_Module);
BLT_COMPILER_UNUSED(core);
switch (parameters_type) {
case BLT_MODULE_PARAMETERS_TYPE_MEDIA_NODE_CONSTRUCTOR:
{
BLT_MediaNodeConstructor* constructor =
(BLT_MediaNodeConstructor*)parameters;
/* the input and output protocols should be PACKET */
if ((constructor->spec.input.protocol !=
BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.input.protocol !=
BLT_MEDIA_PORT_PROTOCOL_PACKET) ||
(constructor->spec.output.protocol !=
BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.output.protocol !=
BLT_MEDIA_PORT_PROTOCOL_PACKET)) {
return BLT_FAILURE;
}
/* the input type should be BLT_MP4_ES_MIME_TYPE */
if (constructor->spec.input.media_type->id !=
self->mp4es_type_id) {
return BLT_FAILURE;
} else {
/* check the object type id */
BLT_Mp4AudioMediaType* media_type = (BLT_Mp4AudioMediaType*)constructor->spec.input.media_type;
if (media_type->base.stream_type != BLT_MP4_STREAM_TYPE_AUDIO) return BLT_FAILURE;
if (media_type->base.format_or_object_type_id != BLT_AAC_OBJECT_TYPE_ID_MPEG2_AAC_LC &&
media_type->base.format_or_object_type_id != BLT_AAC_OBJECT_TYPE_ID_MPEG4_AUDIO) {
return BLT_FAILURE;
}
if (media_type->base.format_or_object_type_id == BLT_AAC_OBJECT_TYPE_ID_MPEG4_AUDIO) {
/* check that this is AAC LC */
AacDecoderConfig decoder_config;
if (BLT_FAILED(AacDecoderConfig_Parse(media_type->decoder_info, media_type->decoder_info_length, &decoder_config))) {
return BLT_FAILURE;
}
if (decoder_config.object_type != BLT_AAC_OBJECT_TYPE_AAC_LC &&
decoder_config.object_type != BLT_AAC_OBJECT_TYPE_SBR) {
return BLT_FAILURE;
}
}
}
/* the output type should be unspecified, or audio/pcm */
if (!(constructor->spec.output.media_type->id ==
BLT_MEDIA_TYPE_ID_AUDIO_PCM) &&
!(constructor->spec.output.media_type->id ==
BLT_MEDIA_TYPE_ID_UNKNOWN)) {
return BLT_FAILURE;
}
/* compute the match level */
if (constructor->name != NULL) {
/* we're being probed by name */
if (ATX_StringsEqual(constructor->name, "AacDecoder")) {
/* our name */
*match = BLT_MODULE_PROBE_MATCH_EXACT;
} else {
/* not our name */
return BLT_FAILURE;
}
} else {
/* we're probed by protocol/type specs only */
*match = BLT_MODULE_PROBE_MATCH_MAX - 10;
}
ATX_LOG_FINE_1("AacDecoderModule::Probe - Ok [%d]", *match);
return BLT_SUCCESS;
}
break;
default:
break;
}
return BLT_FAILURE;
}
/*----------------------------------------------------------------------
| OsxAudioUnitsOutput_MapDeviceIndex
+---------------------------------------------------------------------*/
static BLT_Result
OsxAudioUnitsOutput_MapDeviceName(const char* name, AudioDeviceID* device_id)
{
OSStatus err;
BLT_Result result = BLT_ERROR_NO_SUCH_DEVICE;
UInt32 prop_size = 0;
AudioDeviceID* devices = NULL;
unsigned int device_count = 0;
ATX_UInt32 device_index = 0;
unsigned int device_selector = 1;
char* device_name = NULL;
unsigned int i;
/* setup a default value */
*device_id = 0;
/* check the parameters */
if (name[0] == '\0') return BLT_ERROR_NO_SUCH_DEVICE;
/* parse the name */
if (name[0] == '#') {
++name;
ATX_LOG_FINE_1("device name = %s", name);
} else {
if (BLT_FAILED(ATX_ParseInteger32U(name, &device_index, ATX_FALSE))) {
return BLT_ERROR_NO_SUCH_DEVICE;
}
ATX_LOG_FINE_1("device index = %d", device_index);
name = NULL;
/* 0 means default */
if (device_index == 0) {
/* look at the device's streams */
AudioDeviceID default_device_id = 0;
prop_size = sizeof(AudioDeviceID);
err = AudioHardwareGetProperty(kAudioHardwarePropertyDefaultOutputDevice, &prop_size, &default_device_id);
if (err == noErr) {
prop_size = 0;
err = AudioDeviceGetPropertyInfo(default_device_id, 0, FALSE, kAudioDevicePropertyStreams, &prop_size, NULL);
if (err == noErr) {
ATX_LOG_FINE_1("device has %d streams", (int)prop_size/4);
}
}
return BLT_SUCCESS;
}
}
/* ask how many devices exist */
err = AudioHardwareGetPropertyInfo(kAudioHardwarePropertyDevices, &prop_size, NULL);
if (err != noErr) {
ATX_LOG_FINE_1("AudioHardwareGetPropertyInfo failed (%d)", (int)err);
return 0;
}
device_count = prop_size/sizeof(AudioDeviceID);
ATX_LOG_FINE_1("found %d devices", device_count);
/* allocate memory for the array */
devices = (AudioDeviceID*)ATX_AllocateZeroMemory(sizeof(AudioDeviceID) * device_count);
if (devices == NULL) return 0;
/* retrieve the list of device IDs */
err = AudioHardwareGetProperty(kAudioHardwarePropertyDevices, &prop_size, devices);
if (err != noErr) {
ATX_LOG_FINE_1("AudioHardwareGetProperty(kAudioHardwarePropertyDevices) failed (%d)", (int)err);
return 0;
}
/* find the device ID we want */
for (i=0; i<device_count; i++) {
/* get the device name */
err = AudioDeviceGetPropertyInfo(devices[i], 0, false,
kAudioDevicePropertyDeviceName,
&prop_size, NULL);
if (err == noErr) {
if (device_name) ATX_FreeMemory(device_name);
device_name = (char*)ATX_AllocateZeroMemory(prop_size+1);
err = AudioDeviceGetProperty(devices[i], 0, false,
kAudioDevicePropertyDeviceName,
&prop_size, device_name);
if (err == noErr) {
ATX_LOG_FINE_2("device name [%d] = %s", i, device_name);
}
/* cleanup the string */
device_name[prop_size] = '\0'; /* NULL-terminate the string */
if (prop_size > 0) {
unsigned int x;
for (x=prop_size-1; x; x--) {
if (device_name[x] == ' ') {
device_name[x] = '\0';
} else if (device_name[x]) {
break;
}
}
}
} else {
continue;
}
/* look at the device's streams */
prop_size = 0;
err = AudioDeviceGetPropertyInfo(devices[i], 0, FALSE, kAudioDevicePropertyStreams, &prop_size, NULL);
if (err != noErr || prop_size == 0) {
ATX_LOG_FINE("skipping device (not an output)");
continue;
}
if (name) {
/* look for a match by name */
if (ATX_StringsEqual(device_name, name)) {
*device_id = devices[i];
ATX_LOG_FINE("device selected as output");
result = BLT_SUCCESS;
break;
}
} else {
/* look for a match by index */
if (device_selector++ == device_index) {
*device_id = devices[i];
ATX_LOG_FINE("device selected as output");
result = BLT_SUCCESS;
break;
}
}
}
if (device_name) ATX_FreeMemory(device_name);
if (devices) ATX_FreeMemory(devices);
return result;
}
/*----------------------------------------------------------------------
| WaveFormatterModule_Probe
+---------------------------------------------------------------------*/
BLT_METHOD
WaveFormatterModule_Probe(BLT_Module* _self,
BLT_Core* core,
BLT_ModuleParametersType parameters_type,
BLT_AnyConst parameters,
BLT_Cardinal* match)
{
WaveFormatterModule* self = ATX_SELF_EX(WaveFormatterModule, BLT_BaseModule, BLT_Module);
BLT_COMPILER_UNUSED(core);
switch (parameters_type) {
case BLT_MODULE_PARAMETERS_TYPE_MEDIA_NODE_CONSTRUCTOR:
{
BLT_MediaNodeConstructor* constructor =
(BLT_MediaNodeConstructor*)parameters;
/* the input protocol should be STREAM_PUSH and the */
/* output protocol should be STREAM_PUSH */
if ((constructor->spec.input.protocol !=
BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.input.protocol !=
BLT_MEDIA_PORT_PROTOCOL_STREAM_PUSH) ||
(constructor->spec.output.protocol !=
BLT_MEDIA_PORT_PROTOCOL_ANY &&
constructor->spec.output.protocol !=
BLT_MEDIA_PORT_PROTOCOL_STREAM_PUSH)) {
return BLT_FAILURE;
}
/* the input type should be audio/pcm */
if (constructor->spec.input.media_type->id !=
BLT_MEDIA_TYPE_ID_AUDIO_PCM) {
return BLT_FAILURE;
}
/* compute the match level */
if (constructor->name != NULL) {
/* we're being probed by name */
if (ATX_StringsEqual(constructor->name, "WaveFormatter")) {
/* our name */
*match = BLT_MODULE_PROBE_MATCH_EXACT;
} else {
/* not our name */
return BLT_FAILURE;
}
} else {
/* we're probed by protocol/type specs only */
/* the output type should be audio/wav */
if (constructor->spec.output.media_type->id !=
self->wav_type_id) {
return BLT_FAILURE;
}
*match = BLT_MODULE_PROBE_MATCH_MAX - 10;
}
ATX_LOG_FINE_1("WaveFormatterModule::Probe - Ok [%d]", *match);
return BLT_SUCCESS;
}
break;
default:
break;
}
return BLT_FAILURE;
}