Function CompressTextureSetWithTargetPSNR

tools/cli/NtcCommandLine.cpp:1391–1469

};

bool CompressTextureSetWithTargetPSNR(ntc::IContext* context, ntc::ITextureSet* textureSet)
{
    ntc::Status ntcStatus;

    ntc::AdaptiveCompressionSessionWrapper session(context);
    ntcStatus = context->CreateAdaptiveCompressionSession(session.ptr());
    CHECK_NTC_RESULT("CreateAdaptiveCompressionSession")

    float const targetPsnr = g_options.targetPsnr;
    float const maxBitsPerPixel = std::isnan(g_options.maxBitsPerPixel) ? 0.f : g_options.maxBitsPerPixel;
    ntcStatus = session->Reset(targetPsnr, maxBitsPerPixel);
    CHECK_NTC_RESULT("Reset")
    
    printf("Starting search for optimal BPP to achieve %.2f dB PSNR.\n", g_options.targetPsnr);
    
    int experimentCount = 0;
    std::vector<AdaptiveSearchResult> results;

    while (!session->Finished())
    {
        float bitsPerPixel;
        ntc::LatentShape latentShape;
        session->GetCurrentPreset(&bitsPerPixel, &latentShape);

        printf("Experiment %d: %.2f bpp...\n", experimentCount + 1, bitsPerPixel);

        ntcStatus = textureSet->SetLatentShape(latentShape);
        CHECK_NTC_RESULT(SetLatentShape)

        float psnr = NAN;
        if (!CompressTextureSet(context, textureSet, &psnr))
            return false;

        // Store the compression result
        AdaptiveSearchResult result;
        result.bitsPerPixel = bitsPerPixel;
        result.latentShape = latentShape;
        result.psnr = psnr;

        // Save the compressed data to an in-memory vector
        size_t bufferSize = textureSet->GetOutputStreamSize();
        result.compressedData.resize(bufferSize);
        ntcStatus = textureSet->SaveToMemory(result.compressedData.data(), &bufferSize);
        CHECK_NTC_RESULT(SaveToMemory)

        // Trim the buffer to the actual size of the saved data
        result.compressedData.resize(bufferSize);

        results.push_back(std::move(result));
        
        session->Next(psnr);
        ++experimentCount;
    }

    // Get and validate the index of the final result
    int finalIndex = session->GetIndexOfFinalRun();
    if (finalIndex < 0 || finalIndex >= int(results.size()))
    {