video_player.c

Go to the documentation of this file.

/*
    Author      : Milind G. Padalkar ( milind.padalkar@gamil.com )
    Purpose     : a. Successful use of most commonly used OpenCV functions
              b. Developing a simple test application that can be used for displaying a video
    Frist Created   : 15-09-2010
        Last Modified   : 28-02-2011
*/

#include<highgui.h>
#include<cv.h>
#include<stdio.h>
#include<string.h>

//dimensions of vairous sub-images

#define sldr_btn_width  15


#define sldr_height 10


#define ctrl_pnl_height 200


#define p_width     840


#define scrn_height 480


#define p_height    ( scrn_height + sldr_height + ctrl_pnl_height )


//alias for source of callbacks

#define MOUSE_CALLBACK  0


#define OTHER_CALLS 1


#define EDIT_CALLS  2

//alies for type of text field

#define STATIC_TEXT 0


#define EDIT_TEXT   1

//alies for button type

#define PLAY_BTN    0


#define PAUSE_BTN   1


#define STOP_BTN    2


#define STEPUP_BTN  3


#define STEPDOWN_BTN    4

//alies for button state

#define BTN_ACTIVE  0


#define BTN_INACTIVE    1


typedef struct{
        int x1;
        int y1;
        int x2;
        int y2;
} Field_Area;


//Global Variables

CvCapture *vid;


IplImage *player;


IplImage *pnl;


IplImage *slider;


IplImage *sldr_btn;


IplImage *sldr_val;


IplImage *oslider;


IplImage *frame_area;


IplImage *frame;


IplImage *old_frame;


IplImage *cur_frame_no;


IplImage *fps_edit;


IplImage *four_cc_edit;


IplImage *status_edit;


IplImage *numFrames;


IplImage *step_edit;



IplImage *play_pause_btn;


IplImage *stop_btn;


IplImage *stepup_btn;


IplImage *stepdown_btn;


int sldr_start; 
int sldr_maxval; 


int step_val = 1;

char line[ 20 ];


char edit_text[ 20 ];

char status_line[ 15 ];
char four_cc_str[4];


double fps;


long fourcc_l;

char *fourcc;


int blink_count = 0;

int blink_max = 5;              
char blink_char = '|' ;         

Field_Area play_pause_btn_area; 
Field_Area stop_btn_area;       
Field_Area stepup_btn_area;     
Field_Area stepdown_btn_area;   
Field_Area fps_edit_area;       
Field_Area four_cc_edit_area;   
Field_Area status_edit_area;    
Field_Area step_edit_area;      

//Controllers
bool sldr_moving    =   false;      
bool playing        =   false;      
bool processing     =   false;      
bool typing_step    =   false;      
bool blinking       =   false;      


//Colors
CvScalar red        =   cvScalar( 0, 0, 255 );          
CvScalar green      =   cvScalar( 0, 255, 0 );          
CvScalar blue       =   cvScalar( 255, 0, 0 );          
CvScalar black      =   cvScalar( 0, 0, 0 );            
CvScalar white      =   cvScalar( 255, 255, 255 );      
CvScalar light_yellow   =   cvScalar( 242, 255, 255 );  
CvScalar yellow     =   cvScalar( 0, 255, 255 );        
CvScalar gray       =   cvScalar( 242, 242, 242 );      
CvScalar orange     =   cvScalar( 0, 242, 255 );        
CvScalar voilet     =   cvScalar( 255, 0, 127 );        
CvScalar brown      =   cvScalar( 0, 0, 127 );          

//Font Parameters
CvFont font;                
CvFont font_italic;         
CvFont font_bold;           
CvFont font_bold_italic;    
int font_face_italic = CV_FONT_HERSHEY_SIMPLEX|CV_FONT_ITALIC;  
int font_face = CV_FONT_HERSHEY_SIMPLEX;                        
double hscale = 0.5;        
double vscale = 0.5;        
double shear = 0;           
int thickness = 1;          
int line_type = 8;          

//Various
void resetField( IplImage* image, int text_type );

void initialize_pnl( char* filename );

int moveSlider( int pos, int call_from );

void my_mouse_callback( int event, int x, int y, int flags, void* param );

void getButton( IplImage* image, int btn_type, int btn_state );

void getSpectrumVert( IplImage* image, CvScalar color1, CvScalar color2 );

void getSpectrumHorz( IplImage* image, CvScalar color1, CvScalar color2 );

void draw_triangle( IplImage* image, CvScalar color );

void draw_square( IplImage* image, CvScalar color );

void draw_pause( IplImage* image, CvScalar color );

void draw_stepup( IplImage* image, CvScalar color );

void draw_stepdown( IplImage* image, CvScalar color );

void fill_color( IplImage* image, CvScalar color );

void change_status();

void type_step( char c, int frame_val );

void resetAllEdits();

