Adds _cogl_pixel_format_is_endian_dependant api

This adds an internal utility function
_cogl_pixel_format_is_endian_dependant() that can query whether
accessing the components of a given format depends on the endianness of
the current host CPU or whether a pixel can be loaded as a word and
channels accessed using bit masking and shifting.

Reviewed-by: Neil Roberts <neil@linux.intel.com>

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__ */

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;
+}