diff --git a/client_utils/android/BitmapRegionDecoder.cpp b/client_utils/android/BitmapRegionDecoder.cpp
index c5262b8..067a76f 100644
--- a/client_utils/android/BitmapRegionDecoder.cpp
+++ b/client_utils/android/BitmapRegionDecoder.cpp
@@ -23,6 +23,9 @@
 
     switch (codec->getEncodedFormat()) {
         case SkEncodedImageFormat::kJPEG:
+#ifdef SK_CODEC_DECODES_JPEGR
+        case SkEncodedImageFormat::kJPEGR:
+#endif
         case SkEncodedImageFormat::kPNG:
         case SkEncodedImageFormat::kWEBP:
         case SkEncodedImageFormat::kHEIF:
diff --git a/src/codec/SkAndroidCodec.cpp b/src/codec/SkAndroidCodec.cpp
index 11eceaa..dd4d582 100644
--- a/src/codec/SkAndroidCodec.cpp
+++ b/src/codec/SkAndroidCodec.cpp
@@ -107,6 +107,9 @@
 #ifndef SK_CODEC_DECODES_AVIF
         case SkEncodedImageFormat::kAVIF:
 #endif
+#ifdef SK_CODEC_DECODES_JPEGR
+        case SkEncodedImageFormat::kJPEGR:
+#endif
             return std::make_unique<SkSampledCodec>(codec.release());
 #ifdef SK_HAS_WUFFS_LIBRARY
         case SkEncodedImageFormat::kGIF:
@@ -120,9 +123,6 @@
 #ifdef SK_CODEC_DECODES_AVIF
         case SkEncodedImageFormat::kAVIF:
 #endif
-#ifdef SK_CODEC_DECODES_JPEGR
-        case SkEncodedImageFormat::kJPEGR:
-#endif
 #if defined(SK_CODEC_DECODES_WEBP) || defined(SK_CODEC_DECODES_RAW) || \
         defined(SK_HAS_WUFFS_LIBRARY) || defined(SK_CODEC_DECODES_AVIF)
             return std::make_unique<SkAndroidCodecAdapter>(codec.release());
diff --git a/src/codec/SkJpegRCodec.cpp b/src/codec/SkJpegRCodec.cpp
index 5532f5b..96bdc46 100644
--- a/src/codec/SkJpegRCodec.cpp
+++ b/src/codec/SkJpegRCodec.cpp
@@ -24,22 +24,22 @@
 #include "include/core/SkStream.h"
 #include "include/core/SkTypes.h"
 #include "include/core/SkYUVAInfo.h"
-#include "include/private/base/SkTemplates.h"
 #include "include/private/base/SkMalloc.h"
+#include "include/private/base/SkTemplates.h"
 #include "include/private/base/SkTo.h"
 #include "modules/skcms/skcms.h"
 #include "src/codec/SkCodecPriv.h"
 #include "src/codec/SkParseEncodedOrigin.h"
+#include "src/codec/SkSwizzler.h"
 #include "src/core/SkStreamPriv.h"
 
-static SkEncodedOrigin get_orientation(const std::vector<uint8_t> &exifData) {
+static SkEncodedOrigin get_orientation(const std::vector<uint8_t>& exifData) {
     SkEncodedOrigin orientation = kDefault_SkEncodedOrigin;
     if (exifData.size() > 6) {
         constexpr size_t kOffset = 6;
         const size_t exifSize = exifData.size();
-        const uint8_t *data = exifData.data();
-        SkParseEncodedOrigin(data + kOffset, exifSize - kOffset,
-                &orientation);
+        const uint8_t* data = exifData.data();
+        SkParseEncodedOrigin(data + kOffset, exifSize - kOffset, &orientation);
     }
     return orientation;
 }
@@ -135,6 +135,7 @@
 
         // JPEGR always report 10-bit color depth
         const uint8_t colorDepth = 10;
+        const int bitsPerComponent = 8;
 
         // iccSkData will outlive iccData as it is passed to profile, hence we need a copy
         sk_sp<SkData> iccSkData = SkData::MakeWithCopy(iccData.data(), iccData.size());
@@ -145,8 +146,9 @@
                                                  jpegRInfo.height,
                                                  SkEncodedInfo::kRGBA_Color,
                                                  SkEncodedInfo::kOpaque_Alpha,
-                                                 colorDepth,
-                                                 std::move(profile));
+                                                 bitsPerComponent,
+                                                 std::move(profile),
+                                                 colorDepth);
 
         SkEncodedOrigin orientation = get_orientation(exifData);
 
