Jest to główny plik programu, zawiera podstawowe menu oraz niżej opisane funkcje.

Funkcja Tworz_Watki odpowiada za utworzenie odpowiedniej ilości watków spe, oraz uruchomieniu dla każdego z nich programu do wykonania. Funkcję wywołujemy z 3 parametrami, kolejno : number - nr filtru, który będziemy używać dlZ - liczba 0 lub 2, dla filtrów działających w 2 wymiarach wpisujemy 0, dla filtrów 3d liczba 2 prog - określenie progu dla binaryzacji, dla innych filtrów wartość 0 Funkcja nie zwraca żadnych wartości, chyba że wystąpi wyjątek. Funkcja przekazuje do każdego z wątków spe ilość obrazów 2D, które mają zostać stworzone w pliku wynikowym. Dodatkowo przekazywane są odpowiednio zmodyfikowane adresy pliku wejściowego, oraz wynikowego, a dokładniej przekazywany jest adres początku pierwszego z obrazów, które mają zostać przetworzone przez wątek spe, oraz adres pierwszego obrazu w pliku wynikowym, gdzie przetworzone dane mają zostać zapisane. Tablica control_blocks[MAX_NUM_SPE_THREADS], o szerokości równej ilości watków spe umożliwia przekazywanie parametrów do każdego utworzonego wątku spe. Jest to jedna z najważniejszych zmiennych w programie. Aby było możliwe przesłanie pojedynczego elementu tablicy do wątku spe jego rozmiar musi wynieść 64kB, w przeciwnym razie wystąpi błąd szyny.

Funkcja Ramka służy do filtrowania pierwszego i ostatniego obrazu z pośród wszystkich obrazów składających się na obraz 3D. Jest wywoływana tylko w przypadku działania filtrów 3D. Wykonanie filtru 3D na pierwszym i ostatnim obrazku jest niemożliwe, gdyż nie posiadamy obrazu -1 i odpowiednio następnego po ostatnim, aby wykonać odpowiednie obliczenia. Dlatego pierwszy obraz jest filtrowany na podstawie piwreszego i drugiego, natomiast ostatni jest filtrowany na podstawie ostatniego i przedostatniego. Wszystkie te obliczenia są wykonywane w głównym programie, po zakończeniu przetwarzania przez wszystkie wątki. Funkcja przyjmuje 18 parametrów, które są wagami filtru odpowiednio dla: x1 -x9 pierwszy i ostatni obraz y1 - y9 drugi i przedostatni obraz x5 to punkt, który będzie uśredniony.

Funkcja ZwrocStrumien zwraca wskaźnik typu unsigned char do ciągłego obszaru pamięci, w którym jest przechowywanyplik wejściowy. Alokacji ciągłego obszaru pamięci dokonano za pomocą funkcji posix_memalign. Jako parametr przyjmuje ona nazwę pliku, który ma zostać wczytany do pamięci.

Funkcja ZapiszStrumien zapisuje dane znajdujące się pod adresem *model do pliku, którego nazwę podajemy jako parametr.

#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>
#include <libspe2.h>
#include <pthread.h>

#include "single_buffer.h"
#include <dma_example.h>



typedef struct _ppu_thread_data
{
  spe_context_ptr_t spe_context;        
  void* control_block_ptr;              
} ppu_thread_data_t;


extern spe_program_handle_t dma_example_spu;


void *ppu_pthread_function(void *argp) {
  ppu_thread_data_t *thread_data = (ppu_thread_data_t *)argp;
  spe_context_ptr_t ctx;
  unsigned int entry = SPE_DEFAULT_ENTRY;

  ctx = thread_data->spe_context;
  
  if (spe_context_run(ctx, &entry, 0, thread_data->control_block_ptr, NULL, NULL) < 0) {
    perror ("Failed running context");
    exit (1);
  }
  pthread_exit(NULL);
}

void ZapiszStrumien(const char *nazwaPliku, JEDNOSTKA *model);
JEDNOSTKA *ZwrocStrumien(const char *nazwaPliku);
void Tworz_Watki(unsigned int number, unsigned int dlZ, unsigned int prog);

