/*----------------------------------------------------------------------
| AlsaOutput_Create
+---------------------------------------------------------------------*/
static BLT_Result
AlsaOutput_Create(BLT_Module* module,
BLT_Core* core,
BLT_ModuleParametersType parameters_type,
BLT_AnyConst parameters,
BLT_MediaNode** object)
{
AlsaOutput* output;
BLT_MediaNodeConstructor* constructor =
(BLT_MediaNodeConstructor*)parameters;
ATX_LOG_FINE("creating output");
/* check parameters */
if (parameters == NULL ||
parameters_type != BLT_MODULE_PARAMETERS_TYPE_MEDIA_NODE_CONSTRUCTOR) {
return BLT_ERROR_INVALID_PARAMETERS;
}
/* allocate memory for the object */
output = ATX_AllocateZeroMemory(sizeof(AlsaOutput));
if (output == NULL) {
*object = NULL;
return BLT_ERROR_OUT_OF_MEMORY;
}
/* construct the inherited object */
BLT_BaseMediaNode_Construct(&ATX_BASE(output, BLT_BaseMediaNode), module, core);
/* construct the object */
output->state = BLT_ALSA_OUTPUT_STATE_CLOSED;
output->device_handle = NULL;
output->media_type.sample_rate = 0;
output->media_type.channel_count = 0;
output->media_type.bits_per_sample = 0;
/* parse the name */
if (constructor->name && ATX_StringLength(constructor->name) > 5) {
output->device_name = ATX_String_Create(constructor->name+5);
} else {
output->device_name = ATX_String_Create("default");
}
/* setup the expected media type */
BLT_PcmMediaType_Init(&output->expected_media_type);
/* setup interfaces */
ATX_SET_INTERFACE_EX(output, AlsaOutput, BLT_BaseMediaNode, BLT_MediaNode);
ATX_SET_INTERFACE_EX(output, AlsaOutput, BLT_BaseMediaNode, ATX_Referenceable);
ATX_SET_INTERFACE(output, AlsaOutput, BLT_PacketConsumer);
ATX_SET_INTERFACE(output, AlsaOutput, BLT_OutputNode);
ATX_SET_INTERFACE(output, AlsaOutput, BLT_MediaPort);
*object = &ATX_BASE_EX(output, BLT_BaseMediaNode, BLT_MediaNode);
return BLT_SUCCESS;
}
/*----------------------------------------------------------------------
| ATX_HttpHeader_Create
+---------------------------------------------------------------------*/
static ATX_Result
ATX_HttpHeader_Create(ATX_CString name,
ATX_CString value,
ATX_HttpHeader** header)
{
/* allocate a new object */
*header = (ATX_HttpHeader*)ATX_AllocateZeroMemory(sizeof(ATX_HttpHeader));
if (*header == NULL) {
return ATX_ERROR_OUT_OF_MEMORY;
}
/* construct the object */
(*header)->name = ATX_String_Create(name);
(*header)->value = ATX_String_Create(value);
return ATX_SUCCESS;
}
/*----------------------------------------------------------------------
| ATX_HttpMessage_Construct
+---------------------------------------------------------------------*/
static ATX_Result
ATX_HttpMessage_Construct(ATX_HttpMessage* message)
{
ATX_Result result;
/* construct the object */
result = ATX_List_Create(&message->headers);
if (ATX_FAILED(result)) return result;
/* set the default protocol */
message->protocol = ATX_String_Create(ATX_HTTP_DEFAULT_PROTOCOL);
return ATX_SUCCESS;
}
/*----------------------------------------------------------------------
| BLT_TcpNetworkStream_Create
+---------------------------------------------------------------------*/
BLT_Result
BLT_TcpNetworkStream_Create(const char* name, ATX_InputStream** stream)
{
ATX_Socket* sock;
ATX_String hostname = ATX_String_Create(name);
ATX_UInt16 port = BLT_TCP_NETWORK_STREAM_DEFAULT_PORT;
int sep;
ATX_Result result = ATX_SUCCESS;
/* default */
*stream = NULL;
/* parse the hostname/port */
sep = ATX_String_FindCharFrom(&hostname, ':', 6);
if (sep > 0) {
/* we have a port number */
int port_long = 0;
result = ATX_ParseInteger(name+sep+1, &port_long, ATX_FALSE);
if (ATX_FAILED(result)) {
ATX_LOG_WARNING("BLT_TcpNetworkStream_Create - invalid port spec");
goto end;
}
port = (ATX_UInt16)port_long;
ATX_String_SetLength(&hostname, sep);
}
/* create a socket */
result = ATX_TcpClientSocket_Create(&sock);
if (ATX_FAILED(result)) goto end;
/* connect */
ATX_LOG_FINE_2("BLT_TcpNetworkStream_Create - connecting to %s:%d",
ATX_CSTR(hostname), port);
result = ATX_Socket_ConnectToHost(sock, ATX_CSTR(hostname), port, BLT_TCP_NETWORK_STREAM_DEFAULT_TIMEOUT);
if (ATX_FAILED(result)) {
ATX_LOG_WARNING_1("BLT_TcpNetworkStream_Create - failed to connect (%d)", result);
goto end;
}
ATX_LOG_FINE("BLT_TcpNetworkStream_Create - connected");
/* return the input stream */
result = ATX_Socket_GetInputStream(sock, stream);
/* release the socket */
ATX_DESTROY_OBJECT(sock);
end:
ATX_String_Destruct(&hostname);
return result;
}
/*----------------------------------------------------------------------
| Listener_Create
+---------------------------------------------------------------------*/
ATX_METHOD
Listener_Create(ATX_CString name,
ATX_PropertyListener** object)
{
/* allocate the object */
Listener* listener = (Listener*)ATX_AllocateMemory(sizeof(Listener));
if (listener == NULL) {
*object = NULL;
return ATX_ERROR_OUT_OF_MEMORY;
}
/* construct the object */
listener->name = ATX_String_Create(name);
/* setup the interfaces */
ATX_SET_INTERFACE(listener, Listener, ATX_PropertyListener);
ATX_SET_INTERFACE(listener, Listener, ATX_Destroyable);
*object = &ATX_BASE(listener, ATX_PropertyListener);
return ATX_SUCCESS;
}
/*----------------------------------------------------------------------
| ATX_HttpRequest_Create
+---------------------------------------------------------------------*/
ATX_Result
ATX_HttpRequest_Create(ATX_CString method,
ATX_CString url,
ATX_HttpRequest** request)
{
ATX_Result result;
/* allocate a new object */
*request = (ATX_HttpRequest*)ATX_AllocateZeroMemory(sizeof(ATX_HttpRequest));
if (*request == NULL) {
return ATX_ERROR_OUT_OF_MEMORY;
}
/* construct the base object */
result = ATX_HttpMessage_Construct(&(*request)->base);
if (ATX_FAILED(result)) {
ATX_FreeMemory((void*)request);
return result;
}
/* construct the object */
(*request)->method = ATX_String_Create(method);
result = ATX_HttpUrl_Construct(&(*request)->url, url);
if (ATX_FAILED(result)) {
ATX_HttpMessage_Destruct(&(*request)->base);
ATX_FreeMemory((void*)request);
return result;
}
/* set the host header */
if (!ATX_String_IsEmpty(&(*request)->url.host)) {
ATX_HttpMessage_SetHeader((ATX_HttpMessage*)(*request),
ATX_HTTP_HEADER_HOST,
ATX_CSTR((*request)->url.host));
}
return ATX_SUCCESS;
}
/*----------------------------------------------------------------------
| 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;
}
/*----------------------------------------------------------------------
| ATX_HttpUrl_Construct
+---------------------------------------------------------------------*/
static ATX_Result
ATX_HttpUrl_Construct(ATX_HttpUrl* self, const char* url)
{
ATX_HttpUrl_ParserState state;
const char* mark;
char c;
/* set default values */
ATX_INIT_STRING(self->username);
ATX_INIT_STRING(self->password);
ATX_INIT_STRING(self->host);
self->port = ATX_HTTP_DEFAULT_PORT;
self->path = ATX_String_Create("/");
/* check parameters */
if (url == NULL) return ATX_ERROR_INVALID_PARAMETERS;
/* check that this is an http url */
if ((url[0] != 'h' && url[0] != 'H') ||
(url[1] != 't' && url[1] != 'T') ||
(url[2] != 't' && url[2] != 'T') ||
(url[3] != 'p' && url[3] != 'P') ||
(url[4] != ':')) {
return ATX_ERROR_INVALID_SYNTAX;
}
/* intialize the parser */
state = ATX_HTTP_URL_PARSER_STATE_START;
url+= 5;
mark = url;
/* parse the URL */
do {
c = *url++;
switch (state) {
case ATX_HTTP_URL_PARSER_STATE_START:
if (c == '/') {
state = ATX_HTTP_URL_PARSER_STATE_LEADING_SLASH;
} else {
return ATX_ERROR_INVALID_SYNTAX;
}
break;
case ATX_HTTP_URL_PARSER_STATE_LEADING_SLASH:
if (c == '/') {
state = ATX_HTTP_URL_PARSER_STATE_HOST;
mark = url;
} else {
return ATX_ERROR_INVALID_SYNTAX;
}
break;
case ATX_HTTP_URL_PARSER_STATE_HOST:
if (c == ':') {
ATX_String_AssignN(&self->host, mark, (ATX_Size)(url-mark));
state = ATX_HTTP_URL_PARSER_STATE_PORT;
} else if (c == '/' || c == 0) {
ATX_String_AssignN(&self->host, mark, (ATX_Size)(url-1-mark));
self->port = ATX_HTTP_DEFAULT_PORT;
if (c == '/') ATX_String_Append(&self->path, url);
return ATX_SUCCESS;
}
break;
case ATX_HTTP_URL_PARSER_STATE_PORT:
if (c >= '0' && c <= '9') {
self->port = self->port*10+(c-'0');
} else if (c == '/' || c == 0) {
if (c == '/') ATX_String_Append(&self->path, url);
return ATX_SUCCESS;
} else {
/* invalid character */
self->port = ATX_HTTP_INVALID_PORT;
return ATX_ERROR_INVALID_SYNTAX;
}
}
} while (c);
return ATX_SUCCESS;
}