@@ -216,6 +218,128 @@
     }
 }
 
+void SkJpegRCodec::initializeSwizzler(const SkImageInfo& dstInfo, const Options& options) {
+    const int srcBPP = 4;
+
+    fSwizzler = SkSwizzler::MakeSimple(srcBPP, dstInfo, options);
+    SkASSERT(fSwizzler);
+}
+
+void SkJpegRCodec::allocateStorage(const SkImageInfo& dstInfo) {
+    int dstWidth = dstInfo.width();
+
+    size_t swizzleBytes = 0;
+    const SkEncodedInfo& encodedInfo = this->getEncodedInfo();
+    if (fSwizzler) {
+        const int srcBPP = encodedInfo.bitsPerPixel() / 8;
+        swizzleBytes = srcBPP * encodedInfo.width();
+        dstWidth = fSwizzler->swizzleWidth();
+        SkASSERT(!this->colorXform() || SkIsAlign4(swizzleBytes));
+    }
+
+    size_t totalBytes = swizzleBytes;
+    fStorage.reset(totalBytes);
+    if (totalBytes > 0) {
+        fSwizzleSrcRow = (swizzleBytes > 0) ? fStorage.get() : nullptr;
+    }
+}
+
+SkSampler* SkJpegRCodec::getSampler(bool createIfNecessary) {
+    if (!createIfNecessary || fSwizzler) {
+        SkASSERT(!fSwizzler || (fSwizzleSrcRow && fStorage.get() == fSwizzleSrcRow));
+        return fSwizzler.get();
+    }
+
+    this->initializeSwizzler(this->dstInfo(), this->options());
+    this->allocateStorage(this->dstInfo());
+    return fSwizzler.get();
+}
+
+SkCodec::Result SkJpegRCodec::decodeImage(const SkImageInfo& dstInfo, void* dst) {
+    const SkColorType dstColorType = dstInfo.colorType();
+    if (dstColorType != kRGBA_1010102_SkColorType && dstColorType != kRGBA_8888_SkColorType) {
+        // We only support RGBA1010102 and RGBA8888 colors
+        return kUnimplemented;
+    }
+
+    const bool decodeSDR = (dstColorType == kRGBA_8888_SkColorType);
+    jpegr_compressed_struct compressedImage;
+    jpegr_uncompressed_struct decompressedImage;
+    compressedImage.data = (void*)fData->data();
+    compressedImage.length = fData->size();
+
+    // Decode to intermediate buffer
+    if (dst == nullptr) {
+        const SkEncodedInfo& encodedInfo = this->getEncodedInfo();
+        fDecodedImage.reset(encodedInfo.width() * encodedInfo.height() *
+                            encodedInfo.bitsPerPixel() / 8);
+        decompressedImage.data = fDecodedImage.get();
+    } else {
+        decompressedImage.data = dst;
+    }
+
+    if (fRecoveryMap->decodeJPEGR(&compressedImage, &decompressedImage, nullptr, decodeSDR) != 0) {
+        return kInternalError;
+    }
+    return kSuccess;
+}
+
+SkCodec::Result SkJpegRCodec::onStartScanlineDecode(const SkImageInfo& dstInfo,
+                                                    const Options& options) {
+    // We need to decode the whole image.
+    // Decode it and put to a temporary storage
+    SkCodec::Result result = kSuccess;
+    if ((result = this->decodeImage(dstInfo, nullptr)) != kSuccess) {
+        return result;
+    }
+
+    if (options.fSubset) {
+        this->initializeSwizzler(dstInfo, options);
+    } else {
+        fSwizzler.reset(nullptr);
+    }
+
+    this->allocateStorage(dstInfo);
+
+    return kSuccess;
+}
+
+int SkJpegRCodec::onGetScanlines(void* dst, int count, size_t dstRowBytes) {
+    uint8_t* decodeDst = (uint8_t*)dst;
+    uint32_t* swizzleDst = (uint32_t*)dst;
+    size_t decodeDstRowBytes = dstRowBytes;
+    size_t swizzleDstRowBytes = dstRowBytes;
+    int dstWidth =
+            this->options().fSubset ? this->options().fSubset->width() : this->dstInfo().width();
+    if (fDecodedImage.get() == nullptr) {
+        return 0;
+    }
+    if (fSwizzleSrcRow) {
+        decodeDst = fSwizzleSrcRow;
+        decodeDstRowBytes = 0;
+        dstWidth = fSwizzler->swizzleWidth();
+    }
+    const int currentLine = this->nextScanline();
+    const int decodeWidth = this->dstInfo().width();
+    const int bpp = this->getEncodedInfo().bitsPerPixel() / 8;
+    const int decodeStride = decodeWidth * bpp;
+
+    for (int y = 0; y < count; y++) {
+        memcpy(decodeDst, fDecodedImage.get() + decodeStride * (y + currentLine), decodeStride);
+
+        if (fSwizzler) {
+            fSwizzler->swizzle(swizzleDst, decodeDst);
+        }
+
+        decodeDst = SkTAddOffset<uint8_t>(decodeDst, decodeDstRowBytes);
+        swizzleDst = SkTAddOffset<uint32_t>(swizzleDst, swizzleDstRowBytes);
+    }
+
+    return count;
+}
+
+bool SkJpegRCodec::onSkipScanlines(int count) { return true; }
+
 /*
  * Performs the JpegR decode
  */