/*
width       840 (display)
height      480(display) + 10(slider) + 200(ctrl pnl)   
*/
//Main function
//argv[1]   :   video-file path
int main( int argc, char** argv ){

    //Initialize the font
    cvInitFont( &font, font_face, hscale, vscale, shear, thickness, line_type );
    cvInitFont( &font_italic, font_face_italic, hscale, vscale, shear, thickness, line_type );
    cvInitFont( &font_bold, font_face, hscale, vscale, shear, thickness+1, line_type );
    cvInitFont( &font_bold_italic, font_face_italic, hscale, vscale, shear, thickness+1, line_type );
    
    //Create the player image
    player = cvCreateImage( cvSize( p_width, p_height ), IPL_DEPTH_8U, 3 );
    
    //Create Control Pannel
    pnl = cvCreateImageHeader( cvSize( p_width, ctrl_pnl_height ), IPL_DEPTH_8U, 3 );
    pnl->origin = player->origin;
    pnl->widthStep = player->widthStep;
    pnl->imageData = player->imageData + ( p_height - ctrl_pnl_height )*player->widthStep;
    for( int row=0; row<pnl->height; row++ ){
        uchar* ptr = ( uchar* )( pnl->imageData + row*pnl->widthStep );
        for( int col=0; col<pnl->width; col++ ){
            ptr[ col*pnl->nChannels + 0 ] = 226;
            ptr[ col*pnl->nChannels + 1 ] = 235;
            ptr[ col*pnl->nChannels + 2 ] = 240;
        }
    }
    //Add text & buttons
    initialize_pnl( argv[1] );
    
    //create custom slider (non-opencv)
    slider = cvCreateImageHeader( cvSize( p_width, 10 ), IPL_DEPTH_8U, 3 );
    slider->origin = player->origin;
    slider->widthStep = player->widthStep;
    slider->imageData = player->imageData + ( p_height - sldr_height - ctrl_pnl_height )*player->widthStep;
    for( int row=0; row<slider->height; row++ ){
        uchar* ptr = ( uchar* )( slider->imageData + row*slider->widthStep );
        for( int col=0; col<slider->width; col++ ){
            ptr[ col*slider->nChannels + 0 ] = 94;
            ptr[ col*slider->nChannels + 1 ] = 118;
            ptr[ col*slider->nChannels + 2 ] = 254;
        }
    }
    oslider = cvCloneImage( slider );
    sldr_btn = cvCreateImage( cvSize( 15, sldr_height ), IPL_DEPTH_8U, 3 );
    for( int row=0; row<sldr_btn->height; row++ ){
        uchar* ptr = ( uchar* )( sldr_btn->imageData + row*sldr_btn->widthStep );
        for( int col=0; col<sldr_btn->width; col++ ){
            ptr[ col*slider->nChannels + 0 ] = 100;
            ptr[ col*slider->nChannels + 1 ] = 150;
            ptr[ col*slider->nChannels + 2 ] = 100;
        }
    }
    sldr_val = cvCreateImageHeader( cvSize( sldr_btn_width, sldr_height ), IPL_DEPTH_8U, 3 );
    sldr_val->origin = slider->origin;
    sldr_val->widthStep = slider->widthStep;
    sldr_val->imageData = slider->imageData;
    cvCopy( sldr_btn, sldr_val );
    
    //display window
    cvNamedWindow( "Video Player", CV_WINDOW_AUTOSIZE );

    //install mouse callback
    cvSetMouseCallback(
        "Video Player",
        my_mouse_callback,
        ( void* )NULL
    );
    
    
    //load the video
    vid = cvCaptureFromFile( argv[1] );
    //check the video
    if( !vid ){
        printf( "Error loading the video file. Either missing file or codec not installed\n" );
        return( 1 );
    }
    frame_area = cvCreateImageHeader( cvSize( p_width, scrn_height ), IPL_DEPTH_8U, 3 );
    frame_area->origin = player->origin;
    frame_area->widthStep = player->widthStep;
    frame_area->imageData = player->imageData;
    fps = cvGetCaptureProperty( vid, CV_CAP_PROP_FPS );
    sldr_start = cvGetCaptureProperty( vid, CV_CAP_PROP_POS_FRAMES );
    fourcc_l = cvGetCaptureProperty( vid, CV_CAP_PROP_FOURCC );
    fourcc = ( char* )( &fourcc_l );
    sprintf( four_cc_str, "%c%c%c%c", fourcc[0], fourcc[1], fourcc[2], fourcc[3] );
    //printf( "FPS : %f\n", fps );
    sldr_maxval = cvGetCaptureProperty( vid, CV_CAP_PROP_FRAME_COUNT ); //check this property
    if( sldr_maxval<1 ){
        printf( "Number of frames < 1. Cannot continue...\n" );
        return( 1 );
    }
    cvSetCaptureProperty(
        vid,
        CV_CAP_PROP_POS_FRAMES,
        sldr_start
    );
    sprintf( line, "%d", sldr_maxval );
    cvPutText( numFrames, line, cvPoint( 3, numFrames->height - 4 ), &font, black );
    sprintf( line, "%d", ( int )cvRound( fps ) );
    cvPutText( fps_edit, line, cvPoint( 3, fps_edit->height - 4 ), &font, black );
    sprintf( line, "%d", sldr_start );
    cvPutText( cur_frame_no, line, cvPoint( 3, cur_frame_no->height - 4 ), &font, black );
    sprintf( line, "%s", four_cc_str );
    cvPutText( four_cc_edit, line, cvPoint( 3, four_cc_edit->height - 8 ), &font, black );
    moveSlider( sldr_start, OTHER_CALLS );
    
    frame = cvQueryFrame( vid );
    old_frame = cvCloneImage( frame );
    if( !frame ){
        printf( "Cannot load video. Missing Codec : %s\n", four_cc_str );
        return( 1 );
    }
    cvShowImage( "Video Player", player );
    
    char c;
    int cur_frame;
    while( 1 ){
        if( ( c = cvWaitKey( 1000/fps ) )==27 ){
            break;
        }
        if( !processing ){
            if( playing ){
                for( int i = 0; i < ( step_val - 1 ); i++ ){
                    cvQueryFrame( vid );
                }
                frame = cvQueryFrame( vid );
                if( !frame ){
                    playing = false;
                }
                else{
                    cvCopy( frame, old_frame );
                }
            }
            //to avoid any negative value of cur_frame
            while( 1 ){
                if( ( cur_frame = ( int )cvGetCaptureProperty( vid, CV_CAP_PROP_POS_FRAMES ) )>=0 ){
                    break;
                }
                //for some unknown reason cvQueryFrame was needed to be called twice to get to the desired frame.
                frame = cvQueryFrame( vid );
                cvCopy( frame, old_frame );
            }
            //defines the task to be carried out when editing a text-field
            if( typing_step ){
                type_step( c, cur_frame );
            }
            //this takes care if for some reason the cur_frame overshoots the sldr_maxval.
            if( cur_frame == ( sldr_maxval-1 ) ){
                getButton( play_pause_btn, PLAY_BTN, BTN_ACTIVE );
                sprintf( status_line, "End reached" );
                change_status();
            }
            cvResize( old_frame, frame_area );
            //printf( "Current frame : %d\n", cur_frame );
            moveSlider( cur_frame, OTHER_CALLS );
        }
        cvShowImage( "Video Player", player );
    }
    
    //destory window
    cvDestroyWindow( "Video Player" );
    
    //Release image
    cvReleaseImageHeader( &stepdown_btn );
    cvReleaseImageHeader( &stepup_btn );
    cvReleaseImageHeader( &stop_btn );
    cvReleaseImageHeader( &play_pause_btn );
    cvReleaseImageHeader( &step_edit );
    cvReleaseImageHeader( &four_cc_edit );
    cvReleaseImageHeader( &fps_edit );
    cvReleaseImageHeader( &numFrames );
    cvReleaseImageHeader( &cur_frame_no );
    cvReleaseImageHeader( &pnl );
    cvReleaseImageHeader( &sldr_val );
    cvReleaseImageHeader( &slider );
    cvReleaseImageHeader( &frame_area );
    cvReleaseImage( &old_frame );
    cvReleaseImage( &sldr_btn );
    cvReleaseImage( &oslider );
    cvReleaseImage( &player );
    
    //Release the video
    cvReleaseCapture( &vid );
    
    return( 0 );
}



