diff --git a/src/dawn_native/CommandValidation.cpp b/src/dawn_native/CommandValidation.cpp
index ea2017d..25f49f2 100644
--- a/src/dawn_native/CommandValidation.cpp
+++ b/src/dawn_native/CommandValidation.cpp
@@ -429,11 +429,13 @@
     MaybeError ValidateTextureToTextureCopyRestrictions(const ImageCopyTexture& src,
                                                         const ImageCopyTexture& dst,
                                                         const Extent3D& copySize) {
-        // Metal requires texture-to-texture copies be the same format
-        DAWN_INVALID_IF(src.texture->GetFormat().format != dst.texture->GetFormat().format,
-                        "Source %s format (%s) and destination %s format (%s) do not match.",
-                        src.texture, src.texture->GetFormat().format, dst.texture,
-                        dst.texture->GetFormat().format);
+        // Metal requires texture-to-texture copies happens between texture formats that equal to
+        // each other or only have diff on srgb-ness.
+        DAWN_INVALID_IF(
+            !src.texture->GetFormat().CopyCompatibleWith(dst.texture->GetFormat()),
+            "Source %s format (%s) and destination %s format (%s) are not copy compatible.",
+            src.texture, src.texture->GetFormat().format, dst.texture,
+            dst.texture->GetFormat().format);
 
         return ValidateTextureToTextureCopyCommonRestrictions(src, dst, copySize);
     }
diff --git a/src/dawn_native/Format.cpp b/src/dawn_native/Format.cpp
index c8d0588..45f89f1 100644
--- a/src/dawn_native/Format.cpp
+++ b/src/dawn_native/Format.cpp
@@ -104,6 +104,10 @@
         return (aspects & (Aspect::Plane0 | Aspect::Plane1)) != 0;
     }
 
+    bool Format::CopyCompatibleWith(const Format& format) const {
+        return baseFormat == format.baseFormat;
+    }
+
     const AspectInfo& Format::GetAspectInfo(wgpu::TextureAspect aspect) const {
         return GetAspectInfo(SelectFormatAspects(*this, aspect));
     }
@@ -157,47 +161,57 @@
             formatsSet.set(index);
         };
 
