/*----------------------------------------------------------------------
| ATX_HttpMessage_GetBody
+---------------------------------------------------------------------*/
ATX_Result
ATX_HttpMessage_GetBody(const ATX_HttpMessage* self,
ATX_InputStream* stream,
ATX_Size* content_length)
{
/* return a reference to the stream */
if (stream) {
stream = self->body;
ATX_REFERENCE_OBJECT(stream);
}
/* return the content length */
if (content_length) {
const ATX_String* length_string =
ATX_HttpMessage_GetHeader(self, ATX_HTTP_HEADER_CONTENT_LENGTH);
if (length_string && self->body) {
int length = 0;
if (ATX_SUCCEEDED(ATX_String_ToInteger(length_string, &length, ATX_TRUE))) {
*content_length = (ATX_Size)length;
}
} else {
*content_length = 0;
}
}
return ATX_SUCCESS;
}
/*----------------------------------------------------------------------
| WaveParserOutput_GetStream
+---------------------------------------------------------------------*/
BLT_METHOD
WaveParserOutput_GetStream(BLT_InputStreamProvider* _self,
ATX_InputStream** stream)
{
WaveParser* self = ATX_SELF_M(output, WaveParser, BLT_InputStreamProvider);
*stream = self->output.stream;
ATX_REFERENCE_OBJECT(*stream);
return BLT_SUCCESS;
}
/*----------------------------------------------------------------------
| WaveFormatterOutput_SetStream
+---------------------------------------------------------------------*/
BLT_METHOD
WaveFormatterOutput_SetStream(BLT_OutputStreamUser* _self,
ATX_OutputStream* stream)
{
WaveFormatter* self = ATX_SELF_M(output, WaveFormatter, BLT_OutputStreamUser);
/* keep a reference to the stream */
self->output.stream = stream;
ATX_REFERENCE_OBJECT(stream);
return BLT_SUCCESS;
}
/*----------------------------------------------------------------------
| BLT_Decoder_OutputChanged
+---------------------------------------------------------------------*/
static void
BLT_Decoder_OutputChanged(BLT_Decoder* decoder, BLT_MediaNode* node)
{
ATX_RELEASE_OBJECT(decoder->output);
if (node) {
decoder->output = ATX_CAST(node, BLT_OutputNode);
if (decoder->output) {
ATX_REFERENCE_OBJECT(decoder->output);
}
} else {
decoder->output = NULL;
}
}
/*----------------------------------------------------------------------
| DcfParserOutput_GetStream
+---------------------------------------------------------------------*/
BLT_METHOD
DcfParserOutput_GetStream(BLT_InputStreamProvider* _self,
ATX_InputStream** stream)
{
DcfParserOutput* self = ATX_SELF(DcfParserOutput, BLT_InputStreamProvider);
// copy our stream pointer
*stream = self->stream;
if (self->stream == NULL) return BLT_ERROR_INVALID_MEDIA_FORMAT;
// give a reference count to the caller
ATX_REFERENCE_OBJECT(*stream);
return BLT_SUCCESS;
}
/*----------------------------------------------------------------------
| ATX_HttpMessage_SetBody
+---------------------------------------------------------------------*/
ATX_Result
ATX_HttpMessage_SetBody(ATX_HttpMessage* self,
ATX_InputStream* stream,
ATX_Size content_length)
{
ATX_RELEASE_OBJECT(self->body);
self->body = stream;
ATX_REFERENCE_OBJECT(stream);
/* recompute the content length header */
if (stream) {
char length_string[32];
ATX_Http_NumToAscii(length_string, content_length);
ATX_HttpMessage_SetHeader(self, ATX_HTTP_HEADER_CONTENT_LENGTH,
length_string);
}
return ATX_SUCCESS;
}
/*----------------------------------------------------------------------
| FileOutput_GetStream
+---------------------------------------------------------------------*/
BLT_METHOD
FileOutput_GetStream(BLT_OutputStreamProvider* _self,
ATX_OutputStream** stream,
const BLT_MediaType* media_type)
{
FileOutput* self = ATX_SELF(FileOutput, BLT_OutputStreamProvider);
*stream = self->stream;
ATX_REFERENCE_OBJECT(*stream);
/* we're providing the stream, but we *receive* the type */
if (media_type) {
if (self->media_type->id == BLT_MEDIA_TYPE_ID_UNKNOWN) {
BLT_MediaType_Free(self->media_type);
BLT_MediaType_Clone(media_type, &self->media_type);
} else if (self->media_type->id != media_type->id) {
return BLT_ERROR_INVALID_MEDIA_TYPE;
}
}
return BLT_SUCCESS;
}
/*----------------------------------------------------------------------
| AdtsParserInput_SetStream
+---------------------------------------------------------------------*/
BLT_METHOD
AdtsParserInput_SetStream(BLT_InputStreamUser* _self,
ATX_InputStream* stream,
const BLT_MediaType* media_type)
{
AdtsParserInput* self = ATX_SELF(AdtsParserInput, BLT_InputStreamUser);
static BLT_UInt32 first_enter = 1;
BLT_Position where;
BLT_LargeSize stream_size;
BLT_StreamInfo info;
/* check media type */
if (media_type == NULL || media_type->id != self->media_type.id) {
return BLT_ERROR_INVALID_MEDIA_TYPE;
}
/* if we had a stream, release it */
ATX_RELEASE_OBJECT(self->stream);
/* keep a reference to the stream */
self->stream = stream;
ATX_REFERENCE_OBJECT(stream);
AdtsParser* pParser = ATX_SELF_M(input, AdtsParser, BLT_InputStreamUser);
/*count file size*/
if(first_enter){
/* update the stream info */
ATX_InputStream_GetSize(pParser->input.stream, &stream_size);
info.size = stream_size;
if (ATX_BASE(pParser, BLT_BaseMediaNode).context) {
info.mask = BLT_STREAM_INFO_MASK_SIZE;
BLT_Stream_SetInfo(ATX_BASE(pParser, BLT_BaseMediaNode).context, &info);
}
first_enter = 0;
}
return BLT_SUCCESS;
}
/*----------------------------------------------------------------------
| WaveFormatterInputPort_GetStream
+---------------------------------------------------------------------*/
BLT_METHOD
WaveFormatterInput_GetStream(BLT_OutputStreamProvider* _self,
ATX_OutputStream** stream,
const BLT_MediaType* media_type)
{
WaveFormatter* self = ATX_SELF_M(input, WaveFormatter, BLT_OutputStreamProvider);
/* check that we have a stream */
if (self->output.stream == NULL) return BLT_ERROR_PORT_HAS_NO_STREAM;
/* return our output stream */
*stream = self->output.stream;
ATX_REFERENCE_OBJECT(*stream);
/* we're providing the stream, but we *receive* the type */
if (media_type) {
if (media_type->id != BLT_MEDIA_TYPE_ID_AUDIO_PCM) {
return BLT_ERROR_INVALID_MEDIA_TYPE;
} else {
/* copy the input type parameters */
self->input.media_type = *(const BLT_PcmMediaType*)media_type;
}
}
/* write a header unless the output stream already has some data */
/* (this might be due to the fact that we're writing more than */
/* one input stream into the same output stream */
{
ATX_Position where = 0;
ATX_OutputStream_Tell(self->output.stream, &where);
if (where == 0) {
WaveFormatter_WriteWavHeader(self, &self->input.media_type);
}
}
return BLT_SUCCESS;
}
/*----------------------------------------------------------------------
| 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;
}
