diff --git a/layers/image.cpp b/layers/image.cpp
index a49ded8..e03a195 100644
--- a/layers/image.cpp
+++ b/layers/image.cpp
@@ -60,7 +60,7 @@
 };
 
 static unordered_map<void*, layer_data*> layer_data_map;
-static device_table_map image_device_table_map;
+static device_table_map   image_device_table_map;
 static instance_table_map image_instance_table_map;
 
 // "my device data"
@@ -218,7 +218,7 @@
         uint32_t *pCount,
         VkExtensionProperties* pProperties)
 {
-    /* ParamChecker does not have any global extensions */
+    // ParamChecker does not have any global extensions
     return util_GetExtensionProperties(0, NULL, pCount, pProperties);
 }
 
@@ -237,7 +237,7 @@
         uint32_t*                                   pCount,
         VkExtensionProperties*                      pProperties)
 {
-    /* ParamChecker does not have any physical device extensions */
+    // ParamChecker does not have any physical device extensions
     return util_GetExtensionProperties(0, NULL, pCount, pProperties);
 }
 
@@ -246,7 +246,7 @@
         uint32_t*                                   pCount,
         VkLayerProperties*                          pProperties)
 {
-    /* ParamChecker's physical device layers are the same as global */
+    // ParamChecker's physical device layers are the same as global
     return util_GetLayerProperties(ARRAY_SIZE(pc_global_layers), pc_global_layers,
                                    pCount, pProperties);
 }
@@ -392,12 +392,14 @@
     if (imageEntry != device_data->imageMap.end()) {
         if (pCreateInfo->subresourceRange.baseMipLevel >= imageEntry->second->mipLevels) {
             std::stringstream ss;
-            ss << "vkCreateImageView called with baseMipLevel " << pCreateInfo->subresourceRange.baseMipLevel << " for image " << pCreateInfo->image.handle << " that only has " << imageEntry->second->mipLevels << " mip levels.";
+            ss << "vkCreateImageView called with baseMipLevel " << pCreateInfo->subresourceRange.baseMipLevel
+               << " for image " << pCreateInfo->image.handle << " that only has " << imageEntry->second->mipLevels << " mip levels.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
         }
         if (pCreateInfo->subresourceRange.baseArrayLayer >= imageEntry->second->arraySize) {
             std::stringstream ss;
-            ss << "vkCreateImageView called with baseArrayLayer " << pCreateInfo->subresourceRange.baseArrayLayer << " for image " << pCreateInfo->image.handle << " that only has " << imageEntry->second->arraySize << " mip levels.";
+            ss << "vkCreateImageView called with baseArrayLayer " << pCreateInfo->subresourceRange.baseArrayLayer << " for image "
+               << pCreateInfo->image.handle << " that only has " << imageEntry->second->arraySize << " mip levels.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
         }
         if (!pCreateInfo->subresourceRange.numLevels) {
@@ -410,12 +412,77 @@
             ss << "vkCreateImageView called with 0 in pCreateInfo->subresourceRange.arraySize.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, (VkDbgObjectType)0, 0, 0, IMAGE_VIEW_CREATE_ERROR, "IMAGE", ss.str().c_str());
         }
-    }
 
