struct module * jpeg_compress_init(struct module *parent, char * opts)
{
struct state_video_compress_jpeg *s;
int frame_idx;
s = (struct state_video_compress_jpeg *) malloc(sizeof(struct state_video_compress_jpeg));
for (frame_idx = 0; frame_idx < 2; frame_idx++) {
s->out[frame_idx] = NULL;
}
s->decoded = NULL;
if(opts && strcmp(opts, "help") == 0) {
printf("JPEG comperssion usage:\n");
printf("\t-c JPEG[:<quality>[:<restart_interval>]]\n");
return &compress_init_noerr;
} else if(opts && strcmp(opts, "list_devices") == 0) {
printf("CUDA devices:\n");
gpujpeg_print_devices_info();
return &compress_init_noerr;
}
s->restart_interval = -1;
gpujpeg_set_default_parameters(&s->encoder_param);
if(opts) {
parse_fmt(s, opts);
} else {
printf("[JPEG] setting default encode parameters (quality: %d)\n",
s->encoder_param.quality
);
}
int ret;
printf("Initializing CUDA device %d...\n", cuda_devices[0]);
ret = gpujpeg_init_device(cuda_devices[0], TRUE);
if(ret != 0) {
fprintf(stderr, "[JPEG] initializing CUDA device %d failed.\n", cuda_devices[0]);
return NULL;
}
s->encoder = NULL; /* not yet configured */
platform_spin_init(&s->spin);
module_init_default(&s->module_data);
s->module_data.cls = MODULE_CLASS_DATA;
s->module_data.priv_data = s;
s->module_data.deleter = jpeg_compress_done;
s->module_data.msg_callback = compress_change_callback;
module_register(&s->module_data, parent);
return &s->module_data;
}
void * jpeg_compress_init(char * opts)
{
struct compress_jpeg_state *s;
int frame_idx;
s = (struct compress_jpeg_state *) malloc(sizeof(struct compress_jpeg_state));
for (frame_idx = 0; frame_idx < 2; frame_idx++) {
s->out[frame_idx] = NULL;
}
s->decoded = NULL;
if(opts && strcmp(opts, "help") == 0) {
printf("JPEG comperssion usage:\n");
printf("\t-c JPEG[:<quality>]\n");
return NULL;
} else if(opts && strcmp(opts, "list_devices") == 0) {
printf("CUDA devices:\n");
gpujpeg_print_devices_info();
return NULL;
}
if(opts) {
char *tok, *save_ptr = NULL;
gpujpeg_set_default_parameters(&s->encoder_param);
tok = strtok_r(opts, ":", &save_ptr);
s->encoder_param.quality = atoi(tok);
int ret;
printf("Initializing CUDA device %d...\n", cuda_device);
ret = gpujpeg_init_device(cuda_device, TRUE);
if(ret != 0) {
fprintf(stderr, "[JPEG] initializing CUDA device %d failed.\n", cuda_device);
return NULL;
}
tok = strtok_r(NULL, ":", &save_ptr);
if(tok) {
fprintf(stderr, "[JPEG] WARNING: Trailing configuration parameters.\n");
}
} else {
gpujpeg_set_default_parameters(&s->encoder_param);
printf("[JPEG] setting default encode parameters (quality: %d)\n",
s->encoder_param.quality
);
}
s->encoder = NULL; /* not yet configured */
return s;
}
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;
}
/**
* @return maximal buffer size needed to image with such a properties
*/
int jpeg_to_dxt_decompress_reconfigure_real(void *state, struct video_desc desc,
int rshift, int gshift, int bshift, int pitch, codec_t out_codec, int i)
{
UNUSED(rshift);
UNUSED(gshift);
UNUSED(bshift);
struct state_decompress_jpeg_to_dxt *s = (struct state_decompress_jpeg_to_dxt *) state;
assert(out_codec == DXT1 || out_codec == DXT5);
assert(pitch == (int) desc.width / s->ppb); // default for DXT1
free(s->input[i]);
free(s->output[i]);
if(s->jpeg_decoder[i] != NULL) {
gpujpeg_decoder_destroy(s->jpeg_decoder[i]);
} else {
gpujpeg_init_device(cuda_devices[i], 0);
}
if(s->dxt_out_buff[i] != NULL) {
cudaFree(s->dxt_out_buff[i]);
}
if(cudaSuccess != cudaMallocHost((void **) &s->dxt_out_buff[i], desc.width * desc.height / s->ppb)) {
fprintf(stderr, "Could not allocate CUDA output buffer.\n");
return 0;
}
//gpujpeg_init_device(cuda_device, GPUJPEG_OPENGL_INTEROPERABILITY);
s->jpeg_decoder[i] = gpujpeg_decoder_create();
if(!s->jpeg_decoder[i]) {
fprintf(stderr, "Creating JPEG decoder failed.\n");
return 0;
}
s->input[i] = malloc(desc.width * desc.height);
s->output[i] = malloc(desc.width / s->ppb * desc.height);
return desc.width * desc.height;
}
void * jpeg_decompress_init(void)
{
struct state_decompress_jpeg *s;
s = (struct state_decompress_jpeg *) malloc(sizeof(struct state_decompress_jpeg));
s->decoder = NULL;
s->pitch = 0;
int ret;
printf("Initializing CUDA device %d...\n", cuda_devices[0]);
ret = gpujpeg_init_device(cuda_devices[0], TRUE);
if(ret != 0) {
fprintf(stderr, "[JPEG] initializing CUDA device %d failed.\n", cuda_devices[0]);
free(s);
return NULL;
}
return s;
}