void Ramka(unsigned int x1, unsigned int x2, unsigned int x3, unsigned int x4, unsigned int x5, unsigned int x6,
           unsigned int x7, unsigned int x8, unsigned int x9, unsigned int y1, unsigned int y2, unsigned int y3,
           unsigned int y4, unsigned int y5, unsigned int y6, unsigned int y7, unsigned int y8, unsigned int y9);

int prog;
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//-------------------------------------------------------------------------------------  MAIN FUNCTION  ----------------------------------------------------------------------------------------------------
//-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

int main()
{
  int wybor;
  int rc = posix_memalign ((void**)(&out_data), 128, szerokoscX*wysokoscY*dlugoscZ * sizeof(JEDNOSTKA));
  if (rc != 0)
  {
    fprintf (stderr, "Failed allocating space for control block\n");
    exit (1);
  }

  do{
    printf("\nWitamy w programie Filtrowanie 3D !\n\n");
    printf("1 - Wczytanie bitmapy\n");
    printf("2 - Zapisanie bitmapy do pliku\n");
    printf("3 - Binaryzacja\n");
    printf("4 - Usrednianie 3d\n");
    printf("5 - Usun Srednia 3d\n");
    printf("6 - Negatyw_Vektor\n");
    printf("7 - Sobel Poziomy 2d\n");
    printf("8 - Sobel Pionowy 2d\n");
    printf("9 - Sobel Poziomy 3d\n");
    printf("10 - Usun Srednia 2d\n");
    printf("11 - Zmiana ilosci watkow SPE\n");
    printf("0 - Zakonczenie programu\n");
    scanf("%d",&wybor);

    switch (wybor)
    {
      case 1: in_data = ZwrocStrumien("../img/men.raw");
        break;
      case 2:   ZapiszStrumien ("../img/nowy.raw",out_data);
        break;
      case 3:   printf("\n\nPodaj prog : ");scanf("%d",&prog);
        Tworz_Watki(3,0,prog);
        break;
      case 4:   Tworz_Watki(4,2,0);
        Ramka(1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1);
        break;
      case 5:   Tworz_Watki(8,2,0);
        Ramka(-1,-1,-1,-1,9,-1,-1,-1,-1,-1,-1,-1,-1,9,-1,-1,-1,-1);
        break;
      case 6:   Tworz_Watki(5,0,0);
        break;
      case 7:   Tworz_Watki(6,0,0);
        break;
      case 8:   Tworz_Watki(7,0,0);
        break;
      case 9:   Tworz_Watki(9,2,0);
        Ramka(1,2,1,0,0,0,-1,-2,-1,1,2,1,0,0,0,-1,-2,-1);
        break;
      case 10:  Tworz_Watki(10,0,0);
      break;
      case 11:  printf("\n\nAktualna liczba watkow SPE to : %d",MAX_NUM_SPE_THREADS);
        printf("\nPodaj nowa wartosc : ");scanf("%d",&MAX_NUM_SPE_THREADS);
        break;
      case 0:   printf("Koniec Programu");
        break;

    }
    //system("cls");
  } while (wybor!=0);

  printf("\nThe program has successfully executed.\n");
  return (0);
}


