/** 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_encoder_encode(struct gpujpeg_encoder* encoder, struct gpujpeg_encoder_input* input, uint8_t** image_compressed, int* image_compressed_size)
{
// Get coder
struct gpujpeg_coder* coder = &encoder->coder;
// Reset durations
coder->duration_memory_to = 0.0;
coder->duration_memory_from = 0.0;
coder->duration_memory_map = 0.0;
coder->duration_memory_unmap = 0.0;
coder->duration_preprocessor = 0.0;
coder->duration_dct_quantization = 0.0;
coder->duration_huffman_coder = 0.0;
coder->duration_stream = 0.0;
coder->duration_in_gpu = 0.0;
// Load input image
if ( input->type == GPUJPEG_ENCODER_INPUT_IMAGE ) {
GPUJPEG_CUSTOM_TIMER_START(encoder->def);
// Copy image to device memory
if ( cudaSuccess != cudaMemcpy(coder->d_data_raw, input->image, coder->data_raw_size * sizeof(uint8_t), cudaMemcpyHostToDevice) )
return -1;
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_memory_to = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
} else if ( input->type == GPUJPEG_ENCODER_INPUT_OPENGL_TEXTURE ) {
assert(input->texture != NULL);
GPUJPEG_CUSTOM_TIMER_START(encoder->def);
// Map texture to CUDA
int data_size = 0;
uint8_t* d_data = gpujpeg_opengl_texture_map(input->texture, &data_size);
assert(data_size == (coder->data_raw_size));
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_memory_map = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
GPUJPEG_CUSTOM_TIMER_START(encoder->def);
// Copy image data from texture pixel buffer object to device data
cudaMemcpy(coder->d_data_raw, d_data, coder->data_raw_size * sizeof(uint8_t), cudaMemcpyDeviceToDevice);
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_memory_to = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
GPUJPEG_CUSTOM_TIMER_START(encoder->def);
// Unmap texture from CUDA
gpujpeg_opengl_texture_unmap(input->texture);
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_memory_unmap = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
} else if(input->type == GPUJPEG_ENCODER_INPUT_IMAGE_ON_GPU) {
GPUJPEG_CUSTOM_TIMER_START(encoder->def);
coder->d_data_raw = input->image;
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_memory_to = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
} else {
// Unknown output type
assert(0);
}
//gpujpeg_table_print(encoder->table[JPEG_COMPONENT_LUMINANCE]);
//gpujpeg_table_print(encoder->table[JPEG_COMPONENT_CHROMINANCE]);
GPUJPEG_CUSTOM_TIMER_START(encoder->in_gpu);
GPUJPEG_CUSTOM_TIMER_START(encoder->def);
// Preprocessing
if ( gpujpeg_preprocessor_encode(&encoder->coder) != 0 )
return -1;
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_preprocessor = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
GPUJPEG_CUSTOM_TIMER_START(encoder->def);
// Perform DCT and quantization
if ( gpujpeg_dct_gpu(encoder) != 0 )
return -1;
// If restart interval is 0 then the GPU processing is in the end (even huffman coder will be performed on CPU)
if ( coder->param.restart_interval == 0 ) {
GPUJPEG_CUSTOM_TIMER_STOP(encoder->in_gpu);
coder->duration_in_gpu = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->in_gpu);
}
// Initialize writer output buffer current position
encoder->writer->buffer_current = encoder->writer->buffer;
// Write header
gpujpeg_writer_write_header(encoder);
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_dct_quantization = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
GPUJPEG_CUSTOM_TIMER_START(encoder->def);
// Perform huffman coding on CPU (when restart interval is not set)
if ( coder->param.restart_interval == 0 ) {
// Copy quantized data from device memory to cpu memory
cudaMemcpy(coder->data_quantized, coder->d_data_quantized, coder->data_size * sizeof(int16_t), cudaMemcpyDeviceToHost);
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_memory_from = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
GPUJPEG_CUSTOM_TIMER_START(encoder->def);
// Perform huffman coding
if ( gpujpeg_huffman_cpu_encoder_encode(encoder) != 0 ) {
fprintf(stderr, "[GPUJPEG] [Error] Huffman encoder on CPU failed!\n");
return -1;
}
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_huffman_coder = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
}
// Perform huffman coding on GPU (when restart interval is set)
else {
// Perform huffman coding
unsigned int output_size;
if ( gpujpeg_huffman_gpu_encoder_encode(encoder, &output_size) != 0 ) {
fprintf(stderr, "[GPUJPEG] [Error] Huffman encoder on GPU failed!\n");
return -1;
}
GPUJPEG_CUSTOM_TIMER_STOP(encoder->in_gpu);
coder->duration_in_gpu = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->in_gpu);
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_huffman_coder = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
GPUJPEG_CUSTOM_TIMER_START(encoder->def);
// Copy compressed data from device memory to cpu memory
if ( cudaSuccess != cudaMemcpy(coder->data_compressed, coder->d_data_compressed, output_size, cudaMemcpyDeviceToHost) != 0 )
return -1;
// Copy segments from device memory
if ( cudaSuccess != cudaMemcpy(coder->segment, coder->d_segment, coder->segment_count * sizeof(struct gpujpeg_segment), cudaMemcpyDeviceToHost) )
return -1;
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_memory_from = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
GPUJPEG_CUSTOM_TIMER_START(encoder->def);
if ( coder->param.interleaved == 1 ) {
// Write scan header (only one scan is written, that contains all color components data)
gpujpeg_writer_write_scan_header(encoder, 0);
// Write scan data
for ( int segment_index = 0; segment_index < coder->segment_count; segment_index++ ) {
struct gpujpeg_segment* segment = &coder->segment[segment_index];
gpujpeg_writer_write_segment_info(encoder);
// Copy compressed data to writer
memcpy(
encoder->writer->buffer_current,
&coder->data_compressed[segment->data_compressed_index],
segment->data_compressed_size
);
encoder->writer->buffer_current += segment->data_compressed_size;
//printf("Compressed data %d bytes\n", segment->data_compressed_size);
}
// Remove last restart marker in scan (is not needed)
encoder->writer->buffer_current -= 2;
gpujpeg_writer_write_segment_info(encoder);
} else {
// Write huffman coder results as one scan for each color component
int segment_index = 0;
for ( int comp = 0; comp < coder->param_image.comp_count; comp++ ) {
// Write scan header
gpujpeg_writer_write_scan_header(encoder, comp);
// Write scan data
for ( int index = 0; index < coder->component[comp].segment_count; index++ ) {
struct gpujpeg_segment* segment = &coder->segment[segment_index];
gpujpeg_writer_write_segment_info(encoder);
// Copy compressed data to writer
memcpy(
encoder->writer->buffer_current,
&coder->data_compressed[segment->data_compressed_index],
segment->data_compressed_size
);
encoder->writer->buffer_current += segment->data_compressed_size;
//printf("Compressed data %d bytes\n", segment->data_compressed_size);
segment_index++;
}
// Remove last restart marker in scan (is not needed)
encoder->writer->buffer_current -= 2;
gpujpeg_writer_write_segment_info(encoder);
}
}
GPUJPEG_CUSTOM_TIMER_STOP(encoder->def);
coder->duration_stream = GPUJPEG_CUSTOM_TIMER_DURATION(encoder->def);
}
gpujpeg_writer_emit_marker(encoder->writer, GPUJPEG_MARKER_EOI);
// Set compressed image
*image_compressed = encoder->writer->buffer;
*image_compressed_size = encoder->writer->buffer_current - encoder->writer->buffer;
return 0;
}
