diff --git a/cogl/cogl-private.h b/cogl/cogl-private.h
index b4ff42056..8f2a72e7f 100644
--- a/cogl/cogl-private.h
+++ b/cogl/cogl-private.h
@@ -75,6 +75,33 @@ _cogl_get_enable_legacy_state (void);
 int
 _cogl_pixel_format_get_bytes_per_pixel (CoglPixelFormat format);
 
+/*
+ * _cogl_pixel_format_has_aligned_components:
+ * @format: a #CoglPixelFormat
+ *
+ * Queries whether the ordering of the components for the given
+ * @format depend on the endianness of the host CPU or if the
+ * components can be accessed using bit shifting and bitmasking by
+ * loading a whole pixel into a word.
+ *
+ * XXX: If we ever consider making something like this public we
+ * should really try to think of a better name and come up with
+ * much clearer documentation since it really depends on what
+ * point of view you consider this from whether a format like
+ * COGL_PIXEL_FORMAT_RGBA_8888 is endian dependent. E.g. If you
+ * read an RGBA_8888 pixel into a uint32
+ * it's endian dependent how you mask out the different channels.
+ * But If you already have separate color components and you want
+ * to write them to an RGBA_8888 pixel then the bytes can be
+ * written sequentially regardless of the endianness.
+ *
+ * Return value: %TRUE if you need to consider the host CPU
+ *               endianness when dealing with the given @format
+ *               else %FALSE.
+ */
+gboolean
+_cogl_pixel_format_is_endian_dependant (CoglPixelFormat format);
+
 G_END_DECLS
 
 #endif /* __COGL_PRIVATE_H__ */
diff --git a/cogl/cogl.c b/cogl/cogl.c
index d22a91faf..82a7f771a 100644
--- a/cogl/cogl.c
+++ b/cogl/cogl.c
@@ -1024,3 +1024,24 @@ _cogl_pixel_format_get_bytes_per_pixel (CoglPixelFormat format)
 
   return bpp_lut [format & 0xf];
 }
+
+/* Note: this also refers to the mapping defined above for
+ * _cogl_pixel_format_get_bytes_per_pixel() */
+gboolean
+_cogl_pixel_format_is_endian_dependant (CoglPixelFormat format)
+{
+  int aligned_lut[] = { -1, 1,  1,  1,
+                         0, 0,  0, -1,
+                         1, 1, -1, -1,
+                         0, 0, -1, -1};
+  int aligned = aligned_lut[format & 0xf];
+
+  _COGL_RETURN_VAL_IF_FAIL (aligned != -1, FALSE);
+
+  /* NB: currently checking whether the format components are aligned
+   * or not determines whether the format is endian dependent or not.
+   * In the future though we might consider adding formats with
+   * aligned components that are also endian independant. */
+
+  return aligned;
+}