-    // TODO: Image aspect mask must be only VK_IMAGE_ASPECT_COLOR_BIT, VK_IMAGE_ASPECT_DEPTH_BIT or VK_IMAGE_ASPECT_STENCIL_BIT
-    //       if the format is a color, depth-only or stencil-only format respectively. If using a depth/stencil format,
-    //       aspectMask must include at least one of VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT, and may include both.
-    //       Add after image/buffer state tracking is implemented.
+        // Validate correct image aspect bits for desired formats and format consistency
+        VkFormat           imageFormat = imageEntry->second->format;
+        VkFormat           ivciFormat  = pCreateInfo->format;
+        VkImageAspectFlags aspectMask  = pCreateInfo->subresourceRange.aspectMask;
+
+        if (vk_format_is_color(imageFormat)) {
+            if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != VK_IMAGE_ASPECT_COLOR_BIT) {
+                std::stringstream ss;
+                ss << "vkCreateImageView: Color image formats must have the VK_IMAGE_ASPECT_COLOR_BIT set";
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
+                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+            }
+            if ((aspectMask & VK_IMAGE_ASPECT_COLOR_BIT) != aspectMask) {
+                std::stringstream ss;
+                ss << "vkCreateImageView: Color image formats must have ONLY the VK_IMAGE_ASPECT_COLOR_BIT set";
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
+                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+            }
+            if (VK_FALSE == vk_format_is_color(ivciFormat)) {
+                std::stringstream ss;
+                ss << "vkCreateImageView: The image view's format can differ from the parent image's format, but both must be "
+                   << "color formats.  ImageFormat is " << string_VkFormat(imageFormat) << " ImageViewFormat is " << string_VkFormat(ivciFormat);
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
+                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
+            }
+            // TODO:  Uncompressed formats are compatible if they occupy they same number of bits per pixel.
+            //        Compressed formats are compatible if the only difference between them is the numerical type of
+            //        the uncompressed pixels (e.g. signed vs. unsigned, or sRGB vs. UNORM encoding).
+        } else  if (vk_format_is_depth_and_stencil(imageFormat)) {
+            if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) !=
+                              (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
+                std::stringstream ss;
+                ss << "vkCreateImageView: Combination depth/stencil image formats must have both VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set";
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
+                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+            }
+            if ((aspectMask & (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) != aspectMask) {
+                std::stringstream ss;
+                ss << "vkCreateImageView: Combination depth/stencil image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT and VK_IMAGE_ASPECT_STENCIL_BIT set";
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
+                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+            }
+        } else  if (vk_format_is_depth_only(imageFormat)) {
+            if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != VK_IMAGE_ASPECT_DEPTH_BIT) {
+                std::stringstream ss;
+                ss << "vkCreateImageView: Depth-only image formats must have the VK_IMAGE_ASPECT_DEPTH_BIT set";
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
+                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+            }
+            if ((aspectMask & VK_IMAGE_ASPECT_DEPTH_BIT) != aspectMask) {
+                std::stringstream ss;
+                ss << "vkCreateImageView: Depth-only image formats can have only the VK_IMAGE_ASPECT_DEPTH_BIT set";
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
+                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+            }
+        } else  if (vk_format_is_stencil_only(imageFormat)) {
+            if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != VK_IMAGE_ASPECT_STENCIL_BIT) {
+                std::stringstream ss;
+                ss << "vkCreateImageView: Stencil-only image formats must have the VK_IMAGE_ASPECT_STENCIL_BIT set";
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
+                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+            }
+            if ((aspectMask & VK_IMAGE_ASPECT_STENCIL_BIT) != aspectMask) {
+                std::stringstream ss;
+                ss << "vkCreateImageView: Stencil-only image formats can have only the VK_IMAGE_ASPECT_STENCIL_BIT set";
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
+                                   (uint64_t)pCreateInfo->image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+            }
+        }
+    }
 
     if (skipCall)
         return VK_ERROR_VALIDATION_FAILED;
@@ -608,7 +675,6 @@
     }
 }
 