-        auto AddColorFormat = [&AddFormat](wgpu::TextureFormat format, bool renderable,
-                                           bool supportsStorageUsage, uint32_t byteSize,
-                                           SampleTypeBit sampleTypes, uint8_t componentCount) {
-            Format internalFormat;
-            internalFormat.format = format;
-            internalFormat.isRenderable = renderable;
-            internalFormat.isCompressed = false;
-            internalFormat.isSupported = true;
-            internalFormat.supportsStorageUsage = supportsStorageUsage;
-            internalFormat.aspects = Aspect::Color;
-            internalFormat.componentCount = componentCount;
-            AspectInfo* firstAspect = internalFormat.aspectInfo.data();
-            firstAspect->block.byteSize = byteSize;
-            firstAspect->block.width = 1;
-            firstAspect->block.height = 1;
-            if (HasOneBit(sampleTypes)) {
-                switch (sampleTypes) {
-                    case SampleTypeBit::Float:
-                    case SampleTypeBit::UnfilterableFloat:
-                        firstAspect->baseType = wgpu::TextureComponentType::Float;
-                        break;
-                    case SampleTypeBit::Sint:
-                        firstAspect->baseType = wgpu::TextureComponentType::Sint;
-                        break;
-                    case SampleTypeBit::Uint:
-                        firstAspect->baseType = wgpu::TextureComponentType::Uint;
-                        break;
-                    default:
-                        UNREACHABLE();
-                }
-            } else {
-                ASSERT((sampleTypes & SampleTypeBit::Float) != 0);
-                firstAspect->baseType = wgpu::TextureComponentType::Float;
-            }
-            firstAspect->supportedSampleTypes = sampleTypes;
-            firstAspect->format = format;
-            AddFormat(internalFormat);
-        };
+        auto AddColorFormat =
+            [&AddFormat](wgpu::TextureFormat format, bool renderable, bool supportsStorageUsage,
+                         uint32_t byteSize, SampleTypeBit sampleTypes, uint8_t componentCount,
+                         wgpu::TextureFormat baseFormat = wgpu::TextureFormat::Undefined) {
+                Format internalFormat;
+                internalFormat.format = format;
+                internalFormat.isRenderable = renderable;
+                internalFormat.isCompressed = false;
+                internalFormat.isSupported = true;
+                internalFormat.supportsStorageUsage = supportsStorageUsage;
+                internalFormat.aspects = Aspect::Color;
+                internalFormat.componentCount = componentCount;
 
-        auto AddDepthFormat = [&AddFormat](wgpu::TextureFormat format, uint32_t byteSize,
-                                           bool isSupported) {
+                // Default baseFormat of each color formats should be themselves.
+                if (baseFormat == wgpu::TextureFormat::Undefined) {
+                    internalFormat.baseFormat = format;
+                } else {
+                    internalFormat.baseFormat = baseFormat;
+                }
+
+                AspectInfo* firstAspect = internalFormat.aspectInfo.data();
+                firstAspect->block.byteSize = byteSize;
+                firstAspect->block.width = 1;
+                firstAspect->block.height = 1;
+                if (HasOneBit(sampleTypes)) {
+                    switch (sampleTypes) {
+                        case SampleTypeBit::Float:
+                        case SampleTypeBit::UnfilterableFloat:
+                            firstAspect->baseType = wgpu::TextureComponentType::Float;
+                            break;
+                        case SampleTypeBit::Sint:
+                            firstAspect->baseType = wgpu::TextureComponentType::Sint;
+                            break;
+                        case SampleTypeBit::Uint:
+                            firstAspect->baseType = wgpu::TextureComponentType::Uint;
+                            break;
+                        default:
+                            UNREACHABLE();
+                    }
+                } else {
+                    ASSERT((sampleTypes & SampleTypeBit::Float) != 0);
+                    firstAspect->baseType = wgpu::TextureComponentType::Float;
+                }
+                firstAspect->supportedSampleTypes = sampleTypes;
+                firstAspect->format = format;
+                AddFormat(internalFormat);
+            };
+
+        auto AddDepthFormat = [&AddFormat](
+                                  wgpu::TextureFormat format, uint32_t byteSize, bool isSupported,
+                                  wgpu::TextureFormat baseFormat = wgpu::TextureFormat::Undefined) {
             Format internalFormat;
             internalFormat.format = format;
             internalFormat.isRenderable = true;
@@ -206,6 +220,14 @@
             internalFormat.supportsStorageUsage = false;
             internalFormat.aspects = Aspect::Depth;
             internalFormat.componentCount = 1;
+
+            // Default baseFormat of each depth formats should be themselves.
+            if (baseFormat == wgpu::TextureFormat::Undefined) {
+                internalFormat.baseFormat = format;
+            } else {
+                internalFormat.baseFormat = baseFormat;
+            }
+
             AspectInfo* firstAspect = internalFormat.aspectInfo.data();
             firstAspect->block.byteSize = byteSize;
             firstAspect->block.width = 1;
@@ -216,7 +238,9 @@
             AddFormat(internalFormat);
         };
 
-        auto AddStencilFormat = [&AddFormat](wgpu::TextureFormat format, bool isSupported) {
+        auto AddStencilFormat = [&AddFormat](wgpu::TextureFormat format, bool isSupported,
+                                             wgpu::TextureFormat baseFormat =
+                                                 wgpu::TextureFormat::Undefined) {
             Format internalFormat;
             internalFormat.format = format;
             internalFormat.isRenderable = true;
@@ -225,6 +249,15 @@
             internalFormat.supportsStorageUsage = false;
             internalFormat.aspects = Aspect::Stencil;
             internalFormat.componentCount = 1;
+            internalFormat.baseFormat = baseFormat;
+
+            // Default baseFormat of each stencil formats should be themselves.
+            if (baseFormat == wgpu::TextureFormat::Undefined) {
+                internalFormat.baseFormat = format;
+            } else {
+                internalFormat.baseFormat = baseFormat;
+            }
+
             AspectInfo* firstAspect = internalFormat.aspectInfo.data();
             firstAspect->block.byteSize = 1;
             firstAspect->block.width = 1;
@@ -235,31 +268,41 @@
             AddFormat(internalFormat);
         };
 
-        auto AddCompressedFormat = [&AddFormat](wgpu::TextureFormat format, uint32_t byteSize,
-                                                uint32_t width, uint32_t height, bool isSupported,
-                                                uint8_t componentCount) {
-            Format internalFormat;
-            internalFormat.format = format;
-            internalFormat.isRenderable = false;
-            internalFormat.isCompressed = true;
-            internalFormat.isSupported = isSupported;
-            internalFormat.supportsStorageUsage = false;
-            internalFormat.aspects = Aspect::Color;
-            internalFormat.componentCount = componentCount;
-            AspectInfo* firstAspect = internalFormat.aspectInfo.data();
-            firstAspect->block.byteSize = byteSize;
-            firstAspect->block.width = width;
-            firstAspect->block.height = height;
-            firstAspect->baseType = wgpu::TextureComponentType::Float;
-            firstAspect->supportedSampleTypes = kAnyFloat;
-            firstAspect->format = format;
-            AddFormat(internalFormat);
-        };
+        auto AddCompressedFormat =
+            [&AddFormat](wgpu::TextureFormat format, uint32_t byteSize, uint32_t width,
+                         uint32_t height, bool isSupported, uint8_t componentCount,
+                         wgpu::TextureFormat baseFormat = wgpu::TextureFormat::Undefined) {
+                Format internalFormat;
+                internalFormat.format = format;
+                internalFormat.isRenderable = false;
+                internalFormat.isCompressed = true;
+                internalFormat.isSupported = isSupported;
+                internalFormat.supportsStorageUsage = false;
+                internalFormat.aspects = Aspect::Color;
+                internalFormat.componentCount = componentCount;
+
+                // Default baseFormat of each compressed formats should be themselves.
+                if (baseFormat == wgpu::TextureFormat::Undefined) {
+                    internalFormat.baseFormat = format;
+                } else {
+                    internalFormat.baseFormat = baseFormat;
+                }
+
+                AspectInfo* firstAspect = internalFormat.aspectInfo.data();
+                firstAspect->block.byteSize = byteSize;
+                firstAspect->block.width = width;
+                firstAspect->block.height = height;
+                firstAspect->baseType = wgpu::TextureComponentType::Float;
+                firstAspect->supportedSampleTypes = kAnyFloat;
+                firstAspect->format = format;
+                AddFormat(internalFormat);
+            };
 
         auto AddMultiAspectFormat =
             [&AddFormat, &table](wgpu::TextureFormat format, Aspect aspects,
                                  wgpu::TextureFormat firstFormat, wgpu::TextureFormat secondFormat,
-                                 bool isRenderable, bool isSupported, uint8_t componentCount) {
+                                 bool isRenderable, bool isSupported, uint8_t componentCount,
+                                 wgpu::TextureFormat baseFormat = wgpu::TextureFormat::Undefined) {
                 Format internalFormat;
                 internalFormat.format = format;
                 internalFormat.isRenderable = isRenderable;
@@ -268,6 +311,14 @@
                 internalFormat.supportsStorageUsage = false;
                 internalFormat.aspects = aspects;
                 internalFormat.componentCount = componentCount;
+
+                // Default baseFormat of each multi aspect formats should be themselves.
+                if (baseFormat == wgpu::TextureFormat::Undefined) {
+                    internalFormat.baseFormat = format;
+                } else {
+                    internalFormat.baseFormat = baseFormat;
+                }
+
                 const size_t firstFormatIndex = ComputeFormatIndex(firstFormat);
                 const size_t secondFormatIndex = ComputeFormatIndex(secondFormat);
 
@@ -301,12 +352,12 @@
         AddColorFormat(wgpu::TextureFormat::RG16Sint, true, false, 4, SampleTypeBit::Sint, 2);
         AddColorFormat(wgpu::TextureFormat::RG16Float, true, false, 4, kAnyFloat, 2);
         AddColorFormat(wgpu::TextureFormat::RGBA8Unorm, true, true, 4, kAnyFloat, 4);
-        AddColorFormat(wgpu::TextureFormat::RGBA8UnormSrgb, true, false, 4, kAnyFloat, 4);
+        AddColorFormat(wgpu::TextureFormat::RGBA8UnormSrgb, true, false, 4, kAnyFloat, 4, wgpu::TextureFormat::RGBA8Unorm);
         AddColorFormat(wgpu::TextureFormat::RGBA8Snorm, false, true, 4, kAnyFloat, 4);
         AddColorFormat(wgpu::TextureFormat::RGBA8Uint, true, true, 4, SampleTypeBit::Uint, 4);
         AddColorFormat(wgpu::TextureFormat::RGBA8Sint, true, true, 4, SampleTypeBit::Sint, 4);
         AddColorFormat(wgpu::TextureFormat::BGRA8Unorm, true, false, 4, kAnyFloat, 4);
-        AddColorFormat(wgpu::TextureFormat::BGRA8UnormSrgb, true, false, 4, kAnyFloat, 4);
+        AddColorFormat(wgpu::TextureFormat::BGRA8UnormSrgb, true, false, 4, kAnyFloat, 4, wgpu::TextureFormat::BGRA8Unorm);
         AddColorFormat(wgpu::TextureFormat::RGB10A2Unorm, true, false, 4, kAnyFloat, 4);
 
         AddColorFormat(wgpu::TextureFormat::RG11B10Ufloat, false, false, 4, kAnyFloat, 3);
@@ -346,28 +397,28 @@
         // BC compressed formats
         bool isBCFormatSupported = device->IsFeatureEnabled(Feature::TextureCompressionBC);
         AddCompressedFormat(wgpu::TextureFormat::BC1RGBAUnorm, 8, 4, 4, isBCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::BC1RGBAUnormSrgb, 8, 4, 4, isBCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::BC1RGBAUnormSrgb, 8, 4, 4, isBCFormatSupported, 4, wgpu::TextureFormat::BC1RGBAUnorm);
         AddCompressedFormat(wgpu::TextureFormat::BC4RSnorm, 8, 4, 4, isBCFormatSupported, 1);
         AddCompressedFormat(wgpu::TextureFormat::BC4RUnorm, 8, 4, 4, isBCFormatSupported, 1);
         AddCompressedFormat(wgpu::TextureFormat::BC2RGBAUnorm, 16, 4, 4, isBCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::BC2RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::BC2RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported, 4, wgpu::TextureFormat::BC2RGBAUnorm);
         AddCompressedFormat(wgpu::TextureFormat::BC3RGBAUnorm, 16, 4, 4, isBCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::BC3RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::BC3RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported, 4, wgpu::TextureFormat::BC3RGBAUnorm);
         AddCompressedFormat(wgpu::TextureFormat::BC5RGSnorm, 16, 4, 4, isBCFormatSupported, 2);
         AddCompressedFormat(wgpu::TextureFormat::BC5RGUnorm, 16, 4, 4, isBCFormatSupported, 2);
         AddCompressedFormat(wgpu::TextureFormat::BC6HRGBFloat, 16, 4, 4, isBCFormatSupported, 3);
         AddCompressedFormat(wgpu::TextureFormat::BC6HRGBUfloat, 16, 4, 4, isBCFormatSupported, 3);
         AddCompressedFormat(wgpu::TextureFormat::BC7RGBAUnorm, 16, 4, 4, isBCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::BC7RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::BC7RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported, 4, wgpu::TextureFormat::BC7RGBAUnorm);
 
         // ETC2/EAC compressed formats
         bool isETC2FormatSupported = device->IsFeatureEnabled(Feature::TextureCompressionETC2);
         AddCompressedFormat(wgpu::TextureFormat::ETC2RGB8Unorm, 8, 4, 4, isETC2FormatSupported, 3);
-        AddCompressedFormat(wgpu::TextureFormat::ETC2RGB8UnormSrgb, 8, 4, 4, isETC2FormatSupported, 3);
+        AddCompressedFormat(wgpu::TextureFormat::ETC2RGB8UnormSrgb, 8, 4, 4, isETC2FormatSupported, 3, wgpu::TextureFormat::ETC2RGB8Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ETC2RGB8A1Unorm, 8, 4, 4, isETC2FormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ETC2RGB8A1UnormSrgb, 8, 4, 4, isETC2FormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ETC2RGB8A1UnormSrgb, 8, 4, 4, isETC2FormatSupported, 4, wgpu::TextureFormat::ETC2RGB8A1Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ETC2RGBA8Unorm, 16, 4, 4, isETC2FormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ETC2RGBA8UnormSrgb, 16, 4, 4, isETC2FormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ETC2RGBA8UnormSrgb, 16, 4, 4, isETC2FormatSupported, 4, wgpu::TextureFormat::ETC2RGBA8Unorm);
         AddCompressedFormat(wgpu::TextureFormat::EACR11Unorm, 8, 4, 4, isETC2FormatSupported, 1);
         AddCompressedFormat(wgpu::TextureFormat::EACR11Snorm, 8, 4, 4, isETC2FormatSupported, 1);
         AddCompressedFormat(wgpu::TextureFormat::EACRG11Unorm, 16, 4, 4, isETC2FormatSupported, 2);
@@ -376,33 +427,33 @@
         // ASTC compressed formats
         bool isASTCFormatSupported = device->IsFeatureEnabled(Feature::TextureCompressionASTC);
         AddCompressedFormat(wgpu::TextureFormat::ASTC4x4Unorm, 16, 4, 4, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC4x4UnormSrgb, 16, 4, 4, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC4x4UnormSrgb, 16, 4, 4, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC4x4Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC5x4Unorm, 16, 5, 4, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC5x4UnormSrgb, 16, 5, 4, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC5x4UnormSrgb, 16, 5, 4, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC5x4Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC5x5Unorm, 16, 5, 5, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC5x5UnormSrgb, 16, 5, 5, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC5x5UnormSrgb, 16, 5, 5, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC5x5Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC6x5Unorm, 16, 6, 5, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC6x5UnormSrgb, 16, 6, 5, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC6x5UnormSrgb, 16, 6, 5, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC6x5Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC6x6Unorm, 16, 6, 6, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC6x6UnormSrgb, 16, 6, 6, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC6x6UnormSrgb, 16, 6, 6, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC6x6Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC8x5Unorm, 16, 8, 5, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC8x5UnormSrgb, 16, 8, 5, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC8x5UnormSrgb, 16, 8, 5, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC8x5Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC8x6Unorm, 16, 8, 6, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC8x6UnormSrgb, 16, 8, 6, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC8x6UnormSrgb, 16, 8, 6, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC8x6Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC8x8Unorm, 16, 8, 8, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC8x8UnormSrgb, 16, 8, 8, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC8x8UnormSrgb, 16, 8, 8, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC8x8Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC10x5Unorm, 16, 10, 5, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC10x5UnormSrgb, 16, 10, 5, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC10x5UnormSrgb, 16, 10, 5, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC10x5Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC10x6Unorm, 16, 10, 6, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC10x6UnormSrgb, 16, 10, 6, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC10x6UnormSrgb, 16, 10, 6, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC10x6Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC10x8Unorm, 16, 10, 8, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC10x8UnormSrgb, 16, 10, 8, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC10x8UnormSrgb, 16, 10, 8, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC10x8Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC10x10Unorm, 16, 10, 10, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC10x10UnormSrgb, 16, 10, 10, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC10x10UnormSrgb, 16, 10, 10, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC10x10Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC12x10Unorm, 16, 12, 10, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC12x10UnormSrgb, 16, 12, 10, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC12x10UnormSrgb, 16, 12, 10, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC12x10Unorm);
         AddCompressedFormat(wgpu::TextureFormat::ASTC12x12Unorm, 16, 12, 12, isASTCFormatSupported, 4);
-        AddCompressedFormat(wgpu::TextureFormat::ASTC12x12UnormSrgb, 16, 12, 12, isASTCFormatSupported, 4);
+        AddCompressedFormat(wgpu::TextureFormat::ASTC12x12UnormSrgb, 16, 12, 12, isASTCFormatSupported, 4, wgpu::TextureFormat::ASTC12x12Unorm);
 
         // multi-planar formats
         const bool isMultiPlanarFormatSupported = device->IsFeatureEnabled(Feature::MultiPlanarFormats);
diff --git a/src/dawn_native/Format.h b/src/dawn_native/Format.h
index 2f604d3..a0730c6 100644
--- a/src/dawn_native/Format.h
+++ b/src/dawn_native/Format.h
@@ -85,6 +85,7 @@
     // A wgpu::TextureFormat along with all the information about it necessary for validation.
     struct Format {
         wgpu::TextureFormat format;
+
         bool isRenderable;
         bool isCompressed;
         // A format can be known but not supported because it is part of a disabled extension.
@@ -110,6 +111,14 @@
         // in [0, kKnownFormatCount)
         size_t GetIndex() const;
 
+        // baseFormat represents the memory layout of the format.
+        // If two formats has the same baseFormat, they could copy to each other.
+        wgpu::TextureFormat baseFormat;
+
+        // CopyCompatibleWith() returns true if the input format has the same baseFormat
+        // with current format.
+        bool CopyCompatibleWith(const Format& format) const;
+
       private:
         // Used to store the aspectInfo for one or more planes. For single plane "color" formats,
         // only the first aspect info or aspectInfo[0] is valid. For depth-stencil, the first aspect
diff --git a/src/dawn_native/d3d12/CommandBufferD3D12.cpp b/src/dawn_native/d3d12/CommandBufferD3D12.cpp
index 5ae6149..aa83abb 100644
--- a/src/dawn_native/d3d12/CommandBufferD3D12.cpp
+++ b/src/dawn_native/d3d12/CommandBufferD3D12.cpp
@@ -64,7 +64,7 @@
                                 const Extent3D& copySize) {
             // Checked by validation
             ASSERT(src.texture->GetSampleCount() == dst.texture->GetSampleCount());
-            ASSERT(src.texture->GetFormat().format == dst.texture->GetFormat().format);
+            ASSERT(src.texture->GetFormat().CopyCompatibleWith(dst.texture->GetFormat()));
             ASSERT(src.aspect == dst.aspect);
 
             const Extent3D& srcSize = src.texture->GetSize();
@@ -168,7 +168,8 @@
                     Toggle::
                         UseTempBufferInSmallFormatTextureToTextureCopyFromGreaterToLessMipLevel)) {
                 bool copyToLesserLevel = srcCopy.mipLevel > dstCopy.mipLevel;
-                ASSERT(srcCopy.texture->GetFormat().format == dstCopy.texture->GetFormat().format);
+                ASSERT(
+                    srcCopy.texture->GetFormat().CopyCompatibleWith(dstCopy.texture->GetFormat()));
 
                 // GetAspectInfo(aspect) requires HasOneBit(aspect) == true, plus the texel block
                 // sizes of depth stencil formats are always no less than 4 bytes.
diff --git a/src/dawn_native/metal/CommandBufferMTL.mm b/src/dawn_native/metal/CommandBufferMTL.mm
index 45ff8d9..ec6296d 100644
--- a/src/dawn_native/metal/CommandBufferMTL.mm
+++ b/src/dawn_native/metal/CommandBufferMTL.mm
@@ -897,6 +897,10 @@
                         *sourceZPtr = copy->source.origin.z + z;
                         *destinationZPtr = copy->destination.origin.z + z;
 
+                        // Hold the ref until out of scope
+                        NSPRef<id<MTLTexture>> dstTextureView =
+                            dstTexture->CreateFormatView(srcTexture->GetFormat().format);
+
                         [commandContext->EnsureBlit()
                               copyFromTexture:srcTexture->GetMTLTexture()
                                   sourceSlice:sourceLayer
@@ -904,7 +908,7 @@
                                  sourceOrigin:MTLOriginMake(copy->source.origin.x,
                                                             copy->source.origin.y, sourceOriginZ)
                                    sourceSize:sizeOneSlice
-                                    toTexture:dstTexture->GetMTLTexture()
+                                    toTexture:dstTextureView.Get()
                              destinationSlice:destinationLayer
                              destinationLevel:copy->destination.mipLevel
                             destinationOrigin:MTLOriginMake(copy->destination.origin.x,
diff --git a/src/dawn_native/metal/TextureMTL.h b/src/dawn_native/metal/TextureMTL.h
index bfcf02f..8c9a30d 100644
--- a/src/dawn_native/metal/TextureMTL.h
+++ b/src/dawn_native/metal/TextureMTL.h
@@ -48,6 +48,7 @@
                                            NSPRef<id<MTLTexture>> wrapped);
 
         id<MTLTexture> GetMTLTexture();
+        NSPRef<id<MTLTexture>> CreateFormatView(wgpu::TextureFormat format);
 
         void EnsureSubresourceContentInitialized(CommandRecordingContext* commandContext,
                                                  const SubresourceRange& range);
diff --git a/src/dawn_native/metal/TextureMTL.mm b/src/dawn_native/metal/TextureMTL.mm
index 7a98886..496ca10 100644
--- a/src/dawn_native/metal/TextureMTL.mm
+++ b/src/dawn_native/metal/TextureMTL.mm
@@ -113,6 +113,49 @@
             return false;
         }
 
+        // Metal only allows format reinterpretation to happen on swizzle pattern or conversion
+        // between linear space and sRGB without setting MTLTextureUsagePixelFormatView flag. For
+        // example, creating bgra8Unorm texture view on rgba8Unorm texture or creating
+        // rgba8Unorm_srgb texture view on rgab8Unorm texture.
+        bool AllowFormatReinterpretationWithoutFlag(MTLPixelFormat origin,
+                                                    MTLPixelFormat reinterpretation) {
+            switch (origin) {
+                case MTLPixelFormatRGBA8Unorm:
+                    return reinterpretation == MTLPixelFormatBGRA8Unorm ||
+                           reinterpretation == MTLPixelFormatRGBA8Unorm_sRGB;
+                case MTLPixelFormatBGRA8Unorm:
+                    return reinterpretation == MTLPixelFormatRGBA8Unorm ||
+                           reinterpretation == MTLPixelFormatBGRA8Unorm_sRGB;
+                case MTLPixelFormatRGBA8Unorm_sRGB:
+                    return reinterpretation == MTLPixelFormatBGRA8Unorm_sRGB ||
+                           reinterpretation == MTLPixelFormatRGBA8Unorm;
+                case MTLPixelFormatBGRA8Unorm_sRGB:
+                    return reinterpretation == MTLPixelFormatRGBA8Unorm_sRGB ||
+                           reinterpretation == MTLPixelFormatBGRA8Unorm;
+#if defined(DAWN_PLATFORM_MACOS)
+                case MTLPixelFormatBC1_RGBA:
+                    return reinterpretation == MTLPixelFormatBC1_RGBA_sRGB;
+                case MTLPixelFormatBC1_RGBA_sRGB:
+                    return reinterpretation == MTLPixelFormatBC1_RGBA;
+                case MTLPixelFormatBC2_RGBA:
+                    return reinterpretation == MTLPixelFormatBC2_RGBA_sRGB;
+                case MTLPixelFormatBC2_RGBA_sRGB:
+                    return reinterpretation == MTLPixelFormatBC2_RGBA;
+                case MTLPixelFormatBC3_RGBA:
+                    return reinterpretation == MTLPixelFormatBC3_RGBA_sRGB;
+                case MTLPixelFormatBC3_RGBA_sRGB:
+                    return reinterpretation == MTLPixelFormatBC3_RGBA;
+                case MTLPixelFormatBC7_RGBAUnorm:
+                    return reinterpretation == MTLPixelFormatBC7_RGBAUnorm_sRGB;
+                case MTLPixelFormatBC7_RGBAUnorm_sRGB:
+                    return reinterpretation == MTLPixelFormatBC7_RGBAUnorm;
+#endif
+
+                default:
+                    return false;
+            }
+        }
+
         ResultOrError<wgpu::TextureFormat> GetFormatEquivalentToIOSurfaceFormat(uint32_t format) {
             switch (format) {
                 case kCVPixelFormatType_32RGBA:
@@ -382,7 +425,10 @@
         mtlDesc.width = GetWidth();
         mtlDesc.height = GetHeight();
         mtlDesc.sampleCount = GetSampleCount();
-        // TODO: add MTLTextureUsagePixelFormatView when needed when we support format
+        // Metal only allows format reinterpretation to happen on swizzle pattern or conversion
+        // between linear space and sRGB. For example, creating bgra8Unorm texture view on
+        // rgba8Unorm texture or creating rgba8Unorm_srgb texture view on rgab8Unorm texture.
+        // TODO: add MTLTextureUsagePixelFormatView when needed when we support other format
         // reinterpretation.
         mtlDesc.usage = MetalTextureUsage(GetFormat(), GetInternalUsage(), GetSampleCount());
         mtlDesc.pixelFormat = MetalPixelFormat(GetFormat().format);
@@ -509,6 +555,17 @@
         return mMtlTexture.Get();
     }
 
+    NSPRef<id<MTLTexture>> Texture::CreateFormatView(wgpu::TextureFormat format) {
+        if (GetFormat().format == format) {
+            return mMtlTexture;
+        }
+
+        ASSERT(AllowFormatReinterpretationWithoutFlag(MetalPixelFormat(GetFormat().format),
+                                                      MetalPixelFormat(format)));
+        return AcquireNSPRef(
+            [mMtlTexture.Get() newTextureViewWithPixelFormat:MetalPixelFormat(format)]);
+    }
+
     MaybeError Texture::ClearTexture(CommandRecordingContext* commandContext,
                                      const SubresourceRange& range,
                                      TextureBase::ClearValue clearValue) {
diff --git a/src/tests/end2end/CopyTests.cpp b/src/tests/end2end/CopyTests.cpp
index 1907ffd..20cacaa 100644
--- a/src/tests/end2end/CopyTests.cpp
+++ b/src/tests/end2end/CopyTests.cpp
@@ -327,9 +327,13 @@
     // CopyTextureToTextureInternal.
     using UsageCopySrc = bool;
     DAWN_TEST_PARAM_STRUCT(CopyTestsParams, UsageCopySrc);
+
+    using SrcColorFormat = wgpu::TextureFormat;
+    DAWN_TEST_PARAM_STRUCT(SrcColorFormatParams, SrcColorFormat);
 }  // namespace
 
-class CopyTests_T2T : public CopyTests, public DawnTestWithParams<CopyTestsParams> {
+template <typename Parent>
+class CopyTests_T2TBase : public CopyTests, public Parent {
   protected:
     std::vector<wgpu::FeatureName> GetRequiredFeatures() override {
         return {wgpu::FeatureName::DawnInternalUsages};
@@ -338,24 +342,10 @@
     void DoTest(const TextureSpec& srcSpec,
                 const TextureSpec& dstSpec,
                 const wgpu::Extent3D& copySize,
-                bool copyWithinSameTexture = false,
-                wgpu::TextureDimension dimension = wgpu::TextureDimension::e2D) {
-        DoTest(srcSpec, dstSpec, copySize, dimension, dimension, copyWithinSameTexture);
-    }
-
-    void DoTest(const TextureSpec& srcSpec,
-                const TextureSpec& dstSpec,
-                const wgpu::Extent3D& copySize,
                 wgpu::TextureDimension srcDimension,
                 wgpu::TextureDimension dstDimension,
-                bool copyWithinSameTexture = false) {
-        const bool usageCopySrc = GetParam().mUsageCopySrc;
-        // If we do this test with a CopyWithinSameTexture, it will need to have usageCopySrc in the
-        // public usage of the texture as it will later use a CopyTextureToBuffer, that needs the
-        // public usage of it.
-        DAWN_TEST_UNSUPPORTED_IF(!usageCopySrc && copyWithinSameTexture);
-
-        ASSERT_EQ(srcSpec.format, dstSpec.format);
+                bool copyWithinSameTexture = false,
+                bool usageCopySrc = false) {
         const wgpu::TextureFormat format = srcSpec.format;
 
         wgpu::TextureDescriptor srcDescriptor;
@@ -375,7 +365,7 @@
         } else {
             internalDesc.internalUsage = wgpu::TextureUsage::CopySrc;
         }
-        wgpu::Texture srcTexture = device.CreateTexture(&srcDescriptor);
+        wgpu::Texture srcTexture = this->device.CreateTexture(&srcDescriptor);
 
         wgpu::Texture dstTexture;
         if (copyWithinSameTexture) {
@@ -385,10 +375,10 @@
             dstDescriptor.dimension = dstDimension;
             dstDescriptor.size = dstSpec.textureSize;
             dstDescriptor.sampleCount = 1;
-            dstDescriptor.format = format;
+            dstDescriptor.format = dstSpec.format;
             dstDescriptor.mipLevelCount = dstSpec.levelCount;
             dstDescriptor.usage = wgpu::TextureUsage::CopySrc | wgpu::TextureUsage::CopyDst;
-            dstTexture = device.CreateTexture(&dstDescriptor);
+            dstTexture = this->device.CreateTexture(&dstDescriptor);
         }
 
         // Create an upload buffer and use it to completely populate the subresources of the src
@@ -409,12 +399,12 @@
                 srcTexture, srcSpec.copyLevel, {0, 0, srcSpec.copyOrigin.z});
             wgpu::TextureDataLayout textureDataLayout = utils::CreateTextureDataLayout(
                 0, srcDataCopyLayout.bytesPerRow, srcDataCopyLayout.rowsPerImage);
-            queue.WriteTexture(&imageCopyTexture, srcTextureCopyData.data(),
-                               srcDataCopyLayout.byteLength, &textureDataLayout,
-                               &srcDataCopyLayout.mipSize);
+            this->queue.WriteTexture(&imageCopyTexture, srcTextureCopyData.data(),
+                                     srcDataCopyLayout.byteLength, &textureDataLayout,
+                                     &srcDataCopyLayout.mipSize);
         }
 
-        wgpu::CommandEncoder encoder = device.CreateCommandEncoder();
+        wgpu::CommandEncoder encoder = this->device.CreateCommandEncoder();
 
         // Perform the texture to texture copy
         wgpu::ImageCopyTexture srcImageCopyTexture =
@@ -442,7 +432,7 @@
         wgpu::BufferDescriptor outputBufferDescriptor;
         outputBufferDescriptor.size = dstDataCopyLayout.byteLength;
         outputBufferDescriptor.usage = wgpu::BufferUsage::CopySrc | wgpu::BufferUsage::CopyDst;
-        wgpu::Buffer outputBuffer = device.CreateBuffer(&outputBufferDescriptor);
+        wgpu::Buffer outputBuffer = this->device.CreateBuffer(&outputBufferDescriptor);
         const uint32_t bytesPerTexel = utils::GetTexelBlockSizeInBytes(format);
         const uint32_t expectedDstDataOffset = dstSpec.copyOrigin.x * bytesPerTexel +
                                                dstSpec.copyOrigin.y * dstDataCopyLayout.bytesPerRow;
@@ -452,7 +442,7 @@
         encoder.CopyTextureToBuffer(&dstImageCopyTexture, &outputImageCopyBuffer, &copySize);
 
         wgpu::CommandBuffer commands = encoder.Finish();
-        queue.Submit(1, &commands);
+        this->queue.Submit(1, &commands);
 
         // Validate if the data in outputBuffer is what we expected, including the untouched data
         // outside of the copy.
@@ -504,6 +494,67 @@
     }
 };
 
+class CopyTests_T2T : public CopyTests_T2TBase<DawnTestWithParams<CopyTestsParams>> {
+  protected:
+    void DoTest(const TextureSpec& srcSpec,
+                const TextureSpec& dstSpec,
+                const wgpu::Extent3D& copySize,
+                bool copyWithinSameTexture = false,
+                wgpu::TextureDimension dimension = wgpu::TextureDimension::e2D) {
+        DoTest(srcSpec, dstSpec, copySize, dimension, dimension, copyWithinSameTexture);
+    }
+
+    void DoTest(const TextureSpec& srcSpec,
+                const TextureSpec& dstSpec,
+                const wgpu::Extent3D& copySize,
+                wgpu::TextureDimension srcDimension,
+                wgpu::TextureDimension dstDimension,
+                bool copyWithinSameTexture = false) {
+        const bool usageCopySrc = GetParam().mUsageCopySrc;
+        // If we do this test with a CopyWithinSameTexture, it will need to have usageCopySrc in the
+        // public usage of the texture as it will later use a CopyTextureToBuffer, that needs the
+        // public usage of it.
+        DAWN_TEST_UNSUPPORTED_IF(!usageCopySrc && copyWithinSameTexture);
+
+        ASSERT_EQ(srcSpec.format, dstSpec.format);
+
+        CopyTests_T2TBase<DawnTestWithParams<CopyTestsParams>>::DoTest(
+            srcSpec, dstSpec, copySize, srcDimension, dstDimension, copyWithinSameTexture,
+            usageCopySrc);
+    }
+};
+
+class CopyTests_Formats : public CopyTests_T2TBase<DawnTestWithParams<SrcColorFormatParams>> {
+  protected:
+    // Texture format is compatible and could be copied to each other if the only diff is srgb-ness.
+    wgpu::TextureFormat GetCopyCompatibleFormat(wgpu::TextureFormat format) {
+        switch (format) {
+            case wgpu::TextureFormat::RGBA8Unorm:
+                return wgpu::TextureFormat::RGBA8UnormSrgb;
+            case wgpu::TextureFormat::RGBA8UnormSrgb:
+                return wgpu::TextureFormat::RGBA8Unorm;
+            case wgpu::TextureFormat::BGRA8Unorm:
+                return wgpu::TextureFormat::BGRA8UnormSrgb;
+            case wgpu::TextureFormat::BGRA8UnormSrgb:
+                return wgpu::TextureFormat::BGRA8Unorm;
+            default:
+                UNREACHABLE();
+        }
+    }
+
+    void DoTest(TextureSpec srcSpec,
+                TextureSpec dstSpec,
+                const wgpu::Extent3D& copySize,
+                wgpu::TextureDimension srcDimension = wgpu::TextureDimension::e2D,
+                wgpu::TextureDimension dstDimension = wgpu::TextureDimension::e2D) {
+        srcSpec.format = GetParam().mSrcColorFormat;
+        dstSpec.format = GetCopyCompatibleFormat(srcSpec.format);
+
+        CopyTests_T2TBase<DawnTestWithParams<SrcColorFormatParams>>::DoTest(
+            srcSpec, dstSpec, copySize, srcDimension, dstDimension);
+    }
+};
+
 class CopyTests_B2B : public DawnTest {
   protected:
     // This is the same signature as CopyBufferToBuffer except that the buffers are replaced by
@@ -2409,6 +2460,27 @@
                          MetalBackend(), OpenGLBackend(), OpenGLESBackend(), VulkanBackend()},
                         {true, false});
 
+// Test copying between textures that have srgb compatible texture formats;
+TEST_P(CopyTests_Formats, SrgbCompatibility) {
+    // Skip backends because which fails to support *-srgb formats
+    // and bgra* formats.
+    DAWN_SUPPRESS_TEST_IF(IsOpenGLES());
+    DAWN_SUPPRESS_TEST_IF(IsOpenGL() && IsLinux());
+
+    constexpr uint32_t kWidth = 256;
+    constexpr uint32_t kHeight = 128;
+
+    TextureSpec textureSpec;
+    textureSpec.textureSize = {kWidth, kHeight, 1};
+    DoTest(textureSpec, textureSpec, {kWidth, kHeight, 1});
+}
+
+DAWN_INSTANTIATE_TEST_P(CopyTests_Formats,
+                        {D3D12Backend(), MetalBackend(), OpenGLBackend(), OpenGLESBackend(),
+                         VulkanBackend()},
+                        {wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureFormat::RGBA8UnormSrgb,
+                         wgpu::TextureFormat::BGRA8Unorm, wgpu::TextureFormat::BGRA8UnormSrgb});
+
 static constexpr uint64_t kSmallBufferSize = 4;
 static constexpr uint64_t kLargeBufferSize = 1 << 16;
 
diff --git a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
index 7f57c7d..28d05e0 100644
--- a/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
+++ b/src/tests/unittests/validation/CopyCommandsValidationTests.cpp
@@ -1646,6 +1646,21 @@
         descriptor.requiredFeaturesCount = 2;
         return adapter.CreateDevice(&descriptor);
     }
+
+    wgpu::TextureFormat GetCopyCompatibleFormat(wgpu::TextureFormat format) {
+        switch (format) {
+            case wgpu::TextureFormat::BGRA8Unorm:
+                return wgpu::TextureFormat::BGRA8UnormSrgb;
+            case wgpu::TextureFormat::BGRA8UnormSrgb:
+                return wgpu::TextureFormat::BGRA8Unorm;
+            case wgpu::TextureFormat::RGBA8Unorm:
+                return wgpu::TextureFormat::RGBA8UnormSrgb;
+            case wgpu::TextureFormat::RGBA8UnormSrgb:
+                return wgpu::TextureFormat::RGBA8Unorm;
+            default:
+                UNREACHABLE();
+        }
+    }
 };
 
 TEST_F(CopyCommandTest_T2T, Success) {
@@ -1892,6 +1907,23 @@
                 {0, 0, 1});
 }
 
