#include <stdlib.h>

//Максимальное кол-во областей в изображении
#define MAX_AREAS 1000
#define min(x,y) (x<y?x:y)

//Структура хранения информации об областях
typedef struct TAreaInfo
{
    //Номер кластера
    short iNumber;
    //Номер моды
    short iMode;
    //Счётчик мощности моды
    int iCount;
} TAreaInfo;

//Счётчики количества областей в изображении и в контейнере
static int iAreasCount=0, iAreasInfoCount=0;

//Ограниченный массив структур описателей областей!!!
static TAreaInfo AreasInfo[MAX_AREAS+1];

//Таблица соответствия значений пикселов модам гистограммы
static int ModeNumb4Pix[256];

//Функция создания новой области
static inline int AddNewAreaInfo(const int iModeNumb)
{
//    if (iAreasInfoCount>=MAX_AREAS) return -1;
    iAreasCount++;
    AreasInfo[iAreasInfoCount].iMode=iModeNumb;
    AreasInfo[iAreasInfoCount].iNumber=-1;
    AreasInfo[iAreasInfoCount].iCount=0;
    return iAreasInfoCount++;
}

/*!\brief Разбиение изображения на непересекающиеся области
* \param Image - исходное изображение
* \param Height - высота изображения
* \param Width - ширина изображение
* \param AreasNumbBuf - буфер результата, отражающий номера областей каждого из пикселов
* \param Thr1 - нижний порог
* \param Thr2 - верхний порог
* \result Количество непересекающихся областей в изображении
*/
int SplitImage2Areas(
    register unsigned char ** __restrict Image,
    register int Height, register int Width,
    register int ** __restrict AreasNumbBuf,
    register int Thr1, register int Thr2)
{
    //Изображение последовательно просматривается по строкам
    //для отнесения каждого пиксела к определённой области
    //Вычисление площади, занимаемой каждой областью и модой
    register int iPrevAreaNumbL=-1;  //Номер области предыдущей левой точки
    register int iPrevModeNumbL=-1;  //Номер моды предыдущей левой точки
    register int iPrevAreaNumbU=-1;  //Номер области предыдущей верхней точки
    register int iPrevModeNumbU=-1;  //Номер моды предыдущей верхней точки
    register int iPrevAreaNumbUL=-1; //Номер области предыдущей верхней левой точки
    register int iPrevModeNumbUL=-1; //Номер моды предыдущей верхней левой точки
    register int iPrevAreaNumbUR=-1; //Номер области предыдущей верхней правой точки
    register int iPrevModeNumbUR=-1; //Номер моды предыдущей верхней правой точки
    //Временные переменные
    register int i, y, x, iSrcIndex, iDstIndex, iDelta, iTmp;
    register int iCurrPixel, iCurrAreaNumb, iCurrModeNumb;
    register TAreaInfo * __restrict pSrcObj, * __restrict pDstObj, * __restrict pTmpObj;

    //Проверка корректности входных параметров
    if ((Image==0)||(Width<=0)||(Height<=0)||(ModeNumb4Pix==0)||(AreasNumbBuf==0)) return -1;
    //Формирование таблицы мод пикселей
    for (i=0; i<256; i++)
    {
        if (i<Thr1)
            ModeNumb4Pix[i]=0;
        else if (i>=Thr2)
            ModeNumb4Pix[i]=1;
        else
            ModeNumb4Pix[i]=-1;
    }
    //Обнуление счётчиков кол-ва областей
    iAreasCount=iAreasInfoCount=0;
    //Обработка верхней левой точки изображения
    iCurrPixel=Image[0][0];
    iCurrModeNumb=ModeNumb4Pix[iCurrPixel];
    if (iCurrModeNumb<0)
    {
        //Сканирование зигзагом окрестных точек для
        //выявления ближайшей с установленной модой
        iDelta=min(Width,Height);
        for (i=1; i<iDelta; i++)
        {
            iSrcIndex=-1;
            for (y=i, x=0; y>=0; y--, x++)
            {
                iDstIndex=Image[y][x];
                iTmp=ModeNumb4Pix[iDstIndex];
                if (iTmp<0) continue;
                iDstIndex=abs(iDstIndex-iCurrPixel);
                if ((iSrcIndex<0)||(iSrcIndex>iDstIndex))
                {
                    iSrcIndex=iDstIndex;
                    iCurrModeNumb=iTmp;
                }
            }
            //Нашли подходящую точку - выход из поиска
            if (iCurrModeNumb>=0) break;
        }
        //Если точек нет, то нулевая мода
        if (iCurrModeNumb<0) iCurrModeNumb=0;
    }
    iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
    AreasNumbBuf[0][0]=iCurrAreaNumb;
    //Обработка первой верхней строки изображения,
    //начиная со второго пиксела строки
    for (x=1; x<Width; x++)
    {
        //Запоминание номера области и моды для левой точки
        iPrevAreaNumbL=iCurrAreaNumb;
        iPrevModeNumbL=iCurrModeNumb;
        //Номер моды текущей точки
        iCurrModeNumb=ModeNumb4Pix[Image[0][x]];
        //В зависимости от наличия моды
        if (iCurrModeNumb<0) {
            iCurrModeNumb=iPrevModeNumbL;
            iCurrAreaNumb=iPrevAreaNumbL;
        }
        else if (iCurrModeNumb==iPrevModeNumbL) {
            iCurrAreaNumb=iPrevAreaNumbL;
        }
        else {
            //Добавление новой области
            iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
        }
        //Установка номера области текущей точки
        AreasNumbBuf[0][x] = iCurrAreaNumb;
        //Инкремент счётчика площади, занимаемой областью
        AreasInfo[iCurrAreaNumb].iCount++;
    }
    //Декремент ширины изображения для увеличения скорости обработки
    Width--;
    //Цикл по всем точкам изображения
    for (y=1; y<Height; y++)
    {
        //Установка начального значения для верхней левой точки
        iPrevAreaNumbUL=AreasNumbBuf[y-1][0];
        iPrevModeNumbUL=AreasInfo[iPrevAreaNumbUL].iMode;
        //Установка начального значения для верхней точки
        iPrevAreaNumbU=AreasNumbBuf[y-1][1];
        iPrevModeNumbU=AreasInfo[iPrevAreaNumbU].iMode;
        //Значение яркости первого пикселя строки
        iCurrPixel=Image[y][0];
        //Значение моды первого пикселя строки
        iPrevModeNumbL=ModeNumb4Pix[iCurrPixel];
        //В зависимости от признака переходности пиксела
        if (iPrevModeNumbL<0) {
            if (abs(iCurrPixel-Image[y-1][0])<abs(iCurrPixel-Image[y-1][1]))
            {
                iPrevModeNumbL=iPrevModeNumbUL;
                iPrevAreaNumbL=iPrevAreaNumbUL;
            }
            else
            {
                iPrevModeNumbL=iPrevModeNumbU;
                iPrevAreaNumbL=iPrevAreaNumbU;
            }
        }
        else if (iPrevModeNumbL==iPrevModeNumbUL)
            iPrevAreaNumbL=iPrevAreaNumbUL; //Верхняя левая точка
        else if (iPrevModeNumbL==iPrevModeNumbU)
            iPrevAreaNumbL=iPrevAreaNumbU;  //Верхняя точка
        else {
            //Добавление новой области
            iPrevAreaNumbL=AddNewAreaInfo(iPrevModeNumbL);
        }
        //Установка номера области первого пиксела строки
        AreasNumbBuf[y][0] = iPrevAreaNumbL;
        //Инкремент счётчика площади, занимаемой областью
        AreasInfo[iPrevAreaNumbL].iCount++;
        //Обработка очередной строки изображения
        for (x=1; x<Width; x++)
        {
            //Определение параметров верхней правой точки
            iPrevAreaNumbUR=AreasNumbBuf[y-1][x+1];
            iPrevModeNumbUR=AreasInfo[iPrevAreaNumbUR].iMode;
            //Значение яркости текущего пикселя
            iCurrPixel=Image[y][x];
            //Номер моды текущей точки
            iCurrModeNumb=ModeNumb4Pix[iCurrPixel];
            //В зависимости от того является ли точка переходной
            if (iCurrModeNumb<0)
            {
                //Текущая точка является переходной к любой области
                //Перебор всех точек окрестности и выбор наиболее близкой области
                //Левая точка
                iDelta=abs(Image[y][x-1]-iCurrPixel);
                iCurrAreaNumb=iPrevAreaNumbL;
                iCurrModeNumb=iPrevModeNumbL;
                //Верхняя точка
                iTmp=abs(Image[y-1][x]-iCurrPixel);
                if (iDelta>iTmp) {
                    iDelta=iTmp;
                    iCurrAreaNumb=iPrevAreaNumbU;
                    iCurrModeNumb=iPrevModeNumbU;
                }
                //Верхняя левая точка
                iTmp=abs(Image[y-1][x-1]-iCurrPixel);
                if (iDelta>iTmp) {
                    iDelta=iTmp;
                    iCurrAreaNumb=iPrevAreaNumbUL;
                    iCurrModeNumb=iPrevModeNumbUL;
                }
                //Верхняя правая точка
                iTmp=abs(Image[y-1][x+1]-iCurrPixel);
                if (iDelta>iTmp) {
                    iDelta=iTmp;
                    iCurrAreaNumb=iPrevAreaNumbUR;
                    iCurrModeNumb=iPrevModeNumbUR;
                }
            }
            //Эта точка не является переходной ни к одной из мод
            //Просмотр всех соседних уже размеченных ранее точек
            //для возможного определения номера области текущей точки
            else if (iCurrModeNumb==iPrevModeNumbL)
                    iCurrAreaNumb=iPrevAreaNumbL;  //Левая точка
            else if (iCurrModeNumb==iPrevModeNumbUL)
                    iCurrAreaNumb=iPrevAreaNumbUL; //Верхняя левая точка
            else if (iCurrModeNumb==iPrevModeNumbU)
                    iCurrAreaNumb=iPrevAreaNumbU;  //Верхняя точка
            else if (iCurrModeNumb==iPrevModeNumbUR)
                    iCurrAreaNumb=iPrevAreaNumbUR; //Верхняя правая точка
            else {
                //Добавление новой области
                iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
            }
            //Установка номера области текущей точки
            AreasNumbBuf[y][x] = iCurrAreaNumb;
            //Объект области в дереве
            pSrcObj=&AreasInfo[iCurrAreaNumb];
            //Инкремент счётчика площади, занимаемой областью
            pSrcObj->iCount++;
            //Сканирование верхней правой точки для добавления её в список соседних областей
            if ((iCurrModeNumb==iPrevModeNumbUR)&&(iCurrAreaNumb!=iPrevAreaNumbUR))
            {
                //Объект области предыдущей ссылки
                pDstObj=&AreasInfo[iPrevAreaNumbUR];
                //Всего четыре возможных варианта
                if (pSrcObj->iNumber<0)
                {
                    if (pDstObj->iNumber>=0)
                    {
                        //Только добавляется ссылка на ссылочную область
                        pSrcObj->iNumber=pDstObj->iNumber;
                        //Декремент кол-ва областей
                        iAreasCount--;
                    }
                    else
                    {
                        //Обе области являются доменными
                        iTmp=min(iCurrAreaNumb,iPrevAreaNumbUR);
                        pSrcObj->iNumber=iTmp;
                        pDstObj->iNumber=iTmp;
                        //Декремент кол-ва областей
                        iAreasCount--;
                    }
                }
                else //if (pSrcObj->iNumber>=0)
                {
                    if (pDstObj->iNumber<0)
                    {
                        //Только добавляется ссылка на ссылочную область
                        pDstObj->iNumber=pSrcObj->iNumber;
                        //Декремент кол-ва областей
                        iAreasCount--;
                    }
                    else
                    {
                        iSrcIndex=pSrcObj->iNumber;
                        iDstIndex=pDstObj->iNumber;
                        if (iSrcIndex!=iDstIndex)
                        {
                            //Это самый трудоёмкий случай.
                            //Но, к счастью, самый редкий!
                            //Необходимо объединить две области
                            for (i=0; i<iAreasInfoCount; i++)
                            {
                                pTmpObj=&AreasInfo[i];
                                if (pTmpObj->iNumber==iSrcIndex)
                                    pTmpObj->iNumber=iDstIndex;
                            }
                            //Декремент кол-ва областей
                            iAreasCount--;
                        }
                    }
                }
            }
            //Запоминание номера области и моды для левой точки
            iPrevAreaNumbL=iCurrAreaNumb;
            iPrevModeNumbL=iCurrModeNumb;
            //Запоминание номера области и моды для верхней левой точки
            iPrevAreaNumbUL=iPrevAreaNumbU;
            iPrevModeNumbUL=iPrevModeNumbU;
            //Запоминание номера области и моды для верхней точки
            iPrevAreaNumbU=iPrevAreaNumbUR;
            iPrevModeNumbU=iPrevModeNumbUR;
        }
        //Значение яркости последнего пикселя строки
        iCurrPixel=Image[y][Width];
        //Значение моды последнего пикселя строки
        iCurrModeNumb=ModeNumb4Pix[iCurrPixel];
        //В зависимости от наличия моды
        if (iCurrModeNumb<0) {
            //Левая точка
            iDelta=abs(Image[y][x-1]-iCurrPixel);
            iCurrAreaNumb=iPrevAreaNumbL;
            iCurrModeNumb=iPrevModeNumbL;
            //Верхняя левая точка
            iTmp=abs(Image[y-1][x-1]-iCurrPixel);
            if (iDelta>iTmp) {
                iDelta=iTmp;
                iCurrAreaNumb=iPrevAreaNumbUL;
                iCurrModeNumb=iPrevModeNumbUL;
            }
            //Верхняя точка
            iTmp=abs(Image[y-1][x]-iCurrPixel);
            if (iDelta>iTmp) {
                iDelta=iTmp;
                iCurrAreaNumb=iPrevAreaNumbU;
                iCurrModeNumb=iPrevModeNumbU;
            }
        }
        else if (iCurrModeNumb==iPrevModeNumbL)
            iCurrAreaNumb=iPrevAreaNumbL;  //Левая точка
        else if (iCurrModeNumb==iPrevModeNumbUL)
            iCurrAreaNumb=iPrevAreaNumbUL; //Верхняя левая точка
        else if (iCurrModeNumb==iPrevModeNumbU)
            iCurrAreaNumb=iPrevAreaNumbU;  //Верхняя правая точка
        else {
            //Добавление новой области
            iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
        }
        //Установка номера области последнего пикселя строки
        AreasNumbBuf[y][Width] = iCurrAreaNumb;
        //Инкремент счётчика площади, занимаемой областью
        AreasInfo[iCurrAreaNumb].iCount++;
    }
    //Восстановление исходной ширины изображения
    Width++;

    //Упорядочивание переадресации областей (именно здесь)!!!!!
    for (i=0; i<iAreasInfoCount; i++)
    {
        pTmpObj=&AreasInfo[i];
        iTmp=pTmpObj->iNumber;
        if (iTmp<0)
        {
            //Это независимый кластер
            pTmpObj->iNumber=i;
        }
        else if (iTmp!=i)
        {
            //Это не кластерная область
            AreasInfo[iTmp].iCount+=pTmpObj->iCount;
            //Обнуление счётчика - выключение области
            pTmpObj->iCount=0;
        }
    }

    //Могут оставаться независимые области с индексами больше iAreasCount
    for (iDstIndex=0, iSrcIndex=iAreasCount; iSrcIndex<iAreasInfoCount; iSrcIndex++)
    {
        //Если эта область уже переадресована - все нормально
        pSrcObj=&AreasInfo[iSrcIndex];
        if ((pSrcObj==NULL)||(pSrcObj->iCount==0)) continue;
        //Поиск индекса для переадресации
        for (; iDstIndex<iAreasCount; iDstIndex++)
        {
            pDstObj=&AreasInfo[iDstIndex];
            if ((pDstObj!=NULL)&&(pDstObj->iCount==0)) break;
        }
        //Сохранение указателя на моду
        pDstObj->iMode=pSrcObj->iMode;
        //Коррекция счётчиков мощности областей
        pDstObj->iCount=pSrcObj->iCount;
        pSrcObj->iCount=0;
        //Установка ссылки данной области на переадресованную
        pSrcObj->iNumber=iDstIndex;
        //Замена всех ссылок на эту область!!!!!!!!
        for (i=0; i<iAreasInfoCount; i++)
        {
            pTmpObj=&AreasInfo[i];
            if (pTmpObj->iNumber==iSrcIndex) pTmpObj->iNumber=iDstIndex;
        }
    }

    //Переписывание индексов областей на новые переназначенные
    for (y=0; y<Height; y++) for (x=0; x<Width; x++)
    {
        iTmp=AreasNumbBuf[y][x];
        iTmp=AreasInfo[iTmp].iNumber;
        AreasNumbBuf[y][x]=iTmp;
    }

    return iAreasCount;
}