void Tworz_Watki(unsigned int number, unsigned int dlZ, unsigned int prog)
{
  int i, num_spe_threads, num_elements_per_spe, rc;
  spe_context_ptr_t spe_contexts[MAX_NUM_SPE_THREADS];
  pthread_t spe_threads[MAX_NUM_SPE_THREADS];
  control_block_t* control_blocks[MAX_NUM_SPE_THREADS];
  ppu_thread_data_t ppu_thread_data[MAX_NUM_SPE_THREADS];
  union {
    unsigned long long ull;
    unsigned int ui[2];
  } long_addr;

  num_spe_threads = MAX_NUM_SPE_THREADS;
  num_elements_per_spe = szerokoscX*wysokoscY;
  printf("\nLiczba elementow na 1 spe : %.2d\n", num_elements_per_spe);

  
  int il_obr = (dlugoscZ-dlZ)/num_spe_threads; 

  
  int rest = (dlugoscZ-dlZ) % num_spe_threads;
  rest += il_obr;
  printf("\nReszta %d\n", rest-il_obr);

  unsigned char *in_data_copy = in_data;  
  unsigned char *out_data_copy = out_data;
  out_data_copy += szerokoscX*wysokoscY*(rest-il_obr);  
  in_data_copy += szerokoscX*wysokoscY*(rest-il_obr);

  for (i = 0; i < num_spe_threads; i++)
  {
    
    rc = posix_memalign ((void**)(&control_blocks[i]), 128, sizeof (control_block_t));
    if (rc != 0)
    {
      fprintf (stderr, "Failed allocating space for control block\n");
      exit (1);
    }

    
    long_addr.ui[0] = 0;
    if (i == 0)long_addr.ui[1] = (unsigned int)in_data;
    else long_addr.ui[1] = (unsigned int)in_data_copy + i* num_elements_per_spe*(il_obr)* sizeof(unsigned char);
    control_blocks[i]->in_addr = long_addr.ull;

    long_addr.ui[0] = 0;
    if (i == 0)long_addr.ui[1] = (unsigned int)out_data;
    else long_addr.ui[1] = (unsigned int)out_data_copy + i* num_elements_per_spe *(il_obr)* sizeof(unsigned char);
    control_blocks[i]->out_addr = long_addr.ull;

    control_blocks[i]->num_elements_per_spe = num_elements_per_spe;
    control_blocks[i]->id = i;
    control_blocks[i]->pad[0] = number;

    if (i == 0)control_blocks[i]->pad[1] = rest;
    else control_blocks[i]->pad[1] = il_obr;     
      control_blocks[i]->pad[2] = prog;

    
    spe_contexts[i]= spe_context_create (0, NULL);
    if (spe_contexts[i] == NULL)
    {
      perror ("Failed creating SPE context");
      exit (1);
    }

    
    if (spe_program_load (spe_contexts[i], &dma_example_spu))
    {
      perror ("Failed loading SPE program");
      exit (1);
    }

    
    ppu_thread_data[i].spe_context = spe_contexts[i];
    ppu_thread_data[i].control_block_ptr = control_blocks[i];

    
    if (pthread_create (&spe_threads[i], NULL, &ppu_pthread_function, &ppu_thread_data[i]))
    {
      perror ("Failed creating SPE thread");
      exit (1);
    }

    
    
    if (pthread_join (spe_threads[i], NULL))
    {
      perror ("Failed pthread_join");
      exit (1);
    }

    
    if (spe_context_destroy (spe_contexts[i]) != 0)
    {
      perror ("Failed destroying SPE context");
      exit (1);
    }
    free (control_blocks[i]);
  }

  printf("\nzakonczono\n");
}

