/* * device.c: The basic device interface * * See the main source file 'vdr.c' for copyright information and * how to reach the author. * * $Id: device.c 2.74.1.4 2014/03/11 09:29:52 kls Exp $ */ #include "device.h" #include #include #include #include "audio.h" #include "channels.h" #include "i18n.h" #include "player.h" #include "receiver.h" #include "status.h" #include "transfer.h" // --- cLiveSubtitle --------------------------------------------------------- class cLiveSubtitle : public cReceiver { protected: virtual void Receive(uchar *Data, int Length); public: cLiveSubtitle(int SPid); virtual ~cLiveSubtitle(); }; cLiveSubtitle::cLiveSubtitle(int SPid) { AddPid(SPid); } cLiveSubtitle::~cLiveSubtitle() { cReceiver::Detach(); } void cLiveSubtitle::Receive(uchar *Data, int Length) { if (cDevice::PrimaryDevice()) cDevice::PrimaryDevice()->PlayTs(Data, Length); } // --- cDeviceHook ----------------------------------------------------------- cDeviceHook::cDeviceHook(void) { cDevice::deviceHooks.Add(this); } bool cDeviceHook::DeviceProvidesTransponder(const cDevice *Device, const cChannel *Channel) const { return true; } // --- cDevice --------------------------------------------------------------- // The minimum number of unknown PS1 packets to consider this a "pre 1.3.19 private stream": #define MIN_PRE_1_3_19_PRIVATESTREAM 10 int cDevice::numDevices = 0; int cDevice::useDevice = 0; int cDevice::nextCardIndex = 0; int cDevice::currentChannel = 1; cDevice *cDevice::device[MAXDEVICES] = { NULL }; cDevice *cDevice::primaryDevice = NULL; cList cDevice::deviceHooks; cDevice::cDevice(void) :patPmtParser(true) { cardIndex = nextCardIndex++; dsyslog("new device number %d", CardIndex() + 1); SetDescription("receiver on device %d", CardIndex() + 1); mute = false; volume = Setup.CurrentVolume; sectionHandler = NULL; eitFilter = NULL; patFilter = NULL; sdtFilter = NULL; nitFilter = NULL; camSlot = NULL; startScrambleDetection = 0; occupiedTimeout = 0; player = NULL; isPlayingVideo = false; keepTracks = false; // used in ClrAvailableTracks()! ClrAvailableTracks(); currentAudioTrack = ttNone; currentAudioTrackMissingCount = 0; currentSubtitleTrack = ttNone; liveSubtitle = NULL; dvbSubtitleConverter = NULL; autoSelectPreferredSubtitleLanguage = true; for (int i = 0; i < MAXRECEIVERS; i++) receiver[i] = NULL; if (numDevices < MAXDEVICES) device[numDevices++] = this; else esyslog("ERROR: too many devices!"); } cDevice::~cDevice() { Detach(player); DetachAllReceivers(); delete liveSubtitle; delete dvbSubtitleConverter; if (this == primaryDevice) primaryDevice = NULL; } bool cDevice::WaitForAllDevicesReady(int Timeout) { for (time_t t0 = time(NULL); time(NULL) - t0 < Timeout; ) { bool ready = true; for (int i = 0; i < numDevices; i++) { if (device[i] && !device[i]->Ready()) { ready = false; cCondWait::SleepMs(100); } } if (ready) return true; } return false; } void cDevice::SetUseDevice(int n) { if (n < MAXDEVICES) useDevice |= (1 << n); } int cDevice::NextCardIndex(int n) { if (n > 0) { nextCardIndex += n; if (nextCardIndex >= MAXDEVICES) esyslog("ERROR: nextCardIndex too big (%d)", nextCardIndex); } else if (n < 0) esyslog("ERROR: invalid value in nextCardIndex(%d)", n); return nextCardIndex; } int cDevice::DeviceNumber(void) const { for (int i = 0; i < numDevices; i++) { if (device[i] == this) return i; } return -1; } cString cDevice::DeviceType(void) const { return ""; } cString cDevice::DeviceName(void) const { return ""; } void cDevice::MakePrimaryDevice(bool On) { if (!On) { DELETENULL(liveSubtitle); DELETENULL(dvbSubtitleConverter); } } bool cDevice::SetPrimaryDevice(int n) { n--; if (0 <= n && n < numDevices && device[n]) { isyslog("setting primary device to %d", n + 1); if (primaryDevice) primaryDevice->MakePrimaryDevice(false); primaryDevice = device[n]; primaryDevice->MakePrimaryDevice(true); primaryDevice->SetVideoFormat(Setup.VideoFormat); primaryDevice->SetVolumeDevice(Setup.CurrentVolume); return true; } esyslog("ERROR: invalid primary device number: %d", n + 1); return false; } bool cDevice::HasDecoder(void) const { return false; } cSpuDecoder *cDevice::GetSpuDecoder(void) { return NULL; } cDevice *cDevice::ActualDevice(void) { cDevice *d = cTransferControl::ReceiverDevice(); if (!d) d = PrimaryDevice(); return d; } cDevice *cDevice::GetDevice(int Index) { return (0 <= Index && Index < numDevices) ? device[Index] : NULL; } static int GetClippedNumProvidedSystems(int AvailableBits, cDevice *Device) { int MaxNumProvidedSystems = (1 << AvailableBits) - 1; int NumProvidedSystems = Device->NumProvidedSystems(); if (NumProvidedSystems > MaxNumProvidedSystems) { esyslog("ERROR: device %d supports %d modulation systems but cDevice::GetDevice() currently only supports %d delivery systems which should be fixed", Device->CardIndex() + 1, NumProvidedSystems, MaxNumProvidedSystems); NumProvidedSystems = MaxNumProvidedSystems; } else if (NumProvidedSystems <= 0) { esyslog("ERROR: device %d reported an invalid number (%d) of supported delivery systems - assuming 1", Device->CardIndex() + 1, NumProvidedSystems); NumProvidedSystems = 1; } return NumProvidedSystems; } cDevice *cDevice::GetDevice(const cChannel *Channel, int Priority, bool LiveView, bool Query) { // Collect the current priorities of all CAM slots that can decrypt the channel: int NumCamSlots = CamSlots.Count(); int SlotPriority[NumCamSlots]; int NumUsableSlots = 0; bool InternalCamNeeded = false; if (Channel->Ca() >= CA_ENCRYPTED_MIN) { for (cCamSlot *CamSlot = CamSlots.First(); CamSlot; CamSlot = CamSlots.Next(CamSlot)) { SlotPriority[CamSlot->Index()] = MAXPRIORITY + 1; // assumes it can't be used if (CamSlot->ModuleStatus() == msReady) { if (CamSlot->ProvidesCa(Channel->Caids())) { if (!ChannelCamRelations.CamChecked(Channel->GetChannelID(), CamSlot->SlotNumber())) { SlotPriority[CamSlot->Index()] = CamSlot->Priority(); NumUsableSlots++; } } } } if (!NumUsableSlots) InternalCamNeeded = true; // no CAM is able to decrypt this channel } bool NeedsDetachReceivers = false; cDevice *d = NULL; cCamSlot *s = NULL; uint32_t Impact = 0xFFFFFFFF; // we're looking for a device with the least impact for (int j = 0; j < NumCamSlots || !NumUsableSlots; j++) { if (NumUsableSlots && SlotPriority[j] > MAXPRIORITY) continue; // there is no CAM available in this slot for (int i = 0; i < numDevices; i++) { if (Channel->Ca() && Channel->Ca() <= CA_DVB_MAX && Channel->Ca() != device[i]->CardIndex() + 1) continue; // a specific card was requested, but not this one bool HasInternalCam = device[i]->HasInternalCam(); if (InternalCamNeeded && !HasInternalCam) continue; // no CAM is able to decrypt this channel and the device uses vdr handled CAMs if (NumUsableSlots && !HasInternalCam && !CamSlots.Get(j)->Assign(device[i], true)) continue; // CAM slot can't be used with this device bool ndr; if (device[i]->ProvidesChannel(Channel, Priority, &ndr)) { // this device is basically able to do the job if (NumUsableSlots && !HasInternalCam && device[i]->CamSlot() && device[i]->CamSlot() != CamSlots.Get(j)) ndr = true; // using a different CAM slot requires detaching receivers // Put together an integer number that reflects the "impact" using // this device would have on the overall system. Each condition is represented // by one bit in the number (or several bits, if the condition is actually // a numeric value). The sequence in which the conditions are listed corresponds // to their individual severity, where the one listed first will make the most // difference, because it results in the most significant bit of the result. uint32_t imp = 0; imp <<= 1; imp |= LiveView ? !device[i]->IsPrimaryDevice() || ndr : 0; // prefer the primary device for live viewing if we don't need to detach existing receivers imp <<= 1; imp |= !device[i]->Receiving() && (device[i] != cTransferControl::ReceiverDevice() || device[i]->IsPrimaryDevice()) || ndr; // use receiving devices if we don't need to detach existing receivers, but avoid primary device in local transfer mode imp <<= 1; imp |= device[i]->Receiving(); // avoid devices that are receiving imp <<= 4; imp |= GetClippedNumProvidedSystems(4, device[i]) - 1; // avoid cards which support multiple delivery systems imp <<= 1; imp |= device[i] == cTransferControl::ReceiverDevice(); // avoid the Transfer Mode receiver device imp <<= 8; imp |= device[i]->Priority() - IDLEPRIORITY; // use the device with the lowest priority (- IDLEPRIORITY to assure that values -100..99 can be used) imp <<= 8; imp |= ((NumUsableSlots && !HasInternalCam) ? SlotPriority[j] : IDLEPRIORITY) - IDLEPRIORITY;// use the CAM slot with the lowest priority (- IDLEPRIORITY to assure that values -100..99 can be used) imp <<= 1; imp |= ndr; // avoid devices if we need to detach existing receivers imp <<= 1; imp |= (NumUsableSlots || InternalCamNeeded) ? 0 : device[i]->HasCi(); // avoid cards with Common Interface for FTA channels imp <<= 1; imp |= device[i]->AvoidRecording(); // avoid SD full featured cards imp <<= 1; imp |= (NumUsableSlots && !HasInternalCam) ? !ChannelCamRelations.CamDecrypt(Channel->GetChannelID(), j + 1) : 0; // prefer CAMs that are known to decrypt this channel imp <<= 1; imp |= device[i]->IsPrimaryDevice(); // avoid the primary device if (imp < Impact) { // This device has less impact than any previous one, so we take it. Impact = imp; d = device[i]; NeedsDetachReceivers = ndr; if (NumUsableSlots && !HasInternalCam) s = CamSlots.Get(j); } } } if (!NumUsableSlots) break; // no CAM necessary, so just one loop over the devices } if (d && !Query) { if (NeedsDetachReceivers) d->DetachAllReceivers(); if (s) { if (s->Device() != d) { if (s->Device()) s->Device()->DetachAllReceivers(); if (d->CamSlot()) d->CamSlot()->Assign(NULL); s->Assign(d); } } else if (d->CamSlot() && !d->CamSlot()->IsDecrypting()) d->CamSlot()->Assign(NULL); } return d; } cDevice *cDevice::GetDeviceForTransponder(const cChannel *Channel, int Priority) { cDevice *Device = NULL; for (int i = 0; i < cDevice::NumDevices(); i++) { if (cDevice *d = cDevice::GetDevice(i)) { if (d->IsTunedToTransponder(Channel)) return d; // if any device is tuned to the transponder, we're done if (d->ProvidesTransponder(Channel)) { if (d->MaySwitchTransponder(Channel)) Device = d; // this device may switch to the transponder without disturbing any receiver or live view else if (!d->Occupied() && d->MaySwitchTransponder(Channel)) { // MaySwitchTransponder() implicitly calls Occupied() if (d->Priority() < Priority && (!Device || d->Priority() < Device->Priority())) Device = d; // use this one only if no other with less impact can be found } } } } return Device; } bool cDevice::HasCi(void) { return false; } void cDevice::SetCamSlot(cCamSlot *CamSlot) { camSlot = CamSlot; } void cDevice::Shutdown(void) { deviceHooks.Clear(); for (int i = 0; i < numDevices; i++) { delete device[i]; device[i] = NULL; } } uchar *cDevice::GrabImage(int &Size, bool Jpeg, int Quality, int SizeX, int SizeY) { return NULL; } bool cDevice::GrabImageFile(const char *FileName, bool Jpeg, int Quality, int SizeX, int SizeY) { int result = 0; int fd = open(FileName, O_WRONLY | O_CREAT | O_NOFOLLOW | O_TRUNC, DEFFILEMODE); if (fd >= 0) { int ImageSize; uchar *Image = GrabImage(ImageSize, Jpeg, Quality, SizeX, SizeY); if (Image) { if (safe_write(fd, Image, ImageSize) == ImageSize) isyslog("grabbed image to %s", FileName); else { LOG_ERROR_STR(FileName); result |= 1; } free(Image); } else result |= 1; close(fd); } else { LOG_ERROR_STR(FileName); result |= 1; } return result == 0; } void cDevice::SetVideoDisplayFormat(eVideoDisplayFormat VideoDisplayFormat) { cSpuDecoder *spuDecoder = GetSpuDecoder(); if (spuDecoder) { if (Setup.VideoFormat) spuDecoder->setScaleMode(cSpuDecoder::eSpuNormal); else { switch (VideoDisplayFormat) { case vdfPanAndScan: spuDecoder->setScaleMode(cSpuDecoder::eSpuPanAndScan); break; case vdfLetterBox: spuDecoder->setScaleMode(cSpuDecoder::eSpuLetterBox); break; case vdfCenterCutOut: spuDecoder->setScaleMode(cSpuDecoder::eSpuNormal); break; default: esyslog("ERROR: invalid value for VideoDisplayFormat '%d'", VideoDisplayFormat); } } } } void cDevice::SetVideoFormat(bool VideoFormat16_9) { } eVideoSystem cDevice::GetVideoSystem(void) { return vsPAL; } void cDevice::GetVideoSize(int &Width, int &Height, double &VideoAspect) { Width = 0; Height = 0; VideoAspect = 1.0; } void cDevice::GetOsdSize(int &Width, int &Height, double &PixelAspect) { Width = 720; Height = 480; PixelAspect = 1.0; } //#define PRINTPIDS(s) { char b[500]; char *q = b; q += sprintf(q, "%d %s ", CardIndex(), s); for (int i = 0; i < MAXPIDHANDLES; i++) q += sprintf(q, " %s%4d %d", i == ptOther ? "* " : "", pidHandles[i].pid, pidHandles[i].used); dsyslog("%s", b); } #define PRINTPIDS(s) bool cDevice::HasPid(int Pid) const { for (int i = 0; i < MAXPIDHANDLES; i++) { if (pidHandles[i].pid == Pid) return true; } return false; } bool cDevice::AddPid(int Pid, ePidType PidType, int StreamType) { if (Pid || PidType == ptPcr) { int n = -1; int a = -1; if (PidType != ptPcr) { // PPID always has to be explicit for (int i = 0; i < MAXPIDHANDLES; i++) { if (i != ptPcr) { if (pidHandles[i].pid == Pid) n = i; else if (a < 0 && i >= ptOther && !pidHandles[i].used) a = i; } } } if (n >= 0) { // The Pid is already in use if (++pidHandles[n].used == 2 && n <= ptTeletext) { // It's a special PID that may have to be switched into "tap" mode PRINTPIDS("A"); if (!SetPid(&pidHandles[n], n, true)) { esyslog("ERROR: can't set PID %d on device %d", Pid, CardIndex() + 1); if (PidType <= ptTeletext) DetachAll(Pid); DelPid(Pid, PidType); return false; } if (camSlot) camSlot->SetPid(Pid, true); } PRINTPIDS("a"); return true; } else if (PidType < ptOther) { // The Pid is not yet in use and it is a special one n = PidType; } else if (a >= 0) { // The Pid is not yet in use and we have a free slot n = a; } else { esyslog("ERROR: no free slot for PID %d on device %d", Pid, CardIndex() + 1); return false; } if (n >= 0) { pidHandles[n].pid = Pid; pidHandles[n].streamType = StreamType; pidHandles[n].used = 1; PRINTPIDS("C"); if (!SetPid(&pidHandles[n], n, true)) { esyslog("ERROR: can't set PID %d on device %d", Pid, CardIndex() + 1); if (PidType <= ptTeletext) DetachAll(Pid); DelPid(Pid, PidType); return false; } if (camSlot) camSlot->SetPid(Pid, true); } } return true; } void cDevice::DelPid(int Pid, ePidType PidType) { if (Pid || PidType == ptPcr) { int n = -1; if (PidType == ptPcr) n = PidType; // PPID always has to be explicit else { for (int i = 0; i < MAXPIDHANDLES; i++) { if (pidHandles[i].pid == Pid) { n = i; break; } } } if (n >= 0 && pidHandles[n].used) { PRINTPIDS("D"); if (--pidHandles[n].used < 2) { SetPid(&pidHandles[n], n, false); if (pidHandles[n].used == 0) { pidHandles[n].handle = -1; pidHandles[n].pid = 0; if (camSlot) camSlot->SetPid(Pid, false); } } PRINTPIDS("E"); } } } bool cDevice::SetPid(cPidHandle *Handle, int Type, bool On) { return false; } void cDevice::DelLivePids(void) { for (int i = ptAudio; i < ptOther; i++) { if (pidHandles[i].pid) DelPid(pidHandles[i].pid, ePidType(i)); } } void cDevice::StartSectionHandler(void) { if (!sectionHandler) { sectionHandler = new cSectionHandler(this); AttachFilter(eitFilter = new cEitFilter); AttachFilter(patFilter = new cPatFilter); AttachFilter(sdtFilter = new cSdtFilter(patFilter)); AttachFilter(nitFilter = new cNitFilter(sdtFilter)); } } void cDevice::StopSectionHandler(void) { if (sectionHandler) { delete nitFilter; delete sdtFilter; delete patFilter; delete eitFilter; delete sectionHandler; nitFilter = NULL; sdtFilter = NULL; patFilter = NULL; eitFilter = NULL; sectionHandler = NULL; } } int cDevice::OpenFilter(u_short Pid, u_char Tid, u_char Mask) { return -1; } int cDevice::ReadFilter(int Handle, void *Buffer, size_t Length) { return safe_read(Handle, Buffer, Length); } void cDevice::CloseFilter(int Handle) { close(Handle); } void cDevice::AttachFilter(cFilter *Filter) { if (sectionHandler) sectionHandler->Attach(Filter); } void cDevice::Detach(cFilter *Filter) { if (sectionHandler) sectionHandler->Detach(Filter); } bool cDevice::ProvidesSource(int Source) const { return false; } bool cDevice::DeviceHooksProvidesTransponder(const cChannel *Channel) const { cDeviceHook *Hook = deviceHooks.First(); while (Hook) { if (!Hook->DeviceProvidesTransponder(this, Channel)) return false; Hook = deviceHooks.Next(Hook); } return true; } bool cDevice::ProvidesTransponder(const cChannel *Channel) const { return false; } bool cDevice::ProvidesTransponderExclusively(const cChannel *Channel) const { for (int i = 0; i < numDevices; i++) { if (device[i] && device[i] != this && device[i]->ProvidesTransponder(Channel)) return false; } return true; } bool cDevice::ProvidesChannel(const cChannel *Channel, int Priority, bool *NeedsDetachReceivers) const { return false; } bool cDevice::ProvidesEIT(void) const { return false; } int cDevice::NumProvidedSystems(void) const { return 0; } int cDevice::SignalStrength(void) const { return -1; } int cDevice::SignalQuality(void) const { return -1; } const cChannel *cDevice::GetCurrentlyTunedTransponder(void) const { return NULL; } bool cDevice::IsTunedToTransponder(const cChannel *Channel) const { return false; } bool cDevice::MaySwitchTransponder(const cChannel *Channel) const { return time(NULL) > occupiedTimeout && !Receiving() && !(pidHandles[ptAudio].pid || pidHandles[ptVideo].pid || pidHandles[ptDolby].pid); } bool cDevice::SwitchChannel(const cChannel *Channel, bool LiveView) { if (LiveView) { isyslog("switching to channel %d", Channel->Number()); cControl::Shutdown(); // prevents old channel from being shown too long if GetDevice() takes longer } for (int i = 3; i--;) { switch (SetChannel(Channel, LiveView)) { case scrOk: return true; case scrNotAvailable: Skins.Message(mtInfo, tr("Channel not available!")); return false; case scrNoTransfer: Skins.Message(mtError, tr("Can't start Transfer Mode!")); return false; case scrFailed: break; // loop will retry default: esyslog("ERROR: invalid return value from SetChannel"); } esyslog("retrying"); } return false; } bool cDevice::SwitchChannel(int Direction) { bool result = false; Direction = sgn(Direction); if (Direction) { cControl::Shutdown(); // prevents old channel from being shown too long if GetDevice() takes longer int n = CurrentChannel() + Direction; int first = n; cChannel *channel; while ((channel = Channels.GetByNumber(n, Direction)) != NULL) { // try only channels which are currently available if (GetDevice(channel, LIVEPRIORITY, true, true)) break; n = channel->Number() + Direction; } if (channel) { int d = n - first; if (abs(d) == 1) dsyslog("skipped channel %d", first); else if (d) dsyslog("skipped channels %d..%d", first, n - sgn(d)); if (PrimaryDevice()->SwitchChannel(channel, true)) result = true; } else if (n != first) Skins.Message(mtError, tr("Channel not available!")); } return result; } eSetChannelResult cDevice::SetChannel(const cChannel *Channel, bool LiveView) { cStatus::MsgChannelSwitch(this, 0, LiveView); if (LiveView) { StopReplay(); DELETENULL(liveSubtitle); DELETENULL(dvbSubtitleConverter); } cDevice *Device = (LiveView && IsPrimaryDevice()) ? GetDevice(Channel, LIVEPRIORITY, true) : this; bool NeedsTransferMode = Device != this; eSetChannelResult Result = scrOk; // If this DVB card can't receive this channel, let's see if we can // use the card that actually can receive it and transfer data from there: if (NeedsTransferMode) { if (Device && CanReplay()) { if (Device->SetChannel(Channel, false) == scrOk) // calling SetChannel() directly, not SwitchChannel()! cControl::Launch(new cTransferControl(Device, Channel)); else Result = scrNoTransfer; } else Result = scrNotAvailable; } else { Channels.Lock(false); // Stop section handling: if (sectionHandler) { sectionHandler->SetStatus(false); sectionHandler->SetChannel(NULL); } // Tell the camSlot about the channel switch and add all PIDs of this // channel to it, for possible later decryption: if (camSlot) camSlot->AddChannel(Channel); if (SetChannelDevice(Channel, LiveView)) { // Start section handling: if (sectionHandler) { patFilter->Trigger(Channel->Sid()); sectionHandler->SetChannel(Channel); sectionHandler->SetStatus(true); } // Start decrypting any PIDs that might have been set in SetChannelDevice(): if (camSlot) camSlot->StartDecrypting(); } else Result = scrFailed; Channels.Unlock(); } if (Result == scrOk) { if (LiveView && IsPrimaryDevice()) { currentChannel = Channel->Number(); // Set the available audio tracks: ClrAvailableTracks(); for (int i = 0; i < MAXAPIDS; i++) SetAvailableTrack(ttAudio, i, Channel->Apid(i), Channel->Alang(i)); if (Setup.UseDolbyDigital) { for (int i = 0; i < MAXDPIDS; i++) SetAvailableTrack(ttDolby, i, Channel->Dpid(i), Channel->Dlang(i)); } for (int i = 0; i < MAXSPIDS; i++) SetAvailableTrack(ttSubtitle, i, Channel->Spid(i), Channel->Slang(i)); if (!NeedsTransferMode) EnsureAudioTrack(true); EnsureSubtitleTrack(); } cStatus::MsgChannelSwitch(this, Channel->Number(), LiveView); // only report status if channel switch successful } return Result; } void cDevice::ForceTransferMode(void) { if (!cTransferControl::ReceiverDevice()) { cChannel *Channel = Channels.GetByNumber(CurrentChannel()); if (Channel) SetChannelDevice(Channel, false); // this implicitly starts Transfer Mode } } int cDevice::Occupied(void) const { int Seconds = occupiedTimeout - time(NULL); return Seconds > 0 ? Seconds : 0; } void cDevice::SetOccupied(int Seconds) { if (Seconds >= 0) occupiedTimeout = time(NULL) + min(Seconds, MAXOCCUPIEDTIMEOUT); } bool cDevice::SetChannelDevice(const cChannel *Channel, bool LiveView) { return false; } bool cDevice::HasLock(int TimeoutMs) const { return true; } bool cDevice::HasProgramme(void) const { return Replaying() || pidHandles[ptAudio].pid || pidHandles[ptVideo].pid; } int cDevice::GetAudioChannelDevice(void) { return 0; } void cDevice::SetAudioChannelDevice(int AudioChannel) { } void cDevice::SetVolumeDevice(int Volume) { } void cDevice::SetDigitalAudioDevice(bool On) { } void cDevice::SetAudioTrackDevice(eTrackType Type) { } void cDevice::SetSubtitleTrackDevice(eTrackType Type) { } bool cDevice::ToggleMute(void) { int OldVolume = volume; mute = !mute; //XXX why is it necessary to use different sequences??? if (mute) { SetVolume(0, true); Audios.MuteAudio(mute); // Mute external audio after analog audio } else { Audios.MuteAudio(mute); // Enable external audio before analog audio SetVolume(OldVolume, true); } volume = OldVolume; return mute; } int cDevice::GetAudioChannel(void) { int c = GetAudioChannelDevice(); return (0 <= c && c <= 2) ? c : 0; } void cDevice::SetAudioChannel(int AudioChannel) { if (0 <= AudioChannel && AudioChannel <= 2) SetAudioChannelDevice(AudioChannel); } void cDevice::SetVolume(int Volume, bool Absolute) { int OldVolume = volume; volume = constrain(Absolute ? Volume : volume + Volume, 0, MAXVOLUME); SetVolumeDevice(volume); Absolute |= mute; cStatus::MsgSetVolume(Absolute ? volume : volume - OldVolume, Absolute); if (volume > 0) { mute = false; Audios.MuteAudio(mute); } } void cDevice::ClrAvailableTracks(bool DescriptionsOnly, bool IdsOnly) { if (keepTracks) return; if (DescriptionsOnly) { for (int i = ttNone; i < ttMaxTrackTypes; i++) *availableTracks[i].description = 0; } else { if (IdsOnly) { for (int i = ttNone; i < ttMaxTrackTypes; i++) availableTracks[i].id = 0; } else memset(availableTracks, 0, sizeof(availableTracks)); pre_1_3_19_PrivateStream = 0; SetAudioChannel(0); // fall back to stereo currentAudioTrackMissingCount = 0; currentAudioTrack = ttNone; currentSubtitleTrack = ttNone; } } bool cDevice::SetAvailableTrack(eTrackType Type, int Index, uint16_t Id, const char *Language, const char *Description) { eTrackType t = eTrackType(Type + Index); if (Type == ttAudio && IS_AUDIO_TRACK(t) || Type == ttDolby && IS_DOLBY_TRACK(t) || Type == ttSubtitle && IS_SUBTITLE_TRACK(t)) { if (Language) strn0cpy(availableTracks[t].language, Language, sizeof(availableTracks[t].language)); if (Description) Utf8Strn0Cpy(availableTracks[t].description, Description, sizeof(availableTracks[t].description)); if (Id) { availableTracks[t].id = Id; // setting 'id' last to avoid the need for extensive locking if (Type == ttAudio || Type == ttDolby) { int numAudioTracks = NumAudioTracks(); if (!availableTracks[currentAudioTrack].id && numAudioTracks && currentAudioTrackMissingCount++ > numAudioTracks * 10) EnsureAudioTrack(); else if (t == currentAudioTrack) currentAudioTrackMissingCount = 0; } else if (Type == ttSubtitle && autoSelectPreferredSubtitleLanguage) EnsureSubtitleTrack(); } return true; } else esyslog("ERROR: SetAvailableTrack called with invalid Type/Index (%d/%d)", Type, Index); return false; } const tTrackId *cDevice::GetTrack(eTrackType Type) { return (ttNone < Type && Type < ttMaxTrackTypes) ? &availableTracks[Type] : NULL; } int cDevice::NumTracks(eTrackType FirstTrack, eTrackType LastTrack) const { int n = 0; for (int i = FirstTrack; i <= LastTrack; i++) { if (availableTracks[i].id) n++; } return n; } int cDevice::NumAudioTracks(void) const { return NumTracks(ttAudioFirst, ttDolbyLast); } int cDevice::NumSubtitleTracks(void) const { return NumTracks(ttSubtitleFirst, ttSubtitleLast); } bool cDevice::SetCurrentAudioTrack(eTrackType Type) { if (ttNone < Type && Type <= ttDolbyLast) { cMutexLock MutexLock(&mutexCurrentAudioTrack); if (IS_DOLBY_TRACK(Type)) SetDigitalAudioDevice(true); currentAudioTrack = Type; if (player) player->SetAudioTrack(currentAudioTrack, GetTrack(currentAudioTrack)); else SetAudioTrackDevice(currentAudioTrack); if (IS_AUDIO_TRACK(Type)) SetDigitalAudioDevice(false); return true; } return false; } bool cDevice::SetCurrentSubtitleTrack(eTrackType Type, bool Manual) { if (Type == ttNone || IS_SUBTITLE_TRACK(Type)) { currentSubtitleTrack = Type; autoSelectPreferredSubtitleLanguage = !Manual; if (dvbSubtitleConverter) dvbSubtitleConverter->Reset(); if (Type == ttNone && dvbSubtitleConverter) { cMutexLock MutexLock(&mutexCurrentSubtitleTrack); DELETENULL(dvbSubtitleConverter); } DELETENULL(liveSubtitle); if (player) player->SetSubtitleTrack(currentSubtitleTrack, GetTrack(currentSubtitleTrack)); else SetSubtitleTrackDevice(currentSubtitleTrack); if (currentSubtitleTrack != ttNone && !Replaying() && !Transferring()) { const tTrackId *TrackId = GetTrack(currentSubtitleTrack); if (TrackId && TrackId->id) { liveSubtitle = new cLiveSubtitle(TrackId->id); AttachReceiver(liveSubtitle); } } return true; } return false; } void cDevice::EnsureAudioTrack(bool Force) { if (keepTracks) return; if (Force || !availableTracks[currentAudioTrack].id) { eTrackType PreferredTrack = ttAudioFirst; int PreferredAudioChannel = 0; int LanguagePreference = -1; int StartCheck = Setup.CurrentDolby ? ttDolbyFirst : ttAudioFirst; int EndCheck = ttDolbyLast; for (int i = StartCheck; i <= EndCheck; i++) { const tTrackId *TrackId = GetTrack(eTrackType(i)); int pos = 0; if (TrackId && TrackId->id && I18nIsPreferredLanguage(Setup.AudioLanguages, TrackId->language, LanguagePreference, &pos)) { PreferredTrack = eTrackType(i); PreferredAudioChannel = pos; } if (Setup.CurrentDolby && i == ttDolbyLast) { i = ttAudioFirst - 1; EndCheck = ttAudioLast; } } // Make sure we're set to an available audio track: const tTrackId *Track = GetTrack(GetCurrentAudioTrack()); if (Force || !Track || !Track->id || PreferredTrack != GetCurrentAudioTrack()) { if (!Force) // only log this for automatic changes dsyslog("setting audio track to %d (%d)", PreferredTrack, PreferredAudioChannel); SetCurrentAudioTrack(PreferredTrack); SetAudioChannel(PreferredAudioChannel); } } } void cDevice::EnsureSubtitleTrack(void) { if (keepTracks) return; if (Setup.DisplaySubtitles) { eTrackType PreferredTrack = ttNone; int LanguagePreference = INT_MAX; // higher than the maximum possible value for (int i = ttSubtitleFirst; i <= ttSubtitleLast; i++) { const tTrackId *TrackId = GetTrack(eTrackType(i)); if (TrackId && TrackId->id && (I18nIsPreferredLanguage(Setup.SubtitleLanguages, TrackId->language, LanguagePreference) || (i == ttSubtitleFirst + 8 && !*TrackId->language && LanguagePreference == INT_MAX))) // compatibility mode for old subtitles plugin PreferredTrack = eTrackType(i); } // Make sure we're set to an available subtitle track: const tTrackId *Track = GetTrack(GetCurrentSubtitleTrack()); if (!Track || !Track->id || PreferredTrack != GetCurrentSubtitleTrack()) SetCurrentSubtitleTrack(PreferredTrack); } else SetCurrentSubtitleTrack(ttNone); } bool cDevice::CanReplay(void) const { return HasDecoder(); } bool cDevice::SetPlayMode(ePlayMode PlayMode) { return false; } int64_t cDevice::GetSTC(void) { return -1; } void cDevice::TrickSpeed(int Speed) { } void cDevice::Clear(void) { Audios.ClearAudio(); if (dvbSubtitleConverter) dvbSubtitleConverter->Reset(); } void cDevice::Play(void) { Audios.MuteAudio(mute); if (dvbSubtitleConverter) dvbSubtitleConverter->Freeze(false); } void cDevice::Freeze(void) { Audios.MuteAudio(true); if (dvbSubtitleConverter) dvbSubtitleConverter->Freeze(true); } void cDevice::Mute(void) { Audios.MuteAudio(true); } void cDevice::StillPicture(const uchar *Data, int Length) { if (Data[0] == 0x47) { // TS data cTsToPes TsToPes; uchar *buf = NULL; int Size = 0; while (Length >= TS_SIZE) { int Pid = TsPid(Data); if (Pid == PATPID) patPmtParser.ParsePat(Data, TS_SIZE); else if (patPmtParser.IsPmtPid(Pid)) patPmtParser.ParsePmt(Data, TS_SIZE); else if (Pid == patPmtParser.Vpid()) { if (TsPayloadStart(Data)) { int l; while (const uchar *p = TsToPes.GetPes(l)) { int Offset = Size; int NewSize = Size + l; if (uchar *NewBuffer = (uchar *)realloc(buf, NewSize)) { Size = NewSize; buf = NewBuffer; memcpy(buf + Offset, p, l); } else { LOG_ERROR_STR("out of memory"); free(buf); return; } } TsToPes.Reset(); } TsToPes.PutTs(Data, TS_SIZE); } Length -= TS_SIZE; Data += TS_SIZE; } int l; while (const uchar *p = TsToPes.GetPes(l)) { int Offset = Size; int NewSize = Size + l; if (uchar *NewBuffer = (uchar *)realloc(buf, NewSize)) { Size = NewSize; buf = NewBuffer; memcpy(buf + Offset, p, l); } else { esyslog("ERROR: out of memory"); free(buf); return; } } if (buf) { StillPicture(buf, Size); free(buf); } } } bool cDevice::Replaying(void) const { return player != NULL; } bool cDevice::Transferring(void) const { return cTransferControl::ReceiverDevice() != NULL; } bool cDevice::AttachPlayer(cPlayer *Player) { if (CanReplay()) { if (player) Detach(player); DELETENULL(liveSubtitle); DELETENULL(dvbSubtitleConverter); patPmtParser.Reset(); player = Player; if (!Transferring()) ClrAvailableTracks(false, true); SetPlayMode(player->playMode); player->device = this; player->Activate(true); return true; } return false; } void cDevice::Detach(cPlayer *Player) { if (Player && player == Player) { cPlayer *p = player; player = NULL; // avoids recursive calls to Detach() p->Activate(false); p->device = NULL; cMutexLock MutexLock(&mutexCurrentSubtitleTrack); delete dvbSubtitleConverter; dvbSubtitleConverter = NULL; SetPlayMode(pmNone); SetVideoDisplayFormat(eVideoDisplayFormat(Setup.VideoDisplayFormat)); PlayTs(NULL, 0); patPmtParser.Reset(); Audios.ClearAudio(); isPlayingVideo = false; } } void cDevice::StopReplay(void) { if (player) { Detach(player); if (IsPrimaryDevice()) cControl::Shutdown(); } } bool cDevice::Poll(cPoller &Poller, int TimeoutMs) { return false; } bool cDevice::Flush(int TimeoutMs) { return true; } int cDevice::PlayVideo(const uchar *Data, int Length) { return -1; } int cDevice::PlayAudio(const uchar *Data, int Length, uchar Id) { return -1; } int cDevice::PlaySubtitle(const uchar *Data, int Length) { if (!dvbSubtitleConverter) dvbSubtitleConverter = new cDvbSubtitleConverter; return dvbSubtitleConverter->ConvertFragments(Data, Length); } int cDevice::PlayPesPacket(const uchar *Data, int Length, bool VideoOnly) { bool FirstLoop = true; uchar c = Data[3]; const uchar *Start = Data; const uchar *End = Start + Length; while (Start < End) { int d = End - Start; int w = d; switch (c) { case 0xBE: // padding stream, needed for MPEG1 case 0xE0 ... 0xEF: // video isPlayingVideo = true; w = PlayVideo(Start, d); break; case 0xC0 ... 0xDF: // audio SetAvailableTrack(ttAudio, c - 0xC0, c); if ((!VideoOnly || HasIBPTrickSpeed()) && c == availableTracks[currentAudioTrack].id) { w = PlayAudio(Start, d, c); if (FirstLoop) Audios.PlayAudio(Data, Length, c); } break; case 0xBD: { // private stream 1 int PayloadOffset = Data[8] + 9; // Compatibility mode for old subtitles plugin: if ((Data[7] & 0x01) && (Data[PayloadOffset - 3] & 0x81) == 0x01 && Data[PayloadOffset - 2] == 0x81) PayloadOffset--; uchar SubStreamId = Data[PayloadOffset]; uchar SubStreamType = SubStreamId & 0xF0; uchar SubStreamIndex = SubStreamId & 0x1F; // Compatibility mode for old VDR recordings, where 0xBD was only AC3: pre_1_3_19_PrivateStreamDetected: if (pre_1_3_19_PrivateStream > MIN_PRE_1_3_19_PRIVATESTREAM) { SubStreamId = c; SubStreamType = 0x80; SubStreamIndex = 0; } else if (pre_1_3_19_PrivateStream) pre_1_3_19_PrivateStream--; // every known PS1 packet counts down towards 0 to recover from glitches... switch (SubStreamType) { case 0x20: // SPU case 0x30: // SPU SetAvailableTrack(ttSubtitle, SubStreamIndex, SubStreamId); if ((!VideoOnly || HasIBPTrickSpeed()) && currentSubtitleTrack != ttNone && SubStreamId == availableTracks[currentSubtitleTrack].id) w = PlaySubtitle(Start, d); break; case 0x80: // AC3 & DTS if (Setup.UseDolbyDigital) { SetAvailableTrack(ttDolby, SubStreamIndex, SubStreamId); if ((!VideoOnly || HasIBPTrickSpeed()) && SubStreamId == availableTracks[currentAudioTrack].id) { w = PlayAudio(Start, d, SubStreamId); if (FirstLoop) Audios.PlayAudio(Data, Length, SubStreamId); } } break; case 0xA0: // LPCM SetAvailableTrack(ttAudio, SubStreamIndex, SubStreamId); if ((!VideoOnly || HasIBPTrickSpeed()) && SubStreamId == availableTracks[currentAudioTrack].id) { w = PlayAudio(Start, d, SubStreamId); if (FirstLoop) Audios.PlayAudio(Data, Length, SubStreamId); } break; default: // Compatibility mode for old VDR recordings, where 0xBD was only AC3: if (pre_1_3_19_PrivateStream <= MIN_PRE_1_3_19_PRIVATESTREAM) { dsyslog("unknown PS1 packet, substream id = %02X (counter is at %d)", SubStreamId, pre_1_3_19_PrivateStream); pre_1_3_19_PrivateStream += 2; // ...and every unknown PS1 packet counts up (the very first one counts twice, but that's ok) if (pre_1_3_19_PrivateStream > MIN_PRE_1_3_19_PRIVATESTREAM) { dsyslog("switching to pre 1.3.19 Dolby Digital compatibility mode - substream id = %02X", SubStreamId); ClrAvailableTracks(); pre_1_3_19_PrivateStream = MIN_PRE_1_3_19_PRIVATESTREAM + 1; goto pre_1_3_19_PrivateStreamDetected; } } } } break; default: ;//esyslog("ERROR: unexpected packet id %02X", c); } if (w > 0) Start += w; else { if (Start != Data) esyslog("ERROR: incomplete PES packet write!"); return Start == Data ? w : Start - Data; } FirstLoop = false; } return Length; } int cDevice::PlayPes(const uchar *Data, int Length, bool VideoOnly) { if (!Data) { if (dvbSubtitleConverter) dvbSubtitleConverter->Reset(); return 0; } int i = 0; while (i <= Length - 6) { if (Data[i] == 0x00 && Data[i + 1] == 0x00 && Data[i + 2] == 0x01) { int l = PesLength(Data + i); if (i + l > Length) { esyslog("ERROR: incomplete PES packet!"); return Length; } int w = PlayPesPacket(Data + i, l, VideoOnly); if (w > 0) i += l; else return i == 0 ? w : i; } else i++; } if (i < Length) esyslog("ERROR: leftover PES data!"); return Length; } int cDevice::PlayTsVideo(const uchar *Data, int Length) { // Video PES has no explicit length, so we can only determine the end of // a PES packet when the next TS packet that starts a payload comes in: if (TsPayloadStart(Data)) { int l; while (const uchar *p = tsToPesVideo.GetPes(l)) { int w = PlayVideo(p, l); if (w <= 0) { tsToPesVideo.SetRepeatLast(); return w; } } tsToPesVideo.Reset(); } tsToPesVideo.PutTs(Data, Length); return Length; } int cDevice::PlayTsAudio(const uchar *Data, int Length) { // Audio PES always has an explicit length and consists of single packets: int l; if (const uchar *p = tsToPesAudio.GetPes(l)) { int w = PlayAudio(p, l, p[3]); if (w <= 0) { tsToPesAudio.SetRepeatLast(); return w; } tsToPesAudio.Reset(); } tsToPesAudio.PutTs(Data, Length); return Length; } int cDevice::PlayTsSubtitle(const uchar *Data, int Length) { if (!dvbSubtitleConverter) dvbSubtitleConverter = new cDvbSubtitleConverter; tsToPesSubtitle.PutTs(Data, Length); int l; if (const uchar *p = tsToPesSubtitle.GetPes(l)) { dvbSubtitleConverter->Convert(p, l); tsToPesSubtitle.Reset(); } return Length; } //TODO detect and report continuity errors? int cDevice::PlayTs(const uchar *Data, int Length, bool VideoOnly) { int Played = 0; if (!Data) { tsToPesVideo.Reset(); tsToPesAudio.Reset(); tsToPesSubtitle.Reset(); } else if (Length < TS_SIZE) { esyslog("ERROR: skipped %d bytes of TS fragment", Length); return Length; } else { 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); return Played + Skipped; } int Pid = TsPid(Data); if (TsHasPayload(Data)) { // silently ignore TS packets w/o payload int PayloadOffset = TsPayloadOffset(Data); if (PayloadOffset < TS_SIZE) { if (Pid == PATPID) patPmtParser.ParsePat(Data, TS_SIZE); else if (patPmtParser.IsPmtPid(Pid)) patPmtParser.ParsePmt(Data, TS_SIZE); else if (Pid == patPmtParser.Vpid()) { isPlayingVideo = true; int w = PlayTsVideo(Data, TS_SIZE); if (w < 0) return Played ? Played : w; if (w == 0) break; } else if (Pid == availableTracks[currentAudioTrack].id) { if (!VideoOnly || HasIBPTrickSpeed()) { int w = PlayTsAudio(Data, TS_SIZE); if (w < 0) return Played ? Played : w; if (w == 0) break; Audios.PlayTsAudio(Data, TS_SIZE); } } else if (Pid == availableTracks[currentSubtitleTrack].id) { if (!VideoOnly || HasIBPTrickSpeed()) PlayTsSubtitle(Data, TS_SIZE); } } } else if (Pid == patPmtParser.Ppid()) { int w = PlayTsVideo(Data, TS_SIZE); if (w < 0) return Played ? Played : w; if (w == 0) break; } Played += TS_SIZE; Length -= TS_SIZE; Data += TS_SIZE; } } return Played; } int cDevice::Priority(void) const { int priority = IDLEPRIORITY; if (IsPrimaryDevice() && !Replaying() && HasProgramme()) priority = TRANSFERPRIORITY; // we use the same value here, no matter whether it's actual Transfer Mode or real live viewing cMutexLock MutexLock(&mutexReceiver); for (int i = 0; i < MAXRECEIVERS; i++) { if (receiver[i]) priority = max(receiver[i]->priority, priority); } return priority; } bool cDevice::Ready(void) { return true; } bool cDevice::Receiving(bool Dummy) const { cMutexLock MutexLock(&mutexReceiver); for (int i = 0; i < MAXRECEIVERS; i++) { if (receiver[i]) return true; } return false; } #define TS_SCRAMBLING_TIMEOUT 3 // seconds to wait until a TS becomes unscrambled #define TS_SCRAMBLING_TIME_OK 10 // seconds before a Channel/CAM combination is marked as known to decrypt void cDevice::Action(void) { if (Running() && OpenDvr()) { while (Running()) { // Read data from the DVR device: uchar *b = NULL; if (GetTSPacket(b)) { if (b) { int Pid = TsPid(b); // Check whether the TS packets are scrambled: bool DetachReceivers = false; bool DescramblingOk = false; int CamSlotNumber = 0; if (startScrambleDetection) { cCamSlot *cs = CamSlot(); CamSlotNumber = cs ? cs->SlotNumber() : 0; if (CamSlotNumber) { bool Scrambled = b[3] & TS_SCRAMBLING_CONTROL; int t = time(NULL) - startScrambleDetection; if (Scrambled) { if (t > TS_SCRAMBLING_TIMEOUT) DetachReceivers = true; } else if (t > TS_SCRAMBLING_TIME_OK) { DescramblingOk = true; startScrambleDetection = 0; } } } // Distribute the packet to all attached receivers: Lock(); for (int i = 0; i < MAXRECEIVERS; i++) { if (receiver[i] && receiver[i]->WantsPid(Pid)) { if (DetachReceivers) { ChannelCamRelations.SetChecked(receiver[i]->ChannelID(), CamSlotNumber); Detach(receiver[i]); } else receiver[i]->Receive(b, TS_SIZE); if (DescramblingOk) ChannelCamRelations.SetDecrypt(receiver[i]->ChannelID(), CamSlotNumber); } } Unlock(); } } else break; } CloseDvr(); } } bool cDevice::OpenDvr(void) { return false; } void cDevice::CloseDvr(void) { } bool cDevice::GetTSPacket(uchar *&Data) { return false; } bool cDevice::AttachReceiver(cReceiver *Receiver) { if (!Receiver) return false; if (Receiver->device == this) return true; // activate the following line if you need it - actually the driver should be fixed! //#define WAIT_FOR_TUNER_LOCK #ifdef WAIT_FOR_TUNER_LOCK #define TUNER_LOCK_TIMEOUT 5000 // ms if (!HasLock(TUNER_LOCK_TIMEOUT)) { esyslog("ERROR: device %d has no lock, can't attach receiver!", CardIndex() + 1); return false; } #endif cMutexLock MutexLock(&mutexReceiver); for (int i = 0; i < MAXRECEIVERS; i++) { if (!receiver[i]) { for (int n = 0; n < Receiver->numPids; n++) { if (!AddPid(Receiver->pids[n])) { for ( ; n-- > 0; ) DelPid(Receiver->pids[n]); return false; } } Receiver->Activate(true); Lock(); Receiver->device = this; receiver[i] = Receiver; Unlock(); if (camSlot) { camSlot->StartDecrypting(); startScrambleDetection = time(NULL); } Start(); return true; } } esyslog("ERROR: no free receiver slot!"); return false; } void cDevice::Detach(cReceiver *Receiver) { if (!Receiver || Receiver->device != this) return; bool receiversLeft = false; cMutexLock MutexLock(&mutexReceiver); for (int i = 0; i < MAXRECEIVERS; i++) { if (receiver[i] == Receiver) { Lock(); receiver[i] = NULL; Receiver->device = NULL; Unlock(); Receiver->Activate(false); for (int n = 0; n < Receiver->numPids; n++) DelPid(Receiver->pids[n]); } else if (receiver[i]) receiversLeft = true; } if (camSlot) camSlot->StartDecrypting(); if (!receiversLeft) Cancel(-1); } void cDevice::DetachAll(int Pid) { if (Pid) { cMutexLock MutexLock(&mutexReceiver); for (int i = 0; i < MAXRECEIVERS; i++) { cReceiver *Receiver = receiver[i]; if (Receiver && Receiver->WantsPid(Pid)) Detach(Receiver); } } } void cDevice::DetachAllReceivers(void) { cMutexLock MutexLock(&mutexReceiver); for (int i = 0; i < MAXRECEIVERS; i++) Detach(receiver[i]); } // --- cTSBuffer ------------------------------------------------------------- cTSBuffer::cTSBuffer(int File, int Size, int CardIndex) { SetDescription("TS buffer on device %d", CardIndex); f = File; cardIndex = CardIndex; delivered = false; ringBuffer = new cRingBufferLinear(Size, TS_SIZE, true, "TS"); ringBuffer->SetTimeouts(100, 100); ringBuffer->SetIoThrottle(); Start(); } cTSBuffer::~cTSBuffer() { Cancel(3); delete ringBuffer; } void cTSBuffer::Action(void) { if (ringBuffer) { bool firstRead = true; cPoller Poller(f); while (Running()) { if (firstRead || Poller.Poll(100)) { firstRead = false; int r = ringBuffer->Read(f); if (r < 0 && FATALERRNO) { if (errno == EOVERFLOW) esyslog("ERROR: driver buffer overflow on device %d", cardIndex); else { LOG_ERROR; break; } } } } } } uchar *cTSBuffer::Get(void) { int Count = 0; if (delivered) { ringBuffer->Del(TS_SIZE); delivered = false; } uchar *p = ringBuffer->Get(Count); if (p && Count >= TS_SIZE) { if (*p != TS_SYNC_BYTE) { for (int i = 1; i < Count; i++) { if (p[i] == TS_SYNC_BYTE) { Count = i; break; } } ringBuffer->Del(Count); esyslog("ERROR: skipped %d bytes to sync on TS packet on device %d", Count, cardIndex); return NULL; } delivered = true; return p; } return NULL; }