Manchester encode a data stream Manchester coding is a telecom protocol used in radio communications that guarantees bit transitions at a regular interval so a receiver can recover the clock rate from the data itself. It doubles the bitrate, but is cheap and simple to implement.  It is widely used by amateur radio operators.

The concept is very simple: at a hardware level, the clock and data lines are simply XORed together.  In software, this is portrayed as converting an input stream of bits into a double-rate output stream, with each input '1' translated to a '01' and each input '0' translated to a '10'.

This is an easy problem, but open to a lot of implementations because of its bitstream nature.  That is, the encoding is conceptually a bit-by-bit process instead of a byte-by-byte process.  So we all agree on endianness, the least significant bits of the input become the least significant byte of the output.

Golfing time!  Write a function that, given an arbitrary length array of bytes, returns an array of that data manchester encoded.  

Input and output should be considered little-endian, least significant byte first, and least significant BIT first in the bit stream.

ASCII bitstream drawing:

bit #      5 4 3 2 1 0                                5  4  3  2  1  0
IN ------- 1 0 1 0 1 1 ---&gt; [manchester encoder] ---  01 10 01 10 01 01 ----&gt; OUT


Examples:

Example 1 (hex):
       LSB              MSB     &lt;-- least sig BYTE first
IN : [0x10, 0x02]  
OUT: [0xAA, 0xA9, 0xA6, 0xAA]  

Example 1 (binary):
      msb  lsb                      msb  lsb  &lt;-- translated hex, so msb first
BIN: [00010000, 00000010]                     &lt;-- least sig NIBBLE...
BIN: [10101010, 10101001, 10100110, 10101010] &lt;-- becomes least sig BYTE
         LSB                           MSB

Example 2
IN :  [0xFF, 0x00, 0xAA, 0x55]  
OUT: [0x55, 0x55, 0xAA, 0xAA, 0x66, 0x66, 0x99, 0x99]

Example 3
IN : [0x12, 0x34, 0x56, 0x78, 0x90]  
OUT: [0xA6, 0xA9, 0x9A, 0xA5, 0x96, 0x99, 0x6A, 0x95, 0xAA, 0x69] 

Example 4
IN : [0x01, 0x02, 0x03, 0xF1, 0xF2, 0xF3]  
OUT: [0xA9, 0xAA, 0xA6, 0xAA, 0xA5, 0xAA, 0xA9, 0x55, 0xA6, 0x55, 0xA5, 0x55]


Rules:


Solution only requires algorithm to convert input to output.  
Acquiring input and printing output are NOT a required part of the solution, but may be included.  You are encouraged to provide your test/print code if not included in your solution.
Input is an array of 8-bit bytes (whatever that may mean in your language of choice), NOT a text string.  You can use strings as the storage format if convenient in your language, but non-printable characters (i.e. 0xFF) must be supported.  Input can also take a length if necessary.
Memory for output must be allocated by your routine, not provided. edit: unnecessary requirement
Output is also an array of 8-bit bytes, and a length if necessary.
Must support at least 16KB input
Performance must not be too horrible: &lt; 10s for 16KB
Least-significant byte first in memory.


Side-channel challenge:


Challenge another user's answer by proving your code is faster, more memory efficient, or produces a smaller binary!  


Get golfing!  Shortest code wins!
GolfScript 28 characters
{2{base}:|~4|43691-~256|~\}%

Equivalent version without obfuscating optimization:
{2base 4base 43691-~256base~\}%

The code accept input as an array of integers, and return ditto.
For each number in the array the number is converted to base 2 array form, it is then converted back to a number as if it was base 4, this has the effect of spacing out the bits with a 0 in between each. 43691 is then subtracted from the number, and the result is binary inverted, this is equivalent to subtracting the number from 43690 (43690 = 0b1010101010101010). The number is then split into two parts by converting it to a base 256 array, the array is decomposed and the order of the two resulting numbers is inverted.
Example input:
[1 2 3 241 242 243]

Example output:
[169 170 166 170 165 170 169 85 166 85 165 85]