mirrors/recycled-ni-neutrino
1
0
Fork 0
mirror of https://github.com/tuxbox-fork-migrations/recycled-ni-neutrino.git synced 2025-08-28 16:01:10 +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

458
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"
@@ -164,9 +112,9 @@ bool CMovieInfo::encodeMovieInfoXml(std::string * extMessage, MI_MOVIE_INFO * mo
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_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";
@@ -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,13 +224,8 @@ 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
movie_info->productionDate += 1900;
@@ -292,282 +233,6 @@ bool CMovieInfo::loadMovieInfo(MI_MOVIE_INFO * movie_info, CFile * file)
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)
//bool result = false;
const char *text = _text.c_str();
int bytes = _text.length();
/** search ****/
int pos = 0;
EPG_AUDIO_PIDS audio_pids;
@@ -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)
{
@@ -872,17 +527,17 @@ void MI_MOVIE_INFO::clear(void)
file.Url = "";
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);
}

91
src/gui/movieinfo.h
View File

@@ -1,15 +1,8 @@
/***************************************************************************
Neutrino-GUI - DBoxII-Project
Homepage: http://dbox.cyberphoria.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.
/*
movieinfo - Neutrino-GUI
Copyright (C) 2005 Günther <Günther@tuxbox.berlios.org>
Copyright (C) 2015 Sven Hoefer (svenhoefer)
License: GPL
@@ -27,21 +20,7 @@
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
***********************************************************
Module Name: movieinfo.h .
Description: implementation of the CMovieInfo class
Date: Nov 2005
Author: Günther@tuxbox.berlios.org
Revision History:
Date Author Change Description
Nov 2005 Günther initial start
****************************************************************************/
*/
#ifndef MOVIEINFO_H_
#define MOVIEINFO_H_
@@ -57,16 +36,9 @@
#include <stdint.h>
#include "driver/file.h"
/************************************************************************/
/************************************************************************/
/***************** CMovieInfo ********************************/
/************************************************************************/
/* XML tags for xml file*/
#define MI_XML_TAG_NEUTRINO "neutrino"
#define MI_XML_TAG_RECORD "record"
#define MI_XML_TAG_CHANNELNAME "channelname"
#define MI_XML_TAG_EPGTITLE "epgtitle"
#define MI_XML_TAG_ID "id"
@@ -103,7 +75,6 @@
#define MI_XML_TAG_BOOKMARK_USER_NAME "bookmarkusername"
#define MI_XML_TAG_DATE_OF_LAST_PLAY "dateoflastplay"
#define MI_MAX_AUDIO_PIDS 4 // just to avoid the buffer is filled endless, might be increased later on , but 4 audio pids might be enough
#define MI_MOVIE_BOOK_USER_MAX 20 // just to avoid the buffer is filled endless, might be increased later on. Make sure to increase the bookmark menu as well
@@ -116,14 +87,14 @@ typedef enum
MI_PARENTAL_OVER18 = 18,
MI_PARENTAL_ALWAYS = 99,
MI_PARENTAL_MAX_NUMBER = 100
}MI_PARENTAL_LOCKAGE;
} MI_PARENTAL_LOCKAGE;
typedef struct
{
int pos; // position in seconds from file start
int length; // bookmark type, 0: just a bookmark, < 0 jump back (seconds), > 0 jump forward (seconds)
std::string name; // bookmark name to be displayed
}MI_BOOKMARK;
} MI_BOOKMARK;
typedef struct
{
@@ -131,7 +102,7 @@ typedef struct
int end; // movie end in seconds from file start
int lastPlayStop; // position of last play stop in seconds from file start
MI_BOOKMARK user[MI_MOVIE_BOOK_USER_MAX]; // other user defined bookmarks
}MI_MOVIE_BOOKMARKS;
} MI_MOVIE_BOOKMARKS;
typedef struct
{
@@ -139,15 +110,11 @@ typedef struct
int selected;
int epgAudioPid; // epg audio pid nr, usually filled by VCR
std::string epgAudioPidName; // epg audio pid name, usually filled by VCR
}EPG_AUDIO_PIDS;
} EPG_AUDIO_PIDS;
/************************************************************************/
/************************************************************************/
class MI_MOVIE_INFO
class MI_MOVIE_INFO //MI_MOVIE_INFO &operator=(const MI_MOVIE_INFO& src);
{
public:
//MI_MOVIE_INFO &operator=(const MI_MOVIE_INFO& src);
CFile file; // not stored in xml
std::string productionCountry; // user defined Country (not from EPG yet, but might be possible)
std::string epgTitle; // plain movie name, usually filled by EPG
@@ -176,14 +143,21 @@ class MI_MOVIE_INFO
int epgVideoPid; // currently not used, we just do not want to loose this info if movie info is saved backed
int VideoType;
int epgVTXPID; // currently not used, we just do not want to loose this info if movie info is saved backed
bool marked;
bool delAsk;
std::string tfile; // thumbnail/cover file name
std::string ytdate; // yt published
std::string ytid; // yt published
std::string ytdate; // youtube published
std::string ytid; // youtube published
int ytitag; // youtube quality profile
enum miSource { UNKNOWN = 0, YT, NK };
enum miSource {
UNKNOWN = 0,
YT,
NK
};
miSource source;
void clear(void);
@@ -198,23 +172,16 @@ class CMovieInfo
public: // Functions
CMovieInfo();
~CMovieInfo();
bool convertTs2XmlName(std::string& filename); // convert a ts file name in .xml file name
bool loadMovieInfo(MI_MOVIE_INFO* movie_info, CFile* file = NULL ); // load movie information for the given .xml filename. If there is no filename, the filename (ts) from movie_info is converted to xml and used instead
bool encodeMovieInfoXml(std::string* extMessage, MI_MOVIE_INFO * movie_info); // encode the movie_info structure to xml string
bool saveMovieInfo(MI_MOVIE_INFO& movie_info, CFile* file = NULL ); // encode the movie_info structure to xml and save it to the given .xml filename. If there is no filename, the filename (ts) from movie_info is converted to xml and used instead
#if 0
void showMovieInfo(MI_MOVIE_INFO& movie_info); // open a Hintbox and show the movie info
#endif
void printDebugMovieInfo(MI_MOVIE_INFO& movie_info); // print movie info on debug channel (RS232)
bool addNewBookmark(MI_MOVIE_INFO* movie_info,MI_BOOKMARK &new_bookmark); // add a new bookmark to the given movie info. If there is no space false is returned
bool convertTs2XmlName(std::string &filename); // convert a ts file name in .xml file name
bool loadMovieInfo(MI_MOVIE_INFO *movie_info, CFile *file = NULL ); // load movie information for the given .xml filename. If there is no filename, the filename (ts) from movie_info is converted to xml and used instead
bool encodeMovieInfoXml(std::string *extMessage, MI_MOVIE_INFO *movie_info); // encode the movie_info structure to xml string
bool saveMovieInfo(MI_MOVIE_INFO &movie_info, CFile *file = NULL ); // encode the movie_info structure to xml and save it to the given .xml filename. If there is no filename, the filename (ts) from movie_info is converted to xml and used instead
bool addNewBookmark(MI_MOVIE_INFO *movie_info, MI_BOOKMARK &new_bookmark); // add a new bookmark to the given movie info. If there is no space false is returned
private:// Functions
bool parseXmlTree (std::string &text, MI_MOVIE_INFO* movie_info); // this is the 'good' function, but it needs the xmllib which is not currently linked within neutrino. Might be to slow as well. If used, add bookmark parsing
bool parseXmlQuickFix(std::string &text, MI_MOVIE_INFO* movie_info); // OK, this is very quick an dirty. It does not waste execution time or flash (this is QUICK). But, do not play to much with the xml files (e.g. with MS Notepad) since small changes in the structure could cause the parser to fail (this it DIRTY).
bool loadFile(CFile& file, std::string &buffer);
bool saveFile(const CFile& file, std::string &buffer);
private:// variables
private: // Functions
bool parseXmlTree(std::string &text, MI_MOVIE_INFO *movie_info);
bool loadFile(CFile &file, std::string &buffer);
bool saveFile(const CFile &file, std::string &buffer);
};
#endif /*MOVIEINFO_H_*/
// vim:ts=4