Revise paste now with real pixels!

#include <SDL/SDL.h>
#include <libfreenect.h>
#include <libfreenect_sync.h>
#include <stdio.h>
#include <unistd.h>  //tcgetattr and sleep

//g++ -g -Wall -o "ppplotKinect" "ppplotKinect.cpp"  -lSDL -lSDL_ttf -lSDL_mixer -lSDL_image   -lfreenect -lfreenect_sync 
SDL_Surface* Backbuffer = NULL;
 
freenect_context *f_ctx;
freenect_device *f_dev;

#define WIDTH 640
#define HEIGHT 480

int die = 0;

int kInit();                 //initiallize / test kinect library and device connection
void kClose();         //close the kinect device
void depth_cb(freenect_device *dev, void *depth, uint32_t timestamp);
void no_kinect_quit(void);     
bool ProgramIsRunning();
void DrawPixel(SDL_Surface *surface, int x, int y , unsigned int depth_value);
void IR(freenect_device *dev, uint16_t brightness);
int main(int argc, char* args[]){
    if(SDL_Init(SDL_INIT_EVERYTHING) < 0)    {
        printf("Failed to initialize SDL!\n");
        return 0;
    }
    kInit();  //init kinect lib, and device
    	int ire = freenect_get_ir_brightness(f_dev);
		printf("%d brightness\n", ire);
    //freenect_start_ir(f_dev);
    IR(f_dev,30);  //brightness 1 to 50 may effect resolution depending on conditions.

freenect_set_depth_callback(f_dev, depth_cb);
    // Start the depth stream
    freenect_start_depth(f_dev);
   // Backbuffer = SDL_SetVideoMode(640 ,480, 32, SDL_FULLSCREEN | SDL_SWSURFACE);
    Backbuffer = SDL_SetVideoMode(1280 ,960, 32, SDL_SWSURFACE);
    SDL_WM_SetCaption("Ghost Data", NULL);
    while(ProgramIsRunning())    {
		        if (freenect_process_events(f_ctx) < 0){
            break;
		}
    }
   SDL_Quit();
    kClose();
    return 0;
}

void depth_cb(freenect_device *dev, void *depth, uint32_t timestamp){
    // Cast the depth data to unsigned short (16-bit) xbox uses 11 bits of depth
    uint16_t *depth_data = (uint16_t *)depth;

unsigned int depth_value =0;
    int x = 0;
    int y = 0;
    int index = 0; //index 0 to 307840

for (x=0; x<=WIDTH; x++){  
     index = y*WIDTH+x;  
	depth_value = depth_data[index];  
    DrawPixel(Backbuffer, x, y, depth_value);

if(x>=WIDTH){
		if(y>=HEIGHT){
	    x=0;
	    y++;
	    SDL_Flip(Backbuffer);	
	    return;
		}
		y++;  //goto next line
		x=0;
		}     
	}
}
bool ProgramIsRunning(){
    SDL_Event event;
	int brightness = freenect_get_ir_brightness(f_dev);

bool running = true;
    while(SDL_PollEvent(&event))   {
        if(event.type == SDL_QUIT)
            running = false;
    }
    if(event.type==SDL_KEYDOWN){
		switch(event.key.keysym.sym){
			case SDLK_ESCAPE :
					running=false;
					break;
					
			case SDLK_a : 
			//get brightness add 1
			brightness = freenect_get_ir_brightness(f_dev);
		    freenect_set_ir_brightness(f_dev, brightness+1);
		    printf("brightness: %d \n", brightness);
		    if (brightness >=50){
				brightness=50;
				break;
				}
			break;
			case SDLK_d :
			//get brightness sub 1
			brightness = freenect_get_ir_brightness(f_dev);
		    freenect_set_ir_brightness(f_dev, brightness-1);
		    printf("brightness: %d \n", brightness);
		    if (brightness <=1){
				brightness=1;
				break;
				}
			break;
				
             default : 
                    break;			
			}
		}

return running;
}

void DrawPixel(SDL_Surface *surface,int x , int y , unsigned  int depth_value){
    if(SDL_MUSTLOCK(surface)){
        if(SDL_LockSurface(surface) < 0)
            return;
    }
    Uint32 *buffer;
    Uint32 color;

color = SDL_MapRGB(surface->format, 0, 0, 0);
    if(x >= surface->w || x < 0 || y >= surface->h || y < 0)
        return;
//write a switch to convert depth to rgb values.
switch (depth_value) {
    //depth value fckery
    case 0 ... 400:
    color = SDL_MapRGB(surface->format, depth_value+100,0,0);  //red
    break;
    
    case 401 ... 624:
  color = SDL_MapRGB(surface->format, 255,depth_value/3,0); //orange scale
    break;
    
    case 625 ... 824:
    color = SDL_MapRGB(surface->format, depth_value-300,depth_value-300,0);  //yello
    break;
    
    case  825 ... 925:
    color = SDL_MapRGB(surface->format, 0,depth_value/5,0); //green scale
    break;
      
    case 926 ... 1480:
    color = SDL_MapRGB(surface->format, depth_value/20,0,depth_value/7); //indiogo
    break;
    
    case 1481 ... 1999:
    color = SDL_MapRGB(surface->format, 0,255, 255);
    break;
      /*  
    case 1666 ... 1850:
    color = SDL_MapRGB(surface->format, 128,0,depth_value);
    break;
    
    case 1851 ... 1999:
    color = SDL_MapRGB(surface->format, 255,0,depth_value/12);
    break;

case 2036 ... 2047:
    color = SDL_MapRGB(surface->format, 0,0,0);
    break;
**/
   case 2000 ... 2047:
        color = SDL_MapRGB(surface->format, depth_value,depth_value,depth_value); 
     break;
    default:
color = SDL_MapRGB(surface->format, 0,0,0);
    break;
        }

buffer = (Uint32*)surface->pixels  + y*surface->pitch/4 + x;
    (*buffer) = color;

if(SDL_MUSTLOCK(surface))
        SDL_UnlockSurface(surface);
}
//Kinect Stuff
int kInit(){
	    // Initialize libfreenect
    if (freenect_init(&f_ctx, NULL) < 0)    {
        printf("Failed to initialize libfreenect!\n");
        exit(1);
    }

// Set the log level (optional)
  //  freenect_set_log_level(f_ctx, FREENECT_LOG_DEBUG);
  
    // Open the Kinect device
    if (freenect_open_device(f_ctx, &f_dev, 0) < 0)    {
        printf("Failed to open Kinect device!\n");
       exit(1);
    }
    return 0;
	}

void IR(freenect_device *dev, uint16_t brightness){
		
		int ire = freenect_get_ir_brightness(f_dev);
		freenect_set_ir_brightness(f_dev, brightness);
		printf("%d brightness\n", ire);
		//int freenect_set_ir_brightness(f_dev,  brightness);
		}
void kClose(){
		//shutdown functions
    freenect_stop_depth(f_dev);
    freenect_close_device(f_dev);
    freenect_shutdown(f_ctx);
   // SDL_Quit();
		}
void no_kinect_quit(void){
	printf("Error: Kinect not connected?\n");
	exit(1);
}