+// Test copying between textures that have srgb compatible texture formats;
+TEST_F(CopyCommandTest_T2T, SrgbFormatsCompatibility) {
+    for (wgpu::TextureFormat srcTextureFormat :
+         {wgpu::TextureFormat::BGRA8Unorm, wgpu::TextureFormat::BGRA8UnormSrgb,
+          wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureFormat::RGBA8UnormSrgb}) {
+        wgpu::TextureFormat dstTextureFormat = GetCopyCompatibleFormat(srcTextureFormat);
+        wgpu::Texture source =
+            Create2DTexture(16, 16, 5, 2, srcTextureFormat, wgpu::TextureUsage::CopySrc);
+        wgpu::Texture destination =
+            Create2DTexture(16, 16, 5, 2, dstTextureFormat, wgpu::TextureUsage::CopyDst);
+
+        // Failure when formats don't match
+        TestT2TCopy(utils::Expectation::Success, source, 0, {0, 0, 0}, destination, 0, {0, 0, 0},
+                    {0, 0, 1});
+    }
+}
+
 TEST_F(CopyCommandTest_T2T, MultisampledCopies) {
     wgpu::Texture sourceMultiSampled1x = Create2DTexture(
         16, 16, 1, 1, wgpu::TextureFormat::RGBA8Unorm, wgpu::TextureUsage::CopySrc, 1);
@@ -2112,6 +2144,97 @@
         uint32_t height = utils::GetTextureFormatBlockHeight(format) * 4;
         return Create2DTexture(format, 1, width, height);
     }
