diff options
Diffstat (limited to 'device.c')
| -rw-r--r-- | device.c | 1364 |
1 files changed, 1364 insertions, 0 deletions
diff --git a/device.c b/device.c new file mode 100644 index 00000000..01a25f6e --- /dev/null +++ b/device.c @@ -0,0 +1,1364 @@ +/* + * device.c: xine-lib output device for the Video Disk Recorder + * + * See the main source file 'xineliboutput.c' for copyright information and + * how to reach the author. + * + * $Id: device.c,v 1.1 2006-06-03 10:01:17 phintuka Exp $ + * + */ + +#include <vdr/config.h> +#include <vdr/thread.h> +#include <vdr/dvbspu.h> +#include <vdr/channels.h> +#include <vdr/skins.h> +#include <vdr/status.h> +#include <vdr/remote.h> + +//#define XINELIBOUTPUT_DEBUG +//#define XINELIBOUTPUT_DEBUG_STDOUT +//#define XINELIBOUTPUT_DEBUG_STDERR + +#include "logdefs.h" +#include "config.h" +#include "osd.h" + +#ifdef ENABLE_SUSPEND +# include "tools/timer.h" +# include "tools/timer.c" +# ifdef SUSPEND_BY_PLAYER +# include "dummy_player.h" +# include "dummy_player.c" +# endif +# define ACTIVITY m_inactivityTimer = 0; +#else +# define ACTIVITY +#endif + +#include "tools/listiter.h" +#include "tools/pes.h" + +#include "frontend_local.h" +#include "frontend_svr.h" + +#include "device.h" + +#define STILLPICTURE_REPEAT_COUNT 3 + +//---------------------------- status monitor ------------------------------- + +#define DEBUG_SWITCHING_TIME + +#ifdef DEBUG_SWITCHING_TIME +int64_t switchtimeOff = 0LL; +int64_t switchtimeOn = 0LL; +bool switchingIframe; +#endif + +class cXinelibStatusMonitor : public cStatus +{ + private: + cXinelibStatusMonitor(); + cXinelibStatusMonitor(cXinelibStatusMonitor&); + + public: + cXinelibStatusMonitor(cXinelibDevice& device, int cardIndex) : + m_Device(device), m_cardIndex(cardIndex) {}; + + protected: + virtual void ChannelSwitch(const cDevice *Device, int ChannelNumber); +#if VDRVERSNUM < 10338 + virtual void Replaying(const cControl *Control, const char *Name); +#else + virtual void Replaying(const cControl *Control, const char *Name, + const char *FileName, bool On); +#endif + + cXinelibDevice& m_Device; + int m_cardIndex; +}; + +void cXinelibStatusMonitor::ChannelSwitch(const cDevice *Device, + int ChannelNumber) +{ + TRACEF("cXinelibStatusMonitor::ChannelSwitch"); + + if (ChannelNumber) { + if (Device->CardIndex() == m_cardIndex) { +#ifdef DEBUG_SWITCHING_TIME + switchtimeOn = cTimeMs::Now(); +#endif + m_Device.SetTvMode(Channels.GetByNumber(ChannelNumber)); + TRACE("cXinelibStatusMonitor: Set to TvMode"); + } + } else { + if (Device->CardIndex() == m_cardIndex) { +#ifdef DEBUG_SWITCHING_TIME + switchtimeOff = cTimeMs::Now(); +#endif + m_Device.StopOutput(); + TRACE("cXinelibStatusMonitor: received stop"); + } + } +} + +#if VDRVERSNUM < 10338 +void cXinelibStatusMonitor::Replaying(const cControl *Control, + const char *Name) +{ + TRACEF("cXinelibStatusMonitor::Replaying"); + + if (Name != NULL) { + TRACE("cXinelibStatusMonitor: Replaying " << Name); + m_Device.SetReplayMode(); + } +} +#else +void cXinelibStatusMonitor::Replaying(const cControl *Control, + const char *Name, + const char *FileName, bool On) +{ + TRACEF("cXinelibStatusMonitor::Replaying"); + + if (On /*&& Name != NULL*/) { + TRACE("cXinelibStatusMonitor: Replaying " << Name << "("<<FileName")"); + m_Device.SetReplayMode(); + } +} +#endif + +//----------------------------- device ---------------------------------------- + +#ifdef USENOPPLAYER +class cNopControl : public cControl { +public: + cNopControl() : cControl(new cPlayer()) + { LOGMSG("cNopControl created"); } + ~cNopControl() + { LOGMSG("cNopControl destroyed"); } + virtual void Hide(void) {}; + + static int NopPlayerActivated; +}; + +int cNopControl::NopPlayerActivated = 0; +#endif + +// +// Singleton +// + +cXinelibDevice* cXinelibDevice::m_pInstance = NULL; + +cXinelibDevice& cXinelibDevice::Instance(void) +{ + TRACEF("cXinelibDevice::Instance"); + if (!m_pInstance) { + m_pInstance = new cXinelibDevice(); + TRACE("cXinelibDevice::Instance(): create, cardindex = " + << m_pInstance->CardIndex()); + } + + return *m_pInstance; +} + +void cXinelibDevice::Dispose(void) +{ + TRACEF("cXinelibDevice::Dispose"); + delete m_pInstance; + m_pInstance = NULL; +} + +// +// init and shutdown +// + +cXinelibDevice::cXinelibDevice() +{ + TRACEF("cXinelibDevice::cXinelibDevice"); + + m_statusMonitor = NULL; + m_spuDecoder = NULL; + + m_local = NULL; + m_server = NULL; + + if(*xc.local_frontend && strncmp(xc.local_frontend, "none", 4)) + m_clients.Add(m_local = new cXinelibLocal(xc.local_frontend)); + if(xc.remote_mode && xc.listen_port>0) + m_clients.Add(m_server = new cXinelibServer(xc.listen_port)); + + m_ac3Present = false; + m_spuPresent = false; +#ifdef ENABLE_SUSPEND + m_suspended = false; + ACTIVITY +#endif + m_liveMode = false; + m_TrickSpeed = -1; + m_SkipAudio = false; + m_PlayingFile = false; + m_StreamStart = true; + m_RadioStream = false; + m_AudioCount = 0; +} + +cXinelibDevice::~cXinelibDevice() +{ + TRACEF("cXinelibDevice::~cXinelibDevice"); + + StopDevice(); + + m_pInstance = NULL; +} + +bool cXinelibDevice::StartDevice() +{ + TRACEF("cXinelibDevice::StartDevice"); + + // if(dynamic_cast<cXinelibLocal*>(it)) + if(m_local) { + m_local->Start(); + while(!m_local->IsReady()) { + cCondWait::SleepMs(100); + if(m_local->IsFinished()) { + LOGMSG("cXinelibDevice::Start(): Local frontend init failed"); + return false; + } + } + if(xc.force_primary_device) + ForcePrimaryDevice(true); + } + + if(m_server) { + m_server->Start(); + while(!m_server->IsReady()) { + cCondWait::SleepMs(100); + if(m_server->IsFinished()) { + LOGMSG("cXinelibDevice::Start(): Server init failed"); + return false; + } + } + } + +#ifdef ENABLE_SUSPEND + m_suspended = false; + ACTIVITY +#endif + + m_statusMonitor = new cXinelibStatusMonitor(*this, CardIndex()); + +#ifdef ENABLE_SUSPEND + CreateTimerEvent(this, &cXinelibDevice::CheckInactivityTimer, 60*1000, false); +#endif + +#ifdef USENOPPLAYER + if(!m_local) { + LOGMSG("No clients, activating cNopControl"); + cControl::Launch(new cNopControl); + cNopControl::NopPlayerActivated = true; + } +#endif + + LOGDBG("cXinelibDevice::StartDevice(): Device started"); + return true; +} + +void cXinelibDevice::StopDevice(void) +{ + TRACEF("cXinelibDevice::StopDevice"); + LOGDBG("cXinelibDevice::StopDevice(): Stopping device ..."); +#ifdef ENABLE_SUSPEND + CancelTimerEvents(this); +#endif + if(m_statusMonitor) { + delete m_statusMonitor; + m_statusMonitor = NULL; + } + if (m_spuDecoder) { + delete m_spuDecoder; + m_spuDecoder = NULL; + } + + ForEach(m_clients, &cXinelibThread::SetLiveMode, false); + TrickSpeed(-1); + ForEach(m_clients, &cXinelibThread::Stop); + + m_local = m_server = NULL; + m_clients.Clear(); +} + +void cXinelibDevice::MakePrimaryDevice(bool On) +{ + TRACEF("cXinelibDevice::MakePrimaryDevice"); + if(On) + new cXinelibOsdProvider(this); +} + +void cXinelibDevice::ForcePrimaryDevice(bool On) +{ + static int Original = 0; + static int Counter = 0; + + TRACEF("cXinelibDevice::ForcePrimaryDevice"); + + if(On) { + Counter++; +#ifdef USENOPPLAYER + if(cNopControl::NopPlayerActivated) { + LOGMSG("First client, stopping cNopControl"); + cControl::Shutdown(); + cNopControl::NopPlayerActivated = false; + } +#endif + if(xc.force_primary_device) { + if(cDevice::PrimaryDevice() && this != cDevice::PrimaryDevice()) { + /* TODO: may need to use vdr main thread for this */ + Original = cDevice::PrimaryDevice()->DeviceNumber() + 1; + cControl::Shutdown(); + LOGMSG("Forcing primary device, original index = %d", Original); + if(cOsd::IsOpen()) { + LOGMSG("Forcing primary device, old OSD still open !"); +#if VDRVERSNUM >= 10400 + xc.main_menu_mode = CloseOsd; + cRemote::CallPlugin("xineliboutput"); +#endif + } + SetPrimaryDevice(DeviceNumber() + 1); + } + } + + } else /* Off */ { + Counter--; + if(Counter<0) + LOGMSG("Internal error (ForcePrimaryDevice < 0)"); + if(!Counter) { + if(Original) { + LOGMSG("Restoring original primary device %d", Original); + cControl::Shutdown(); + if(cOsd::IsOpen()) { + LOGMSG("Restoring primary device, xineliboutput OSD still open !"); +#if VDRVERSNUM >= 10400 + xc.main_menu_mode = CloseOsd; + cRemote::CallPlugin("xineliboutput"); +#endif + } + cDevice::SetPrimaryDevice(Original); + Original = 0; + } +#ifdef USENOPPLAYER + if(!m_local && !cControl::Control()) { + LOGMSG("No clients, activating cNopControl"); + cControl::Launch(new cNopControl); + cNopControl::NopPlayerActivated = true; + } +#endif + } + } +} + + +// +// Configuration +// + +void cXinelibDevice::ConfigureOSD(bool prescale_osd, bool unscaled_osd) +{ + TRACEF("cXinelibDevice::ConfigureOSD"); + + ACTIVITY + if(m_local) + m_local->ConfigureOSD(prescale_osd, unscaled_osd); + if(m_server) + m_server->ConfigureOSD(prescale_osd, unscaled_osd); +} + +void cXinelibDevice::ConfigurePostprocessing(char *deinterlace_method, int audio_delay, int audio_compression, int *audio_equalizer, int audio_surround) +{ + TRACEF("cXinelibDevice::ConfigurePostprocessing"); + + ACTIVITY + if(m_local) + m_local->ConfigurePostprocessing(deinterlace_method, audio_delay, + audio_compression, audio_equalizer, + audio_surround); + if(m_server) + m_server->ConfigurePostprocessing(deinterlace_method, audio_delay, + audio_compression, audio_equalizer, + audio_surround); +} + +void cXinelibDevice::ConfigurePostprocessing(char *name, bool on, char *args) +{ + TRACEF("cXinelibDevice::ConfigurePostprocessing"); + + ACTIVITY + if(m_local) + m_local->ConfigurePostprocessing(name, on, args); + if(m_server) + m_server->ConfigurePostprocessing(name, on, args); +} + +void cXinelibDevice::ConfigureVideo(int hue, int saturation, int brightness, int contrast) +{ + TRACEF("cXinelibDevice::ConfigureVideo"); + + ACTIVITY + if(m_local) + m_local->ConfigureVideo(hue, saturation, brightness, contrast); + if(m_server) + m_server->ConfigureVideo(hue, saturation, brightness, contrast); +} + +void cXinelibDevice::ConfigureDecoder(int pes_buffers, int priority) +{ + TRACEF("cXinelibDevice::ConfigureDecoder"); + + ACTIVITY + if(m_local) + m_local->ConfigureDecoder(pes_buffers, priority); + //if(m_server) + // m_server->ConfigureDecoder(pes_buffers, priority); + + cXinelibOsdProvider::RefreshOsd(); +} + +void cXinelibDevice::ConfigureWindow(int fullscreen, int width, int height, + int modeswitch, char *modeline, + int aspect, int scale_video, int field_order) +{ + TRACEF("cXinelibDevice::ConfigureWindow"); + + ACTIVITY + if((!*xc.local_frontend || !strncmp(xc.local_frontend, "none", 4)) && m_local) { + cXinelibThread *tmp = m_local; + m_clients.Del(tmp, false); + m_local = NULL; + cCondWait::SleepMs(5); + tmp->Stop(); + cCondWait::SleepMs(5); + delete tmp; + if(xc.force_primary_device) + ForcePrimaryDevice(false); + } + if(m_local) + m_local->ConfigureWindow(fullscreen, width, height, modeswitch, modeline, + aspect, scale_video, field_order); + else if(*xc.local_frontend && strncmp(xc.local_frontend, "none", 4)) { + cXinelibThread *tmp = new cXinelibLocal(xc.local_frontend); + tmp->Start(); + m_clients.Add(m_local = tmp); + + cCondWait::SleepMs(25); + while(!m_local->IsReady() && !m_local->IsFinished()) + cCondWait::SleepMs(25); + + if(m_local->IsFinished()) { + m_local = NULL; + m_clients.Del(tmp, true); + Skins.QueueMessage(mtError, tr("Frontend initialization failed"), 10); + } else { + if(xc.force_primary_device) + ForcePrimaryDevice(true); + + m_local->ConfigureWindow(fullscreen, width, height, modeswitch, modeline, + aspect, scale_video, field_order); + } + } +} + +void cXinelibDevice::Listen(bool activate, int port) +{ + TRACEF("cXinelibDevice::Listen"); + + ACTIVITY + if(activate && port>0) { + if(!m_server) { + cXinelibThread *tmp = new cXinelibServer(port); + tmp->Start(); + m_clients.Add(m_server = tmp); + + cCondWait::SleepMs(10); + while(!m_server->IsReady() && !m_server->IsFinished()) + cCondWait::SleepMs(10); + + if(m_server->IsFinished()) { + Skins.QueueMessage(mtError, tr("Server initialization failed"), 10); + m_server = NULL; + m_clients.Del(tmp, true); + } + + } else { + if(! m_server->Listen(port)) + Skins.QueueMessage(mtError, tr("Server initialization failed"), 10); + } + } else if( /*((!activate) || port<=0) && */ m_server) { + cXinelibThread *tmp = m_server; + m_clients.Del(tmp, false); + m_server = NULL; + cCondWait::SleepMs(5); + tmp->Stop(); + cCondWait::SleepMs(5); + delete tmp; + } +} + +// +// OSD +// + +void cXinelibDevice::OsdCmd(void *cmd) +{ + TRACEF("cXinelibDevice::OsdCmd"); + + ACTIVITY + if(m_server) // call first server, local frontend modifies contents of the message ... + m_server->OsdCmd(cmd); + if(m_local) + m_local->OsdCmd(cmd); +} + +// +// Play mode control +// + +void cXinelibDevice::StopOutput(void) +{ + TRACEF("cXinelibDevice::StopOutput"); + + ACTIVITY + m_RadioStream = false; + m_AudioCount = 0; + + ForEach(m_clients, &cXinelibThread::SetLiveMode, false); + Clear(); + ForEach(m_clients, &cXinelibThread::QueueBlankDisplay); + ForEach(m_clients, &cXinelibThread::SetNoVideo, false); +} + +void cXinelibDevice::SetTvMode(cChannel *Channel) +{ + TRACEF("cXinelibDevice::SetTvMode"); + + m_RadioStream = false; + if (Channel && !Channel->Vpid() && (Channel->Apid(0) || Channel->Apid(1))) + m_RadioStream = true; + if(/*playMode==pmAudioOnly||*/playMode==pmAudioOnlyBlack) + m_RadioStream = true; + TRACE("cXinelibDevice::SetTvMode - isRadio = "<<m_RadioStream); + + m_StreamStart = true; + m_liveMode = true; + ACTIVITY + m_TrickSpeed = -1; + m_SkipAudio = false; + m_AudioCount = 0; + + Clear(); + ForEach(m_clients, &cXinelibThread::SetNoVideo, m_RadioStream); + ForEach(m_clients, &cXinelibThread::SetLiveMode, true); + ForEach(m_clients, &cXinelibThread::QueueBlankDisplay); + ForEach(m_clients, &cXinelibThread::ResumeOutput); +} + +void cXinelibDevice::SetReplayMode(void) +{ + TRACEF("cXinelibDevice::SetReplayMode"); + + //m_RadioStream = false; +#if 1 + //m_RadioStream = (playMode==pmAudioOnly || playMode==pmAudioOnlyBlack); + //TRACE("cXinelibDevice::SetReplayMode - isRadio = "<<m_RadioStream); + m_RadioStream = true; // first seen replayed video packet resets this + m_AudioCount = 15; +#endif + + ForEach(m_clients, &cXinelibThread::SetLiveMode, false); + TrickSpeed(-1); + ForEach(m_clients, &cXinelibThread::Clear); + ForEach(m_clients, &cXinelibThread::SetNoVideo, false /*m_RadioStream*/); + if(m_RadioStream && !m_liveMode) + ForEach(m_clients, &cXinelibThread::BlankDisplay); + ForEach(m_clients, &cXinelibThread::ResumeOutput); + + m_liveMode = false; + ACTIVITY +} + +bool cXinelibDevice::SetPlayMode(ePlayMode PlayMode) +{ + TRACEF("cXinelibDevice::SetPlayMode"); + + ACTIVITY + +#ifdef XINELIBOUTPUT_DEBUG + switch (PlayMode) { + case pmNone: + TRACE("cXinelibDevice::SetPlayMode audio/video from decoder"); break; + case pmAudioVideo: + TRACE("cXinelibDevice::SetPlayMode audio/video from player"); break; + case pmVideoOnly: + TRACE("cXinelibDevice::SetPlayMode video from player, audio from decoder"); break; + case pmAudioOnly: + TRACE("cXinelibDevice::SetPlayMode audio from player, video from decoder"); break; + case pmAudioOnlyBlack: + TRACE("cXinelibDevice::SetPlayMode audio only from player, no video (black screen)"); break; + case pmExtern_THIS_SHOULD_BE_AVOIDED: + TRACE("cXinelibDevice::SetPlayMode this should be avoided"); break; + } +#endif + + m_ac3Present = false; + m_spuPresent = false; + playMode = PlayMode; + + TrickSpeed(-1); + if (playMode == pmAudioOnlyBlack /*|| playMode == pmNone*/) { + TRACE("pmAudioOnlyBlack --> BlankDisplay, NoVideo"); + ForEach(m_clients, &cXinelibThread::BlankDisplay); + ForEach(m_clients, &cXinelibThread::SetNoVideo, true); + } + + return true; +} + +// +// Playback control +// + +void cXinelibDevice::TrickSpeed(int Speed) +{ + TRACEF("cXinelibDevice::TrickSpeed"); + + int RealSpeed = abs(Speed); + ACTIVITY + m_TrickSpeed = Speed; + m_TrickSpeedPts = 0; + + ForEach(m_clients, &cXinelibThread::TrickSpeed, RealSpeed); +} + +void cXinelibDevice::Clear(void) +{ + TRACEF("cXinelibDevice::Clear"); + m_StreamStart = 1; + TrickSpeed(-1); + ForEach(m_clients, &cXinelibThread::Clear); +} + +void cXinelibDevice::Play(void) +{ + TRACEF("cXinelibDevice::Play"); + + ACTIVITY + m_SkipAudio = false; + + ForEach(m_clients, &cXinelibThread::SetLiveMode, false); + TrickSpeed(-1); +} + +void cXinelibDevice::Freeze(void) +{ + TRACEF("cXinelibDevice::Freeze"); + + ACTIVITY + + TrickSpeed(0); +} + +// +// Suspend device, inactivity timer +// +#ifdef ENABLE_SUSPEND +void cXinelibDevice::CheckInactivityTimer() +{ + TRACEF("cXinelibDevice::CheckInactivityTimer"); + + Lock(); + + if(xc.inactivity_timer>0) { + int old_Timer = m_inactivityTimer++; + TRACE("cXinelibDevice::CheckInactivityTimer @" << time(NULL)); + TRACE("cXinelibDevice::CheckInactivityTimer: m_inactivityTimer = " << m_inactivityTimer); + + if(old_Timer<=xc.inactivity_timer && m_inactivityTimer>xc.inactivity_timer) { + SuspendedAction(); + Unlock(); +# ifndef SUSPEND_BY_PLAYER + CreateTimerEvent(this, &cXinelibDevice::SuspendedAction, 5000); +# endif + return; + } + } + Unlock(); +} + +bool cXinelibDevice::SuspendedAction(void) +{ + TRACEF("cXinelibDevice::SuspendedAction"); + + LOCK_THREAD; + if(m_suspended || (xc.inactivity_timer>0 && m_inactivityTimer>xc.inactivity_timer)) { + if(m_liveMode) { +# ifndef SUSPEND_BY_PLAYER + TRACE("cXinelibDevice::SuspendedAction - DECODER SUSPENDED"); + ForEach(m_clients, &cXinelibThread::SetLiveMode, false); + ForEach(m_clients, &cXinelibThread::LogoDisplay); +# else + if(!cDummyPlayerControl::IsOpen()) + cControl::Launch(new cDummyPlayerControl); +# endif + } + return true; + } + +# ifndef SUSPEND_BY_PLAYER + ForEach(m_clients, &cXinelibThread::SetLiveMode, m_liveMode); +# else + if(cDummyPlayerControl::IsOpen()) + cDummyPlayerControl::Close(); +# endif + + return false; +} + +void cXinelibDevice::Suspend(bool onoff) +{ + TRACEF("cXinelibDevice::Suspend"); + TRACE("cXinelibDevice::Suspend = " << onoff); + + Lock(); + ACTIVITY + + if(!m_suspended && onoff) { + m_suspended = onoff; + SuspendedAction(); + Unlock(); +#ifndef SUSPEND_BY_PLAYER + CreateTimerEvent(this, &cXinelibDevice::SuspendedAction, 5000); +#endif + return; + } + m_suspended = onoff; + Unlock(); +} +#endif // ENABLE_SUSPEND + +// +// Playback of files and images +// + +int cXinelibDevice::PlayFileCtrl(const char *Cmd) +{ + TRACEF("cXinelibDevice::PlayFile"); + int result = -1; + + if(m_PlayingFile) { + if(m_server) + result = m_server->PlayFileCtrl(Cmd); + if(m_local) + result = m_local->PlayFileCtrl(Cmd); + } + return result; +} + +bool cXinelibDevice::EndOfStreamReached(void) +{ + return (((!m_server) || m_server->EndOfStreamReached()) && + ((!m_local) || m_local->EndOfStreamReached())); +} + +bool cXinelibDevice::PlayFile(const char *FileName, int Position, bool LoopPlay) +{ + TRACEF("cXinelibDevice::PlayFile"); + TRACE("cXinelibDevice::PlayFile(\"" << FileName << "\")"); + + bool result = true; + + if(FileName) { + if(!m_PlayingFile) { + m_PlayingFile = true; + StopOutput(); + } + result = (((!m_server) || + m_server->PlayFile(FileName, Position, LoopPlay)) && + ((!m_local) || + m_local->PlayFile(FileName, Position, LoopPlay))); + } else if(/*!FileName &&*/m_PlayingFile) { + result = (((!m_server) || m_server->PlayFile(NULL, 0)) && + ((!m_local) || m_local->PlayFile(NULL, 0))); + if(!m_liveMode) + SetReplayMode(); + else + SetTvMode(Channels.GetByNumber(cDevice::CurrentChannel())); + m_PlayingFile = false; + } + + return result; +} + +// +// Data stream handling +// + +int cXinelibDevice::PlayAny(const uchar *buf, int length) +{ + TRACEF("cXinelibDevice::PlayAny"); + + if(m_PlayingFile) + return length; + +#ifdef ENABLE_SUSPEND + if(m_suspended || (xc.inactivity_timer > 0 && + m_inactivityTimer > xc.inactivity_timer)) { + if(m_liveMode) { + return length; + } + } +#endif + + bool isMpeg1 = false; + + int len = pes_packet_len(buf, length, isMpeg1); + if(len>0 && len != length) + LOGMSG("cXinelibDevice::PlayAny: invalid data !"); + + // strip timestamps in trick speed modes + if(m_SkipAudio || m_TrickSpeed > 0) { + if(!m_SkipAudio) { + +#ifdef TEST_TRICKSPEEDS +#warning Experimental trickspeed mode handling included ! + // TODO: re-gen pts or signal pts+trickspeed for udp scheduler + bool Video = false, Audio = false; + uchar PictureType = NO_PICTURE; + int64_t pts = pes_extract_pts(buf, length, Audio, Video); + if(m_TrickSpeedPts <= 0LL) { + if(pts>0 && Video) { + m_TrickSpeedPts = pts; + if(ScanVideoPacket(buf, length, PictureType) > 0) + ; + LOGMSG("TrickSpeed: VIDEO PTS %lld (%s)", pts, + PictureTypeStr(PictureType)); + } + } else if(Audio) { + LOGMSG("TrickSpeed: AUDIO PTS %lld", pts); + } else if(pts > 0LL) { + if(ScanVideoPacket(buf, length, PictureType) > 0) + ; + LOGMSG("TrickSpeed: VIDEO PTS DIFF %lld (%s)", pts - m_TrickSpeedPts, + PictureTypeStr(PictureType)); + //m_TrickSpeedPts += (int64_t)(40*90 * m_TrickSpeed); /* 40ms * 90kHz */ + //pes_change_pts((uchar *)buf, length); + } + pes_strip_pts((uchar*)buf, length); + +#else + pes_strip_pts((uchar*)buf, length); +#endif + } else { + pes_strip_pts((uchar*)buf, length); + } + } + + if(m_local) { + length = (isMpeg1 ? m_local->Play_Mpeg1_PES(buf,length) : + m_local->Play_PES(buf,length)); + } + if(m_server && length > 0) { + int length2 = isMpeg1 ? m_server->Play_Mpeg1_PES(buf, length) : + m_server->Play_PES(buf, length); + if(!m_local) + return length2; + } + + return length; +} + +int cXinelibDevice::PlayVideo(const uchar *buf, int length) +{ + TRACEF("cXinelibDevice::PlayVideo"); + + if(m_RadioStream) { + m_RadioStream = false; + m_AudioCount = 0; + ForEach(m_clients, &cXinelibThread::SetNoVideo, m_RadioStream); + } + +#ifdef START_IFRAME + // Start with I-frame if stream has video + if(m_StreamStart) { + // wait for first I-frame + uchar pictureType; + if( ScanVideoPacket(buf, length, /*0,*/pictureType) > 0 && + pictureType == I_FRAME) { + m_StreamStart = false; + } else { + return length; + } + } +#else + m_StreamStart = false; +#endif + +#ifdef DEBUG_SWITCHING_TIME + if(switchtimeOff && switchtimeOn) { + uchar pictureType; + if( ScanVideoPacket(buf, length, /*0,*/pictureType) > 0 && + pictureType == I_FRAME) { + if(!switchingIframe) { + int64_t now = cTimeMs::Now(); + switchingIframe = true; + LOGMSG("Channel switch: off -> on %lld ms, on -> 1. I-frame %lld ms", + switchtimeOn-switchtimeOff, now-switchtimeOn); + } else { + int64_t now = cTimeMs::Now(); + LOGMSG("Channel switch: on -> 2. I-frame %lld ms, Total %lld ms", + now-switchtimeOn, now-switchtimeOff); + switchtimeOff = 0LL; + switchtimeOn = 0LL; + switchingIframe = false; + } + } + } +#endif + + return PlayAny(buf, length); +} + +void cXinelibDevice::StillPicture(const uchar *Data, int Length) +{ + TRACEF("cXinelibDevice::StillPicture"); + + bool isPes = (!Data[0] && !Data[1] && Data[2] == 0x01 && + (Data[3] & 0xF0) == 0xE0); + bool isMpeg1 = isPes && ((Data[6] & 0xC0) != 0x80); + int i; + + if(m_PlayingFile) + return; + + TRACE("cXinelibDevice::StillPicture: isPes = "<<isPes + <<", isMpeg1 = "<<isMpeg1); + + ForEach(m_clients, &cXinelibThread::Clear); + ForEach(m_clients, &cXinelibThread::SetNoVideo, false); + ForEach(m_clients, &cXinelibThread::SetLiveMode, false); + ForEach(m_clients, &cXinelibThread::SetStillMode, true); + ForEach(m_clients, &cXinelibThread::TrickSpeed, 1); + + m_TrickSpeed = -1; // to make Poll work ... + m_SkipAudio = 1; // enables audio and pts stripping + + for(i=0; i<STILLPICTURE_REPEAT_COUNT; i++) + if(isMpeg1) { + ForEach(m_clients, &cXinelibThread::Play_Mpeg1_PES, Data, Length, + &mmin<int>, Length); + } else if(isPes) { + /*cDevice::*/PlayPes(Data, Length, m_SkipAudio); + } else { + ForEach(m_clients, &cXinelibThread::Play_Mpeg2_ES, + Data, Length, VIDEO_STREAM, + &mand<bool>, true); + } + + ForEach(m_clients, &cXinelibThread::Play_Mpeg2_ES, + Data, 0, VIDEO_STREAM, + &mand<bool>, true); + +#if 0 + if(m_server) + for(i=0; i<5; i++) + if(m_server->Flush(50)) + break; + else + LOGMSG("cXinelibDevice::StillPicture: retry server flush (%d)", i+1); +#endif + m_TrickSpeed = 0; + m_SkipAudio = 0; +} + +int cXinelibDevice::PlayAudio(const uchar *buf, int length, uchar Id) +{ + TRACEF("cXinelibDevice::PlayAudio"); + +#ifdef SKIP_AC3_AUDIO + // skip AC3 audio + if(((unsigned char *)buf)[3] == PRIVATE_STREAM1) { + TRACE("cXinelibDevice::PlayVideo: PRIVATE_STREAM1 discarded"); + return length; + } +#endif + + // strip audio in trick speed modes + if(m_SkipAudio || m_TrickSpeed > 0) + return length; + + if(m_RadioStream) { + if(m_AudioCount) { + m_AudioCount--; + if(!m_AudioCount) + ForEach(m_clients, &cXinelibThread::SetNoVideo, m_RadioStream); + } + } + + return PlayAny(buf, length); +} + +int cXinelibDevice::PlaySpu(const uchar *buf, int length, uchar Id) +{ + TRACEF("cXinelibDevice::PlaySpu"); + +#ifdef SKIP_DVDSPU + return length; +#else + if(((unsigned char *)buf)[3] == PRIVATE_STREAM1) { + + if(!m_spuPresent) { + TRACE("cXinelibDevice::PlaySpu first DVD SPU frame"); + Skins.QueueMessage(mtInfo,"DVD SPU"); + m_spuPresent = true; + } + } + + // + // TODO: channel must be selectable + // + // use: cXinelibThread::SpuStreamChanged(int StreamId); + // + + return PlayAny(buf, length); +#endif +} + +void cXinelibDevice::SetVolumeDevice(int Volume) +{ + TRACEF("cXinelibDevice::SetVolumeDevice"); + + ACTIVITY + ForEach(m_clients, &cXinelibThread::SetVolume, Volume); +} + +void cXinelibDevice::SetAudioTrackDevice(eTrackType Type) +{ + TRACEF("cXinelibDevice::SetAudioTrackDevice"); + + LOGDBG("SetAudioTrackDevice(%d)", (int)Type); + if(IS_DOLBY_TRACK(Type)) + ForEach(m_clients, &cXinelibThread::AudioStreamChanged, + true, (int)(Type - ttDolbyFirst)); + if(IS_AUDIO_TRACK(Type)) + ForEach(m_clients, &cXinelibThread::AudioStreamChanged, + false, AUDIO_STREAM + (int)(Type - ttAudioFirst)); +} + +void cXinelibDevice::SetAudioChannelDevice(int AudioChannel) +{ + TRACEF("cXinelibDevice::SetAudioChannelDevice"); + + LOGDBG("SetAudioChannelDevice(%d)", (int)AudioChannel); + m_AudioChannel = AudioChannel; + // + // TODO + // + // - stereo, left only, right only + // +} + +void cXinelibDevice::SetDigitalAudioDevice(bool On) +{ + TRACEF("cXinelibDevice::SetDigitalAudioDevice"); + + LOGDBG("SeDigitalAudioDevice(%s)", On ? "on" : "off"); + // + // should we do something here ??? + // +} + +void cXinelibDevice::SetVideoFormat(bool VideoFormat16_9) +{ + TRACEF("cXinelibDevice::SetVideoFormat"); + + LOGDBG("SetVideoFormat(%s)", VideoFormat16_9 ? "16:9" : "4:3"); + ACTIVITY + cDevice::SetVideoFormat(VideoFormat16_9); + + // + // TODO + // +#if 0 + if(xc.aspect != ASPECT_AUTO && + xc.aspect != ASPECT_DEFAULT) { + if(VideoFormat16_9) + xc.aspect = ASPECT_16_9; + else if(xc.aspect == ASPECT_16_9) + xc.aspect = ASPECT_4_3; + ConfigureDecoder(,,,xc.aspect,,,); + } +#endif +} + +void cXinelibDevice::SetVideoDisplayFormat(eVideoDisplayFormat VideoDisplayFormat) +{ + TRACEF("cXinelibDevice::SetVideoDisplayFormat"); + + LOGDBG("SetVideoDisplayFormat(%d)", VideoDisplayFormat); + cDevice::SetVideoDisplayFormat(VideoDisplayFormat); + // + // TODO + // + // - set normal, pan&scan, letterbox (only for 4:3?) + // +#if 0 + if(xc.aspect != ASPECT_AUTO && + xc.aspect != ASPECT_DEFAULT) { + switch(VideoDisplayFormat) { + case vdfPanAndScan: + xc.aspect = ASPECT_PAN_SCAN; + break; + case vdfLetterBox: + xc.aspect = ASPECT_4_3; /* borders are added automatically if needed */ + break; + case vdfCenterCutOut: + xc.aspect = ASPECT_CENTER_CUT_OUT; + break; + } + ConfigureDecoder(,,,xc.aspect,,,); + } +#endif +} + +eVideoSystem cXinelibDevice::GetVideoSystem(void) +{ + TRACEF("cXinelibDevice::GetVideoSystem"); + return cDevice::GetVideoSystem(); +} + +bool cXinelibDevice::Poll(cPoller &Poller, int TimeoutMs) +{ + TRACEF("cXinelibDevice::Poll"); + + if(m_PlayingFile) + return true; + + if(m_TrickSpeed == 0) { + cCondWait::SleepMs(TimeoutMs); + return Poller.Poll(0); + } + + if(!m_local && !m_server) { + /* nothing to do... why do I exist ... ? */ + cCondWait::SleepMs(TimeoutMs); + return Poller.Poll(0); + } + + bool result = true; + + if(m_local) + result = result && m_local->Poll(Poller, TimeoutMs); + if(m_server) + result = result && m_server->Poll(Poller, TimeoutMs); + + return result /*|| Poller.Poll(0)*/; +} + +bool cXinelibDevice::Flush(int TimeoutMs) +{ + TRACEF("cXinelibDevice::Flush"); + + if(m_TrickSpeed == 0) { + ForEach(m_clients, &cXinelibThread::SetLiveMode, false); + TrickSpeed(-1); + } + + bool r = ForEach(m_clients, &cXinelibThread::Flush, TimeoutMs, + &mand<bool>, true); + + return r; +} + +#if 0 +// +// TODO +// - forward spu's directly to Xine +// +class cXineSpuDecoder : public cDvbSpuDecoder +{ + private: + cSpuDecoder::eScaleMode scaleMode; + cXinelibDevice *m_Device; + + public: + cXineSpuDecoder(cXinelibDevice *dev) { + scaleMode = eSpuNormal; + m_Device = dev; + } + virtual ~cXineSpuDecoder() {}; + + virtual int setTime(uint32_t pts) { return 1; } + + cSpuDecoder::eScaleMode getScaleMode(void) { return scaleMode; } + virtual void setScaleMode(cSpuDecoder::eScaleMode ScaleMode) + { scaleMode = ScaleMode; } + virtual void setPalette(uint32_t * pal) {}; + virtual void setHighlight(uint16_t sx, uint16_t sy, + uint16_t ex, uint16_t ey, + uint32_t palette) {}; + virtual void clearHighlight(void) {}; + virtual void Empty(void) {}; + virtual void Hide(void) {}; + virtual void Draw(void) {}; + virtual bool IsVisible(void) { return true; } + virtual void processSPU(uint32_t pts, uint8_t * buf, + bool AllowedShow = true); +}; + +#define CMD_SPU_MENU 0x00 +#define CMD_SPU_SHOW 0x01 +#define CMD_SPU_HIDE 0x02 +#define CMD_SPU_SET_PALETTE 0x03 +#define CMD_SPU_SET_ALPHA 0x04 +#define CMD_SPU_SET_SIZE 0x05 +#define CMD_SPU_SET_PXD_OFFSET 0x06 +#define CMD_SPU_CHG_COLCON 0x07 +#define CMD_SPU_EOF 0xff + +#define spuU32(i) ((spu[i] << 8) + spu[i+1]) + +void cXineSpuDecoder::processSPU(uint32_t pts, uint8_t * buf, bool AllowedShow) +{ + uchar buf2[65536+8] = {0, 0, 1, PRIVATE_STREAM1, 0, 0, 0x80, 0x80, 5}; + int len = ((buf[0] << 8) | buf[1]); + + if(len+8 < 0xffff) { + buf2[4] = ((len+8)<<8) & 0xFF; + buf2[5] = ((len+8)) & 0xFF; + } else { + // should be able to handle this (but only internally ...) + LOGMSG("cXineSpuDecoder: SPU bigger than PES packet !"); + buf2[4] = 0xff; + buf2[5] = 0xff; + } + buf2[9] = ((pts>>29) & 0x0E) | 0x21; + buf2[10] = (pts>>22) & 0xFF; + buf2[11] = (pts>>14) & 0xFE; + buf2[12] = (pts>>7) & 0xFF; + buf2[13] = (pts<<1) & 0xFE; + + memcpy(buf2+14, buf, len); + + m_Device->PlaySpu(buf, len+14, 0); +} +#endif + +cSpuDecoder *cXinelibDevice::GetSpuDecoder(void) +{ + TRACEF("cXinelibDevice::GetSpuDecoder"); + if (!m_spuDecoder && IsPrimaryDevice()) + // + // TODO + // + // - use own derived SpuDecoder with special cXinelibOsd + // -> always visible + // + +#if 1 + m_spuDecoder = new cDvbSpuDecoder(); +#else +#warning NON-FUNCTIONAL SPU DECODER SELECTED !!! + m_spuDecoder = new cXineSpuDecoder(this); +#endif + return m_spuDecoder; +} + +int64_t cXinelibDevice::GetSTC(void) +{ + TRACEF("cXinelibDevice::GetSTC"); + + if(m_local) + return m_local->GetSTC(); + if(m_server) + return m_server->GetSTC(); + return cDevice::GetSTC(); +} + + +#if VDRVERSNUM < 10338 + +bool cXinelibDevice::GrabImage(const char *FileName, bool Jpeg, + int Quality, int SizeX, int SizeY) +{ + uchar *Data = NULL; + int Size = 0; + TRACEF("cXinelibDevice::GrabImage"); + + ACTIVITY + if(m_local) + Data = m_local->GrabImage(Size, Jpeg, Quality, SizeX, SizeY); + if(!Data && m_server) + Data = m_local->GrabImage(Size, Jpeg, Quality, SizeX, SizeY); + + if(Data) { + FILE *fp = fopen(FileName, "wb"); + if(fp) { + fwrite(Data, Size, 1, fp); + fclose(fp); + free(Data); + return true; + } + LOGERR("Grab: Can't open %s", FileName); + free(Data); + } else { + LOGMSG("Grab to %s failed", FileName); + } + return false; +} + +#else + +uchar *cXinelibDevice::GrabImage(int &Size, bool Jpeg, + int Quality, int SizeX, int SizeY) +{ + TRACEF("cXinelibDevice::GrabImage"); + + ACTIVITY + if(m_local) + return m_local->GrabImage(Size, Jpeg, Quality, SizeX, SizeY); + if(m_server) + return m_local->GrabImage(Size, Jpeg, Quality, SizeX, SizeY); + + return NULL; +} + +#endif + + +#if 0 +// override cDevice to get DVD SPUs +int cXinelibDevice::PlayPesPacket(const uchar *Data, int Length, + bool VideoOnly) +{ +#ifndef SKIP_DVDSPU + switch (Data[3]) { + case 0xBD: { // private stream 1 + int PayloadOffset = Data[8] + 9; + uchar SubStreamId = Data[PayloadOffset]; + uchar SubStreamType = SubStreamId & 0xF0; + uchar SubStreamIndex = SubStreamId & 0x1F; + switch (SubStreamType) { + case 0x20: // SPU + case 0x30: // SPU + return PlaySpu(Data, Length, SubStreamIndex); + break; + default: + ; + } + } + default: + ; + } +#endif + return cDevice::PlayPesPacket(Data, Length, VideoOnly); +} +#endif |