/*----------------------------------------------------------------------
| CMediaCrawler::FormatObjectId
+---------------------------------------------------------------------*/
NPT_String
CMediaCrawler::FormatObjectId(const NPT_String& server_uuid, const NPT_String& server_object_id)
{
NPT_String object_id = NPT_String("0/") + server_uuid;
if (server_object_id.GetLength())
object_id += NPT_String("/") + server_object_id;
return object_id;
}
/*----------------------------------------------------------------------
| PLT_HttpHelper::SetBasicAuthorization
+---------------------------------------------------------------------*/
void
PLT_HttpHelper::SetBasicAuthorization(NPT_HttpRequest& request,
const char* username,
const char* password)
{
NPT_String encoded;
NPT_String cred = NPT_String(username) + ":" + password;
NPT_Base64::Encode((const NPT_Byte *)cred.GetChars(), cred.GetLength(), encoded);
request.GetHeaders().SetHeader(NPT_HTTP_HEADER_AUTHORIZATION, NPT_String("Basic " + encoded));
}
/*----------------------------------------------------------------------
| NPT_String::FromInteger
+---------------------------------------------------------------------*/
NPT_String
NPT_String::FromInteger(NPT_Int64 value)
{
char str[32];
char* c = &str[31];
*c-- = '\0';
// handle the sign
bool negative = false;
if (value < 0) {
negative = true;
value = -value;
}
// process the digits
do {
int digit = (int)(value%10);
*c-- = '0'+digit;
value /= 10;
} while(value);
if (negative) {
*c = '-';
} else {
++c;
}
return NPT_String(c);
}
FrontEnd::FrontEnd()
: m_state(State_Stopped)
, m_includeLoopback(false)
{
m_taskGroup = new TaskGroup();
m_userAgentHeader = NPT_String("SITEVIEW/1.0");
setOSVersion("WTF/1.0");
}
/*----------------------------------------------------------------------
| NPT_File::ListDir
+---------------------------------------------------------------------*/
NPT_Result
NPT_File::ListDir(const char* path,
NPT_List<NPT_String>& entries,
NPT_Ordinal start /* = 0 */,
NPT_Cardinal max /* = 0 */)
{
// default return value
entries.Clear();
// check the arguments
if (path == NULL) return NPT_ERROR_INVALID_PARAMETERS;
// list the entries
DIR *directory = opendir(path);
if (directory == NULL) return NPT_ERROR_NO_SUCH_ITEM;
NPT_Cardinal count = 0;
for (;;) {
struct dirent* entry_pointer = NULL;
#if defined(NPT_CONFIG_HAVE_READDIR_R)
struct dirent entry;
int result = readdir_r(directory, &entry, &entry_pointer);
if (result != 0 || entry_pointer == NULL) break;
#else
entry_pointer = readdir(directory);
if (entry_pointer == NULL) break;
#endif
// ignore odd names
if (entry_pointer->d_name[0] == '\0') continue;
// ignore . and ..
if (entry_pointer->d_name[0] == '.' &&
entry_pointer->d_name[1] == '\0') {
continue;
}
if (entry_pointer->d_name[0] == '.' &&
entry_pointer->d_name[1] == '.' &&
entry_pointer->d_name[2] == '\0') {
continue;
}
// continue if we still have some items to skip
if (start > 0) {
--start;
continue;
}
entries.Add(NPT_String(entry_pointer->d_name));
// stop when we have reached the maximum requested
if (max && ++count == max) break;
}
closedir(directory);
return NPT_SUCCESS;
}
/*----------------------------------------------------------------------
| NPT_String::SubString
+---------------------------------------------------------------------*/
NPT_String
NPT_String::SubString(NPT_Ordinal first, NPT_Size length) const
{
if (first >= GetLength()) {
first = GetLength();
length = 0;
} else if (first+length >= GetLength()) {
length = GetLength()-first;
}
return NPT_String(GetChars()+first, length);
}
void GPAC_MediaController::OnMRStateVariablesChanged(PLT_Service* service, NPT_List<PLT_StateVariable*>* vars )
{
u32 count;
u32 i;
s32 render_idx = -1;
count = gf_list_count(m_MediaRenderers);
for (i=0; i<count; i++) {
GPAC_MediaRendererItem *mr = (GPAC_MediaRendererItem *) gf_list_get(m_MediaRenderers, i);
if ( mr->m_device.AsPointer() == service->GetDevice() ) {
render_idx = i;
break;
}
}
if (render_idx < 0) return;
count = vars->GetItemCount();
for (i=0; i<count; i++) {
PLT_StateVariable *svar;
vars->Get(i, svar);
if (svar->GetName() == NPT_String("AbsoluteTimePosition")) {
u32 h, m, s;
if (sscanf((char *) svar->GetValue(), "%d:%d:%d", &h, &m, &s)==3) {
Double time = h*3600 + m*60 + s;
this->m_pUPnP->onTimeChanged(render_idx, time);
}
}
else if (svar->GetName() == NPT_String("CurrentTrackDuration")) {
u32 h, m, s;
if (sscanf((char *) svar->GetValue(), "%d:%d:%d", &h, &m, &s)==3) {
Double time = h*3600 + m*60 + s;
this->m_pUPnP->onDurationChanged(render_idx, time);
}
}
}
}
/*----------------------------------------------------------------------
| NPT_String::FromIntegerU
+---------------------------------------------------------------------*/
NPT_String
NPT_String::FromIntegerU(NPT_UInt64 value)
{
char str[32];
char* c = &str[31];
*c = '\0';
// process the digits
do {
int digit = (int)(value%10);
*--c = '0'+digit;
value /= 10;
} while(value);
return NPT_String(c);
}
/*----------------------------------------------------------------------
| NPT_String::operator+(const NPT_String& , const char*)
+---------------------------------------------------------------------*/
NPT_String
operator+(const char* s1, const NPT_String& s2)
{
// shortcut
if (s1 == NULL) return NPT_String(s2);
// measure strings
NPT_Size s1_length = NPT_String::StringLength(s1);
NPT_Size s2_length = s2.GetLength();
// allocate space for the new string
NPT_String result;
char* start = result.PrepareToWrite(s1_length+s2_length);
// concatenate the two strings into the result
NPT_String::CopyBuffer(start, s1, s1_length);
NPT_String::CopyString(start+s1_length, s2.GetChars());
return result;
}
/*----------------------------------------------------------------------
| TestNamespaces
+---------------------------------------------------------------------*/
static void
TestNamespaces()
{
NPT_XmlElementNode* top = new NPT_XmlElementNode("top");
top->SetNamespaceUri("", "http://namespace1.com");
CHECK(top->GetNamespaceUri("") &&
*(top->GetNamespaceUri("")) == "http://namespace1.com");
NPT_XmlElementNode* child1 = new NPT_XmlElementNode("child1");
top->AddChild(child1);
CHECK(child1->GetNamespaceUri(""));
CHECK(*(child1->GetNamespaceUri("")) == "http://namespace1.com");
NPT_XmlElementNode* child2 = new NPT_XmlElementNode("ns1", "child2");
top->AddChild(child2);
CHECK(child2->GetNamespaceUri(""));
CHECK(*(child2->GetNamespaceUri("")) == "http://namespace1.com");
CHECK(child2->GetNamespaceUri("ns1") == NULL);
child2->SetNamespaceUri("ns1", "http://blabla");
CHECK(child2->GetNamespaceUri("ns1"));
CHECK(*child2->GetNamespaceUri("ns1") == "http://blabla");
CHECK(*child2->GetNamespace() == "http://blabla");
// testing a child with a namespace defined in parent
NPT_XmlElementNode* child3 = new NPT_XmlElementNode("ns1", "child3");
child2->AddChild(child3);
CHECK(child3->GetNamespaceUri(""));
CHECK(*(child3->GetNamespaceUri("")) == "http://namespace1.com");
CHECK(child3->GetNamespaceUri("ns1"));
CHECK(*child3->GetNamespaceUri("ns1") == "http://blabla");
CHECK(*child3->GetNamespace() == "http://blabla");
// testing adding a namespace in a node which namespace is defined in parent
child3->SetNamespaceUri("ns3", "http://foofoo");
CHECK(child3->GetNamespaceUri("ns1"));
CHECK(*child3->GetNamespaceUri("ns1") == "http://blabla");
CHECK(*child3->GetNamespace() == "http://blabla");
const char* xml1 =
"<top>"
" <child1 xmlns:foo='blabla'><cc1 foo:attr1='0'/></child1>"
" <child2 xmlns='foobar' attr1='1'>"
" <cc2/>"
" <cc3 />"
" </child2 >"
" <ns2:child3 xmlns:ns2='abcd'><cc3/></ns2:child3>"
" <child4 ns3:attr1='3' xmlns:ns3='efgh'>"
" <ns3:cc4 ns3:attr1='4'/>"
" </child4>"
"</top>";
NPT_XmlParser parser;
NPT_XmlNode* root = NULL;
NPT_Result result = parser.Parse(xml1, root);
CHECK(NPT_SUCCEEDED(result));
CHECK(root != NULL);
NPT_XmlWriter writer;
NPT_MemoryStream output;
writer.Serialize(*root, output);
NPT_LargeSize size;
output.GetSize(size);
printf(NPT_String((const char*)output.GetData(), (NPT_Size)size).GetChars());
delete top;
delete root;
// test default and empty namespaces
const char* xml2 = "<top><a></a><b xmlns='foo'><c xmlns=''></c></b></top>";
result = parser.Parse(xml2, root);
CHECK(root->AsElementNode()->GetNamespace() == NULL);
NPT_XmlElementNode* a_elem = (*root->AsElementNode()->GetChildren().GetItem(0))->AsElementNode();
CHECK(a_elem->GetNamespace() == NULL);
NPT_XmlElementNode* b_elem = (*root->AsElementNode()->GetChildren().GetItem(1))->AsElementNode();
CHECK(*b_elem->GetNamespace() == "foo");
NPT_XmlElementNode* c_elem = (*b_elem->GetChildren().GetItem(0))->AsElementNode();
CHECK(c_elem->GetNamespace() == NULL);
delete root;
}
/*----------------------------------------------------------------------
| NPT_fsopen_utf8
+---------------------------------------------------------------------*/
FILE*
NPT_fsopen_utf8(const char* path, const char* mode, int sh_flags)
{
NPT_WIN32_USE_CHAR_CONVERSION;
return _wfsopen(NPT_WIN32_A2W(path), NPT_WIN32_A2W(mode + NPT_String(", ccs=UNICODE")), sh_flags);
}
/*----------------------------------------------------------------------
| PLT_StateVariable::SetExtraAttribute
+---------------------------------------------------------------------*/
NPT_Result
PLT_StateVariable::SetExtraAttribute(const char* name, const char* value)
{
return m_ExtraAttributes.Put(NPT_String(name), NPT_String(value));
}
/*----------------------------------------------------------------------
| CUPnPRenderer::PlayMedia
+---------------------------------------------------------------------*/
NPT_Result
CUPnPRenderer::PlayMedia(const char* uri, const char* meta, PLT_Action* action)
{
bool bImageFile = false;
PLT_Service* service;
NPT_CHECK_SEVERE(FindServiceByType("urn:schemas-upnp-org:service:AVTransport:1", service));
{ NPT_AutoLock lock(m_state);
service->SetStateVariable("TransportState", "TRANSITIONING");
service->SetStateVariable("TransportStatus", "OK");
}
PLT_MediaObjectListReference list;
PLT_MediaObject* object = NULL;
if (meta && NPT_SUCCEEDED(PLT_Didl::FromDidl(meta, list))) {
list->Get(0, object);
}
if (object) {
CFileItem item(uri, false);
PLT_MediaItemResource* res = object->m_Resources.GetFirstItem();
for(NPT_Cardinal i = 0; i < object->m_Resources.GetItemCount(); i++) {
if(object->m_Resources[i].m_Uri == uri) {
res = &object->m_Resources[i];
break;
}
}
for(NPT_Cardinal i = 0; i < object->m_Resources.GetItemCount(); i++) {
if(object->m_Resources[i].m_ProtocolInfo.ToString().StartsWith("xbmc-get:")) {
res = &object->m_Resources[i];
item.SetPath(CStdString(res->m_Uri));
break;
}
}
if (res && res->m_ProtocolInfo.IsValid()) {
item.SetMimeType((const char*)res->m_ProtocolInfo.GetContentType());
}
item.m_dateTime.SetFromDateString((const char*)object->m_Date);
item.m_strTitle = (const char*)object->m_Title;
item.SetLabel((const char*)object->m_Title);
item.SetLabelPreformated(true);
if (object->m_ExtraInfo.album_arts.GetItem(0)) {
//FIXME only considers 1st image
item.SetArt("thumb", (const char*)object->m_ExtraInfo.album_arts.GetItem(0)->uri);
}
if (object->m_ObjectClass.type.StartsWith("object.item.audioItem")) {
if(NPT_SUCCEEDED(PopulateTagFromObject(*item.GetMusicInfoTag(), *object, res)))
item.SetLabelPreformated(false);
} else if (object->m_ObjectClass.type.StartsWith("object.item.videoItem")) {
if(NPT_SUCCEEDED(PopulateTagFromObject(*item.GetVideoInfoTag(), *object, res)))
item.SetLabelPreformated(false);
} else if (object->m_ObjectClass.type.StartsWith("object.item.imageItem")) {
bImageFile = true;
}
bImageFile?CApplicationMessenger::Get().PictureShow(item.GetPath())
:CApplicationMessenger::Get().MediaPlay(item);
} else {
bImageFile = NPT_String(PLT_MediaObject::GetUPnPClass(uri)).StartsWith("object.item.imageItem", true);
bImageFile?CApplicationMessenger::Get().PictureShow((const char*)uri)
:CApplicationMessenger::Get().MediaPlay((const char*)uri);
}
if (g_application.IsPlaying() || g_windowManager.GetActiveWindow() == WINDOW_SLIDESHOW) {
NPT_AutoLock lock(m_state);
service->SetStateVariable("TransportState", "PLAYING");
service->SetStateVariable("TransportStatus", "OK");
service->SetStateVariable("AVTransportURI", uri);
service->SetStateVariable("AVTransportURIMetaData", meta);
} else {
NPT_AutoLock lock(m_state);
service->SetStateVariable("TransportState", "STOPPED");
service->SetStateVariable("TransportStatus", "ERROR_OCCURRED");
}
if (action) {
NPT_CHECK_SEVERE(action->SetArgumentsOutFromStateVariable());
}
return NPT_SUCCESS;
}