+
+    wgpu::TextureFormat GetCopyCompatibleFormat(wgpu::TextureFormat format) {
+        switch (format) {
+            case wgpu::TextureFormat::BC1RGBAUnorm:
+                return wgpu::TextureFormat::BC1RGBAUnormSrgb;
+            case wgpu::TextureFormat::BC1RGBAUnormSrgb:
+                return wgpu::TextureFormat::BC1RGBAUnorm;
+            case wgpu::TextureFormat::BC2RGBAUnorm:
+                return wgpu::TextureFormat::BC2RGBAUnormSrgb;
+            case wgpu::TextureFormat::BC2RGBAUnormSrgb:
+                return wgpu::TextureFormat::BC2RGBAUnorm;
+            case wgpu::TextureFormat::BC3RGBAUnorm:
+                return wgpu::TextureFormat::BC3RGBAUnormSrgb;
+            case wgpu::TextureFormat::BC3RGBAUnormSrgb:
+                return wgpu::TextureFormat::BC3RGBAUnorm;
+            case wgpu::TextureFormat::BC7RGBAUnorm:
+                return wgpu::TextureFormat::BC7RGBAUnormSrgb;
+            case wgpu::TextureFormat::BC7RGBAUnormSrgb:
+                return wgpu::TextureFormat::BC7RGBAUnorm;
+            case wgpu::TextureFormat::ETC2RGB8Unorm:
+                return wgpu::TextureFormat::ETC2RGB8UnormSrgb;
+            case wgpu::TextureFormat::ETC2RGB8UnormSrgb:
+                return wgpu::TextureFormat::ETC2RGB8Unorm;
+            case wgpu::TextureFormat::ETC2RGB8A1Unorm:
+                return wgpu::TextureFormat::ETC2RGB8A1UnormSrgb;
+            case wgpu::TextureFormat::ETC2RGB8A1UnormSrgb:
+                return wgpu::TextureFormat::ETC2RGB8A1Unorm;
+            case wgpu::TextureFormat::ETC2RGBA8Unorm:
+                return wgpu::TextureFormat::ETC2RGBA8UnormSrgb;
+            case wgpu::TextureFormat::ETC2RGBA8UnormSrgb:
+                return wgpu::TextureFormat::ETC2RGBA8Unorm;
+            case wgpu::TextureFormat::ASTC4x4Unorm:
+                return wgpu::TextureFormat::ASTC4x4UnormSrgb;
+            case wgpu::TextureFormat::ASTC4x4UnormSrgb:
+                return wgpu::TextureFormat::ASTC4x4Unorm;
+            case wgpu::TextureFormat::ASTC5x4Unorm:
+                return wgpu::TextureFormat::ASTC5x4UnormSrgb;
+            case wgpu::TextureFormat::ASTC5x4UnormSrgb:
+                return wgpu::TextureFormat::ASTC5x4Unorm;
+            case wgpu::TextureFormat::ASTC5x5Unorm:
+                return wgpu::TextureFormat::ASTC5x5UnormSrgb;
+            case wgpu::TextureFormat::ASTC5x5UnormSrgb:
+                return wgpu::TextureFormat::ASTC5x5Unorm;
+            case wgpu::TextureFormat::ASTC6x5Unorm:
+                return wgpu::TextureFormat::ASTC6x5UnormSrgb;
+            case wgpu::TextureFormat::ASTC6x5UnormSrgb:
+                return wgpu::TextureFormat::ASTC6x5Unorm;
+            case wgpu::TextureFormat::ASTC6x6Unorm:
+                return wgpu::TextureFormat::ASTC6x6UnormSrgb;
+            case wgpu::TextureFormat::ASTC6x6UnormSrgb:
+                return wgpu::TextureFormat::ASTC6x6Unorm;
+            case wgpu::TextureFormat::ASTC8x5Unorm:
+                return wgpu::TextureFormat::ASTC8x5UnormSrgb;
+            case wgpu::TextureFormat::ASTC8x5UnormSrgb:
+                return wgpu::TextureFormat::ASTC8x5Unorm;
+            case wgpu::TextureFormat::ASTC8x6Unorm:
+                return wgpu::TextureFormat::ASTC8x6UnormSrgb;
+            case wgpu::TextureFormat::ASTC8x6UnormSrgb:
+                return wgpu::TextureFormat::ASTC8x6Unorm;
+            case wgpu::TextureFormat::ASTC8x8Unorm:
+                return wgpu::TextureFormat::ASTC8x8UnormSrgb;
+            case wgpu::TextureFormat::ASTC8x8UnormSrgb:
+                return wgpu::TextureFormat::ASTC8x8Unorm;
+            case wgpu::TextureFormat::ASTC10x5Unorm:
+                return wgpu::TextureFormat::ASTC10x5UnormSrgb;
+            case wgpu::TextureFormat::ASTC10x5UnormSrgb:
+                return wgpu::TextureFormat::ASTC10x5Unorm;
+            case wgpu::TextureFormat::ASTC10x6Unorm:
+                return wgpu::TextureFormat::ASTC10x6UnormSrgb;
+            case wgpu::TextureFormat::ASTC10x6UnormSrgb:
+                return wgpu::TextureFormat::ASTC10x6Unorm;
+            case wgpu::TextureFormat::ASTC10x8Unorm:
+                return wgpu::TextureFormat::ASTC10x8UnormSrgb;
+            case wgpu::TextureFormat::ASTC10x8UnormSrgb:
+                return wgpu::TextureFormat::ASTC10x8Unorm;
+            case wgpu::TextureFormat::ASTC10x10Unorm:
+                return wgpu::TextureFormat::ASTC10x10UnormSrgb;
+            case wgpu::TextureFormat::ASTC10x10UnormSrgb:
+                return wgpu::TextureFormat::ASTC10x10Unorm;
+            case wgpu::TextureFormat::ASTC12x10Unorm:
+                return wgpu::TextureFormat::ASTC12x10UnormSrgb;
+            case wgpu::TextureFormat::ASTC12x10UnormSrgb:
+                return wgpu::TextureFormat::ASTC12x10Unorm;
+            case wgpu::TextureFormat::ASTC12x12Unorm:
+                return wgpu::TextureFormat::ASTC12x12UnormSrgb;
+            case wgpu::TextureFormat::ASTC12x12UnormSrgb:
+                return wgpu::TextureFormat::ASTC12x12Unorm;
+            default:
+                UNREACHABLE();
+        }
+    }
 };
 
 // Tests to verify that bufferOffset must be a multiple of the compressed texture blocks in bytes