@@ -227,12 +351,6 @@
     if (options.fSubset) {
         return kUnimplemented;
     }
-    const SkColorType dstColorType = dstInfo.colorType();
-    if (dstColorType != kRGBA_1010102_SkColorType && dstColorType != kRGBA_8888_SkColorType) {
-        // We only support RGBA1010102 and RGBA8888 colors
-        return kUnimplemented;
-    }
-
     if (this->dimensions() != dstInfo.dimensions()) {
         // No Scaling
         return kUnimplemented;
@@ -243,16 +361,9 @@
         return kUnimplemented;
     }
 
-    const bool decodeSDR = (dstColorType == kRGBA_8888_SkColorType);
-
-    jpegr_compressed_struct compressedImage;
-    jpegr_uncompressed_struct decompressedImage;
-    compressedImage.data = (void*)fData->data();
-    compressedImage.length = fData->size();
-
-    decompressedImage.data = dst;
-    if (fRecoveryMap->decodeJPEGR(&compressedImage, &decompressedImage, nullptr, decodeSDR) != 0) {
-        return kInternalError;
+    SkCodec::Result result = kSuccess;
+    if ((result = this->decodeImage(dstInfo, dst)) != kSuccess) {
+        return result;
     }
 
     *rowsDecoded = dstInfo.height();
diff --git a/src/codec/SkJpegRCodec.h b/src/codec/SkJpegRCodec.h
index a3ab47a..bc36cee 100644
--- a/src/codec/SkJpegRCodec.h
+++ b/src/codec/SkJpegRCodec.h
@@ -32,6 +32,7 @@
 #include <memory>
 
 class SkStream;
+class SkSwizzler;
 struct SkImageInfo;
 
 /*
@@ -109,9 +110,29 @@
                  SkEncodedOrigin origin,
                  sk_sp<SkData> data);
 
+    void initializeSwizzler(const SkImageInfo& dstInfo, const Options& options);
+    void allocateStorage(const SkImageInfo& dstInfo);
+
+    // If "dst" is nullptr decoded image will be placed to fDecodedImage
+    Result decodeImage(const SkImageInfo& dstInfo, void* dst);
+
+    /*
+     * Scanline decoding.
+     */
+    SkSampler* getSampler(bool createIfNecessary) override;
+    Result onStartScanlineDecode(const SkImageInfo& dstInfo, const Options& options) override;
+    int onGetScanlines(void* dst, int count, size_t rowBytes) override;
+    bool onSkipScanlines(int count) override;
+
     std::unique_ptr<RecoveryMap> fRecoveryMap;
     sk_sp<SkData> fData;
 
+    skia_private::AutoTMalloc<uint8_t> fStorage;
+    skia_private::AutoTMalloc<uint8_t> fDecodedImage;
+    uint8_t* fSwizzleSrcRow = nullptr;
+
+    std::unique_ptr<SkSwizzler> fSwizzler;
+
 #endif  // SK_CODEC_DECODES_JPEGR
 };