int gif_main_init()
{
int colors_num;
unsigned char *colors;
int Size;
int i;
/* unsigned char *Buffer, *BufferP; */
fp_gif = fopen(".\\res\\res_gif\\porsche.gif", "rb"); // "porsche.gif" "jump.gif" "gif_gril.gif" "460.gif"
if(NULL == fp_gif)
{
assert(0);
}
if ((gif_file = DGifOpenFileHandle(fp_gif)) == NULL)
{
assert(0);
}
colors_num = (1<<gif_file->SColorMap->BitsPerPixel);
colors = gif_file->SColorMap->Colors;
BackGround = gif_file->SBackGroundColor;
ColorMap = (gif_file->Image.ColorMap ? gif_file->Image.ColorMap : gif_file->SColorMap);
ColorMapSize = ColorMap->ColorCount;
Size = gif_file->SWidth * sizeof(GifPixelType);
if ((GifRow = (GifRowType) mymalloc(Size)) == NULL)
{
assert(0); /* First row. */
}
for (i = 0; i < gif_file->SWidth; i++)
{
GifRow[i] = gif_file->SBackGroundColor;
}
open_trace_file();
#if 0
{
int i=0;
for(i=0; i<256;i++)
{
write_trace("", i);
write_trace(" ", ColorMap->Colors[i].Red);
write_trace(" ", ColorMap->Colors[i].Green);
write_trace(" ", ColorMap->Colors[i].Blue);
}
}
#endif
}
/*
* Determine the trace type for file 'fn'.
*
* Returns:
* TT_SCF, TT_CTF, TT_ZTR, TT_ABI, TT_ALF, TT_BIO, or TT_PLN for success.
* TT_UNK for unknown type.
* TT_ERR for error.
*/
int determine_trace_type(char *fn)
{
FILE *fp;
int r;
#ifdef USE_BIOLIMS
if(IS_BIOLIMS_PATH(fn))
return TT_BIO;
#endif
if ( (fp = open_trace_file(fn, NULL)) == NULL ) return TT_ERR;
r = fdetermine_trace_type(fp);
fclose(fp);
return r;
}
static jboolean RtkServer__rtksvrstart(JNIEnv* env, jclass thiz,
jint j_cycle,
jint j_buffsize,
jintArray j_strs,
jobjectArray j_paths,
jintArray j_format,
jint j_navsel,
jobjectArray j_cmds,
jobjectArray j_rcvopts,
jint j_nmea_cycle,
jint j_nmea_req,
jdoubleArray j_nmeapos,
jobject j_procopt,
jobject j_solopt1,
jobject j_solopt2
) {
struct native_ctx_t *nctx;
int i;
jobject obj;
jboolean res;
/* Input stream types */
int strs[8];
/* input stream paths */
const char *paths[8] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL };
jstring paths_jstring[8] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL };
/* input stream formats (STRFMT_???) */
int format[3];
/* input stream start commands */
const char *cmds[3] = {NULL, NULL, NULL};
jstring cmds_jstring[3] = {NULL, NULL, NULL};
/* receiver options */
const char *rcvopts[3] = {NULL, NULL, NULL};
char *rcvopts_jstring[3] = {NULL, NULL, NULL};
/* rtk processing options */
prcopt_t prcopt;
/* solution options */
solopt_t solopt[2];
/* nmea position */
double nmeapos[3];
res = JNI_FALSE;
for (i=0; i<sizeof(paths)/sizeof(paths[0]); ++i) {
paths_jstring[i] = (*env)->GetObjectArrayElement(env, j_paths, i);
if ((*env)->ExceptionOccurred(env))
goto rtksvrstart_end;
if (paths_jstring[i] != NULL) {
paths[i] = (*env)->GetStringUTFChars(env, paths_jstring[i], NULL);
if (paths[i] == NULL)
goto rtksvrstart_end;
}
}
for (i=0; i<sizeof(cmds)/sizeof(cmds[0]); ++i) {
cmds_jstring[i] = (*env)->GetObjectArrayElement(env, j_cmds, i);
if ((*env)->ExceptionOccurred(env))
goto rtksvrstart_end;
if (cmds_jstring[i] != NULL) {
cmds[i] = (*env)->GetStringUTFChars(env, cmds_jstring[i], NULL);
if (cmds[i] == NULL)
goto rtksvrstart_end;
}
}
for (i=0; i<sizeof(rcvopts)/sizeof(rcvopts[0]); ++i) {
rcvopts_jstring[i] = (*env)->GetObjectArrayElement(env, j_rcvopts, i);
if ((*env)->ExceptionOccurred(env))
goto rtksvrstart_end;
if (rcvopts_jstring[i] != NULL) {
rcvopts[i] = (*env)->GetStringUTFChars(env, rcvopts_jstring[i], NULL);
if (rcvopts[i] == NULL)
goto rtksvrstart_end;
}
}
(*env)->GetIntArrayRegion(env, j_strs, 0,
sizeof(strs)/sizeof(strs[0]), strs);
if ((*env)->ExceptionOccurred(env))
goto rtksvrstart_end;
(*env)->GetIntArrayRegion(env, j_format, 0,
sizeof(format)/sizeof(format[0]), format);
if ((*env)->ExceptionOccurred(env))
goto rtksvrstart_end;
(*env)->GetDoubleArrayRegion(env, j_nmeapos, 0,
sizeof(nmeapos)/sizeof(nmeapos[0]), nmeapos);
if ((*env)->ExceptionOccurred(env))
goto rtksvrstart_end;
solution_options2solopt_t(env, j_solopt1, &solopt[0]);
solution_options2solopt_t(env, j_solopt2, &solopt[1]);
nctx = (struct native_ctx_t *)(uintptr_t)(*env)->GetLongField(env, thiz, m_object_field);
if (nctx == NULL) {
LOGV("nctx is null");
goto rtksvrstart_end;
}
{
/* Open trace / solution files */
gtime_t now;
now = timeget();
if (solopt[0].trace > 0)
open_trace_file(env, solopt[0].trace, now);
/* treat processing options only now for having trace */
processing_options2prcopt_t(env, j_procopt, &prcopt);
if (solopt[0].sstat > 0)
open_solution_status_file(env, solopt[0].sstat, now);
}
if ((*env)->ExceptionOccurred(env))
goto rtksvrstart_end;
char errmsg[2048]=""; // Modif Mathieu Peyréga : adapt to new 2.4.3b26 API
char *cmds_periodic[]={NULL,NULL,NULL}; // Modif Mathieu Peyréga : adapt to new 2.4.3b26 API
if (!rtksvrstart(
&nctx->rtksvr,
/* SvrCycle ms */ j_cycle,
/* SvrBuffSize */ j_buffsize,
/* stream types */ strs,
/* paths */ (char **)paths,
/* input stream format */ format,
/* NavSelect */ j_navsel,
/* input stream start commands */ (char **)cmds,
/* input stream periodic commands */ (char **)cmds_periodic, // Modif Mathieu Peyréga : adapt to new 2.4.3b26 API
/* receiver options */ (char **)rcvopts,
/* nmea request cycle ms */ j_nmea_cycle,
/* nmea request type */ j_nmea_req,
/* transmitted nmea position */ nmeapos,
/* rtk processing options */&prcopt,
/* solution options */ solopt,
/* monitor stream */ &nctx->monistr,
/* err */errmsg // Modif Mathieu Peyréga : adapt to new 2.4.3b26 API
)) {
}else {
res = JNI_TRUE;
}
rtksvrstart_end:
for (i=0; i<sizeof(paths)/sizeof(paths[0]); ++i) {
if (paths[i] != NULL)
(*env)->ReleaseStringUTFChars(env, paths_jstring[i], paths[i]);
}
for (i=0; i<sizeof(cmds)/sizeof(cmds[0]); ++i) {
if (cmds[i] != NULL)
(*env)->ReleaseStringUTFChars(env, cmds_jstring[i], cmds[i]);
}
for (i=0; i<sizeof(rcvopts)/sizeof(rcvopts[0]); ++i) {
if (rcvopts[i] != NULL)
(*env)->ReleaseStringUTFChars(env, rcvopts_jstring[i], rcvopts[i]);
}
if (!res) {
traceclose();
rtkclosestat();
}
return res;
}
int convert(char *file, int format, mFILE *ofp, char *name, int output_conf) {
Read *r;
Exp_info *e;
char buf[50];
double aq;
if (format == TT_BIO) {
if (NULL == (r = read_reading(file, format))) {
fprintf(stderr, "%s: failed to read\n", file);
return 1;
}
} else {
FILE *infp;
if (NULL == (infp = open_trace_file(file, NULL))) {
perror(file);
return 1;
}
if (NULL == (r = fread_reading(infp, file, format))) {
fprintf(stderr, "%s: failed to read\n", file);
return 1;
}
fclose(infp);
}
e = read2exp(r, name);
if (NULL == e) {
fprintf(stderr, "Failed to create experiment file.\n");
read_deallocate(r);
return 1;
}
sprintf(buf, "%f", aq = avg_qual(r));
exp_set_entry(e, EFLT_AQ, buf);
exp_print_mfile(ofp, e);
if (output_conf && aq != 0) {
char *cstr;
int1 *conf;
int i;
conf = xmalloc(r->NBases * sizeof(*conf));
cstr = xmalloc(5 * r->NBases+2);
for (i = 0; i < r->NBases; i++) {
switch (r->base[i]) {
case 'a':
case 'A':
conf[i] = r->prob_A[i];
break;
case 'c':
case 'C':
conf[i] = r->prob_C[i];
break;
case 'g':
case 'G':
conf[i] = r->prob_G[i];
break;
case 't':
case 'T':
conf[i] = r->prob_T[i];
break;
default:
conf[i] = (r->prob_A[i] +
r->prob_C[i] +
r->prob_G[i] +
r->prob_T[i]) / 4;
break;
}
}
conf2str(conf, r->NBases, cstr);
exp_set_entry(e, EFLT_AV, cstr);
xfree(cstr);
xfree(conf);
}
read_deallocate(r);
exp_destroy_info(e);
mfflush(ofp);
return 0;
}
V_EXPORT VSCRIPT_STATUS VSCRIPT_CL_compile_to_bytecode(VSCRIPT_CL_CTX *ctx, const char *source_file, VSCRIPTXLIB *extlib)
{
VSCRIPT_STATUS ret;
FILE *fp;
int rt;
AST_BASE *ast;
vscript_ctx = (VSCRIPTCTX *) ctx;
vscript_ctx->extension_library = (struct tagXMETHODLIB *) extlib;
if ( MY_YY_open_file( source_file ) ) {
fprintf( stderr, "Can't open file %s\n", source_file );
return VSCRIPT_STATUS_CL_NO_INPUT_ERROR;
}
/* ********************************************** *
parsing
* ********************************************** */
ret = MY_YY_parse(&ast);
switch(ret) {
case MY_YY_PARSE_STATUS_OK:
{
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_TRACE) {
fprintf(stdout,"*** syntax ok ***\n");
}
if (! VTREE_check_tree( &vscript_ctx->my_ast_root->node )) {
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_TRACE) {
fprintf(stdout,"*** ERROR: parse tree is not ok ***\n");
}
return VSCRIPT_STATUS_INTERNAL_ERROR;
}
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_DUMP_AST) {
FILE *fp = open_trace_file(source_file, TRACE_FILE_AST);
if (fp) {
MY_YY_dump_as_xml( fp, vscript_ctx->my_ast_root );
fclose(fp);
}
}
}
break;
case MY_YY_PARSE_STATUS_SYNTAX_ERROR:
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_TRACE) {
fprintf(stderr,"*** ERROR: some kind of syntax error ***\n");
}
return VSCRIPT_STATUS_CL_SYNTAX_ERROR;
default:
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_TRACE) {
fprintf(stderr,"*** internal parser error (%d) ***\n",ret);
}
return VSCRIPT_STATUS_INTERNAL_ERROR;
}
/* ********************************************** *
semantics check / code gen
* ********************************************** */
if (!MY_YY_code_gen( vscript_ctx->my_ast_root )) {
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_TRACE) {
fprintf(stdout,"*** semantics and code generation ok ***\n");
}
} else {
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_TRACE) {
fprintf(stderr,"*** ERROR semantics or code generation ***\n");
}
return VSCRIPT_STATUS_CL_SEMANTIC_OR_CODEGEN_ERROR;
}
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_DUMP_LISTING) {
FILE *fp = open_trace_file( source_file, TRACE_FILE_LISTING);
if (fp) {
ASM_CONSTANT_POOL_dump(fp, vscript_ctx);
ASM_write_listing(fp, vscript_ctx->my_code );
fclose(fp);
}
}
/* ********************************************** *
link back references in opcodes
* ********************************************** */
//resolution of back references (now that all locations are set)
if (!ASM_resolve_backrefs( vscript_ctx->my_code )) {
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_TRACE) {
fprintf(stderr,"*** resolving back references ok ***\n");
}
} else {
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_TRACE) {
fprintf(stderr,"*** ERROR resolving back references ***\n");
}
return VSCRIPT_STATUS_CL_BACKREF_ERROR;
}
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_DUMP_LISTING_LINKED) {
FILE *fp = open_trace_file(source_file, TRACE_FILE_LISTING_RESOLVED);
if (fp) {
ASM_CONSTANT_POOL_dump(fp, vscript_ctx);
ASM_write_listing(fp, vscript_ctx->my_code );
fclose(fp);
}
}
/* ********************************************** *
write executable file
* ********************************************** */
fp = open_trace_file( source_file, TRACE_FILE_OUTPUT_FILE);
if (!fp) {
return VSCRIPT_STATUS_CL_WRITE_EXE_ERROR;
}
rt = EXE_write_exe_file( fp, vscript_ctx );
fclose(fp);
if (!rt) {
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_TRACE) {
fprintf(stderr,"*** write exe file ok ***\n");
}
} else {
if (vscript_ctx->trace_opts & VSCRIPT_CL_DEBUG_TRACE) {
fprintf(stderr,"*** ERROR write exe file ***\n");
}
return VSCRIPT_STATUS_CL_WRITE_EXE_ERROR;
}
return VSCRIPT_STATUS_OK;
}
/*
* ---------------------------------------------------------------------------
* Loads confidence values from the trace file and averages them.
* 'opos' is optional - if not known then set to NULL.
*
* Returns 0 for success
* -1 for failure
*/
int get_read_conf(Exp_info *e, int length, int2 *opos, int1 *conf) {
int ttype, i;
FILE *fp;
uint_1 *prob_A, *prob_C, *prob_G, *prob_T;
char *seq;
float scf_version;
int nbases = 0;
/* Sanity check */
if (!(exp_Nentries(e,EFLT_LT) && exp_Nentries(e,EFLT_LN)))
return -1;
/* Find and load trace file */
ttype = trace_type_str2int(exp_get_entry(e, EFLT_LT));
if (ttype != TT_SCF &&
ttype != TT_ZTR)
return -1;
/*
* We only support direct reading accuracy values from SCF files.
* Otherwise we have to take a slower approach.
*/
if (ttype != TT_SCF) {
Read *r;
int sec = read_sections(0);
read_sections(READ_BASES);
if (NULL == (r = read_reading(exp_get_entry(e,EFLT_LN), TT_ANYTR))) {
read_sections(sec);
return -1;
}
prob_A = (int1 *)xmalloc(r->NBases);
prob_C = (int1 *)xmalloc(r->NBases);
prob_G = (int1 *)xmalloc(r->NBases);
prob_T = (int1 *)xmalloc(r->NBases);
seq = (char *)xmalloc(r->NBases);
memcpy(prob_A, r->prob_A, r->NBases);
memcpy(prob_C, r->prob_C, r->NBases);
memcpy(prob_G, r->prob_G, r->NBases);
memcpy(prob_T, r->prob_T, r->NBases);
memcpy(seq, r->base, r->NBases);
nbases = r->NBases;
read_deallocate(r);
read_sections(sec);
} else {
Header h;
/* For SCF files we read directly - the above code would also do. */
if (NULL == (fp = open_trace_file(exp_get_entry(e,EFLT_LN), NULL)))
return -1;
/* Read the SCF header */
if (-1 == read_scf_header(fp, &h))
return -1;
scf_version = scf_version_str2float(h.version);
nbases = h.bases;
/* Alloc memory */
prob_A = (uint_1 *)xmalloc(h.bases * sizeof(*prob_A));
prob_C = (uint_1 *)xmalloc(h.bases * sizeof(*prob_A));
prob_G = (uint_1 *)xmalloc(h.bases * sizeof(*prob_A));
prob_T = (uint_1 *)xmalloc(h.bases * sizeof(*prob_A));
seq = (char *)xmalloc(h.bases * sizeof(*seq));
if (NULL == prob_A ||
NULL == prob_C ||
NULL == prob_G ||
NULL == prob_T ||
NULL == seq)
return -1;
/* Load base scores */
if (scf_version >= 3.0) {
/*
* Version 3 base format:
* num_bases * 4byte peak index
* num_bases * prob_A
* num_bases * prob_C
* num_bases * prob_G
* num_bases * prob_T
* num_bases * base
* num_bases * spare (x3)
*/
fseek(fp, (off_t)h.bases_offset + 4 * h.bases, SEEK_SET);
if (h.bases != fread(prob_A, 1, h.bases, fp))
return -1;
if (h.bases != fread(prob_C, 1, h.bases, fp))
return -1;
if (h.bases != fread(prob_G, 1, h.bases, fp))
return -1;
if (h.bases != fread(prob_T, 1, h.bases, fp))
return -1;
if (h.bases != fread(seq, 1, h.bases, fp))
return -1;
} else {
int i;
uint_1 buf[12];
/*
* Version 2 base format
* num_bases * base_struct, where base_struct is 12 bytes:
* 0-3 peak_index
* 4-7 prob_A/C/G/T
* 8 base
* 9- spare
*/
fseek(fp, (off_t)h.bases_offset, SEEK_SET);
for (i = 0; (unsigned)i < h.bases; i++) {
if (1 != fread(buf, 12, 1, fp))
return -1;
prob_A[i] = buf[4];
prob_C[i] = buf[5];
prob_G[i] = buf[6];
prob_T[i] = buf[7];
seq[i] = buf[8];
}
}
fclose(fp);
}
/* Determine confidence values */
if (opos) {
for (i=0; i<length; i++) {
if (opos[i] == 0) {
/* Inserted base, change to 0% */
conf[i] = 0;
} else {
switch(seq[opos[i]-1]) {
case 'a':
case 'A':
conf[i] = prob_A[opos[i]-1];
break;
case 'c':
case 'C':
conf[i] = prob_C[opos[i]-1];
break;
case 'g':
case 'G':
conf[i] = prob_G[opos[i]-1];
break;
case 't':
case 'T':
conf[i] = prob_T[opos[i]-1];
break;
default:
conf[i] = 2;
}
}
}
} else {
int mlength = MIN(length, nbases);
for (i=0; i < mlength; i++) {
switch(seq[i]) {
case 'a':
case 'A':
conf[i] = prob_A[i];
break;
case 'c':
case 'C':
conf[i] = prob_C[i];
break;
case 'g':
case 'G':
conf[i] = prob_G[i];
break;
case 't':
case 'T':
conf[i] = prob_T[i];
break;
case 'n':
case 'N':
case '-':
conf[i] = (prob_A[i] + prob_C[i] + prob_G[i] + prob_T[i]) / 4;
break;
default:
conf[i] = 2;
}
}
for (; i < length; i++)
conf[i] = 2;
}
xfree(prob_A);
xfree(prob_C);
xfree(prob_G);
xfree(prob_T);
xfree(seq);
return 0;
}
int trace_main(char *hostIp, int portNum, char *imsi, int outflag, char *path)
{
int fd_stdin, peersock, maxfd, status, readsize;
int selStatus;
fd_set fdset_Read;
FILE *fp = NULL;
char buff[128];
struct timeval timeout;
fd_stdin = fileno(stdin);
peersock = connect_to_peer(hostIp, portNum);
if(peersock < 0)
return 1;
if(outflag){
fp = open_trace_file(path, imsi);
if(!fp)
exit(1);
}
timeout.tv_sec = 0;
timeout.tv_usec = 100;
while(1){
FD_ZERO(&fdset_Read);
FD_SET(fd_stdin, &fdset_Read);
FD_SET(peersock, &fdset_Read);
maxfd = (fd_stdin >= peersock)?fd_stdin:peersock;
maxfd += 1;
selStatus = select(maxfd, &fdset_Read, NULL, NULL, &timeout);
if(selStatus < 0){
fprintf(stderr, "[ERROR] select - %s\n", strerror(errno));
}else if(selStatus > 0){
if(FD_ISSET(fd_stdin, &fdset_Read)){
memset(buff, 0x00, sizeof(buff));
read_from_fd(fd_stdin, buff, 1);
if(buff[0] == 'q' || buff[0] == 'Q'){
close(peersock);
fclose(fp);
return 1;
}
}
if(FD_ISSET(peersock, &fdset_Read)){
status = read_trace(peersock, fp, imsi);
if(status < 0){
// try to reconnect to peer.
peersock = connect_to_peer(hostIp, portNum);
if(peersock < 0)
return 1;
}
}
}
#ifdef DEBUG_1
else{
printf(".");
}
#endif
}
return 0;
}
