#include "packer.h"

#include "cr_pixeldata.h"

#include "cr_error.h"

#include "cr_mem.h"

#include "cr_version.h"

void PACK_APIENTRY crPackDrawPixels(GLsizei width, GLsizei height,

GLenum format, GLenum type,

const GLvoid *pixels,

const CRPixelPackState *unpackstate )

{

unsigned char *data_ptr;

int packet_length, imagesize;

int noimagedata = (pixels == NULL) || crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB);

packet_length =

sizeof( width ) +

sizeof( height ) +

sizeof( format ) +

sizeof( type ) + sizeof(int) + sizeof(GLint);

if (!noimagedata)

{

imagesize = crImageSize( format, type, width, height );

if (imagesize<=0)

{

crDebug("crPackDrawPixels: 0 image size, ignoring");

return;

}

packet_length += imagesize;

}

data_ptr = (unsigned char *) crPackAlloc( packet_length );

WRITE_DATA( 0, GLsizei, width );

WRITE_DATA( 4, GLsizei, height );

WRITE_DATA( 8, GLenum, format );

WRITE_DATA( 12, GLenum, type );

WRITE_DATA( 16, GLint, noimagedata );

WRITE_DATA( 20, GLint, (GLint) (uintptr_t) pixels );

if (!noimagedata)

{

crPixelCopy2D(width, height,

(void *) (data_ptr + 24), format, type, NULL, /* dst */

pixels, format, type, unpackstate); /* src */

}

crHugePacket( CR_DRAWPIXELS_OPCODE, data_ptr );

crPackFree( data_ptr );

}

void PACK_APIENTRY crPackReadPixels(GLint x, GLint y, GLsizei width,

GLsizei height, GLenum format,

GLenum type, GLvoid *pixels,

const CRPixelPackState *packstate,

int *writeback)

{

CR_GET_PACKER_CONTEXT(pc);

unsigned char *data_ptr;

GLint stride = 0;

GLint bytes_per_row;

int bytes_per_pixel;

*writeback = 0;

bytes_per_pixel = crPixelSize(format, type);

if (bytes_per_pixel <= 0) {

char string[80];

sprintf(string, "crPackReadPixels(format 0x%x or type 0x%x)", format, type);

__PackError(__LINE__, __FILE__, GL_INVALID_ENUM, string);

return;

}

/* default bytes_per_row so crserver can allocate memory */

bytes_per_row = width * bytes_per_pixel;

stride = bytes_per_row;

if (packstate->alignment != 1) {

GLint remainder = bytes_per_row % packstate->alignment;

if (remainder)

stride = bytes_per_row + (packstate->alignment - remainder);

}

CR_GET_BUFFERED_POINTER(pc, 48 + sizeof(CRNetworkPointer) );

WRITE_DATA( 0, GLint, x );

WRITE_DATA( 4, GLint, y );

WRITE_DATA( 8, GLsizei, width );

WRITE_DATA( 12, GLsizei, height );

WRITE_DATA( 16, GLenum, format );

WRITE_DATA( 20, GLenum, type );

WRITE_DATA( 24, GLint, stride ); /* XXX not really used! */

WRITE_DATA( 28, GLint, packstate->alignment );

WRITE_DATA( 32, GLint, packstate->skipRows );

WRITE_DATA( 36, GLint, packstate->skipPixels );

WRITE_DATA( 40, GLint, bytes_per_row );

WRITE_DATA( 44, GLint, packstate->rowLength );

WRITE_NETWORK_POINTER( 48, (char *) pixels );

WRITE_OPCODE( pc, CR_READPIXELS_OPCODE );

CR_CMDBLOCK_CHECK_FLUSH(pc);

CR_UNLOCK_PACKER_CONTEXT(pc);

}

#define CEIL8(N) (((N) + 7) & ~0x7)

void PACK_APIENTRY crPackBitmap(GLsizei width, GLsizei height,

GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove,

const GLubyte *bitmap, const CRPixelPackState *unpack )

