Unsupported codec error in C API Sample code of nvImageCodec official guide

Accelerated Computing GPU-Accelerated Libraries
1

I have correctly installed nvImageCodec and I want to run the simple example from the official guide.

I have used a valid jpeg image named “maito_gai.jpg”.

#include <nvimgcodec.h>
#include <vector>
#include <iostream>
#include <fstream>

#include <cuda_runtime.h>
#include <nvcomp.hpp>

#include <cuda.h>

int main() {
	checkCudaError(cudaSetDevice(0), "cudaSetDevice");


	cudaDeviceProp deviceProp;
	cudaGetDeviceProperties(&deviceProp, 0);

	std::cout << "Using device " << deviceProp.name << std::endl;
	std::cout << "Compute Capability: " << deviceProp.major << "." << deviceProp.minor << std::endl;

	int n;
	cudaRuntimeGetVersion(&n);
	std::cout << n << std::endl;


// exact example for nvImageCodec
	nvimgcodecInstance_t instance;
	nvimgcodecInstanceCreateInfo_t instance_create_info{ NVIMGCODEC_STRUCTURE_TYPE_INSTANCE_CREATE_INFO, sizeof(nvimgcodecInstanceCreateInfo_t), 0 };
	instance_create_info.load_builtin_modules = 1;
	instance_create_info.load_extension_modules = 1;
	instance_create_info.create_debug_messenger = 1;

	nvimgcodecInstanceCreate(&instance, &instance_create_info);

	nvimgcodecCodeStream_t code_stream;
	nvimgcodecCodeStreamCreateFromFile(instance, &code_stream, "./maito_gai.jpg");
	nvimgcodecImageInfo_t input_image_info{ NVIMGCODEC_STRUCTURE_TYPE_IMAGE_INFO, sizeof(nvimgcodecImageInfo_t), 0 };
	nvimgcodecCodeStreamGetImageInfo(code_stream, &input_image_info);

	std::cout << "Input image info: " << std::endl;
	std::cout << "\t - width:" << input_image_info.plane_info[0].width << std::endl;
	std::cout << "\t - height:" << input_image_info.plane_info[0].height << std::endl;
	std::cout << "\t - components:" << input_image_info.num_planes << std::endl;
	std::cout << "\t - codec:" << input_image_info.codec_name << std::endl;

	nvimgcodecImageInfo_t output_image_info(input_image_info);
	output_image_info.sample_format = NVIMGCODEC_SAMPLEFORMAT_P_RGB;
	output_image_info.color_spec = NVIMGCODEC_COLORSPEC_SRGB;
	output_image_info.chroma_subsampling = NVIMGCODEC_SAMPLING_NONE;
	output_image_info.num_planes = 3;
	output_image_info.buffer_kind = NVIMGCODEC_IMAGE_BUFFER_KIND_STRIDED_DEVICE;

	auto sample_type = output_image_info.plane_info[0].sample_type;
	int bytes_per_element = static_cast<unsigned int>(sample_type) >> (8 + 3);
	size_t device_pitch_in_bytes = input_image_info.plane_info[0].width * bytes_per_element;

	for (uint32_t c = 0; c < output_image_info.num_planes; ++c) {
		output_image_info.plane_info[c].height = input_image_info.plane_info[0].height;
		output_image_info.plane_info[c].width = input_image_info.plane_info[0].width;
		output_image_info.plane_info[c].row_stride = device_pitch_in_bytes;
	}

	output_image_info.buffer_size = output_image_info.plane_info[0].row_stride * output_image_info.plane_info[0].height * output_image_info.num_planes;
	output_image_info.cuda_stream = 0; // It is possible to assign cuda stream which will be used for synchronization. Here we assume it is default stream.

	cudaMalloc(&output_image_info.buffer, output_image_info.buffer_size);

	nvimgcodecImage_t image;
	nvimgcodecImageCreate(instance, &image, &output_image_info);

	nvimgcodecExecutionParams_t exec_params{ NVIMGCODEC_STRUCTURE_TYPE_EXECUTION_PARAMS, sizeof(nvimgcodecExecutionParams_t), 0 };
	exec_params.device_id = NVIMGCODEC_DEVICE_CURRENT;
	nvimgcodecDecoder_t decoder;
	std::string dec_options{ ":fancy_upsampling=0" };
	nvimgcodecDecoderCreate(instance, &decoder, &exec_params, dec_options.c_str());

	nvimgcodecDecodeParams_t decode_params{ NVIMGCODEC_STRUCTURE_TYPE_DECODE_PARAMS, sizeof(nvimgcodecDecodeParams_t), 0 };
	decode_params.apply_exif_orientation = 1;

	nvimgcodecFuture_t decode_future;
	nvimgcodecDecoderDecode(decoder, &code_stream, &image, 1, &decode_params, &decode_future);

	size_t status_size;
	nvimgcodecProcessingStatus_t decode_status;
	nvimgcodecFutureGetProcessingStatus(decode_future, &decode_status, &status_size);
	cudaDeviceSynchronize(); // makes GPU wait until all decoding is finished
	if (decode_status != NVIMGCODEC_PROCESSING_STATUS_SUCCESS) {
		std::cerr << "Error: Something went wrong during decoding - processing status: " << decode_status << std::endl;
	}
	nvimgcodecFutureDestroy(decode_future);

	return 0;
}

In the original code in the guide there is an error

nvimgcodecImage_t image;
nvimgcodecImageCreate(instance, &image, &image_info);

“image_info” is not defined, therefore I use “output_image_info”. As output I got the perfect input image information like codec, width, height, and so on. But the decoding returns the error “NVIMGCODEC_PROCESSING_STATUS_CODEC_UNSUPPORTED”. Can I have some support?