Получить данные из битовой структуры.

        /// <summary>
        /// Read packed integers from buffer. For example - read 10-bit integers, that placed one by one with no gap
        /// </summary>
        /// <param name="pBuffer">Buffer to read</param>
        /// <param name="pFrom">Read from this index</param>
        /// <param name="pIntCount">How many N-bit integers would be readed</param>
        /// <param name="pBitPerInt">Count of bits per one integer (from 8 to 32)</param>
        /// <returns>Array of readed integers</returns>
        public static int[] ReadPackedIntegers(byte[] pBuffer, int pFrom, int pIntCount, int pBitPerInt)
        {
            //can we do it?
            if (pBitPerInt > 32) throw new ArgumentException("This method can operate only up to 32 bit integers!");
            //check buffer length
            if (pIntCount * pBitPerInt > (pBuffer.Length - pFrom) * 8)
                throw new ArgumentException("Buffer is too short for contain " + pIntCount.ToString() + " of " + pBitPerInt.ToString() + " bits numbers");
            //result
            int[] res = new int[pIntCount];

            int ri = 0;//res index
            int pbi = pFrom;//pBuffer index
            int msl = 8;//shift mask left
            int nsr = pBitPerInt > 7 ? 0 : 8 - pBitPerInt;//number shift right
            int b2rc = 8 - nsr;//bits to read from byte
            int b2rfn = pBitPerInt;//bits to read for number
            while (ri < pIntCount)
            {
                unchecked
                {
                    //read data
                    res[ri] |= ((pBuffer[pbi] & ~((int)0xFFFFFFFF << msl)) >> nsr);
                }
                b2rfn -= b2rc;//how bits we read
                //free place for next bits
                if (b2rfn == 0)//if requested number collected
                {
                    ri++;//step to next
                    b2rfn = pBitPerInt;
                }
                //we'll get partial result at next step
                if (nsr < pBitPerInt)
                {
                    //eat last bit
                    if (nsr == 0)
                    {
                        nsr = 8;
                        b2rc = b2rfn > 8 ? 8 : b2rfn;
                        pbi++;
                    }
                    else
                    {
                        b2rc = nsr;
                    }
                }
                else
                {
                    b2rc = pBitPerInt;
                }
                msl = nsr;
                nsr -= b2rc;
                if(b2rfn != pBitPerInt)
                    res[ri] <<= b2rc;
            }
            return res;
        }

union {
  struct { byte a, b , c, d } bytes;
  struct { byte a; word b: 12; word c: 12; } myReprentation;
}