diff --git a/src/core/SkVM.cpp b/src/core/SkVM.cpp
index 2528726..6ce2199 100644
--- a/src/core/SkVM.cpp
+++ b/src/core/SkVM.cpp
@@ -851,6 +851,14 @@
         return round(mul(x, splat(limit)));
     }
 
+    Color Builder::unpack_1010102(I32 rgba) {
+        return {
+            from_unorm(10, extract(rgba,  0, splat(0x3ff))),
+            from_unorm(10, extract(rgba, 10, splat(0x3ff))),
+            from_unorm(10, extract(rgba, 20, splat(0x3ff))),
+            from_unorm( 2, extract(rgba, 30, splat(0x3  ))),
+        };
+    }
     Color Builder::unpack_8888(I32 rgba) {
         return {
             from_unorm(8, extract(rgba,  0, splat(0xff))),
diff --git a/src/core/SkVM.h b/src/core/SkVM.h
index 5d870f3..39aaeb0 100644
--- a/src/core/SkVM.h
+++ b/src/core/SkVM.h
@@ -542,8 +542,9 @@
         F32 from_unorm(int bits, I32);   // E.g. from_unorm(8, x) -> x * (1/255.0f)
         I32   to_unorm(int bits, F32);   // E.g.   to_unorm(8, x) -> round(x * 255)
 
-        Color unpack_8888(I32 rgba);
-        Color unpack_565 (I32 bgr );  // bottom 16 bits
+        Color unpack_1010102(I32 rgba);
+        Color unpack_8888   (I32 rgba);
+        Color unpack_565    (I32 bgr );  // bottom 16 bits
 
         void   premul(F32* r, F32* g, F32* b, F32 a);
         void unpremul(F32* r, F32* g, F32* b, F32 a);
diff --git a/src/core/SkVMBlitter.cpp b/src/core/SkVMBlitter.cpp
index 8e77ba4..21bf4c2 100644
--- a/src/core/SkVMBlitter.cpp
+++ b/src/core/SkVMBlitter.cpp
@@ -144,10 +144,17 @@
             }
 
             switch (params.colorType) {
-                default: *ok = false;        break;
-                case kRGB_565_SkColorType:   break;
-                case kRGBA_8888_SkColorType: break;
-                case kBGRA_8888_SkColorType: break;
+                default: *ok = false;
+                         break;
+
+                case kRGB_565_SkColorType:
+                case kRGB_888x_SkColorType:
+                case kRGBA_8888_SkColorType:
+                case kBGRA_8888_SkColorType:
+                case kRGBA_1010102_SkColorType:
+                case kBGRA_1010102_SkColorType:
+                case kRGB_101010x_SkColorType:
+                case kBGR_101010x_SkColorType:  break;
             }
 
             if (!skvm::BlendModeSupported(params.blendMode)) {
@@ -269,11 +276,25 @@
             SkDEBUGCODE(dst_loaded = true;)
             switch (params.colorType) {
                 default: SkUNREACHABLE;
-                case kRGB_565_SkColorType:   dst = unpack_565 (load16(dst_ptr)); break;
-                case kRGBA_8888_SkColorType: dst = unpack_8888(load32(dst_ptr)); break;
+                case kRGB_565_SkColorType: dst = unpack_565(load16(dst_ptr));
+                                           break;
+
+                case  kRGB_888x_SkColorType: [[fallthrough]];
+                case kRGBA_8888_SkColorType: dst = unpack_8888(load32(dst_ptr));
+                                             break;
+
                 case kBGRA_8888_SkColorType: dst = unpack_8888(load32(dst_ptr));
                                              std::swap(dst.r, dst.b);
                                              break;
+
+                case  kRGB_101010x_SkColorType: [[fallthrough]];
+                case kRGBA_1010102_SkColorType: dst = unpack_1010102(load32(dst_ptr));
+                                                break;
+
+                case  kBGR_101010x_SkColorType: [[fallthrough]];
+                case kBGRA_1010102_SkColorType: dst = unpack_1010102(load32(dst_ptr));
+                                                std::swap(dst.r, dst.b);
+                                                break;
             }
 
             // When a destination is known opaque, we may assume it both starts and stays fully
@@ -385,13 +406,24 @@
                                                to_unorm(5,src.r),11));
                     break;
 
-                case kBGRA_8888_SkColorType: std::swap(src.r, src.b);  // fallthrough
+                case kBGRA_8888_SkColorType: std::swap(src.r, src.b);  [[fallthrough]];
+                case  kRGB_888x_SkColorType:                           [[fallthrough]];
                 case kRGBA_8888_SkColorType:
                      store32(dst_ptr, pack(pack(to_unorm(8, src.r),
                                                 to_unorm(8, src.g), 8),
                                            pack(to_unorm(8, src.b),
                                                 to_unorm(8, src.a), 8), 16));
                      break;
+
+                case  kBGR_101010x_SkColorType:                          [[fallthrough]];
+                case kBGRA_1010102_SkColorType: std::swap(src.r, src.b); [[fallthrough]];
+                case  kRGB_101010x_SkColorType:                          [[fallthrough]];
+                case kRGBA_1010102_SkColorType:
+                     store32(dst_ptr, pack(pack(to_unorm(10, src.r),
+                                                to_unorm(10, src.g), 10),
+                                           pack(to_unorm(10, src.b),
+                                                to_unorm( 2, src.a), 10), 20));
+                     break;
             }
         }
     };
diff --git a/src/shaders/SkImageShader.cpp b/src/shaders/SkImageShader.cpp
index 8fec905..4603aab 100755
--- a/src/shaders/SkImageShader.cpp
+++ b/src/shaders/SkImageShader.cpp
@@ -671,8 +671,13 @@
     switch (pm.colorType()) {
         default: return false;
         case   kRGB_565_SkColorType:
+        case  kRGB_888x_SkColorType:
         case kRGBA_8888_SkColorType:
-        case kBGRA_8888_SkColorType: break;
+        case kBGRA_8888_SkColorType:
+        case kRGBA_1010102_SkColorType:
+        case kBGRA_1010102_SkColorType:
+        case  kRGB_101010x_SkColorType:
+        case  kBGR_101010x_SkColorType: break;
     }
 
     // We can exploit image opacity to skip work unpacking alpha channels.
@@ -736,10 +741,22 @@
         switch (pm.colorType()) {
             default: SkUNREACHABLE;
             case   kRGB_565_SkColorType: c = p->unpack_565 (p->gather16(img, index)); break;
-            case kRGBA_8888_SkColorType: c = p->unpack_8888(p->gather32(img, index)); break;
+
+            case  kRGB_888x_SkColorType: [[fallthrough]];
+            case kRGBA_8888_SkColorType: c = p->unpack_8888(p->gather32(img, index));
+                                         break;
             case kBGRA_8888_SkColorType: c = p->unpack_8888(p->gather32(img, index));
                                          std::swap(c.r, c.b);
                                          break;
+
+            case  kRGB_101010x_SkColorType: [[fallthrough]];
+            case kRGBA_1010102_SkColorType: c = p->unpack_1010102(p->gather32(img, index));
+                                            break;
+
+            case  kBGR_101010x_SkColorType: [[fallthrough]];
+            case kBGRA_1010102_SkColorType: c = p->unpack_1010102(p->gather32(img, index));
+                                            std::swap(c.r, c.b);
+                                            break;
         }
         // If we know the image is opaque, jump right to alpha = 1.0f, skipping work to unpack it.
         if (input_is_opaque) {