//Function to move the custom built slider
int moveSlider( int pos, int call_from ){
    int frame_val;
    //Scaling to obtain the current frame number
    float scale = ( sldr_maxval )/( float )( p_width );
    //printf( "Pos : %d\tScale : %f\n", pos, scale );
    if( call_from == MOUSE_CALLBACK ){
        frame_val = cvCeil( scale*pos );
    }
    if( call_from == OTHER_CALLS ){
        frame_val = pos;
    }
    //Scaling to set the slider button at an appropriate location between 0 and (p_width - sldr_btn_width)
    scale = ( p_width - sldr_btn_width )/( float )( sldr_maxval );
    //printf( "Frame slider : %d\n", frame_val );
    int new_pos = cvCeil( scale*frame_val );
    //frame_val should be an integral multiple of step_val
    if( frame_val%step_val != 0 ){
        frame_val = step_val*( ( int )frame_val/( int )step_val );
    }
    resetField( cur_frame_no, STATIC_TEXT );
    sprintf( line, "%d", frame_val );
    cvPutText( cur_frame_no, line, cvPoint( 3, cur_frame_no->height - 4 ), &font, black );
    cvCopy( oslider, slider );
    sldr_val->imageData = slider->imageData + new_pos*slider->nChannels;
    cvCopy( sldr_btn, sldr_val );
    return( frame_val );
}

