int krad_opus_decoder_read (krad_opus_t *krad_opus, int channel, char *buffer, int buffer_length) {
int resample_process_size = 512;
krad_opus->ret = krad_ringbuffer_peek (krad_opus->resampled_ringbuf[channel - 1], (char *)buffer, buffer_length );
if (krad_opus->ret >= buffer_length) {
krad_ringbuffer_read_advance (krad_opus->resampled_ringbuf[channel - 1], buffer_length );
return krad_opus->ret;
} else {
while (krad_ringbuffer_read_space (krad_opus->resampled_ringbuf[channel - 1]) < buffer_length) {
if (krad_ringbuffer_read_space (krad_opus->ringbuf[channel - 1]) >= resample_process_size * 4 ) {
krad_opus->ret = krad_ringbuffer_peek (krad_opus->ringbuf[channel - 1],
(char *)krad_opus->read_samples[channel - 1],
(resample_process_size * 4) );
krad_opus->src_data[channel - 1].data_in = krad_opus->read_samples[channel - 1];
krad_opus->src_data[channel - 1].input_frames = resample_process_size;
krad_opus->src_data[channel - 1].data_out = krad_opus->resampled_samples[channel - 1];
krad_opus->src_data[channel - 1].output_frames = 2048;
krad_opus->src_error[channel - 1] = src_process (krad_opus->src_resampler[channel - 1],
&krad_opus->src_data[channel - 1]);
if (krad_opus->src_error[channel - 1] != 0) {
failfast ("krad_opus_read_audio src resampler error: %s\n",
src_strerror(krad_opus->src_error[channel - 1]));
}
krad_ringbuffer_read_advance (krad_opus->ringbuf[channel - 1],
(krad_opus->src_data[channel - 1].input_frames_used * 4) );
krad_opus->ret = krad_ringbuffer_write (krad_opus->resampled_ringbuf[channel - 1],
(char *)krad_opus->resampled_samples[channel - 1],
(krad_opus->src_data[channel - 1].output_frames_gen * 4) );
if (krad_ringbuffer_read_space (krad_opus->resampled_ringbuf[channel - 1]) >= buffer_length ) {
return krad_ringbuffer_read (krad_opus->resampled_ringbuf[channel - 1], buffer, buffer_length );
}
} else {
return 0;
}
}
}
return 0;
}
static void kradpulse_playback_cb(pa_stream *stream, size_t length, void *userdata) {
krad_pulse_t *kradpulse = (krad_pulse_t *)userdata;
pa_usec_t usec;
int neg;
int c, s;
pa_stream_get_latency(stream, &usec, &neg);
//printf(" latency %8d us wanted %d frames\n", (int)usec, length / 4 / 2 );
if (kradpulse->kradaudio->process_callback != NULL) {
kradpulse->kradaudio->process_callback(length / 4 / 2, kradpulse->kradaudio->userdata);
}
if ((krad_ringbuffer_read_space (kradpulse->kradaudio->output_ringbuffer[1]) >= length / 2 ) && (krad_ringbuffer_read_space (kradpulse->kradaudio->output_ringbuffer[0]) >= length / 2 )) {
for (c = 0; c < 2; c++) {
krad_ringbuffer_read (kradpulse->kradaudio->output_ringbuffer[c], (char *)kradpulse->samples[c], (length / 2) );
}
for (s = 0; s < length / 4 / 2; s++) {
for (c = 0; c < 2; c++) {
kradpulse->interleaved_samples[s * 2 + c] = kradpulse->samples[c][s];
}
}
for (c = 0; c < 2; c++) {
compute_peak(kradpulse->kradaudio, KOUTPUT, &kradpulse->interleaved_samples[c], c, length / 4 / 2 , 1);
}
} else {
for (s = 0; s < length / 4 / 2; s++) {
for (c = 0; c < 2; c++) {
kradpulse->interleaved_samples[s * 2 + c] = 0.0f;
}
}
}
pa_stream_write(stream, kradpulse->interleaved_samples, length, NULL, 0LL, PA_SEEK_RELATIVE);
}
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;
}
void *audio_encoding_thread(void *arg) {
krad_v4l2_vpx_display_test_t *display_test = (krad_v4l2_vpx_display_test_t *)arg;
int bytes;
float *audio = calloc(1, 1000000);
unsigned char *buffer = calloc(1, 1000000);
ogg_packet *op;
int framecnt;
if (display_test->audio_codec == 1) {
framecnt = 1470;
}
if (display_test->audio_codec == 2) {
framecnt = 4096;
}
while (!(display_test->stop_audio_encoding)) {
while (krad_ringbuffer_read_space(display_test->input_ringbuffer[1]) > framecnt * 4) {
if (display_test->audio_codec == 1) {
op = krad_vorbis_encode(display_test->krad_vorbis, framecnt, display_test->input_ringbuffer[0], display_test->input_ringbuffer[1]);
if (op != NULL) {
printf("bytes is %ld\n", op->bytes);
if (display_test->first_block == 0) {
pthread_rwlock_rdlock(&display_test->ebml_write_lock);
} else {
display_test->first_block = 0;
}
kradebml_add_audio(display_test->ebml, display_test->audiotrack, op->packet, op->bytes, framecnt);
//kradebml_write(display_test->ebml);
pthread_rwlock_unlock (&display_test->ebml_write_lock);
}
}
if (display_test->audio_codec == 2) {
krad_ringbuffer_read(display_test->input_ringbuffer[1], (char *)audio, 4096 * 4);
bytes = krad_flac_encode(display_test->krad_flac, audio, 4096, buffer);
printf("bytes is %d\n", bytes);
if (display_test->first_block == 0) {
pthread_rwlock_rdlock(&display_test->ebml_write_lock);
} else {
display_test->first_block = 0;
}
kradebml_add_audio(display_test->ebml, display_test->audiotrack, buffer, bytes, 4096);
//kradebml_write(display_test->ebml);
pthread_rwlock_unlock (&display_test->ebml_write_lock);
}
}
while (krad_ringbuffer_read_space(display_test->input_ringbuffer[1]) < framecnt * 4) {
usleep(10000);
if (display_test->stop_audio_encoding) {
break;
}
}
}
free(audio);
free(buffer);
return NULL;
}
void kr_streamer_run (kr_streamer_t *streamer) {
krad_frame_t *frame;
int32_t frames;
kr_medium_t *amedium;
kr_codeme_t *acodeme;
kr_medium_t *vmedium;
kr_codeme_t *vcodeme;
struct SwsContext *converter;
int sws_algo;
int32_t ret;
int32_t muxdelay;
uint32_t c;
muxdelay = 1;
signal (SIGINT, signal_recv);
signal (SIGTERM, signal_recv);
converter = NULL;
sws_algo = SWS_BILINEAR;
amedium = kr_medium_kludge_create ();
acodeme = kr_codeme_kludge_create ();
vmedium = kr_medium_kludge_create ();
vcodeme = kr_codeme_kludge_create ();
streamer->timer = krad_timer_create ();
kr_audioport_connect(streamer->audioport);
kr_videoport_activate (streamer->videoport);
while (!destroy) {
while (krad_ringbuffer_read_space (streamer->audio_ring[1]) >= 1024 * 4) {
for (c = 0; c < streamer->params->channels; c++) {
krad_ringbuffer_read (streamer->audio_ring[c],
(char *)amedium->a.samples[c],
1024 * 4);
}
amedium->a.count = 1024;
amedium->a.channels = streamer->params->channels;
ret = kr_vorbis_encode (streamer->vorbis_enc, acodeme, amedium);
if (ret == 1) {
kr_mkv_add_audio (streamer->mkv, 2,
acodeme->data,
acodeme->sz,
acodeme->count);
muxdelay = 0;
while (1) {
ret = kr_vorbis_encode (streamer->vorbis_enc, acodeme, NULL);
if (ret == 1) {
kr_mkv_add_audio (streamer->mkv, 2,
acodeme->data,
acodeme->sz,
acodeme->count);
} else {
break;
}
}
}
}
if (muxdelay > 0) {
continue;
}
frame = NULL;
frames = krad_ringbuffer_read_space (streamer->frame_ring) / sizeof(void *);
if (frames > 1) {
krad_vpx_encoder_deadline_set (streamer->vpx_enc, 1);
sws_algo = SWS_POINT;
}
if (frames == 0) {
krad_vpx_encoder_deadline_set (streamer->vpx_enc, 10000);
sws_algo = SWS_BILINEAR;
usleep (2000);
continue;
}
if (frames > 0) {
krad_ringbuffer_read (streamer->frame_ring,
(char *)&frame,
sizeof(krad_frame_t *));
vmedium->v.tc = krad_timer_current_ms (streamer->timer);
if (!krad_timer_started (streamer->timer)) {
krad_timer_start (streamer->timer);
}
frame->yuv_pixels[0] = (uint8_t *)frame->pixels;
frame->format = PIX_FMT_RGB32;
frame->yuv_pixels[1] = NULL;
frame->yuv_pixels[2] = NULL;
frame->yuv_strides[0] = streamer->width * 4;
frame->yuv_strides[1] = 0;
frame->yuv_strides[2] = 0;
frame->yuv_strides[3] = 0;
converter = sws_getCachedContext ( converter,
streamer->width,
streamer->height,
frame->format,
streamer->params->width,
streamer->params->height,
PIX_FMT_YUV420P,
sws_algo,
NULL, NULL, NULL);
if (converter == NULL) {
failfast ("Krad streamer: could not sws_getCachedContext");
}
vmedium->v.pps[0] = streamer->params->width;
vmedium->v.pps[1] = streamer->params->width/2;
vmedium->v.pps[2] = streamer->params->width/2;
vmedium->v.ppx[0] = vmedium->data;
vmedium->v.ppx[1] = vmedium->data +
streamer->params->width * (streamer->params->height);
vmedium->v.ppx[2] = vmedium->data + streamer->params->width *
(streamer->params->height) +
((streamer->params->width * (streamer->params->height)) /4);
sws_scale (converter,
(const uint8_t * const*)frame->yuv_pixels,
frame->yuv_strides,
0,
streamer->height,
vmedium->v.ppx,
vmedium->v.pps);
krad_framepool_unref_frame (frame);
ret = kr_vpx_encode (streamer->vpx_enc, vcodeme, vmedium);
if (ret == 1) {
kr_mkv_add_video_tc (streamer->mkv, 1,
vcodeme->data, vcodeme->sz,
vcodeme->key, vcodeme->tc);
}
printf ("\rKrad Streamer Frame# %12"PRIu64"",
streamer->eframes++);
fflush (stdout);
//krad_ticker_wait (streamer->ticker);
}
}
kr_medium_kludge_destroy (&vmedium);
kr_codeme_kludge_destroy (&vcodeme);
kr_medium_kludge_destroy (&amedium);
kr_codeme_kludge_destroy (&acodeme);
if (converter != NULL) {
sws_freeContext (converter);
converter = NULL;
}
krad_timer_destroy (streamer->timer);
}
int audio_encoding_unit_process (void *arg) {
krad_link_t *krad_link = (krad_link_t *)arg;
int c;
int s;
int bytes;
int frames;
int ret;
char buffer[1];
kr_slice_t *kr_slice;
bytes = 0;
kr_slice = NULL;
ret = read (krad_link->socketpair[1], buffer, 1);
if (ret != 1) {
if (ret == 0) {
printk ("Krad AU Transponder: port read got EOF");
return -1;
}
printk ("Krad AU Transponder: port read unexpected read return value %d", ret);
}
if (krad_link->codec != VORBIS) {
frames = krad_link->au_framecnt;
}
while (krad_ringbuffer_read_space(krad_link->audio_input_ringbuffer[krad_link->channels - 1]) >= krad_link->au_framecnt * 4) {
if (krad_link->codec == OPUS) {
for (c = 0; c < krad_link->channels; c++) {
krad_ringbuffer_read (krad_link->audio_input_ringbuffer[c], (char *)krad_link->au_samples[c], (krad_link->au_framecnt * 4) );
krad_opus_encoder_write (krad_link->krad_opus, c + 1, (char *)krad_link->au_samples[c], krad_link->au_framecnt * 4);
}
bytes = krad_opus_encoder_read (krad_link->krad_opus, krad_link->au_buffer, &krad_link->au_framecnt);
}
if (krad_link->codec == FLAC) {
for (c = 0; c < krad_link->channels; c++) {
krad_ringbuffer_read (krad_link->audio_input_ringbuffer[c], (char *)krad_link->au_samples[c], (krad_link->au_framecnt * 4) );
}
for (s = 0; s < krad_link->au_framecnt; s++) {
for (c = 0; c < krad_link->channels; c++) {
krad_link->au_interleaved_samples[s * krad_link->channels + c] = krad_link->au_samples[c][s];
}
}
bytes = krad_flac_encode (krad_link->krad_flac, krad_link->au_interleaved_samples, krad_link->au_framecnt, krad_link->au_buffer);
}
if (krad_link->codec == VORBIS) {
/*
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
for (c = 0; c < krad_link->channels; c++) {
krad_ringbuffer_read (krad_link->audio_input_ringbuffer[c], (char *)float_buffer[c], krad_link->au_framecnt * 4);
}
ret = kr_vorbis_encode (vorbis_enc, codeme, medium);
if (ret == 1) {
kr_mkv_add_audio (new_mkv, 2, codeme->data, codeme->sz, codeme->count);
}
kr_medium_kludge_destroy (&medium);
kr_codeme_kludge_destroy (&codeme);
bytes =
*/
}
while (bytes > 0) {
if (krad_link->subunit != NULL) {
kr_slice = kr_slice_create_with_data (krad_link->au_buffer, bytes);
kr_slice->frames = frames;
kr_slice->codec = krad_link->codec;
kr_xpdr_slice_broadcast (krad_link->subunit, &kr_slice);
kr_slice_unref (kr_slice);
}
bytes = 0;
if (krad_link->codec == VORBIS) {
// bytes = krad_vorbis_encoder_read (krad_link->krad_vorbis, &frames, &krad_link->au_buffer);
}
if (krad_link->codec == OPUS) {
bytes = krad_opus_encoder_read (krad_link->krad_opus, krad_link->au_buffer, &krad_link->au_framecnt);
}
}
}
return 0;
}
int krad_opus_encoder_read (krad_opus_t *krad_opus, unsigned char *buffer, int *nframes) {
int ready;
int bytes;
int resp;
int s, c;
while (krad_ringbuffer_read_space (krad_opus->ringbuf[krad_opus->channels - 1]) >= 512 * 4 ) {
for (c = 0; c < krad_opus->channels; c++) {
krad_opus->ret = krad_ringbuffer_peek (krad_opus->ringbuf[c], (char *)krad_opus->samples[c], (512 * 4) );
krad_opus->src_data[c].data_in = krad_opus->samples[c];
krad_opus->src_data[c].input_frames = 512;
krad_opus->src_data[c].data_out = krad_opus->resampled_samples[c];
krad_opus->src_data[c].output_frames = 2048;
krad_opus->src_error[c] = src_process (krad_opus->src_resampler[c], &krad_opus->src_data[c]);
if (krad_opus->src_error[c] != 0) {
failfast ("Krad Opus Encoder: src resampler error: %s\n", src_strerror(krad_opus->src_error[c]));
}
krad_ringbuffer_read_advance (krad_opus->ringbuf[c], (krad_opus->src_data[c].input_frames_used * 4) );
krad_opus->ret = krad_ringbuffer_write (krad_opus->resampled_ringbuf[c],
(char *)krad_opus->resampled_samples[c],
(krad_opus->src_data[c].output_frames_gen * 4) );
}
}
if (krad_opus->new_bitrate != krad_opus->bitrate) {
krad_opus->bitrate = krad_opus->new_bitrate;
resp = opus_multistream_encoder_ctl (krad_opus->encoder, OPUS_SET_BITRATE(krad_opus->bitrate));
if (resp != OPUS_OK) {
failfast ("Krad Opus Encoder: bitrate request failed %s\n", opus_strerror (resp));
} else {
printk ("Krad Opus Encoder: set opus bitrate %d\n", krad_opus->bitrate);
}
}
if (krad_opus->new_frame_size != krad_opus->frame_size) {
krad_opus->frame_size = krad_opus->new_frame_size;
printk ("Krad Opus Encoder: frame size is now %d\n", krad_opus->frame_size);
}
if (krad_opus->new_complexity != krad_opus->complexity) {
krad_opus->complexity = krad_opus->new_complexity;
resp = opus_multistream_encoder_ctl (krad_opus->encoder, OPUS_SET_COMPLEXITY(krad_opus->complexity));
if (resp != OPUS_OK) {
failfast ("Krad Opus Encoder: complexity request failed %s. \n", opus_strerror(resp));
} else {
printk ("Krad Opus Encoder: set opus complexity %d\n", krad_opus->complexity);
}
}
if (krad_opus->new_signal != krad_opus->signal) {
krad_opus->signal = krad_opus->new_signal;
resp = opus_multistream_encoder_ctl (krad_opus->encoder, OPUS_SET_SIGNAL(krad_opus->signal));
if (resp != OPUS_OK) {
failfast ("Krad Opus Encoder: signal request failed %s\n", opus_strerror(resp));
} else {
printk ("Krad Opus Encoder: set opus signal mode %d\n", krad_opus->signal);
}
}
if (krad_opus->new_bandwidth != krad_opus->bandwidth) {
krad_opus->bandwidth = krad_opus->new_bandwidth;
resp = opus_multistream_encoder_ctl (krad_opus->encoder, OPUS_SET_BANDWIDTH(krad_opus->bandwidth));
if (resp != OPUS_OK) {
failfast ("Krad Opus Encoder: bandwidth request failed %s\n", opus_strerror(resp));
} else {
printk ("Krad Opus Encoder: Set Opus bandwidth mode %d\n", krad_opus->bandwidth);
}
}
ready = 1;
for (c = 0; c < krad_opus->channels; c++) {
if (krad_ringbuffer_read_space (krad_opus->resampled_ringbuf[c]) < krad_opus->frame_size * 4) {
ready = 0;
}
}
if (ready == 1) {
for (c = 0; c < krad_opus->channels; c++) {
krad_opus->ret = krad_ringbuffer_read (krad_opus->resampled_ringbuf[c],
(char *)krad_opus->resampled_samples[c],
(krad_opus->frame_size * 4) );
}
for (s = 0; s < krad_opus->frame_size; s++) {
for (c = 0; c < krad_opus->channels; c++) {
krad_opus->interleaved_resampled_samples[s * krad_opus->channels + c] = krad_opus->resampled_samples[c][s];
}
}
bytes = opus_multistream_encode_float (krad_opus->encoder,
krad_opus->interleaved_resampled_samples,
krad_opus->frame_size,
buffer,
krad_opus->frame_size * 2);
if (bytes < 0) {
failfast ("Krad Opus Encoding failed: %s.", opus_strerror (bytes));
}
*nframes = krad_opus->frame_size;
return bytes;
}
return 0;
}
