diff --git a/data/icons/status/channel/res_2160.png b/data/icons/status/channel/res_2160.png new file mode 100644 index 000000000..e5c1a75fb Binary files /dev/null and b/data/icons/status/channel/res_2160.png differ diff --git a/data/icons/status/channel/res_uhd.png b/data/icons/status/channel/res_uhd.png new file mode 100644 index 000000000..250127a90 Binary files /dev/null and b/data/icons/status/channel/res_uhd.png differ diff --git a/data/webtv/Makefile.am b/data/webtv/Makefile.am new file mode 100644 index 000000000..87442050b --- /dev/null +++ b/data/webtv/Makefile.am @@ -0,0 +1,7 @@ +installdir = $(WEBTVDIR) + +install_DATA = \ + filmon.lua \ + filmon.xml \ + yt_live.lua \ + yt_live.xml diff --git a/data/webtv_usr.xml b/data/webtv_usr.xml new file mode 100644 index 000000000..2e017daac --- /dev/null +++ b/data/webtv_usr.xml @@ -0,0 +1,5 @@ + + + + + diff --git a/lib/hardware/coolstream/hd1/libcoolstream/playback_cs.h b/lib/hardware/coolstream/hd1/libcoolstream/playback_cs.h index c5eb51377..9d844a5ea 100644 --- a/lib/hardware/coolstream/hd1/libcoolstream/playback_cs.h +++ b/lib/hardware/coolstream/hd1/libcoolstream/playback_cs.h @@ -66,6 +66,7 @@ public: bool IsEnabled(void) const { return enabled; } void FindAllPids(playback_audio_pid_info_t *audiopids, uint16_t size, uint16_t *numpida); void FindAllPids(uint16_t *apids, unsigned short *ac3flags, uint16_t *numpida, std::string *language); + void FindAllPids(uint16_t *apids, unsigned short *ac3flags, uint32_t *numpida, std::string *language){FindAllPids(apids, ac3flags, (uint16_t*) numpida, language);} void FindAllSubs(uint16_t *pids, unsigned short *supported, uint16_t *numpida, std::string *language); bool SelectSubtitles(int pid, std::string charset = ""); void GetChapters(std::vector &positions, std::vector &titles); @@ -73,6 +74,14 @@ public: void GetTitles(std::vector &playlists, std::vector &titles, int ¤t); void SetTitle(int title); uint64_t GetReadCount(void); + void FindAllTeletextsubtitlePids(int *, unsigned int *numpids, std::string *, int *, int *){*numpids = 0;} + void FindAllSubtitlePids(int * /*pids*/, unsigned int *numpids, std::string * /*language*/){*numpids = 0;} + int GetSubtitlePid(void){return 0;} + bool SetTeletextPid(int /*pid*/){return true;} + int GetAPid(){return 0;} + void GetMetadata(std::vector /*&keys*/, std::vector /*&values*/){}; +} +} }; #endif // __PLAYBACK_CS_H_ diff --git a/lib/hardware/coolstream/hd2/libcoolstream/playback_cs.h b/lib/hardware/coolstream/hd2/libcoolstream/playback_cs.h index d0dfea272..2ec13a430 100644 --- a/lib/hardware/coolstream/hd2/libcoolstream/playback_cs.h +++ b/lib/hardware/coolstream/hd2/libcoolstream/playback_cs.h @@ -67,6 +67,7 @@ public: bool IsEnabled(void) const { return enabled; } void FindAllPids(playback_audio_pid_info_t *audiopids, uint16_t size, uint16_t *numpida); void FindAllPids(uint16_t *apids, unsigned short *ac3flags, uint16_t *numpida, std::string *language); + void FindAllPids(uint16_t *apids, unsigned short *ac3flags, uint32_t *numpida, std::string *language){FindAllPids(apids, ac3flags, (uint16_t*) numpida, language);} void FindAllSubs(uint16_t *pids, unsigned short *supported, uint16_t *numpida, std::string *language); bool SelectSubtitles(int pid, std::string charset = ""); void GetChapters(std::vector &positions, std::vector &titles); @@ -74,6 +75,12 @@ public: void GetTitles(std::vector &playlists, std::vector &titles, int ¤t); void SetTitle(int title); uint64_t GetReadCount(void); + void FindAllTeletextsubtitlePids(int *, unsigned int *numpids, std::string *, int *, int *){*numpids = 0;} + void FindAllSubtitlePids(int * /*pids*/, unsigned int *numpids, std::string * /*language*/){*numpids = 0;} + int GetSubtitlePid(void){return 0;} + bool SetTeletextPid(int /*pid*/){return true;} + int GetAPid(){return 0;} + void GetMetadata(std::vector /*&keys*/, std::vector /*&values*/){}; }; #endif // __PLAYBACK_CS_H_ diff --git a/src/driver/Makefile.am b/src/driver/Makefile.am index f4d708063..298e9274d 100644 --- a/src/driver/Makefile.am +++ b/src/driver/Makefile.am @@ -82,6 +82,11 @@ libneutrino_driver_a_SOURCES += \ fb_accel_glfb.cpp \ simple_display.cpp endif +if BOXTYPE_ARMBOX +libneutrino_driver_a_SOURCES += \ + fb_accel.cpp \ + simple_display.cpp +endif if USE_STB_HAL AM_CPPFLAGS += \ @DIRECTFB_CFLAGS@ diff --git a/src/driver/display.h b/src/driver/display.h index e80049a46..31935c152 100644 --- a/src/driver/display.h +++ b/src/driver/display.h @@ -2,6 +2,6 @@ #if HAVE_COOL_HARDWARE #include #endif -#if HAVE_TRIPLEDRAGON || HAVE_SPARK_HARDWARE || HAVE_AZBOX_HARDWARE || HAVE_GENERIC_HARDWARE +#if HAVE_TRIPLEDRAGON || HAVE_SPARK_HARDWARE || HAVE_AZBOX_HARDWARE || HAVE_GENERIC_HARDWARE || HAVE_ARM_HARDWARE #include #endif diff --git a/src/driver/lcdd.cpp b/src/driver/lcdd.cpp index 85af71262..d5ac2181b 100644 --- a/src/driver/lcdd.cpp +++ b/src/driver/lcdd.cpp @@ -51,8 +51,6 @@ #include extern CRemoteControl * g_RemoteControl; /* neutrino.cpp */ -/* we get edvbstring.h included via from src/system/settings.h */ -#if 0 /* from edvbstring.cpp */ static bool isUTF8(const std::string &string) { @@ -84,7 +82,6 @@ static bool isUTF8(const std::string &string) } return true; // can be UTF8 (or pure ASCII, at least no non-UTF-8 8bit characters) } -#endif CLCD::CLCD() { @@ -145,9 +142,8 @@ void CLCD::count_down() { } void CLCD::wake_up() { - int tmp = atoi(g_settings.lcd_setting_dim_time.c_str()); - if (tmp > 0) { - timeout_cnt = (unsigned int)tmp; + if (atoi(g_settings.lcd_setting_dim_time) > 0) { + timeout_cnt = atoi(g_settings.lcd_setting_dim_time); setlcdparameter(); } } @@ -155,8 +151,8 @@ void CLCD::wake_up() { #ifndef BOXMODEL_DM500 void* CLCD::TimeThread(void *p) { - set_threadname("lcd:time"); ((CLCD *)p)->thread_started = true; + set_threadname("lcd:time"); while (((CLCD *)p)->thread_started) { sleep(1); @@ -392,7 +388,7 @@ void CLCD::setlcdparameter(int /*dimm*/, const int contrast, const int /*power*/ void CLCD::setlcdparameter(void) { last_toggle_state_power = g_settings.lcd_setting[SNeutrinoSettings::LCD_POWER]; - int dim_time = atoi(g_settings.lcd_setting_dim_time.c_str()); + int dim_time = atoi(g_settings.lcd_setting_dim_time); int dim_brightness = g_settings.lcd_setting_dim_brightness; bool timeouted = (dim_time > 0) && (timeout_cnt == 0); int brightness, power = 0; @@ -716,13 +712,11 @@ void CLCD::showVolume(const char vol, const bool perform_update) wake_up(); } -void CLCD::showPercentOver(const unsigned char perc, const bool perform_update, const MODES /*m*/) +void CLCD::showPercentOver(const unsigned char perc, const bool perform_update, const MODES m) { -/* if (mode != m) - printf("CLCD::showPercentOver: mode (%d) != m (%d), please report\n", (int)mode, (int)m); - // return; -*/ + return; + int left, top, width, height = 5; bool draw = true; percentOver = perc; @@ -905,14 +899,13 @@ void CLCD::showAudioPlayMode(AUDIOMODES m) displayUpdate(); } -void CLCD::showAudioProgress(const char perc) //, bool isMuted) +void CLCD::showAudioProgress(const char perc, bool isMuted) { if (mode == MODE_AUDIO) { display.draw_fill_rect (11,53,73,61, CLCDDisplay::PIXEL_OFF); int dp = perc * 61 / 100 + 12; display.draw_fill_rect (11,54,dp,60, CLCDDisplay::PIXEL_ON); -#if 0 if(isMuted) { if(dp > 12) @@ -923,7 +916,6 @@ void CLCD::showAudioProgress(const char perc) //, bool isMuted) else display.draw_line (12,55,72,59, CLCDDisplay::PIXEL_ON); } -#endif displayUpdate(); } } diff --git a/src/driver/lcdd.h b/src/driver/lcdd.h index 789c88cb3..3b2539319 100644 --- a/src/driver/lcdd.h +++ b/src/driver/lcdd.h @@ -60,10 +60,51 @@ typedef enum FP_ICON_PAUSE = 0x0A000001, FP_ICON_CAM1 = 0x0B000001, FP_ICON_COL2 = 0x0B000002, - FP_ICON_CAM2 = 0x0C000001 + FP_ICON_CAM2 = 0x0C000001, + FP_ICON_CLOCK, + FP_ICON_FR, + FP_ICON_FF, + FP_ICON_DD, + FP_ICON_LOCK } fp_icon; #define CVFD CLCD +typedef enum +{ + SPARK_PLAY_FASTBACKWARD = 1, + SPARK_PLAY = 3, + SPARK_PLAY_FASTFORWARD = 5, + SPARK_PAUSE = 6, + SPARK_REC1 = 7, + SPARK_MUTE = 8, + SPARK_CYCLE = 9, + SPARK_DD = 10, + SPARK_CA = 11, + SPARK_CI= 12, + SPARK_USB = 13, + SPARK_DOUBLESCREEN = 14, + SPARK_HDD_A8 = 16, + SPARK_HDD_A7 = 17, + SPARK_HDD_A6 = 18, + SPARK_HDD_A5 = 19, + SPARK_HDD_A4 = 20, + SPARK_HDD_A3 = 21, + SPARK_HDD_FULL = 22, + SPARK_HDD_A2 = 23, + SPARK_HDD_A1 = 24, + SPARK_MP3 = 25, + SPARK_AC3 = 26, + SPARK_TVMODE_LOG = 27, + SPARK_AUDIO = 28, + SPARK_HDD = 30, + SPARK_CLOCK = 33, + SPARK_TER = 37, + SPARK_SAT = 42, + SPARK_TIMESHIFT = 43, + SPARK_CAB = 45, + SPARK_ALL = 46 +} spark_icon; + #ifdef LCD_UPDATE #ifdef HAVE_CONFIG_H #include @@ -116,6 +157,7 @@ class CLCD private: + #ifdef HAVE_TRIPLEDRAGON class FontsDef { @@ -173,7 +215,14 @@ class CLCD static void *TimeThread(void *); pthread_t thrTime; bool thread_running; + int last_toggle_state_power; + int brightness; + unsigned int timeout_cnt; + unsigned int switch_name_time_cnt; + void setlcdparameter(int dimm, int power); + void count_down(); #endif + public: bool has_lcd; void wake_up(); @@ -191,6 +240,7 @@ class CLCD void setHddUsage(int perc); void showServicename(const std::string name, const bool clear_epg = false); + std::string getServicename(void) { return servicename; } void setEPGTitle(const std::string title); void setMovieInfo(const AUDIOMODES playmode, const std::string big, const std::string small, const bool centered = false); void setMovieAudio(const bool is_ac3); @@ -203,7 +253,7 @@ class CLCD void showMenuText(const int position, const char * text, const int highlight = -1, const bool utf_encoded = false); void showAudioTrack(const std::string & artist, const std::string & title, const std::string & album); void showAudioPlayMode(AUDIOMODES m=AUDIO_MODE_PLAY); - void showAudioProgress(const char perc); + void showAudioProgress(const char perc, bool isMuted = false); void setBrightness(int); int getBrightness(); @@ -225,7 +275,7 @@ class CLCD int getAutoDimm(); void setBrightnessDeepStandby(int) { return ; }; int getBrightnessDeepStandby() { return 0; }; - + void repaintIcons() { return; }; void setMuted(bool); void resume(); @@ -234,6 +284,10 @@ class CLCD void Lock(); void Unlock(); void Clear(); + void SetIcons(int icon, bool show); + void UpdateIcons(); + void ShowDiskLevel(); + void Reset() {}; void ShowIcon(fp_icon icon, bool show); void ShowText(const char *s) { showServicename(std::string(s), true); }; ~CLCD(); diff --git a/src/driver/movieinfo.cpp b/src/driver/movieinfo.cpp index a2fa9eb51..3e555bc38 100644 --- a/src/driver/movieinfo.cpp +++ b/src/driver/movieinfo.cpp @@ -386,8 +386,11 @@ bool CMovieInfo::parseXmlTree(std::string &_text, MI_MOVIE_INFO *movie_info) } } } - //printf("MOVIE INFO: apid %d type %d name %s selected %d\n", audio_pids.AudioPid, audio_pids.atype, audio_pids.AudioPidName.c_str(), audio_pids.selected); - movie_info->audioPids.push_back(audio_pids); + //printf("MOVIE INFO: apid %d type %d name %s selected %d\n", audio_pids.AudioPid, audio_pids.atype, audio_pids.epgAudioPidName.c_str(), audio_pids.selected); + unsigned int j, asize = movie_info->audioPids.size(); + for (j = 0; j < asize && audio_pids.AudioPid != movie_info->audioPids[j].AudioPid; j++); + if (j == asize) + movie_info->audioPids.push_back(audio_pids); } /* parse bookmarks */ GET_XML_DATA_INT(text, pos, MI_XML_TAG_BOOKMARK_START, movie_info->bookmarks.start) @@ -487,6 +490,57 @@ bool CMovieInfo::addNewBookmark(MI_MOVIE_INFO * movie_info, MI_BOOKMARK & new_bo } +void CMovieInfo::clearMovieInfo(MI_MOVIE_INFO * movie_info) +{ + //TRACE("[mi]->clearMovieInfo \r\n"); + tm timePlay; + timePlay.tm_hour = 0; + timePlay.tm_min = 0; + timePlay.tm_sec = 0; + timePlay.tm_year = 100; + timePlay.tm_mday = 0; + timePlay.tm_mon = 1; + + movie_info->file.Name = ""; + movie_info->file.Size = 0; // Megabytes + movie_info->file.Time = mktime(&timePlay); + movie_info->dateOfLastPlay = mktime(&timePlay); // (date, month, year) + movie_info->dirItNr = 0; // + movie_info->genreMajor = 0; //genreMajor; + movie_info->genreMinor = 0; //genreMinor; + movie_info->length = 0; // (minutes) + movie_info->quality = 0; // (3 stars: classics, 2 stars: very good, 1 star: good, 0 stars: OK) + movie_info->productionDate = 0; // (Year) years since 1900 + movie_info->parentalLockAge = 0; // MI_PARENTAL_LOCKAGE (0,6,12,16,18) + + movie_info->channelId = 0; + movie_info->epgId = 0; + movie_info->mode = 0; + movie_info->VideoPid = 0; + movie_info->VideoType = 0; + movie_info->VtxtPid = 0; + + movie_info->audioPids.clear(); + + movie_info->productionCountry = ""; + movie_info->epgTitle = ""; + movie_info->epgInfo1 = ""; //epgInfo1 + movie_info->epgInfo2 = ""; //epgInfo2 + movie_info->channelName = ""; + movie_info->serieName = ""; // (name e.g. 'StarWars) + movie_info->bookmarks.end = 0; + movie_info->bookmarks.start = 0; + movie_info->bookmarks.lastPlayStop = 0; + for (int i = 0; i < MI_MOVIE_BOOK_USER_MAX; i++) { + movie_info->bookmarks.user[i].pos = 0; + movie_info->bookmarks.user[i].length = 0; + movie_info->bookmarks.user[i].name = ""; + } + movie_info->tfile.clear(); + movie_info->ytdate.clear(); + movie_info->ytid.clear(); +} + void MI_MOVIE_INFO::clear(void) { tm timePlay; diff --git a/src/driver/movieinfo.h b/src/driver/movieinfo.h index 8ce7e4426..49e7e2deb 100644 --- a/src/driver/movieinfo.h +++ b/src/driver/movieinfo.h @@ -177,6 +177,7 @@ class CMovieInfo 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 + void clearMovieInfo(MI_MOVIE_INFO *movie_info); // clear infos completly private: // Functions bool parseXmlTree(std::string &text, MI_MOVIE_INFO *movie_info); diff --git a/src/driver/screenshot.cpp b/src/driver/screenshot.cpp index ec4a80339..0fdfb1ccb 100644 --- a/src/driver/screenshot.cpp +++ b/src/driver/screenshot.cpp @@ -54,6 +54,7 @@ extern "C" { extern cVideo *videoDecoder; +#if HAVE_COOL_HARDWARE /* constructor, defaults is empty fname and CScreenShot::FORMAT_JPG format */ CScreenShot::CScreenShot(const std::string fname, screenshot_format_t fmt) { @@ -147,6 +148,7 @@ bool CScreenShot::GetData() #endif if (videoDecoder->getBlank()) get_video = false; + #ifdef BOXMODEL_CS_HD2 if (extra_osd && !get_video) { uint32_t memSize = xres * yres * sizeof(fb_pixel_t) * 2; @@ -161,7 +163,7 @@ bool CScreenShot::GetData() } else #endif -#ifdef SCREENSHOT +#if 1 // to enable after libcs/drivers update res = videoDecoder->GetScreenImage(pixel_data, xres, yres, get_video, get_osd, scale_to_video); #endif @@ -317,7 +319,11 @@ bool CScreenShot::SavePng() png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL); info_ptr = png_create_info_struct(png_ptr); +#if (PNG_LIBPNG_VER < 10500) + if (setjmp(png_ptr->jmpbuf)) +#else if (setjmp(png_jmpbuf(png_ptr))) +#endif { printf("CScreenShot::SavePng: %s save error\n", filename.c_str()); png_destroy_write_struct(&png_ptr, &info_ptr); @@ -524,3 +530,529 @@ void CScreenShot::MakeFileName(const t_channel_id channel_id) printf("CScreenShot::MakeFileName: [%s]\n", fname); filename = std::string(fname); } +#else //HAVE_COOL_HARDWARE + +/* constructor, defaults is empty fname and CScreenShot::FORMAT_JPG format */ +CScreenShot::CScreenShot(const std::string fname, screenshot_format_t fmt) +{ + format = fmt; + filename = fname; + pixel_data = NULL; + fd = NULL; + xres = 0; + yres = 0; + extra_osd = false; + scs_thread = 0; + pthread_mutex_init(&thread_mutex, NULL); + pthread_mutex_init(&getData_mutex, NULL); + get_video = g_settings.screenshot_video; + get_osd = g_settings.screenshot_mode; + scale_to_video = g_settings.screenshot_scale; +} + +CScreenShot::~CScreenShot() +{ + pthread_mutex_destroy(&thread_mutex); + pthread_mutex_destroy(&getData_mutex); +// printf("[CScreenShot::%s:%d] thread: %p\n", __func__, __LINE__, this); +} + +#ifdef BOXMODEL_CS_HD2 + +bool CScreenShot::mergeOsdScreen(uint32_t dx, uint32_t dy, fb_pixel_t* osdData) +{ + uint8_t* d = (uint8_t *)pixel_data; + fb_pixel_t* d2; + + for (uint32_t count = 0; count < dy; count++ ) { + fb_pixel_t *pixpos = (fb_pixel_t*)&osdData[count*dx]; + d2 = (fb_pixel_t*)d; + for (uint32_t count2 = 0; count2 < dx; count2++ ) { + //don't paint backgroundcolor (*pixpos = 0x00000000) + if (*pixpos) { + fb_pixel_t pix = *pixpos; + if ((pix & 0xff000000) == 0xff000000) + *d2 = (pix & 0x00ffffff); + else { + uint8_t *in = (uint8_t *)(pixpos); + uint8_t *out = (uint8_t *)d2; + int a = in[3]; + *out = (*out + ((*in - *out) * a) / 256); + in++; out++; + *out = (*out + ((*in - *out) * a) / 256); + in++; out++; + *out = (*out + ((*in - *out) * a) / 256); + } + } + d2++; + pixpos++; + } + d += dx*sizeof(fb_pixel_t); + } + return true; +} +#endif + +/* try to get video frame data in ARGB format, restore GXA state */ +bool CScreenShot::GetData() +{ +#ifdef BOXMODEL_CS_HD2 + /* Workaround for broken osd screenshot with new fb driver and 1280x720 resolution */ + CFrameBuffer* frameBuffer = CFrameBuffer::getInstance(); + fb_pixel_t* screenBuf = NULL; + uint32_t _xres = 0, _yres = 0; + if (frameBuffer->fullHdAvailable() && (frameBuffer->getScreenWidth(true) == 1280)) { + _xres = xres = 1280; + _yres = yres = 720; + get_osd = false; + extra_osd = true; + screenBuf = new fb_pixel_t[_xres*_yres*sizeof(fb_pixel_t)]; + if (screenBuf == NULL) { + printf("[CScreenShot::%s:%d] memory error\n", __func__, __LINE__); + return false; + } + printf("\n[CScreenShot::%s:%d] Read osd screen...", __func__, __LINE__); + frameBuffer->SaveScreen(0, 0, _xres, _yres, screenBuf); + printf(" done.\n"); + } +#endif + + bool res = false; + pthread_mutex_lock(&getData_mutex); + +#ifdef BOXMODEL_CS_HD1 + CFrameBuffer::getInstance()->setActive(false); +#endif + if (videoDecoder->getBlank()) + get_video = false; + +#ifdef BOXMODEL_CS_HD2 + if (extra_osd && !get_video) { + uint32_t memSize = xres * yres * sizeof(fb_pixel_t) * 2; + pixel_data = (uint8_t*)cs_malloc_uncached(memSize); + if (pixel_data == NULL) { + printf("[CScreenShot::%s:%d] memory error\n", __func__, __LINE__); + pthread_mutex_unlock(&getData_mutex); + return false; + } + memset(pixel_data, 0, memSize); + res = true; + } + else +#endif +#if 1 // to enable after libcs/drivers update + res = videoDecoder->GetScreenImage(pixel_data, xres, yres, get_video, get_osd, scale_to_video); +#endif + +#ifdef BOXMODEL_CS_HD1 + /* sort of hack. GXA used to transfer/convert live image to RGB, + * so setup GXA back */ + CFrameBuffer::getInstance()->setupGXA(); + CFrameBuffer::getInstance()->add_gxa_sync_marker(); + CFrameBuffer::getInstance()->setActive(true); +#endif + pthread_mutex_unlock(&getData_mutex); + if (!res) { + printf("[CScreenShot::%s:%d] GetScreenImage failed\n", __func__, __LINE__); + return false; + } + +#ifdef BOXMODEL_CS_HD2 + if (extra_osd && screenBuf) { + printf("[CScreenShot::%s:%d] Merge osd screen to screenshot...", __func__, __LINE__); + mergeOsdScreen(_xres, _yres, screenBuf); + delete[] screenBuf; + printf(" done.\n \n"); + } +#endif + printf("[CScreenShot::%s:%d] data: %p %d x %d\n", __func__, __LINE__, pixel_data, xres, yres); + return true; +} + +bool CScreenShot::startThread() +{ + if (!scs_thread) { + void *ptr = static_cast(this); + int res = pthread_create(&scs_thread, NULL, initThread, ptr); + if (res != 0) { + printf("[CScreenShot::%s:%d] ERROR! pthread_create\n", __func__, __LINE__); + return false; + } + pthread_detach(scs_thread); + pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0); + pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, 0); + } + return true; +} + +void* CScreenShot::initThread(void *arg) +{ + CScreenShot *scs = static_cast(arg); + pthread_cleanup_push(cleanupThread, scs); +// printf("[CScreenShot::%s:%d] thread: %p\n", __func__, __LINE__, scs); + + scs->runThread(); + pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0); + pthread_exit(0); + + pthread_cleanup_pop(0); + return 0; +} + +/* thread function to save data asynchroniosly. delete itself after saving */ +void CScreenShot::runThread() +{ + pthread_mutex_lock(&thread_mutex); + printf("[CScreenShot::%s:%d] save to %s format %d\n", __func__, __LINE__, filename.c_str(), format); + + bool ret = SaveFile(); + + printf("[CScreenShot::%s:%d] %s finished: %d\n", __func__, __LINE__, filename.c_str(), ret); + pthread_mutex_unlock(&thread_mutex); +} + +void CScreenShot::cleanupThread(void *arg) +{ + CScreenShot *scs = static_cast(arg); +// printf("[CScreenShot::%s:%d] thread: %p\n", __func__, __LINE__, scs); + delete scs; +} + +// printf("[CScreenShot::%s:%d] thread: %p\n", __func__, __LINE__, scs); +delete scs; +} + +/* start ::run in new thread to save file in selected format */ +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE +bool CScreenShot::Start(const std::string custom_cmd) +{ + std::string cmd = "/bin/grab "; + if (get_osd && !get_video) + cmd += "-o "; + else if (!get_osd && get_video) + cmd += "-v "; + + switch (format) { + case FORMAT_PNG: + cmd += "-p "; + break; + case FORMAT_JPG: + cmd += "-j 100"; + break; + default: + ; + } + + if (!scale_to_video) + cmd += " -d"; + + if (xres) { + char tmp[10]; + snprintf(tmp, sizeof(tmp), "%d", xres); + cmd += "-w " + std::string(tmp); + } + + if (!custom_cmd.empty()) + cmd = "/bin/grab " + custom_cmd; + + cmd += " '"; + cmd += filename; + cmd += "'"; + fprintf(stderr, "running: %s\n", cmd.c_str()); + system(cmd.c_str()); + return true; +} +#else + +/* start ::run in new thread to save file in selected format */ +bool CScreenShot::Start() +{ + set_threadname("n:screenshot"); + bool ret = false; + if (GetData()) + ret = startThread(); + else + delete this; + return ret; + } +#endif + +/* save file in sync mode, return true if save ok, or false */ +bool CScreenShot::StartSync() +{ + bool ret = false; + printf("[CScreenShot::%s:%d] save to %s format %d\n", __func__, __LINE__, filename.c_str(), format); + if (GetData()) + ret = SaveFile(); + printf("[CScreenShot::%s:%d] %s finished: %d\n", __func__, __LINE__, filename.c_str(), ret); + return ret; +} + +/* save file in selected format, free data received from video decoder */ +bool CScreenShot::SaveFile() +{ + bool ret = true; + + switch (format) { + case FORMAT_PNG: + ret = SavePng(); + break; + default: + printf("CScreenShot::SaveFile unsupported format %d, using jpeg\n", format); + /* fall through */ + case FORMAT_JPG: + ret = SaveJpg(); + break; + case FORMAT_BMP: + ret = SaveBmp(); + break; + } + + cs_free_uncached((void *) pixel_data); + return ret; +} + +/* try to open file, return true if success, or false */ +bool CScreenShot::OpenFile() +{ + fd = fopen(filename.c_str(), "w"); + if (!fd) { + printf("CScreenShot::OpenFile: failed to open %s\n", filename.c_str()); + return false; + } + return true; +} + +/* save screenshot in png format, return true if success, or false */ +bool CScreenShot::SavePng() +{ + png_bytep *row_pointers; + png_structp png_ptr; + png_infop info_ptr; + + TIMER_START(); + if(!OpenFile()) + return false; + + row_pointers = (png_bytep *) malloc(sizeof(png_bytep) * yres); + if (!row_pointers) { + printf("CScreenShot::SavePng: malloc error\n"); + fclose(fd); + return false; + } + + png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, (png_voidp)NULL, (png_error_ptr)NULL, (png_error_ptr)NULL); + info_ptr = png_create_info_struct(png_ptr); +#if (PNG_LIBPNG_VER < 10500) + if (setjmp(png_ptr->jmpbuf)) +#else + if (setjmp(png_jmpbuf(png_ptr))) +#endif + { + printf("CScreenShot::SavePng: %s save error\n", filename.c_str()); + png_destroy_write_struct(&png_ptr, &info_ptr); + free(row_pointers); + fclose(fd); + return false; + } + + png_init_io(png_ptr, fd); + + int y; + for (y=0; yerr really points to a my_error_mgr struct, so coerce pointer */ + my_error_ptr myerr = (my_error_ptr) cinfo->err; + + /* Always display the message. */ + /* We could postpone this until after returning, if we chose. */ + (*cinfo->err->output_message) (cinfo); + + /* Return control to the setjmp point */ + longjmp(myerr->setjmp_buffer, 1); +} + +/* save screenshot in jpg format, return true if success, or false */ +bool CScreenShot::SaveJpg() +{ + int quality = 90; + + TIMER_START(); + if(!OpenFile()) + return false; + + for (int y = 0; y < yres; y++) { + int xres1 = y*xres*3; + int xres2 = xres1+2; + for (int x = 0; x < xres; x++) { + int x2 = x*3; + memmove(pixel_data + x2 + xres1, pixel_data + x*4 + y*xres*4, 3); + SWAP(pixel_data[x2 + xres1], pixel_data[x2 + xres2]); + } + } + + struct jpeg_compress_struct cinfo; + struct my_error_mgr jerr; + JSAMPROW row_pointer[1]; + unsigned int row_stride; + + cinfo.err = jpeg_std_error(&jerr.pub); + jerr.pub.error_exit = my_error_exit; + + if (setjmp(jerr.setjmp_buffer)) { + printf("CScreenShot::SaveJpg: %s save error\n", filename.c_str()); + jpeg_destroy_compress(&cinfo); + fclose(fd); + return false; + } + + jpeg_create_compress(&cinfo); + jpeg_stdio_dest(&cinfo, fd); + + cinfo.image_width = xres; + cinfo.image_height = yres; + cinfo.input_components = 3; + cinfo.in_color_space = JCS_RGB; + cinfo.dct_method = JDCT_IFAST; + + jpeg_set_defaults(&cinfo); + jpeg_set_quality(&cinfo, quality, TRUE); + jpeg_start_compress(&cinfo, TRUE); + row_stride = xres * 3; + + while (cinfo.next_scanline < cinfo.image_height) { + row_pointer[0] = & pixel_data[cinfo.next_scanline * row_stride]; + jpeg_write_scanlines(&cinfo, row_pointer, 1); + } + jpeg_finish_compress(&cinfo); + jpeg_destroy_compress(&cinfo); + fclose(fd); + TIMER_STOP(("[CScreenShot::SaveJpg] " + filename).c_str()); + return true; +} + +/* save screenshot in bmp format, return true if success, or false */ +bool CScreenShot::SaveBmp() +{ + TIMER_START(); + if(!OpenFile()) + return false; + + unsigned char hdr[14 + 40]; + unsigned int i = 0; +#define PUT32(x) hdr[i++] = ((x)&0xFF); hdr[i++] = (((x)>>8)&0xFF); hdr[i++] = (((x)>>16)&0xFF); hdr[i++] = (((x)>>24)&0xFF); +#define PUT16(x) hdr[i++] = ((x)&0xFF); hdr[i++] = (((x)>>8)&0xFF); +#define PUT8(x) hdr[i++] = ((x)&0xFF); + PUT8('B'); PUT8('M'); + PUT32((((xres * yres) * 3 + 3) &~ 3) + 14 + 40); + PUT16(0); PUT16(0); PUT32(14 + 40); + PUT32(40); PUT32(xres); PUT32(yres); + PUT16(1); + PUT16(4*8); // bits + PUT32(0); PUT32(0); PUT32(0); PUT32(0); PUT32(0); PUT32(0); +#undef PUT32 +#undef PUT16 +#undef PUT8 + fwrite(hdr, 1, i, fd); + + int y; + for (y=yres-1; y>=0 ; y-=1) { + fwrite(pixel_data+(y*xres*4),xres*4,1,fd); + } + fclose(fd); + TIMER_STOP(("[CScreenShot::SaveBmp] " + filename).c_str()); + return true; + +} + +/* + * create filename member from channel name and its current EPG data, + * with added date and time including msecs and suffix for selected format + */ +void CScreenShot::MakeFileName(const t_channel_id channel_id) +{ + char fname[512]; // UTF-8 + std::string channel_name; + CEPGData epgData; + unsigned int pos = 0; + + snprintf(fname, sizeof(fname), "%s/", g_settings.screenshot_dir.c_str()); + pos = strlen(fname); + + channel_name = CServiceManager::getInstance()->GetServiceName(channel_id); + if (!(channel_name.empty())) { + strcpy(&(fname[pos]), UTF8_TO_FILESYSTEM_ENCODING(channel_name.c_str())); + ZapitTools::replace_char(&fname[pos]); + strcat(fname, "_"); + } + pos = strlen(fname); + + if(CEitManager::getInstance()->getActualEPGServiceKey(channel_id, &epgData)) { + CShortEPGData epgdata; + if(CEitManager::getInstance()->getEPGidShort(epgData.eventID, &epgdata)) { + if (!(epgdata.title.empty())) { + strcpy(&(fname[pos]), epgdata.title.c_str()); + ZapitTools::replace_char(&fname[pos]); + } + } + } + pos = strlen(fname); + + struct timeval tv; + gettimeofday(&tv, NULL); + strftime(&(fname[pos]), sizeof(fname) - pos - 1, "_%Y%m%d_%H%M%S", localtime(&tv.tv_sec)); + pos = strlen(fname); + snprintf(&(fname[pos]), sizeof(fname) - pos - 1, "_%03d", (int) tv.tv_usec/1000); + + switch (format) { + case FORMAT_PNG: + strcat(fname, ".png"); + break; + default: + printf("CScreenShot::MakeFileName unsupported format %d, using jpeg\n", format); + /* fall through */ + case FORMAT_JPG: + strcat(fname, ".jpg"); + break; + case FORMAT_BMP: + strcat(fname, ".bmp"); + break; + } + printf("CScreenShot::MakeFileName: [%s]\n", fname); + filename = std::string(fname); +} + +#endif // HAVE_COOL_HARDWARE diff --git a/src/driver/screenshot.h b/src/driver/screenshot.h index bf17e72bf..461d245a3 100644 --- a/src/driver/screenshot.h +++ b/src/driver/screenshot.h @@ -44,6 +44,7 @@ class CScreenShot bool get_osd; bool get_video; bool scale_to_video; +#if !HAVE_SPARK_HARDWARE && !HAVE_DUCKBOX_HARDWARE FILE *fd; pthread_t scs_thread; pthread_mutex_t thread_mutex; @@ -61,6 +62,7 @@ class CScreenShot static void* initThread(void *arg); void runThread(); static void cleanupThread(void *arg); +#endif #ifdef BOXMODEL_CS_HD2 bool mergeOsdScreen(uint32_t dx, uint32_t dy, fb_pixel_t* osdData); @@ -75,7 +77,11 @@ class CScreenShot void EnableVideo(bool enable) { get_video = enable; } void EnableOSD(bool enable) { get_osd = enable; } void ScaleToVideo(bool enable) { scale_to_video = enable; } +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE + bool Start(const std::string custom_cmd = ""); +#else bool Start(); +#endif bool StartSync(); }; diff --git a/src/driver/simple_display.cpp b/src/driver/simple_display.cpp index df158909a..89e1d7266 100644 --- a/src/driver/simple_display.cpp +++ b/src/driver/simple_display.cpp @@ -25,6 +25,8 @@ #endif #include +#include +#include #include #include @@ -33,19 +35,53 @@ #include //#include #include + #if HAVE_SPARK_HARDWARE #include #define DISPLAY_DEV "/dev/vfd" +#include +#include +static bool usb_icon = false; +static bool timer_icon = false; #endif + #if HAVE_AZBOX_HARDWARE #define DISPLAY_DEV "/proc/vfd" #define LED_DEV "/proc/led" #endif + #if HAVE_GENERIC_HARDWARE #define DISPLAY_DEV "/dev/null" +static bool usb_icon = false; +static bool timer_icon = false; #endif -#include +#if HAVE_ARM_HARDWARE +#define DISPLAY_DEV "/dev/dbox/oled0" +#include +#include +static bool usb_icon = false; +static bool timer_icon = false; +static int proc_put(const char *path, bool state) +{ + int ret, ret2; + int pfd = open(path, O_WRONLY); + char *value; + if (state) + value="1"; + else + value="0"; + if (pfd < 0) + return pfd; + ret = write(pfd, value, 1); + ret2 = close(pfd); + if (ret2 < 0) + return ret2; + return ret; +} +#else +static int proc_put(const char *path, bool state) {} +#endif static char volume = 0; //static char percent = 0; @@ -121,8 +157,16 @@ printf("%s '%s'\n", __func__, s); CLCD::CLCD() { - /* do not show menu in neutrino... */ - has_lcd = false; + /* do not show menu in neutrino...,at Line Display true, because there is th GLCD Menu */ + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) + { + has_lcd = true; + mode = MODE_TVRADIO; + switch_name_time_cnt = 0; + timeout_cnt = 0; + } else + has_lcd = false; + servicename = ""; thread_running = false; } @@ -147,6 +191,18 @@ CLCD* CLCD::getInstance() void CLCD::wake_up() { + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + if (atoi(g_settings.lcd_setting_dim_time.c_str()) > 0) { + timeout_cnt = atoi(g_settings.lcd_setting_dim_time.c_str()); + g_settings.lcd_setting_dim_brightness > -1 ? + setBrightness(g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS]) : setPower(1); + } + else + setPower(1); + if(g_settings.lcd_info_line){ + switch_name_time_cnt = g_settings.timing[SNeutrinoSettings::TIMING_INFOBAR] + 10; + } + } } void* CLCD::TimeThread(void *) @@ -154,7 +210,25 @@ void* CLCD::TimeThread(void *) set_threadname("n:boxdisplay"); /* to not confuse with TV display */ while (CLCD::getInstance()->thread_running) { sleep(1); - CLCD::getInstance()->showTime(); + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + struct stat buf; + if (stat("/tmp/vfd.locked", &buf) == -1) { + CLCD::getInstance()->showTime(); + CLCD::getInstance()->count_down(); + } else + CLCD::getInstance()->wake_up(); + } else + CLCD::getInstance()->showTime(); +#if 0 + /* hack, just if we missed the blit() somewhere + * this will update the framebuffer once per second */ + if (getenv("SPARK_NOBLIT") == NULL) { + CFrameBuffer *fb = CFrameBuffer::getInstance(); + /* plugin start locks the framebuffer... */ + if (!fb->Locked()) + fb->blit(); + } +#endif } return NULL; } @@ -172,6 +246,11 @@ void CLCD::init(const char *, const char *, const char *, const char *, const ch void CLCD::setlcdparameter(void) { + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + last_toggle_state_power = g_settings.lcd_setting[SNeutrinoSettings::LCD_POWER]; + setlcdparameter((mode == MODE_STANDBY) ? g_settings.lcd_setting[SNeutrinoSettings::LCD_STANDBY_BRIGHTNESS] : (mode == MODE_SHUTDOWN) ? g_settings.lcd_setting[SNeutrinoSettings::LCD_DEEPSTANDBY_BRIGHTNESS] : g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS], + last_toggle_state_power); + } } void CLCD::showServicename(std::string name, bool) @@ -179,10 +258,10 @@ void CLCD::showServicename(std::string name, bool) if (g_info.hw_caps->display_type == HW_DISPLAY_LED_NUM) return; servicename = name; - if (mode != MODE_TVRADIO) + if (mode != MODE_TVRADIO && mode != MODE_AUDIO) return; - replace_umlauts(servicename); - strncpy(display_text, servicename.c_str(), sizeof(display_text) - 1); + replace_umlauts(name); + strncpy(display_text, name.c_str(), sizeof(display_text) - 1); display_text[sizeof(display_text) - 1] = '\0'; upd_display = true; } @@ -197,7 +276,7 @@ void CLCD::setled(int red, int green) if (fd < 0) return; - // printf("%s red:%d green:%d\n", __func__, red, green); +printf("%s red:%d green:%d\n", __func__, red, green); for (i = 0; i < 2; i++) { @@ -307,9 +386,14 @@ void CLCD::showTime(bool force) blink = !blink; if (led_g) green = blink; - - if (led_r || led_g) - setled(red, green); + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + if (led_r) + SetIcons(SPARK_REC1, red); + if (led_g) + SetIcons(SPARK_PLAY, green); + } else + if (led_r || led_g) + setled(red, green); } void CLCD::showRCLock(int) @@ -332,10 +416,15 @@ void CLCD::showVolume(const char vol, const bool update) volume = 100; if (muted) + { + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) + SetIcons(SPARK_MUTE, 1); strcpy(s, mutestr[type]); - else + } else { + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) + SetIcons(SPARK_MUTE, 0); sprintf(s, vol_fmt[type], volume); - + } display(s); vol_active = true; } @@ -355,18 +444,18 @@ void CLCD::showMenuText(const int, const char *text, const int, const bool) upd_display = true; } -void CLCD::showAudioTrack(const std::string &, const std::string & /*title*/, const std::string &) +void CLCD::showAudioTrack(const std::string &, const std::string & title, const std::string &) { if (mode != MODE_AUDIO) return; -// ShowText(title.c_str()); + ShowText(title.c_str()); } void CLCD::showAudioPlayMode(AUDIOMODES) { } -void CLCD::showAudioProgress(const char) +void CLCD::showAudioProgress(const char, bool) { } @@ -376,7 +465,10 @@ void CLCD::setMode(const MODES m, const char * const) switch (m) { case MODE_TVRADIO: - setled(0, 0); + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) + SetIcons(SPARK_CYCLE, 0); + else + setled(0, 0); showclock = true; power = true; if (g_info.hw_caps->display_type != HW_DISPLAY_LED_NUM) { @@ -388,11 +480,13 @@ void CLCD::setMode(const MODES m, const char * const) break; case MODE_SHUTDOWN: showclock = false; - showTime(); Clear(); break; case MODE_STANDBY: - setled(0, 1); + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) + SetIcons(SPARK_CYCLE, 1); + else + setled(0, 1); showclock = true; showTime(true); break; @@ -402,22 +496,80 @@ void CLCD::setMode(const MODES m, const char * const) } } -void CLCD::setBrightness(int) +void CLCD::setBrightness(int dimm) { +#if HAVE_SPARK_HARDWARE + switch(dimm) { + case 15: + case 14: dimm = 7; break; + case 13: + case 12: dimm = 6; break; + case 11: + case 10: dimm = 5; break; + case 9: + case 8: dimm = 4; break; + case 7: + case 6: dimm = 3; break; + case 5: + case 4: dimm = 2; break; + case 3: + case 2: dimm = 1; break; + case 1: + case 0: dimm = 0; break; + } + + struct aotom_ioctl_data d; + + if (dimm < 0 || dimm > 7) + return; + + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + int fd = dev_open(); + if (fd < 0) + return; + + d.u.brightness.level = dimm; + + if (ioctl(fd, VFDBRIGHTNESS, &d) < 0) + fprintf(stderr, "[neutrino] %s set brightness VFDBRIGHTNESS: %m\n", __func__); + + close(fd); + } +#elif HAVE_ARM_HARDWARE + std::string value = to_string(255/15*dimm); + int pfd = open("/proc/stb/lcd/oled_brightness", O_WRONLY); + if (pfd) + write(pfd, value.c_str(), value.length()); + close(pfd); +#endif } int CLCD::getBrightness() { - return 0; + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + if(g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS] > 15) + g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS] = 15; + return g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS]; + } else + return 0; } -void CLCD::setBrightnessStandby(int) +void CLCD::setBrightnessStandby(int bright) { + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + g_settings.lcd_setting[SNeutrinoSettings::LCD_STANDBY_BRIGHTNESS] = bright; + setlcdparameter(); + } } int CLCD::getBrightnessStandby() { - return 0; + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + if(g_settings.lcd_setting[SNeutrinoSettings::LCD_STANDBY_BRIGHTNESS] > 15) + g_settings.lcd_setting[SNeutrinoSettings::LCD_STANDBY_BRIGHTNESS] = 15; + return g_settings.lcd_setting[SNeutrinoSettings::LCD_STANDBY_BRIGHTNESS]; + } else + return 0; } void CLCD::setPower(int) @@ -426,7 +578,10 @@ void CLCD::setPower(int) int CLCD::getPower() { - return 0; + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) + return g_settings.lcd_setting[SNeutrinoSettings::LCD_POWER]; + else + return 0; } void CLCD::togglePower(void) @@ -436,6 +591,11 @@ void CLCD::togglePower(void) Clear(); else showTime(true); + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + last_toggle_state_power = 1 - last_toggle_state_power; + setlcdparameter((mode == MODE_STANDBY) ? g_settings.lcd_setting[SNeutrinoSettings::LCD_STANDBY_BRIGHTNESS] : (mode == MODE_SHUTDOWN) ? g_settings.lcd_setting[SNeutrinoSettings::LCD_DEEPSTANDBY_BRIGHTNESS] : g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS], + last_toggle_state_power); + } } void CLCD::setMuted(bool mu) @@ -471,6 +631,10 @@ void CLCD::Clear() if(ret < 0) perror("[neutrino] spark_led Clear() VFDDISPLAYCLR"); close(fd); + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + SetIcons(SPARK_ALL, false); + SetIcons(SPARK_CLOCK, timer_icon); + } servicename.clear(); printf("spark_led:%s\n", __func__); } @@ -481,17 +645,186 @@ void CLCD::Clear() } #endif +void CLCD::count_down() { + if (timeout_cnt > 0) { + timeout_cnt--; + if (timeout_cnt == 0 ) { + if (g_settings.lcd_setting_dim_brightness > -1) { + // save lcd brightness, setBrightness() changes global setting + int b = g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS]; + setBrightness(g_settings.lcd_setting_dim_brightness); + g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS] = b; + } else { + setPower(0); + } + } + } + if (g_settings.lcd_info_line && switch_name_time_cnt > 0) { + switch_name_time_cnt--; + if (switch_name_time_cnt == 0) { + if (g_settings.lcd_setting_dim_brightness > -1) { + CLCD::getInstance()->showTime(true); + } + } + } +} + +void CLCD::setlcdparameter(int dimm, const int power) +{ + if(dimm < 0) + dimm = 0; + else if(dimm > 15) + dimm = 15; + + if(!power) + dimm = 0; + + if(brightness == dimm) + return; + + brightness = dimm; + +printf("CLCD::setlcdparameter dimm %d power %d\n", dimm, power); + setBrightness(dimm); +} + +void CLCD::SetIcons(int icon, bool on) +{ +#if HAVE_SPARK_HARDWARE + struct aotom_ioctl_data d; + d.u.icon.icon_nr = icon; + if (on == true) + d.u.icon.on = 1; + else + d.u.icon.on = 0; + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + int fd = dev_open(); + if (fd < 0) + return; + if (ioctl(fd, VFDICONDISPLAYONOFF, &d) <0) + perror("[neutrino] SetIcons() VFDICONDISPLAYONOFF"); + close(fd); + } +#else + //nothing +#endif +} +void CLCD::ShowDiskLevel() +{ +#if !HAVE_GENERIC_HARDWARE && !HAVE_ARM_HARDWARE + int hdd_icons[9] ={24, 23, 21, 20, 19, 18, 17, 16, 22}; + int percent, digits, i, j; + uint64_t t, u; + if (get_fs_usage(g_settings.network_nfs_recordingdir.c_str(), t, u)) + { + SetIcons(SPARK_HDD, true); + percent = (int)((u * 1000ULL) / t + 60); + digits = percent / 125; + if (percent > 1050) + digits = 9; + //printf("HDD Fuell = %d Digits = %d\n", percent, digits); + if (digits > 0) + { + for (i=0; igetLiveFE(); + SetIcons(SPARK_SAT, aktFE->isSat(aktFE->getCurrentDeliverySystem())); + SetIcons(SPARK_CAB, aktFE->isCable(aktFE->getCurrentDeliverySystem())); + SetIcons(SPARK_TER, aktFE->isTerr(aktFE->getCurrentDeliverySystem())); + + ShowDiskLevel(); + SetIcons(SPARK_USB, usb_icon); +#endif +#if HAVE_SPARK_HARDWARE || HAVE_ARM_HARDWARE + CZapitChannel * chan = CZapit::getInstance()->GetCurrentChannel(); + if (chan) + { + ShowIcon(FP_ICON_HD,chan->isHD()); + ShowIcon(FP_ICON_LOCK,!chan->camap.empty()); + if (chan->getAudioChannel() != NULL) + { + ShowIcon(FP_ICON_DD, chan->getAudioChannel()->audioChannelType == CZapitAudioChannel::AC3); + SetIcons(SPARK_MP3, chan->getAudioChannel()->audioChannelType == CZapitAudioChannel::MPEG); + } + } +#endif +} + void CLCD::ShowIcon(fp_icon i, bool on) { switch (i) { case FP_ICON_CAM1: led_r = on; - setled(led_r, -1); /* switch instant on / switch off if disabling */ + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + SetIcons(SPARK_REC1, on); + proc_put("/proc/stb/lcd/symbol_recording",on);} + else + setled(led_r, -1); /* switch instant on / switch off if disabling */ break; case FP_ICON_PLAY: led_g = on; - setled(-1, led_g); + if (g_info.hw_caps->display_type == HW_DISPLAY_LINE_TEXT) { + SetIcons(SPARK_PLAY, on); + proc_put("/proc/stb/lcd/symbol_playback",on);} + else + setled(-1, led_g); + break; + case FP_ICON_USB: + usb_icon = on; + SetIcons(SPARK_USB, on); + proc_put("/proc/stb/lcd/symbol_usb",on); + break; + case FP_ICON_HDD: + SetIcons(SPARK_HDD, on); + proc_put("/proc/stb/lcd/symbol_hdd",on); + break; + case FP_ICON_PAUSE: + SetIcons(SPARK_PAUSE, on); + break; + case FP_ICON_FF: + SetIcons(SPARK_PLAY_FASTFORWARD, on); + break; + case FP_ICON_FR: + SetIcons(SPARK_PLAY_FASTBACKWARD, on); + break; + case FP_ICON_DD: + SetIcons(SPARK_DD, on); + SetIcons(SPARK_AC3, on); + break; + case FP_ICON_LOCK: + SetIcons(SPARK_CA, on); + proc_put("/proc/stb/lcd/symbol_scrambled",on); + break; + case FP_ICON_RADIO: + SetIcons(SPARK_AUDIO, on); + break; + case FP_ICON_TV: + SetIcons(SPARK_TVMODE_LOG, on); + proc_put("/proc/stb/lcd/symbol_tv",on); + break; + case FP_ICON_HD: + SetIcons(SPARK_DOUBLESCREEN, on); + break; + case FP_ICON_CLOCK: + timer_icon = on; + SetIcons(SPARK_CLOCK, on); + proc_put("/proc/stb/lcd/symbol_timeshift",on); break; default: break; diff --git a/src/driver/vfd.cpp b/src/driver/vfd.cpp index b081d5b62..49e7edfac 100644 --- a/src/driver/vfd.cpp +++ b/src/driver/vfd.cpp @@ -47,8 +47,222 @@ #include extern CRemoteControl * g_RemoteControl; /* neutrino.cpp */ +#ifdef HAVE_DUCKBOX_HARDWARE +#include +#include +#define VFD_DEVICE "/dev/vfd" + +#if defined (BOXMODEL_OCTAGON1008) || defined (BOXMODEL_TF7700) +#define VFDLENGTH 8 +#elif defined (BOXMODEL_FORTIS_HDBOX) || defined (BOXMODEL_ATEVIO7500) +#define VFDLENGTH 12 +#elif defined (BOXMODEL_HS7810A) || defined (BOXMODEL_HS7119) || defined (BOXMODEL_HS7819) || defined (BOXMODEL_CUBEREVO_250HD) || defined (BOXMODEL_IPBOX55) +#define VFDLENGTH 4 +#elif defined (BOXMODEL_HS7110) +#define VFDLENGTH 0 +#elif defined (BOXMODEL_IPBOX9900) || defined (BOXMODEL_IPBOX99) +#define VFDLENGTH 14 +#else +#define VFDLENGTH 16 +#endif + +#define SCROLL_TIME 100000 + +bool invert = false; + +bool blocked = false; +int blocked_counter = 0; +int file_vfd = -1; +bool active_icon[16] = { false }; + +pthread_t vfd_scrollText; + +struct vfd_ioctl_data { + unsigned char start; + unsigned char data[64]; + unsigned char length; +}; + +static void write_to_vfd(unsigned int DevType, struct vfd_ioctl_data * data, bool force = false) +{ + int file_closed = 0; + if (blocked) { + if (file_vfd > -1) { + blocked_counter++; + usleep(SCROLL_TIME); + } else { + blocked = false; + } + } + if (blocked_counter > 10) { + force = true; + blocked_counter = 0; + } +// printf("[CVFD] - blocked_counter=%i, blocked=%i, force=%i\n", blocked, blocked_counter, force); + if (force || !blocked) { + if (blocked) { + if (file_vfd > -1) { + file_closed = close(file_vfd); + file_vfd = -1; + } + } + blocked = true; + if (file_vfd == -1) + file_vfd = open (VFD_DEVICE, O_RDWR); + if (file_vfd > -1) { + ioctl(file_vfd, DevType, data); + ioctl(file_vfd, I_FLUSH, FLUSHRW); + file_closed = close(file_vfd); + file_vfd = -1; + } + blocked = false; + blocked_counter = 0; + } +} + +#if defined (BOXMODEL_UFS910) || defined (BOXMODEL_UFS922) +static void writeCG (unsigned char adress, unsigned char pixeldata[5]) +{ + struct vfd_ioctl_data data; + data.start = adress & 0x07; + data.data[0] = pixeldata[0]; + data.data[1] = pixeldata[1]; + data.data[2] = pixeldata[2]; + data.data[3] = pixeldata[3]; + data.data[4] = pixeldata[4]; + data.length = 5; + write_to_vfd(VFDWRITECGRAM, &data); + return; +} +#endif + +static void ShowNormalText(char * str, bool fromScrollThread = false) +{ + if (blocked) + { + printf("[CVFD] - blocked\n"); + usleep(SCROLL_TIME); + } + + int ws = 0; // needed whitespace for centering + struct vfd_ioctl_data data; + + if (!fromScrollThread) + { + if(vfd_scrollText != 0) + { + pthread_cancel(vfd_scrollText); + pthread_join(vfd_scrollText, NULL); + + vfd_scrollText = 0; + } + } + if ((strlen(str) > VFDLENGTH && !fromScrollThread) && (g_settings.lcd_vfd_scroll >= 1)) + { + CVFD::getInstance()->ShowScrollText(str); + return; + } + + if (strlen(str) < VFDLENGTH && VFDLENGTH > 7) // do not center on small displays + ws = (VFDLENGTH-strlen(str))/2; + else + ws = 0; + memset(data.data, ' ', 63); + if (!fromScrollThread) + { + memcpy (data.data+ws, str, VFDLENGTH-ws); + data.start = 0; + if ((strlen(str) % 2) == 1 && VFDLENGTH > 7) // do not center on small displays + data.length = VFDLENGTH-ws-1; + else + data.length = VFDLENGTH-ws; + } + else + { + memcpy ( data.data, str, VFDLENGTH); + data.start = 0; + data.length = VFDLENGTH; + } + write_to_vfd(VFDDISPLAYCHARS, &data); + return; +} +void CVFD::ShowScrollText(char *str) +{ + printf("CVFD::ShowScrollText: [%s]\n", str); + + if (blocked) + { + printf("[CVFD] - blocked\n"); + usleep(SCROLL_TIME); + } + + //stop scrolltextthread + if(vfd_scrollText != 0) + { + pthread_cancel(vfd_scrollText); + pthread_join(vfd_scrollText, NULL); + + vfd_scrollText = 0; + scrollstr = (char *)""; + } + + //scroll text thread + scrollstr = str; + pthread_create(&vfd_scrollText, NULL, ThreadScrollText, (void *)scrollstr); +} + +void* CVFD::ThreadScrollText(void * arg) +{ + pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL); + + int i; + char *str = (char *)arg; + int len = strlen(str); + char out[VFDLENGTH+1]; + char buf[VFDLENGTH+65]; + + memset(out, 0, VFDLENGTH+1); + + int retries = g_settings.lcd_vfd_scroll; + + if (len > VFDLENGTH) + { + printf("CVFD::ThreadScrollText: [%s], length %d\n", str, len); + memset(buf, ' ', (len + VFDLENGTH)); + memcpy(buf, str, len); + + while(retries--) + { +// usleep(SCROLL_TIME); + + for (i = 0; i <= (len-1); i++) + { + // scroll text until end + memcpy(out, buf+i, VFDLENGTH); + ShowNormalText(out,true); + usleep(SCROLL_TIME); + } + } + } + memcpy(out, str, VFDLENGTH); // display first VFDLENGTH chars after scrolling + ShowNormalText(out,true); + + pthread_exit(0); + + return NULL; +} +#endif + CVFD::CVFD() { + text[0] = 0; + g_str[0] = 0; + clearClock = 0; + mode = MODE_TVRADIO; + switch_name_time_cnt = 0; + timeout_cnt = 0; + service_number = -1; + #ifdef VFD_UPDATE m_fileList = NULL; m_fileListPos = 0; @@ -64,12 +278,16 @@ CVFD::CVFD() has_lcd = true; has_led_segment = false; +#if !HAVE_DUCKBOX_HARDWARE fd = open("/dev/display", O_RDONLY); if(fd < 0) { perror("/dev/display"); has_lcd = false; has_led_segment = false; } +#else + fd = 1; +#endif #ifdef BOXMODEL_CS_HD2 if (fd >= 0) { @@ -103,21 +321,16 @@ CVFD::CVFD() support_text = true; support_numbers = true; #endif - - text.clear(); - clearClock = 0; - mode = MODE_TVRADIO; - switch_name_time_cnt = 0; - timeout_cnt = 0; - service_number = -1; } CVFD::~CVFD() { +#if !HAVE_DUCKBOX_HARDWARE if(fd > 0){ close(fd); fd = -1; } +#endif } CVFD* CVFD::getInstance() @@ -154,7 +367,7 @@ void CVFD::count_down() { } void CVFD::wake_up() { - if(fd < 0) return; + if(fd < 0) return; if (atoi(g_settings.lcd_setting_dim_time.c_str()) > 0) { timeout_cnt = atoi(g_settings.lcd_setting_dim_time.c_str()); @@ -166,6 +379,9 @@ void CVFD::wake_up() { if(g_settings.lcd_info_line){ switch_name_time_cnt = g_settings.timing[SNeutrinoSettings::TIMING_INFOBAR] + 10; } +#if defined (BOXMODEL_OCTAGON1008) + ShowIcon(ICON_COLON2, false); +#endif } @@ -214,9 +430,68 @@ void CVFD::setlcdparameter(int dimm, const int power) brightness = dimm; printf("CVFD::setlcdparameter dimm %d power %d\n", dimm, power); +#if !HAVE_DUCKBOX_HARDWARE int ret = ioctl(fd, IOC_FP_SET_BRIGHT, dimm); if(ret < 0) perror("IOC_FP_SET_BRIGHT"); +#else +// Brightness + struct vfd_ioctl_data data; +#if !defined (BOXMODEL_HS7810A) && !defined (BOXMODEL_HS7119) && !defined (BOXMODEL_HS7819) + memset(&data, 0, sizeof(struct vfd_ioctl_data)); + data.start = brightness & 0x07; + data.length = 0; + write_to_vfd(VFDBRIGHTNESS, &data); +#endif +#if defined (BOXMODEL_FORTIS_HDBOX) || defined (BOXMODEL_ATEVIO7500) + usleep(100000); + memset(&data, 0, sizeof(struct vfd_ioctl_data)); + data.start = 0; + data.length = 5; + if (power) { + data.data[0] = 0x01; // red led + } + else + { + data.data[0] = 0xf2; // cross plus blue led + } + data.start = 0; + data.data[4] = 0; // off + data.length = 5; + write_to_vfd(VFDPWRLED, &data); + usleep(100000); + memset(&data, 0, sizeof(struct vfd_ioctl_data)); + data.start = 0; + data.length = 5; + if (power) { + data.data[0] = 0xf2; // cross plus blue led + } + else + { + data.data[0] = 0x01; // red led + } + data.start = 0; + data.data[4] = brightness*2; + data.length = 5; + write_to_vfd(VFDPWRLED, &data); +#elif defined (BOXMODEL_HS7810A) || defined (BOXMODEL_HS7819) + memset(&data, 0, sizeof(struct vfd_ioctl_data)); + data.start = 0; + data.data[0] = 0x02; // logo + data.data[4] = (brightness & 0x07); + data.length = 5; + write_to_vfd(VFDPWRLED, &data); +#elif !defined (BOXMODEL_UFS912) && !defined (BOXMODEL_UFS913) && !defined (BOXMODEL_OCTAGON1008) +// Power on/off + if (power) { + data.start = 0x01; + } else { + data.start = 0x00; + } + data.length = 0; + write_to_vfd(VFDDISPLAYWRITEONOFF, &data, true); +#endif +#endif } void CVFD::setlcdparameter(void) @@ -227,6 +502,7 @@ void CVFD::setlcdparameter(void) last_toggle_state_power); } +#if !HAVE_DUCKBOX_HARDWARE void CVFD::setled(int led1, int led2) { int ret = -1; @@ -324,6 +600,7 @@ void CVFD::setled(void) } setled(led1, led2); } +#endif void CVFD::showServicename(const std::string & name, int number) // UTF-8 { @@ -367,6 +644,24 @@ void CVFD::showTime(bool force) if(force || ( switch_name_time_cnt == 0 && ((hour != t->tm_hour) || (minute != t->tm_min))) ) { hour = t->tm_hour; minute = t->tm_min; +#if !defined (BOXMODEL_HS7810A) && !defined (BOXMODEL_HS7819) +#if defined (BOXMODEL_OCTAGON1008) + ShowIcon(ICON_COLON2, true); +#elif defined (BOXMODEL_OCTAGON1008) || defined (BOXMODEL_HS7119) || defined (BOXMODEL_CUBEREVO_250HD) + strftime(timestr, 5, "%H%M", t); +#else + strftime(timestr, 6, "%H:%M", t); +#endif + ShowText(timestr); +#else //HS7810A or HS7819, string should not scroll + strftime(timestr, 6, "%H:%M", t); + struct vfd_ioctl_data data; + memset(data.data, ' ', 6); + memcpy (data.data, timestr, 6); + data.start = 0; + data.length = 5; + write_to_vfd(VFDDISPLAYCHARS, &data); +#endif if (support_text) { strftime(timestr, 20, "%H:%M", t); ShowText(timestr); @@ -386,24 +681,44 @@ void CVFD::showTime(bool force) clearClock = 0; if(has_lcd) ShowIcon(FP_ICON_CAM1, false); +#if !HAVE_DUCKBOX_HARDWARE setled(false);//off +#endif } else { clearClock = 1; if(has_lcd) ShowIcon(FP_ICON_CAM1, true); +#if !HAVE_DUCKBOX_HARDWARE setled(true);//on +#endif } } else if(clearClock || (recstatus != tmp_recstatus)) { // in case icon ON after record stopped clearClock = 0; if(has_lcd) ShowIcon(FP_ICON_CAM1, false); +#if !HAVE_DUCKBOX_HARDWARE setled(); +#endif } recstatus = tmp_recstatus; } +#if HAVE_DUCKBOX_HARDWARE +void CVFD::UpdateIcons() +{ + CZapitChannel * chan = CZapit::getInstance()->GetCurrentChannel(); + if (chan) + { + ShowIcon(FP_ICON_HD,chan->isHD()); + ShowIcon(FP_ICON_LOCK,!chan->camap.empty()); + if (chan->getAudioChannel() != NULL) + ShowIcon(FP_ICON_DD, chan->getAudioChannel()->audioChannelType == CZapitAudioChannel::AC3); + } +} +#endif + void CVFD::showRCLock(int duration) { if (!has_lcd || !g_settings.lcd_notify_rclock) @@ -435,8 +750,75 @@ void CVFD::showVolume(const char vol, const bool force_update) if (g_settings.lcd_setting[SNeutrinoSettings::LCD_SHOW_VOLUME] == 1) { wake_up(); +#if HAVE_DUCKBOX_HARDWARE + int pp = (int) round((double) vol / (double) 2); + if(oldpp != pp) + { +#if defined (BOXMODEL_UFS910) || defined (BOXMODEL_UFS922) + int i; + unsigned char speaker[5] = {0x1C, 0x1C, 0x1C, 0x3E, 0x7F}; // speaker symbol + writeCG(0, speaker); + + int j = pp / 5; + // v-lines 0-5 = {0x10,0x11,0x12,0x13,0x14,0x15} + char c0[1] = {0x5F}; + char c1[1] = {0x11}; + char c2[1] = {0x12}; + char c3[1] = {0x13}; + char c4[1] = {0x14}; + char c5[1] = {0x15}; + char VolumeBar[17]; + memset (VolumeBar, 0, sizeof(VolumeBar)); + char act[2] = {0x01, 0x20}; + strncat(VolumeBar, act, 2); + for(i=1; i <= j; i++) + { + strncat(VolumeBar, c5, 1); + } + i = pp % 5; + switch (i) + { + case 1: + strncat(VolumeBar, c1, 1); + break; + case 2: + strncat(VolumeBar, c2, 1); + break; + case 3: + strncat(VolumeBar, c3, 1); + break; + case 4: + strncat(VolumeBar, c4, 1); + break; + } + //dprintf(DEBUG_DEBUG,"CVFD::showVolume: vol %d - pp %d - fullblocks %d - mod %d - %s\n", vol, pp, j, i, VolumeBar); + if (strlen(VolumeBar) < 12) { + for (int a=strlen(VolumeBar); a < 12; a++) + strncat(VolumeBar, c0, 1); + } + ShowText(VolumeBar); +#elif defined (BOXMODEL_TF7700) + char vol_chr[64] = ""; + snprintf(vol_chr, sizeof(vol_chr)-1, "VOL: %d%%", (int)vol); + ShowText(vol_chr); +#elif defined (BOXMODEL_OCTAGON1008) + char vol_chr[64] = ""; + snprintf(vol_chr, sizeof(vol_chr)-1, "VOL=%3d", (int)vol); + ShowText(vol_chr); +#elif defined (BOXMODEL_HS7119) || defined (BOXMODEL_HS7810A) || defined (BOXMODEL_HS7819) || defined (BOXMODEL_CUBEREVO_250HD) || defined (BOXMODEL_IPBOX55) + char vol_chr[64] = ""; + snprintf(vol_chr, sizeof(vol_chr)-1, "v%3d", (int)vol); + ShowText(vol_chr); +#elif defined (BOXMODEL_FORTIS_HDBOX) || defined (BOXMODEL_ATEVIO7500) || defined (BOXMODEL_UFS912) || defined (BOXMODEL_UFS913) || defined (BOXMODEL_CUBEREVO) || defined (BOXMODEL_CUBEREVO_MINI) || defined (BOXMODEL_CUBEREVO_MINI2) || defined (BOXMODEL_CUBEREVO_2000HD) || defined (BOXMODEL_CUBEREVO_3000HD) || defined (BOXMODEL_IPBOX9900) || defined (BOXMODEL_IPBOX99) + char vol_chr[64] = ""; + snprintf(vol_chr, sizeof(vol_chr)-1, "Volume: %d%%", (int)vol); + ShowText(vol_chr); +#endif + oldpp = pp; + } +#else ShowIcon(FP_ICON_FRAME, true); - int pp = (vol * 8 + 50) / 100; + int pp = (int) round((double) vol * (double) 8 / (double) 100); if(pp > 8) pp = 8; if(force_update || oldpp != pp) { @@ -453,11 +835,15 @@ printf("CVFD::showVolume: %d, bar %d\n", (int) vol, pp); } oldpp = pp; } +#endif } } void CVFD::showPercentOver(const unsigned char perc, const bool /*perform_update*/, const MODES origin) { +#if HAVE_DUCKBOX_HARDWARE + return; +#else static int ppold = 0; if(!has_lcd) return; @@ -477,7 +863,7 @@ void CVFD::showPercentOver(const unsigned char perc, const bool /*perform_update if(perc == 255) pp = 0; else - pp = (perc * 8 + 50) / 100; + pp = (int) round((double) perc * (double) 8 / (double) 100); if(pp > 8) pp = 8; if(pp != ppold) { @@ -495,6 +881,7 @@ void CVFD::showPercentOver(const unsigned char perc, const bool /*perform_update ppold = pp; } } +#endif } void CVFD::showMenuText(const int /*position*/, const char * ptext, const int /*highlight*/, const bool /*utf_encoded*/) @@ -533,18 +920,38 @@ void CVFD::showAudioPlayMode(AUDIOMODES m) case AUDIO_MODE_PLAY: ShowIcon(FP_ICON_PLAY, true); ShowIcon(FP_ICON_PAUSE, false); +#ifdef HAVE_DUCKBOX_HARDWARE + ShowIcon(FP_ICON_FF, false); + ShowIcon(FP_ICON_FR, false); +#endif break; case AUDIO_MODE_STOP: ShowIcon(FP_ICON_PLAY, false); ShowIcon(FP_ICON_PAUSE, false); +#ifdef HAVE_DUCKBOX_HARDWARE + ShowIcon(FP_ICON_FF, false); + ShowIcon(FP_ICON_FR, false); +#endif break; case AUDIO_MODE_PAUSE: ShowIcon(FP_ICON_PLAY, false); ShowIcon(FP_ICON_PAUSE, true); +#ifdef HAVE_DUCKBOX_HARDWARE + ShowIcon(FP_ICON_FF, false); + ShowIcon(FP_ICON_FR, false); +#endif break; case AUDIO_MODE_FF: +#ifdef HAVE_DUCKBOX_HARDWARE + ShowIcon(FP_ICON_FF, true); + ShowIcon(FP_ICON_FR, false); +#endif break; case AUDIO_MODE_REV: +#ifdef HAVE_DUCKBOX_HARDWARE + ShowIcon(FP_ICON_FF, false); + ShowIcon(FP_ICON_FR, true); +#endif break; } wake_up(); @@ -632,6 +1039,11 @@ void CVFD::setMode(const MODES m, const char * const title) ShowIcon(FP_ICON_COL1, true); ShowIcon(FP_ICON_COL2, true); #endif +#if ! HAVE_COOL_HARDWARE + ClearIcons(); +#endif + ShowIcon(FP_ICON_USB, false); + ShowIcon(FP_ICON_HDD, false); showclock = true; showTime(true); /* "showclock = true;" implies that "showTime();" does a "displayUpdate();" */ /* "showTime()" clears the whole lcd in MODE_STANDBY */ @@ -659,7 +1071,9 @@ void CVFD::setMode(const MODES m, const char * const title) #endif // VFD_UPDATE } wake_up(); +#if !HAVE_DUCKBOX_HARDWARE setled(); +#endif } void CVFD::setBrightness(int bright) @@ -673,8 +1087,13 @@ void CVFD::setBrightness(int bright) int CVFD::getBrightness() { //FIXME for old neutrino.conf +#if defined (BOXMODEL_OCTAGON1008) || defined (BOXMODEL_FORTIS_HDBOX) || defined (BOXMODEL_ATEVIO7500) + if(g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS] > 7) + g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS] = 7; +#else if(g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS] > 15) g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS] = 15; +#endif return g_settings.lcd_setting[SNeutrinoSettings::LCD_BRIGHTNESS]; } @@ -690,8 +1109,13 @@ void CVFD::setBrightnessStandby(int bright) int CVFD::getBrightnessStandby() { //FIXME for old neutrino.conf +#if defined (BOXMODEL_OCTAGON1008) || defined (BOXMODEL_FORTIS_HDBOX) || defined (BOXMODEL_ATEVIO7500) + if(g_settings.lcd_setting[SNeutrinoSettings::LCD_STANDBY_BRIGHTNESS] > 7) + g_settings.lcd_setting[SNeutrinoSettings::LCD_STANDBY_BRIGHTNESS] = 7; +#else if(g_settings.lcd_setting[SNeutrinoSettings::LCD_STANDBY_BRIGHTNESS] > 15) g_settings.lcd_setting[SNeutrinoSettings::LCD_STANDBY_BRIGHTNESS] = 15; +#endif return g_settings.lcd_setting[SNeutrinoSettings::LCD_STANDBY_BRIGHTNESS]; } @@ -706,8 +1130,13 @@ void CVFD::setBrightnessDeepStandby(int bright) int CVFD::getBrightnessDeepStandby() { //FIXME for old neutrino.conf +#if defined (BOXMODEL_OCTAGON1008) || defined (BOXMODEL_FORTIS_HDBOX) || defined (BOXMODEL_ATEVIO7500) + if(g_settings.lcd_setting[SNeutrinoSettings::LCD_DEEPSTANDBY_BRIGHTNESS] > 7) + g_settings.lcd_setting[SNeutrinoSettings::LCD_DEEPSTANDBY_BRIGHTNESS] = 7; +#else if(g_settings.lcd_setting[SNeutrinoSettings::LCD_DEEPSTANDBY_BRIGHTNESS] > 15) g_settings.lcd_setting[SNeutrinoSettings::LCD_DEEPSTANDBY_BRIGHTNESS] = 15; +#endif return g_settings.lcd_setting[SNeutrinoSettings::LCD_DEEPSTANDBY_BRIGHTNESS]; } @@ -765,39 +1194,122 @@ void CVFD::Unlock() void CVFD::Clear() { if(fd < 0) return; +#if !HAVE_DUCKBOX_HARDWARE int ret = ioctl(fd, IOC_FP_CLEAR_ALL, 0); if(ret < 0) perror("IOC_FP_SET_TEXT"); else - text.clear(); + text[0] = 0; +#else +#if defined (BOXMODEL_HS7810A) || defined (BOXMODEL_HS7119) || defined (BOXMODEL_HS7819) || defined (BOXMODEL_CUBEREVO_250HD) || defined (BOXMODEL_IPBOX55) + ShowText(" "); +#elif defined (BOXMODEL_OCTAGON1008) || defined (BOXMODEL_TF7700) + ShowText(" "); +#elif defined (BOXMODEL_FORTIS_HDBOX) || defined (BOXMODEL_ATEVIO7500) + ShowText(" "); +#elif defined (BOXMODEL_IPBOX9900) || defined (BOXMODEL_IPBOX99) + ShowText(" "); +#elif !defined (BOXMODEL_HS7110) + ShowText(" "); +#endif +#endif } void CVFD::ShowIcon(fp_icon icon, bool show) { +#if !HAVE_DUCKBOX_HARDWARE if(!has_lcd || fd < 0) return; //printf("CVFD::ShowIcon %s %x\n", show ? "show" : "hide", (int) icon); int ret = ioctl(fd, show ? IOC_FP_SET_ICON : IOC_FP_CLEAR_ICON, icon); if(ret < 0) perror(show ? "IOC_FP_SET_ICON" : "IOC_FP_CLEAR_ICON"); +#else +#if defined (BOXMODEL_ATEVIO7500) || defined (BOXMODEL_HS7110) || defined (BOXMODEL_HS7810A) || defined (BOXMODEL_HS7119) || defined (BOXMODEL_HS7819) + return; +#endif + if (icon == 0) + return; + + if (active_icon[icon & 0x0F] == show) + return; + else + active_icon[icon & 0x0F] = show; + + //printf("CVFD::ShowIcon %s %x\n", show ? "show" : "hide", (int) icon); + struct vfd_ioctl_data data; + memset(&data, 0, sizeof(struct vfd_ioctl_data)); + data.start = 0x00; + data.data[0] = icon; + data.data[4] = show; + data.length = 5; + write_to_vfd(VFDICONDISPLAYONOFF, &data); + return; +#endif } +#ifdef HAVE_DUCKBOX_HARDWARE +void CVFD::ClearIcons() +{ +#if defined (BOXMODEL_ATEVIO7500) || defined (BOXMODEL_HS7110) || defined (BOXMODEL_HS7810A) || defined (BOXMODEL_HS7119) || defined (BOXMODEL_HS7819) + return; +#endif + for (int id = 0x10; id < FP_ICON_MAX; id++) { +#if defined (BOXMODEL_OCTAGON1008) + if (id != FP_ICON_USB && id != FP_ICON_HDD) +#elif defined(BOXMODEL_FORTIS_HDBOX) || defined (BOXMODEL_TF7700) + if (id != FP_ICON_USB) +#else + if (id != 0x10 && id != 0x12) +#endif + ShowIcon((fp_icon)id, false); + } + return; +} + +void CVFD::ShowText(const char * str) +{ + memset(g_str, 0, sizeof(g_str)); + memcpy(g_str, str, sizeof(g_str)-1); + + int i = strlen(str); + if (i > 63) { + g_str[60] = '.'; + g_str[61] = '.'; + g_str[62] = '.'; + g_str[63] = '\0'; + i = 63; + } + ShowNormalText(g_str, false); +} +void CVFD::repaintIcons() +{ + char * model = g_info.hw_caps->boxname; + if(strstr(model, "ufs912") || strstr(model, "ufs913")) + { + bool tmp_icon[16] = {false}; + printf("VFD repaint icons boxmodel: %s\n", model); + for (int i = 0x10; i < FP_ICON_MAX; i++) + { + tmp_icon[i & 0x0F] = active_icon[i & 0x0F]; + active_icon[i & 0x0F] = false; + ShowIcon((fp_icon)i, tmp_icon[i & 0x0F]); + } + } +} +#else void CVFD::ShowText(const char * str) { if (fd < 0 || !support_text) return; char flags[2] = { FP_FLAG_ALIGN_LEFT, 0 }; - if (! str) { - printf("CVFD::ShowText: str is NULL!\n"); - return; - } - if (g_settings.lcd_scroll && ((int)strlen(str) > g_info.hw_caps->display_xres)) + if (g_settings.lcd_scroll) flags[0] |= FP_FLAG_SCROLL_ON | FP_FLAG_SCROLL_SIO | FP_FLAG_SCROLL_DELAY; std::string txt = std::string(flags) + str; txt = trim(txt); - printf("CVFD::ShowText: [0x%02x][%s]\n", flags[0], txt.c_str() + 1); + printf("CVFD::ShowText: [%s]\n", txt.c_str() + 1); size_t len = txt.length(); if (txt == text || len > 255) @@ -810,6 +1322,7 @@ void CVFD::ShowText(const char * str) perror("IOC_FP_SET_TEXT"); } } +#endif void CVFD::ShowNumber(int number) { diff --git a/src/driver/vfd.h b/src/driver/vfd.h index 84039020d..6e7d343d2 100644 --- a/src/driver/vfd.h +++ b/src/driver/vfd.h @@ -82,6 +82,7 @@ class CVFD MODES mode; std::string servicename; + char *scrollstr; int service_number; bool support_text; bool support_numbers; @@ -90,13 +91,17 @@ class CVFD bool muted; bool showclock; pthread_t thrTime; +#if HAVE_DUCKBOX_HARDWARE + pthread_t thread_start_loop; +#endif int last_toggle_state_power; bool clearClock; unsigned int timeout_cnt; - unsigned int switch_name_time_cnt; + unsigned int switch_name_time_cnt; int fd; int brightness; std::string text; + char g_str[64]; void count_down(); @@ -104,23 +109,29 @@ class CVFD static void* TimeThread(void*); void setlcdparameter(int dimm, int power); +#if !HAVE_DUCKBOX_HARDWARE void setled(int led1, int led2); +#endif public: ~CVFD(); bool has_lcd; bool has_led_segment; void setlcdparameter(void); +#if !HAVE_DUCKBOX_HARDWARE void setled(void); void setled(bool on_off); void setBacklight(bool on_off); +#else + void setBacklight(bool /*on_off*/) { }; +#endif static CVFD* getInstance(); void init(const char * fontfile, const char * fontname); void setMode(const MODES m, const char * const title = ""); void showServicename(const std::string & name, int number = -1); // UTF-8 - void setEPGTitle(const std::string) { return; }; + void setEPGTitle(const std::string) { return; } void showTime(bool force = false); /** blocks for duration seconds */ void showRCLock(int duration = 2); @@ -154,10 +165,18 @@ class CVFD void Unlock(); void Clear(); void ShowIcon(fp_icon icon, bool show); +#if HAVE_DUCKBOX_HARDWARE + void repaintIcons(); + void UpdateIcons(); + void ShowScrollText(char * str); + static void* ThreadScrollText(void * arg); + void ClearIcons(); +#endif void ShowText(const char *str); void ShowNumber(int number); void wake_up(); MODES getMode(void) { return mode; }; + std::string getServicename(void) { return servicename; } #ifdef LCD_UPDATE private: CFileList* m_fileList; diff --git a/src/gui/lua/luainstance.cpp b/src/gui/lua/luainstance.cpp index c031083ce..7f7485a9a 100644 --- a/src/gui/lua/luainstance.cpp +++ b/src/gui/lua/luainstance.cpp @@ -36,7 +36,12 @@ #include #include #include +#if HAVE_COOL_HARDWARE #include +#endif +#if USE_STB_HAL +#include +#endif #include "luainstance.h" #include "lua_cc_header.h" diff --git a/src/gui/movieplayer.cpp b/src/gui/movieplayer.cpp index 28f249fee..d56f65d9d 100644 --- a/src/gui/movieplayer.cpp +++ b/src/gui/movieplayer.cpp @@ -80,15 +80,27 @@ #include #include #include +#include +#include +#ifdef ENABLE_GRAPHLCD +#include +bool glcd_play = false; +#endif +#include +#include +#include +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE +#include +#endif + #include -#ifndef HAVE_COOL_HARDWARE -#define LCD_MODE CVFD::MODE_MOVIE -#else -#define LCD_MODE CVFD::MODE_MENU_UTF8 +#if 0 +#include #endif extern cVideo * videoDecoder; +extern cAudio * audioDecoder; extern CRemoteControl *g_RemoteControl; /* neutrino.cpp */ extern CVolume* g_volume; @@ -152,8 +164,19 @@ CMoviePlayerGui::~CMoviePlayerGui() instance_bg = NULL; } instance_mp = NULL; + filelist.clear(); } +#if !HAVE_COOL_HARDWARE +// used by libdvbsub/dvbsub.cpp +void getPlayerPts(int64_t *pts) +{ + cPlayback *playback = CMoviePlayerGui::getInstance().getPlayback(); + if (playback) + playback->GetPts((uint64_t &) *pts); +} +#endif + void CMoviePlayerGui::Init(void) { playing = false; @@ -179,8 +202,6 @@ void CMoviePlayerGui::Init(void) tsfilefilter.addFilter("wav"); tsfilefilter.addFilter("asf"); tsfilefilter.addFilter("aiff"); - tsfilefilter.addFilter("mp4"); - tsfilefilter.addFilter("mov"); #endif tsfilefilter.addFilter("mpg"); tsfilefilter.addFilter("mpeg"); @@ -188,15 +209,19 @@ void CMoviePlayerGui::Init(void) tsfilefilter.addFilter("mpv"); tsfilefilter.addFilter("vob"); tsfilefilter.addFilter("m2ts"); + tsfilefilter.addFilter("mp4"); + tsfilefilter.addFilter("mov"); tsfilefilter.addFilter("m3u"); tsfilefilter.addFilter("m3u8"); tsfilefilter.addFilter("pls"); + tsfilefilter.addFilter("iso"); +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE + tsfilefilter.addFilter("trp"); tsfilefilter.addFilter("vdr"); -#ifdef HAVE_SPARK_HARDWARE + tsfilefilter.addFilter("mp3"); tsfilefilter.addFilter("flv"); tsfilefilter.addFilter("wmv"); #endif - tsfilefilter.addFilter("iso"); if (g_settings.network_nfs_moviedir.empty()) Path_local = "/"; @@ -216,15 +241,14 @@ void CMoviePlayerGui::Init(void) speed = 1; timeshift = TSHIFT_MODE_OFF; numpida = 0; + numpids = 0; + numpidt = 0; showStartingHint = false; - min_x = 0; - max_x = 0; - min_y = 0; - max_y = 0; - ext_subs = false; iso_file = false; +#if 0 lock_subs = false; +#endif bgThread = 0; info_1 = ""; info_2 = ""; @@ -259,6 +283,9 @@ void CMoviePlayerGui::cutNeutrino() if (isUPNP) return; +#if 0 + CZapit::getInstance()->setMoviePlayer(true);// let CCamManager::SetMode know, the call is from MoviePlayer +#endif g_Zapit->lockPlayBack(); #ifdef HAVE_AZBOX_HARDWARE @@ -305,8 +332,8 @@ void CMoviePlayerGui::restoreNeutrino() if (isUPNP) return; - //g_Zapit->unlockPlayBack(); - CZapit::getInstance()->EnablePlayback(true); + g_Zapit->unlockPlayBack(); + //CZapit::getInstance()->EnablePlayback(true); printf("%s: restore mode %x\n", __func__, m_LastMode);fflush(stdout); #if 0 @@ -326,16 +353,35 @@ void CMoviePlayerGui::restoreNeutrino() printf("%s: restoring done.\n", __func__);fflush(stdout); } +static bool running = false; int CMoviePlayerGui::exec(CMenuTarget * parent, const std::string & actionKey) { printf("[movieplayer] actionKey=%s\n", actionKey.c_str()); + if (running) + return menu_return::RETURN_EXIT_ALL; + running = true; if (parent) parent->hide(); - puts("[movieplayer.cpp] executing " MOVIEPLAYER_START_SCRIPT "."); - if (my_system(MOVIEPLAYER_START_SCRIPT) != 0) - perror(MOVIEPLAYER_START_SCRIPT " failed"); +#if 0 + if (actionKey == "fileplayback" || actionKey == "tsmoviebrowser") + { + if(actionKey == "fileplayback") { + printf("[movieplayer] wakeup_hdd(%s) for %s\n", g_settings.network_nfs_moviedir.c_str(), actionKey.c_str()); + wakeup_hdd(g_settings.network_nfs_moviedir.c_str(),true); + } + else { + printf("[movieplayer] wakeup_hdd(%s) for %s\n", g_settings.network_nfs_recordingdir.c_str(), actionKey.c_str()); + wakeup_hdd(g_settings.network_nfs_recordingdir.c_str(),true); + } + } +#endif + if (!access(MOVIEPLAYER_START_SCRIPT, X_OK)) { + puts("[movieplayer.cpp] executing " MOVIEPLAYER_START_SCRIPT "."); + if (my_system(MOVIEPLAYER_START_SCRIPT) != 0) + perror(MOVIEPLAYER_START_SCRIPT " failed"); + } Cleanup(); ClearFlags(); @@ -349,13 +395,17 @@ int CMoviePlayerGui::exec(CMenuTarget * parent, const std::string & actionKey) if (actionKey == "tsmoviebrowser") { isMovieBrowser = true; moviebrowser->setMode(MB_SHOW_RECORDS); + wakeup_hdd(g_settings.network_nfs_recordingdir.c_str()); } +#if 0 else if (actionKey == "ytplayback") { isMovieBrowser = true; moviebrowser->setMode(MB_SHOW_YT); isYT = true; } +#endif else if (actionKey == "fileplayback") { + wakeup_hdd(g_settings.network_nfs_moviedir.c_str()); } else if (actionKey == "timeshift") { timeshift = TSHIFT_MODE_ON; @@ -371,6 +421,12 @@ int CMoviePlayerGui::exec(CMenuTarget * parent, const std::string & actionKey) isBookmark = true; } #endif + else if (actionKey == "netstream") { + isHTTP = true; + p_movie_info = NULL; + is_file_player = true; + PlayFile(); + } else if (actionKey == "upnp") { isUPNP = true; is_file_player = true; @@ -389,28 +445,40 @@ int CMoviePlayerGui::exec(CMenuTarget * parent, const std::string & actionKey) haveLuaInfoFunc = false; } else { + running = false; return menu_return::RETURN_REPAINT; } + std::string oldservicename = CVFD::getInstance()->getServicename(); while(!isHTTP && !isUPNP && SelectFile()) { + CVFD::getInstance()->setMode(CVFD::MODE_TVRADIO); + CVFD::getInstance()->showServicename(file_name.c_str()); if (timeshift != TSHIFT_MODE_OFF) { + CVFD::getInstance()->ShowIcon(FP_ICON_TIMESHIFT, true); PlayFile(); + CVFD::getInstance()->ShowIcon(FP_ICON_TIMESHIFT, false); break; } do { + is_file_player = true; PlayFile(); } while (repeat_mode || filelist_it != filelist.end()); } + CVFD::getInstance()->showServicename(oldservicename.c_str()); bookmarkmanager->flush(); - puts("[movieplayer.cpp] executing " MOVIEPLAYER_END_SCRIPT "."); - if (my_system(MOVIEPLAYER_END_SCRIPT) != 0) - perror(MOVIEPLAYER_END_SCRIPT " failed"); + if (!access(MOVIEPLAYER_END_SCRIPT, X_OK)) { + puts("[movieplayer.cpp] executing " MOVIEPLAYER_END_SCRIPT "."); + if (my_system(MOVIEPLAYER_END_SCRIPT) != 0) + perror(MOVIEPLAYER_END_SCRIPT " failed"); + } CVFD::getInstance()->setMode(CVFD::MODE_TVRADIO); + running = false; + if (timeshift != TSHIFT_MODE_OFF){ timeshift = TSHIFT_MODE_OFF; return menu_return::RETURN_EXIT_ALL; @@ -420,6 +488,7 @@ int CMoviePlayerGui::exec(CMenuTarget * parent, const std::string & actionKey) void CMoviePlayerGui::updateLcd() { +#if !HAVE_SPARK_HARDWARE char tmp[20]; std::string lcd; std::string name; @@ -431,15 +500,49 @@ void CMoviePlayerGui::updateLcd() switch (playstate) { case CMoviePlayerGui::PAUSE: +#if !defined(BOXMODEL_UFS910) \ + && !defined(BOXMODEL_UFS912) \ + && !defined(BOXMODEL_UFS913) \ + && !defined(BOXMODEL_UFS922) \ + && !defined(BOXMODEL_FORTIS_HDBOX) \ + && !defined(BOXMODEL_OCTAGON1008) \ + && !defined(BOXMODEL_HS7110) \ + && !defined(BOXMODEL_HS7810A) \ + && !defined(BOXMODEL_HS7119) \ + && !defined(BOXMODEL_HS7819) \ + && !defined(BOXMODEL_IPBOX9900) \ + && !defined(BOXMODEL_IPBOX99) \ + && !defined(BOXMODEL_IPBOX55) + lcd = "|| "; +#else + lcd = ""; +#endif if (speed < 0) { sprintf(tmp, "%dx<| ", abs(speed)); lcd = tmp; } else if (speed > 0) { sprintf(tmp, "%dx|> ", abs(speed)); lcd = tmp; +#if !defined(BOXMODEL_UFS910) \ + && !defined(BOXMODEL_UFS912) \ + && !defined(BOXMODEL_UFS913) \ + && !defined(BOXMODEL_UFS922) \ + && !defined(BOXMODEL_OCTAGON1008) \ + && !defined(BOXMODEL_HS7110) \ + && !defined(BOXMODEL_HS7810A) \ + && !defined(BOXMODEL_HS7119) \ + && !defined(BOXMODEL_HS7819) \ + && !defined(BOXMODEL_IPBOX9900) \ + && !defined(BOXMODEL_IPBOX99) \ + && !defined(BOXMODEL_IPBOX55) } else lcd = "|| "; +#else + } else + lcd = ""; +#endif break; +#if !defined(BOXMODEL_OCTAGON1008) case CMoviePlayerGui::REW: sprintf(tmp, "%dx<< ", abs(speed)); lcd = tmp; @@ -448,15 +551,32 @@ void CMoviePlayerGui::updateLcd() sprintf(tmp, "%dx>> ", abs(speed)); lcd = tmp; break; +#endif case CMoviePlayerGui::PLAY: +#if !defined(BOXMODEL_UFS910) \ + && !defined(BOXMODEL_UFS912) \ + && !defined(BOXMODEL_UFS913) \ + && !defined(BOXMODEL_UFS922) \ + && !defined(BOXMODEL_FORTIS_HDBOX) \ + && !defined(BOXMODEL_OCTAGON1008) \ + && !defined(BOXMODEL_HS7110) \ + && !defined(BOXMODEL_HS7810A) \ + && !defined(BOXMODEL_HS7119) \ + && !defined(BOXMODEL_HS7819) \ + && !defined(BOXMODEL_CUBEREVO_MINI2) \ + && !defined(BOXMODEL_IPBOX9900) \ + && !defined(BOXMODEL_IPBOX99) \ + && !defined(BOXMODEL_IPBOX55) lcd = "> "; +#endif break; default: break; } lcd += name; - CVFD::getInstance()->setMode(LCD_MODE); + CVFD::getInstance()->setMode(CVFD::MODE_MENU_UTF8); CVFD::getInstance()->showMenuText(0, lcd.c_str(), -1, true); +#endif } void CMoviePlayerGui::fillPids() @@ -467,6 +587,9 @@ void CMoviePlayerGui::fillPids() vpid = p_movie_info->VideoPid; vtype = p_movie_info->VideoType; numpida = 0; currentapid = 0; + numpids = 0; + numpidt = 0; + currentttxsub = ""; /* FIXME: better way to detect TS recording */ if (!p_movie_info->audioPids.empty()) { currentapid = p_movie_info->audioPids[0].AudioPid; @@ -475,27 +598,44 @@ void CMoviePlayerGui::fillPids() is_file_player = true; return; } - for (int i = 0; i < (int)p_movie_info->audioPids.size(); i++) { - apids[i] = p_movie_info->audioPids[i].AudioPid; - ac3flags[i] = p_movie_info->audioPids[i].atype; - numpida++; - if (p_movie_info->audioPids[i].selected) { - currentapid = p_movie_info->audioPids[i].AudioPid; - currentac3 = p_movie_info->audioPids[i].atype; + for (unsigned int i = 0; i < p_movie_info->audioPids.size(); i++) { + unsigned int j; + for (j = 0; j < numpida && p_movie_info->audioPids[i].AudioPid != apids[j]; j++); + if (j == numpida) { + apids[i] = p_movie_info->audioPids[i].AudioPid; + ac3flags[i] = p_movie_info->audioPids[i].atype; + numpida++; + if (p_movie_info->audioPids[i].selected) { + currentapid = p_movie_info->audioPids[i].AudioPid; + currentac3 = p_movie_info->audioPids[i].atype; + } + if (numpida == REC_MAX_APIDS) + break; } } } void CMoviePlayerGui::Cleanup() { - for (int i = 0; i < numpida; i++) { + /*clear audiopids */ + for (unsigned int i = 0; i < REC_MAX_APIDS; i++) { apids[i] = 0; ac3flags[i] = 0; language[i].clear(); } numpida = 0; currentapid = 0; - currentspid = -1; - numsubs = 0; + // clear subtitlepids + for (unsigned int i = 0; i < REC_MAX_SPIDS; i++) { + spids[i] = 0; + slanguage[i].clear(); + } + numpids = 0; + // clear teletextpids + for (unsigned int i = 0; i < REC_MAX_TPIDS; i++) { + tpids[i] = 0; + tlanguage[i].clear(); + } + numpidt = 0; currentttxsub = ""; vpid = 0; vtype = 0; @@ -569,8 +709,8 @@ bool CMoviePlayerGui::prepareFile(CFile *file) bool ret = true; numpida = 0; currentapid = 0; - currentspid = -1; - numsubs = 0; +// currentspid = -1; +// numsubs = 0; autoshot_done = 0; if (file->Url.empty()) file_name = file->Name; @@ -587,10 +727,12 @@ bool CMoviePlayerGui::prepareFile(CFile *file) printf("CMoviePlayerGui::prepareFile: file %s start %d\n", file_name.c_str(), startposition); } } +#if 0 if (isYT) { file_name = file->Url; is_file_player = true; } +#endif fillPids(); } if (file->getType() == CFile::FILE_ISO) @@ -621,8 +763,9 @@ bool CMoviePlayerGui::SelectFile() Path_local = g_settings.network_nfs_moviedir; printf("CMoviePlayerGui::SelectFile: isBookmark %d timeshift %d isMovieBrowser %d\n", isBookmark, timeshift, isMovieBrowser); +#if 0 wakeup_hdd(g_settings.network_nfs_recordingdir.c_str()); - +#endif if (timeshift != TSHIFT_MODE_OFF) { t_channel_id live_channel_id = CZapit::getInstance()->GetCurrentChannelID(); p_movie_info = CRecordManager::getInstance()->GetMovieInfo(live_channel_id); @@ -741,7 +884,9 @@ bool CMoviePlayerGui::StartWebtv(void) last_read = position = duration = 0; cutNeutrino(); +#if 0 clearSubtitle(); +#endif playback->Open(is_file_player ? PLAYMODE_FILE : PLAYMODE_TS); @@ -805,7 +950,9 @@ void* CMoviePlayerGui::bgPlayThread(void *arg) bgmutex.unlock(); if (res == 0) break; +#if 0 mp->showSubtitle(0); +#endif } printf("%s: play end...\n", __func__);fflush(stdout); mp->PlayFileEnd(); @@ -999,9 +1146,24 @@ bool CMoviePlayerGui::getLiveUrl(const std::string &url, const std::string &scri } std::string _script = script; +#if 0 if (_script.find("/") == std::string::npos) - _script = g_settings.livestreamScriptPath + "/" + _script; - + { + std::string _s = g_settings.livestreamScriptPath + "/" + _script; + printf("[%s:%s:%d] script: %s\n", __file__, __func__, __LINE__, _s.c_str()); + if (!file_exists(_s.c_str())) + { + _s = std::string(WEBTVDIR_VAR) + "/" + _script; + printf("[%s:%s:%d] script: %s\n", __file__, __func__, __LINE__, _s.c_str()); + } + if (!file_exists(_s.c_str())) + { + _s = std::string(WEBTVDIR) + "/" + _script; + printf("[%s:%s:%d] script: %s\n", __file__, __func__, __LINE__, _s.c_str()); + } + _script = _s; + } +#endif size_t pos = _script.find(".lua"); if (!file_exists(_script.c_str()) || (pos == std::string::npos) || (_script.length()-pos != 4)) { printf(">>>>> [%s:%s:%d] script error\n", __file__, __func__, __LINE__); @@ -1101,6 +1263,10 @@ bool CMoviePlayerGui::PlayBackgroundStart(const std::string &file, const std::st instance_bg->movie_info.channelId = chan; instance_bg->p_movie_info = &movie_info; + numpida = 0; currentapid = 0; + numpids = 0; + numpidt = 0; currentttxsub = ""; + stopPlayBack(); webtv_started = true; if (pthread_create (&bgThread, 0, CMoviePlayerGui::bgPlayThread, instance_bg)) { @@ -1113,10 +1279,20 @@ bool CMoviePlayerGui::PlayBackgroundStart(const std::string &file, const std::st return true; } +bool MoviePlayerZapto(const std::string &file, const std::string &name, t_channel_id chan) +{ + return CMoviePlayerGui::getInstance().PlayBackgroundStart(file, name, chan); +} + +extern void MoviePlayerStop(void) +{ + CMoviePlayerGui::getInstance().stopPlayBack(); +} + void CMoviePlayerGui::stopPlayBack(void) { printf("%s: stopping...\n", __func__); - //playback->RequestAbort(); + playback->RequestAbort(); repeat_mode = REPEAT_OFF; if (bgThread) { @@ -1180,7 +1356,10 @@ bool CMoviePlayerGui::PlayFileStart(void) if (isWebTV) videoDecoder->setBlank(true); +#if 0 clearSubtitle(); +#endif + playback->SetTeletextPid(-1); printf("IS FILE PLAYER: %s\n", is_file_player ? "true": "false" ); playback->Open(is_file_player ? PLAYMODE_FILE : PLAYMODE_TS); @@ -1195,9 +1374,30 @@ bool CMoviePlayerGui::PlayFileStart(void) duration = p_movie_info->length * 60 * 1000; int percent = CZapit::getInstance()->GetPidVolume(p_movie_info->channelId, currentapid, currentac3 == 1); CZapit::getInstance()->SetVolumePercent(percent); +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE + CScreenSetup cSS; + cSS.showBorder(p_movie_info->epgId); +#endif + } else { +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE + CScreenSetup cSS; + cSS.showBorder(0); +#endif } file_prozent = 0; +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE + old3dmode = frameBuffer->get3DMode(); +#endif +#ifdef ENABLE_GRAPHLCD + nGLCD::MirrorOSD(false); + if (p_movie_info) + nGLCD::lockChannel(p_movie_info->channelName, p_movie_info->epgTitle); + else { + glcd_play = true; + nGLCD::lockChannel(g_Locale->getText(LOCALE_MOVIEPLAYER_HEAD), file_name.c_str(), file_prozent); + } +#endif pthread_t thrStartHint = 0; if (is_file_player) { showStartingHint = true; @@ -1215,10 +1415,36 @@ bool CMoviePlayerGui::PlayFileStart(void) repeat_mode = REPEAT_OFF; return false; } else { + numpida = REC_MAX_APIDS; + playback->FindAllPids(apids, ac3flags, &numpida, language); + if (p_movie_info) + for (unsigned int i = 0; i < numpida; i++) { + unsigned int j, asize = p_movie_info->audioPids.size(); + for (j = 0; j < asize && p_movie_info->audioPids[j].AudioPid != apids[i]; j++); + if (j == asize) { + AUDIO_PIDS pids; + pids.AudioPid = apids[i]; + pids.selected = 0; + pids.atype = ac3flags[i]; + pids.AudioPidName = language[i]; + p_movie_info->audioPids.push_back(pids); + } + } + else + for (unsigned int i = 0; i < numpida; i++) + if (apids[i] == playback->GetAPid()) { + CZapit::getInstance()->SetVolumePercent((ac3flags[i] == 1) ? g_settings.audio_volume_percent_ac3 : g_settings.audio_volume_percent_pcm); + break; + } repeat_mode = (repeat_mode_enum) g_settings.movieplayer_repeat_on; playstate = CMoviePlayerGui::PLAY; CVFD::getInstance()->ShowIcon(FP_ICON_PLAY, true); - if(timeshift != TSHIFT_MODE_OFF) { +#if HAVE_DUCKBOX_HARDWARE || HAVE_SPARK_HARDWARE + CVFD::getInstance()->ShowIcon(FP_ICON_FR, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FF, false); + CVFD::getInstance()->ShowIcon(FP_ICON_PAUSE, false); +#endif + if (timeshift != TSHIFT_MODE_OFF) { startposition = -1; int i; int towait = (timeshift == TSHIFT_MODE_ON) ? TIMESHIFT_SECONDS+1 : TIMESHIFT_SECONDS; @@ -1243,7 +1469,15 @@ bool CMoviePlayerGui::PlayFileStart(void) startposition = duration; } else { if (g_settings.timeshift_pause) + { playstate = CMoviePlayerGui::PAUSE; +#if HAVE_DUCKBOX_HARDWARE || HAVE_SPARK_HARDWARE + CVFD::getInstance()->ShowIcon(FP_ICON_PLAY, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FR, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FF, false); + CVFD::getInstance()->ShowIcon(FP_ICON_PAUSE, true); +#endif + } if (timeshift == TSHIFT_MODE_ON) startposition = 0; else @@ -1279,13 +1513,14 @@ bool CMoviePlayerGui::PlayFileStart(void) bool CMoviePlayerGui::SetPosition(int pos, bool absolute) { - clearSubtitle(); + StopSubtitles(true); bool res = playback->SetPosition(pos, absolute); if(is_file_player && res && speed == 0 && playstate == CMoviePlayerGui::PAUSE){ playstate = CMoviePlayerGui::PLAY; speed = 1; playback->SetSpeed(speed); } + StartSubtitles(true); return res; } @@ -1342,15 +1577,33 @@ void CMoviePlayerGui::PlayFileLoop(void) { bool first_start = true; bool update_lcd = true; +#if 0 + neutrino_msg_t lastmsg = 0; +#endif + int ss,mm,hh; +#if HAVE_COOL_HARDWARE int eof = 0; - int lastpos = 0; int eof2 = 0; int position_tmp = 0; +#endif bool at_eof = !(playstate >= CMoviePlayerGui::PLAY);; keyPressed = CMoviePlayerGui::PLUGIN_PLAYSTATE_NORMAL; +#if 0 //bisectional jumps + int bisection_jump = g_settings.movieplayer_bisection_jump * 60; + int bisection_loop = -1; + int bisection_loop_max = 5; +#endif while (playstate >= CMoviePlayerGui::PLAY) { +#ifdef ENABLE_GRAPHLCD + if (p_movie_info) + nGLCD::lockChannel(p_movie_info->channelName, p_movie_info->epgTitle, duration ? (100 * position / duration) : 0); + else { + glcd_play = true; + nGLCD::lockChannel(g_Locale->getText(LOCALE_MOVIEPLAYER_HEAD), file_name.c_str(), file_prozent); + } +#endif if (update_lcd) { update_lcd = false; updateLcd(); @@ -1364,13 +1617,32 @@ void CMoviePlayerGui::PlayFileLoop(void) neutrino_msg_data_t data; g_RCInput->getMsg(&msg, &data, 10); // 1 secs.. +#if 0 //bisectional jumps + if (bisection_loop > -1) + bisection_loop++; + if (bisection_loop > bisection_loop_max) + bisection_loop = -1; +#endif if ((playstate >= CMoviePlayerGui::PLAY) && (timeshift != TSHIFT_MODE_OFF || (playstate != CMoviePlayerGui::PAUSE))) { if (playback->GetPosition(position, duration)) { FileTimeOSD->update(position, duration); if (duration > 100) file_prozent = (unsigned char) (position / (duration / 100)); +#if HAVE_TRIPLEDRAGON + CVFD::getInstance()->showPercentOver(file_prozent, true, CVFD::MODE_MOVIE); +#else CVFD::getInstance()->showPercentOver(file_prozent); +#endif +#if HAVE_DUCKBOX_HARDWARE + ss = position/1000; + hh = ss/3600; + ss -= hh * 3600; + mm = ss/60; + ss -= mm * 60; + std::string Value = to_string(hh/10) + to_string(hh%10) + ":" + to_string(mm/10) + to_string(mm%10) + ":" + to_string(ss/10) + to_string(ss%10); + CVFD::getInstance()->ShowText(Value.c_str()); +#endif playback->GetSpeed(speed); /* at BOF lib set speed 1, check it */ @@ -1379,11 +1651,11 @@ void CMoviePlayerGui::PlayFileLoop(void) update_lcd = true; } #ifdef DEBUG - if (msg < CRCInput::RC_Events || eof > 0 || position - lastpos >= 10000) { - lastpos = position; - printf("CMoviePlayerGui::%s: spd %d pos %d/%d (%d, %d%%)\n", __func__, speed, position, duration, duration-position, file_prozent); - } + printf("CMoviePlayerGui::%s: spd %d pos %d/%d (%d, %d%%)\n", __func__, speed, position, duration, duration-position, file_prozent); #endif + } else +#if HAVE_COOL_HARDWARE + { /* in case ffmpeg report incorrect values */ if(file_prozent > 89 && (playstate == CMoviePlayerGui::PLAY) && (speed == 1)){ if(position_tmp != position){ @@ -1411,13 +1683,23 @@ void CMoviePlayerGui::PlayFileLoop(void) else eof = 0; } +#else + { + if (filelist_it == filelist.end() - 1 || filelist_it == filelist.end()) + g_RCInput->postMsg((neutrino_msg_t) g_settings.mpkey_stop, 0); + else + g_RCInput->postMsg((neutrino_msg_t) CRCInput::RC_right, 0); + } +#endif handleMovieBrowser(0, position); if (playstate == CMoviePlayerGui::STOPPED) at_eof = true; FileTimeOSD->update(position, duration); } +#if 0 showSubtitle(0); +#endif if (playstate == CMoviePlayerGui::PAUSE && (msg == CRCInput::RC_timeout || msg == NeutrinoMessages::EVT_TIMER)) { @@ -1435,8 +1717,10 @@ void CMoviePlayerGui::PlayFileLoop(void) { videoDecoder->setBlank(false); screensaver(false); - //ignore first keypress stop - just quit the screensaver and call infoviewer - if (msg == CRCInput::RC_stop) { +#if 0 //ignore first keypress stop - just quit the screensaver and call infoviewer + if (msg <= CRCInput::RC_MaxRC) { +#endif + if (msg <= CRCInput::RC_stop) { g_RCInput->clearRCMsg(); callInfoViewer(); continue; @@ -1447,10 +1731,37 @@ void CMoviePlayerGui::PlayFileLoop(void) if (msg == (neutrino_msg_t) g_settings.mpkey_plugin) { g_Plugins->startPlugin_by_name(g_settings.movieplayer_plugin.c_str ()); - } else if (msg == (neutrino_msg_t) g_settings.mpkey_stop) { +#if 0 + } else if ((msg == (neutrino_msg_t) g_settings.mpkey_stop) || msg == CRCInput::RC_home) { +#endif } else if (msg == (neutrino_msg_t) g_settings.mpkey_stop) { playstate = CMoviePlayerGui::STOPPED; keyPressed = CMoviePlayerGui::PLUGIN_PLAYSTATE_STOP; ClearQueue(); + } else if ((!filelist.empty() && msg == (neutrino_msg_t) CRCInput::RC_ok)) { + disableOsdElements(MUTE); + CFileBrowser *playlist = new CFileBrowser(); + CFile *pfile = NULL; + pfile = &(*filelist_it); + int selected = std::distance( filelist.begin(), filelist_it ); + filelist_it = filelist.end(); + if (playlist->playlist_manager(filelist, selected)) + { + playstate = CMoviePlayerGui::STOPPED; + CFile *sfile = NULL; + for (filelist_it = filelist.begin(); filelist_it != filelist.end(); ++filelist_it) + { + pfile = &(*filelist_it); + sfile = playlist->getSelectedFile(); + if ( (sfile->getFileName() == pfile->getFileName()) && (sfile->getPath() == pfile->getPath())) + break; + } + } + else { + if (!filelist.empty()) + filelist_it = filelist.begin() + selected; + } + delete playlist; + enableOsdElements(MUTE); } else if (msg == CRCInput::RC_left || msg == CRCInput::RC_right) { bool reset_vzap_it = true; switch (g_settings.mode_left_right_key_tv) @@ -1487,6 +1798,19 @@ void CMoviePlayerGui::PlayFileLoop(void) repeat_mode = REPEAT_OFF; g_settings.movieplayer_repeat_on = repeat_mode; callInfoViewer(); +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE + } else if (msg == (neutrino_msg_t) g_settings.mpkey_next3dmode) { + frameBuffer->set3DMode((CFrameBuffer::Mode3D)(((frameBuffer->get3DMode()) + 1) % CFrameBuffer::Mode3D_SIZE)); +#endif + } else if (msg == (neutrino_msg_t) g_settings.key_next43mode) { + g_videoSettings->next43Mode(); + } else if (msg == (neutrino_msg_t) g_settings.key_switchformat) { + g_videoSettings->SwitchFormat(); + } else if (msg == (neutrino_msg_t) CRCInput::RC_home) { + playstate = CMoviePlayerGui::STOPPED; + playback->RequestAbort(); + filelist.clear(); + repeat_mode = REPEAT_OFF; } else if (msg == (neutrino_msg_t) g_settings.mpkey_play) { if (time_forced) { time_forced = false; @@ -1495,6 +1819,12 @@ void CMoviePlayerGui::PlayFileLoop(void) FileTimeOSD->setMpTimeForced(false); if (playstate > CMoviePlayerGui::PLAY) { playstate = CMoviePlayerGui::PLAY; +#if HAVE_DUCKBOX_HARDWARE || HAVE_SPARK_HARDWARE + CVFD::getInstance()->ShowIcon(FP_ICON_PLAY, true); + CVFD::getInstance()->ShowIcon(FP_ICON_PAUSE, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FR, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FF, false); +#endif speed = 1; playback->SetSpeed(speed); updateLcd(); @@ -1534,31 +1864,48 @@ void CMoviePlayerGui::PlayFileLoop(void) if (playstate == CMoviePlayerGui::PAUSE) { playstate = CMoviePlayerGui::PLAY; //CVFD::getInstance()->ShowIcon(VFD_ICON_PAUSE, false); +#if HAVE_DUCKBOX_HARDWARE || HAVE_SPARK_HARDWARE + CVFD::getInstance()->ShowIcon(FP_ICON_PLAY, true); + CVFD::getInstance()->ShowIcon(FP_ICON_PAUSE, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FR, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FF, false); +#endif speed = 1; playback->SetSpeed(speed); } else { playstate = CMoviePlayerGui::PAUSE; //CVFD::getInstance()->ShowIcon(VFD_ICON_PAUSE, true); +#if HAVE_DUCKBOX_HARDWARE || HAVE_SPARK_HARDWARE + CVFD::getInstance()->ShowIcon(FP_ICON_PLAY, false); + CVFD::getInstance()->ShowIcon(FP_ICON_PAUSE, true); + CVFD::getInstance()->ShowIcon(FP_ICON_FR, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FF, false); +#endif speed = 0; playback->SetSpeed(speed); } updateLcd(); + if (timeshift == TSHIFT_MODE_OFF) callInfoViewer(); } else if (msg == (neutrino_msg_t) g_settings.mpkey_bookmark) { - if (is_file_player) - selectChapter(); - else - handleMovieBrowser((neutrino_msg_t) g_settings.mpkey_bookmark, position); + handleMovieBrowser((neutrino_msg_t) g_settings.mpkey_bookmark, position); update_lcd = true; +#if 0 clearSubtitle(); +#endif } else if (msg == (neutrino_msg_t) g_settings.mpkey_audio) { selectAudioPid(); update_lcd = true; +#if 0 clearSubtitle(); +#endif } else if (msg == (neutrino_msg_t) g_settings.mpkey_subtitle) { + selectAudioPid(); +#if 0 selectSubtitle(); clearSubtitle(); +#endif update_lcd = true; } else if (msg == (neutrino_msg_t) g_settings.mpkey_time) { FileTimeOSD->switchMode(position, duration); @@ -1573,9 +1920,21 @@ void CMoviePlayerGui::PlayFileLoop(void) int newspeed = 0; bool setSpeed = false; if (msg == (neutrino_msg_t) g_settings.mpkey_rewind) { - newspeed = (speed >= 0) ? -1 : speed - 1; + newspeed = (speed >= 0) ? -1 : (speed - 1); +#if HAVE_DUCKBOX_HARDWARE || HAVE_SPARK_HARDWARE + CVFD::getInstance()->ShowIcon(FP_ICON_PLAY, true); + CVFD::getInstance()->ShowIcon(FP_ICON_PAUSE, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FR, true); + CVFD::getInstance()->ShowIcon(FP_ICON_FF, false); +#endif } else { - newspeed = (speed <= 0) ? 2 : speed + 1; + newspeed = (speed <= 0) ? 2 : (speed + 1); +#if HAVE_DUCKBOX_HARDWARE || HAVE_SPARK_HARDWARE + CVFD::getInstance()->ShowIcon(FP_ICON_PLAY, true); + CVFD::getInstance()->ShowIcon(FP_ICON_PAUSE, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FR, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FF, true); +#endif } /* if paused, playback->SetSpeed() start slow motion */ if (playback->SetSpeed(newspeed)) { @@ -1594,15 +1953,15 @@ void CMoviePlayerGui::PlayFileLoop(void) FileTimeOSD->setMpTimeForced(true); if (timeshift == TSHIFT_MODE_OFF) callInfoViewer(); - } else if (msg == CRCInput::RC_1) { // Jump Backwards 1 minute + } else if (msg == CRCInput::RC_1) { // Jump Backward 1 minute SetPosition(-60 * 1000); } else if (msg == CRCInput::RC_3) { // Jump Forward 1 minute SetPosition(60 * 1000); - } else if (msg == CRCInput::RC_4) { // Jump Backwards 5 minutes + } else if (msg == CRCInput::RC_4) { // Jump Backward 5 minutes SetPosition(-5 * 60 * 1000); } else if (msg == CRCInput::RC_6) { // Jump Forward 5 minutes SetPosition(5 * 60 * 1000); - } else if (msg == CRCInput::RC_7) { // Jump Backwards 10 minutes + } else if (msg == CRCInput::RC_7) { // Jump Backward 10 minutes SetPosition(-10 * 60 * 1000); } else if (msg == CRCInput::RC_9) { // Jump Forward 10 minutes SetPosition(10 * 60 * 1000); @@ -1612,19 +1971,39 @@ void CMoviePlayerGui::PlayFileLoop(void) SetPosition(duration/2, true); } else if (msg == CRCInput::RC_8) { // goto end SetPosition(duration - 60 * 1000, true); +#if 0 } else if (msg == CRCInput::RC_page_up) { SetPosition(10 * 1000); } else if (msg == CRCInput::RC_page_down) { SetPosition(-10 * 1000); + + //- bisectional jumps + } else if (msg == CRCInput::RC_page_up || msg == CRCInput::RC_page_down) { + int direction = (msg == CRCInput::RC_page_up) ? 1 : -1; + int jump = 10; + + if (g_settings.movieplayer_bisection_jump) + { + if ((lastmsg == CRCInput::RC_page_up || lastmsg == CRCInput::RC_page_down) && (bisection_loop > -1 && bisection_loop <= bisection_loop_max)) + bisection_jump /= 2; + else + bisection_jump = g_settings.movieplayer_bisection_jump * 60; + + bisection_loop = 0; + jump = bisection_jump; + } + + SetPosition(direction*jump * 1000); +#endif } else if (msg == CRCInput::RC_0) { // cancel bookmark jump handleMovieBrowser(CRCInput::RC_0, position); } else if (msg == (neutrino_msg_t) g_settings.mpkey_goto) { bool cancel = true; playback->GetPosition(position, duration); - int ss = position/1000; - int hh = ss/3600; + ss = position/1000; + hh = ss/3600; ss -= hh * 3600; - int mm = ss/60; + mm = ss/60; ss -= mm * 60; std::string Value = to_string(hh/10) + to_string(hh%10) + ":" + to_string(mm/10) + to_string(mm%10) + ":" + to_string(ss/10) + to_string(ss%10); CTimeInput jumpTime (LOCALE_MPKEY_GOTO, &Value, NONEXISTANT_LOCALE, NONEXISTANT_LOCALE, NULL, &cancel); @@ -1663,21 +2042,54 @@ void CMoviePlayerGui::PlayFileLoop(void) else callInfoViewer(); update_lcd = true; +#if 0 clearSubtitle(); +#endif +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE + } else if (msg == CRCInput::RC_text) { + int pid = playback->GetFirstTeletextPid(); + if (pid > -1) { + playback->SetTeletextPid(0); + StopSubtitles(true); + if (g_settings.cacheTXT) + tuxtxt_stop(); + playback->SetTeletextPid(pid); + tuxtx_stop_subtitle(); + tuxtx_main(pid, 0, 2, true); + tuxtxt_stop(); + playback->SetTeletextPid(0); + if (currentttxsub != "") { + CSubtitleChangeExec SubtitleChanger(playback); + SubtitleChanger.exec(NULL, currentttxsub); + } + StartSubtitles(true); + frameBuffer->paintBackground(); + //purge input queue + do + g_RCInput->getMsg(&msg, &data, 1); + while (msg != CRCInput::RC_timeout); + } else if (g_RemoteControl->current_PIDs.PIDs.vtxtpid) { + StopSubtitles(true); + // The playback stream doesn't come with teletext. + tuxtx_main(g_RemoteControl->current_PIDs.PIDs.vtxtpid, 0, 2); + frameBuffer->paintBackground(); + StartSubtitles(true); + //purge input queue + do + g_RCInput->getMsg(&msg, &data, 1); + while (msg != CRCInput::RC_timeout); + } +#endif } else if (timeshift != TSHIFT_MODE_OFF && (msg == CRCInput::RC_text || msg == CRCInput::RC_epg || msg == NeutrinoMessages::SHOW_EPG)) { bool restore = FileTimeOSD->IsVisible(); FileTimeOSD->kill(); - if (msg == CRCInput::RC_epg ) + StopSubtitles(true); + if (msg == CRCInput::RC_epg) g_EventList->exec(CNeutrinoApp::getInstance()->channelList->getActiveChannel_ChannelID(), CNeutrinoApp::getInstance()->channelList->getActiveChannelName()); else if (msg == NeutrinoMessages::SHOW_EPG) g_EpgData->show(CNeutrinoApp::getInstance()->channelList->getActiveChannel_ChannelID()); - else { - if (g_settings.cacheTXT) - tuxtxt_stop(); - tuxtx_main(g_RemoteControl->current_PIDs.PIDs.vtxtpid, 0, 2); - frameBuffer->paintBackground(); - } + StartSubtitles(true); if (restore) FileTimeOSD->show(position); #if 0 @@ -1693,7 +2105,9 @@ void CMoviePlayerGui::PlayFileLoop(void) } else if (msg == NeutrinoMessages::SHOW_EPG) { handleMovieBrowser(NeutrinoMessages::SHOW_EPG, position); } else if (msg == NeutrinoMessages::EVT_SUBT_MESSAGE) { +#if 0 showSubtitle(data); +#endif } else if (msg == NeutrinoMessages::ANNOUNCE_RECORD || msg == NeutrinoMessages::RECORD_START) { CNeutrinoApp::getInstance()->handleMsg(msg, data); @@ -1714,7 +2128,7 @@ void CMoviePlayerGui::PlayFileLoop(void) if (playstate == CMoviePlayerGui::PLAY && (position >= 300000 || (duration < 300000 && (position > (duration /2))))) makeScreenShot(true); } else if (CNeutrinoApp::getInstance()->listModeKey(msg)) { - // do nothing + //FIXME do nothing ? } else if (msg == (neutrino_msg_t) CRCInput::RC_setup) { CNeutrinoApp::getInstance()->handleMsg(NeutrinoMessages::SHOW_MAINMENU, 0); } else if (msg == CRCInput::RC_red || msg == CRCInput::RC_green || msg == CRCInput::RC_yellow || msg == CRCInput::RC_blue ) { @@ -1733,11 +2147,17 @@ void CMoviePlayerGui::PlayFileLoop(void) keyPressed = CMoviePlayerGui::PLUGIN_PLAYSTATE_LEAVE_ALL; ClearQueue(); } - else if (msg <= CRCInput::RC_MaxRC ) { + else if (msg <= CRCInput::RC_MaxRC) { update_lcd = true; +#if 0 clearSubtitle(); +#endif } } +#if 0 + if (msg < CRCInput::RC_MaxRC) + lastmsg = msg; +#endif } printf("CMoviePlayerGui::PlayFile: exit, isMovieBrowser %d p_movie_info %p\n", isMovieBrowser, p_movie_info); playstate = CMoviePlayerGui::STOPPED; @@ -1759,18 +2179,35 @@ void CMoviePlayerGui::PlayFileEnd(bool restore) printf("%s: stopping, this %p thread %p\n", __func__, this, CMoviePlayerGui::bgPlayThread);fflush(stdout); if (filelist_it == filelist.end()) FileTimeOSD->kill(); +#if 0 clearSubtitle(); +#endif playback->SetSpeed(1); playback->Close(); +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE + frameBuffer->set3DMode(old3dmode); + CScreenSetup cSS; + cSS.showBorder(CZapit::getInstance()->GetCurrentChannelID()); +#endif +#ifdef ENABLE_GRAPHLCD + if (p_movie_info || glcd_play == true) { + glcd_play = false; + nGLCD::unlockChannel(); + } +#endif if (iso_file) { iso_file = false; - if (umount2(ISO_MOUNT_POINT ,MNT_FORCE)) + if (umount2(ISO_MOUNT_POINT, MNT_FORCE)) perror(ISO_MOUNT_POINT); } CVFD::getInstance()->ShowIcon(FP_ICON_PLAY, false); CVFD::getInstance()->ShowIcon(FP_ICON_PAUSE, false); +#if HAVE_DUCKBOX_HARDWARE || HAVE_SPARK_HARDWARE + CVFD::getInstance()->ShowIcon(FP_ICON_FR, false); + CVFD::getInstance()->ShowIcon(FP_ICON_FF, false); +#endif if (restore) restoreNeutrino(); @@ -1812,11 +2249,41 @@ void CMoviePlayerGui::callInfoViewer(bool init_vzap_it) return; } - if(duration == 0) - UpdatePosition(); + std::vector keys, values; + playback->GetMetadata(keys, values); + size_t count = keys.size(); + if (count > 0) { + CMovieInfo cmi; + cmi.clearMovieInfo(&movie_info); + for (size_t i = 0; i < count; i++) { + std::string key = trim(keys[i]); + if (movie_info.epgTitle.empty() && !strcasecmp("title", key.c_str())) { + movie_info.epgTitle = isUTF8(values[i]) ? values[i] : convertLatin1UTF8(values[i]); + CVFD::getInstance()->showServicename(movie_info.epgTitle.c_str()); + continue; + } + if (movie_info.channelName.empty() && !strcasecmp("artist", key.c_str())) { + movie_info.channelName = isUTF8(values[i]) ? values[i] : convertLatin1UTF8(values[i]); + continue; + } + if (movie_info.epgInfo1.empty() && !strcasecmp("album", key.c_str())) { + movie_info.epgInfo1 = isUTF8(values[i]) ? values[i] : convertLatin1UTF8(values[i]); + continue; + } + } + if (!movie_info.channelName.empty() || !movie_info.epgTitle.empty()) + p_movie_info = &movie_info; +#ifdef ENABLE_GRAPHLCD + if (p_movie_info) + nGLCD::lockChannel(p_movie_info->channelName, p_movie_info->epgTitle); +#endif + } + + if (p_movie_info) { + + if(duration == 0) + UpdatePosition(); - if (isMovieBrowser && p_movie_info) - { MI_MOVIE_INFO *mi; mi = p_movie_info; if (!filelist.empty() && g_settings.mode_left_right_key_tv == SNeutrinoSettings::VZAP) @@ -1828,24 +2295,61 @@ void CMoviePlayerGui::callInfoViewer(bool init_vzap_it) mi = milist[idx]; } } - g_InfoViewer->showMovieTitle(playstate, mi->epgId >>16, mi->channelName, mi->epgTitle, mi->epgInfo1, + + std::string channelName = mi->channelName; + if (channelName.empty()) + channelName = pretty_name; + + std::string channelTitle = mi->epgTitle; + if (channelTitle.empty()) + channelTitle = pretty_name; + + CVFD::getInstance()->ShowText(channelTitle.c_str()); + + g_InfoViewer->showMovieTitle(playstate, mi->epgId >>16, channelName, mi->epgTitle, mi->epgInfo1, duration, position, repeat_mode, init_vzap_it ? 0 /*IV_MODE_DEFAULT*/ : 1 /*IV_MODE_VIRTUAL_ZAP*/); + unlink("/tmp/cover.jpg"); return; } /* not moviebrowser => use the filename as title */ + CVFD::getInstance()->ShowText(pretty_name.c_str()); g_InfoViewer->showMovieTitle(playstate, 0, pretty_name, info_1, info_2, duration, position, repeat_mode); + unlink("/tmp/cover.jpg"); } bool CMoviePlayerGui::getAudioName(int apid, std::string &apidtitle) { if (p_movie_info == NULL) - return false; - - for (int i = 0; i < (int)p_movie_info->audioPids.size(); i++) { - if (p_movie_info->audioPids[i].AudioPid == apid && !p_movie_info->audioPids[i].AudioPidName.empty()) { - apidtitle = p_movie_info->audioPids[i].AudioPidName; + { + numpida = REC_MAX_APIDS; + playback->FindAllPids(apids, ac3flags, &numpida, language); + for (unsigned int count = 0; count < numpida; count++) + if(apid == apids[count]){ + apidtitle = getISO639Description(language[count].c_str()); return true; + } + } + else + { + if (!isMovieBrowser) + { + numpida = REC_MAX_APIDS; + playback->FindAllPids(apids, ac3flags, &numpida, language); + for (unsigned int count = 0; count < numpida; count++) + if(apid == apids[count]){ + apidtitle = getISO639Description(language[count].c_str()); + return true; + } + } + else + { + for (int i = 0; i < (int)p_movie_info->audioPids.size(); i++) { + if (p_movie_info->audioPids[i].AudioPid == apid && !p_movie_info->audioPids[i].AudioPidName.empty()) { + apidtitle = getISO639Description(p_movie_info->audioPids[i].AudioPidName.c_str()); + return true; + } + } } } return false; @@ -1865,7 +2369,7 @@ void CMoviePlayerGui::addAudioFormat(int count, std::string &apidtitle, bool& en enabled = false; break; case 3: /*MP2*/ - apidtitle.append("( MP2)"); + apidtitle.append(" (MP2)"); break; case 4: /*MP3*/ apidtitle.append(" (MP3)"); @@ -1874,10 +2378,9 @@ void CMoviePlayerGui::addAudioFormat(int count, std::string &apidtitle, bool& en apidtitle.append(" (AAC)"); break; case 6: /*DTS*/ - apidtitle.append(" (DTS)"); if (apidtitle.find("DTS") == std::string::npos) apidtitle.append(" (DTS)"); -#if ! defined(HAVE_SPARK_HARDWARE) && ! defined (BOXMODEL_CS_HD2) +#ifndef BOXMODEL_CS_HD2 enabled = false; #endif break; @@ -1889,43 +2392,28 @@ void CMoviePlayerGui::addAudioFormat(int count, std::string &apidtitle, bool& en } } -void CMoviePlayerGui::getCurrentAudioName(bool file_player, std::string &audioname) +void CMoviePlayerGui::getCurrentAudioName(bool /* file_player */, std::string &audioname) { - if (file_player && !numpida) { - playback->FindAllPids(apids, ac3flags, &numpida, language); - if (numpida) - currentapid = apids[0]; - } - bool dumm = true; - for (unsigned int count = 0; count < numpida; count++) { - if (currentapid == apids[count]) { - if (!file_player) { - getAudioName(apids[count], audioname); - return ; - } else if (!language[count].empty()) { - audioname = language[count]; - addAudioFormat(count, audioname, dumm); - if (!dumm && (count < numpida)) { - currentapid = apids[count+1]; - continue; - } - return ; - } - char apidnumber[20]; - sprintf(apidnumber, "Stream %d %X", count + 1, apids[count]); - audioname = apidnumber; - addAudioFormat(count, audioname, dumm); - if (!dumm && (count < numpida)) { - currentapid = apids[count+1]; - continue; - } - return ; + numpida = REC_MAX_APIDS; + playback->FindAllPids(apids, ac3flags, &numpida, language); + if (numpida && !currentapid) + currentapid = apids[0]; + for (unsigned int count = 0; count < numpida; count++) + if(currentapid == apids[count]){ + if (getAudioName(apids[count], audioname)) + return; + audioname = language[count]; + return; } - } } void CMoviePlayerGui::selectAudioPid() { + CAudioSelectMenuHandler APIDSelector; + StopSubtitles(true); + APIDSelector.exec(NULL, "-1"); + StartSubtitles(true); +#if 0 CMenuWidget APIDSelector(LOCALE_APIDSELECTOR_HEAD, NEUTRINO_ICON_AUDIO); APIDSelector.addIntroItems(); @@ -1997,6 +2485,7 @@ void CMoviePlayerGui::selectAudioPid() getCurrentAudioName(is_file_player, currentaudioname); printf("[movieplayer] apid changed to %d type %d\n", currentapid, currentac3); } +#endif } void CMoviePlayerGui::handleMovieBrowser(neutrino_msg_t msg, int /*position*/) @@ -2049,6 +2538,9 @@ void CMoviePlayerGui::handleMovieBrowser(neutrino_msg_t msg, int /*position*/) newComHintBox.movePosition(newx, newy); return; } +#if 0 + else if ((msg == (neutrino_msg_t) g_settings.mpkey_stop) || msg == CRCInput::RC_home) { +#endif else if (msg == (neutrino_msg_t) g_settings.mpkey_stop) { // if we have a movie information, try to save the stop position printf("CMoviePlayerGui::handleMovieBrowser: stop, isMovieBrowser %d p_movie_info %p\n", isMovieBrowser, p_movie_info); @@ -2291,6 +2783,27 @@ void CMoviePlayerGui::UpdatePosition() } } +void CMoviePlayerGui::StopSubtitles(bool enable_glcd_mirroring __attribute__((unused))) +{ +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE + printf("[CMoviePlayerGui] %s\n", __FUNCTION__); + int ttx, ttxpid, ttxpage; + + int current_sub = playback->GetSubtitlePid(); + if (current_sub > -1) + dvbsub_pause(); + tuxtx_subtitle_running(&ttxpid, &ttxpage, &ttx); + if (ttx) { + tuxtx_pause_subtitle(true); + frameBuffer->paintBackground(); + } +#ifdef ENABLE_GRAPHLCD + if (enable_glcd_mirroring) + nGLCD::MirrorOSD(g_settings.glcd_mirror_osd); +#endif +#endif +} + void CMoviePlayerGui::showHelp() { Helpbox helpbox(g_Locale->getText(LOCALE_MESSAGEBOX_INFO)); @@ -2321,6 +2834,24 @@ void CMoviePlayerGui::showHelp() helpbox.hide(); } +void CMoviePlayerGui::StartSubtitles(bool show __attribute__((unused))) +{ +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE + printf("[CMoviePlayerGui] %s: %s\n", __FUNCTION__, show ? "Show" : "Not show"); +#ifdef ENABLE_GRAPHLCD + nGLCD::MirrorOSD(false); +#endif + + if(!show) + return; + int current_sub = playback->GetSubtitlePid(); + if (current_sub > -1) + dvbsub_start(current_sub, true); + tuxtx_pause_subtitle(false); +#endif +} + +#if 0 void CMoviePlayerGui::selectChapter() { if (!is_file_player) @@ -2618,7 +3149,7 @@ void CMoviePlayerGui::showSubtitle(neutrino_msg_data_t data) size_t start = 0, end = 0; /* split string with \N as newline */ std::string delim("\\N"); - while ((end = str.find(delim, start)) != std::string::npos) { + while ((end = str.find(delim, start)) != string::npos) { subtext.push_back(str.substr(start, end - start)); start = end + 2; } @@ -2666,9 +3197,137 @@ void CMoviePlayerGui::showSubtitle(neutrino_msg_data_t data) avsubtitle_free(sub); delete sub; } +#endif + +bool CMoviePlayerGui::setAPID(unsigned int i) { + if (currentapid != apids[i]) { + currentapid = apids[i]; + currentac3 = ac3flags[i]; + playback->SetAPid(currentapid, currentac3); + CZapit::getInstance()->SetVolumePercent((ac3flags[i] == 1) ? g_settings.audio_volume_percent_ac3 : g_settings.audio_volume_percent_pcm); + } + return (i < numpida); +} + +std::string CMoviePlayerGui::getAPIDDesc(unsigned int i) +{ + std::string apidtitle; + if (i < numpida) + getAudioName(apids[i], apidtitle); + if (apidtitle == "") + apidtitle = "Stream " + to_string(i); + return apidtitle; +} + +unsigned int CMoviePlayerGui::getAPID(unsigned int i) +{ + if (i < numpida) + return apids[i]; + return -1; +} + +unsigned int CMoviePlayerGui::getAPID(void) +{ + for (unsigned int i = 0; i < numpida; i++) + if (apids[i] == currentapid) + return i; + return -1; +} + +unsigned int CMoviePlayerGui::getAPIDCount(void) +{ + unsigned int count = 0; + numpida = REC_MAX_APIDS; + playback->FindAllPids(apids, ac3flags, &numpida, language); + for (unsigned int i = 0; i < numpida; i++) { + if (i != count) { + apids[count] = apids[i]; + ac3flags[count] = ac3flags[i]; + language[count] = language[i]; + } + if (language[i].empty()) { + language[i] = "Stream "; + language[i] += to_string(count); + } + bool ena = false; + addAudioFormat(i, language[i], ena); + if (ena) + count++; + } + numpida = count; + return numpida; +} + +unsigned int CMoviePlayerGui::getSubtitleCount(void) +{ + // these may change in-stream + numpids = REC_MAX_SPIDS; + playback->FindAllSubtitlePids(spids, &numpids, slanguage); + numpidt = REC_MAX_TPIDS; + playback->FindAllTeletextsubtitlePids(tpids, &numpidt, tlanguage, tmag, tpage); + + return numpids + numpidt; +} + +CZapitAbsSub* CMoviePlayerGui::getChannelSub(unsigned int i, CZapitAbsSub **s) +{ + if (i < numpidt) { + CZapitTTXSub *_s = new CZapitTTXSub; + _s->thisSubType = CZapitAbsSub::TTX; + _s->pId = tpids[i]; + _s->ISO639_language_code = tlanguage[i]; + _s->teletext_magazine_number = tmag[i]; + _s->teletext_page_number = tpage[i]; + *s = _s; + return *s; + } + i -= numpidt; + if (i < numpids) { + CZapitAbsSub *_s = new CZapitAbsSub; + _s->thisSubType = CZapitAbsSub::SUB; + _s->pId = spids[i]; + _s->ISO639_language_code = slanguage[i]; + *s = _s; + return *s; + } + return NULL; +} + +int CMoviePlayerGui::getCurrentSubPid(CZapitAbsSub::ZapitSubtitleType st) +{ + switch(st) { + case CZapitAbsSub::DVB: + case CZapitAbsSub::SUB: + return playback->GetSubtitlePid(); + case CZapitAbsSub::TTX: + return -1; // FIXME ... caller would need both pid and page + } + return -1; +} + +t_channel_id CMoviePlayerGui::getChannelId(void) +{ + return p_movie_info ? p_movie_info->epgId : 0; +} + +void CMoviePlayerGui::getAPID(int &apid, unsigned int &is_ac3) +{ + apid = currentapid, is_ac3 = (currentac3 == AUDIO_FMT_DOLBY_DIGITAL || currentac3 == AUDIO_FMT_DD_PLUS); +} + +bool CMoviePlayerGui::getAPID(unsigned int i, int &apid, unsigned int &is_ac3) +{ + if (i < numpida) { + apid = apids[i]; + is_ac3 = (ac3flags[i] == 1); + return true; + } + return false; +} void CMoviePlayerGui::selectAutoLang() { +#if 0 if (!numsubs) playback->FindAllSubs(spids, sub_supported, &numsubs, slanguage); @@ -2680,14 +3339,15 @@ void CMoviePlayerGui::selectAutoLang() } } } +#endif if (g_settings.auto_lang && (numpida > 1)) { int pref_idx = -1; playback->FindAllPids(apids, ac3flags, &numpida, language); - for(int i = 0; i < 3; i++) { + for (int i = 0; i < 3; i++) { for (unsigned j = 0; j < numpida; j++) { std::map::const_iterator it; - for(it = iso639.begin(); it != iso639.end(); ++it) { + for (it = iso639.begin(); it != iso639.end(); ++it) { if (g_settings.pref_lang[i] == it->second && strncasecmp(language[j].c_str(), it->first.c_str(), 3) == 0) { bool enabled = true; // TODO: better check of supported @@ -2711,6 +3371,7 @@ void CMoviePlayerGui::selectAutoLang() getCurrentAudioName(is_file_player, currentaudioname); } } +#if 0 if (isWebTV && g_settings.auto_subs && numsubs > 0) { for(int i = 0; i < 3; i++) { if(g_settings.pref_subs[i].empty() || g_settings.pref_subs[i] == "none") @@ -2739,6 +3400,7 @@ void CMoviePlayerGui::selectAutoLang() } } } +#endif } void CMoviePlayerGui::parsePlaylist(CFile *file) @@ -2746,6 +3408,7 @@ void CMoviePlayerGui::parsePlaylist(CFile *file) std::ifstream infile; char cLine[1024]; char name[1024] = { 0 }; + std::string file_path = file->getPath(); infile.open(file->Name.c_str(), std::ifstream::in); filelist_it = filelist.erase(filelist_it); CFile tmp_file; @@ -2769,6 +3432,22 @@ void CMoviePlayerGui::parsePlaylist(CFile *file) filelist.push_back(tmp_file); } } + else + { + printf("name %s [%d] file: %s\n", name, dur, cLine); + std::string illegalChars = "\\/:?\"<>|"; + std::string::iterator it; + std::string name_s = name; + for (it = name_s.begin() ; it < name_s.end() ; ++it){ + bool found = illegalChars.find(*it) != std::string::npos; + if(found){ + *it = ' '; + } + } + tmp_file.Name = name_s; + tmp_file.Url = file_path + cLine; + filelist.push_back(tmp_file); + } } } filelist_it = filelist.begin(); @@ -2792,7 +3471,6 @@ void CMoviePlayerGui::makeScreenShot(bool autoshot, bool forcover) if (autoshot && (autoshot_done || !g_settings.auto_cover)) return; -#ifdef SCREENSHOT bool cover = autoshot || g_settings.screenshot_cover || forcover; char ending[(sizeof(int)*2) + 6] = ".jpg"; if (!cover) @@ -2842,9 +3520,10 @@ void CMoviePlayerGui::makeScreenShot(bool autoshot, bool forcover) sc->SetSize(w, h); } } - sc->Start(); +#if ! HAVE_COOL_HARDWARE + sc->Start("-r 320 -j 75"); #else - (void)forcover; + sc->Start(); #endif if (autoshot) autoshot_done = true; @@ -2852,16 +3531,15 @@ void CMoviePlayerGui::makeScreenShot(bool autoshot, bool forcover) size_t CMoviePlayerGui::GetReadCount() { - uint64_t this_read = 0; - this_read = playback->GetReadCount(); - uint64_t res; - if (this_read < last_read) - res = 0; - else - res = this_read - last_read; - last_read = this_read; -//printf("GetReadCount: %lld\n", res); - return (size_t) res; + uint64_t this_read = 0; + this_read = playback->GetReadCount(); + uint64_t res; + if (this_read < last_read) + res = 0; + else + res = this_read - last_read; + last_read = this_read; + return (size_t) res; } void CMoviePlayerGui::screensaver(bool on) diff --git a/src/gui/movieplayer.h b/src/gui/movieplayer.h index bef6bc9c9..6e2015478 100644 --- a/src/gui/movieplayer.h +++ b/src/gui/movieplayer.h @@ -42,6 +42,7 @@ #include #include #include +#include #include #include @@ -99,7 +100,7 @@ class CMoviePlayerGui : public CMenuTarget std::string livestreamInfo2; CFrameBuffer * frameBuffer; - int m_LastMode; + int m_LastMode; std::string file_name; std::string pretty_name; @@ -121,13 +122,18 @@ class CMoviePlayerGui : public CMenuTarget int currentVideoSystem; uint32_t currentOsdResolution; - unsigned short numpida; - unsigned short vpid; - unsigned short vtype; - std::string language[MAX_PLAYBACK_PIDS]; - unsigned short apids[MAX_PLAYBACK_PIDS]; - unsigned short ac3flags[MAX_PLAYBACK_PIDS]; - unsigned short currentapid, currentac3; + unsigned int numpida; + int vpid; + int vtype; + std::string language[REC_MAX_APIDS]; +#if HAVE_COOL_HARDWARE + uint16_t apids[REC_MAX_APIDS]; + unsigned short ac3flags[REC_MAX_APIDS]; +#else + int apids[REC_MAX_APIDS]; + unsigned int ac3flags[REC_MAX_APIDS]; +#endif + int currentapid, currentac3; repeat_mode_enum repeat_mode; /* screensaver */ @@ -135,16 +141,37 @@ class CMoviePlayerGui : public CMenuTarget bool m_screensaver; void screensaver(bool on); + // subtitle data + unsigned int numpids; +#ifndef REC_MAX_SPIDS +#define REC_MAX_SPIDS 20 // whatever +#endif + std::string slanguage[REC_MAX_SPIDS]; + int spids[REC_MAX_SPIDS]; + + // teletext subtitle data + unsigned int numpidt; +#ifndef REC_MAX_TPIDS +#define REC_MAX_TPIDS 50 // not pids, actually -- a pid may cover multiple subtitle pages +#endif + std::string tlanguage[REC_MAX_TPIDS]; + int tpids[REC_MAX_TPIDS]; + int tmag[REC_MAX_TPIDS]; + int tpage[REC_MAX_TPIDS]; + std::string currentttxsub; + +#if 0 /* subtitles vars */ unsigned short numsubs; - std::string slanguage[MAX_PLAYBACK_PIDS]; - unsigned short spids[MAX_PLAYBACK_PIDS]; - unsigned short sub_supported[MAX_PLAYBACK_PIDS]; + std::string slanguage[REC_MAX_APIDS]; + unsigned short spids[REC_MAX_APIDS]; + unsigned short sub_supported[REC_MAX_APIDS]; int currentspid; int min_x, min_y, max_x, max_y; int64_t end_time; bool ext_subs; bool lock_subs; +#endif uint64_t last_read; /* playback from MB */ @@ -155,10 +182,12 @@ class CMoviePlayerGui : public CMenuTarget bool isYT; bool showStartingHint; static CMovieBrowser* moviebrowser; - MI_MOVIE_INFO * p_movie_info; MI_MOVIE_INFO movie_info; P_MI_MOVIE_LIST milist; const static short MOVIE_HINT_BOX_TIMER = 5; // time to show bookmark hints in seconds +#if HAVE_SPARK_HARDWARE || HAVE_DUCKBOX_HARDWARE + CFrameBuffer::Mode3D old3dmode; +#endif /* playback from file */ bool is_file_player; @@ -210,8 +239,11 @@ class CMoviePlayerGui : public CMenuTarget bool SelectFile(); void updateLcd(); +#if 0 + void selectSubtitle(); bool convertSubtitle(std::string &text); void selectChapter(); +#endif void selectAutoLang(); void parsePlaylist(CFile *file); bool mountIso(CFile *file); @@ -238,25 +270,44 @@ class CMoviePlayerGui : public CMenuTarget static CMoviePlayerGui& getInstance(bool background = false); + MI_MOVIE_INFO * p_movie_info; int exec(CMenuTarget* parent, const std::string & actionKey); bool Playing() { return playing; }; std::string CurrentAudioName() { return currentaudioname; }; int GetSpeed() { return speed; } int GetPosition() { return position; } int GetDuration() { return duration; } + int getState() { return playstate; } void UpdatePosition(); int timeshift; int file_prozent; + cPlayback *getPlayback() { return playback; } void SetFile(std::string &name, std::string &file, std::string info1="", std::string info2="") { pretty_name = name; file_name = file; info_1 = info1; info_2 = info2; } + unsigned int getAPID(void); + unsigned int getAPID(unsigned int i); + void getAPID(int &apid, unsigned int &is_ac3); + bool getAPID(unsigned int i, int &apid, unsigned int &is_ac3); + bool setAPID(unsigned int i); + unsigned int getAPIDCount(void); + std::string getAPIDDesc(unsigned int i); + unsigned int getSubtitleCount(void); + CZapitAbsSub* getChannelSub(unsigned int i, CZapitAbsSub **s); + int getCurrentSubPid(CZapitAbsSub::ZapitSubtitleType st); + void setCurrentTTXSub(const char *s) { currentttxsub = s; } + t_channel_id getChannelId(void); bool PlayBackgroundStart(const std::string &file, const std::string &name, t_channel_id chan, const std::string &script=""); void stopPlayBack(void); + void StopSubtitles(bool enable_glcd_mirroring); + void StartSubtitles(bool show = true); void setLastMode(int m) { m_LastMode = m; } void Pause(bool b = true); - void selectAudioPid(); + void selectAudioPid(void); bool SetPosition(int pos, bool absolute = false); +#if 0 void selectSubtitle(); void showSubtitle(neutrino_msg_data_t data); void clearSubtitle(bool lock = false); +#endif int getKeyPressed() { return keyPressed; }; size_t GetReadCount(); std::string GetFile() { return pretty_name; } diff --git a/src/gui/osd_helpers.cpp b/src/gui/osd_helpers.cpp index b5bb20127..18b41f809 100644 --- a/src/gui/osd_helpers.cpp +++ b/src/gui/osd_helpers.cpp @@ -14,7 +14,12 @@ #include #include +#if HAVE_COOL_HARDWARE #include +#endif +#if USE_STB_HAL +#include +#endif extern CInfoClock *InfoClock; extern CTimeOSD *FileTimeOSD; diff --git a/src/gui/osd_setup.cpp b/src/gui/osd_setup.cpp index b14dbbac7..de70d8ff5 100644 --- a/src/gui/osd_setup.cpp +++ b/src/gui/osd_setup.cpp @@ -66,6 +66,13 @@ #include #include "cs_api.h" +#if HAVE_COOL_HARDWARE +#include +#endif +#if USE_STB_HAL +#include +#endif + extern CRemoteControl * g_RemoteControl; extern const char * locale_real_names[]; diff --git a/src/lcddisplay/fontrenderer.cpp b/src/lcddisplay/fontrenderer.cpp index b4b8aac40..e52e71d6e 100644 --- a/src/lcddisplay/fontrenderer.cpp +++ b/src/lcddisplay/fontrenderer.cpp @@ -321,11 +321,6 @@ void LcdFont::RenderString(int x, int y, const int width, const char * text, con pthread_mutex_unlock(&renderer->render_mutex); } -int LcdFont::getRenderWidth(const std::string &text, const bool utf8_encoded) -{ - return getRenderWidth(text.c_str(), utf8_encoded); -}; - int LcdFont::getRenderWidth(const char * text, const bool utf8_encoded) { pthread_mutex_lock(&renderer->render_mutex); diff --git a/src/lcddisplay/fontrenderer.h b/src/lcddisplay/fontrenderer.h index 97479f590..805149c1c 100644 --- a/src/lcddisplay/fontrenderer.h +++ b/src/lcddisplay/fontrenderer.h @@ -56,15 +56,13 @@ class LcdFont FT_Error getGlyphBitmap(FT_ULong glyph_index, FTC_SBit *sbit); - public: - void RenderString(int x, int y, int width, const char *text, int color, - int selected = 0, const bool utf8_encoded = true); + public: + void RenderString(int x, int y, int width, const char *text, int color, int selected=0, const bool utf8_encoded = false); - int getRenderWidth(const char *text, const bool utf8_encoded = true); - int getRenderWidth(const std::string &text, const bool utf8_encoded = true); + int getRenderWidth(const char *text, const bool utf8_encoded = false); - LcdFont(CLCDDisplay *fb, LcdFontRenderClass *render, FTC_FaceID faceid, int isize); - ~LcdFont(){} + LcdFont(CLCDDisplay *fb, LcdFontRenderClass *render, FTC_FaceID faceid, int isize); + ~LcdFont(){} }; diff --git a/src/lcddisplay/lcddisplay.cpp b/src/lcddisplay/lcddisplay.cpp index d26151b1f..a7858e61d 100644 --- a/src/lcddisplay/lcddisplay.cpp +++ b/src/lcddisplay/lcddisplay.cpp @@ -25,7 +25,7 @@ */ #include -#ifdef HAVE_SPARK_HARDWARE +#if HAVE_SPARK_HARDWARE #define HAVE_GENERIC_HARDWARE 1 #endif #include "lcddisplay.h" @@ -458,7 +458,11 @@ bool CLCDDisplay::load_png(const char * const filename) png_destroy_read_struct(&png_ptr, (png_infopp)NULL, (png_infopp)NULL); else { +#if (PNG_LIBPNG_VER < 10500) + if (!(setjmp(png_ptr->jmpbuf))) +#else if (!setjmp(png_jmpbuf(png_ptr))) +#endif { png_init_io(png_ptr,fh); diff --git a/src/neutrino.cpp b/src/neutrino.cpp index fc23a65dd..b54df7d83 100644 --- a/src/neutrino.cpp +++ b/src/neutrino.cpp @@ -2712,9 +2712,11 @@ void CNeutrinoApp::RealRun() if (g_settings.recording_type != CNeutrinoApp::RECORDING_OFF) CRecordManager::getInstance()->exec(NULL, "Record"); } +#if 0 else if ((mode == mode_webtv) && msg == (neutrino_msg_t) g_settings.mpkey_subtitle) { CMoviePlayerGui::getInstance(true).selectSubtitle(); } +#endif /* after sensitive key bind, check user menu */ else if (usermenu.showUserMenu(msg)) { } @@ -3048,10 +3050,12 @@ int CNeutrinoApp::handleMsg(const neutrino_msg_t _msg, neutrino_msg_data_t data) } return messages_return::handled; } +#if 0 if (mode == mode_webtv && msg == NeutrinoMessages::EVT_SUBT_MESSAGE) { CMoviePlayerGui::getInstance(true).showSubtitle(data); return messages_return::handled; } +#endif if (msg == NeutrinoMessages::EVT_AUTO_SET_VIDEOSYSTEM) { printf(">>>>>[CNeutrinoApp::%s:%d] Receive EVT_AUTO_SET_VIDEOSYSTEM message\n", __func__, __LINE__); COsdHelpers *coh = COsdHelpers::getInstance(); @@ -4786,8 +4790,10 @@ void CNeutrinoApp::StopSubtitles() tuxtx_pause_subtitle(true); frameBuffer->paintBackground(); } +#if 0 if (mode == mode_webtv) CMoviePlayerGui::getInstance(true).clearSubtitle(true); +#endif } void CNeutrinoApp::StartSubtitles(bool show) @@ -4797,8 +4803,10 @@ void CNeutrinoApp::StartSubtitles(bool show) return; dvbsub_start(0); tuxtx_pause_subtitle(false); +#if 0 if (mode == mode_webtv) CMoviePlayerGui::getInstance(true).clearSubtitle(false); +#endif } void CNeutrinoApp::SelectSubtitles() diff --git a/src/zapit/include/private/linux/dvb/video.h b/src/zapit/include/private/linux/dvb/video.h index d3d14a59d..a86ce29e6 100644 --- a/src/zapit/include/private/linux/dvb/video.h +++ b/src/zapit/include/private/linux/dvb/video.h @@ -154,7 +154,7 @@ struct video_status { struct video_still_picture { - char __user *iFrame; /* pointer to a single iframe in memory */ + char *iFrame; /* pointer to a single iframe in memory */ __s32 size; }; @@ -187,7 +187,7 @@ typedef struct video_spu { typedef struct video_spu_palette { /* SPU Palette information */ int length; - __u8 __user *palette; + __u8 *palette; } video_spu_palette_t; diff --git a/src/zapit/include/zapit/capmt.h b/src/zapit/include/zapit/capmt.h index e85a3f458..1868fb0b4 100644 --- a/src/zapit/include/zapit/capmt.h +++ b/src/zapit/include/zapit/capmt.h @@ -66,7 +66,11 @@ class CCam : public CBasicClient bool sendMessage(const char * const data, const size_t length, bool update = false); bool makeCaPmt(CZapitChannel * channel, bool add_private, uint8_t list = CAPMT_ONLY, const CaIdVector &caids = CaIdVector()); bool setCaPmt(bool update = false); +#if ! HAVE_COOL_HARDWARE + bool sendCaPmt(uint64_t tpid, uint8_t *rawpmt, int rawlen, uint8_t type, unsigned char scrambled = 0, casys_map_t camap = std::set(), int mode = 0 , bool enable = false); +#else bool sendCaPmt(uint64_t tpid, uint8_t *rawpmt, int rawlen, uint8_t type); +#endif int makeMask(int demux, bool add); int getCaMask(void) { return camask; } void setCaMask(int mask) { camask = mask; } diff --git a/src/zapit/include/zapit/channel.h b/src/zapit/include/zapit/channel.h index 30f1b5a83..a9c7e38d5 100644 --- a/src/zapit/include/zapit/channel.h +++ b/src/zapit/include/zapit/channel.h @@ -55,7 +55,8 @@ class CZapitAbsSub std::string ISO639_language_code; enum ZapitSubtitleType { TTX, - DVB + DVB, + SUB }; ZapitSubtitleType thisSubType; }; diff --git a/src/zapit/src/capmt.cpp b/src/zapit/src/capmt.cpp index 1f21a5dbc..c4e28b155 100644 --- a/src/zapit/src/capmt.cpp +++ b/src/zapit/src/capmt.cpp @@ -142,11 +142,19 @@ bool CCam::setCaPmt(bool update) return sendMessage((char *)cabuf, calen, update); } +#if ! HAVE_COOL_HARDWARE +bool CCam::sendCaPmt(uint64_t tpid, uint8_t *rawpmt, int rawlen, uint8_t type, unsigned char scrambled, casys_map_t camap, int mode, bool enable) +{ + return cCA::GetInstance()->SendCAPMT(tpid, source_demux, camask, + rawpmt ? cabuf : NULL, rawpmt ? calen : 0, rawpmt, rawpmt ? rawlen : 0, (CA_SLOT_TYPE) type, scrambled, camap, mode, enable); +} +#else bool CCam::sendCaPmt(uint64_t tpid, uint8_t *rawpmt, int rawlen, uint8_t type) { return cCA::GetInstance()->SendCAPMT(tpid, source_demux, camask, rawpmt ? cabuf : NULL, rawpmt ? calen : 0, rawpmt, rawpmt ? rawlen : 0, (CA_SLOT_TYPE) type); } +#endif int CCam::makeMask(int demux, bool add) {