//Function for mouse callback events
void my_mouse_callback( int event, int x, int y, int flags, void* param ){
    IplImage* image = ( IplImage* )param;
    switch( event ){
        case CV_EVENT_MOUSEMOVE: {
            if( sldr_moving ){
                // mouse on slider
                if( ( y > scrn_height ) && ( y <= scrn_height + sldr_height ) ){
                    int cur_frame = moveSlider( x, MOUSE_CALLBACK );
                    if( vid ){
                        cvSetCaptureProperty( vid, CV_CAP_PROP_POS_FRAMES, ( double )( cur_frame-1 ) );
                        cvQueryFrame( vid );
                        cvCopy( cvQueryFrame( vid ), old_frame );
                    }
                }
            }
        }
        break;
        case CV_EVENT_LBUTTONDOWN: {
            sldr_moving = true;
            resetAllEdits();
            // mouse on slider
            if( ( y > scrn_height ) && ( y <= scrn_height + sldr_height ) ){
                int cur_frame = moveSlider( x, MOUSE_CALLBACK );
                if( vid ){
                    cvSetCaptureProperty( vid, CV_CAP_PROP_POS_FRAMES, ( double )( cur_frame-1 + step_val -1 ) );
                    cvQueryFrame( vid );
                    cvCopy( cvQueryFrame( vid ), old_frame );
                    //printf( "Before val : %f\n", cvGetCaptureProperty( vid, CV_CAP_PROP_POS_FRAMES ) );
                }
                if( !playing ){
                    sprintf( status_line, "Slider moved" );
                    change_status();
                }
            }
            // mouse on play/pause button
            if(
                ( y > play_pause_btn_area.y1 ) &&
                ( y <= play_pause_btn_area.y2 ) &&
                ( x > play_pause_btn_area.x1 ) &&
                ( x <= play_pause_btn_area.x2 )
            ){
                //printf( "Frame val : %d\n", ( int )cvGetCaptureProperty( vid, CV_CAP_PROP_POS_FRAMES ) );
                if( playing ){
                    playing = false;
                    getButton( play_pause_btn, PLAY_BTN, BTN_ACTIVE );
                    sprintf( status_line, "Paused" );
                    change_status();
                }
                else{
                    playing = true;
                    getButton( play_pause_btn, PAUSE_BTN, BTN_ACTIVE );
                    sprintf( status_line, "Playing" );
                    change_status();
                }
            }
            // mouse on stop button
            if(
                ( y > stop_btn_area.y1 ) &&
                ( y <= stop_btn_area.y2 ) &&
                ( x > stop_btn_area.x1 ) &&
                ( x <= stop_btn_area.x2 )
            ){
                playing = false;
                moveSlider( sldr_start, OTHER_CALLS );
                if( vid ){
                    cvSetCaptureProperty( vid, CV_CAP_PROP_POS_FRAMES, ( double )( sldr_start-1 ) );
                    cvQueryFrame( vid );
                    cvCopy( cvQueryFrame( vid ), old_frame );
                }
                getButton( play_pause_btn, PLAY_BTN, BTN_ACTIVE );
                sprintf( status_line, "Stopped" );
                change_status();
            }
            // mouse on stepup button
            if(
                ( y > stepup_btn_area.y1 ) &&
                ( y <= stepup_btn_area.y2 ) &&
                ( x > stepup_btn_area.x1 ) &&
                ( x <= stepup_btn_area.x2 )
            ){
                int cur_frame = ( int )cvGetCaptureProperty( vid, CV_CAP_PROP_POS_FRAMES );
                //printf( "Frame val : %d\n", cur_frame );
                if( cur_frame + 1 + step_val - 1 < sldr_maxval ){
                    for( int i=0; i < ( step_val - 1 ); i++ ){
                        cvQueryFrame( vid );
                    }
                    frame = cvQueryFrame( vid );
                    if( frame ){
                        cvCopy( frame, old_frame );
                    }
                }
                if( !playing ){
                    sprintf( status_line, "Stepped Up" );
                    change_status();
                }
                //printf( "Stepup pressed \n" );
            }
            // mouse on stepdown button
            if(
                ( y > stepdown_btn_area.y1 ) &&
                ( y <= stepdown_btn_area.y2 ) &&
                ( x > stepdown_btn_area.x1 ) &&
                ( x <= stepdown_btn_area.x2 )
            ){
                processing = true;
                int cur_frame = ( int )cvGetCaptureProperty( vid, CV_CAP_PROP_POS_FRAMES );
                //printf( "Frame val : %d\n", cur_frame );
                if( cur_frame - 1 - ( step_val - 1 ) >= sldr_start ){
                    moveSlider( ( cur_frame - 1 - ( step_val - 1 ) ), OTHER_CALLS );
                    cvSetCaptureProperty( vid, CV_CAP_PROP_POS_FRAMES, ( double )( cur_frame - 1 - ( step_val - 1 ) ) );
                    cvQueryFrame( vid );
                    cvCopy( cvQueryFrame( vid ), old_frame );
                    //printf( "New Frame val : %d\n", ( int )cvGetCaptureProperty( vid, CV_CAP_PROP_POS_FRAMES ) );
                }
                if( !playing ){
                    sprintf( status_line, "Stepped Down" );
                    change_status();
                }
                processing = false;
                //printf( "Stepdown pressed \n" );
            }
            // mouse on step_edit field
            if(
                ( y > step_edit_area.y1 ) &&
                ( y <= step_edit_area.y2 ) &&
                ( x > step_edit_area.x1 ) &&
                ( x <= step_edit_area.x2 )
            ){
                sprintf( edit_text, "" );
                typing_step = true;
            }
        }
        break;
        case CV_EVENT_LBUTTONUP: {
            sldr_moving = false;
        }
        break;
    }
}


