snet_record_t *SNetRecCreate( snet_record_descr_t descr, ...)
{
snet_record_t *rec;
va_list args;
rec = SNetMemAlloc( sizeof( snet_record_t));
REC_DESCR( rec) = descr;
va_start( args, descr);
switch (descr) {
case REC_data:
RECPTR( rec) = SNetMemAlloc( sizeof( snet_record_types_t));
RECORD( rec, data_rec) = SNetMemAlloc( sizeof( data_rec_t));
DATA_REC( rec, btags) = SNetIntMapCreate(0);
DATA_REC( rec, tags) = SNetIntMapCreate(0);
DATA_REC( rec, fields) = SNetRefMapCreate(0);
DATA_REC( rec, mode) = MODE_binary;
GenerateRecId( &DATA_REC( rec, rid) );
DATA_REC( rec, parent_rids) = NULL;
DATA_REC( rec, interface_id) = 0;
break;
case REC_trigger_initialiser:
RECPTR( rec) = SNetMemAlloc( sizeof( snet_record_types_t));
break;
case REC_sync:
{
RECPTR( rec) = SNetMemAlloc( sizeof( snet_record_types_t));
RECORD( rec, sync_rec) = SNetMemAlloc( sizeof( sync_rec_t));
SYNC_REC( rec, input) = va_arg( args, snet_stream_t *);
SYNC_REC( rec, outtype) = NULL;
}
break;
case REC_collect:
RECPTR( rec) = SNetMemAlloc( sizeof( snet_record_types_t));
RECORD( rec, coll_rec) = SNetMemAlloc( sizeof( coll_rec_t));
COLL_REC( rec, output) = va_arg( args, snet_stream_t*);
break;
case REC_terminate:
RECPTR( rec) = SNetMemAlloc( sizeof( snet_record_types_t));
RECORD( rec, terminate_rec) = SNetMemAlloc( sizeof( terminate_rec_t));
TERM_REC( rec, local) = false;
break;
case REC_sort_end:
RECPTR( rec) = SNetMemAlloc( sizeof( snet_record_types_t));
RECORD( rec, sort_end_rec) = SNetMemAlloc( sizeof( sort_end_rec_t));
SORT_E_REC( rec, level) = va_arg( args, int);
SORT_E_REC( rec, num) = va_arg( args, int);
break;
default:
SNetUtilDebugFatal("Unknown control record description. [%d]", descr);
break;
}
va_end( args);
return rec;
}
int main(int argc, char * argv[]) {
RECORD(7, c1, c2, i, j, k, n, v);
INIT_n(unknownu);
assume(n > 0);
assume(n < 10);
INIT_j(unknown);
INIT_v(unknown);
c1 = 4000;
c2 = 2000;
k = 0;
i = 0;
while (i < n) {
PRINT_VARS();
i++;
if (unknown4())
v = 0;
else
v = 1;
if (v == 0)
k += c1;
else
k += c2;
}
PRINT_VARS();
assert(k > n);
}
/* Range from 0 to 100 */
int mxuvc_audio_set_volume(int vol)
{
RECORD("%i", vol);
int ret;
int16_t uac_vol;
AUDIO_CTRL *ctrl;
TRACE("Setting audio volume to %i\n", vol);
CHECK_ERROR(vol < 0 || vol > 100, -1, "Unable to set audio "
"volume to %i. Volume must be in the range "
"[0; 100].", vol);
ctrl = get_ctrl_by_id(CTRL_VOLUME);
uac_vol = (ctrl->max-ctrl->min)*vol/100 + ctrl->min;
if(aud_cfg.vol != uac_vol){
aud_cfg.vol = uac_vol;
ret = set_ctrl(CTRL_VOLUME, SET_CUR, &uac_vol);
CHECK_ERROR(ret < 0, -1, "Unable to set audio volume to %i",
vol);
} else {
TRACE("Audio volume already set to %i\n", vol);
}
return 0;
}
int main(int argc, char * argv[]) {
RECORD(4, x, m, input, N);
x = 0;
m = 0;
INIT_N(unknown);
INIT_input(unknown);
while (x < N) {
PRINT_VARS();
input = unknown();
if (input != 0) {
m = x;
}
x = x + 1;
}
PRINT_VARS();
if (N > 0) {
assert((0 <= m) && (m < N));
}
return 0;
}
int mxuvc_audio_set_format(audio_channel_t ch, audio_format_t fmt)
{
RECORD("%s", audformat2str(fmt));
CHECK_ERROR(ch >= audio_num_channels, -1,
"Unsupported channel number %d", ch);
TRACE("Setting audio format to %s.\n", audformat2str(fmt));
switch(fmt) {
case AUD_FORMAT_AAC_RAW:
ERROR(-1, "Unable to set the audio format to AAC. Audio "
"format not implemented");
cur_aud_format = AUD_FORMAT_AAC_RAW;
break;
case AUD_FORMAT_PCM_RAW:
cur_aud_format = AUD_FORMAT_PCM_RAW;
break;
default:
ERROR(-1, "Unable to set the audio format: unknown audio "
"format %i", fmt);
break;
}
return 0;
}
int main(int argc, char * argv[]) {
RECORD(4, i, j, k, n);
INIT_j(unknown);
INIT_k(unknown);
INIT_n(unknown);
for (i = 0; i < n; i++) {
PRINT_VARS();
PRINT_BAR(1);
for (j = i; j < n; j++) {
PRINT_VARS();
PRINT_BAR(2);
for (k = j; k < n; k++) {
PRINT_VARS();
assert(k >= i);
}
PRINT_VARS();
PRINT_BAR(3);
}
PRINT_VARS();
PRINT_BAR(2);
}
PRINT_VARS();
PRINT_BAR(1);
}
int main(int argc, char* argv[]) {
RECORD(4, i, j, k, n);
INIT_n(unknown);
k = 1;
i = 1;
j = 0;
while(i < n) {
PRINT_VARS();
PRINT_BAR(1);
assert(k >= i);
j = 0;
while(j < i) {
PRINT_VARS();
k += (i - j);
j++;
}
PRINT_VARS();
PRINT_BAR(2);
i++;
}
PRINT_VARS();
PRINT_BAR(1);
return 0;
}
int main(int argc, char* argv[]) {
RECORD(6, i, j, k, n, t, pvlen);
INIT_j(unknown);
INIT_n(unknown);
INIT_t(unknown);
INIT_pvlen(unknown);
k = 0;
i = 0;
// pkt = pktq->tqh_first;
while (unknown1()) {
PRINT_VARS();
i = i + 1;
}
PRINT_VARS();
PRINT_BAR(1);
if (i > pvlen) {
pvlen = i;
} else {
}
i = 0;
while (unknown2()) {
PRINT_VARS();
t = i;
i = i + 1;
k = k + 1;
}
PRINT_VARS();
PRINT_BAR(2);
while (unknown3()) {
PRINT_VARS();
;
}
PRINT_VARS();
PRINT_BAR(3);
j = 0;
n = i;
assert(k >= 0);
k = k - 1;
i = i - 1;
j = j + 1;
while (j < n) {
PRINT_VARS();
assert(k >= 0);
k = k - 1;
i = i - 1;
j = j + 1;
}
PRINT_VARS();
PRINT_BAR(4);
return 0;
}
/* Get the current sample rate */
int mxuvc_audio_get_samplerate(audio_channel_t ch)
{
RECORD("");
CHECK_ERROR(ch >= audio_num_channels, -1,
"Unsupported channel number %d", ch);
return aud_cfg.format[aud_cfg.fmt_idx].samFr;
}
int mxuvc_audio_set_mic_mute(int bMute)
{
RECORD("%i", bMute);
TRACE("Setting mic mute to %i\n", bMute);
int16_t ctrlVal = ((int16_t) bMute) & 0x1;
set_ctrl(CTRL_MUTE, SET_CUR, &ctrlVal);
return 0;
}
void UpdateApplication::check(bool show)
// ----------------------------------------------------------------------------
// Check for update
// ----------------------------------------------------------------------------
{
// This method starts the "check for update" algorithm which is
// asynchronous.
// If 'show' is true, a progress dialog may be shown during the check, and
// a dialog is shown at the end to tell if update is available or not.
// If 'show' is false, no interaction with the user occurs
// until the algorithm detects that an update is available.
RECORD(ALWAYS, "Check for update");
IFTRACE(update)
debug() << "Checking for update (interactive: " << show << ")\n";
this->show = show;
if (show && state != Idle)
{
// Already running. Just show the progress dialog.
progress->show();
return;
}
if (edition.isEmpty())
{
showNoUpdateAvailable();
return;
}
if (!manager)
manager = new QNetworkAccessManager();
progress->setLabelText(tr("Checking for update"));
if (show)
progress->show();
// The URL where to get update information from. Redirects to a .ini file.
#ifdef CFG_LIBRE_EDITION
QUrl url("http://www.taodyne.com/taopresentations/2.0/update");
#else
QUrl url("http://www.taodyne.com/taopresentations/2.0-libre/update");
#endif
IFTRACE(update)
debug() << "Downloading: '" << +url.toString() << "'\n";
state = WaitingForUpdate;
// Create and send HTTP request
request.setUrl(url);
reply = manager->get(request);
connectSignals(reply);
}
int mxuvc_audio_register_cb(audio_channel_t ch, mxuvc_audio_cb_t func, void *user_data)
{
RECORD("%p, %p",func, user_data);
CHECK_ERROR(ch >= audio_num_channels, -1,
"Unsupported channel number %d", ch);
aud_cb = func;
aud_cb_user_data = user_data;
return 0;
}
/* Deinitialize the audio path */
int mxuvc_audio_deinit()
{
RECORD("");
int ret, i;
int int_num[2] = {aud_cfg.ctrlif, aud_cfg.interface};
if(!audio_initialized)
return 1;
deregister_libusb_removal_cb((libusb_pollfd_removed_cb) audio_removed);
if(!audio_disconnected) {
/* Stop the audio first if not stopped yet */
if(aud_started == 1)
mxuvc_audio_stop(AUD_CH1);
for(i=0; i<2; i++) {
TRACE2("Releasing audio interface %i\n", int_num[i]);
ret = libusb_release_interface(audio_hdl, int_num[i]);
CHECK_ERROR(ret < 0 && ret != LIBUSB_ERROR_NOT_FOUND &&
ret != LIBUSB_ERROR_NO_DEVICE, -1,
"Unable to release USB interface %i. Libusb "
"return code is: %i", int_num[i], ret);
}
/* Re-attach the previously attached kernel driver */
for(i=0; i<2; i++)
libusb_attach_kernel_driver(audio_hdl, int_num[i]);
}
/* Exit Camera Event loop/thread */
stop_libusb_events();
/* Free USB resources */
TRACE("Freeing USB audio resources\n");
//if(mxuvc_audio_alive())
libusb_close(audio_hdl);
exit_libusb(&audio_ctx);
if(aud_cfg.xfers) {
free(aud_cfg.xfers);
aud_cfg.xfers = NULL;
}
if(abuf) {
free(abuf);
abuf = NULL;
}
audio_hdl = NULL;
audio_ctx = NULL;
audio_initialized = 0;
TRACE("The audio has been successfully uninitialized\n");
//mxuvc_debug_stoprec();
return 0;
}
void SNetRecDestroy( snet_record_t *rec)
{
int name;
snet_ref_t *field;
switch (REC_DESCR( rec)) {
case REC_data:
RECORD_FOR_EACH_FIELD(rec, name, field) {
SNetRefDestroy(field);
}
SNetRefMapDestroy( DATA_REC( rec, fields));
SNetIntMapDestroy( DATA_REC( rec, tags));
SNetIntMapDestroy( DATA_REC( rec, btags));
if (DATA_REC( rec, parent_rids) != NULL) SNetRecIdListDestroy( DATA_REC( rec, parent_rids));
SNetMemFree( RECORD( rec, data_rec));
break;
case REC_sync:
{
snet_variant_t *var = SYNC_REC( rec, outtype);
if (var != NULL) {
SNetVariantDestroy(var);
}
SNetMemFree( RECORD( rec, sync_rec));
}
break;
case REC_collect:
SNetMemFree( RECORD( rec, coll_rec));
break;
case REC_sort_end:
SNetMemFree( RECORD( rec, sort_end_rec));
break;
case REC_terminate:
SNetMemFree( RECORD( rec, terminate_rec));
break;
case REC_trigger_initialiser:
break;
default:
SNetUtilDebugFatal("Unknown record description, in SNetRecDestroy");
break;
}
int startRecord()
{
int i;
int res;
int pollres;
struct input_event event;
int version;
const char *device = NULL;
const char *device_path = "/dev/input";
nfds = 1;
ufds = (pollfd*)calloc(1, sizeof(ufds[0]));
ufds[0].fd = inotify_init();
ufds[0].events = POLLIN;
res = inotify_add_watch(ufds[0].fd, device_path, IN_DELETE | IN_CREATE);
if(res < 0) {
fprintf(stderr, "could not add watch for %s, %s\n", device_path, strerror(errno));
return 1;
}
res = scan_dir(device_path);
if(res < 0) {
fprintf(stderr, "scan dir failed for %s\n", device_path);
return 1;
}
while(1) {
pollres = poll(ufds, nfds, -1);
if(ufds[0].revents & POLLIN) {
read_notify(device_path, ufds[0].fd);
}
for(i = 1; i < nfds; i++) {
if(ufds[i].revents) {
if(ufds[i].revents & POLLIN) {
res = read(ufds[i].fd, &event, sizeof(event));
if(res < (int)sizeof(event)) {
fprintf(stderr, "could not get event\n");
return 1;
}
RECORD("[%8ld.%06ld] %s: %x %x %x\n", event.time.tv_sec, event.time.tv_usec, device_names[i], event.type, event.code, event.value);
}
}
}
}
return 0;
}
int main(int argc, char * argv[]) {
RECORD(3, i, j, x);
INIT_i(unknown);
j = 0;
x = 100;
for (i = 0; i < x; i++) {
PRINT_VARS();
j = j + 2;
}
PRINT_VARS();
assert(j == 2 * x);
}
int main(int argc, char * argv[]) {
RECORD(2, x, N);
INIT_N(unknownu);
assume(N >= 0);
x = 0;
while (x < N) {
PRINT_VARS();
x = x + 1;
}
PRINT_VARS();
assert(x == N);
return 0;
}
int main(int argc, char * argv[]) {
RECORD(2, i, j);
i = 1;
j = 10;
while (j >= i) {
PRINT_VARS();
i = i + 2;
j = j - 1;
}
PRINT_VARS();
assert(j == 6);
return 0;
}
int main(int argc, char * argv[]) {
RECORD(4, a, b, j, flag);
INIT_a(unknown);
INIT_b(unknown);
INIT_flag(unknown);
j = 0;
for (b = 0; b < 100; ++b) {
PRINT_VARS();
if (flag != 0) j = j + 1;
}
PRINT_VARS();
if (flag != 0) assert(j == 100);
}
int main(int argc, char* argv[]) {
RECORD(5, i, m, n, x, y);
INIT_n(unknown);
x = 0; y = 0; i = 0; m = 10;
while(i < n) {
PRINT_VARS();
i++;
x++;
if(i % 2 == 0) y++;
}
PRINT_VARS();
if(i == m) assert(x == 2 * y);
return 0;
}
int main(int argc, char * argv[]) {
RECORD(3, n, r, x);
n = 0;
x = 0;
INIT_r(unknown);
while (r != 0) {
PRINT_VARS();
n++;
x += 2 * n - 1;
r = unknown();
}
PRINT_VARS();
assert(x == n * n);
}
int main(int argc, char* argv[]) {
RECORD(4, i, j, k, n);
INIT_n(unknown);
assume(n > 0);
INIT_k(unknown);
assume(k > n);
j = 0;
while(j < n) {
PRINT_VARS();
j++;
k--;
}
PRINT_VARS();
assert(k >= 0);
return 0;
}
int main(int argc, char* argv[]) {
RECORD(5, i, j, k, n, m);
INIT_m(unknown1);
INIT_n(unknown1);
assume(m + 1 < n);
INIT_i(unknown1);
INIT_j(unknown1);
INIT_k(unknown1);
for (i = 0; i < n; i += 4) {
PRINT_VARS();
PRINT_BAR(1);
for (j = i; j < m;) {
PRINT_VARS();
PRINT_BAR(2);
if (unknown1()) {
assert(j >= 0);
j++;
k = 0;
while (k < j) {
PRINT_VARS();
k++;
}
PRINT_VARS();
PRINT_BAR(3);
} else {
assert(n + j + 5 > i);
j += 2;
}
}
PRINT_VARS();
PRINT_BAR(2);
}
PRINT_VARS();
PRINT_BAR(1);
assert(true);
return 0;
}
void Initialize()
// ----------------------------------------------------------------------------
// Initialize application symbols
// ----------------------------------------------------------------------------
{
RECORD(ALWAYS, "Initializing XLR symbols");
XL::EnterBasics();
Tao::EnterGraphics();
Tao::EnterAttributes();
Tao::EnterShapes();
Tao::EnterShapes3D();
Tao::EnterTables();
Tao::EnterFrames();
Tao::EnterTextDrawing();
Tao::EnterWidgetSurfaces();
Tao::EnterManipulators();
Tao::EnterTransforms();
Tao::EnterLighting();
Tao::EnterChooser();
}
int main(int argc, char * argv[]) {
RECORD(4, j, x, y, s);
INIT_x(unknown);
assume(x >= 0);
INIT_y(unknown);
s = 0;
j = 0;
while (j < x) {
PRINT_VARS();
s = s + y;
j++;
}
PRINT_VARS();
assert(s == x * y);
}
int main(int argc, char * argv[]) {
RECORD(4, k, x, y, z);
x = 0;
y = 0;
z = 0;
k = 0;
while (unknown1()) {
PRINT_VARS();
if (k % 3 == 0) x++;
y++;
z++;
k = x + y + z;
}
PRINT_VARS();
assert(x == y);
assert(y == z);
}
int main(int argc, char * argv[]) {
RECORD(4, x, n1, sn, loop1);
x = 0;
sn = 0;
INIT_n1(unknown);
INIT_loop1(unknown);
while(true) {
PRINT_VARS();
sn = sn + 1;
x++;
assert(sn == x*1 || sn == 0);
}
PRINT_VARS();
assert(false);
}
/* Sets the sample rate */
int mxuvc_audio_set_samplerate(audio_channel_t ch, int samplingFr)
{
RECORD("%i", samplingFr);
int i, splr, restart=0, ret;
CHECK_ERROR(ch >= audio_num_channels, -1,
"Unsupported channel number %d", ch);
TRACE("Setting audio sample rate to %i.\n", samplingFr);
if(aud_started) {
ret = _mxuvc_audio_stop(ch);
CHECK_ERROR(ret < 0, -1,
"Could not set the audio sample rate to %i",
samplingFr);
restart = 1;
}
/* Select alt settings [1:8khz] [2:16khz] [3:24khz] */
for(i=0;i<MAX_AUD_FMTS;i++) {
if(aud_cfg.format[i].samFr != samplingFr)
continue;
aud_cfg.fmt_idx = i;
splr = aud_cfg.format[aud_cfg.fmt_idx].samFr;
aud_target_size = AUD_NUM_CH*2*splr*audio_duration_ms/1000;
if(restart) {
ret = _mxuvc_audio_start(ch);
CHECK_ERROR(ret < 0, -1,
"Could not set the audio sample rate to %i",
samplingFr);
}
return 0;
}
ERROR_NORET("Could not set the audio sample rate to %i: "
"sample rate not available.", samplingFr);
return -1;
}
int main(int argc, char * argv[]) {
RECORD(6, a, b, i, j, k, flag);
INIT_a(unknown);
INIT_b(unknown);
INIT_k(unknown);
INIT_flag(unknown);
j = 1;
if (flag != 0) {
i = 0;
} else {
i = 1;
}
while (unknown1()) {
PRINT_VARS();
i += 2;
if (i % 2 == 0) {
j += 2;
} else
j++;
}
PRINT_VARS();
PRINT_BAR(1);
a = 0;
b = 0;
while (unknown2()) {
PRINT_VARS();
a++;
b += (j - i);
}
PRINT_VARS();
PRINT_BAR(2);
if (flag != 0) assert(a == b);
}
int w2rcox ( int cmd, WTFUN_ARRAY *awtfp, int coll )
{
#endif
/* read all language bit strigs
*/
#if PARMLANG
WTFUN_XWT *xwtp=awtfp->vwtfp[coll]; // current
if (parmlanguage) {
if (readnlangs >= MAXPARMLANG) fatal("wtrig2/terminverted/lang/MAXPARMLANG");
for (langidx=0; langidx < readnlangs; langidx++) {
int xdir;
/* read */
RECORD(ifrec,colxdb,readnterms+langidx+1);
if (RECrc != RCNORMAL) fatal("wtrig2/terminverted/lang/RCNORMAL");
/* allocate */
langshits[nlangs]=(char *)loadfile(NULL,'@',"",NULL,hitbytes,'\0');
/* store bit string */
xdir=fieldx(ifrec,TAG35,1); if (xdir < 0) fatal("wtrig2/terminverted/lang/TAG35");
memmove(langshits[nlangs],FIELDP(xdir),hitbytes);
/* store name */
xdir=fieldx(ifrec,TAG34,1); if (xdir < 0) fatal("wtrig2/terminverted/lang/TAG34");
for (p=FIELDP(xdir), left=DIRlen(xdir); left--; ) {
if (*p == '^') break;
*p=isisuctab[*p]; p++;
}
*p='\0'; /* ok */
langsname[nlangs]=strdup(FIELDP(xdir)); //...
langscount[nlangs++]=0;
}
if (nlangs != readnlangs) fatal("wtrig2/terminverted/lang/nlangs");
}
#endif /* PARMLANG */
#if WHENFUN
return 0;
}
