/** Documented at declaration */ void gpujpeg_image_convert(const char* input, const char* output, struct gpujpeg_image_parameters param_image_from, struct gpujpeg_image_parameters param_image_to) { assert(param_image_from.width == param_image_to.width); assert(param_image_from.height == param_image_to.height); assert(param_image_from.comp_count == param_image_to.comp_count); // Load image int image_size = gpujpeg_image_calculate_size(¶m_image_from); uint8_t* image = NULL; if ( gpujpeg_image_load_from_file(input, &image, &image_size) != 0 ) { fprintf(stderr, "[GPUJPEG] [Error] Failed to load image [%s]!\n", input); return; } struct gpujpeg_coder coder; gpujpeg_set_default_parameters(&coder.param); coder.param.color_space_internal = GPUJPEG_RGB; // Initialize coder and preprocessor coder.param_image = param_image_from; assert(gpujpeg_coder_init(&coder) == 0); assert(gpujpeg_preprocessor_encoder_init(&coder) == 0); // Perform preprocessor assert(cudaMemcpy(coder.d_data_raw, image, coder.data_raw_size * sizeof(uint8_t), cudaMemcpyHostToDevice) == cudaSuccess); assert(gpujpeg_preprocessor_encode(&coder) == 0); // Save preprocessor result uint8_t* buffer = NULL; assert(cudaMallocHost((void**)&buffer, coder.data_size * sizeof(uint8_t)) == cudaSuccess); assert(buffer != NULL); assert(cudaMemcpy(buffer, coder.d_data, coder.data_size * sizeof(uint8_t), cudaMemcpyDeviceToHost) == cudaSuccess); // Deinitialize decoder gpujpeg_coder_deinit(&coder); // Initialize coder and postprocessor coder.param_image = param_image_to; assert(gpujpeg_coder_init(&coder) == 0); assert(gpujpeg_preprocessor_decoder_init(&coder) == 0); // Perform postprocessor assert(cudaMemcpy(coder.d_data, buffer, coder.data_size * sizeof(uint8_t), cudaMemcpyHostToDevice) == cudaSuccess); assert(gpujpeg_preprocessor_decode(&coder) == 0); // Save preprocessor result assert(cudaMemcpy(coder.data_raw, coder.d_data_raw, coder.data_raw_size * sizeof(uint8_t), cudaMemcpyDeviceToHost) == cudaSuccess); if ( gpujpeg_image_save_to_file(output, coder.data_raw, coder.data_raw_size) != 0 ) { fprintf(stderr, "[GPUJPEG] [Error] Failed to save image [%s]!\n", output); return; } // Deinitialize decoder gpujpeg_coder_deinit(&coder); }
/** Documented at declaration */ int gpujpeg_decoder_init(struct gpujpeg_decoder* decoder, struct gpujpeg_parameters* param, struct gpujpeg_image_parameters* param_image) { assert(param_image->comp_count == 1 || param_image->comp_count == 3); // Get coder struct gpujpeg_coder* coder = &decoder->coder; // Check if (re)inialization is needed int change = 0; change |= coder->param_image.width != param_image->width; change |= coder->param_image.height != param_image->height; change |= coder->param_image.comp_count != param_image->comp_count; change |= coder->param.restart_interval != param->restart_interval; change |= coder->param.interleaved != param->interleaved; for ( int comp = 0; comp < param_image->comp_count; comp++ ) { change |= coder->param.sampling_factor[comp].horizontal != param->sampling_factor[comp].horizontal; change |= coder->param.sampling_factor[comp].vertical != param->sampling_factor[comp].vertical; } if ( change == 0 ) return 0; // For now we can't reinitialize decoder, we can only do first initialization if ( coder->param_image.width != 0 || coder->param_image.height != 0 || coder->param_image.comp_count != 0 ) { fprintf(stderr, "[GPUJPEG] [Error] Can't reinitialize decoder, implement if needed!\n"); return -1; } coder->param = *param; coder->param_image = *param_image; // Initialize coder if ( gpujpeg_coder_init(coder) != 0 ) return -1; // Init postprocessor if ( gpujpeg_preprocessor_decoder_init(&decoder->coder) != 0 ) { fprintf(stderr, "Failed to init postprocessor!"); return -1; } return 0; }