Method _OpenAsset

Libraries/ImageProcessingResolver/Resolver.cpp:165–310

ImageProcessingResolverPlugin::~ImageProcessingResolverPlugin() {}

std::shared_ptr<ArAsset> ImageProcessingResolverPlugin::_OpenAsset(
    const ArResolvedPath& resolvedPath) const
{
    // Get string for path.
    std::string pathStr = resolvedPath.GetPathString();

    // Is the path an encoded URI path?
    if (pathStr.find(assetPathPrefix) != std::string::npos)
    {
        // Get the cacheEntry for this URI.
        AssetCacheEntry& cacheEntry =
            const_cast<ImageProcessingResolverPlugin*>(this)->_assetCache[pathStr];

        // If we do not have an asset cached, create one.
        if (!cacheEntry.pAsset)
        {

            // Use the Hio image function to read the source image.
            pxr::HioImageSharedPtr const image =
                pxr::HioImage::OpenForReading(cacheEntry.sourceFilename);

            // If image load failed, return null asset.
            if (!image)
            {
                return nullptr;
            }

            // Create a temp buffer for the source image pixels.
            // NOTE: Multiplying int values may exceed INT_MAX. Cast to size_t for security.
            size_t sizeInBytes = static_cast<size_t>(image->GetWidth()) *
                static_cast<size_t>(image->GetHeight()) *
                static_cast<size_t>(image->GetBytesPerPixel());
            std::vector<unsigned char> tempBuf(sizeInBytes);
            // Read the source image into the temp buffer.
            pxr::HioImage::StorageSpec imageData;
            imageData.width   = image->GetWidth();
            imageData.height  = image->GetHeight();
            imageData.depth   = 1;
            imageData.flipped = false;
            imageData.format  = image->GetFormat();
            imageData.data    = tempBuf.data();
            image->Read(imageData);

            // Get the maxDim query parameter, default to 16k if not specified.
            int maxDim = 16 * 1024;
            cacheEntry.getQuery("maxDim", &maxDim);

            // If the input image's dimensions are larger than maxDim shrink it, keeping the aspect
            // ratio the same.
            if (imageData.width > imageData.height)
            {
                if (imageData.width > maxDim)
                {
                    int newWidth    = maxDim;
                    float sizeRatio = float(maxDim) / float(imageData.width);
                    int newHeight   = int(imageData.height * sizeRatio);
                    shrinkImage(imageData, tempBuf, newWidth, newHeight);
                }