void calcModes(unsigned char * restrict image, char * restrict modes, int pixelsCount, int thresold1, int thresold2)
{  
    int thresoldLo=_packl4(_pack2(thresold1,thresold1),_pack2(thresold1,thresold1));
    int thresoldHi=_packl4(_pack2(thresold2,thresold2),_pack2(thresold2,thresold2));

    for(int i=0;i<pixelsCount;i+=8)
    {
        // Загрузим сразу 8 пикселов
        double pixels=_amemd8_const(image+i);                       // D

        // Если пиксел >= thresold1, то в соответсвующем байте будет 0xff
        int compare1Lo=_xpnd4(_cmpgtu4(_lo(pixels),thresoldLo));    // L + M

        // Если пиксел >= thresold2, то в соответсвующем байте будет 0xff
        int compare1Hi=_xpnd4(_cmpgtu4(_lo(pixels),thresoldHi));    // L + M

        // Здесь очень удачно все сложилось - возможны три варианта:
        // если пиксел>=thresold1 и пиксел<thresold2, то получится 0xff ^ 0x00 = 0xff = -1;
        // если пиксел>=thresold1 и пиксел>=thresold2, то получится 0xff ^ 0xfe = 0x01
        // если пиксел<thresold, то пиксел<thresold2 и получается 0x00 ^ 0x00 = 0x00
        int result1=compare1Lo ^ (compare1Hi & 0xfefefefe);         // LSD + LSD


        // Здесь все тоже самое, для оставшихся четырех пикселов
        int compare2Lo=_xpnd4(_cmpgtu4(_hi(pixels),thresoldLo));    // L + M
        int compare2Hi=_xpnd4(_cmpgtu4(_hi(pixels),thresoldHi));    // L + M

        int result2=compare2Lo ^ (compare2Hi & 0xfefefefe);         // LSD + LSD

        // Сохраним результат
        _amemd8(image+i)=_itod(result2,result1);                    // D

        // Здесь получаем, что 4L и 4M юнита - два цикла; еще осталось 4S и 4D, 2D на загрузку
        // уйдет -> остается 4S и 2D юнита, для внутренностей цикла надо 4LSD => останется два S
        // юнита на поддержание цикла. Теоретически, производительность кода - 2 такта на 8 пикселов
        // или 0.25 такта на пиксел. При этом удалось добиться соответствия со значениями мод из
        // оригинального кода, добавив лишь одно ограничение по - количество пикселей должно быть кратно 8.
        // Следует также отметить, что даже при больших размерах изображения, не возникает простоя из-за
        // того, что данные не находятся в кэше.
    }
}

    //Обработка первой верхней строки изображения, начиная со второго пиксела строки
    for (x=1; x<Width; x++)
    {
        //Запоминание номера области и моды для левой точки
        iPrevAreaNumbL=iCurrAreaNumb;
        iPrevModeNumbL=iCurrModeNumb;
        //Номер моды текущей точки
        iCurrModeNumb=ModeNumb4Pix[Image[0][x]];
        //В зависимости от наличия моды
        if (iCurrModeNumb<0) {
            iCurrModeNumb=iPrevModeNumbL;
            iCurrAreaNumb=iPrevAreaNumbL;
        }
        else if (iCurrModeNumb==iPrevModeNumbL) {
            iCurrAreaNumb=iPrevAreaNumbL;
        }
        else {
            //Добавление новой области
            iCurrAreaNumb=AddNewAreaInfo(iCurrModeNumb);
        }
        //Установка номера области текущей точки
        AreasNumbBuf[0][x] = iCurrAreaNumb;
        //Инкремент счётчика площади, занимаемой областью
        AreasInfo[iCurrAreaNumb].iCount++;
    }

