jpeg на at91sam9g20, скорость сжатия Опции

[wmakc]

Делаю jpeg кодер для сжатия raw картинки с матрицы mt9d131. Картинка сжимается примерно за 3 секунды. Для такого контроллера это нормально?

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

Код

for(i=0; i<614400; i++)
{
     data[i] = Buffer[i];
}

Картинка около 600 килобайт. Пробовал напрямую использовать буфер(Buffer), в который ISI интерфейс записывает картинку, но во время сжатия были искажения цветов, тоесть там что-то с обращением.



Еще много времени уходит на квантование:

CODE

void fdct_and_quantization(SBYTE *data,float *fdtbl,SWORD *outdata)
{
int tmp0, tmp1, tmp2, tmp3, tmp4, tmp5, tmp6, tmp7;
int tmp10, tmp11, tmp12, tmp13;
int z1, z2, z3, z4, z5, z11, z13;
int *dataptr;
int datafloat[64];
int temp;
SBYTE ctr;
BYTE i;
for (i=0; i<64; i++)
datafloat[i] = data[i];

dataptr=datafloat;
for (ctr = 7; ctr >= 0; ctr--)
{
tmp0 = dataptr[0] + dataptr[7];
tmp7 = dataptr[0] - dataptr[7];
tmp1 = dataptr[1] + dataptr[6];
tmp6 = dataptr[1] - dataptr[6];
tmp2 = dataptr[2] + dataptr[5];
tmp5 = dataptr[2] - dataptr[5];
tmp3 = dataptr[3] + dataptr[4];
tmp4 = dataptr[3] - dataptr[4];

/* Even part */

tmp10 = tmp0 + tmp3; /* phase 2 */
tmp13 = tmp0 - tmp3;
tmp11 = tmp1 + tmp2;
tmp12 = tmp1 - tmp2;

dataptr[0] = tmp10 + tmp11; /* phase 3 */
dataptr[4] = tmp10 - tmp11;

z1 = (tmp12 + tmp13) * (0.707106781); /* c4 */
dataptr[2] = tmp13 + z1; /* phase 5 */
dataptr[6] = tmp13 - z1;

/* Odd part */

tmp10 = tmp4 + tmp5; /* phase 2 */
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;

/* The rotator is modified from fig 4-8 to avoid extra negations. */
z5 = (tmp10 - tmp12) * (0.382683433); /* c6 */
z2 = ( 0.541196100) * tmp10 + z5; /* c2-c6 */
z4 = ( 1.306562965) * tmp12 + z5; /* c2+c6 */
z3 = tmp11 * ( 0.707106781); /* c4 */

z11 = tmp7 + z3; /* phase 5 */
z13 = tmp7 - z3;

dataptr[5] = z13 + z2; /* phase 6 */
dataptr[3] = z13 - z2;
dataptr[1] = z11 + z4;
dataptr[7] = z11 - z4;

dataptr += 8; /* advance pointer to next row */
}

dataptr = datafloat;
for (ctr = 7; ctr >= 0; ctr--)
{
tmp0 = dataptr[0] + dataptr[56];
tmp7 = dataptr[0] - dataptr[56];
tmp1 = dataptr[8] + dataptr[48];
tmp6 = dataptr[8] - dataptr[48];
tmp2 = dataptr[16] + dataptr[40];
tmp5 = dataptr[16] - dataptr[40];
tmp3 = dataptr[24] + dataptr[32];
tmp4 = dataptr[24] - dataptr[32];

/* Even part */

tmp10 = tmp0 + tmp3; /* phase 2 */
tmp13 = tmp0 - tmp3;
tmp11 = tmp1 + tmp2;
tmp12 = tmp1 - tmp2;

dataptr[0] = tmp10 + tmp11; /* phase 3 */
dataptr[32] = tmp10 - tmp11;

z1 = (tmp12 + tmp13) * ( 0.707106781); /* c4 */
dataptr[16] = tmp13 + z1; /* phase 5 */
dataptr[48] = tmp13 - z1;

/* Odd part */

tmp10 = tmp4 + tmp5; /* phase 2 */
tmp11 = tmp5 + tmp6;
tmp12 = tmp6 + tmp7;

/* The rotator is modified from fig 4-8 to avoid extra negations. */
z5 = (tmp10 - tmp12) * ( 0.382683433); /* c6 */
z2 = ( 0.541196100) * tmp10 + z5; /* c2-c6 */
z4 = ( 1.306562965) * tmp12 + z5; /* c2+c6 */
z3 = tmp11 * ( 0.707106781); /* c4 */

z11 = tmp7 + z3; /* phase 5 */
z13 = tmp7 - z3;

dataptr[40] = z13 + z2; /* phase 6 */
dataptr[24] = z13 - z2;
dataptr[8] = z11 + z4;
dataptr[56] = z11 - z4;

dataptr++; /* advance pointer to next column */
}

for (i = 0; i < 64; i++)
{
/* Apply the quantization and scaling factor */
outdata[i] = datafloat[i] * fdtbl[i];
}
}

После замены у всех переменных типа float на int скорость сжатия возросла в 3 раза.

В общем вопросы по порядку:
1. Как быстро скопировать переменную в памяти( или использовать буфер isi интерфейса без порчи картинки)
2. Ускорить функцию квантования(Хотел бы разместить часть переменных в sram( она же быстрее sdram?))

Сообщение отредактировал aaarrr - Aug 21 2010, 16:33

Причина редактирования: Оформление цитаты исходника

[AlexandrY]

Реальное быстродействие памяти у микроконтроллеров такого типа можете оценить здесь:
http://eewiki.ru/wiki/Example_DRAMSpeed_for_ARMGS10

Для memcpy выравнивание практически не имеет значения, там в начале алгоритм сам подстраивает выравнивание. Разница будет только в пару десятков тактов.
Ваша пересылка должна занять не более 15 мс.

[aaarrr]

Для memcpy выравнивание практически не имеет значения, там в начале алгоритм сам подстраивает выравнивание. Разница будет только в пару десятков тактов.

Еще как имеет. Для одинаково выровненных данных при копировании будут использованы LDM/STM, если же данные выровнены не одинаково, то скоростное копирование отпадает.

[AlexandrY]

Еще как имеет. Для одинаково выровненных данных при копировании будут использованы LDM/STM, если же данные выровнены не одинаково, то скоростное копирование отпадает.

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

[aaarrr]

Ладно повторю яснее.

И я попробую яснее. Если источник имеет одно выравнивание (скажем, младшие два бита адреса равны 1), а приемник другое (например, 3), то 32-битной пересылки пачками не получится в принципе. Максимум, что можно сделать (и делается в нормальных memcpy) - это 32-битное одинарное чтение, затем перепаковка и 32-битная запись.

Иллюстрация:

Код

Word          0    1    2    3    4
              0123 0123 0123 0123 0123
Source         ABC DEFG HIJK LMNO
Destination      A BCDE FGHI JKLM NO

[AlexandrY]

И я попробую яснее. Если источник имеет одно выравнивание (скажем, младшие два бита адреса равны 1), а приемник другое (например, 3), то 32-битной пересылки пачками не получится в принципе. Максимум, что можно сделать (и делается в нормальных memcpy) - это 32-битное одинарное чтение, затем перепаковка и 32-битная запись.

Иллюстрация:

Код

Word          0    1    2    3    4
              0123 0123 0123 0123 0123
Source         ABC DEFG HIJK LMNO
Destination      A BCDE FGHI JKLM NO

Согласен. Что-то замкнуло у меня.
Надо будет проверить влияние этого на производительность.