frodovdr
/
vdr-plugin-femon
mirror of https://github.com/rofafor/vdr-plugin-femon.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Refactored class members.

This commit is contained in:
Rolf Ahrenberg 2015-03-07 18:22:02 +02:00
parent 9420ab95e3
commit bdb9595cbe
23 changed files with 1284 additions and 1279 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
HISTORY
View File

@ -519,3 +519,7 @@ VDR Plugin 'femon' Revision History
- Updated CA definitions.
- Fixed the SVDRP service IP menu item (Thanks to Toerless Eckert).
- Fixed the detaching of receiver during a channel switch.
2015-XX-XX: Version 2.2.1
-

240
femon.c
View File

@ -22,7 +22,7 @@
#define GITVERSION ""
#endif
static const char VERSION[] = "2.2.0" GITVERSION;
static const char VERSION[] = "2.2.1" GITVERSION;
static const char DESCRIPTION[] = trNOOP("DVB Signal Information Monitor (OSD)");
static const char MAINMENUENTRY[] = trNOOP("Signal Information");
@ -40,13 +40,13 @@ public:
virtual void Housekeeping(void);
virtual void MainThreadHook(void) {}
virtual cString Active(void) { return NULL; }
virtual const char *MainMenuEntry(void) { return (femonConfig.hidemenu ? NULL : tr(MAINMENUENTRY)); }
virtual const char *MainMenuEntry(void) { return (FemonConfig.hidemenu ? NULL : tr(MAINMENUENTRY)); }
virtual cOsdObject *MainMenuAction(void);
virtual cMenuSetupPage *SetupMenu(void);
virtual bool SetupParse(const char *Name, const char *Value);
virtual bool Service(const char *Id, void *Data);
virtual bool SetupParse(const char *nameP, const char *valueP);
virtual bool Service(const char *idP, void *dataP);
virtual const char **SVDRPHelpPages(void);
virtual cString SVDRPCommand(const char *Command, const char *Option, int &ReplyCode);
virtual cString SVDRPCommand(const char *commandP, const char *optionP, int &replyCodeP);
};
cPluginFemon::cPluginFemon()
@ -108,35 +108,35 @@ cOsdObject *cPluginFemon::MainMenuAction(void)
return NULL;
}
bool cPluginFemon::SetupParse(const char *Name, const char *Value)
bool cPluginFemon::SetupParse(const char *nameP, const char *valueP)
{
// Parse your own setup parameters and store their values.
if (!strcasecmp(Name, "HideMenu")) femonConfig.hidemenu = atoi(Value);
else if (!strcasecmp(Name, "DisplayMode")) femonConfig.displaymode = atoi(Value);
else if (!strcasecmp(Name, "Position")) femonConfig.position = atoi(Value);
else if (!strcasecmp(Name, "Skin")) femonConfig.skin = atoi(Value);
else if (!strcasecmp(Name, "Theme")) femonConfig.theme = atoi(Value);
else if (!strcasecmp(Name, "Downscale")) femonConfig.downscale = atoi(Value);
else if (!strcasecmp(Name, "RedLimit")) femonConfig.redlimit = atoi(Value);
else if (!strcasecmp(Name, "GreenLimit")) femonConfig.greenlimit = atoi(Value);
else if (!strcasecmp(Name, "UpdateInterval")) femonConfig.updateinterval = atoi(Value);
else if (!strcasecmp(Name, "AnalStream")) femonConfig.analyzestream = atoi(Value);
else if (!strcasecmp(Name, "CalcInterval")) femonConfig.calcinterval = atoi(Value);
else if (!strcasecmp(Name, "UseSvdrp")) femonConfig.usesvdrp = atoi(Value);
else if (!strcasecmp(Name, "ServerPort")) femonConfig.svdrpport = atoi(Value);
else if (!strcasecmp(Name, "ServerIp")) strn0cpy(femonConfig.svdrpip, Value, sizeof(femonConfig.svdrpip));
if (!strcasecmp(nameP, "HideMenu")) FemonConfig.hidemenu = atoi(valueP);
else if (!strcasecmp(nameP, "DisplayMode")) FemonConfig.displaymode = atoi(valueP);
else if (!strcasecmp(nameP, "Position")) FemonConfig.position = atoi(valueP);
else if (!strcasecmp(nameP, "Skin")) FemonConfig.skin = atoi(valueP);
else if (!strcasecmp(nameP, "Theme")) FemonConfig.theme = atoi(valueP);
else if (!strcasecmp(nameP, "Downscale")) FemonConfig.downscale = atoi(valueP);
else if (!strcasecmp(nameP, "RedLimit")) FemonConfig.redlimit = atoi(valueP);
else if (!strcasecmp(nameP, "GreenLimit")) FemonConfig.greenlimit = atoi(valueP);
else if (!strcasecmp(nameP, "UpdateInterval")) FemonConfig.updateinterval = atoi(valueP);
else if (!strcasecmp(nameP, "AnalStream")) FemonConfig.analyzestream = atoi(valueP);
else if (!strcasecmp(nameP, "CalcInterval")) FemonConfig.calcinterval = atoi(valueP);
else if (!strcasecmp(nameP, "UseSvdrp")) FemonConfig.usesvdrp = atoi(valueP);
else if (!strcasecmp(nameP, "ServerPort")) FemonConfig.svdrpport = atoi(valueP);
else if (!strcasecmp(nameP, "ServerIp")) strn0cpy(FemonConfig.svdrpip, valueP, sizeof(FemonConfig.svdrpip));
else
return false;
if (femonConfig.displaymode < 0 || femonConfig.displaymode >= eFemonModeMaxNumber) femonConfig.displaymode = 0;
if (FemonConfig.displaymode < 0 || FemonConfig.displaymode >= eFemonModeMaxNumber) FemonConfig.displaymode = 0;
return true;
}
bool cPluginFemon::Service(const char *Id, void *Data)
bool cPluginFemon::Service(const char *idP, void *dataP)
{
if (strcmp(Id,"FemonService-v1.0") == 0) {
if (Data) {
FemonService_v1_0 *data = reinterpret_cast<FemonService_v1_0*>(Data);
if (strcmp(idP, "FemonService-v1.0") == 0) {
if (dataP) {
FemonService_v1_0 *data = reinterpret_cast<FemonService_v1_0*>(dataP);
if (!cDevice::ActualDevice())
return false;
cDvbDevice *dev = getDvbDevice(cDevice::ActualDevice());
@ -196,82 +196,82 @@ const char **cPluginFemon::SVDRPHelpPages(void)
return HelpPages;
}
cString cPluginFemon::SVDRPCommand(const char *Command, const char *Option, int &ReplyCode)
cString cPluginFemon::SVDRPCommand(const char *commandP, const char *optionP, int &replyCodeP)
{
cDvbDevice *dev = getDvbDevice(cDevice::ActualDevice());
if (*Option && isnumber(Option)) {
cDvbDevice *dev2 = dynamic_cast<cDvbDevice*>(cDevice::GetDevice(int(strtol(Option, NULL, 10))));
if (*optionP && isnumber(optionP)) {
cDvbDevice *dev2 = dynamic_cast<cDvbDevice*>(cDevice::GetDevice(int(strtol(optionP, NULL, 10))));
if (dev2)
dev = dev2;
}
if (cReplayControl::NowReplaying() || !dev) {
ReplyCode = 550; // Requested action not taken
replyCodeP = 550; // Requested action not taken
return cString("Cannot open femon plugin while replaying");
}
if (strcasecmp(Command, "OPEN") == 0) {
if (strcasecmp(commandP, "OPEN") == 0) {
if (!cFemonOsd::Instance())
cRemote::CallPlugin(Name());
return cString("Opening femon plugin");
}
else if (strcasecmp(Command, "QUIT") == 0) {
else if (strcasecmp(commandP, "QUIT") == 0) {
if (cFemonOsd::Instance())
cRemote::Put(kBack);
return cString("Closing femon plugin");
}
else if (strcasecmp(Command, "NEXT") == 0) {
else if (strcasecmp(commandP, "NEXT") == 0) {
if (cFemonOsd::Instance())
return cString::sprintf("Switching to next device: %s", cFemonOsd::Instance()->DeviceSwitch(1) ? "ok" : "failed");
else
return cString("Cannot switch device");
}
else if (strcasecmp(Command, "PREV") == 0) {
else if (strcasecmp(commandP, "PREV") == 0) {
if (cFemonOsd::Instance())
return cString::sprintf("Switching to previous device: %s", cFemonOsd::Instance()->DeviceSwitch(-1) ? "ok" : "failed");
else
return cString("Cannot switch device");
}
else if (strcasecmp(Command, "INFO") == 0) {
else if (strcasecmp(commandP, "INFO") == 0) {
return getFrontendInfo(dev);
}
else if (strcasecmp(Command, "NAME") == 0) {
else if (strcasecmp(commandP, "NAME") == 0) {
return getFrontendName(dev);
}
else if (strcasecmp(Command, "STAT") == 0) {
else if (strcasecmp(commandP, "STAT") == 0) {
return getFrontendStatus(dev);
}
else if (strcasecmp(Command, "STRG") == 0) {
else if (strcasecmp(commandP, "STRG") == 0) {
return cString::sprintf("%d on device #%d", dev->SignalStrength(), dev->CardIndex());
}
else if (strcasecmp(Command, "QUAL") == 0) {
else if (strcasecmp(commandP, "QUAL") == 0) {
return cString::sprintf("%d on device #%d", dev->SignalQuality(), dev->CardIndex());
}
else if (strcasecmp(Command, "SGNL") == 0) {
else if (strcasecmp(commandP, "SGNL") == 0) {
int value = getSignal(dev);
return cString::sprintf("%04X (%02d%%) on device #%d", value, value / 655, dev->CardIndex());
}
else if (strcasecmp(Command, "SNRA") == 0) {
else if (strcasecmp(commandP, "SNRA") == 0) {
int value = getSNR(dev);
return cString::sprintf("%04X (%02d%%) on device #%d", value, value / 655, dev->CardIndex());
}
else if (strcasecmp(Command, "BERA") == 0) {
else if (strcasecmp(commandP, "BERA") == 0) {
return cString::sprintf("%08X on device #%d", getBER(dev), dev->CardIndex());
}
else if (strcasecmp(Command, "UNCB") == 0) {
else if (strcasecmp(commandP, "UNCB") == 0) {
return cString::sprintf("%08X on device #%d", getUNC(dev), dev->CardIndex());
}
else if (strcasecmp(Command, "VIBR") == 0) {
else if (strcasecmp(commandP, "VIBR") == 0) {
if (cFemonOsd::Instance())
return cString::sprintf("%s on device #%d", *getBitrateMbits(cFemonOsd::Instance()->GetVideoBitrate()), cDevice::ActualDevice()->CardIndex());
else
return cString::sprintf("--- Mbit/s on device #%d", cDevice::ActualDevice()->CardIndex());
}
else if (strcasecmp(Command, "AUBR") == 0) {
else if (strcasecmp(commandP, "AUBR") == 0) {
if (cFemonOsd::Instance())
return cString::sprintf("%s on device #%d", *getBitrateKbits(cFemonOsd::Instance()->GetAudioBitrate()), cDevice::ActualDevice()->CardIndex());
else
return cString::sprintf("--- kbit/s on device #%d", cDevice::ActualDevice()->CardIndex());
}
else if (strcasecmp(Command, "DDBR") == 0) {
else if (strcasecmp(commandP, "DDBR") == 0) {
if (cFemonOsd::Instance())
return cString::sprintf("%s on device #%d", *getBitrateKbits(cFemonOsd::Instance()->GetDolbyBitrate()), cDevice::ActualDevice()->CardIndex());
else
@ -282,42 +282,42 @@ cString cPluginFemon::SVDRPCommand(const char *Command, const char *Option, int
class cMenuFemonSetup : public cMenuSetupPage {
private:
const char *dispmodes[eFemonModeMaxNumber];
const char *skins[eFemonSkinMaxNumber];
const char *themes[eFemonThemeMaxNumber];
cFemonConfig data;
cVector<const char*> help;
const char *dispModesM[eFemonModeMaxNumber];
const char *skinsM[eFemonSkinMaxNumber];
const char *themesM[eFemonThemeMaxNumber];
cFemonConfig dataM;
cVector<const char*> helpM;
void Setup(void);
protected:
virtual eOSState ProcessKey(eKeys Key);
virtual void Store(void);
public:
cMenuFemonSetup(void);
cMenuFemonSetup();
};
cMenuFemonSetup::cMenuFemonSetup(void)
cMenuFemonSetup::cMenuFemonSetup()
{
debug("%s()\n", __PRETTY_FUNCTION__);
dispmodes[eFemonModeBasic] = tr("basic");
dispmodes[eFemonModeTransponder] = tr("transponder");
dispmodes[eFemonModeStream] = tr("stream");
dispmodes[eFemonModeAC3] = tr("AC-3");
dispModesM[eFemonModeBasic] = tr("basic");
dispModesM[eFemonModeTransponder] = tr("transponder");
dispModesM[eFemonModeStream] = tr("stream");
dispModesM[eFemonModeAC3] = tr("AC-3");
skins[eFemonSkinClassic] = tr("Classic");
skins[eFemonSkinElchi] = tr("Elchi");
skinsM[eFemonSkinClassic] = tr("Classic");
skinsM[eFemonSkinElchi] = tr("Elchi");
themes[eFemonThemeClassic] = tr("Classic");
themes[eFemonThemeElchi] = tr("Elchi");
themes[eFemonThemeSTTNG] = tr("ST:TNG");
themes[eFemonThemeDeepBlue] = tr("DeepBlue");
themes[eFemonThemeMoronimo] = tr("Moronimo");
themes[eFemonThemeEnigma] = tr("Enigma");
themes[eFemonThemeEgalsTry] = tr("EgalsTry");
themes[eFemonThemeDuotone] = tr("Duotone");
themes[eFemonThemeSilverGreen] = tr("SilverGreen");
themes[eFemonThemePearlHD] = tr("PearlHD");
themesM[eFemonThemeClassic] = tr("Classic");
themesM[eFemonThemeElchi] = tr("Elchi");
themesM[eFemonThemeSTTNG] = tr("ST:TNG");
themesM[eFemonThemeDeepBlue] = tr("DeepBlue");
themesM[eFemonThemeMoronimo] = tr("Moronimo");
themesM[eFemonThemeEnigma] = tr("Enigma");
themesM[eFemonThemeEgalsTry] = tr("EgalsTry");
themesM[eFemonThemeDuotone] = tr("Duotone");
themesM[eFemonThemeSilverGreen] = tr("SilverGreen");
themesM[eFemonThemePearlHD] = tr("PearlHD");
data = femonConfig;
dataM = FemonConfig;
SetMenuCategory(mcSetupPlugins);
Setup();
}
@ -327,52 +327,52 @@ void cMenuFemonSetup::Setup(void)
int current = Current();
Clear();
help.Clear();
helpM.Clear();
Add(new cMenuEditBoolItem(tr("Hide main menu entry"), &data.hidemenu));
help.Append(tr("Define whether the main menu entry is hidden."));
Add(new cMenuEditBoolItem(tr("Hide main menu entry"), &dataM.hidemenu));
helpM.Append(tr("Define whether the main menu entry is hidden."));
Add(new cMenuEditStraItem(tr("Default display mode"), &data.displaymode, eFemonModeMaxNumber, dispmodes));
help.Append(tr("Define the default display mode at startup."));
Add(new cMenuEditStraItem(tr("Default display mode"), &dataM.displaymode, eFemonModeMaxNumber, dispModesM));
helpM.Append(tr("Define the default display mode at startup."));
Add(new cMenuEditStraItem(trVDR("Setup.OSD$Skin"), &data.skin, eFemonSkinMaxNumber, skins));
help.Append(tr("Define the used OSD skin."));
Add(new cMenuEditStraItem(trVDR("Setup.OSD$Skin"), &dataM.skin, eFemonSkinMaxNumber, skinsM));
helpM.Append(tr("Define the used OSD skin."));
Add(new cMenuEditStraItem(trVDR("Setup.OSD$Theme"), &data.theme, eFemonThemeMaxNumber,themes));
help.Append(tr("Define the used OSD theme."));
Add(new cMenuEditStraItem(trVDR("Setup.OSD$Theme"), &dataM.theme, eFemonThemeMaxNumber, themesM));
helpM.Append(tr("Define the used OSD theme."));
Add(new cMenuEditBoolItem(tr("Position"), &data.position, trVDR("bottom"), trVDR("top")));
help.Append(tr("Define the position of OSD."));
Add(new cMenuEditBoolItem(tr("Position"), &dataM.position, trVDR("bottom"), trVDR("top")));
helpM.Append(tr("Define the position of OSD."));
Add(new cMenuEditIntItem(tr("Downscale OSD size [%]"), &data.downscale, 0, 20));
help.Append(tr("Define the downscale ratio for OSD size."));
Add(new cMenuEditIntItem(tr("Downscale OSD size [%]"), &dataM.downscale, 0, 20));
helpM.Append(tr("Define the downscale ratio for OSD size."));
Add(new cMenuEditIntItem(tr("Red limit [%]"), &data.redlimit, 1, 50));
help.Append(tr("Define a limit for red bar, which is used to indicate a bad signal."));
Add(new cMenuEditIntItem(tr("Red limit [%]"), &dataM.redlimit, 1, 50));
helpM.Append(tr("Define a limit for red bar, which is used to indicate a bad signal."));
Add(new cMenuEditIntItem(tr("Green limit [%]"), &data.greenlimit, 51, 100));
help.Append(tr("Define a limit for green bar, which is used to indicate a good signal."));
Add(new cMenuEditIntItem(tr("Green limit [%]"), &dataM.greenlimit, 51, 100));
helpM.Append(tr("Define a limit for green bar, which is used to indicate a good signal."));
Add(new cMenuEditIntItem(tr("OSD update interval [0.1s]"), &data.updateinterval, 1, 100));
help.Append(tr("Define an interval for OSD updates. The smaller interval generates higher CPU load."));
Add(new cMenuEditIntItem(tr("OSD update interval [0.1s]"), &dataM.updateinterval, 1, 100));
helpM.Append(tr("Define an interval for OSD updates. The smaller interval generates higher CPU load."));
Add(new cMenuEditBoolItem(tr("Analyze stream"), &data.analyzestream));
help.Append(tr("Define whether the DVB stream is analyzed and bitrates calculated."));
Add(new cMenuEditBoolItem(tr("Analyze stream"), &dataM.analyzestream));
helpM.Append(tr("Define whether the DVB stream is analyzed and bitrates calculated."));
if (femonConfig.analyzestream) {
Add(new cMenuEditIntItem(tr("Calculation interval [0.1s]"), &data.calcinterval, 1, 100));
help.Append(tr("Define an interval for calculation. The bigger interval generates more stable values."));
if (FemonConfig.analyzestream) {
Add(new cMenuEditIntItem(tr("Calculation interval [0.1s]"), &dataM.calcinterval, 1, 100));
helpM.Append(tr("Define an interval for calculation. The bigger interval generates more stable values."));
}
Add(new cMenuEditBoolItem(tr("Use SVDRP service"), &data.usesvdrp));
help.Append(tr("Define whether the SVDRP service is used in client/server setups."));
Add(new cMenuEditBoolItem(tr("Use SVDRP service"), &dataM.usesvdrp));
helpM.Append(tr("Define whether the SVDRP service is used in client/server setups."));
if (data.usesvdrp) {
Add(new cMenuEditIntItem(tr("SVDRP service port"), &data.svdrpport, 1, 65535));
help.Append(tr("Define the port number of SVDRP service."));
if (dataM.usesvdrp) {
Add(new cMenuEditIntItem(tr("SVDRP service port"), &dataM.svdrpport, 1, 65535));
helpM.Append(tr("Define the port number of SVDRP service."));
Add(new cMenuEditStrItem(tr("SVDRP service IP"), data.svdrpip, sizeof(data.svdrpip), ".1234567890"));
help.Append(tr("Define the IP address of SVDRP service."));
Add(new cMenuEditStrItem(tr("SVDRP service IP"), dataM.svdrpip, sizeof(dataM.svdrpip), ".1234567890"));
helpM.Append(tr("Define the IP address of SVDRP service."));
}
SetCurrent(Get(current));
@ -382,35 +382,35 @@ void cMenuFemonSetup::Setup(void)
void cMenuFemonSetup::Store(void)
{
debug("%s()\n", __PRETTY_FUNCTION__);
femonConfig = data;
SetupStore("HideMenu", femonConfig.hidemenu);
SetupStore("DisplayMode", femonConfig.displaymode);
SetupStore("Skin", femonConfig.skin);
SetupStore("Theme", femonConfig.theme);
SetupStore("Position", femonConfig.position);
SetupStore("Downscale", femonConfig.downscale);
SetupStore("RedLimit", femonConfig.redlimit);
SetupStore("GreenLimit", femonConfig.greenlimit);
SetupStore("UpdateInterval", femonConfig.updateinterval);
SetupStore("AnalStream", femonConfig.analyzestream);
SetupStore("CalcInterval", femonConfig.calcinterval);
SetupStore("UseSvdrp", femonConfig.usesvdrp);
SetupStore("ServerPort", femonConfig.svdrpport);
SetupStore("ServerIp", femonConfig.svdrpip);
FemonConfig = dataM;
SetupStore("HideMenu", FemonConfig.hidemenu);
SetupStore("DisplayMode", FemonConfig.displaymode);
SetupStore("Skin", FemonConfig.skin);
SetupStore("Theme", FemonConfig.theme);
SetupStore("Position", FemonConfig.position);
SetupStore("Downscale", FemonConfig.downscale);
SetupStore("RedLimit", FemonConfig.redlimit);
SetupStore("GreenLimit", FemonConfig.greenlimit);
SetupStore("UpdateInterval", FemonConfig.updateinterval);
SetupStore("AnalStream", FemonConfig.analyzestream);
SetupStore("CalcInterval", FemonConfig.calcinterval);
SetupStore("UseSvdrp", FemonConfig.usesvdrp);
SetupStore("ServerPort", FemonConfig.svdrpport);
SetupStore("ServerIp", FemonConfig.svdrpip);
}
eOSState cMenuFemonSetup::ProcessKey(eKeys Key)
{
int oldUsesvdrp = data.usesvdrp;
int oldAnalyzestream = data.analyzestream;
int oldUsesvdrp = dataM.usesvdrp;
int oldAnalyzestream = dataM.analyzestream;
eOSState state = cMenuSetupPage::ProcessKey(Key);
if (Key != kNone && (data.analyzestream != oldAnalyzestream || data.usesvdrp != oldUsesvdrp))
if (Key != kNone && (dataM.analyzestream != oldAnalyzestream || dataM.usesvdrp != oldUsesvdrp))
Setup();
if ((Key == kInfo) && (state == osUnknown) && (Current() < help.Size()))
return AddSubMenu(new cMenuText(cString::sprintf("%s - %s '%s'", tr("Help"), trVDR("Plugin"), PLUGIN_NAME_I18N), help[Current()]));
if ((Key == kInfo) && (state == osUnknown) && (Current() < helpM.Size()))
return AddSubMenu(new cMenuText(cString::sprintf("%s - %s '%s'", tr("Help"), trVDR("Plugin"), PLUGIN_NAME_I18N), helpM[Current()]));
return state;
}

34
femonaac.c
View File

@ -10,13 +10,13 @@
#define IS_HEAAC_AUDIO(buf) (((buf)[0] == 0xFF) && (((buf)[1] & 0xF6) == 0xF0))
int cFemonAAC::s_Samplerates[16] =
int cFemonAAC::sampleRateS[16] =
{
96000, 88200, 64000, 48000, 44100, 32000, 24000, 22050, 16000, 12000, 11025, 8000, -1, -1, -1, -1
};
cFemonAAC::cFemonAAC(cFemonAudioIf *audiohandler)
: m_AudioHandler(audiohandler)
cFemonAAC::cFemonAAC(cFemonAudioIf *audioHandlerP)
: audioHandlerM(audioHandlerP)
{
}
@ -24,11 +24,11 @@ cFemonAAC::~cFemonAAC()
{
}
bool cFemonAAC::processAudio(const uint8_t *buf, int len)
bool cFemonAAC::processAudio(const uint8_t *bufP, int lenP)
{
cFemonBitStream bs(buf, len * 8);
cFemonBitStream bs(bufP, lenP * 8);
if (!m_AudioHandler)
if (!audioHandlerM)
return false;
/* ADTS Fixed Header:
@ -46,9 +46,9 @@ bool cFemonAAC::processAudio(const uint8_t *buf, int len)
*/
// skip PES header
if (!PesLongEnough(len))
if (!PesLongEnough(lenP))
return false;
bs.SkipBits(8 * PesPayloadOffset(buf));
bs.SkipBits(8 * PesPayloadOffset(bufP));
// HE-AAC audio detection
if (bs.GetBits(12) != 0xFFF) // syncword
@ -66,38 +66,38 @@ bool cFemonAAC::processAudio(const uint8_t *buf, int len)
bs.SkipBit(); // private pid
int channel_configuration = bs.GetBits(3); // channel_configuration
m_AudioHandler->SetAudioCodec(AUDIO_CODEC_HEAAC);
m_AudioHandler->SetAudioBitrate(AUDIO_BITRATE_RESERVED);
audioHandlerM->SetAudioCodec(AUDIO_CODEC_HEAAC);
audioHandlerM->SetAudioBitrate(AUDIO_BITRATE_RESERVED);
switch (channel_configuration) {
case 0:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_STEREO);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_STEREO);
break;
case 1:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_JOINT_STEREO);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_JOINT_STEREO);
break;
case 2:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_DUAL);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_DUAL);
break;
case 3:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_SINGLE);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_SINGLE);
break;
default:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_INVALID);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_INVALID);
break;
}
switch (sampling_frequency_index) {
case 0xC ... 0xF:
m_AudioHandler->SetAudioSamplingFrequency(AUDIO_SAMPLING_FREQUENCY_RESERVED);
audioHandlerM->SetAudioSamplingFrequency(AUDIO_SAMPLING_FREQUENCY_RESERVED);
break;
default:
m_AudioHandler->SetAudioSamplingFrequency(s_Samplerates[sampling_frequency_index]);
audioHandlerM->SetAudioSamplingFrequency(sampleRateS[sampling_frequency_index]);
break;
}

8
femonaac.h
View File

@ -12,15 +12,15 @@
class cFemonAAC {
private:
cFemonAudioIf *m_AudioHandler;
cFemonAudioIf *audioHandlerM;
static int s_Samplerates[16];
static int sampleRateS[16];
public:
cFemonAAC(cFemonAudioIf *audiohandler);
cFemonAAC(cFemonAudioIf *audioHandlerP);
virtual ~cFemonAAC();
bool processAudio(const uint8_t *buf, int len);
bool processAudio(const uint8_t *bufP, int lenP);
};
#endif //__FEMONAAC_H

38
femonac3.c
View File

@ -9,25 +9,25 @@
#include "femontools.h"
#include "femonac3.h"
int cFemonAC3::s_Bitrates[32] =
int cFemonAC3::bitrateS[32] =
{
32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 448, 512, 576, 640, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
int cFemonAC3::s_Frequencies[4] =
int cFemonAC3::frequencieS[4] =
{
480, 441, 320, 0
};
int cFemonAC3::s_Frames[3][32] =
int cFemonAC3::frameS[3][32] =
{
{64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 448, 512, 640, 768, 896, 1024, 1152, 1280, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{69, 87, 104, 121, 139, 174, 208, 243, 278, 348, 417, 487, 557, 696, 835, 975, 1114, 1253, 1393, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
{96, 120, 144, 168, 192, 240, 288, 336, 384, 480, 576, 672, 768, 960, 1152, 1344, 1536, 1728, 1920, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
};
cFemonAC3::cFemonAC3(cFemonAC3If *audiohandler)
: m_AudioHandler(audiohandler)
cFemonAC3::cFemonAC3(cFemonAC3If *audioHandlerP)
: audioHandlerM(audioHandlerP)
{
}
@ -35,21 +35,21 @@ cFemonAC3::~cFemonAC3()
{
}
bool cFemonAC3::processAudio(const uint8_t *buf, int len)
bool cFemonAC3::processAudio(const uint8_t *bufP, int lenP)
{
int fscod, frmsizcod, bsmod, acmod;
int centermixlevel = AUDIO_CENTER_MIX_LEVEL_INVALID;
int surroundmixlevel = AUDIO_SURROUND_MIX_LEVEL_INVALID;
int dolbysurroundmode = AUDIO_DOLBY_SURROUND_MODE_INVALID;
cFemonBitStream bs(buf, len * 8);
cFemonBitStream bs(bufP, lenP * 8);
if (!m_AudioHandler)
if (!audioHandlerM)
return false;
// skip PES header
if (!PesLongEnough(len))
if (!PesLongEnough(lenP))
return false;
bs.SkipBits(8 * PesPayloadOffset(buf));
bs.SkipBits(8 * PesPayloadOffset(bufP));
// http://rmworkshop.com/dvd_info/related_info/ac3hdr.htm
@ -78,16 +78,16 @@ bool cFemonAC3::processAudio(const uint8_t *buf, int len)
if (acmod == 0x02)
dolbysurroundmode = bs.GetBits(2);
m_AudioHandler->SetAC3Bitrate(1000 * s_Bitrates[frmsizcod >> 1]);
m_AudioHandler->SetAC3SamplingFrequency(100 * s_Frequencies[fscod]);
m_AudioHandler->SetAC3Bitstream(bsmod);
m_AudioHandler->SetAC3AudioCoding(acmod);
m_AudioHandler->SetAC3CenterMix(centermixlevel);
m_AudioHandler->SetAC3SurroundMix(surroundmixlevel);
m_AudioHandler->SetAC3DolbySurround(dolbysurroundmode);
audioHandlerM->SetAC3Bitrate(1000 * bitrateS[frmsizcod >> 1]);
audioHandlerM->SetAC3SamplingFrequency(100 * frequencieS[fscod]);
audioHandlerM->SetAC3Bitstream(bsmod);
audioHandlerM->SetAC3AudioCoding(acmod);
audioHandlerM->SetAC3CenterMix(centermixlevel);
audioHandlerM->SetAC3SurroundMix(surroundmixlevel);
audioHandlerM->SetAC3DolbySurround(dolbysurroundmode);
m_AudioHandler->SetAC3LFE(bs.GetBit()); // low frequency effects on
m_AudioHandler->SetAC3Dialog(bs.GetBits(5)); // dialog normalization
audioHandlerM->SetAC3LFE(bs.GetBit()); // low frequency effects on
audioHandlerM->SetAC3Dialog(bs.GetBits(5)); // dialog normalization
return true;
}

12
femonac3.h
View File

@ -12,17 +12,17 @@
class cFemonAC3 {
private:
cFemonAC3If *m_AudioHandler;
cFemonAC3If *audioHandlerM;
static int s_Bitrates[32];
static int s_Frequencies[4];
static int s_Frames[3][32];
static int bitrateS[32];
static int frequencieS[4];
static int frameS[3][32];
public:
cFemonAC3(cFemonAC3If *audiohandler);
cFemonAC3(cFemonAC3If *audioHandlerP);
virtual ~cFemonAC3();
bool processAudio(const uint8_t *buf, int len);
bool processAudio(const uint8_t *bufP, int lenP);
};
#endif //__FEMONAC3_H

26
femonaudio.h
View File

@ -113,13 +113,13 @@ public:
virtual ~cFemonAudioIf() {}
// enum
virtual void SetAudioCodec(eAudioCodec codec) = 0;
virtual void SetAudioCodec(eAudioCodec codecP) = 0;
// kbit/s or eAudioBitrate
virtual void SetAudioBitrate(double bitrate) = 0;
virtual void SetAudioBitrate(double bitRateP) = 0;
// Hz or eAudioSamplingFrequency
virtual void SetAudioSamplingFrequency(int sampling) = 0;
virtual void SetAudioSamplingFrequency(int samplingP) = 0;
// eAudioChannelMode
virtual void SetAudioChannel(eAudioChannelMode mode) = 0;
virtual void SetAudioChannel(eAudioChannelMode modeP) = 0;
};
class cFemonAC3If {
@ -128,23 +128,23 @@ public:
virtual ~cFemonAC3If() {}
// bit/s or eAudioBitrate
virtual void SetAC3Bitrate(int bitrate) = 0;
virtual void SetAC3Bitrate(int bitRateP) = 0;
// Hz or eAudioSamplingFrequency
virtual void SetAC3SamplingFrequency(int sampling) = 0;
virtual void SetAC3SamplingFrequency(int samplingP) = 0;
// 0..7 or eAudioBitstreamMode
virtual void SetAC3Bitstream(int mode) = 0;
virtual void SetAC3Bitstream(int modeP) = 0;
// 0..7 or eAudioCodingMode
virtual void SetAC3AudioCoding(int mode) = 0;
virtual void SetAC3AudioCoding(int modeP) = 0;
// eAudioDolbySurroundMode
virtual void SetAC3DolbySurround(int mode) = 0;
virtual void SetAC3DolbySurround(int modeP) = 0;
// eAudioCenterMixLevel
virtual void SetAC3CenterMix(int level) = 0;
virtual void SetAC3CenterMix(int levelP) = 0;
// eAudioSurroundMixLevel
virtual void SetAC3SurroundMix(int level) = 0;
virtual void SetAC3SurroundMix(int levelP) = 0;
// -dB
virtual void SetAC3Dialog(int level) = 0;
virtual void SetAC3Dialog(int levelP) = 0;
// boolean
virtual void SetAC3LFE(bool onoff) = 0;
virtual void SetAC3LFE(bool onoffP) = 0;
};
#endif //__FEMONAUDIO_H

4
femoncfg.c
View File

@ -8,7 +8,7 @@
#include <string.h>
#include "femoncfg.h"
cFemonConfig femonConfig;
cFemonConfig FemonConfig;
cFemonConfig::cFemonConfig(void)
{
@ -28,7 +28,7 @@ cFemonConfig::cFemonConfig(void)
strncpy(svdrpip, "0.0.0.0", sizeof(svdrpip));
}
const cFemonTheme femonTheme[eFemonThemeMaxNumber] =
const cFemonTheme FemonTheme[eFemonThemeMaxNumber] =
{
{
// eFemonThemeClassic

4
femoncfg.h
View File

@ -39,7 +39,7 @@ public:
char svdrpip[MaxSvdrpIp + 1]; // must end with additional null
};
extern cFemonConfig femonConfig;
extern cFemonConfig FemonConfig;
enum eFemonSkins
{
@ -76,6 +76,6 @@ struct cFemonTheme
unsigned int clrGreen;
};
extern const cFemonTheme femonTheme[eFemonThemeMaxNumber];
extern const cFemonTheme FemonTheme[eFemonThemeMaxNumber];
#endif // __FEMONCFG_H

195
femonh264.c
View File

@ -8,7 +8,7 @@
#include "femontools.h"
#include "femonh264.h"
const cFemonH264::t_DAR cFemonH264::s_DAR[] =
const cFemonH264::t_DAR cFemonH264::darS[] =
{
{ VIDEO_ASPECT_RATIO_1_1, 100 },
{ VIDEO_ASPECT_RATIO_4_3, 133 },
@ -30,7 +30,7 @@ const cFemonH264::t_DAR cFemonH264::s_DAR[] =
{ VIDEO_ASPECT_RATIO_2_1, 200 }
};
const cFemonH264::t_SAR cFemonH264::s_SAR[] =
const cFemonH264::t_SAR cFemonH264::sarS[] =
{
{ 0, 0 }, // VIDEO_ASPECT_RATIO_INVALID
{ 1, 1 }, // VIDEO_ASPECT_RATIO_1_1
@ -51,7 +51,7 @@ const cFemonH264::t_SAR cFemonH264::s_SAR[] =
{ 2, 1 } // VIDEO_ASPECT_RATIO_2_1
};
const eVideoFormat cFemonH264::s_VideoFormats[] =
const eVideoFormat cFemonH264::videoFormatS[] =
{
VIDEO_FORMAT_COMPONENT,
VIDEO_FORMAT_PAL,
@ -62,25 +62,25 @@ const eVideoFormat cFemonH264::s_VideoFormats[] =
VIDEO_FORMAT_RESERVED
};
const uint8_t cFemonH264::s_SeiNumClockTsTable[9] =
const uint8_t cFemonH264::seiNumClockTsTableS[9] =
{
1, 1, 1, 2, 2, 3, 3, 2, 3
};
cFemonH264::cFemonH264(cFemonVideoIf *videohandler)
: m_VideoHandler(videohandler),
m_Width(0),
m_Height(0),
m_AspectRatio(VIDEO_ASPECT_RATIO_INVALID),
m_Format(VIDEO_FORMAT_INVALID),
m_FrameRate(0),
m_BitRate(0),
m_Scan(VIDEO_SCAN_INVALID),
m_CpbDpbDelaysPresentFlag(false),
m_PicStructPresentFlag(false),
m_FrameMbsOnlyFlag(false),
m_MbAdaptiveFrameFieldFlag(false),
m_TimeOffsetLength(0)
cFemonH264::cFemonH264(cFemonVideoIf *videoHandlerP)
: videoHandlerM(videoHandlerP),
widthM(0),
heightM(0),
aspectRatioM(VIDEO_ASPECT_RATIO_INVALID),
formatM(VIDEO_FORMAT_INVALID),
frameRateM(0),
bitRateM(0),
scanM(VIDEO_SCAN_INVALID),
cpbDpbDelaysPresentFlagM(false),
picStructPresentFlagM(false),
frameMbsOnlyFlagM(false),
mbAdaptiveFrameFieldFlagM(false),
timeOffsetLengthM(0)
{
reset();
}
@ -89,18 +89,19 @@ cFemonH264::~cFemonH264()
{
}
bool cFemonH264::processVideo(const uint8_t *buf, int len)
bool cFemonH264::processVideo(const uint8_t *bufP, int lenP)
{
uint8_t nal_data[len];
uint8_t nal_data[lenP];
bool aud_found = false, sps_found = false, sei_found = true; // SEI temporarily disabled!
const uint8_t *buf = bufP;
const uint8_t *start = buf;
const uint8_t *end = start + len;
const uint8_t *end = start + lenP;
if (!m_VideoHandler)
if (!videoHandlerM)
return false;
// skip PES header
if (!PesLongEnough(len))
if (!PesLongEnough(lenP))
return false;
buf += PesPayloadOffset(buf);
start = buf;
@ -119,7 +120,7 @@ bool cFemonH264::processVideo(const uint8_t *buf, int len)
if (!aud_found) {
switch (buf[4] >> 5) {
case 0: case 3: case 5: // I_FRAME
//debug("H.264: Found NAL AUD at offset %d/%d\n", int(buf - start), len);
//debug("H.264: Found NAL AUD at offset %d/%d\n", int(buf - start), lenP);
aud_found = true;
break;
case 1: case 4: case 6: // P_FRAME;
@ -132,7 +133,7 @@ bool cFemonH264::processVideo(const uint8_t *buf, int len)
case NAL_SPS:
if (!sps_found) {
//debug("H.264: Found NAL SPS at offset %d/%d\n", int(buf - start), len);
//debug("H.264: Found NAL SPS at offset %d/%d\n", int(buf - start), lenP);
int nal_len = nalUnescape(nal_data, buf + 4, int(end - buf - 4));
consumed = parseSPS(nal_data, nal_len);
if (consumed > 0)
@ -142,7 +143,7 @@ bool cFemonH264::processVideo(const uint8_t *buf, int len)
case NAL_SEI:
if (!sei_found) {
//debug("H.264: Found NAL SEI at offset %d/%d\n", int(buf - start), len);
//debug("H.264: Found NAL SEI at offset %d/%d\n", int(buf - start), lenP);
int nal_len = nalUnescape(nal_data, buf + 4, int(end - buf - 4));
consumed = parseSEI(nal_data, nal_len);
if (consumed > 0)
@ -161,18 +162,18 @@ bool cFemonH264::processVideo(const uint8_t *buf, int len)
}
if (aud_found) {
m_VideoHandler->SetVideoCodec(VIDEO_CODEC_H264);
videoHandlerM->SetVideoCodec(VIDEO_CODEC_H264);
if (sps_found) {
//debug("H.264: size %dx%d, aspect %d format %d bitrate %.0f\n", m_Width, m_Height, m_AspectRatio, m_Format, m_BitRate);
m_VideoHandler->SetVideoFormat(m_Format);
m_VideoHandler->SetVideoSize(m_Width, m_Height);
m_VideoHandler->SetVideoAspectRatio(m_AspectRatio);
m_VideoHandler->SetVideoBitrate(m_BitRate);
//debug("H.264: size %dx%d, aspect %d format %d bitrate %.0f\n", widthM, heightM, aspectRatioM, formatM, bitRateM);
videoHandlerM->SetVideoFormat(formatM);
videoHandlerM->SetVideoSize(widthM, heightM);
videoHandlerM->SetVideoAspectRatio(aspectRatioM);
videoHandlerM->SetVideoBitrate(bitRateM);
}
if (sps_found || sei_found) {
//debug("H.264: scan %d framerate %.2f\n", m_Scan, (m_Scan == VIDEO_SCAN_PROGRESSIVE) ? (m_FrameRate / 2) : m_FrameRate);
m_VideoHandler->SetVideoScan(m_Scan);
m_VideoHandler->SetVideoFramerate((m_Scan == VIDEO_SCAN_PROGRESSIVE) ? (m_FrameRate / 2) : m_FrameRate);
//debug("H.264: scan %d framerate %.2f\n", scanM, (scanM == VIDEO_SCAN_PROGRESSIVE) ? (frameRateM / 2) : frameRateM);
videoHandlerM->SetVideoScan(scanM);
videoHandlerM->SetVideoFramerate((scanM == VIDEO_SCAN_PROGRESSIVE) ? (frameRateM / 2) : frameRateM);
}
}
@ -181,60 +182,60 @@ bool cFemonH264::processVideo(const uint8_t *buf, int len)
void cFemonH264::reset()
{
m_CpbDpbDelaysPresentFlag = false;
m_PicStructPresentFlag = false;
m_FrameMbsOnlyFlag = false;
m_MbAdaptiveFrameFieldFlag = false;
m_TimeOffsetLength = 0;
cpbDpbDelaysPresentFlagM = false;
picStructPresentFlagM = false;
frameMbsOnlyFlagM = false;
mbAdaptiveFrameFieldFlagM = false;
timeOffsetLengthM = 0;
}
const uint8_t *cFemonH264::nextStartCode(const uint8_t *start, const uint8_t *end)
const uint8_t *cFemonH264::nextStartCode(const uint8_t *startP, const uint8_t *endP)
{
for (end -= 3; start < end; ++start) {
if ((start[0] == 0x00) && (start[1] == 0x00) && (start[2] == 0x01))
return start;
for (endP -= 3; startP < endP; ++startP) {
if ((startP[0] == 0x00) && (startP[1] == 0x00) && (startP[2] == 0x01))
return startP;
}
return (end + 3);
return (endP + 3);
}
int cFemonH264::nalUnescape(uint8_t *dst, const uint8_t *src, int len)
int cFemonH264::nalUnescape(uint8_t *dstP, const uint8_t *srcP, int lenP)
{
int s = 0, d = 0;
while (s < len) {
if (!src[s] && !src[s + 1]) {
while (s < lenP) {
if (!srcP[s] && !srcP[s + 1]) {
// hit 00 00 xx
dst[d] = dst[d + 1] = 0;
dstP[d] = dstP[d + 1] = 0;
s += 2;
d += 2;
if (src[s] == 3) {
if (srcP[s] == 3) {
s++; // 00 00 03 xx --> 00 00 xx
if (s >= len)
if (s >= lenP)
return d;
}
}
dst[d++] = src[s++];
dstP[d++] = srcP[s++];
}
return d;
}
int cFemonH264::parseSPS(const uint8_t *buf, int len)
int cFemonH264::parseSPS(const uint8_t *bufP, int lenP)
{
int profile_idc, level_idc, constraint_set3_flag, pic_order_cnt_type, i, j;
cFemonBitStream bs(buf, len);
cFemonBitStream bs(bufP, lenP);
uint32_t width = m_Width;
uint32_t height = m_Height;
eVideoAspectRatio aspect_ratio = m_AspectRatio;
eVideoFormat format = m_Format;
double frame_rate = m_FrameRate;
double bit_rate = m_BitRate;
bool cpb_dpb_delays_present_flag = m_CpbDpbDelaysPresentFlag;
bool pic_struct_present_flag = m_PicStructPresentFlag;
bool frame_mbs_only_flag = m_FrameMbsOnlyFlag;
bool mb_adaptive_frame_field_flag = m_MbAdaptiveFrameFieldFlag;
uint32_t time_offset_length = m_TimeOffsetLength;
uint32_t width = widthM;
uint32_t height = heightM;
eVideoAspectRatio aspect_ratio = aspectRatioM;
eVideoFormat format = formatM;
double frame_rate = frameRateM;
double bit_rate = bitRateM;
bool cpb_dpb_delays_present_flag = cpbDpbDelaysPresentFlagM;
bool pic_struct_present_flag = picStructPresentFlagM;
bool frame_mbs_only_flag = frameMbsOnlyFlagM;
bool mb_adaptive_frame_field_flag = mbAdaptiveFrameFieldFlagM;
uint32_t time_offset_length = timeOffsetLengthM;
profile_idc = bs.GetBits(8); // profile_idc
bs.SkipBit(); // constraint_set0_flag
@ -523,14 +524,14 @@ int cFemonH264::parseSPS(const uint8_t *buf, int len)
sar_width = bs.GetBits(16); // sar_width
sar_height = bs.GetBits(16); // sar_height
}
else if (aspect_ratio_idc < ELEMENTS(s_SAR)) {
sar_width = s_SAR[aspect_ratio_idc].w;
sar_height = s_SAR[aspect_ratio_idc].h;
else if (aspect_ratio_idc < ELEMENTS(sarS)) {
sar_width = sarS[aspect_ratio_idc].w;
sar_height = sarS[aspect_ratio_idc].h;
}
if (sar_width && sar_height) {
int index = -1, ratio = int(100.0L * sar_width * width / sar_height / height);
for (unsigned int i = 0; i < ELEMENTS(s_DAR); ++i) {
if (s_DAR[i].ratio == ratio) {
for (unsigned int i = 0; i < ELEMENTS(darS); ++i) {
if (darS[i].ratio == ratio) {
index = i;
break;
}
@ -542,7 +543,7 @@ int cFemonH264::parseSPS(const uint8_t *buf, int len)
aspect_ratio = VIDEO_ASPECT_RATIO_INVALID;
}
else
aspect_ratio = s_DAR[index].dar;
aspect_ratio = darS[index].dar;
//debug("H.264 SPS: DAR %dx%d (%d)\n", sar_width, sar_height, aspect_ratio);
}
}
@ -551,8 +552,8 @@ int cFemonH264::parseSPS(const uint8_t *buf, int len)
if (bs.GetBit()) { // video_signal_type_present_flag
uint32_t video_format;
video_format = bs.GetBits(3); // video_format
if (video_format < sizeof(s_VideoFormats) / sizeof(s_VideoFormats[0])) {
format = s_VideoFormats[video_format];
if (video_format < sizeof(videoFormatS) / sizeof(videoFormatS[0])) {
format = videoFormatS[video_format];
//debug("H.264 SPS: video format %d\n", format);
}
bs.SkipBit(); // video_full_range_flag
@ -621,30 +622,30 @@ int cFemonH264::parseSPS(const uint8_t *buf, int len)
}
}
m_Width = width;
m_Height = height;
m_AspectRatio = aspect_ratio;
m_Format = format;
m_Scan = frame_mbs_only_flag ? VIDEO_SCAN_PROGRESSIVE : VIDEO_SCAN_INTERLACED;
m_FrameRate = frame_rate;
m_BitRate = bit_rate;
m_CpbDpbDelaysPresentFlag = cpb_dpb_delays_present_flag;
m_PicStructPresentFlag = pic_struct_present_flag;
m_FrameMbsOnlyFlag = frame_mbs_only_flag;
m_MbAdaptiveFrameFieldFlag = mb_adaptive_frame_field_flag;
m_TimeOffsetLength = time_offset_length;
widthM = width;
heightM = height;
aspectRatioM = aspect_ratio;
formatM = format;
scanM = frame_mbs_only_flag ? VIDEO_SCAN_PROGRESSIVE : VIDEO_SCAN_INTERLACED;
frameRateM = frame_rate;
bitRateM = bit_rate;
cpbDpbDelaysPresentFlagM = cpb_dpb_delays_present_flag;
picStructPresentFlagM = pic_struct_present_flag;
frameMbsOnlyFlagM = frame_mbs_only_flag;
mbAdaptiveFrameFieldFlagM = mb_adaptive_frame_field_flag;
timeOffsetLengthM = time_offset_length;
return (bs.Index() / 8);
}
int cFemonH264::parseSEI(const uint8_t *buf, int len)
int cFemonH264::parseSEI(const uint8_t *bufP, int lenP)
{
int num_referenced_subseqs, i;
cFemonBitStream bs(buf, len);
cFemonBitStream bs(bufP, lenP);
eVideoScan scan = m_Scan;
eVideoScan scan = scanM;
while ((bs.Index() * 8 + 16) < len) { // sei_message
while ((bs.Index() * 8 + 16) < lenP) { // sei_message
int lastByte, payloadSize = 0, payloadType = 0;
do {
@ -659,16 +660,16 @@ int cFemonH264::parseSEI(const uint8_t *buf, int len)
switch (payloadType) { // sei_payload
case 1: // pic_timing
if (m_CpbDpbDelaysPresentFlag) { // cpb_dpb_delays_present_flag
if (cpbDpbDelaysPresentFlagM) { // cpb_dpb_delays_present_flag
bs.SkipUeGolomb(); // cpb_removal_delay
bs.SkipUeGolomb(); // dpb_output_delay
}
if (m_PicStructPresentFlag) { // pic_struct_present_flag
if (picStructPresentFlagM) { // pic_struct_present_flag
uint32_t pic_struct, ct_type = 0, i = 0;
pic_struct = bs.GetBits(4); // pic_struct
if (pic_struct >= (sizeof(s_SeiNumClockTsTable)) / sizeof(s_SeiNumClockTsTable[0]))
if (pic_struct >= (sizeof(seiNumClockTsTableS)) / sizeof(seiNumClockTsTableS[0]))
return 0;
if (m_FrameMbsOnlyFlag && !m_MbAdaptiveFrameFieldFlag)
if (frameMbsOnlyFlagM && !mbAdaptiveFrameFieldFlagM)
scan = VIDEO_SCAN_PROGRESSIVE;
else {
switch (pic_struct) {
@ -691,7 +692,7 @@ int cFemonH264::parseSEI(const uint8_t *buf, int len)
}
}
//debug("H.264 SEI: pic struct %d scan type %d\n", pic_struct, scan);
for (i = 0; i < s_SeiNumClockTsTable[pic_struct]; ++i) {
for (i = 0; i < seiNumClockTsTableS[pic_struct]; ++i) {
if (bs.GetBit()) { // clock_timestamp_flag[i]
int full_timestamp_flag;
ct_type |= (1 << bs.GetBits(2)); // ct_type
@ -717,8 +718,8 @@ int cFemonH264::parseSEI(const uint8_t *buf, int len)
}
}
}
if (m_TimeOffsetLength > 0)
bs.SkipBits(m_TimeOffsetLength); // time_offset
if (timeOffsetLengthM > 0)
bs.SkipBits(timeOffsetLengthM); // time_offset
}
}
if (i > 0)
@ -753,7 +754,7 @@ int cFemonH264::parseSEI(const uint8_t *buf, int len)
bs.ByteAlign();
}
m_Scan = scan;
scanM = scan;
return (bs.Index() / 8);
}

38
femonh264.h
View File

@ -29,19 +29,19 @@ private:
int h;
} t_SAR;
cFemonVideoIf *m_VideoHandler;
uint32_t m_Width;
uint32_t m_Height;
eVideoAspectRatio m_AspectRatio;
eVideoFormat m_Format;
double m_FrameRate;
double m_BitRate;
eVideoScan m_Scan;
bool m_CpbDpbDelaysPresentFlag;
bool m_PicStructPresentFlag;
bool m_FrameMbsOnlyFlag;
bool m_MbAdaptiveFrameFieldFlag;
uint32_t m_TimeOffsetLength;
cFemonVideoIf *videoHandlerM;
uint32_t widthM;
uint32_t heightM;
eVideoAspectRatio aspectRatioM;
eVideoFormat formatM;
double frameRateM;
double bitRateM;
eVideoScan scanM;
bool cpbDpbDelaysPresentFlagM;
bool picStructPresentFlagM;
bool frameMbsOnlyFlagM;
bool mbAdaptiveFrameFieldFlagM;
uint32_t timeOffsetLengthM;
void reset();
const uint8_t *nextStartCode(const uint8_t *start, const uint8_t *end);
@ -49,16 +49,16 @@ private:
int parseSPS(const uint8_t *buf, int len);
int parseSEI(const uint8_t *buf, int len);
static const t_SAR s_SAR[];
static const t_DAR s_DAR[];
static const eVideoFormat s_VideoFormats[];
static const uint8_t s_SeiNumClockTsTable[9];
static const t_SAR sarS[];
static const t_DAR darS[];
static const eVideoFormat videoFormatS[];
static const uint8_t seiNumClockTsTableS[9];
public:
cFemonH264(cFemonVideoIf *videohandler);
cFemonH264(cFemonVideoIf *videoHandlerP);
virtual ~cFemonH264();
bool processVideo(const uint8_t *buf, int len);
bool processVideo(const uint8_t *bufP, int lenP);
};
#endif //__FEMONH264_H

42
femonlatm.c
View File

@ -8,20 +8,20 @@
#include "femontools.h"
#include "femonlatm.h"
int cFemonLATM::s_Bitrates[3][16] =
int cFemonLATM::bitrateS[3][16] =
{
{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, -1}, // MPEG-2 Layer I
{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, -1}, // MPEG-2 Layer II/III
{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, -1} // MPEG-2 Layer II/III
};
int cFemonLATM::s_Samplerates[4] =
int cFemonLATM::sampleRateS[4] =
{
22050, 24000, 16000, -1
};
cFemonLATM::cFemonLATM(cFemonAudioIf *audiohandler)
: m_AudioHandler(audiohandler)
cFemonLATM::cFemonLATM(cFemonAudioIf *audioHandlerP)
: audioHandlerM(audioHandlerP)
{
}
@ -29,23 +29,23 @@ cFemonLATM::~cFemonLATM()
{
}
bool cFemonLATM::processAudio(const uint8_t *buf, int len)
bool cFemonLATM::processAudio(const uint8_t *bufP, int lenP)
{
cFemonBitStream bs(buf, len * 8);
cFemonBitStream bs(bufP, lenP * 8);
if (!m_AudioHandler)
if (!audioHandlerM)
return false;
// skip PES header
if (!PesLongEnough(len))
if (!PesLongEnough(lenP))
return false;
bs.SkipBits(8 * PesPayloadOffset(buf));
bs.SkipBits(8 * PesPayloadOffset(bufP));
// MPEG audio detection
if (bs.GetBits(12) != 0x56E) // syncword
return false;
m_AudioHandler->SetAudioCodec(AUDIO_CODEC_LATM);
audioHandlerM->SetAudioCodec(AUDIO_CODEC_LATM);
if (bs.GetBit() == 0) // id: MPEG-1=1, extension to lower sampling frequencies=0
return true; // @todo: lower sampling frequencies support
@ -59,52 +59,52 @@ bool cFemonLATM::processAudio(const uint8_t *buf, int len)
switch (mode) {
case 0:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_STEREO);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_STEREO);
break;
case 1:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_JOINT_STEREO);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_JOINT_STEREO);
break;
case 2:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_DUAL);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_DUAL);
break;
case 3:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_SINGLE);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_SINGLE);
break;
default:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_INVALID);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_INVALID);
break;
}
if (layer == 3) {
m_AudioHandler->SetAudioBitrate(AUDIO_BITRATE_FREE);
audioHandlerM->SetAudioBitrate(AUDIO_BITRATE_FREE);
}
else {
switch (bit_rate_index) {
case 0:
m_AudioHandler->SetAudioBitrate(AUDIO_BITRATE_FREE);
audioHandlerM->SetAudioBitrate(AUDIO_BITRATE_FREE);
break;
case 0xF:
m_AudioHandler->SetAudioBitrate(AUDIO_BITRATE_RESERVED);
audioHandlerM->SetAudioBitrate(AUDIO_BITRATE_RESERVED);
break;
default:
m_AudioHandler->SetAudioBitrate(1000 * s_Bitrates[layer][bit_rate_index]);
audioHandlerM->SetAudioBitrate(1000 * bitrateS[layer][bit_rate_index]);
break;
}
}
switch (sampling_frequency) {
case 3:
m_AudioHandler->SetAudioSamplingFrequency(AUDIO_SAMPLING_FREQUENCY_RESERVED);
audioHandlerM->SetAudioSamplingFrequency(AUDIO_SAMPLING_FREQUENCY_RESERVED);
break;
default:
m_AudioHandler->SetAudioSamplingFrequency(s_Samplerates[sampling_frequency]);
audioHandlerM->SetAudioSamplingFrequency(sampleRateS[sampling_frequency]);
break;
}

10
femonlatm.h
View File

@ -12,16 +12,16 @@
class cFemonLATM {
private:
cFemonAudioIf *m_AudioHandler;
cFemonAudioIf *audioHandlerM;
static int s_Bitrates[3][16];
static int s_Samplerates[4];
static int bitrateS[3][16];
static int sampleRateS[4];
public:
cFemonLATM(cFemonAudioIf *audiohandler);
cFemonLATM(cFemonAudioIf *audioHandlerP);
virtual ~cFemonLATM();
bool processAudio(const uint8_t *buf, int len);
bool processAudio(const uint8_t *bufP, int lenP);
};
#endif //__FEMONLATM_H

68
femonmpeg.c
View File

@ -10,7 +10,7 @@
#define IS_EXTENSION_START(buf) (((buf)[0] == 0x00) && ((buf)[1] == 0x00) && ((buf)[2] == 0x01) && ((buf)[3] == 0xB5))
int cFemonMPEG::s_Bitrates[2][3][16] =
int cFemonMPEG::bitrateS[2][3][16] =
{
{
{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, -1}, // MPEG-2 Layer I
@ -24,21 +24,21 @@ int cFemonMPEG::s_Bitrates[2][3][16] =
}
};
int cFemonMPEG::s_Samplerates[2][4] =
int cFemonMPEG::sampleRateS[2][4] =
{
{22050, 24000, 16000, -1}, // MPEG-2
{44100, 48000, 32000, -1} // MPEG-1
};
eAudioCodec cFemonMPEG::s_Formats[2][4] =
eAudioCodec cFemonMPEG::formatS[2][4] =
{
{AUDIO_CODEC_MPEG2_I, AUDIO_CODEC_MPEG2_II, AUDIO_CODEC_MPEG2_III, AUDIO_CODEC_UNKNOWN}, // MPEG-2
{AUDIO_CODEC_MPEG1_I, AUDIO_CODEC_MPEG1_II, AUDIO_CODEC_MPEG1_III, AUDIO_CODEC_UNKNOWN} // MPEG-1
};
cFemonMPEG::cFemonMPEG(cFemonVideoIf *videohandler, cFemonAudioIf *audiohandler)
: m_VideoHandler(videohandler),
m_AudioHandler(audiohandler)
cFemonMPEG::cFemonMPEG(cFemonVideoIf *videoHandlerP, cFemonAudioIf *audioHandlerP)
: videoHandlerM(videoHandlerP),
audioHandlerM(audioHandlerP)
{
}
@ -46,17 +46,17 @@ cFemonMPEG::~cFemonMPEG()
{
}
bool cFemonMPEG::processAudio(const uint8_t *buf, int len)
bool cFemonMPEG::processAudio(const uint8_t *bufP, int lenP)
{
cFemonBitStream bs(buf, len * 8);
cFemonBitStream bs(bufP, lenP * 8);
if (!m_AudioHandler)
if (!audioHandlerM)
return false;
// skip PES header
if (!PesLongEnough(len))
if (!PesLongEnough(lenP))
return false;
bs.SkipBits(8 * PesPayloadOffset(buf));
bs.SkipBits(8 * PesPayloadOffset(bufP));
// MPEG audio detection
if (bs.GetBits(12) != 0xFFF) // syncword
@ -71,68 +71,68 @@ bool cFemonMPEG::processAudio(const uint8_t *buf, int len)
bs.SkipBit(); // private pid
int mode = bs.GetBits(2); // mode
m_AudioHandler->SetAudioCodec(s_Formats[id][layer]);
audioHandlerM->SetAudioCodec(formatS[id][layer]);
switch (mode) {
case 0:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_STEREO);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_STEREO);
break;
case 1:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_JOINT_STEREO);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_JOINT_STEREO);
break;
case 2:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_DUAL);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_DUAL);
break;
case 3:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_SINGLE);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_SINGLE);
break;
default:
m_AudioHandler->SetAudioChannel(AUDIO_CHANNEL_MODE_INVALID);
audioHandlerM->SetAudioChannel(AUDIO_CHANNEL_MODE_INVALID);
break;
}
switch (bit_rate_index) {
case 0:
m_AudioHandler->SetAudioBitrate(AUDIO_BITRATE_FREE);
audioHandlerM->SetAudioBitrate(AUDIO_BITRATE_FREE);
break;
case 0xF:
m_AudioHandler->SetAudioBitrate(AUDIO_BITRATE_RESERVED);
audioHandlerM->SetAudioBitrate(AUDIO_BITRATE_RESERVED);
break;
default:
m_AudioHandler->SetAudioBitrate(1000 * s_Bitrates[id][layer][bit_rate_index]);
audioHandlerM->SetAudioBitrate(1000 * bitrateS[id][layer][bit_rate_index]);
break;
}
switch (sampling_frequency) {
case 3:
m_AudioHandler->SetAudioSamplingFrequency(AUDIO_SAMPLING_FREQUENCY_RESERVED);
audioHandlerM->SetAudioSamplingFrequency(AUDIO_SAMPLING_FREQUENCY_RESERVED);
break;
default:
m_AudioHandler->SetAudioSamplingFrequency(s_Samplerates[id][sampling_frequency]);
audioHandlerM->SetAudioSamplingFrequency(sampleRateS[id][sampling_frequency]);
break;
}
return true;
}
bool cFemonMPEG::processVideo(const uint8_t *buf, int len)
bool cFemonMPEG::processVideo(const uint8_t *bufP, int lenP)
{
cFemonBitStream bs(buf, len * 8);
cFemonBitStream bs(bufP, lenP * 8);
if (!m_VideoHandler)
if (!videoHandlerM)
return false;
// skip PES header
if (!PesLongEnough(len))
if (!PesLongEnough(lenP))
return false;
bs.SkipBits(8 * PesPayloadOffset(buf));
bs.SkipBits(8 * PesPayloadOffset(bufP));
// MPEG-2 video detection, search for start code
if (bs.GetBits(32) != 0x000001B3) // sequence header
@ -274,13 +274,13 @@ bool cFemonMPEG::processVideo(const uint8_t *buf, int len)
}
}
m_VideoHandler->SetVideoCodec(VIDEO_CODEC_MPEG2);
m_VideoHandler->SetVideoSize(horizontal_size, vertical_size);
m_VideoHandler->SetVideoBitrate(400.0 * (double)(bit_rate));
m_VideoHandler->SetVideoFramerate(frame_rate);
m_VideoHandler->SetVideoScan(eVideoScan(scan));
m_VideoHandler->SetVideoAspectRatio(eVideoAspectRatio(aspect));
m_VideoHandler->SetVideoFormat(eVideoFormat(format));
videoHandlerM->SetVideoCodec(VIDEO_CODEC_MPEG2);
videoHandlerM->SetVideoSize(horizontal_size, vertical_size);
videoHandlerM->SetVideoBitrate(400.0 * (double)(bit_rate));
videoHandlerM->SetVideoFramerate(frame_rate);
videoHandlerM->SetVideoScan(eVideoScan(scan));
videoHandlerM->SetVideoAspectRatio(eVideoAspectRatio(aspect));
videoHandlerM->SetVideoFormat(eVideoFormat(format));
return true;
}

16
femonmpeg.h
View File

@ -13,19 +13,19 @@
class cFemonMPEG {
private:
cFemonVideoIf *m_VideoHandler;
cFemonAudioIf *m_AudioHandler;
cFemonVideoIf *videoHandlerM;
cFemonAudioIf *audioHandlerM;
static int s_Bitrates[2][3][16];
static int s_Samplerates[2][4];
static eAudioCodec s_Formats[2][4];
static int bitrateS[2][3][16];
static int sampleRateS[2][4];
static eAudioCodec formatS[2][4];
public:
cFemonMPEG(cFemonVideoIf *videohandler, cFemonAudioIf *audiohandler);
cFemonMPEG(cFemonVideoIf *videoHandlerP, cFemonAudioIf *audioHandlerP);
virtual ~cFemonMPEG();
bool processVideo(const uint8_t *buf, int len);
bool processAudio(const uint8_t *buf, int len);
bool processVideo(const uint8_t *bufP, int lenP);
bool processAudio(const uint8_t *bufP, int lenP);
};
#endif //__FEMONMPEG_H

748
femonosd.c
View File

File diff suppressed because it is too large Load Diff

84
femonosd.h
View File

@ -31,44 +31,44 @@ private:
DEVICESOURCE_COUNT
};
static cFemonOsd *pInstance;
static cFemonOsd *pInstanceS;
cOsd *m_Osd;
cFemonReceiver *m_Receiver;
int m_Frontend;
int m_SvdrpFrontend;
double m_SvdrpVideoBitrate;
double m_SvdrpAudioBitrate;
SvdrpConnection_v1_0 m_SvdrpConnection;
cPlugin *m_SvdrpPlugin;
int m_Number;
int m_OldNumber;
int m_Quality;
bool m_QualityValid;
int m_Strength;
bool m_StrengthValid;
uint16_t m_SNR;
bool m_SNRValid;
uint16_t m_Signal;
bool m_SignalValid;
uint32_t m_BER;
bool m_BERValid;
uint32_t m_UNC;
bool m_UNCValid;
cString m_FrontendName;
fe_status_t m_FrontendStatus;
bool m_FrontendStatusValid;
dvb_frontend_info m_FrontendInfo;
eDeviceSourceType m_DeviceSource;
int m_DisplayMode;
int m_OsdWidth;
int m_OsdHeight;
int m_OsdLeft;
int m_OsdTop;
cFont *m_Font;
cTimeMs m_InputTime;
cCondWait m_Sleep;
cMutex m_Mutex;
cOsd *osdM;
cFemonReceiver *receiverM;
int frontendM;
int svdrpFrontendM;
double svdrpVideoBitRateM;
double svdrpAudioBitRateM;
SvdrpConnection_v1_0 svdrpConnectionM;
cPlugin *svdrpPluginM;
int numberM;
int oldNumberM;
int qualityM;
bool qualityValidM;
int strengthM;
bool strengthValidM;
uint16_t snrM;
bool snrValidM;
uint16_t signalM;
bool signalValidM;
uint32_t berM;
bool berValidM;
uint32_t uncM;
bool uncValidM;
cString frontendNameM;
fe_status_t frontendStatusM;
bool frontendStatusValidM;
dvb_frontend_info frontendInfoM;
eDeviceSourceType deviceSourceM;
int displayModeM;
int osdWidthM;
int osdHeightM;
int osdLeftM;
int osdTopM;
cFont *fontM;
cTimeMs inputTimeM;
cCondWait sleepM;
cMutex mutexM;
void DrawStatusWindow(void);
void DrawInfoWindow(void);
@ -80,17 +80,17 @@ protected:
cFemonOsd(const cFemonOsd&);
cFemonOsd& operator= (const cFemonOsd&);
virtual void Action(void);
virtual void ChannelSwitch(const cDevice *device, int channelNumber, bool liveView);
virtual void SetAudioTrack(int Index, const char * const *Tracks);
virtual void ChannelSwitch(const cDevice *deviceP, int channelNumberP, bool liveViewP);
virtual void SetAudioTrack(int indexP, const char * const *tracksP);
public:
static cFemonOsd *Instance(bool create = false);
static cFemonOsd *Instance(bool createP = false);
~cFemonOsd();
virtual void Show(void);
virtual eOSState ProcessKey(eKeys Key);
virtual eOSState ProcessKey(eKeys keyP);
bool DeviceSwitch(int direction);
bool DeviceSwitch(int directionP);
double GetVideoBitrate(void);
double GetAudioBitrate(void);
double GetDolbyBitrate(void);

240
femonreceiver.c
View File

@ -10,66 +10,66 @@
#include "femoncfg.h"
#include "femonreceiver.h"
cFemonReceiver::cFemonReceiver(const cChannel *Channel, int ATrack, int DTrack)
: cReceiver(Channel),
cFemonReceiver::cFemonReceiver(const cChannel *channelP, int aTrackP, int dTrackP)
: cReceiver(channelP),
cThread("femon receiver"),
m_Mutex(),
m_Sleep(),
m_Active(false),
m_DetectH264(this),
m_DetectMPEG(this, this),
m_DetectAAC(this),
m_DetectLATM(this),
m_DetectAC3(this),
m_VideoBuffer(KILOBYTE(512), TS_SIZE, false, "Femon video"),
m_VideoType(Channel ? Channel->Vtype(): 0),
m_VideoPid(Channel ? Channel->Vpid() : 0),
m_VideoPacketCount(0),
m_VideoBitrate(0.0),
m_VideoValid(false),
m_AudioBuffer(KILOBYTE(256), TS_SIZE, false, "Femon audio"),
m_AudioPid(Channel ? Channel->Apid(ATrack) : 0),
m_AudioPacketCount(0),
m_AudioBitrate(0.0),
m_AudioValid(false),
m_AC3Buffer(KILOBYTE(256), TS_SIZE, false, "Femon AC3"),
m_AC3Pid(Channel ? Channel->Dpid(DTrack) : 0),
m_AC3PacketCount(0),
m_AC3Bitrate(0),
m_AC3Valid(false)
mutexM(),
sleepM(),
activeM(false),
detectH264M(this),
detectMpegM(this, this),
detectAacM(this),
detectLatmM(this),
detectAc3M(this),
videoBufferM(KILOBYTE(512), TS_SIZE, false, "Femon video"),
videoTypeM(channelP ? channelP->Vtype(): 0),
videoPidM(channelP ? channelP->Vpid() : 0),
videoPacketCountM(0),
videoBitRateM(0.0),
videoValidM(false),
audioBufferM(KILOBYTE(256), TS_SIZE, false, "Femon audio"),
audioPidM(channelP ? channelP->Apid(aTrackP) : 0),
audioPacketCountM(0),
audioBitRateM(0.0),
audioValidM(false),
ac3BufferM(KILOBYTE(256), TS_SIZE, false, "Femon AC3"),
ac3PidM(channelP ? channelP->Dpid(dTrackP) : 0),
ac3PacketCountM(0),
ac3BitRateM(0),
ac3ValidM(false)
{
debug("%s()\n", __PRETTY_FUNCTION__);
SetPids(NULL);
AddPid(m_VideoPid);
AddPid(m_AudioPid);
AddPid(m_AC3Pid);
AddPid(videoPidM);
AddPid(audioPidM);
AddPid(ac3PidM);
m_VideoBuffer.SetTimeouts(0, 100);
m_AudioBuffer.SetTimeouts(0, 100);
m_AC3Buffer.SetTimeouts(0, 100);
videoBufferM.SetTimeouts(0, 100);
audioBufferM.SetTimeouts(0, 100);
ac3BufferM.SetTimeouts(0, 100);
m_VideoInfo.codec = VIDEO_CODEC_INVALID;
m_VideoInfo.format = VIDEO_FORMAT_INVALID;
m_VideoInfo.scan = VIDEO_SCAN_INVALID;
m_VideoInfo.aspectRatio = VIDEO_ASPECT_RATIO_INVALID;
m_VideoInfo.width = 0;
m_VideoInfo.height = 0;
m_VideoInfo.frameRate = 0;
m_VideoInfo.bitrate = AUDIO_BITRATE_INVALID;
m_AudioInfo.codec = AUDIO_CODEC_UNKNOWN;
m_AudioInfo.bitrate = AUDIO_BITRATE_INVALID;
m_AudioInfo.samplingFrequency = AUDIO_SAMPLING_FREQUENCY_INVALID;
m_AudioInfo.channelMode = AUDIO_CHANNEL_MODE_INVALID;
m_AC3Info.bitrate = AUDIO_BITRATE_INVALID;
m_AC3Info.samplingFrequency = AUDIO_SAMPLING_FREQUENCY_INVALID;
m_AC3Info.bitstreamMode = AUDIO_BITSTREAM_MODE_INVALID;
m_AC3Info.audioCodingMode = AUDIO_CODING_MODE_INVALID;
m_AC3Info.dolbySurroundMode = AUDIO_DOLBY_SURROUND_MODE_INVALID;
m_AC3Info.centerMixLevel = AUDIO_CENTER_MIX_LEVEL_INVALID;
m_AC3Info.surroundMixLevel = AUDIO_SURROUND_MIX_LEVEL_INVALID;
m_AC3Info.dialogLevel = 0;
m_AC3Info.lfe = false;
videoInfoM.codec = VIDEO_CODEC_INVALID;
videoInfoM.format = VIDEO_FORMAT_INVALID;
videoInfoM.scan = VIDEO_SCAN_INVALID;
videoInfoM.aspectRatio = VIDEO_ASPECT_RATIO_INVALID;
videoInfoM.width = 0;
videoInfoM.height = 0;
videoInfoM.frameRate = 0;
videoInfoM.bitrate = AUDIO_BITRATE_INVALID;
audioInfoM.codec = AUDIO_CODEC_UNKNOWN;
audioInfoM.bitrate = AUDIO_BITRATE_INVALID;
audioInfoM.samplingFrequency = AUDIO_SAMPLING_FREQUENCY_INVALID;
audioInfoM.channelMode = AUDIO_CHANNEL_MODE_INVALID;
ac3InfoM.bitrate = AUDIO_BITRATE_INVALID;
ac3InfoM.samplingFrequency = AUDIO_SAMPLING_FREQUENCY_INVALID;
ac3InfoM.bitstreamMode = AUDIO_BITSTREAM_MODE_INVALID;
ac3InfoM.audioCodingMode = AUDIO_CODING_MODE_INVALID;
ac3InfoM.dolbySurroundMode = AUDIO_DOLBY_SURROUND_MODE_INVALID;
ac3InfoM.centerMixLevel = AUDIO_CENTER_MIX_LEVEL_INVALID;
ac3InfoM.surroundMixLevel = AUDIO_SURROUND_MIX_LEVEL_INVALID;
ac3InfoM.dialogLevel = 0;
ac3InfoM.lfe = false;
}
cFemonReceiver::~cFemonReceiver(void)
@ -82,50 +82,50 @@ void cFemonReceiver::Deactivate(void)
{
debug("%s()\n", __PRETTY_FUNCTION__);
Detach();
if (m_Active) {
m_Active = false;
m_Sleep.Signal();
if (activeM) {
activeM = false;
sleepM.Signal();
if (Running())
Cancel(3);
}
}
void cFemonReceiver::Activate(bool On)
void cFemonReceiver::Activate(bool onP)
{
debug("%s(%d)\n", __PRETTY_FUNCTION__, On);
if (On)
debug("%s(%d)\n", __PRETTY_FUNCTION__, onP);
if (onP)
Start();
else
Deactivate();
}
void cFemonReceiver::Receive(uchar *Data, int Length)
void cFemonReceiver::Receive(uchar *dataP, int lengthP)
{
// TS packet length: TS_SIZE
if (Running() && (*Data == TS_SYNC_BYTE) && (Length == TS_SIZE)) {
int len, pid = TsPid(Data);
if (pid == m_VideoPid) {
++m_VideoPacketCount;
len = m_VideoBuffer.Put(Data, Length);
if (len != Length) {
m_VideoBuffer.ReportOverflow(Length - len);
m_VideoBuffer.Clear();
if (Running() && (*dataP == TS_SYNC_BYTE) && (lengthP == TS_SIZE)) {
int len, pid = TsPid(dataP);
if (pid == videoPidM) {
++videoPacketCountM;
len = videoBufferM.Put(dataP, lengthP);
if (len != lengthP) {
videoBufferM.ReportOverflow(lengthP - len);
videoBufferM.Clear();
}
}
else if (pid == m_AudioPid) {
++m_AudioPacketCount;
len = m_AudioBuffer.Put(Data, Length);
if (len != Length) {
m_AudioBuffer.ReportOverflow(Length - len);
m_AudioBuffer.Clear();
else if (pid == audioPidM) {
++audioPacketCountM;
len = audioBufferM.Put(dataP, lengthP);
if (len != lengthP) {
audioBufferM.ReportOverflow(lengthP - len);
audioBufferM.Clear();
}
}
else if (pid == m_AC3Pid) {
++m_AC3PacketCount;
len = m_AC3Buffer.Put(Data, Length);
if (len != Length) {
m_AC3Buffer.ReportOverflow(Length - len);
m_AC3Buffer.Clear();
else if (pid == ac3PidM) {
++ac3PacketCountM;
len = ac3BufferM.Put(dataP, lengthP);
if (len != lengthP) {
ac3BufferM.ReportOverflow(lengthP - len);
ac3BufferM.Clear();
}
}
}
@ -135,17 +135,17 @@ void cFemonReceiver::Action(void)
{
debug("%s()\n", __PRETTY_FUNCTION__);
cTimeMs calcPeriod(0);
m_Active = true;
activeM = true;
while (Running() && m_Active) {
while (Running() && activeM) {
uint8_t *Data;
double timeout;
int len, Length;
bool processed = false;
// process available video data
while ((Data = m_VideoBuffer.Get(Length))) {
if (!m_Active || (Length < TS_SIZE))
while ((Data = videoBufferM.Get(Length))) {
if (!activeM || (Length < TS_SIZE))
break;
Length = TS_SIZE;
if (*Data != TS_SYNC_BYTE) {
@ -155,34 +155,34 @@ void cFemonReceiver::Action(void)
break;
}
}
m_VideoBuffer.Del(Length);
videoBufferM.Del(Length);
continue;
}
processed = true;
if (TsPayloadStart(Data)) {
while (const uint8_t *p = m_VideoAssembler.GetPes(len)) {
if (m_VideoType == 0x1B) { // MPEG4
if (m_DetectH264.processVideo(p, len)) {
m_VideoValid = true;
while (const uint8_t *p = videoAssemblerM.GetPes(len)) {
if (videoTypeM == 0x1B) { // MPEG4
if (detectH264M.processVideo(p, len)) {
videoValidM = true;
break;
}
}
else {
if (m_DetectMPEG.processVideo(p, len)) {
m_VideoValid = true;
if (detectMpegM.processVideo(p, len)) {
videoValidM = true;
break;
}
}
}
m_VideoAssembler.Reset();
videoAssemblerM.Reset();
}
m_VideoAssembler.PutTs(Data, Length);
m_VideoBuffer.Del(Length);
videoAssemblerM.PutTs(Data, Length);
videoBufferM.Del(Length);
}
// process available audio data
while ((Data = m_AudioBuffer.Get(Length))) {
if (!m_Active || (Length < TS_SIZE))
while ((Data = audioBufferM.Get(Length))) {
if (!activeM || (Length < TS_SIZE))
break;
Length = TS_SIZE;
if (*Data != TS_SYNC_BYTE) {
@ -192,22 +192,22 @@ void cFemonReceiver::Action(void)
break;
}
}
m_AudioBuffer.Del(Length);
audioBufferM.Del(Length);
continue;
}
processed = true;
if (const uint8_t *p = m_AudioAssembler.GetPes(len)) {
if (m_DetectAAC.processAudio(p, len) || m_DetectLATM.processAudio(p, len) || m_DetectMPEG.processAudio(p, len))
m_AudioValid = true;
m_AudioAssembler.Reset();
if (const uint8_t *p = audioAssemblerM.GetPes(len)) {
if (detectAacM.processAudio(p, len) || detectLatmM.processAudio(p, len) || detectMpegM.processAudio(p, len))
audioValidM = true;
audioAssemblerM.Reset();
}
m_AudioAssembler.PutTs(Data, Length);
m_AudioBuffer.Del(Length);
audioAssemblerM.PutTs(Data, Length);
audioBufferM.Del(Length);
}
// process available dolby data
while ((Data = m_AC3Buffer.Get(Length))) {
if (!m_Active || (Length < TS_SIZE))
while ((Data = ac3BufferM.Get(Length))) {
if (!activeM || (Length < TS_SIZE))
break;
Length = TS_SIZE;
if (*Data != TS_SYNC_BYTE) {
@ -217,34 +217,34 @@ void cFemonReceiver::Action(void)
break;
}
}
m_AC3Buffer.Del(Length);
ac3BufferM.Del(Length);
continue;
}
processed = true;
if (const uint8_t *p = m_AC3Assembler.GetPes(len)) {
if (m_DetectAC3.processAudio(p, len))
m_AC3Valid = true;
m_AC3Assembler.Reset();
if (const uint8_t *p = ac3AssemblerM.GetPes(len)) {
if (detectAc3M.processAudio(p, len))
ac3ValidM = true;
ac3AssemblerM.Reset();
}
m_AC3Assembler.PutTs(Data, Length);
m_AC3Buffer.Del(Length);
ac3AssemblerM.PutTs(Data, Length);
ac3BufferM.Del(Length);
}
// calculate bitrates
timeout = double(calcPeriod.Elapsed());
if (m_Active && (timeout >= (100.0 * femonConfig.calcinterval))) {
if (activeM && (timeout >= (100.0 * FemonConfig.calcinterval))) {
// TS packet 188 bytes - 4 byte header; MPEG standard defines 1Mbit = 1000000bit
// PES headers should be compensated!
m_VideoBitrate = (1000.0 * 8.0 * 184.0 * m_VideoPacketCount) / timeout;
m_VideoPacketCount = 0;
m_AudioBitrate = (1000.0 * 8.0 * 184.0 * m_AudioPacketCount) / timeout;
m_AudioPacketCount = 0;
m_AC3Bitrate = (1000.0 * 8.0 * 184.0 * m_AC3PacketCount) / timeout;
m_AC3PacketCount = 0;
videoBitRateM = (1000.0 * 8.0 * 184.0 * videoPacketCountM) / timeout;
videoPacketCountM = 0;
audioBitRateM = (1000.0 * 8.0 * 184.0 * audioPacketCountM) / timeout;
audioPacketCountM = 0;
ac3BitRateM = (1000.0 * 8.0 * 184.0 * ac3PacketCountM) / timeout;
ac3PacketCountM = 0;
calcPeriod.Set(0);
}
if (!processed)
m_Sleep.Wait(10); // to avoid busy loop and reduce cpu load
sleepM.Wait(10); // to avoid busy loop and reduce cpu load
}
}

264
femonreceiver.h
View File

@ -22,156 +22,156 @@
class cFemonReceiver : public cReceiver, public cThread, public cFemonVideoIf, public cFemonAudioIf, public cFemonAC3If {
private:
cMutex m_Mutex;
cCondWait m_Sleep;
bool m_Active;
cMutex mutexM;
cCondWait sleepM;
bool activeM;
cFemonH264 m_DetectH264;
cFemonMPEG m_DetectMPEG;
cFemonAAC m_DetectAAC;
cFemonLATM m_DetectLATM;
cFemonAC3 m_DetectAC3;
cFemonH264 detectH264M;
cFemonMPEG detectMpegM;
cFemonAAC detectAacM;
cFemonLATM detectLatmM;
cFemonAC3 detectAc3M;
cRingBufferLinear m_VideoBuffer;
cTsToPes m_VideoAssembler;
int m_VideoType;
int m_VideoPid;
int m_VideoPacketCount;
double m_VideoBitrate;
bool m_VideoValid;
video_info_t m_VideoInfo;
cRingBufferLinear videoBufferM;
cTsToPes videoAssemblerM;
int videoTypeM;
int videoPidM;
int videoPacketCountM;
double videoBitRateM;
bool videoValidM;
video_info_t videoInfoM;
cRingBufferLinear m_AudioBuffer;
cTsToPes m_AudioAssembler;
int m_AudioPid;
int m_AudioPacketCount;
double m_AudioBitrate;
bool m_AudioValid;
audio_info_t m_AudioInfo;
cRingBufferLinear audioBufferM;
cTsToPes audioAssemblerM;
int audioPidM;
int audioPacketCountM;
double audioBitRateM;
bool audioValidM;
audio_info_t audioInfoM;
cRingBufferLinear m_AC3Buffer;
cTsToPes m_AC3Assembler;
int m_AC3Pid;
int m_AC3PacketCount;
double m_AC3Bitrate;
bool m_AC3Valid;
ac3_info_t m_AC3Info;
cRingBufferLinear ac3BufferM;
cTsToPes ac3AssemblerM;
int ac3PidM;
int ac3PacketCountM;
double ac3BitRateM;
bool ac3ValidM;
ac3_info_t ac3InfoM;
protected:
virtual void Activate(bool On);
virtual void Receive(uchar *Data, int Length);
virtual void Activate(bool onP);
virtual void Receive(uchar *dataP, int lengthP);
virtual void Action(void);
public:
virtual void SetVideoCodec(eVideoCodec codec) { cMutexLock MutexLock(&m_Mutex);
m_VideoInfo.codec = codec; }
virtual void SetVideoFormat(eVideoFormat format) { cMutexLock MutexLock(&m_Mutex);
m_VideoInfo.format = format; }
virtual void SetVideoScan(eVideoScan scan) { cMutexLock MutexLock(&m_Mutex);
m_VideoInfo.scan = scan; }
virtual void SetVideoAspectRatio(eVideoAspectRatio aspectratio) { cMutexLock MutexLock(&m_Mutex);
m_VideoInfo.aspectRatio = aspectratio; }
virtual void SetVideoSize(int width, int height) { cMutexLock MutexLock(&m_Mutex);
m_VideoInfo.width = width;
m_VideoInfo.height = height; }
virtual void SetVideoFramerate(double framerate) { cMutexLock MutexLock(&m_Mutex);
m_VideoInfo.frameRate = framerate; }
virtual void SetVideoBitrate(double bitrate) { cMutexLock MutexLock(&m_Mutex);
m_VideoInfo.bitrate = bitrate; }
virtual void SetVideoCodec(eVideoCodec codecP) { cMutexLock MutexLock(&mutexM);
videoInfoM.codec = codecP; }
virtual void SetVideoFormat(eVideoFormat formatP) { cMutexLock MutexLock(&mutexM);
videoInfoM.format = formatP; }
virtual void SetVideoScan(eVideoScan scanP) { cMutexLock MutexLock(&mutexM);
videoInfoM.scan = scanP; }
virtual void SetVideoAspectRatio(eVideoAspectRatio aspectRatioP) { cMutexLock MutexLock(&mutexM);
videoInfoM.aspectRatio = aspectRatioP; }
virtual void SetVideoSize(int widthP, int heightP) { cMutexLock MutexLock(&mutexM);
videoInfoM.width = widthP;
videoInfoM.height = heightP; }
virtual void SetVideoFramerate(double frameRateP) { cMutexLock MutexLock(&mutexM);
videoInfoM.frameRate = frameRateP; }
virtual void SetVideoBitrate(double bitRateP) { cMutexLock MutexLock(&mutexM);
videoInfoM.bitrate = bitRateP; }
virtual void SetAudioCodec(eAudioCodec codec) { cMutexLock MutexLock(&m_Mutex);
m_AudioInfo.codec = codec; }
virtual void SetAudioBitrate(double bitrate) { cMutexLock MutexLock(&m_Mutex);
m_AudioInfo.bitrate = bitrate; }
virtual void SetAudioSamplingFrequency(int sampling) { cMutexLock MutexLock(&m_Mutex);
m_AudioInfo.samplingFrequency = sampling; }
virtual void SetAudioChannel(eAudioChannelMode mode) { cMutexLock MutexLock(&m_Mutex);
m_AudioInfo.channelMode = mode; }
virtual void SetAudioCodec(eAudioCodec codecP) { cMutexLock MutexLock(&mutexM);
audioInfoM.codec = codecP; }
virtual void SetAudioBitrate(double bitRateP) { cMutexLock MutexLock(&mutexM);
audioInfoM.bitrate = bitRateP; }
virtual void SetAudioSamplingFrequency(int samplingP) { cMutexLock MutexLock(&mutexM);
audioInfoM.samplingFrequency = samplingP; }
virtual void SetAudioChannel(eAudioChannelMode modeP) { cMutexLock MutexLock(&mutexM);
audioInfoM.channelMode = modeP; }
virtual void SetAC3Bitrate(int bitrate) { cMutexLock MutexLock(&m_Mutex);
m_AC3Info.bitrate = bitrate; }
virtual void SetAC3SamplingFrequency(int sampling) { cMutexLock MutexLock(&m_Mutex);
m_AC3Info.samplingFrequency = sampling; }
virtual void SetAC3Bitstream(int mode) { cMutexLock MutexLock(&m_Mutex);
m_AC3Info.bitstreamMode = mode; }
virtual void SetAC3AudioCoding(int mode) { cMutexLock MutexLock(&m_Mutex);
m_AC3Info.audioCodingMode = mode; }
virtual void SetAC3DolbySurround(int mode) { cMutexLock MutexLock(&m_Mutex);
m_AC3Info.dolbySurroundMode = mode; }
virtual void SetAC3CenterMix(int level) { cMutexLock MutexLock(&m_Mutex);
m_AC3Info.centerMixLevel = level; }
virtual void SetAC3SurroundMix(int level) { cMutexLock MutexLock(&m_Mutex);
m_AC3Info.surroundMixLevel = level; }
virtual void SetAC3Dialog(int level) { cMutexLock MutexLock(&m_Mutex);
m_AC3Info.dialogLevel = level; }
virtual void SetAC3LFE(bool onoff) { cMutexLock MutexLock(&m_Mutex);
m_AC3Info.lfe = onoff; }
virtual void SetAC3Bitrate(int bitRateP) { cMutexLock MutexLock(&mutexM);
ac3InfoM.bitrate = bitRateP; }
virtual void SetAC3SamplingFrequency(int samplingP) { cMutexLock MutexLock(&mutexM);
ac3InfoM.samplingFrequency = samplingP; }
virtual void SetAC3Bitstream(int modeP) { cMutexLock MutexLock(&mutexM);
ac3InfoM.bitstreamMode = modeP; }
virtual void SetAC3AudioCoding(int modeP) { cMutexLock MutexLock(&mutexM);
ac3InfoM.audioCodingMode = modeP; }
virtual void SetAC3DolbySurround(int modeP) { cMutexLock MutexLock(&mutexM);
ac3InfoM.dolbySurroundMode = modeP; }
virtual void SetAC3CenterMix(int levelP) { cMutexLock MutexLock(&mutexM);
ac3InfoM.centerMixLevel = levelP; }
virtual void SetAC3SurroundMix(int levelP) { cMutexLock MutexLock(&mutexM);
ac3InfoM.surroundMixLevel = levelP; }
virtual void SetAC3Dialog(int levelP) { cMutexLock MutexLock(&mutexM);
ac3InfoM.dialogLevel = levelP; }
virtual void SetAC3LFE(bool onoffP) { cMutexLock MutexLock(&mutexM);
ac3InfoM.lfe = onoffP; }
public:
cFemonReceiver(const cChannel* Channel, int ATrack, int DTrack);
cFemonReceiver(const cChannel* channelP, int aTrackp, int dTrackP);
virtual ~cFemonReceiver();
void Deactivate(void);
bool VideoValid(void) { cMutexLock MutexLock(&m_Mutex);
return m_VideoValid; }; // boolean
double VideoBitrate(void) { cMutexLock MutexLock(&m_Mutex);
return m_VideoBitrate; }; // bit/s
int VideoCodec(void) { cMutexLock MutexLock(&m_Mutex);
return m_VideoInfo.codec; }; // eVideoCodec
int VideoFormat(void) { cMutexLock MutexLock(&m_Mutex);
return m_VideoInfo.format; }; // eVideoFormat
int VideoScan(void) { cMutexLock MutexLock(&m_Mutex);
return m_VideoInfo.scan; }; // eVideoScan
int VideoAspectRatio(void) { cMutexLock MutexLock(&m_Mutex);
return m_VideoInfo.aspectRatio; }; // eVideoAspectRatio
int VideoHorizontalSize(void) { cMutexLock MutexLock(&m_Mutex);
return m_VideoInfo.width; }; // pixels
int VideoVerticalSize(void) { cMutexLock MutexLock(&m_Mutex);
return m_VideoInfo.height; }; // pixels
double VideoFrameRate(void) { cMutexLock MutexLock(&m_Mutex);
return m_VideoInfo.frameRate; }; // Hz
double VideoStreamBitrate(void) { cMutexLock MutexLock(&m_Mutex);
return m_VideoInfo.bitrate; }; // bit/s
bool VideoValid(void) { cMutexLock MutexLock(&mutexM);
return videoValidM; }; // boolean
double VideoBitrate(void) { cMutexLock MutexLock(&mutexM);
return videoBitRateM; }; // bit/s
int VideoCodec(void) { cMutexLock MutexLock(&mutexM);
return videoInfoM.codec; }; // eVideoCodec
int VideoFormat(void) { cMutexLock MutexLock(&mutexM);
return videoInfoM.format; }; // eVideoFormat
int VideoScan(void) { cMutexLock MutexLock(&mutexM);
return videoInfoM.scan; }; // eVideoScan
int VideoAspectRatio(void) { cMutexLock MutexLock(&mutexM);
return videoInfoM.aspectRatio; }; // eVideoAspectRatio
int VideoHorizontalSize(void) { cMutexLock MutexLock(&mutexM);
return videoInfoM.width; }; // pixels
int VideoVerticalSize(void) { cMutexLock MutexLock(&mutexM);
return videoInfoM.height; }; // pixels
double VideoFrameRate(void) { cMutexLock MutexLock(&mutexM);
return videoInfoM.frameRate; }; // Hz
double VideoStreamBitrate(void) { cMutexLock MutexLock(&mutexM);
return videoInfoM.bitrate; }; // bit/s
bool AudioValid(void) { cMutexLock MutexLock(&m_Mutex);
return m_AudioValid; }; // boolean
double AudioBitrate(void) { cMutexLock MutexLock(&m_Mutex);
return m_AudioBitrate; }; // bit/s
int AudioCodec(void) { cMutexLock MutexLock(&m_Mutex);
return m_AudioInfo.codec; }; // eAudioCodec
int AudioChannelMode(void) { cMutexLock MutexLock(&m_Mutex);
return m_AudioInfo.channelMode; }; // eAudioChannelMode
double AudioStreamBitrate(void) { cMutexLock MutexLock(&m_Mutex);
return m_AudioInfo.bitrate; }; // bit/s or eAudioBitrate
int AudioSamplingFreq(void) { cMutexLock MutexLock(&m_Mutex);
return m_AudioInfo.samplingFrequency; }; // Hz or eAudioSamplingFrequency
bool AudioValid(void) { cMutexLock MutexLock(&mutexM);
return audioValidM; }; // boolean
double AudioBitrate(void) { cMutexLock MutexLock(&mutexM);
return audioBitRateM; }; // bit/s
int AudioCodec(void) { cMutexLock MutexLock(&mutexM);
return audioInfoM.codec; }; // eAudioCodec
int AudioChannelMode(void) { cMutexLock MutexLock(&mutexM);
return audioInfoM.channelMode; }; // eAudioChannelMode
double AudioStreamBitrate(void) { cMutexLock MutexLock(&mutexM);
return audioInfoM.bitrate; }; // bit/s or eAudioBitrate
int AudioSamplingFreq(void) { cMutexLock MutexLock(&mutexM);
return audioInfoM.samplingFrequency; }; // Hz or eAudioSamplingFrequency
bool AC3Valid(void) { cMutexLock MutexLock(&m_Mutex);
return m_AC3Valid; }; // boolean
double AC3Bitrate(void) { cMutexLock MutexLock(&m_Mutex);
return m_AC3Bitrate; }; // bit/s
double AC3StreamBitrate(void) { cMutexLock MutexLock(&m_Mutex);
return m_AC3Info.bitrate; }; // bit/s or eAudioBitrate
int AC3SamplingFreq(void) { cMutexLock MutexLock(&m_Mutex);
return m_AC3Info.samplingFrequency; }; // Hz or eAudioSamplingFrequency
int AC3BitStreamMode(void) { cMutexLock MutexLock(&m_Mutex);
return m_AC3Info.bitstreamMode; }; // 0..7 or eAudioBitstreamMode
int AC3AudioCodingMode(void) { cMutexLock MutexLock(&m_Mutex);
return m_AC3Info.audioCodingMode; }; // 0..7 or eAudioCodingMode
bool AC3_2_0(void) { cMutexLock MutexLock(&m_Mutex);
return (m_AC3Info.audioCodingMode == AUDIO_CODING_MODE_2_0); }; // boolean
bool AC3_5_1(void) { cMutexLock MutexLock(&m_Mutex);
return (m_AC3Info.audioCodingMode == AUDIO_CODING_MODE_3_2); }; // boolean
int AC3DolbySurroundMode(void) { cMutexLock MutexLock(&m_Mutex);
return m_AC3Info.dolbySurroundMode; }; // eAudioDolbySurroundMode
int AC3CenterMixLevel(void) { cMutexLock MutexLock(&m_Mutex);
return m_AC3Info.centerMixLevel; }; // eAudioCenterMixLevel
int AC3SurroundMixLevel(void) { cMutexLock MutexLock(&m_Mutex);
return m_AC3Info.surroundMixLevel; }; // eAudioSurroundMixLevel
int AC3DialogLevel(void) { cMutexLock MutexLock(&m_Mutex);
return m_AC3Info.dialogLevel; }; // -dB
bool AC3Lfe(void) { cMutexLock MutexLock(&m_Mutex);
return m_AC3Info.lfe; }; // boolean
bool AC3Valid(void) { cMutexLock MutexLock(&mutexM);
return ac3ValidM; }; // boolean
double AC3Bitrate(void) { cMutexLock MutexLock(&mutexM);
return ac3BitRateM; }; // bit/s
double AC3StreamBitrate(void) { cMutexLock MutexLock(&mutexM);
return ac3InfoM.bitrate; }; // bit/s or eAudioBitrate
int AC3SamplingFreq(void) { cMutexLock MutexLock(&mutexM);
return ac3InfoM.samplingFrequency; }; // Hz or eAudioSamplingFrequency
int AC3BitStreamMode(void) { cMutexLock MutexLock(&mutexM);
return ac3InfoM.bitstreamMode; }; // 0..7 or eAudioBitstreamMode
int AC3AudioCodingMode(void) { cMutexLock MutexLock(&mutexM);
return ac3InfoM.audioCodingMode; }; // 0..7 or eAudioCodingMode
bool AC3_2_0(void) { cMutexLock MutexLock(&mutexM);
return (ac3InfoM.audioCodingMode == AUDIO_CODING_MODE_2_0); }; // boolean
bool AC3_5_1(void) { cMutexLock MutexLock(&mutexM);
return (ac3InfoM.audioCodingMode == AUDIO_CODING_MODE_3_2); }; // boolean
int AC3DolbySurroundMode(void) { cMutexLock MutexLock(&mutexM);
return ac3InfoM.dolbySurroundMode; }; // eAudioDolbySurroundMode
int AC3CenterMixLevel(void) { cMutexLock MutexLock(&mutexM);
return ac3InfoM.centerMixLevel; }; // eAudioCenterMixLevel
int AC3SurroundMixLevel(void) { cMutexLock MutexLock(&mutexM);
return ac3InfoM.surroundMixLevel; }; // eAudioSurroundMixLevel
int AC3DialogLevel(void) { cMutexLock MutexLock(&mutexM);
return ac3InfoM.dialogLevel; }; // -dB
bool AC3Lfe(void) { cMutexLock MutexLock(&mutexM);
return ac3InfoM.lfe; }; // boolean
};
#endif //__FEMONRECEIVER_H

374
femontools.c
View File

@ -19,88 +19,88 @@
#include "femonosd.h"
#include "femontools.h"
static cString getCA(int value)
static cString getCA(int valueP)
{
// http://www.dvb.org/index.php?id=174
// http://en.wikipedia.org/wiki/Conditional_access_system
switch (value) {
case 0x0000: return cString::sprintf("%s (%X)", trVDR("Free To Air"), value); // Reserved
switch (valueP) {
case 0x0000: return cString::sprintf("%s (%X)", trVDR("Free To Air"), valueP); // Reserved
case 0x0001 ... 0x009F:
case 0x00A2 ... 0x00FF: return cString::sprintf("%s (%X)", tr("Fixed"), value); // Standardized systems
case 0x00A0 ... 0x00A1: return cString::sprintf("%s (%X)", tr("Analog"), value); // Analog signals
case 0x0100 ... 0x01FF: return cString::sprintf("SECA Mediaguard (%X)", value); // Canal Plus
case 0x0464: return cString::sprintf("EuroDec (%X)", value); // EuroDec
case 0x0500 ... 0x05FF: return cString::sprintf("Viaccess (%X)", value); // France Telecom
case 0x0600 ... 0x06FF: return cString::sprintf("Irdeto (%X)", value); // Irdeto
case 0x0700 ... 0x07FF: return cString::sprintf("DigiCipher 2 (%X)", value); // Jerrold/GI/Motorola 4DTV
case 0x0900 ... 0x09FF: return cString::sprintf("NDS Videoguard (%X)", value); // NDS
case 0x0B00 ... 0x0BFF: return cString::sprintf("Conax (%X)", value); // Norwegian Telekom
case 0x0D00 ... 0x0DFF: return cString::sprintf("CryptoWorks (%X)", value); // Philips CryptoTec
case 0x0E00 ... 0x0EFF: return cString::sprintf("PowerVu (%X)", value); // Scientific Atlanta
case 0x1000: return cString::sprintf("RAS (%X)", value); // Tandberg Television
case 0x1200 ... 0x12FF: return cString::sprintf("NagraVision (%X)", value); // BellVu Express
case 0x1700 ... 0x17FF: return cString::sprintf("VCAS (%X)", value); // Verimatrix Inc. former BetaTechnik
case 0x1800 ... 0x18FF: return cString::sprintf("NagraVision (%X)", value); // Kudelski SA
case 0x22F0: return cString::sprintf("Codicrypt (%X)", value); // Scopus Network Technologies
case 0x2600: return cString::sprintf("BISS (%X)", value); // European Broadcasting Union
case 0x2719: return cString::sprintf("VanyaCas (%X)", value); // S-Curious Research & Technology Pvt. Ltd.
case 0x4347: return cString::sprintf("CryptOn (%X)", value); // CryptOn
case 0x4800: return cString::sprintf("Accessgate (%X)", value); // Telemann
case 0x4900: return cString::sprintf("China Crypt (%X)", value); // CryptoWorks
case 0x4A02: return cString::sprintf("Tongfang (%X)", value); // Tsinghua Tongfang Company
case 0x4A10: return cString::sprintf("EasyCas (%X)", value); // EasyCas
case 0x4A20: return cString::sprintf("AlphaCrypt (%X)", value); // AlphaCrypt
case 0x4A60: return cString::sprintf("SkyCrypt (%X)", value); // @Sky
case 0x4A61: return cString::sprintf("Neotioncrypt (%X)", value); // Neotion
case 0x4A62: return cString::sprintf("SkyCrypt (%X)", value); // @Sky
case 0x4A63: return cString::sprintf("Neotion SHL (%X)", value); // Neotion
case 0x4A64 ... 0x4A6F: return cString::sprintf("SkyCrypt (%X)", value); // @Sky
case 0x4A70: return cString::sprintf("DreamCrypt (%X)", value); // Dream Multimedia
case 0x4A80: return cString::sprintf("ThalesCrypt (%X)", value); // Thales Broadcast & Multimedia
case 0x4AA1: return cString::sprintf("KeyFly (%X)", value); // SIDSA
case 0x4ABF: return cString::sprintf("CTI-CAS (%X)", value); // Beijing Compunicate Technology Inc.
case 0x4AC1: return cString::sprintf("Latens (%X)", value); // Latens Systems
case 0x4AD0 ... 0x4AD1: return cString::sprintf("X-Crypt (%X)", value); // XCrypt Inc.
case 0x4AD4: return cString::sprintf("OmniCrypt (%X)", value); // Widevine Technologies, Inc.
case 0x4AE0 ... 0x4AE1: return cString::sprintf("Z-Crypt (%X)", value); // Digi Raum Electronics Co. Ltd.
case 0x4AE4: return cString::sprintf("CoreCrypt (%X)", value); // CoreTrust
case 0x4AE5: return cString::sprintf("PRO-Crypt (%X)", value); // IK SATPROF
case 0x4AEA: return cString::sprintf("Cryptoguard (%X)", value); // Gryptoguard AB
case 0x4AEB: return cString::sprintf("Abel Quintic (%X)", value); // Abel DRM Systems
case 0x4AF0: return cString::sprintf("ABV (%X)", value); // Alliance Broadcast Vision
case 0x5500: return cString::sprintf("Z-Crypt (%X)", value); // Digi Raum Electronics Co. Ltd.
case 0x5501: return cString::sprintf("Griffin (%X)", value); // Nucleus Systems Ltd.
case 0x5581: return cString::sprintf("Bulcrypt (%X)", value); // Bulcrypt
case 0x7BE1: return cString::sprintf("DRE-Crypt (%X)", value); // DRE-Crypt
case 0xA101: return cString::sprintf("RosCrypt-M (%X)", value); // NIIR
case 0xEAD0: return cString::sprintf("VanyaCas (%X)", value); // S-Curious Research & Technology Pvt. Ltd.
case 0x00A2 ... 0x00FF: return cString::sprintf("%s (%X)", tr("Fixed"), valueP); // Standardized systems
case 0x00A0 ... 0x00A1: return cString::sprintf("%s (%X)", tr("Analog"), valueP); // Analog signals
case 0x0100 ... 0x01FF: return cString::sprintf("SECA Mediaguard (%X)", valueP); // Canal Plus
case 0x0464: return cString::sprintf("EuroDec (%X)", valueP); // EuroDec
case 0x0500 ... 0x05FF: return cString::sprintf("Viaccess (%X)", valueP); // France Telecom
case 0x0600 ... 0x06FF: return cString::sprintf("Irdeto (%X)", valueP); // Irdeto
case 0x0700 ... 0x07FF: return cString::sprintf("DigiCipher 2 (%X)", valueP); // Jerrold/GI/Motorola 4DTV
case 0x0900 ... 0x09FF: return cString::sprintf("NDS Videoguard (%X)", valueP); // NDS
case 0x0B00 ... 0x0BFF: return cString::sprintf("Conax (%X)", valueP); // Norwegian Telekom
case 0x0D00 ... 0x0DFF: return cString::sprintf("CryptoWorks (%X)", valueP); // Philips CryptoTec
case 0x0E00 ... 0x0EFF: return cString::sprintf("PowerVu (%X)", valueP); // Scientific Atlanta
case 0x1000: return cString::sprintf("RAS (%X)", valueP); // Tandberg Television
case 0x1200 ... 0x12FF: return cString::sprintf("NagraVision (%X)", valueP); // BellVu Express
case 0x1700 ... 0x17FF: return cString::sprintf("VCAS (%X)", valueP); // Verimatrix Inc. former BetaTechnik
case 0x1800 ... 0x18FF: return cString::sprintf("NagraVision (%X)", valueP); // Kudelski SA
case 0x22F0: return cString::sprintf("Codicrypt (%X)", valueP); // Scopus Network Technologies
case 0x2600: return cString::sprintf("BISS (%X)", valueP); // European Broadcasting Union
case 0x2719: return cString::sprintf("VanyaCas (%X)", valueP); // S-Curious Research & Technology Pvt. Ltd.
case 0x4347: return cString::sprintf("CryptOn (%X)", valueP); // CryptOn
case 0x4800: return cString::sprintf("Accessgate (%X)", valueP); // Telemann
case 0x4900: return cString::sprintf("China Crypt (%X)", valueP); // CryptoWorks
case 0x4A02: return cString::sprintf("Tongfang (%X)", valueP); // Tsinghua Tongfang Company
case 0x4A10: return cString::sprintf("EasyCas (%X)", valueP); // EasyCas
case 0x4A20: return cString::sprintf("AlphaCrypt (%X)", valueP); // AlphaCrypt
case 0x4A60: return cString::sprintf("SkyCrypt (%X)", valueP); // @Sky
case 0x4A61: return cString::sprintf("Neotioncrypt (%X)", valueP); // Neotion
case 0x4A62: return cString::sprintf("SkyCrypt (%X)", valueP); // @Sky
case 0x4A63: return cString::sprintf("Neotion SHL (%X)", valueP); // Neotion
case 0x4A64 ... 0x4A6F: return cString::sprintf("SkyCrypt (%X)", valueP); // @Sky
case 0x4A70: return cString::sprintf("DreamCrypt (%X)", valueP); // Dream Multimedia
case 0x4A80: return cString::sprintf("ThalesCrypt (%X)", valueP); // Thales Broadcast & Multimedia
case 0x4AA1: return cString::sprintf("KeyFly (%X)", valueP); // SIDSA
case 0x4ABF: return cString::sprintf("CTI-CAS (%X)", valueP); // Beijing Compunicate Technology Inc.
case 0x4AC1: return cString::sprintf("Latens (%X)", valueP); // Latens Systems
case 0x4AD0 ... 0x4AD1: return cString::sprintf("X-Crypt (%X)", valueP); // XCrypt Inc.
case 0x4AD4: return cString::sprintf("OmniCrypt (%X)", valueP); // Widevine Technologies, Inc.
case 0x4AE0 ... 0x4AE1: return cString::sprintf("Z-Crypt (%X)", valueP); // Digi Raum Electronics Co. Ltd.
case 0x4AE4: return cString::sprintf("CoreCrypt (%X)", valueP); // CoreTrust
case 0x4AE5: return cString::sprintf("PRO-Crypt (%X)", valueP); // IK SATPROF
case 0x4AEA: return cString::sprintf("Cryptoguard (%X)", valueP); // Gryptoguard AB
case 0x4AEB: return cString::sprintf("Abel Quintic (%X)", valueP); // Abel DRM Systems
case 0x4AF0: return cString::sprintf("ABV (%X)", valueP); // Alliance Broadcast Vision
case 0x5500: return cString::sprintf("Z-Crypt (%X)", valueP); // Digi Raum Electronics Co. Ltd.
case 0x5501: return cString::sprintf("Griffin (%X)", valueP); // Nucleus Systems Ltd.
case 0x5581: return cString::sprintf("Bulcrypt (%X)", valueP); // Bulcrypt
case 0x7BE1: return cString::sprintf("DRE-Crypt (%X)", valueP); // DRE-Crypt
case 0xA101: return cString::sprintf("RosCrypt-M (%X)", valueP); // NIIR
case 0xEAD0: return cString::sprintf("VanyaCas (%X)", valueP); // S-Curious Research & Technology Pvt. Ltd.
default: break;
}
return cString::sprintf("%X", value);
return cString::sprintf("%X", valueP);
}
static const char *getUserString(int Value, const tDvbParameterMap *Map)
static const char *getUserString(int valueP, const tDvbParameterMap *mapP)
{
const tDvbParameterMap *map = Map;
const tDvbParameterMap *map = mapP;
while (map && map->userValue != -1) {
if (map->driverValue == Value)
if (map->driverValue == valueP)
return map->userString ? trVDR(map->userString) : "---";
map++;
}
return "---";
}
cDvbDevice *getDvbDevice(cDevice* device)
cDvbDevice *getDvbDevice(cDevice* deviceP)
{
cDvbDevice *dev = dynamic_cast<cDvbDevice*>(device);
cDvbDevice *dev = dynamic_cast<cDvbDevice*>(deviceP);
#ifdef __DYNAMIC_DEVICE_PROBE
if (!dev && device && device->HasSubDevice())
dev = dynamic_cast<cDvbDevice*>(device->SubDevice());
if (!dev && deviceP && deviceP->HasSubDevice())
dev = dynamic_cast<cDvbDevice*>(deviceP->SubDevice());
#endif
return dev;
}
cString getFrontendInfo(cDvbDevice *device)
cString getFrontendInfo(cDvbDevice *deviceP)
{
struct dvb_frontend_info value;
fe_status_t status;
@ -111,17 +111,17 @@ cString getFrontendInfo(cDvbDevice *device)
uint32_t unc = 0;
cChannel *channel = Channels.GetByNumber(cDevice::CurrentChannel());
if (!device)
if (!deviceP)
return info;
int fe = open(*cString::sprintf(FRONTEND_DEVICE, device->Adapter(), device->Frontend()), O_RDONLY | O_NONBLOCK);
int fe = open(*cString::sprintf(FRONTEND_DEVICE, deviceP->Adapter(), deviceP->Frontend()), O_RDONLY | O_NONBLOCK);
if (fe < 0)
return info;
info = cString::sprintf("CARD:%d\nSTRG:%d\nQUAL:%d", device->CardIndex(), device->SignalStrength(), device->SignalQuality());
info = cString::sprintf("CARD:%d\nSTRG:%d\nQUAL:%d", deviceP->CardIndex(), deviceP->SignalStrength(), deviceP->SignalQuality());
if (ioctl(fe, FE_GET_INFO, &value) >= 0)
info = cString::sprintf("%s\nTYPE:%d\nNAME:%s", *info, value.type, *device->DeviceName());
info = cString::sprintf("%s\nTYPE:%d\nNAME:%s", *info, value.type, *deviceP->DeviceName());
if (ioctl(fe, FE_READ_STATUS, &status) >= 0)
info = cString::sprintf("%s\nSTAT:%02X", *info, status);
if (ioctl(fe, FE_READ_SIGNAL_STRENGTH, &signal) >= 0)
@ -143,39 +143,39 @@ cString getFrontendInfo(cDvbDevice *device)
return info;
}
cString getFrontendName(cDvbDevice *device)
cString getFrontendName(cDvbDevice *deviceP)
{
if (!device)
if (!deviceP)
return NULL;
return (cString::sprintf("%s on device #%d", *device->DeviceName(), device->CardIndex()));
return (cString::sprintf("%s on deviceP #%d", *deviceP->DeviceName(), deviceP->CardIndex()));
}
cString getFrontendStatus(cDvbDevice *device)
cString getFrontendStatus(cDvbDevice *deviceP)
{
fe_status_t value;
if (!device)
if (!deviceP)
return NULL;
int fe = open(*cString::sprintf(FRONTEND_DEVICE, device->Adapter(), device->Frontend()), O_RDONLY | O_NONBLOCK);
int fe = open(*cString::sprintf(FRONTEND_DEVICE, deviceP->Adapter(), deviceP->Frontend()), O_RDONLY | O_NONBLOCK);
if (fe < 0)
return NULL;
memset(&value, 0, sizeof(value));
ioctl(fe, FE_READ_STATUS, &value);
close(fe);
return (cString::sprintf("Status %s:%s:%s:%s:%s on device #%d", (value & FE_HAS_LOCK) ? "LOCKED" : "-", (value & FE_HAS_SIGNAL) ? "SIGNAL" : "-", (value & FE_HAS_CARRIER) ? "CARRIER" : "-", (value & FE_HAS_VITERBI) ? "VITERBI" : "-", (value & FE_HAS_SYNC) ? "SYNC" : "-", device->CardIndex()));
return (cString::sprintf("Status %s:%s:%s:%s:%s on deviceP #%d", (value & FE_HAS_LOCK) ? "LOCKED" : "-", (value & FE_HAS_SIGNAL) ? "SIGNAL" : "-", (value & FE_HAS_CARRIER) ? "CARRIER" : "-", (value & FE_HAS_VITERBI) ? "VITERBI" : "-", (value & FE_HAS_SYNC) ? "SYNC" : "-", deviceP->CardIndex()));
}
uint16_t getSignal(cDvbDevice *device)
uint16_t getSignal(cDvbDevice *deviceP)
{
uint16_t value = 0;
if (!device)
if (!deviceP)
return (value);
int fe = open(*cString::sprintf(FRONTEND_DEVICE, device->Adapter(), device->Frontend()), O_RDONLY | O_NONBLOCK);
int fe = open(*cString::sprintf(FRONTEND_DEVICE, deviceP->Adapter(), deviceP->Frontend()), O_RDONLY | O_NONBLOCK);
if (fe < 0)
return (value);
ioctl(fe, FE_READ_SIGNAL_STRENGTH, &value);
@ -184,14 +184,14 @@ uint16_t getSignal(cDvbDevice *device)
return (value);
}
uint16_t getSNR(cDvbDevice *device)
uint16_t getSNR(cDvbDevice *deviceP)
{
uint16_t value = 0;
if (!device)
if (!deviceP)
return (value);
int fe = open(*cString::sprintf(FRONTEND_DEVICE, device->Adapter(), device->Frontend()), O_RDONLY | O_NONBLOCK);
int fe = open(*cString::sprintf(FRONTEND_DEVICE, deviceP->Adapter(), deviceP->Frontend()), O_RDONLY | O_NONBLOCK);
if (fe < 0)
return (value);
ioctl(fe, FE_READ_SNR, &value);
@ -200,14 +200,14 @@ uint16_t getSNR(cDvbDevice *device)
return (value);
}
uint32_t getBER(cDvbDevice *device)
uint32_t getBER(cDvbDevice *deviceP)
{
uint32_t value = 0;
if (!device)
if (!deviceP)
return (value);
int fe = open(*cString::sprintf(FRONTEND_DEVICE, device->Adapter(), device->Frontend()), O_RDONLY | O_NONBLOCK);
int fe = open(*cString::sprintf(FRONTEND_DEVICE, deviceP->Adapter(), deviceP->Frontend()), O_RDONLY | O_NONBLOCK);
if (fe < 0)
return (value);
ioctl(fe, FE_READ_BER, &value);
@ -216,14 +216,14 @@ uint32_t getBER(cDvbDevice *device)
return (value);
}
uint32_t getUNC(cDvbDevice *device)
uint32_t getUNC(cDvbDevice *deviceP)
{
uint32_t value = 0;
if (!device)
if (!deviceP)
return (value);
int fe = open(*cString::sprintf(FRONTEND_DEVICE, device->Adapter(), device->Frontend()), O_RDONLY | O_NONBLOCK);
int fe = open(*cString::sprintf(FRONTEND_DEVICE, deviceP->Adapter(), deviceP->Frontend()), O_RDONLY | O_NONBLOCK);
if (fe < 0)
return (value);
ioctl(fe, FE_READ_UNCORRECTED_BLOCKS, &value);
@ -232,39 +232,39 @@ uint32_t getUNC(cDvbDevice *device)
return (value);
}
cString getApids(const cChannel *channel)
cString getApids(const cChannel *channelP)
{
int value = 0;
cString apids = cString::sprintf("%d", channel->Apid(value));
while (channel->Apid(++value) && (value < MAXAPIDS))
apids = cString::sprintf("%s, %d", *apids, channel->Apid(value));
cString apids = cString::sprintf("%d", channelP->Apid(value));
while (channelP->Apid(++value) && (value < MAXAPIDS))
apids = cString::sprintf("%s, %d", *apids, channelP->Apid(value));
return apids;
}
cString getDpids(const cChannel *channel)
cString getDpids(const cChannel *channelP)
{
int value = 0;
cString dpids = cString::sprintf("%d", channel->Dpid(value));
while (channel->Dpid(++value) && (value < MAXDPIDS))
dpids = cString::sprintf("%s, %d", *dpids, channel->Dpid(value));
cString dpids = cString::sprintf("%d", channelP->Dpid(value));
while (channelP->Dpid(++value) && (value < MAXDPIDS))
dpids = cString::sprintf("%s, %d", *dpids, channelP->Dpid(value));
return dpids;
}
cString getSpids(const cChannel *channel)
cString getSpids(const cChannel *channelP)
{
int value = 0;
cString spids = cString::sprintf("%d", channel->Spid(value));
while (channel->Spid(++value) && (value < MAXSPIDS))
spids = cString::sprintf("%s, %d", *spids, channel->Spid(value));
cString spids = cString::sprintf("%d", channelP->Spid(value));
while (channelP->Spid(++value) && (value < MAXSPIDS))
spids = cString::sprintf("%s, %d", *spids, channelP->Spid(value));
return spids;
}
cString getCAids(const cChannel *channel)
cString getCAids(const cChannel *channelP)
{
int value = 0;
cString caids = cString::sprintf("%s", *getCA(channel->Ca(value)));
while (channel->Ca(++value) && (value < MAXCAIDS))
caids = cString::sprintf("%s, %s", *caids, *getCA(channel->Ca(value)));
cString caids = cString::sprintf("%s", *getCA(channelP->Ca(value)));
while (channelP->Ca(++value) && (value < MAXCAIDS))
caids = cString::sprintf("%s, %s", *caids, *getCA(channelP->Ca(value)));
return caids;
}
@ -275,37 +275,37 @@ cString getVideoStream(int value)
return cString::sprintf("---");
}
cString getAudioStream(int value, const cChannel *channel)
cString getAudioStream(int valueP, const cChannel *channelP)
{
int pid = 0;
if (IS_AUDIO_TRACK(value))
pid = int(value - ttAudioFirst);
if (channel && channel->Apid(pid)) {
if (channel->Alang(pid))
return cString::sprintf("#%d (%s)", channel->Apid(pid), channel->Alang(pid));
if (IS_AUDIO_TRACK(valueP))
pid = int(valueP - ttAudioFirst);
if (channelP && channelP->Apid(pid)) {
if (channelP->Alang(pid))
return cString::sprintf("#%d (%s)", channelP->Apid(pid), channelP->Alang(pid));
else
return cString::sprintf("#%d", channel->Apid(pid));
return cString::sprintf("#%d", channelP->Apid(pid));
}
return cString::sprintf("---");
}
cString getAC3Stream(int value, const cChannel *channel)
cString getAC3Stream(int valueP, const cChannel *channelP)
{
int pid = 0;
if (IS_DOLBY_TRACK(value))
pid = int(value - ttDolbyFirst);
if (channel && channel->Dpid(pid)) {
if (channel->Dlang(pid))
return cString::sprintf("#%d (%s)", channel->Dpid(pid), channel->Dlang(pid));
if (IS_DOLBY_TRACK(valueP))
pid = int(valueP - ttDolbyFirst);
if (channelP && channelP->Dpid(pid)) {
if (channelP->Dlang(pid))
return cString::sprintf("#%d (%s)", channelP->Dpid(pid), channelP->Dlang(pid));
else
return cString::sprintf("#%d", channel->Dpid(pid));
return cString::sprintf("#%d", channelP->Dpid(pid));
}
return cString::sprintf("---");
}
cString getVideoCodec(int value)
cString getVideoCodec(int valueP)
{
switch (value) {
switch (valueP) {
case VIDEO_CODEC_MPEG2: return cString::sprintf("%s", tr("MPEG-2"));
case VIDEO_CODEC_H264: return cString::sprintf("%s", tr("H.264"));
default: break;
@ -313,9 +313,9 @@ cString getVideoCodec(int value)
return cString::sprintf("---");
}
cString getAudioCodec(int value)
cString getAudioCodec(int valueP)
{
switch (value) {
switch (valueP) {
case AUDIO_CODEC_MPEG1_I: return cString::sprintf("%s", tr("MPEG-1 Layer I"));
case AUDIO_CODEC_MPEG1_II: return cString::sprintf("%s", tr("MPEG-1 Layer II"));
case AUDIO_CODEC_MPEG1_III: return cString::sprintf("%s", tr("MPEG-1 Layer III"));
@ -329,9 +329,9 @@ cString getAudioCodec(int value)
return cString::sprintf("---");
}
cString getAudioChannelMode(int value)
cString getAudioChannelMode(int valueP)
{
switch (value) {
switch (valueP) {
case AUDIO_CHANNEL_MODE_STEREO: return cString::sprintf("%s", tr("stereo"));
case AUDIO_CHANNEL_MODE_JOINT_STEREO: return cString::sprintf("%s", tr("joint Stereo"));
case AUDIO_CHANNEL_MODE_DUAL: return cString::sprintf("%s", tr("dual"));
@ -341,76 +341,76 @@ cString getAudioChannelMode(int value)
return cString::sprintf("---");
}
cString getCoderate(int value)
cString getCoderate(int valueP)
{
return cString::sprintf("%s", getUserString(value, CoderateValues));
return cString::sprintf("%s", getUserString(valueP, CoderateValues));
}
cString getTransmission(int value)
cString getTransmission(int valueP)
{
return cString::sprintf("%s", getUserString(value, TransmissionValues));
return cString::sprintf("%s", getUserString(valueP, TransmissionValues));
}
cString getBandwidth(int value)
cString getBandwidth(int valueP)
{
return cString::sprintf("%s", getUserString(value, BandwidthValues));
return cString::sprintf("%s", getUserString(valueP, BandwidthValues));
}
cString getInversion(int value)
cString getInversion(int valueP)
{
return cString::sprintf("%s", getUserString(value, InversionValues));
return cString::sprintf("%s", getUserString(valueP, InversionValues));
}
cString getHierarchy(int value)
cString getHierarchy(int valueP)
{
return cString::sprintf("%s", getUserString(value, HierarchyValues));
return cString::sprintf("%s", getUserString(valueP, HierarchyValues));
}
cString getGuard(int value)
cString getGuard(int valueP)
{
return cString::sprintf("%s", getUserString(value, GuardValues));
return cString::sprintf("%s", getUserString(valueP, GuardValues));
}
cString getModulation(int value)
cString getModulation(int valueP)
{
return cString::sprintf("%s", getUserString(value, ModulationValues));
return cString::sprintf("%s", getUserString(valueP, ModulationValues));
}
cString getTerrestrialSystem(int value)
cString getTerrestrialSystem(int valueP)
{
return cString::sprintf("%s", getUserString(value, SystemValuesTerr));
return cString::sprintf("%s", getUserString(valueP, SystemValuesTerr));
}
cString getSatelliteSystem(int value)
cString getSatelliteSystem(int valueP)
{
return cString::sprintf("%s", getUserString(value, SystemValuesSat));
return cString::sprintf("%s", getUserString(valueP, SystemValuesSat));
}
cString getRollOff(int value)
cString getRollOff(int valueP)
{
return cString::sprintf("%s", getUserString(value, RollOffValues));
return cString::sprintf("%s", getUserString(valueP, RollOffValues));
}
cString getPilot(int value)
cString getPilot(int valueP)
{
return cString::sprintf("%s", getUserString(value, PilotValues));
return cString::sprintf("%s", getUserString(valueP, PilotValues));
}
cString getResolution(int width, int height, int scan)
cString getResolution(int widthP, int heightP, int scanP)
{
if ((width > 0) && (height > 0)) {
switch (scan) {
case VIDEO_SCAN_INTERLACED: return cString::sprintf("%dx%d %s", width, height, tr("interlaced"));
case VIDEO_SCAN_PROGRESSIVE: return cString::sprintf("%dx%d %s", width, height, tr("progressive"));
default: return cString::sprintf("%dx%d", width, height);
if ((widthP > 0) && (heightP > 0)) {
switch (scanP) {
case VIDEO_SCAN_INTERLACED: return cString::sprintf("%dx%d %s", widthP, heightP, tr("interlaced"));
case VIDEO_SCAN_PROGRESSIVE: return cString::sprintf("%dx%d %s", widthP, heightP, tr("progressive"));
default: return cString::sprintf("%dx%d", widthP, heightP);
}
}
return cString::sprintf("---");
}
cString getAspectRatio(int value)
cString getAspectRatio(int valueP)
{
switch (value) {
switch (valueP) {
case VIDEO_ASPECT_RATIO_RESERVED: return cString::sprintf("%s", tr("reserved"));
case VIDEO_ASPECT_RATIO_EXTENDED: return cString::sprintf("%s", tr("extended"));
case VIDEO_ASPECT_RATIO_1_1: return cString::sprintf("1:1");
@ -436,9 +436,9 @@ cString getAspectRatio(int value)
return cString::sprintf("---");
}
cString getVideoFormat(int value)
cString getVideoFormat(int valueP)
{
switch (value) {
switch (valueP) {
case VIDEO_FORMAT_UNKNOWN: return cString::sprintf("%s", tr("unknown"));
case VIDEO_FORMAT_RESERVED: return cString::sprintf("%s", tr("reserved"));
case VIDEO_FORMAT_COMPONENT: return cString::sprintf("%s", tr("component"));
@ -451,16 +451,16 @@ cString getVideoFormat(int value)
return cString::sprintf("---");
}
cString getFrameRate(double value)
cString getFrameRate(double valueP)
{
if (value > 0)
return cString::sprintf("%.2f %s", value, tr("Hz"));
if (valueP > 0)
return cString::sprintf("%.2f %s", valueP, tr("Hz"));
return cString::sprintf("---");
}
cString getAC3BitStreamMode(int value, int coding)
cString getAC3BitStreamMode(int valueP, int codingP)
{
switch (value) {
switch (valueP) {
case AUDIO_BITSTREAM_MODE_CM: return cString::sprintf("%s", tr("Complete Main (CM)"));
case AUDIO_BITSTREAM_MODE_ME: return cString::sprintf("%s", tr("Music and Effects (ME)"));
case AUDIO_BITSTREAM_MODE_VI: return cString::sprintf("%s", tr("Visually Impaired (VI)"));
@ -468,16 +468,16 @@ cString getAC3BitStreamMode(int value, int coding)
case AUDIO_BITSTREAM_MODE_D: return cString::sprintf("%s", tr("Dialogue (D)"));
case AUDIO_BITSTREAM_MODE_C: return cString::sprintf("%s", tr("Commentary (C)"));
case AUDIO_BITSTREAM_MODE_E: return cString::sprintf("%s", tr("Emergency (E)"));
case AUDIO_BITSTREAM_MODE_VO_KAR: return cString::sprintf("%s", (coding == 1) ? tr("Voice Over (VO)") : tr("Karaoke"));
case AUDIO_BITSTREAM_MODE_VO_KAR: return cString::sprintf("%s", (codingP == 1) ? tr("Voice Over (VO)") : tr("Karaoke"));
default: break;
}
return cString::sprintf("---");
}
cString getAC3AudioCodingMode(int value, int stream)
cString getAC3AudioCodingMode(int valueP, int streamP)
{
if (stream != 7) {
switch (value) {
if (streamP != 7) {
switch (valueP) {
case AUDIO_CODING_MODE_1_1: return cString::sprintf("1+1 - %s, %s", tr("Ch1"), tr("Ch2"));
case AUDIO_CODING_MODE_1_0: return cString::sprintf("1/0 - %s", tr("C"));
case AUDIO_CODING_MODE_2_0: return cString::sprintf("2/0 - %s, %s", tr("L"), tr("R"));
@ -492,9 +492,9 @@ cString getAC3AudioCodingMode(int value, int stream)
return cString::sprintf("---");
}
cString getAC3CenterMixLevel(int value)
cString getAC3CenterMixLevel(int valueP)
{
switch (value) {
switch (valueP) {
case AUDIO_CENTER_MIX_LEVEL_MINUS_3dB: return cString::sprintf("-3.0 %s", tr("dB"));
case AUDIO_CENTER_MIX_LEVEL_MINUS_4_5dB: return cString::sprintf("-4.5 %s", tr("dB"));
case AUDIO_CENTER_MIX_LEVEL_MINUS_6dB: return cString::sprintf("-6.0 %s", tr("dB"));
@ -504,9 +504,9 @@ cString getAC3CenterMixLevel(int value)
return cString::sprintf("---");
}
cString getAC3SurroundMixLevel(int value)
cString getAC3SurroundMixLevel(int valueP)
{
switch (value) {
switch (valueP) {
case AUDIO_SURROUND_MIX_LEVEL_MINUS_3dB: return cString::sprintf("-3 %s", tr("dB"));
case AUDIO_SURROUND_MIX_LEVEL_MINUS_6dB: return cString::sprintf("-6 %s", tr("dB"));
case AUDIO_SURROUND_MIX_LEVEL_0_dB: return cString::sprintf("0 %s", tr("dB"));
@ -516,9 +516,9 @@ cString getAC3SurroundMixLevel(int value)
return cString::sprintf("---");
}
cString getAC3DolbySurroundMode(int value)
cString getAC3DolbySurroundMode(int valueP)
{
switch (value) {
switch (valueP) {
case AUDIO_DOLBY_SURROUND_MODE_NOT_INDICATED: return cString::sprintf("%s", tr("not indicated"));
case AUDIO_DOLBY_SURROUND_MODE_NOT_DOLBYSURROUND: return cString::sprintf("%s", trVDR("no"));
case AUDIO_DOLBY_SURROUND_MODE_DOLBYSURROUND: return cString::sprintf("%s", trVDR("yes"));
@ -528,57 +528,57 @@ cString getAC3DolbySurroundMode(int value)
return cString::sprintf("---");
}
cString getAC3DialogLevel(int value)
cString getAC3DialogLevel(int valueP)
{
if (value > 0)
return cString::sprintf("-%d %s", value, tr("dB"));
if (valueP > 0)
return cString::sprintf("-%d %s", valueP, tr("dB"));
return cString::sprintf("---");
}
cString getFrequencyMHz(int value)
cString getFrequencyMHz(int valueP)
{
double freq = value;
double freq = valueP;
while (freq > 20000.0) freq /= 1000.0;
return cString::sprintf("%s %s", *dtoa(freq, "%lg"), tr("MHz"));
}
cString getAudioSamplingFreq(int value)
cString getAudioSamplingFreq(int valueP)
{
switch (value) {
switch (valueP) {
case AUDIO_SAMPLING_FREQUENCY_INVALID: return cString::sprintf("---");
case AUDIO_SAMPLING_FREQUENCY_RESERVED: return cString::sprintf("%s", tr("reserved"));
default: break;
}
return cString::sprintf("%d %s", value, tr("Hz"));
return cString::sprintf("%d %s", valueP, tr("Hz"));
}
cString getAudioBitrate(double value, double stream)
cString getAudioBitrate(double valueP, double streamP)
{
switch ((int)stream) {
switch ((int)streamP) {
case AUDIO_BITRATE_INVALID: return cString::sprintf("---");
case AUDIO_BITRATE_RESERVED: return cString::sprintf("%s (%s)", tr("reserved"), *getBitrateKbits(value));
case AUDIO_BITRATE_FREE: return cString::sprintf("%s (%s)", tr("free"), *getBitrateKbits(value));
case AUDIO_BITRATE_RESERVED: return cString::sprintf("%s (%s)", tr("reserved"), *getBitrateKbits(valueP));
case AUDIO_BITRATE_FREE: return cString::sprintf("%s (%s)", tr("free"), *getBitrateKbits(valueP));
default: break;
}
return cString::sprintf("%s (%s)", *getBitrateKbits(stream), *getBitrateKbits(value));
return cString::sprintf("%s (%s)", *getBitrateKbits(streamP), *getBitrateKbits(valueP));
}
cString getVideoBitrate(double value, double stream)
cString getVideoBitrate(double valueP, double streamP)
{
return cString::sprintf("%s (%s)", *getBitrateMbits(stream), *getBitrateMbits(value));
return cString::sprintf("%s (%s)", *getBitrateMbits(streamP), *getBitrateMbits(valueP));
}
cString getBitrateMbits(double value)
cString getBitrateMbits(double valueP)
{
if (value > 0)
return cString::sprintf("%.2f %s", value / 1000000.0, tr("Mbit/s"));
if (valueP > 0)
return cString::sprintf("%.2f %s", valueP / 1000000.0, tr("Mbit/s"));
return cString::sprintf("---");
}
cString getBitrateKbits(double value)
cString getBitrateKbits(double valueP)
{
if (value > 0)
return cString::sprintf("%.0f %s", value / 1000.0, tr("kbit/s"));
if (valueP > 0)
return cString::sprintf("%.0f %s", valueP / 1000.0, tr("kbit/s"));
return cString::sprintf("---");
}

92
femontools.h
View File

@ -28,59 +28,59 @@
#define SATIP_DEVICE "SAT>IP"
cDvbDevice *getDvbDevice(cDevice* device);
cDvbDevice *getDvbDevice(cDevice* deviceP);
cString getFrontendInfo(cDvbDevice *device);
cString getFrontendName(cDvbDevice *device);
cString getFrontendStatus(cDvbDevice *device);
cString getFrontendInfo(cDvbDevice *deviceP);
cString getFrontendName(cDvbDevice *deviceP);
cString getFrontendStatus(cDvbDevice *deviceP);
uint16_t getSNR(cDvbDevice *device);
uint16_t getSignal(cDvbDevice *device);
uint16_t getSNR(cDvbDevice *deviceP);
uint16_t getSignal(cDvbDevice *deviceP);
uint32_t getBER(cDvbDevice *device);
uint32_t getUNC(cDvbDevice *device);
uint32_t getBER(cDvbDevice *deviceP);
uint32_t getUNC(cDvbDevice *deviceP);
cString getApids(const cChannel *channel);
cString getDpids(const cChannel *channel);
cString getSpids(const cChannel *channel);
cString getCAids(const cChannel *channel);
cString getVideoStream(int value);
cString getVideoCodec(int value);
cString getAudioStream(int value, const cChannel *channel);
cString getAudioCodec(int value);
cString getAudioChannelMode(int value);
cString getCoderate(int value);
cString getTransmission(int value);
cString getBandwidth(int value);
cString getInversion(int value);
cString getHierarchy(int value);
cString getGuard(int value);
cString getModulation(int value);
cString getTerrestrialSystem(int value);
cString getSatelliteSystem(int value);
cString getRollOff(int value);
cString getPilot(int value);
cString getResolution(int width, int height, int scan);
cString getAspectRatio(int value);
cString getVideoFormat(int value);
cString getFrameRate(double value);
cString getAC3Stream(int value, const cChannel *channel);
cString getAC3BitStreamMode(int value, int coding);
cString getAC3AudioCodingMode(int value, int stream);
cString getAC3CenterMixLevel(int value);
cString getAC3SurroundMixLevel(int value);
cString getAC3DolbySurroundMode(int value);
cString getAC3DialogLevel(int value);
cString getFrequencyMHz(int value);
cString getAudioSamplingFreq(int value);
cString getAudioBitrate(double value, double stream);
cString getVideoBitrate(double value, double stream);
cString getBitrateMbits(double value);
cString getBitrateKbits(double value);
cString getApids(const cChannel *channelP);
cString getDpids(const cChannel *channelP);
cString getSpids(const cChannel *channelP);
cString getCAids(const cChannel *channelP);
cString getVideoStream(int valueP);
cString getVideoCodec(int valueP);
cString getAudioStream(int valueP, const cChannel *channelP);
cString getAudioCodec(int valueP);
cString getAudioChannelMode(int valueP);
cString getCoderate(int valueP);
cString getTransmission(int valueP);
cString getBandwidth(int valueP);
cString getInversion(int valueP);
cString getHierarchy(int valueP);
cString getGuard(int valueP);
cString getModulation(int valueP);
cString getTerrestrialSystem(int valueP);
cString getSatelliteSystem(int valueP);
cString getRollOff(int valueP);
cString getPilot(int valueP);
cString getResolution(int widthP, int heightP, int scanP);
cString getAspectRatio(int valueP);
cString getVideoFormat(int valueP);
cString getFrameRate(double valueP);
cString getAC3Stream(int valueP, const cChannel *channelP);
cString getAC3BitStreamMode(int valueP, int codingP);
cString getAC3AudioCodingMode(int valueP, int streamP);
cString getAC3CenterMixLevel(int valueP);
cString getAC3SurroundMixLevel(int valueP);
cString getAC3DolbySurroundMode(int valueP);
cString getAC3DialogLevel(int valueP);
cString getFrequencyMHz(int valueP);
cString getAudioSamplingFreq(int valueP);
cString getAudioBitrate(double valueP, double streamP);
cString getVideoBitrate(double valueP, double streamP);
cString getBitrateMbits(double valueP);
cString getBitrateKbits(double valueP);
class cFemonBitStream : public cBitStream {
public:
cFemonBitStream(const uint8_t *Data, const int Length) : cBitStream(Data, Length) {}
cFemonBitStream(const uint8_t *dataP, const int lengthP) : cBitStream(dataP, lengthP) {}
uint32_t GetUeGolomb();
int32_t GetSeGolomb();
void SkipGolomb();

14
femonvideo.h
View File

@ -75,19 +75,19 @@ public:
virtual ~cFemonVideoIf() {}
// eVideoCodec
virtual void SetVideoCodec(eVideoCodec codec) = 0;
virtual void SetVideoCodec(eVideoCodec codecP) = 0;
// eVideoFormat
virtual void SetVideoFormat(eVideoFormat format) = 0;
virtual void SetVideoFormat(eVideoFormat formatP) = 0;
// eVideoScan
virtual void SetVideoScan(eVideoScan scan) = 0;
virtual void SetVideoScan(eVideoScan scanP) = 0;
// eVideoAspectRatio
virtual void SetVideoAspectRatio(eVideoAspectRatio aspectratio) = 0;
virtual void SetVideoAspectRatio(eVideoAspectRatio aspectRatioP) = 0;
// pixels
virtual void SetVideoSize(int width, int height) = 0;
virtual void SetVideoSize(int widthP, int heightP) = 0;
// Hz
virtual void SetVideoFramerate(double framerate) = 0;
virtual void SetVideoFramerate(double frameRateP) = 0;
// Mbit/s
virtual void SetVideoBitrate(double bitrate) = 0;
virtual void SetVideoBitrate(double bitRateP) = 0;
};
#endif //__FEMONVIDEO_H

8
svdrpservice.h
View File

@ -11,11 +11,11 @@
class cLine: public cListObject {
private:
char *Line;
char *lineM;
public:
const char *Text() { return Line; }
cLine(const char *s) { Line = s ? strdup(s) : NULL; };
virtual ~cLine() { if (Line) free(Line); };
const char *Text() { return lineM; }
cLine(const char *strP) { lineM = strP ? strdup(strP) : NULL; };
virtual ~cLine() { if (lineM) free(lineM); };
};
struct SvdrpConnection_v1_0 {