Esempio n. 1
0
/* Rotate the low-pass filter, so it becomes band-pass. */
float * get_complex_taps(float * taps, int tapslen, float rotate) {
    size_t align = volk_get_alignment();
    float * ctaps = volk_safe_malloc(tapslen * COMPLEX * sizeof(float), align);

    for(int i = 0; i<tapslen; i++) {
        ctaps[COMPLEX*i]     = taps[i] * cos(rotate*i);
        ctaps[COMPLEX*i + 1] = taps[i] * sin(rotate*i);
    }
    return ctaps;
}
Esempio n. 2
0
void *srslte_vec_malloc(uint32_t size) {
#ifndef HAVE_VOLK
  return malloc(size);
#else
  void *ptr;
  if (posix_memalign(&ptr,volk_get_alignment(),size)) {
    return NULL;
  } else {
    return ptr;
  }
#endif
}
Esempio n. 3
0
void *srslte_vec_realloc(void *ptr, uint32_t old_size, uint32_t new_size) {
#ifndef HAVE_VOLK
  return realloc(ptr, new_size);
#else
  void *new_ptr;
  if (posix_memalign(&new_ptr,volk_get_alignment(),new_size)) {
    return NULL;
  } else {
    memcpy(new_ptr, ptr, old_size);
    free(ptr);
    return new_ptr;
  }
#endif
}
Esempio n. 4
0
/* history .. the frame it should start with (or -1 for current frame) */
worker * create_xlate_worker(float rotate, int decim, int history, float * taps, int tapslen) {

    worker * w = calloc(1, sizeof(worker));

    w->rotate = rotate;
    w->decim = decim;
    w->wid = widx;
    w->taps = get_complex_taps(taps, tapslen, rotate);
    w->tapslen = tapslen;

    w->maxval = calc_max_amplitude(taps, tapslen);

    free(taps);

    if(history == -1) {
        w->last_written = sdr_cptr;
    } else {
        w->last_written = history;
        if(w->last_written < sdr_cptr - BUFSIZE) {
            fprintf(stderr, "Cannot play that much in history\n");
            w->last_written = sdr_cptr - BUFSIZE;
        }
    }
    w->send_cptr = w->last_written;

    // allocate space for one more sample, because there might be a fir offset that will make us produce more tham SDRPACKETSIZE/decim
    w->maxoutsize = COMPLEX * sizeof(float) * (SDRPACKETSIZE/decim+1);
    size_t align = volk_get_alignment();

    //workers[wid].outbuf = safe_malloc(sizeof(char*) * BUFSIZE);
    for(int i = 0; i<BUFSIZE; i++) {
        w->outbuf[i].data = volk_safe_malloc(w->maxoutsize, align);
    }

    int ret = pthread_create(&w->thr, NULL, &xlate_worker_thr, (void*) w);
    if(ret < 0) {
        err(EXIT_FAILURE, "cannot create xlater worker thread");
    }
    pthread_setname_np(w->thr, "worker");

    w->enabled = true;

    SLIST_INSERT_HEAD(&worker_head, w, next);

    widx++;

    return w;

}