-
 VK_LAYER_EXPORT void VKAPI vkCmdCopyBufferToImage(
     VkCmdBuffer              cmdBuffer,
     VkBuffer                 srcBuffer,
@@ -648,13 +714,91 @@
     const VkImageBlit *pRegions,
     VkTexFilter        filter)
 {
-    // TODO: From the spec -- these validation items will require the image layer to maintain image/buffer state.
-    //       If one of srcImage and destImage images has signed integer format, the other one must also have be signed integer format.
-    //       If one of srcImage and destImage images has unsigned integer format, the other one must also have be an unsigned integer format.
-    //       If the format of srcImage is a depth, stencil, depth stencil or integer-based format then filter must be VK_TEX_FILTER_NEAREST.
-    //       If one of srcImage and destImage images has a format of depth, stencil or depth stencil, the other one must have exactly the same format.
-    //           Additionally the allowed aspect bits in srcSubresource and destSubresource are only VK_IMAGE_ASPECT_DEPTH_BIT and
-    //           VK_IMAGE_ASPECT_STENCIL_BIT and the given aspect must exist in the format of both srcImage and destImage images.
+    VkBool32    skipCall    = VK_FALSE;
+    layer_data *device_data = get_my_data_ptr(get_dispatch_key(cmdBuffer), layer_data_map);
+
+    auto srcImageEntry  = device_data->imageMap.find(srcImage.handle);
+    auto destImageEntry = device_data->imageMap.find(destImage.handle);
+
+    if ((srcImageEntry  != device_data->imageMap.end()) &&
+        (destImageEntry != device_data->imageMap.end())) {
+
+        VkFormat srcFormat = srcImageEntry->second->format;
+        VkFormat dstFormat = destImageEntry->second->format;
+
+        // Validate consistency for signed and unsigned formats
+        if ((vk_format_is_sint(srcFormat) && !vk_format_is_sint(dstFormat)) ||
+            (vk_format_is_uint(srcFormat) && !vk_format_is_uint(dstFormat))) {
+            std::stringstream ss;
+            ss << "vkCmdBlitImage: If one of srcImage and destImage images has signed/unsigned integer format, "
+               << "the other one must also have signed/unsigned integer format.  "
+               << "Source format is " << string_VkFormat(srcFormat) << " Destinatino format is " << string_VkFormat(dstFormat);
+            skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
+                               (uint64_t)cmdBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
+        }
+
+        // Validate aspect bits and formats for depth/stencil images
+        if (vk_format_is_depth_or_stencil(srcFormat) ||
+            vk_format_is_depth_or_stencil(dstFormat)) {
+            if (srcFormat != dstFormat) {
+                std::stringstream ss;
+                ss << "vkCmdBlitImage: If one of srcImage and destImage images has a format of depth, stencil or depth "
+                   << "stencil, the other one must have exactly the same format.  "
+                   << "Source format is " << string_VkFormat(srcFormat) << " Destinatino format is " << string_VkFormat(dstFormat);
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
+                                   (uint64_t)cmdBuffer, 0, IMAGE_INVALID_FORMAT, "IMAGE", ss.str().c_str());
+            }
+
+            for (uint32_t i = 0; i < regionCount; i++) {
+                VkImageAspectFlags srcAspect = pRegions[i].srcSubresource.aspect;
+                VkImageAspectFlags dstAspect = pRegions[i].destSubresource.aspect;
+
+                if (srcAspect != dstAspect) {
+                    std::stringstream ss;
+                    ss << "vkCmdBlitImage: Image aspects of depth/stencil images should match";
+                    skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_WARN_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
+                                       (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                }
+                if (vk_format_is_depth_and_stencil(srcFormat)) {
+                    if (srcAspect != (VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT)) {
+                        std::stringstream ss;
+                        ss << "vkCmdBlitImage: Combination depth/stencil image formats must have both VK_IMAGE_ASPECT_DEPTH_BIT "
+                           << "and VK_IMAGE_ASPECT_STENCIL_BIT set in both the srcImage and destImage";
+                        skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
+                                           (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                    }
+                } else if (vk_format_is_stencil_only(srcFormat)) {
+                    if (srcAspect != VK_IMAGE_ASPECT_STENCIL_BIT) {
+                        std::stringstream ss;
+                        ss << "vkCmdBlitImage: Stencil-only image formats must have only the VK_IMAGE_ASPECT_STENCIL_BIT "
+                           << "set in both the srcImage and destImage";
+                        skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
+                                           (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                    }
+                } else if (vk_format_is_depth_only(srcFormat)) {
+                    if (srcAspect != VK_IMAGE_ASPECT_DEPTH_BIT) {
+                        std::stringstream ss;
+                        ss << "vkCmdBlitImage: Depth-only image formats must have only the VK_IMAGE_ASPECT_DEPTH "
+                           << "set in both the srcImage and destImage";
+                        skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
+                                           (uint64_t)cmdBuffer, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+                    }
+                }
+            }
+        }
+
+        // Validate filter
+        if (vk_format_is_depth_or_stencil(srcFormat) ||
+            vk_format_is_int(srcFormat)) {
+            if (filter != VK_TEX_FILTER_NEAREST) {
+                std::stringstream ss;
+                ss << "vkCmdBlitImage: If the format of srcImage is a depth, stencil, depth stencil or integer-based format "
+                   << "then filter must be VK_TEX_FILTER_NEAREST.";
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
+                                   (uint64_t)cmdBuffer, 0, IMAGE_INVALID_FILTER, "IMAGE", ss.str().c_str());
+            }
+        }
+    }
 
     get_dispatch_table(image_device_table_map, cmdBuffer)->CmdBlitImage(cmdBuffer, srcImage,
         srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
@@ -684,8 +828,8 @@
         }
     }
 
-    if ((srcImageEntry != device_data->imageMap.end())
-    && (destImageEntry != device_data->imageMap.end())) {
+    if ((srcImageEntry  != device_data->imageMap.end()) &&
+        (destImageEntry != device_data->imageMap.end())) {
         if (srcImageEntry->second->format != destImageEntry->second->format) {
             char const str[] =  "vkCmdResolveImage called with unmatched source and dest formats.";
             skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_COMMAND_BUFFER,
@@ -720,11 +864,38 @@
     const VkImageSubresource *pSubresource,
     VkSubresourceLayout      *pLayout)
 {
-    get_dispatch_table(image_device_table_map, device)->GetImageSubresourceLayout(device,
-         image, pSubresource, pLayout);
+    VkBool32    skipCall    = VK_FALSE;
+    layer_data *device_data = get_my_data_ptr(get_dispatch_key(device), layer_data_map);
+    VkFormat    format;
 
-    // TODO: After state tracking for images/buffers is implemented, validate that returned aspects match
-    //       the created formats -- color for color formats, depth|stencil for ds formats
+    auto imageEntry = device_data->imageMap.find(image.handle);
+
+    // Validate that image aspects match formats
+    if (imageEntry != device_data->imageMap.end()) {
+        format = imageEntry->second->format;
+        if (vk_format_is_color(format)) {
+            if (pSubresource->aspect != VK_IMAGE_ASPECT_COLOR_BIT) {
+                std::stringstream ss;
+                ss << "vkGetImageSubresourceLayout: For color formats, the aspect field of VkImageSubresource must be VK_IMAGE_ASPECT_COLOR.";
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
+                                   (uint64_t)image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+            }
+        } else if (vk_format_is_depth_or_stencil(format)) {
+            if ((pSubresource->aspect != VK_IMAGE_ASPECT_DEPTH_BIT) &&
+                (pSubresource->aspect != VK_IMAGE_ASPECT_STENCIL_BIT)) {
+                std::stringstream ss;
+                ss << "vkGetImageSubresourceLayout: For depth/stencil formats, the aspect selects either the depth or stencil image aspect.";
+                skipCall |= log_msg(device_data->report_data, VK_DBG_REPORT_ERROR_BIT, VK_OBJECT_TYPE_IMAGE,
+                                   (uint64_t)image.handle, 0, IMAGE_INVALID_IMAGE_ASPECT, "IMAGE", ss.str().c_str());
+            }
+        }
+    }
+
+    if (VK_FALSE == skipCall) {
+        get_dispatch_table(image_device_table_map, device)->GetImageSubresourceLayout(device,
+                           image, pSubresource, pLayout);
+    }
+
 }
 
 VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI vkGetDeviceProcAddr(VkDevice device, const char* funcName)
@@ -733,7 +904,7 @@
         return NULL;
     }
 
-    /* loader uses this to force layer initialization; device object is wrapped */
+    // loader uses this to force layer initialization; device object is wrapped
     if (!strcmp(funcName, "vkGetDeviceProcAddr")) {
         initDeviceTable(image_device_table_map, (const VkBaseLayerObject *) device);
         return (PFN_vkVoidFunction) vkGetDeviceProcAddr;
@@ -780,7 +951,7 @@
         return NULL;
     }
 
-    /* loader uses this to force layer initialization; instance object is wrapped */
+    // loader uses this to force layer initialization; instance object is wrapped
     if (!strcmp(funcName, "vkGetInstanceProcAddr")) {
         initInstanceTable(image_instance_table_map, (const VkBaseLayerObject *) instance);
         return (PFN_vkVoidFunction) vkGetInstanceProcAddr;
diff --git a/layers/image.h b/layers/image.h
index cce4b9c..1392d51 100644
--- a/layers/image.h
+++ b/layers/image.h
@@ -40,22 +40,26 @@
     IMAGE_MISMATCHED_IMAGE_TYPE,            // Image types for source and dest images do not match
     IMAGE_MISMATCHED_IMAGE_FORMAT,          // Image formats for source and dest images do not match
     IMAGE_INVALID_RESOLVE_SAMPLES,          // Image resolve source samples less than two or dest samples greater than one
+    IMAGE_INVALID_FORMAT,                   // Operation specifies an invalid format, or there is a format mismatch
+    IMAGE_INVALID_FILTER,                   // Operation specifies an invalid filter setting
 } IMAGE_ERROR;
 
 typedef struct _IMAGE_STATE
 {
-    uint32_t mipLevels;
-    uint32_t arraySize;
-    VkFormat format;
-    uint32_t samples;
+    uint32_t    mipLevels;
+    uint32_t    arraySize;
+    VkFormat    format;
+    uint32_t    samples;
     VkImageType imageType;
-    _IMAGE_STATE():mipLevels(0), arraySize(0), format(VK_FORMAT_UNDEFINED), samples(0), imageType(VK_IMAGE_TYPE_NUM) {};
+    VkExtent3D  extent;
+    _IMAGE_STATE():mipLevels(0), arraySize(0), format(VK_FORMAT_UNDEFINED), samples(0), imageType(VK_IMAGE_TYPE_NUM), extent{0} {};
     _IMAGE_STATE(const VkImageCreateInfo* pCreateInfo):
         mipLevels(pCreateInfo->mipLevels),
         arraySize(pCreateInfo->arrayLayers),
         format(pCreateInfo->format),
         samples(pCreateInfo->samples),
-        imageType(pCreateInfo->imageType)
+        imageType(pCreateInfo->imageType),
+        extent(pCreateInfo->extent)
         {};
 } IMAGE_STATE;
 
diff --git a/layers/vk_layer_utils.cpp b/layers/vk_layer_utils.cpp
index c4d10f6..b0a483a 100644
--- a/layers/vk_layer_utils.cpp
+++ b/layers/vk_layer_utils.cpp
@@ -210,16 +210,20 @@
     { 4, 4 },  //    [VK_FORMAT_B10G10R10A2_SINT]
 };
 
-// Return true if format is a depth-stencil format
-bool vk_format_is_ds(VkFormat format)
+// Return true if format is a depth or stencil format
+bool vk_format_is_depth_or_stencil(VkFormat format)
+{
+    return (vk_format_is_depth_and_stencil(format) ||
+            vk_format_is_depth_only(format)        ||
+            vk_format_is_stencil_only(format));
+}
+
+// Return true if format contains depth and stencil information
+bool vk_format_is_depth_and_stencil(VkFormat format)
 {
     bool is_ds = false;
 
     switch (format) {
-    case VK_FORMAT_D16_UNORM:
-    case VK_FORMAT_D24_UNORM_X8:
-    case VK_FORMAT_D32_SFLOAT:
-    case VK_FORMAT_S8_UINT:
     case VK_FORMAT_D16_UNORM_S8_UINT:
     case VK_FORMAT_D24_UNORM_S8_UINT:
     case VK_FORMAT_D32_SFLOAT_S8_UINT:
@@ -228,10 +232,33 @@
     default:
         break;
     }
-
     return is_ds;
 }
 
+// Return true if format is a stencil-only format
+bool vk_format_is_stencil_only(VkFormat format)
+{
+    return (format == VK_FORMAT_S8_UINT);
+}
+
+// Return true if format is a depth-only format
+bool vk_format_is_depth_only(VkFormat format)
+{
+    bool is_depth = false;
+
+    switch (format) {
+    case VK_FORMAT_D16_UNORM:
+    case VK_FORMAT_D24_UNORM_X8:
+    case VK_FORMAT_D32_SFLOAT:
+        is_depth = true;
+        break;
+    default:
+        break;
+    }
+
+    return is_depth;
+}
+
 // Return true if format is of time UNORM
 bool vk_format_is_norm(VkFormat format)
 {
@@ -305,51 +332,73 @@
     return is_norm;
 };
 
+
 // Return true if format is an integer format
 bool vk_format_is_int(VkFormat format)
 {
-    bool is_int = false;
+    return (vk_format_is_sint(format) || vk_format_is_uint(format));
+}
+
+// Return true if format is an unsigned integer format
+bool vk_format_is_uint(VkFormat format)
+{
+    bool is_uint = false;
 
     switch (format) {
     case VK_FORMAT_R8_UINT:
-    case VK_FORMAT_R8_SINT:
     case VK_FORMAT_R8G8_UINT:
-    case VK_FORMAT_R8G8_SINT:
     case VK_FORMAT_R8G8B8_UINT:
-    case VK_FORMAT_R8G8B8_SINT:
     case VK_FORMAT_R8G8B8A8_UINT:
-    case VK_FORMAT_R8G8B8A8_SINT:
     case VK_FORMAT_R10G10B10A2_UINT:
-    case VK_FORMAT_R10G10B10A2_SINT:
     case VK_FORMAT_R16_UINT:
-    case VK_FORMAT_R16_SINT:
     case VK_FORMAT_R16G16_UINT:
-    case VK_FORMAT_R16G16_SINT:
     case VK_FORMAT_R16G16B16_UINT:
-    case VK_FORMAT_R16G16B16_SINT:
     case VK_FORMAT_R16G16B16A16_UINT:
-    case VK_FORMAT_R16G16B16A16_SINT:
     case VK_FORMAT_R32_UINT:
-    case VK_FORMAT_R32_SINT:
     case VK_FORMAT_R32G32_UINT:
-    case VK_FORMAT_R32G32_SINT:
     case VK_FORMAT_R32G32B32_UINT:
-    case VK_FORMAT_R32G32B32_SINT:
     case VK_FORMAT_R32G32B32A32_UINT:
-    case VK_FORMAT_R32G32B32A32_SINT:
     case VK_FORMAT_B8G8R8_UINT:
-    case VK_FORMAT_B8G8R8_SINT:
     case VK_FORMAT_B8G8R8A8_UINT:
-    case VK_FORMAT_B8G8R8A8_SINT:
     case VK_FORMAT_B10G10R10A2_UINT:
-    case VK_FORMAT_B10G10R10A2_SINT:
-        is_int = true;
+        is_uint = true;
         break;
     default:
         break;
     }
 
-    return is_int;
+    return is_uint;
+}
+
+// Return true if format is a signed integer format
+bool vk_format_is_sint(VkFormat format)
+{
+    bool is_sint = false;
+
+    switch (format) {
+    case VK_FORMAT_R8_SINT:
+    case VK_FORMAT_R8G8_SINT:
+    case VK_FORMAT_R8G8B8_SINT:
+    case VK_FORMAT_R8G8B8A8_SINT:
+    case VK_FORMAT_R10G10B10A2_SINT:
+    case VK_FORMAT_R16_SINT:
+    case VK_FORMAT_R16G16_SINT:
+    case VK_FORMAT_R16G16B16_SINT:
+    case VK_FORMAT_R16G16B16A16_SINT:
+    case VK_FORMAT_R32_SINT:
+    case VK_FORMAT_R32G32_SINT:
+    case VK_FORMAT_R32G32B32_SINT:
+    case VK_FORMAT_R32G32B32A32_SINT:
+    case VK_FORMAT_B8G8R8_SINT:
+    case VK_FORMAT_B8G8R8A8_SINT:
+    case VK_FORMAT_B10G10R10A2_SINT:
+        is_sint = true;
+        break;
+    default:
+        break;
+    }
+
+    return is_sint;
 }
 
 // Return true if format is a floating-point format
diff --git a/layers/vk_layer_utils.h b/layers/vk_layer_utils.h
index bd5eac8..376f81b 100644
--- a/layers/vk_layer_utils.h
+++ b/layers/vk_layer_utils.h
@@ -37,15 +37,20 @@
     return (format == VK_FORMAT_UNDEFINED);
 }
 
