Finish copy run logic

git-svn-id: svn://svn.code.sf.net/p/nuttx/code/trunk@2609 42af7a65-404d-4744-a932-0658087f49c3

1 files changed, 228 insertions, 51 deletions

diff --git a/nuttx/graphics/nxglib/nxglib_copyrun.h b/nuttx/graphics/nxglib/nxglib_copyrun.h
index 7f02512c7..500d2fb75 100644
--- a/nuttx/graphics/nxglib/nxglib_copyrun.h
+++ b/nuttx/graphics/nxglib/nxglib_copyrun.h
@@ -83,68 +83,83 @@ nxgl_copyrun_1bpp(FAR const uint8_t *src, FAR uint8_t *dest,
 {
   uint8_t indata;
   uint8_t outdata;
-  unsigned int inpixels = 0;
   unsigned int outpixels = 0;
-  unsigned int outbit;
 
-  /* Set up the input */
+  DEBUGASSERT(remainder > 0 && remainder < 8);
+
+  /* Take only the first 8-remainder pixels from the first byte.
+   * remainder is number between 1 and 7 (not zero!) that represents
+   * the alignment of the pixel bits in the source.
+   */
 
   indata = *src++;
 
-  /* Set up the output */
+#ifdef CONFIG_NX_PACKEDMSFIRST
+  /* If CONFIG_NX_PACKEDMSFIRST is defined, then bits 0-(remainder-1)
+   * are carried over to the first pass through the loop. For
+   * example if remainder == 2:
+   *
+   * indata: xxAA AAAA maps to nextdata: AAAA AAxx
+   */
 
-  outdata = 0;
-  outbit  = 0;
+  nextdata = (indata << remainder);
 
-  /* Loop until all pixels have been packed into the destination */
+#else
+  /* If CONFIG_NX_PACKEDMSFIRST is NOT defined, then bits (7-remainder)-7
+   * are carried over to the first pass through the loop.  For example
+   * if remainder == 2:
+   *
+   * indata: AAAA AAxx maps to nextdata: xxAA AAAA
+   */
+ 
+  nextdata = (indata >> remainder);
 
-  while (outpixels < npixels && inpixels < npixels)
-    {
-      /* Pack pixels from the source into the destination */
-      /* Check the input bit */
-
-      if ((*src & (1 << inbit)) != 0)
-        {
-          /* If it is set, then set the corresponding bit
-           * in the output (probably not the same bit.
-           */
-
-          outdata |= (1 << outbit);
-        }
-      inpixels++;
-
-      /* Check if we have used all of the bits in the input */
-
-      if (++inbit >= 8)
-        {
-          /* Yes.. Get the next byte from the source and reset
-           * the source bit number.
-           */
-
-          indata = *src++;
-          inbit  = 0;
-        }
-
-      /* Now check if we have filled the output byte */
-
-      if (++outbit >= 8)
-        {
-          /* Yes.. Write the output and reset the output bit
-           * number
-           */
-
-          *dest++    = outdata;
-          outdata    = 0;
-          outbit     = 0;
-          outpixels += 8;
-        }
-    }
+#endif
 
-  /* Handle any bits still in outdata */
+  /* Loop until all pixels have been packed into the destination.  Note:
+   * a outpixels increments by 8 so a few extra pixels will be packed on
+   * the output.  This should not be an issue.
+   */
 
-  if (outpixels < inpixels)
+  while (outpixels < npixels)
     {
-      *dest = outdata;
+      /* Get the next byte from the source */
+
+      indata  = *src++;
+      outdata = nextdata;
+
+      /* remainder is number between 1 and 7 (not zero!) that represents
+       * the alignment of the pixel bits in the source.
+       */
+
+#ifdef CONFIG_NX_PACKEDMSFIRST
+      /* If CONFIG_NX_PACKEDMSFIRST is defined, then bits (7-remainder)-7
+       * are carried over from that last pass through the loop. For
+       * example if remainder == 2:
+       *
+       *   nextdata = AAAA AAxx  - dest     = AAAA AABB
+       *   src      = BBCC CCCC  - nextdata = CCCC CCxx
+       */
+
+       outdata |= (indata >> (8 - remainder));
+       nextdata = (indata << remainder);
+#else
+      /* If CONFIG_NX_PACKEDMSFIRST is NOT defined, then bits 0-(remainder-1)
+       * are carried over from that last pass through the loop .  For
+       * example if remainder == 2:
+       *
+       *   nextdata = xxAA AAAA  - dest     = BBAA AAAA
+       *   src      = CCCC CCBB  - nextdata = xxCC CCCC
+       */
+
+       outdata |= (indata << (8 - remainder));
+       nextdata = (indata >> remainder);
+#endif
+
+      /* Transfer the byte to the run buffer */
+
+      *dest++ = outdata;
+      outpixels += 8;
     }
 }
 
@@ -153,6 +168,88 @@ static inline void
 nxgl_copyrun_2bpp(FAR const uint8_t *src, FAR uint8_t *dest,
                   unsigned int inbit, size_t npixels)
 {
+  uint8_t indata;
+  uint8_t outdata;
+  unsigned int outpixels = 0;
+  unsigned int shift;
+
+  DEBUGASSERT(remainder > 0 && remainder < 4);
+
+  /* Take only the first 8-(2*remainder) pixels from the first byte.
+   * remainder is number between 1 and 3 (not zero!) that represents
+   * the alignment of the pixel bits in the source.
+   */
+
+  indata = *src++;
+  shift  = (remainder << 1);
+
+#ifdef CONFIG_NX_PACKEDMSFIRST
+  /* If CONFIG_NX_PACKEDMSFIRST is defined, then bits 0-(2*remainder-1)
+   * are carried over to the first pass through the loop. For
+   * example if remainder == 1:
+   *
+   * indata: xxAA AAAA maps to nextdata: AAAA AAxx
+   */
+
+  nextdata = (indata << shift);
+  
+#else
+  /* If CONFIG_NX_PACKEDMSFIRST is NOT defined, then bits (7-2*remainder)-7
+   * are carried over to the first pass through the loop.  For example
+   * if remainder == 1:
+   *
+   * indata: AAAA AAxx maps to nextdata: xxAA AAAA
+   */
+ 
+  nextdata = (indata >> shift);
+
+#endif
+
+  /* Loop until all pixels have been packed into the destination.  Note:
+   * a outpixels increments by 8 so a few extra pixels will be packed on
+   * the output.  This should not be an issue.
+   */
+
+  while (outpixels < npixels)
+    {
+      /* Get the next byte from the source */
+
+      indata  = *src++;
+      outdata = nextdata;
+
+      /* remainder is number between 1 and 3 (not zero!) that represents
+       * the alignment of the pixel bits in the source.
+       */
+
+#ifdef CONFIG_NX_PACKEDMSFIRST
+      /* If CONFIG_NX_PACKEDMSFIRST is defined, then bits (7-2*remainder)-7
+       * are carried over from that last pass through the loop. For example
+       * if remainder == 1:
+       *
+       *   nextdata = AAAA AAxx  - dest     = AAAA AABB
+       *   src      = BBCC CCCC  - nextdata = CCCC CCxx
+       */
+
+       outdata |= (indata >> (8 - shift));
+       nextdata = (indata << shift);
+#else
+      /* If CONFIG_NX_PACKEDMSFIRST is NOT defined, then bits 0-(2*remainder-1)
+       * are carried over from that last pass through the loop.  For example
+       * if remainder == 1:
+       *
+       *   nextdata = xxAA AAAA  - dest     = BBAA AAAA
+       *   src      = CCCC CCBB  - nextdata = xxCC CCCC
+       */
+
+       outdata |= (indata << (8 - shift));
+       nextdata = (indata >> shift);
+#endif
+
+      /* Transfer the byte to the run buffer */
+
+      *dest++ = outdata;
+      outpixels += 4;
+    }
 }
 
 #elif NXGLIB_BITSPERPIXEL == 4
@@ -160,6 +257,86 @@ static inline void
 nxgl_copyrun_4bpp(FAR const uint8_t *src, FAR uint8_t *dest,
                   unsigned int inbit, size_t npixels)
 {
+  uint8_t indata;
+  uint8_t outdata;
+  unsigned int outpixels = 0;
+
+  DEBUGASSERT(remainder == 1);
+
+  /* Take only the first 8-remainder pixels from the first byte.
+   * remainder is number between 1 and 3 (not zero!) that represents
+   * the alignment of the pixel bits in the source.
+   */
+
+  indata = *src++;
+  shift  = (remainder << 1);
+
+#ifdef CONFIG_NX_PACKEDMSFIRST
+  /* If CONFIG_NX_PACKEDMSFIRST is defined, then bits 0-3
+   * are carried over to the first pass through the loop. For
+   * example:
+   *
+   * indata: xxxx AAAA maps to nextdata: AAAA xxxx
+   */
+
+  nextdata = (indata << 4);
+  
+#else
+  /* If CONFIG_NX_PACKEDMSFIRST is NOT defined, then bits 4-7
+   * are carried over to the first pass through the loop.  For example:
+   *
+   * indata: AAAA xxxx maps to nextdata: xxxx AAAA
+   */
+ 
+  nextdata = (indata >> 4);
+
+#endif
+
+  /* Loop until all pixels have been packed into the destination.  Note:
+   * a outpixels increments by 8 so a few extra pixels will be packed on
+   * the output.  This should not be an issue.
+   */
+
+  while (outpixels < npixels)
+    {
+      /* Get the next byte from the source */
+
+      indata  = *src++;
+      outdata = nextdata;
+
+      /* remainder is number between 1 and 3 (not zero!) that represents
+       * the alignment of the pixel bits in the source.
+       */
+
+#ifdef CONFIG_NX_PACKEDMSFIRST
+      /* If CONFIG_NX_PACKEDMSFIRST is defined, then bits 4-7
+       * are carried over from that last pass through the loop (or are
+       * ignored initially. For example if remainder == 1:
+       *
+       *   nextdata = AAAA xxxx  - dest     = AAAA BBBB
+       *   src      = BBBB CCCC  - nextdata = CCCC xxxx
+       */
+
+       outdata |= (indata >> 4);
+       nextdata = (indata << 4);
+#else
+      /* If CONFIG_NX_PACKEDMSFIRST is NOT defined, then bits 0-(remainder-1)
+       * are carried over from that last pass through the loop (or are
+       * ignored initially).  For example if remainder == 2:
+       *
+       *   nextdata = xxAA AAAA  - dest     = BBAA AAAA
+       *   src      = CCCC CCBB  - nextdata = xxCC CCCC
+       */
+
+       outdata |= (indata << 4);
+       nextdata = (indata >> 4);
+#endif
+
+      /* Transfer the byte to the run buffer */
+
+      *dest++ = outdata;
+      outpixels += 2;
+    }
 }
 #endif
 #endif /* __GRAPHICS_NXGLIB_NXGLIB_COPYRUN_H */