/**
* Prints the name of the card input.
* @param aCard card to print name of.
*/
void printCard(struct card aCard) {
char *c = getCardName(aCard); //Get a char array with the name
printf("%s",c);
}
void printCards(int *pHand, int numCards, char *dtype) {
int i;
printf("Printing current %s:\n", dtype);
for (i = 0; i < numCards; i++) {
printf(" Pos [%d] Card [%d:%s]\n", i, pHand[i], getCardName(pHand[i]));
}
printf(" Cards in %s: %d\n\n", dtype, numCards);
}
void GuiGame::receiveCard(CardId id)
{
// TODO: show the card
displayMessage("You won the card " + getCardName(id) + ".");
}
bool LegacyAmixerControl::accessHW(bool receive, string &error)
{
CAutoLog autoLog(getConfigurableElement(), "ALSA", isDebugEnabled());
#ifdef SIMULATION
if (receive) {
memset(getBlackboardLocation(), 0, getSize());
}
log_info("%s ALSA Element Instance: %s\t\t(Control Element: %s)",
receive ? "Reading" : "Writing",
getConfigurableElement()->getPath().c_str(),
getControlName().c_str());
return true;
#endif
int ret;
// Mixer handle
snd_ctl_t *sndCtrl;
uint32_t value;
uint32_t index;
uint32_t elementCount;
snd_ctl_elem_id_t *id;
snd_ctl_elem_info_t *info;
snd_ctl_elem_value_t *control;
logControlInfo(receive);
// Check parameter type is ok (deferred error, no exceptions available :-()
if (!isTypeSupported()) {
error = "Parameter type not supported.";
return false;
}
int cardNumber = getCardNumber();
if (cardNumber < 0) {
error = "Card " + getCardName() + " not found. Error: " + strerror(cardNumber);
return false;
}
#ifdef ANDROID
if ((ret = snd_ctl_hw_open(&sndCtrl, NULL, cardNumber, 0)) < 0) {
error = snd_strerror(ret);
return false;
}
#else
// Create device name
ostringstream deviceName;
deviceName << "hw:" << cardNumber;
// Open sound control
if ((ret = snd_ctl_open(&sndCtrl, deviceName.str().c_str(), 0)) < 0) {
error = snd_strerror(ret);
return false;
}
#endif
// Allocate in stack
snd_ctl_elem_id_alloca(&id);
snd_ctl_elem_info_alloca(&info);
snd_ctl_elem_value_alloca(&control);
// Set interface
snd_ctl_elem_id_set_interface(id, SND_CTL_ELEM_IFACE_MIXER);
string controlName = getControlName();
// Set name or id
if (isdigit(controlName[0])) {
snd_ctl_elem_id_set_numid(id, asInteger(controlName));
} else {
snd_ctl_elem_id_set_name(id, controlName.c_str());
}
// Init info id
snd_ctl_elem_info_set_id(info, id);
// Get info
if ((ret = snd_ctl_elem_info(sndCtrl, info)) < 0) {
error = "ALSA: Unable to get element info " + controlName +
": " + snd_strerror(ret);
// Close sound control
snd_ctl_close(sndCtrl);
return false;
}
// Get type
snd_ctl_elem_type_t eType = snd_ctl_elem_info_get_type(info);
// Get element count
elementCount = snd_ctl_elem_info_get_count(info);
uint32_t scalarSize = getScalarSize();
// If size defined in the PFW different from alsa mixer control size, return an error
if (elementCount * scalarSize != getSize()) {
error = "ALSA: Control element count (" + asString(elementCount) +
") and configurable scalar element count (" +
asString(getSize() / scalarSize) + ") mismatch";
// Close sound control
snd_ctl_close(sndCtrl);
return false;
}
// Set value id
snd_ctl_elem_value_set_id(control, id);
if (receive) {
// Read element
if ((ret = snd_ctl_elem_read(sndCtrl, control)) < 0) {
error = "ALSA: Unable to read element " + controlName +
": " + snd_strerror(ret);
// Close sound control
snd_ctl_close(sndCtrl);
return false;
}
// Go through all indexes
for (index = 0; index < elementCount; index++) {
switch (eType) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
value = snd_ctl_elem_value_get_boolean(control, index);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
value = snd_ctl_elem_value_get_integer(control, index);
break;
case SND_CTL_ELEM_TYPE_INTEGER64:
value = snd_ctl_elem_value_get_integer64(control, index);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
value = snd_ctl_elem_value_get_enumerated(control, index);
break;
case SND_CTL_ELEM_TYPE_BYTES:
value = snd_ctl_elem_value_get_byte(control, index);
break;
default:
error = "ALSA: Unknown control element type while reading alsa element " +
controlName;
return false;
}
if (isDebugEnabled()) {
log_info("Reading alsa element %s, index %u with value %u",
controlName.c_str(), index, value);
}
// Write data to blackboard (beware this code is OK on Little Endian machines only)
toBlackboard(value);
}
} else {
// Go through all indexes
for (index = 0; index < elementCount; index++) {
// Read data from blackboard (beware this code is OK on Little Endian machines only)
value = fromBlackboard();
if (isDebugEnabled()) {
log_info("Writing alsa element %s, index %u with value %u",
controlName.c_str(), index, value);
}
switch (eType) {
case SND_CTL_ELEM_TYPE_BOOLEAN:
snd_ctl_elem_value_set_boolean(control, index, value);
break;
case SND_CTL_ELEM_TYPE_INTEGER:
snd_ctl_elem_value_set_integer(control, index, value);
break;
case SND_CTL_ELEM_TYPE_INTEGER64:
snd_ctl_elem_value_set_integer64(control, index, value);
break;
case SND_CTL_ELEM_TYPE_ENUMERATED:
snd_ctl_elem_value_set_enumerated(control, index, value);
break;
case SND_CTL_ELEM_TYPE_BYTES:
snd_ctl_elem_value_set_byte(control, index, value);
break;
default:
error = "ALSA: Unknown control element type while writing alsa element " +
controlName;
return false;
}
}
// Write element
if ((ret = snd_ctl_elem_write(sndCtrl, control)) < 0) {
error = "ALSA: Unable to write element " + controlName +
": " + snd_strerror(ret);
// Close sound control
snd_ctl_close(sndCtrl);
return false;
}
}
// Close sound control
snd_ctl_close(sndCtrl);
return true;
}
bool TinyAmixerControl::accessHW(bool receive, std::string &error)
{
CAutoLog autoLog(getConfigurableElement(), "ALSA", isDebugEnabled());
// Mixer handle
struct mixer *mixer;
// Mixer control handle
struct mixer_ctl *mixerControl;
uint32_t elementCount;
std::string controlName = getControlName();
// Debug conditionnaly enabled in XML
logControlInfo(receive);
// Check parameter type is ok (deferred error, no exceptions available :-()
if (!isTypeSupported()) {
error = "Parameter type not supported.";
return false;
}
// Check card number
int32_t cardIndex = getCardNumber();
if (cardIndex < 0) {
error = "Card " + getCardName() + " not found. Error: " + strerror(-cardIndex);
return false;
}
// Open alsa mixer
// getMixerHandle is non-const; we need to forcefully remove the constness
// then, we need to cast the generic subsystem into a TinyAlsaSubsystem.
mixer = static_cast<TinyAlsaSubsystem *>(
const_cast<CSubsystem *>(getSubsystem()))->getMixerHandle(cardIndex);
if (!mixer) {
error = "Failed to open mixer for card: " + getCardName();
return false;
}
// Get control handle
if (isdigit(controlName[0])) {
mixerControl = mixer_get_ctl(mixer, asInteger(controlName));
} else {
mixerControl = mixer_get_ctl_by_name(mixer, controlName.c_str());
}
// Check control has been found
if (!mixerControl) {
error = "Failed to open mixer control: " + controlName;
return false;
}
// Get element count
elementCount = getNumValues(mixerControl);
uint32_t scalarSize = getScalarSize();
// Check available size
if (elementCount * scalarSize != getSize()) {
error = "ALSA: Control element count (" + asString(elementCount) +
") and configurable scalar element count (" +
asString(getSize() / scalarSize) + ") mismatch";
return false;
}
// Read/Write element
bool success;
if (receive) {
success = readControl(mixerControl, elementCount, error);
} else {
success = writeControl(mixerControl, elementCount, error);
}
return success;
}
