예제 #1
0
파일: rtest.c 프로젝트: softirq/common
int main(int argc, char **argv)
{
    printf("read index files\n");
    open_index("test1.idx", &name1,0);

    printf("List the keys in each index file in ascending order:\n\n");
    uplist(&name1);

    printf("List the keys for each index file in decending order\n\n");
    downlist(&name1);

    /* always close all files */
    close_index(&name1);
}
예제 #2
0
// {string name, int32 start_sec, int32 start_nano,
//               int32 end_sec,   int32 end_nano}[]
// = archiver.names(int32 key, string pattern)
xmlrpc_value *get_names(xmlrpc_env *env, xmlrpc_value *args, void *user)
{
#ifdef LOGFILE
    LOG_MSG("archiver.names\n");
#endif
    // Get args, maybe setup pattern
    AutoPtr<RegularExpression> regex;
    xmlrpc_int32 key;
    char *pattern = 0;
    size_t pattern_len = 0; 
    xmlrpc_parse_value(env, args, "(is#)", &key, &pattern, &pattern_len);
    if (env->fault_occurred)
        return 0;
    // Create result
    AutoXmlRpcValue result(xmlrpc_build_value(env, "()"));
    if (env->fault_occurred)
        return 0;
    try
    {
        if (pattern_len > 0)
            regex.assign(new RegularExpression(pattern));
        // Open Index
        stdString directory;
        AutoPtr<Index> index(open_index(env, key));
        if (env->fault_occurred)
            return 0;
        // Put all names in binary tree
        Index::NameIterator ni;
        BinaryTree<ChannelInfo> channels;
        ChannelInfo info;
        bool ok;
        for (ok = index->getFirstChannel(ni);
             ok; ok = index->getNextChannel(ni))
        {
            if (regex && !regex->doesMatch(ni.getName()))
                continue; // skip what doesn't match regex
            info.name = ni.getName();
            AutoPtr<RTree> tree(index->getTree(info.name, directory));
            if (tree)
                tree->getInterval(info.start, info.end);
            else // Is this an error?
                info.start = info.end = nullTime;
            channels.add(info);
        }
        index->close();
        // Sorted dump of names
        ChannelInfo::UserArg user_arg;
        user_arg.env = env;
        user_arg.result = result;
        channels.traverse(ChannelInfo::add_name_to_result, (void *)&user_arg);
#ifdef LOGFILE
        LOG_MSG("get_names(%d, '%s') -> %d names\n",
                key,
                (pattern ? pattern : "<no pattern>"),
                xmlrpc_array_size(env, result));
#endif
    }
    catch (GenericException &e)
    {
        xmlrpc_env_set_fault_formatted(env, ARCH_DAT_SERV_FAULT,
                                       (char *) e.what());
        return 0;
    }
    return result.release();
}
예제 #3
0
// Return the data for all the names[], start .. end etc.
// as get_values() is supposed to return them.
//
// Returns raw values if interpol <= 0.0.
// Returns 0 on error.
xmlrpc_value *get_sheet_data(xmlrpc_env *env,
                             int key,
                             const stdVector<stdString> names,
                             const epicsTime &start, const epicsTime &end,
                             long count,
                             ReaderFactory::How how, double delta)
{
    try
    {
#ifdef LOGFILE
        stdString txt;
        LOG_MSG("get_sheet_data\n");
        LOG_MSG("Start : %s\n", epicsTimeTxt(start, txt));
        LOG_MSG("End   : %s\n", epicsTimeTxt(end, txt));
        LOG_MSG("Method: %s\n", ReaderFactory::toString(how, delta));
 #endif
        AutoPtr<Index> index(open_index(env, key));
        if (env->fault_occurred)
            return 0;

        AutoPtr<SpreadsheetReader> sheet(new SpreadsheetReader(*index, how, delta));
    
        AutoXmlRpcValue results(xmlrpc_build_value(env, "()"));
        if (env->fault_occurred)
            return 0;    

        long name_count = names.size();
        AutoArrayPtr<AutoXmlRpcValue> meta     (new AutoXmlRpcValue[name_count]);
        AutoArrayPtr<AutoXmlRpcValue> values   (new AutoXmlRpcValue[name_count]);
        AutoArrayPtr<xmlrpc_int32>    xml_type (new xmlrpc_int32[name_count]);
        AutoArrayPtr<xmlrpc_int32>    xml_count(new xmlrpc_int32[name_count]);
        AutoArrayPtr<size_t>          ch_vals  (new size_t[name_count]);
        bool ok = sheet->find(names, &start);
        long i;
        // Per-channel meta-info.
        for (i=0; i<name_count; ++i)
        {
#ifdef LOGFILE
            LOG_MSG("Handling '%s'\n", names[i].c_str());
#endif
            ch_vals[i] = 0;
            values[i] = xmlrpc_build_value(env, "()");            
            if (env->fault_occurred)
                return 0;
            if (sheet->found(i))
            {   // Fix meta/type/count based on first value
                meta[i] = encode_ctrl_info(env, &sheet->getInfo(i));
                dbr_type_to_xml_type(sheet->getType(i), sheet->getCount(i),
                                     xml_type[i], xml_count[i]);
#if 0
                LOG_MSG("Ch %lu: type, count = %d, %d\n", i, (int)xml_type[i], (int)xml_count[i]);
#endif
            }
            else
            {   // Channel exists, but has no data
                meta[i] = encode_ctrl_info(env, 0);
                xml_type[i] = XML_ENUM;
                xml_count[i] = 1;
            }
        }
        // Collect values
        long num_vals = 0;
        while (ok && num_vals < count && sheet->getTime() < end)
        {
            for (i=0; i<name_count; ++i)
            {
                if (sheet->get(i))
                {
                    ++ch_vals[i];
                    encode_value(env,
                                 sheet->getType(i), sheet->getCount(i),
                                 sheet->getTime(), sheet->get(i),
                                 xml_type[i], xml_count[i], values[i]);
                }
                else
                {   // Encode as no value, but one of them ;-)
                    // to avoid confusion w/ viewers that like to see some data in any case.
                    encode_value(env, 0, 1, sheet->getTime(), 0,
                                 xml_type[i], xml_count[i], values[i]);
                }
                
            }
            ++num_vals;
            ok = sheet->next();
        }
        // Assemble result = { name, meta, type, count, values }
        for (i=0; i<name_count; ++i)
        {
            AutoXmlRpcValue result(
                xmlrpc_build_value(env, "{s:s,s:V,s:i,s:i,s:V}",
                                   "name",   names[i].c_str(),
                                   "meta",   meta[i].get(),
                                   "type",   xml_type[i],
                                   "count",  xml_count[i],
                                   "values", values[i].get()));    
            // Add to result array
            xmlrpc_array_append_item(env, results, result);
#ifdef LOGFILE
            LOG_MSG("Ch %lu: %zu values\n", i, ch_vals[i]);
#endif
        }
#ifdef LOGFILE
        LOG_MSG("%ld values total\n", num_vals);
#endif
        return results.release();
    }
    catch (GenericException &e)
    {
#ifdef LOGFILE
        LOG_MSG("Error:\n%s\n", e.what());
#endif
        xmlrpc_env_set_fault_formatted(env, ARCH_DAT_DATA_ERROR,
                                       "%s", e.what());
    }
    return 0;
}
예제 #4
0
// Return the data for all the names[], start .. end etc.
// as get_values() is supposed to return them.
// Returns 0 on error.
xmlrpc_value *get_channel_data(xmlrpc_env *env,
                               int key,
                               const stdVector<stdString> names,
                               const epicsTime &start, const epicsTime &end,
                               long count,
                               ReaderFactory::How how, double delta)
{
    AutoXmlRpcValue results;
    try
    {
#ifdef LOGFILE
        stdString txt;
        LOG_MSG("get_channel_data\n");
        LOG_MSG("Method: %s\n", ReaderFactory::toString(how, delta));
        LOG_MSG("Start:  %s\n", epicsTimeTxt(start, txt));
        LOG_MSG("End  :  %s\n", epicsTimeTxt(end, txt));
#endif
        AutoPtr<Index> index(open_index(env, key));
        if (env->fault_occurred)
            return 0;
        AutoPtr<DataReader> reader(ReaderFactory::create(*index, how, delta));
        results = xmlrpc_build_value(env, "()");
        if (env->fault_occurred)
            return 0;
        long i, name_count = names.size();
        for (i=0; i<name_count; ++i)
        {
#ifdef LOGFILE
            LOG_MSG("Handling '%s'\n", names[i].c_str());
#endif
            long num_vals = 0;            
            AutoXmlRpcValue values(xmlrpc_build_value(env, "()"));
            if (env->fault_occurred)
                return 0;
            const RawValue::Data *data = reader->find(names[i], &start);
            AutoXmlRpcValue meta;
            xmlrpc_int32 xml_type, xml_count;
            if (data == 0)
            {   // No exception from file error etc., just no data.
                meta = encode_ctrl_info(env, 0);
                xml_type = XML_ENUM;
                xml_count = 1;
            }
            else
            {
                // Fix meta/type/count based on first value
                meta = encode_ctrl_info(env, &reader->getInfo());
                dbr_type_to_xml_type(reader->getType(), reader->getCount(),
                                     xml_type, xml_count);
                while (num_vals < count
                       && data
                       && RawValue::getTime(data) < end)
                {
                    encode_value(env, reader->getType(), reader->getCount(),
                                 RawValue::getTime(data), data,
                                 xml_type, xml_count, values);
                    ++num_vals;
                    data = reader->next();
                }
            }
            // Assemble result = { name, meta, type, count, values }
            AutoXmlRpcValue result(xmlrpc_build_value(
                                       env, "{s:s,s:V,s:i,s:i,s:V}",
                                       "name",   names[i].c_str(),
                                       "meta",   (xmlrpc_value *)meta,
                                       "type",   xml_type,
                                       "count",  xml_count,
                                       "values", (xmlrpc_value *)values));
            // Add to result array
            xmlrpc_array_append_item(env, results, result);
#ifdef LOGFILE
            LOG_MSG("%ld values\n", num_vals);
#endif
        } // for ( .. name .. )
    }
    catch (GenericException &e)
    {
#ifdef LOGFILE
        LOG_MSG("Error:\n%s\n", e.what());
#endif
        xmlrpc_env_set_fault_formatted(env, ARCH_DAT_DATA_ERROR,
                                       "%s", e.what());
        return 0;
    }
    return results.release();
}
예제 #5
0
int freenect_process_events(freenect_context *ctx)
{
	/* This is where the magic happens. We read 1 update from the index
	   per call, so this needs to be called in a loop like usual.  If the
	   index line is a Depth/RGB image the provided callback is called.  If
	   the index line is accelerometer data, then it is used to update our
	   internal state.  If you query for the accelerometer data you get the
	   last sensor reading that we have.  The time delays are compensated as
	   best as we can to match those from the original data and current run
	   conditions (e.g., if it takes longer to run this code then we wait less).
	 */
	if (!index_fp)
		open_index();
	char type;
	double record_cur_time;
	unsigned int timestamp, data_size;
	char *data = NULL;
	if (parse_line(&type, &record_cur_time, &timestamp, &data_size, &data))
		return -1;
	// Sleep an amount that compensates for the original and current delays
	// playback_ is w.r.t. the current time
	// record_ is w.r.t. the original time period during the recording
	if (record_prev_time != 0. && playback_prev_time != 0.)
		sleep_highres((record_cur_time - record_prev_time) - (get_time() - playback_prev_time));
	record_prev_time = record_cur_time;
	switch (type) {
		case 'd':
			if (cur_depth_cb && depth_running) {
				void *cur_depth = skip_line(data);
				if (depth_buffer) {
					memcpy(depth_buffer, cur_depth, freenect_find_depth_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_DEPTH_11BIT).bytes);
					cur_depth = depth_buffer;
				}
				cur_depth_cb(fake_dev, cur_depth, timestamp);
			}
			break;
		case 'r':
			if (cur_rgb_cb && rgb_running) {
				void *cur_rgb = skip_line(data);
				if (rgb_buffer) {
					memcpy(rgb_buffer, cur_rgb, freenect_find_video_mode(FREENECT_RESOLUTION_MEDIUM, FREENECT_VIDEO_RGB).bytes);
					cur_rgb = rgb_buffer;
				}
				cur_rgb_cb(fake_dev, cur_rgb, timestamp);
			}
			break;
		case 'a':
			if (data_size == sizeof(state)) {
				memcpy(&state, data, sizeof(state));
			} else if (!already_warned) {
				already_warned = 1;
				printf("\n\nWarning: Accelerometer data has an unexpected"
				       " size [%u] instead of [%u].  The acceleration "
				       "and tilt data will be substituted for dummy "
				       "values.  This data was probably made with an "
				       "older version of record (the upstream interface "
				       "changed).\n\n",
				       data_size, (unsigned int)sizeof state);
			}
			break;
	}
	free(data);
	playback_prev_time = get_time();
	return 0;
}
예제 #6
0
파일: cptoqe.c 프로젝트: hschauhan/Qemacs
int main(int argc, char **argv)
{
    int i;
    const char *filename;
    const char *indexname = NULL;
    char name[256], *p;
    FILE *f;

    printf("/* This file was generated automatically by cptoqe */\n");

    printf("\n" "/*"
           "\n" " * More Charsets and Tables for QEmacs"
           "\n" " *"
           "\n" " * Copyright (c) 2002 Fabrice Bellard."
           "\n" " * Copyright (c) 2002-2008 Charlie Gordon."
           "\n" " *"
           "\n" " * This library is free software; you can redistribute it and/or"
           "\n" " * modify it under the terms of the GNU Lesser General Public"
           "\n" " * License as published by the Free Software Foundation; either"
           "\n" " * version 2 of the License, or (at your option) any later version."
           "\n" " *"
           "\n" " * This library is distributed in the hope that it will be useful,"
           "\n" " * but WITHOUT ANY WARRANTY; without even the implied warranty of"
           "\n" " * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU"
           "\n" " * Lesser General Public License for more details."
           "\n" " *"
           "\n" " * You should have received a copy of the GNU Lesser General Public"
           "\n" " * License along with this library; if not, write to the Free Software"
           "\n" " * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA"
           "\n" " */"
           "\n" ""
           "\n" "#include \"qe.h\""
           "\n" "");

    add_init("int charset_more_init(void)\n{\n");

    for (i = 1; i < argc; i++) {
        filename = argv[i];

        if (!strcmp(filename, "-i")) {
            if (++i >= argc) {
                fprintf(stderr, "cptoqe: missing index name after -i\n");
                exit(2);
            }
            indexname = argv[i];
            continue;
        }

        pstrcpy(name, sizeof(name), get_basename(filename));
        strip_extension(name);
        for (p = name; *p; p++) {
            if (*p == '_')
                *p = '-';
            else
                *p = tolower((unsigned char)*p);
        }

        f = open_index(indexname, name);
        if (!f) {
            f = fopen(filename, "r");
            if (!f) {
                perror(filename);
                exit(1);
            }
        }

        handle_cp(f, name, filename);

        fclose(f);
    }

    add_init("\n    return 0;\n}\n\n"
             "qe_module_init(charset_more_init);\n");

    printf("%s", module_init);

    return 0;
}
예제 #7
0
파일: record.c 프로젝트: ABMNYZ/libfreenect
int main(int argc, char **argv)
{
	int c=1;
	while (c < argc) {
		if (strcmp(argv[c],"-ffmpeg")==0)
			use_ffmpeg = 1;
		else if (strcmp(argv[c],"-ffmpeg-opts")==0) {
			if (++c < argc)
				ffmpeg_opts = argv[c];
		} else if (strcmp(argv[c],"-h")==0)
			usage();
		else
			out_dir = argv[c];
		c++;
	}

	if (!out_dir)
		usage();

	signal(SIGINT, signal_cleanup);

	if (use_ffmpeg) {
		FILE *f;

		char *index_fn = malloc(strlen(out_dir) + 50);
		sprintf(index_fn, "%s-index.txt", out_dir);
		index_fp = open_index(index_fn);
		free(index_fn);
		if (!index_fp)
			return 1;

		depth_name = malloc(strlen(out_dir) + 50);
		rgb_name = malloc(strlen(out_dir) + 50);
		sprintf(depth_name, "%s-depth.avi", out_dir);
		sprintf(rgb_name, "%s-rgb.avi", out_dir);

		f = fopen(depth_name, "r");
		if (f) {
			printf("Error: %s already exists, to avoid overwriting "
				   "use a different name.\n", depth_name);
			fclose(f);
			exit(1);
		}
		f = fopen(rgb_name, "r");
		if (f) {
			printf("Error: %s already exists, to avoid overwriting "
				   "use a different name.\n", depth_name);
			fclose(f);
			exit(1);
		}
		init();
		free(depth_name);
		free(rgb_name);
		if (depth_stream) fclose(depth_stream);
		if (rgb_stream) fclose(rgb_stream);
		fclose(index_fp);
	} else {
#ifdef _WIN32
		_mkdir(out_dir);
#else
		mkdir(out_dir, S_IRWXU | S_IRWXG | S_IRWXO);
#endif
		char *fn = malloc(strlen(out_dir) + 50);
		sprintf(fn, "%s/INDEX.txt", out_dir);
		index_fp = open_index(fn);
		free(fn);
		if (!index_fp) {
			fclose(index_fp);
			return 1;
		}

		init();
		fclose(index_fp);
	}
	return 0;
}
예제 #8
0
파일: hf.c 프로젝트: songchao43088/DBI
/*
	get the next entry of a scan
        returns the RID of the next record that meets all the conditions
	returns (rid_t) -1 in case we are out of records
*/
RID hf_scan_next(CURSOR *cur, void *record){
	if (cur->index == -1){

		long long schema_space = 2*cur->hf->n_fields;
   	     long long record_space = (cur->hf->n_records) * hf_record_length(cur->hf);
		long long file_size = sizeof(long long) + sizeof(int) + schema_space + record_space;
		
		if (cur->current >= file_size)
			return -1;

		hf_record(cur->hf, cur->current, record);
	
		cur->current += hf_record_length(cur->hf);
     
   	     // if the current record doesn't meet all the conditions, fetch and check the next
		while (filter(record, cur->con, cur->conditions, cur->hf) == 0){
			
			if (cur->current >= file_size)
				return -1;
			hf_record(cur->hf, cur->current, record);
				
			cur->current += hf_record_length(cur->hf);
		}
			
		return cur->current - hf_record_length(cur->hf);
	} else {

		INDEX_FILE *index_file;
		index_file = open_index(cur->con[cur->index].field-1, cur->hf);
		void *buf2 = calloc(105,sizeof(char));
		int zero = 0;
		if (buf2==NULL){
			printf("Malloc failed");
			exit(1);
		} 
		if (cur->index_current_bucket == -1){

			(*encode[cur->hf->schema_array[cur->con[cur->index].field-1]])(buf2, (char*)cur->con[cur->index].value, &zero,atoi((cur->hf->schema[cur->con[cur->index].field-1])+1));
			zero = 0;
			cur->index_current_bucket = (*calculate_index[cur->hf->schema_array[cur->con[cur->index].field-1]])(buf2,index_file->s,index_file->n,0);
		}
		int i = cur->con[cur->index].field-1;
	
		int original_offset;
		int original_usage;
		void *original_bucket = calloc(BSIZE,sizeof(char));
		//void *bucket;
		//bucket = calloc(BSIZE,sizeof(char));
		if (original_bucket==NULL){
			printf("Malloc failed");
			exit(1);
		}
		void *buf = calloc(105,sizeof(char));
		if (buf==NULL){
			printf("Malloc failed");
			exit(1);
		}
		if (cur->index_mo == 0){
			read_bucket(original_bucket, cur->index_current_bucket, index_file->main_path);
		} else {
			read_bucket(original_bucket, cur->index_current_bucket, index_file->overflow_path);
		}
		original_usage = ((int*)original_bucket)[0];
		for (original_offset = cur->index_bucket_offset; original_offset < original_usage; original_offset += atoi((cur->hf->schema[i])+1)+sizeof(long long)){
			RID rid = (*read_keypair[cur->hf->schema_array[i]])(original_bucket, buf, original_offset, atoi((cur->hf->schema[i])+1));
			hf_record(cur->hf, rid, record);
			if (filter(record, cur->con, cur->conditions, cur->hf) == 1){
				cur->index_bucket_offset = original_offset + atoi((cur->hf->schema[i])+1)+sizeof(long long);
				free(original_bucket);
				free(buf);
				return rid;
			}
		}
		while (((long long*)(original_bucket+4))[0]!=-1){
			int current_bucket = ((long long*)(original_bucket+4))[0];
			read_bucket(original_bucket, ((long long*)(original_bucket+4))[0], index_file->overflow_path);
			original_usage = ((int*)original_bucket)[0];
			for (original_offset = 12; original_offset < original_usage; original_offset += atoi((cur->hf->schema[i])+1)+sizeof(long long)){
				RID rid = (*read_keypair[cur->hf->schema_array[i]])(original_bucket, buf, original_offset, atoi((cur->hf->schema[i])+1));
				hf_record(cur->hf, rid, record);
				if (filter(record, cur->con, cur->conditions, cur->hf) == 1){
					cur->index_bucket_offset = original_offset + atoi((cur->hf->schema[i])+1)+sizeof(long long);
					cur->index_current_bucket = current_bucket;
					cur->index_mo = 1;
					free(original_bucket);
					free(buf);
					return rid;
				}
			}
		}
		free(original_bucket);
		free(buf);
		free(buf2);
		return -1;
	}
}
예제 #9
0
char task_output::run (char state)
{
	//*p_serial_comp << endl << "Out State " << state << endl;
	
	switch(state)
	{
		// Wait for output change
		case(0):
			if (flag_stop_motors)
			{
				return(3);
			}
			else if (flag_start_motors)
			{
				return(5);
			}
			else if(flag_init_motors)
			{
				return(7);
			}
			else if(flag_output_change)
			{
				flag_output_change = false;
				return(1);	// Go to state 1 (Check for interferences)
			}
			else
			{
				flag_ready_to_output = true;
				return(STL_NO_TRANSITION);				
			}
			return(STL_NO_TRANSITION);
			break;
		// Check for interferences		
		case(1):
			flag_ready_to_output = false;
			if(flag_interference_thumb)
			{
				open_thumb();
				flag_interference_thumb = false;
			}
			if(flag_interference_index)
			{
				open_index();
				flag_interference_index = false;
			}
			if(flag_interference_middle)
			{
				open_middle();
				flag_interference_middle = false;
			}
			if(flag_interference_ring)
			{
				open_ring();
				flag_interference_ring = false;
			}
			if(flag_interference_pinky)
			{
				open_pinky();
				flag_interference_pinky = false;
			}
			return(2);
			break;	
		// Process outputs
		case(2):	
			if (!flag_motors_enabled)
			{
				flag_motors_enabled = true;
			}	
			// Parse character
			switch(character_to_output)
			{
				case('0'):
				case('O'):
				case('o'):
					thumb_curl();
					index_curl();
					middle_curl();
					ring_curl();
					pinky_curl();
					wrist_default();
					return(0);
					break;
				case('1'):
					thumb_flat_up();
					index_stretch();
					middle_clench();
					ring_clench();
					pinky_clench();
					wrist_default();
					return(0);
					break;
				case('2'):
					thumb_flat_up();
					index_stretch();
					middle_stretch();
					ring_clench();
					pinky_clench();
					wrist_default();
					return(0);
					break;
				case('3'):
					thumb_stretch();
					index_stretch();
					middle_stretch();
					ring_clench();
					pinky_clench();
					wrist_default();
					return(0);
					break;
				case('4'):
				case('b'):
				case('B'):
					switch(character_step)
					{
						case(1):
							thumb_fold_out();
							index_stretch();
							middle_stretch();
							ring_stretch();
							pinky_stretch();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							thumb_fold_in();
							flag_interference_thumb = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
					break;
				case('5'):
					thumb_stretch();
					index_stretch();
					middle_stretch();
					ring_stretch();
					pinky_stretch();
					wrist_default();
					return(0);
					break;
				case('6'):
				case('W'):
				case('w'):
					switch(character_step)
					{
						case(1):
							thumb_fold_out();
							index_stretch();
							middle_stretch();
							ring_stretch();
							pinky_clench();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							thumb_fold_in();
							flag_interference_thumb = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
					break;
				case('7'):
					switch(character_step)
					{
						case(1):
							thumb_fold_out();
							index_stretch();
							middle_stretch();
							ring_clench();
							pinky_stretch();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							thumb_fold_in();
							flag_interference_thumb = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
					break;
				case('8'):
					switch(character_step)
					{
						case(1):
							thumb_fold_out();
							index_stretch();
							middle_clench();
							ring_stretch();
							pinky_stretch();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							thumb_fold_in();
							flag_interference_thumb = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
					break;
				case('9'):
					thumb_flat_up();
					index_clench();
					middle_stretch();
					ring_stretch();
					pinky_stretch();
					wrist_default();
					return(0);
					break;
				case('A'):
				case('a'):
					thumb_flat_up();
					index_clench();
					middle_clench();
					ring_clench();
					pinky_clench();
					wrist_default();
					return(0);
					break;
				case('C'):
				case('c'):
					thumb_fold_out();
					index_curl();
					middle_curl();
					ring_curl();
					pinky_clench();
					wrist_default();
					return(0);
					break;
				case('D'):
				case('d'):
					thumb_curl();
					index_stretch();
					middle_curl();
					ring_curl();
					pinky_clench();
					wrist_default();
					return(0);
					break;
				case('E'):
				case('e'):
					switch(character_step)
					{
						case(1):
							thumb_fold_out();
							index_stretch();
							middle_stretch();
							ring_stretch();
							pinky_stretch();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							thumb_fold_in();
							index_curl();
							middle_curl();
							ring_curl();
							pinky_curl();
							flag_interference_thumb = true;
							flag_interference_index = true;
							flag_interference_middle = true;
							flag_interference_ring = true;
							flag_interference_pinky = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
					break;
				case('F'):
				case('f'):
					thumb_flat_up();
					index_clench();
					middle_stretch();
					ring_stretch();
					pinky_stretch();
					wrist_default();
					return(0);
					break;
				case('G'):
				case('g'):
					thumb_flat_up();
					index_stretch();
					middle_clench();
					ring_clench();
					pinky_clench();
					wrist_bent();
					return(0);
					break;
				case('H'):
				case('h'):
					thumb_flat_up();
					index_stretch();
					middle_stretch();
					ring_clench();
					pinky_clench();
					wrist_bent();
					return(0);
					break;
				case('I'):
				case('i'):
					thumb_flat_up();
					index_clench();
					middle_clench();
					ring_clench();
					pinky_stretch();
					wrist_default();
					return(0);
					break;
				case('J'):
				case('j'):
					switch(character_step)
					{
						case(1):
							thumb_flat_up();
							index_clench();
							middle_clench();
							ring_clench();
							pinky_stretch();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							wrist_bent();
							character_step++;
							return(STL_NO_TRANSITION);
						case(3):
							wrist_bent_and_twisted();
							character_step++;
							return(STL_NO_TRANSITION);
						case(4):
							wrist_twisted();
							character_step = 1;
							return(0);
					}
					break;
				case('K'):
				case('k'):
					switch(character_step)
					{
						case(1):
							thumb_flat_up();
							index_stretch();
							middle_stretch();
							ring_clench();
							pinky_clench();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
						thumb_fold_in();
							flag_interference_thumb = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
					break;
				case('L'):
				case('l'):
					thumb_stretch();
					index_stretch();
					middle_clench();
					ring_clench();
					pinky_clench();
					wrist_default();
					return(0);
					break;
				case('M'):
				case('m'):
					switch(character_step)
					{
						case(1):
							thumb_fold_in();
							index_stretch();
							middle_stretch();
							ring_stretch();
							pinky_clench();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							index_vert_clench();
							middle_vert_clench();
							ring_curl();
							flag_interference_thumb = true;
							flag_interference_index = true;
							flag_interference_middle = true;
							flag_interference_ring = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
					break;
				case('N'):
				case('n'):
					switch(character_step)
					{
						case(1):
							thumb_fold_in();
							index_stretch();
							middle_stretch();
							ring_clench();
							pinky_clench();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							index_vert_clench();
							middle_vert_clench();
							flag_interference_thumb = true;
							flag_interference_index = true;
							flag_interference_middle = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
					break;
				case('P'):
				case('p'):
					thumb_fold_up();
					index_stretch();
					middle_fold();
					ring_clench();
					pinky_clench();
					wrist_bent();
					flag_interference_thumb = true;
					flag_interference_middle = true;
					return(0);
					break;
				case('Q'):
				case('q'):
					thumb_fold_out();
					index_fold();
					middle_clench();
					ring_clench();
					pinky_clench();
					wrist_bent();
					return(0);
					break;
				case('R'):
				case('r'):
					thumb_flat_up();
					index_cross();
					middle_clench();
					ring_clench();
					pinky_clench();
					wrist_default();
					flag_interference_index = true;
					return(0);
					break;
				case('S'):
				case('s'):
					switch(character_step)
					{
						case(1):
							thumb_fold_out();
							index_clench();
							middle_clench();
							ring_clench();
							pinky_clench();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							thumb_fold_in();
							flag_interference_thumb = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
					break;
				case('T'):
				case('t'):
					switch(character_step)
					{
						case(1):
							thumb_flat_up();
							index_vert_clench();
							middle_clench();
							ring_clench();
							pinky_clench();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							thumb_fold_in();
							flag_interference_thumb = true;
							flag_interference_index = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
					break;
				case('U'):
				case('u'):
					switch(character_step)
					{
						case(1):
							thumb_flat_up();
							index_stretch();
							middle_stretch();
							ring_clench();
							pinky_clench();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							index_u();
							flag_interference_thumb = true;
							flag_interference_index = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
					break;
				case('X'):
				case('x'):
					switch(character_step)
					{
						case(1):
							thumb_fold_out();
							index_stretch();
							middle_clench();
							ring_clench();
							pinky_clench();
							wrist_default();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							thumb_fold_in();
							index_vert_clench();
							flag_interference_thumb = true;
							flag_interference_index = true;
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
				case('Y'):
				case('y'):
					thumb_stretch();
					index_clench();
					middle_clench();
					ring_clench();
					pinky_stretch();
					wrist_default();
					break;
				case('Z'):
				case('z'):
					switch(character_step)
					{
						case(1):
							thumb_flat_up();
							index_clench();
							middle_clench();
							ring_clench();
							pinky_stretch();
							wrist_z1();
							character_step++;
							return(STL_NO_TRANSITION);
						case(2):
							wrist_z2();
							character_step++;
							return(STL_NO_TRANSITION);
						case(3):
							wrist_z3();
							character_step++;
							return(STL_NO_TRANSITION);
						case(4):
							wrist_bent();
							character_step = 1;
							return(0);
						default:
							*p_serial_comp << endl << "Error character " << character_to_output << " step " << character_step << endl;
					}
			}
				
			return(0);	// Go to state 2 (output) when done
			break;
		// Send Stop Command to a Motor
		case(3):
			flag_stop_motors = false;
			p_slave_chooser->choose(motor_to_stop);
			if(p_serial_slave->ready_to_send())
			{
				*p_serial_slave << "S";
			}
			return(4);
			break;
		// Wait for confirmation on stop command
		case(4):
			if(p_serial_slave->check_for_char())
			{
				input_character = p_serial_slave->getchar();
				if (input_character == 's')
					*p_serial_comp << endl << "Motor " << motor_to_stop << " stopped";
				else
					*p_serial_comp << endl << "Motor stop error " << motor_to_stop << endl;
				
				if (motor_to_stop == 10)
				{
					motor_to_stop = 1;
					return(0);
				}
				else
				{
					motor_to_stop++;
					return(3);
				}
			}
			else
			{
				return(STL_NO_TRANSITION);
			}
		// Send Start Command to a Motor
		case(5):
			flag_start_motors = false;
			p_slave_chooser->choose(motor_to_start);
			if(p_serial_slave->ready_to_send())
			{
				*p_serial_slave << "G";
			}
			return(6);
			break;
		// Wait for confirmation on start command
		case(6):
			if(p_serial_slave->check_for_char())
			{
				input_character = p_serial_slave->getchar();
				if (input_character == 'g')
					*p_serial_comp << endl << "Motor " << motor_to_start << " enabled";
				else
					*p_serial_comp << endl << "Motor start error " << motor_to_start << endl;
				
				if (motor_to_start == 10)
				{
					motor_to_start = 1;
					return(0);
				}
				else
				{
					motor_to_start++;
					return(5);
				}
			}
			else
			{
				return(STL_NO_TRANSITION);
			}
		// Send initialization command to one motor
		case(7):
			p_slave_chooser->choose(motor_to_init);
			if(p_serial_slave->ready_to_send())
			{
				if (motor_to_init > 0 && motor_to_init < 10)
					character_to_output = motor_to_init + 0x30;
				else if (motor_to_init == 10)
					character_to_output = '0';
				else
					*p_serial_comp << endl << "Motor conf error " << motor_to_init << endl;
			
				*p_serial_slave << character_to_output;
				return(8);
			}
			break;
		// Wait for initialization response from motor
		case(8):
			if(p_serial_slave->check_for_char())
			{
				input_character = p_serial_slave->getchar();
				if (input_character == '!')
					*p_serial_comp << endl << "Motor " << motor_to_init << " initialized";
				else
					*p_serial_comp << endl << "Motor init error " << motor_to_init << endl;
				
				if (motor_to_init == 10)
				{
					motor_to_init = 1;
					return(0);
				}
				else
				{
					motor_to_init++;
					return(7);
				}
			}
			else
			{
				return(STL_NO_TRANSITION);
			}
			break;
		default:
			return(0);
			break;
			
	}
	// If we get here, no transition is called for
	return (STL_NO_TRANSITION);
}
예제 #10
0
int IndexFile::create_index(Asset *asset, MainProgressBar *progress)
{
	int result = 0;
	this->mwindow = mwindow;
	this->asset = asset;
	interrupt_flag = 0;

// open the source file
	File source;
	if(open_source(&source)) return 1;


	get_index_filename(source_filename, 
		mwindow->preferences->index_directory, 
		index_filename, 
		asset->path);


// Test for index in stream table of contents
	if(!source.get_index(index_filename))
	{
printf("IndexFile::create_index 1\n");
		redraw_edits(1);
	}
	else
// Build index from scratch
	{




		asset->index_zoom = get_required_scale(&source);

// Indexes are now built for everything since it takes too long to draw
// from CDROM source.


// total length of input file
		int64_t length_source = source.get_audio_length(0);  

// get amount to read at a time in floats
		int64_t buffersize = 65536;
		char string[BCTEXTLEN];
		sprintf(string, _("Creating %s."), index_filename);

		progress->update_title(string);
		progress->update_length(length_source);
		redraw_timer->update();

// thread out index thread
		IndexThread *index_thread = new IndexThread(mwindow, 
			this, 
			asset, 
			index_filename, 
			buffersize, 
			length_source);
		index_thread->start_build();

// current sample in source file
		int64_t position = 0;
		int64_t fragment_size = buffersize;
		int current_buffer = 0;


// pass through file once
		while(position < length_source && !result)
		{
			if(length_source - position < fragment_size && fragment_size == buffersize) fragment_size = length_source - position;

			index_thread->input_lock[current_buffer]->lock("IndexFile::create_index 1");
			index_thread->input_len[current_buffer] = fragment_size;

			int cancelled = progress->update(position);
			if(cancelled || 
				index_thread->interrupt_flag || 
				interrupt_flag)
			{
				result = 3;
			}

			for(int channel = 0; !result && channel < asset->channels; channel++)
			{
				source.set_audio_position(position, 0);
				source.set_channel(channel);

// Read from source file
				if(source.read_samples(index_thread->buffer_in[current_buffer][channel], 
					fragment_size,
					0)) result = 1;
			}

// Release buffer to thread
			if(!result)
			{
				index_thread->output_lock[current_buffer]->unlock();
				current_buffer++;
				if(current_buffer >= TOTAL_BUFFERS) current_buffer = 0;
				position += fragment_size;
			}
			else
			{
				index_thread->input_lock[current_buffer]->unlock();
			}
		}

// end thread cleanly
		index_thread->input_lock[current_buffer]->lock("IndexFile::create_index 2");
		index_thread->last_buffer[current_buffer] = 1;
		index_thread->output_lock[current_buffer]->unlock();
		index_thread->stop_build();

		delete index_thread;
	}


	source.close_file();



	open_index(asset);

	close_index();

	mwindow->edl->set_index_file(asset);
	return 0;
}
예제 #11
0
int IndexFile::open_index(MWindow *mwindow, Asset *asset)
{
	return open_index(asset);
}