新LCD具有不同的像素布局，需要更高效的方法转换阵列缓冲区（工作方法太慢）

提前感谢任何人提供的任何帮助

这是我的问题：我正在更换一个过时的LCD。新的和旧的LCD都是240宽128高的像素，但像素排列不同。 我已经编写了将屏幕数组从旧格式转换为新格式的代码，但是速度太慢了。我希望有人在位操纵更好，我可以想出一个更好的方法。下面是箭头的排列，表示8个像素的字节及其在LCD上的方向

基本上，旧的LCD是以8个像素字节的水平切片排列的，水平递增，然后环绕，然后垂直递增。 新的LCD以8像素字节的垂直切片排列，水平递增，然后环绕，垂直递增

我试图将这两种排列可视化，用箭头表示8个像素字节，用垂直或水平箭头指向位增量的方向。两种表示法中的每个箭头都是一个字节或8个像素

这是旧LCD的布局：30字节乘以128字节代表30720位或像素 240位水平是30字节 128字节垂直

这是新LCD的布局：240字节乘以16字节，代表30720位或像素 16字节中的128位垂直 240字节水平

下面是我的翻译代码，虽然有效，但速度太慢。它通过新排列的字节递增，找到旧排列中每个字节的每个位的来源。太慢和乏味，落后的制度，必须有更好的办法！我尝试将所有函数调用更改为内联代码，但没有任何改进

#define DISPLAY_BUFFER_SIZE     3840            // buffer size in *bytes*
#define HORIZONTAL_PIX    240
#define VERTICAL_ROWS    16
#define VERTICAL_PIX    128
#define HORIZONTAL_COL    30
#define BITS_IN_BYTE    8

UBYTE isBitSet(UBYTE* arr, USHORT bit)
{
    USHORT index = bit / 8;  // Get the index of the array for byte with this bit
    USHORT bitPosition = 7-(bit % 8);  // Position of this bit a byte   Every byte on the OLD LCD was bit swapped from MSB to LSB so annoyingly this is reversed here
   return (arr[index] >> bitPosition & 1) == 1;
}


// main code inside another function

    for (i=0; i<DISPLAY_BUFFER_SIZE; i++)
    {
        newbyte_pos = i % HORIZONTAL_PIX;  // Value is 0 to 29.     30 = 240col / 8bits
        newbyte_offset = i / HORIZONTAL_PIX;    // Value is 0 to 127
        new_display_byte = 0x00;

        // Bit 0
        oldbit_num = (newbyte_offset * 1920) + (240 * 0) + newbyte_pos;
        if (isBitSet(buffer_pointer, oldbit_num))
            new_display_byte |= 0x01;
        // Bit 1
        oldbit_num = (newbyte_offset * 1920) + (240 * 1) + newbyte_pos;
        if (isBitSet(buffer_pointer, oldbit_num))
            new_display_byte |= 0x02;
        // Bit 2
        oldbit_num = (newbyte_offset * 1920) + (240 * 2) + newbyte_pos;
        if (isBitSet(buffer_pointer, oldbit_num))
            new_display_byte |= 0x04;
        // Bit 3
        oldbit_num = (newbyte_offset * 1920) + (240 * 3) + newbyte_pos;
        if (isBitSet(buffer_pointer, oldbit_num))
            new_display_byte |= 0x08;
        // Bit 4
        oldbit_num = (newbyte_offset * 1920) + (240 * 4) + newbyte_pos;
        if (isBitSet(buffer_pointer, oldbit_num))
            new_display_byte |= 0x10;
        // Bit 5
        oldbit_num = (newbyte_offset * 1920) + (240 * 5) + newbyte_pos;
        if (isBitSet(buffer_pointer, oldbit_num))
            new_display_byte |= 0x20;
        // Bit 6
        oldbit_num = (newbyte_offset * 1920) + (240 * 6) + newbyte_pos;
        if (isBitSet(buffer_pointer, oldbit_num))
            new_display_byte |= 0x40;
        // Bit 7
        oldbit_num = (newbyte_offset * 1920) + (240 * 7) + newbyte_pos;
        if (isBitSet(buffer_pointer, oldbit_num))
            new_display_byte |= 0x80;

        new_display_buf[i] = new_display_byte;
    }
 }

