static bool is_blacklisted()
{
char line_buffer[64];
CZapitClient zapit;
t_channel_id channel=zapit.getCurrentServiceID();
if(!blacklist.empty())
{
sprintf(line_buffer,"%llx",channel);
return (blacklist.find(line_buffer, 0) != std::string::npos);
}
return 0;
}
void disableVideoOutput(bool disable)
{
int arg=disable?1:0;
int fd;
printf("[controld] videoOutput %s\n", disable?"off":"on");
if((fd = open(SAA7126_DEVICE,O_RDWR|O_NONBLOCK)) < 0)
{
perror("[controld] SAA DEVICE: ");
return;
}
if ( (ioctl(fd,SAAIOSPOWERSAVE,&arg) < 0))
{
perror("[controld] IOCTL: ");
close(fd);
return;
}
close(fd);
/*
arg=disable?0:0xf;
if((fd = open("/dev/dbox/fp0",O_RDWR|O_NONBLOCK)) < 0)
{
perror("[controld] FP DEVICE: ");
return;
}
if ( (ioctl(fd,FP_IOCTL_LCD_DIMM,&arg) < 0))
{
perror("[controld] IOCTL: ");
close(fd);
return;
}
close(fd);
*/
if(!disable)
{
zapit.startPlayBack();
setvideooutput(settings.videooutput, false);
setVideoFormat(settings.videoformat, false);
}
else
{
setvideooutput(0, false);
setVideoFormat(-1, false);
zapit.stopPlayBack();
}
}
void InitZapitChannelHelper(CZapitClient::channelsMode mode)
{
CZapitChannelExec *ZapitChannelChooser = new CZapitChannelExec;
std::vector<CMenuWidget *> toDelete;
CZapitClient zapit;
CZapitClient::BouquetList bouquetlist;
zapit.getBouquets(bouquetlist, false, true, mode); // UTF-8
CZapitClient::BouquetList::iterator bouquet = bouquetlist.begin();
CMenuWidget mctv(LOCALE_TIMERLIST_BOUQUETSELECT, NEUTRINO_ICON_SETTINGS);
for(; bouquet != bouquetlist.end();bouquet++)
{
CMenuWidget* mwtv = new CMenuWidget(LOCALE_TIMERLIST_CHANNELSELECT, NEUTRINO_ICON_SETTINGS);
toDelete.push_back(mwtv);
CZapitClient::BouquetChannelList channellist;
zapit.getBouquetChannels(bouquet->bouquet_nr,channellist,mode, true); // UTF-8
CZapitClient::BouquetChannelList::iterator channel = channellist.begin();
for(; channel != channellist.end();channel++)
{
char cChannelId[32];
sprintf(cChannelId,
"ZC%c:%d,",
(mode==CZapitClient::MODE_TV)?'T':'R',
channel->nr);
mwtv->addItem(new CMenuForwarderNonLocalized(channel->name, true, NULL, ZapitChannelChooser, (std::string(cChannelId) + channel->name).c_str()));
}
if (!channellist.empty())
mctv.addItem(new CMenuForwarderNonLocalized(bouquet->name, true, NULL, mwtv));
channellist.clear();
}
mctv.exec (NULL, "");
mctv.hide ();
// delete dynamic created objects
for(unsigned int count=0;count<toDelete.size();count++)
{
delete toDelete[count];
}
toDelete.clear();
}
void shutdownBox()
{
lcdd.shutdown();
zapit.shutdown();
timerd.shutdown();
saveSettings();
if (execlp("/sbin/halt", "/sbin/halt", 0)<0)
{
perror("exec failed - halt\n");
}
}
int CAudioSelectMenuHandler::doMenu ()
{
CMenuWidget AudioSelector(LOCALE_APIDSELECTOR_HEAD, "audio", 360);
unsigned int count;
CSubtitleChangeExec SubtitleChanger;
for(count=0; count < g_RemoteControl->current_PIDs.APIDs.size(); count++ ) {
char apid[5];
sprintf(apid, "%d", count);
AudioSelector.addItem(new CMenuForwarderNonLocalized(
g_RemoteControl->current_PIDs.APIDs[count].desc, true, NULL,
APIDChanger, apid, CRCInput::convertDigitToKey(count + 1)),
(count == g_RemoteControl->current_PIDs.PIDs.selected_apid));
}
// -- setup menue for to Dual Channel Stereo
AudioSelector.addItem(GenericMenuSeparatorLine);
CMenuOptionChooser* oj = new CMenuOptionChooser(LOCALE_AUDIOMENU_ANALOGOUT,
&g_settings.audio_AnalogMode,
AUDIOMENU_ANALOGOUT_OPTIONS, AUDIOMENU_ANALOGOUT_OPTION_COUNT,
true, audioSetupNotifier, CRCInput::RC_red, NEUTRINO_ICON_BUTTON_RED);
AudioSelector.addItem( oj );
CChannelList *channelList = CNeutrinoApp::getInstance ()->channelList;
int curnum = channelList->getActiveChannelNumber();
CZapitChannel * cc = channelList->getChannel(curnum);
bool sep_added = false;
if(cc)
{
bool subs_running = false;
for (int i = 0 ; i < (int)cc->getSubtitleCount() ; ++i)
{
CZapitAbsSub* s = cc->getChannelSub(i);
if (s->thisSubType == CZapitAbsSub::DVB) {
CZapitDVBSub* sd = reinterpret_cast<CZapitDVBSub*>(s);
fprintf(stderr, "[neutrino] adding DVB subtitle %s pid 0x%x\n", sd->ISO639_language_code.c_str(), sd->pId);
if(!sep_added) {
sep_added = true;
AudioSelector.addItem(new CMenuSeparator(CMenuSeparator::LINE | CMenuSeparator::STRING, LOCALE_SUBTITLES_HEAD));
}
char spid[10];
snprintf(spid,sizeof(spid), "DVB:%d", sd->pId);
char item[64];
snprintf(item,sizeof(item), "DVB: %s (pid %03X)", sd->ISO639_language_code.c_str(), sd->pId);
bool this_sub_running = (sd->pId == dvbsub_getpid());
subs_running |= this_sub_running;
AudioSelector.addItem(new CMenuForwarderNonLocalized(item /*sd->ISO639_language_code.c_str()*/,
!this_sub_running, NULL, &SubtitleChanger, spid, CRCInput::convertDigitToKey(++count)));
} else if (s->thisSubType == CZapitAbsSub::TTX) {
CZapitTTXSub* sd = reinterpret_cast<CZapitTTXSub*>(s);
fprintf(stderr, "[neutrino] adding TTX subtitle %s pid %X mag %d page %d\n",
sd->ISO639_language_code.c_str(), sd->pId, sd->teletext_magazine_number, sd->teletext_page_number);
if(!sep_added) {
sep_added = true;
AudioSelector.addItem(new CMenuSeparator(CMenuSeparator::LINE | CMenuSeparator::STRING, LOCALE_SUBTITLES_HEAD));
}
char spid[64];
int page = ((sd->teletext_magazine_number & 0xFF) << 8) | sd->teletext_page_number;
int pid = sd->pId;
snprintf(spid,sizeof(spid), "TTX:%d:%03X:%s", sd->pId, page, sd->ISO639_language_code.c_str());
char item[64];
snprintf(item,sizeof(item), "TTX: %s (pid %X page %03X)", sd->ISO639_language_code.c_str(), sd->pId, page);
bool this_sub_running = tuxtx_subtitle_running(&pid, &page, NULL);
subs_running |= this_sub_running;
AudioSelector.addItem(new CMenuForwarderNonLocalized(item /*sd->ISO639_language_code.c_str()*/,
!this_sub_running, NULL, &SubtitleChanger, spid, CRCInput::convertDigitToKey(++count)));
}
}
if(sep_added) {
if (subs_running)
AudioSelector.addItem(new CMenuForwarder(LOCALE_SUBTITLES_STOP, true, NULL, &SubtitleChanger, "off", CRCInput::RC_stop));
} else {
// subtitles might not be available, but started by zapit anyway, as it remembers pids
dvbsub_stop();
tuxtx_stop_subtitle();
}
}
AudioSelector.addItem(new CMenuSeparator(CMenuSeparator::LINE | CMenuSeparator::STRING, LOCALE_VOLUME_ADJUSTMENT));
int percent[g_RemoteControl->current_PIDs.APIDs.size()];
CZapitClient zapit;
for(count = 0; count < g_RemoteControl->current_PIDs.APIDs.size(); count++ ) {
zapit.getVolumePercent((unsigned int *) &percent[count], g_RemoteControl->current_PIDs.APIDs[count].pid);
AudioSelector.addItem(new CMenuOptionNumberChooser(NONEXISTANT_LOCALE, &percent[count],
count == g_RemoteControl->current_PIDs.PIDs.selected_apid,
0, 999, audioSetupNotifier, 0, 0, NONEXISTANT_LOCALE,
g_RemoteControl->current_PIDs.APIDs[count].desc));
}
return AudioSelector.exec(NULL, "");
}
int main ()
{
unsigned Bouquet;
unsigned Channel;
unsigned BufNum;
int RadioMode;
int ExtraPidNum;
unsigned ExtraPid[MAX_PID_NUM];
unsigned StoppedDmxReaders, EmptyStreamBuffers;
char CmdString[100];
char TcpString[STRING_SIZE];
pthread_t TcpReceiverThread;
//pthread_attr_t ThreadAttr;
//struct sched_param SchedParam;
int RetVal, i;
unsigned u, v;
mainProcessID = getpid();
// ****************************************************
// * INIT
// ****************************************************
// * - Programm umschalten
// * - PID's ermitteln
// * - IP-Adresse, Port, MTU ermitteln
// ****************************************************
// Eingabe parsen
ReadLine( TcpString );
RetVal = sscanf( TcpString, "%s %u %u %u %u %s %x %x %x %x %x %x %x %x %x",
CmdString, &(Send.Port), &BufNum,
&Bouquet, &Channel, ExtraAVString,
&(ExtraPid[0]), &(ExtraPid[1]), &(ExtraPid[2]),
&(ExtraPid[3]), &(ExtraPid[4]), &(ExtraPid[5]),
&(ExtraPid[6]), &(ExtraPid[7]), &(ExtraPid[8]) );
if ( RetVal < 4 || RetVal > 12 || Send.Port <= 1023 ) {
fprintf(stderr, "ERROR: main() - illegal arguments\nEXIT\n");
fflush(stderr);
exit(-1);
}
ExtraPidNum = RetVal-6; // -1 => keine zus. PID's (wg. AVString)
if ( BufNum > MAX_SPKT_BUF_NUM || BufNum < 5 ) {
fprintf(stderr, "ERROR: main() - BufNum too large/small\nEXIT\n");
fflush(stderr);
exit(-1);
}
for (u=0; u<BufNum-1; u++) NextSPktBuf[u] = u+1;
NextSPktBuf[BufNum-1] = 0;
if (!strcmp(CmdString, "VIDEO")) {
RadioMode = 0;
TSMode = 0;
} else if (!strcmp(CmdString, "VIDEOTS")) {
RadioMode = 0;
TSMode = 1;
} else if (!strcmp(CmdString, "AUDIO")) {
RadioMode = 1;
TSMode = 0;
} else if (!strcmp(CmdString, "AUDIOTS")) {
RadioMode = 1;
TSMode = 1;
} else {
fprintf(stderr, "ERROR: main() - illegal command\nEXIT\n");
fflush(stderr);
exit(-1);
}
StreamNum = 0;
if ( Bouquet != 0 ) {
CZapitClient zapit;
// Programm umschalten
CZapitClient::responseGetPIDs pids;
if (RadioMode) {
zapit.setMode(CZapitClient::MODE_RADIO);
} else {
zapit.setMode(CZapitClient::MODE_TV);
}
zapit.zapTo(Bouquet-1,Channel);
zapit.getPIDS(pids);
// Pid's ermitteln
if (pids.PIDs.vpid) {
Stream[StreamNum].Filter.pid = pids.PIDs.vpid;
AVString[StreamNum] = 'v';
Stream[StreamNum++].BufPacketNum =
AV_BUF_FACTOR * AUDIO_BUF_PACKET_NUM;
}
for ( u=0; u<pids.APIDs.size(); u++) {
Stream[StreamNum].Filter.pid = pids.APIDs[u].pid;
AVString[StreamNum] = 'a';
Stream[StreamNum++].BufPacketNum = AUDIO_BUF_PACKET_NUM;
}
/* if (TSMode) {
// PMT-Pid wird benotigt nicht ServiceID!!
//Stream[StreamNum].Filter.pid = zapit.getCurrentServiceID();
//AVString[StreamNum] = 'a';
//Stream[StreamNum++].BufPacketNum = AUDIO_BUF_PACKET_NUM;
//zapit.stopPlayBack();
// TS-Streaming geht nur im SPTS-Mode mit Playback!
// sonst ist der Stream "nicht richtig gemuxt"
}*/
}
//if (TSMode) {
// Stream[StreamNum].Filter.pid = 0;
// AVString[StreamNum] = 'a';
// Stream[StreamNum++].BufPacketNum = AUDIO_BUF_PACKET_NUM;
//}
for ( i=0; i<ExtraPidNum; i++) {
Stream[StreamNum].Filter.pid = ExtraPid[i];
switch( ExtraAVString[i] ) {
case 'v':
AVString[StreamNum] = 'v';
Stream[StreamNum++].BufPacketNum =
AV_BUF_FACTOR * AUDIO_BUF_PACKET_NUM;
break;
case 'a':
AVString[StreamNum] = 'a';
Stream[StreamNum++].BufPacketNum = AUDIO_BUF_PACKET_NUM;
break;
default:
fprintf(stderr, "ERROR: main() - illegal extra AV string \n");
fflush(stderr);
break;
}
}
if (StreamNum == 0) {
fprintf(stderr, "ERROR: main() - no pids to record\nEXIT\n");
fflush(stderr);
exit(-1);
}
AVString[StreamNum] = 0;
if (TSMode) {
StreamThreadNum = 1;
Stream[0].BufPacketNum = 188;
} else {
StreamThreadNum = StreamNum;
}
// Adresse fuer Send.Socket ermitteln
Send.AddrLen = sizeof(struct sockaddr_in);
if ( -1 == getpeername(STDIN_FILENO,
(struct sockaddr *)&(Send.Addr), &(Send.AddrLen)) ) {
perror("ERROR: main() - getpeername");
fprintf(stderr, "EXIT\n");
fflush(stderr);
exit(-1);
}
Send.Addr.sin_family = AF_INET;
Send.Addr.sin_port = htons( (unsigned short)(Send.Port) );
printf("INFO: IP %x Port %u\n", Send.Addr.sin_addr.s_addr, Send.Port);
fflush(stdout);
// Antwort an Client
printf("PID %s %i", AVString, StreamThreadNum);
for (u=0; u<StreamNum; u++) printf(" %x", Stream[u].Filter.pid);
printf("\n");
fflush(stdout);
// START-Befehl abwarten
ReadLine( TcpString );
if ( !strncmp(TcpString, "STOP", 4) ) { // ZapMode
printf("INFO: zap mode\nEXIT\n" );
fflush(stdout);
exit(0);
} else if ( strncmp(TcpString, "START", 5) ) {
fprintf(stderr, "ERROR: main() - START command expected\nEXIT\n");
fflush(stderr);
exit(-1);
}
// *****************************************************
// * Start streaming
// *****************************************************
// Super Packet Buffer initialisieren
for (u=0; u<BufNum; u++) {
SPkt.ReSendStatus[u] = 0;
SPkt.Buf[u] = (unsigned char*) malloc( SPKT_BUF_SIZE );
if ( SPkt.Buf[u] == 0 ) {
fprintf(stderr, "ERROR: main() - malloc SPkt.Buf\nEXIT\n");
fflush(stderr);
exit(-1);
}
}
SPkt.WritePkt = 0;
SPkt.WriteBuf = 0;
SPkt.ReadPkt = 0;
SPkt.ReadBuf = 0;
// UdpSender einrichten
Send.Socket = -1;
Send.Packet = 0;
RestartUdpSender();
// DmxReader vorbereiten
StreamStop = 0;
for (u=0; u<StreamThreadNum; u++) {
Stream[u].ReadBuf = 0;
Stream[u].WriteBuf = 0;
Stream[u].ReadPkt = 0;
Stream[u].Stopped = 0;
Stream[u].Ptr = (void*)&(Stream[u]);
for( v=0; v<2; v++) {
Stream[u].Buf[v] = (unsigned char*)malloc(
Stream[u].BufPacketNum * NET_DATA_PER_PACKET );
if ( Stream[u].Buf[v] == 0 ) {
fprintf(stderr, "ERROR: main() - malloc Stream.Buf\nEXIT\n");
fflush(stderr);
exit(-1);
}
}
}
// Tcp Receiver starten -> STOP, RESEND Befehle auswerten
if ( pthread_create(&TcpReceiverThread, 0, TcpReceiver, 0 ) ) {
perror("ERROR: main() - TcpReceiver pthread_create");
fprintf(stderr, "EXIT\n");
fflush(stderr);
exit(-1);
}
//SchedParam.sched_priority = 10;
//pthread_attr_init(&ThreadAttr);
//pthread_attr_setschedpolicy(&ThreadAttr, SCHED_FIFO );
//pthread_attr_setschedparam(&ThreadAttr, &SchedParam);
// DmxReader Thread's starten
if (TSMode) {
if ( pthread_create(&(Stream[u].Thread), 0, //&ThreadAttr,
DmxTSReader, 0 ) ) {
perror("ERROR: main() - DmxReader pthread_create");
fprintf(stderr, "EXIT\n");
fflush(stderr);
exit(-1);
}
} else {
for (u=0; u<StreamThreadNum; u++) {
if ( pthread_create(&(Stream[u].Thread), 0, //&ThreadAttr,
DmxReader, Stream[u].Ptr ) ) {
perror("ERROR: main() - DmxReader pthread_create");
fprintf(stderr, "EXIT\n");
fflush(stderr);
exit(-1);
}
}
}
// ****************************************************************
// Hauptschleife
// ==============================================================
// Pakete von den DmxBuf's in SPktBuf's umkopieren und
// Headern versehen
// ****************************************************************
StoppedDmxReaders = 0;
do {
WritePtr = SPkt.Buf[SPkt.WriteBuf] +
SPkt.WritePkt * DATA_PER_PACKET;
for (u=0; u<BufNum; u++) {
if ( SPkt.ReSendStatus) {
for (v=0; v<SPKT_BUF_PACKET_NUM; v++) {
if ( SPkt.ReSend[u][v] ) {
ReadPtr = SPkt.Buf[u] + v * DATA_PER_PACKET;
memmove ( WritePtr, ReadPtr, DATA_PER_PACKET );
PacketHeader = (PacketHeaderType*)WritePtr;
PacketHeader->Packet = SPkt.WritePkt++;
PacketHeader->Status = 0;
PacketHeader->SPktBuf = SPkt.WriteBuf;
WritePtr += DATA_PER_PACKET;
CheckNextSPktWriteBuf( );
}
SPkt.ReSend[u][v] = 0;
}
}
}
EmptyStreamBuffers = 0;
do {
for(u=0; u<StreamThreadNum; u++) {
if ( Stream[u].Stopped ) {
StoppedDmxReaders++;
EmptyStreamBuffers++;
continue;
}
if ( Stream[u].WriteBuf != Stream[u].ReadBuf ) {
ReadPtr = Stream[u].Buf[Stream[u].ReadBuf];
for (v=0; v<Stream[u].BufPacketNum; v++) {
PacketHeader = (PacketHeaderType*)WritePtr;
PacketHeader->Packet = SPkt.WritePkt++;
PacketHeader->Status = 0;
PacketHeader->SPktBuf = SPkt.WriteBuf;
PacketHeader->Stream = u;
PacketHeader->StreamPacket = Stream[u].ReadPkt++;
WritePtr += sizeof(PacketHeaderType);
memmove ( WritePtr, ReadPtr, NET_DATA_PER_PACKET );
ReadPtr += NET_DATA_PER_PACKET;
WritePtr += NET_DATA_PER_PACKET;
CheckNextSPktWriteBuf( );
}
if ( Stream[u].ReadBuf == 0 ) Stream[u].ReadBuf = 1;
else Stream[u].ReadBuf = 0;
} else {
EmptyStreamBuffers++;
}
}
} while ( EmptyStreamBuffers < StreamThreadNum );
usleep(15000); // 10% * 128 * 1468 * 8 / 10 MBit/s
} while (StoppedDmxReaders < StreamThreadNum );
PacketHeader->Status = 2;
SPkt.WriteBuf = NextSPktBuf[SPkt.WriteBuf];
StreamStop = 0;
for (i=0; i<200; i++) {
if ( StreamStop ) break;
usleep(15000);
}
printf("EXIT\n" );
fflush(stdout);
/* siehe stopPlayBack
if (Bouquet != 0 && TSMode) {
zapit.startPlayBack();
}
*/
exit(0);
}
int main (int argc, char** argv)
{
int i;
uint32_t j;
//uint32_t k;
uint64_t ii;
int bouquet = -1;
unsigned int channel = 0;
unsigned int count;
int diseqcRepeats = -1;
int diseqcType = -1;
uint64_t satmask = 0xFFFF;
int audio = 0;
int mute = -1;
int volume = -1;
int nvod = -1;
int arat = -1;
int m43 = -1;
int lockrc = -1;
const char * channelName = NULL;
bool playback = false;
bool recordmode = false;
bool radio = false;
bool reload = false;
bool register_neutrino = false;
bool savebouquets = false;
bool show_satellites = false;
bool set_pal = false;
int set_hd = 0;
bool scan = false;
bool rezap = false;
bool zapByName = false;
bool killzapit = false;
bool enterStandby = false;
bool leaveStandby = false;
bool sendMotorCommand = false;
bool quiet = false;
bool getchannel = false;
bool aspectratio = false;
bool mode43 = false;
uint8_t motorCmdType = 0;
uint8_t motorCmd = 0;
uint8_t motorNumParameters = 0;
uint8_t motorParam1 = 0;
uint8_t motorParam2 = 0;
uint8_t motorAddr = 0;
uint32_t diseqc[5];
unsigned int tmp;
int scan_mode = 1;
t_channel_id zapsid = 0;
/* command line */
for (i = 1; i < argc; i++)
{
if (!strncmp(argv[i], "-a", 2))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &audio);
continue;
}
}
else if (!strncmp(argv[i], "-dr", 3))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &diseqcRepeats);
continue;
}
}
else if (!strncmp(argv[i], "-dt", 3))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &diseqcType);
continue;
}
}
else if (!strncmp(argv[i], "-q", 2))
{
quiet = true;
continue;
}
else if (!strncmp(argv[i], "-c", 2))
{
reload = true;
continue;
}
else if (!strncmp(argv[i], "-esb", 4))
{
enterStandby = true;
continue;
}
else if (!strncmp(argv[i], "-kill", 5))
{
killzapit = true;
continue;
}
else if (!strncmp(argv[i], "-lsb", 4))
{
leaveStandby = true;
continue;
}
else if (!strncmp(argv[i], "-rz", 3))
{
rezap = true;
continue;
}
else if (!strncmp(argv[i], "-mute", 5))
{
mute = 1;
continue;
}
else if (!strncmp(argv[i], "-m", 2))
{
if (i < argc - 6)
{
sscanf(argv[++i], "%x", &tmp);
motorCmdType = tmp;
sscanf(argv[++i], "%x", &tmp);
motorAddr = tmp;
sscanf(argv[++i], "%x", &tmp);
motorCmd = tmp;
sscanf(argv[++i], "%x", &tmp);
motorNumParameters = tmp;
sscanf(argv[++i], "%x", &tmp);
motorParam1 = tmp;
sscanf(argv[++i], "%x", &tmp);
motorParam2 = tmp;
printf("[pzapit] motor command = %x %x %x %x %x %x\n", motorCmdType, motorAddr, motorCmd, motorNumParameters, motorParam1, motorParam2);
sendMotorCommand = true;
continue;
}
}
else if (!strncmp(argv[i], "-rn", 3))
{
register_neutrino = true;
continue;
}
else if (!strncmp(argv[i], "-nvod", 5))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &nvod);
continue;
}
}
else if (!strncmp(argv[i], "-n", 2))
{
if (i < argc - 1)
{
zapByName = true;
channelName = argv[++i];
continue;
}
}
else if (!strncmp(argv[i], "-p", 2))
{
playback = true;
continue;
}
else if (!strncmp(argv[i], "-ra", 3))
{
radio = true;
continue;
}
else if (!strncmp(argv[i], "-re", 3))
{
recordmode = true;
continue;
}
else if (!strncmp(argv[i], "-var", 4))
{
aspectratio = true;
if (i < argc - 1)
sscanf(argv[++i], "%d", &arat);
continue;
}
else if (!strncmp(argv[i], "-vm43", 5))
{
mode43 = true;
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &m43);
continue;
}
#if 0
//FIXME howto read aspect mode back?
continue;
#endif
}
else if (!strncmp(argv[i], "-sb", 3))
{
savebouquets = true;
continue;
}
else if (!strncmp(argv[i], "-se", 3))
{
if (i < argc - 2)
{
sscanf(argv[++i], "%" SCNd64 "", &satmask);
sscanf(argv[++i], "%d", &diseqc[0]);
/*
diseqc[0] = strlen(argv[i+1]);
for (i++, j = 0; j <= diseqc[0]; j++)
{
diseqc[j+1] = argv[i][j] - 48;
}
*/
continue;
}
}
else if (!strncmp(argv[i], "-sh", 3))
{
show_satellites = true;
continue;
}
else if (!strncmp(argv[i], "-st", 3))
{
scan = true;
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &scan_mode);
}
continue;
}
else if (!strncmp(argv[i], "--pal", 4))
{
set_pal = true;
continue;
}
else if (!strncmp(argv[i], "--1080", 6))
{
set_hd = 8;
continue;
}
else if (!strncmp(argv[i], "--1083", 6))
{
set_hd = 9;
continue;
}
else if (!strncmp(argv[i], "--1082", 6))
{
set_hd = 10;
continue;
}
else if (!strncmp(argv[i], "--720", 5))
{
set_hd = 7;
continue;
}
else if (!strncmp(argv[i], "-unmute", 7))
{
mute = 0;
continue;
}
else if (!strncmp(argv[i], "-vol", 4))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &volume);
continue;
}
}
else if (!strncmp(argv[i], "-gi", 3))
{
getchannel = true;
continue;
}
else if (!strncmp(argv[i], "-zi", 3))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%" SCNx64 "", &zapsid);
continue;
}
}
else if (!strncmp(argv[i], "-lockrc", 7))
{
lockrc = 1;
continue;
}
else if (!strncmp(argv[i], "-unlockrc", 9))
{
lockrc = 0;
continue;
}
else if (i < argc - 1)
{
if ((sscanf(argv[i], "%d", &bouquet) > 0) && (sscanf(argv[++i], "%u", &channel) > 0))
continue;
}
else if (sscanf(argv[i], "%d", &bouquet) > 0)
continue;
return usage(argv[0]);
}
/* create zapit client */
CZapitClient zapit;
#if 0
TP_params TP;
TP.TP_id = 12345;
TP.polarization = 1;
TP.feparams.Frequency = 11727000;
TP.feparams.u.qpsk.SymbolRate = 27500000;
TP.feparams.u.qpsk.FEC_inner = (CodeRate) 3;
zapit.scan_TP(TP);
exit(0);
#endif
/* send diseqc 1.2 motor command */
if (sendMotorCommand)
{
zapit.sendMotorCommand(motorCmdType, motorAddr, motorCmd, motorNumParameters, motorParam1, motorParam2);
return 0;
}
/* kill zapit*/
if (killzapit)
{
zapit.shutdown();
std::cout << "zapit shot down :)" << std::endl;
return 0;
}
if (enterStandby)
{
zapit.setStandby(true);
return 0;
}
if (leaveStandby)
{
zapit.setStandby(false);
return 0;
}
/* audio mute */
if (mute != -1)
{
std::cout << "mute/unmute" << std::endl;
zapit.muteAudio(mute);
return 0;
}
if (volume != -1)
{
std::cout << "set volume" << std::endl;
zapit.setVolume(volume, volume);
return 0;
}
if (lockrc != -1)
{
zapit.lockRc(lockrc);
return 0;
}
if (rezap)
{
zapit.Rezap();
return 0;
}
/* reload services */
if (reload)
{
std::cout << "reloading channels" << std::endl;
zapit.reinitChannels();
return 0;
}
if (register_neutrino)
{
#define NEUTRINO_UDS_NAME "/tmp/neutrino.sock"
std::cout << "registering neutrino" << std::endl;
for (int ic = CZapitClient::FIRST_EVENT_MARKER; ic < CZapitClient::LAST_EVENT_MARKER; ic++)
zapit.registerEvent(ic, 222, NEUTRINO_UDS_NAME);
return 0;
}
if (diseqcType != -1)
{
zapit.setDiseqcType((diseqc_t) diseqcType);
if (diseqcRepeats == -1)
return 0;
}
if (diseqcRepeats != -1)
{
zapit.setDiseqcRepeat(diseqcRepeats);
return 0;
}
if (playback)
{
if (zapit.isPlayBackActive())
zapit.stopPlayBack();
else
zapit.startPlayBack();
if (!recordmode)
return 0;
}
if (recordmode)
{
zapit.setRecordMode(!zapit.isRecordModeActive());
return 0;
}
if (aspectratio)
{
if(arat >= 0)
zapit.setAspectRatio(arat);
else
{
zapit.getAspectRatio(&arat);
printf("%d\n", arat);
}
return 0;
}
if (mode43)
{
if(m43 >= 0)
zapit.setMode43(m43);
else
{
zapit.getMode43(&m43);
printf("%d\n",m43);
}
return 0;
}
if (savebouquets)
{
zapit.saveBouquets();
return 0;
}
if (show_satellites)
{
std::vector<CZapitClient::responseGetSatelliteList> satelliteList;
zapit.getScanSatelliteList(satelliteList);
std::vector<CZapitClient::responseGetSatelliteList>::const_iterator rI;
for ( ii = 0, rI = satelliteList.begin(); rI != satelliteList.end(); ii++, rI++)
printf("%" PRId64 " : %s %d\n", ii, rI->satName, rI->satPosition);
//std::cout << (1 << ii) << ": " << rI->satName << std::endl;
return 0;
}
else if (satmask != 0xFFFF)
{
std::vector<CZapitClient::responseGetSatelliteList> satelliteList;
zapit.getScanSatelliteList(satelliteList);
std::vector<CZapitClient::commandSetScanSatelliteList> newSatelliteList;
CZapitClient::commandSetScanSatelliteList item;
for (j = 0; j < satelliteList.size(); j++)
{
if (satmask == j)
{
std::cout << "diseqc " << diseqc[0] << ": " << satelliteList[j].satName << std::endl;
cstrncpy(item.satName, satelliteList[j].satName, sizeof(item.satName) - 1);
item.position = diseqc[0];
newSatelliteList.push_back(item);
break;
}
}
zapit.setScanSatelliteList(newSatelliteList);
return 0;
}
/* transponderscan */
if (scan)
{
unsigned int satellite;
unsigned int processed_transponder;
unsigned int transponder;
unsigned int services;
printf("Start scan, mode %d\n", scan_mode);
zapit.startScan(scan_mode);
while (zapit.isScanReady(satellite, processed_transponder, transponder, services) == false)
{
std::cout << "satellite: " << satellite << ", transponder: " << processed_transponder <<", of: " << transponder << ", services: " << services << std::endl;
sleep(1);
}
return 0;
}
if (set_pal)
{
//zapit.stopPlayBack();
zapit.setVideoSystem(2);
//zapit.startPlayBack();
return 0;
}
if (set_hd)
{
//zapit.stopPlayBack();
zapit.setVideoSystem(set_hd);
//zapit.startPlayBack();
return 0;
}
if (getchannel)
{
t_channel_id channelid = zapit.getCurrentServiceID();
printf("%" PRIx64 " (%s)\n", channelid, (zapit.getChannelName(channelid)).c_str());
return 0;
}
/* choose source mode */
zapit.setMode(radio ? CZapitClient::MODE_RADIO : CZapitClient::MODE_TV);
if (zapsid > 0)
{
printf("Zapping to: %" PRIx64 " (%s) ", zapsid, (zapit.getChannelName(zapsid)).c_str());
tmp = zapit.zapTo_serviceID(zapsid);
if (!tmp)
printf("failed");
printf("\n");
return tmp;
}
/* set audio channel */
if (audio)
{
zapit.setAudioChannel(audio - 1);
return 0;
}
if (nvod != -1)
{
zapit.zaptoNvodSubService(nvod);
return 0;
}
else
{
std::vector<CZapitClient::responseGetBouquetChannels> channels;
if (zapByName)
{
zapit.getChannels(channels);
std::vector<CZapitClient::responseGetBouquetChannels>::const_iterator ch_resp;
for (ch_resp = channels.begin(), channel = 1; ch_resp != channels.end(); ch_resp++, ++channel)
{
if (!strcasecmp(ch_resp->name, channelName))
{
std::cout << "found channel number: " << channel << std::endl;
goto channel_found;
}
}
std::cout << "channel not found." << std::endl;
return 0;
}
else /* zap by bouquet number and channel number */
{
/* read channel list */
if (bouquet != -1)
zapit.getBouquetChannels(bouquet - 1, channels, CZapitClient::MODE_CURRENT, true);
/* display bouquet list */
else
{
std::vector<CZapitClient::responseGetBouquets> bouquets;
std::vector<CZapitClient::responseGetBouquets>::const_iterator b_resp;
zapit.getBouquets(bouquets, false);
for (b_resp = bouquets.begin(); b_resp != bouquets.end(); ++b_resp)
std::cout << (b_resp->bouquet_nr + 1) << ": " << b_resp->name << std::endl;
return 0;
}
/* display channel list */
if (!channel)
{
std::vector<CZapitClient::responseGetBouquetChannels>::const_iterator ch_resp;
for (ch_resp = channels.begin(), channel = 1; ch_resp != channels.end(); ch_resp++, ++channel)
//std::cout << channel << ": " << ch_resp->name << ": " << ch_resp->channel_id<< std::endl;
printf("%3d: %s (%04x)\n", channel, ch_resp->name, (short) (ch_resp->channel_id &0xFFFF));
return 0;
}
}
/* zap */
if (channel > channels.size())
{
std::cout << "Only " << channels.size() << " channels in bouquet " << bouquet << std::endl;
return 0;
}
channel_found:
zapit.zapTo(channels[channel-1].nr);
std::cout << "zapped to " << channels[channel-1].name << std::endl;
}
if (!quiet)
{
CZapitClient::responseGetPIDs pids;
zapit.getPIDS(pids);
if (pids.PIDs.vpid)
std::cout << " video: 0x" << std::hex << pids.PIDs.vpid << std::endl;
if (pids.PIDs.vtxtpid)
std::cout << "teletext: 0x" << std::hex << pids.PIDs.vtxtpid << std::endl;
if (pids.PIDs.pcrpid)
std::cout << " pcr: 0x" << std::hex << pids.PIDs.pcrpid << std::endl;
for (count = 0; count < pids.APIDs.size(); count++)
{
std::cout << " audio " << std::dec << count + 1 << ": 0x" << std::hex << pids.APIDs[count].pid << " (" << pids.APIDs[count].desc;
if (pids.APIDs[count].is_ac3)
std::cout << ", ac3";
else if (pids.APIDs[count].is_aac)
std::cout << ", aac";
else
std::cout << ", unknown";
std::cout << ")" << std::endl;
}
}
return 0;
}
int main(int argc, char **argv)
{
int listenfd, connfd;
printf("Controld $Id: controld.cpp,v 1.76.2.1 2002/10/24 20:34:32 thegoodguy Exp $\n\n");
switch (fork())
{
case -1:
perror("[controld] fork");
return -1;
case 0:
break;
default:
return 0;
}
if (setsid() == -1)
{
perror("[controld] setsid");
return -1;
}
eventServer = new CEventServer;
struct sockaddr_un servaddr;
int clilen;
memset(&servaddr, 0, sizeof(struct sockaddr_un));
servaddr.sun_family = AF_UNIX;
strcpy(servaddr.sun_path, CONTROLD_UDS_NAME);
clilen = sizeof(servaddr.sun_family) + strlen(servaddr.sun_path);
unlink(CONTROLD_UDS_NAME);
//network-setup
if ((listenfd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0)
{
perror("socket");
}
if ( bind(listenfd, (struct sockaddr*) &servaddr, clilen) <0 )
{
perror("[controld] bind failed...\n");
exit(-1);
}
if (listen(listenfd, 5) !=0)
{
perror("[controld] listen failed...\n");
exit( -1 );
}
//busyBox
signal(SIGHUP,sig_catch);
signal(SIGINT,sig_catch);
signal(SIGQUIT,sig_catch);
signal(SIGTERM,sig_catch);
/* load configuration */
config = new CConfigFile(',');
if (!config->loadConfig(CONF_FILE))
{
/* set defaults if no configuration file exists */
printf("[controld] %s not found\n", CONF_FILE);
}
settings.volume = config->getInt32("volume", 100);
settings.volume_avs = config->getInt32("volume_avs", 100);
settings.mute = config->getBool("mute", false);
settings.mute_avs = config->getBool("mute_avs", false);
settings.videooutput = config->getInt32("videooutput", 1); // fblk1 - rgb
settings.videoformat = config->getInt32("videoformat", 2); // fnc2 - 4:3
setBoxType(); // dummy set - liest den aktuellen Wert aus!
watchDog = new CEventWatchDog();
aspectRatioNotifier = new CControldAspectRatioNotifier();
watchDog->registerNotifier(WDE_VIDEOMODE, aspectRatioNotifier);
//init
audioControl::setVolume(map_volume(settings.volume_avs, true));
zapit.setVolume(map_volume(settings.volume, false), map_volume(settings.volume, false));
lcdd.setVolume(settings.volume_avs); // we could also display settings.volume at startup
audioControl::setMute(settings.mute_avs);
zapit.muteAudio(settings.mute);
lcdd.setMute(settings.mute || settings.mute_avs);
setvideooutput(settings.videooutput);
setVideoFormat(settings.videoformat, false);
try
{
struct CControld::Header rmessage;
while(true)
{
connfd = accept(listenfd, (struct sockaddr*) &servaddr, (socklen_t*) &clilen);
memset(&rmessage, 0, sizeof(rmessage));
read(connfd,&rmessage,sizeof(rmessage));
parse_command(connfd, &rmessage);
close(connfd);
}
}
catch (std::exception& e)
{
printf("[controld] caught std-exception in main-thread %s!\n", e.what());
}
catch (...)
{
printf("[controld] caught exception in main-thread!\n");
}
}
void parse_command(int connfd, CControld::Header * rmessage)
{
if(rmessage->version != CControld::ACTVERSION)
{
perror("[controld] wrong version\n");
return;
}
switch (rmessage->cmd)
{
case CControld::CMD_SHUTDOWN:
shutdownBox();
break;
case CControld::CMD_SAVECONFIG:
saveSettings();
break;
case CControld::CMD_SETVOLUME:
case CControld::CMD_SETVOLUME_AVS:
CControld::commandVolume msg_commandVolume;
read(connfd, &msg_commandVolume, sizeof(msg_commandVolume));
if (rmessage->cmd == CControld::CMD_SETVOLUME)
{
settings.volume = msg_commandVolume.volume;
config->setInt32("volume", settings.volume);
zapit.setVolume(map_volume(msg_commandVolume.volume, false), map_volume(msg_commandVolume.volume, false));
}
else
{
settings.volume_avs = msg_commandVolume.volume;
config->setInt32("volume_avs", settings.volume_avs);
audioControl::setVolume(map_volume(msg_commandVolume.volume, true));
}
lcdd.setVolume(msg_commandVolume.volume);
eventServer->sendEvent(CControldClient::EVT_VOLUMECHANGED, CEventServer::INITID_CONTROLD, &msg_commandVolume.volume, sizeof(msg_commandVolume.volume));
break;
case CControld::CMD_MUTE:
settings.mute = true;
config->setBool("mute", settings.mute);
zapit.muteAudio(true);
lcdd.setMute(true);
eventServer->sendEvent(CControldClient::EVT_MUTECHANGED, CEventServer::INITID_CONTROLD, &settings.mute, sizeof(settings.mute));
break;
case CControld::CMD_MUTE_AVS:
settings.mute_avs = true;
config->setBool("mute_avs", settings.mute_avs);
audioControl::setMute(true);
lcdd.setMute(true);
eventServer->sendEvent(CControldClient::EVT_MUTECHANGED, CEventServer::INITID_CONTROLD, &settings.mute_avs, sizeof(settings.mute_avs));
break;
case CControld::CMD_UNMUTE:
settings.mute = false;
config->setBool("mute", settings.mute);
zapit.muteAudio(false);
lcdd.setMute(settings.mute_avs);
eventServer->sendEvent(CControldClient::EVT_MUTECHANGED, CEventServer::INITID_CONTROLD, &settings.mute_avs, sizeof(settings.mute_avs));
break;
case CControld::CMD_UNMUTE_AVS:
settings.mute_avs = false;
config->setBool("mute_avs", settings.mute_avs);
audioControl::setMute(false);
lcdd.setMute(settings.mute);
eventServer->sendEvent(CControldClient::EVT_MUTECHANGED, CEventServer::INITID_CONTROLD, &settings.mute, sizeof(settings.mute));
break;
case CControld::CMD_SETANALOGMODE:
CControld::commandAnalogMode msgmd;
read(connfd, &msgmd, sizeof(msgmd));
zapit.setAudioMode(msgmd.mode);
break;
case CControld::CMD_SETVIDEOFORMAT:
//printf("[controld] set videoformat\n");
CControld::commandVideoFormat msg2;
read(connfd, &msg2, sizeof(msg2));
setVideoFormat(msg2.format);
break;
case CControld::CMD_SETVIDEOOUTPUT:
//printf("[controld] set videooutput\n");
CControld::commandVideoOutput msg3;
read(connfd, &msg3, sizeof(msg3));
setvideooutput(msg3.output);
break;
case CControld::CMD_SETBOXTYPE:
//printf("[controld] set boxtype\n"); //-------------------dummy!!!!!!!!!!
CControld::commandBoxType msg4;
read(connfd, &msg4, sizeof(msg4));
setBoxType();
break;
case CControld::CMD_SETSCARTMODE:
//printf("[controld] set scartmode\n");
CControld::commandScartMode msg5;
read(connfd, &msg5, sizeof(msg5));
setScartMode(msg5.mode);
break;
case CControld::CMD_SETVIDEOPOWERDOWN:
//printf("[controld] set scartmode\n");
CControld::commandVideoPowerSave msg10;
read(connfd, &msg10, sizeof(msg10));
disableVideoOutput(msg10.powerdown);
break;
case CControld::CMD_GETVOLUME:
case CControld::CMD_GETVOLUME_AVS:
CControld::responseVolume msg_responseVolume;
msg_responseVolume.volume = (rmessage->cmd == CControld::CMD_GETVOLUME) ? settings.volume : settings.volume_avs;
write(connfd, &msg_responseVolume, sizeof(msg_responseVolume));
break;
case CControld::CMD_GETMUTESTATUS:
case CControld::CMD_GETMUTESTATUS_AVS:
CControld::responseMute msg_responseMute;
msg_responseMute.mute = (rmessage->cmd == CControld::CMD_GETMUTESTATUS) ? settings.mute : settings.mute_avs;
write(connfd, &msg_responseMute, sizeof(msg_responseMute));
break;
case CControld::CMD_GETVIDEOFORMAT:
//printf("[controld] get videoformat (fnc)\n");
CControld::responseVideoFormat msg8;
msg8.format = settings.videoformat;
write(connfd,&msg8,sizeof(msg8));
break;
case CControld::CMD_GETASPECTRATIO:
//printf("[controld] get videoformat (fnc)\n");
CControld::responseAspectRatio msga;
msga.aspectRatio = aspectRatio;
write(connfd,&msga,sizeof(msga));
break;
case CControld::CMD_GETVIDEOOUTPUT:
//printf("[controld] get videooutput (fblk)\n");
CControld::responseVideoOutput msg9;
msg9.output = settings.videooutput;
write(connfd,&msg9,sizeof(msg9));
break;
case CControld::CMD_GETBOXTYPE:
//printf("[controld] get boxtype\n");
CControld::responseBoxType msg0;
msg0.boxtype = settings.boxtype;
write(connfd,&msg0,sizeof(msg0));
break;
case CControld::CMD_REGISTEREVENT:
eventServer->registerEvent(connfd);
break;
case CControld::CMD_UNREGISTEREVENT:
eventServer->unRegisterEvent(connfd);
break;
default:
printf("[controld] unknown command\n");
}
}
void setVideoFormat(int format, bool bSaveFormat = true )
{
int fd;
int videoDisplayFormat;
int avsiosfncFormat;
int wss;
/*
16:9 : fnc 1
4:3 : fnc 2
*/
if (bSaveFormat) // only set settings if we dont come from watchdog or video_off
{
if (format < 0)
format=0;
if (format > 3)
format=3;
settings.videoformat = format;
config->setInt32("videoformat", settings.videoformat);
}
if (format==0) // automatic switch
{
printf("[controld] setting VideoFormat to auto \n");
switch ( aspectRatio )
{
case 2 : // 4:3
format= 2;
break;
case 3 : // 16:9
case 4 : // 21,1:1
format= 1;
break;
default:
format= 2;
// damits nicht ausgeht beim starten :)
}
}
if ((fd = open("/dev/dbox/avs0",O_RDWR)) < 0)
{
perror("open");
return;
}
if (format< 0)
format= 0;
avsiosfncFormat = format;
if (settings.boxtype == CControldClient::BOXTYPE_PHILIPS) // Philips
{
switch (format)
{
case 1 :
avsiosfncFormat=2;
break;
case 2 :
avsiosfncFormat=3;
break;
}
}
if (ioctl(fd,AVSIOSFNC,&avsiosfncFormat)< 0)
{
perror("AVSIOSFNC");
close(fd);
return;
}
close(fd);
switch( format )
{
// ? case AVS_FNCOUT_INTTV : videoDisplayFormat = VIDEO_PAN_SCAN;
case AVS_FNCOUT_EXT169 :
videoDisplayFormat = VIDEO_CENTER_CUT_OUT;
wss = SAA_WSS_169F;
break;
case AVS_FNCOUT_EXT43 :
videoDisplayFormat = VIDEO_LETTER_BOX;
wss = SAA_WSS_43F;
break;
default:
videoDisplayFormat = VIDEO_LETTER_BOX;
wss = SAA_WSS_43F;
break;
// ? case AVS_FNCOUT_EXT43_1 : videoDisplayFormat = VIDEO_PAN_SCAN;
}
zapit.setDisplayFormat((int)videoDisplayFormat);
if ( (fd = open(SAA7126_DEVICE,O_RDWR)) < 0)
{
perror("open " SAA7126_DEVICE);
return;
}
ioctl(fd,SAAIOSWSS,&wss);
close(fd);
}
int main (int argc, char** argv)
{
int i;
uint32_t j;
uint32_t k;
int bouquet = -1;
unsigned int channel = 0;
unsigned int count;
int diseqcRepeats = -1;
int diseqcType = -1;
int satmask = 0;
int audio = 0;
int mute = -1;
int volume = -1;
int nvod = -1;
int fastzap = -1;
t_channel_id zapsid = 0;
const char * channelName = NULL;
bool playback = false;
bool recordmode = false;
bool radio = false;
bool reload = false;
bool register_neutrino = false;
bool savebouquets = false;
bool show_satellites = false;
bool set_pal = false;
bool set_ntsc = false;
bool scan = false;
bool zapByName = false;
bool rezap = false;
bool killzapit = false;
bool savezapit = false;
bool enterStandby = false;
bool leaveStandby = false;
bool sendMotorCommand = false;
#ifdef HAVE_DBOX_HARDWARE
bool Iecon = false;
bool Iecoff = false;
bool Iecstate = false;
bool pes = false;
bool spts = false;
bool decmode = false;
#endif
#ifdef HAVE_TRIPLEDRAGON
bool zoom = false;
int zoomlevel = 0;
bool pig = false;
bool avinfo = false;
int pig_x = 0;
int pig_y = 0;
int pig_w = 0;
int pig_h = 0;
int pig_a = 0;
#endif
bool getchannel = false;
bool getmode = false;
bool getpids = false;
bool includeBouquetOthers = false;
bool getserviceinfo = false;
uint8_t motorCmdType = 0;
uint8_t motorCmd = 0;
uint8_t motorNumParameters = 0;
uint8_t motorParam1 = 0;
uint8_t motorParam2 = 0;
uint8_t motorAddr = 0;
uint32_t diseqc[5];
unsigned int tmp;
/* command line */
for (i = 1; i < argc; i++)
{
if (!strncmp(argv[i], "-a", 2))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &audio);
continue;
}
}
else if (!strncmp(argv[i], "-dr", 3))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &diseqcRepeats);
continue;
}
}
else if (!strncmp(argv[i], "-dt", 3))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &diseqcType);
continue;
}
}
else if (!strncmp(argv[i], "-c", 2))
{
reload = true;
continue;
}
else if (!strncmp(argv[i], "-gm", 3))
{
getmode = true;
continue;
}
else if (!strncmp(argv[i], "-gi", 3))
{
getchannel = true;
continue;
}
else if (!strncmp(argv[i], "-rz", 3))
{
rezap = true;
continue;
}
else if (!strncmp(argv[i], "-zi", 3))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%llx", &zapsid);
continue;
}
}
else if (!strncmp(argv[i], "-esb", 4))
{
enterStandby = true;
continue;
}
else if (!strncmp(argv[i], "-kill", 5))
{
killzapit = true;
continue;
}
else if (!strncmp(argv[i], "-lsb", 4))
{
leaveStandby = true;
continue;
}
else if (!strncmp(argv[i], "-motor", 6))
{
if (i < argc - 6)
{
sscanf(argv[++i], "%x", &tmp);
motorCmdType = tmp;
sscanf(argv[++i], "%x", &tmp);
motorAddr = tmp;
sscanf(argv[++i], "%x", &tmp);
motorCmd = tmp;
sscanf(argv[++i], "%x", &tmp);
motorNumParameters = tmp;
sscanf(argv[++i], "%x", &tmp);
motorParam1 = tmp;
sscanf(argv[++i], "%x", &tmp);
motorParam2 = tmp;
printf("[pzapit] motor command = %x %x %x %x %x %x\n", motorCmdType, motorAddr, motorCmd, motorNumParameters, motorParam1, motorParam2);
sendMotorCommand = true;
continue;
}
}
else if (!strncmp(argv[i], "-rn", 3))
{
register_neutrino = true;
continue;
}
else if (!strncmp(argv[i], "-mute", 5))
{
mute = 1;
continue;
}
else if (!strncmp(argv[i], "-nvod", 5))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &nvod);
continue;
}
}
else if (!strncmp(argv[i], "-n", 2))
{
if (i < argc - 1)
{
zapByName = true;
channelName = argv[++i];
continue;
}
}
else if (!strncmp(argv[i], "-p", 2))
{
playback = true;
continue;
}
else if (!strncmp(argv[i], "-ra", 3))
{
radio = true;
continue;
}
else if (!strncmp(argv[i], "-re", 3))
{
recordmode = true;
continue;
}
// don't change order with "-sb" or the other will always be found first
else if (!strncmp(argv[i], "-sbo", 4))
{
savebouquets = true;
includeBouquetOthers = true;
continue;
}
else if (!strncmp(argv[i], "-sb", 3))
{
savebouquets = true;
continue;
}
else if (!strncmp(argv[i], "-se", 3))
{
if (i < argc - 2)
{
sscanf(argv[++i], "%d", &satmask);
diseqc[0] = strlen(argv[i+1]);
for (i++, j = 0; j <= diseqc[0]; j++)
{
diseqc[j+1] = argv[i][j] - 48;
}
continue;
}
}
else if (!strncmp(argv[i], "-sh", 3))
{
show_satellites = true;
continue;
}
else if (!strncmp(argv[i], "-st", 3))
{
scan = true;
continue;
}
else if (!strncmp(argv[i], "--pal", 4))
{
set_pal = true;
continue;
}
else if (!strncmp(argv[i], "--ntsc", 5))
{
set_ntsc = true;
continue;
}
else if (!strncmp(argv[i], "-unmute", 7))
{
mute = 0;
continue;
}
#ifdef HAVE_DBOX_HARDWARE
else if (!strncmp(argv[i], "--iecon", 7))
{
Iecon = true;
continue;
}
else if (!strncmp(argv[i], "--iecoff", 8))
{
Iecoff = true;
continue;
}
else if (!strncmp(argv[i], "--iecstate", 10))
{
Iecstate = true;
continue;
}
else if (!strncmp(argv[i], "--pes", 5))
{
pes = true;
continue;
}
else if (!strncmp(argv[i], "--spts", 6))
{
spts = true;
continue;
}
else if (!strncmp(argv[i], "--decmode", 9))
{
decmode = true;
continue;
}
#endif
#ifdef HAVE_TRIPLEDRAGON
else if (!strncmp(argv[i], "--zoom", 6))
{
zoom = true;
if (i < argc - 1) {
sscanf(argv[++i], "%d", &zoomlevel);
}
continue;
}
else if (!strncmp(argv[i], "--pig", 5))
{
pig = true;
if (i < argc - 1) {
sscanf(argv[++i], "%d", &pig_x);
}
if (i < argc - 1) {
sscanf(argv[++i], "%d", &pig_y);
}
if (i < argc - 1) {
sscanf(argv[++i], "%d", &pig_w);
}
if (i < argc - 1) {
sscanf(argv[++i], "%d", &pig_h);
}
if (i < argc - 1) {
sscanf(argv[++i], "%d", &pig_a);
}
continue;
}
else if (!strncmp(argv[i], "--avinfo", 6))
{
avinfo = true;
continue;
}
#endif
else if (!strncmp(argv[i], "-vol", 4))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &volume);
continue;
}
}
else if (!strncmp(argv[i], "--fastzap", 9))
{
if (i < argc - 1)
{
sscanf(argv[++i], "%d", &fastzap);
continue;
}
}
else if (!strncmp(argv[i], "--getpids", 9))
{
getpids = true;
continue;
}
else if (!strncmp(argv[i], "-gsi", 4))
{
getserviceinfo = true;
continue;
}
else if (!strncmp(argv[i], "-save", 5))
{
savezapit = true;
continue;
}
else if (i < argc - 1)
{
if ((sscanf(argv[i], "%d", &bouquet) > 0) && (sscanf(argv[++i], "%u", &channel) > 0))
continue;
}
else if (sscanf(argv[i], "%d", &bouquet) > 0)
continue;
return usage(argv[0]);
}
/* create zapit client */
CZapitClient zapit;
/* send diseqc 1.2 motor command */
if (sendMotorCommand)
{
zapit.sendMotorCommand(motorCmdType, motorAddr, motorCmd, motorNumParameters, motorParam1, motorParam2);
}
/* kill zapit*/
if (killzapit)
{
zapit.shutdown();
std::cout << "zapit shot down :)" << std::endl;
return 0;
}
if (enterStandby)
{
zapit.setStandby(true);
return 0;
}
if (leaveStandby)
{
zapit.setStandby(false);
return 0;
}
if (fastzap > -1)
{
zapit.setFastZap(fastzap != 0);
return 0;
}
if (getmode)
{
int mode = zapit.getMode(); // 1 = TV, 2 = Radio
std::cout << "Mode: " << mode;
if (mode == CZapitClient::MODE_TV)
std::cout << " (TV)" << std::endl;
else if (mode == CZapitClient::MODE_RADIO)
std::cout << " (Radio)" << std::endl;
else
std::cout << " (unknown!)" << std::endl;
return mode;
}
if (getchannel)
{
int mode = zapit.getMode();
if (mode == CZapitClient::MODE_STANDBY)
{
std::cerr << "zapit is in standby mode, no channel active." << std::endl;
return 1;
}
t_channel_id c = zapit.getCurrentServiceID();
printf("%llx (%s)\n", c, (zapit.getChannelName(c)).c_str());
return 0;
}
if (rezap)
{
zapit.ReZap();
return 0;
}
/* audio mute */
if (mute != -1)
{
std::cout << "mute/unmute" << std::endl;
zapit.muteAudio(mute);
return 0;
}
if (volume != -1)
{
std::cout << "set volume" << std::endl;
zapit.setVolume(volume, volume);
return 0;
}
#ifdef HAVE_DBOX_HARDWARE
if (Iecon)
{
std::cout << "Iec on" << std::endl;
zapit.IecOn();
return 0;
}
if (Iecoff)
{
std::cout << "Iec off" << std::endl;
zapit.IecOff();
return 0;
}
if (Iecstate)
{
std::cout << "Iec state = " << zapit.IecState() << std::endl;
return 0;
}
if (pes)
{
std::cout << "set decoder to PES mode" << std::endl;
zapit.PlaybackPES();
return 0;
}
if (spts)
{
std::cout << "set decoder to SPTS mode" << std::endl;
zapit.PlaybackSPTS();
return 0;
}
if (decmode)
{
std::cout << "decoder mode = " << zapit.PlaybackState() << std::endl;
return 0;
}
#endif
#ifdef HAVE_TRIPLEDRAGON
if (zoom)
{
if (zoomlevel > 0)
zapit.setZoom(zoomlevel);
std::cout << "zoom = " << zapit.getZoom() << "%" << std::endl;
return 0;
}
if (pig)
{
zapit.setPIG(pig_x, pig_y, pig_w, pig_h, !!pig_a);
std::cout << "pig = " << pig_x << "." << pig_y << "." << pig_w << "." << pig_h << ":" << pig_a << std::endl;
return 0;
}
if (avinfo)
{
AVInfo v = zapit.getAVInfo();
std::cout << "h_size = " << v.vinfo.h_size << " v_size = " << v.vinfo.v_size << " ar = " << v.vinfo.pel_aspect_ratio << " rate = " << v.vinfo.frame_rate << std::endl;
printf("atype = %d astatus0 = 0x%08x astatus1 = 0x%08x\n", v.atype, v.astatus.word00, v.astatus.word01);
return 0;
}
#endif
/* reload services */
if (reload)
{
std::cout << "reloading channels" << std::endl;
zapit.reinitChannels();
return 0;
}
if (register_neutrino)
{
#define NEUTRINO_UDS_NAME "/tmp/neutrino.sock"
std::cout << "registering neutrino" << std::endl;
for (i = CZapitClient::FIRST_EVENT_MARKER; i < CZapitClient::LAST_EVENT_MARKER; i++)
zapit.registerEvent(i, 222, NEUTRINO_UDS_NAME);
return 0;
}
if (diseqcType != -1)
{
zapit.setDiseqcType((diseqc_t) diseqcType);
if (diseqcRepeats == -1)
return 0;
}
if (diseqcRepeats != -1)
{
zapit.setDiseqcRepeat(diseqcRepeats);
return 0;
}
if (playback)
{
if (zapit.isPlayBackActive())
zapit.stopPlayBack();
else
zapit.startPlayBack();
if (!recordmode)
return 0;
}
if (recordmode)
{
zapit.setRecordMode(!zapit.isRecordModeActive());
return 0;
}
if (savebouquets)
{
zapit.saveBouquets(includeBouquetOthers);
return 0;
}
if (show_satellites)
{
std::vector<CZapitClient::responseGetSatelliteList> satelliteList;
zapit.getScanSatelliteList(satelliteList);
std::vector<CZapitClient::responseGetSatelliteList>::const_iterator rI;
for (i = 0, rI = satelliteList.begin(); rI != satelliteList.end(); i++, rI++)
std::cout << (1 + i) << ": " << rI->satName << std::endl;
return 0;
}
else if (satmask != 0)
{
std::vector<CZapitClient::responseGetSatelliteList> satelliteList;
zapit.getScanSatelliteList(satelliteList);
std::vector<CZapitClient::commandSetScanSatelliteList> newSatelliteList;
CZapitClient::commandSetScanSatelliteList item;
for (i = 1, j = 0, k = 0; j < satelliteList.size(); i = (i << 1), k++)
{
if (satmask & i)
{
j++;
std::cout << "diseqc " << diseqc[j] << ": " << satelliteList[k].satName << std::endl;
strcpy(item.satName, satelliteList[k].satName);
item.diseqc = diseqc[j];
newSatelliteList.push_back(item);
}
if ((j >= diseqc[0]) || (k >= satelliteList.size()))
{
break;
}
}
zapit.setScanSatelliteList(newSatelliteList);
return 0;
}
/* transponderscan */
if (scan)
{
unsigned int satellite;
unsigned int processed_transponder;
unsigned int transponder;
unsigned int services;
zapit.startScan(1);
while (zapit.isScanReady(satellite, processed_transponder, transponder, services) == false)
{
std::cout << "satellite: " << satellite << ", transponder: " << processed_transponder <<", of: " << transponder << ", services: " << services << std::endl;
sleep(1);
}
return 0;
}
if (set_pal)
{
zapit.stopPlayBack();
zapit.setVideoSystem_a(PAL);
zapit.startPlayBack();
return 0;
}
if (set_ntsc)
{
zapit.stopPlayBack();
zapit.setVideoSystem_a(NTSC);
zapit.startPlayBack();
return 0;
}
/* set audio channel */
if (audio)
{
zapit.setAudioChannel(audio - 1);
return 0;
}
if (nvod != -1)
{
zapit.zaptoNvodSubService(nvod);
return 0;
}
if (getpids)
{
CZapitClient::responseGetPIDs pids;
zapit.getPIDS(pids);
if (pids.PIDs.vpid)
std::cout << " video: 0x" << std::hex << pids.PIDs.vpid << std::endl;
if (pids.PIDs.ecmpid)
std::cout << " ecmpid: 0x" << std::hex << pids.PIDs.ecmpid << std::endl;
if (pids.PIDs.vtxtpid)
std::cout << "teletext: 0x" << std::hex << pids.PIDs.vtxtpid << std::endl;
if (pids.PIDs.pcrpid)
std::cout << " pcr: 0x" << std::hex << pids.PIDs.pcrpid << std::endl;
if (pids.PIDs.pmtpid)
std::cout << " pmt: 0x" << std::hex << pids.PIDs.pmtpid << std::endl;
if (pids.PIDs.privatepid)
std::cout << " private: 0x" << std::hex << pids.PIDs.privatepid << std::endl;
for (count = 0; count < pids.APIDs.size(); count++)
{
if (count == pids.PIDs.selected_apid)
std::cout << "*";
else
std::cout << " ";
std::cout << "audio " << std::dec << count + 1 << ": 0x" << std::hex << pids.APIDs[count].pid << " (" << pids.APIDs[count].desc;
if (pids.APIDs[count].is_ac3)
std::cout << ", ac3";
std::cout << ")" << std::endl;
}
for (count = 0 ; count < pids.SubPIDs.size() ; count++)
{
if (pids.SubPIDs[count].pid != pids.PIDs.vtxtpid) {
std::cout << "DVB-Sub "
<< std::dec << count + 1
<< ": 0x" << std::hex << pids.SubPIDs[count].pid
<< " (" << pids.SubPIDs[count].desc << ")"
<< std::endl;
} else {
std::cout << "TTX-Sub "
<< std::dec << count + 1
<< ": " << pids.SubPIDs[count].composition_page
<< " (" << pids.SubPIDs[count].desc << ")"
<< std::endl;
}
}
return 0;
}
if (getserviceinfo)
{
CZapitClient::CCurrentServiceInfo si;
si = zapit.getCurrentServiceInfo();
printf("frequency = %d.%d MHz", si.tsfrequency/1000, si.tsfrequency%1000);
if (si.polarisation != 2) /* only satellite has polarisation */
{
printf(" (%c)\n", (si.polarisation == HORIZONTAL) ? 'h' : 'v');
//satellite
printf("diseqc = %d\n", si.diseqc);
}
else
{
printf("\n");
}
printf("onid = 0x%04x\n", si.onid);
printf("sid = 0x%04x\n", si.sid);
printf("tsid = 0x%04x\n", si.tsid);
printf("pmtpid = 0x%04x\n", si.pmtpid);
printf("vpid = 0x%04x\n", si.vpid);
printf("apid = 0x%04x\n", si.apid);
printf("spid = 0x%04x\n", si.spid);
printf("spage = 0x%04x\n", si.spage);
printf("pcrpid = 0x%04x\n", si.pcrpid);
printf("vtxtpid = 0x%04x\n", si.vtxtpid);
return 0;
}
/* save zapit*/
if (savezapit)
{
zapit.saveSettings();
std::cout << "zapit settings saved" << std::endl;
return 0;
}
/* if we got here, we want to zap by name, bouquet / number or onidsid */
/* choose source mode */
zapit.setMode(radio ? CZapitClient::MODE_RADIO : CZapitClient::MODE_TV);
if (zapsid > 0)
{
printf("Zapping to: %llx (%s) ", zapsid, (zapit.getChannelName(zapsid)).c_str());
tmp = zapit.zapTo_serviceID(zapsid);
if (!tmp)
printf("failed");
printf("\n");
return tmp;
}
std::vector<CZapitClient::responseGetBouquetChannels> channels;
if (zapByName)
{
zapit.getChannels(channels);
std::vector<CZapitClient::responseGetBouquetChannels>::const_iterator ch_resp;
for (ch_resp = channels.begin(), channel = 1; ch_resp != channels.end(); ch_resp++, channel++)
{
if (!strcasecmp(ch_resp->name, channelName))
{
std::cout << "found channel number: " << channel << std::endl;
goto channel_found;
}
}
std::cout << "channel not found." << std::endl;
return 0;
}
else /* zap by bouquet number and channel number */
{
/* read channel list */
if (bouquet != -1)
zapit.getBouquetChannels(bouquet - 1, channels);
/* display bouquet list */
else
{
std::vector<CZapitClient::responseGetBouquets> bouquets;
std::vector<CZapitClient::responseGetBouquets>::const_iterator b_resp;
zapit.getBouquets(bouquets, false);
for (b_resp = bouquets.begin(); b_resp != bouquets.end(); b_resp++)
std::cout << (b_resp->bouquet_nr + 1) << ": " << b_resp->name << std::endl;
return 0;
}
/* display channel list */
if (!channel)
{
std::vector<CZapitClient::responseGetBouquetChannels>::const_iterator ch_resp;
for (ch_resp = channels.begin(), channel = 1; ch_resp != channels.end(); ch_resp++, channel++)
std::cout << channel << ": " << ch_resp->name << std::endl;
return 0;
}
}
/* zap */
if (channel > channels.size())
{
std::cout << "Only " << channels.size() << " channels in bouquet " << bouquet << std::endl;
return 0;
}
channel_found:
zapit.zapTo(channels[channel-1].nr);
std::cout << "zapped to " << channels[channel-1].name << std::endl;
return 0;
}
/* too many subtle differences between old and new API, so i just have this
code twice - much more readable than putting #ifdefs all over the place
*/
#ifndef HAVE_TRIPLEDRAGON
#if HAVE_DVB_API_VERSION >= 3
void *CEventWatchDog::watchdogThread(void *arg)
{
const char *verb_aratio[] = { "4:3", "16:9", "2.21:1" };
CEventWatchDog *WatchDog = (CEventWatchDog *)arg;
int fd_ev = -1, fd_video;
while (true)
{
#if defined HAVE_DBOX_HARDWARE || defined HAVE_DREAMBOX_HARDWARE || defined HAVE_IPBOX_HARDWARE
#define _DEVNUM 2
struct pollfd pfd[2];
fd_ev = open(EVENT_DEVICE, O_RDWR|O_NONBLOCK);
if (fd_ev < 0)
{
perror("[controld] " EVENT_DEVICE);
pthread_exit(NULL);
}
if (ioctl(fd_ev, EVENT_SET_FILTER, EVENT_VCR_CHANGED) < 0) {
perror("[controld] EVENT_SET_FILTER");
close(fd_ev);
pthread_exit(NULL);
}
pfd[1].fd = fd_ev;
pfd[1].events = POLLIN;
#else
#define _DEVNUM 1
struct pollfd pfd[1];
#endif
fd_video = open(VIDEO_DEVICE, O_RDONLY|O_NONBLOCK);
if (fd_video < 0)
{
perror("[controld] " VIDEO_DEVICE);
if (fd_ev >= 0)
close(fd_ev);
pthread_exit(NULL);
}
pfd[0].fd = fd_video;
pfd[0].events = POLLPRI;
while (poll(pfd, _DEVNUM, -1) > 0) {
#if defined HAVE_DBOX_HARDWARE || defined HAVE_DREAMBOX_HARDWARE || defined HAVE_IPBOX_HARDWARE
if (pfd[1].revents & POLLIN) {
struct event_t event;
while (read(fd_ev, &event, sizeof(event)) == sizeof(event)) {
if (event.event == EVENT_VCR_CHANGED) {
int newVCRMode = WatchDog->getVCRMode();
if ((newVCRMode != WatchDog->VCRMode)) {
pthread_mutex_lock( &WatchDog->wd_mutex );
WatchDog->VCRMode = newVCRMode;
WatchDog->vcrModeChanged( newVCRMode );
if(newVCRMode > 0)
{
//Set Aspect ratio of scart input signal (1->4:3 / 2->16:9)
// vcr AR is saved in Bit 8-15, DVB AR is saved in bits 0-7
WatchDog->VideoMode = (WatchDog->VideoMode & 0xFF) | ((newVCRMode-1) << 8);
WatchDog->videoModeChanged(WatchDog->VideoMode);
}
pthread_mutex_unlock( &WatchDog->wd_mutex );
}
}
}
}
#endif
if (pfd[0].revents & POLLPRI) {
struct video_event event;
if (ioctl(fd_video, VIDEO_GET_EVENT, &event) == -1) {
perror("[controld] VIDEO_GET_EVENT");
}
else if (event.type == VIDEO_EVENT_SIZE_CHANGED) {
printf("[controld] VIDEO_EVENT_SIZE_CHANGED %ux%u (%s -> %s)\n",
event.u.size.w,
event.u.size.h,
verb_aratio[WatchDog->VideoMode&3],
verb_aratio[event.u.size.aspect_ratio]);
// DVB AR is saved in Bites 0-7
if ((WatchDog->VideoMode & 0xFF) != event.u.size.aspect_ratio) {
pthread_mutex_lock(&WatchDog->wd_mutex);
WatchDog->VideoMode = (WatchDog->VideoMode & 0xFF00 ) | event.u.size.aspect_ratio;
WatchDog->videoModeChanged(WatchDog->VideoMode);
pthread_mutex_unlock(&WatchDog->wd_mutex);
}
}
}
}
perror("[CONTROLD] eventwatchdog poll()");
close(fd_video);
if (fd_ev >= 0)
close(fd_ev);
sleep(1);
}
pthread_exit(NULL);
}
#else /* old API -> dreambox */
void *CEventWatchDog::watchdogThread(void *arg)
{
#if defined HAVE_DBOX_HARDWARE || defined HAVE_DREAMBOX_HARDWARE || defined HAVE_IPBOX_HARDWARE
char *verb_aratio[] = { "4:3", "16:9", "2.21:1" };
CEventWatchDog *WatchDog = (CEventWatchDog *)arg;
int fd_ev;
while (true)
{
if ((fd_ev = open(EVENT_DEVICE, O_RDWR | O_NONBLOCK)) < 0) {
perror("[controld] " EVENT_DEVICE);
pthread_exit(NULL);
}
if (ioctl(fd_ev, EVENT_SET_FILTER, EVENT_VCR_CHANGED | EVENT_ARATIO_CHANGE) < 0) {
perror("[controld] EVENT_SET_FILTER");
close(fd_ev);
pthread_exit(NULL);
}
CZapitClient zapit;
struct pollfd pfd[1];
pfd[0].fd = fd_ev;
pfd[0].events = POLLIN;
#if 0
int pollret;
while ((pollret = poll(pfd, 1, 2500)) >= 0) {
if (pollret == 0) {
if (WatchDog->getVideoMode() & 0x100) {
printf("[controld] possible hang of mpeg decoder detected\n");
if (zapit.isPlayBackActive()) {
zapit.stopPlayBack();
usleep(200000); //stopPlayBack is not blocking :-(
zapit.startPlayBack();
}
}
}
#endif
while (poll(pfd, 1, -1) >= 0) {
if (!(pfd[0].revents & POLLIN))
continue;
struct event_t event;
while (read(fd_ev, &event, sizeof(event)) == sizeof(event)) {
if (event.event == EVENT_VCR_CHANGED) {
int newVCRMode = WatchDog->getVCRMode();
if (newVCRMode == WatchDog->VCRMode)
continue;
pthread_mutex_lock( &WatchDog->wd_mutex );
WatchDog->VCRMode = newVCRMode;
WatchDog->vcrModeChanged( newVCRMode );
if(newVCRMode > 0) {
//Set Aspect ratio of scart input signal (1->4:3 / 2->16:9)
// vcr AR is saved in Bit 8-15, DVB AR is saved in bits 0-7
WatchDog->VideoMode = (WatchDog->VideoMode & 0xFF) | ((newVCRMode-1) << 8);
WatchDog->videoModeChanged(WatchDog->VideoMode);
}
pthread_mutex_unlock( &WatchDog->wd_mutex );
} else if (event.event == EVENT_ARATIO_CHANGE) {
int aspect = WatchDog->getVideoMode();
if ((WatchDog->VideoMode & 0xFF) != aspect) {
printf("[controld] aspect ratio changed %u -> %u (%s -> %s)\n",
(WatchDog->VideoMode & 0xFF), aspect,
verb_aratio[WatchDog->VideoMode&3],
verb_aratio[aspect]);
pthread_mutex_lock(&WatchDog->wd_mutex);
WatchDog->VideoMode = (WatchDog->VideoMode & 0xFF00) | aspect;
WatchDog->videoModeChanged(WatchDog->VideoMode);
pthread_mutex_unlock(&WatchDog->wd_mutex);
}
} else {
printf("[controld] unknown event: 0x%02x\n", event.event);
}
}
}
perror("[CONTROLD] eventwatchdog poll()");
close(fd_ev);
sleep(1);
}
pthread_exit(NULL);
#endif
return NULL;
}
#endif
#else /* TRIPLEDRAGON */
void *CEventWatchDog::watchdogThread(void *arg)
{
const char *verb_aratio[] = { "4:3", "16:9", "2.21:1", "unknown" };
CEventWatchDog *WatchDog = (CEventWatchDog *)arg;
while (true)
{
sleep(1);
int newVCRMode = WatchDog->getVCRMode();
if (newVCRMode != WatchDog->VCRMode)
{
printf("[controld] VCR SCART PIN8 changed from %dV to %dV\n", WatchDog->VCRMode * 6, newVCRMode * 6);
pthread_mutex_lock( &WatchDog->wd_mutex );
WatchDog->VCRMode = newVCRMode;
WatchDog->vcrModeChanged( newVCRMode );
if(newVCRMode > 0) {
//Set Aspect ratio of scart input signal (1->4:3 / 2->16:9)
// vcr AR is saved in Bit 8-15, DVB AR is saved in bits 0-7
WatchDog->VideoMode = (WatchDog->VideoMode & 0xFF) | ((newVCRMode-1) << 8);
WatchDog->videoModeChanged(WatchDog->VideoMode);
}
pthread_mutex_unlock( &WatchDog->wd_mutex );
}
int aspect = WatchDog->getVideoMode();
if ((WatchDog->VideoMode & 0xFF) != aspect) {
printf("[controld] aspect ratio changed %u -> %u (%s -> %s)\n",
(WatchDog->VideoMode & 0xFF), aspect,
verb_aratio[WatchDog->VideoMode&3],
verb_aratio[aspect]);
pthread_mutex_lock(&WatchDog->wd_mutex);
WatchDog->VideoMode = (WatchDog->VideoMode & 0xFF00) | aspect;
WatchDog->videoModeChanged(WatchDog->VideoMode);
pthread_mutex_unlock(&WatchDog->wd_mutex);
}
}
pthread_exit(NULL);
}
#endif
void CEventWatchDog::registerNotifier( uint watchdogEvent, CEventWatchdogNotifier* notifier )
{
if (bThreadRunning)
pthread_mutex_lock( &wd_mutex );
Notifiers.find(watchdogEvent)->second->insert( Notifiers.find(watchdogEvent)->second->end(), notifier);
if (watchdogEvent== WDE_VIDEOMODE)
{
videoModeChanged( getVideoMode() );
}
if (watchdogEvent== WDE_VCRONOFF)
{
vcrModeChanged( getVCRMode() );
}
if (bThreadRunning)
pthread_mutex_unlock( &wd_mutex );
if (!bThreadRunning)
startThread();
}
void CEventWatchDog::unregisterNotifier( uint watchdogEvent, CEventWatchdogNotifier* notifier )
{
if (bThreadRunning)
pthread_mutex_lock( &wd_mutex );
EventWatchdogNotifiers* notifiers = Notifiers.find(watchdogEvent)->second;
EventWatchdogNotifiers::iterator it;
for (it=notifiers->end(); it>=notifiers->begin(); it--)
{
if (*it == notifier)
{
notifiers->erase(it);
}
}
if (bThreadRunning)
pthread_mutex_unlock( &wd_mutex );
}
