1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
|
/*
* device.h: The basic device interface
*
* See the main source file 'vdr.c' for copyright information and
* how to reach the author.
*
* $Id: device.h 1.3 2002/06/23 11:50:24 kls Exp $
*/
#ifndef __DEVICE_H
#define __DEVICE_H
#include <stdlib.h> // FIXME: this is apparently necessary for the ost/... header files
// FIXME: shouldn't every header file include ALL the other header
// FIXME: files it depends on? The sequence in which header files
// FIXME: are included here should not matter - and it should NOT
// FIXME: be necessary to include <stdlib.h> here!
#include <ost/dmx.h>
#include <ost/frontend.h>
#include <ost/audio.h>
#include <ost/video.h>
#include "eit.h"
#include "thread.h"
enum eSetChannelResult { scrOk, scrNoTransfer, scrFailed };
#define MAXDEVICES 4 // the maximum number of devices in the system
#define MAXCACAPS 16 // the maximum number of different CA values per DVB device
#define MAXPIDHANDLES 16 // the maximum number of different PIDs per DVB device
#define MAXRECEIVERS 16 // the maximum number of receivers per DVB device
#define MAXVOLUME 255
#define VOLUMEDELTA 5 // used to increase/decrease the volume
class cPlayer;
class cReceiver;
class cDevice : cThread {
friend class cOsd;//XXX
private:
static int numDevices;
static int useDevice;
static cDevice *device[MAXDEVICES];
static cDevice *primaryDevice;
public:
static int NumDevices(void) { return numDevices; }
// Returns the total number of DVB devices.
static void SetUseDevice(int n);
// Sets the 'useDevice' flag of the given DVB device.
// If this function is not called before Initialize(), all DVB devices
// will be used.
static bool SetPrimaryDevice(int n);
// Sets the primary DVB device to 'n' (which must be in the range
// 1...numDevices) and returns true if this was possible.
static cDevice *PrimaryDevice(void) { return primaryDevice; }
// Returns the primary DVB device.
static cDevice *GetDevice(int Ca, int Priority, int Frequency = 0, int Vpid = 0, bool *ReUse = NULL);
// Selects a free DVB device, avoiding the primaryDevice if possible.
// If Ca is not 0, the device with the given number will be returned
// in case Ca is <= MAXDEVICES, or the device that provides the given
// value in its caCaps.
// If there is a device that is already tuned to the given Frequency,
// and that device is able to receive multiple channels ("budget" cards),
// that device will be returned. Else if a ("full featured") device is
// tuned to Frequency and Vpid, that one will be returned.
// If all DVB devices are currently receiving, the one receiving the
// lowest priority timer (if any) that is lower than the given Priority
// will be returned.
// If ReUse is given, the caller will be informed whether the device can be re-used
// for a new recording. If ReUse returns 'true', the caller must NOT switch the channel
// (the device is already properly tuned). Otherwise the caller MUST switch the channel.
static void SetCaCaps(void);
// Sets the CaCaps of all DVB devices according to the Setup data.
static bool Probe(const char *FileName);
// Probes for existing DVB devices.
static bool Initialize(void);
// Initializes the DVB devices.
// Must be called before accessing any DVB functions.
static void Shutdown(void);
// Closes down all DVB devices.
// Must be called at the end of the program.
private:
int cardIndex;
int caCaps[MAXCACAPS];
FrontendType frontendType;
char *dvrFileName;
bool active;
int fd_osd, fd_frontend, fd_sec, fd_audio, fd_video;
int OsdDeviceHandle(void) { return fd_osd; }
public:
cDevice(int n);
virtual ~cDevice();
bool IsPrimaryDevice(void) { return this == primaryDevice; }
int CardIndex(void) const { return cardIndex; }
// Returns the card index of this device (0 ... MAXDEVICES - 1).
int ProvidesCa(int Ca);
// Checks whether this DVB device provides the given value in its
// caCaps. Returns 0 if the value is not provided, 1 if only this
// value is provided, and > 1 if this and other values are provided.
// If the given value is equal to the number of this DVB device,
// 1 is returned. If it is 0 (FTA), 1 plus the number of other values
// in caCaps is returned.
bool HasDecoder(void) const { return fd_video >= 0 && fd_audio >= 0; }
// Channel facilities
private:
int currentChannel;
int frequency;
public:
eSetChannelResult SetChannel(int ChannelNumber, int Frequency, char Polarization, int Diseqc, int Srate, int Vpid, int Apid, int Tpid, int Ca, int Pnr);
static int CurrentChannel(void) { return primaryDevice ? primaryDevice->currentChannel : 0; }
int Channel(void) { return currentChannel; }
// PID handle facilities
private:
enum ePidType { ptVideo, ptAudio, ptTeletext, ptDolby, ptOther };
class cPidHandle {
public:
int pid;
int fd;
int used;
cPidHandle(void) { pid = used = 0; fd = -1; }
};
cPidHandle pidHandles[MAXPIDHANDLES];
bool AddPid(int Pid, ePidType PidType = ptOther);
bool DelPid(int Pid);
bool SetPid(int fd, dmxPesType_t PesType, int Pid, dmxOutput_t Output);
virtual void Action(void);
// Image Grab facilities
public:
bool GrabImage(const char *FileName, bool Jpeg = true, int Quality = -1, int SizeX = -1, int SizeY = -1);
// Video format facilities
public:
virtual void SetVideoFormat(videoFormat_t Format);
// Volume facilities
private:
bool mute;
int volume;
public:
bool IsMute(void) { return mute; }
bool ToggleMute(void);
// Turns the volume off or on and returns the new mute state.
void SetVolume(int Volume, bool Absolute = false);
// Sets the volume to the given value, either absolutely or relative to
// the current volume.
static int CurrentVolume(void) { return primaryDevice ? primaryDevice->volume : 0; }//XXX???
// EIT facilities
private:
cSIProcessor *siProcessor;
// Player facilities
private:
cPlayer *player;
public:
void TrickSpeed(int Speed);
void Clear(void);
void Play(void);
void Freeze(void);
void Mute(void);
void StillPicture(const uchar *Data, int Length);
bool Replaying(void);
// Returns true if we are currently replaying.
void StopReplay(void);
// Stops the current replay session (if any).
bool AttachPlayer(cPlayer *Player);
void Detach(cPlayer *Player);
virtual int PlayVideo(const uchar *Data, int Length);
virtual int PlayAudio(const uchar *Data, int Length);
// Receiver facilities
private:
cReceiver *receiver[MAXRECEIVERS];
int ca;
int Priority(void);
// Returns the priority of the current receiving session (0..MAXPRIORITY),
// or -1 if no receiver is currently active. The primary DVB device will
// always return at least Setup.PrimaryLimit-1.
int CanShift(int Ca, int Priority, int UsedCards = 0);
public:
int Ca(void) { return ca; }
// Returns the ca of the current receiving session.
bool Receiving(void);
// Returns true if we are currently receiving.
bool AttachReceiver(cReceiver *Receiver);
void Detach(cReceiver *Receiver);
};
#endif //__DEVICE_H
|
