c# - 从左向右移位 16 位 C#

Question

我有一个具有以下表示的 8 位数组。 Data[i] = 192=11000000, data[i+1]= 85=01010101, 我需要将表示转换为 16 位数组，其中newArr[i] =343=101010111. 相同的数字仅向右移动。我的第一个想法是使用我拥有 bpp 的字段（位数 = 10）。所以var t=16-10。Data[i] >>t. 然而，这并Data[i+1]>>t没有给出正确的答案。请帮忙

Answer 1

我为您准备了这两个函数，用于转换字节数组：

static public void ShiftLeft(this byte[] data, int count, bool rol)
{
    if ((count <0) || (count > 8))
        throw new ArgumentException("Count must between 0 and 8.");
    byte mask = (byte)(0xFF << (8 - count));
    int bits = rol ? data[0] & mask : 0;
    for (int i = data.Length - 1; i >= 0; i--)
    {
        int b = data[i] & mask;
        data[i] = (byte)((data[i] << count) | (bits >> (8 - count)));
        bits = b;
    }
}

static public void ShiftRight(this byte[] data, int count, bool rol)
{
    if ((count <0) || (count > 8))
        throw new ArgumentException("Count must between 0 and 8.");
    byte mask = (byte)(0xFF >> (7 - count));
    int bits = rol ? data[data.Length - 1] & mask : 0;
    for (int i = 0; i < data.Length; i++)
    {
        int b = data[i] & mask;
        data[i] = (byte)((data[i] >> count) | (bits << (8 - count)));
        bits = b;
    }
}

对于您的代码示例，请像这样称呼它们：

byte[] data = ...;
ShiftLeft(data, 2, false);

假设您想将 2 个字节复制到 1 个 ushort 中，您可以使用此代码（确保它的长度均匀！）：

byte[] data = ...;
short[] sdata = new short[data.Length / 2];
Buffer.BlockCopy(data, 0, sdata, 0, dataLen);

如果您想将 1 个字节复制到 1 个 ushort 中，那么这就是答案：

byte[] data = ...;
short[] sdata = Array.ConvertAll(data, b => (short)b);

Answer 2

我认为您的问题意味着您想要进行此转换：合并aaaaaaaa并bbbbbbbb进入bbbbbbbbaaaaaaaa，然后应用右移 6，产生000000bbbbbbbbaa.

那么这将是您的代码：

using System;

public class Test
{
  public static void Main()
  {
    byte[] src = new byte[2] { 192, 85 };
    ushort[] tgt = new ushort[1];

    for ( int i = 0 ; i < src.Length ; i+=2 )
    {
      tgt[i] = (ushort)( ( src[i+1]<<8 | src[i] )>>6 );
    }
    System.Console.WriteLine( tgt[0].ToString() );
  }
}

如果您想要组合 to aaaabbbbbbbbaa，那么这将需要在第二步中使用|-ing a ，因为 C# 中没有循环移位运算符。src[i]<<10

Answer 3

我的最终代码：D

 public override short[] GetShortDataAlignedRight()
    {
        short[] ReturnArray = new short[_channels[0].Data.Length / 2];
        if (_channels[0].Bpp == 8)
        {
            Buffer.BlockCopy(_channels[0].Data, 0, ReturnArray, 0, _channels[0].Data.Length);
        }
        else
        {
            short tempData;
            int offsetHigh = 8 - (16 - _channels[0].Bpp);
            int offsetLow = (16 - _channels[0].Bpp);
            for (int i = 0, j = 0; i < _channels[0].Data.Length; i += 2, j++)
            {
                tempData = (short)(_channels[0].Data[i] >> offsetLow);
                tempData |= (short)(_channels[0].Data[i + 1] << offsetHigh);
                ReturnArray[j] = tempData;
            }
        }
        return ReturnArray;
    }