void Ramka(unsigned int x1, unsigned int x2, unsigned int x3, unsigned int x4, unsigned int x5, unsigned int x6,
           unsigned int x7, unsigned int x8, unsigned int x9, unsigned int y1, unsigned int y2, unsigned int y3,
           unsigned int y4, unsigned int y5, unsigned int y6, unsigned int y7, unsigned int y8, unsigned int y9)
{
  
  
  int i;
  int Z = 1;

  for (i = szerokoscX; i<szerokoscX*wysokoscY - szerokoscX ; i++)
  {
    if ((i % szerokoscX == 0) || (i % szerokoscX == szerokoscX-1))
      continue;

    int wynik = 0;
    wynik = x1*(*(in_data+i-szerokoscX-1)) + x2*(*(in_data+i-szerokoscX)) + x3*(*(in_data+i-szerokoscX+1)) +
      x4*(*(in_data+i-1)) + x5*(*(in_data+i)) + x6*(*(in_data+i+1)) +
      x7*(*(in_data+i+szerokoscX+1)) + x8*(*(in_data+i+szerokoscX)) + x9*(*(in_data+i+szerokoscX-1)) +
      y1*(*(in_data+i-szerokoscX-1 + szerokoscX*szerokoscX)) + y2*(*(in_data+i-szerokoscX + szerokoscX*szerokoscX)) + y3*(*(in_data+i-szerokoscX+1 + szerokoscX*szerokoscX)) +
      y4*(*(in_data+i-1 + szerokoscX*szerokoscX)) + y5*(*(in_data+i + szerokoscX*szerokoscX)) + y6*(*(in_data+i+1 + szerokoscX*szerokoscX)) +
      y7*(*(in_data+i+szerokoscX+1 + szerokoscX*szerokoscX)) + y8*(*(in_data+i+szerokoscX + szerokoscX*szerokoscX)) + y9*(*(in_data+i+szerokoscX-1 + szerokoscX*szerokoscX)) ;

    *(out_data+i) = wynik/18;
  }

  
  
  for (Z=1; Z<dlugoscZ-1; Z++)
  {
    for (i= szerokoscX*wysokoscY*Z  ; i< szerokoscX*wysokoscY*(Z+1) ; i++)
    {
      
      if ( (i >= szerokoscX*wysokoscY*Z) && (i <= szerokoscX*wysokoscY*Z+szerokoscX))
      {
        *(out_data+i) = *(in_data+i);
      }
      else if (i % szerokoscX == 0)
      {
        *(out_data+i-1) = *(in_data+i);  
        *(out_data+i) = *(in_data+i);   
      }
      else if (i >=szerokoscX*wysokoscY*Z+szerokoscX*(szerokoscX-1) +1)  
      {
        *(out_data+i) = *(in_data+i);
      }
    }
  }

  
  for (i = szerokoscX*wysokoscY*dlugoscZ - szerokoscX*wysokoscY + szerokoscX; i<szerokoscX*wysokoscY*dlugoscZ - szerokoscX ; i++)
  {
    if ((i % szerokoscX == 0) || (i % szerokoscX == szerokoscX-1))
      continue;

    int wynik = 0;
    wynik =x1*(*(in_data+i-szerokoscX-1)) + x2*(*(in_data+i-szerokoscX)) + x3*(*(in_data+i-szerokoscX+1)) +
      x4*(*(in_data+i-1)) + x5*(*(in_data+i)) + x6*(*(in_data+i+1)) +
      x7*(*(in_data+i+szerokoscX+1)) + x8*(*(in_data+i+szerokoscX)) + x9*(*(in_data+i+szerokoscX-1)) +
      y1*(*(in_data+i-szerokoscX - 1 - szerokoscX*szerokoscX)) + y2*(*(in_data+i-szerokoscX - szerokoscX*szerokoscX)) + y3*(*(in_data+i-szerokoscX+1 - szerokoscX*szerokoscX)) +
      y4*(*(in_data+i-1 - szerokoscX*szerokoscX)) + y5*(*(in_data+i - szerokoscX*szerokoscX)) + y6*(*(in_data+i+1 - szerokoscX*szerokoscX)) +
      y7*(*(in_data+i+szerokoscX+1 - szerokoscX*szerokoscX)) + y8*(*(in_data+i+szerokoscX - szerokoscX*szerokoscX)) + y9*(*(in_data+i+szerokoscX-1 - szerokoscX*szerokoscX)) ;

    *(out_data+i) = wynik/18;
  }
}

JEDNOSTKA *ZwrocStrumien(const char *nazwaPliku)
{
  JEDNOSTKA wsk;
  JEDNOSTKA *model;
  long i;
  FILE *plik;

  plik = fopen(nazwaPliku,"rb+");
  if (!plik)
  {
    printf("Nie udalo sie otworzyc pliku %s\n",nazwaPliku);
    return NULL;
  }

  
  int rc = posix_memalign ((void**)(&model), 128, szerokoscX*wysokoscY*dlugoscZ * sizeof(JEDNOSTKA));
  if (rc != 0)
  {
    fprintf (stderr, "Failed allocating space for control block\n");
    exit (1);
  }

  for (i = 0; i < szerokoscX*wysokoscY*dlugoscZ; i++)
  {
    fread(&wsk,1,1,plik);
    model[i] = wsk;
  }
  return model;
}


void ZapiszStrumien(const char *nazwaPliku, JEDNOSTKA *model)
{
  FILE *plik;
  int i;
  JEDNOSTKA wsk;

  if (model ==NULL)     
  {
    exit(1);
  }

  plik = fopen(nazwaPliku,"wb+");
  if (!plik)
  {
    printf("Nie udalo sie otworzyc pliku %s\n",nazwaPliku);
    exit(1);
  }

  for (i = 0; i < szerokoscX*wysokoscY*dlugoscZ; i++)
  {
    wsk = model[i];
    fwrite(&wsk,1,1,plik);
  }
}

