From 2719f73b6813d11d13a9650cdd2ab8ec6e69385d Mon Sep 17 00:00:00 2001 From: V3n3RiX Date: Sat, 9 Jul 2022 15:43:36 +0100 Subject: gentoo resync : 09.07.2022 --- .../vdr/files/vdr-2.4.1_mainmenuhook-1.0.1.patch | 114 ++++ .../vdr/files/vdr-2.6.1-patch-for-permashift.patch | 517 ++++++++++++++++++ media-video/vdr/files/vdr-2.6.1_naludump.patch | 598 +++++++++++++++++++++ media-video/vdr/files/vdr-2.6.1_pinplugin.patch | 447 +++++++++++++++ 4 files changed, 1676 insertions(+) create mode 100644 media-video/vdr/files/vdr-2.4.1_mainmenuhook-1.0.1.patch create mode 100644 media-video/vdr/files/vdr-2.6.1-patch-for-permashift.patch create mode 100644 media-video/vdr/files/vdr-2.6.1_naludump.patch create mode 100644 media-video/vdr/files/vdr-2.6.1_pinplugin.patch (limited to 'media-video/vdr/files') diff --git a/media-video/vdr/files/vdr-2.4.1_mainmenuhook-1.0.1.patch b/media-video/vdr/files/vdr-2.4.1_mainmenuhook-1.0.1.patch new file mode 100644 index 000000000000..deec2cd7cfdb --- /dev/null +++ b/media-video/vdr/files/vdr-2.4.1_mainmenuhook-1.0.1.patch @@ -0,0 +1,114 @@ +original https://raw.githubusercontent.com/VDR4Arch/vdr4arch/master/vdr/vdr-MainMenuHooks.patch + +rebased for media-video/vdr-2.4.1 + +Signed-off-by: Joerg Bornkessel ( 2019 Dez 22 ) +diff -Naur vdr-2.4.1.orig/config.h vdr-2.4.1/config.h +--- vdr-2.4.1.orig/config.h 2019-12-22 00:04:59.000000000 +0100 ++++ vdr-2.4.1/config.h 2019-12-22 00:11:25.000000000 +0100 +@@ -36,6 +36,10 @@ + // plugins to work with newer versions of the core VDR as long as no + // VDR header files have changed. + ++// The MainMenuHook Patch's version number: ++#define MAINMENUHOOKSVERSION "1.0.1" ++#define MAINMENUHOOKSVERSNUM 10001 // Version * 10000 + Major * 100 + Minor ++ + #define MAXPRIORITY 99 + #define MINPRIORITY (-MAXPRIORITY) + #define LIVEPRIORITY 0 // priority used when selecting a device for live viewing +diff -Naur vdr-2.4.1.orig/menu.c vdr-2.4.1/menu.c +--- vdr-2.4.1.orig/menu.c 2019-12-22 00:04:59.000000000 +0100 ++++ vdr-2.4.1/menu.c 2019-12-22 00:11:25.000000000 +0100 +@@ -4395,15 +4395,31 @@ + + // Initial submenus: + ++ cOsdObject *menu = NULL; + switch (State) { +- case osSchedule: AddSubMenu(new cMenuSchedule); break; +- case osChannels: AddSubMenu(new cMenuChannels); break; +- case osTimers: AddSubMenu(new cMenuTimers); break; +- case osRecordings: AddSubMenu(new cMenuRecordings(NULL, 0, OpenSubMenus)); break; +- case osSetup: AddSubMenu(new cMenuSetup); break; +- case osCommands: AddSubMenu(new cMenuCommands(tr("Commands"), &Commands)); break; ++ case osSchedule: ++ if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osSchedule", &menu)) ++ menu = new cMenuSchedule; ++ break; ++ case osChannels: ++ if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osChannels", &menu)) ++ menu = new cMenuChannels; ++ break; ++ case osTimers: ++ if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osTimers", &menu)) ++ menu = new cMenuTimers; ++ break; ++ case osRecordings: ++ if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osRecordings", &menu)) ++ menu = new cMenuRecordings(NULL, 0, OpenSubMenus); ++ break; ++ case osSetup: menu = new cMenuSetup; break; ++ case osCommands: menu = new cMenuCommands(tr("Commands"), &Commands); break; + default: break; + } ++ if (menu) ++ if (menu->IsMenu()) ++ AddSubMenu((cOsdMenu *) menu); + } + + cOsdObject *cMenuMain::PluginOsdObject(void) +@@ -4511,13 +4527,34 @@ + eOSState state = cOsdMenu::ProcessKey(Key); + HadSubMenu |= HasSubMenu(); + ++ cOsdObject *menu = NULL; + switch (state) { +- case osSchedule: return AddSubMenu(new cMenuSchedule); +- case osChannels: return AddSubMenu(new cMenuChannels); +- case osTimers: return AddSubMenu(new cMenuTimers); +- case osRecordings: return AddSubMenu(new cMenuRecordings); +- case osSetup: return AddSubMenu(new cMenuSetup); +- case osCommands: return AddSubMenu(new cMenuCommands(tr("Commands"), &Commands)); ++ case osSchedule: ++ if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osSchedule", &menu)) ++ menu = new cMenuSchedule; ++ else ++ state = osContinue; ++ break; ++ case osChannels: ++ if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osChannels", &menu)) ++ menu = new cMenuChannels; ++ else ++ state = osContinue; ++ break; ++ case osTimers: ++ if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osTimers", &menu)) ++ menu = new cMenuTimers; ++ else ++ state = osContinue; ++ break; ++ case osRecordings: ++ if (!cPluginManager::CallFirstService("MainMenuHooksPatch-v1.0::osRecordings", &menu)) ++ menu = new cMenuRecordings; ++ else ++ state = osContinue; ++ break; ++ case osSetup: menu = new cMenuSetup; break; ++ case osCommands: menu = new cMenuCommands(tr("Commands"), &Commands); break; + case osStopRecord: if (Interface->Confirm(tr("Stop recording?"))) { + if (cOsdItem *item = Get(Current())) { + cRecordControls::Stop(item->Text() + strlen(tr(STOP_RECORDING))); +@@ -4568,6 +4605,12 @@ + default: break; + } + } ++ if (menu) { ++ if (menu->IsMenu()) ++ return AddSubMenu((cOsdMenu *) menu); ++ pluginOsdObject = menu; ++ return osPlugin; ++ } + if (!HasSubMenu() && Update(HadSubMenu)) + Display(); + if (Key != kNone) { diff --git a/media-video/vdr/files/vdr-2.6.1-patch-for-permashift.patch b/media-video/vdr/files/vdr-2.6.1-patch-for-permashift.patch new file mode 100644 index 000000000000..03b476f986bb --- /dev/null +++ b/media-video/vdr/files/vdr-2.6.1-patch-for-permashift.patch @@ -0,0 +1,517 @@ +Adapted Patch from forum post +https://www.vdr-portal.de/forum/index.php?thread/134171-permashift-1-0-4-f%C3%BCr-vdr-2-4-betaversion/&postID=1341243#post1341243 + +SRC Url https://www.vdr-portal.de/index.php?attachment/45632-vdr-2-5-4-patch-for-permashift-diff-gz/ adapted for vdr-2.6.1 + +Signed-off-by: Martin Dummer + +diff -Naur vdr-2.6.1.orig/device.c vdr-2.6.1/device.c +--- vdr-2.6.1.orig/device.c 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/device.c 2022-02-06 18:05:26.452890690 +0100 +@@ -1880,6 +1880,17 @@ + ReleaseCamSlot(); + } + ++cRecorder* cDevice::GetPreRecording(const cChannel *Channel) ++{ ++ cMutexLock MutexLock(&mutexReceiver); ++ for (int i = 0; i < MAXRECEIVERS; i++) { ++ if (receiver[i]) ++ if (receiver[i]->IsPreRecording(Channel)) ++ return (cRecorder*)receiver[i]; ++ } ++ return NULL; ++} ++ + // --- cTSBuffer ------------------------------------------------------------- + + cTSBuffer::cTSBuffer(int File, int Size, int DeviceNumber) +diff -Naur vdr-2.6.1.orig/device.h vdr-2.6.1/device.h +--- vdr-2.6.1.orig/device.h 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/device.h 2022-02-06 18:05:51.541429884 +0100 +@@ -85,6 +85,7 @@ + + class cPlayer; + class cReceiver; ++class cRecorder; + class cLiveSubtitle; + + class cDeviceHook : public cListObject { +@@ -854,6 +855,8 @@ + ///< Returns true if we are currently receiving. The parameter has no meaning (for backwards compatibility only). + bool AttachReceiver(cReceiver *Receiver); + ///< Attaches the given receiver to this device. ++ cRecorder* GetPreRecording(const cChannel *Channel); ++ ///< Get precocious recording for the channel if there is one. + void Detach(cReceiver *Receiver, bool ReleaseCam = true); + ///< Detaches the given receiver from this device. + ///< If ReleaseCam is true, the CAM slot will be released if it +diff -Naur vdr-2.6.1.orig/dvbplayer.c vdr-2.6.1/dvbplayer.c +--- vdr-2.6.1.orig/dvbplayer.c 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/dvbplayer.c 2022-02-06 18:05:26.452890690 +0100 +@@ -249,13 +249,14 @@ + cUnbufferedFile *replayFile; + double framesPerSecond; + bool isPesRecording; +- bool pauseLive; ++ ReplayState replayState; + bool eof; + bool firstPacket; + ePlayModes playMode; + ePlayDirs playDir; + int trickSpeed; + int readIndex; ++ int startIndex; + bool readIndependent; + cFrame *readFrame; + cFrame *playFrame; +@@ -271,6 +272,8 @@ + virtual void Action(void); + public: + cDvbPlayer(const char *FileName, bool PauseLive); ++ cDvbPlayer(const char *FileName, ReplayState newReplayState); ++ void Construct(const char *FileName, ReplayState newReplayState); + virtual ~cDvbPlayer(); + void SetMarks(const cMarks *Marks); + bool Active(void) { return cThread::Running(); } +@@ -297,6 +300,17 @@ + cDvbPlayer::cDvbPlayer(const char *FileName, bool PauseLive) + :cThread("dvbplayer") + { ++ Construct(FileName, PauseLive? restPauseLive : restNormal); ++} ++ ++cDvbPlayer::cDvbPlayer(const char *FileName, ReplayState newReplayState) ++:cThread("dvbplayer") ++{ ++ Construct(FileName, newReplayState); ++} ++ ++void cDvbPlayer::Construct(const char *FileName, ReplayState newReplayState) ++{ + nonBlockingFileReader = NULL; + ringBuffer = NULL; + marks = NULL; +@@ -304,7 +318,8 @@ + cRecording Recording(FileName); + framesPerSecond = Recording.FramesPerSecond(); + isPesRecording = Recording.IsPesRecording(); +- pauseLive = PauseLive; ++ replayState = newReplayState; ++ bool reuse = (replayState == restReusePause || replayState == restReuseRewind); + eof = false; + firstPacket = true; + playMode = pmPlay; +@@ -323,15 +338,21 @@ + return; + ringBuffer = new cRingBufferFrame(PLAYERBUFSIZE); + // Create the index file: +- index = new cIndexFile(FileName, false, isPesRecording, pauseLive); ++ index = new cIndexFile(FileName, false, isPesRecording, replayState == restPauseLive); + if (!index) + esyslog("ERROR: can't allocate index"); + else if (!index->Ok()) { + delete index; + index = NULL; + } +- else if (PauseLive) ++ else if (reuse) + framesPerSecond = cRecording(FileName).FramesPerSecond(); // the fps rate might have changed from the default ++ startIndex = 0; ++ if (replayState == restReuseRewind || replayState == restReusePause) { ++ int Current, Total; ++ GetIndex(Current, Total, false); ++ startIndex = max(Total - 1, 0); ++ } + } + + cDvbPlayer::~cDvbPlayer() +@@ -481,8 +502,21 @@ + bool CutIn = false; + bool AtLastMark = false; + +- if (pauseLive) +- Goto(0, true); ++ if (replayState == restPauseLive) { ++ Goto(0, true); ++ } ++ else if (replayState == restReuseRewind || replayState == restReusePause) { ++ readIndex = startIndex; ++ Goto(readIndex, true); ++ playMode = pmPlay; ++ if (replayState == restReuseRewind) { ++ Backward(); ++ } ++ else if (replayState == restReusePause) { ++ Pause(); ++ } ++ } ++ + while (Running()) { + if (WaitingForData) + WaitingForData = !nonBlockingFileReader->WaitForDataMs(3); // this keeps the CPU load low, but reacts immediately on new data +@@ -985,6 +1019,11 @@ + { + } + ++cDvbPlayerControl::cDvbPlayerControl(const char *FileName, ReplayState replayState) ++:cControl(player = new cDvbPlayer(FileName, replayState)) ++{ ++} ++ + cDvbPlayerControl::~cDvbPlayerControl() + { + Stop(); +diff -Naur vdr-2.6.1.orig/dvbplayer.h vdr-2.6.1/dvbplayer.h +--- vdr-2.6.1.orig/dvbplayer.h 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/dvbplayer.h 2022-02-06 18:05:26.452890690 +0100 +@@ -16,6 +16,14 @@ + + class cDvbPlayer; + ++enum ReplayState ++{ ++ restNormal, ++ restPauseLive, ++ restReusePause, ++ restReuseRewind ++}; ++ + class cDvbPlayerControl : public cControl { + private: + cDvbPlayer *player; +@@ -25,6 +33,8 @@ + // If PauseLive is true, special care is taken to make sure the index + // file of the recording is long enough to allow the player to display + // the first frame in still picture mode. ++ cDvbPlayerControl(const char *FileName, ReplayState replayState); ++ // Sets up a player for the given file. replayState represents the initial state. + virtual ~cDvbPlayerControl(); + void SetMarks(const cMarks *Marks); + bool Active(void); +diff -Naur vdr-2.6.1.orig/menu.c vdr-2.6.1/menu.c +--- vdr-2.6.1.orig/menu.c 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/menu.c 2022-02-06 18:05:26.452890690 +0100 +@@ -5303,6 +5303,16 @@ + + cRecordControl::cRecordControl(cDevice *Device, cTimers *Timers, cTimer *Timer, bool Pause) + { ++ Construct(Device, Timers, Timer, Pause, NULL); ++} ++ ++cRecordControl::cRecordControl(cDevice *Device, cTimers *Timers, cTimer *Timer, bool Pause, bool* reused) ++{ ++ Construct(Device, Timers, Timer, Pause, reused); ++} ++ ++void cRecordControl::Construct(cDevice *Device, cTimers *Timers, cTimer *Timer, bool Pause, bool* reused) ++{ + const char *LastReplayed = cReplayControl::LastReplayed(); // must do this before locking schedules! + // Whatever happens here, the timers will be modified in some way... + Timers->SetModified(); +@@ -5331,6 +5341,7 @@ + timer->SetPending(true); + timer->SetRecording(true); + event = timer->Event(); ++ if (reused != NULL) *reused = false; + + if (event || GetEvent()) + dsyslog("Title: '%s' Subtitle: '%s'", event->Title(), event->ShortText()); +@@ -5360,8 +5371,21 @@ + if (MakeDirs(fileName, true)) { + Recording.WriteInfo(); // we write this *before* attaching the recorder to the device, to make sure the info file is present when the recorder needs to update the fps value! + const cChannel *ch = timer->Channel(); +- recorder = new cRecorder(fileName, ch, timer->Priority()); +- if (device->AttachReceiver(recorder)) { ++ ++ if (!Timer) { ++ recorder = device->GetPreRecording(ch); ++ if (recorder != NULL) { ++ recorder->ActivatePreRecording(fileName, timer->Priority()); ++ if (reused != NULL) *reused = true; ++ } ++ } ++ ++ if (recorder == NULL) { ++ recorder = new cRecorder(fileName, ch, timer->Priority()); ++ if (!device->AttachReceiver(recorder)) DELETENULL(recorder); ++ } ++ ++ if (recorder != NULL) { + cStatus::MsgRecording(device, Recording.Name(), Recording.FileName(), true); + if (!Timer && !LastReplayed) // an instant recording, maybe from cRecordControls::PauseLiveVideo() + cReplayControl::SetRecording(fileName); +@@ -5371,8 +5395,6 @@ + Recordings->AddByName(fileName); + return; + } +- else +- DELETENULL(recorder); + } + else + timer->SetDeferred(DEFERTIMER); +@@ -5452,7 +5474,7 @@ + cRecordControl *cRecordControls::RecordControls[MAXRECORDCONTROLS] = { NULL }; + int cRecordControls::state = 0; + +-bool cRecordControls::Start(cTimers *Timers, cTimer *Timer, bool Pause) ++bool cRecordControls::Start(cTimers *Timers, cTimer *Timer, bool Pause, bool* reused) + { + static time_t LastNoDiskSpaceMessage = 0; + int FreeMB = 0; +@@ -5490,7 +5512,7 @@ + if (!Timer || Timer->Matches()) { + for (int i = 0; i < MAXRECORDCONTROLS; i++) { + if (!RecordControls[i]) { +- RecordControls[i] = new cRecordControl(device, Timers, Timer, Pause); ++ RecordControls[i] = new cRecordControl(device, Timers, Timer, Pause, reused); + return RecordControls[i]->Process(time(NULL)); + } + } +@@ -5514,6 +5536,11 @@ + return Start(Timers, NULL, Pause); + } + ++bool cRecordControls::Start(cTimers *Timers, cTimer *Timer, bool Pause) ++{ ++ return Start(Timers, Timer, Pause, NULL); ++} ++ + void cRecordControls::Stop(const char *InstantId) + { + LOCK_TIMERS_WRITE; +@@ -5549,10 +5576,17 @@ + + bool cRecordControls::PauseLiveVideo(void) + { ++ return PauseLiveVideo(false); ++} ++ ++bool cRecordControls::PauseLiveVideo(bool rewind) ++{ + Skins.Message(mtStatus, tr("Pausing live video...")); ++ bool reused = false; + cReplayControl::SetRecording(NULL); // make sure the new cRecordControl will set cReplayControl::LastReplayed() +- if (Start(true)) { +- cReplayControl *rc = new cReplayControl(true); ++ LOCK_TIMERS_WRITE; ++ if (Start(Timers, NULL, true, &reused)) { ++ cReplayControl *rc = new cReplayControl(rewind? restReuseRewind : reused? restReusePause : restPauseLive); + cControl::Launch(rc); + cControl::Attach(); + Skins.Message(mtStatus, NULL); +@@ -5695,7 +5729,18 @@ + cReplayControl::cReplayControl(bool PauseLive) + :cDvbPlayerControl(fileName, PauseLive) + { +- cDevice::PrimaryDevice()->SetKeepTracks(PauseLive); ++ Construct(PauseLive? restPauseLive : restNormal); ++} ++ ++cReplayControl::cReplayControl(ReplayState replayState) ++:cDvbPlayerControl(fileName, replayState) ++{ ++ Construct(replayState); ++} ++ ++void cReplayControl::Construct(ReplayState replayState) ++{ ++ cDevice::PrimaryDevice()->SetKeepTracks(replayState == restPauseLive); + currentReplayControl = this; + displayReplay = NULL; + marksModified = false; +diff -Naur vdr-2.6.1.orig/menu.h vdr-2.6.1/menu.h +--- vdr-2.6.1.orig/menu.h 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/menu.h 2022-02-06 18:05:26.452890690 +0100 +@@ -246,6 +246,8 @@ + bool GetEvent(void); + public: + cRecordControl(cDevice *Device, cTimers *Timers, cTimer *Timer = NULL, bool Pause = false); ++ cRecordControl(cDevice *Device, cTimers *Timers, cTimer *Timer, bool Pause, bool* reused); ++ void Construct(cDevice *Device, cTimers *Timers, cTimer *Timer, bool Pause, bool* reused); + virtual ~cRecordControl(); + bool Process(time_t t); + cDevice *Device(void) { return device; } +@@ -261,10 +263,12 @@ + static int state; + public: + static bool Start(cTimers *Timers, cTimer *Timer, bool Pause = false); ++ static bool Start(cTimers *Timers, cTimer *Timer, bool Pause, bool* reused); + static bool Start(bool Pause = false); + static void Stop(const char *InstantId); + static void Stop(cTimer *Timer); + static bool PauseLiveVideo(void); ++ static bool PauseLiveVideo(bool rewind); + static const char *GetInstantId(const char *LastInstantId); + static cRecordControl *GetRecordControl(const char *FileName); + static cRecordControl *GetRecordControl(const cTimer *Timer); +@@ -320,6 +324,8 @@ + void EditTest(void); + public: + cReplayControl(bool PauseLive = false); ++ cReplayControl(ReplayState replayState); ++ void Construct(ReplayState replayState); + virtual ~cReplayControl(); + void Stop(void); + virtual cOsdObject *GetInfo(void); +diff -Naur vdr-2.6.1.orig/receiver.h vdr-2.6.1/receiver.h +--- vdr-2.6.1.orig/receiver.h 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/receiver.h 2022-02-06 18:05:26.452890690 +0100 +@@ -85,6 +85,10 @@ + ///< case the device is needed otherwise, so code that uses a cReceiver + ///< should repeatedly check whether it is still attached, and if + ///< it isn't, delete it (or take any other appropriate measures). ++ virtual bool IsPreRecording(const cChannel *Channel) { return false; } ++ ///< prerecords given channel; may be turned into a disc recording. ++ virtual bool ActivatePreRecording(const char* fileName, int Priority) { return false; } ++ ///< turn prerecording into a disc recording + }; + + #endif //__RECEIVER_H +diff -Naur vdr-2.6.1.orig/recorder.c vdr-2.6.1/recorder.c +--- vdr-2.6.1.orig/recorder.c 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/recorder.c 2022-02-06 18:05:26.452890690 +0100 +@@ -164,11 +164,25 @@ + cRecorder::cRecorder(const char *FileName, const cChannel *Channel, int Priority) + :cReceiver(Channel, Priority) + ,cThread("recording") ++,tsChecker(NULL), frameChecker(NULL), recordingInfo(NULL), ringBuffer(NULL), frameDetector(NULL), fileName(NULL), index(NULL), recordFile(NULL), recordingName(NULL) + { +- tsChecker = new cTsChecker; +- frameChecker = new cFrameChecker; ++ if (FileName != NULL) { ++ InitializeFile(FileName, Channel); ++ } ++} ++ ++void cRecorder::InitializeFile(const char *FileName, const cChannel *Channel) ++{ ++ if (tsChecker == NULL) { ++ tsChecker = new cTsChecker; ++ } ++ if (frameChecker == NULL) { ++ frameChecker = new cFrameChecker; ++ } + recordingName = strdup(FileName); +- recordingInfo = new cRecordingInfo(recordingName); ++ if (recordingInfo == NULL) { ++ recordingInfo = new cRecordingInfo(recordingName); ++ } + recordingInfo->Read(); + oldErrors = max(0, recordingInfo->Errors()); // in case this is a re-started recording + errors = oldErrors; +@@ -193,7 +207,9 @@ + Pid = Channel->Dpid(0); + Type = 0x06; + } +- frameDetector = new cFrameDetector(Pid, Type); ++ if (frameDetector == NULL) { ++ frameDetector = new cFrameDetector(Pid, Type); ++ } + index = NULL; + fileSize = 0; + lastDiskSpaceCheck = time(NULL); +diff -Naur vdr-2.6.1.orig/recorder.h vdr-2.6.1/recorder.h +--- vdr-2.6.1.orig/recorder.h 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/recorder.h 2022-02-06 18:05:26.452890690 +0100 +@@ -19,8 +19,8 @@ + class cTsChecker; + class cFrameChecker; + +-class cRecorder : public cReceiver, cThread { +-private: ++class cRecorder : public cReceiver, protected cThread { ++protected: + cTsChecker *tsChecker; + cFrameChecker *frameChecker; + cRingBufferLinear *ringBuffer; +@@ -41,7 +41,6 @@ + bool RunningLowOnDiskSpace(void); + bool NextFile(void); + void HandleErrors(bool Force = false); +-protected: + virtual void Activate(bool On); + ///< If you override Activate() you need to call Detach() (which is a + ///< member of the cReceiver class) from your own destructor in order +@@ -49,6 +48,9 @@ + ///< destroyed. + virtual void Receive(const uchar *Data, int Length); + virtual void Action(void); ++ void InitializeFile(const char *FileName, const cChannel *Channel); ++ ///< Starts recording to file. ++ ///< Called in constructor if file name has been given. + public: + cRecorder(const char *FileName, const cChannel *Channel, int Priority); + ///< Creates a new recorder for the given Channel and +diff -Naur vdr-2.6.1.orig/ringbuffer.c vdr-2.6.1/ringbuffer.c +--- vdr-2.6.1.orig/ringbuffer.c 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/ringbuffer.c 2022-02-06 18:05:26.452890690 +0100 +@@ -368,6 +368,25 @@ + return NULL; + } + ++uchar *cRingBufferLinear::GetRest(int &Count) ++{ ++ int Head = head; ++ if (getThreadTid <= 0) ++ getThreadTid = cThread::ThreadId(); ++ int rest = Size() - tail; ++ int diff = Head - tail; ++ int cont = (diff >= 0) ? diff : Size() + diff - margin; ++ if (cont > rest) ++ cont = rest; ++ uchar *p = buffer + tail; ++ if (cont > 0) { ++ Count = gotten = cont; ++ return p; ++ } ++ WaitForGet(); ++ return NULL; ++} ++ + void cRingBufferLinear::Del(int Count) + { + if (Count > gotten) { +diff -Naur vdr-2.6.1.orig/ringbuffer.h vdr-2.6.1/ringbuffer.h +--- vdr-2.6.1.orig/ringbuffer.h 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/ringbuffer.h 2022-02-06 18:05:26.452890690 +0100 +@@ -98,6 +98,12 @@ + ///< The data will remain in the buffer until a call to Del() deletes it. + ///< Returns a pointer to the data, and stores the number of bytes + ///< actually available in Count. If the returned pointer is NULL, Count has no meaning. ++ uchar *GetRest(int &Count); ++ ///< Gets data from the ring buffer disregarding the margin. ++ ///< Might have to be called several times to get all data. ++ ///< The data will remain in the buffer until a call to Del() deletes it. ++ ///< Returns a pointer to the data, and stores the number of bytes ++ ///< actually available in Count. If the returned pointer is NULL, Count has no meaning. + void Del(int Count); + ///< Deletes at most Count bytes from the ring buffer. + ///< Count must be less or equal to the number that was returned by a previous +diff -Naur vdr-2.6.1.orig/vdr.c vdr-2.6.1/vdr.c +--- vdr-2.6.1.orig/vdr.c 2022-02-02 10:56:43.000000000 +0100 ++++ vdr-2.6.1/vdr.c 2022-02-06 18:05:26.452890690 +0100 +@@ -1352,13 +1352,22 @@ + key = kNone; + break; + // Pausing live video: ++ case kFastRew: ++ { ++ // test if there's a live buffer to rewind into... ++ LOCK_CHANNELS_READ; ++ if (cDevice::ActualDevice()->GetPreRecording(Channels->GetByNumber(cDevice::CurrentChannel())) == NULL) { ++ break; ++ } ++ } ++ // fall through to pause + case kPlayPause: + case kPause: + if (!Control) { + DELETE_MENU; + if (Setup.PauseKeyHandling) { + if (Setup.PauseKeyHandling > 1 || Interface->Confirm(tr("Pause live video?"))) { +- if (!cRecordControls::PauseLiveVideo()) ++ if (!cRecordControls::PauseLiveVideo(int(key) == kFastRew)) + Skins.QueueMessage(mtError, tr("No free DVB device to record!")); + } + } diff --git a/media-video/vdr/files/vdr-2.6.1_naludump.patch b/media-video/vdr/files/vdr-2.6.1_naludump.patch new file mode 100644 index 000000000000..efea3a1d74f7 --- /dev/null +++ b/media-video/vdr/files/vdr-2.6.1_naludump.patch @@ -0,0 +1,598 @@ +diff -a -U 2 -r a/config.c b/config.c +--- a/config.c ++++ b/config.c +@@ -469,4 +469,5 @@ + SplitEditedFiles = 0; + DelTimeshiftRec = 0; ++ DumpNaluFill = 0; + MinEventTimeout = 30; + MinUserInactivity = 300; +@@ -697,4 +698,5 @@ + else if (!strcasecmp(Name, "SplitEditedFiles")) SplitEditedFiles = atoi(Value); + else if (!strcasecmp(Name, "DelTimeshiftRec")) DelTimeshiftRec = atoi(Value); ++ else if (!strcasecmp(Name, "DumpNaluFill")) DumpNaluFill = atoi(Value); + else if (!strcasecmp(Name, "MinEventTimeout")) MinEventTimeout = atoi(Value); + else if (!strcasecmp(Name, "MinUserInactivity")) MinUserInactivity = atoi(Value); +@@ -829,4 +831,5 @@ + Store("SplitEditedFiles", SplitEditedFiles); + Store("DelTimeshiftRec", DelTimeshiftRec); ++ Store("DumpNaluFill", DumpNaluFill); + Store("MinEventTimeout", MinEventTimeout); + Store("MinUserInactivity", MinUserInactivity); +diff -a -U 2 -r a/config.h b/config.h +--- a/config.h ++++ b/config.h +@@ -341,4 +341,5 @@ + int SplitEditedFiles; + int DelTimeshiftRec; ++ int DumpNaluFill; + int MinEventTimeout, MinUserInactivity; + time_t NextWakeupTime; +diff -a -U 2 -r a/menu.c b/menu.c +--- a/menu.c ++++ b/menu.c +@@ -4185,4 +4185,5 @@ + Add(new cMenuEditBoolItem(tr("Setup.Recording$Split edited files"), &data.SplitEditedFiles)); + Add(new cMenuEditStraItem(tr("Setup.Recording$Delete timeshift recording"),&data.DelTimeshiftRec, 3, delTimeshiftRecTexts)); ++ Add(new cMenuEditBoolItem(tr("Setup.Recording$Dump NALU Fill data"), &data.DumpNaluFill)); + } + +diff -a -U 2 -r a/recorder.c b/recorder.c +--- a/recorder.c ++++ b/recorder.c +@@ -195,4 +195,12 @@ + } + frameDetector = new cFrameDetector(Pid, Type); ++ if ( Type == 0x1B // MPEG4 video ++ && (Setup.DumpNaluFill ? (strstr(FileName, "NALUKEEP") == NULL) : (strstr(FileName, "NALUDUMP") != NULL))) { // MPEG4 ++ isyslog("Starting NALU fill dumper"); ++ naluStreamProcessor = new cNaluStreamProcessor(); ++ naluStreamProcessor->SetPid(Pid); ++ } ++ else ++ naluStreamProcessor = NULL; + index = NULL; + fileSize = 0; +@@ -217,4 +225,10 @@ + { + Detach(); ++ if (naluStreamProcessor) { ++ long long int TotalPackets = naluStreamProcessor->GetTotalPackets(); ++ long long int DroppedPackets = naluStreamProcessor->GetDroppedPackets(); ++ isyslog("NALU fill dumper: %lld of %lld packets dropped, %lli%%", DroppedPackets, TotalPackets, TotalPackets ? DroppedPackets*100/TotalPackets : 0); ++ delete naluStreamProcessor; ++ } + delete index; + delete fileName; +@@ -357,10 +371,32 @@ + t.Set(MAXBROKENTIMEOUT); + } +- if (recordFile->Write(b, Count) < 0) { +- LOG_ERROR_STR(fileName->Name()); +- break; ++ if (naluStreamProcessor) { ++ naluStreamProcessor->PutBuffer(b, Count); ++ bool Fail = false; ++ while (true) { ++ int OutLength = 0; ++ uchar *OutData = naluStreamProcessor->GetBuffer(OutLength); ++ if (!OutData || OutLength <= 0) ++ break; ++ if (recordFile->Write(OutData, OutLength) < 0) { ++ LOG_ERROR_STR(fileName->Name()); ++ Fail = true; ++ break; ++ } ++ HandleErrors(); ++ fileSize += OutLength; ++ } ++ if (Fail) ++ break; ++ } ++ else { ++ if (recordFile->Write(b, Count) < 0) { ++ LOG_ERROR_STR(fileName->Name()); ++ break; ++ } ++ HandleErrors(); ++ fileSize += Count; + } +- HandleErrors(); +- fileSize += Count; ++ + } + } +diff -a -U 2 -r a/recorder.h b/recorder.h +--- a/recorder.h ++++ b/recorder.h C2022-01-08 17:51:00.397595525 +0100 +@@ -27,4 +27,5 @@ + cFrameDetector *frameDetector; + cPatPmtGenerator patPmtGenerator; ++ cNaluStreamProcessor *naluStreamProcessor; + cFileName *fileName; + cRecordingInfo *recordingInfo; +diff -a -U 2 -r a/remux.c b/remux.c +--- a/remux.c ++++ b/remux.c +@@ -357,4 +357,40 @@ + } + ++void TsExtendAdaptionField(unsigned char *Packet, int ToLength) ++{ ++ // Hint: ExtenAdaptionField(p, TsPayloadOffset(p) - 4) is a null operation ++ ++ int Offset = TsPayloadOffset(Packet); // First byte after existing adaption field ++ ++ if (ToLength <= 0) ++ { ++ // Remove adaption field ++ Packet[3] = Packet[3] & ~TS_ADAPT_FIELD_EXISTS; ++ return; ++ } ++ ++ // Set adaption field present ++ Packet[3] = Packet[3] | TS_ADAPT_FIELD_EXISTS; ++ ++ // Set new length of adaption field: ++ Packet[4] = ToLength <= TS_SIZE-4 ? ToLength-1 : TS_SIZE-4-1; ++ ++ if (Packet[4] == TS_SIZE-4-1) ++ { ++ // No more payload, remove payload flag ++ Packet[3] = Packet[3] & ~TS_PAYLOAD_EXISTS; ++ } ++ ++ int NewPayload = TsPayloadOffset(Packet); // First byte after new adaption field ++ ++ // Fill new adaption field ++ if (Offset == 4 && Offset < NewPayload) ++ Offset++; // skip adaptation_field_length ++ if (Offset == 5 && Offset < NewPayload) ++ Packet[Offset++] = 0; // various flags set to 0 ++ while (Offset < NewPayload) ++ Packet[Offset++] = 0xff; // stuffing byte ++} ++ + // --- cPatPmtGenerator ------------------------------------------------------ + +@@ -1765,2 +1801,343 @@ + return Processed; + } ++ ++// --- cNaluDumper --------------------------------------------------------- ++ ++cNaluDumper::cNaluDumper() ++{ ++ LastContinuityOutput = -1; ++ reset(); ++} ++ ++void cNaluDumper::reset() ++{ ++ LastContinuityInput = -1; ++ ContinuityOffset = 0; ++ PesId = -1; ++ PesOffset = 0; ++ NaluFillState = NALU_NONE; ++ NaluOffset = 0; ++ History = 0xffffffff; ++ DropAllPayload = false; ++} ++ ++void cNaluDumper::ProcessPayload(unsigned char *Payload, int size, bool PayloadStart, sPayloadInfo &Info) ++{ ++ Info.DropPayloadStartBytes = 0; ++ Info.DropPayloadEndBytes = 0; ++ int LastKeepByte = -1; ++ ++ if (PayloadStart) ++ { ++ History = 0xffffffff; ++ PesId = -1; ++ NaluFillState = NALU_NONE; ++ } ++ ++ for (int i=0; i= 0x00000180 && History <= 0x000001FF) ++ { ++ // Start of PES packet ++ PesId = History & 0xff; ++ PesOffset = 0; ++ NaluFillState = NALU_NONE; ++ } ++ else if (PesId >= 0xe0 && PesId <= 0xef // video stream ++ && History >= 0x00000100 && History <= 0x0000017F) // NALU start code ++ { ++ int NaluId = History & 0xff; ++ NaluOffset = 0; ++ NaluFillState = ((NaluId & 0x1f) == 0x0c) ? NALU_FILL : NALU_NONE; ++ } ++ ++ if (PesId >= 0xe0 && PesId <= 0xef // video stream ++ && PesOffset >= 1 && PesOffset <= 2) ++ { ++ Payload[i] = 0; // Zero out PES length field ++ } ++ ++ if (NaluFillState == NALU_FILL && NaluOffset > 0) // Within NALU fill data ++ { ++ // We expect a series of 0xff bytes terminated by a single 0x80 byte. ++ ++ if (Payload[i] == 0xFF) ++ { ++ DropByte = true; ++ } ++ else if (Payload[i] == 0x80) ++ { ++ NaluFillState = NALU_TERM; // Last byte of NALU fill, next byte sets NaluFillEnd=true ++ DropByte = true; ++ } ++ else // Invalid NALU fill ++ { ++ dsyslog("cNaluDumper: Unexpected NALU fill data: %02x", Payload[i]); ++ NaluFillState = NALU_END; ++ if (LastKeepByte == -1) ++ { ++ // Nalu fill from beginning of packet until last byte ++ // packet start needs to be dropped ++ Info.DropPayloadStartBytes = i; ++ } ++ } ++ } ++ else if (NaluFillState == NALU_TERM) // Within NALU fill data ++ { ++ // We are after the terminating 0x80 byte ++ NaluFillState = NALU_END; ++ if (LastKeepByte == -1) ++ { ++ // Nalu fill from beginning of packet until last byte ++ // packet start needs to be dropped ++ Info.DropPayloadStartBytes = i; ++ } ++ } ++ ++ if (!DropByte) ++ LastKeepByte = i; // Last useful byte ++ } ++ ++ Info.DropAllPayloadBytes = (LastKeepByte == -1); ++ Info.DropPayloadEndBytes = size-1-LastKeepByte; ++} ++ ++bool cNaluDumper::ProcessTSPacket(unsigned char *Packet) ++{ ++ bool HasAdaption = TsHasAdaptationField(Packet); ++ bool HasPayload = TsHasPayload(Packet); ++ ++ // Check continuity: ++ int ContinuityInput = TsContinuityCounter(Packet); ++ if (LastContinuityInput >= 0) ++ { ++ int NewContinuityInput = HasPayload ? (LastContinuityInput + 1) & TS_CONT_CNT_MASK : LastContinuityInput; ++ int Offset = (NewContinuityInput - ContinuityInput) & TS_CONT_CNT_MASK; ++ if (Offset > 0) ++ dsyslog("cNaluDumper: TS continuity offset %i", Offset); ++ if (Offset > ContinuityOffset) ++ ContinuityOffset = Offset; // max if packets get dropped, otherwise always the current one. ++ } ++ LastContinuityInput = ContinuityInput; ++ ++ if (HasPayload) { ++ sPayloadInfo Info; ++ int Offset = TsPayloadOffset(Packet); ++ ProcessPayload(Packet + Offset, TS_SIZE - Offset, TsPayloadStart(Packet), Info); ++ ++ if (DropAllPayload && !Info.DropAllPayloadBytes) ++ { ++ // Return from drop packet mode to normal mode ++ DropAllPayload = false; ++ ++ // Does the packet start with some remaining NALU fill data? ++ if (Info.DropPayloadStartBytes > 0) ++ { ++ // Add these bytes as stuffing to the adaption field. ++ ++ // Sample payload layout: ++ // FF FF FF FF FF 80 00 00 01 xx xx xx xx ++ // ^DropPayloadStartBytes ++ ++ TsExtendAdaptionField(Packet, Offset - 4 + Info.DropPayloadStartBytes); ++ } ++ } ++ ++ bool DropThisPayload = DropAllPayload; ++ ++ if (!DropAllPayload && Info.DropPayloadEndBytes > 0) // Payload ends with 0xff NALU Fill ++ { ++ // Last packet of useful data ++ // Do early termination of NALU fill data ++ Packet[TS_SIZE-1] = 0x80; ++ DropAllPayload = true; ++ // Drop all packets AFTER this one ++ ++ // Since we already wrote the 0x80, we have to make sure that ++ // as soon as we stop dropping packets, any beginning NALU fill of next ++ // packet gets dumped. (see DropPayloadStartBytes above) ++ } ++ ++ if (DropThisPayload && HasAdaption) ++ { ++ // Drop payload data, but keep adaption field data ++ TsExtendAdaptionField(Packet, TS_SIZE-4); ++ DropThisPayload = false; ++ } ++ ++ if (DropThisPayload) ++ { ++ return true; // Drop packet ++ } ++ } ++ ++ // Fix Continuity Counter and reproduce incoming offsets: ++ int NewContinuityOutput = TsHasPayload(Packet) ? (LastContinuityOutput + 1) & TS_CONT_CNT_MASK : LastContinuityOutput; ++ NewContinuityOutput = (NewContinuityOutput + ContinuityOffset) & TS_CONT_CNT_MASK; ++ TsSetContinuityCounter(Packet, NewContinuityOutput); ++ LastContinuityOutput = NewContinuityOutput; ++ ContinuityOffset = 0; ++ ++ return false; // Keep packet ++} ++ ++// --- cNaluStreamProcessor --------------------------------------------------------- ++ ++cNaluStreamProcessor::cNaluStreamProcessor() ++{ ++ pPatPmtParser = NULL; ++ vpid = -1; ++ data = NULL; ++ length = 0; ++ tempLength = 0; ++ tempLengthAtEnd = false; ++ TotalPackets = 0; ++ DroppedPackets = 0; ++} ++ ++void cNaluStreamProcessor::PutBuffer(uchar *Data, int Length) ++{ ++ if (length > 0) ++ esyslog("cNaluStreamProcessor::PutBuffer: New data before old data was processed!"); ++ ++ data = Data; ++ length = Length; ++} ++ ++uchar* cNaluStreamProcessor::GetBuffer(int &OutLength) ++{ ++ if (length <= 0) ++ { ++ // Need more data - quick exit ++ OutLength = 0; ++ return NULL; ++ } ++ if (tempLength > 0) // Data in temp buffer? ++ { ++ if (tempLengthAtEnd) // Data is at end, copy to beginning ++ { ++ // Overlapping src and dst! ++ for (int i=0; i 0) ++ { ++ int Size = min(TS_SIZE-tempLength, length); ++ memcpy(tempBuffer+tempLength, data, Size); ++ data += Size; ++ length -= Size; ++ tempLength += Size; ++ } ++ if (tempLength < TS_SIZE) ++ { ++ // All incoming data buffered, but need more data ++ tempLengthAtEnd = false; ++ OutLength = 0; ++ return NULL; ++ } ++ // Now: TempLength==TS_SIZE ++ if (tempBuffer[0] != TS_SYNC_BYTE) ++ { ++ // Need to sync on TS within temp buffer ++ int Skipped = 1; ++ while (Skipped < TS_SIZE && (tempBuffer[Skipped] != TS_SYNC_BYTE || (Skipped < length && data[Skipped] != TS_SYNC_BYTE))) ++ Skipped++; ++ esyslog("ERROR: skipped %d bytes to sync on start of TS packet", Skipped); ++ // Pass through skipped bytes ++ tempLengthAtEnd = true; ++ tempLength = TS_SIZE - Skipped; // may be 0, thats ok ++ OutLength = Skipped; ++ return tempBuffer; ++ } ++ // Now: TempBuffer is a TS packet ++ int Pid = TsPid(tempBuffer); ++ if (pPatPmtParser) ++ { ++ if (Pid == 0) ++ pPatPmtParser->ParsePat(tempBuffer, TS_SIZE); ++ else if (pPatPmtParser->IsPmtPid(Pid)) ++ pPatPmtParser->ParsePmt(tempBuffer, TS_SIZE); ++ } ++ ++ TotalPackets++; ++ bool Drop = false; ++ if (Pid == vpid || (pPatPmtParser && Pid == pPatPmtParser->Vpid() && pPatPmtParser->Vtype() == 0x1B)) ++ Drop = NaluDumper.ProcessTSPacket(tempBuffer); ++ if (!Drop) ++ { ++ // Keep this packet, then continue with new data ++ tempLength = 0; ++ OutLength = TS_SIZE; ++ return tempBuffer; ++ } ++ // Drop TempBuffer ++ DroppedPackets++; ++ tempLength = 0; ++ } ++ // Now: TempLength==0, just process data/length ++ ++ // Pointer to processed data / length: ++ uchar *Out = data; ++ uchar *OutEnd = Out; ++ ++ while (length >= TS_SIZE) ++ { ++ if (data[0] != TS_SYNC_BYTE) { ++ int Skipped = 1; ++ while (Skipped < length && (data[Skipped] != TS_SYNC_BYTE || (length - Skipped > TS_SIZE && data[Skipped + TS_SIZE] != TS_SYNC_BYTE))) ++ Skipped++; ++ esyslog("ERROR: skipped %d bytes to sync on start of TS packet", Skipped); ++ ++ // Pass through skipped bytes ++ if (OutEnd != data) ++ memcpy(OutEnd, data, Skipped); ++ OutEnd += Skipped; ++ continue; ++ } ++ // Now: Data starts with complete TS packet ++ ++ int Pid = TsPid(data); ++ if (pPatPmtParser) ++ { ++ if (Pid == 0) ++ pPatPmtParser->ParsePat(data, TS_SIZE); ++ else if (pPatPmtParser->IsPmtPid(Pid)) ++ pPatPmtParser->ParsePmt(data, TS_SIZE); ++ } ++ ++ TotalPackets++; ++ bool Drop = false; ++ if (Pid == vpid || (pPatPmtParser && Pid == pPatPmtParser->Vpid() && pPatPmtParser->Vtype() == 0x1B)) ++ Drop = NaluDumper.ProcessTSPacket(data); ++ if (!Drop) ++ { ++ if (OutEnd != data) ++ memcpy(OutEnd, data, TS_SIZE); ++ OutEnd += TS_SIZE; ++ } ++ else ++ { ++ DroppedPackets++; ++ } ++ data += TS_SIZE; ++ length -= TS_SIZE; ++ } ++ // Now: Less than a packet remains. ++ if (length > 0) ++ { ++ // copy remains into temp buffer ++ memcpy(tempBuffer, data, length); ++ tempLength = length; ++ tempLengthAtEnd = false; ++ length = 0; ++ } ++ OutLength = (OutEnd - Out); ++ return OutLength > 0 ? Out : NULL; ++} +diff -a -U 2 -r a/remux.h b/remux.h +--- a/remux.h ++++ b/remux.h +@@ -65,4 +65,9 @@ + } + ++inline bool TsSetPayload(const uchar *p) ++{ ++ return p[3] & TS_PAYLOAD_EXISTS; ++} ++ + inline bool TsHasAdaptationField(const uchar *p) + { +@@ -156,4 +161,5 @@ + void TsSetPts(uchar *p, int l, int64_t Pts); + void TsSetDts(uchar *p, int l, int64_t Dts); ++void TsExtendAdaptionField(unsigned char *Packet, int ToLength); + + // Some PES handling tools: +@@ -550,3 +556,77 @@ + }; + ++ ++#define PATCH_NALUDUMP 100 ++ ++class cNaluDumper { ++ unsigned int History; ++ ++ int LastContinuityInput; ++ int LastContinuityOutput; ++ int ContinuityOffset; ++ ++ bool DropAllPayload; ++ ++ int PesId; ++ int PesOffset; ++ ++ int NaluOffset; ++ ++ enum eNaluFillState { ++ NALU_NONE=0, // currently not NALU fill stream ++ NALU_FILL, // Within NALU fill stream, 0xff bytes and NALU start code in byte 0 ++ NALU_TERM, // Within NALU fill stream, read 0x80 terminating byte ++ NALU_END // Beyond end of NALU fill stream, expecting 0x00 0x00 0x01 now ++ }; ++ ++ eNaluFillState NaluFillState; ++ ++ struct sPayloadInfo { ++ int DropPayloadStartBytes; ++ int DropPayloadEndBytes; ++ bool DropAllPayloadBytes; ++ }; ++ ++public: ++ cNaluDumper(); ++ ++ void reset(); ++ ++ // Single packet interface: ++ bool ProcessTSPacket(unsigned char *Packet); ++ ++private: ++ void ProcessPayload(unsigned char *Payload, int size, bool PayloadStart, sPayloadInfo &Info); ++}; ++ ++class cNaluStreamProcessor { ++ //Buffer stream interface: ++ int vpid; ++ uchar *data; ++ int length; ++ uchar tempBuffer[TS_SIZE]; ++ int tempLength; ++ bool tempLengthAtEnd; ++ cPatPmtParser *pPatPmtParser; ++ cNaluDumper NaluDumper; ++ ++ long long int TotalPackets; ++ long long int DroppedPackets; ++public: ++ cNaluStreamProcessor(); ++ ++ void SetPid(int VPid) { vpid = VPid; } ++ void SetPatPmtParser(cPatPmtParser *_pPatPmtParser) { pPatPmtParser = _pPatPmtParser; } ++ // Set either a PID or set a pointer to an PatPmtParser that will detect _one_ PID ++ ++ void PutBuffer(uchar *Data, int Length); ++ // Add new data to be processed. Data must be valid until Get() returns NULL. ++ uchar* GetBuffer(int &OutLength); ++ // Returns filtered data, or NULL/0 to indicate that all data from Put() was processed ++ // or buffered. ++ ++ long long int GetTotalPackets() { return TotalPackets; } ++ long long int GetDroppedPackets() { return DroppedPackets; } ++}; ++ + #endif // __REMUX_H diff --git a/media-video/vdr/files/vdr-2.6.1_pinplugin.patch b/media-video/vdr/files/vdr-2.6.1_pinplugin.patch new file mode 100644 index 000000000000..2552f9e7109f --- /dev/null +++ b/media-video/vdr/files/vdr-2.6.1_pinplugin.patch @@ -0,0 +1,447 @@ +original vdr-pinplugin_vdr-2.3.1.diff +rebased for media-video/vdr-2.6.1 + +Signed-off-by: Christian Kunkel ( 2021 Feb 12 ) +Reviewed-by: Martin Dummer ( 2022-06-22 ) +diff -Naur a/Makefile b/Makefile +--- a/Makefile 2022-02-02 10:56:43.000000000 +0100 ++++ b/Makefile 2022-06-20 08:08:11.346956148 +0200 +@@ -351,7 +351,7 @@ + clean: + @$(MAKE) --no-print-directory -C $(LSIDIR) clean + @-rm -f $(OBJS) $(DEPFILE) vdr vdr.pc core* *~ +- @-rm -rf $(LOCALEDIR) $(PODIR)/*.mo $(PODIR)/*.pot ++ @-rm -rf $(LOCALEDIR) $(PODIR)/*~ $(PODIR)/*.mo $(PODIR)/*.pot + @-rm -rf include + @-rm -rf srcdoc + CLEAN: clean +diff -Naur a/device.c b/device.c +--- a/device.c 2022-02-02 10:56:43.000000000 +0100 ++++ b/device.c 2022-06-20 08:08:11.346956148 +0200 +@@ -839,6 +839,7 @@ + const cChannel *Channel; + while ((Channel = Channels->GetByNumber(n, Direction)) != NULL) { + // try only channels which are currently available ++ if (!cStatus::MsgChannelProtected(0, Channel)) // PIN PATCH + if (GetDevice(Channel, LIVEPRIORITY, true, true)) + break; + n = Channel->Number() + Direction; +@@ -860,6 +861,12 @@ + + eSetChannelResult cDevice::SetChannel(const cChannel *Channel, bool LiveView) + { ++ // I hope 'LiveView = false' indicates a channel switch for recording, // PIN PATCH ++ // I really don't know, but it works ... // PIN PATCH ++ ++ if (LiveView && cStatus::MsgChannelProtected(this, Channel)) // PIN PATCH ++ return scrNotAvailable; // PIN PATCH ++ + cMutexLock MutexLock(&mutexChannel); // to avoid a race between SVDRP CHAN and HasProgramme() + cStatus::MsgChannelSwitch(this, 0, LiveView); + +diff -Naur a/menu.c b/menu.c +--- a/menu.c 2022-02-02 10:56:43.000000000 +0100 ++++ b/menu.c 2022-06-20 08:08:11.346956148 +0200 +@@ -1035,6 +1035,18 @@ + Add(new cMenuEditBitItem( tr("VPS"), &data.flags, tfVps)); + Add(new cMenuEditIntItem( tr("Priority"), &data.priority, 0, MAXPRIORITY)); + Add(new cMenuEditIntItem( tr("Lifetime"), &data.lifetime, 0, MAXLIFETIME)); ++ ++ // PIN PATCH ++ if (cOsd::pinValid || !data.fskProtection) Add(new cMenuEditBoolItem(tr("Childlock"),&data.fskProtection)); ++ else { ++ char* buf = 0; ++ int res = 0; ++ res = asprintf(&buf, "%s\t%s", tr("Childlock"), data.fskProtection ? tr("yes") : tr("no")); ++ if (res < 0) ; // memory problems :o ++ Add(new cOsdItem(buf)); ++ free(buf); ++ } ++ + Add(file = new cMenuEditStrItem( tr("File"), data.file, sizeof(data.file))); + SetFirstDayItem(); + SetPatternItem(true); +@@ -3130,7 +3142,8 @@ + } + } + } +- if (*Item->Text() && !LastDir) { ++ if (*Item->Text() && !LastDir ++ && (!cStatus::MsgReplayProtected(Item->Recording(), Item->Name(), base, Item->IsDirectory(), true))) { // PIN PATCH + Add(Item); + LastItem = Item; + if (Item->IsDirectory()) +@@ -3201,6 +3214,9 @@ + { + cMenuRecordingItem *ri = (cMenuRecordingItem *)Get(Current()); + if (ri) { ++ if (cStatus::MsgReplayProtected(ri->Recording(), ri->Name(), base, ++ ri->IsDirectory()) == true) // PIN PATCH ++ return osContinue; + if (ri->IsDirectory()) + Open(); + else { +@@ -4506,28 +4522,32 @@ + + // Basic menu items: + +- Add(new cOsdItem(hk(tr("Schedule")), osSchedule)); +- Add(new cOsdItem(hk(tr("Channels")), osChannels)); +- Add(new cOsdItem(hk(tr("Timers")), osTimers)); +- Add(new cOsdItem(hk(tr("Recordings")), osRecordings)); ++ // PIN PATCH ++ if (!cStatus::MsgMenuItemProtected("Schedule", true)) Add(new cOsdItem(hk(tr("Schedule")), osSchedule)); ++ if (!cStatus::MsgMenuItemProtected("Channels", true)) Add(new cOsdItem(hk(tr("Channels")), osChannels)); ++ if (!cStatus::MsgMenuItemProtected("Timers", true)) Add(new cOsdItem(hk(tr("Timers")), osTimers)); ++ if (!cStatus::MsgMenuItemProtected("Recordings", true)) Add(new cOsdItem(hk(tr("Recordings")), osRecordings)); + + // Plugins: + + for (int i = 0; ; i++) { + cPlugin *p = cPluginManager::GetPlugin(i); + if (p) { ++ if (!cStatus::MsgPluginProtected(p, true)) { // PIN PATCH + const char *item = p->MainMenuEntry(); + if (item) + Add(new cMenuPluginItem(hk(item), i)); + } ++ } + else + break; + } + + // More basic menu items: + +- Add(new cOsdItem(hk(tr("Setup")), osSetup)); ++ if (!cStatus::MsgMenuItemProtected("Setup", true)) Add(new cOsdItem(hk(tr("Setup")), osSetup)); // PIN PATCH + if (Commands.Count()) ++ if (!cStatus::MsgMenuItemProtected("Commands", true)) // PIN PATCH + Add(new cOsdItem(hk(tr("Commands")), osCommands)); + + Update(true); +@@ -4600,6 +4620,14 @@ + eOSState state = cOsdMenu::ProcessKey(Key); + HadSubMenu |= HasSubMenu(); + ++ // > PIN PATCH ++ cOsdItem* item = Get(Current()); ++ ++ if (item && item->Text() && state != osContinue && state != osUnknown && state != osBack) ++ if (cStatus::MsgMenuItemProtected(item->Text())) ++ return osContinue; ++ // PIN PATCH < ++ + switch (state) { + case osSchedule: return AddSubMenu(new cMenuSchedule); + case osChannels: return AddSubMenu(new cMenuChannels); +@@ -4624,6 +4652,7 @@ + if (item) { + cPlugin *p = cPluginManager::GetPlugin(item->PluginIndex()); + if (p) { ++ if (!cStatus::MsgPluginProtected(p)) { // PIN PATCH + cOsdObject *menu = p->MainMenuAction(); + if (menu) { + if (menu->IsMenu()) +@@ -4635,6 +4664,7 @@ + } + } + } ++ } + state = osEnd; + } + break; +@@ -4814,6 +4844,7 @@ + Channel = Direction > 0 ? Channels->Next(Channel) : Channels->Prev(Channel); + if (!Channel && Setup.ChannelsWrap) + Channel = Direction > 0 ? Channels->First() : Channels->Last(); ++ if (!cStatus::MsgChannelProtected(0, Channel)) // PIN PATCH + if (Channel && !Channel->GroupSep() && cDevice::GetDevice(Channel, LIVEPRIORITY, true, true)) + return Channel; + } +@@ -5491,6 +5522,7 @@ + for (int i = 0; i < MAXRECORDCONTROLS; i++) { + if (!RecordControls[i]) { + RecordControls[i] = new cRecordControl(device, Timers, Timer, Pause); ++ cStatus::MsgRecordingFile(RecordControls[i]->FileName()); // PIN PATCH + return RecordControls[i]->Process(time(NULL)); + } + } +diff -Naur a/osd.c b/osd.c +--- a/osd.c 2022-02-02 10:56:43.000000000 +0100 ++++ b/osd.c 2022-06-20 08:08:11.346956148 +0200 +@@ -1844,6 +1844,7 @@ + cSize cOsd::maxPixmapSize(INT_MAX, INT_MAX); + cVector cOsd::Osds; + cMutex cOsd::mutex; ++bool cOsd::pinValid = false; // PIN PATCH + + cOsd::cOsd(int Left, int Top, uint Level) + { +diff -Naur a/osd.h b/osd.h +--- a/osd.h 2022-02-02 10:56:43.000000000 +0100 ++++ b/osd.h 2022-06-20 08:08:11.346956148 +0200 +@@ -957,6 +957,7 @@ + ///< + ///< If a plugin uses a derived cPixmap implementation, it needs to use that + ///< type instead of cPixmapMemory. ++ static bool pinValid; // PIN PATCH + }; + + #define MAXOSDIMAGES 64 +diff -Naur a/status.c b/status.c +--- a/status.c 2022-02-02 10:56:43.000000000 +0100 ++++ b/status.c 2022-06-20 08:08:11.346956148 +0200 +@@ -136,3 +136,55 @@ + for (cStatus *sm = statusMonitors.First(); sm; sm = statusMonitors.Next(sm)) + sm->OsdProgramme(PresentTime, PresentTitle, PresentSubtitle, FollowingTime, FollowingTitle, FollowingSubtitle); + } ++ ++bool cStatus::MsgChannelProtected(const cDevice* Device, const cChannel* Channel) // PIN PATCH ++{ ++ for (cStatus *sm = statusMonitors.First(); sm; sm = statusMonitors.Next(sm)) ++ if (sm->ChannelProtected(Device, Channel) == true) ++ return true; ++ ++ return false; ++} ++ ++bool cStatus::MsgReplayProtected(const cRecording* Recording, const char* Name, ++ const char* Base, bool isDirectory, int menuView) // PIN PATCH ++{ ++ for (cStatus *sm = statusMonitors.First(); sm; sm = statusMonitors.Next(sm)) ++ if (sm->ReplayProtected(Recording, Name, Base, isDirectory, menuView) == true) ++ return true; ++ return false; ++} ++ ++void cStatus::MsgRecordingFile(const char* FileName) ++{ ++ for (cStatus *sm = statusMonitors.First(); sm; sm = statusMonitors.Next(sm)) // PIN PATCH ++ sm->RecordingFile(FileName); ++} ++ ++void cStatus::MsgTimerCreation(cTimer* Timer, const cEvent *Event) ++{ ++ for (cStatus *sm = statusMonitors.First(); sm; sm = statusMonitors.Next(sm)) // PIN PATCH ++ sm->TimerCreation(Timer, Event); ++} ++ ++bool cStatus::MsgPluginProtected(cPlugin* Plugin, int menuView) // PIN PATCH ++{ ++ for (cStatus *sm = statusMonitors.First(); sm; sm = statusMonitors.Next(sm)) ++ if (sm->PluginProtected(Plugin, menuView) == true) ++ return true; ++ return false; ++} ++ ++void cStatus::MsgUserAction(const eKeys key) // PIN PATCH ++{ ++ for (cStatus *sm = statusMonitors.First(); sm; sm = statusMonitors.Next(sm)) ++ sm->UserAction(key); ++} ++ ++bool cStatus::MsgMenuItemProtected(const char* Name, int menuView) // PIN PATCH ++{ ++ for (cStatus *sm = statusMonitors.First(); sm; sm = statusMonitors.Next(sm)) ++ if (sm->MenuItemProtected(Name, menuView) == true) ++ return true; ++ return false; ++} +diff -Naur a/status.h b/status.h +--- a/status.h 2022-02-02 10:56:43.000000000 +0100 ++++ b/status.h 2022-06-20 08:08:11.350956230 +0200 +@@ -14,6 +14,7 @@ + #include "device.h" + #include "player.h" + #include "tools.h" ++#include "plugin.h" + + // Several member functions of the following classes are called with a pointer to + // an object from a global list (cTimer, cChannel, cRecording or cEvent). In these +@@ -99,6 +100,22 @@ + // The OSD displays the single line Text with the current channel information. + virtual void OsdProgramme(time_t PresentTime, const char *PresentTitle, const char *PresentSubtitle, time_t FollowingTime, const char *FollowingTitle, const char *FollowingSubtitle) {} + // The OSD displays the given programme information. ++ virtual bool ChannelProtected(const cDevice *Device, const cChannel* Channel) { return false; } // PIN PATCH ++ // Checks if a channel is protected. ++ virtual bool ReplayProtected(const cRecording* Recording, const char* Name, ++ const char* Base, bool isDirectory, int menuView = false) { return false; } // PIN PATCH ++ // Checks if a recording is protected. ++ virtual void RecordingFile(const char* FileName) {} // PIN PATCH ++ // The given DVB device has started recording to FileName. FileName is the name of the ++ // recording directory ++ virtual void TimerCreation(cTimer* Timer, const cEvent *Event) {} // PIN PATCH ++ // The given timer is created ++ virtual bool PluginProtected(cPlugin* Plugin, int menuView = false) { return false; } // PIN PATCH ++ // Checks if a plugin is protected. ++ virtual void UserAction(const eKeys key) {} // PIN PATCH ++ // report user action ++ virtual bool MenuItemProtected(const char* Name, int menuView = false) { return false; } // PIN PATCH ++ + public: + cStatus(void); + virtual ~cStatus(); +@@ -122,6 +139,14 @@ + static void MsgOsdTextItem(const char *Text, bool Scroll = false); + static void MsgOsdChannel(const char *Text); + static void MsgOsdProgramme(time_t PresentTime, const char *PresentTitle, const char *PresentSubtitle, time_t FollowingTime, const char *FollowingTitle, const char *FollowingSubtitle); ++ static bool MsgChannelProtected(const cDevice* Device, const cChannel* Channel); // PIN PATCH ++ static bool MsgReplayProtected(const cRecording* Recording, const char* Name, ++ const char* Base, bool isDirectory, int menuView = false); // PIN PATCH ++ static void MsgRecordingFile(const char* FileName); // PIN PATCH ++ static void MsgTimerCreation(cTimer* Timer, const cEvent *Event); // PIN PATCH ++ static bool MsgPluginProtected(cPlugin* Plugin, int menuView = false); // PIN PATCH ++ static void MsgUserAction(const eKeys key); // PIN PATCH ++ static bool MsgMenuItemProtected(const char* Name, int menuView = false); // PIN PATCH + }; + + #endif //__STATUS_H +diff -Naur a/timers.c b/timers.c +--- a/timers.c 2022-02-02 10:56:43.000000000 +0100 ++++ b/timers.c 2022-06-20 08:14:07.898392829 +0200 +@@ -81,6 +81,7 @@ + stop -= 2400; + priority = Pause ? Setup.PausePriority : Setup.DefaultPriority; + lifetime = Pause ? Setup.PauseLifetime : Setup.DefaultLifetime; ++ fskProtection = 0; // PIN PATCH + if (Instant && channel) + snprintf(file, sizeof(file), "%s%s", Setup.MarkInstantRecord ? "@" : "", *Setup.NameInstantRecord ? Setup.NameInstantRecord : channel->Name()); + } +@@ -212,11 +213,13 @@ + stop -= 2400; + priority = PatternTimer ? PatternTimer->Priority() : Setup.DefaultPriority; + lifetime = PatternTimer ? PatternTimer->Lifetime() : Setup.DefaultLifetime; ++ fskProtection = 0; // PIN PATCH + if (!FileName) + FileName = Event->Title(); + if (!isempty(FileName)) + Utf8Strn0Cpy(file, FileName, sizeof(file)); + SetEvent(Event); ++ cStatus::MsgTimerCreation(this, Event); // PIN PATCH + } + + cTimer::cTimer(const cTimer &Timer) +@@ -255,6 +258,7 @@ + stop = Timer.stop; + priority = Timer.priority; + lifetime = Timer.lifetime; ++ fskProtection = Timer.fskProtection; // PIN PATCH + strncpy(pattern, Timer.pattern, sizeof(pattern)); + strncpy(file, Timer.file, sizeof(file)); + free(aux); +@@ -484,6 +488,7 @@ + result = false; + } + } ++ fskProtection = aux && strstr(aux, "yes"); // PIN PATCH + free(channelbuffer); + free(daybuffer); + free(filebuffer); +@@ -1037,6 +1042,36 @@ + Matches(); // refresh start and end time + } + ++void cTimer::SetFskProtection(int aFlag) // PIN PATCH ++{ ++ char* p; ++ char* tmp = 0; ++ int res = 0; ++ ++ fskProtection = aFlag; ++ ++ if (fskProtection && (!aux || !strstr(aux, "yes"))) ++ { ++ // add protection info to aux ++ ++ if (aux) { tmp = strdup(aux); free(aux); } ++ res = asprintf(&aux, "%syes", tmp ? tmp : ""); ++ } ++ else if (!fskProtection && aux && (p = strstr(aux, "yes"))) ++ { ++ // remove protection info from aux ++ ++ res = asprintf(&tmp, "%.*s%s", (int)(p-aux), aux, p+strlen("yes")); ++ free(aux); ++ aux = strdup(tmp); ++ } ++ ++ if (res < 0) ; // memory problems :o ++ ++ if (tmp) ++ free(tmp); ++} ++ + // --- cTimers --------------------------------------------------------------- + + cTimers cTimers::timers; +diff -Naur a/timers.h b/timers.h +--- a/timers.h 2022-02-02 10:56:43.000000000 +0100 ++++ b/timers.h 2022-06-20 08:08:11.350956230 +0200 +@@ -45,6 +45,7 @@ + int start; ///< the start and stop time of this timer as given by the user, + int stop; ///< in the form hhmm, with hh (00..23) and mm (00..59) added as hh*100+mm + int priority; ++ int fskProtection; // PIN PATCH + int lifetime; + mutable char pattern[NAME_MAX * 2 + 1]; // same size as 'file', to be able to initially fill 'pattern' with 'file' in the 'Edit timer' menu + mutable char file[NAME_MAX * 2 + 1]; // *2 to be able to hold 'title' and 'episode', which can each be up to 255 characters long +@@ -70,6 +71,7 @@ + int Start(void) const { return start; } + int Stop(void) const { return stop; } + int Priority(void) const { return priority; } ++ int FskProtection(void) const { return fskProtection; } // PIN PATCH + int Lifetime(void) const { return lifetime; } + const char *Pattern(void) const { return pattern; } + const char *File(void) const { return file; } +@@ -120,6 +122,7 @@ + void SetRemote(const char *Remote); + void SetDeferred(int Seconds); + void SetFlags(uint Flags); ++ void SetFskProtection(int aFlag); // PIN PATCH + void ClrFlags(uint Flags); + void InvFlags(uint Flags); + bool HasFlags(uint Flags) const; +diff -Naur a/vdr.c b/vdr.c +--- a/vdr.c 2022-02-02 10:56:43.000000000 +0100 ++++ b/vdr.c 2022-06-20 08:08:11.350956230 +0200 +@@ -71,6 +71,7 @@ + #include "tools.h" + #include "transfer.h" + #include "videodir.h" ++#include "status.h" // PIN PATCH + + #define MINCHANNELWAIT 10 // seconds to wait between failed channel switchings + #define ACTIVITYTIMEOUT 60 // seconds before starting housekeeping +@@ -1210,6 +1211,7 @@ + if (!Menu) + Interact = Control = cControl::Control(ControlMutexLock); + if (ISREALKEY(key)) { ++ cStatus::MsgUserAction(key); // PIN PATCH + EITScanner.Activity(); + // Cancel shutdown countdown: + if (ShutdownHandler.countdown) +@@ -1282,10 +1284,12 @@ + Control->Hide(); + cPlugin *plugin = cPluginManager::GetPlugin(PluginName); + if (plugin) { ++ if (!cStatus::MsgPluginProtected(plugin)) { // PIN PATCH + Menu = plugin->MainMenuAction(); + if (Menu) + Menu->Show(); + } ++ } + else + esyslog("ERROR: unknown plugin '%s'", PluginName); + } +@@ -1505,9 +1509,11 @@ + case kPlay: + if (cReplayControl::LastReplayed()) { + Control = NULL; ++ if (cStatus::MsgReplayProtected(0, cReplayControl::LastReplayed(), 0, false) == false) { // PIN PATCH + cControl::Shutdown(); + cControl::Launch(new cReplayControl); + } ++ } + else + DirectMainFunction(osRecordings); // no last viewed recording, so enter the Recordings menu + break; -- cgit v1.2.3