struct context
{
  unsigned long long frame_addr; 
  unsigned int num;  
} __attribute__((aligned(128))); 

#include <cstdio>
#include <libspe2.h>
#include <pthread.h>

#include "CImg.h"
#include "context.h"

using namespace cimg_library;
using namespace std;

bool file_exists(const char * filename); 
void print_video_info(const CImgList<unsigned char> &video);

spe_program_handle_t* spu;

void *spe_handler(void *arg) 
{
  spe_context_ptr_t spe_ctx;
  context *data = (context *)arg;

  unsigned int entry=SPE_DEFAULT_ENTRY;;

  spe_ctx = spe_context_create(0, NULL);
  spe_program_load (spe_ctx, spu);

  spe_context_run(spe_ctx, &entry,0,data,NULL,NULL);
  spe_context_destroy(spe_ctx);

  pthread_exit(NULL);
}

int main(int argc, char** argv)
{
  if(argc == 1)
  {
    printf("Nie podales nazwy pliku wejsciowego!\n%s nazwa_filmu_wej.mpg nazwa_filmu_wyj.mpg\n",argv[0]);
    exit(1);
  }

  if(argc == 2)
  {
    printf("Nie podales nazwy pliku wyjsciowego!\n%s nazwa_filmu_wej.mpg nazwa_filmu_wyj.mpg\n",argv[0]);
    exit(1);
  }

  if(!file_exists(argv[1]))
  {
    printf("Nie mozna otworzyc pliku %s\n",argv[1]);
    exit(1);
  }

  CImgList<unsigned char> video; 
  video.load_ffmpeg(argv[1]);

  print_video_info(video);

  int height = video[0].height;
  int width  = video[0].width;

  int num_spe = spe_cpu_info_get(SPE_COUNT_USABLE_SPES, -1); 

  int spu_part_size = (width * height * 3) / num_spe; 
  int rest_spu_part_size = (width * height * 3) % num_spe;

  pthread_t *pthreads = new pthread_t[num_spe]; 
  context *ctxs = new context[num_spe];

  spu = spe_image_open("video-spu"); 

  printf("Przetwarzanie przez %d jednostek SPU\n",num_spe);
  printf("Prosze czekac(moze to potrwac kilka minut)...\n");
  printf("---------------------------------------------\n"); 

  int old_progress = 0;

  for(int j=0; j<video.size; j++)
  {
    unsigned char *in_data = video[j].ptr(); 

    for(int i=0;i<num_spe;i++)
    {
      ctxs[i].num = spu_part_size; 
      if(i == num_spe-1)
        ctxs[i].num += rest_spu_part_size;

      ctxs[i].frame_addr = (unsigned long long int)(in_data)+ctxs[i].num*i; 
      pthread_create(&pthreads[i], NULL, &spe_handler, &ctxs[i]);
    }

    for (int i=0; i<num_spe; i++) 
      pthread_join (pthreads[i], NULL);
  }

  printf("Zakonczono przetwarzanie! Trwa zapis pliku wideo: %s\n", argv[2]);

  video.save_ffmpeg(argv[2]); 

  printf("Zapis zakonczony powodzeniem!\n");

  delete[] pthreads;
  delete[] ctxs;

  return (0);
}

bool file_exists(const char * filename)
{
  if (FILE * file = fopen(filename, "r"))
  {
    fclose(file);
    return true;
  }
  return false;
}

void print_video_info(const CImgList<unsigned char> &video) 
{
  printf("Przetwarzanie video\n");
  printf("----------------------------------------------------------------\n");

  printf("INFO:\n");
  printf("szerokosc: %d\n", video[0].width);
  printf("wysokosc: %d\n", video[0].height);
  printf("ilosc klatek: %d\n\n", video.size);
}

#include <cstdlib>
#include <cstdio>
#include <spu_mfcio.h>

#include "context.h"

#define MAX_CHUNK_SIZE 4096 

unsigned char local_pixel_data[MAX_CHUNK_SIZE] __attribute__ ((aligned (128))); 

context context_data; 

void negatyw(unsigned char* pixel_data, unsigned int size) 
{
  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*) pixel_data;

  int vectorchunk = (size / 16); 

  for (int i = 0; i < vectorchunk; i++)
  {
    pixels[i] = maxPixel - pixels[i];
  }

  int rest = size%16; 
  int rest_position = vectorchunk*16;

  for (int i = 0; i < rest; i++)
  {
    pixel_data[rest_position+i] = 255 - pixel_data[rest_position+i];
  }
}

int main(unsigned long long speid __attribute__((unused)), unsigned long long argp)
{
  unsigned long long frame_addr; 
  unsigned int chunk_size;

  unsigned int tag = mfc_tag_reserve(); 
  if (tag == MFC_TAG_INVALID)
  {
    printf ("BLAD SPU! \n Nie mozna przydzielic tagu dla SPU.\n");
    return 1;
  }

  mfc_get (&context_data, argp, sizeof (context_data), tag, 0, 0); 

  mfc_write_tag_mask (1 << tag); 
  mfc_read_tag_status_all ();

  int num_chunks = context_data.num/MAX_CHUNK_SIZE; 

  int last_chunk_size = context_data.num%MAX_CHUNK_SIZE;

  if(last_chunk_size != 0)
    num_chunks++;

  for (int i = 0; i < num_chunks; i++) 
  {
    if(last_chunk_size != 0 && i == (num_chunks-1)) 
      chunk_size = last_chunk_size;
    else
      chunk_size = MAX_CHUNK_SIZE;

    frame_addr = context_data.frame_addr + (i* MAX_CHUNK_SIZE * sizeof(unsigned char));

    mfc_get (local_pixel_data, frame_addr, chunk_size * sizeof(unsigned char), tag, 0, 0); 

    mfc_write_tag_mask (1 << tag);
    mfc_read_tag_status_all ();

    negatyw (local_pixel_data, chunk_size); 

    mfc_put (local_pixel_data, frame_addr, chunk_size * sizeof(unsigned char), tag, 0, 0);

    mfc_write_tag_mask (1 << tag);
    mfc_read_tag_status_all ();
  }

  return 0;
}