#include <stdlib.h>
#include <csl_dat.h>

#define IMG_WIDTH  640
#define IMG_HEIGHT 480

// Буферы для кэширования строк изображения
static unsigned char ModesBuf[3][IMG_WIDTH];

//Функция, классифицирующая пикселы изображения по модам
void SplitImage2Modes(unsigned char ** restrict image, unsigned char ** restrict modes,
    int thresold1, int thresold2)
{
    //Рабочие регистры цикла
    int lockPixels, compareLo, compareHi, result1, result2;
    unsigned char * restrict pCurrLineBuf;
    double pixels;

    //Open DAT-chanel
    DAT_open(DAT_CHAANY, DAT_PRI_HIGH, 0);

    //Загрузка первой строки изображения
    Uint32 id_LoadTransfer = DAT_copy(image[0], ModesBuf[0], IMG_WIDTH);
    //Начальная инициализация идентификатора канала сохранения
    Uint32 id_SaveTransfer=DAT_XFRID_WAITNONE;

    //кольцевой указатель на буфер текущей строки
    int iCurrBufIndex=0;

    //пакеты порогов
    int thresoldLo=_packl4(_pack2(thresold1,thresold1),_pack2(thresold1,thresold1));
    int thresoldHi=_packl4(_pack2(thresold2,thresold2),_pack2(thresold2,thresold2));

    //цикл по всем строкам изображения
//#pragma MUST_ITERATE(IMG_HEIGHT, IMG_HEIGHT);
    for(int y=0; y<IMG_HEIGHT; y++)
    {
        //Указатель на текущую обрабатываемую строку
        pCurrLineBuf = ModesBuf[iCurrBufIndex];
        //Продвижение индекса на следующую строку
        iCurrBufIndex++; iCurrBufIndex%=3;
        //Ожидание окончания загрузки текущей строки изображения
        while(DAT_busy(id_LoadTransfer));
        //Запуск загрузки следующей строки изображения
        id_LoadTransfer = DAT_copy(image[y+1], ModesBuf[iCurrBufIndex], IMG_WIDTH);
        //обработка текущей строки
//#pragma MUST_ITERATE(IMG_WIDTH/8, IMG_WIDTH/8);
        for(int x=0; x<IMG_WIDTH; x+=8)
        {
            // Загрузим сразу 8 пикселов
            pixels=_amemd8_const(pCurrLineBuf+x);                  // D

            //Первые четыре пиксела
            lockPixels=_lo(pixels);

            // Если пиксел >= thresold1, то в соответсвующем байте будет 0xff
            compareLo=_xpnd4(_cmpgtu4(lockPixels,thresoldLo));     // L + M

            // Если пиксел >= thresold2, то в соответсвующем байте будет 0xff
            compareHi=_xpnd4(_cmpgtu4(lockPixels,thresoldHi));     // L + M

            // Здесь очень удачно все сложилось - возможны три варианта:
            // если пиксел>=thresold1 и пиксел<thresold2, то получится 0xff ^ 0x00 = 0xff = -1;
            // если пиксел>=thresold1 и пиксел>=thresold2, то получится 0xff ^ 0xfe = 0x01
            // если пиксел<thresold, то пиксел<thresold2 и получается 0x00 ^ 0x00 = 0x00
            result1=compareLo ^ (compareHi & 0xfefefefe);          // LSD + LSD

            // Здесь все тоже самое, для оставшихся четырех пикселов
            lockPixels=_hi(pixels);

            compareLo=_xpnd4(_cmpgtu4(lockPixels,thresoldLo));     // L + M
            compareHi=_xpnd4(_cmpgtu4(lockPixels,thresoldHi));     // L + M

            result2=compareLo ^ (compareHi & 0xfefefefe);          // LSD + LSD

            // Сохраним результат
            _amemd8(pCurrLineBuf+x)=_itod(result2,result1);        // D

            // Здесь получаем, что 4L и 4M юнита - два цикла; еще осталось 4S и 4D, 2D на загрузку
            // уйдет -> остается 4S и 2D юнита, для внутренностей цикла надо 4LSD => останется два S
            // юнита на поддержание цикла. Теоретически, производительность кода - 2 такта на 8 пикселов
            // или 0.25 такта на пиксел. При этом удалось добиться соответствия со значениями мод из
            // оригинального кода, добавив лишь одно ограничение по - количество пикселей должно быть кратно 8.
            // Следует также отметить, что даже при больших размерах изображения, не возникает простоя из-за
            // того, что данные не находятся в кэше.
        }
        //Ожидание окончания сохранения результата
        while(DAT_busy(id_SaveTransfer));
        //Сохранение строки результата
        id_SaveTransfer = DAT_copy(pCurrLineBuf, modes[y], IMG_WIDTH);
    }

    //Ожидание окончания сохранения результата
    while(DAT_busy(id_SaveTransfer));

    //Close DAT-chanel
    DAT_close();
}

