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; }