mirrors/recycled-ni-neutrino
1
0
Fork 0
mirror of https://github.com/tuxbox-fork-migrations/recycled-ni-neutrino.git synced 2025-08-30 00:41:09 +02:00
Code Issues Packages Projects Releases Wiki Activity

movieinfo: cleanup from unused code; reformat code; no binary changes

Browse Source 
Origin commit data
------------------
Commit: 8b3b4ba4d1
Author: vanhofen <vanhofen@gmx.de>
Date: 2016-08-11 (Thu, 11 Aug 2016)

Origin message was:
------------------
- movieinfo: cleanup from unused code; reformat code; no binary changes
This commit is contained in:
vanhofen
2016-08-11 11:47:00 +02:00
parent b175c9e6db
commit 7a1f95dcfa
2 changed files with 171 additions and 554 deletions
Download Patch File Download Diff File Expand all files Collapse all files

474
src/gui/movieinfo.cpp
View File

@@ -1,14 +1,10 @@
/***************************************************************************
Neutrino-GUI - DBoxII-Project
/*
movieinfo - Neutrino-GUI
Homepage: http://dbox.cyberphoria.org/
Copyright (C) 2005 Günther <Günther@tuxbox.berlios.org>
Kommentar:
Diese GUI wurde von Grund auf neu programmiert und sollte nun vom
Aufbau und auch den Ausbaumoeglichkeiten gut aussehen. Neutrino basiert
auf der Client-Server Idee, diese GUI ist also von der direkten DBox-
Steuerung getrennt. Diese wird dann von Daemons uebernommen.
Copyright (C) 2009, 2012 Stefan Seyfried
Copyright (C) 2015 Sven Hoefer (svenhoefer)
License: GPL
@@ -26,20 +22,8 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***********************************************************
*/
Module Name: movieinfo.cpp .
Description: Implementation of the CMovieInfo class
This class loads, saves and shows the movie Information from the any .xml File on HD
Date: Nov 2005
Author: Günther@tuxbox.berlios.org
Copyright(C) 2009, 2012 Stefan Seyfried
****************************************************************************/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
@@ -56,30 +40,19 @@
#include <neutrino.h>
// #define XMLTREE_LIB
#ifdef XMLTREE_LIB
#include <xmltree/xmltree.h>
#include <xmltree/xmltok.h>
#endif
#define TRACE printf
/************************************************************************
************************************************************************/
CMovieInfo::CMovieInfo()
{
//TRACE("[mi] new\r\n");
//TRACE("[mi] new\n");
}
CMovieInfo::~CMovieInfo()
{
//TRACE("[mi] del\r\n");
//TRACE("[mi] del\n");
;
}
/************************************************************************
************************************************************************/
bool CMovieInfo::convertTs2XmlName(std::string& filename)
{
size_t lastdot = filename.find_last_of(".");
@@ -91,9 +64,6 @@ bool CMovieInfo::convertTs2XmlName(std::string& filename)
return false;
}
/************************************************************************
************************************************************************/
static void XML_ADD_TAG_STRING(std::string &_xml_text_, const char *_tag_name_, std::string _tag_content_)
{
_xml_text_ += "\t\t<";
@@ -127,31 +97,9 @@ static void XML_ADD_TAG_LONG(std::string &_xml_text_, const char *_tag_name_, ui
_xml_text_ += ">\n";
}
#if 0
std::string decodeXmlSpecialChars(std::string s);
static void XML_GET_DATA_STRING(XMLTreeNode *_node_, const char *_tag_, std::string &_string_dest_)
{
if(!strcmp(_node_->GetType(), _tag_) && _node_->GetData())
_string_dest_ = decodeXmlSpecialChars(_node_->GetData());
}
static void XML_GET_DATA_INT(XMLTreeNode *_node_, const char *_tag_, int _int_dest_)
{
if(!strcmp(_node_->GetType(), _tag_) && _node_->GetData())
_int_dest_ = atoi(_node_->GetData());
}
static void XML_GET_DATA_LONG(XMLTreeNode *_node_, const char *_tag_,long int _int_dest_)
{
if(!strcmp(_node_->GetType(), _tag_) && _node_->GetData());
sscanf(_node_->GetData(), "%llu", &_int_dest_);
}
#endif
bool CMovieInfo::encodeMovieInfoXml(std::string * extMessage, MI_MOVIE_INFO * movie_info)
{
//TRACE("[mi]->encodeMovieInfoXml\r\n");
//TRACE("[mi]->encodeMovieInfoXml\n");
*extMessage = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\n"
"<" MI_XML_TAG_NEUTRINO " commandversion=\"1\">\n"
@@ -163,14 +111,14 @@ bool CMovieInfo::encodeMovieInfoXml(std::string * extMessage, MI_MOVIE_INFO * mo
XML_ADD_TAG_LONG(*extMessage, MI_XML_TAG_ID, movie_info->epgId);
XML_ADD_TAG_STRING(*extMessage, MI_XML_TAG_INFO1, movie_info->epgInfo1);
XML_ADD_TAG_STRING(*extMessage, MI_XML_TAG_INFO2, movie_info->epgInfo2);
XML_ADD_TAG_LONG(*extMessage, MI_XML_TAG_EPGID, movie_info->epgEpgId); // %llu
XML_ADD_TAG_UNSIGNED(*extMessage, MI_XML_TAG_MODE, movie_info->epgMode); //%d
XML_ADD_TAG_UNSIGNED(*extMessage, MI_XML_TAG_VIDEOPID, movie_info->epgVideoPid); //%u
XML_ADD_TAG_UNSIGNED(*extMessage, MI_XML_TAG_VIDEOTYPE, movie_info->VideoType); //%u
XML_ADD_TAG_LONG(*extMessage, MI_XML_TAG_EPGID, movie_info->epgEpgId); // %llu
XML_ADD_TAG_UNSIGNED(*extMessage, MI_XML_TAG_MODE, movie_info->epgMode); // %d
XML_ADD_TAG_UNSIGNED(*extMessage, MI_XML_TAG_VIDEOPID, movie_info->epgVideoPid); // %u
XML_ADD_TAG_UNSIGNED(*extMessage, MI_XML_TAG_VIDEOTYPE, movie_info->VideoType); // %u
if ( !movie_info->audioPids.empty() ) {
*extMessage += "\t\t<" MI_XML_TAG_AUDIOPIDS ">\n";
for (unsigned int i = 0; i < movie_info->audioPids.size(); i++) // pids.APIDs.size()
for (unsigned int i = 0; i < movie_info->audioPids.size(); i++) // pids.APIDs.size()
{
*extMessage += "\t\t\t<" MI_XML_TAG_AUDIO " " MI_XML_TAG_PID "=\"";
*extMessage += to_string(movie_info->audioPids[i].epgAudioPid);
@@ -184,9 +132,8 @@ bool CMovieInfo::encodeMovieInfoXml(std::string * extMessage, MI_MOVIE_INFO * mo
}
*extMessage += "\t\t</" MI_XML_TAG_AUDIOPIDS ">\n";
}
XML_ADD_TAG_UNSIGNED(*extMessage, MI_XML_TAG_VTXTPID, movie_info->epgVTXPID); //%u
/*****************************************************
* new tags */
XML_ADD_TAG_UNSIGNED(*extMessage, MI_XML_TAG_VTXTPID, movie_info->epgVTXPID); // %u
XML_ADD_TAG_UNSIGNED(*extMessage, MI_XML_TAG_GENRE_MAJOR, movie_info->genreMajor);
XML_ADD_TAG_UNSIGNED(*extMessage, MI_XML_TAG_GENRE_MINOR, movie_info->genreMinor);
XML_ADD_TAG_STRING(*extMessage, MI_XML_TAG_SERIE_NAME, movie_info->serieName);
@@ -223,12 +170,11 @@ bool CMovieInfo::encodeMovieInfoXml(std::string * extMessage, MI_MOVIE_INFO * mo
return true;
}
/************************************************************************
************************************************************************/
bool CMovieInfo::saveMovieInfo(MI_MOVIE_INFO & movie_info, CFile * file)
{
//TRACE("[mi]->saveXml \r\n");
//TRACE("[mi]->saveMovieInfo\n");
bool result = true;
std::string text;
CFile file_xml;
@@ -239,35 +185,35 @@ bool CMovieInfo::saveMovieInfo(MI_MOVIE_INFO & movie_info, CFile * file)
} else {
file_xml.Name = file->Name;
}
TRACE("[mi] saveXml: %s\r\n", file_xml.Name.c_str());
TRACE("[mi] saveMovieInfo: %s\n", file_xml.Name.c_str());
if (result == true) {
result = encodeMovieInfoXml(&text, &movie_info);
if (result == true) {
result = saveFile(file_xml, text); // save
if (result == false) {
TRACE("[mi] saveXml: save error\r\n");
TRACE("[mi] saveMovieInfo: save error\n");
}
} else {
TRACE("[mi] saveXml: encoding error\r\n");
TRACE("[mi] saveMovieInfo: encoding error\n");
}
} else {
TRACE("[mi] saveXml: error\r\n");
TRACE("[mi] saveMovieInfo: error\n");
}
return (result);
}
/************************************************************************
************************************************************************/
bool CMovieInfo::loadMovieInfo(MI_MOVIE_INFO * movie_info, CFile * file)
{
//TRACE("[mi]->loadMovieInfo \r\n");
//TRACE("[mi]->loadMovieInfo\n");
bool result = true;
CFile file_xml;
if (file == NULL) {
// if there is no give file, we use the file name from movie info but we have to convert the ts name to xml name first
// if there is no give file, we use the file name from movie info
// but we have to convert the ts name to xml name first
file_xml.Name = movie_info->file.Name;
result = convertTs2XmlName(file_xml.Name);
} else {
@@ -278,296 +224,15 @@ bool CMovieInfo::loadMovieInfo(MI_MOVIE_INFO * movie_info, CFile * file)
// load xml file in buffer
std::string text;
result = loadFile(file_xml, text);
if (result == true) {
#ifdef XMLTREE_LIB
if (result == true)
result = parseXmlTree(text, movie_info);
#else /* XMLTREE_LIB */
result = parseXmlQuickFix(text, movie_info);
#endif /* XMLTREE_LIB */
}
}
if (movie_info->productionDate > 50 && movie_info->productionDate < 200) // backwardcompaibility
if (movie_info->productionDate > 50 && movie_info->productionDate < 200) // backwardcompaibility
movie_info->productionDate += 1900;
return (result);
}
/************************************************************************
************************************************************************/
#if 0
//never used
bool CMovieInfo::parseXmlTree(char */*text*/, MI_MOVIE_INFO * /*movie_info*/)
{
#ifndef XMLTREE_LIB
return (false); // no XML lib available return false
#else /* XMLTREE_LIB */
//int helpIDtoLoad = 80;
//XMLTreeParser *parser=new XMLTreeParser("ISO-8859-1");
XMLTreeParser *parser = new XMLTreeParser(NULL);
if (!parser->Parse(text, strlen(text), 1)) {
TRACE("parse error: %s at line %d \r\n", parser->ErrorString(parser->GetErrorCode()), parser->GetCurrentLineNumber());
//fclose(in);
delete parser;
return (false);
}
XMLTreeNode *root = parser->RootNode();
if (!root) {
TRACE(" root error \r\n");
delete parser;
return (false);
}
if (strcmp(root->GetType(), MI_XML_TAG_NEUTRINO)) {
TRACE("not neutrino file. %s", root->GetType());
delete parser;
return (false);
}
XMLTreeNode *node = parser->RootNode();
for (node = node->GetChild(); node; node = node->GetNext()) {
if (!strcmp(node->GetType(), MI_XML_TAG_RECORD)) {
for (XMLTreeNode * xam1 = node->GetChild(); xam1; xam1 = xam1->GetNext()) {
XML_GET_DATA_STRING(xam1, MI_XML_TAG_CHANNELNAME, movie_info->epgChannel);
XML_GET_DATA_STRING(xam1, MI_XML_TAG_EPGTITLE, movie_info->epgTitle);
XML_GET_DATA_LONG(xam1, MI_XML_TAG_ID, movie_info->epgId);
XML_GET_DATA_STRING(xam1, MI_XML_TAG_INFO1, movie_info->epgInfo1);
XML_GET_DATA_STRING(xam1, MI_XML_TAG_INFO2, movie_info->epgInfo2);
XML_GET_DATA_LONG(xam1, MI_XML_TAG_EPGID, movie_info->epgEpgId); // %llu
XML_GET_DATA_INT(xam1, MI_XML_TAG_MODE, movie_info->epgMode); //%d
XML_GET_DATA_INT(xam1, MI_XML_TAG_VIDEOPID, movie_info->epgVideoPid); //%u
XML_GET_DATA_INT(xam1, MI_XML_TAG_VIDEOTYPE, movie_info->VideoType); //%u
if (!strcmp(xam1->GetType(), MI_XML_TAG_AUDIOPIDS)) {
for (XMLTreeNode * xam2 = xam1->GetChild(); xam2; xam2 = xam2->GetNext()) {
if (!strcmp(xam2->GetType(), MI_XML_TAG_AUDIO)) {
EPG_AUDIO_PIDS pids;
pids.epgAudioPid = atoi(xam2->GetAttributeValue(MI_XML_TAG_PID));
pids.atype = atoi(xam2->GetAttributeValue(MI_XML_TAG_ATYPE));
pids.selected = atoi(xam2->GetAttributeValue(MI_XML_TAG_SELECTED));
pids.epgAudioPidName = decodeXmlSpecialChars(xam2->GetAttributeValue(MI_XML_TAG_NAME));
//printf("MOVIE INFO: apid %d type %d name %s selected %d\n", pids.epgAudioPid, pids.atype, pids.epgAudioPidName.c_str(), pids.selected);
movie_info->audioPids.push_back(pids);
}
}
}
XML_GET_DATA_INT(xam1, MI_XML_TAG_VTXTPID, movie_info->epgVTXPID); //%u
/*****************************************************
* new tags */
XML_GET_DATA_INT(xam1, MI_XML_TAG_GENRE_MAJOR, movie_info->genreMajor);
XML_GET_DATA_INT(xam1, MI_XML_TAG_GENRE_MINOR, movie_info->genreMinor);
XML_GET_DATA_STRING(xam1, MI_XML_TAG_SERIE_NAME, movie_info->serieName);
XML_GET_DATA_INT(xam1, MI_XML_TAG_LENGTH, movie_info->length);
XML_GET_DATA_STRING(xam1, MI_XML_TAG_PRODUCT_COUNTRY, movie_info->productionCountry);
//if(!strcmp(xam1->GetType(), MI_XML_TAG_PRODUCT_COUNTRY)) if(xam1->GetData() != NULL)strncpy(movie_info->productionCountry, xam1->GetData(),4);
XML_GET_DATA_INT(xam1, MI_XML_TAG_PRODUCT_DATE, movie_info->productionDate);
XML_GET_DATA_INT(xam1, MI_XML_TAG_RATING, movie_info->rating);
XML_GET_DATA_INT(xam1, MI_XML_TAG_QUALITIY, movie_info->quality);
XML_GET_DATA_INT(xam1, MI_XML_TAG_QUALITY, movie_info->quality);
XML_GET_DATA_INT(xam1, MI_XML_TAG_PARENTAL_LOCKAGE, movie_info->parentalLockAge);
XML_GET_DATA_INT(xam1, MI_XML_TAG_DATE_OF_LAST_PLAY, movie_info->dateOfLastPlay);
if (!strcmp(xam1->GetType(), MI_XML_TAG_BOOKMARK)) {
for (XMLTreeNode * xam2 = xam1->GetChild(); xam2; xam2 = xam2->GetNext()) {
XML_GET_DATA_INT(xam2, MI_XML_TAG_BOOKMARK_START, movie_info->bookmarks.start);
XML_GET_DATA_INT(xam2, MI_XML_TAG_BOOKMARK_END, movie_info->bookmarks.end);
XML_GET_DATA_INT(xam2, MI_XML_TAG_BOOKMARK_LAST, movie_info->bookmarks.lastPlayStop);
}
}
/*****************************************************/
}
}
}
delete parser;
if (movie_info->epgInfo2.empty()) {
movie_info->epgInfo2 = movie_info->epgInfo1;
//movie_info->epgInfo1 = "";
}
#endif /* XMLTREE_LIB */
return (true);
}
#endif
/************************************************************************
************************************************************************/
#if 0
void CMovieInfo::showMovieInfo(MI_MOVIE_INFO & movie_info)
{
std::string print_buffer = movie_info.epgInfo1;
print_buffer += "\n";
if (movie_info.epgInfo1 != movie_info.epgInfo2) {
print_buffer += movie_info.epgInfo2;
print_buffer += "\n";
}
if ( !movie_info.productionCountry.empty() || movie_info.productionDate != 0) {
print_buffer += movie_info.productionCountry;
print_buffer += to_string(movie_info.productionDate + 1900);
print_buffer += "\n";
}
if (!movie_info.serieName.empty()) {
print_buffer += "\n";
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_SERIE);
print_buffer += ": ";
print_buffer += movie_info.serieName;
print_buffer += "\n";
}
if (!movie_info.epgChannel.empty()) {
print_buffer += "\n";
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_CHANNEL);
print_buffer += ": ";
print_buffer += movie_info.epgChannel;
print_buffer += "\n";
}
if (movie_info.rating != 0) {
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_RATING);
print_buffer += ": ";
print_buffer += to_string(movie_info.rating / 10);
print_buffer += ",";
print_buffer += to_string(movie_info.rating % 10);
print_buffer += "/10";
print_buffer += "\n";
}
if (movie_info.quality != 0) {
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_QUALITY);
print_buffer += ": ";
print_buffer += to_string(movie_info.quality);
print_buffer += "\n";
}
if (movie_info.parentalLockAge != 0) {
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_PARENTAL_LOCKAGE);
print_buffer += ": ";
print_buffer += to_string(movie_info.parentalLockAge);
print_buffer += " ";
print_buffer += g_Locale->getText(LOCALE_UNIT_LONG_YEARS);
print_buffer += "\n";
}
if (movie_info.length != 0) {
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_LENGTH);
print_buffer += ": ";
print_buffer += to_string(movie_info.length);
print_buffer += "\n";
}
if ( !movie_info.audioPids.empty() ) {
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_AUDIO);
print_buffer += ": ";
for (unsigned int i = 0; i < movie_info.audioPids.size(); i++) {
if (i)
print_buffer += ", ";
print_buffer += movie_info.audioPids[i].epgAudioPidName;
}
print_buffer += "\n";
}
if (movie_info.genreMajor != 0)
{
neutrino_locale_t locale_genre;
unsigned char i = (movie_info.genreMajor & 0x0F0);
if (i >= 0x010 && i < 0x0B0)
{
i >>= 4;
i--;
locale_genre = genre_sub_classes_list[i][((movie_info.genreMajor & 0x0F) < genre_sub_classes[i]) ? (movie_info.genreMajor & 0x0F) : 0];
}
else
locale_genre = LOCALE_GENRE_UNKNOWN;
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_GENRE_MAJOR);
print_buffer += ": ";
print_buffer += g_Locale->getText(locale_genre);
print_buffer += "\n";
}
tm *date_tm = localtime(&movie_info.dateOfLastPlay);
print_buffer += "\n";
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_PREVPLAYDATE);
print_buffer += ": ";
print_buffer += strftime("%F", date_tm);
print_buffer += "\n";
date_tm = localtime(&movie_info.file.Time);
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_RECORDDATE);
print_buffer += ": ";
print_buffer += strftime("%F", date_tm);
print_buffer += "\n";
if (movie_info.file.Size != 0) {
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_SIZE);
print_buffer += ": ";
print_buffer += to_string(movie_info.file.Size >> 20);
print_buffer += "\n";
}
print_buffer += g_Locale->getText(LOCALE_MOVIEBROWSER_INFO_FILE);
print_buffer += ": ";
print_buffer += movie_info.file.Name;
print_buffer += "\n";
ShowMsg2UTF(movie_info.epgTitle.empty()? movie_info.file.getFileName().c_str() : movie_info.epgTitle.c_str(), print_buffer.c_str(), CMsgBox::mbrBack, CMsgBox::mbBack); // UTF-8*/
}
#endif
/************************************************************************
************************************************************************/
#if 0
//never used
void CMovieInfo::printDebugMovieInfo(MI_MOVIE_INFO & movie_info)
{
TRACE(" FileName: %s", movie_info.file.Name.c_str());
//TRACE(" FilePath: %s", movie_info.file.GetFilePath );
//TRACE(" FileLength: %d", movie_info.file.GetLength );
//TRACE(" FileStatus: %d", movie_info.file.GetStatus );
TRACE(" ********** Movie Data ***********\r\n"); // (date, month, year)
TRACE(" dateOfLastPlay: \t%d\r\n", (int)movie_info.dateOfLastPlay); // (date, month, year)
TRACE(" dirItNr: \t\t%d\r\n", movie_info.dirItNr); //
TRACE(" genreMajor: \t\t%d\r\n", movie_info.genreMajor); //genreMajor;
TRACE(" genreMinor: \t\t%d\r\n", movie_info.genreMinor); //genreMinor;
TRACE(" length: \t\t%d\r\n", movie_info.length); // (minutes)
TRACE(" rating: \t\t%d,%d\r\n", movie_info.rating / 10, movie_info.rating % 10); // user rating (like IMDb rating; 75 means 7.5/10)
TRACE(" quality: \t\t%d\r\n", movie_info.quality); // (3 stars: classics, 2 stars: very good, 1 star: good, 0 stars: OK)
TRACE(" productionCount:\t>%s<\r\n", movie_info.productionCountry.c_str());
TRACE(" productionDate: \t%d\r\n", movie_info.productionDate); // (Year) years since 1900
TRACE(" parentalLockAge: \t\t\t%d\r\n", movie_info.parentalLockAge); // MI_PARENTAL_LOCKAGE (0,6,12,16,18)
TRACE(" format: \t\t%d\r\n", movie_info.format); // MI_VIDEO_FORMAT(16:9, 4:3)
TRACE(" audio: \t\t%d\r\n", movie_info.audio); // MI_AUDIO (AC3, Deutsch, Englisch)
TRACE(" epgId: \t\t%d\r\n", (int)movie_info.epgId);
TRACE(" epgEpgId: \t\t%llu\r\n", movie_info.epgEpgId);
TRACE(" epgMode: \t\t%d\r\n", movie_info.epgMode);
TRACE(" epgVideoPid: \t\t%d\r\n", movie_info.epgVideoPid);
TRACE(" epgVTXPID: \t\t%d\r\n", movie_info.epgVTXPID);
TRACE(" Size: \t\t%d\r\n", (int)movie_info.file.Size >> 20);
TRACE(" Date: \t\t%d\r\n", (int)movie_info.file.Time);
for (unsigned int i = 0; i < movie_info.audioPids.size(); i++) {
TRACE(" audioPid (%d): \t\t%d\r\n", i, movie_info.audioPids[i].epgAudioPid);
TRACE(" audioName(%d): \t\t>%s<\r\n", i, movie_info.audioPids[i].epgAudioPidName.c_str());
}
TRACE(" epgTitle: \t\t>%s<\r\n", movie_info.epgTitle.c_str());
TRACE(" epgInfo1:\t\t>%s<\r\n", movie_info.epgInfo1.c_str()); //epgInfo1
TRACE(" epgInfo2:\t\t\t>%s<\r\n", movie_info.epgInfo2.c_str()); //epgInfo2
TRACE(" epgChannel:\t\t>%s<\r\n", movie_info.epgChannel.c_str());
TRACE(" serieName:\t\t>%s<\r\n", movie_info.serieName.c_str()); // (name e.g. 'StarWars)
TRACE(" bookmarks start: \t%d\r\n", movie_info.bookmarks.start);
TRACE(" bookmarks end: \t%d\r\n", movie_info.bookmarks.end);
TRACE(" bookmarks lastPlayStop: %d\r\n", movie_info.bookmarks.lastPlayStop);
for (int i = 0; i < MI_MOVIE_BOOK_USER_MAX; i++) {
if (movie_info.bookmarks.user[i].pos != 0 || i == 0) {
TRACE(" bookmarks user, pos:%d, type:%d, name: >%s<\r\n", movie_info.bookmarks.user[i].pos, movie_info.bookmarks.user[i].length, movie_info.bookmarks.user[i].name.c_str());
}
}
}
#endif
/************************************************************************
************************************************************************/
static int find_next_char(char to_find, const char *text, int start_pos, int end_pos)
{
while (start_pos < end_pos) {
@@ -607,14 +272,13 @@ static int find_next_char(char to_find, const char *text, int start_pos, int end
_pos_ += sizeof(_tag_) ;\
int pos_prev = _pos_;\
while(_pos_ < bytes && _text_[_pos_] != '<' ) pos++;\
_dest_ = strtoull(&_text_[pos_prev], NULL, 10); /*atoll(&_text_[pos_prev]);*/\
_dest_ = strtoull(&_text_[pos_prev], NULL, 10);\
continue;\
}
//void CMovieInfo::strReplace(std::string& orig, const char* fstr, const std::string rstr)
void strReplace(std::string & orig, const char *fstr, const std::string &rstr)
void strReplace(std::string &orig, const char *fstr, const std::string &rstr)
{
// replace all occurrence of fstr with rstr and, and returns a reference to itself
// replace all occurrence of fstr with rstr and returns a reference to itself
size_t index = 0;
size_t fstrlen = strlen(fstr);
size_t rstrlen = rstr.size();
@@ -637,18 +301,15 @@ std::string decodeXmlSpecialChars(std::string s)
return s;
}
/************************************************************************
************************************************************************/
bool CMovieInfo::parseXmlQuickFix(std::string &_text, MI_MOVIE_INFO * movie_info)
bool CMovieInfo::parseXmlTree(std::string &_text, MI_MOVIE_INFO *movie_info)
{
#ifndef XMLTREE_LIB
int bookmark_nr = 0;
movie_info->dateOfLastPlay = 0; //100*366*24*60*60; // (date, month, year)
movie_info->dateOfLastPlay = 0; //100*366*24*60*60; // (date, month, year)
//bool result = false;
const char *text = _text.c_str();
int bytes = _text.length();
/** search ****/
int pos = 0;
EPG_AUDIO_PIDS audio_pids;
@@ -756,10 +417,10 @@ bool CMovieInfo::parseXmlQuickFix(std::string &_text, MI_MOVIE_INFO * movie_info
}
/* parse bookmarks */
GET_XML_DATA_INT(text, pos, MI_XML_TAG_BOOKMARK_START, movie_info->bookmarks.start)
GET_XML_DATA_INT(text, pos, MI_XML_TAG_BOOKMARK_END, movie_info->bookmarks.end)
GET_XML_DATA_INT(text, pos, MI_XML_TAG_BOOKMARK_LAST, movie_info->bookmarks.lastPlayStop)
GET_XML_DATA_INT(text, pos, MI_XML_TAG_BOOKMARK_END, movie_info->bookmarks.end)
GET_XML_DATA_INT(text, pos, MI_XML_TAG_BOOKMARK_LAST, movie_info->bookmarks.lastPlayStop)
if (bookmark_nr < MI_MOVIE_BOOK_USER_MAX) {
if (bookmark_nr < MI_MOVIE_BOOK_USER_MAX) {
if (strncmp(&text[pos], MI_XML_TAG_BOOKMARK_USER, sizeof(MI_XML_TAG_BOOKMARK_USER) - 1) == 0) {
pos += sizeof(MI_XML_TAG_BOOKMARK_USER);
//int pos2 = strcspn(&text[pos],MI_XML_TAG_BOOKMARK_USER_POS);
@@ -816,16 +477,13 @@ bool CMovieInfo::parseXmlQuickFix(std::string &_text, MI_MOVIE_INFO * movie_info
}
return (true);
#endif
return (false);
}
/************************************************************************
************************************************************************/
bool CMovieInfo::addNewBookmark(MI_MOVIE_INFO * movie_info, MI_BOOKMARK & new_bookmark)
{
TRACE("[mi] addNewBookmark\r\n");
TRACE("[mi] addNewBookmark\n");
bool result = false;
if (movie_info != NULL) {
// search for free entry
@@ -854,9 +512,6 @@ bool CMovieInfo::addNewBookmark(MI_MOVIE_INFO * movie_info, MI_BOOKMARK & new_bo
return (result);
}
/************************************************************************
************************************************************************/
void MI_MOVIE_INFO::clear(void)
{
@@ -870,19 +525,19 @@ void MI_MOVIE_INFO::clear(void)
file.Name = "";
file.Url = "";
file.Size = 0; // Megabytes
file.Size = 0; // Megabytes
file.Time = mktime(&timePlay);
dateOfLastPlay = mktime(&timePlay); // (date, month, year)
dirItNr = 0; //
genreMajor = 0; //genreMajor;
genreMinor = 0; //genreMinor;
length = 0; // (minutes)
rating = 0; // (like IMDb rating)
quality = 0; // (3 stars: classics, 2 stars: very good, 1 star: good, 0 stars: OK)
productionDate = 0; // (Year) years since 1900
parentalLockAge = 0; // MI_PARENTAL_LOCKAGE (0,6,12,16,18)
// format = 0; // MI_VIDEO_FORMAT(16:9, 4:3)
// audio = 0; // MI_AUDIO (AC3, Deutsch, Englisch)
dateOfLastPlay = mktime(&timePlay);
dirItNr = 0;
genreMajor = 0;
genreMinor = 0;
length = 0;
rating = 0;
quality = 0;
productionDate = 0;
parentalLockAge = 0;
//format = 0;
//audio = 0;
epgId = 0;
epgEpgId = 0;
@@ -895,10 +550,10 @@ void MI_MOVIE_INFO::clear(void)
productionCountry = "";
epgTitle = "";
epgInfo1 = ""; //epgInfo1
epgInfo2 = ""; //epgInfo2
epgInfo1 = "";
epgInfo2 = "";
epgChannel = "";
serieName = ""; // (name e.g. 'StarWars)
serieName = "";
bookmarks.end = 0;
bookmarks.start = 0;
bookmarks.lastPlayStop = 0;
@@ -908,24 +563,23 @@ void MI_MOVIE_INFO::clear(void)
bookmarks.user[i].name = "";
}
tfile = "";
ytdate = "";
ytid = "";
ytitag = 0;
marked = false;
delAsk = true;
}
/************************************************************************
************************************************************************/
bool CMovieInfo::loadFile(CFile & file, std::string &buffer)
bool CMovieInfo::loadFile(CFile &file, std::string &buffer)
{
bool result = true;
int fd = open(file.Name.c_str(), O_RDONLY);
if (fd == -1) // cannot open file, return!!!!!
if (fd == -1)
{
TRACE("[mi] loadXml: cannot open (%s)\r\n", file.Name.c_str());
TRACE("[mi] loadFile: cannot open (%s)\n", file.Name.c_str());
return false;
}
struct stat st;
@@ -935,7 +589,7 @@ bool CMovieInfo::loadFile(CFile & file, std::string &buffer)
}
char buf[st.st_size];
if (st.st_size != read(fd, buf, st.st_size)) {
TRACE("[mi] loadXml: cannot read (%s)\r\n", file.Name.c_str());
TRACE("[mi] loadFile: cannot read (%s)\n", file.Name.c_str());
result = false;
} else
buffer = std::string(buf, st.st_size);
@@ -945,22 +599,18 @@ bool CMovieInfo::loadFile(CFile & file, std::string &buffer)
return result;
}
/************************************************************************
************************************************************************/
bool CMovieInfo::saveFile(const CFile & file, std::string &text)
{
bool result = false;
int fd;
if ((fd = open(file.Name.c_str(), O_SYNC | O_WRONLY | O_CREAT | O_TRUNC, S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH)) >= 0) {
/*int nr=*/
write(fd, text.c_str(), text.size());
//fdatasync(fd);
close(fd);
result = true;
//TRACE("[mi] saved (%d)\r\n",nr);
//TRACE("[mi] saved (%d)\n",nr);
} else {
TRACE("[mi] ERROR: cannot open\r\n");
TRACE("[mi] ERROR: cannot open\n");
}
return (result);
}