path: root/src/lib/fastvideo.cc

#include "exceptions.h"
#include "fastvideo.h"
#include <fastvideo_decoder_j2k.h>
#include <fastvideo_sdk.h>
#include <iostream>


using boost::shared_ptr;


void
handle (fastExportToHostHandle_t& adapter, fastGpuTimerHandle_t& device_to_host_timer)
{
	fastExportParameters_t exportParameters;
	exportParameters.convert = options.ConvertToBGR ? FAST_CONVERT_BGR : FAST_CONVERT_NONE;

	int aligned_width = info.width * 3;
	aligned_width += 4 - (aligned_width % FAST_ALIGNMENT);
	size_t decoded_size = info.height * aligned_width;
	uint8_t* decoded = 0;
	fastStatus_t r = fastMalloc(reinterpret_cast<void**>(&decoded), decoded_size);
	if (r != FAST_OK) {
		throw FastvideoError ("fastMalloc");
	}

	fastGpuTimerStart(device_to_host_timer	);

	CHECK_FAST(fastExportToHostCopy(
			adapter,

			img.data.get(),
			img.w,
			img.wPitch,
			img.h,

			&exportParameters
			));

	float elapsedTimeGpu = 0.;
	fastGpuTimerStop(deviceToHostTimer);
	fastGpuTimerGetTime(deviceToHostTimer, &elapsedTimeGpu);

	totalInternalTime += elapsedTimeGpu / 1000.0;

	outputImgs->push_back(img);
	if (imagesLeft == 0)
		break;
	CHECK_FAST(fastDecoderJ2kGetNextDecodedImage(decoder, &report, &imagesLeft));
}


