Как преобразовать буфер BYTE (от 0 до 255) в буфер с плавающей запятой (от 0,0 до 1,0)? Конечно, между двумя значениями должна быть связь, например: 0 в байтовом буфере будет .0.f в плавающем буфере, 128 в байтовом буфере будет .5f в плавающем буфере, 255 в байтовом буфере будет 1.f в буфер с плавающей запятой.

На самом деле это код, который у меня есть:

for (int y=0;y<height;y++) {
    for (int x=0;x<width;x++) {
        float* floatpixel = floatbuffer + (y * width + x) * 4;
        BYTE* bytepixel = (bytebuffer + (y * width + x) * 4);
        floatpixel[0] = bytepixel[0]/255.f;
        floatpixel[1] = bytepixel[1]/255.f;
        floatpixel[2] = bytepixel[2]/255.f;
        floatpixel[3] = 1.0f; // A
    }
}

Это работает очень медленно. Мой друг посоветовал мне использовать таблицу преобразования, но я хотел знать, может ли кто-нибудь предложить мне другой подход.

7
Jorjon 25 Июн 2009 в 17:00

7 ответов

Лучший ответ

Независимо от того, решите вы использовать таблицу поиска или нет, ваш код выполняет много работы на каждой итерации цикла, в которой он действительно не нуждается - вероятно, достаточно, чтобы затмить стоимость преобразования и умножения.

Объявите свои указатели ограниченными и указатели, которые вы читаете только из константы. Умножьте на 1/255 вместо деления на 255. Не вычисляйте указатели на каждой итерации внутреннего цикла, просто вычисляйте начальные значения и увеличивайте их. Разверните внутреннюю петлю несколько раз. Используйте векторные операции SIMD, если ваша цель это поддерживает. Не увеличивайте и не сравнивайте с максимумом, вместо этого уменьшайте и сравнивайте с нулем.

Что-то типа

float* restrict floatpixel = floatbuffer;
BYTE const* restrict bytepixel = bytebuffer;
for( int size = width*height; size > 0; --size )
{
    floatpixel[0] = bytepixel[0]*(1.f/255.f);
    floatpixel[1] = bytepixel[1]*(1.f/255.f);
    floatpixel[2] = bytepixel[2]*(1.f/255.f);
    floatpixel[3] = 1.0f; // A
    floatpixel += 4;
    bytepixel += 4;
}

Было бы началом.

9
moonshadow 25 Июн 2009 в 13:19

Я знаю, что это старый вопрос, но, поскольку никто не дал решения, использующего представление с плавающей запятой IEEE, вот один.

// Use three unions instead of one to avoid pipeline stalls
union { float f; uint32_t i; } t, u, v, w;
t.f = 32768.0f;
float const b = 256.f / 255.f;

for(int size = width * height; size > 0; --size)
{
    u.i = t.i | bytepixel[0]; floatpixel[0] = (u.f - t.f) * b;
    v.i = t.i | bytepixel[1]; floatpixel[1] = (v.f - t.f) * b;
    w.i = t.i | bytepixel[2]; floatpixel[2] = (w.f - t.f) * b;
    floatpixel[3] = 1.0f; // A
    floatpixel += 4;
    bytepixel += 4;
}

Это более чем в два раза быстрее , чем преобразование int в float на моем компьютере (процессор Core 2 Duo).

Вот версия приведенного выше кода для SSE3, которая выполняет 16 операций с плавающей запятой за раз. Для этого требуется, чтобы bytepixel и floatpixel были выровнены по 128 бит, а общий размер был кратен 4. Обратите внимание, что встроенный в SSE3 int для преобразований с плавающей запятой здесь не поможет, поскольку они в любом случае потребуется дополнительное умножение. Я считаю, что это кратчайший путь с точки зрения инструкций, но если ваш компилятор недостаточно умен, вы можете развернуть и запланировать действия вручную.

/* Magic values */
__m128i zero = _mm_set_epi32(0, 0, 0, 0);
__m128i magic1 = _mm_set_epi32(0xff000000, 0xff000000, 0xff000000, 0xff000000);
__m128i magic2 = _mm_set_epi32(0x47004700, 0x47004700, 0x47004700, 0x47004700);
__m128 magic3 = _mm_set_ps(32768.0f, 32768.0f, 32768.0f, 32768.0f);
__m128 magic4 = _mm_set_ps(256.0f / 255.0f, 256.0f / 255.0f, 256.0f / 255.0f, 256.0f / 255.0f);

