/*----------------------------------------------------------------------
| CMediaCrawler::ProcessFileRequest
+---------------------------------------------------------------------*/
NPT_Result
CMediaCrawler::ProcessFileRequest(NPT_HttpRequest& request,
NPT_HttpResponse& response,
NPT_SocketInfo& info)
{
NPT_COMPILER_UNUSED(info);
NPT_LOG_FINE("CMediaCrawler::ProcessFileRequest Received Request:");
PLT_LOG_HTTP_MESSAGE(NPT_LOG_LEVEL_FINE, &request);
if (request.GetMethod().Compare("GET") && request.GetMethod().Compare("HEAD")) {
response.SetStatus(500, "Internal Server Error");
return NPT_SUCCESS;
}
// add the user agent header, some stupid media servers like YME needs it
if (!request.GetHeaders().GetHeader(NPT_HTTP_HEADER_USER_AGENT)) {
request.GetHeaders().SetHeader(NPT_HTTP_HEADER_USER_AGENT,
"Platinum/" PLT_PLATINUM_VERSION_STRING);
}
// File requested
NPT_HttpResponse* out_response = NULL;
NPT_HttpUrlQuery query(request.GetUrl().GetQuery());
const char* url = query.GetField("url");
if (url) {
// look for handler
CStreamHandler* handler = NULL;
NPT_ContainerFind(m_StreamHandlers, CStreamHandlerFinder(NULL, url), handler);
if (handler && NPT_SUCCEEDED(handler->ProcessFileRequest(request, out_response)) && out_response) {
// copy response code and reason
response.SetStatus(out_response->GetStatusCode(), out_response->GetReasonPhrase());
// copy headers
NPT_List<NPT_HttpHeader*>::Iterator headers = out_response->GetHeaders().GetHeaders().GetFirstItem();
while (headers) {
response.GetHeaders().SetHeader((*headers)->GetName(), (*headers)->GetValue());
++headers;
}
response.SetEntity(new NPT_HttpEntity(response.GetHeaders()));
// update inputstream
NPT_HttpEntity* out_entity;
if ((out_entity = out_response->GetEntity()) != NULL) {
NPT_InputStreamReference inputstream;
out_entity->GetInputStream(inputstream);
if (!inputstream.IsNull()) {
// set the stream but do not update the content length
response.GetEntity()->SetInputStream(inputstream, false);
}
}
delete out_response;
return NPT_SUCCESS;
}
}
response.SetStatus(404, "File Not Found");
return NPT_SUCCESS;
}
NPT_Result SetupResponse(NPT_HttpRequest& /*request*/,
const NPT_HttpRequestContext& /*context*/,
NPT_HttpResponse& response) {
NPT_HttpEntity* entity = response.GetEntity();
entity->SetContentType("text/html");
return NPT_SUCCESS;
}
NPT_Result SetupResponse(NPT_HttpRequest& /*request*/,
const NPT_HttpRequestContext& /*context*/,
NPT_HttpResponse& response) {
NPT_HttpEntity* entity = response.GetEntity();
entity->SetContentType("text/html");
entity->SetTransferEncoding("chunked");
response.SetProtocol(NPT_HTTP_PROTOCOL_1_1);
return NPT_SUCCESS;
}
NPT_Result SetupResponse(NPT_HttpRequest& /*request*/,
const NPT_HttpRequestContext& /*context*/,
NPT_HttpResponse& response) {
NPT_HttpEntity* entity = response.GetEntity();
entity->SetContentType("text/html");
entity->SetInputStream("<html><body>Bye Bye!</body></html>");
KillRequest = true;
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| CUPnPRenderer::ProcessHttpRequest
+---------------------------------------------------------------------*/
NPT_Result
CUPnPRenderer::ProcessHttpGetRequest(NPT_HttpRequest& request,
const NPT_HttpRequestContext& context,
NPT_HttpResponse& response)
{
// get the address of who sent us some data back
NPT_String ip_address = context.GetRemoteAddress().GetIpAddress().ToString();
NPT_String method = request.GetMethod();
NPT_String protocol = request.GetProtocol();
NPT_HttpUrl url = request.GetUrl();
if (url.GetPath() == "/thumb") {
NPT_HttpUrlQuery query(url.GetQuery());
NPT_String filepath = query.GetField("path");
if (!filepath.IsEmpty()) {
NPT_HttpEntity* entity = response.GetEntity();
if (entity == NULL) return NPT_ERROR_INVALID_STATE;
// check the method
if (request.GetMethod() != NPT_HTTP_METHOD_GET &&
request.GetMethod() != NPT_HTTP_METHOD_HEAD) {
response.SetStatus(405, "Method Not Allowed");
return NPT_SUCCESS;
}
// prevent hackers from accessing files outside of our root
if ((filepath.Find("/..") >= 0) || (filepath.Find("\\..") >=0)) {
return NPT_FAILURE;
}
#if 1
std::string path;
//url
#else
// open the file
CStdString path = CURL::Decode((const char*) filepath);
#endif
NPT_File file(path.c_str());
NPT_Result result = file.Open(NPT_FILE_OPEN_MODE_READ);
if (NPT_FAILED(result)) {
response.SetStatus(404, "Not Found");
return NPT_SUCCESS;
}
NPT_InputStreamReference stream;
file.GetInputStream(stream);
entity->SetContentType(GetMimeType(filepath));
entity->SetInputStream(stream, true);
return NPT_SUCCESS;
}
}
return PLT_MediaRenderer::ProcessHttpGetRequest(request, context, response);
}
/*----------------------------------------------------------------------
| NPT_HttpLoggerConfigurator::SetupResponse
+---------------------------------------------------------------------*/
NPT_Result
NPT_HttpLoggerConfigurator::SetupResponse(NPT_HttpRequest& request,
const NPT_HttpRequestContext& /*context*/,
NPT_HttpResponse& response)
{
// we only support GET here
if (request.GetMethod() != NPT_HTTP_METHOD_GET) return NPT_ERROR_HTTP_METHOD_NOT_SUPPORTED;
// construct the response message
NPT_String msg;
msg = "<ul>";
NPT_List<NPT_LogConfigEntry>& config = LogManager.GetConfig();
NPT_List<NPT_LogConfigEntry>::Iterator cit = config.GetFirstItem();
for (; cit; ++cit) {
NPT_LogConfigEntry& entry = (*cit);
msg += "<li>";
msg += entry.m_Key;
msg += "=";
msg += entry.m_Value;
msg += "</li>";
}
msg += "</ul>";
msg += "<ul>";
NPT_List<NPT_Logger*>& loggers = LogManager.GetLoggers();
NPT_List<NPT_Logger*>::Iterator lit = loggers.GetFirstItem();
for (;lit;++lit) {
NPT_Logger* logger = (*lit);
msg += "<li>";
msg += logger->GetName();
msg += ", level=";
msg += NPT_String::FromInteger(logger->GetLevel());
NPT_List<NPT_LogHandler*>& handlers = logger->GetHandlers();
NPT_List<NPT_LogHandler*>::Iterator hit = handlers.GetFirstItem();
msg += ", handlers=";
for (;hit;++hit) {
NPT_LogHandler* handler = (*hit);
msg += handler->ToString();
}
msg += "</li>";
}
msg += "</ul>";
// setup the response body
NPT_HttpEntity* entity = response.GetEntity();
entity->SetContentType("text/html");
entity->SetInputStream(msg);
return NPT_SUCCESS;
}
// NPT_HttpRequetsHandler methods
virtual NPT_Result SetupResponse(NPT_HttpRequest& request,
const NPT_HttpRequestContext& context,
NPT_HttpResponse& response) {
NPT_COMPILER_UNUSED(request);
NPT_COMPILER_UNUSED(context);
NPT_HttpEntity* entity = response.GetEntity();
if (entity == NULL) return NPT_ERROR_INVALID_STATE;
entity->SetContentType(m_MimeType);
entity->SetInputStream(m_Body);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| Test5
+---------------------------------------------------------------------*/
static bool
Test5(NPT_HttpUrl url)
{
NPT_LOG_INFO("########### TEST 5 ######################");
NPT_HttpClient client;
// first request
NPT_HttpRequest request(url, NPT_HTTP_METHOD_POST, NPT_HTTP_PROTOCOL_1_1);
NPT_HttpEntity* request_entity = new NPT_HttpEntity();
request_entity->SetInputStream("Testing");
request.SetEntity(request_entity);
NPT_HttpResponse* response = NULL;
client.SendRequest(request, response);
NPT_HttpEntity* entity = NULL;
if (response && (entity = response->GetEntity())) {
NPT_DataBuffer buffer;
if (NPT_FAILED(entity->Load(buffer))) return false;
}
// try again
delete response;
response = NULL;
request_entity = new NPT_HttpEntity();
request_entity->SetInputStream("Testing2");
request.SetEntity(request_entity);
client.SendRequest(request, response);
entity = NULL;
if (response && (entity = response->GetEntity())) {
NPT_DataBuffer buffer;
if (NPT_FAILED(entity->Load(buffer))) return false;
}
return true;
}
bool CStreamCtrl::RecvHeaderData(NPT_HttpUrl url,NPT_DataBuffer& buffer)
{
NPT_HttpClient client;
NPT_String rdUrl=url.ToString();
// first request
NPT_HttpRequest request(url, NPT_HTTP_METHOD_GET, NPT_HTTP_PROTOCOL_1_1);
NPT_HttpResponse* response = NULL;
client.SendRequest(request, response);
NPT_HttpEntity* entity = NULL;
if (response && (entity = response->GetEntity())) {
if (NPT_FAILED(entity->Load(buffer))) return false;
}
else
return false;
return true;
}
NPT_Result SetupResponse(NPT_HttpRequest& request,
NPT_HttpResponse& response,
NPT_SocketInfo& /*info*/) {
NPT_String msg = "<HTML>";
msg += "PATH=";
msg += request.GetUrl().GetPath();
msg += " <P><UL>";
if (request.GetUrl().HasQuery()) {
NPT_HttpUrlQuery query(request.GetUrl().GetQuery());
for (NPT_List<NPT_HttpUrlQuery::Field>::Iterator it = query.GetFields().GetFirstItem();
it;
++it) {
NPT_HttpUrlQuery::Field& field = *it;
msg += "<LI>";
msg += field.m_Name;
msg += " = ";
msg += field.m_Value;
msg += " </LI>";
}
}
msg += "</UL></HTML>";
if (request.GetMethod() == NPT_HTTP_METHOD_POST) {
NPT_DataBuffer request_body;
request.GetEntity()->Load(request_body);
NPT_Debug("REQUEST: body = %d bytes\n", request_body.GetDataSize());
NPT_Debug("REQUEST: content type = %s\n", request.GetEntity()->GetContentType().GetChars());
if (request.GetEntity()->GetContentType().StartsWith("text") ||
request.GetEntity()->GetContentType() == "application/x-www-form-urlencoded") {
NPT_String body_string;
body_string.Assign((char*)request_body.GetData(), request_body.GetDataSize());
NPT_Debug("%s", body_string.GetChars());
}
}
NPT_HttpEntity* entity = response.GetEntity();
entity->SetContentType("text/html");
entity->SetInputStream(msg);
return NPT_SUCCESS;
}
bool CStreamCtrl::RecvMediaData(NPT_HttpUrl url,int in_nStartPos,
int in_nEndPos,NPT_DataBuffer& buffer)
{
NPT_HttpClient client;
NPT_String rdUrl=url.ToString();
// first request
NPT_HttpRequest request(url, NPT_HTTP_METHOD_GET, NPT_HTTP_PROTOCOL_1_1);
char range[100]={0};
sprintf(range," bytes=%d-%d",in_nStartPos,in_nEndPos-1);
request.GetHeaders().SetHeader(NPT_HTTP_HEADER_RANGE,range);
NPT_HttpResponse* response = NULL;
client.SendRequest(request, response);
NPT_HttpEntity* entity = NULL;
if (response && (entity = response->GetEntity())) {
if (NPT_FAILED(entity->Load(buffer))) return false;
}
else
return false;
return true;
}
/*----------------------------------------------------------------------
| PLT_HttpStreamRequestHandler::SetupResponse
+---------------------------------------------------------------------*/
NPT_Result
PLT_HttpStreamRequestHandler::SetupResponse(NPT_HttpRequest& request,
const NPT_HttpRequestContext& context,
NPT_HttpResponse& response)
{
PLT_LOG_HTTP_REQUEST(NPT_LOG_LEVEL_FINE, "PLT_HttpStreamRequestHandler::SetupResponse:", &request);
if (request.GetMethod().Compare("GET") &&
request.GetMethod().Compare("HEAD")) {
return NPT_FAILURE;
}
NPT_Reference<PLT_FrameBuffer> buffer;
if (!m_StreamValidator.OnNewRequestAccept(request, context, response, buffer)) {
return NPT_ERROR_NO_SUCH_ITEM;
}
response.SetProtocol(NPT_HTTP_PROTOCOL_1_0);
response.GetHeaders().SetHeader(NPT_HTTP_HEADER_CONNECTION, "close");
response.GetHeaders().SetHeader("Cache-Control", "no-store, no-cache, must-revalidate, pre-check=0, post-check=0, max-age=0");
response.GetHeaders().SetHeader("Pragma", "no-cache");
response.GetHeaders().SetHeader("Expires", "Tue, 4 Jan 2000 02:43:05 GMT");
// HEAD request has no entity or if status code is not 2xx
if (!request.GetMethod().Compare("HEAD") || response.GetStatusCode()/100 != 2)
return NPT_SUCCESS;
NPT_HttpEntity* entity = response.GetEntity();
NPT_CHECK_POINTER_FATAL(entity);
entity->SetContentType("multipart/x-mixed-replace;boundary=" BOUNDARY);
NPT_InputStreamReference body(new PLT_InputFrameStream(buffer, BOUNDARY));
entity->SetInputStream(body, false);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| BtPlayerServer::SendStatus
+---------------------------------------------------------------------*/
NPT_Result
BtPlayerServer::SendStatus(NPT_HttpResponse& response, NPT_UrlQuery& query)
{
NPT_String json;
// json start
const char* json_callback = query.GetField("callback");
if (json_callback) {
json += NPT_UrlQuery::UrlDecode(json_callback)+'(';
}
json += '{';
// state
json += "\"state\": ";
switch (m_DecoderState) {
case BLT_DecoderServer::STATE_STOPPED:
json += "\"STOPPED\"";
break;
case BLT_DecoderServer::STATE_PLAYING:
json += "\"PLAYING\"";
break;
case BLT_DecoderServer::STATE_PAUSED:
json += "\"PAUSED\"";
break;
case BLT_DecoderServer::STATE_EOS:
json += "\"END OF STREAM\"";
break;
default:
json += "\"UNKNOWN\"";
break;
}
json += ',';
// timecode
json += NPT_String::Format("\"timecode\": \"%02d:%02d:%02d\", ",
m_DecoderTimecode.h,
m_DecoderTimecode.m,
m_DecoderTimecode.s);
// position
json += NPT_String::Format("\"position\": %f, ", m_DecoderPosition);
// stream info
json += "\"streamInfo\": {";
if (m_StreamInfo.mask & BLT_STREAM_INFO_MASK_NOMINAL_BITRATE) {
json += NPT_String::Format("\"nominalBitrate\": %d, ", m_StreamInfo.nominal_bitrate);
}
if (m_StreamInfo.mask & BLT_STREAM_INFO_MASK_AVERAGE_BITRATE) {
json += NPT_String::Format("\"averageBitrate\": %d, ", m_StreamInfo.average_bitrate);
}
if (m_StreamInfo.mask & BLT_STREAM_INFO_MASK_INSTANT_BITRATE) {
json += NPT_String::Format("\"instantBitrate\": %d, ", m_StreamInfo.instant_bitrate);
}
if (m_StreamInfo.mask & BLT_STREAM_INFO_MASK_SIZE) {
json += NPT_String::Format("\"size\": %d, ", m_StreamInfo.size);
}
if (m_StreamInfo.mask & BLT_STREAM_INFO_MASK_DURATION) {
unsigned int seconds = m_StreamInfo.duration/1000;
json += NPT_String::Format("\"duration\": \"%02d:%02d:%02d\", ",
(seconds)/36000,
(seconds%3600)/60,
(seconds%60));
}
if (m_StreamInfo.mask & BLT_STREAM_INFO_MASK_SAMPLE_RATE) {
json += NPT_String::Format("\"sampleRate\": %d, ", m_StreamInfo.sample_rate);
}
if (m_StreamInfo.mask & BLT_STREAM_INFO_MASK_CHANNEL_COUNT) {
json += NPT_String::Format("\"channelCount\": %d, ", m_StreamInfo.channel_count);
}
if (m_StreamInfo.mask & BLT_STREAM_INFO_MASK_DATA_TYPE) {
json += NPT_String::Format("\"dataType\": \"%s\", ", m_StreamInfo.data_type);
}
json += "},";
// stream properties
// json end
json += '}';
if (json_callback) {
json += ')';
}
// send the html document
NPT_HttpEntity* entity = response.GetEntity();
entity->SetContentType("application/json");
entity->SetInputStream(json);
NPT_LOG_FINE_1("status: %s", json.GetChars());
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| PLT_HttpServer::ServeStream
+---------------------------------------------------------------------*/
NPT_Result
PLT_HttpServer::ServeStream(const NPT_HttpRequest& request,
const NPT_HttpRequestContext& context,
NPT_HttpResponse& response,
NPT_InputStreamReference& body,
const char* content_type)
{
if (body.IsNull()) return NPT_FAILURE;
// set date
NPT_TimeStamp now;
NPT_System::GetCurrentTimeStamp(now);
response.GetHeaders().SetHeader("Date", NPT_DateTime(now).ToString(NPT_DateTime::FORMAT_RFC_1123), true);
// get entity
NPT_HttpEntity* entity = response.GetEntity();
NPT_CHECK_POINTER_FATAL(entity);
// set the content type
entity->SetContentType(content_type);
// check for range requests
const NPT_String* range_spec = request.GetHeaders().GetHeaderValue(NPT_HTTP_HEADER_RANGE);
// setup entity body
NPT_CHECK(NPT_HttpFileRequestHandler::SetupResponseBody(response, body, range_spec));
// set some default headers
if (response.GetEntity()->GetTransferEncoding() != NPT_HTTP_TRANSFER_ENCODING_CHUNKED) {
// set but don't replace Accept-Range header only if body is seekable
NPT_Position offset;
if (NPT_SUCCEEDED(body->Tell(offset)) && NPT_SUCCEEDED(body->Seek(offset))) {
response.GetHeaders().SetHeader(NPT_HTTP_HEADER_ACCEPT_RANGES, "bytes", false);
}
}
// set getcontentFeatures.dlna.org
const NPT_String* value = request.GetHeaders().GetHeaderValue("getcontentFeatures.dlna.org");
if (value) {
PLT_HttpRequestContext tmp_context(request, context);
const char* dlna = PLT_ProtocolInfo::GetDlnaExtension(entity->GetContentType(),
&tmp_context);
if (dlna) response.GetHeaders().SetHeader("ContentFeatures.DLNA.ORG", dlna, false);
}
// transferMode.dlna.org
value = request.GetHeaders().GetHeaderValue("transferMode.dlna.org");
if (value) {
// Interactive mode not supported?
/*if (value->Compare("Interactive", true) == 0) {
response.SetStatus(406, "Not Acceptable");
return NPT_SUCCESS;
}*/
response.GetHeaders().SetHeader("TransferMode.DLNA.ORG", value->GetChars(), false);
} else {
response.GetHeaders().SetHeader("TransferMode.DLNA.ORG", "Streaming", false);
}
if (request.GetHeaders().GetHeaderValue("TimeSeekRange.dlna.org")) {
response.SetStatus(406, "Not Acceptable");
return NPT_SUCCESS;
}
return NPT_SUCCESS;
}
NPT_Result SetupResponse(NPT_HttpRequest& request,
const NPT_HttpRequestContext& context,
NPT_HttpResponse& response) {
NPT_String msg = "<HTML>";
msg += "PATH=";
msg += request.GetUrl().GetPath();
msg += "<P><B>Local Address:</B> ";
msg += context.GetLocalAddress().ToString();
msg += "<P>";
msg += "<B>Remote Address:</B> ";
msg += context.GetRemoteAddress().ToString();
msg += "<P><UL>";
if (request.GetUrl().HasQuery()) {
NPT_UrlQuery query(request.GetUrl().GetQuery());
for (NPT_List<NPT_UrlQuery::Field>::Iterator it = query.GetFields().GetFirstItem();
it;
++it) {
NPT_UrlQuery::Field& field = *it;
msg += "<LI>";
msg += field.m_Name;
msg += " = ";
msg += field.m_Value;
msg += " </LI>";
// check for a 'delay' field
if (field.m_Name == "delay") {
NPT_UInt32 delay = 0;
field.m_Value.ToInteger(delay);
NPT_Debug("DELAY: %d seconds\n", delay);
NPT_System::Sleep(NPT_TimeInterval((float)delay));
}
}
}
msg += "</UL></HTML>";
if (request.GetMethod() == NPT_HTTP_METHOD_POST) {
NPT_DataBuffer request_body;
request.GetEntity()->Load(request_body);
NPT_Debug("REQUEST: body = %d bytes\n", request_body.GetDataSize());
NPT_Debug("REQUEST: content type = %s\n", request.GetEntity()->GetContentType().GetChars());
if (request.GetEntity()->GetContentType().StartsWith("text") ||
request.GetEntity()->GetContentType() == "application/x-www-form-urlencoded") {
NPT_String body_string;
body_string.Assign((char*)request_body.GetData(), request_body.GetDataSize());
NPT_Debug("%s", body_string.GetChars());
}
}
NPT_HttpEntity* entity = response.GetEntity();
entity->SetContentType("text/html");
NPT_MemoryStreamReference memory_stream(
new NPT_MemoryStream((const void*)msg.GetChars(), msg.GetLength()));
entity->SetInputStream(memory_stream, !m_Chunked);
if (m_Chunked) {
entity->SetTransferEncoding(NPT_HTTP_TRANSFER_ENCODING_CHUNKED);
}
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| BtPlayerServer::SetupResponse
+---------------------------------------------------------------------*/
NPT_Result
BtPlayerServer::SetupResponse(NPT_HttpRequest& request,
const NPT_HttpRequestContext& /*context*/,
NPT_HttpResponse& response)
{
const NPT_Url& url = request.GetUrl();
const NPT_String& path = url.GetPath();
NPT_UrlQuery query;
// parse the query part, if any
if (url.HasQuery()) {
query.Parse(url.GetQuery());
}
// lock the player
NPT_AutoLock lock(m_Lock);
// handle form requests
if (path == "/") {
response.GetHeaders().SetHeader("Location", "/control/ajax");
response.SetStatus(301, "Moved Permanently");
return BLT_SUCCESS;
}
// handle form requests
if (path == "/control/form") {
return SendControlForm(response, NULL);
}
// handle status requests
if (path == "/player/status") {
return SendStatus(response, query);
}
// handle commands
const char* mode_field = query.GetField("mode");
const char* form_msg = "OK";
bool use_form = false;
if (mode_field && NPT_StringsEqual(mode_field, "form")) {
use_form = true;
}
if (path == "/player/set-input") {
const char* name_field = query.GetField("name");
if (name_field) {
NPT_String name = NPT_UrlQuery::UrlDecode(name_field);
m_Player.SetInput(name);
} else {
form_msg = "INVALID PARAMETERS";
}
} else if (path == "/player/set-output") {
const char* name_field = query.GetField("name");
if (name_field) {
NPT_String name = NPT_UrlQuery::UrlDecode(name_field);
m_Player.SetOutput(name);
} else {
form_msg = "INVALID PARAMETERS";
}
} else if (path == "/player/play") {
m_Player.Play();
} else if (path == "/player/pause") {
m_Player.Pause();
} else if (path == "/player/stop") {
m_Player.Stop();
} else if (path == "/player/seek") {
const char* timecode_field = query.GetField("timecode");
const char* position_field = query.GetField("position");
if (timecode_field) {
NPT_String timecode = NPT_UrlQuery::UrlDecode(timecode_field);
DoSeekToTimecode(timecode);
} else if (position_field) {
unsigned int position;
if (NPT_SUCCEEDED(NPT_ParseInteger(position_field, position))) {
m_Player.SeekToPosition(position, 100);
}
} else {
form_msg = "INVALID PARAMETER";
}
} else if (path == "/player/set-volume") {
const char* volume_field = query.GetField("volume");
if (volume_field) {
unsigned int volume;
if (NPT_SUCCEEDED(NPT_ParseInteger(volume_field, volume))) {
m_Player.SetVolume((float)volume/100.0f);
}
} else {
form_msg = "INVALID PARAMETER";
}
}
if (use_form) {
return SendControlForm(response, form_msg);
} else {
NPT_HttpEntity* entity = response.GetEntity();
entity->SetContentType("application/json");
entity->SetInputStream("{}");
return NPT_SUCCESS;
}
printf("BtPlayerServer::SetupResponse - command not found\n");
response.SetStatus(404, "Command Not Found");
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| BtPlayerServer::SendControlForm
+---------------------------------------------------------------------*/
NPT_Result
BtPlayerServer::SendControlForm(NPT_HttpResponse& response, const char* msg)
{
// create the html document
NPT_String html = "<html>";
// optional message
if (msg && msg[0]) {
html += "<";
html += msg;
html += "><p>";
}
// status
html += "<p><b>State: </b>";
switch (m_DecoderState) {
case BLT_DecoderServer::STATE_STOPPED:
html += "[STOPPED]";
break;
case BLT_DecoderServer::STATE_PLAYING:
html += "[PLAYING]";
break;
case BLT_DecoderServer::STATE_PAUSED:
html += "[PAUSED]";
break;
case BLT_DecoderServer::STATE_EOS:
html += "[END OF STREAM]";
break;
default:
html += "[UNKNOWN]";
break;
}
html += "</p><p><b>Time Code: </b>";
html += NPT_String::Format("\"%02d:%02d:%02d\"",
m_DecoderTimecode.h,
m_DecoderTimecode.m,
m_DecoderTimecode.s);
html += "</p>";
html += "<p>";
html += "<b>Content Format: </b>";
if (m_StreamInfo.data_type) {
html += m_StreamInfo.data_type;
}
html += "<br>";
// control form
html += BT_CONTROL_FORM;
html += "</html>";
// send the html document
NPT_HttpEntity* entity = response.GetEntity();
entity->SetContentType("text/html");
entity->SetInputStream(html);
return NPT_SUCCESS;
}