W tym pliku znajdują się funkcje odpowiedzialne za działanie samych filtrów.

Funkcja Filtr2d jako parametr przyjmuje 9 elementową tablicę wag. Funkcja ta filtruje cały obraz 3d, jednak każdy z obrazów składowych jest filtrowany jak obraz 2D.

Postępowanie w przypadku filtrowania 2D. Zakładamy, że filtrowany obraz 2D ma wymiary 512 * 512 pikseli. Z filtrowanego obrazu 2D są pobierane pierwsze trzy rzędy danych, czyli 512*3 a następnie są one ładowane do tablicy 2D. Powstała tablica ma wymiary x = 512 y = 3. Kolejnym krokiem jest wykonanie filtru na podstawie danych zawartych w tablicy 2D oraz wag podanych jako parametr. Filtrujemy piksele o współrzędnych x = 1 .. 510 y = 2. Piksele x = 0 oraz x = 511 są uśredniane osobno na podstawie prawego i odpowiednio lewego otoczenia. Ostatecznie przefiltrowany rząd danych o współrzędnych x = 0 .. 511 y = 2 jest zapisywany do pliku wynikowego i wszystkie operacje są wykonywane od początku dla kolejnej porcji danych( rzędy 2,3,4). Całe wyżej zammieszczone postępowanie zostało zawarte w funkcji Filtr2d(int tabl[9]).

Funkcja Filtr3d przyjmuje jako parametr tablicę wag, na podstawie których jest wykonywane filtrowanie. Parametr ma 27 elementów(9 na każdy obraz, który jest brany pod uwagę przy filtrowaniu pojedynczego piksela), z których pierwsze 9 to wagi elementów obrazu przed obrazem filtrowanym kolejne 9 to wagi obrazu środkowego ostatnie 9 to wagi elementów obrazu za obrazem filtrowanym dzięki takiemu podejściu możliwe jest wykonanie dowolnego filtru, przez zmianę wag.

Postępowanie w przypadku filtrowania 3D. W celu uproszcenia rozumowania zakładamy, że filtrowany będzie drugi obraz z obrazu 3D na podstawie pierwszego, drugiego i trzeciego. Dodatkowo zakładamy, że kostka 3D ma wymiary 512*512*83, gdzie: 512*512 to szerokoscX * wysokoscY dla każdego obrazka 83 to liczba obrazów w kostce 3D Pierwszym zadaniem jest stworzenie tablicy o ilości elementów równej szerokoscX*3*3 czyli 512*3*3, a następnie pobraniu do niej danych z pierwszego, drugiego i trzeciego obrazu, z tym że pobieramy 3 pierwsze rzędy z pierwszego obrazu, trzy pierwsze rzędy z drugiego, oraz 3 pierwsze rzędy z trzeciego obrazu. Następnie tworzona jest tablica trójwymiarowa i pobrane dane są do niej wpisywane w taki sposób, że powstaje trójwymiarowy obraz, o długości x = 512, wysokości y = 3, oraz głębokości z = 3, jest to obraz, którego środek będzie filtrowany. Ostatnim zadaniem jest wykonanie obliczeń filtrujących dla każdego piksela wewnątrz powstałego obrazu czyli dla pikseli o współrzędnych x = 1 .. 510, y = 2, z = 2. Piksele x = 0 oraz x = 511 są przepisywane. Ostatecznie otrzymano zbiór 512 pikseli umieszczonych w tablicy, które reprezentują przefiltrowany środek stworzonego obrazu. Ten rezultat jest zapisywany w pliku wynikowym i następuje powtórzenie wszystkich wykonanych czynności,z tym, że pobierane są kolejne 3 rzędy danych 2,3,4 z wszystkich trzech obrazów. Całe wyżej zammieszczone postępowanie zostało zawarte w funkcji Filtr3d(int tabl[27]).

Filtr negatyw jako jedyny nadawał się do zastosowania wektoryzacji obliczeń. Spowodowne to było tym, że każdy piksel jest tylko zanegowany i niezależny od otoczenia. Na każdym pikselu kolejno wykonujemy tą samą operację. Wektoryzacja pozwoliła na wykonywanie tych samych obliczeń na 16 pikselach jednocześnie

