int cAudio::setVolume(unsigned int left, unsigned int right)
{
// int avsfd;
int ret;
int vl = map_volume(left);
int vr = map_volume(right);
volume = (left + right) / 2;
int v = map_volume(volume);
if (clipfd != -1 && mixer_fd != -1) {
int tmp = 0;
/* not sure if left / right is correct here, but it is always the same anyways ;-) */
if (! Muted)
tmp = left << 8 | right;
ret = ioctl(mixer_fd, MIXER_WRITE(mixer_num), &tmp);
if (ret == -1)
lt_info("%s: MIXER_WRITE(%d),%04x: %m\n", __func__, mixer_num, tmp);
return ret;
}
// if (settings.volume_type == CControld::TYPE_OST || forcetype == (int)CControld::TYPE_OST)
{
AUDVOL vol;
vol.frontleft = vl;
vol.frontright = vr;
vol.rearleft = vl;
vol.rearright = vr;
vol.center = v;
vol.lfe = v;
ret = ioctl(fd, MPEG_AUD_SET_VOL, &vol);
if (ret < 0)
lt_info("setVolume MPEG_AUD_SET_VOL failed (%m)\n");
return ret;
}
#if 0
else if (settings.volume_type == CControld::TYPE_AVS || forcetype == (int)CControld::TYPE_AVS)
int CAudio::setVolume(unsigned char volume, int forcetype)
{
if (settings.volume_type == CControld::TYPE_OST || forcetype == (int)CControld::TYPE_OST)
{
unsigned int v = map_volume(volume, false);
struct audio_mixer mixer;
mixer.volume_left = v;
mixer.volume_right = v;
return fop(ioctl, AUDIO_SET_MIXER, &mixer);
}
#ifdef HAVE_DBOX_HARDWARE
else if (settings.volume_type == CControld::TYPE_AVS || forcetype == (int)CControld::TYPE_AVS)
{
int fd;
int i = map_volume(volume, true);
if ((fd = open(AVS_DEVICE, O_RDWR)) < 0)
perror("[controld] " AVS_DEVICE);
else {
if (ioctl(fd, AVSIOSVOL, &i) < 0)
perror("[controld] AVSIOSVOL");
close(fd);
return 0;
}
}
#else
printf("CAudio::setVolume: volume_type != TYPE_OST not supported on dreambox!\n");
#endif
return -1;
}
int CAudio::setVolume(const unsigned char volume, int forcetype)
{
int avsfd;
int v = (int)map_volume(volume, false);
if (settings.volume_type == CControld::TYPE_OST || forcetype == (int)CControld::TYPE_OST)
{
AUDVOL vol;
vol.frontleft = v;
vol.frontright = v;
vol.rearleft = v;
vol.rearright = v;
vol.center = v;
vol.lfe = v;
return fop(ioctl, MPEG_AUD_SET_VOL, &vol);
}
else if (settings.volume_type == CControld::TYPE_AVS || forcetype == (int)CControld::TYPE_AVS)
{
if ((avsfd = open(AVS_DEVICE, O_RDWR)) < 0)
perror("[controld] " AVS_DEVICE);
else {
if (ioctl(avsfd, IOC_AVS_SET_VOLUME, v))
perror("[controld] IOC_AVS_SET_VOLUME");
close(avsfd);
return 0;
}
}
fprintf(stderr, "CAudio::setVolume: invalid settings.volume_type = %d\n", settings.volume_type);
return -1;
}
int
main(int argc, char *argv[])
{
const char *dev = NULL, *sys_dev = NULL, *map_name = NULL;
const char *keyfiles[MAX_KEYFILES];
const char *h_keyfiles[MAX_KEYFILES];
int nkeyfiles;
int n_hkeyfiles;
int ch, error;
int flags = 0;
int info_vol = 0, map_vol = 0, protect_hidden = 0,
unmap_vol = 0, info_map = 0,
create_vol = 0, contain_hidden = 0, use_secure_erase = 1,
use_weak_keys = 0;
struct pbkdf_prf_algo *prf = NULL;
struct tc_cipher_chain *cipher_chain = NULL;
struct pbkdf_prf_algo *h_prf = NULL;
struct tc_cipher_chain *h_cipher_chain = NULL;
if ((error = tc_play_init()) != 0) {
fprintf(stderr, "Initialization failed, exiting.");
exit(EXIT_FAILURE);
}
atexit(check_and_purge_safe_mem);
signal(SIGUSR1, sig_handler);
signal(SIGINFO, sig_handler);
nkeyfiles = 0;
n_hkeyfiles = 0;
while ((ch = getopt_long(argc, argv, "a:b:cd:ef:ghij:k:m:s:u:vwx:y:z",
longopts, NULL)) != -1) {
switch(ch) {
case 'a':
if (prf != NULL)
usage();
if ((prf = check_prf_algo(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(EXIT_SUCCESS);
else
usage();
/* NOT REACHED */
}
break;
case 'b':
if (cipher_chain != NULL)
usage();
if ((cipher_chain = check_cipher_chain(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(EXIT_SUCCESS);
else
usage();
/* NOT REACHED */
}
break;
case 'c':
create_vol = 1;
break;
case 'd':
dev = optarg;
break;
case 'e':
protect_hidden = 1;
break;
case 'f':
h_keyfiles[n_hkeyfiles++] = optarg;
break;
case 'g':
contain_hidden = 1;
break;
case 'i':
info_vol = 1;
break;
case 'j':
info_map = 1;
map_name = optarg;
break;
case 'k':
keyfiles[nkeyfiles++] = optarg;
break;
case 'm':
map_vol = 1;
map_name = optarg;
break;
case 's':
flags |= TC_FLAG_SYS;
sys_dev = optarg;
break;
case 'u':
unmap_vol = 1;
map_name = optarg;
break;
case 'v':
printf("tcplay v%d.%d\n", MAJ_VER, MIN_VER);
exit(EXIT_SUCCESS);
/* NOT REACHED */
case 'w':
fprintf(stderr, "WARNING: Using urandom as source of "
"entropy for key material is a really bad idea.\n");
use_weak_keys = 1;
break;
case 'x':
if (h_prf != NULL)
usage();
if ((h_prf = check_prf_algo(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(EXIT_SUCCESS);
else
usage();
/* NOT REACHED */
}
break;
case 'y':
if (h_cipher_chain != NULL)
usage();
if ((h_cipher_chain = check_cipher_chain(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(EXIT_SUCCESS);
else
usage();
/* NOT REACHED */
}
break;
case 'z':
use_secure_erase = 0;
break;
case FLAG_LONG_FDE:
flags |= TC_FLAG_FDE;
break;
case FLAG_LONG_USE_BACKUP:
flags |= TC_FLAG_BACKUP;
break;
case 'h':
case '?':
default:
usage();
/* NOT REACHED */
}
}
argc -= optind;
argv += optind;
/* Check arguments */
if (!(((map_vol || info_vol || create_vol) && dev != NULL) ||
((unmap_vol || info_map) && map_name != NULL)) ||
(TC_FLAG_SET(flags, SYS) && TC_FLAG_SET(flags, FDE)) ||
(map_vol && info_vol) ||
(map_vol && create_vol) ||
(unmap_vol && map_vol) ||
(unmap_vol && info_vol) ||
(unmap_vol && create_vol) ||
(create_vol && info_vol) ||
(contain_hidden && !create_vol) ||
(TC_FLAG_SET(flags, SYS) && (sys_dev == NULL)) ||
(map_vol && (map_name == NULL)) ||
(unmap_vol && (map_name == NULL)) ||
(!(protect_hidden || create_vol) && n_hkeyfiles > 0)) {
usage();
/* NOT REACHED */
}
/* Create a new volume */
if (create_vol) {
error = create_volume(dev, contain_hidden, keyfiles, nkeyfiles,
h_keyfiles, n_hkeyfiles, prf, cipher_chain, h_prf,
h_cipher_chain, NULL, NULL,
0, 1 /* interactive */,
use_secure_erase, use_weak_keys);
if (error) {
tc_log(1, "could not create new volume on %s\n", dev);
}
} else if (info_map) {
error = info_mapped_volume(map_name, 1 /* interactive */);
} else if (info_vol) {
error = info_volume(dev, flags, sys_dev, protect_hidden,
keyfiles, nkeyfiles, h_keyfiles, n_hkeyfiles, NULL, NULL,
1 /* interactive */, DEFAULT_RETRIES, 0);
} else if (map_vol) {
error = map_volume(map_name,
dev, flags, sys_dev, protect_hidden,
keyfiles, nkeyfiles, h_keyfiles, n_hkeyfiles, NULL, NULL,
1 /* interactive */, DEFAULT_RETRIES, 0);
} else if (unmap_vol) {
error = dm_teardown(map_name, NULL);
}
return error;
}
int
main(int argc, char *argv[])
{
struct tcplay_opts *opts;
int ch, error;
int info_vol = 0, map_vol = 0,
unmap_vol = 0, info_map = 0,
create_vol = 0, modify_vol = 0;
if ((error = tc_play_init()) != 0) {
fprintf(stderr, "Initialization failed, exiting.");
exit(EXIT_FAILURE);
}
atexit(check_and_purge_safe_mem);
signal(SIGUSR1, sig_handler);
signal(SIGINFO, sig_handler);
if ((opts = opts_init()) == NULL) {
fprintf(stderr, "Initialization failed (opts), exiting.");
exit(EXIT_FAILURE);
}
opts->interactive = 1;
while ((ch = getopt_long(argc, argv, "a:b:cd:ef:ghij:k:m:s:tu:vwx:y:zC:",
longopts, NULL)) != -1) {
switch(ch) {
case 'a':
if (opts->prf_algo != NULL)
usage();
if ((opts->prf_algo = check_prf_algo(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(EXIT_SUCCESS);
else
usage();
/* NOT REACHED */
}
break;
case 'b':
if (opts->cipher_chain != NULL)
usage();
if ((opts->cipher_chain = check_cipher_chain(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(EXIT_SUCCESS);
else
usage();
/* NOT REACHED */
}
break;
case 'c':
create_vol = 1;
break;
case 'C':
opts->custom_iterations = atoi(optarg);
break;
case 'd':
_set_str_opt(dev);
break;
case 'e':
opts->protect_hidden = 1;
break;
case 'f':
if ((error = opts_add_keyfile_hidden(opts, optarg)) != 0) {
fprintf(stderr, "Could not add keyfile: %s\n", optarg);
exit(EXIT_FAILURE);
}
break;
case 'g':
opts->hidden = 1;
break;
case 'i':
info_vol = 1;
break;
case 'j':
info_map = 1;
_set_str_opt(map_name);
break;
case 'k':
if ((error = opts_add_keyfile(opts, optarg)) != 0) {
fprintf(stderr, "Could not add keyfile: %s\n", optarg);
exit(EXIT_FAILURE);
}
break;
case 'm':
map_vol = 1;
_set_str_opt(map_name);
break;
case 's':
opts->flags |= TC_FLAG_SYS;
_set_str_opt(sys_dev);
break;
case 't':
opts->flags |= TC_FLAG_ALLOW_TRIM;
break;
case 'u':
unmap_vol = 1;
_set_str_opt(map_name);
break;
case 'v':
printf("tcplay v%d.%d\n", MAJ_VER, MIN_VER);
exit(EXIT_SUCCESS);
/* NOT REACHED */
case 'w':
fprintf(stderr, "WARNING: Using urandom as source of "
"entropy for key material is a really bad idea.\n");
opts->weak_keys_and_salt = 1;
break;
case 'x':
if (opts->h_prf_algo != NULL)
usage();
if ((opts->h_prf_algo = check_prf_algo(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(EXIT_SUCCESS);
else
usage();
/* NOT REACHED */
}
break;
case 'y':
if (opts->h_cipher_chain != NULL)
usage();
if ((opts->h_cipher_chain = check_cipher_chain(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(EXIT_SUCCESS);
else
usage();
/* NOT REACHED */
}
break;
case 'z':
opts->secure_erase = 0;
break;
case FLAG_LONG_FDE:
opts->flags |= TC_FLAG_FDE;
break;
case FLAG_LONG_USE_BACKUP:
opts->flags |= TC_FLAG_BACKUP;
break;
case FLAG_LONG_USE_HDR_FILE:
opts->flags |= TC_FLAG_HDR_FROM_FILE;
_set_str_opt(hdr_file_in);
break;
case FLAG_LONG_USE_HHDR_FILE:
opts->flags |= TC_FLAG_H_HDR_FROM_FILE;
_set_str_opt(h_hdr_file_in);
break;
case FLAG_LONG_MOD:
modify_vol = 1;
break;
case FLAG_LONG_MOD_KF:
if ((error = opts_add_keyfile_new(opts, optarg)) != 0) {
fprintf(stderr, "Could not add keyfile: %s\n", optarg);
exit(EXIT_FAILURE);
}
break;
case FLAG_LONG_MOD_PRF:
if (opts->new_prf_algo != NULL)
usage();
if ((opts->new_prf_algo = check_prf_algo(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(EXIT_SUCCESS);
else
usage();
/* NOT REACHED */
}
break;
case FLAG_LONG_MOD_NONE:
opts->new_prf_algo = NULL;
opts->flags |= TC_FLAG_ONLY_RESTORE;
opts->flags |= TC_FLAG_BACKUP;
break;
case FLAG_LONG_MOD_TO_FILE:
opts->flags |= TC_FLAG_SAVE_TO_FILE;
_set_str_opt(hdr_file_out);
break;
case FLAG_LONG_NO_RETRIES:
opts->retries = 1;
break;
case 'h':
case '?':
default:
usage();
/* NOT REACHED */
}
}
argc -= optind;
argv += optind;
/* Check arguments */
if (!(((map_vol || info_vol || create_vol || modify_vol) && opts->dev != NULL) ||
((unmap_vol || info_map) && opts->map_name != NULL)) ||
(TC_FLAG_SET(opts->flags, SYS) && TC_FLAG_SET(opts->flags, FDE)) ||
(map_vol + info_vol + create_vol + unmap_vol + info_map + modify_vol > 1) ||
(opts->hidden && !create_vol) ||
(TC_FLAG_SET(opts->flags, SYS) && (opts->sys_dev == NULL)) ||
(TC_FLAG_SET(opts->flags, ONLY_RESTORE) && (opts->n_newkeyfiles > 0 || opts->new_prf_algo != NULL)) ||
(TC_FLAG_SET(opts->flags, BACKUP) && (opts->sys_dev != NULL || TC_FLAG_SET(opts->flags, FDE))) ||
(map_vol && (opts->map_name == NULL)) ||
(unmap_vol && (opts->map_name == NULL)) ||
(!modify_vol && opts->n_newkeyfiles > 0) ||
(!modify_vol && opts->new_prf_algo != NULL) ||
(!modify_vol && TC_FLAG_SET(opts->flags, ONLY_RESTORE)) ||
(!modify_vol && TC_FLAG_SET(opts->flags, SAVE_TO_FILE)) ||
(!(opts->protect_hidden || create_vol) && opts->n_hkeyfiles > 0)) {
usage();
/* NOT REACHED */
}
/* Create a new volume */
if (create_vol) {
error = create_volume(opts);
if (error) {
tc_log(1, "could not create new volume on %s\n", opts->dev);
}
} else if (info_map) {
error = info_mapped_volume(opts);
} else if (info_vol) {
error = info_volume(opts);
} else if (map_vol) {
error = map_volume(opts);
} else if (unmap_vol) {
error = dm_teardown(opts->map_name, NULL);
} else if (modify_vol) {
error = modify_volume(opts);
}
return error;
}
int
main(int argc, char *argv[])
{
const char *dev = NULL, *sys_dev = NULL, *map_name = NULL;
const char *keyfiles[MAX_KEYFILES];
const char *h_keyfiles[MAX_KEYFILES];
int nkeyfiles;
int n_hkeyfiles;
int ch, error;
int sflag = 0, info_vol = 0, map_vol = 0, protect_hidden = 0,
create_vol = 0, contain_hidden = 0, use_secure_erase = 1;
struct pbkdf_prf_algo *prf = NULL;
struct tc_cipher_chain *cipher_chain = NULL;
struct pbkdf_prf_algo *h_prf = NULL;
struct tc_cipher_chain *h_cipher_chain = NULL;
if ((error = tc_play_init()) != 0) {
fprintf(stderr, "Initialization failed, exiting.");
exit(1);
}
atexit(check_and_purge_safe_mem);
signal(SIGUSR1, sig_handler);
signal(SIGINFO, sig_handler);
nkeyfiles = 0;
n_hkeyfiles = 0;
while ((ch = getopt_long(argc, argv, "a:b:cd:ef:ghik:m:s:vx:y:z",
longopts, NULL)) != -1) {
switch(ch) {
case 'a':
if (prf != NULL)
usage();
if ((prf = check_prf_algo(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(0);
else
usage();
/* NOT REACHED */
}
break;
case 'b':
if (cipher_chain != NULL)
usage();
if ((cipher_chain = check_cipher_chain(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(0);
else
usage();
/* NOT REACHED */
}
break;
case 'c':
create_vol = 1;
break;
case 'd':
if (sflag) usage();
dev = optarg;
break;
case 'e':
protect_hidden = 1;
break;
case 'f':
h_keyfiles[n_hkeyfiles++] = optarg;
break;
case 'g':
contain_hidden = 1;
break;
case 'i':
info_vol = 1;
break;
case 'k':
keyfiles[nkeyfiles++] = optarg;
break;
case 'm':
map_vol = 1;
map_name = optarg;
break;
case 's':
if (dev) usage();
sflag = 1;
sys_dev = optarg;
dev = optarg;
break;
case 'v':
printf("tcplay v%d.%d\n", MAJ_VER, MIN_VER);
exit(0);
/* NOT REACHED */
case 'x':
if (h_prf != NULL)
usage();
if ((h_prf = check_prf_algo(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(0);
else
usage();
/* NOT REACHED */
}
break;
case 'y':
if (h_cipher_chain != NULL)
usage();
if ((h_cipher_chain = check_cipher_chain(optarg, 0)) == NULL) {
if (strcmp(optarg, "help") == 0)
exit(0);
else
usage();
/* NOT REACHED */
}
break;
case 'z':
use_secure_erase = 0;
break;
case 'h':
case '?':
default:
usage();
/* NOT REACHED */
}
}
argc -= optind;
argv += optind;
/* Check arguments */
if (!((map_vol || info_vol || create_vol) && dev != NULL) ||
(map_vol && info_vol) ||
(map_vol && create_vol) ||
(create_vol && info_vol) ||
(contain_hidden && !create_vol) ||
(sflag && (sys_dev == NULL)) ||
(map_vol && (map_name == NULL)) ||
(!(protect_hidden || create_vol) && n_hkeyfiles > 0)) {
usage();
/* NOT REACHED */
}
/* Create a new volume */
if (create_vol) {
error = create_volume(dev, contain_hidden, keyfiles, nkeyfiles,
h_keyfiles, n_hkeyfiles, prf, cipher_chain, h_prf,
h_cipher_chain, NULL, NULL,
0, 1 /* interactive */,
use_secure_erase);
if (error) {
tc_log(1, "could not create new volume on %s\n", dev);
}
} else if (info_vol) {
error = info_volume(dev, sflag, sys_dev, protect_hidden,
keyfiles, nkeyfiles, h_keyfiles, n_hkeyfiles, NULL, NULL,
1 /* interactive */, DEFAULT_RETRIES, 0);
} else if (map_vol) {
error = map_volume(map_name,
dev, sflag, sys_dev, protect_hidden,
keyfiles, nkeyfiles, h_keyfiles, n_hkeyfiles, NULL, NULL,
1 /* interactive */, DEFAULT_RETRIES, 0);
}
return error;
}
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");
}
}
