Билинейная интерполяция с C на Neon

Question

Я пытаюсь уменьшить изображение с помощью Neon. Поэтому я попытался использовать неон, написав функцию, которая вычитает два изображения с помощью неона, и я преуспел. Теперь я вернулся, чтобы написать билинейную интерполяцию, используя неоновые свойства. Прямо сейчас у меня есть две проблемы, получая 4 пикселя из одной строки и одного столбца, а также вычисляйте интерполированное значение (серое) с 4 пикселей или если это возможно из 8 пикселей из одной строки и одной колонки. Я пытался подумать об этом, но я думаю, что алгоритм должен быть переписан вообще?

void resizeBilinearNeon(uint8_t *src, uint8_t *dest, float srcWidth, float srcHeight, float destWidth, float destHeight) 
{ 

    int A, B, C, D, x, y, index; 

     float x_ratio = ((float)(srcWidth-1))/destWidth ; 
     float y_ratio = ((float)(srcHeight-1))/destHeight ; 
     float x_diff, y_diff; 

     for (int i=0;i<destHeight;i++) { 
      for (int j=0;j<destWidth;j++) { 
       x = (int)(x_ratio * j) ; 
       y = (int)(y_ratio * i) ; 
       x_diff = (x_ratio * j) - x ; 
       y_diff = (y_ratio * i) - y ; 
       index = y*srcWidth+x ; 

       uint8x8_t pixels_r = vld1_u8 (src[index]); 
       uint8x8_t pixels_c = vld1_u8 (src[index+srcWidth]); 

       // Y = A(1-w)(1-h) + B(w)(1-h) + C(h)(1-w) + Dwh 
       gray = (int)(
          pixels_r[0]*(1-x_diff)*(1-y_diff) + pixels_r[1]*(x_diff)*(1-y_diff) + 
          pixels_c[0]*(y_diff)*(1-x_diff) + pixels_c[1]*(x_diff*y_diff) 
          ) ; 

       dest[i*w2 + j] = gray ; 
      } 
    } 

Answer 1

@MarkRansom не подходит для ближайшего соседа по сравнению с 2x2 билинейной интерполяцией; bilinear с использованием 4 пикселей обеспечит лучший выход, чем ближайший сосед. Он прав, что усреднение соответствующего количества пикселей (более 4 при масштабировании на> 2: 1) приведет к получению лучшего результата. Однако NEON не поможет с уменьшением дискретизации изображения, если масштабирование не выполняется с помощью отношения целого числа.

Максимальное преимущество наборов инструкций NEON и других SIMD - это возможность обрабатывать 8 или 16 пикселей одновременно с использованием тех же операций. Получая доступ к отдельным элементам таким образом, вы теряете все преимущества SIMD. Другая проблема заключается в том, что перемещение данных из регистров NEON в ARM является медленной. Изображения с понижающей дискретизацией лучше всего выполнять с помощью графического процессора или оптимизированных команд ARM.

Answer 2

Neon определенно поможет с понижающей дискретизацией в произвольном соотношении с использованием билинейной фильтрации. Ключ является грамотным использованием инструкции vtbl.8, который способен выполнить параллельный просмотровый стол на 8 последовательных пиксели назначения из предварительно загруженного массива:

d0 = a [b] c [d] e [f] g h, d1 = i j k l m n o p 
d2 = q r s t u v [w] x, d3 = [y] z [A] B [C][D] E F ... 
d4 = G H I J K L M N, d5 = O P Q R S T U V ... 

можно легко вычислить дробные позиции для в скобках:

[b] [d] [f] [w] [y] [A] [C] [D], accessed with vtbl.8 d6, {d0,d1,d2,d3} 
The row below would be accessed with   vtbl.8 d7, {d2,d3,d4,d5} 

Incrementing vadd.8 d6, d30; с d30 = [1 1 1 1 1 ... 1] дает индексы поиска для пикселей справа от начала координат и т. д.

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

В приложениях реального времени, использующих, например, из lanzcos может быть немного избыточным, но все же осуществимым с использованием NEON. Уменьшение дискретизации больших факторов требует, конечно, (тяжелой) фильтрации, но может быть легко достигнуто с итерационным усреднением и декомпрессией на 2: 1 и только в конце с использованием дробного отбора проб.

Для любых 8 последовательных пикселей писать, можно вычислить вектор

x_positions = (X + [0 1 2 3 4 5 6 7]) * source_width/target_width; 
    y_positions = (Y + [0 0 0 0 0 0 0 0]) * source_height/target_height; 

    ptr = to_int(x_positions) + y_positions * stride; 
    x_position += (ptr & 7); // this pointer arithmetic goes only for 8-bit planar 
    ptr &= ~7;    // this is to adjust read pointer to qword alignment 

    vld1.8 {d0,d1}, [r0] 
    vld1.8 {d2,d3], [r0], r2 // wasn't this possible? (use r2==stride) 

    d4 = int_part_of (x_positions); 
    d5 = d4 + 1; 
    d6 = fract_part_of (x_positions); 
    d7 = fract_part_of (y_positions); 

    vtbl.8 d8,d4,{d0,d1} // read top row 
    vtbl.8 d9,d5,{d0,d1} // read top row +1 
    MIX(d8,d9,d6)    // horizontal mix of ptr[] & ptr[1] 
    vtbl.8 d10,d4,{d2,d3} // read bottom row 
    vtbl.8 d11,d5,{d2,d3} // read bottom row 
    MIX(d10,d11,d6)   // horizontal mix of ptr[1024] & ptr[1025] 
    MIX(d8,d10,d7) 

    // MIX (dst, src, fract) is a macro that somehow does linear blending 
    // should be doable with ~3-4 instructions 

Для вычисления целых частей, достаточно использовать 8.8 разрядное разрешение (один действительно не должен рассчитывать 666+ [0 1 2 3 .. 7]) и сохранить все промежуточные результаты в регистре simd.

Отказ от ответственности - это концептуальный псевдо-векторный код. В SIMD есть две параллельные задачи, которые необходимо оптимизировать: какова минимальная сумма необходимых арифметических операций и как минимизировать ненужное перетасовку/копирование данных. В этом отношении также NEON с тремя методами регистрации намного лучше подходит для серьезных DSP, чем SSE. Второе отношение - это сумма команды умножения и третье преимущество команд чередования.