#include <stdlib.h>
#include <stdio.h>
#include <spu_mfcio.h>
#include <single_buffer.h>
#include <dma_example.h>
//#define USE_TIMER 1
#ifdef USE_TIMER
#include <spu_timer.h>
#endif

/* USE_TIMER */
unsigned char local_buffer[CHUNK_SIZE] __attribute__ ((aligned (128)));
unsigned char local_buffer1[szerokoscX*9] __attribute__ ((aligned (128)));
unsigned char wynik[szerokoscX] __attribute__ ((aligned (128)));
unsigned char local_buffer2[szerokoscX] __attribute__ ((aligned (128)));
unsigned char local_buffer3[szerokoscX*3] __attribute__ ((aligned (128)));
control_block_t control_block __attribute__ ((aligned (128)));
unsigned int tag;
unsigned long long in_addr, out_addr;

void Filtr2d(int tabl[9]);
void Filtr3d(int tabl[27]); 

int main(unsigned long long speid __attribute__ ((unused)), unsigned long long argp, unsigned long long envp __attribute__ ((unused)))
{
  int i;

#ifdef
  USE_TIMER uint64_t start, time_working;
  spu_slih_register (MFC_DECREMENTER_EVENT, spu_clock_slih);
  spu_clock_start();
  start = spu_clock_read();
#endif 

  tag = mfc_tag_reserve();
  if (tag == MFC_TAG_INVALID) {
    printf ("SPU ERROR, unable to reserve tag\n");
    return 1;
  } 

  mfc_get (&control_block, argp, sizeof (control_block_t), tag, 0, 0); 
  mfc_write_tag_mask (1 << tag);
  mfc_read_tag_status_all (); 

  if(control_block.pad[0] == 3)
  {
    printf("SPU %d work pad = %d\n",control_block.id,control_block.pad[1]);
    int j;

    for (j=0; j<control_block.pad[1]; j++)
    { 
      if(j!=0)
      {
        control_block.in_addr += szerokoscX*wysokoscY;
        control_block.out_addr += szerokoscX*wysokoscY;
      }
      for (i = 0; i <szerokoscX; i++)
      {
        int k;
        in_addr  = control_block.in_addr  + (i* CHUNK_SIZE * sizeof(unsigned char));
        out_addr = control_block.out_addr + (i* CHUNK_SIZE * sizeof(unsigned char));

        mfc_get (local_buffer2, in_addr, szerokoscX * sizeof(unsigned char), tag, 0, 0);
        mfc_write_tag_mask (1 << tag);
        mfc_read_tag_status_all ();

        for (k=0; k< szerokoscX ; k++) {
          if (*(local_buffer2+k) > control_block.pad[2])
            *(local_buffer2+k) = 255;
          else
            *(local_buffer2+k)= 0;
        } 

        mfc_put (local_buffer2, out_addr, szerokoscX * sizeof(unsigned char), tag, 0, 0);
        mfc_write_tag_mask (1 << tag); 
        mfc_read_tag_status_all ();
      }
    }
  } 

  if (control_block.pad[0] == 4)
  {
    printf("\nSPU %d work, liczba obr do przetworzenia = %d",control_block.id,control_block.pad[1]);
    int tab_wag[27] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
    Filtr3d(tab_wag);
  } 

  if (control_block.pad[0] == 8)
  {
    printf("\nSPU %d work, liczba obr do przetworzenia = %d",control_block.id,control_block.pad[1]);
    int tab_wag[27] = {-1,-1,-1,-1,9,-1,-1,-1,-1,-1,-1,-1,-1,9,-1,-1,-1,-1,-1,-1,-1,-1,9,-1,-1,-1,-1};
    Filtr3d(tab_wag);
  } 

  if (control_block.pad[0] == 5)
  {
    printf("SPU %d work pad = %d\n",control_block.id,control_block.pad[1]);
    int j;
    for (j=0; j<control_block.pad[1]; j++)
    { 
    if (j!=0)
    {
      control_block.in_addr += szerokoscX*wysokoscY;
      control_block.out_addr += szerokoscX*wysokoscY;
    }
    for (i = 0; i < szerokoscX; i++)
    {
      int k;
      in_addr  = control_block.in_addr  + (i* CHUNK_SIZE * sizeof(unsigned char));
      out_addr = control_block.out_addr + (i* CHUNK_SIZE * sizeof(unsigned char));

      mfc_get (local_buffer2, in_addr, szerokoscX * sizeof(unsigned char), tag, 0, 0);
      mfc_write_tag_mask (1 << tag);
      mfc_read_tag_status_all ();

      vector unsigned char *pixels;
      vector unsigned char maxPixel = (vector unsigned char) {255,255,255,255,255,255,255,255,255,255,255,255,255,255,255,255};
      pixels = (vector unsigned char*) local_buffer2;

      for (k =0; k< szerokoscX/16 ; k++)
      {
        pixels[k] = maxPixel - pixels[k];
      } 

      mfc_put (local_buffer2, out_addr, szerokoscX * sizeof(unsigned char), tag, 0, 0);
      mfc_write_tag_mask (1 << tag); 
      mfc_read_tag_status_all ();
    }
    }
  } 

  if (control_block.pad[0] == 6)
  {
    printf("SPU %d work pad = %d \n",control_block.id,control_block.pad[1]);
    int tab_wag[9] = {1,2,1,0,0,0,-1,-2,-1};
    Filtr2d(tab_wag);
  } 

  if (control_block.pad[0] == 9)
  {
    printf("\nSPU %d work, liczba obr do przetworzenia = %d",control_block.id,control_block.pad[1]);
    int tab_wag[27] = {1,2,1,0,0,0,-1,-2,-1,1,2,1,0,0,0,-1,-2,-1,1,2,1,0,0,0,-1,-2,-1};
    Filtr3d(tab_wag);
  } 

  if (control_block.pad[0] == 7)
  {
    printf("SPU %d work pad = %d\n",control_block.id,control_block.pad[1]);
    int tab_wag[9] = {1,0,-1,2,0,-2,1,0,-1};
    Filtr2d(tab_wag);
  } 

  if (control_block.pad[0] == 10)
  {
    printf("SPU %d work pad = %d \n",control_block.id,control_block.pad[1]);
    int tab_wag[9] = {-1,-1,-1,-1,9,-1,-1,-1,-1};
    Filtr2d(tab_wag);
  } 

#ifdef USE_TIMER
  time_working = (spu_clock_read() - start);
  spu_clock_stop();
  printf ("SPE time_working = %lld\n", time_working);
#endif

  return 0;
}

