static int get_solaris_eeprom_parameter(char *parameter,char *outbuffer) {
int fd=0,status=0;
struct openpromio *openprominfo=NULL;
fd=open("/dev/openprom",O_RDONLY);
if ( fd == -1 ) {
snmp_log(LOG_ERR,"cannot open /dev/openprom\n");
return 1;
}
openprominfo=(struct openpromio *)op_malloc(8192);
if(!openprominfo) return 1;
strcpy(openprominfo->oprom_array,parameter);
status=ioctl(fd,OPROMGETOPT,openprominfo);
if ( status == -1 ) {
snmp_log(LOG_ERR,"cannot read from /dev/openprom\n");
close(fd);
op_free(openprominfo);
return 1;
}
strcpy(outbuffer,openprominfo->oprom_array);
op_free(openprominfo);
/* close file */
close(fd);
return(0);
}
void op_rt_exit() {
/* free storage for plans */
for (int ip = 0; ip < OP_plan_index; ip++) {
free(OP_plans[ip].dats);
free(OP_plans[ip].idxs);
free(OP_plans[ip].maps);
free(OP_plans[ip].accs);
free(OP_plans[ip].inds_staged);
free(OP_plans[ip].nthrcol);
free(OP_plans[ip].thrcol);
free(OP_plans[ip].offset);
free(OP_plans[ip].ind_offs);
free(OP_plans[ip].ind_sizes);
free(OP_plans[ip].nelems);
free(OP_plans[ip].blkmap);
free(OP_plans[ip].ind_map);
free(OP_plans[ip].ind_maps);
free(OP_plans[ip].nindirect);
free(OP_plans[ip].loc_map);
free(OP_plans[ip].loc_maps);
free(OP_plans[ip].ncolblk);
free(OP_plans[ip].nsharedCol);
op_free(OP_plans[ip].col_reord);
if (OP_plans[ip].col_offsets != NULL) {
op_free(OP_plans[ip].col_offsets[0]);
op_free(OP_plans[ip].col_offsets);
}
}
OP_plan_index = 0;
OP_plan_max = 0;
free(OP_plans);
OP_plans = NULL;
}
RepList::~RepList()
{
for (int i = 0; i < pos; i++) {
op_free(dat[i]->pattern);
op_free(dat[i]->pattern2);
op_free(dat[i]);
}
op_free(dat);
}
void
Debug::TimeEnd(const char* key, const char* s)
{
uni_char* ukey = uni_up_strdup(key);
uni_char* us = uni_up_strdup(s);
if ( ukey != 0 && us != 0 )
Debug::TimeEnd(ukey, us);
op_free(ukey);
op_free(us);
}
int
abb_fread(void *mod_priv,
uint64_t src_off,
uint64_t src_len,
struct elasto_data *dest_data)
{
int ret;
struct op *op;
struct apb_fh *apb_fh = mod_priv;
ret = az_req_blob_get(&apb_fh->path,
false,
dest_data,
src_off,
src_len,
&op);
if (ret < 0) {
goto err_out;
}
ret = elasto_fop_send_recv(apb_fh->io_conn, op);
if (ret < 0) {
goto err_op_free;
}
ret = 0;
err_op_free:
op->rsp.data = NULL;
op_free(op);
err_out:
return ret;
}
static prMALError
SDKQuietFile(
imStdParms *stdParms,
imFileRef *SDKfileRef,
void *privateData)
{
// "Quiet File" really means close the file handle, but we're still
// using it and might open it again, so hold on to any stored data
// structures you don't want to re-create.
// If file has not yet been closed
if(SDKfileRef && *SDKfileRef != imInvalidHandleValue)
{
ImporterLocalRec8H ldataH = reinterpret_cast<ImporterLocalRec8H>(privateData);
stdParms->piSuites->memFuncs->lockHandle(reinterpret_cast<char**>(ldataH));
ImporterLocalRec8Ptr localRecP = reinterpret_cast<ImporterLocalRec8Ptr>( *ldataH );
if(localRecP->vf)
{
int clear_err = ov_clear(localRecP->vf);
assert(clear_err == OV_OK);
delete localRecP->vf;
localRecP->vf = NULL;
}
if(localRecP->opus)
{
op_free(localRecP->opus);
localRecP->opus = NULL;
}
if(localRecP->flac)
{
localRecP->flac->finish();
delete localRecP->flac;
localRecP->flac = NULL;
}
stdParms->piSuites->memFuncs->unlockHandle(reinterpret_cast<char**>(ldataH));
#ifdef PRWIN_ENV
CloseHandle(*SDKfileRef);
#else
FSCloseFork( CAST_REFNUM(*SDKfileRef) );
#endif
*SDKfileRef = imInvalidHandleValue;
}
return malNoError;
}
static void
abb_fwrite_multi_finish_cmpl(evutil_socket_t sock,
short flags,
void *priv)
{
int ret;
struct abb_fwrite_multi_finish_state *finish_state = priv;
struct abb_io_multi_state *multi_state = finish_state->multi_state;
ret = elasto_conn_op_rx(finish_state->ev_tx);
if (ret < 0) {
dbg(2, "block list put failed: %s\n", strerror(-ret));
abb_io_multi_error_set(multi_state, ret);
} else if (finish_state->op->rsp.is_error) {
ret = elasto_fop_err_code_map(finish_state->op->rsp.err_code);
dbg(2, "block list put error response: %d\n", ret);
abb_io_multi_error_set(multi_state, ret);
}
elasto_conn_op_free(finish_state->ev_tx);
op_free(finish_state->op);
dbg(0, "multipart upload finished\n");
ret = event_base_loopbreak(multi_state->ev_base);
if (ret < 0) {
dbg(0, "failed to break dispatch loop\n");
}
/* data_ctx cleanup after event loop exit */
}
static OP_STATUS LifreqIoctl(PosixNetLookup::Store * carrier, int sock, int type)
{
struct lifnum ifn;
#ifdef POSIX_SUPPORT_IPV6
ifn.lifn_family = AF_UNSPEC;
#else
ifn.lifn_family = AF_INET;
#endif
ifn.lifn_flags = 0;
ifn.lifn_count = 0;
if (1 + ioctl(sock, SIOCGLIFNUM, &ifn) == 0) // ioctl returns -1 on failure
return OpStatus::ERR;
if (ifn.lifn_count > 0)
{
struct lifreq * buffer = reinterpret_cast<struct lifreq *>(
op_calloc(ifn.lifn_count, sizeof(struct lifreq)));
if (!buffer)
return OpStatus::ERR_NO_MEMORY;
OP_STATUS res = DigestLifreq(carrier, sock, type, buffer, ifn);
op_free(buffer);
RETURN_IF_ERROR(res);
}
return OpStatus::OK;
}
static OP_BOOLEAN
CheckSecurityOveride(const OpSecurityContext& source, const OpSecurityContext& target, BOOL *allowed, OpSecurityCheckCallback* security_callback)
{
OP_ASSERT((allowed == NULL) != (security_callback == NULL));
if (DOM_Utils::GetDocument(source.GetRuntime()))
{
WindowCommander *wc = DOM_Utils::GetDocument(source.GetRuntime())->GetWindow()->GetWindowCommander();
URL origin_url= DOM_Utils::GetOriginURL(source.GetRuntime());
// Can't keep both src and tgt in URL's internal buffer, so one needs to be duplicated.
uni_char *src = uni_strdup(origin_url.GetAttribute(URL::KUniName_Username_Password_Hidden, TRUE).CStr());
RETURN_OOM_IF_NULL(src);
const uni_char *tgt = target.GetURL().GetAttribute(URL::KUniName_Username_Password_Hidden, TRUE).CStr();
OpDocumentListener::XHRPermission res = wc->GetDocumentListener()->OnXHR(wc, src, tgt);
op_free(src);
switch(res)
{
case OpDocumentListener::ALLOW:
if (security_callback)
security_callback->OnSecurityCheckSuccess(TRUE);
else
*allowed = TRUE;
return OpBoolean::IS_TRUE;
case OpDocumentListener::DENY:
if (security_callback)
security_callback->OnSecurityCheckSuccess(FALSE);
else
*allowed = FALSE;
return OpBoolean::IS_TRUE;
}
}
return OpBoolean::IS_FALSE;
}
void OpPersona::FreeClearElementsList()
{
for(UINT32 x = 0; x < m_clear_elements.GetCount(); x++)
{
op_free(m_clear_elements.Get(x));
}
m_clear_elements.Clear();
}
Error AudioStreamPlaybackOpus::set_file(const String &p_file) {
file=p_file;
stream_valid=false;
Error err;
f=FileAccess::open(file,FileAccess::READ,&err);
if (err) {
ERR_FAIL_COND_V( err, err );
}
int _err;
opus_file = op_open_callbacks(f,&_op_callbacks,NULL,0,&_err);
switch (_err) {
case OP_EREAD: { // - Can't read the file.
memdelete(f); f=NULL;
ERR_FAIL_V( ERR_FILE_CANT_READ );
} break;
case OP_EVERSION: // - Unrecognized version number.
case OP_ENOTFORMAT: // - Stream is not Opus data.
case OP_EIMPL : { // - Stream used non-implemented feature.
memdelete(f); f=NULL;
ERR_FAIL_V( ERR_FILE_UNRECOGNIZED );
} break;
case OP_EBADLINK: // - Failed to find old data after seeking.
case OP_EBADTIMESTAMP: // - Timestamp failed the validity checks.
case OP_EBADHEADER: { // - Invalid or mising Opus bitstream header.
memdelete(f); f=NULL;
ERR_FAIL_V( ERR_FILE_CORRUPT );
} break;
case OP_EFAULT: { // - Internal logic fault; indicates a bug or heap/stack corruption.
memdelete(f); f=NULL;
ERR_FAIL_V( ERR_BUG );
} break;
}
const OpusHead *oinfo = op_head(opus_file,-1);
stream_channels=oinfo->channel_count;
pre_skip=oinfo->pre_skip;
frames_mixed=pre_skip;
ogg_int64_t len = op_pcm_total(opus_file,-1);
if(len < 0) {
length = 0;
} else {
length=(len/osrate);
}
op_free(opus_file);
memdelete(f);
f=NULL;
stream_valid=true;
return OK;
}
/*
* et_opus_read_file_info:
* @file: file to read info from
* @ETFileInfo: ET_File_Info to put information into
* @error: a GError or %NULL
*
* Read header information of an Opus file.
*
* Returns: %TRUE if successful otherwise %FALSE
*/
gboolean
et_opus_read_file_info (GFile *gfile, ET_File_Info *ETFileInfo,
GError **error)
{
OggOpusFile *file;
const OpusHead* head;
GFileInfo *info;
g_return_val_if_fail (gfile != NULL && ETFileInfo != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
file = et_opus_open_file (gfile, error);
if (!file)
{
g_assert (error == NULL || *error != NULL);
return FALSE;
}
/* FIXME: Improve error-checking. */
head = op_head (file, -1);
/* TODO: Read the vendor string from the Vorbis comment? */
ETFileInfo->version = head->version;
ETFileInfo->bitrate = op_bitrate (file, -1) / 1000;
ETFileInfo->mode = head->channel_count;
/* All Opus audio is encoded at 48 kHz, but the input sample rate can
* differ, and then input_sample_rate will be set. */
if (head->input_sample_rate != 0)
{
ETFileInfo->samplerate = head->input_sample_rate;
}
else
{
ETFileInfo->samplerate = 48000;
}
ETFileInfo->duration = op_pcm_total (file, -1) / 48000;
op_free (file);
info = g_file_query_info (gfile, G_FILE_ATTRIBUTE_STANDARD_SIZE,
G_FILE_QUERY_INFO_NONE, NULL, NULL);
if (info)
{
ETFileInfo->size = g_file_info_get_size (info);
g_object_unref (info);
}
else
{
ETFileInfo->size = 0;
}
g_assert (error == NULL || *error == NULL);
return TRUE;
}
void
OpusDecoders_dealloc(decoders_OpusDecoder *self)
{
if (self->opus_file != NULL)
op_free(self->opus_file);
Py_XDECREF(self->audiotools_pcm);
Py_TYPE(self)->tp_free((PyObject*)self);
}
void cmdMusic(const std::string& args) {
// terrible hack for testing audio
// decode the entire file into a big buffer all at once
OggOpusFile* opusFile;
if (args.length() == 0) {
opusFile = op_open_memory(
static_cast<const uint8_t*>(EMBED_DATA(Who_Likes_to_Party_Kevin_MacLeod_incompetech_opus)),
EMBED_SIZE(Who_Likes_to_Party_Kevin_MacLeod_incompetech_opus),
NULL);
} else {
opusFile = op_open_file(args.c_str(), NULL);
}
if (!opusFile) {
narf::console->println("Failed to open music file " + args);
return;
}
auto newMusicSize = op_pcm_total(opusFile, -1) * 2; // stereo
auto newMusicSamples = new float[newMusicSize];
size_t decoded = 0;
while (decoded < newMusicSize) {
auto rc = op_read_float_stereo(opusFile, newMusicSamples + decoded, newMusicSize - decoded);
if (rc < 0) {
narf::console->println("opusfile decode failed");
decoded = 0;
break;
}
decoded += rc * 2; // return code is number of samples per channel, and we are decoding in stereo
}
if (decoded != newMusicSize) {
narf::console->println("opusfile decode returned wrong number of samples (got " + std::to_string(decoded) + ", expected " + std::to_string(newMusicSize) + ")");
delete[] newMusicSamples;
newMusicSamples = nullptr;
newMusicSize = 0;
}
SDL_LockMutex(musicMutex);
if (musicSamples) {
delete[] musicSamples;
}
musicSamples = newMusicSamples;
musicSize = newMusicSize;
musicCursor = 0;
SDL_UnlockMutex(musicMutex);
op_free(opusFile);
}
/*
=======================================================================================================================================
S_OggOpus_CodecCloseStream
=======================================================================================================================================
*/
void S_OggOpus_CodecCloseStream(snd_stream_t *stream) {
// check if input is valid
if (!stream) {
return;
}
// let the opus codec cleanup its stuff
op_free((OggOpusFile *)stream->ptr);
// close the stream
S_CodecUtilClose(&stream);
}
void AudioStreamPlaybackOpus::_clear_stream() {
if(!stream_loaded)
return;
op_free(opus_file);
_close_file();
stream_loaded=false;
stream_channels=1;
playing=false;
}
static void
abb_fwrite_multi_data_free(struct abb_fwrite_multi_data_ctx *data_ctx)
{
elasto_conn_op_free(data_ctx->ev_tx);
if (data_ctx->op != NULL) {
data_ctx->op->req.data = NULL;
op_free(data_ctx->op);
}
elasto_data_free(data_ctx->this_data);
free(data_ctx->blk.id);
free(data_ctx);
}
Debug::~Debug()
{
if (do_debugging && g_dbg_tracing)
{
Exit();
g_dbg_level--;
if (g_dbg_level == 0 && g_dbg_out != NULL)
{
g_dbg_out->Close();
OP_DELETE(g_dbg_out);
g_dbg_out = NULL;
}
}
op_free(function_name);
function_name = 0;
op_free(debugging_key);
debugging_key = 0;
}
void OpMemGroup::ReleaseAll(void)
{
void* ptr = all;
while ( ptr != 0 )
{
void* next = *(void**)ptr;
op_free(ptr);
ptr = next;
}
Reset();
}
static void
xmms_opus_destroy (xmms_xform_t *xform)
{
xmms_opus_data_t *data;
g_return_if_fail (xform);
data = xmms_xform_private_data_get (xform);
g_return_if_fail (data);
op_free (data->opusfile);
g_free (data);
}
void
OpusDecoders_dealloc(decoders_OpusDecoder *self)
{
if (self->opus_file != NULL)
op_free(self->opus_file);
Py_XDECREF(self->audiotools_pcm);
if (self->channels != NULL)
self->channels->del(self->channels);
self->ob_type->tp_free((PyObject*)self);
}
/*
* et_opus_tag_read_file_tag:
* @filename: file from which to read tags
* @FileTag: File_Tag to read tag into
* @error: a GError or %NULL
*
* Read file tags and store into File_Tag.
*
* Returns: %TRUE if successful otherwise %FALSE
*/
gboolean
et_opus_tag_read_file_tag (GFile *gfile, File_Tag *FileTag,
GError **error)
{
OggOpusFile *file;
const OpusTags *tags;
GFileInfo *info;
g_return_val_if_fail (gfile != NULL && FileTag != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
file = et_opus_open_file (gfile, error);
if (!file)
{
g_assert (error == NULL || *error != NULL);
return FALSE;
}
tags = op_tags (file, 0);
info = g_file_query_info (gfile, G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME,
G_FILE_QUERY_INFO_NONE, NULL, error);
if (!info)
{
op_free (file);
g_assert (error == NULL || *error != NULL);
return FALSE;
}
/* The cast is safe according to the opusfile documentation. */
et_add_file_tags_from_vorbis_comments ((vorbis_comment *)tags, FileTag,
g_file_info_get_display_name (info));
g_object_unref (info);
op_free (file);
g_assert (error == NULL || *error == NULL);
return TRUE;
}
static int
apb_fstat_blob(struct apb_fh *apb_fh,
struct elasto_fstat *fstat)
{
int ret;
struct op *op;
struct az_rsp_blob_prop_get *blob_prop_get_rsp;
ret = az_req_blob_prop_get(&apb_fh->path, &op);
if (ret < 0) {
goto err_out;
}
ret = elasto_fop_send_recv(apb_fh->io_conn, op);
if (ret < 0) {
goto err_op_free;
}
blob_prop_get_rsp = az_rsp_blob_prop_get(op);
if (blob_prop_get_rsp == NULL) {
ret = -ENOMEM;
goto err_op_free;
}
if (!blob_prop_get_rsp->is_page) {
/* should have been checked on open */
dbg(0, "blob flagged as block in stat for page blob!\n");
ret = -EINVAL;
goto err_op_free;
}
fstat->ent_type = ELASTO_FSTAT_ENT_FILE;
fstat->size = blob_prop_get_rsp->len;
fstat->blksize = 512;
if (blob_prop_get_rsp->lease_status == AOP_LEASE_STATUS_UNLOCKED) {
fstat->lease_status = ELASTO_FLEASE_UNLOCKED;
} else if (blob_prop_get_rsp->lease_status == AOP_LEASE_STATUS_LOCKED) {
fstat->lease_status = ELASTO_FLEASE_LOCKED;
}
/* flag which values are valid in the stat response */
fstat->field_mask = (ELASTO_FSTAT_FIELD_TYPE
| ELASTO_FSTAT_FIELD_SIZE
| ELASTO_FSTAT_FIELD_BSIZE
| ELASTO_FSTAT_FIELD_LEASE);
ret = 0;
err_op_free:
op_free(op);
err_out:
return ret;
}
JNIEXPORT void JNICALL Java_com_glester_jopus_JOpusDecodable_jopusClose(JNIEnv* environment, jobject caller)
{
OpusWrapper* opus;
jclass callerClass;
jfieldID metaPointerID;
// get wrapper data.
callerClass = (*environment)->GetObjectClass(environment, caller);
metaPointerID = (*environment)->GetFieldID(environment, callerClass, "wrapperPointer", "J");
opus = (OpusWrapper*)((*environment)->GetLongField(environment, caller, metaPointerID));
op_free(opus->file);
free(opus);
}
int AudioStreamPlaybackOpus::mix(int16_t* p_bufer,int p_frames) {
if (!playing)
return 0;
int total=p_frames;
while (true) {
int todo = p_frames;
if (todo==0 || todo<MIN_MIX) {
break;
}
int ret=op_read(opus_file,(opus_int16*)p_bufer,todo*stream_channels,¤t_section);
if (ret<0) {
playing = false;
ERR_EXPLAIN("Error reading Opus File: "+file);
ERR_BREAK(ret<0);
} else if (ret==0) { // end of song, reload?
op_free(opus_file);
_close_file();
f=FileAccess::open(file,FileAccess::READ);
int errv = 0;
opus_file = op_open_callbacks(f,&_op_callbacks,NULL,0,&errv);
if (errv!=0) {
playing=false;
break; // :(
}
if (!has_loop()) {
playing=false;
repeats=1;
break;
}
if (loop_restart_time) {
bool ok = op_pcm_seek(opus_file, (loop_restart_time*osrate)+pre_skip)==0;
if (!ok) {
playing=false;
ERR_PRINT("loop restart time rejected")
}
frames_mixed=(loop_restart_time*osrate)+pre_skip;
} else {
bool OpusDecoder::Open(FILE* file) {
finished = false;
int res;
OpusFileCallbacks callbacks = {custom_read, custom_seek, custom_tell, custom_close};
oof = op_open_callbacks(file, &callbacks, nullptr, 0, &res);
if (res != 0) {
error_message = "Opus: Error reading file";
op_free(oof);
fclose(file);
return false;
}
return true;
}
Result SoundSourceOpus::open() {
int error = 0;
QByteArray qBAFilename = m_qFilename.toLocal8Bit();
m_ptrOpusFile = op_open_file(qBAFilename.constData(), &error);
if ( m_ptrOpusFile == NULL ) {
qDebug() << "opus: Input does not appear to be an Opus bitstream.";
m_lFilelength = 0;
return ERR;
}
// opusfile lib all ways gives you 48000 samplerate and stereo 16 bit sample
m_iChannels = 2;
this->setBitrate((int)op_bitrate_instant(m_ptrOpusFile));
this->setSampleRate(48000);
this->setChannels(m_iChannels);
if (m_iChannels > 2) {
qDebug() << "opus: No support for more than 2 m_iChannels!";
op_free(m_ptrOpusFile);
m_lFilelength = 0;
return ERR;
}
// op_pcm_total returns the total number of frames in the ogg file. The
// frame is the channel-independent measure of samples. The total samples in
// the file is m_iChannels * ov_pcm_total. rryan 7/2009 I verified this by
// hand. a 30 second long 48khz mono ogg and a 48khz stereo ogg both report
// 1440000 for op_pcm_total.
qint64 ret = op_pcm_total(m_ptrOpusFile, -1) * 2;
// qDebug() << m_qFilename << "chan:" << m_iChannels << "sample:" << m_iSampleRate << "LEN:" << ret;
if (ret >= 0) {
// We pretend that the file is stereo to the rest of the world.
m_lFilelength = ret;
} else { //error
if (ret == OP_EINVAL) {
//The file is not seekable. Not sure if any action is needed.
qDebug() << "opus: file is not seekable " << m_qFilename;
}
}
return OK;
}
static int
apb_fstat_acc(struct apb_fh *apb_fh,
struct elasto_fstat *fstat)
{
int ret;
struct op *op;
struct az_mgmt_rsp_acc_prop_get *acc_prop_get_rsp;
if (apb_fh->mgmt_conn == NULL) {
dbg(0, "Account stat requires Publish Settings "
"credentials\n");
ret = -EINVAL;
goto err_out;
}
ret = az_mgmt_req_acc_prop_get(apb_fh->sub_id,
apb_fh->path.acc,
&op);
if (ret < 0) {
goto err_out;
}
ret = elasto_fop_send_recv(apb_fh->mgmt_conn, op);
if (ret < 0) {
goto err_op_free;
}
acc_prop_get_rsp = az_mgmt_rsp_acc_prop_get(op);
if (acc_prop_get_rsp == NULL) {
ret = -ENOMEM;
goto err_op_free;
}
fstat->ent_type = ELASTO_FSTAT_ENT_DIR;
fstat->size = 0;
fstat->blksize = 0;
/* Azure only supports leases at a container or blob level */
fstat->lease_status = ELASTO_FLEASE_UNLOCKED;
fstat->field_mask = ELASTO_FSTAT_FIELD_TYPE;
ret = 0;
err_op_free:
op_free(op);
err_out:
return ret;
}
void
Debug::SetOutputFile(const uni_char* filename)
{
if (!g_dbg_filename || !uni_str_eq(filename, g_dbg_filename))
{
op_free(g_dbg_filename);
g_dbg_filename = uni_down_strdup(filename);
if ( g_dbg_filename == 0 )
{
g_dbg_use_file = FALSE;
return;
}
g_dbg_use_file = TRUE;
SetupOutput();
}
}
OP_STATUS SoundUtils::SoundIt(const OpStringC &sndfile, BOOL force, BOOL async)
{
OP_STATUS rc = OpStatus::OK;
if ((!g_pcui->GetIntegerPref(PrefsCollectionUI::SoundsEnabled) && !force) || !IsStr(sndfile.CStr()))
return rc;
OpString osPrefsNoSound;
TRAP_AND_RETURN(rc, g_languageManager->GetStringL(Str::SI_NO_SOUND_STRING, osPrefsNoSound));
if (sndfile.CompareI(osPrefsNoSound) == 0 || sndfile.Compare("None") == 0)
return OpStatus::ERR;
#if defined(MSWIN)
rc = ( sndPlaySound(sndfile.CStr(), (async ? SND_ASYNC : SND_SYNC) | SND_NODEFAULT)==TRUE ? OpStatus::OK : OpStatus::ERR);
#elif defined(_UNIX_DESKTOP_)
if (g_audio_player)
{
char *filename = uni_down_strdup(sndfile.CStr());
if (!filename)
return OpStatus::ERR_NO_MEMORY;
WavFile *wav = OP_NEW(WavFile, ());
if (!wav)
{
rc = OpStatus::ERR_NO_MEMORY;
}
else
{
if (wav->Open(filename))
{
g_audio_player->Play(wav);
}
else
{
OP_DELETE(wav);
rc = OpStatus::ERR;
}
}
op_free(filename);
}
#elif defined(_MACINTOSH_)
rc = (MacPlaySound(sndfile.CStr(), async) == TRUE) ? OpStatus::OK : OpStatus::ERR;
#endif
return rc;
}