{

const int noimagedata = (bitmap == NULL) || crStateIsBufferBound(GL_PIXEL_UNPACK_BUFFER_ARB);

unsigned char *data_ptr;

int data_length = 0;

GLubyte *destBitmap = NULL;

int packet_length =

sizeof( width ) +

sizeof( height ) +

sizeof( xorig ) +

sizeof( yorig ) +

sizeof( xmove ) +

sizeof( ymove ) +

sizeof( GLuint ) + sizeof(GLint);

if (!noimagedata)

{

data_length = CEIL8(width) * height / 8;

packet_length += data_length;

}

data_ptr = (unsigned char *) crPackAlloc( packet_length );

WRITE_DATA( 0, GLsizei, width );

WRITE_DATA( 4, GLsizei, height );

WRITE_DATA( 8, GLfloat, xorig );

WRITE_DATA( 12, GLfloat, yorig );

WRITE_DATA( 16, GLfloat, xmove );

WRITE_DATA( 20, GLfloat, ymove );

WRITE_DATA( 24, GLuint, noimagedata );

WRITE_DATA( 28, GLint, (GLint) (uintptr_t) bitmap);

if (!noimagedata)

crBitmapCopy(width, height, (GLubyte *)(data_ptr + 32), bitmap, unpack);

crHugePacket( CR_BITMAP_OPCODE, data_ptr );

crPackFree( data_ptr );

}

void PACK_APIENTRY crPackZPixCR( GLsizei width, GLsizei height,

GLenum format, GLenum type,

GLenum ztype, GLint zparm, GLint length,

const GLvoid *pixels,

const CRPixelPackState *unpackstate )

{

unsigned char *data_ptr;

int packet_length;

(void)unpackstate;

if (pixels == NULL)

{

return;

}

packet_length =

sizeof( int ) + /* packet size */

sizeof( GLenum ) + /* extended opcode */

sizeof( width ) +

sizeof( height ) +

sizeof( format ) +

sizeof( type ) +

sizeof( ztype ) +

sizeof( zparm ) +

sizeof( length );

packet_length += length;

data_ptr = (unsigned char *) crPackAlloc( packet_length );

WRITE_DATA( 0, GLenum , CR_ZPIXCR_EXTEND_OPCODE );

WRITE_DATA( 4, GLsizei, width );

WRITE_DATA( 8, GLsizei, height );

WRITE_DATA( 12, GLenum, format );

WRITE_DATA( 16, GLenum, type );

WRITE_DATA( 20, GLenum, ztype );

WRITE_DATA( 24, GLint, zparm );

WRITE_DATA( 28, GLint, length );

crMemcpy((void *) (data_ptr+32), pixels, length);

crHugePacket( CR_EXTEND_OPCODE, data_ptr );

crPackFree( data_ptr );

}

void PACK_APIENTRY

crPackGetTexImage( GLenum target, GLint level, GLenum format, GLenum type,

GLvoid * pixels, const CRPixelPackState * packstate,

int * writeback )

{

CR_GET_PACKER_CONTEXT(pc);

unsigned char *data_ptr;

(void) pc;

CR_GET_BUFFERED_POINTER( pc, 40 );

WRITE_DATA( 0, GLint, 40 );

WRITE_DATA( 4, GLenum, CR_GETTEXIMAGE_EXTEND_OPCODE );

WRITE_DATA( 8, GLenum, target );

WRITE_DATA( 12, GLint, level );

WRITE_DATA( 16, GLenum, format );

WRITE_DATA( 20, GLenum, type );

WRITE_NETWORK_POINTER( 24, (void *) pixels );

WRITE_NETWORK_POINTER( 32, (void *) writeback );

WRITE_OPCODE( pc, CR_EXTEND_OPCODE );

CR_CMDBLOCK_CHECK_FLUSH(pc);

CR_UNLOCK_PACKER_CONTEXT(pc);

}