//Function to reset any field
void resetField( IplImage* image, int text_type ){
    if( text_type == STATIC_TEXT ){
        for( int row=0; row<image->height; row++ ){
            uchar *ptr = ( uchar* )( image->imageData + row*image->widthStep );
            for( int col=0; col<image->width; col++  ){
                ptr[ col*image->nChannels + 0 ] = 226;
                ptr[ col*image->nChannels + 1 ] = 235;
                ptr[ col*image->nChannels + 2 ] = 240;
            }
        }
    }
    else{
        for( int row=0; row<image->height; row++ ){
            uchar *ptr = ( uchar* )( image->imageData + row*image->widthStep );
            for( int col=0; col<image->width; col++  ){
                if( row==0 || row==image->height-1 || col==0 || col==image->width-1 ){
                    ptr[ col*image->nChannels + 0 ] = 0;
                    ptr[ col*image->nChannels + 1 ] = 0;
                    ptr[ col*image->nChannels + 2 ] = 0;
                }
                else
                {
                    ptr[ col*image->nChannels + 0 ] = 255;
                    ptr[ col*image->nChannels + 1 ] = 255;
                    ptr[ col*image->nChannels + 2 ] = 255;
                }   
            }
        }
    }
}

//Function to get new buttons
void getButton( IplImage* image, int btn_type, int btn_state ){
    getSpectrumVert( image, voilet, black );
    if( btn_type==PLAY_BTN ){
        draw_triangle( image, green );
    }
    if( btn_type==STOP_BTN ){
        draw_square( image, green );
    }
    if( btn_type==PAUSE_BTN ){
        draw_pause( image, green );
    }
    if( btn_type==STEPUP_BTN ){
        draw_stepup( image, green );
    }
    if( btn_type==STEPDOWN_BTN ){
        draw_stepdown( image, green );
    }
}

//Function to vertically color a button
void getSpectrumVert( IplImage* image, CvScalar color1, CvScalar color2 ){
    for( int row=0; row<image->height; row++ ){
        //If topmost row is selected
        if( row==0 ){
            uchar *ptr = ( uchar* )( image->imageData + row*image->widthStep );
            for( int col=0; col<image->width; col++ ){
                for( int chl=0; chl<image->nChannels; chl++ ){
                    ptr[ col*image->nChannels + chl] = color1.val[chl];
                }
            }
        }
        //If bottommost row is selected
        if( row==image->height-1 ){
            uchar *ptr = ( uchar* )( image->imageData + row*image->widthStep );
            for( int col=0; col<image->width; col++ ){
                for( int chl=0; chl<image->nChannels; chl++ ){
                    ptr[ col*image->nChannels + chl] = color2.val[chl];
                }
            }
        }
    }
    
    //Interpolation is applied
    //b_a_L => (B-A)/L... (X-A)/l = (B-A)/L :: => X = (((B-A)/L)*l + A)
    for( int row=1; row<image->height-1; row++ ){
        uchar *ptr = ( uchar* )( image->imageData );
        for( int col=0; col<image->width; col++ ){
            for( int chl=0; chl<image->nChannels; chl++ ){
                ptr[ row*image->widthStep + col*image->nChannels + chl  ] = (
                    ptr[ ( image->height-1 )*image->widthStep + col*image->nChannels + chl ] - ptr[ col*image->nChannels + chl ] )*(
                        row/( float )image->height ) + ptr[ col*image->nChannels + chl ];
            }
        }
    }
}

//Function to get the horizontal spectrum
void getSpectrumHorz( IplImage* image, CvScalar color1, CvScalar color2 ){
    //Color the leftmost and rightmost pixels of each row with with color1 and color2 respectively
    for( int row=0; row<image->height; row++ ){
        uchar *ptr = ( uchar* )( image->imageData + row*image->widthStep );
        for( int chl=0; chl<image->nChannels; chl++ ){
            ptr[chl] = color1.val[chl];
            ptr[ ( image->width-1 )*image->nChannels + chl ] = color2.val[ chl ];
        }
    }
    //Interploation applied here
    //b_a_L => (B-A)/L... (X-A)/l = (B-A)/L :: => X = (((B-A)/L)*l + A)
    for( int row=0; row<image->height; row++ ){
        uchar *ptr = ( uchar* )( image->imageData + row*image->widthStep );
        for( int col=0; col<image->width; col++ ){
            for( int chl=0; chl<image->nChannels; chl++ ){
                ptr[ col*image->nChannels + chl  ] =  ( ptr[ ( image->width - 1 )*image->nChannels + chl ] - ptr[ chl ] )*( col/( float )image->width ) + ptr[ chl ];
            }
        }
    }
}

