/* -------------------------------------
* gap_sdl_memory_buffer
* -------------------------------------
*/
int
gap_sdl_memory_buffer(char *buffer, long buffer_len, GapSdlErrFunc erf)
{
int rc = 1;
int ii = 0;
AudioPlaybackThreadUserData *usrPtr;
usrPtr = getUsrPtr();
if (usrPtr != NULL)
{
stop_audio();
usrPtr->sounds[ii].data = buffer; /* point to memory provided by the caller */
usrPtr->sounds[ii].dpos = 0;
usrPtr->sounds[ii].dlen = buffer_len;
if (usrPtr->sounds[ii].fpWav != NULL)
{
fclose(usrPtr->sounds[ii].fpWav);
usrPtr->sounds[ii].fpWav = NULL;
}
rc = 0; /* OK */
}
if ( (rc != 0) && (erf != NULL) )
{
call_errfunc(erf, "memory_buffer: %ld len: %ld not accepted", (long)&buffer, buffer_len);
}
return (rc);
} /* end gap_sdl_memory_buffer */
int read(unsigned char* data, int num_samples)
{
MutexHolder mh(m_mutex);
// m_logger(2, "Read request...");
if (m_outputProcState == kRunning &&
m_buffer.size() < num_samples * m_input_format.mBytesPerFrame)
{
stop_audio();
return 0;
}
const UInt32 inputDataSizeBytes = my_min(num_samples * m_input_format.mBytesPerFrame,
m_buffer.size());
std::vector<unsigned char> input_data(m_buffer.begin(),
m_buffer.begin() + inputDataSizeBytes);
m_buffer.erase(m_buffer.begin(),
m_buffer.begin() + inputDataSizeBytes);
int outputDataSizeBytes = num_samples*m_format.mBytesPerFrame;
OSStatus err;
err = m_converter->convert(&input_data[0],
input_data.size(),
data,
outputDataSizeBytes);
if (err != kAudioHardwareNoError)
{
char buf[1024] = {0};
sprintf(buf,
"Conversion failed, num_samples=%i, inputDataSize = %i\n"
"buffer_size = %i, outputDataSize = %i (err=0x%lX (= %i))",
num_samples,
inputDataSizeBytes,
m_buffer.size(),
outputDataSizeBytes,
err, err);
m_logger(0, buf);
return 0;
}
/*
char buf[512] = {0};
sprintf(buf, "Converted %i bytes to %i bytes (num_samples=%i)",
inputDataSizeBytes, outputDataSizeBytes, num_samples);
m_logger(2, buf);*/
return outputDataSizeBytes / m_format.mBytesPerFrame;
}
void start_audio(const struct params * prm)
{
gettimeofday(&last_data_packet_time,NULL);
if (audio_started && audio_params && prm && (memcmp(audio_params,prm,sizeof(struct params))==0))
return;
if (audio_started)
stop_audio();
audio_started = 1;
audio_params = malloc(sizeof(struct params));
memcpy(audio_params,prm,sizeof(struct params));
keep_going = 1;
pthread_create(&audio,NULL,(void * (*)(void*))audio_thread,(void*)audio_params);
}
JNIEXPORT void JNICALL Java_cn_edu_hust_buildingtalkback_jni_NativeInterface_stopAudio(
JNIEnv *env, jclass clazz)
{
LOG_FUNC();
stop_audio();
}
static status_t
cd_ioctl(void* cookie, uint32 op, void* buffer, size_t length)
{
cd_handle* handle = (cd_handle*)cookie;
cd_driver_info *info = handle->info;
TRACE("ioctl(op = %lu)\n", op);
switch (op) {
case B_GET_DEVICE_SIZE:
{
status_t status = update_capacity(info);
if (status != B_OK)
return status;
size_t size = info->capacity * info->block_size;
return user_memcpy(buffer, &size, sizeof(size_t));
}
case B_GET_GEOMETRY:
{
if (buffer == NULL /*|| length != sizeof(device_geometry)*/)
return B_BAD_VALUE;
device_geometry geometry;
status_t status = get_geometry(handle, &geometry);
if (status != B_OK)
return status;
return user_memcpy(buffer, &geometry, sizeof(device_geometry));
}
case B_GET_ICON_NAME:
return user_strlcpy((char*)buffer, "devices/drive-optical",
B_FILE_NAME_LENGTH);
case B_GET_VECTOR_ICON:
{
device_icon iconData;
if (length != sizeof(device_icon))
return B_BAD_VALUE;
if (user_memcpy(&iconData, buffer, sizeof(device_icon)) != B_OK)
return B_BAD_ADDRESS;
if (iconData.icon_size >= (int32)sizeof(kCDIcon)) {
if (user_memcpy(iconData.icon_data, kCDIcon,
sizeof(kCDIcon)) != B_OK)
return B_BAD_ADDRESS;
}
iconData.icon_size = sizeof(kCDIcon);
return user_memcpy(buffer, &iconData, sizeof(device_icon));
}
case B_SCSI_GET_TOC:
// TODO: we pass a user buffer here!
return get_toc(info, (scsi_toc *)buffer);
case B_EJECT_DEVICE:
case B_SCSI_EJECT:
return load_eject(info, false);
case B_LOAD_MEDIA:
return load_eject(info, true);
case B_SCSI_GET_POSITION:
{
if (buffer == NULL)
return B_BAD_VALUE;
scsi_position position;
status_t status = get_position(info, &position);
if (status != B_OK)
return status;
return user_memcpy(buffer, &position, sizeof(scsi_position));
}
case B_SCSI_GET_VOLUME:
// TODO: we pass a user buffer here!
return get_set_volume(info, (scsi_volume *)buffer, false);
case B_SCSI_SET_VOLUME:
// TODO: we pass a user buffer here!
return get_set_volume(info, (scsi_volume *)buffer, true);
case B_SCSI_PLAY_TRACK:
{
scsi_play_track track;
if (user_memcpy(&track, buffer, sizeof(scsi_play_track)) != B_OK)
return B_BAD_ADDRESS;
return play_track_index(info, &track);
}
case B_SCSI_PLAY_POSITION:
{
scsi_play_position position;
if (user_memcpy(&position, buffer, sizeof(scsi_play_position))
!= B_OK)
return B_BAD_ADDRESS;
return play_msf(info, &position);
}
case B_SCSI_STOP_AUDIO:
return stop_audio(info);
case B_SCSI_PAUSE_AUDIO:
return pause_resume(info, false);
case B_SCSI_RESUME_AUDIO:
return pause_resume(info, true);
case B_SCSI_SCAN:
{
scsi_scan scanBuffer;
if (user_memcpy(&scanBuffer, buffer, sizeof(scsi_scan)) != B_OK)
return B_BAD_ADDRESS;
return scan(info, &scanBuffer);
}
case B_SCSI_READ_CD:
// TODO: we pass a user buffer here!
return read_cd(info, (scsi_read_cd *)buffer);
default:
return sSCSIPeripheral->ioctl(handle->scsi_periph_handle, op,
buffer, length);
}
}
int start_listening(const char * port)
{
struct addrinfo hints, *res,*p;
int sockfd;
int socks[100];
int nsocks = 0;
int i;
// first, load up address structs with getaddrinfo():
memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC; // use IPv4 or IPv6, whichever
hints.ai_socktype = SOCK_DGRAM;
hints.ai_flags = AI_PASSIVE; // fill in my IP for me
int r;
if ((r = getaddrinfo(NULL, port, &hints, &res))!=0)
{
fprintf(stderr,"getaddrinfo: %s",gai_strerror(r));
return -1;
}
for (p=res; p; p=p->ai_next)
{
// make a socket, bind it, and listen on it:
if ((sockfd = socket(res->ai_family, res->ai_socktype, res->ai_protocol))<0)
continue;
if (fcntl(sockfd, F_SETFL, O_NONBLOCK)<0)
{
close(sockfd);
continue;
}
if (bind(sockfd, res->ai_addr, res->ai_addrlen)<0)
{
close(sockfd);
continue;
}
socks[nsocks++]=sockfd;
if (nsocks==100)
break;
}
if (nsocks==0)
{
fprintf(stderr,"no valid interfaces to listen on found\n");
return -1;
}
pthread_mutex_init(&queue_mutex,NULL);
int asocks = nsocks;
while (asocks)
{
fd_set fds;
int max=0;
FD_ZERO(&fds);
for (i=0; i<nsocks; i++)
{
if (socks[i]<0) continue;
FD_SET(socks[i],&fds);
if (socks[i]+1>max)
max=socks[i]+1;
}
struct timeval timeout;
timeout.tv_sec = 1;
timeout.tv_usec = 0;
if ((select(max,&fds,NULL,NULL,&timeout)<0)&&(errno!=EINTR))
{
fprintf(stderr,"select(): %s\n",strerror(errno));
for (i=0; i<nsocks; i++)
close(socks[i]);
return -1;
}
for (i=0; i<nsocks; i++)
{
if (socks[i]<0) continue;
if (FD_ISSET(socks[i],&fds))
{
struct sockaddr_storage their_addr;
socklen_t addr_size = sizeof their_addr;
uint8_t * buffer = memory[memory_pointer];
ssize_t ret = recvfrom(socks[i],buffer,MAX_BUFFER_SIZE,0,(struct sockaddr *)&their_addr,&addr_size);
if (ret == -1)
{
fprintf(stderr,"recvfrom(): %s\n",strerror(errno));
close(socks[i]);
socks[i] = -1;
asocks--;
} else {
if (!parse_data(buffer,(size_t)ret))
memory_pointer++;
}
}
}
if (timedout(&last_data_packet_time,1000000))
stop_audio();
}
for (i=0; i<nsocks; i++)
if (socks[i]>=0)
close(socks[i]);
stop_audio();
return 0;
}
int main(void) {
FRESULT res;
WORD br;
sei(); // Globally enable interrupts
hibernate_init();
DAC_init();
keys_init();
if (pf_mount(&fs)) { sound_osch(); }
else { sound_gut(); }
while(1) {
cli(); // disable interrupts to avoid race condition with sleep function
if (FLAG_CHECK(NEW_SOUND)) {
hibernate_timer_stop();
FLAG_CLEAR(NEW_SOUND);
sei();
switch (special_mode) {
case 1:
if (new_sound_id == old_sound_id - 1) {
special_mode = 2;
goto sound_ende;
} else if (new_sound_id == old_sound_id + 1) {
special_mode = 4;
goto sound_ende;
} else if (new_sound_id == old_sound_id) {
credits_counter = CREDITS_COUNTER_MAX - 5;
special_mode = 0;
goto sound_ende;
} else special_mode = 0;
break;
case 2:
special_mode = 3;
break;
case 4:
special_mode = 5;
break;
default:
special_mode = 0;
}
if (new_sound_id == 36) {
special_mode = 1;
goto sound_ende;
}
old_sound_id = new_sound_id;
char* filename;
if (++credits_counter > CREDITS_COUNTER_MAX) {
credits_counter = 0;
filename = "image.hex";
} else {
if (new_sound_id == 255) goto sound_ende;
filename = filenames(bank, new_sound_id);
}
uint8_t tries = 3;
while (pf_open(filename) && pf_open("error1.wav")) {
if ((tries--) == 0) goto sound_ende;
_delay_ms(10);
pf_mount(&fs);
}
if (parse_wav_header()) {
if (pf_open("error2.wav") || parse_wav_header()) goto sound_ende;
}
do {
#define read_length 16384
if (wavinfo.data_length > read_length) {
res = pf_read(0, read_length, &br);
wavinfo.data_length -= read_length;
} else {
res = pf_read(0, wavinfo.data_length, &br);
break;
}
} while (res==0 && br==read_length && wavinfo.data_length>0 && !FLAG_CHECK(NEW_SOUND));
stop_audio();
sound_ende:
hibernate_timer_init();
} else {
sleep_enable();
sei();
sleep_cpu();
sleep_disable();
}
hibernate_check();
}
}
bool obs_transition_audio_render(obs_source_t *transition,
uint64_t *ts_out, struct obs_source_audio_mix *audio,
uint32_t mixers, size_t channels, size_t sample_rate,
obs_transition_audio_mix_callback_t mix_a,
obs_transition_audio_mix_callback_t mix_b)
{
obs_source_t *sources[2];
struct transition_state state = {0};
bool stopped = false;
uint64_t min_ts;
float t;
if (!transition_valid(transition, "obs_transition_audio_render"))
return false;
lock_transition(transition);
sources[0] = transition->transition_sources[0];
sources[1] = transition->transition_sources[1];
min_ts = calc_min_ts(sources);
if (min_ts) {
t = calc_time(transition, min_ts);
if (t >= 1.0f && transition->transitioning_audio)
stopped = stop_audio(transition);
sources[0] = transition->transition_sources[0];
sources[1] = transition->transition_sources[1];
min_ts = calc_min_ts(sources);
if (min_ts)
copy_transition_state(transition, &state);
} else if (transition->transitioning_audio) {
stopped = stop_audio(transition);
}
unlock_transition(transition);
if (min_ts) {
if (state.transitioning_audio) {
if (state.s[0])
process_audio(transition, state.s[0], audio,
min_ts, mixers, channels,
sample_rate, mix_a);
if (state.s[1])
process_audio(transition, state.s[1], audio,
min_ts, mixers, channels,
sample_rate, mix_b);
} else if (state.s[0]) {
memcpy(audio->output[0].data[0],
state.s[0]->audio_output_buf[0][0],
TOTAL_AUDIO_SIZE);
}
obs_source_release(state.s[0]);
obs_source_release(state.s[1]);
}
if (stopped)
obs_source_dosignal(transition, "source_transition_stop",
"transition_stop");
*ts_out = min_ts;
return !!min_ts;
}
int ffplay(const char *filename, const char *force_format) {
char errbuf[256];
int r = 0;
int frameFinished;
AVPacket packet;
int audio_buf_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
int16_t *audio_buf = (int16_t *) malloc((AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2);
if(!audio_buf) {
ds_printf("DS_ERROR: No free memory\n");
return -1;
}
memset(audio_buf, 0, (AVCODEC_MAX_AUDIO_FRAME_SIZE * 3) / 2);
AVFormatContext *pFormatCtx = NULL;
AVFrame *pFrame = NULL;
AVCodecContext *pVideoCodecCtx = NULL, *pAudioCodecCtx = NULL;
AVInputFormat *file_iformat = NULL;
video_txr_t movie_txr;
int videoStream = -1, audioStream = -1;
maple_device_t *cont = NULL;
cont_state_t *state = NULL;
int pause = 0, done = 0;
char fn[MAX_FN_LEN];
sprintf(fn, "ds:%s", filename);
memset(&movie_txr, 0, sizeof(movie_txr));
if(!codecs_inited) {
avcodec_register_all();
avcodec_register(&mp1_decoder);
avcodec_register(&mp2_decoder);
avcodec_register(&mp3_decoder);
avcodec_register(&vorbis_decoder);
//avcodec_register(&mpeg4_decoder);
codecs_inited = 1;
}
if(force_format)
file_iformat = av_find_input_format(force_format);
else
file_iformat = NULL;
// Open video file
ds_printf("DS_PROCESS_FFMPEG: Opening file: %s\n", filename);
if((r = av_open_input_file((AVFormatContext**)(&pFormatCtx), fn, file_iformat, /*FFM_PACKET_SIZE*/0, NULL)) != 0) {
av_strerror(r, errbuf, 256);
ds_printf("DS_ERROR_FFMPEG: %s\n", errbuf);
free(audio_buf);
return -1; // Couldn't open file
}
// Retrieve stream information
ds_printf("DS_PROCESS_FFMPEG: Retrieve stream information...\n");
if((r = av_find_stream_info(pFormatCtx)) < 0) {
av_strerror(r, errbuf, 256);
ds_printf("DS_ERROR_FFMPEG: %s\n", errbuf);
av_close_input_file(pFormatCtx);
free(audio_buf);
return -1; // Couldn't find stream information
}
// Dump information about file onto standard error
dump_format(pFormatCtx, 0, filename, 0);
//thd_sleep(5000);
pVideoCodecCtx = findDecoder(pFormatCtx, AVMEDIA_TYPE_VIDEO, &videoStream);
pAudioCodecCtx = findDecoder(pFormatCtx, AVMEDIA_TYPE_AUDIO, &audioStream);
//LockInput();
if(pVideoCodecCtx) {
//LockVideo();
ShutdownVideoThread();
SDL_DS_FreeScreenTexture(0);
int format = 0;
switch(pVideoCodecCtx->pix_fmt) {
case PIX_FMT_YUV420P:
case PIX_FMT_YUVJ420P:
format = PVR_TXRFMT_YUV422;
#ifdef USE_HW_YUV
yuv_conv_init();
#endif
break;
case PIX_FMT_UYVY422:
case PIX_FMT_YUVJ422P:
format = PVR_TXRFMT_YUV422;
break;
default:
format = PVR_TXRFMT_RGB565;
break;
}
MakeVideoTexture(&movie_txr, pVideoCodecCtx->width, pVideoCodecCtx->height, format | PVR_TXRFMT_NONTWIDDLED, PVR_FILTER_BILINEAR);
#ifdef USE_HW_YUV
yuv_conv_setup(movie_txr.addr, PVR_YUV_MODE_MULTI, PVR_YUV_FORMAT_YUV420, movie_txr.width, movie_txr.height);
pvr_dma_init();
#endif
} else {
ds_printf("DS_ERROR: Didn't find a video stream.\n");
}
if(pAudioCodecCtx) {
#ifdef USE_DIRECT_AUDIO
audioinit(pAudioCodecCtx);
#else
sprintf(fn, "%s/firmware/aica/ds_stream.drv", getenv("PATH"));
if(snd_init_fw(fn) < 0) {
goto exit_free;
}
if(aica_audio_open(pAudioCodecCtx->sample_rate, pAudioCodecCtx->channels, 8192) < 0) {
goto exit_free;
}
//snd_cpu_clock(0x19);
//snd_init_decoder(8192);
#endif
} else {
ds_printf("DS_ERROR: Didn't find a audio stream.\n");
}
//ds_printf("FORMAT: %d\n", pVideoCodecCtx->pix_fmt);
// Allocate video frame
pFrame = avcodec_alloc_frame();
if(pFrame == NULL) {
ds_printf("DS_ERROR: Can't alloc memory\n");
goto exit_free;
}
int pressed = 0, framecnt = 0;
uint32 fa = 0;
fa = GET_EXPORT_ADDR("ffplay_format_handler");
if(fa > 0 && fa != 0xffffffff) {
EXPT_GUARD_BEGIN;
void (*ff_format_func)(AVFormatContext *, AVCodecContext *, AVCodecContext *) =
(void (*)(AVFormatContext *, AVCodecContext *, AVCodecContext *))fa;
ff_format_func(pFormatCtx, pVideoCodecCtx, pAudioCodecCtx);
EXPT_GUARD_CATCH;
EXPT_GUARD_END;
}
fa = GET_EXPORT_ADDR("ffplay_frame_handler");
void (*ff_frame_func)(AVFrame *) = NULL;
if(fa > 0 && fa != 0xffffffff) {
EXPT_GUARD_BEGIN;
ff_frame_func = (void (*)(AVFrame *))fa;
// Test call
ff_frame_func(NULL);
EXPT_GUARD_CATCH;
ff_frame_func = NULL;
EXPT_GUARD_END;
}
fa = GET_EXPORT_ADDR("ffplay_render_handler");
if(fa > 0 && fa != 0xffffffff) {
EXPT_GUARD_BEGIN;
movie_txr.render_cb = (void (*)(void *))fa;
// Test call
movie_txr.render_cb(NULL);
EXPT_GUARD_CATCH;
movie_txr.render_cb = NULL;
EXPT_GUARD_END;
}
while(av_read_frame(pFormatCtx, &packet) >= 0 && !done) {
do {
if(ff_frame_func)
ff_frame_func(pFrame);
cont = maple_enum_type(0, MAPLE_FUNC_CONTROLLER);
framecnt++;
if(cont) {
state = (cont_state_t *)maple_dev_status(cont);
if (!state) {
break;
}
if (state->buttons & CONT_START || state->buttons & CONT_B) {
av_free_packet(&packet);
done = 1;
}
if (state->buttons & CONT_A) {
if((framecnt - pressed) > 10) {
pause = pause ? 0 : 1;
if(pause) {
#ifdef USE_DIRECT_AUDIO
audio_end();
#else
stop_audio();
#endif
} else {
#ifndef USE_DIRECT_AUDIO
start_audio();
#endif
}
}
pressed = framecnt;
}
if(state->buttons & CONT_DPAD_LEFT) {
//av_seek_frame(pFormatCtx, -1, timestamp * ( AV_TIME_BASE / 1000 ), AVSEEK_FLAG_BACKWARD);
}
if(state->buttons & CONT_DPAD_RIGHT) {
//av_seek_frame(pFormatCtx, -1, timestamp * ( AV_TIME_BASE / 1000 ), AVSEEK_FLAG_BACKWARD);
}
}
if(pause) thd_sleep(100);
} while(pause);
//printf("Packet: size: %d data: %02x%02x%02x pst: %d\n", packet.size, packet.data[0], packet.data[1], packet.data[2], pFrame->pts);
// Is this a packet from the video stream?
if(packet.stream_index == videoStream) {
//printf("video\n");
// Decode video frame
if((r = avcodec_decode_video2(pVideoCodecCtx, pFrame, &frameFinished, &packet)) < 0) {
//av_strerror(r, errbuf, 256);
//printf("DS_ERROR_FFMPEG: %s\n", errbuf);
} else {
// Did we get a video frame?
if(frameFinished && !pVideoCodecCtx->hurry_up) {
RenderVideo(&movie_txr, pFrame, pVideoCodecCtx);
}
}
} else if(packet.stream_index == audioStream) {
//printf("audio\n");
//snd_decode((uint8*)audio_buf, audio_buf_size, AICA_CODEC_MP3);
audio_buf_size = AVCODEC_MAX_AUDIO_FRAME_SIZE;
if((r = avcodec_decode_audio3(pAudioCodecCtx, audio_buf, &audio_buf_size, &packet)) < 0) {
//av_strerror(r, errbuf, 256);
//printf("DS_ERROR_FFMPEG: %s\n", errbuf);
//continue;
} else {
if(audio_buf_size > 0 && !pAudioCodecCtx->hurry_up) {
#ifdef USE_DIRECT_AUDIO
audio_write(pAudioCodecCtx, audio_buf, audio_buf_size);
#else
aica_audio_write((char*)audio_buf, audio_buf_size);
#endif
}
}
}
// Free the packet that was allocated by av_read_frame
av_free_packet(&packet);
}
goto exit_free;
exit_free:
if(pFrame)
av_free(pFrame);
if(pFormatCtx)
av_close_input_file(pFormatCtx);
if(audioStream > -1) {
if(pAudioCodecCtx)
avcodec_close(pAudioCodecCtx);
#ifdef USE_DIRECT_AUDIO
audio_end();
#else
aica_audio_close();
sprintf(fn, "%s/firmware/aica/kos_stream.drv", getenv("PATH"));
snd_init_fw(fn);
#endif
}
if(audio_buf) {
free(audio_buf);
}
if(videoStream > -1) {
if(pVideoCodecCtx)
avcodec_close(pVideoCodecCtx);
FreeVideoTexture(&movie_txr);
SDL_DS_AllocScreenTexture(GetScreen());
InitVideoThread();
//UnlockVideo();
}
//UnlockInput();
ProcessVideoEventsUpdate(NULL);
return 0;
}
/* -------------------------------------
* gap_sdl_cmd
* -------------------------------------
* perform simple audio_player command .
* Note: some of the commands do not make sense
* in this SDL based implementation
* and are just dummies for compatibility with the
* API (that was designed base on the older wavplay client functions)
*/
int
gap_sdl_cmd(int cmd,int flags,GapSdlErrFunc erf) {
static char *sdl_no_error_available = "";
char *sdl_error;
int rc = 1;
AudioPlaybackThreadUserData *usrPtr;
sdl_error = sdl_no_error_available;
usrPtr = getUsrPtr();
if (usrPtr != NULL)
{
if(gap_debug)
{
printf("gap_sdl_cmd cmd:%d (%s) flags:%d SdlAudioStatus:%d\n"
, cmd
, msg_name(cmd)
, flags
, (int)SDL_GetAudioStatus()
);
}
switch(cmd)
{
case GAP_SDL_CMD_Bye:
stop_audio();
close_files();
rc = 0; /* OK */
break;
case GAP_SDL_CMD_Play:
rc = start_audio();
sdl_error = SDL_GetError(); /* SDL_GetError uses sttically allocated message that must NOT be freed */
break;
case GAP_SDL_CMD_Pause:
stop_audio();
rc = 0; /* OK */
break;
case GAP_SDL_CMD_Stop:
stop_audio();
close_files();
rc = 0; /* OK */
break;
case GAP_SDL_CMD_Restore:
stop_audio();
rc = 0; /* OK */
break;
case GAP_SDL_CMD_SemReset:
rc = 0; /* OK */
break;
}
}
if ((rc != 0) && (erf != NULL ))
{
call_errfunc(erf, "%s: Sending cmd%d to audio_player failed (rc:%d) err:%s",
msg_name(cmd),
cmd,
sdl_error,
rc);
}
if(gap_debug)
{
printf("gap_sdl_cmd cmd:%d (%s) flags:%d retcode:%d\n", cmd, msg_name(cmd), flags, rc);
}
return rc; /* Zero indicates success */
} /* end gap_sdl_cmd */
/* -------------------------------------
* gap_sdl_path
* -------------------------------------
*
* Send a pathname to the audio_player.
* (use flags =1 to keep current playback parameters)
* typical call with flags == 0 does init the audio playback parameters
* from the header information of the specified RIFF WAVE file (rfered by pathname)
*/
int
gap_sdl_path(const char *pathname,int flags,GapSdlErrFunc erf)
{
int rc = 1;
AudioPlaybackThreadUserData *usrPtr;
usrPtr = getUsrPtr();
if (usrPtr != NULL)
{
int rcCheck;
long sample_rate;
long channels;
long bytes_per_sample;
long bits;
long samples;
rcCheck = gap_audio_wav_file_check(pathname, &sample_rate, &channels
, &bytes_per_sample, &bits, &samples);
if (rcCheck == 0)
{
int ii;
rc = 0; /* OK */
ii = 0;
stop_audio();
usrPtr->sounds[ii].data = NULL; /* no preloded memory available */
usrPtr->sounds[ii].dpos = 0;
usrPtr->sounds[ii].dlen = 0;
if (flags != 1)
{
/* set audio params from wavefile header */
usrPtr->format = AUDIO_S16;
usrPtr->samplerate = sample_rate;
usrPtr->channels = channels;
usrPtr->bits_per_sample = bits;
usrPtr->frame_size = (usrPtr->bits_per_sample / 8) * usrPtr->channels;
switch (bits)
{
case 8:
usrPtr->format = AUDIO_U8;
break;
case 16:
usrPtr->format = AUDIO_S16; /* same as AUDIO_S16LSB */
break;
default:
rc = 2; /* unsupported bits_per_channel value */
break;
}
}
if (rc == 0)
{
if (usrPtr->sounds[ii].fpWav != NULL)
{
if (strcmp(usrPtr->sounds[ii].wav_filename, pathname) != 0)
{
/* file differs from currently opened wavfile, force close/reopen */
fclose(usrPtr->sounds[ii].fpWav);
usrPtr->sounds[ii].fpWav = NULL;
}
else
{
long seekPosition;
/* current wavfile was specified again, just rewind existing filehandle */
seekPosition = usrPtr->sounds[ii].offset_to_first_sample;
fseek(usrPtr->sounds[ii].fpWav, seekPosition, SEEK_SET);
}
}
if (usrPtr->sounds[ii].fpWav == NULL)
{
g_snprintf(usrPtr->sounds[ii].wav_filename, MAX_WAV_FILENAME_LENGTH -1, pathname);
usrPtr->sounds[ii].wav_filename[MAX_WAV_FILENAME_LENGTH -1] = '\0';
usrPtr->sounds[ii].offset_to_first_sample = 0;
usrPtr->sounds[ii].fpWav = gap_audio_wav_open_seek_data(usrPtr->sounds[ii].wav_filename);
}
if(usrPtr->sounds[ii].fpWav == NULL)
{
rc = 3; /* failed to open audio data file */
}
else
{
/* store current file offset (position of the 1st audio sample data byte) */
usrPtr->sounds[ii].offset_to_first_sample = ftell(usrPtr->sounds[ii].fpWav);
}
}
}
}
if ( (rc != 0) && (erf != NULL) )
{
if (pathname != NULL)
{
// TODO provide to_string for errorcodes rc
call_errfunc(erf, "path: Not a valid RIFF WAVE file %s rc:%d (%s)", pathname, rc, " ");
}
else
{
call_errfunc(erf, "path: is NULL (name of RIFF WAVE file was expected).");
}
}
return (rc);
} /* end gap_sdl_path */
