int kqt_Handle_set_audio_rate(kqt_Handle handle, long rate)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
if (rate <= 0)
{
Handle_set_error(h, ERROR_ARGUMENT, "Audio rate must be positive");
return 0;
}
#if LONG_MAX > INT32_MAX
else if ((int64_t)rate > INT32_MAX)
{
Handle_set_error(h, ERROR_ARGUMENT, "Audio rate must be <= %" PRId32, INT32_MAX);
return 0;
}
#endif
if (!Player_set_audio_rate(h->player, (int32_t)rate))
{
Handle_set_error(
h, ERROR_MEMORY, "Couldn't allocate memory after change of audio rate.");
return 0;
}
return 1;
}
int kqt_Handle_set_audio_buffer_size(kqt_Handle handle, long size)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
if (size <= 0)
{
Handle_set_error(h, ERROR_ARGUMENT, "Buffer size must be positive");
return 0;
}
if (size > KQT_AUDIO_BUFFER_SIZE_MAX)
{
Handle_set_error(
h,
ERROR_ARGUMENT,
"Buffer size must not be greater than %ld frames",
KQT_AUDIO_BUFFER_SIZE_MAX);
return 0;
}
if (!Player_set_audio_buffer_size(h->player, (int32_t)size))
{
Handle_set_error(h, ERROR_MEMORY, "Couldn't allocate memory for new buffers");
return 0;
}
return 1;
}
/**************************************xyt.c***********************************/
PetscInt XYT_free(xyt_ADT xyt_handle)
{
PCTFS_comm_init();
check_handle(xyt_handle);
n_xyt_handles--;
free(xyt_handle->info->nsep);
free(xyt_handle->info->lnsep);
free(xyt_handle->info->fo);
free(xyt_handle->info->stages);
free(xyt_handle->info->solve_uu);
free(xyt_handle->info->solve_w);
free(xyt_handle->info->x);
free(xyt_handle->info->xcol_vals);
free(xyt_handle->info->xcol_sz);
free(xyt_handle->info->xcol_indices);
free(xyt_handle->info->y);
free(xyt_handle->info->ycol_vals);
free(xyt_handle->info->ycol_sz);
free(xyt_handle->info->ycol_indices);
free(xyt_handle->info);
free(xyt_handle->mvi->local2global);
PCTFS_gs_free(xyt_handle->mvi->PCTFS_gs_handle);
free(xyt_handle->mvi);
free(xyt_handle);
/* if the check fails we nuke */
/* if NULL pointer passed to free we nuke */
/* if the calls to free fail that's not my problem */
return(0);
}
/**************************************xyt.c***********************************/
PetscInt XYT_factor(xyt_ADT xyt_handle, /* prev. allocated xyt handle */
PetscInt *local2global, /* global column mapping */
PetscInt n, /* local num rows */
PetscInt m, /* local num cols */
PetscErrorCode (*matvec)(void*,PetscScalar*,PetscScalar*), /* b_loc=A_local.x_loc */
void *grid_data) /* grid data for matvec */
{
PCTFS_comm_init();
check_handle(xyt_handle);
/* only 2^k for now and all nodes participating */
if ((1<<(xyt_handle->level=PCTFS_i_log2_num_nodes))!=PCTFS_num_nodes) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_PLIB,"only 2^k for now and MPI_COMM_WORLD!!! %D != %D\n",1<<PCTFS_i_log2_num_nodes,PCTFS_num_nodes);
/* space for X info */
xyt_handle->info = (xyt_info*)malloc(sizeof(xyt_info));
/* set up matvec handles */
xyt_handle->mvi = set_mvi(local2global, n, m, (PetscErrorCode (*)(mv_info*,PetscScalar*,PetscScalar*))matvec, grid_data);
/* matrix is assumed to be of full rank */
/* LATER we can reset to indicate rank def. */
xyt_handle->ns=0;
/* determine separators and generate firing order - NB xyt info set here */
det_separators(xyt_handle);
return(do_xyt_factor(xyt_handle));
}
HANDLE repGetPeers(HANDLE rep, cb_repGetPeers cb, void *cbarg, int maxResults, Constraint *cons, int clen,
Ranking *ranks, int rlen, const char *ch) {
if (!check_handle(rep, __FUNCTION__)) return NULL;
debug("About to call getPeers with maxResults %d, constaints %s and rankings %s",
maxResults, constraints2str(cons, clen), rankings2str(ranks, rlen));
char uri[10240];
request_data *rd = (request_data *)malloc(sizeof(request_data));
if (!rd) return NULL;
rd->id = (void *)rd;
rd->cb = cb;
rd->cbarg = cbarg;
rd->server = rep;
rd->data = maxResults;
sprintf(uri, "/GetPeers?maxresults=%d&%s%s%s",
maxResults, constraints2str(cons, clen),
(rlen ? "&" : ""), rankings2str(ranks, rlen));
if (ch) {
if (clen + rlen > 0) strcat(uri, "&");
strcat(uri, "channel=");
strcat(uri, ch);
}
debug("Making getPeers request with URI %s", uri);
make_request(uri, _stringlist_callback, (void *)rd);
return (HANDLE)(rd);
}
int kqt_Handle_set_thread_count(kqt_Handle handle, int count)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
if (count < 1)
{
Handle_set_error(h, ERROR_ARGUMENT, "Thread count must be positive");
return 0;
}
if (count > KQT_THREADS_MAX)
{
Handle_set_error(
h, ERROR_ARGUMENT, "Thread count must not exceed %d", KQT_THREADS_MAX);
return 0;
}
Error* error = ERROR_AUTO;
if (!Player_set_thread_count(h->player, count, error))
{
Handle_set_error_from_Error(h, error);
return 0;
}
return 1;
}
int kqt_Handle_set_position(kqt_Handle handle, int track, long long nanoseconds)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
if (track < -1 || track >= KQT_TRACKS_MAX)
{
Handle_set_error(h, ERROR_ARGUMENT, "Invalid track number: %d", track);
return 0;
}
if (nanoseconds < 0)
{
Handle_set_error(h, ERROR_ARGUMENT, "nanoseconds must be non-negative");
return 0;
}
int64_t skip_frames = (int64_t)(((double)nanoseconds / 1000000000L) *
Player_get_audio_rate(h->player));
Device_states_reset(Player_get_device_states(h->player));
Player_reset(h->player, track);
Player_skip(h->player, skip_frames);
return 1;
}
int ul_db_check(ul_db_handle_t * handle){
if(db_master_write){
return check_handle(&mdb.write.dbf, mdb.write.dbh, handle);
} else {
LM_ERR("checking is useless in read-only mode\n");
return 0;
}
}
const driver_settings *
get_driver_settings(void *handle)
{
if (!check_handle(handle))
return NULL;
return &((settings_handle *)handle)->settings;
}
status_t
unload_driver_settings(void *handle)
{
if (!check_handle(handle))
return B_BAD_VALUE;
free_settings(handle);
return B_OK;
}
/* Returns the number of files inside the packfile. Uses the value at 0x04.
*/
uint32_t get_itemcount() {
check_handle();
rewind(packfile);
packheader head;
fread(&head, sizeof(head), 1, packfile);
return head.itemcount;
}
long kqt_Handle_get_frames_available(kqt_Handle handle)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
return Player_get_frames_available(h->player);
}
int kqt_Handle_get_thread_count(kqt_Handle handle)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
return Player_get_thread_count(h->player);
}
const char* kqt_Handle_receive_events(kqt_Handle handle)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
return Player_get_events(h->player);
}
/**************************************xyt.c***********************************/
PetscInt XYT_solve(xyt_ADT xyt_handle, PetscScalar *x, PetscScalar *b)
{
PCTFS_comm_init();
check_handle(xyt_handle);
/* need to copy b into x? */
if (b) PCTFS_rvec_copy(x,b,xyt_handle->mvi->n);do_xyt_solve(xyt_handle,x);
return(0);
}
long long kqt_Handle_get_position(kqt_Handle handle)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
return Player_get_nanoseconds(h->player);
}
int kqt_Handle_get_buffer_count(kqt_Handle handle)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
return KQT_BUFFERS_MAX;
}
long kqt_Handle_get_audio_buffer_size(kqt_Handle handle)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
return Player_get_audio_buffer_size(h->player);
}
int kqt_Handle_has_stopped(kqt_Handle handle)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
return Player_has_stopped(h->player);
}
static int cb(
struct nfq_q_handle *qh,
struct nfgenmsg *nfmsg,
struct nfq_data *nfqdata,
void *data
)
{
/* TODO - should have an option "delay", to explicitly avoid
offering a verdict right away */
static const char* verdict_opt[] = {
"accept", "drop", NULL
};
static int verdict_val[] = {
NF_ACCEPT, NF_DROP,
};
lua_State* L = data;
struct nfqnl_msg_packet_hdr *ph = nfq_get_msg_packet_hdr(nfqdata);
/* struct nfqnl_msg_packet_hw *hwph = nfq_get_msg_packet_hw(nfdata); */
u_int32_t id = 0;
if (ph) {
/* TODO - why is this conditional in sample source? */
id = ntohl(ph->packet_id);
}
/* We expect stack to look like:
* [1] qhandle
* [2] cbfn
*/
check_handle(L);
luaL_checktype(L, 2, LUA_TFUNCTION);
lua_pushvalue(L, 2); /* Push copy of fn */
lua_pushlightuserdata(L, nfqdata);
lua_call(L, 1, 2);
/* Return will be:
* [3] "accept", "drop", ..., default is accept
* [4] string, the replacement packet, default is 0,NULL
*/
{
int verdict = luaL_checkoption(L, 3, "accept", verdict_opt);
size_t replacesz = 0;
const char* replace = lua_tolstring(L, 4, &replacesz);
/*printf("verdict %s data %p data_len %zd\n", verdict_opt[verdict], replace, replacesz);*/
/* Reset stack, chopping any return values. */
lua_settop(L, 2);
return nfq_set_verdict(qh, id, verdict_val[verdict], replacesz, (void*)replace);
}
}
/* Checks to make sure the magic bytes of the packfile match "PACK".
*/
void check_magic() {
check_handle();
packheader head;
rewind(packfile);
fread(&head, sizeof(head), 1, packfile);
if(head.magic != expected_magic) {
printf("ERROR: packfile magic bytes do not match 'PACK'\n");
exit(EXIT_FAILURE);
}
}
/*-
-- qhandle = nfq.bind_pf(qhandle, family)
Protocol family is one of "inet", "inet6".
Note that sample code seems to always unbind before binding, I've no idea why,
and there is no indication of whether its possible to bind to multiple address
families.
Return is qhandle on success and nil,emsg,errno on failure.
*/
static int bind_pf(lua_State* L)
{
struct nfq_handle* h = check_handle(L);
int pf = check_PF(L, 2);
if(nfq_bind_pf(h, pf) < 0) {
return push_error(L);
}
lua_settop(L, 1);
return 1;
}
const float* kqt_Handle_get_audio(kqt_Handle handle, int index)
{
check_handle(handle, NULL);
Handle* h = get_handle(handle);
check_data_is_valid(h, NULL);
check_data_is_validated(h, NULL);
if (index < 0 || index >= KQT_BUFFERS_MAX)
{
Handle_set_error(h, ERROR_ARGUMENT, "Buffer #%d does not exist", index);
return NULL;
}
return Player_get_audio(h->player, index);
}
status_t
get_driver_settings_string(void *_handle, char *buffer, size_t *_bufferSize, bool flat)
{
settings_handle *handle = (settings_handle *)_handle;
size_t bufferSize = *_bufferSize;
int32 i;
if (!check_handle(handle) || !buffer || *_bufferSize == 0)
return B_BAD_VALUE;
for (i = 0; i < handle->settings.parameter_count; i++) {
put_parameter(&buffer, &bufferSize, &handle->settings.parameters[i], 0, flat);
}
*_bufferSize -= bufferSize;
return bufferSize >= 0 ? B_OK : B_BUFFER_OVERFLOW;
}
/**************************************xxt.c***********************************/
PetscInt XXT_stats(xxt_ADT xxt_handle)
{
PetscInt op[] = {NON_UNIFORM,GL_MIN,GL_MAX,GL_ADD,GL_MIN,GL_MAX,GL_ADD,GL_MIN,GL_MAX,GL_ADD};
PetscInt fop[] = {NON_UNIFORM,GL_MIN,GL_MAX,GL_ADD};
PetscInt vals[9], work[9];
PetscScalar fvals[3], fwork[3];
PetscErrorCode ierr;
PCTFS_comm_init();
check_handle(xxt_handle);
/* if factorization not done there are no stats */
if (!xxt_handle->info||!xxt_handle->mvi) {
if (!PCTFS_my_id) { ierr = PetscPrintf(PETSC_COMM_WORLD,"XXT_stats() :: no stats available!\n");CHKERRQ(ierr); }
return 1;
}
vals[0]=vals[1]=vals[2]=xxt_handle->info->nnz;
vals[3]=vals[4]=vals[5]=xxt_handle->mvi->n;
vals[6]=vals[7]=vals[8]=xxt_handle->info->msg_buf_sz;
PCTFS_giop(vals,work,sizeof(op)/sizeof(op[0])-1,op);
fvals[0]=fvals[1]=fvals[2] =xxt_handle->info->tot_solve_time/xxt_handle->info->nsolves++;
PCTFS_grop(fvals,fwork,sizeof(fop)/sizeof(fop[0])-1,fop);
if (!PCTFS_my_id) {
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: min xxt_nnz=%D\n",PCTFS_my_id,vals[0]);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: max xxt_nnz=%D\n",PCTFS_my_id,vals[1]);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: avg xxt_nnz=%g\n",PCTFS_my_id,1.0*vals[2]/PCTFS_num_nodes);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: tot xxt_nnz=%D\n",PCTFS_my_id,vals[2]);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: xxt C(2d) =%g\n",PCTFS_my_id,vals[2]/(PetscPowReal(1.0*vals[5],1.5)));CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: xxt C(3d) =%g\n",PCTFS_my_id,vals[2]/(PetscPowReal(1.0*vals[5],1.6667)));CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: min xxt_n =%D\n",PCTFS_my_id,vals[3]);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: max xxt_n =%D\n",PCTFS_my_id,vals[4]);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: avg xxt_n =%g\n",PCTFS_my_id,1.0*vals[5]/PCTFS_num_nodes);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: tot xxt_n =%D\n",PCTFS_my_id,vals[5]);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: min xxt_buf=%D\n",PCTFS_my_id,vals[6]);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: max xxt_buf=%D\n",PCTFS_my_id,vals[7]);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: avg xxt_buf=%g\n",PCTFS_my_id,1.0*vals[8]/PCTFS_num_nodes);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: min xxt_slv=%g\n",PCTFS_my_id,fvals[0]);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: max xxt_slv=%g\n",PCTFS_my_id,fvals[1]);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD,"%D :: avg xxt_slv=%g\n",PCTFS_my_id,fvals[2]/PCTFS_num_nodes);CHKERRQ(ierr);
}
return(0);
}
int kqt_Handle_play(kqt_Handle handle, long nframes)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_data_is_validated(h, 0);
if (nframes <= 0)
{
Handle_set_error(h, ERROR_ARGUMENT, "Number of frames must be positive.");
return 0;
}
Player_play(h->player, (int32_t)min(nframes, KQT_AUDIO_BUFFER_SIZE_MAX));
return 1;
}
const char *
get_driver_parameter(void *handle, const char *keyName, const char *unknownValue, const char *noArgValue)
{
struct driver_parameter *parameter;
if (!check_handle(handle))
return unknownValue;
// check for the parameter
if ((parameter = get_parameter(handle, keyName)) == NULL)
return unknownValue;
// check for the argument
if (parameter->value_count <= 0)
return noArgValue;
return parameter->values[0];
}
long long kqt_Handle_get_duration(kqt_Handle handle, int track)
{
check_handle(handle, -1);
Handle* h = get_handle(handle);
check_data_is_valid(h, -1);
check_data_is_validated(h, -1);
if (track < -1 || track >= KQT_TRACKS_MAX)
{
Handle_set_error(h, ERROR_ARGUMENT, "Invalid track number: %d", track);
return -1;
}
Player_reset(h->length_counter, track);
Player_skip(h->length_counter, KQT_CALC_DURATION_MAX);
return Player_get_nanoseconds(h->length_counter);
}
int respond_to_extension(CONDITION_PARAMS)
{
msg_t *with = nua_current_request(nua);
if (!(check_handle(ep, call, nh, SIP_500_INTERNAL_SERVER_ERROR)))
return 0;
save_event_in_list(ctx, event, ep, call);
switch (event) {
case nua_i_method:
RESPOND(ep, call, nh, SIP_200_OK,
NUTAG_WITH(with),
SIPTAG_SUBJECT_STR("extended"),
TAG_END());
return 1;
default:
return 0;
}
}
int kqt_Handle_set_data(
kqt_Handle handle,
const char* key,
const void* data,
long length)
{
check_handle(handle, 0);
Handle* h = get_handle(handle);
check_data_is_valid(h, 0);
check_key(h, key, 0);
// Short-circuit if we have already got invalid data
// TODO: Remove this if we decide to collect more error info
if (Error_is_set(&h->validation_error))
return 1;
if (length < 0)
{
Handle_set_error(
h, ERROR_ARGUMENT, "Data length must be non-negative");
return 0;
}
if (data == NULL && length > 0)
{
Handle_set_error(
h,
ERROR_ARGUMENT,
"Data must not be null if given length (%ld) is positive",
length);
return 0;
}
if (!parse_data(h, key, data, length))
return 0;
h->data_is_validated = false;
return 1;
}