-bool vk_format_is_ds(VkFormat format);
+bool vk_format_is_depth_or_stencil(VkFormat format);
+bool vk_format_is_depth_and_stencil(VkFormat format);
+bool vk_format_is_depth_only(VkFormat format);
+bool vk_format_is_stencil_only(VkFormat format);
 
 static inline bool vk_format_is_color(VkFormat format)
 {
-    return !(vk_format_is_undef(format) || vk_format_is_ds(format));
+    return !(vk_format_is_undef(format) || vk_format_is_depth_or_stencil(format));
 }
 
 bool   vk_format_is_norm(VkFormat format);
 bool   vk_format_is_int(VkFormat format);
+bool   vk_format_is_sint(VkFormat format);
+bool   vk_format_is_uint(VkFormat format);
 bool   vk_format_is_float(VkFormat format);
 bool   vk_format_is_srgb(VkFormat format);
 bool   vk_format_is_compressed(VkFormat format);
diff --git a/layers/vk_validation_layer_details.md b/layers/vk_validation_layer_details.md
index 132bd6d..6fcbcd9 100644
--- a/layers/vk_validation_layer_details.md
+++ b/layers/vk_validation_layer_details.md
@@ -112,11 +112,11 @@
 
 ## Image
 
-### Image Overview
+### Image Layer Overview
 
 The Image layer is responsible for validating format-related information and enforcing format restrictions.
 
