bool readImage(char *filename, int frameNumber, vpx_image_t **pRGBImage, vpx_image_t **pYV12Image, int flip)
{
// Load image.
//
char path[512];
sprintf(path, filename, frameNumber);
ILuint imageHandle;
ilGenImages(1, &imageHandle);
ilBindImage(imageHandle);
ILboolean ok = ilLoadImage(path);
if (ok)
{
if (ilConvertImage(IL_RGB, IL_UNSIGNED_BYTE))
{
unsigned int w = ilGetInteger(IL_IMAGE_WIDTH);
unsigned int h = ilGetInteger(IL_IMAGE_HEIGHT);
if (*pRGBImage == NULL)
{
*pRGBImage = vpx_img_alloc(NULL, VPX_IMG_FMT_RGB24, w, h, 1);
}
if (*pYV12Image == NULL)
{
*pYV12Image = vpx_img_alloc(NULL, VPX_IMG_FMT_I420, w, h, 1);
}
memcpy((*pRGBImage)->img_data, ilGetData(), w * h * 3);
rgb24toyv12(*pRGBImage, *pYV12Image);
if (flip)
{
vpx_img_flip(*pYV12Image);
}
ilDeleteImages(1, &imageHandle);
return true;
}
}
else
{
ILenum ilError = ilGetError();
fprintf(stderr, "Can't load [%s], [%x %s]\n.", path, ilError, iluErrorString(ilError));
}
return false;
}
int main (int argc, char *argv[]) {
krad_v4l2_vpx_display_test_t *display_test;
krad_flac_t *krad_flac;
krad_dirac_t *krad_dirac;
krad_vpx_encoder_t *krad_vpx_encoder;
//krad_vpx_decoder_t *krad_vpx_decoder;
kradgui_t *kradgui;
kradebml_t *ebml;
cairo_surface_t *cst;
cairo_t *cr;
char *filename = "/home/oneman/kode/testmedia/capture/new_testfile4.webm";
int hud_width, hud_height;
int hud_stride;
int hud_byte_size;
unsigned char *hud_data;
struct SwsContext *sws_context;
int fps;
int videotrack;
int audiotrack;
char *device;
krad_v4l2_t *kradv4l2;
krad_sdl_opengl_display_t *krad_opengl_display;
int width;
int height;
int count;
//int first_frame;
int read_composited;
unsigned char *read_screen_buffer;
unsigned char *dbuffer;
unsigned char *dfbuffer;
krad_audio_t *audio;
krad_audio_api_t audio_api;
krad_vorbis_t *krad_vorbis;
hud_width = 320;
hud_height = 240;
read_composited = 1;
//first_frame = 1;
width = 640;
height = 480;
fps = 30;
count = 0;
int keyframe;
int bitrate;
void *frame = NULL;
void *vpx_packet;
int packet_size;
int took;
int video_codec;
int audio_codec;
int framenum;
int bytes;
bitrate = 1000;
video_codec = 1;
audio_codec = 1;
if (argc < 2) {
device = DEFAULT_DEVICE;
printf("no device provided, using %s , to provide a device, example: krad_v4l2_test /dev/video0\n", device);
} else {
device = argv[1];
printf("Using %s\n", device);
}
display_test = calloc(1, sizeof(krad_v4l2_vpx_display_test_t));
pthread_rwlock_init(&display_test->ebml_write_lock, NULL);
pthread_rwlock_rdlock(&display_test->ebml_write_lock);
//display_test->kradtimer = kradtimer_create();
display_test->input_ringbuffer[0] = krad_ringbuffer_create (RINGBUFFER_SIZE);
display_test->input_ringbuffer[1] = krad_ringbuffer_create (RINGBUFFER_SIZE);
display_test->samples[0] = malloc(4 * 8192);
display_test->samples[1] = malloc(4 * 8192);
display_test->first_block = 1;
display_test->audio_codec = audio_codec;
dbuffer = calloc(1, 2000000);
dfbuffer = calloc(1, 2000000);
audio_api = JACK;
//audio = kradaudio_create("krad v4l2 vpx display test", audio_api);
krad_vorbis = krad_vorbis_encoder_create(2, 44100, 0.7);
krad_flac = krad_flac_encoder_create(1, 44100, 16);
read_screen_buffer = calloc(1, width * height * 4 * 4 * 4 * 4);
sws_context = sws_getContext ( width, height, PIX_FMT_RGB32, width, height, PIX_FMT_YUV420P, SWS_BICUBIC, NULL, NULL, NULL);
ebml = kradebml_create();
//kradebml_open_output_stream(ebml, "192.168.1.2", 9080, "/teststream.webm", "secretkode");
kradebml_open_output_file(ebml, filename);
if (video_codec == 1) {
kradebml_header(ebml, "webm", APPVERSION);
} else {
kradebml_header(ebml, "matroska", APPVERSION);
}
if (video_codec == 1) {
videotrack = kradebml_add_video_track(ebml, "V_VP8", 30, width, height);
}
if (video_codec == 2) {
videotrack = kradebml_add_video_track(ebml, "V_DIRAC", 10, width, height);
}
if (audio_codec == 1) {
audiotrack = kradebml_add_audio_track(ebml, "A_VORBIS", 44100, 2, krad_vorbis->header, krad_vorbis->headerpos);
}
if (audio_codec == 2) {
bytes = krad_flac_encoder_read_min_header(krad_flac, dfbuffer);
audiotrack = kradebml_add_audio_track(ebml, "A_FLAC", 44100, 1, dfbuffer, bytes);
display_test->krad_flac = krad_flac;
}
kradebml_write(ebml);
krad_opengl_display = krad_sdl_opengl_display_create(APPVERSION, width, height, width, height);
//krad_opengl_display = krad_sdl_opengl_display_create(APPVERSION, 1920, 1080, width, height);
krad_vpx_encoder = krad_vpx_encoder_create(width, height, bitrate);
krad_dirac = krad_dirac_encoder_create(width, height);
kradgui = kradgui_create(width, height);
kradgui_add_item(kradgui, REEL_TO_REEL);
hud_stride = cairo_format_stride_for_width (CAIRO_FORMAT_ARGB32, hud_width);
hud_byte_size = hud_stride * hud_height;
hud_data = calloc (1, hud_byte_size);
cst = cairo_image_surface_create_for_data (hud_data, CAIRO_FORMAT_ARGB32, hud_width, hud_height, hud_stride);
krad_opengl_display->hud_width = hud_width;
krad_opengl_display->hud_height = hud_height;
krad_opengl_display->hud_data = hud_data;
display_test->audiotrack = audiotrack;
display_test->ebml = ebml;
//display_test->audio = audio;
display_test->krad_vorbis = krad_vorbis;
display_test->kradgui = kradgui;
kradv4l2 = kradv4l2_create();
kradv4l2_open(kradv4l2, device, width, height, fps);
kradv4l2_start_capturing (kradv4l2);
kradgui_reset_elapsed_time(kradgui);
kradgui->render_timecode = 1;
audio = kradaudio_create("krad v4l2 vpx display test", KINPUT, audio_api);
display_test->audio = audio;
pthread_create(&display_test->audio_encoding_thread, NULL, audio_encoding_thread, (void *)display_test);
kradaudio_set_process_callback(audio, krad_v4l2_vpx_display_test_audio_callback, display_test);
if (audio_api == JACK) {
krad_jack_t *jack = (krad_jack_t *)audio->api;
kradjack_connect_port(jack->jack_client, "firewire_pcm:001486af2e61ac6b_Unknown0_in", "krad v4l2 vpx display test:InputLeft");
kradjack_connect_port(jack->jack_client, "firewire_pcm:001486af2e61ac6b_Unknown0_in", "krad v4l2 vpx display test:InputRight");
}
while (count < TEST_COUNT) {
//kradtimer_start(display_test->kradtimer, "cycle");
cr = cairo_create(cst);
kradgui->cr = cr;
kradgui_render(kradgui);
cairo_destroy(cr);
frame = kradv4l2_read_frame_wait (kradv4l2);
if (display_test->start_audio == 0) {
display_test->start_audio = 1;
usleep(200000);
}
if (video_codec == 2) {
// memcpy(dfbuffer, frame, width * height + (((width * height) / 2) * 2));
}
krad_vpx_convert_uyvy2yv12(krad_vpx_encoder->image, frame, width, height);
///krad_vpx_convert_frame_for_local_gl_display(krad_vpx_encoder);
kradv4l2_frame_done (kradv4l2);
krad_sdl_opengl_display_render(krad_opengl_display, krad_vpx_encoder->image->planes[0], krad_vpx_encoder->image->stride[0], krad_vpx_encoder->image->planes[1], krad_vpx_encoder->image->stride[1], krad_vpx_encoder->image->planes[2], krad_vpx_encoder->image->stride[2]);
krad_sdl_opengl_draw_screen( krad_opengl_display );
if (read_composited) {
krad_sdl_opengl_read_screen( krad_opengl_display, read_screen_buffer);
rgb_to_yv12(sws_context, read_screen_buffer, width, height, krad_vpx_encoder->image->planes, krad_vpx_encoder->image->stride);
vpx_img_flip(krad_vpx_encoder->image);
}
if (video_codec == 1) {
count++;
packet_size = krad_vpx_encoder_write(krad_vpx_encoder, (unsigned char **)&vpx_packet, &keyframe);
//printf("packet size was %d\n", packet_size);
if (read_composited) {
vpx_img_flip(krad_vpx_encoder->image);
}
if (packet_size) {
pthread_rwlock_wrlock(&display_test->ebml_write_lock);
kradebml_add_video(ebml, videotrack, vpx_packet, packet_size, keyframe);
//kradebml_write(ebml);
pthread_rwlock_unlock (&display_test->ebml_write_lock);
}
}
if (video_codec == 2) {
// packet_size = krad_dirac_encode (krad_dirac, dfbuffer, dbuffer, &framenum, &took);
packet_size = krad_dirac_encode (krad_dirac, krad_vpx_encoder->image->img_data, dbuffer, &framenum, &took);
if (took == 1) {
took = 0;
count++;
}
if (packet_size > 0) {
krad_dirac_packet_type(dbuffer[4]);
//write(fd, buffer, len);
printf("Encoded size is %d for frame %d\n", packet_size, framenum);
}
//printf("packet size was %d\n", packet_size);
if (read_composited) {
vpx_img_flip(krad_vpx_encoder->image);
}
keyframe = 0;
if (packet_size) {
pthread_rwlock_wrlock(&display_test->ebml_write_lock);
kradebml_add_video(ebml, videotrack, dbuffer, packet_size, keyframe);
//kradebml_write(ebml);
pthread_rwlock_unlock (&display_test->ebml_write_lock);
}
}
//kradtimer_finish_show(display_test->kradtimer);
}
display_test->start_audio = 0;
if (video_codec == 2) {
schro_encoder_end_of_stream (krad_dirac->encoder);
// packet_size = krad_dirac_encode (krad_dirac, dfbuffer, dbuffer, &framenum, &took);
while ((framenum != count - 1) && (framenum != 0)) {
packet_size = krad_dirac_encode (krad_dirac, krad_vpx_encoder->image->img_data, dbuffer, &framenum, &took);
if (packet_size > 0) {
krad_dirac_packet_type(dbuffer[4]);
//write(fd, buffer, len);
printf("Encoded size is %d for frame %d\n", packet_size, framenum);
} else {
usleep(50000);
}
//printf("packet size was %d\n", packet_size);
if (read_composited) {
//vpx_img_flip(krad_vpx_encoder->image);
}
keyframe = 0;
if (packet_size) {
pthread_rwlock_wrlock(&display_test->ebml_write_lock);
kradebml_add_video(ebml, videotrack, dbuffer, packet_size, keyframe);
//kradebml_write(ebml);
pthread_rwlock_unlock (&display_test->ebml_write_lock);
}
}
}
//display_test->start_audio = 0;
printf("finish audio encoding\n");
usleep(2000000);
display_test->stop_audio_encoding = 1;
pthread_join(display_test->audio_encoding_thread, NULL);
kradebml_destroy(ebml);
kradv4l2_stop_capturing (kradv4l2);
kradv4l2_close(kradv4l2);
kradv4l2_destroy(kradv4l2);
krad_dirac_encoder_destroy(krad_dirac);
krad_vpx_encoder_destroy(krad_vpx_encoder);
// must be before vorbis
kradaudio_destroy(audio);
krad_vorbis_encoder_destroy(krad_vorbis);
krad_flac_encoder_destroy(krad_flac);
free(display_test->samples[0]);
free(display_test->samples[1]);
krad_sdl_opengl_display_destroy(krad_opengl_display);
kradgui_destroy(kradgui);
free(read_screen_buffer);
sws_freeContext (sws_context);
krad_ringbuffer_free ( display_test->input_ringbuffer[0] );
krad_ringbuffer_free ( display_test->input_ringbuffer[1] );
pthread_rwlock_destroy(&display_test->ebml_write_lock);
//kradtimer_destroy(display_test->kradtimer);
free(display_test);
free(dbuffer);
free(dfbuffer);
return 0;
}