#定义显示缓冲区大小3840//缓冲区大小（以*字节为单位）*
#定义水平投影240
#定义垂直行16
#定义垂直像素128
#定义水平坐标30
#定义字节8中的位
UBYTE是位集（UBYTE*arr，USHORT位）
{
USHORT index=bit/8；//获取该位字节的数组索引
USHORT bitPosition=7-（位%8）；//此位的位置为一个字节旧LCD上的每个字节都是从MSB位交换到LSB位的，令人恼火的是，这里颠倒了
返回值（arr[index]>>bitPosition&1）==1；
}
//另一个函数中的主代码
对于（i=0；i而言，您需要的是一个可以快速转置8x8位块的函数，然后您可以在显示器中的所有480个块上运行它

void transpose8x8bits(UBYTE * block, UBYTE * result)
{
    int bit;
    for (bit = 7; bit >= 0; bit--)
    {
        result[7-bit] = (((block[0] >> bit) & 1) << 7) |
                        (((block[1] >> bit) & 1) << 6) |
                        (((block[2] >> bit) & 1) << 5) |
                        (((block[3] >> bit) & 1) << 4) |
                        (((block[4] >> bit) & 1) << 3) |
                        (((block[5] >> bit) & 1) << 2) |
                        (((block[6] >> bit) & 1) << 1) |
                         ((block[7] >> bit) & 1);
}

无效转置8x8位（UBYTE*块，UBYTE*结果）
{
整数位；
对于（位=7；位>=0；位--）
{
结果[7位]=（（块[0]>>位&1）>位&1）>位&1）>位&1）>位&1）>位&1）>位&1）>位&1）；
}
以下是基于Mark Ransom非常有用的建议的新代码：

void transpose8x8bits(UBYTE * block, UBYTE * result)
{
    int bit;
    for (bit = 7; bit >= 0; bit--)
    {
        result[7-bit] = (((block[0] >> bit) & 1) << 0) |
                        (((block[30] >> bit) & 1) << 1) |
                        (((block[60] >> bit) & 1) << 2) |
                        (((block[90] >> bit) & 1) << 3) |
                        (((block[120] >> bit) & 1) << 4) |
                        (((block[150] >> bit) & 1) << 5) |
                        (((block[180] >> bit) & 1) << 6) |
                         (((block[210] >> bit) & 1) << 7);
    }
}

//////////////////////////////////////////////////////////////////
    // calling code

    buf_inx = 0;
    for (z=0; z<16; z++)  // 128 bits / 8 bit per byte = 16 bytes
    {
        for (i=0; i<30; i++)
        {
            transpose8x8bits((buffer_pointer+i+(z*240)), (new_display_buf+buf_inx));
            buf_inx += 8;
        }
    }

无效转置8x8位（UBYTE*块，UBYTE*结果）
{
整数位；
对于（位=7；位>=0；位--）
{
结果[7位]=（（块[0]>>位）和1）>位）&1）>bit）&1）>bit）&1）>bit）&1）>bit）&1）>bit）&1）为什么要标记两种语言？您只使用其中一种语言编写。请尝试在位置内联或粘贴
isBitSet
代码。更改执行路径会降低处理器的速度。编译器可能已经在执行此操作，但无需计算
newbyte_offset*1920
8次..只需做一次。也许你也可以预先计算
240*x
，然后再加上正确的一个。你能用移位避免除法吗？除法是另一个减慢执行速度的项目。试着在旧位和新位之间建立一个数学关系。所有的比较都是e放慢你的计划。谢谢马克，这看起来正是我需要的。我会尝试一下，然后再发布改进。我试图给你的答案投票，但它说我的代表太低了，无法计算。@CharlesNuzum别担心，它最终会解决的。你最终应该能够打勾，以表明这是公认的答案。@CharlesNuzum回答，但我不会这样做，直到你知道它工作得很好。嗨，马克，我想你误解了布局的改变一点，但不管怎样，对你的建议做一些改变，它工作得更快。下面是我如何使用你的代码：void transpose8x8bit（UBYTE*块，UBYTE*结果）{int位；for（bit=7；bit>=0；bit--）{result[7-bit]=（（块[0]>>位&1]>位&1）>位&1）>位&1）>位&1）>位&1）>位&1）啊，我现在明白我的错误了-你需要遍历整条线，而不是8个像素。我很高兴你找到了它！不过我会更改名称，它不再是8x8转置了。