int
err(char *message)
{
snprintf(msg, MSG_SIZE, "%s\n%s", message, strerror(errno));
show_dialog_message(msg);
return -1;
}
static void mmrerror( mmr_context_t *ctxt, const char *errmsg ) {
const mmr_error_info_t *err = mmr_error_info( ctxt );
unsigned errcode = err->error_code;
const char *name;
if ( errcode >= NERRS || ( name = errlist[ errcode ] ) == NULL ) {
name = "bad error code";
}
snprintf(msg, MSG_SIZE, "%s: error %d (%s)\n", errmsg, errcode, name );
show_dialog_message(msg);
}
/**
* Print the Locale data.
*
* @param language the locale language value.
* @param country the locale country value
*/
void
display_locale(const char *language, const char *country)
{
/*
* Print the locale values
*/
if(language == NULL) {
language = "None";
}
if(country == NULL) {
country = "None";
}
snprintf(msg, MSG_SIZE, "Language: %s\n Country: %s\n", language, country);
show_dialog_message(msg);
}
/**
* Displays geolocation data in the main dialog.
*/
static void
display_geolocation_data(int count,
double latitude, double longitude, double accuracy,
double altitude, bool altitude_valid,
double altitude_accuracy, bool altitude_accuracy_valid,
double heading, bool heading_valid,
double speed, bool speed_valid,
int num_satellites_used, bool num_satellites_valid)
{
char altitude_buf[128];
char altitude_accuracy_buf[128];
char heading_buf[128];
char speed_buf[128];
char num_satellites_used_buf[128];
snprintf(msg, MSG_SIZE,
"Geolocation report #%d\n"
"\tlatitude: % 13.8f degrees\n"
"\tlongitude: % 13.8f degrees\n"
"\taccuracy: % 7.3f m\n"
"\t%s\n"
"\t%s\n"
"\t%s\n"
"\t%s\n"
"\t%s\n",
count,
latitude, longitude, accuracy,
format_double_data(altitude_buf, sizeof altitude_buf, "altitude", "m",
altitude, altitude_valid),
format_double_data(altitude_accuracy_buf, sizeof altitude_accuracy_buf, "altitude accuracy", "m",
altitude_accuracy, altitude_accuracy_valid),
format_double_data(heading_buf, sizeof heading_buf, "heading", get_bearing(heading),
heading, heading_valid),
/* Speed is reported in m/s. To convert to km/h, use the formula:
* 1 m/s = 60*60/1000 km/h = 3.6 km/h
*/
format_double_data(speed_buf, sizeof speed_buf, "speed", "km/h",
speed*3.6, speed_valid),
format_int_data(num_satellites_used_buf, sizeof num_satellites_used_buf, "number of satellites used", "",
num_satellites_used, num_satellites_valid)
);
show_dialog_message(msg);
}
/**
* A sample application that demonstrates the BlackBerry(R) 10 Native SDK APIs
* for geolocation.
*/
int
main(int argc, char *argv[])
{
bool exit_application = false;
/*
* Before we can listen for events from the BlackBerry(R) 10 OS platform
* services, we need to initialize the BPS infrastructure
*/
bps_initialize();
/*
* Initialize the screen so that the window group Id is properly set, to allow
* the dialogs to be displayed.
*/
if (setup_screen() != EXIT_SUCCESS) {
fprintf(stderr, "Unable to initialize screen.");
exit(-1);
}
/*
* Once the BPS infrastructure has been initialized we can register for
* events from the various BlackBerry(R) 10 OS platform services. The
* Navigator service manages and delivers application life cycle and
* visibility events.
*
* For this sample, we request Navigator events so that we can track when
* the system is terminating the application (NAVIGATOR_EXIT event).
*
* We request dialog events so we can be notified when the dialog service
* responds to our requests/queries.
*
* We request geolocation events so that we can be notified of our current
* geolocation.
*/
if (BPS_SUCCESS != navigator_request_events(0)) {
fprintf(stderr, "Error requesting navigator events: %s", strerror(errno));
exit(-1);
}
if (BPS_SUCCESS != dialog_request_events(0)) {
fprintf(stderr, "Error requesting dialog events: %s", strerror(errno));
exit(-1);
}
if (BPS_SUCCESS != geolocation_request_events(0)) {
fprintf(stderr, "Error requesting geolocation events: %s", strerror(errno));
exit(-1);
}
/*
* Get geolocation events once a second, which is the most often that they
* are capable of being reported.
*/
geolocation_set_period(1);
/*
* Create and display the dialog that will show the geolocation data.
*/
create_dialog();
show_dialog_message("Geolocation getting first fix");
/*
* Process Geolocation, Dialog and Navigator events until we receive a
* NAVIGATOR_EXIT event.
*/
while (!exit_application) {
/*
* Using a negative timeout (-1) in the call to bps_get_event(...)
* ensures that we don't busy wait by blocking until an event is
* available.
*/
bps_event_t *event = NULL;
bps_get_event(&event, -1);
if (event) {
/*
* If it is a geolocation event, determine the response code and
* handle the event accordingly.
*/
if (bps_event_get_domain(event) == geolocation_get_domain()) {
handle_geolocation_response(event);
}
/*
* If it is a dialog event, determine the response code and handle
* the event accordingly.
*/
else if (bps_event_get_domain(event) == dialog_get_domain()) {
/* We have no buttons so we don't need to do anything. */
;
}
/*
* If it is a NAVIGATOR_EXIT event then set the exit_application
* flag so the application will stop processing events, clean up and
* exit.
*/
else if (bps_event_get_domain(event) == navigator_get_domain()) {
exit_application = handle_navigator_event(event);
}
}
}
/*
* Stop geolocation events.
*/
geolocation_stop_events(0);
/*
* Destroy the dialog, if it exists.
*/
destroy_dialog();
/*
* Clean up the bps infrastructure and exit
*/
bps_shutdown();
cleanup_screen();
return 0;
}
static int mmr_sigevent_handler(void *p) {
int rc;
mmr_context_t *ctxt = (mmr_context_t *)p;
if (NULL == p) {
show_dialog_message("mmr context error\n");
return EXIT_FAILURE;
}
const mmr_event_t *mmr_event = mmr_event_get( ctxt );
if (NULL == mmr_event) {
show_dialog_message("mmr event error\n");
return EXIT_FAILURE;
}
static mmr_state_t last_state = MMR_EVENT_NONE;
static int last_speed = 0;
if ((last_state != mmr_event->state) || (last_speed != mmr_event->speed)) {
last_state = mmr_event->state;
last_speed = mmr_event->speed;
switch (mmr_event->state) {
case MMR_STATE_PLAYING:
if (0 == mmr_event->speed)
show_dialog_message("MMRenderer Status: Pausing\n");
else
show_dialog_message("MMRenderer Status: Playing\n");
break;
case MMR_STATE_STOPPED:
show_dialog_message("MMRenderer Status: Stopped\n");
break;
case MMR_STATE_IDLE:
show_dialog_message("MMRenderer Status: Idle\n");
break;
case MMR_STATE_DESTROYED:
show_dialog_message("MMRenderer Status: Destroyed\n");
break;
default:
show_dialog_message("MMRenderer Status: Unknown\n");
break;
}
}
if ((MMR_EVENT_ERROR == mmr_event->type) && (MMR_STATE_STOPPED == mmr_event->state)){
/*
* We have reached the end. Do not rearm. Return failure to signal we
* don't want to be recalled.
*/
show_dialog_message("MMRenderer Status: No more data\n");
return EXIT_FAILURE;
}
rc = mmr_event_arm(ctxt, &mmr_sigevent);
if ( rc > 0) {
//event is already available, manually arm
MsgDeliverEvent(0, &mmr_sigevent);
} else if ( rc < 0 ) {
show_dialog_message("mmr_event_arm() error\n");
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
int main( int argc, char **argv ) {
const char *mmrname = NULL;
const char *ctxtname = "testplayer";
const char *audioout = NULL;
const char *inputtype = "track";
char cwd[PATH_MAX];
char inputurl[PATH_MAX];
int rc;
int final_return_code = EXIT_FAILURE;
int exit_application = 0;
mmr_connection_t *connection = NULL;
mmr_context_t *ctxt = NULL;
/*
* Before we can listen for events from the BlackBerry(R) 10 OS platform
* services, we need to initialize the BPS infrastructure
*/
bps_initialize();
if (setup_screen() != EXIT_SUCCESS) {
printf("Unable to set up the screen. Exiting.");
return 0;
}
/*
* Once the BPS infrastructure has been initialized we can register for
* events from the various BlackBerry(R) 10 OS platform services. The
* Navigator service manages and delivers application life cycle and
* visibility events.
* For this sample, we request Navigator events so we can track when
* the system is terminating the application (NAVIGATOR_EXIT event).
* This allows us to clean up application resources.
*/
navigator_request_events(0);
dialog_request_events(0);
/*
* Create and display the dialog.
*/
create_dialog();
getcwd(cwd, PATH_MAX);
rc = snprintf(inputurl, PATH_MAX, "file://%s%s", cwd, WAV_RELATIVE_PATH);
if (rc > PATH_MAX - 1)
{
show_dialog_message("File name and path too long");
goto fail;
}
mode_t mode = S_IRUSR | S_IXUSR;
int audio_oid; // output ID
strm_dict_t *aoparams = NULL; // output parameters
audioout = DEFAULT_AUDIO_OUT;
if ( ( connection = mmr_connect( mmrname ) ) == NULL ) {
snprintf(msg, MSG_SIZE, "mmr_connect: %s", strerror(errno));
show_dialog_message(msg);
} else if ( ( ctxt = mmr_context_create( connection, ctxtname, 0, mode ) ) == NULL ) {
snprintf(msg, MSG_SIZE, "%s: %s", ctxtname, strerror(errno));
show_dialog_message(msg);
} else if ( audioout && ( audio_oid = mmr_output_attach( ctxt, audioout, "audio" ) ) < 0 ) {
mmrerror( ctxt, audioout );
} else if ( aoparams && mmr_output_parameters( ctxt, audio_oid, aoparams ) ) {
mmrerror( ctxt, "output parameters (audio)" );
} else if ( mmr_input_attach( ctxt, inputurl, inputtype ) < 0 ) {
mmrerror( ctxt, inputurl );
} else if ( mmr_play( ctxt ) < 0 ) {
mmrerror( ctxt, "mmr_play" );
} else if (BPS_SUCCESS != bps_add_sigevent_handler( &mmr_sigevent, mmr_sigevent_handler, ctxt ) ) {
snprintf( msg, MSG_SIZE, "bps_add_sigevent_handler() failure %s", strerror( errno ) );
show_dialog_message( msg );
} else if ( drain_and_arm_mmr_events ( ctxt ) ) {
snprintf( msg, MSG_SIZE, "drain_and_arm_mmr_events() failure %s", strerror( errno ) );
show_dialog_message( msg );
} else {
show_dialog_message( "Playing Audio\n" );
final_return_code = EXIT_SUCCESS;
}
fail:
/*
* Process Navigator events until we receive a NAVIGATOR_EXIT event.
*/
while (!exit_application) {
/*
* Using a negative timeout (-1) in the call to bps_get_event(...)
* ensures that we don't busy wait by blocking until an event is
* available.
*/
bps_event_t *event = NULL;
bps_get_event(&event, -1);
if (event) {
/*
* If it is a NAVIGATOR_EXIT event then set the exit_application
* flag so the application will stop processing events, clean up
* and exit
*/
if (bps_event_get_domain(event) == navigator_get_domain()) {
if (NAVIGATOR_EXIT == bps_event_get_code(event)) {
if (final_return_code == EXIT_SUCCESS) {
mmr_stop( ctxt ); // Not really necessary -- mmr_input_detach() would take care of this
mmr_input_detach( ctxt ); // Not really necessary -- mmr_context_destroy() would take care of this
mmr_context_destroy( ctxt ); // Not really necessary -- mmr_disconnect() would take care of this
mmr_disconnect( connection ); // Not really necessary -- exiting would take care of this
}
exit_application = 1;
}
} else if (bps_event_get_domain(event) == dialog_get_domain()) {
if (DIALOG_RESPONSE == bps_event_get_code(event)) {
handle_dialog_response_events(event);
}
}
}
}
/*
* Destroy the dialog, if it exists and cleanup screen resources.
*/
destroy_dialog();
cleanup_screen();
/*
* Clean up the BPS infrastructure and exit
*/
bps_shutdown();
return final_return_code;
}
static void handle_dialog_response_events(bps_event_t *event) {
if (NULL == event) {
return;
}
if (NULL == dialog_event_get_selected_context(event)) {
return ;
}
float volume;
int rc;
if (0 == strcmp("query", dialog_event_get_selected_context(event))) {
rc = audiomixer_get_output_level(AUDIOMIXER_OUTPUT_SPEAKER, &volume);
if (BPS_SUCCESS == rc) {
snprintf(msg, MSG_SIZE, "Successfully queried the output level.\ncurrent volume is %f\n", volume);
show_dialog_message(msg);
} else {
show_dialog_message("Failed to query the output level.\n");
}
} else if (0 == strcmp("half", dialog_event_get_selected_context(event))) {
rc = audiomixer_get_output_level(AUDIOMIXER_OUTPUT_SPEAKER, &volume);
if (BPS_SUCCESS != rc) {
show_dialog_message("Failed to query the output level.\n");
return;
}
volume /= 2.0;
rc = audiomixer_set_output_level(AUDIOMIXER_OUTPUT_SPEAKER, volume);
if (BPS_SUCCESS == rc) {
show_dialog_message("Successfully decreased the volume by half.\n");
} else {
show_dialog_message("Failed to decrease the volume.\n");
}
} else if (0 == strcmp("double", dialog_event_get_selected_context(event))) {
rc = audiomixer_get_output_level(AUDIOMIXER_OUTPUT_SPEAKER, &volume);
if (BPS_SUCCESS != rc) {
show_dialog_message("Failed to query the output level.\n");
return;
}
if (volume == 0.0) {
volume = 2.0;
} else {
volume *= 2.0;
}
rc = audiomixer_set_output_level(AUDIOMIXER_OUTPUT_SPEAKER, volume);
if (BPS_SUCCESS == rc) {
show_dialog_message("Successfully doubled the volume.\n");
} else {
show_dialog_message("Failed to double the volume.\n");
}
} else if (0 == strcmp("toggle", dialog_event_get_selected_context(event))) {
rc = audiomixer_toggle_output_mute(AUDIOMIXER_OUTPUT_SPEAKER);
if (BPS_SUCCESS == rc) {
show_dialog_message("Successfully toggled the mute setting.\n");
} else {
show_dialog_message("Failed to toggle the mute setting.\n");
}
}
}
int
main(int argc, char **argv)
{
FILE *file;
int samples;
char *sample_buffer;
int rtn, final_return_code = -1, exit_application = 0;
int bsize, bytes_read, total_written = 0;
fd_set rfds, wfds;
char input_file[PATH_MAX];
char cwd[PATH_MAX];
/*
* Before we can listen for events from the BlackBerry Tablet OS platform
* services, we need to initialize the BPS infrastructure
*/
bps_initialize();
if (setup_screen() != EXIT_SUCCESS) {
printf("Unable to set up the screen. Exiting.");
exit(-1);
}
/*
* Once the BPS infrastructure has been initialized we can register for
* events from the various BlackBerry Tablet OS platform services. The
* Navigator service manages and delivers application life cycle and
* visibility events.
*
* For this sample, we request Navigator events so we can track when
* the system is terminating the application (NAVIGATOR_EXIT event).
* This allows us to clean up application resources.
*
* We request Audio Device events because we want to make sure that
* we properly handle changes in audio output.
*
* We request dialog events to properly initialize the dialog
* subsystem in order to display status and error messages.
*/
if (BPS_SUCCESS != navigator_request_events(0)) {
fprintf(stderr, "Error requesting navigator events: %s", strerror(errno));
exit(-1);
}
if (BPS_SUCCESS != dialog_request_events(0)) {
fprintf(stderr, "Error requesting dialog events: %s", strerror(errno));
exit(-1);
}
if (BPS_SUCCESS != audiodevice_request_events(0)) {
fprintf(stderr, "Error requesting audio device events: %s", strerror(errno));
exit(-1);
}
/*
* Create and display the dialog.
*/
create_dialog();
/*
* Open and check the input file.
*/
getcwd(cwd, PATH_MAX);
rtn = snprintf(input_file, PATH_MAX, "%s/%s", cwd, WAV_RELATIVE_PATH);
if (rtn > PATH_MAX - 1) {
err("File name and path too long");
goto fail1;
}
if ((file = fopen(input_file, "r")) == 0) {
err("File open failed");
goto fail1;
}
if (check_hdr(file) == -1) {
err("check_hdr failed");
goto fail2;
}
/*
* Parse the headers in the wav file to figure out what kind of data we
* are dealing with in the file.
*/
samples = find_tag(file, "fmt ");
fread(&wav_header, sizeof(wav_header), 1, file);
fseek(file,(samples - sizeof(wave_hdr)), SEEK_CUR);
sample_rate = ENDIAN_LE32(wav_header.samples_per_sec);
sample_channels = ENDIAN_LE16(wav_header.channels);
sample_bits = ENDIAN_LE16(wav_header.bits_per_sample);
snprintf(msg, MSG_SIZE, "SampleRate = %d, channels = %d, SampleBits = %d\n", sample_rate, sample_channels,
sample_bits);
show_dialog_message(msg);
if (setup_snd(NULL)) {
goto fail2;
}
bsize = setup.buf.block.frag_size;
samples = find_tag(file, "data");
sample_buffer = malloc(bsize);
if (!sample_buffer) {
goto fail3;
}
FD_ZERO(&rfds);
FD_ZERO(&wfds);
bytes_read = 1;
while (total_written < samples && bytes_read > 0 ) {
bps_event_t *event = NULL;
while (BPS_SUCCESS == bps_get_event(&event, 0) && event) {
/*
* If it is a NAVIGATOR_EXIT event then we are done so stop
* processing events, clean up and exit
*/
if (bps_event_get_domain(event) == navigator_get_domain()) {
if (NAVIGATOR_EXIT == bps_event_get_code(event)) {
exit_application = 1;
goto success;
}
}
if (bps_event_get_domain(event) == audiodevice_get_domain()) {
/*
* If it is a audio device event then it means a new audio device
* has been enabled and a switch is required. We close the old,
* open the new audio device using the path and get the card number so
* that we can close and re-open the mixer with the new card
* number.
*/
const char * audiodevice_path = audiodevice_event_get_path(event);
if (NULL == audiodevice_path) {
snprintf(msg, MSG_SIZE, "audiodevice_event_get_path failed: %s\n", snd_strerror(rtn));
show_dialog_message(msg);
goto fail5;
}
if ((rtn = snd_mixer_close(mixer_handle)) < 0) {
snprintf(msg, MSG_SIZE, "snd_mixer_close failed: %s\n", snd_strerror(rtn));
show_dialog_message(msg);
goto fail4;
}
if ((rtn = snd_pcm_close(pcm_handle)) < 0) {
snprintf(msg, MSG_SIZE, "snd_pcm_close failed: %s\n", snd_strerror(rtn));
show_dialog_message(msg);
goto fail3;
}
if (setup_snd(audiodevice_path)) {
/*
* setup_snd() closes pcm and mixer handles in the case of error so we
* skip clean up of the handles in the case of failure.
*/
goto fail3;
}
}
}
if (tcgetpgrp(0) == getpid())
FD_SET(STDIN_FILENO, &rfds);
FD_SET(snd_mixer_file_descriptor(mixer_handle), &rfds);
FD_SET(snd_pcm_file_descriptor(pcm_handle, SND_PCM_CHANNEL_PLAYBACK), &wfds);
rtn = max(snd_mixer_file_descriptor(mixer_handle),
snd_pcm_file_descriptor(pcm_handle, SND_PCM_CHANNEL_PLAYBACK));
if (select(rtn + 1, &rfds, &wfds, NULL, NULL) == -1) {
err("select");
goto fail5;
}
if (FD_ISSET(snd_pcm_file_descriptor(pcm_handle, SND_PCM_CHANNEL_PLAYBACK), &wfds)) {
snd_pcm_channel_status_t status;
int written = 0;
if ((bytes_read = fread(sample_buffer, 1, min(samples - total_written, bsize), file)) <= 0)
continue;
written = snd_pcm_plugin_write(pcm_handle, sample_buffer, bytes_read);
if (written < bytes_read) {
memset(&status, 0, sizeof(status));
status.channel = SND_PCM_CHANNEL_PLAYBACK;
if (snd_pcm_plugin_status(pcm_handle, &status) < 0) {
show_dialog_message("underrun: playback channel status error\n");
goto fail5;
}
if (status.status == SND_PCM_STATUS_READY ||
status.status == SND_PCM_STATUS_UNDERRUN) {
if (snd_pcm_plugin_prepare(pcm_handle, SND_PCM_CHANNEL_PLAYBACK) < 0) {
show_dialog_message("underrun: playback channel prepare error\n");
goto fail5;
}
}
if (written < 0)
written = 0;
written += snd_pcm_plugin_write(pcm_handle, sample_buffer + written, bytes_read - written);
}
total_written += written;
}
}
success:
bytes_read = snd_pcm_plugin_flush(pcm_handle, SND_PCM_CHANNEL_PLAYBACK);
final_return_code = 0;
/*
* there are return codes to these close calls, but we would do the same
* thing regardless of error or success so we do not check the return codes.
*/
fail5:
snd_mixer_close(mixer_handle);
fail4:
snd_pcm_close(pcm_handle);
fail3:
free(sample_buffer);
sample_buffer = NULL;
fail2:
fclose(file);
fail1:
while (!exit_application) {
/*
* Something went wrong so there is probably an error message and
* we don't want to exit right away because we want the user to see
* the message in the dialog.
*
* Using a negative timeout (-1) in the call to bps_get_event(...)
* ensures that we don't busy wait by blocking until an event is
* available.
*/
bps_event_t *event = NULL;
bps_get_event(&event, -1);
if (event) {
/*
* If it is a NAVIGATOR_EXIT event then we are done so stop
* processing events, clean up and exit
*/
if (bps_event_get_domain(event) == navigator_get_domain()) {
if (NAVIGATOR_EXIT == bps_event_get_code(event)) {
exit_application = 1;
}
}
}
}
/*
* Destroy the dialog, if it exists and cleanup screen resources.
*/
destroy_dialog();
cleanup_screen();
bps_shutdown();
return final_return_code;
}
/*
* General setup of the libasound audio mixer and pcm components.
* Some of the settings are based on the format of the wav data.
*/
int
setup_snd(const char * name)
{
int fragsize = -1;
int num_frags = -1;
int rtn;
char *dev_name;
if (NULL == name) {
dev_name = "pcmPreferred";
} else {
dev_name = (char *) name;
}
if ((rtn = snd_pcm_open_name(&pcm_handle, dev_name, SND_PCM_OPEN_PLAYBACK)) < 0) {
snprintf(msg, MSG_SIZE, "snd_pcm_open_name failed: %s\n", snd_strerror(rtn));
show_dialog_message(msg);
return FAILURE;
}
if ((rtn = snd_pcm_info(pcm_handle, &info)) < 0) {
snprintf(msg, MSG_SIZE, "snd_pcm_info failed: %s\n", snd_strerror(rtn));
goto setup_failure;
}
card = info.card;
/* disabling mmap is not actually required in this example but it is included to
* demonstrate how it is used when it is required.
*/
if ((rtn = snd_pcm_plugin_set_disable(pcm_handle, PLUGIN_DISABLE_MMAP)) < 0) {
snprintf(msg, MSG_SIZE, "snd_pcm_plugin_set_disable failed: %s\n", snd_strerror(rtn));
goto setup_failure;
}
memset(&pi, 0, sizeof(pi));
pi.channel = SND_PCM_CHANNEL_PLAYBACK;
if ((rtn = snd_pcm_plugin_info(pcm_handle, &pi)) < 0) {
snprintf(msg, MSG_SIZE, "snd_pcm_plugin_info failed: %s\n", snd_strerror(rtn));
goto setup_failure;
}
memset(&pp, 0, sizeof(pp));
pp.mode = SND_PCM_MODE_BLOCK;
pp.channel = SND_PCM_CHANNEL_PLAYBACK;
pp.start_mode = SND_PCM_START_FULL;
pp.stop_mode = SND_PCM_STOP_STOP;
pp.buf.block.frag_size = pi.max_fragment_size;
if (fragsize != -1) {
pp.buf.block.frag_size = fragsize;
}
pp.buf.block.frags_max = num_frags;
pp.buf.block.frags_min = 1;
pp.format.interleave = 1;
pp.format.rate = sample_rate;
pp.format.voices = sample_channels;
if (ENDIAN_LE16(wav_header.format_tag) == 6)
pp.format.format = SND_PCM_SFMT_A_LAW;
else if (ENDIAN_LE16(wav_header.format_tag) == 7)
pp.format.format = SND_PCM_SFMT_MU_LAW;
else if (sample_bits == 8)
pp.format.format = SND_PCM_SFMT_U8;
else if (sample_bits == 24)
pp.format.format = SND_PCM_SFMT_S24;
else
pp.format.format = SND_PCM_SFMT_S16_LE;
strcpy(pp.sw_mixer_subchn_name, "Wave playback channel");
if ((rtn = snd_pcm_plugin_params(pcm_handle, &pp)) < 0) {
snprintf(msg, MSG_SIZE, "snd_pcm_plugin_params failed: %s\n", snd_strerror(rtn));
goto setup_failure;
}
if ((rtn = snd_pcm_plugin_prepare(pcm_handle, SND_PCM_CHANNEL_PLAYBACK)) < 0) {
snprintf(msg, MSG_SIZE, "snd_pcm_plugin_prepare failed: %s\n", snd_strerror(rtn));
goto setup_failure;
}
memset(&setup, 0, sizeof(setup));
memset(&group, 0, sizeof(group));
setup.channel = SND_PCM_CHANNEL_PLAYBACK;
setup.mixer_gid = &group.gid;
if ((rtn = snd_pcm_plugin_setup(pcm_handle, &setup)) < 0) {
snprintf(msg, MSG_SIZE, "snd_pcm_plugin_setup failed: %s\n", snd_strerror(rtn));
goto setup_failure;
}
if (group.gid.name[0] == 0) {
snprintf(msg, MSG_SIZE, "Mixer Pcm Group [%s] Not Set \n", group.gid.name);
goto setup_failure;
}
if ((rtn = snd_mixer_open(&mixer_handle, card, setup.mixer_device)) < 0) {
snprintf(msg, MSG_SIZE, "snd_mixer_open failed: %s\n", snd_strerror(rtn));
goto setup_failure;
}
char tmp[MSG_SIZE];
snprintf(msg, MSG_SIZE, "Format %s \n", snd_pcm_get_format_name(setup.format.format));
snprintf(tmp, MSG_SIZE, "Frag Size %d \n", setup.buf.block.frag_size);
strlcat(msg, tmp, MSG_SIZE);
snprintf(tmp, MSG_SIZE, "Total Frags %d \n", setup.buf.block.frags);
strlcat(msg, tmp, MSG_SIZE);
snprintf(tmp, MSG_SIZE, "Rate %d \n", setup.format.rate);
strlcat(msg, tmp, MSG_SIZE);
snprintf(tmp, MSG_SIZE, "Voices %d \n", setup.format.voices);
strlcat(msg, tmp, MSG_SIZE);
snprintf(tmp, MSG_SIZE, "Mixer Pcm Group [%s]\n", group.gid.name);
strlcat(msg, tmp, MSG_SIZE);
show_dialog_message(msg);
return SUCCESS;
setup_failure:
show_dialog_message(msg);
snd_pcm_close(pcm_handle);
return FAILURE;
}
