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); }
void krad_ebml_player_play_file_blocking(krad_ebml_player_t *krad_ebml_player, char *filename) { krad_ebml_player->command = PLAY; krad_ebml_player->state = PLAYING; kradebml_open_input_file(krad_ebml_player->ebml, filename); //kradebml_open_input_stream(krad_ebml_player->ebml, "192.168.1.2", 9080, "/teststream.krado"); kradebml_debug(krad_ebml_player->ebml); krad_ebml_player->len = kradebml_read_audio_header(krad_ebml_player->ebml, 1, krad_ebml_player->buffer); krad_ebml_player->opus = kradopus_decoder_create(krad_ebml_player->buffer, krad_ebml_player->len, 44100.0f); kradaudio_set_process_callback(krad_ebml_player->audio, krad_ebml_player_audio_callback, krad_ebml_player); while (((krad_ebml_player->len = kradebml_read_audio(krad_ebml_player->ebml, krad_ebml_player->buffer)) > 0) && (krad_ebml_player->command != STOP)) { kradopus_write_opus(krad_ebml_player->opus, krad_ebml_player->buffer, krad_ebml_player->len); while (krad_ringbuffer_read_space (krad_ebml_player->opus->ringbuf[DEFAULT_CHANNEL_COUNT - 1]) >= (RINGBUFFER_SIZE - 960 * 4 * 10)) { usleep(50000); } } while (krad_ebml_player->command != STOP) { usleep(50000); } kradopus_decoder_destroy(krad_ebml_player->opus); krad_ebml_player->state = STOPPED; }
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; }