-### Image Details Table
+### Image Layer Details Table
 
 DETAILS TABLE PENDING
 
@@ -126,11 +126,13 @@
 | RenderPass Attachments | Validates that attachment image layouts, loadOps, and storeOps are valid Vulkan values | RENDERPASS_INVALID_ATTACHMENT | vkCreateRenderPass | TBD | NA |
 | Subpass DS Settings | Verifies that if there is no depth attachment then the subpass attachment is set to VK_ATTACHMENT_UNUSED | RENDERPASS_INVALID_DS_ATTACHMENT | vkCreateRenderPass | TBD | NA |
 | View Creation | Verify that requested Image View Creation parameters are reasonable for the image that the view is being created for | VIEW_CREATE_ERROR | vkCreateImageView | TBD | NA |
-| Image Aspects | Verify that Image commands are using valid Image Aspect flags | INVALID_IMAGE_ASPECT | vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyBufferToImage vkCmdResolveImage | TBD | NA |
+| Image Aspects | Verify that Image commands are using valid Image Aspect flags | INVALID_IMAGE_ASPECT | vkCreateImageView vkCmdClearColorImage vkCmdClearDepthStencilImage vkCmdClearAttachments vkCmdCopyImage vkCmdCopyImageToBuffer vkCmdCopyBufferToImage vkCmdResolveImage vkCmdBlitImage | InvalidImageViewAspect | NA |
 | Image Aspect Mismatch | Verify that Image commands with source and dest images use matching aspect flags | MISMATCHED_IMAGE_ASPECT | vkCmdCopyImage | TBD | NA |
 | Image Type Mismatch | Verify that Image commands with source and dest images use matching types | MISMATCHED_IMAGE_TYPE | vkCmdCopyImage vkCmdResolveImage | CopyImageTypeMismatch ResolveImageTypeMismatch | NA |
 | Image Format Mismatch | Verify that Image commands with source and dest images use matching formats | MISMATCHED_IMAGE_FORMAT | vkCmdCopyImage vkCmdResolveImage | CopyImageDepthStencilFormatMismatch ResolveImageFormatMismatch | NA |
 | Resolve Sample Count | Verifies that source and dest images sample counts are valid | INVALID_RESOLVE_SAMPLES | vkCmdResolveImage | ResolveImageHighSampleCount ResolveImageLowSampleCount | NA |
