int main (int argc, char *argv[]) {
kr_client_t *kr;
kr_videoport_t *kr_videoport;
if (argc != 2) {
if (argc > 2) {
fprintf (stderr, "Only takes station argument.\n");
} else {
fprintf (stderr, "No station specified.\n");
}
return 1;
}
kr = kr_connect (argv[1]);
if (kr == NULL) {
fprintf (stderr, "Could not connect to %s krad radio daemon.\n", argv[1]);
return 1;
}
kr_videoport = kr_videoport_create (kr);
if (kr_videoport != NULL) {
printf ("i worked real good\n");
}
kr_videoport_set_callback (kr_videoport, videoport_process, NULL);
kr_videoport_activate (kr_videoport);
usleep (8000000);
kr_videoport_deactivate (kr_videoport);
kr_videoport_destroy (kr_videoport);
kr_disconnect (kr);
return 0;
}
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 main (int argc, char *argv[]) {
int ret;
uint32_t width;
uint32_t height;
kr_client_t *client;
kr_videoport_t *videoport;
kr_udp_recvr_t *udp_recvr;
int port;
port = 3777;
ret = 0;
if (argc < 2) {
if (argc > 2) {
fprintf (stderr, "Only takes station argument.\n");
} else {
fprintf (stderr, "No station specified.\n");
}
return 1;
}
if (argc > 2) {
port = atoi (argv[2]);
}
client = kr_client_create ("krad videoport client");
if (client == NULL) {
fprintf (stderr, "Could not create KR client.\n");
return 1;
}
kr_connect (client, argv[1]);
if (!kr_connected (client)) {
fprintf (stderr, "Could not connect to %s krad radio daemon.\n", argv[1]);
kr_client_destroy (&client);
return 1;
}
if (kr_compositor_get_info_wait (client, &width, &height, NULL, NULL) != 1) {
kr_client_destroy (&client);
return 1;
}
if (kr_compositor_get_info_wait (client, &width, &height, NULL, NULL) != 1) {
fprintf (stderr, "Could not get compositor info!\n");
kr_client_destroy (&client);
return 1;
}
videoport = kr_videoport_create (client, INPUT);
if (videoport == NULL) {
fprintf (stderr, "Could not make videoport.\n");
kr_client_destroy (&client);
return 1;
} else {
printf ("Working!\n");
}
udp_recvr = calloc (1, sizeof (kr_udp_recvr_t));
udp_recvr->width = width;
udp_recvr->height = height;
udp_recvr->client = client;
udp_recvr->videoport = videoport;
kr_videoport_set_callback (videoport, videoport_process, udp_recvr);
signal (SIGINT, signal_recv);
signal (SIGTERM, signal_recv);
kr_videoport_activate (videoport);
kr_udp_recvr (udp_recvr, port);
kr_videoport_deactivate (videoport);
kr_videoport_destroy (videoport);
kr_client_destroy (&client);
if (udp_recvr->frames > 0) {
printf ("Rendered %d frames!\n", udp_recvr->frames);
}
free (udp_recvr);
if (ret == 0) {
printf ("Worked!\n");
}
return ret;
}
