int main(int argc, char **argv)
{
struct gpujpeg_parameters param;
gpujpeg_set_default_parameters(¶m);
struct gpujpeg_image_parameters param_image;
param_image.width = 1920;
param_image.height = 1080;
param_image.comp_count = 3;
// (for now, it must be 3)
param_image.color_space = GPUJPEG_RGB;
// or GPUJPEG_YCBCR_ITU_R or GPUJPEG_YCBCR_JPEG
// (default value is GPUJPEG_RGB)
param_image.sampling_factor = GPUJPEG_4_4_4;
if (gpujpeg_init_device(0, GPUJPEG_VERBOSE))
{
printf("Unable to init device\n");
return -1;
}
struct gpujpeg_encoder* encoder = gpujpeg_encoder_create(¶m, ¶m_image);
if (encoder == NULL)
return -1;
int image_size = 0;
uint8_t* image = NULL;
//if (gpujpeg_image_load_from_file("input_image.rgb", &image, &image_size) != 0)
// return -1;
/*
uint8_t* encoder_input = NULL;
uint8_t* image_compressed = NULL;
int image_compressed_size = 0;
if (gpujpeg_encoder_encode(encoder, &encoder_input, &image_compressed, &image_compressed_size) != 0 )
return -1;
*/
return 0;
}
static int configure_with(struct state_video_compress_jpeg *s, struct video_frame *frame)
{
unsigned int x;
int frame_idx;
s->saved_desc.width = frame->tiles[0].width;
s->saved_desc.height = frame->tiles[0].height;
s->saved_desc.color_spec = frame->color_spec;
s->saved_desc.fps = frame->fps;
s->saved_desc.interlacing = frame->interlacing;
s->saved_desc.tile_count = frame->tile_count;
for (frame_idx = 0; frame_idx < 2; frame_idx++) {
s->out[frame_idx] = vf_alloc(frame->tile_count);
}
for (x = 0; x < frame->tile_count; ++x) {
if (vf_get_tile(frame, x)->width != vf_get_tile(frame, 0)->width ||
vf_get_tile(frame, x)->width != vf_get_tile(frame, 0)->width) {
fprintf(stderr,"[JPEG] Requested to compress tiles of different size!");
//exit_uv(129);
return FALSE;
}
}
for (frame_idx = 0; frame_idx < 2; frame_idx++) {
for (x = 0; x < frame->tile_count; ++x) {
vf_get_tile(s->out[frame_idx], x)->width = vf_get_tile(frame, 0)->width;
vf_get_tile(s->out[frame_idx], x)->height = vf_get_tile(frame, 0)->height;
}
s->out[frame_idx]->interlacing = frame->interlacing;
s->out[frame_idx]->fps = frame->fps;
s->out[frame_idx]->color_spec = s->color_spec;
s->out[frame_idx]->color_spec = JPEG;
}
switch (frame->color_spec) {
case RGB:
s->decoder = (decoder_t) memcpy;
s->rgb = TRUE;
break;
case RGBA:
s->decoder = (decoder_t) vc_copylineRGBAtoRGB;
s->rgb = TRUE;
break;
case BGR:
s->decoder = (decoder_t) vc_copylineBGRtoRGB;
s->rgb = TRUE;
break;
/* TODO: enable (we need R10k -> RGB)
* case R10k:
s->decoder = (decoder_t) vc_copyliner10k;
s->rgb = TRUE;
break;*/
case YUYV:
s->decoder = (decoder_t) vc_copylineYUYV;
s->rgb = FALSE;
break;
case UYVY:
case Vuy2:
case DVS8:
s->decoder = (decoder_t) memcpy;
s->rgb = FALSE;
break;
case v210:
s->decoder = (decoder_t) vc_copylinev210;
s->rgb = FALSE;
break;
case DVS10:
s->decoder = (decoder_t) vc_copylineDVS10;
s->rgb = FALSE;
break;
case DPX10:
s->decoder = (decoder_t) vc_copylineDPX10toRGB;
s->rgb = TRUE;
break;
default:
fprintf(stderr, "[JPEG] Unknown codec: %d\n", frame->color_spec);
//exit_uv(128);
return FALSE;
}
s->encoder_param.verbose = 0;
s->encoder_param.segment_info = 1;
if(s->rgb) {
s->encoder_param.interleaved = 0;
s->encoder_param.restart_interval = s->restart_interval == -1 ? 8
: s->restart_interval;
/* LUMA */
s->encoder_param.sampling_factor[0].horizontal = 1;
s->encoder_param.sampling_factor[0].vertical = 1;
/* Cb and Cr */
s->encoder_param.sampling_factor[1].horizontal = 1;
s->encoder_param.sampling_factor[1].vertical = 1;
s->encoder_param.sampling_factor[2].horizontal = 1;
s->encoder_param.sampling_factor[2].vertical = 1;
} else {
s->encoder_param.interleaved = 1;
s->encoder_param.restart_interval = s->restart_interval == -1 ? 2
: s->restart_interval;
/* LUMA */
s->encoder_param.sampling_factor[0].horizontal = 2;
s->encoder_param.sampling_factor[0].vertical = 1;
/* Cb and Cr */
s->encoder_param.sampling_factor[1].horizontal = 1;
s->encoder_param.sampling_factor[1].vertical = 1;
s->encoder_param.sampling_factor[2].horizontal = 1;
s->encoder_param.sampling_factor[2].vertical = 1;
}
struct gpujpeg_image_parameters param_image;
gpujpeg_image_set_default_parameters(¶m_image);
param_image.width = s->out[0]->tiles[0].width;
param_image.height = s->out[0]->tiles[0].height;
param_image.comp_count = 3;
if(s->rgb) {
param_image.color_space = GPUJPEG_RGB;
param_image.sampling_factor = GPUJPEG_4_4_4;
} else {
param_image.color_space = GPUJPEG_YCBCR_BT709;
param_image.sampling_factor = GPUJPEG_4_2_2;
}
s->encoder = gpujpeg_encoder_create(&s->encoder_param, ¶m_image);
for (frame_idx = 0; frame_idx < 2; frame_idx++) {
for (x = 0; x < frame->tile_count; ++x) {
vf_get_tile(s->out[frame_idx], x)->data = (char *) malloc(s->out[frame_idx]->tiles[0].width * s->out[frame_idx]->tiles[0].height * 3);
}
}
s->encoder_input_linesize = s->out[frame_idx]->tiles[0].width *
(param_image.color_space == GPUJPEG_RGB ? 3 : 2);
if(!s->encoder) {
fprintf(stderr, "[DXT GLSL] Failed to create encoder.\n");
//exit_uv(128);
return FALSE;
}
s->decoded = malloc(4 * s->out[0]->tiles[0].width * s->out[0]->tiles[0].height);
return TRUE;
}