@@ -2358,6 +2481,48 @@
     }
 }
 
+// Test copying between textures that have srgb compatible texture formats;
+TEST_F(CopyCommandTest_CompressedTextureFormats, SrgbFormatCompatibility) {
+    constexpr std::array<wgpu::TextureFormat, 42> srcFormats = {
+        wgpu::TextureFormat::BC1RGBAUnorm,    wgpu::TextureFormat::BC1RGBAUnormSrgb,
+        wgpu::TextureFormat::BC2RGBAUnorm,    wgpu::TextureFormat::BC2RGBAUnormSrgb,
+        wgpu::TextureFormat::BC3RGBAUnorm,    wgpu::TextureFormat::BC3RGBAUnormSrgb,
+        wgpu::TextureFormat::BC7RGBAUnorm,    wgpu::TextureFormat::BC7RGBAUnormSrgb,
+        wgpu::TextureFormat::ETC2RGB8Unorm,   wgpu::TextureFormat::ETC2RGB8UnormSrgb,
+        wgpu::TextureFormat::ETC2RGB8A1Unorm, wgpu::TextureFormat::ETC2RGB8A1UnormSrgb,
+        wgpu::TextureFormat::ETC2RGBA8Unorm,  wgpu::TextureFormat::ETC2RGBA8UnormSrgb,
+        wgpu::TextureFormat::ASTC4x4Unorm,    wgpu::TextureFormat::ASTC4x4UnormSrgb,
+        wgpu::TextureFormat::ASTC5x4Unorm,    wgpu::TextureFormat::ASTC5x4UnormSrgb,
+        wgpu::TextureFormat::ASTC5x5Unorm,    wgpu::TextureFormat::ASTC5x5UnormSrgb,
+        wgpu::TextureFormat::ASTC6x5Unorm,    wgpu::TextureFormat::ASTC6x5UnormSrgb,
+        wgpu::TextureFormat::ASTC6x6Unorm,    wgpu::TextureFormat::ASTC6x6UnormSrgb,
+        wgpu::TextureFormat::ASTC8x5Unorm,    wgpu::TextureFormat::ASTC8x5UnormSrgb,
+        wgpu::TextureFormat::ASTC8x6Unorm,    wgpu::TextureFormat::ASTC8x6UnormSrgb,
+        wgpu::TextureFormat::ASTC8x8Unorm,    wgpu::TextureFormat::ASTC8x8UnormSrgb,
+        wgpu::TextureFormat::ASTC10x5Unorm,   wgpu::TextureFormat::ASTC10x5UnormSrgb,
+        wgpu::TextureFormat::ASTC10x6Unorm,   wgpu::TextureFormat::ASTC10x6UnormSrgb,
+        wgpu::TextureFormat::ASTC10x8Unorm,   wgpu::TextureFormat::ASTC10x8UnormSrgb,
+        wgpu::TextureFormat::ASTC10x10Unorm,  wgpu::TextureFormat::ASTC10x10UnormSrgb,
+        wgpu::TextureFormat::ASTC12x10Unorm,  wgpu::TextureFormat::ASTC12x10UnormSrgb,
+        wgpu::TextureFormat::ASTC12x12Unorm,  wgpu::TextureFormat::ASTC12x12UnormSrgb};
+
+    constexpr uint32_t kBlockPerDim = 2;
+    constexpr uint32_t kMipmapLevels = 1;
+    for (wgpu::TextureFormat srcFormat : srcFormats) {
+        uint32_t blockWidth = utils::GetTextureFormatBlockWidth(srcFormat);
+        uint32_t blockHeight = utils::GetTextureFormatBlockHeight(srcFormat);
+        uint32_t testWidth = blockWidth * kBlockPerDim;
+        uint32_t testHeight = blockHeight * kBlockPerDim;
+        wgpu::Texture texture = Create2DTexture(srcFormat, kMipmapLevels, testWidth, testHeight);
+        wgpu::Texture texture2 = Create2DTexture(GetCopyCompatibleFormat(srcFormat), kMipmapLevels,
+                                                 testWidth, testHeight);
+        wgpu::Extent3D extent3D = {testWidth, testHeight, 1};
+
+        TestBothT2TCopies(utils::Expectation::Success, texture, 0, {0, 0, 0}, texture2, 0,
+                          {0, 0, 0}, extent3D);
+    }
+}
+
 class CopyCommandTest_ClearBuffer : public CopyCommandTest {};
 
 TEST_F(CopyCommandTest_ClearBuffer, Success) {