RSTag* create_chunk(int x, int z, uint8_t* zero_height)
{
uint8_t* blocks = rs_malloc0(0x8000);
uint8_t* blocklight = rs_malloc0(0x4000);
uint8_t* skylight = rs_malloc0(0x4000);
uint8_t* data = rs_malloc0(0x4000);
uint8_t* heightmap = rs_malloc0(0x100);
generate_terrain(x, z, blocks);
generate_heightmap(blocks, heightmap);
generate_skylight(blocks, heightmap, skylight);
if (zero_height)
*zero_height = heightmap[0];
RSTag* level = rs_tag_new(RS_TAG_COMPOUND,
"xPos", rs_tag_new(RS_TAG_INT, x),
"zPos", rs_tag_new(RS_TAG_INT, z),
"Blocks", rs_tag_new(RS_TAG_BYTE_ARRAY, 0x8000, blocks),
"BlockLight", rs_tag_new(RS_TAG_BYTE_ARRAY, 0x4000, blocklight),
"SkyLight", rs_tag_new(RS_TAG_BYTE_ARRAY, 0x4000, skylight),
"Data", rs_tag_new(RS_TAG_BYTE_ARRAY, 0x4000, data),
"HeightMap", rs_tag_new(RS_TAG_BYTE_ARRAY, 0x100, heightmap),
"Entities", rs_tag_new(RS_TAG_LIST, NULL),
"TileEntities", rs_tag_new(RS_TAG_LIST, NULL),
"TerrainPopulated", rs_tag_new(RS_TAG_BYTE, 1),
"LastUpdate", rs_tag_new(RS_TAG_LONG, 0),
NULL);
rs_free(blocks);
rs_free(blocklight);
rs_free(skylight);
rs_free(data);
rs_free(heightmap);
return rs_tag_new(RS_TAG_COMPOUND, "Level", level, NULL);
}
mx_real_t *get_regression(mx_complex_t *samples, int n_samples) {
int i, length = n_samples/2;
mx_real_t x_mean=0, y_mean=0, rate = 1.0*SAMPLERATE/n_samples, up_sum=0, down_sum=0;
mx_real_t *reg = (mx_real_t *) rs_malloc(2*sizeof(mx_real_t),"regression coefficients");
mx_real_t *en = (mx_real_t *) rs_malloc((length-1)*sizeof(mx_real_t),"regression coefficients");
mx_real_t *ra = (mx_real_t *) rs_malloc((length-1)*sizeof(mx_real_t),"regression coefficients");
for (i = 1; i < length; i ++) {
mx_real_t re = mx_re(samples[i]), im = mx_im(samples[i]), energy;
mx_real_t f = i * rate;
energy = re * re + im * im;
energy = sqrt(energy);
en[i-1]=energy;
ra[i-1]=f;
x_mean+=energy;
y_mean+=f;
}
x_mean/=length-1;
y_mean/=length-1;
for (i=0;i<length-1;i++) {
up_sum+=(ra[i]-y_mean)*(en[i]-x_mean);
down_sum+=(ra[i]-y_mean)*(ra[i]-y_mean);
}
reg[0]=up_sum/down_sum;
reg[1]=x_mean-reg[0]*y_mean;
rs_free(en);
rs_free(ra);
return reg;
}
void mfcc_destroy(dsp_fextract_t *fex) {
dsp_mfcc_t *cfg;
/* Parameter pruefen ... */
if (!fex || fex->type != dsp_fextype_MFCC)
return;
cfg = fex->config;
/* ... und ggf. existierende Eintraege loeschen */
if (cfg->wderiv)
dsp_delay_destroy(cfg->wderiv);
if (cfg->channel) {
rs_free(cfg->channel->pMeans);
rs_free(cfg->channel);
}
if (cfg->ehist) {
rs_free(cfg->ehist->idx_history);
mx_histogram_destroy(cfg->ehist);
}
rs_free(fex->config);
rs_free(fex);
fex=NULL;
}
int librlc_rs_encode(int k, int m, int w, int packet_size,
const char *orig_data, int orig_data_len,
char **encoded_data, char **encoded_parity,
int *chunk_len)
{
rs_coder_t rs_code;
// rs init
rs_init(&rs_code, k+m, k, w, packet_size);
// rs encode
rs_encode(rs_code.prsi, orig_data, orig_data_len, encoded_data, encoded_parity, chunk_len);
// rs free
rs_free(&rs_code);
return 0;
}
int librlc_rs_repair(int k, int m, int w, int packet_size,
char *available_data, int *data_list, int data_num,int chunk_len,
int *repair_list, int repair_num, char **out_data)
{
int ret = 0;
rs_coder_t rs_code;
//rs init
rs_init(&rs_code, k+m, k, w, packet_size);
// re repair
ret = rs_repair(rs_code.prsi, available_data, data_list, data_num,
chunk_len, repair_list, repair_num, out_data);
// rs free
rs_free(&rs_code);
return ret;
}
/*
* Free program data.
*/
void rs_program_free(RSProgram* prgm)
{
if (!prgm)
return;
rs_free(prgm->filename);
rs_free(prgm->data);
rs_free(prgm->header);
rs_free(prgm->signature);
rs_free(prgm->pagenums);
rs_free(prgm);
}
static int
hwloc_aix_get_sth_membind(hwloc_topology_t topology, rstype_t what, rsid_t who, hwloc_bitmap_t nodeset, hwloc_membind_policy_t *policy, int flags __hwloc_attribute_unused)
{
hwloc_bitmap_t hwloc_set;
rsethandle_t rset;
unsigned cpu, maxcpus;
int res = -1;
int depth, n, i;
depth = hwloc_get_type_depth(topology, HWLOC_OBJ_NUMANODE);
if (depth < 0) {
errno = EXDEV;
return -1;
}
n = hwloc_get_nbobjs_by_depth(topology, depth);
rset = rs_alloc(RS_EMPTY);
if (ra_getrset(what, who, 0, rset) == -1)
goto out;
hwloc_set = hwloc_bitmap_alloc();
maxcpus = rs_getinfo(rset, R_MAXPROCS, 0);
for (cpu = 0; cpu < maxcpus; cpu++)
if (rs_op(RS_TESTRESOURCE, rset, NULL, R_PROCS, cpu) == 1)
hwloc_bitmap_set(hwloc_set, cpu);
hwloc_bitmap_and(hwloc_set, hwloc_set, hwloc_topology_get_complete_cpuset(topology));
hwloc_bitmap_zero(nodeset);
for (i = 0; i < n; i++) {
hwloc_obj_t obj = hwloc_get_obj_by_depth(topology, depth, i);
if (hwloc_bitmap_isincluded(obj->cpuset, hwloc_set))
hwloc_bitmap_set(nodeset, obj->os_index);
}
hwloc_bitmap_free(hwloc_set);
*policy = HWLOC_MEMBIND_BIND;
res = 0;
out:
rs_free(rset);
return res;
}
static void *
hwloc_aix_alloc_membind(hwloc_topology_t topology, size_t len, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags)
{
void *ret;
rsid_t rsid;
uint_t aix_policy;
if (hwloc_aix_membind_policy_from_hwloc(&aix_policy, policy))
return hwloc_alloc_or_fail(topology, len, flags);
if (hwloc_aix_prepare_membind(topology, &rsid.at_rset, nodeset, flags))
return hwloc_alloc_or_fail(topology, len, flags);
ret = ra_mmap(NULL, len, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS, -1, 0, R_RSET, rsid, aix_policy);
rs_free(rsid.at_rset);
return ret;
}
int emo_afile_segment(char *file, asegmentation_method_t *method, asegmentation_type_t type, dsp_sample_t ***signal_segment, int **segment_length) {
int size=SEGMENT_LENGTH, n_samples=0, n_segments, samples_read;
FILE *fp;
dsp_sample_t *signal=NULL;
dsp_vad_t *Vad;
signal = (dsp_sample_t *) rs_malloc(sizeof(dsp_sample_t) * size, "Signal data");
if (!method)
method = (asegmentation_method_t *) rs_malloc(sizeof(asegmentation_method_t),"Audio segmentation method");
if (strcmp(file,"-")==0)
fp = stdin;
else
fp = fopen(file,"r");
if (!fp) {
rs_warning("Cannot open file %s!",file);
return -1;
}
while ((samples_read =fread(signal+n_samples,sizeof(dsp_sample_t),BLOCKSIZE,fp)) && samples_read >0) {
n_samples+=samples_read;
if (size <= n_samples) {
size +=SEGMENT_LENGTH;
signal = (dsp_sample_t *) rs_realloc(signal,sizeof(dsp_sample_t) * size, "Signal data");
}
if (samples_read != BLOCKSIZE)
break;
}
fclose(fp);
if (type == vad && !method->vad) {
Vad = dsp_vad_create(DSP_MK_VERSION(1,0),VAD_FRAME_LEN);
method->vad = Vad;
}
n_segments = emo_asegment(method,type,signal,n_samples,signal_segment,segment_length);
if (n_segments == -1)
rs_error("Aborting during procession of file %s!",file);
rs_free(signal);
return n_segments;
}
int svm_classify (svm_classifier_t *svm, mx_real_t *instance) {
int i;
mx_real_t best_class;
struct svm_node *x;
x = (struct svm_node *) rs_malloc((svm->feature_dim+1)*sizeof(struct svm_node),"Feature vector representation for svm");
for (i=0;i<svm->feature_dim;i++) {
x[i].index=i+1;
x[i].value=instance[i];
}
x[i].index=-1;
_scale_instance(&x,svm->feature_dim,svm->max,svm->min);
best_class = svm_predict(svm->model,x);
rs_free(x);
return (int) best_class;
}
/* TODO: seems to be right, but doesn't seem to be working (EINVAL), even after
* aligning the range on 64K... */
static int
hwloc_aix_set_area_membind(hwloc_topology_t topology, const void *addr, size_t len, hwloc_const_nodeset_t nodeset, hwloc_membind_policy_t policy, int flags)
{
subrange_t subrange;
rsid_t rsid = { .at_subrange = &subrange };
uint_t aix_policy;
int ret;
fprintf(stderr,"yop\n");
if ((flags & (HWLOC_MEMBIND_MIGRATE|HWLOC_MEMBIND_STRICT))
== (HWLOC_MEMBIND_MIGRATE|HWLOC_MEMBIND_STRICT)) {
errno = ENOSYS;
return -1;
}
subrange.su_offset = (uintptr_t) addr;
subrange.su_length = len;
subrange.su_rstype = R_RSET;
if (hwloc_aix_membind_policy_from_hwloc(&aix_policy, policy))
return -1;
if (hwloc_aix_prepare_membind(topology, &subrange.su_rsid.at_rset, nodeset, flags))
return -1;
subrange.su_policy = aix_policy;
res = ra_attachrset(R_SUBRANGE, rsid, subrange.su_rsid.at_rset, 0);
if (res < 0 && errno == EPERM) {
/* EPERM may mean that one thread has ben bound with bindprocessor().
* Unbind the entire process (we can't unbind individual threads)
* and try again.
* FIXME: actually check that this EPERM can happen
*/
bindprocessor(BINDPROCESS, getpid(), PROCESSOR_CLASS_ANY);
res = ra_attachrset(R_SUBRANGE, rsid, subrange.su_rsid.at_rset, 0);
}
rs_free(subrange.su_rsid.at_rset);
return ret;
}
fextract_t *fextract_create(int frame_len, char *m_e_params,int maj, int min) {
fextract_t *fex;
dsp_fextract_t *mfcc;
fex = (fextract_t *) rs_malloc(sizeof(fextract_t),"emotion feature extraction data");
if (maj==1)
fex->n_features = V1_N_FEATURES;
else
if (maj==2)
fex->n_features = V2_N_FEATURES;
else
rs_error("Unrecognised feature extraction version!");
/* Abtastrate etc. ... */
fex->samplerate = SAMPLERATE;
fex->frame_len = frame_len; /* global frame length (in frames) */
fex->pitch = pitch_create(AC_GAUSS);
fex->frame_shift = fex->frame_len - ((fex->pitch->method == AC_GAUSS? 2 : 1 ) * fex->pitch->periodsPerWindow / fex->pitch->minimumPitch - fex->pitch->dt) * fex->samplerate ; /* global shift (in frames) */
fex->hnr = hnr_create();
fex->vq = pitch_create(FCC_NORMAL);
/* MFCCs ... */
mfcc = (dsp_fextract_t *) rs_malloc(sizeof(dsp_fextract_t), "feature extraction data");
mfcc->type = dsp_fextype_MFCC;
mfcc->version = DSP_MK_VERSION(1, 4);
if (!dsp_mfcc_create(mfcc, m_e_params)) {
rs_free(mfcc);
mfcc = NULL;
rs_warning("Could not initialize MFCC configuration!");
}
fex->mfcc=mfcc;
return(fex);
}
void maxi_do_primary_check( )
{
/* Handles error correction of primary message */
uint8_t data[15];
uint8_t results[15];
int j;
int datalen = 10;
int ecclen = 10;
rs_init_gf(0x43);
rs_init_code(ecclen, 1);
for(j = 0; j < datalen; j += 1)
data[j] = maxi_codeword[j];
rs_encode(datalen, data, results);
for ( j = 0; j < ecclen; j += 1)
maxi_codeword[ datalen + j] = results[ecclen - 1 - j];
rs_free();
}
static int
hwloc_aix_set_sth_cpubind(hwloc_topology_t topology, rstype_t what, rsid_t who, pid_t pid, hwloc_const_bitmap_t hwloc_set, int flags __hwloc_attribute_unused)
{
rsethandle_t rad;
int res;
unsigned cpu;
if (flags & HWLOC_CPUBIND_NOMEMBIND) {
errno = ENOSYS;
return -1;
}
/* The resulting binding is always strict */
if (hwloc_bitmap_isequal(hwloc_set, hwloc_topology_get_complete_cpuset(topology))) {
if (ra_detachrset(what, who, 0))
return -1;
return 0;
}
rad = rs_alloc(RS_EMPTY);
hwloc_bitmap_foreach_begin(cpu, hwloc_set)
rs_op(RS_ADDRESOURCE, rad, NULL, R_PROCS, cpu);
hwloc_bitmap_foreach_end();
res = ra_attachrset(what, who, rad, 0);
if (res < 0 && errno == EPERM) {
/* EPERM may mean that one thread has ben bound with bindprocessor().
* Unbind the entire process (we can't unbind individual threads)
* and try again.
*/
bindprocessor(BINDPROCESS, pid, PROCESSOR_CLASS_ANY);
res = ra_attachrset(what, who, rad, 0);
}
rs_free(rad);
return res;
}
int mx_scoreset_resize(mx_scoreset_t *scoreset, int max_lists)
{
int i;
/* first check parameters ... */
if (!scoreset || max_lists <= 0)
return(-1);
/* can't resize below number of lists used ... */
if (max_lists < scoreset->n_lists)
return(-1);
/* if resizing to length 0 ... */
if (max_lists == 0) {
/* ... clear existing list set ... */
scoreset->max_lists = 0;
scoreset->n_lists = 0; /* should have been 0 anyway! */
rs_free(scoreset->list);
scoreset->list = NULL;
}
else {
/* ... resize set of available lists ... */
scoreset->max_lists = max_lists;
scoreset->list = rs_realloc(scoreset->list,
scoreset->max_lists *
sizeof(mx_sscore_t),
"set of score lists");
/* ... and initialize unused entries to NULL */
for (i = scoreset->n_lists; i < scoreset->max_lists; i++)
scoreset->list[i] = NULL;
}
return(scoreset->max_lists);
}
mx_real_t *hnr_calc(pitch_t *hnr, dsp_sample_t *signal, int frameLength) {
int i, nFrames;
mx_real_t r;
mx_real_t *hnr_list, *h;
h=pitch_calc (hnr,signal, frameLength);
rs_free(h);
nFrames=hnr->nframes;
if (nFrames==0)
return NULL;
hnr_list = (mx_real_t *) rs_malloc(nFrames*sizeof(mx_real_t),"list of Harmonics-to-Noise ratio values");
for (i=0;i<nFrames;i++) {
if (hnr->frame_candidates[i]-> candidates[0].F == 0)
hnr_list[i] = -200;
else {
r = hnr->frame_candidates[i]->candidates[0].R;
hnr_list[i] = r <= 1e-15 ? -150 : r > 1 - 1e-15 ? 150 : 10 * log10 (r / (1 - r));
}
}
return hnr_list;
}
void maxi_do_secondary_chk_odd( int ecclen )
{
/* Handles error correction of odd characters in secondary */
unsigned char data[100];
unsigned char results[30];
int j;
int datalen = 68;
rs_init_gf(0x43);
rs_init_code(ecclen, 1);
if (ecclen == 20)
datalen = 84;
for(j = 0; j < datalen; j += 1)
if (j & 1) // odd
data[(j-1)/2] = maxi_codeword[j + 20];
rs_encode(datalen/2, data, results);
for ( j = 0; j < (ecclen); j += 1)
maxi_codeword[ datalen + (2 *j) + 1 + 20 ] = results[ecclen - 1 - j];
rs_free();
}
int mx_scorelist_resize(mx_scorelist_t *scorelist, int max_scores)
{
int i;
/* first check parameters ... */
if (!scorelist || max_scores <= 0)
return(-1);
/* can't resize below number of scores used ... */
if (max_scores < scorelist->n_scores)
return(-1);
/* if resizing to length 0 ... */
if (max_scores == 0) {
/* ... clear existing score list ... */
scorelist->max_scores = 0;
scorelist->n_scores = 0; /* should have been 0 anyway! */
rs_free(scorelist->score);
scorelist->score = NULL;
}
else {
/* ... resize list of available scores ... */
scorelist->max_scores = max_scores;
scorelist->score = rs_realloc(scorelist->score,
scorelist->max_scores *
sizeof(mx_sscore_t),
"list of scores");
/* ... and initialize unused entries to {-1, ?} */
for (i = scorelist->n_scores; i < scorelist->max_scores; i++)
scorelist->score[i].id = -1;
}
return(scorelist->max_scores);
}
void maxi_do_secondary_chk_even(int ecclen )
{
/* Handles error correction of even characters in secondary */
uint8_t data[100];
uint8_t results[30];
int j;
int datalen = 68;
if (ecclen == 20)
datalen = 84;
rs_init_gf(0x43);
rs_init_code(ecclen, 1);
for(j = 0; j < datalen + 1; j += 1)
if (!(j & 1)) // even
data[j/2] = maxi_codeword[j + 20];
rs_encode(datalen/2, data, results);
for ( j = 0; j < (ecclen); j += 1)
maxi_codeword[ datalen + (2 *j) + 20] = results[ecclen - 1 - j];
rs_free();
}
static int
hwloc_aix_set_sth_membind(hwloc_topology_t topology, rstype_t what, rsid_t who, pid_t pid, hwloc_const_bitmap_t nodeset, hwloc_membind_policy_t policy, int flags)
{
rsethandle_t rad;
int res;
if (flags & HWLOC_MEMBIND_NOCPUBIND) {
errno = ENOSYS;
return -1;
}
switch (policy) {
case HWLOC_MEMBIND_DEFAULT:
case HWLOC_MEMBIND_BIND:
break;
default:
errno = ENOSYS;
return -1;
}
if (hwloc_aix_prepare_membind(topology, &rad, nodeset, flags))
return -1;
res = ra_attachrset(what, who, rad, 0);
if (res < 0 && errno == EPERM) {
/* EPERM may mean that one thread has ben bound with bindprocessor().
* Unbind the entire process (we can't unbind individual threads)
* and try again.
*/
bindprocessor(BINDPROCESS, pid, PROCESSOR_CLASS_ANY);
res = ra_attachrset(what, who, rad, 0);
}
rs_free(rad);
return res;
}
static int
hwloc_aix_get_sth_cpubind(hwloc_topology_t topology, rstype_t what, rsid_t who, hwloc_bitmap_t hwloc_set, int flags __hwloc_attribute_unused)
{
rsethandle_t rset;
unsigned cpu, maxcpus;
int res = -1;
rset = rs_alloc(RS_EMPTY);
if (ra_getrset(what, who, 0, rset) == -1)
goto out;
hwloc_bitmap_zero(hwloc_set);
maxcpus = rs_getinfo(rset, R_MAXPROCS, 0);
for (cpu = 0; cpu < maxcpus; cpu++)
if (rs_op(RS_TESTRESOURCE, rset, NULL, R_PROCS, cpu) == 1)
hwloc_bitmap_set(hwloc_set, cpu);
hwloc_bitmap_and(hwloc_set, hwloc_set, hwloc_topology_get_complete_cpuset(topology));
res = 0;
out:
rs_free(rset);
return res;
}
static void
look_rset(int sdl, hwloc_obj_type_t type, struct hwloc_topology *topology, int level)
{
rsethandle_t rset, rad;
int i,maxcpus,j;
int nbnodes;
struct hwloc_obj *obj;
if ((topology->flags & HWLOC_TOPOLOGY_FLAG_WHOLE_SYSTEM))
rset = rs_alloc(RS_ALL);
else
rset = rs_alloc(RS_PARTITION);
rad = rs_alloc(RS_EMPTY);
nbnodes = rs_numrads(rset, sdl, 0);
if (nbnodes == -1) {
perror("rs_numrads");
return;
}
for (i = 0; i < nbnodes; i++) {
if (rs_getrad(rset, rad, sdl, i, 0)) {
fprintf(stderr,"rs_getrad(%d) failed: %s\n", i, strerror(errno));
continue;
}
if (!rs_getinfo(rad, R_NUMPROCS, 0))
continue;
/* It seems logical processors are numbered from 1 here, while the
* bindprocessor functions numbers them from 0... */
obj = hwloc_alloc_setup_object(type, i - (type == HWLOC_OBJ_PU));
obj->cpuset = hwloc_bitmap_alloc();
obj->os_level = sdl;
maxcpus = rs_getinfo(rad, R_MAXPROCS, 0);
for (j = 0; j < maxcpus; j++) {
if (rs_op(RS_TESTRESOURCE, rad, NULL, R_PROCS, j))
hwloc_bitmap_set(obj->cpuset, j);
}
switch(type) {
case HWLOC_OBJ_NODE:
obj->nodeset = hwloc_bitmap_alloc();
hwloc_bitmap_set(obj->nodeset, i);
obj->memory.local_memory = 0; /* TODO: odd, rs_getinfo(rad, R_MEMSIZE, 0) << 10 returns the total memory ... */
obj->memory.page_types_len = 2;
obj->memory.page_types = malloc(2*sizeof(*obj->memory.page_types));
memset(obj->memory.page_types, 0, 2*sizeof(*obj->memory.page_types));
obj->memory.page_types[0].size = hwloc_getpagesize();
#ifdef HAVE__SC_LARGE_PAGESIZE
obj->memory.page_types[1].size = sysconf(_SC_LARGE_PAGESIZE);
#endif
/* TODO: obj->memory.page_types[1].count = rs_getinfo(rset, R_LGPGFREE, 0) / hugepagesize */
break;
case HWLOC_OBJ_CACHE:
obj->attr->cache.size = _system_configuration.L2_cache_size;
obj->attr->cache.associativity = _system_configuration.L2_cache_asc;
obj->attr->cache.linesize = 0; /* TODO: ? */
obj->attr->cache.depth = 2;
obj->attr->cache.type = HWLOC_OBJ_CACHE_UNIFIED; /* FIXME? */
break;
case HWLOC_OBJ_GROUP:
obj->attr->group.depth = level;
break;
case HWLOC_OBJ_CORE:
{
hwloc_obj_t obj2, obj3;
obj2 = hwloc_alloc_setup_object(HWLOC_OBJ_CACHE, i);
obj2->cpuset = hwloc_bitmap_dup(obj->cpuset);
obj2->attr->cache.size = _system_configuration.dcache_size;
obj2->attr->cache.associativity = _system_configuration.dcache_asc;
obj2->attr->cache.linesize = _system_configuration.dcache_line;
obj2->attr->cache.depth = 1;
if (_system_configuration.cache_attrib & (1<<30)) {
/* Unified cache */
obj2->attr->cache.type = HWLOC_OBJ_CACHE_UNIFIED;
hwloc_debug("Adding an L1u cache for core %d\n", i);
hwloc_insert_object_by_cpuset(topology, obj2);
} else {
/* Separate Instruction and Data caches */
obj2->attr->cache.type = HWLOC_OBJ_CACHE_DATA;
hwloc_debug("Adding an L1d cache for core %d\n", i);
hwloc_insert_object_by_cpuset(topology, obj2);
obj3 = hwloc_alloc_setup_object(HWLOC_OBJ_CACHE, i);
obj3->cpuset = hwloc_bitmap_dup(obj->cpuset);
obj3->attr->cache.size = _system_configuration.icache_size;
obj3->attr->cache.associativity = _system_configuration.icache_asc;
obj3->attr->cache.linesize = _system_configuration.icache_line;
obj3->attr->cache.depth = 1;
obj3->attr->cache.type = HWLOC_OBJ_CACHE_INSTRUCTION;
hwloc_debug("Adding an L1i cache for core %d\n", i);
hwloc_insert_object_by_cpuset(topology, obj3);
}
break;
}
default:
break;
}
hwloc_debug_2args_bitmap("%s %d has cpuset %s\n",
hwloc_obj_type_string(type),
i, obj->cpuset);
hwloc_insert_object_by_cpuset(topology, obj);
}
rs_free(rset);
rs_free(rad);
}
/*
Gibt die Segmente einer Datei aus, entweder in Dateien oder auf die
Standardausgabe
Argumente:
file: Name der Audiodatei, die segmentiert werden soll
outdir: Verzeichnis, in dem die Segmente gespeichert werden sollen
n_segments: Anzahl der Segmente der Audiodatei
signal_segment: Array, der die Signaldaten der Segmente enthaelt
segment_length: Array, der die Laenge der Segmente enthaelt
Rueckgabe:
0: Kein Fehler
-1: Fehler
(besser: Anzahl der geschriebenen Segmente...)
*/
int emo_afile_output(char *file, char *outdir, int n_segments, dsp_sample_t **signal_segment, int *segment_length){
int i=0, n_segments_out=0;
char outfile[STRING_LENGTH], *name;
FILE *out_fp;
if (outdir && strcmp(outdir,"-")==0) {
for (i=0;i<n_segments;i++) {
if (output)
fprintf(stderr,"%d\n",segment_length[i]);
fwrite(signal_segment[i],sizeof(dsp_sample_t),segment_length[i],stdout);
n_segments_out++;
}
}
else {
if (strcmp(file,"-")!=0) {
int len;
i=strlen(file)-1;
while (i>=0 && file[i] != '.' && file[i] != '/')
i--;
if (i<0 || file[i] == '/')
i=strlen(file);
len=strrchr(file,'/')?strlen(strrchr(file,'/')):0;
len = i+1-(strrchr(file,'/')?strlen(file)-strlen(strrchr(file,'/'))+1:0);
name = (char *) rs_malloc(len*sizeof(char),"Target file name");
strncpy(name,strrchr(file,'/')?strrchr(file,'/')+1:file,len-1);
name[len-1]='\0';
while (i>=0 && file[i] != '/')
i--;
}
else
name = "";
if (!outdir) {
if (strcmp(file,"-")!=0) {
i=strlen(file);
outdir = (char *) rs_malloc((i+1)*sizeof(char),"Target directory name");
outdir[i]='\0';
//
while (i>-1) {
outdir[i]=file[i];
i--;
}
}
else
outdir="";
}
else
if (outdir[strlen(outdir)-1] != '/') {
int len=strlen(outdir);
char *temp= rs_malloc((len+2)*sizeof(char),"Audio output directory name");
for (i=0;i<len;i++)
temp[i]=outdir[i];
temp[len]='/';
temp[len+1]='\0';
outdir=temp;
}
for (i=0;i<n_segments;i++) {
if (i<9)
sprintf(outfile,"%s%s_0%d.pcm",outdir,name,i+1);
else
sprintf(outfile,"%s%s_%d.pcm",outdir,name,i+1);
out_fp = fopen(outfile,"w");
if (!out_fp) {
rs_warning("Cannot write signal segment %d to file %s!",i,outfile);
break;
}
if (output)
fprintf(stderr,"\tSegment %d has length %d\n",i+1,segment_length[i]);
if (fwrite(signal_segment[i],sizeof(dsp_sample_t),segment_length[i],out_fp) == segment_length[i])
n_segments_out++;
fclose(out_fp);
}
rs_free(name);
}
return n_segments_out;
}
GLOBAL WORD xrsrc_free (WORD *pglobal)
{
return (rs_free (pglobal));
}
int nB_classify_file(naive_bayes_classifier_t *nB, char *filename, fx_select_t *sel, int **evaluation) {
char x;
int i, class_ind, n_instances=0, eval_size=1000, start,end;
int *_eval;
mx_real_t *instance;
FILE *fp, *feature_fp;
char *fname = (char *) rs_malloc(STRING_LENGTH*sizeof(char),"String");
char *class_info = (char *) rs_malloc(STRING_LENGTH*sizeof(char),"String");
char *class_name = (char *) rs_malloc(STRING_LENGTH*sizeof(char),"String");
int full_n_features = sel? sel->n_features : nB->feature_dim;
_eval = (int *) rs_malloc(eval_size*sizeof(int),"evaluation data");
if (!nB)
rs_error("Cannot classify without classifier - use -b or -m options to get one");
if (sel)
if (sel->n_selected != nB->feature_dim)
rs_error("Wrong dimension of classifier!");
instance = (mx_real_t *) rs_malloc(full_n_features*sizeof(mx_real_t),"instance to classify");
fp = fopen(filename,"r");
if (!fp)
rs_error("cannot open file %s with instances to classify!",filename);
while (fscanf(fp,"%s%c",fname,&x)==2) {
feature_fp = fopen(fname,"r");
if (!feature_fp)
rs_error("Cannot open feature file %s!",fname);
if (x != '\n' && x != EOF ) {
while (fscanf(fp,"%s",class_info) ==1) {
if (strcmp(class_info,";")==0)
break;
if (sscanf(class_info,"%[^[]s",class_name)!=1)
rs_error("Class information for file %s is incorrect!",fname);
if(sscanf(class_info+strlen(class_name),"[%d..%d]",&start,&end) !=2)
rs_error("Time information for file %s is incorrect!",fname);
for (i=start;i<=end;i++) {
int k;
fseek(feature_fp,i*sizeof(mx_real_t)*full_n_features,SEEK_SET);
fread(instance,sizeof(mx_real_t)*full_n_features,1,feature_fp);
if (sel)
if (fx_select_apply(&instance,sel,instance) != sel->n_features)
rs_error("Feature selection did not succeed!");
class_ind = nB_classify(nB,instance);
if ((n_instances+1)*2 > eval_size) {
eval_size+=1000;
_eval = (int *) rs_realloc(_eval,eval_size*sizeof(int),"evaluation data");
}
k=cl_name2number(&(nB->mapping),class_name,nB->n_classes);
_eval[n_instances*2]=cl_name2number(&(nB->mapping),class_name,nB->n_classes);
_eval[n_instances*2+1]=class_ind;
n_instances++;
}
}
}
else {
printf("%s\t",fname);
i = fread(instance, sizeof(mx_real_t), full_n_features, feature_fp);
while (i == full_n_features) {
if (sel)
if (fx_select_apply(&instance,sel,instance) != sel->n_features)
rs_error("Feature selection did not succeed!");
class_ind=nB_classify(nB,instance);
n_instances++;
printf("%s ",nB->mapping[class_ind]);
i=fread(instance,sizeof(mx_real_t),full_n_features,feature_fp);
}
if (i!=0 && i != full_n_features)
rs_perror("fread stopped after %d elements -- %d", i, errno);
printf(";\n");
}
fclose(feature_fp);
}
fclose(fp);
rs_free(fname);
rs_free(class_info);
rs_free(class_name);
rs_free(instance);
*evaluation=_eval;
return n_instances;
}
/*
* Check/fix OS header fields and data.
*
* The OS header is much simpler than an application header, and its
* correctness is not as crucial to validation. The most important
* parts of the OS header are the key ID and (for newer calculators)
* the hardware compatibility level. There is no date stamp required.
* The page count is not required, and if present, is used only to
* display the transfer percentage (when using the 84+ boot code.)
*
* TI only sets the OS and program image size fields in their TI-73 OS
* headers. (Bizarrely, they are set in the true OS header, but not
* in the fake OS header that is transferred to page 1A. Furthermore,
* the OS size field is incorrect.) In any case, these fields appear
* to be ignored by all versions of the boot code.
*/
int rs_repair_ti8x_os(RSProgram* os, /* OS */
unsigned int flags) /* flags */
{
unsigned long hdrstart, hdrsize, fieldhead, fieldstart,
fieldsize, ossize;
unsigned char* hdr;
int i;
/* Pad the OS to a multiple of 16384. (While strictly speaking we
could get away with only padding each page to a multiple of 256,
such "partial OSes" are not supported by most linking
software.) */
rs_program_set_length(os, ((os->length + 0x3fff) & ~0x3fff));
/* If no OS header was provided in the input, try to get a header
from page 1A instead */
if (os->header_length < 6
|| os->header[0] != 0x80
|| os->header[1] != 0x0f) {
for (i = 0; i < os->npagenums; i++) {
if (os->pagenums[i] == 0x1a) {
rs_free(os->header);
if (!(os->header = rs_malloc(256)))
return RS_ERR_OUT_OF_MEMORY;
memcpy(os->header, os->data + ((unsigned long) i << 14), 256);
os->header_length = 256;
break;
}
}
}
/* Clear old header/signature (not done on the TI-73 because
official TI-73 OSes contain a fake header; I don't recommend
doing this for third-party OSes) */
if (os->calctype != RS_CALC_TI73)
for (i = 0; i < os->npagenums; i++)
if (os->pagenums[i] == 0x1a)
memset(os->data + ((unsigned long) i << 14), 0xff, 512);
/* Fix header size. OS headers must always begin with an 800x field
and end with an 807x field (TI always uses 800F and 807F, as for
apps; I'm not sure whether it's required.) */
if (os->header_length < 6
|| os->header[0] != 0x80
|| (os->header[1] & 0xf0) != 0) {
rs_error(NULL, os, "no OS header found");
return RS_ERR_MISSING_HEADER;
}
rs_get_field_size(os->header, &hdrstart, NULL);
hdr = os->header + hdrstart;
hdrsize = os->header_length - hdrstart;
if (rs_find_app_field(0x8070, hdr, hdrsize,
&fieldhead, &fieldstart, &fieldsize)) {
rs_error(NULL, os, "OS header has no program image field");
return RS_ERR_MISSING_PROGRAM_IMAGE;
}
hdrsize = fieldstart;
os->header_length = hdrstart + hdrsize;
if ((os->header_length % 64) == 55) {
if (flags & RS_IGNORE_ALL_WARNINGS) {
rs_warning(NULL, os, "OS header has length 55 mod 64");
rs_warning(NULL, os, "(this will fail to validate on TI-83+ BE)");
}
else {
rs_error(NULL, os, "OS header has length 55 mod 64");
rs_error(NULL, os, "(this will fail to validate on TI-83+ BE)");
return RS_ERR_INVALID_PROGRAM_SIZE;
}
}
/* Fix OS / OS image sizes if requested */
if (flags & RS_FIX_OS_SIZE) {
ossize = os->length + hdrsize;
if (rs_set_field_size(os->header, ossize)) {
rs_error(NULL, os, "cannot set OS length");
return RS_ERR_FIELD_TOO_SMALL;
}
if (rs_set_field_size(hdr + fieldhead, os->length)) {
rs_error(NULL, os, "cannot set OS image length");
return RS_ERR_FIELD_TOO_SMALL;
}
}
/* Check for key ID */
if (rs_find_app_field(0x8010, hdr, hdrsize, NULL, NULL, NULL)) {
if (flags & RS_IGNORE_ALL_WARNINGS)
rs_warning(NULL, os, "OS header has no key ID field");
else {
rs_error(NULL, os, "OS header has no key ID field");
return RS_ERR_MISSING_KEY_ID;
}
}
/* Check/fix page count */
if (rs_find_app_field(0x8080, hdr, hdrsize,
NULL, &fieldstart, &fieldsize)) {
if (os->length != 14 * 0x4000L) {
rs_warning(NULL, os, "OS header has no page count field");
}
}
else if (fieldsize != 1) {
rs_warning(NULL, os, "OS header has an invalid page count field");
}
else if (flags & RS_FIX_PAGE_COUNT) {
hdr[fieldstart] = os->length >> 14;
}
int _asegment_vad(dsp_vad_t *vad, dsp_sample_t *signal, int n_samples, dsp_sample_t ***signal_segment, int **length) {
int va=0, i, out_sample;
int n_segments =0, last_va=0, samples=0;
int max_segments=MAX_SEGMENTS, segment_length = SEGMENT_LENGTH;
int delay_len=vad->sigbuf->length;
int *_length;
dsp_sample_t *voice;
dsp_sample_t **_segments;
int temp=0;
dsp_sample_t *_signal;
_signal = (dsp_sample_t *) rs_malloc(n_samples*sizeof(dsp_sample_t),"signal copy");
for (i=0;i<n_samples;i++)
_signal[i]=signal[i];
if (!vad) {
rs_warning("No voice activity detection info available!");
return -1;
}
voice = (dsp_sample_t *) rs_malloc(vad->frame_len * sizeof(dsp_sample_t),"Voice frame");
_segments = (dsp_sample_t **) rs_malloc(max_segments * sizeof(dsp_sample_t *),"Signal segments");
_length = (int *) rs_malloc(max_segments * sizeof(int),"Segment lengths");
for (i=0;i<=n_samples-VAD_FRAME_SHIFT || va >=0;i+=VAD_FRAME_SHIFT) {
if (i > n_samples-VAD_FRAME_SHIFT) {
va = dsp_vad_calc(voice,vad,NULL);
}
else {
if (i>n_samples-vad->frame_len) {
int j, new_len=i+vad->frame_len;
_signal= (dsp_sample_t *) rs_realloc(_signal,new_len*sizeof(dsp_sample_t),"Signal buffer");
for (j=n_samples;j<new_len;j++)
_signal[j]=0;
}
va = dsp_vad_calc(voice, vad, _signal+i);
}
if (va >=0 && ((va && !last_va) || (!va && last_va)) && samples >0) {
out_sample=i-(delay_len-vad->sigbuf->need_elems)*160;
if (out_sample>=n_samples)
out_sample=n_samples-1;
if (va) {
if (n_segments >= max_segments) {
max_segments += MAX_SEGMENTS;
_segments = (dsp_sample_t **) rs_realloc(_segments,max_segments * sizeof(dsp_sample_t *),"Signal segments");
_length = (int *) rs_realloc(_length,max_segments * sizeof(int),"Segment lengths");
}
_segments[n_segments] = (dsp_sample_t *) rs_malloc(segment_length * sizeof(dsp_sample_t),"Signal segment");
if (output)
fprintf(stderr,"[%d..",out_sample);
}
else {
if (output)
fprintf(stderr,"%d] ",out_sample-1);
_length[n_segments]=last_va*VAD_FRAME_SHIFT;
n_segments++;
segment_length=SEGMENT_LENGTH;
}
}
if (!va)
last_va=0;
if (va==1 && samples>0) {
if ((last_va+1)*VAD_FRAME_SHIFT > segment_length) {
segment_length += SEGMENT_LENGTH;
_segments[n_segments] = (dsp_sample_t *) rs_realloc(_segments[n_segments],segment_length * sizeof(dsp_sample_t),"Signal segment");
}
samples+=VAD_FRAME_SHIFT;
memcpy(_segments[n_segments]+last_va*VAD_FRAME_SHIFT,voice,VAD_FRAME_SHIFT*sizeof(dsp_sample_t));
last_va++;
}
temp=0;
while (va==0) {
temp++;
samples+=VAD_FRAME_SHIFT;
va = dsp_vad_calc(voice, vad, NULL);
}
}
if (last_va && samples >0) {
out_sample=i-(delay_len-vad->sigbuf->need_elems)*160;
if (out_sample>=n_samples)
out_sample=n_samples;
if (output)
fprintf(stderr,"%d] ",out_sample-1);
_length[n_segments]=last_va*VAD_FRAME_SHIFT;
n_segments++;
}
if (output)
fprintf(stderr,";\n");
rs_free(voice);
rs_free(_signal);
*signal_segment=_segments;
*length=_length;
return n_segments;
}
int _asegment_info(char *seg_info, dsp_sample_t *signal, int n_samples, dsp_sample_t ***signal_segment, int **length) {
char delim;
int stat=0, frame_length, start, end, i;
int last=0, n_segments=0;
int max_segments=MAX_SEGMENTS;
int *_length;
dsp_sample_t **_segments;
_segments = (dsp_sample_t **) rs_malloc(max_segments * sizeof(dsp_sample_t *),"Signal segments");
_length = (int *) rs_malloc(max_segments * sizeof(int),"Segment lengths");
if ((seg_info = strchr(seg_info,'[')))
seg_info++;
while (seg_info && (stat = sscanf(seg_info, "%d..%d%c", &start,&end,&delim)) == 3) {
if (end +1 > n_samples) {
rs_warning("Wrong segmentation info: Trying to read %d samples from an audio signal that is only %d samples long!",end,n_samples);
return -1;
}
if (n_segments >= max_segments) {
max_segments+=MAX_SEGMENTS;
_segments = (dsp_sample_t**) rs_realloc(_segments,max_segments*sizeof(dsp_sample_t *),"Signal segments");
_length = (int *) rs_realloc(_length,max_segments*sizeof(int),"Segment lengths");
}
frame_length = end-start+1;
if (last) {
_segments[n_segments] = (dsp_sample_t *) rs_realloc(_segments[n_segments],(last+frame_length)*sizeof(dsp_sample_t),"signal segments");
_length[n_segments]+=frame_length;
}
else {
_segments[n_segments] = (dsp_sample_t *) rs_malloc(frame_length *sizeof(dsp_sample_t),"signal segments");
_length[n_segments]=frame_length;
}
memcpy(_segments[n_segments]+last,signal+start,frame_length*sizeof(dsp_sample_t));
switch (delim) {
case '-':
last+=frame_length;
if ((seg_info = strchr(seg_info,'-')))
seg_info++;
break;
case ']':
last=0;
n_segments++;
if ((seg_info = strchr(seg_info,'[')))
seg_info++;
break;
default:
rs_warning("Problem with segmentation information: wrong delimiter '%c'!",delim);
rs_free(_length);
for (i=0;i<n_segments;i++)
rs_free(_segments[i]);
rs_free(_segments);
return -1;
}
}
if (stat !=3) {
rs_warning("Problem with segmentation information: %s!",seg_info);
return -1;
}
*signal_segment=_segments;
*length=_length;
return n_segments;
}
int code_one(struct zint_symbol *symbol, unsigned char source[], int length)
{
int size = 1, i, j, data_blocks;
char datagrid[136][120];
int row, col;
int sub_version = 0;
if((symbol->option_2 < 0) || (symbol->option_2 > 10)) {
strcpy(symbol->errtxt, "Invalid symbol size");
return ERROR_INVALID_OPTION;
}
if(symbol->option_2 == 9) {
/* Version S */
int codewords;
short int elreg[112];
unsigned int data[15], ecc[15];
int stream[30];
int block_width;
if(length > 18) {
strcpy(symbol->errtxt, "Input data too long");
return ERROR_TOO_LONG;
}
if(is_sane(NEON, source, length) == ERROR_INVALID_DATA) {
strcpy(symbol->errtxt, "Invalid input data (Version S encodes numeric input only)");
return ERROR_INVALID_DATA;
}
sub_version = 3; codewords = 12; block_width = 6; /* Version S-30 */
if(length <= 12) { sub_version = 2; codewords = 8; block_width = 4; } /* Version S-20 */
if(length <= 6) { sub_version = 1; codewords = 4; block_width = 2; } /* Version S-10 */
binary_load(elreg, (char *)source, length);
hex_dump(elreg);
for(i = 0; i < 15; i++) {
data[i] = 0;
ecc[i] = 0;
}
for(i = 0; i < codewords; i++) {
data[codewords - i - 1] += 1 * elreg[(i * 5)];
data[codewords - i - 1] += 2 * elreg[(i * 5) + 1];
data[codewords - i - 1] += 4 * elreg[(i * 5) + 2];
data[codewords - i - 1] += 8 * elreg[(i * 5) + 3];
data[codewords - i - 1] += 16 * elreg[(i * 5) + 4];
}
rs_init_gf(0x25);
rs_init_code(codewords, 1);
rs_encode_long(codewords, data, ecc);
rs_free();
for(i = 0; i < codewords; i++) {
stream[i] = data[i];
stream[i + codewords] = ecc[codewords - i - 1];
}
for(i = 0; i < 136; i++) {
for(j = 0; j < 120; j++) {
datagrid[i][j] = '0';
}
}
i = 0;
for(row = 0; row < 2; row++) {
for(col = 0; col < block_width; col++) {
if(stream[i] & 0x10) { datagrid[row * 2][col * 5] = '1'; }
if(stream[i] & 0x08) { datagrid[row * 2][(col * 5) + 1] = '1'; }
if(stream[i] & 0x04) { datagrid[row * 2][(col * 5) + 2] = '1'; }
if(stream[i] & 0x02) { datagrid[(row * 2) + 1][col * 5] = '1'; }
if(stream[i] & 0x01) { datagrid[(row * 2) + 1][(col * 5) + 1] = '1'; }
if(stream[i + 1] & 0x10) { datagrid[row * 2][(col * 5) + 3] = '1'; }
if(stream[i + 1] & 0x08) { datagrid[row * 2][(col * 5) + 4] = '1'; }
if(stream[i + 1] & 0x04) { datagrid[(row * 2) + 1][(col * 5) + 2] = '1'; }
if(stream[i + 1] & 0x02) { datagrid[(row * 2) + 1][(col * 5) + 3] = '1'; }
if(stream[i + 1] & 0x01) { datagrid[(row * 2) + 1][(col * 5) + 4] = '1'; }
i += 2;
}
}
size = 9;
symbol->rows = 8;
symbol->width = 10 * sub_version + 1;
}
if(symbol->option_2 == 10) {
/* Version T */
unsigned int data[40], ecc[25];
unsigned int stream[65];
int data_length;
int data_cw, ecc_cw, block_width;
for(i = 0; i < 40; i++) { data[i] = 0; }
data_length = c1_encode(symbol, source, data, length);
if(data_length == 0) {
return ERROR_TOO_LONG;
}
if(data_length > 38) {
strcpy(symbol->errtxt, "Input data too long");
return ERROR_TOO_LONG;
}
size = 10;
sub_version = 3; data_cw = 38; ecc_cw = 22; block_width = 12;
if(data_length <= 24) { sub_version = 2; data_cw = 24; ecc_cw = 16; block_width = 8; }
if(data_length <= 10) { sub_version = 1; data_cw = 10; ecc_cw = 10; block_width = 4; }
for(i = data_length; i < data_cw; i++) {
data[i] = 129; /* Pad */
}
/* Calculate error correction data */
rs_init_gf(0x12d);
rs_init_code(ecc_cw, 1);
rs_encode_long(data_cw, data, ecc);
rs_free();
/* "Stream" combines data and error correction data */
for(i = 0; i < data_cw; i++) {
stream[i] = data[i];
}
for(i = 0; i < ecc_cw; i++) {
stream[data_cw + i] = ecc[ecc_cw - i - 1];
}
for(i = 0; i < 136; i++) {
for(j = 0; j < 120; j++) {
datagrid[i][j] = '0';
}
}
i = 0;
for(row = 0; row < 5; row++) {
for(col = 0; col < block_width; col++) {
if(stream[i] & 0x80) { datagrid[row * 2][col * 4] = '1'; }
if(stream[i] & 0x40) { datagrid[row * 2][(col * 4) + 1] = '1'; }
if(stream[i] & 0x20) { datagrid[row * 2][(col * 4) + 2] = '1'; }
if(stream[i] & 0x10) { datagrid[row * 2][(col * 4) + 3] = '1'; }
if(stream[i] & 0x08) { datagrid[(row * 2) + 1][col * 4] = '1'; }
if(stream[i] & 0x04) { datagrid[(row * 2) + 1][(col * 4) + 1] = '1'; }
if(stream[i] & 0x02) { datagrid[(row * 2) + 1][(col * 4) + 2] = '1'; }
if(stream[i] & 0x01) { datagrid[(row * 2) + 1][(col * 4) + 3] = '1'; }
i++;
}
}
symbol->rows = 16;
symbol->width = (sub_version * 16) + 1;
}
if((symbol->option_2 != 9) && (symbol->option_2 != 10)) {
/* Version A to H */
unsigned int data[1500], ecc[600];
unsigned int sub_data[190], sub_ecc[75];
unsigned int stream[2100];
int data_length;
for(i = 0; i < 1500; i++) { data[i] = 0; }
data_length = c1_encode(symbol, source, data, length);
if(data_length == 0) {
return ERROR_TOO_LONG;
}
for(i = 7; i >= 0; i--) {
if(c1_data_length[i] >= data_length) {
size = i + 1;
}
}
if(symbol->option_2 > size) {
size = symbol->option_2;
}
for(i = data_length; i < c1_data_length[size - 1]; i++) {
data[i] = 129; /* Pad */
}
/* Calculate error correction data */
data_length = c1_data_length[size - 1];
for(i = 0; i < 190; i++) { sub_data[i] = 0; }
for(i = 0; i < 75; i++) { sub_ecc[i] = 0; }
data_blocks = c1_blocks[size - 1];
rs_init_gf(0x12d);
rs_init_code(c1_ecc_blocks[size - 1], 0);
for(i = 0; i < data_blocks; i++) {
for(j = 0; j < c1_data_blocks[size - 1]; j++) {
sub_data[j] = data[j * data_blocks + i];
}
rs_encode_long(c1_data_blocks[size - 1], sub_data, sub_ecc);
for(j = 0; j < c1_ecc_blocks[size - 1]; j++) {
ecc[c1_ecc_length[size - 1] - (j * data_blocks + i) - 1] = sub_ecc[j];
}
}
rs_free();
/* "Stream" combines data and error correction data */
for(i = 0; i < data_length; i++) {
stream[i] = data[i];
}
for(i = 0; i < c1_ecc_length[size - 1]; i++) {
stream[data_length + i] = ecc[i];
}
for(i = 0; i < 136; i++) {
for(j = 0; j < 120; j++) {
datagrid[i][j] = '0';
}
}
i = 0;
for(row = 0; row < c1_grid_height[size - 1]; row++) {
for(col = 0; col < c1_grid_width[size - 1]; col++) {
if(stream[i] & 0x80) { datagrid[row * 2][col * 4] = '1'; }
if(stream[i] & 0x40) { datagrid[row * 2][(col * 4) + 1] = '1'; }
if(stream[i] & 0x20) { datagrid[row * 2][(col * 4) + 2] = '1'; }
if(stream[i] & 0x10) { datagrid[row * 2][(col * 4) + 3] = '1'; }
if(stream[i] & 0x08) { datagrid[(row * 2) + 1][col * 4] = '1'; }
if(stream[i] & 0x04) { datagrid[(row * 2) + 1][(col * 4) + 1] = '1'; }
if(stream[i] & 0x02) { datagrid[(row * 2) + 1][(col * 4) + 2] = '1'; }
if(stream[i] & 0x01) { datagrid[(row * 2) + 1][(col * 4) + 3] = '1'; }
i++;
}
}
/* for(i = 0; i < (c1_grid_height[size - 1] * 2); i++) {
for(j = 0; j < (c1_grid_width[size - 1] * 4); j++) {
printf("%c", datagrid[i][j]);
}
printf("\n");
} */
symbol->rows = c1_height[size - 1];
symbol->width = c1_width[size - 1];
}
switch(size) {
case 1: /* Version A */
central_finder(symbol, 6, 3, 1);
vert(symbol, 4, 6, 1);
vert(symbol, 12, 5, 0);
set_module(symbol, 5, 12);
spigot(symbol, 0);
spigot(symbol, 15);
block_copy(symbol, datagrid, 0, 0, 5, 4, 0, 0);
block_copy(symbol, datagrid, 0, 4, 5, 12, 0, 2);
block_copy(symbol, datagrid, 5, 0, 5, 12, 6, 0);
block_copy(symbol, datagrid, 5, 12, 5, 4, 6, 2);
break;
case 2: /* Version B */
central_finder(symbol, 8, 4, 1);
vert(symbol, 4, 8, 1);
vert(symbol, 16, 7, 0);
set_module(symbol, 7, 16);
spigot(symbol, 0);
spigot(symbol, 21);
block_copy(symbol, datagrid, 0, 0, 7, 4, 0, 0);
block_copy(symbol, datagrid, 0, 4, 7, 16, 0, 2);
block_copy(symbol, datagrid, 7, 0, 7, 16, 8, 0);
block_copy(symbol, datagrid, 7, 16, 7, 4, 8, 2);
break;
case 3: /* Version C */
central_finder(symbol, 11, 4, 2);
vert(symbol, 4, 11, 1);
vert(symbol, 26, 13, 1);
vert(symbol, 4, 10, 0);
vert(symbol, 26, 10, 0);
spigot(symbol, 0);
spigot(symbol, 27);
block_copy(symbol, datagrid, 0, 0, 10, 4, 0, 0);
block_copy(symbol, datagrid, 0, 4, 10, 20, 0, 2);
block_copy(symbol, datagrid, 0, 24, 10, 4, 0, 4);
block_copy(symbol, datagrid, 10, 0, 10, 4, 8, 0);
block_copy(symbol, datagrid, 10, 4, 10, 20, 8, 2);
block_copy(symbol, datagrid, 10, 24, 10, 4, 8, 4);
break;
case 4: /* Version D */
central_finder(symbol, 16, 5, 1);
vert(symbol, 4, 16, 1);
vert(symbol, 20, 16, 1);
vert(symbol, 36, 16, 1);
vert(symbol, 4, 15, 0);
vert(symbol, 20, 15, 0);
vert(symbol, 36, 15, 0);
spigot(symbol, 0);
spigot(symbol, 12);
spigot(symbol, 27);
spigot(symbol, 39);
block_copy(symbol, datagrid, 0, 0, 15, 4, 0, 0);
block_copy(symbol, datagrid, 0, 4, 15, 14, 0, 2);
block_copy(symbol, datagrid, 0, 18, 15, 14, 0, 4);
block_copy(symbol, datagrid, 0, 32, 15, 4, 0, 6);
block_copy(symbol, datagrid, 15, 0, 15, 4, 10, 0);
block_copy(symbol, datagrid, 15, 4, 15, 14, 10, 2);
block_copy(symbol, datagrid, 15, 18, 15, 14, 10, 4);
block_copy(symbol, datagrid, 15, 32, 15, 4, 10, 6);
break;
case 5: /* Version E */
central_finder(symbol, 22, 5, 2);
vert(symbol, 4, 22, 1);
vert(symbol, 26, 24, 1);
vert(symbol, 48, 22, 1);
vert(symbol, 4, 21, 0);
vert(symbol, 26, 21, 0);
vert(symbol, 48, 21, 0);
spigot(symbol, 0);
spigot(symbol, 12);
spigot(symbol, 39);
spigot(symbol, 51);
block_copy(symbol, datagrid, 0, 0, 21, 4, 0, 0);
block_copy(symbol, datagrid, 0, 4, 21, 20, 0, 2);
block_copy(symbol, datagrid, 0, 24, 21, 20, 0, 4);
block_copy(symbol, datagrid, 0, 44, 21, 4, 0, 6);
block_copy(symbol, datagrid, 21, 0, 21, 4, 10, 0);
block_copy(symbol, datagrid, 21, 4, 21, 20, 10, 2);
block_copy(symbol, datagrid, 21, 24, 21, 20, 10, 4);
block_copy(symbol, datagrid, 21, 44, 21, 4, 10, 6);
break;
case 6: /* Version F */
central_finder(symbol, 31, 5, 3);
vert(symbol, 4, 31, 1);
vert(symbol, 26, 35, 1);
vert(symbol, 48, 31, 1);
vert(symbol, 70, 35, 1);
vert(symbol, 4, 30, 0);
vert(symbol, 26, 30, 0);
vert(symbol, 48, 30, 0);
vert(symbol, 70, 30, 0);
spigot(symbol, 0);
spigot(symbol, 12);
spigot(symbol, 24);
spigot(symbol, 45);
spigot(symbol, 57);
spigot(symbol, 69);
block_copy(symbol, datagrid, 0, 0, 30, 4, 0, 0);
block_copy(symbol, datagrid, 0, 4, 30, 20, 0, 2);
block_copy(symbol, datagrid, 0, 24, 30, 20, 0, 4);
block_copy(symbol, datagrid, 0, 44, 30, 20, 0, 6);
block_copy(symbol, datagrid, 0, 64, 30, 4, 0, 8);
block_copy(symbol, datagrid, 30, 0, 30, 4, 10, 0);
block_copy(symbol, datagrid, 30, 4, 30, 20, 10, 2);
block_copy(symbol, datagrid, 30, 24, 30, 20, 10, 4);
block_copy(symbol, datagrid, 30, 44, 30, 20, 10, 6);
block_copy(symbol, datagrid, 30, 64, 30, 4, 10, 8);
break;
case 7: /* Version G */
central_finder(symbol, 47, 6, 2);
vert(symbol, 6, 47, 1);
vert(symbol, 27, 49, 1);
vert(symbol, 48, 47, 1);
vert(symbol, 69, 49, 1);
vert(symbol, 90, 47, 1);
vert(symbol, 6, 46, 0);
vert(symbol, 27, 46, 0);
vert(symbol, 48, 46, 0);
vert(symbol, 69, 46, 0);
vert(symbol, 90, 46, 0);
spigot(symbol, 0);
spigot(symbol, 12);
spigot(symbol, 24);
spigot(symbol, 36);
spigot(symbol, 67);
spigot(symbol, 79);
spigot(symbol, 91);
spigot(symbol, 103);
block_copy(symbol, datagrid, 0, 0, 46, 6, 0, 0);
block_copy(symbol, datagrid, 0, 6, 46, 19, 0, 2);
block_copy(symbol, datagrid, 0, 25, 46, 19, 0, 4);
block_copy(symbol, datagrid, 0, 44, 46, 19, 0, 6);
block_copy(symbol, datagrid, 0, 63, 46, 19, 0, 8);
block_copy(symbol, datagrid, 0, 82, 46, 6, 0, 10);
block_copy(symbol, datagrid, 46, 0, 46, 6, 12, 0);
block_copy(symbol, datagrid, 46, 6, 46, 19, 12, 2);
block_copy(symbol, datagrid, 46, 25, 46, 19, 12, 4);
block_copy(symbol, datagrid, 46, 44, 46, 19, 12, 6);
block_copy(symbol, datagrid, 46, 63, 46, 19, 12, 8);
block_copy(symbol, datagrid, 46, 82, 46, 6, 12, 10);
break;
case 8: /* Version H */
central_finder(symbol, 69, 6, 3);
vert(symbol, 6, 69, 1);
vert(symbol, 26, 73, 1);
vert(symbol, 46, 69, 1);
vert(symbol, 66, 73, 1);
vert(symbol, 86, 69, 1);
vert(symbol, 106, 73, 1);
vert(symbol, 126, 69, 1);
vert(symbol, 6, 68, 0);
vert(symbol, 26, 68, 0);
vert(symbol, 46, 68, 0);
vert(symbol, 66, 68, 0);
vert(symbol, 86, 68, 0);
vert(symbol, 106, 68, 0);
vert(symbol, 126, 68, 0);
spigot(symbol, 0);
spigot(symbol, 12);
spigot(symbol, 24);
spigot(symbol, 36);
spigot(symbol, 48);
spigot(symbol, 60);
spigot(symbol, 87);
spigot(symbol, 99);
spigot(symbol, 111);
spigot(symbol, 123);
spigot(symbol, 135);
spigot(symbol, 147);
block_copy(symbol, datagrid, 0, 0, 68, 6, 0, 0);
block_copy(symbol, datagrid, 0, 6, 68, 18, 0, 2);
block_copy(symbol, datagrid, 0, 24, 68, 18, 0, 4);
block_copy(symbol, datagrid, 0, 42, 68, 18, 0, 6);
block_copy(symbol, datagrid, 0, 60, 68, 18, 0, 8);
block_copy(symbol, datagrid, 0, 78, 68, 18, 0, 10);
block_copy(symbol, datagrid, 0, 96, 68, 18, 0, 12);
block_copy(symbol, datagrid, 0, 114, 68, 6, 0, 14);
block_copy(symbol, datagrid, 68, 0, 68, 6, 12, 0);
block_copy(symbol, datagrid, 68, 6, 68, 18, 12, 2);
block_copy(symbol, datagrid, 68, 24, 68, 18, 12, 4);
block_copy(symbol, datagrid, 68, 42, 68, 18, 12, 6);
block_copy(symbol, datagrid, 68, 60, 68, 18, 12, 8);
block_copy(symbol, datagrid, 68, 78, 68, 18, 12, 10);
block_copy(symbol, datagrid, 68, 96, 68, 18, 12, 12);
block_copy(symbol, datagrid, 68, 114, 68, 6, 12, 14);
break;
case 9: /* Version S */
horiz(symbol, 5, 1);
horiz(symbol, 7, 1);
set_module(symbol, 6, 0);
set_module(symbol, 6, symbol->width - 1);
unset_module(symbol, 7, 1);
unset_module(symbol, 7, symbol->width - 2);
switch(sub_version) {
case 1: /* Version S-10 */
set_module(symbol, 0, 5);
block_copy(symbol, datagrid, 0, 0, 4, 5, 0, 0);
block_copy(symbol, datagrid, 0, 5, 4, 5, 0, 1);
break;
case 2: /* Version S-20 */
set_module(symbol, 0, 10);
set_module(symbol, 4, 10);
block_copy(symbol, datagrid, 0, 0, 4, 10, 0, 0);
block_copy(symbol, datagrid, 0, 10, 4, 10, 0, 1);
break;
case 3: /* Version S-30 */
set_module(symbol, 0, 15);
set_module(symbol, 4, 15);
set_module(symbol, 6, 15);
block_copy(symbol, datagrid, 0, 0, 4, 15, 0, 0);
block_copy(symbol, datagrid, 0, 15, 4, 15, 0, 1);
break;
}
break;
case 10: /* Version T */
horiz(symbol, 11, 1);
horiz(symbol, 13, 1);
horiz(symbol, 15, 1);
set_module(symbol, 12, 0);
set_module(symbol, 12, symbol->width - 1);
set_module(symbol, 14, 0);
set_module(symbol, 14, symbol->width - 1);
unset_module(symbol, 13, 1);
unset_module(symbol, 13, symbol->width - 2);
unset_module(symbol, 15, 1);
unset_module(symbol, 15, symbol->width - 2);
switch(sub_version) {
case 1: /* Version T-16 */
set_module(symbol, 0, 8);
set_module(symbol, 10, 8);
block_copy(symbol, datagrid, 0, 0, 10, 8, 0, 0);
block_copy(symbol, datagrid, 0, 8, 10, 8, 0, 1);
break;
case 2: /* Version T-32 */
set_module(symbol, 0, 16);
set_module(symbol, 10, 16);
set_module(symbol, 12, 16);
block_copy(symbol, datagrid, 0, 0, 10, 16, 0, 0);
block_copy(symbol, datagrid, 0, 16, 10, 16, 0, 1);
break;
case 3: /* Verion T-48 */
set_module(symbol, 0, 24);
set_module(symbol, 10, 24);
set_module(symbol, 12, 24);
set_module(symbol, 14, 24);
block_copy(symbol, datagrid, 0, 0, 10, 24, 0, 0);
block_copy(symbol, datagrid, 0, 24, 10, 24, 0, 1);
break;
}
break;
}
for(i = 0; i < symbol->rows; i++) {
symbol->row_height[i] = 1;
}
return 0;
}
/*
Segmentiert eine Liste von Dateien
Argumente:
filelist: Name der Datei, die die Dateien enthaelt, die segmentiert
werden sollen
method: dsp_vad_t* fuer voice activity detection,
int fuer frames mit fester Laenge
char* fuer Segmentierungsinfo
type: vad, fixed oder info
Rueckgabewert:
Anzahl der Signalabschnitte in signal_segment;
-1, falls ein Fehler aufgetreten ist
*/
int emo_afilelist_segment(char *filelist, asegmentation_method_t *method, asegmentation_type_t type,int audio_output){
FILE *fp;
int n_segments=0;
int *segment_length=NULL;
dsp_sample_t **signal_segment=NULL;
fp = fopen(filelist,"r");
if (!fp) {
rs_warning("Cannot open input file: %s!",filelist);
return -1;
}
switch (type) {
case vad: {
int stat=0, x=0;
char filename[STRING_LENGTH], outdir[STRING_LENGTH];
if (!method)
method = (asegmentation_method_t *) rs_malloc(sizeof(asegmentation_method_t),"Audio segmentation method");
if (!method->vad)
method->vad = dsp_vad_create(DSP_MK_VERSION(1,0),VAD_FRAME_LEN);
//rest der zeile ueberspringen
while(fscanf(fp,"%s\t%s",filename,outdir)==2 && stat >=0) {
if (output)
fprintf(stderr,"%s\t%s\t",filename,outdir);
stat=emo_afile_segment(filename,method,vad,&signal_segment,&segment_length);
if (stat == -1){
rs_warning("Segmentation of file %s failed!",filename);
return -1;
}
if (audio_output && stat != emo_afile_output(filename,outdir,stat,signal_segment,segment_length)) {
rs_warning("Output of segments of file %s failed!",filename);
return -1;
}
if (segment_length)
rs_free(segment_length);
if (signal_segment) {
int i;
for (i=0;i<stat;i++)
if (signal_segment[i])
rs_free(signal_segment[i]);
rs_free(signal_segment);
}
n_segments+=stat;
while (x != '\n' && x != EOF)
x=fgetc(fp);
x=0;
}
break;
}
case fixed: {
int stat=0, x=0;
char filename[STRING_LENGTH], outdir[STRING_LENGTH];
if (!method->segmentation_info) {
rs_warning("No segment length or shift info available!");
return -1;
}
while(fscanf(fp,"%s\t%s",filename,outdir)==2 && stat >=0) {
stat=emo_afile_segment(filename,method,fixed,&signal_segment,&segment_length);
if (stat == -1){
rs_warning("Segmentation of file %s failed!",filename);
return -1;
}
if (audio_output) {
stat = emo_afile_output(filename,outdir,stat,signal_segment,segment_length);
if (stat == -1){
rs_warning("Output of segments of file %s failed!",filename);
}
return -1;
}
n_segments+=stat;
while (x != '\n' && x != EOF)
x=fgetc(fp);
x=0;
}
break;
}
case info: {
int stat=0;
char filename[STRING_LENGTH], outdir[STRING_LENGTH], seg_info[10*STRING_LENGTH];
if (!method->segmentation_info) {
rs_warning("No segment length or shift info available!");
return -1;
}
while(fscanf(fp,"%s\t%s\t%[^\n]s",filename,outdir,seg_info)==3 && stat >=0) {
method->segmentation_info=seg_info;
stat=emo_afile_segment(filename,method,info,&signal_segment,&segment_length);
if (stat == -1){
rs_warning("Segmentation of file %s failed!",filename);
return -1;
}
if (audio_output && stat != emo_afile_output(filename,outdir,stat,signal_segment,segment_length)) {
rs_warning("Output of segments of file %s failed!",filename);
return -1;
}
n_segments+=stat;
}
break;
}
default: rs_warning("Unknown segmentation type: %d",type);
return -1;
}
fclose(fp);
return n_segments;
}
