int main (int argc, char *argv[]) {
krad_vpx_encoder_t *krad_vpx_encoder;
krad_vpx_decoder_t *krad_vpx_decoder;
int width;
int height;
int count;
int bitrate;
width = 640;
height = 480;
count = 0;
bitrate = 1000;
while (count < TEST_COUNT) {
krad_vpx_decoder = krad_vpx_decoder_create();
krad_vpx_decoder_destroy(krad_vpx_decoder);
krad_vpx_encoder = krad_vpx_encoder_create(width, height, bitrate);
krad_vpx_encoder_destroy(krad_vpx_encoder);
count++;
}
printf("it worked\n");
return 0;
}
void vpxtest () {
int32_t ret;
krad_vpx_encoder_t *vpx_enc;
krad_vpx_decoder_t *vpx_dec;
kr_medium_t *medium;
kr_codeme_t *codeme;
vpx_dec = krad_vpx_decoder_create ();
vpx_enc = krad_vpx_encoder_create (1280, 720,
30,
1,
2300);
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
ret = kr_vpx_encode (vpx_enc, codeme, medium);
printf ("Vpx test enc ret was %d", ret);
ret = kr_vpx_decode (vpx_dec, medium, codeme);
printf ("Vpx test dec ret was %d", ret);
kr_codeme_kludge_destroy (&codeme);
kr_medium_kludge_destroy (&medium);
krad_vpx_encoder_destroy (&vpx_enc);
krad_vpx_decoder_destroy (&vpx_dec);
}
int main (int argc, char *argv[]) {
krad_sdl_opengl_display_t *krad_opengl_display;
krad_vpx_decoder_t *krad_vpx_decoder;
kradebml_t *krad_ebml;
int len;
unsigned char *buffer;
buffer = malloc(1000000);
krad_vpx_decoder = krad_vpx_decoder_create();
krad_ebml = kradebml_create();
kradebml_open_input_file(krad_ebml, argv[1]);
//kradebml_open_input_stream(krad_ebml_player->ebml, "192.168.1.2", 9080, "/teststream.krado");
kradebml_debug(krad_ebml);
krad_opengl_display = krad_sdl_opengl_display_create("Krad TEST", 1920, 1080, krad_ebml->vparams.width, krad_ebml->vparams.height);
while ((len = kradebml_read_video(krad_ebml, buffer)) > 0) {
//printf("got len of %d\n", len);
krad_vpx_decoder_decode(krad_vpx_decoder, buffer, len);
if (krad_vpx_decoder->img != NULL) {
//printf("vpx img: %d %d %d\n", krad_vpx_decoder->img->stride[0], krad_vpx_decoder->img->stride[1], krad_vpx_decoder->img->stride[2]);
krad_sdl_opengl_display_render(krad_opengl_display, krad_vpx_decoder->img->planes[0], krad_vpx_decoder->img->stride[0], krad_vpx_decoder->img->planes[1], krad_vpx_decoder->img->stride[1], krad_vpx_decoder->img->planes[2], krad_vpx_decoder->img->stride[2]);
krad_sdl_opengl_draw_screen( krad_opengl_display );
usleep(13000);
}
}
free(buffer);
krad_vpx_decoder_destroy(krad_vpx_decoder);
kradebml_destroy(krad_ebml);
krad_sdl_opengl_display_destroy(krad_opengl_display);
return 0;
}
void kr_udp_recvr (kr_udp_recvr_t *udp_recvr, int port) {
krad_rebuilder_t *krad_rebuilder;
int sd;
int keyframe;
int started;
int ret;
int slen;
unsigned char *buffer;
unsigned char *packet_buffer;
struct sockaddr_in local_address;
struct sockaddr_in remote_address;
struct SwsContext *scaler;
struct pollfd pollfds[4];
scaler = NULL;
started = 0;
slen = sizeof (remote_address);
buffer = calloc (1, 45000);
packet_buffer = calloc (1, 2300000);
sd = socket (AF_INET, SOCK_DGRAM, 0);
krad_rebuilder = krad_rebuilder_create ();
memset((char *) &local_address, 0, sizeof(local_address));
local_address.sin_family = AF_INET;
local_address.sin_port = htons (port);
local_address.sin_addr.s_addr = htonl(INADDR_ANY);
if (bind (sd, (struct sockaddr *)&local_address, sizeof(local_address)) == -1 ) {
printf("bind error\n");
exit(1);
}
kr_udp_recvr_alloc_framebuf (udp_recvr);
udp_recvr->vpxdec = krad_vpx_decoder_create ();
while (1) {
if (destroy == 1) {
printf ("Got signal!\n");
break;
}
pollfds[0].fd = kr_wayland_get_fd(udp_recvr->wayland);
pollfds[0].events = POLLIN;
pollfds[1].fd = sd;
pollfds[1].events = POLLIN;
ret = poll (pollfds, 2, 1);
if (ret < 0) {
break;
}
if (pollfds[0].revents == POLLIN) {
kr_wayland_process(udp_recvr->wayland);
}
if (pollfds[1].revents == POLLIN) {
ret = recvfrom (sd, buffer, 2000, 0, (struct sockaddr *)&remote_address, (socklen_t *)&slen);
if (ret == -1) {
printf("failed recvin udp\n");
exit (1);
}
//printf ("Received packet from %s:%d\n",
// inet_ntoa(remote_address.sin_addr), ntohs(remote_address.sin_port));
krad_rebuilder_write (krad_rebuilder, buffer, ret);
ret = krad_rebuilder_read_packet (krad_rebuilder, packet_buffer, 1, &keyframe);
if (ret != 0) {
//printf ("read a packet with %d bytes key: %d \n", ret, keyframe);
if ((started == 1) || ((started == 0) && (keyframe == 1))) {
started = 1;
} else {
continue;
}
krad_vpx_decoder_decode (udp_recvr->vpxdec, packet_buffer, ret);
while (udp_recvr->vpxdec->img != NULL) {
int rgb_stride_arr[3] = {4*udp_recvr->width, 0, 0};
uint8_t *dst[4];
scaler = sws_getCachedContext ( scaler,
udp_recvr->vpxdec->width,
udp_recvr->vpxdec->height,
PIX_FMT_YUV420P,
udp_recvr->width,
udp_recvr->height,
PIX_FMT_RGB32,
SWS_BICUBIC,
NULL, NULL, NULL);
int pos = ((udp_recvr->frames_dec + 1) % udp_recvr->framebufsize) * udp_recvr->frame_size;
dst[0] = (unsigned char *)udp_recvr->rgba + pos;
sws_scale (scaler,
(const uint8_t * const*)udp_recvr->vpxdec->img->planes,
udp_recvr->vpxdec->img->stride,
0, udp_recvr->vpxdec->height,
dst, rgb_stride_arr);
udp_recvr->frames_dec++;
//printf ("Received frame!\n");
krad_vpx_decoder_decode_again (udp_recvr->vpxdec);
}
}
}
}
krad_vpx_decoder_destroy (&udp_recvr->vpxdec);
kr_udp_recvr_free_framebuf (udp_recvr);
krad_rebuilder_destroy (krad_rebuilder);
close (sd);
sws_freeContext ( scaler );
free (packet_buffer);
free (buffer);
}
static void remuxcode (kr_mkv_t *mkv, char *file, char *file2) {
int32_t ret;
int32_t bytes_read;
uint32_t track;
uint64_t timecode;
uint8_t *buffer;
uint8_t *vbuffer;
uint8_t *vbuffer2;
uint32_t out_track;
kr_mkv_t *new_mkv;
int32_t keyframe;
uint8_t flags;
int32_t packets;
krad_vpx_decoder_t *vpx_dec;
krad_vpx_encoder_t *vpx_enc;
kr_codec_hdr_t header;
kr_medium_t *medium;
kr_codeme_t *codeme;
krad_vorbis_t *vorbis_dec;
krad_vorbis_t *vorbis_enc;
packets = 0;
//vpxtest ();
buffer = malloc (20000000);
vbuffer = malloc (20000000);
vbuffer2 = malloc (20000000);
new_mkv = kr_mkv_create_file (file);
if (new_mkv == NULL) {
fprintf (stderr, "Could not open %s\n", file);
exit (1);
}
printf ("Created file: %s\n", file);
vpx_dec = krad_vpx_decoder_create ();
vpx_enc = krad_vpx_encoder_create (1280, 720,
30000,
1000,
2200);
out_track = kr_mkv_add_video_track (new_mkv, VP8,
30000,
1000,
mkv->tracks[VIDEO_TRACK].width,
mkv->tracks[VIDEO_TRACK].height);
header.count = mkv->tracks[AUDIO_TRACK].headers;
header.data[0] = mkv->tracks[AUDIO_TRACK].header[0];
header.sz[0] = mkv->tracks[AUDIO_TRACK].header_len[0];
header.data[1] = mkv->tracks[AUDIO_TRACK].header[1];
header.sz[1] = mkv->tracks[AUDIO_TRACK].header_len[1];
header.data[2] = mkv->tracks[AUDIO_TRACK].header[2];
header.sz[2] = mkv->tracks[AUDIO_TRACK].header_len[2];
vorbis_dec = krad_vorbis_decoder_create (&header);
vorbis_enc = krad_vorbis_encoder_create (2, 48000, 0.4);
kr_mkv_add_audio_track (new_mkv, VORBIS, 48000, 2,
vorbis_enc->hdrdata,
3 +
vorbis_enc->header.sz[0] +
vorbis_enc->header.sz[1] +
vorbis_enc->header.sz[2]);
printf ("\n");
while ((bytes_read = kr_mkv_read_packet (mkv, &track, &timecode, &flags, buffer)) > 0) {
printk ("Read packet %d track %d %d bytes", packets++, track, bytes_read);
//fflush (stdout);
if (flags == 0x80) {
keyframe = 1;
} else {
keyframe = 0;
}
if (track == 1) {
/*
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
codeme->sz = bytes_read;
memcpy (codeme->data, buffer, codeme->sz);
ret = kr_vpx_decode (vpx_dec, medium, codeme);
//printf ("Vpx dec ret was %d", ret);
kr_codeme_kludge_destroy (&codeme);
codeme = kr_codeme_kludge_create ();
ret = kr_vpx_encode (vpx_enc, codeme, medium);
//printf ("Vpx enc ret was %d", ret);
kr_medium_kludge_destroy (&medium);
bytes_read = codeme->sz;
memcpy (buffer, codeme->data, codeme->sz);
kr_codeme_kludge_destroy (&codeme);
*/
kr_mkv_add_video (new_mkv, out_track, buffer, bytes_read, keyframe);
}
if (track == 2) {
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
codeme->sz = bytes_read;
memcpy (codeme->data, buffer, codeme->sz);
kr_vorbis_decode (vorbis_dec, medium, codeme);
kr_codeme_kludge_destroy (&codeme);
if (medium->a.count > 0) {
do {
codeme = kr_codeme_kludge_create ();
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);
} while (ret == 1);
}
//}
}
}
//-----------------------------
krad_vorbis_decoder_destroy (&vorbis_dec);
//new_mkv->tracks[VIDEO_TRACK].fps_numerator = 30000;
kr_mkv_destroy (&mkv);
mkv = kr_mkv_open_file (file2);
printf ("FPS %d/%d RES: %dx%d\n",
mkv->tracks[VIDEO_TRACK].fps_numerator,
mkv->tracks[VIDEO_TRACK].fps_denominator,
mkv->tracks[VIDEO_TRACK].width,
mkv->tracks[VIDEO_TRACK].height);
if (mkv == NULL) {
fprintf (stderr, "Could not open %s\n", file2);
exit (1);
}
header.count = mkv->tracks[AUDIO_TRACK].headers;
header.data[0] = mkv->tracks[AUDIO_TRACK].header[0];
header.sz[0] = mkv->tracks[AUDIO_TRACK].header_len[0];
header.data[1] = mkv->tracks[AUDIO_TRACK].header[1];
header.sz[1] = mkv->tracks[AUDIO_TRACK].header_len[1];
header.data[2] = mkv->tracks[AUDIO_TRACK].header[2];
header.sz[2] = mkv->tracks[AUDIO_TRACK].header_len[2];
vorbis_dec = krad_vorbis_decoder_create (&header);
while ((bytes_read = kr_mkv_read_packet (mkv, &track, &timecode, &flags, buffer)) > 0) {
printk ("Read packet %d track %d %d bytes", packets++, track, bytes_read);
//fflush (stdout);
if (flags == 0x80) {
keyframe = 1;
} else {
keyframe = 0;
}
if (track == 1) {
/*
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
codeme->sz = bytes_read;
memcpy (codeme->data, buffer, codeme->sz);
ret = kr_vpx_decode (vpx_dec, medium, codeme);
//printf ("Vpx dec ret was %d", ret);
kr_codeme_kludge_destroy (&codeme);
codeme = kr_codeme_kludge_create ();
ret = kr_vpx_encode (vpx_enc, codeme, medium);
//printf ("Vpx enc ret was %d", ret);
kr_medium_kludge_destroy (&medium);
bytes_read = codeme->sz;
memcpy (buffer, codeme->data, codeme->sz);
kr_codeme_kludge_destroy (&codeme);
*/
kr_mkv_add_video (new_mkv, out_track, buffer, bytes_read, keyframe);
}
if (track == 2) {
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
codeme->sz = bytes_read;
memcpy (codeme->data, buffer, codeme->sz);
kr_vorbis_decode (vorbis_dec, medium, codeme);
kr_codeme_kludge_destroy (&codeme);
if (medium->a.count > 0) {
do {
codeme = kr_codeme_kludge_create ();
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);
} while (ret == 1);
}
//}
}
}
medium = kr_medium_kludge_create ();
codeme = kr_codeme_kludge_create ();
ret = kr_vorbis_encode (vorbis_enc, codeme, medium);
if (codeme->sz > 0) {
printk ("Got 1 another sized %zu with %d samples",
codeme->sz, codeme->count);
kr_mkv_add_audio (new_mkv, 2, codeme->data, codeme->sz, codeme->count);
}
kr_codeme_kludge_destroy (&codeme);
kr_medium_kludge_destroy (&medium);
do {
codeme = kr_codeme_kludge_create ();
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_codeme_kludge_destroy (&codeme);
} while (ret == 1);
//----------------------------
printf ("\nDone.\n");
krad_vpx_encoder_destroy (&vpx_enc);
krad_vpx_decoder_destroy (&vpx_dec);
krad_vorbis_decoder_destroy (&vorbis_dec);
krad_vorbis_encoder_destroy (&vorbis_enc);
kr_mkv_destroy (&new_mkv);
kr_mkv_destroy (&mkv);
free (buffer);
free (vbuffer);
free (vbuffer2);
}