//Function to initialize the control pannel...adding text & buttons
void initialize_pnl( char *filename ){
    int row, col;
    cvPutText( pnl, "Step : ", cvPoint( 3, 60 ), &font, black );
    cvPutText( pnl, "File : ", cvPoint( 3, 140 ), &font, black );
    cvPutText( pnl, filename, cvPoint( 65, 140 ), &font, black );
    cvPutText( pnl, "Control Pannel", cvPoint( 3, 15 ), &font_bold_italic, black );
    cvPutText( pnl, "FPS : ", cvPoint( 700, 100 ), &font, black );
    cvPutText( pnl, "Current Frame : ", cvPoint( 3, 100 ), &font, black );
    cvPutText( pnl, "Total Frames : ", cvPoint( 300, 100 ), &font, black );
    cvPutText( pnl, "FOURCC : ", cvPoint( 668, 60 ), &font, black );
    cvPutText( pnl, "Status : ", cvPoint( 325, 30 ), &font, black );
    //Current Frame field
    row = 88;
    col = 150;
    cur_frame_no = cvCreateImageHeader( cvSize( 120, 18), IPL_DEPTH_8U, 3 );
    cur_frame_no->origin = pnl->origin;
    cur_frame_no->widthStep = pnl->widthStep;
    cur_frame_no->imageData = pnl->imageData + row*pnl->widthStep + col*pnl->nChannels;
    resetField( cur_frame_no, STATIC_TEXT );
    //number of frames field
    row = 88;
    col = 430;
    numFrames = cvCreateImageHeader( cvSize( 120, 18), IPL_DEPTH_8U, 3 );
    numFrames->origin = pnl->origin;
    numFrames->widthStep = pnl->widthStep;
    numFrames->imageData = pnl->imageData + row*pnl->widthStep + col*pnl->nChannels;
    resetField( numFrames, STATIC_TEXT );
    //Step field
    row = 48;
    col = 65;
    step_edit = cvCreateImageHeader( cvSize( 50, 18), IPL_DEPTH_8U, 3 );
    step_edit->origin = pnl->origin;
    step_edit->widthStep = pnl->widthStep;
    step_edit->imageData = pnl->imageData + row*pnl->widthStep + col*pnl->nChannels;
    resetField( step_edit, EDIT_TEXT );
    step_edit_area.x1 = col;
    step_edit_area.x2 = col + step_edit->width;
    step_edit_area.y1 = p_height - ctrl_pnl_height + row;
    step_edit_area.y2 = p_height - ctrl_pnl_height + step_edit->height + row;
    sprintf( line, "%d", step_val );
    cvPutText( step_edit, line, cvPoint( 3, step_edit->height - 4 ), &font, black );
    //FPS field
    row = 88;
    col = 755;
    fps_edit = cvCreateImageHeader( cvSize( 50, 18), IPL_DEPTH_8U, 3 );
    fps_edit->origin = pnl->origin;
    fps_edit->widthStep = pnl->widthStep;
    fps_edit->imageData = pnl->imageData + row*pnl->widthStep + col*pnl->nChannels;
    resetField( fps_edit, STATIC_TEXT );
    fps_edit_area.x1 = col;
    fps_edit_area.x2 = col + fps_edit->width;
    fps_edit_area.y1 = p_height - ctrl_pnl_height + row;
    fps_edit_area.y2 = p_height - ctrl_pnl_height + fps_edit->height + row;
    //FOURCC field
    row = 48;
    col = 755;
    four_cc_edit = cvCreateImageHeader( cvSize( 50, 22), IPL_DEPTH_8U, 3 );
    four_cc_edit->origin = pnl->origin;
    four_cc_edit->widthStep = pnl->widthStep;
    four_cc_edit->imageData = pnl->imageData + row*pnl->widthStep + col*pnl->nChannels;
    resetField( four_cc_edit, STATIC_TEXT );
    four_cc_edit_area.x1 = col;
    four_cc_edit_area.x2 = col + four_cc_edit->width;
    four_cc_edit_area.y1 = p_height - ctrl_pnl_height + row;
    four_cc_edit_area.y2 = p_height - ctrl_pnl_height + four_cc_edit->height + row;
    //Play/Pause button
    row = 48;
    col = 350;
    play_pause_btn = cvCreateImageHeader( cvSize( 60, 18), IPL_DEPTH_8U, 3 );
    play_pause_btn->origin = pnl->origin;
    play_pause_btn->widthStep = pnl->widthStep;
    play_pause_btn->imageData = pnl->imageData + row*pnl->widthStep + col*pnl->nChannels;
    getButton( play_pause_btn, PLAY_BTN, BTN_ACTIVE );
    play_pause_btn_area.x1 = col;
    play_pause_btn_area.x2 = col + play_pause_btn->width;
    play_pause_btn_area.y1 = p_height - ctrl_pnl_height + row;
    play_pause_btn_area.y2 = p_height - ctrl_pnl_height + play_pause_btn->height + row;
    //Stop button
    row = 48;
    col = 415;
    stop_btn = cvCreateImageHeader( cvSize( 60, 18), IPL_DEPTH_8U, 3 );
    stop_btn->origin = pnl->origin;
    stop_btn->widthStep = pnl->widthStep;
    stop_btn->imageData = pnl->imageData + row*pnl->widthStep + col*pnl->nChannels;
    getButton( stop_btn, STOP_BTN, BTN_ACTIVE );
    stop_btn_area.x1 = col;
    stop_btn_area.x2 = col + stop_btn->width;
    stop_btn_area.y1 = p_height - ctrl_pnl_height + row;
    stop_btn_area.y2 = p_height - ctrl_pnl_height + stop_btn->height + row;
    //Stepup button
    row = 48;
    col = 480;
    stepup_btn = cvCreateImageHeader( cvSize( 60, 18), IPL_DEPTH_8U, 3 );
    stepup_btn->origin = pnl->origin;
    stepup_btn->widthStep = pnl->widthStep;
    stepup_btn->imageData = pnl->imageData + row*pnl->widthStep + col*pnl->nChannels;
    getButton( stepup_btn, STEPUP_BTN, BTN_ACTIVE );
    stepup_btn_area.x1 = col;
    stepup_btn_area.x2 = col + stepup_btn->width;
    stepup_btn_area.y1 = p_height - ctrl_pnl_height + row;
    stepup_btn_area.y2 = p_height - ctrl_pnl_height + stepup_btn->height + row;
    //Stepdown button
    row = 48;
    col = 285;
    stepdown_btn = cvCreateImageHeader( cvSize( 60, 18), IPL_DEPTH_8U, 3 );
    stepdown_btn->origin = pnl->origin;
    stepdown_btn->widthStep = pnl->widthStep;
    stepdown_btn->imageData = pnl->imageData + row*pnl->widthStep + col*pnl->nChannels;
    getButton( stepdown_btn, STEPDOWN_BTN, BTN_ACTIVE );
    stepdown_btn_area.x1 = col;
    stepdown_btn_area.x2 = col + stepdown_btn->width;
    stepdown_btn_area.y1 = p_height - ctrl_pnl_height + row;
    stepdown_btn_area.y2 = p_height - ctrl_pnl_height + stepdown_btn->height + row;
    //Status Field
    row = 18;
    col = 395;
    status_edit = cvCreateImageHeader( cvSize( 130, 22), IPL_DEPTH_8U, 3 );
    status_edit->origin = pnl->origin;
    status_edit->widthStep = pnl->widthStep;
    status_edit->imageData = pnl->imageData + row*pnl->widthStep + col*pnl->nChannels;
    resetField( status_edit, STATIC_TEXT );
    status_edit_area.x1 = col;
    status_edit_area.x2 = col + status_edit->width;
    status_edit_area.y1 = p_height - ctrl_pnl_height + row;
    status_edit_area.y2 = p_height - ctrl_pnl_height + status_edit->height + row;
    sprintf( status_line, "Stopped" );
    change_status();
}