+| Verify Format | Verifies the formats are valid for this image operation | INVALID_FORMAT | vkCreateImageView vkCmdBlitImage | TBD | NA |
+| Verify Correct Image Filter| Verifies that specified filter is valid | INVALID_FILTER | vkCmdBlitImage | TBD | NA |
 | NA | Enum used for informational messages | NONE | | NA | None |
 
 ### Image Pending Work
diff --git a/tests/layer_validation_tests.cpp b/tests/layer_validation_tests.cpp
index 3863611..08a6479 100644
--- a/tests/layer_validation_tests.cpp
+++ b/tests/layer_validation_tests.cpp
@@ -4343,6 +4343,7 @@
         image_view_create_info.subresourceRange.numLayers = 1;
         image_view_create_info.subresourceRange.baseMipLevel = 10; // cause an error
         image_view_create_info.subresourceRange.numLevels = 1;
+        image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
 
     VkImageView view;
     err = vkCreateImageView(m_device->device(), &image_view_create_info, &view);
@@ -4354,6 +4355,59 @@
     }
 }
 
+TEST_F(VkLayerTest, InvalidImageViewAspect)
+{
+    VkFlags         msgFlags;
+    std::string     msgString;
+    VkResult        err;
+
+    ASSERT_NO_FATAL_FAILURE(InitState());
+    m_errorMonitor->ClearState();
+
+    // Create an image and try to create a view with an invalid aspectMask
+    VkImage               image;
+
+    const VkFormat tex_format      = VK_FORMAT_B8G8R8A8_UNORM;
+    const int32_t  tex_width       = 32;
+    const int32_t  tex_height      = 32;
+
+    VkImageCreateInfo image_create_info = {};
+        image_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+        image_create_info.pNext = NULL;
+        image_create_info.imageType = VK_IMAGE_TYPE_2D;
+        image_create_info.format = tex_format;
+        image_create_info.extent.width = tex_width;
+        image_create_info.extent.height = tex_height;
+        image_create_info.extent.depth = 1;
+        image_create_info.mipLevels = 1;
+        image_create_info.samples = 1;
+        image_create_info.tiling = VK_IMAGE_TILING_LINEAR;
+        image_create_info.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
+        image_create_info.flags = 0;
+
+    err = vkCreateImage(m_device->device(), &image_create_info, &image);
+    ASSERT_VK_SUCCESS(err);
+
+    VkImageViewCreateInfo image_view_create_info = {};
+        image_view_create_info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
+        image_view_create_info.image = image;
+        image_view_create_info.viewType = VK_IMAGE_VIEW_TYPE_2D;
+        image_view_create_info.format = tex_format;
+        image_view_create_info.subresourceRange.baseMipLevel = 0;
+        image_view_create_info.subresourceRange.numLevels = 1;
+        // Cause an error by setting an invalid image aspect
+        image_view_create_info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_METADATA_BIT;
+
+    VkImageView view;
+    err = vkCreateImageView(m_device->device(), &image_view_create_info, &view);
+
+    msgFlags = m_errorMonitor->GetState(&msgString);
+    ASSERT_TRUE(0 != (msgFlags & VK_DBG_REPORT_ERROR_BIT)) << "Did not receive an error when specifying an invalid ImageView aspect";
+    if (!strstr(msgString.c_str(),"vkCreateImageView: Color image formats must have ONLY the VK_IMAGE_ASPECT_COLOR_BIT set")) {
+        FAIL() << "Error received was not 'VkCreateImageView: Color image formats must have ...' but instead '" << msgString.c_str() << "'";
+    }
+}
+
 TEST_F(VkLayerTest, CopyImageTypeMismatch)
 {
     VkFlags         msgFlags;