void levinson_durbin(
scalar R[], /* order+1 autocorrelation coeff */
scalar lpcs[], /* order+1 LPC's */
int order /* order of the LPC analysis */
)
{
scalar a[order+1][order+1];
scalar sum, e, k;
int i,j; /* loop variables */
scalar ZERO = fl_to_numb(0.0);
e = R[0]; /* Equation 38a, Makhoul */
for(i=1; i<=order; i++) {
sum = ZERO;
for(j=1; j<=i-1; j++)
sum = s_add(sum, s_mul(a[i-1][j],R[i-j]));
k = s_mul(-1.0, s_div(s_add(R[i], sum),e)); /* Equation 38b, Makhoul */
if (s_abs(k) > fl_to_numb(1.0))
k = ZERO;
a[i][i] = k;
for(j=1; j<=i-1; j++)
a[i][j] = s_add(a[i-1][j] , s_mul(k,a[i-1][i-j])); /* Equation 38c, Makhoul */
e = s_mul(e, s_sub(fl_to_numb(1.0),s_mul(k,k))); /* Equation 38d, Makhoul */
}
for(i=1; i<=order; i++)
lpcs[i] = a[order][i];
lpcs[0] = fl_to_numb(1.0);
}
void find_aks(
scalar Sn[], /* Nsam samples with order sample memory */
scalar a[], /* order+1 LPCs with first coeff 1.0 */
int Nsam, /* number of input speech samples */
int order, /* order of the LPC analysis */
scalar *E /* residual energy */
)
{
scalar Wn[LPC_MAX_N]; /* windowed frame of Nsam speech samples */
scalar R[order+1]; /* order+1 autocorrelation values of Sn[] */
int i;
assert(Nsam < LPC_MAX_N);
hanning_window(Sn,Wn,Nsam);
autocorrelate(Wn,R,Nsam,order);
levinson_durbin(R,a,order);
*E = fl_to_numb(0.0);
for(i=0; i<=order; i++)
*E = s_add(*E , s_mul(a[i],R[i]));
if (*E < fl_to_numb(0.0)) {
#ifdef MATH_Q16_16
*E = 1;
#else
*E = powf(2, -16);//fl_to_numb(1E-12); For debuging purposes.
#endif
}
}
void de_emp(
scalar Sn_de[], /* output frame of speech samples */
scalar Sn[], /* input frame of speech samples */
scalar *mem, /* Sn[-1]single sample memory */
int Nsam /* number of speech samples to use */
)
{
int i;
scalar BETA_ = fl_to_numb(BETA);
for(i=0; i<Nsam; i++) {
Sn_de[i] = s_add(Sn[i] , s_mul(BETA_, mem[0]));
mem[0] = Sn_de[i];
}
}
int main(int argc, const char * argv[]) {
// 头插法
SLIST singleLinkList0 = s_init();
for (int i = 0; i < 5; i++) {
s_add(singleLinkList0, 0, i);
}
s_print(singleLinkList0);
// 尾插法
SLIST singleLinkList = s_init();
SNODE* endNode = singleLinkList;
for (int i = 0; i < 5; i++) {
SNODE* node = (SNODE*)malloc(sizeof(SNODE));
node->data = i;
endNode->next = node;
endNode = node;
singleLinkList->data++;
}
s_print(singleLinkList);
s_add(singleLinkList, 3, 5);
s_print(singleLinkList);
printf("%d\n", s_get(singleLinkList, 3));
s_print(singleLinkList);
s_delete(singleLinkList, 1);
s_print(singleLinkList);
s_clear(singleLinkList);
s_print(singleLinkList);
return 0;
}
void inverse_filter(
scalar Sn[], /* Nsam input samples */
scalar a[], /* LPCs for this frame of samples */
int Nsam, /* number of samples */
scalar res[], /* Nsam residual samples */
int order /* order of LPC */
)
{
int i,j; /* loop variables */
for(i=0; i<Nsam; i++) {
res[i] = fl_to_numb(0.0);
for(j=0; j<=order; j++)
res[i] = s_add(res[i] , s_mul(Sn[i-j],a[j]));
}
}
void autocorrelate(
scalar Sn[], /* frame of Nsam windowed speech samples */
scalar Rn[], /* array of P+1 autocorrelation coefficients */
int Nsam, /* number of windowed samples to use */
int order /* order of LPC analysis */
)
{
int i,j; /* loop variables */
scalar Zero = fl_to_numb(0.0);
for(j=0; j<order+1; j++) {
Rn[j] = Zero;
for(i=0; i<Nsam-j; i++)
Rn[j] = s_add(Rn[j] , s_mul(Sn[i],Sn[i+j]));
}
}
mccp_result_t
mccp_hashmap_add_no_lock(mccp_hashmap_t *hmptr,
void *key, void **valptr,
bool allow_overwrite) {
mccp_result_t ret = MCCP_RESULT_ANY_FAILURES;
if (hmptr != NULL &&
*hmptr != NULL &&
valptr != NULL) {
ret = s_add(hmptr, key, valptr, allow_overwrite);
} else {
ret = MCCP_RESULT_INVALID_ARGS;
}
return ret;
}
lagopus_result_t
lagopus_hashmap_add_no_lock(lagopus_hashmap_t *hmptr,
void *key, void **valptr,
bool allow_overwrite) {
lagopus_result_t ret = LAGOPUS_RESULT_ANY_FAILURES;
if (hmptr != NULL &&
*hmptr != NULL &&
valptr != NULL) {
ret = s_add(hmptr, key, valptr, allow_overwrite);
} else {
ret = LAGOPUS_RESULT_INVALID_ARGS;
}
return ret;
}
void inc_size(struct locked_table *tab) {
// First save the size so we can tell if someone else already resized
int old_size = tab->cap;
// Stop resizing if we're at allocation.
if (old_size == PREALLOC_COUNT) {
printf("Oops -- prealloc count reached\n");
goto end;
}
// Acq all the locks
for (int i = 0; i < tab->initial_cap; i++) {
pthread_rwlock_wrlock(tab->locks + i);
}
if (tab->cap != old_size)
goto end;
// Go through and reposition all the old elements
for (int i = 0; i < tab->cap; i++) {
struct serial_list *this_bucket = tab->buckets + i;
struct serial_list_elem *e = this_bucket->head;
while (e) {
int new_ind = e->key & (tab->cap * 2 - 1);
if (new_ind != i) {
s_add(tab->buckets + new_ind, e->key, e->pkt);
int key = e->key;
e = e->next;
s_remove (this_bucket, key);
}
else {
e = e->next;
}
}
}
tab->cap *= 2;
end:
for (int i = 0; i < tab->initial_cap; i++) {
pthread_rwlock_unlock(tab->locks + i);
}
return;
}
bool locked_add(struct hashtable *_t, int key, Packet_t *pkt) {
struct locked_table *tab = (struct locked_table *) _t;
int lock_ind = key & (tab->initial_cap - 1);
bool trigger_resize = false;
pthread_rwlock_wrlock (tab->locks + lock_ind);
int bucket_ind = key & (tab->cap - 1);
bool succ = s_add (tab->buckets + bucket_ind, key, pkt);
if (tab->buckets[bucket_ind].size > RESIZE_THRESH)
trigger_resize = true;
pthread_rwlock_unlock (tab->locks + lock_ind);
if (trigger_resize)
inc_size(tab);
return succ;
}
// old, plus
void WindowSize::draw_calculation(const int y, const int o, const int p)
{
const int base = (hex.get_checked() ? 16 : 10);
std::string s_old(4, ' ');
std::string s_add(4, ' ');
std::string s_new(4, ' ');
std::string s_pls(p < 0 ? "-" : "+");
std::string s_eql("=");
Torbit& tb = get_torbit();
BITMAP* bp = tb.get_al_bitmap();
// Alte Zahl wegputzen
rectfill(bp, x_offset, y, this_xl-2,y+19,color[COL_API_M]);
for (int i = 3, temp = o; i >= 0 && temp > 0; --i) {
s_old[i] = digit_to_character(temp % base);
temp /= base;
if (temp == 0 && base == 16 && i > 0) s_old[i-1] = 'x';
}
for (int i = 3, temp = o+p; i >= 0 && temp > 0; --i) {
s_new[i] = digit_to_character(temp % base);
temp /= base;
if (temp == 0 && base == 16 && i > 0) s_new[i-1] = 'x';
}
s_add[3] = '0';
for (int i = 3, temp = (p < 0) ? -p : p; i >= 0 && temp > 0; --i) {
s_add[i] = digit_to_character(temp % base);
temp /= base;
if (temp == 0 && base == 16 && i > 0) s_add[i-1] = 'x';
}
const int x_here = get_x_here() + x_offset;
Help::draw_shadow_fixed_text(tb, font_med, s_old, x_here+ 0, y, color[COL_TEXT]);
Help::draw_shadow_fixed_text(tb, font_med, s_pls, x_here+ 55, y, color[COL_TEXT]);
Help::draw_shadow_fixed_text(tb, font_med, s_add, x_here+ 85, y, color[COL_TEXT]);
Help::draw_shadow_fixed_text(tb, font_med, s_eql, x_here+135, y, color[COL_TEXT]);
Help::draw_shadow_fixed_text(tb, font_med, s_new, x_here+160, y, color[COL_TEXT_ON]);
}
int main(int argc, char** argv) {
int error = 1;
printf("Set Testing Framework\n");
printf("\n");
// Test equality first so we can use it in later tests
printf("Phase 0: Testing equality methods.\n");
{
set *s1 = malloc(sizeof(set));
set *s2 = malloc(sizeof(set));
int numbers[8] = { -1, 5, 8, 2, 3, 5, 9, 10 };
int order1 [8] = { 0, 7, 3, 2, 4, 5, 6, 1 };
int order2 [8] = { 6, 2, 7, 3, 1, 0, 5, 4 };
int i;
for (i = 0; i < 8; i++) {
s_add(s1, numbers[order1[i]]);
s_add(s2, numbers[order2[i]]);
}
bool eq = s_eq(s1, s2);
if (!eq) {
return error;
}
printf("Equal sets are equal.\n");
error++;
bool seq = s_subseteq(s1, s2) && s_subseteq(s2, s1);
if (!seq) {
return error;
}
printf("Subset works both ways.\n");
error++;
}
printf("\n");
printf("Phase I: Testing single-set operations.\n");
{
set *s = malloc(sizeof(set));
printf("Set created.\n");
error++;
printf("Adding numbers.\n");
s_add(s, 1);
s_add(s, 0);
s_add(s, 6);
s_add(s, 6);
s_add(s, 1);
s_add(s, -1);
// set is now { 1, 0, 6, -1 }
if (s_size(s) != 4) {
return error;
}
printf("Size correct.\n");
error++;
printf("Removing numbers.\n");
s_remove(s, 3); // nothing
s_remove(s, 1); // -1
s_remove(s, 6); // -2
// set is now { 0, -1 }
if (s_size(s) != 2) {
return error;
}
printf("Size still correct.\n");
error++;
printf("Testing s_contains.\n");
{
bool okay = true;
okay &= s_contains(s, 0);
okay &= (!s_contains(s, 1));
okay &= s_contains(s, -1);
okay &+ (!s_contains(s, 8));
if (!okay) {
return error;
}
}
printf("s_contains works as intended.\n");
error++;
}
printf("\n");
printf("Phase II: Testing Multi-Set Operations\n");
{
set *s1 = malloc(sizeof(set)), *s2 = malloc(sizeof(set));
printf("Two sets created.\n");
error++;
s_add(s1, 1);
s_add(s1, 3);
s_add(s1, 7);
s_add(s2, 5);
s_add(s2, -2);
s_add(s2, 3);
printf("Two sets filled.\n");
error++;
{
set *sr_union = s_union(s1, s2);
printf("Union created.\n");
error++;
int shouldBe[5] = { -2, 1, 3, 5, 7 };
int size = sizeof(shouldBe) / sizeof(int);
if (s_size(sr_union) != size) {
node *n = sr_union -> first;
while (n != NULL ) {
printf("%d ", n -> value);
n = n -> next;
}
printf("\n");
printf("Size is %d but should be %d!\n", s_size(sr_union), size);
return error;
}
printf("Size correct (getting good at this).\n");
error++;
int i;
for (i = 0; i < size; i++) {
if (!s_contains(sr_union, shouldBe[i])) {
return error;
}
}
printf("Union set contains all required elements.\n");
error++;
}{
set *sr_isect = s_isect(s1, s2);
printf("Intersection created.\n");
error++;
int shouldBe[1] = { 3 };
int size = sizeof(shouldBe) / sizeof(int);
if (s_size(sr_isect) != size) {
return error;
}
printf("Size correct (again).\n");
error++;
int i;
for (i = 0; i < size; i++) {
if (!s_contains(sr_isect, shouldBe[i])) {
return error;
}
}
printf("Intersection set contains all required elements.\n");
error++;
}{
set *sr_diff = s_diff(s1, s2);
printf("Difference created.\n");
error++;
int shouldBe[2] = { 1, 7 };
int size = sizeof(shouldBe) / sizeof(int);
if (s_size(sr_diff) != size) {
return error;
}
printf("Size correct (miraculously).\n");
error++;
int i;
for (i = 0; i < size; i++) {
if (!s_contains(sr_diff, shouldBe[i])) {
return error;
}
}
printf("Difference set contains all required elements.\n");
error++;
}
}
printf("\n");
printf("Phase III: Testing Specification");
{
set *s = malloc(sizeof(set));
printf("Set created.\n");
error++;
int list[6] = { -2, -1, 1, 4, 8, 9 };
int size = sizeof(list) / sizeof(int);
int i;
for (i = 0; i < size; i++) {
s_add(s, list[i]);
}
printf("Set filled.\n");
error++;
printf("Testing specification with p(x) = (x >= 3).\n");
{
set *sr_p1 = s_spec(s, p1);
printf("Specification complete.\n");
error++;
int expected[3] = { 4, 8, 9 };
int expectedSize = sizeof(expected) / sizeof(int);
if (s_size(sr_p1) != expectedSize) {
return error;
}
printf("Specification size correct - phew!\n");
error++;
int j;
for (j = 0; j < expectedSize; j++) {
if (!s_contains(sr_p1, expected[j])) {
return error;
}
}
printf("Set contains all required elements.\n");
}
printf("Testing specification with p(x) = (x %% 2 == 0).\n");
{
set *sr_p1 = s_spec(s, p2);
printf("Specification complete.\n");
error++;
int expected[3] = { -2, 4, 8 };
int expectedSize = sizeof(expected) / sizeof(int);
if (s_size(sr_p1) != expectedSize) {
return error;
}
printf("Specification size correct; what a surprise.\n");
error++;
int j;
for (j = 0; j < expectedSize; j++) {
if (!s_contains(sr_p1, expected[j])) {
return error;
}
}
printf("Set contains all required elements.\n");
}
}
printf("\n");
printf("Phase IV: Testing Image\n");
{
set *s = malloc(sizeof(set));
set *control = malloc(sizeof(set));
set *control2 = malloc(sizeof(set)); // image with predicate lambda x: x >= 3
int toadd[6] = { -1, 3, 5, 2, 0, 1 };
int expected[6] = { 3, 11, 27, 6, 2, 3 };
int expected2[6] = { 11, 27 };
int i;
for (i = 0; i< 6; i++) {
s_add(s, toadd[i]);
s_add(control, expected[i]);
if (i < 2) s_add(control2, expected2[i]);
}
set *image = s_fullimage(s, f);
bool eq = s_eq(image, control);
if (!eq) {
return error;
}
printf("Full image set matches control set.\n");
error++;
set *pimage = s_image(s, p1, f);
bool peq = s_eq(pimage, control2);
if (!peq) {
return error;
}
printf("Partial image set matches control set.\n");
error++;
}
printf("\n");
printf("Completed without error.\n");
return 0;
}
/* s_add from file ``file'' */
static void
s_file(struct songs **songs, const char *file) {
FILE *f = stdin;
char b[PATH_MAX];
char *t = NULL;
char *dnam = NULL;
size_t s = 0;
ssize_t l = 0;
size_t dlen = 0;
assert(songs != NULL);
if (file != NULL && strcmp(file, "-") != 0) {
char *p;
ssize_t s;
dnam = dirname(file);
if ((dnam = dirname(file)) == NULL) {
warn("dirname %s", file);
return;
}
if (strcmp(dnam, ".") == 0)
dnam = NULL;
else if ((dlen = strlen(dnam)) == 0)
/* probably unreachable */
errx(EX_NOINPUT, "strlen");
if ((f = fopen(file, "r")) == NULL) {
warn("fopen %s", file);
return;
}
}
while ((l = getline(&t, &s, f)) > 0) {
size_t i = 0;
int err;
/* skip trailing whitespace */
while (l > 0 && isspace(t[l - 1]))
l--;
/* skip leading whitespace */
while (l > 0 && isspace(t[i])) {
i++;
l--;
}
if (l == 0)
continue;
if (t[i] == '/' || dnam == NULL) {
if (l + 1 >= sizeof(b)) {
warnx("s_file path too long");
return;
}
if (snprintf(b, l + 1, "%*s", (int)l, t + i)
>= sizeof(b)) {
/* probably unreachable */
warnx("snprintf path too long");
return;
}
} else { /* prepend the file's directory */
/* skip "./" prefix */
if (l >= 2 && t[i] == '.' && t[i + 1] == '/') {
i += 2;
l -= 2;
if (l == 0)
continue;
}
if (dlen + l + 2 >= sizeof(b)) {
warnx("s_file path too long");
return;
}
if (snprintf(b, dlen + l + 2, "%s/%*s",
dnam, (int)l, t + i) >= sizeof(b)) {
/* probably unreachable */
warnx("snprintf path too long");
return;
}
}
s_add(songs, b);
}
if (t != NULL)
free(t);
if (file != NULL && strcmp(file, "-") != 0)
fclose(f);
return;
}
/* add ``f'' to songs, or its contents if ``f'' is a directory */
static void
s_add(struct songs **songs, const char *path) {
struct stat st;
struct songs *s;
DIR *d;
struct dirent *e;
char *p;
size_t l;
assert(songs != NULL && path != NULL);
s = *songs;
if (s == NULL) {
if ((s = malloc(sizeof(struct songs)
+ ISNGSIZ * sizeof(char *))) == NULL)
err(EX_OSERR, "malloc");
s->size = ISNGSIZ;
s->cur = 0;
*songs = s;
}
if (stat(path, &st) != 0) {
warn("stat %s", path);
return;
}
if ((st.st_mode & S_IFDIR) != 0) {
DIR *d;
struct dirent *e;
char b[PATH_MAX];
if ((d = opendir(path)) == NULL) {
warn("opendir %s", path);
return;
}
while ((e = readdir(d)) != NULL) {
if (snprintf(b, sizeof(b), "%s/%*s", path,
(int)e->d_namlen, e->d_name) >= sizeof(b)) {
warnx("snprintf path too long");
break;
}
if (stat(b, &st) != 0) { /* removal race */
warn("stat %s", path);
continue;
}
/* do not recursively search directories */
if (!(st.st_mode & S_IFDIR))
s_add(songs, b);
}
closedir(d);
return;
}
if (s->cur + 1 >= s->size) {
void *p;
if (s->size > 0xFFFF) /* (not so) sane cap */
err(EX_SOFTWARE, "'songs' sanity check");
s->size *= 2;
if ((p = realloc(s, sizeof(struct songs) +
s->size * sizeof(char *))) == NULL)
err(EX_OSERR, "realloc");
s = p;
*songs = s;
}
/* allocate paths here to simplify freeing */
if ((l = strlen(path)) + 1 >= PATH_MAX) {
warnx("s_add path too long");
return;
}
if ((p = malloc(l + 1)) == NULL)
err(EX_OSERR, "malloc");
strncpy(p, path, l);
p[l] = '\0';
s->songs[s->cur++] = p;
s->songs[s->cur] = NULL;
return;
}
/*
* Play audio, normally as a background process.
*/
int
main(int argc, char **argv) {
struct conf conf;
char *cmdfile = NULL;
sigset_t sigmask;
int fd;
int e;
int c;
conf.cmd.f = stdin;
conf.cmd.i = 0;
conf.cmd.conn = 1;
conf.buffer = NULL;
conf.songs = NULL;
conf.dev = NULL;
conf.flags = 0;
while ((c = getopt(argc, argv, "c:d:f:hilrv")) != -1)
switch (c) {
case 'c':
if (strcmp(optarg, "-") == 0) {
cmdfile = NULL;
conf.flags |= CFLAG;
} else
cmdfile = optarg;
break;
case 'd':
conf.dev = optarg;
break;
case 'f': /* file-list */
s_file(&conf.songs, optarg);
break;
case 'h':
usage(0); /* does not return */
case 'i':
info();
return 0;
case 'l': /* loop */
conf.flags |= LFLAG;
break;
case 'r': /* random shuffle */
conf.flags |= RFLAG;
break;
case 'v': /* verbose */
conf.flags |= VFLAG;
break;
case '?':
usage(1); /* does not return */
}
if (cmdfile != NULL) {
if ((fd = open(cmdfile, O_RDONLY | O_NONBLOCK)) < 0)
err(EX_NOINPUT, "open %s", cmdfile);
if ((conf.cmd.f = fdopen(fd, "r")) == NULL) {
close(fd);
err(EX_NOINPUT, "open %s", cmdfile);
}
}
while (optind < argc)
s_add(&conf.songs, argv[optind++]);
if (((cmdfile != NULL || !isatty(0)) && !(conf.flags & CFLAG))
&& conf.songs == NULL) {
s_file(&conf.songs, NULL);
if (cmdfile == NULL)
conf.cmd.f = NULL;
}
if (conf.songs == NULL)
exit(EX_NOINPUT);
if (signal(SIGINFO, sig_info) == SIG_ERR ||
signal(SIGINT, sig_int) == SIG_ERR ||
signal(SIGUSR1, sig_usr1) == SIG_ERR ||
signal(SIGUSR2, sig_usr2) == SIG_ERR ||
signal(SIGTERM, sig_term) == SIG_ERR ||
signal(SIGTTIN, SIG_IGN) == SIG_ERR)
err(EX_OSERR, "signal");
if (sigemptyset(&sigmask) != 0 ||
sigaddset(&sigmask, SIGINFO) != 0 ||
sigaddset(&sigmask, SIGINT) != 0 ||
sigaddset(&sigmask, SIGUSR1) != 0 ||
sigaddset(&sigmask, SIGUSR2) != 0 ||
sigaddset(&sigmask, SIGTERM) != 0 ||
sigaddset(&sigmask, SIGTTIN) != 0)
err(EX_OSERR, "sigaddset");
if (signal(SIGQUIT, sig_term) != SIG_ERR &&
sigaddset(&sigmask, SIGQUIT) != 0)
err(EX_SOFTWARE, "SIGQUIT");
if (sigprocmask(SIG_UNBLOCK, &sigmask, NULL) != 0 ||
sigprocmask(0, NULL, &sigmask) != 0)
err(EX_OSERR, "sigprocmask");
#ifndef OSS
if ((conf.out = a_open(conf.dev)) == NULL)
err(EX_SOFTWARE, "a_open");
#endif
conf.songs->shuffle = NULL;
if ((conf.flags & RFLAG) && (conf.songs->shuffle =
malloc(conf.songs->cur * sizeof(uint16_t))) == NULL)
err(EX_OSERR, "malloc");
if (conf.cmd.f != NULL) {
if ((conf.kq = kqueue()) < 0)
err(EX_OSERR, "kqueue");
EV_SET(&conf.ev, fileno(conf.cmd.f), EVFILT_READ,
EV_ADD | EV_ENABLE | EV_CLEAR, 0, 0, NULL);
if (kevent(conf.kq, &conf.ev, 1, NULL, 0, NULL) != 0)
err(EX_OSERR, "kevent");
}
if (conf.cmd.f == stdin)
nonblock(0);
if ((conf.buffer = malloc(BUFSIZE)) == NULL)
err(EX_OSERR, "malloc");
#ifdef TAME
tame(TAME_MALLOC | TAME_STDIO | TAME_RPATH, NULL);
#else
#ifdef __OpenBSD__
pledge("malloc stdio rpath", NULL);
#endif
#endif
do
c = play(&conf);
while ((conf.flags & LFLAG) && c == CNULL);
ex:
if (conf.songs != NULL) {
if (conf.songs->shuffle != NULL)
free(conf.songs->shuffle);
while (conf.songs->cur-- > 0)
free(conf.songs->songs[conf.songs->cur]);
free(conf.songs);
}
if (conf.buffer != NULL)
free(conf.buffer);
return EX_OK;
}
int main(int argc, char **argv)
{
if (argc<6) {
fprintf(stderr,"ERROR, not enough argument\n");
exit(1);
}
std::string filename(argv[1]);
int SERVICE_PORT =atoi(argv[2]);
std::string s_add(argv[3]);
int portno = atoi(argv[4]);
std::string logname(argv[5]);
char cCurrentPath[FILENAME_MAX];
if (!getcwd(cCurrentPath, sizeof(cCurrentPath)))
{
return errno;
}
std::string pathname(cCurrentPath);
filename = pathname + "/" + filename;
if (logname=="stdout") {
logfs = stdout;
}
else{
logname = pathname + "/" + logname;
logfs = fopen(logname.c_str(), "w");
}
FILE *ofs = fopen(filename.c_str(), "w");
//FILE *ofs = fopen("/Users/Rex/Desktop/cn_second/cn_second/o.txt", "w");
struct sockaddr_in myaddr; /* our address */
struct sockaddr_in remaddr; /* remote address */
socklen_t addrlen = sizeof(remaddr); /* length of addresses */
int recvlen; /* # bytes received */
int fd; /* our socket */
/* create a UDP socket */
if ((fd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
perror("cannot create socket\n");
return 0;
}
/* bind the socket to any valid IP address and a specific port */
memset((char *)&myaddr, 0, sizeof(myaddr));
myaddr.sin_family = AF_INET;
myaddr.sin_addr.s_addr = htonl(INADDR_ANY);
myaddr.sin_port = htons(SERVICE_PORT);
if (bind(fd, (struct sockaddr *)&myaddr, sizeof(myaddr)) < 0) {
perror("bind failed");
return 0;
}
/////intial ack related sender tcp//////
int n,sockfd;
struct sockaddr_in serv_addr;
struct hostent *server;
sockfd = socket(AF_INET, SOCK_STREAM, 0);
if (sockfd < 0)
printf("ERROR opening socket");
server = gethostbyname(s_add.c_str());
if (server == NULL) {
fprintf(stderr,"ERROR, no such host\n");
exit(0);
}
bzero((char *) &serv_addr, sizeof(serv_addr));
serv_addr.sin_family = AF_INET;
bcopy((char *)server->h_addr,
(char *)&serv_addr.sin_addr.s_addr,
server->h_length);
serv_addr.sin_port = htons(portno);
if (connect(sockfd,(struct sockaddr *)&serv_addr,sizeof(serv_addr)) < 0)
printf("ERROR connecting");
int ws;
char addtmp[256];
read(sockfd, &ws, sizeof(int));
read(sockfd, addtmp, 255);
write(sockfd,s_add.c_str() , s_add.size() );
//local = string(addtmp,strlen(addtmp));
local = "127.0.0.1";
//////////
std::vector<out_order_buffer_unit> out_order_buf;
for(int i = 0; i<ws; i ++){
byte *temp = new byte[BUFSIZE+20];
out_order_buffer_unit tmp(-1,temp);
out_order_buf.push_back(tmp);
}
/* now loop, receiving data and printing what we received */
//printf("waiting on port %d\n", SERVICE_PORT);
byte *tcp_packet = new byte[20+BUFSIZE];
short flag,checksum,trash_short;
short len = BUFSIZE;
int totalbyte = 0,countretrans=0;
int seq = 0,acknum = 0,rcv_base = 0,trash_int = 0,hehe;
while(1){
recvlen = recvfrom(fd, tcp_packet, 20+BUFSIZE, 0, (struct sockaddr *)&serv_addr, &addrlen);
len = parse_packet(tcp_packet, &seq, &acknum, &flag, &checksum);
writelog(time(0), s_add, local, seq*BUFSIZE, seq*BUFSIZE+1, flag, -1);
if (flag == END) {
break;
}
if (len==-1){
continue;
}
else{
if (seq==rcv_base) {
totalbyte += 20+len;
//string tmp = "len is "+std::to_string(len)+"\n";
//fwrite(tmp.c_str(), 1, tmp.size(), logfs);
//std::cout<<"len is "<<len<<"\n";
//std::cout<<"Write seq # "<<seq<<" with len = "<<len<<"\n";
fwrite(tcp_packet+20, 1, len, ofs);
//greedy check buffer
int target = seq+1;
rcv_base++;
for(int i = 0; i<ws; i++){
if (out_order_buf[i].first == target){
short len_t = parse_packet(out_order_buf[i].second, &hehe, &trash_int, &trash_short, &trash_short);
//tmp = "len_t is "+std::to_string(len_t)+"\n";
//fwrite(tmp.c_str(), 1, tmp.size(), logfs);
fwrite( (out_order_buf[i].second)+ 20, 1, len_t, ofs);
totalbyte += 20+len_t;
rcv_base++;
target++;
out_order_buf[i].first = -1;
}
}
acknum = seq+1;
flag = ACK;
make_packet(tcp_packet, &seq, &acknum, &flag, &checksum, ofs);
n = write(sockfd, tcp_packet, 20);
if (n < 0)
printf("ERROR writing to socket");
writelog(time(0), local, s_add, seq*BUFSIZE, seq*BUFSIZE+1, flag, -1);
}
else //out of order, buffer it
{
for(int i = 0; i<ws; i++){
if (out_order_buf[i].first == -1){
memcpy(out_order_buf[i].second, tcp_packet, 20+BUFSIZE);
out_order_buf[i].first = seq;
sort(out_order_buf.begin(),out_order_buf.end());
break;
}
}
acknum = seq + 1;
flag = ACK;
checksum = 0;
make_packet(tcp_packet, &seq, &acknum, &flag, &checksum, ofs);
n = write(sockfd, tcp_packet, 20);
if (n < 0)
printf("ERROR writing to socket");
writelog(time(0), local, s_add, seq*BUFSIZE, seq*BUFSIZE+1, flag, -1);
}
}
//printf("seq is %d\n",seq);
}
string summary = "Transmission was successful!\nTotal bytes sent is "+std::to_string(totalbyte)+
"\nNumber of sent segment is "+std::to_string(seq)+"\n";
fwrite(summary.c_str(), 1, summary.size(), logfs);
fclose(logfs);
fclose(ofs);
free(tcp_packet);
for(int i = 0; i<ws; i ++){
free(out_order_buf[i].second);
}
return 0;
}
/* learn AdaBoost stage A[i,j] */
void learnA( int posCount, int negCount, int blockCount, int *rejectCount, bool rejected[],
float ***POS, float ***NEG, Ada *H, float *F_current, float d_minA, float f_maxA, FILE *fout ) {
int selectTable[ posCount ]; /* image selection table */
int imgCount = posCount * 2;
float initialW = 1.f / (float)imgCount;
Matrix posWeight, negWeight; /* data weight in AdaBoost */
int hAllocated = 10;
int hUsed = 0;
int Iid, t;
float f_local = 1.f;
float threshold = 0.f; /* threshold of the strong classifier A[i,j], should be recorded */
Matrix posResult, negResult;
ones( &posWeight, 1, posCount, 1 );
ones( &negWeight, 1, posCount, 1 );
H = (Ada *)malloc( hAllocated * sizeof( Ada ) );
zeros( &posResult, 1, posCount, 1 );
zeros( &negResult, 1, posCount, 1 );
/* Initialize the data weight */
s_mul( &posWeight, initialW );
s_mul( &negWeight, initialW );
/* [0] Randomly select NEG examples from the bootstrap set
* Report an error if NEG images are not enough
*/
if ( posCount + (*rejectCount) > negCount ) {
fprintf( fout, "Warning: Not enough NEG images.\n" );
error( "learnA(): Not enough NEG images." );
}
select_neg( posCount, negCount, rejected, selectTable );
while ( f_local > f_maxA ) {
int fpCount; /* false positive count */
float d_local = 0.f;
/* [1] Add a weak learner h to the strong classifier A[i,j] */
/* Use realloc() if H is full */
if ( hUsed == hAllocated ) {
hAllocated *= 2;
printf( "call realloc()\n" );
H = (Ada*)realloc( H, hAllocated * sizeof( Ada ) );
}
addWeak( posCount, negCount, blockCount, selectTable,
POS, NEG, &posWeight, &negWeight, H, &hUsed );
threshold = 0.f; /*** Adjust by the threshold ONLY WHEN NECESSARY ***/
float minPosResult = 0.f; /* minimum value of the positive result */
int detect = 0; /* detection count */
fpCount = 0;
/* [2.1] Use the H(x) so far to trial-classify
* H(x) = sign( sum[alpha_t * h_t(x)] )
* Process the POS and NEG together in one loop
*/
for ( Iid = 0; Iid < posCount; Iid++ ) {
float posTemp = 0.f;
float negTemp = 0.f;
for ( t = 0; t < hUsed; t++ ) {
int Bid = H[ t ].Bid;
int Fid = H[ t ].Fid;
short parity = H[ t ].parity;
float decision = H[ t ].decision;
float alpha = H[ t ].alpha;
/* determine that positive is positive */
if ( parity * POS[ Iid ][ Bid ][ Fid ] >= parity * decision ) {
posTemp += alpha;
}
/* determine that positive is negative */
else {
posTemp -= alpha;
}
/* determine that negative is positive */
if ( parity * NEG[ selectTable[ Iid ] ][ Bid ][ Fid ] >= parity * decision ) {
negTemp += alpha;
}
/* determine that negative is negative */
else {
negTemp -= alpha;
}
} /* end of loop "t" */
/* Record into posResult or negResult, and collect min( posResult ) */
posResult.data[ 0 ][ 0 ][ Iid ] = posTemp;
negResult.data[ 0 ][ 0 ][ Iid ] = negTemp;
if ( posTemp < minPosResult ) {
minPosResult = posTemp;
}
} /* end of loop "Iid" */
#if 0
full_dump( &posResult, "posResult", ALL, FLOAT );
full_dump( &negResult, "negResult", ALL, FLOAT );
#endif
#if 1
/* count for detections and false positives */
for ( Iid = 0; Iid < posCount; Iid++ ) {
if ( posResult.data[ 0 ][ 0 ][ Iid ] >= 0.f ) {
detect++;
}
if ( negResult.data[ 0 ][ 0 ][ Iid ] >= 0.f ) {
fpCount++;
}
}
d_local = (float)detect / (float)posCount;
printf( "Before modify threshold:\n Detection rate: %f ( %d / %d )\n", d_local, detect, posCount );
/* [3] Calculate f_local of H(x) */
f_local = (float)fpCount / (float)posCount;
printf( " False positive rate: %f ( %d / %d )\n", f_local, fpCount, posCount );
#endif
/* [2.2] Modify the threshold of H(x) to fulfill d_minA
* If min( posResult ) < 0, then let
* result = result - min( posResult ) so that all POS data are
* determined as positive, i.e., detection rate = 100%
*/
if ( minPosResult < 0.f ) {
threshold = minPosResult;
s_add( &posResult, -threshold );
s_add( &negResult, -threshold );
}
printf( "threshold: %f\n", threshold );
#if 0
full_dump( &posResult, "posResult", ALL, FLOAT );
full_dump( &negResult, "negResult", ALL, FLOAT );
#endif
/* count for detections and false positives */
detect = 0;
fpCount = 0;
for ( Iid = 0; Iid < posCount; Iid++ ) {
if ( posResult.data[ 0 ][ 0 ][ Iid ] >= 0.f ) {
detect++;
}
if ( negResult.data[ 0 ][ 0 ][ Iid ] >= 0.f ) {
fpCount++;
}
}
d_local = (float)detect / (float)posCount;
printf( " After modify threshold:\n Detection rate: %f ( %d / %d )\n", d_local, detect, posCount );
//assert( d_local >= d_minA );
/* [3] Calculate f_local of H(x) */
f_local = (float)fpCount / (float)posCount;
printf( "False positive rate: %f ( %d / %d )\n", f_local, fpCount, posCount );
} /* end of loop "f_local > f_maxA" */
*F_current *= f_local;
printf( "\nWeak learners used: %d\n", hUsed );
printf( "Overall false positive rate: %f\n", *F_current );
/* [4] Put in the "rejection list" the negative images rejected by H(x) */
for ( Iid = 0; Iid < posCount; Iid++ ) {
if ( negResult.data[ 0 ][ 0 ][ Iid ] < 0.f ) {
rejected[ selectTable[ Iid ] ] = true;
(*rejectCount)++;
}
}
printf( "Rejected %d negative images in total.\n", *rejectCount );
getchar();
/* [5] Output H(x) information to file */
fprintf( fout, "%d %f\n", hUsed, threshold );
for ( t = 0; t < hUsed; t++ ) {
fprintf( fout, "%d %d %d %f %f\n",
H[ t ].Bid, H[ t ].Fid, H[ t ].parity, H[ t ].decision, H[ t ].alpha );
}
/* Free memory space */
freeMatrix( &posWeight );
freeMatrix( &negWeight );
free( H );
freeMatrix( &posResult );
freeMatrix( &negResult );
}