//Draw triangle in the image
void draw_triangle( IplImage* image, CvScalar color ){
    CvPoint pt1, pt2, pt3;
    pt1.x = image->width/3;
    pt1.y = 3;
    pt2.x = pt1.x;
    pt2.y = image->height - pt1.y;
    pt3.x = 2*pt1.x;
    pt3.y = image->height/2;
    cvLine( image, pt1, pt2, color );
    cvLine( image, pt3, pt2, color );
    cvLine( image, pt1, pt3, color );
    fill_color( image, color );
}

//Draw square in the image
void draw_square( IplImage* image, CvScalar color ){
    CvPoint pt1, pt2;
    pt1.x = 3*image->width/8;
    pt1.y = 3;
    pt2.x = 5*image->width/8;
    pt2.y = image->height - pt1.y;
    cvRectangle( image, pt1, pt2, color );
    fill_color( image, color );
}

//Draw pause symbol in the image
void draw_pause( IplImage* image, CvScalar color ){
    int y_start = 3;
    int y_end = image->height - y_start;
    int dist = 3;
    CvPoint pt1, pt2, tmp1, tmp2;
    pt1.x = image->width/2;
    pt1.y = y_start;
    pt2.x = pt1.x;
    pt2.y = y_end;
    for( int col=0; col<5; col++  ){
        tmp1.x = pt1.x + dist + col;
        tmp1.y = pt1.y;
        tmp2.x = pt2.x + dist + col;
        tmp2.y = pt2.y;
        cvLine( image, tmp1, tmp2, color );
        tmp1.x = pt1.x - dist - col;
        tmp1.y = pt1.y;
        tmp2.x = pt2.x - dist - col;
        tmp2.y = pt2.y;
        cvLine( image, tmp1, tmp2, color );
    }
}



