Subversion Repositories shark

#ifdef MESA_TRACE

#include "glheader.h"

#include <time.h>  /* XXX move into glheader.h */

#include "tr_write.h"

#include "tr_context.h"

#define PATH_MAX 4098

static void trWriteFile( const void * buf, GLint recsize, GLint numrecs, const char * funcname ) {

        GLint recswritten;

        if( !(trCtx()->trDoPrint) ) {

                return;

        }

        recswritten = fwrite( buf, recsize, numrecs, trCtx()->logFP );

        if( recswritten != numrecs ) {

                fprintf( stderr, "Error writing to file in %s\n", funcname );

                fprintf( stderr, "Perhaps the disk is full?\n" );

                /* Should we abort ? */

                trCtx()->trDoPrint = GL_FALSE;

        }

}

static void (*trWrite)( const void *, GLint, GLint, const char *) = trWriteFile;

void trWriteCMD( GLint cmd ) {

        trWrite( (void*)&cmd, sizeof(GLint), 1, "trWriteCMD" );

}

void trWriteb( GLbyte b ) {

        trWrite( (void*)&b, sizeof(GLbyte), 1, "trWriteb" );

}

void trWrited( GLdouble d ) {

        trWrite( (void*)&d, sizeof(GLdouble), 1, "trWrited" );

}

void trWriteClampd( GLclampd cd ) {

        trWrite( (void*)&cd, sizeof(GLclampd), 1, "trWriteClampd" );

}

void trWritef( GLfloat f ) {

        trWrite( (void*)&f, sizeof(GLfloat), 1, "trWritef" );

}

void trWriteClampf( GLclampf cf ) {

        trWrite( (void*)&cf, sizeof(GLclampf), 1, "trWriteClampf" );

}

void trWritei( GLint i ) {

        trWrite( (void*)&i, sizeof(GLint), 1, "trWritei" );

}

void trWrites( GLshort s ) {

        trWrite( (void*)&s, sizeof(GLshort), 1, "trWrites" );

}

void trWriteub( GLubyte ub ) {

        trWrite( (void*)&ub, sizeof(GLubyte), 1, "trWriteub" );

}

void trWriteui( GLuint ui ) {

        trWrite( (void*)&ui, sizeof(GLuint), 1, "trWriteui" );

}

void trWriteus( GLushort us ) {

        trWrite( (void*)&us, sizeof(GLushort), 1, "trWriteus" );

}

void trWriteBool( GLboolean b ) {

        trWrite( (void*)&b, sizeof(GLboolean), 1, "trWriteBool" );

}

void trWriteBits( GLbitfield bf ) {

        trWrite( (void*)&bf, sizeof(GLbitfield), 1, "trWriteBits" );

}

void trWriteEnum( GLenum en ) {

        trWrite( (void*)&en, sizeof(GLenum), 1, "trWriteEnum" );

}

void trWriteSizei( GLsizei si ) {

        trWrite( (void*)&si, sizeof(GLsizei), 1, "trWriteSizei" );

}

void trWritePointer( const void * p ) {

        trWrite( (void*)&p, sizeof(void *), 1, "trWritePointer" );

}

void trWriteArrayb( GLsizei n, const GLbyte * b ) {

        trWrite( (void *)b, sizeof(GLbyte), n, "trWriteArrayb" );

}

void trWriteArrayub( GLsizei n, const GLubyte * ub ) {

        trWrite( (void *)ub, sizeof(GLubyte), n, "trWriteArrayub" );

}

void trWriteArrays( GLsizei n, const GLshort * s ) {

        trWrite( (void *)s, sizeof(GLshort), n, "trWriteArrays" );

}

void trWriteArrayus( GLsizei n, const GLushort * us ) {

        trWrite( (void *)us, sizeof(GLushort), n, "trWriteArrayus" );

}

void trWriteArrayi( GLsizei n, const GLint * i ) {

        trWrite( (void *)i, sizeof(GLint), n, "trWriteArrayi" );

}

void trWriteArrayui( GLsizei n, const GLuint * ui ) {

        trWrite( (void *)ui, sizeof(GLuint), n, "trWriteArrayui" );

}

void trWriteArrayBool( GLsizei n, const GLboolean * b ) {

        trWrite( (void *)b, sizeof(GLboolean), n, "trWriteArrayBool" );

}

void trWriteArrayf( GLsizei n, const GLfloat * f ) {

        trWrite( (void *)f, sizeof(GLfloat), n, "trWriteArrayf" );

}

void trWriteArrayd( GLsizei n, const GLdouble * d ) {

        trWrite( (void *)d, sizeof(GLdouble), n, "trWriteArrayd" );

}

void trWriteString( const char * str ) {

        GLuint length = strlen(str);

        trWriteui( length );

        trWrite( (void *)str, sizeof(GLubyte), length, "trWriteString" );

}

void trFileFlush( void ) {

  fflush( trCtx()->logFP );

}

static void trWriteTypeInformation( void ) {

        trWriteub( sizeof(GLint) );

        trWriteub( sizeof(GLshort) );

        trWriteub( sizeof(GLfloat) );

        trWriteub( sizeof(GLdouble) );

        trWriteub( sizeof(GLboolean) );

        trWriteub( sizeof(GLenum) );

        trWriteub( sizeof(GLsizei) );

        trWriteub( sizeof(GLbitfield) );

        trWriteub( sizeof(GLclampf) );

        trWriteub( sizeof(GLclampd) );

        trWriteub( sizeof(GLvoid *) );

}

static void trWriteHeader( void ) {

        struct tm *newtime;

        time_t aclock;

        char timestring[256];

        trWriteString( "0.0.1" );

        trWriteString( trCtx()->traceName );

        trWritei( trCtx()->framecounter );

        /* Always print this! */

        time( &aclock );

        newtime = localtime( &aclock );

        asctime( newtime );

        snprintf( timestring, sizeof(timestring), "Time: %s", asctime( newtime ) );

        trWriteString( timestring );

}

static void trWriteGLState( void ) {

        /*

         * This function will write all the queryable GL state at

         * the time the trace is started.

         */

}

void trOpenLogFile( void ) {

        GLint numchars;

        char buffer[PATH_MAX];

        numchars = snprintf( buffer, sizeof(buffer), "%s-gl.log.%d",

                             trCtx()->traceName, trCtx()->framecounter );

        if( numchars > -1 && numchars < sizeof(buffer) ) {

                trCtx()->logFP = fopen( buffer, "wb" );

                /* This information is needed before we can extract _anything_ */

                trWriteTypeInformation();

                trWriteHeader();

                trWriteGLState();

                (trCtx()->framecounter)++;

        } else if( numchars > -1 ) {

                fprintf( stderr, "buffer needs to be %d bytes long for logging to work.\n",

                         numchars + 1 );

                exit( -1 );

        } else {

                fprintf( stderr, "buffer needs to grow for logging to work.  Try %d bytes.\n",

                         sizeof(buffer) * 2 );

                exit( -1 );

        }

}

void trCloseLogFile( void ) {

        if( trCtx()->logFP != NULL ) {

                fclose(trCtx()->logFP);

        }

        trCtx()->logFP = NULL;

}

#else

extern void tr_write_dummy_func(void);

void tr_write_dummy_func(void)

{

}

#endif