Exemplo n.º 1
0
static void kradpulse_capture_cb(pa_stream *stream, size_t length, void *userdata) {

    krad_pulse_t *kradpulse = (krad_pulse_t *)userdata;

    pa_usec_t usec;
    int neg;
    const void *samples;
    int c, s;

    pa_stream_get_latency(stream, &usec, &neg);

    //printf("  latency %8d us wanted %d frames\n", (int)usec, length / 4 / 2 );

    pa_stream_peek(stream, &samples, &length);

    if ((krad_ringbuffer_write_space (kradpulse->kradaudio->input_ringbuffer[1]) >= length / 2 ) && (krad_ringbuffer_write_space (kradpulse->kradaudio->input_ringbuffer[0]) >= length / 2 )) {


        memcpy(kradpulse->capture_interleaved_samples, samples, length);

        pa_stream_drop(stream);

        for (s = 0; s < length / 4 / 2; s++) {
            for (c = 0; c < 2; c++) {
                kradpulse->capture_samples[c][s] = kradpulse->capture_interleaved_samples[s * 2 + c];
            }
        }

        for (c = 0; c < 2; c++) {
            krad_ringbuffer_write (kradpulse->kradaudio->input_ringbuffer[c], (char *)kradpulse->capture_samples[c], (length / 2) );
        }


        for (c = 0; c < 2; c++) {
            compute_peak(kradpulse->kradaudio, KINPUT, &kradpulse->capture_interleaved_samples[c], c, length / 4 / 2 , 1);
        }


    }

    if (kradpulse->kradaudio->process_callback != NULL) {
        kradpulse->kradaudio->process_callback(length / 4 / 2, kradpulse->kradaudio->userdata);
    }

}
Exemplo n.º 2
0
static void *krad_transmitter_transmission_thread (void *arg) {

    krad_transmission_t *krad_transmission = (krad_transmission_t *)arg;

    krad_system_set_thread_name ("kr_tx_txmtr");

    int r;
    int e;
    int ret;
    int wait_time;
    uint64_t last_position;
    uint32_t new_bytes_avail;
    uint32_t space_avail;
    uint32_t drop_count;
    krad_transmission_receiver_t *krad_transmission_receiver;

    r = 0;
    e = 0;
    ret = 0;
    wait_time = 2;
    last_position = 0;
    new_bytes_avail = 0;
    space_avail = 0;
    drop_count = 0;
    krad_transmission_receiver = NULL;

    printk ("Krad Transmitter: transmission thread starting for %s", krad_transmission->sysname);

    while (krad_transmission->active == 1) {

        if (krad_transmission->new_data == 1) {

            if (krad_transmission->new_sync_point == 1) {
                krad_transmission->sync_point = krad_transmission->position;
                krad_transmission->new_sync_point = 0;
            }

            space_avail = krad_ringbuffer_write_space (krad_transmission->transmission_ringbuffer);
            new_bytes_avail = krad_ringbuffer_read_space (krad_transmission->ringbuffer);

            if (space_avail < new_bytes_avail) {
                drop_count = new_bytes_avail - space_avail;
                krad_ringbuffer_read_advance (krad_transmission->transmission_ringbuffer, drop_count);
            }

            krad_ringbuffer_read (krad_transmission->ringbuffer,
                                  (char *)krad_transmission->transmission_buffer,
                                  new_bytes_avail);

            krad_ringbuffer_write (krad_transmission->transmission_ringbuffer,
                                   (char *)krad_transmission->transmission_buffer,
                                   new_bytes_avail);

            krad_transmission->position += new_bytes_avail;
            if (krad_transmission->position > DEFAULT_RING_SIZE) {
                krad_transmission->horizon = krad_transmission->position - DEFAULT_RING_SIZE;
            }

            krad_ringbuffer_get_read_vector (krad_transmission->transmission_ringbuffer,
                                             &krad_transmission->tx_vec[0]);
            krad_transmission->new_data = 0;
        }

        ret = epoll_wait (krad_transmission->connections_efd, krad_transmission->transmission_events,
                          KRAD_TRANSMITTER_MAXEVENTS, wait_time);

        if (ret < 0) {
            if ((ret < 0) && (errno == EINTR)) {
                continue;
            }
            printke ("Krad Transmitter: Failed on epoll wait %s", strerror(errno));
            krad_transmission->active = 2;
            break;
        }

        if (ret > 0) {
            for (e = 0; e < ret; e++) {

                krad_transmission_receiver =
                    (krad_transmission_receiver_t *)krad_transmission->transmission_events[e].data.ptr;

                if (krad_transmission_receiver->noob == 1) {
                    krad_transmission_receiver->noob = 0;
                    krad_transmission->receivers++;
                }

                if ((krad_transmission->transmission_events[e].events & EPOLLERR) ||
                        (krad_transmission->transmission_events[e].events & EPOLLHUP) ||
                        (krad_transmission->transmission_events[e].events & EPOLLHUP)) {

                    if (krad_transmission->transmission_events[e].events & EPOLLHUP) {
                        printke ("Krad Transmitter: transmitter transmission receiver connection hangup");
                    }
                    if (krad_transmission->transmission_events[e].events & EPOLLERR) {
                        printke ("Krad Transmitter: transmitter transmission receiver connection error");
                    }
                    if (krad_transmission->transmission_events[e].events & EPOLLHUP) {
                        printk ("Krad Transmitter: client disconnected %d", krad_transmission_receiver->fd);
                    }
                    krad_transmitter_receiver_destroy (krad_transmission_receiver);
                    continue;
                }

                if (krad_transmission->transmission_events[e].events & EPOLLOUT) {
                    krad_transmitter_transmission_transmit (krad_transmission, krad_transmission_receiver);
                }
            }
        }

        if ((last_position != krad_transmission->position) && (krad_transmission->ready_receiver_count > 0)) {
            last_position = krad_transmission->position;
            for (r = 0; r < TOTAL_RECEIVERS; r++) {
                if ((krad_transmission->krad_transmitter->krad_transmission_receivers[r].krad_transmission == krad_transmission) && (krad_transmission->krad_transmitter->krad_transmission_receivers[r].active == 1) && (krad_transmission->krad_transmitter->krad_transmission_receivers[r].ready == 1)) {
                    krad_transmission_receiver = &krad_transmission->krad_transmitter->krad_transmission_receivers[r];
                    krad_transmitter_transmission_transmit (krad_transmission, krad_transmission_receiver);
                }
            }
        }
    }

    krad_transmission->active = 3;

    printk ("Krad Transmitter: transmission thread exiting for %s", krad_transmission->sysname);
    return NULL;
}