#include <stdlib.h>

//Функция, классифицирующая пикселы изображения по модам
void SplitImage2Modes(unsigned char ** restrict image, unsigned char ** restrict modes,
    int height, int width, int thresold1, int thresold2)
{
    if ((image==NULL)||(modes==NULL)) return;

    //цикл по всем пикселам изображения
    for(int y=0; y<height; y++) for(int x=0; x<width; x++)
    {
        int pixel=image[y][x];
        if (pixel<thresold1)
            modes[y][x]=0;
        else if (pixel>thresold2)
            modes[y][x]=1;
        else
            modes[y][x]=-1;
    }
}

#include <stdlib.h>

#include "cs_common.h"

// Буферы для кэширования строк изображения
static unsigned char ModesBuf[3][IMG_WIDTH];

//Функция, классифицирующая пикселы изображения по модам
void SplitImage2Modes(unsigned char ** restrict image, unsigned char ** restrict modes,
    int thresold1, int thresold2)
{
    //Рабочие регистры цикла
    int lockPixels, compareLo, compareHi, result1, result2;
    unsigned char * restrict pCurrLineBuf;
    double pixels;

    //кольцевой указатель на буфер текущей строки
    int iCurrBufIndex=0;

    //пакеты порогов
    int thresoldLo=_packl4(_pack2(thresold1,thresold1),_pack2(thresold1,thresold1));
    int thresoldHi=_packl4(_pack2(thresold2,thresold2),_pack2(thresold2,thresold2));

    //цикл по всем строкам изображения
//#pragma MUST_ITERATE(IMG_HEIGHT, IMG_HEIGHT);
    for(int y=0; y<IMG_HEIGHT; y++)
    {
        //Указатель на текущую обрабатываемую строку
        pCurrLineBuf = ModesBuf[iCurrBufIndex];
        //Продвижение индекса на следующую строку
        iCurrBufIndex++; iCurrBufIndex%=3;
        //обработка текущей строки
//#pragma MUST_ITERATE(IMG_WIDTH/8, IMG_WIDTH/8);
        for(int x=0; x<IMG_WIDTH; x+=8)
        {
            // Загрузим сразу 8 пикселов
            pixels=_amemd8_const(pCurrLineBuf+x);                  // D

            //Первые четыре пиксела
            lockPixels=_lo(pixels);

            // Если пиксел >= thresold1, то в соответсвующем байте будет 0xff
            compareLo=_xpnd4(_cmpgtu4(lockPixels,thresoldLo));     // L + M

            // Если пиксел >= thresold2, то в соответсвующем байте будет 0xff
            compareHi=_xpnd4(_cmpgtu4(lockPixels,thresoldHi));     // L + M

            // Здесь очень удачно все сложилось - возможны три варианта:
            // если пиксел>=thresold1 и пиксел<thresold2, то получится 0xff ^ 0x00 = 0xff = -1;
            // если пиксел>=thresold1 и пиксел>=thresold2, то получится 0xff ^ 0xfe = 0x01
            // если пиксел<thresold, то пиксел<thresold2 и получается 0x00 ^ 0x00 = 0x00
            result1=compareLo ^ (compareHi & 0xfefefefe);          // LSD + LSD

            // Здесь все тоже самое, для оставшихся четырех пикселов
            lockPixels=_hi(pixels);

            compareLo=_xpnd4(_cmpgtu4(lockPixels,thresoldLo));     // L + M
            compareHi=_xpnd4(_cmpgtu4(lockPixels,thresoldHi));     // L + M

            result2=compareLo ^ (compareHi & 0xfefefefe);          // LSD + LSD

            // Сохраним результат
            _amemd8(pCurrLineBuf+x)=_itod(result2,result1);        // D
        }
    }
}