for(int size = width * height / 4; size > 0; --size)
{
    /* Load bytes in vector and force alpha value to 255 so that
     * the output will be 1.0f as expected. */
    __m128i in = _mm_load_si128((__m128i *)bytepixel);
    in = _mm_or_si128(in, magic1);

    /* Shuffle bytes into four ints ORed with 32768.0f and cast
     * to float (the cast is free). */
    __m128i tmplo = _mm_unpacklo_epi8(in, zero);
    __m128i tmphi = _mm_unpackhi_epi8(in, zero);
    __m128 in1 = _mm_castsi128_ps(_mm_unpacklo_epi16(tmplo, magic2));
    __m128 in2 = _mm_castsi128_ps(_mm_unpackhi_epi16(tmplo, magic2));
    __m128 in3 = _mm_castsi128_ps(_mm_unpacklo_epi16(tmphi, magic2));
    __m128 in4 = _mm_castsi128_ps(_mm_unpackhi_epi16(tmphi, magic2));

    /* Subtract 32768.0f and multiply by 256.0f/255.0f */
    __m128 out1 = _mm_mul_ps(_mm_sub_ps(in1, magic3), magic4);
    __m128 out2 = _mm_mul_ps(_mm_sub_ps(in2, magic3), magic4);
    __m128 out3 = _mm_mul_ps(_mm_sub_ps(in3, magic3), magic4);
    __m128 out4 = _mm_mul_ps(_mm_sub_ps(in4, magic3), magic4);

    /* Store 16 floats */
    _mm_store_ps(floatpixel, out1);
    _mm_store_ps(floatpixel + 4, out2);
    _mm_store_ps(floatpixel + 8, out3);
    _mm_store_ps(floatpixel + 12, out4);

    floatpixel += 16;
    bytepixel += 16;
}

Изменить : повысьте точность, используя (f + c/b) * b вместо f * b + c.

Изменить : добавьте версию SSE3.

8
sam hocevar 25 Мар 2011 в 14:12

Используйте для этого статическую таблицу поиска. Когда я работал в компании, занимающейся компьютерной графикой, у нас появилась жестко закодированная таблица поиска для этого, которую мы связали с проектом.

2
Mats Fredriksson 25 Июн 2009 в 13:12

Вам необходимо выяснить, в чем заключается узкое место:

  • если вы повторяете свои таблицы данных в «неправильном» направлении, вы постоянно сталкиваетесь с промахом в кэше. Никакой поиск никогда не поможет обойти это.
  • если ваш процессор масштабируется медленнее, чем поиск, вы можете повысить производительность, выполнив поиск, при условии, что таблица поиска соответствует его кеш-памяти.

Еще один совет:

struct Scale {
    BYTE operator()( const float f ) const { return f * 1./255; }
};
std::transform( float_table, float_table + itssize, floatpixel, Scale() );
2
xtofl 25 Июн 2009 в 13:19

Да, справочная таблица определенно быстрее, чем выполнение большого количества делений в цикле. Просто создайте таблицу из 256 предварительно вычисленных значений с плавающей запятой и используйте значение байта для индексации этой таблицы.

Вы также можете немного оптимизировать цикл, удалив вычисление индекса и просто сделав что-то вроде

float *floatpixel = floatbuffer;
BYTE *bytepixel = bytebuffer;

for (...) {
  *floatpixel++ = float_table[*bytepixel++];
  *floatpixel++ = float_table[*bytepixel++];
  *floatpixel++ = float_table[*bytepixel++];
  *floatpixel++ = 1.0f;
}
1
laalto 25 Июн 2009 в 13:14

Справочная таблица - самый быстрый способ конвертировать :) Вот и все:

Код Python для создания файла byte_to_float.h, включающего:

#!/usr/bin/env python

def main():
    print "static const float byte_to_float[] = {"

    for ii in range(0, 255):
        print "%sf," % (ii/255.0)

    print "1.0f };"    
    return 0

if __name__ == "__main__":
    main()

И код C ++ для преобразования:

floatpixel[0] = byte_to_float[ bytepixel[0] ];

Просто не правда ли?

1
Viet 1 Мар 2010 в 11:22

Не рассчитывайте каждый раз 1/255. Не знаю, хватит ли у компилятора умен, чтобы это удалить. Рассчитайте его один раз и применяйте каждый раз повторно. Еще лучше, определите его как константу.

0
Rodyland 26 Июн 2009 в 05:28