void Connection::detectDisconnect(ReplyPtr reply,
const boost::function<void()>& callback)
{
disconnectCallback_ = callback;
readMore(reply, 0);
}
void StreamingPlayer::initialize(
const t3::FilePath& path,
const int read_byte
) {
// 一回でバッファリングするバイト数
read_byte_ = read_byte;
// バッファリング領域確保
for (int i = 0; i < BUFFER_SIZE; ++i) {
buffer_[i].storage_ = (uint8_t*)T3_SYS_ALLOC(read_byte);
buffer_id_[i] = createBuffer();
}
// wav 一部読み込み
wav_.openstream(path);
cross::AudioSystem::queueBuffers(
source_id_,
buffer_id_.size(),
&buffer_id_[0]
);
readMore();
}
void SfDelegate::onInitiateRead(void *data, size_t size) {
CHECK(mURLRequest != NULL);
mNumBytesRead = 0;
mNumBytesTotal = size;
mDataDestination = data;
if (mAtEOS) {
mOwner->onReadCompleted(0);
return;
}
readMore(mURLRequest);
}
void StreamingPlayer::processBuffer(
const cross::AudioSystem::BufferID id
) {
readMore();
switchCurrentBuffer();
if (currentBufferSize() == 0) {
// もう読み込みバッファが無い
return;
}
cross::AudioSystem::setBufferData(
id,
cross::AudioSystem::format(wav_.channel(), wav_.bitPerSample()),
currentBufferStorage(),
currentBufferSize(),
wav_.samplingRate()
);
}
XMLSize_t
CurlURLInputStream::readBytes(XMLByte* const toFill
, const XMLSize_t maxToRead)
{
fBytesRead = 0;
fBytesToRead = maxToRead;
fWritePtr = toFill;
for (bool tryAgain = true; fBytesToRead > 0 && (tryAgain || fBytesRead == 0); )
{
// First, any buffered data we have available
XMLSize_t bufCnt = fBufferHeadPtr - fBufferTailPtr;
bufCnt = (bufCnt > fBytesToRead) ? fBytesToRead : bufCnt;
if (bufCnt > 0)
{
memcpy(fWritePtr, fBufferTailPtr, bufCnt);
fWritePtr += bufCnt;
fBytesRead += bufCnt;
fTotalBytesRead += bufCnt;
fBytesToRead -= bufCnt;
fBufferTailPtr += bufCnt;
if (fBufferTailPtr == fBufferHeadPtr)
fBufferHeadPtr = fBufferTailPtr = fBuffer;
//printf("consuming %d buffered bytes\n", bufCnt);
tryAgain = true;
continue;
}
// Ask the curl to do some work
int runningHandles = 0;
tryAgain = readMore(&runningHandles);
// If nothing is running any longer, bail out
if (runningHandles == 0)
break;
}
return fBytesRead;
}
void CBufferedStream::ensureSize(si64 size)
{
while (buffer.size() < size && !endOfFileReached)
{
si64 initialSize = buffer.size();
si64 currentStep = std::min<si64>(size, buffer.size());
vstd::amax(currentStep, 1024); // to avoid large number of calls at start
buffer.resize(initialSize + currentStep);
si64 readSize = readMore(buffer.data() + initialSize, currentStep);
if (readSize != currentStep)
{
endOfFileReached = true;
buffer.resize(initialSize + readSize);
buffer.shrink_to_fit();
return;
}
}
}
void
CPacketStreamFilter::filterEvent(const CEvent& event)
{
if (event.getType() == getInputReadyEvent()) {
CLock lock(&m_mutex);
if (!readMore()) {
return;
}
}
else if (event.getType() == getInputShutdownEvent()) {
// discard this if we have buffered data
CLock lock(&m_mutex);
m_inputShutdown = true;
if (m_size != 0) {
return;
}
}
// pass event
CStreamFilter::filterEvent(event);
}
void
PacketStreamFilter::filterEvent(const Event& event)
{
if (event.getType() == m_events->forIStream().inputReady()) {
Lock lock(&m_mutex);
if (!readMore()) {
return;
}
}
else if (event.getType() == m_events->forIStream().inputShutdown()) {
// discard this if we have buffered data
Lock lock(&m_mutex);
m_inputShutdown = true;
if (m_size != 0) {
return;
}
}
// pass event
StreamFilter::filterEvent(event);
}
void SfDelegate::OnReadCompleted(net::URLRequest *request, int bytes_read) {
if (bytes_read == -1) {
MY_LOGI(StringPrintf(
"OnReadCompleted, read failed, status %d",
request->status().status()).c_str());
mOwner->onReadCompleted(ERROR_IO);
return;
}
MY_LOGV(StringPrintf("OnReadCompleted, read %d bytes", bytes_read).c_str());
if (bytes_read < 0) {
MY_LOGI(StringPrintf(
"Read failed w/ status %d\n",
request->status().status()).c_str());
mOwner->onReadCompleted(ERROR_IO);
return;
} else if (bytes_read == 0) {
mAtEOS = true;
mOwner->onReadCompleted(mNumBytesRead);
return;
}
CHECK_GT(bytes_read, 0);
CHECK_LE(mNumBytesRead + bytes_read, mNumBytesTotal);
memcpy((uint8_t *)mDataDestination + mNumBytesRead,
mReadBuffer->data(),
bytes_read);
mNumBytesRead += bytes_read;
readMore(request);
}
void Connection::handleReadBody(ReplyPtr reply)
{
if (request_.type != Request::WebSocket) {
/*
* For a WebSocket: reading and writing may happen in parallel,
* And writing and reading is asynchronous (post() from within
* WtReply::consumeWebSocketMessage()
*/
haveResponse_ = false;
waitingResponse_ = true;
}
RequestParser::ParseResult result = request_parser_
.parseBody(request_, reply, rcv_remaining_,
rcv_buffers_.back().data() + rcv_buffer_size_);
if (request_.type != Request::WebSocket)
waitingResponse_ = false;
if (result == RequestParser::ReadMore) {
readMore(reply, BODY_TIMEOUT);
} else if (result == RequestParser::Done && haveResponse_)
startWriteResponse(reply);
}
XERCES_CPP_NAMESPACE_BEGIN
CurlURLInputStream::CurlURLInputStream(const XMLURL& urlSource, const XMLNetHTTPInfo* httpInfo/*=0*/)
: fMulti(0)
, fEasy(0)
, fMemoryManager(urlSource.getMemoryManager())
, fURLSource(urlSource)
, fTotalBytesRead(0)
, fWritePtr(0)
, fBytesRead(0)
, fBytesToRead(0)
, fDataAvailable(false)
, fBufferHeadPtr(fBuffer)
, fBufferTailPtr(fBuffer)
, fPayload(0)
, fPayloadLen(0)
, fContentType(0)
{
// Allocate the curl multi handle
fMulti = curl_multi_init();
// Allocate the curl easy handle
fEasy = curl_easy_init();
// Set URL option
TranscodeToStr url(fURLSource.getURLText(), "ISO8859-1", fMemoryManager);
curl_easy_setopt(fEasy, CURLOPT_URL, (char*)url.str());
// Set up a way to recieve the data
curl_easy_setopt(fEasy, CURLOPT_WRITEDATA, this); // Pass this pointer to write function
curl_easy_setopt(fEasy, CURLOPT_WRITEFUNCTION, staticWriteCallback); // Our static write function
// Do redirects
curl_easy_setopt(fEasy, CURLOPT_FOLLOWLOCATION, (long)1);
curl_easy_setopt(fEasy, CURLOPT_MAXREDIRS, (long)6);
// Add username and password if authentication is required
const XMLCh *username = urlSource.getUser();
const XMLCh *password = urlSource.getPassword();
if(username && password) {
XMLBuffer userPassBuf(256, fMemoryManager);
userPassBuf.append(username);
userPassBuf.append(chColon);
userPassBuf.append(password);
TranscodeToStr userPass(userPassBuf.getRawBuffer(), "ISO8859-1", fMemoryManager);
curl_easy_setopt(fEasy, CURLOPT_HTTPAUTH, (long)CURLAUTH_ANY);
curl_easy_setopt(fEasy, CURLOPT_USERPWD, (char*)userPass.str());
}
if(httpInfo) {
// Set the correct HTTP method
switch(httpInfo->fHTTPMethod) {
case XMLNetHTTPInfo::GET:
break;
case XMLNetHTTPInfo::PUT:
curl_easy_setopt(fEasy, CURLOPT_UPLOAD, (long)1);
break;
case XMLNetHTTPInfo::POST:
curl_easy_setopt(fEasy, CURLOPT_POST, (long)1);
break;
}
// Add custom headers
if(httpInfo->fHeaders) {
struct curl_slist *headersList = 0;
const char *headersBuf = httpInfo->fHeaders;
const char *headersBufEnd = httpInfo->fHeaders + httpInfo->fHeadersLen;
const char *headerStart = headersBuf;
while(headersBuf < headersBufEnd) {
if(*headersBuf == '\r' && (headersBuf + 1) < headersBufEnd &&
*(headersBuf + 1) == '\n') {
XMLSize_t length = headersBuf - headerStart;
ArrayJanitor<char> header((char*)fMemoryManager->allocate((length + 1) * sizeof(char)),
fMemoryManager);
memcpy(header.get(), headerStart, length);
header.get()[length] = 0;
headersList = curl_slist_append(headersList, header.get());
headersBuf += 2;
headerStart = headersBuf;
continue;
}
++headersBuf;
}
curl_easy_setopt(fEasy, CURLOPT_HTTPHEADER, headersList);
curl_slist_free_all(headersList);
}
// Set up the payload
if(httpInfo->fPayload) {
fPayload = httpInfo->fPayload;
fPayloadLen = httpInfo->fPayloadLen;
curl_easy_setopt(fEasy, CURLOPT_READDATA, this);
curl_easy_setopt(fEasy, CURLOPT_READFUNCTION, staticReadCallback);
curl_easy_setopt(fEasy, CURLOPT_INFILESIZE_LARGE, (curl_off_t)fPayloadLen);
}
}
// Add easy handle to the multi stack
curl_multi_add_handle(fMulti, fEasy);
// Start reading, to get the content type
while(fBufferHeadPtr == fBuffer)
{
int runningHandles = 0;
readMore(&runningHandles);
if(runningHandles == 0) break;
}
// Find the content type
char *contentType8 = 0;
curl_easy_getinfo(fEasy, CURLINFO_CONTENT_TYPE, &contentType8);
if(contentType8)
fContentType = TranscodeFromStr((XMLByte*)contentType8, XMLString::stringLen(contentType8), "ISO8859-1", fMemoryManager).adopt();
}
static BSErr findXMLTag(XMLParser* parser)
{
BSErr err = BSERR_OK;
BSErr parseErr = BSERR_INVAILD;
unsigned char c;
while (err == BSERR_OK) {
//printf("-\n");
if ((err = readMore(parser)) != BSERR_OK) break;
if (parser->size == 0) break;
{
c = (unsigned char)parser->buffer[parser->ptr++];
//printf("%c",c);
if (c <= 0x20 && parser->openclose != XMLPARSER_OPEN) {
} else if (c == '<') {
//タグ内部の解析
int space = 0;
parseErr = BSERR_INVAILD;
if ((err = startTag(parser)) != BSERR_OK) break;
while (err == BSERR_OK) {
if ((err = readMore(parser)) != BSERR_OK) break;
if (parser->size == 0) break;
c = (unsigned char)parser->buffer[parser->ptr++];
if (c == '=') {
if (parser->strptr > 0) {
err = foundTag(parser,stringPtr(parser));
resetStr(parser);
}
while (err == BSERR_OK) {
if ((err = readMore(parser)) != BSERR_OK) break;
if (parser->size == 0) break;
c = (unsigned char)parser->buffer[parser->ptr++];
if (c <= 0x20) {
} else if (c == '\"') {
while (err == BSERR_OK) {
if ((err = readMore(parser)) != BSERR_OK) break;
if (parser->size == 0) break;
c = (unsigned char)parser->buffer[parser->ptr++];
if (c == '\"') {
if (parser->strptr > 0) {
err = foundAtr(parser,stringPtr(parser));
resetStr(parser);
}
break;
} else {
err = appendChar(parser,c);
}
}
break;
} else {
err = BSERR_INVAILD;
}
}
} else if (c == '?') {
if (parser->strptr > 0) {
err = foundTag(parser,stringPtr(parser));
resetStr(parser);
}
err = appendChar(parser,c);
err = foundTag(parser,stringPtr(parser));
resetStr(parser);
} else if (c == '/') {
if (parser->strptr > 0) {
err = foundTag(parser,stringPtr(parser));
resetStr(parser);
}
err = appendChar(parser,c);
err = foundTag(parser,stringPtr(parser));
resetStr(parser);
} else if (c <= 0x20) {
if (space == 0) {
if (parser->strptr > 0) {
err = foundTag(parser,stringPtr(parser));
resetStr(parser);
}
}
space = 1;
} else if (c == '>') {
if (parser->strptr > 0) {
err = foundTag(parser,stringPtr(parser));
resetStr(parser);
}
//printf("et-");
err = endTag(parser);
//printf("et\n");
parseErr = BSERR_OK;
break;
} else {
err = appendChar(parser,c);
space = 0;
}
}
} else {
//文字列の解析
int space = 0;
parseErr = BSERR_INVAILD;
if ((err = startDoc(parser)) != BSERR_OK) break;
if (c <= 0x20) {
space = 1;
}
parser->ptr --;
while (err == BSERR_OK) {
if ((err = readMore(parser)) != BSERR_OK) break;
if (parser->size == 0) break;
c = (unsigned char)parser->buffer[parser->ptr++];
if (c <= 0x20) {
if (parser->strptr > 0 && space == 0) {
err = foundDoc(parser,stringPtr(parser));
resetStr(parser);
}
space = 1;
err = appendChar(parser,c);
} else if (c == '<') {
if (parser->strptr > 0) {
err = foundDoc(parser,stringPtr(parser));
resetStr(parser);
}
//printf("e-");
err = endDoc(parser);
//printf("e\n");
parser->ptr --;
break;
} else {
if (parser->strptr > 0 && space == 1) {
err = foundDoc(parser,stringPtr(parser));
resetStr(parser);
}
err = appendChar(parser,c);
space = 0;
}
}
}
}
}
if (parseErr != BSERR_OK) {
return parseErr;
}
return err;
}