//Function to fill color in the area bounded by the given color
void fill_color( IplImage* image, CvScalar color ){
    bool start_fill = false;
    for( int row=0; row<image->height; row++ ){
        uchar *ptr = ( uchar* )( image->imageData + row*image->widthStep );
        for( int col=0; col<image->width; col++ ){
            if(
                ( ptr[ col*image->nChannels + 0 ] == color.val[0] ) &&
                ( ptr[ col*image->nChannels + 1 ] == color.val[1] ) &&
                ( ptr[ col*image->nChannels + 2 ] == color.val[2] )
            ){
                if( !start_fill ){
                    start_fill = true;
                }
                else{
                    start_fill = false;
                    break;
                }
            }
            if( start_fill ){
                ptr[ col*image->nChannels + 0 ] = color.val[0];
                ptr[ col*image->nChannels + 1 ] = color.val[1];
                ptr[ col*image->nChannels + 2 ] = color.val[2];
            }
        }
    }
}

//Draw stepup symbol
void draw_stepup( IplImage* image, CvScalar color ){
    CvPoint pt1, pt2, pt3, pt4;
    pt1.x = 2*image->width/8;
    pt2.x = 4*image->width/8;
    pt3.x = pt1.x;
    pt4.x = pt2.x;
    int y_start = 3;
    int y_end = image->height/2 ;
    for( int row=y_start; row<=y_end; row++ ){
        pt1.x = pt1.x + row - y_start;
        pt2.x = pt2.x + row - y_start;
        pt1.y = row;
        pt2.y = row;
        pt3.x = pt1.x;
        pt4.x = pt2.x;
        pt3.y = image->height - row;
        pt4.y = pt3.y;
        cvLine( image, pt1, pt2, color );
        cvLine( image, pt3, pt4, color );
    }
}

//Draw stepdown_symbol
void draw_stepdown( IplImage* image, CvScalar color ){
    CvPoint pt1, pt2, pt3, pt4;
    pt1.x = 4*image->width/8;
    pt2.x = 6*image->width/8;
    pt3.x = pt1.x;
    pt4.x = pt2.x;
    int y_start = 3;
    int y_end = image->height/2 ;
    for( int row=y_start; row<=y_end; row++ ){
        pt1.x = pt1.x - row + y_start;
        pt2.x = pt2.x - row + y_start;
        pt1.y = row;
        pt2.y = row;
        pt3.x = pt1.x;
        pt4.x = pt2.x;
        pt3.y = image->height - row;
        pt4.y = pt3.y;
        cvLine( image, pt1, pt2, color );
        cvLine( image, pt3, pt4, color );
    }
}

//Function to change the status
void change_status(){
    resetField( status_edit, STATIC_TEXT );
    cvPutText( status_edit, status_line, cvPoint( 3, status_edit->height - 8 ), &font, black );
}

//Function for editing the step_edit field
void type_step( char c, int frame_val ){
    resetField( step_edit, EDIT_TEXT );
    char temp_text[ 20 ];
    int cur_frame;
    sprintf( temp_text, "" );
    if( blinking ){
        if( blink_count<blink_max ){
            blink_count++;
        }
        else{
            blinking = false;
            blink_char = ' ';
            blink_count = 0;
        }
        //printf( "Blinking...\n" );
    }
    else{
        if( blink_count<blink_max ){
            blink_count++;
        }
        else{
            blinking = true;
            blink_char = '|';
            blink_count = 0;
        }
        //printf( "Not blinking...\n" );
    }
    //valid number
    if( c>=48 && c<=57 ){
        sprintf( temp_text, "%s%c", edit_text, c );
        if( ( frame_val + atoi( temp_text ) )>=0 && ( frame_val + atoi( temp_text ) )<=sldr_maxval && ( atoi( temp_text )!=0 ) ){
            sprintf( edit_text, "%s", temp_text );
        }
    }
    //backspace
    if( c==8 ){
        if( strcmp( edit_text, "" )!=0 ){
            for( int count=0; count<( strlen( edit_text )-1 ); count++ ){
                sprintf( temp_text, "%s%c", temp_text, edit_text[ count ] );
            }
            sprintf( edit_text, "%s", temp_text );
        }
    }
    sprintf( temp_text, "%s%c", edit_text, blink_char );
    cvPutText( step_edit, temp_text, cvPoint( 3, step_edit->height - 4 ), &font, black );
    if( c==10 ){
        resetField( step_edit, EDIT_TEXT );
        cvPutText( step_edit, edit_text, cvPoint( 3, step_edit->height - 4 ), &font, black );
        step_val = atoi( edit_text );
        //printf( "Step : %d\n", step );
        typing_step = false;
    }
}

//Function to reset all edit fields after mouse-left-click is performed
void resetAllEdits(){
    resetField( step_edit, EDIT_TEXT );
    sprintf( edit_text, "%d", step_val );
    cvPutText( step_edit, edit_text, cvPoint( 3, step_edit->height - 4 ), &font, black );
    typing_step = false;
}