void Filtr2d(int tabl[9])
{
  int j,i;
  for (j=0; j<control_block.pad[1]; j++) 
  {
    if (j!=0)
    {
      control_block.in_addr += szerokoscX*wysokoscY;
      control_block.out_addr += szerokoscX*wysokoscY;
    }
    for (i = 0; i < szerokoscX-2; i++)
    {
      in_addr = control_block.in_addr+(i* CHUNK_SIZE * sizeof(unsigned char));
      out_addr = control_block.out_addr + (i* CHUNK_SIZE * sizeof(unsigned char));

      mfc_get (local_buffer3, in_addr, szerokoscX*3 * sizeof(unsigned char),ctag, 0, 0);
      mfc_write_tag_mask (1 << tag);
      mfc_read_tag_status_allc(); 

      int tab2d[szerokoscX][3]; 
      int x,y,k,zm=0;

      for(y=0;y<3;y++)
        for(x=0;x<szerokoscX;x++)
        {
          tab2d[x][y] = local_buffer3[zm++];
        }
        for (k=1; k< szerokoscX-2; k++)
        {
          wynik[k] =
            (
              tabl[0]*tab2d[k-1][0] + tabl[1]*tab2d[k][0] + tabl[2]*tab2d[k+1][0] + tabl[3]*tab2d[k-1][1] +
              tabl[4]*tab2d[k][1] + tabl[5]*tab2d[k+1][1] + tabl[6]*tab2d[k-1][2] + tabl[7]*tab2d[k][2] +
              tabl[8]*tab2d[k+1][2]
            )/9;
        }
        wynik[0] = (
            tabl[0]*tab2d[k][0] + tabl[1]*tab2d[k+1][0] + tabl[3]*tab2d[k][1] +
            tabl[4]*tab2d[k+1][1] + tabl[6]*tab2d[k][2] + tabl[7]*tab2d[k+1][2]
          )/6;

        wynik[szerokoscX-1] = (
            tabl[1]*tab2d[k-1][0] + tabl[2]*tab2d[k][0] + tabl[4]*tab2d[k-1][1] +
            tabl[5]*tab2d[k][1] + tabl[7]*tab2d[k-1][2] + tabl[8]*tab2d[k][2]
          )/6; 

        mfc_put (wynik, out_addr+szerokoscX, szerokoscX * sizeof(unsigned char), tag, 0, 0);
        mfc_write_tag_mask (1 << tag); 
        mfc_read_tag_status_all ();
    }
  }
}
void Filtr3d(int tabl[27])
{
  int j,i;

  for (j=0; j<control_block.pad[1]; j++)
  { 
    if (j!=0)
    {
      control_block.in_addr += szerokoscX*wysokoscY;
      control_block.out_addr += szerokoscX*wysokoscY;
    }
    for (i = 0; i < szerokoscX-2; i++)
    {
      in_addr = control_block.in_addr+ (i* CHUNK_SIZE * sizeof(unsigned char));
      out_addr = control_block.out_addr + (i* CHUNK_SIZE * sizeof(unsigned char)); 

      mfc_get (local_buffer1, in_addr, szerokoscX*3 * sizeof(unsigned char), tag, 0, 0);
      mfc_get (local_buffer1+szerokoscX*3, in_addr+szerokoscX*wysokoscY, szerokoscX*3 * sizeof(unsigned char), tag, 0, 0);
      mfc_get (local_buffer1+szerokoscX*6, in_addr+szerokoscX*wysokoscY*2, szerokoscX*3 * sizeof(unsigned char), tag, 0, 0);
      
      mfc_write_tag_mask (1 << tag);
      mfc_read_tag_status_all (); 

      int tab3d[szerokoscX][3][3]; 
      int x,y,z,k,zm=0;

      for (z=0; z<3; z++)
        for(y=0;y<3;y++)
          for(x=0;x<szerokoscX;x++)
          {
            tab3d[x][y][z] = local_buffer1[zm++];
          }

      
      for (k=1; k<szerokoscX-1; k++)
      {
        wynik[k] = (
          tabl[0]*tab3d[k-1][0][0] + tabl[1]*tab3d[k][0][0] + tabl[2]*tab3d[k+1][0][0] +
          tabl[3]*tab3d[k-1][1][0] + tabl[4]*tab3d[k][1][0] + tabl[5]*tab3d[k+1][1][0] + 
          tabl[6]*tab3d[k-1][2][0] + tabl[7]*tab3d[k][2][0] + tabl[8]*tab3d[k+1][2][0] +
          tabl[9]*tab3d[k-1][0][1]  + tabl[10]*tab3d[k][0][1] + tabl[11]*tab3d[k+1][0][1] +
          tabl[12]*tab3d[k-1][1][1] + tabl[13]*tab3d[k][1][1] + tabl[14]*tab3d[k+1][1][1] + 
          tabl[15]*tab3d[k-1][2][1] + tabl[16]*tab3d[k][2][1] + tabl[17]*tab3d[k+1][2][1] +
          tabl[18]*tab3d[k-1][0][2] + tabl[19]*tab3d[k][0][2] + tabl[20]*tab3d[k+1][0][2] +
          tabl[21]*tab3d[k-1][1][2] + tabl[22]*tab3d[k][1][2] + tabl[23]*tab3d[k+1][1][2] + 
          tabl[24]*tab3d[k-1][2][2] + tabl[25]*tab3d[k][2][2] + tabl[26]*tab3d[k+1][2][2]
        ) / 27;
      } 

      wynik[0] = 1;
      wynik[szerokoscX-1] = 1;

      mfc_put (wynik, out_addr+szerokoscX*wysokoscY+szerokoscX, szerokoscX * sizeof(unsigned char), tag, 0, 0); 
      mfc_write_tag_mask (1 << tag);
      mfc_read_tag_status_all ();
    }
  }
}