1
0
mirror of https://github.com/VDR4Arch/vdr.git synced 2023-10-10 13:36:52 +02:00
vdr/dvbapi.h

338 lines
12 KiB
C
Raw Normal View History

2000-02-19 13:36:48 +01:00
/*
* dvbapi.h: Interface to the DVB driver
*
2000-04-24 09:46:05 +02:00
* See the main source file 'vdr.c' for copyright information and
2000-02-19 13:36:48 +01:00
* how to reach the author.
*
2001-09-14 14:06:43 +02:00
* $Id: dvbapi.h 1.49 2001/09/09 14:37:18 kls Exp $
2000-02-19 13:36:48 +01:00
*/
#ifndef __DVBAPI_H
#define __DVBAPI_H
2000-07-15 12:39:20 +02:00
#if defined(DEBUG_OSD) || defined(REMOTE_KBD)
#include <ncurses.h>
#endif
#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 <linux/videodev.h>
#include <ost/dmx.h>
#include <ost/sec.h>
#include <ost/frontend.h>
#include <ost/video.h>
#include <ost/audio.h>
#include <ost/osd.h>
#include <stdio.h>
2001-08-03 14:18:08 +02:00
2000-10-03 10:34:48 +02:00
#include "dvbosd.h"
2001-08-06 16:19:20 +02:00
#ifdef DVDSUPPORT
2001-08-03 14:18:08 +02:00
#include "dvd.h"
2001-08-06 16:19:20 +02:00
#endif //DVDSUPPORT
2000-10-29 13:17:22 +01:00
#include "eit.h"
2000-12-28 12:57:16 +01:00
#include "thread.h"
2000-09-17 13:47:06 +02:00
// Overlay facilities
#define MAXCLIPRECTS 100
typedef struct CRect {
signed short x, y, width, height;
};
#define FRAMESPERSEC 25
2001-08-25 13:52:38 +02:00
// The maximum file size is limited by the range that can be covered
// with 'int'. 4GB might be possible (if the range is considered
// 'unsigned'), 2GB should be possible (even if the range is considered
// 'signed'), so let's use 2000MB for absolute safety (the actual file size
// may be slightly higher because we stop recording only before the next
// 'I' frame, to have a complete Group Of Pictures):
#define MAXVIDEOFILESIZE 2000 // MB
#define MINVIDEOFILESIZE 100 // MB
2000-12-28 12:57:16 +01:00
const char *IndexToHMSF(int Index, bool WithFrame = false);
2000-12-09 11:13:00 +01:00
// Converts the given index to a string, optionally containing the frame number.
2000-12-28 12:57:16 +01:00
int HMSFToIndex(const char *HMSF);
// Converts the given string (format: "hh:mm:ss.ff") to an index.
enum eSetChannelResult { scrOk, scrNoTransfer, scrFailed };
class cChannel;
2000-12-08 16:23:32 +01:00
class cRecordBuffer;
2001-08-03 14:18:08 +02:00
class cPlayBuffer;
2000-12-08 16:23:32 +01:00
class cReplayBuffer;
2001-08-06 16:19:20 +02:00
#ifdef DVDSUPPORT
2001-08-03 14:18:08 +02:00
class cDVDplayBuffer;
2001-08-06 16:19:20 +02:00
#endif //DVDSUPPORT
2000-11-19 16:49:14 +01:00
class cTransferBuffer;
2000-12-28 12:57:16 +01:00
class cCuttingBuffer;
class cVideoCutter {
private:
static cCuttingBuffer *cuttingBuffer;
public:
static bool Start(const char *FileName);
static void Stop(void);
static bool Active(void);
};
2000-11-19 16:49:14 +01:00
class cDvbApi {
friend class cRecordBuffer;
friend class cReplayBuffer;
2001-08-06 16:19:20 +02:00
#ifdef DVDSUPPORT
2001-08-03 14:18:08 +02:00
friend class cDVDplayBuffer;
2001-08-06 16:19:20 +02:00
#endif //DVDSUPPORT
friend class cTransferBuffer;
private:
int videoDev;
2001-06-24 17:42:19 +02:00
int fd_osd, fd_qpskfe, fd_qamfe, fd_sec, fd_dvr, fd_audio, fd_video, fd_demuxa1, fd_demuxa2, fd_demuxd1, fd_demuxd2, fd_demuxv, fd_demuxt;
int vPid, aPid1, aPid2, dPid1, dPid2;
bool SetPid(int fd, dmxPesType_t PesType, int Pid, dmxOutput_t Output);
bool SetVpid(int Vpid, dmxOutput_t Output) { return SetPid(fd_demuxv, DMX_PES_VIDEO, Vpid, Output); }
2001-06-14 15:57:30 +02:00
bool SetApid1(int Apid, dmxOutput_t Output) { return SetPid(fd_demuxa1, DMX_PES_AUDIO, Apid, Output); }
bool SetApid2(int Apid, dmxOutput_t Output) { return SetPid(fd_demuxa2, DMX_PES_OTHER, Apid, Output); }
2001-06-24 17:42:19 +02:00
bool SetDpid1(int Dpid, dmxOutput_t Output) { return SetPid(fd_demuxd1, DMX_PES_OTHER, Dpid, Output); }
bool SetDpid2(int Dpid, dmxOutput_t Output) { return SetPid(fd_demuxd2, DMX_PES_OTHER, Dpid, Output); }
bool SetTpid(int Tpid, dmxOutput_t Output) { return SetPid(fd_demuxt, DMX_PES_TELETEXT, Tpid, Output); }
bool SetPids(bool ForRecording);
cDvbApi(int n);
2000-02-19 13:36:48 +01:00
public:
~cDvbApi();
2001-02-10 13:13:49 +01:00
#define MAXDVBAPI 4
2000-05-01 16:29:46 +02:00
static int NumDvbApis;
private:
static cDvbApi *dvbApi[MAXDVBAPI];
2001-02-02 15:49:46 +01:00
static int useDvbApi;
int cardIndex;
2000-05-01 16:29:46 +02:00
public:
static cDvbApi *PrimaryDvbApi;
2001-02-02 15:49:46 +01:00
static void SetUseDvbApi(int n);
// Sets the 'useDvbApi' flag of the given DVB device.
// If this function is not called before Init(), all DVB devices
// will be used.
2000-09-10 10:51:58 +02:00
static bool SetPrimaryDvbApi(int n);
// Sets the primary DVB device to 'n' (which must be in the range
// 1...NumDvbApis) and returns true if this was possible.
static cDvbApi *GetDvbApi(int Ca, int Priority);
2000-09-10 10:51:58 +02:00
// Selects a free DVB device, starting with the highest device number
// (but avoiding, if possible, the PrimaryDvbApi).
// If Ca is not 0, the device with the given number will be returned.
// If all DVB devices are currently recording, the one recording the
// lowest priority timer (if any) that is lower than the given Priority
// will be returned.
// The caller must check whether the returned DVB device is actually
// recording and stop recording if necessary.
int CardIndex(void) { return cardIndex; }
// Returns the card index of this DvbApi (0 ... MAXDVBAPI - 1).
static bool Probe(const char *FileName);
// Probes for existing DVB devices.
2000-05-01 16:29:46 +02:00
static bool Init(void);
// Initializes the DVB API.
2000-05-01 16:29:46 +02:00
// Must be called before accessing any DVB functions.
static void Cleanup(void);
// Closes down all DVB devices.
// Must be called at the end of the program.
2000-10-29 13:17:22 +01:00
// EIT facilities
private:
cSIProcessor *siProcessor;
public:
2000-10-29 13:17:22 +01:00
const cSchedules *Schedules(cThreadLock *ThreadLock) const;
// Caller must provide a cThreadLock which has to survive the entire
// time the returned cSchedules is accessed. Once the cSchedules is no
// longer used, the cThreadLock must be destroyed.
void SetUseTSTime(bool On) { if (siProcessor) siProcessor->SetUseTSTime(On); }
2000-09-17 11:53:35 +02:00
// Image Grab facilities
bool GrabImage(const char *FileName, bool Jpeg = true, int Quality = -1, int SizeX = -1, int SizeY = -1);
2000-09-17 13:47:06 +02:00
// Overlay facilities
private:
bool ovlStat, ovlGeoSet, ovlFbSet;
int ovlSizeX, ovlSizeY, ovlPosX, ovlPosY, ovlBpp, ovlPalette, ovlClips, ovlClipCount;
int ovlFbSizeX, ovlFbSizeY;
__u16 ovlBrightness, ovlColour, ovlHue, ovlContrast;
struct video_clip ovlClipRects[MAXCLIPRECTS];
public:
bool OvlF(int SizeX, int SizeY, int FbAddr, int Bpp, int Palette);
bool OvlG(int SizeX, int SizeY, int PosX, int PosY);
bool OvlC(int ClipCount, CRect *Cr);
bool OvlP(__u16 Brightness, __u16 Color, __u16 Hue, __u16 Contrast);
bool OvlO(bool Value);
// On Screen Display facilities
2000-02-19 13:36:48 +01:00
private:
enum { charWidth = 12, // average character width
lineHeight = 27 // smallest text height
};
#ifdef DEBUG_OSD
WINDOW *window;
enum { MaxColorPairs = 16 };
int colorPairs[MaxColorPairs];
void SetColor(eDvbColor colorFg, eDvbColor colorBg = clrBackground);
2000-10-03 10:34:48 +02:00
#else
cDvbOsd *osd;
#endif
int cols, rows;
public:
2000-04-23 15:38:16 +02:00
void Open(int w, int h);
void Close(void);
void Clear(void);
void Fill(int x, int y, int w, int h, eDvbColor color = clrBackground);
2000-12-09 11:13:00 +01:00
void SetBitmap(int x, int y, const cBitmap &Bitmap);
void ClrEol(int x, int y, eDvbColor color = clrBackground);
2000-11-01 11:45:05 +01:00
int CellWidth(void);
2000-12-09 11:13:00 +01:00
int LineHeight(void);
2000-11-01 11:45:05 +01:00
int Width(unsigned char c);
int WidthInCells(const char *s);
2000-11-18 15:46:00 +01:00
eDvbFont SetFont(eDvbFont Font);
void Text(int x, int y, const char *s, eDvbColor colorFg = clrWhite, eDvbColor colorBg = clrBackground);
2000-10-03 10:34:48 +02:00
void Flush(void);
2001-06-16 14:31:14 +02:00
// Video format facilities:
void SetVideoFormat(videoFormat_t Format);
// Channel facilities
2000-11-05 18:39:17 +01:00
private:
int currentChannel;
public:
eSetChannelResult SetChannel(int ChannelNumber, int FrequencyMHz, char Polarization, int Diseqc, int Srate, int Vpid, int Apid1, int Apid2, int Dpid1, int Dpid2, int Tpid, int Ca, int Pnr);
2000-11-05 18:39:17 +01:00
static int CurrentChannel(void) { return PrimaryDvbApi ? PrimaryDvbApi->currentChannel : 0; }
int Channel(void) { return currentChannel; }
2000-11-19 16:49:14 +01:00
// Transfer facilities
private:
cTransferBuffer *transferBuffer;
cDvbApi *transferringFromDvbApi;
public:
bool Transferring(void);
// Returns true if we are currently transferring video data.
private:
cDvbApi *StartTransfer(int TransferToVideoDev);
// Starts transferring video data from this DVB device to TransferToVideoDev.
void StopTransfer(void);
// Stops transferring video data (in case a transfer is currently active).
// Record/Replay facilities
private:
2000-12-08 16:23:32 +01:00
cRecordBuffer *recordBuffer;
2001-08-03 14:18:08 +02:00
cPlayBuffer *replayBuffer;
int ca;
int priority;
int Ca(void) { return ca; }
// Returns the ca of the current recording session (0..MAXDVBAPI).
int Priority(void) { return priority; }
// Returns the priority of the current recording session (0..MAXPRIORITY),
// or -1 if no recording is currently active.
int SetModeRecord(void);
// Initiates recording mode and returns the file handle to read from.
void SetModeReplay(void);
void SetModeNormal(bool FromRecording);
public:
2000-12-28 12:57:16 +01:00
int SecondsToFrames(int Seconds);
// Returns the number of frames corresponding to the given number of seconds.
bool Recording(void);
// Returns true if we are currently recording.
bool Replaying(void);
// Returns true if we are currently replaying.
bool StartRecord(const char *FileName, int Ca, int Priority);
// Starts recording the current channel into the given file, with
// the given ca and priority.
// In order to be able to record longer movies,
// a numerical suffix will be appended to the file name. The inital
// value of that suffix will be larger than any existing file under
// the given name, thus allowing an interrupted recording to continue
// gracefully.
// Returns true if recording was started successfully.
// If there is already a recording session active, false will be
// returned.
void StopRecord(void);
// Stops the current recording session (if any).
2000-12-09 11:13:00 +01:00
bool StartReplay(const char *FileName);
// Starts replaying the given file.
// If there is already a replay session active, it will be stopped
// and the new file will be played back.
2001-08-06 16:19:20 +02:00
#ifdef DVDSUPPORT
2001-08-03 14:18:08 +02:00
bool StartDVDplay(cDVD *dvd, int TitleID);//XXX dvd parameter necessary???
// Starts replaying the given TitleID on the DVD.
2001-08-06 16:19:20 +02:00
#endif //DVDSUPPORT
2000-12-08 16:23:32 +01:00
void StopReplay(void);
// Stops the current replay session (if any).
void Pause(void);
// Pauses the current replay session, or resumes a paused session.
void Play(void);
// Resumes normal replay mode.
void Forward(void);
// Runs the current replay session forward at a higher speed.
void Backward(void);
// Runs the current replay session backwards at a higher speed.
2000-12-28 12:57:16 +01:00
void SkipSeconds(int Seconds);
// Skips the given number of seconds in the current replay session.
// The sign of 'Seconds' determines the direction in which to skip.
// Use a very large negative value to go all the way back to the
// beginning of the recording.
2000-12-28 12:57:16 +01:00
int SkipFrames(int Frames);
// Returns the new index into the current replay session after skipping
// the given number of frames (no actual repositioning is done!).
// The sign of 'Frames' determines the direction in which to skip.
bool GetIndex(int &Current, int &Total, bool SnapToIFrame = false);
// Returns the current and total frame index, optionally snapped to the
// nearest I-frame.
2001-09-14 14:06:43 +02:00
bool GetReplayMode(bool &Play, bool &Forward, int &Speed);
// Returns the current replay mode (if applicable).
// 'Play' tells whether we are playing or pausing, 'Forward' tells whether
// we are going forward or backward and 'Speed' is -1 if this is normal
// play/pause mode, 0 if it is single speed fast/slow forward/back mode
// and >0 if this is multi speed mode.
2001-01-07 17:00:50 +01:00
void Goto(int Index, bool Still = false);
// Positions to the given index and displays that frame as a still picture
// if Still is true.
2001-06-14 15:57:30 +02:00
// Audio track facilities
2001-06-24 17:42:19 +02:00
public:
2001-06-14 15:57:30 +02:00
bool CanToggleAudioTrack(void);
// Returns true if we are currently replaying and this recording has two
// audio tracks, or if the current channel has two audio PIDs.
bool ToggleAudioTrack(void);
// Toggles the audio track if possible.
2001-06-24 17:42:19 +02:00
// Dolby Digital audio facilities
private:
static char *audioCommand;
public:
static void SetAudioCommand(const char *Command);
static const char *AudioCommand(void) { return audioCommand; }
};
2000-05-01 16:29:46 +02:00
class cEITScanner {
private:
enum { ActivityTimeout = 60,
ScanTimeout = 20
};
time_t lastScan, lastActivity;
int currentChannel, lastChannel;
int numTransponders, *transponders;
bool TransponderScanned(cChannel *Channel);
public:
cEITScanner(void);
~cEITScanner();
bool Active(void) { return currentChannel; }
void Activity(void);
void Process(void);
};
2000-02-19 13:36:48 +01:00
#endif //__DVBAPI_H