shared_ptr<OpenJPEGImage>
fastvideo_decompress_j2k (dcp::Data data, int reduce)
{
	const int max_batch_size = 16;
	const int images_to_convert = 64;

	fastTraceCreate("/home/carl/trace.log");

	/*
	fastStatus_t r = fastInit(0, true);
	if (r != FAST_OK) {
		throw FastvideoError ("Init", r);
	}
	*/

	fastSdkParametersHandle_t sdk_parameters;
	fastStatus_t r = fastGetSdkParametersHandle(&sdk_parameters);
	if (r != FAST_OK) {
		throw FastvideoError ("GetSdkParametersHandle", r);
	}
	r = fastDecoderJ2kLibraryInit(sdk_parameters);
	if (r != FAST_OK) {
		throw FastvideoError ("J2kLibraryInit", r);
	}

	fastJ2kImageInfo_t info;
	r = fastDecoderJ2kPredecode(&info, data.data().get(), data.size());
	if (r != FAST_OK) {
		throw FastvideoError ("J2kPredecode");
	}

	std::cout << "predecode -> " << info.width << "x" << info.height << " stream size " << info.streamSize << "\n";

	/* Init */

	fastDecoderJ2kStaticParameters_t parameters;
	memset(&parameters, 0, sizeof(fastDecoderJ2kStaticParameters_t));

	parameters.ResolutionLevels = 0;
	parameters.verboseLevel = 1;
	parameters.enableROI = 0;

	parameters.maxTileHeight = info.height;
	parameters.maxTileWidth = info.width;

	parameters.windowX0 = 0;
	parameters.windowY0 = 0;
	parameters.windowWidth = info.width;
	parameters.windowHeight = info.height;

	parameters.truncationLength = 0;
	parameters.truncationMode = 0;
	parameters.truncationRate = 0;

	parameters.DecodePasses = 0;
	parameters.imageInfo = &info;
	parameters.maxStreamSize = info.streamSize;

	std::cout << "verboseLevel " << parameters.verboseLevel << "\n";
	std::cout << "maxTileWidth " << parameters.maxTileWidth << "\n";
	std::cout << "maxTileHeight " << parameters.maxTileHeight << "\n";
	std::cout << "ResolutionLevels " << parameters.ResolutionLevels << "\n";
	std::cout << "DecodePasses " << parameters.DecodePasses << "\n";
	std::cout << "maxStreamSize " << parameters.maxStreamSize << "\n";
	std::cout << "truncationMode " << parameters.truncationMode << "\n";
	std::cout << "truncationRate " << parameters.truncationRate << "\n";
	std::cout << "truncationLength " << parameters.truncationLength << "\n";
	std::cout << "windowX0 " << parameters.windowX0 << "\n";
	std::cout << "windowY0 " << parameters.windowY0 << "\n";
	std::cout << "windowWidth " << parameters.windowWidth << "\n";
	std::cout << "windowHeight " << parameters.windowHeight << "\n";
	std::cout << "enableROI " << parameters.enableROI << "\n";
	std::cout << "enableMemoryReallocation " << parameters.enableMemoryReallocation << "\n";

	fastDecoderJ2kHandle_t decoder = 0;
	fastDeviceSurfaceBufferHandle_t buffer;
	r = fastDecoderJ2kCreate(
			&decoder,
			&parameters,
			FAST_RGB8, info.width, info.height,
			max_batch_size,
			&buffer
			);
	if (r != FAST_OK) {
		fastTraceClose ();
		throw FastvideoError ("J2kCreate", r);
	}

	unsigned long long requested_mem_size = 0;

	{
		unsigned long long component_mem_size = 0;
		r = fastDecoderJ2kGetAllocatedGpuMemorySize(decoder, &component_mem_size);
		if (r != FAST_OK) {
			throw FastvideoError ("J2kGetAllocatedGpuMemorySize");
		}
		requested_mem_size += component_mem_size;
	}

	fastExportToHostHandle_t adapter;
	fastSurfaceFormat_t surface_format;
	r = fastExportToHostCreate(&adapter, &surface_format, buffer);
	if (r != FAST_OK) {
		throw FastvideoError ("ExportToHostCreate");
	}

	{
		unsigned int component_mem_size = 0;
		r = fastExportToHostGetAllocatedGpuMemorySize(adapter, &component_mem_size);
		if (r != FAST_OK) {
			throw FastvideoError ("ExportToHostGetAllocatedGpuMemorySize");
		}
		requested_mem_size += component_mem_size;
	}

	const double gigabyte = 1024.0 * 1024.0 * 1024.0;
	printf("\nRequested GPU memory size: %.2lf GB\n", requested_mem_size / gigabyte);

	/* Transform */

	double total_time = 0;
	fastGpuTimerHandle_t device_to_host_timer = 0;
	fastGpuTimerCreate(&device_to_host_timer);

	fastDecoderJ2kReport_t report;

	fastExportParameters_t export_parameters;
	export_parameters.convert = FAST_CONVERT_NONE;

	int aligned_width = info.width * 3;
	aligned_width += 4 - (aligned_width % FAST_ALIGNMENT);
	size_t decoded_size = info.height * aligned_width;
	uint8_t* decoded = 0;
	r = fastMalloc(reinterpret_cast<void**>(&decoded), decoded_size);
	if (r != FAST_OK) {
		throw FastvideoError ("fastMalloc");
	}

	for (int i = 0; i < images_to_convert; ++i) {
		fastDecoderJ2kAddImageToBatch(decoder, data.data().get(), data.size());
		int free_slots = 0;
		fastDecoderJ2kFreeSlotsInBatch(decoder, &free_slots);
		if (free_slots == 0) {
			CHECK_FAST(TransformAndExtractBatch(img, &outputImgs));
		}
	}

	int unprocessed_images_count = 0;
	r = fastDecoderJ2kUnprocessedImagesCount(decoder, &unprocessed_images_count);
	if (unprocessed_images_count > 0) { // Process the last non-complete batch

		CHECK_FAST(TransformAndExtractBatch(img, &outputImgs));
	}

	total_time += report.elapsedTime;

	fastGpuTimerStart(device_to_host_timer);
	r = fastExportToHostCopy(adapter, decoded, info.width, aligned_width, info.height, &export_parameters);
	if (r != FAST_OK) {
		throw FastvideoError ("ExportToHostCopy");
	}

	float elapsed_time_gpu = 0.;
	fastGpuTimerStop(device_to_host_timer);
	fastGpuTimerGetTime(device_to_host_timer, &elapsed_time_gpu);

	total_time += elapsed_time_gpu / 1000.0;

	if (report.codeblockCount > 0) {
		printf("Input image : (%dx%d pixels; %d %d-bit channel(s))\n", info.width, info.height, report.channels, report.bitsPerChannel);
		printf("Tile count: %d (%dx%d)\n", report.tileCount, report.tilesX, report.tilesY);
		printf("Window mode disabled: decode full image\n");
		printf("Resolution levels: %d\n", report.resolutionLevels);
		printf("Codeblock size: %dx%d\n", report.cbX, report.cbY);

		const double megabyte = 1024.0 * 1024.0;
		printf("%7.2f ms 1) Tier-2 time (%d codeblocks)\n", report.s1_tier2 * 1000.0, report.codeblockCount);
		printf("%7.2f ms 2) CPU->GPU copy time (%.2lf MB, %.2lf MB/s)\n",
			report.s2_copy * 1000.0,
			report.copyToGpu_size / megabyte,
			report.copyToGpu_size == 0 ? 0 : (report.copyToGpu_size / report.s2_copy / megabyte));
		printf("%7.2f ms 3) Tier-1 time\n", report.s3_tier1 * 1000.0);
		printf("%7.2f ms 4) DWT time\n", report.s6_dwt * 1000.0);
		printf("%7.2f ms 5) Postprocessing time (MCT, DC-shift)\n", report.s7_postprocessing * 1000.0);
		printf("              Output size = ");
		if (report.outStreamSize < 1024)
			printf("%lld bytes", report.outStreamSize);
		else
			printf("%.0f KB", report.outStreamSize / 1024.0f);
		printf(" (%.1f:1)\n", report.outStreamSize == 0 ? 0 : (float)report.outStreamSize / report.inStreamSize);
	}

	printf("Total decode time for %d images = %.1f ms; %.1f FPS;\n", 1,
		total_time * 1000.0, 1 / total_time);

	fastGpuTimerDestroy(device_to_host_timer);

	/* Close */

	r = fastDecoderJ2kDestroy(decoder);
	if (r != FAST_OK) {
		throw FastvideoError ("J2kDestroy");
	}
	r = fastExportToHostDestroy(adapter);
	if (r != FAST_OK) {
		throw FastvideoError ("ExportToHostDestroy");
	}

	fastFree(decoded);

	return shared_ptr<OpenJPEGImage>();
}