/*----------------------------------------------------------------------
| 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;
}
/*----------------------------------------------------------------------
| BLT_DecoderServer_PropertyValueWrapper::BLT_DecoderServer_PropertyValueWrapper
+---------------------------------------------------------------------*/
BLT_DecoderServer_PropertyValueWrapper::BLT_DecoderServer_PropertyValueWrapper(
const ATX_PropertyValue* value)
{
if (value == NULL) {
m_Value = NULL;
return;
}
m_Value = new ATX_PropertyValue();
m_Value->type = value->type;
switch (value->type) {
case ATX_PROPERTY_VALUE_TYPE_BOOLEAN:
case ATX_PROPERTY_VALUE_TYPE_FLOAT:
case ATX_PROPERTY_VALUE_TYPE_INTEGER:
case ATX_PROPERTY_VALUE_TYPE_LARGE_INTEGER:
case ATX_PROPERTY_VALUE_TYPE_POINTER:
m_Value->data = value->data;
break;
case ATX_PROPERTY_VALUE_TYPE_STRING:
if (value->data.string) {
char* copy = new char[ATX_StringLength(value->data.string)+1];
ATX_CopyString(copy, value->data.string);
m_Value->data.string = copy;
} else {
m_Value->data.string = NULL;
}
break;
case ATX_PROPERTY_VALUE_TYPE_RAW_DATA:
if (value->data.raw_data.data &&
value->data.raw_data.size) {
m_Value->data.raw_data.size = value->data.raw_data.size;
m_Value->data.raw_data.data = new unsigned char[value->data.raw_data.size];
ATX_CopyMemory(m_Value->data.raw_data.data, value->data.raw_data.data, value->data.raw_data.size);
} else {
m_Value->data.raw_data.size = 0;
m_Value->data.raw_data.data = NULL;
}
break;
}
}
/*----------------------------------------------------------------------
| BtPlayerServer::DoSeekToTimecode
+---------------------------------------------------------------------*/
void
BtPlayerServer::DoSeekToTimecode(const char* time)
{
BLT_UInt8 val[4] = {0,0,0,0};
ATX_Size length = ATX_StringLength(time);
unsigned int val_c = 0;
bool has_dot = false;
if (length != 11 && length != 8 && length != 5 && length != 2) return;
do {
if ( time[0] >= '0' && time[0] <= '9' &&
time[1] >= '0' && time[0] <= '9' &&
(time[2] == ':' || time[2] == '.' || time[2] == '\0')) {
if (time[2] == '.') {
if (length != 5) return; // dots only on the last part
has_dot = true;
} else {
if (val_c == 3) return; // too many parts
}
val[val_c++] = (time[0]-'0')*10 + (time[1]-'0');
length -= (time[2]=='\0')?2:3;
time += 3;
} else {
return;
}
} while (length >= 2);
BLT_UInt8 h,m,s,f;
if (has_dot) --val_c;
h = val[(val_c+1)%4];
m = val[(val_c+2)%4];
s = val[(val_c+3)%4];
f = val[(val_c )%4];
m_Player.SeekToTimeStamp(h,m,s,f);
}
/*----------------------------------------------------------------------
| ATX_HttpResponse_Parse
+---------------------------------------------------------------------*/
static ATX_Result
ATX_HttpResponse_Parse(ATX_HttpResponse* response, ATX_InputStream* stream)
{
char buffer[ATX_HTTP_MAX_LINE_SIZE+1];
char* line = buffer;
char* find;
ATX_Boolean header_pending = ATX_FALSE;
ATX_String header_name = ATX_EMPTY_STRING;
ATX_String header_value = ATX_EMPTY_STRING;
ATX_Result result;
/* get the first line from the stream */
result = ATX_InputStream_ReadLine(stream, line, sizeof(buffer), NULL);
if (ATX_FAILED(result)) return result;
/* get the protocol */
find = (char*)ATX_Http_FindChar(line, ' ');
if (find == NULL) {
return ATX_ERROR_INVALID_SYNTAX;
}
*find = '\0';
ATX_String_Assign(&response->base.protocol, line);
/* get the status code */
line = (char*)ATX_Http_SkipWhitespace(find+1);
find = (char*)ATX_Http_FindChar(line, ' ');
if (find == NULL) {
return ATX_ERROR_INVALID_SYNTAX;
}
*find = '\0';
if (ATX_StringLength(line) != 3) {
return ATX_ERROR_INVALID_SYNTAX;
}
{
int i;
response->status_code = 0;
for (i=0; i<3; i++) {
if (line[i] < '0' || line[i] > '9') {
return ATX_ERROR_INVALID_SYNTAX;
}
response->status_code *= 10;
response->status_code += line[i]-'0';
}
}
/* the rest is the reason phrase */
line = (char*)ATX_Http_SkipWhitespace(find+1);
ATX_String_Assign(&response->reason_phrase, line);
/* parse headers until an empty line or end of stream */
do {
/* read a line */
result = ATX_InputStream_ReadLine(stream, line, sizeof(buffer), NULL);
if (ATX_FAILED(result)) break;
/* stop if line is empty */
if (line[0] == '\0' || line[0] == '\r' || line[0] == '\n') {
if (header_pending) {
ATX_String_TrimWhitespace(&header_value);
ATX_HttpMessage_SetHeader((ATX_HttpMessage*)response,
ATX_CSTR(header_name),
ATX_CSTR(header_value));
ATX_LOG_FINE_2("ATX_HttpResponse::Parse - %s: %s",
ATX_CSTR(header_name),
ATX_CSTR(header_value));
}
break;
}
/* process the line */
if ((line[0] == ' ' || line[0] == '\t') && header_pending) {
/* this is a line continuation */
ATX_String_Append(&header_value, line+1);
} else {
/* this is a new header */
const char* name;
const char* value;
/* add the pending header to the list */
if (header_pending) {
ATX_String_TrimWhitespace(&header_value);
ATX_HttpMessage_SetHeader((ATX_HttpMessage*)response,
ATX_CSTR(header_name),
ATX_CSTR(header_value));
ATX_LOG_FINE_2("ATX_HttpResponse::Parse - %s: %s",
ATX_CSTR(header_name),
ATX_CSTR(header_value));
}
/* parse header name */
name = ATX_Http_SkipWhitespace(line);
value = ATX_Http_FindChar(name, ':');
ATX_String_AssignN(&header_name, name, (ATX_Size)(value-name));
value = ATX_Http_SkipWhitespace(value+1);
ATX_String_Assign(&header_value, value);
/* don't add the header now, it could be continued */
header_pending = ATX_TRUE;
}
} while(ATX_SUCCEEDED(result));
/* keep a reference to the stream */
response->base.body = stream;
ATX_REFERENCE_OBJECT(stream);
/* cleanup */
ATX_String_Destruct(&header_name);
ATX_String_Destruct(&header_value);
return ATX_SUCCESS;
}
/*----------------------------------------------------------------------
| FileOutput_Create
+---------------------------------------------------------------------*/
static BLT_Result
FileOutput_Create(BLT_Module* module,
BLT_Core* core,
BLT_ModuleParametersType parameters_type,
BLT_CString parameters,
BLT_MediaNode** object)
{
FileOutput* self;
BLT_MediaNodeConstructor* constructor = (BLT_MediaNodeConstructor*)parameters;
BLT_Result result;
ATX_LOG_FINE("FileOutput::Create");
/* check parameters */
*object = NULL;
if (parameters == NULL ||
parameters_type != BLT_MODULE_PARAMETERS_TYPE_MEDIA_NODE_CONSTRUCTOR) {
return BLT_ERROR_INVALID_PARAMETERS;
}
/* check the name */
if (constructor->name == NULL || ATX_StringLength(constructor->name) < 4) {
return BLT_ERROR_INVALID_PARAMETERS;
}
/* allocate memory for the object */
self = ATX_AllocateZeroMemory(sizeof(FileOutput));
if (self == NULL) {
return BLT_ERROR_OUT_OF_MEMORY;
}
/* construct the inherited object */
BLT_BaseMediaNode_Construct(&ATX_BASE(self, BLT_BaseMediaNode), module, core);
/* figure out the media type */
if (constructor->spec.input.media_type->id == BLT_MEDIA_TYPE_ID_UNKNOWN) {
/* unknown type, try to figure it out from the file extension */
BLT_MediaType_Clone(&BLT_MediaType_Unknown, &self->media_type);
result = FileOutput_DecideMediaType(self, constructor->name);
if (BLT_FAILED(result)) {
/* if the type is not found, assume audio/pcm */
BLT_PcmMediaType pcm_type;
BLT_PcmMediaType_Init(&pcm_type);
BLT_MediaType_Clone((BLT_MediaType*)&pcm_type, &self->media_type);
}
} else {
/* use the media type from the input spec */
BLT_MediaType_Clone(constructor->spec.input.media_type,
&self->media_type);
}
/* create the output file object */
result = ATX_File_Create(constructor->name+5, &self->file);
if (BLT_FAILED(result)) {
self->file = NULL;
goto failure;
}
/* open the output file */
result = ATX_File_Open(self->file,
ATX_FILE_OPEN_MODE_WRITE |
ATX_FILE_OPEN_MODE_CREATE |
ATX_FILE_OPEN_MODE_TRUNCATE);
if (ATX_FAILED(result)) goto failure;
/* get the output stream */
result = ATX_File_GetOutputStream(self->file, &self->stream);
if (BLT_FAILED(result)) {
self->stream = NULL;
goto failure;
}
/* setup interfaces */
ATX_SET_INTERFACE_EX(self, FileOutput, BLT_BaseMediaNode, BLT_MediaNode);
ATX_SET_INTERFACE_EX(self, FileOutput, BLT_BaseMediaNode, ATX_Referenceable);
ATX_SET_INTERFACE(self, FileOutput, BLT_OutputStreamProvider);
ATX_SET_INTERFACE(self, FileOutput, BLT_OutputNode);
ATX_SET_INTERFACE(self, FileOutput, BLT_MediaPort);
*object = &ATX_BASE_EX(self, BLT_BaseMediaNode, BLT_MediaNode);
return BLT_SUCCESS;
failure:
FileOutput_Destroy(self);
*object = NULL;
return result;
}
