/* ARGSUSED1 */
void
keyboard(unsigned char c, int x, int y)
{
switch (c) {
case 0x1B:
exit(0);
break;
case 'r':
buttons[RKEY] = 1;
break;
case '.':
buttons[PERIODKEY] = 1;
break;
case ' ':
buttons[SPACEKEY] = 1;
break;
case 'f':
set_fog(!fog);
break;
case 'd':
set_dither(!dither);
break;
case 't':
show_timer = !show_timer;
break;
}
}
/*****************************************************************************
* dce_transform_bit_depth_reduction_program
*
* @brief
* Programs the DCP bit depth reduction registers (Clamp, Round/Truncate,
* Dither) for dce
*
* @param depth : bit depth to set the clamp to (should match denorm)
*
******************************************************************************/
static void program_bit_depth_reduction(
struct dce_transform *xfm_dce,
enum dc_color_depth depth,
const struct bit_depth_reduction_params *bit_depth_params)
{
enum dcp_out_trunc_round_depth trunc_round_depth;
enum dcp_out_trunc_round_mode trunc_mode;
bool spatial_dither_enable;
ASSERT(depth < COLOR_DEPTH_121212); /* Invalid clamp bit depth */
spatial_dither_enable = bit_depth_params->flags.SPATIAL_DITHER_ENABLED;
/* Default to 12 bit truncation without rounding */
trunc_round_depth = DCP_OUT_TRUNC_ROUND_DEPTH_12BIT;
trunc_mode = DCP_OUT_TRUNC_ROUND_MODE_TRUNCATE;
if (bit_depth_params->flags.TRUNCATE_ENABLED) {
/* Don't enable dithering if truncation is enabled */
spatial_dither_enable = false;
trunc_mode = bit_depth_params->flags.TRUNCATE_MODE ?
DCP_OUT_TRUNC_ROUND_MODE_ROUND :
DCP_OUT_TRUNC_ROUND_MODE_TRUNCATE;
if (bit_depth_params->flags.TRUNCATE_DEPTH == 0 ||
bit_depth_params->flags.TRUNCATE_DEPTH == 1)
trunc_round_depth = DCP_OUT_TRUNC_ROUND_DEPTH_8BIT;
else if (bit_depth_params->flags.TRUNCATE_DEPTH == 2)
trunc_round_depth = DCP_OUT_TRUNC_ROUND_DEPTH_10BIT;
else {
/*
* Invalid truncate/round depth. Setting here to 12bit
* to prevent use-before-initialize errors.
*/
trunc_round_depth = DCP_OUT_TRUNC_ROUND_DEPTH_12BIT;
BREAK_TO_DEBUGGER();
}
}
set_clamp(xfm_dce, depth);
set_round(xfm_dce, trunc_mode, trunc_round_depth);
set_dither(xfm_dce,
spatial_dither_enable,
DCP_SPATIAL_DITHER_MODE_A_AA_A,
DCP_SPATIAL_DITHER_DEPTH_30BPP,
bit_depth_params->flags.FRAME_RANDOM,
bit_depth_params->flags.RGB_RANDOM,
bit_depth_params->flags.HIGHPASS_RANDOM);
}
const char* parse_command(CLIENT* client,char* command) {
char* token;
fprintf(stderr,"parse_command: '%s'\n",command);
token=strtok(command," \r\n");
if(token!=NULL) {
if(strcmp(token,"attach")==0) {
// select receiver
token=strtok(NULL," \r\n");
if(token!=NULL) {
int rx=atoi(token);
return attach_receiver(rx,client);
} else {
return INVALID_COMMAND;
}
} else if(strcmp(token,"detach")==0) {
// select receiver
token=strtok(NULL," \r\n");
if(token!=NULL) {
int rx=atoi(token);
return detach_receiver(rx,client);
} else {
return INVALID_COMMAND;
}
} else if(strcmp(token,"frequency")==0) {
// set frequency
token=strtok(NULL," \r\n");
if(token!=NULL) {
long f=atol(token);
return set_frequency (client,f);
} else {
return INVALID_COMMAND;
}
} else if(strcmp(token,"start")==0) {
token=strtok(NULL," \r\n");
if(token!=NULL) {
if(strcmp (token,"iq")==0) {
token=strtok(NULL," \r\n");
if(token!=NULL) {
client->iq_port=atoi(token);
}
printf("***************************Starting async data acquisition... CLIENT REQUESTED %d port\n", client->iq_port);
(receiver[client->receiver]).samples = 0;
if ( hiqsdr_start_asynch_input ( user_data_callback, &(receiver[client->receiver])) < 0 ) {
printf("start async input error\n" );
return INVALID_COMMAND;
} else {
printf("start async input: %s\n", "STARTED");
}
return OK;
} else if(strcmp(token,"bandscope")==0) {
token=strtok(NULL," \r\n");
if(token!=NULL) {
client->bs_port=atoi(token);
}
return OK;
} else {
// invalid command string
return INVALID_COMMAND;
}
} else {
// invalid command string
return INVALID_COMMAND;
}
} else if(strcmp(token,"dither")==0) {
// set frequency
token=strtok(NULL," \r\n");
if(token!=NULL) {
if (strcmp(token,"on")==0) {
return set_dither (client,true);
}
if (strcmp(token,"off")==0) {
return set_dither (client,false);
}
return INVALID_COMMAND;
} else {
return INVALID_COMMAND;
}
} else if(strcmp(token,"setattenuator")==0) {
// set attenuator
token=strtok(NULL," \r\n");
if(token!=NULL) {
long av=atol(token);
return set_attenuator (client,av);
} else {
return INVALID_COMMAND;
}
} else if(strcmp(token,"selectantenna")==0) {
// select antenna
token=strtok(NULL," \r\n");
if(token!=NULL) {
long antenna = atol(token);
return select_antenna (client,antenna);
} else {
return INVALID_COMMAND;
}
} else if(strcmp(token,"selectpresel")==0) {
// select preselector
token=strtok(NULL," \r\n");
if(token!=NULL) {
long presel = atol(token);
return select_preselector (client,presel);
} else {
return INVALID_COMMAND;
}
} else if(strcmp(token,"activatepreamp")==0) {
// activate preamplifier
token=strtok(NULL," \r\n");
if(token!=NULL) {
long preamp = atol(token);
return set_preamplifier (client,preamp);
} else {
return INVALID_COMMAND;
}
} else if(strcmp(token,"random")==0) {
// set frequency
token=strtok(NULL," \r\n");
if(token!=NULL) {
if (strcmp(token,"on")==0) {
return set_random (client,true);
}
if (strcmp(token,"off")==0) {
return set_random (client,false);
}
return INVALID_COMMAND;
} else {
return INVALID_COMMAND;
}
} else if(strcmp(token,"stop")==0) {
token=strtok(NULL," \r\n");
if(token!=NULL) {
if(strcmp(token,"iq")==0) {
token=strtok(NULL," \r\n");
if(token!=NULL) {
client->iq_port=-1;
}
// try to terminate audio thread
close ((receiver[client->receiver]).audio_socket);
printf("Quitting...\n");
hiqsdr_stop_asynch_input ();
return OK;
} else if(strcmp(token,"bandscope")==0) {
client->bs_port=-1;
} else {
// invalid command string
return INVALID_COMMAND;
}
} else {
// invalid command string
return INVALID_COMMAND;
}
} else if(strcmp(token,"quit")==0) {
return QUIT_ASAP;
} else if(strcmp(token,"hardware?")==0) {
return "OK HiQSDR";
} else if(strcmp(token,"getserial?")==0) {
// no serial number concept available in HiQSDR, returns instead the IP address
static char buf[50];
snprintf (buf, sizeof(buf), "OK %s", hiqsdr_get_ip_address());
return buf;
} else if(strcmp(token,"getpreselector?")==0) {
// get preselector
token=strtok(NULL," \r\n");
if(token!=NULL) {
long p=atol(token);
// preselector query
if (p >= 0 && p < 16) {
static char buf[50];
static char pd[BUFSIZ];
if (!hiqsdr_get_preselector_desc(p, pd)) {
snprintf (buf, sizeof(buf), "OK \"%s\"", pd);
return buf;
} else
return INVALID_COMMAND;
} else
return INVALID_COMMAND;
} else {
return INVALID_COMMAND;
}
} else if(strcmp(token,"getpreampstatus?")==0) {
// returns preamp status
static char buf[50];
snprintf (buf, sizeof(buf), "OK %d", hiqsdr_get_preamp ());
return buf;
} else {
// invalid command string
return INVALID_COMMAND;
}
} else {
// empty command string
return INVALID_COMMAND;
}
return INVALID_COMMAND;
}
/**
*******************************************************************************
* dce110_transform_bit_depth_reduction_program
*
* @brief
* Programs the DCP bit depth reduction registers (Clamp, Round/Truncate,
* Dither) for dce110
*
* @param depth : bit depth to set the clamp to (should match denorm)
*
* @return
* true if succeeds.
*******************************************************************************
*/
static bool program_bit_depth_reduction(
struct dce110_transform *xfm110,
enum dc_color_depth depth,
const struct bit_depth_reduction_params *bit_depth_params)
{
enum dcp_bit_depth_reduction_mode depth_reduction_mode;
enum dcp_spatial_dither_mode spatial_dither_mode;
bool frame_random_enable;
bool rgb_random_enable;
bool highpass_random_enable;
if (depth > COLOR_DEPTH_121212) {
ASSERT_CRITICAL(false); /* Invalid clamp bit depth */
return false;
}
if (bit_depth_params->flags.SPATIAL_DITHER_ENABLED) {
depth_reduction_mode = DCP_BIT_DEPTH_REDUCTION_MODE_DITHER;
frame_random_enable = true;
rgb_random_enable = true;
highpass_random_enable = true;
} else {
depth_reduction_mode = DCP_BIT_DEPTH_REDUCTION_MODE_DISABLED;
frame_random_enable = false;
rgb_random_enable = false;
highpass_random_enable = false;
}
spatial_dither_mode = DCP_SPATIAL_DITHER_MODE_A_AA_A;
if (!set_clamp(xfm110, depth)) {
/* Failure in set_clamp() */
ASSERT_CRITICAL(false);
return false;
}
switch (depth_reduction_mode) {
case DCP_BIT_DEPTH_REDUCTION_MODE_DITHER:
/* Spatial Dither: Set round/truncate to bypass (12bit),
* enable Dither (30bpp) */
set_round(xfm110,
DCP_OUT_TRUNC_ROUND_MODE_TRUNCATE,
DCP_OUT_TRUNC_ROUND_DEPTH_12BIT);
set_dither(xfm110, true, spatial_dither_mode,
DCP_SPATIAL_DITHER_DEPTH_30BPP, frame_random_enable,
rgb_random_enable, highpass_random_enable);
break;
case DCP_BIT_DEPTH_REDUCTION_MODE_ROUND:
/* Round: Enable round (10bit), disable Dither */
set_round(xfm110,
DCP_OUT_TRUNC_ROUND_MODE_ROUND,
DCP_OUT_TRUNC_ROUND_DEPTH_10BIT);
set_dither(xfm110, false, spatial_dither_mode,
DCP_SPATIAL_DITHER_DEPTH_30BPP, frame_random_enable,
rgb_random_enable, highpass_random_enable);
break;
case DCP_BIT_DEPTH_REDUCTION_MODE_TRUNCATE: /* Truncate */
/* Truncate: Enable truncate (10bit), disable Dither */
set_round(xfm110,
DCP_OUT_TRUNC_ROUND_MODE_TRUNCATE,
DCP_OUT_TRUNC_ROUND_DEPTH_10BIT);
set_dither(xfm110, false, spatial_dither_mode,
DCP_SPATIAL_DITHER_DEPTH_30BPP, frame_random_enable,
rgb_random_enable, highpass_random_enable);
break;
case DCP_BIT_DEPTH_REDUCTION_MODE_DISABLED: /* Disabled */
/* Truncate: Set round/truncate to bypass (12bit),
* disable Dither */
set_round(xfm110,
DCP_OUT_TRUNC_ROUND_MODE_TRUNCATE,
DCP_OUT_TRUNC_ROUND_DEPTH_12BIT);
set_dither(xfm110, false, spatial_dither_mode,
DCP_SPATIAL_DITHER_DEPTH_30BPP, frame_random_enable,
rgb_random_enable, highpass_random_enable);
break;
default:
/* Invalid DCP Depth reduction mode */
ASSERT_CRITICAL(false);
break;
}
return true;
}