VirtualBox

Ignore:
Timestamp:
Apr 18, 2019 12:07:07 AM (6 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
130111
Message:

Merge first stage of the Chromium cleanup from the branch:

  • r129818 (Remove VBOX_WITH_CR_DISPLAY_LISTS and accompanying code as it was disabled since r108676 and was never brought back (see ​bugref:3456 and ​bugref:8485))
  • r129819 (HostServices/SharedOpenGL: Remove unused main entry point from upstream server process based implementation)
  • r129820 (HostServices/SharedOpenGL: Started eliminating all backends other than HGCM. They are not used and probably wouldn't work anymore anyway)
  • r129821 (HostServices/SharedOpenGL,GuestHost/OpenGLAdditions/common/crOpenGL: Kill crTimer* API as it is not used anywhere)
  • r129822 (HostServices/SharedOpenGL,GuestHost/OpenGLAdditions/common/crOpenGL: Kill most from cr_process.h apart from two used methods)
  • r129823 (HostServices/SharedOpenGL,GuestHost/OpenGLAdditions/common/crOpenGL: Kill crList* API as it is unused)
  • r129824 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Kill crHullInteriorBox API as it is unused)
  • r129825 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Kill crWarpPoint API as it is unused)
  • r129826 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Kill CrSa* API as it is unused and not even compiled in)
  • r129827 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Kill cr_bbox.h as it is unused)
  • r129828 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove a few crParseUrl() two uses)
  • r129829 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove last crParseURL() use)
  • r129830 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove crParseURL())
  • r129831 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove VBOX_WITH_COCOA_QT and related code when not set as it is the default for years now and we don't support anything else anymore)
  • r129832 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove unused cr_logo.h)
  • r129833 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove unused crut_api.h and crut_clientapi.h)
  • r129834 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove unused cr_dmx.h)
  • r129835 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove unused cr_perf.h)
  • r129836 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove cr_rand.h and friends as it is not actively used anywhere)
  • r129837 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Get rid of all the swapped versions in the packer SPU, we never change endianess from guest to host and don't need it)
  • r129838 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove more swapper versions in the packer related code)
  • r129839 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove more swapper versions in the packer related code)
  • r129840 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove unused pack_pica.c)
  • r129841 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove more swapper versions in the packer related code)
  • r129842 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Get rid of cr_endianess.h and friends)
  • r129843 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Get rid of unused lowercase.py)
  • r129844 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Get rid of unused cr_calllists.h and friends)
  • r129845 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Get rid of completely unused idpool.c, not even compiled in)
  • r129846 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Get rid of unused cr_debugopcodes.h and friends)
  • r129847 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Make the cr_mem.h API inline and get rid of the implementation in the util library)
  • r129848 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Get rid of SPUOptions and related code as it is of no use for us)
  • r129849 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Get rid of cr_environment.h and friends and convert usage to RTEnv* APIs)
  • r129850 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Get rid of unused renderspu_agl.c)
  • r129851 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Remove unused code in cr_htable.h)
  • r129853 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Introduce a state paremeter for the unpacker workers instead of reyling on global variables, work in progress)
  • r129854 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Let the caller of crUnpack set up the initial state. This allows to get rid of the global return_ptr and writeback_ptr as they get supplied in the unpacker state by the server)
  • r129855 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Get rid of the cr_lastDispatch and cr_unpackDispatch as they are of no use now)
  • r129856 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Get rid of the global cr_unpackData and cr_unpackDataEnd symbols by indtroducing another hack to make it possible for certail server dispatch callbacks to access the data buffer)
  • r129857 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: build fix for release builds)
  • r129858 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Make the pointer to the unpacker state non const (is required for the access verification))
  • r129859 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: First iteration of the buffer size validation to prevent out of bound read access + added todos for places where additional checks are needed)
  • r129860 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Working on remaining verification todos)
  • r129861 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Working on remaining verification todos)
  • r129871 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Working on remaining verification todos)
  • r129872 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Stop as soon as the unpacker encountered an error)
  • r129876 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Working on remaining verification todos)
  • r129880 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Working on remaining verification todos)
  • r129882 (HostServices/SharedOpenGL,GuestHost/OpenGL,Additions/common/crOpenGL: Fixed some offsets in unpack_texture.c, 3DMark03 renders correctly again)
  • r130013 (HostServices/SharedOpenGL: Convert files to C++ so we can use C99 featuers on Windows with cl.exe)
  • r130014 (HostServices/SharedOpenGL,GuestHost/OpenGL: WIndows build fixes)
  • r130015 (HostServices/SharedOpenGL,GuestHost/OpenGL: More Windows build fixes)
  • r130036 (Config.kmk: Fix linker error on Windows by temporarily disabling the use of VBoxGuestR3DllMinW2K)
  • r130094 (src/VBox/GuestHost/OpenGL: Revert inlining the allocation/free functions in R3 completely as it doesn't work on Windows if memory is allocated and freed across different DLLs which don't share a common CRT, causes crashes in RtlValidtaeHeap())
  • r130095 (src/VBox/GuestHost/OpenGL,src/VBox/Additions/common/crOpenGL/pack: Don't use floating point specifiers in packspu_GetString() to avoid R6002 errors (couldn't fully understand why they occur suddenly after the rework but this gets rid of it))
Location:
trunk
Files:
22 added
22 deleted
6 edited
3 moved

Legend:

Unmodified
Added
Removed

  • trunk

    • Property svn:mergeinfo

      •  

        old new  
        99/branches/VBox-5.1:112367,115992,116543,116550,116568,116573
        1010/branches/VBox-5.2:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124260,124263,124271,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812
         11/branches/aeichner/vbox-chromium-cleanup:129816,129818-129851,129853-129861,129871-129872,129876,129880,129882,130013-130015,130036,130094-130095
        1112/branches/andy/draganddrop:90781-91268
        1213/branches/andy/guestctrl20:78916,78930

  • trunk/src/VBox

    • Property svn:mergeinfo

      •  

        old new  
        99/branches/VBox-5.1/src/VBox:112367,116543,116550,116568,116573
        1010/branches/VBox-5.2/src/VBox:119536,120083,120099,120213,120221,120239,123597-123598,123600-123601,123755,124263,124273,124277-124279,124284-124286,124288-124290,125768,125779-125780,125812,127158-127159,127162-127167,127180
         11/branches/aeichner/vbox-chromium-cleanup/src/VBox:129818-129851,129853-129861,129871-129872,129876,129880,129882,130013-130015,130094-130095
        1112/branches/andy/draganddrop/src/VBox:90781-91268
        1213/branches/andy/guestctrl20/src/VBox:78916,78930

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack.def

    r69390 r78190  
    55EXPORTS
    66crUnpack
    7 crUnpackPush
    8 crUnpackPop
    97crUnpackSetReturnPointer
    108crUnpackSetWritebackPointer

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack.py

    r78116 r78190  
    2727DECLEXPORT(const unsigned char *) cr_unpackData = NULL;
    2828DECLEXPORT(const unsigned char *) cr_unpackDataEnd = NULL;
    29 SPUDispatchTable cr_unpackDispatch;
    30 
    31 static void crUnpackExtend(void);
    32 static void crUnpackExtendDbg(void);
     29
     30static void crUnpackExtend(PCrUnpackerState pState);
     31static void crUnpackExtendDbg(PCrUnpackerState pState);
    3332
    3433#if 0 //def DEBUG_misha
    … …  
    7271    argument out of the buffer's operand area."""
    7372    if arg_type == "GLdouble" or arg_type == "GLclampd":
    74         retval = "READ_DOUBLE(%d)" % offset
    75     else:
    76         retval = "READ_DATA(%d, %s)" % (offset, arg_type)
     73        retval = "READ_DOUBLE(pState, %d)" % offset
     74    else:
     75        retval = "READ_DATA(pState, %d, %s)" % (offset, arg_type)
    7776    return retval
    7877
    … …  
    8382    arg_len = apiutil.PacketLength( params )
    8483    if (return_type != 'void'):
    85         print('\tSET_RETURN_PTR(%d);' % (arg_len + 8)) # extended opcode plus packet length
     84        print('\tSET_RETURN_PTR(pState, %d);' % (arg_len + 8)) # extended opcode plus packet length
    8685    else:
    8786        paramList = [ ('foo', 'void *', 0) ]
    88         print('\tSET_RETURN_PTR(%d);' % (arg_len + 8 - apiutil.PacketLength(paramList)))
    89 
    90 
    91 def FindWritebackPointer( return_type, params ):
    92     """Emit a SET_WRITEBACK_PTR call."""
     87        print('\tSET_RETURN_PTR(pState, %d);' % (arg_len + 8 - apiutil.PacketLength(paramList)))
     88
     89
     90def getWritebackPointerOffset(return_type, params):
     91    """Returns the offset of the writeback pointer"""
    9392    arg_len = apiutil.PacketLength( params )
    9493    if return_type != 'void':
    … …  
    9695        arg_len += apiutil.PacketLength( paramList )
    9796
    98     print('\tSET_WRITEBACK_PTR(%d);' % (arg_len + 8)) # extended opcode plus packet length
     97    return arg_len + 8 # extended opcode plus packet length
     98
     99def FindWritebackPointer( return_type, params ):
     100    """Emit a SET_WRITEBACK_PTR call."""
     101    print('\tSET_WRITEBACK_PTR(pState, %d);' % getWritebackPointerOffset(return_type, params))
    99102
    100103
    … …  
    122125    else:
    123126        print("\t", end="")
    124     print("cr_unpackDispatch.%s(%s);" % (func_name, apiutil.MakeCallStringForDispatcher(params)))
     127    print("pState->pDispatchTbl->%s(%s);" % (func_name, apiutil.MakeCallStringForDispatcher(params)))
    125128
    126129
    … …  
    134137    if arg_type == "GLdouble" or arg_type == "GLclampd":
    135138        print("#ifdef CR_UNALIGNED_ACCESS_OKAY")
    136         print("\tcr_unpackDispatch.%s((%s) cr_unpackData);" % (vec_func, vecType))
     139        print("\tpState->pDispatchTbl->%s((%s) pState->pbUnpackData);" % (vec_func, vecType))
    137140        print("#else")
    138141        for index in range(0, vecSize):
    139             print("\tGLdouble v" + repr(index) + " = READ_DOUBLE(" + repr(index * 8) + ");")
     142            print("\tGLdouble v" + repr(index) + " = READ_DOUBLE(pState, " + repr(index * 8) + ");")
    140143        if return_type != "void":
    141             print("\t(void) cr_unpackDispatch.%s(" % func_name, end="")
     144            print("\t(void) pState->pDispatchTbl->%s(" % func_name, end="")
    142145        else:
    143             print("\tcr_unpackDispatch.%s(" % func_name, end="")
     146            print("\tpState->pDispatchTbl->%s(" % func_name, end="")
    144147        for index in range(0, vecSize):
    145148            print("v" + repr(index), end="")
    … …  
    149152        print("#endif")
    150153    else:
    151         print("\tcr_unpackDispatch.%s((%s) cr_unpackData);" % (vec_func, vecType))
     154        print("\tpState->pDispatchTbl->%s((%s) pState->pbUnpackData);" % (vec_func, vecType))
    152155
    153156
    … …  
    166169    params = apiutil.Parameters(func_name)
    167170    return_type = apiutil.ReturnType(func_name)
    168    
    169     print("static void crUnpack%s(void)" % func_name)
     171
     172    packet_length = apiutil.PacketLength( params )
     173    print("static void crUnpack%s(PCrUnpackerState pState)" % func_name)
    170174    print("{")
    171 
    172     # Verify that the provided buffer length is what we expect.
    173     packet_length = apiutil.PacketLength( params )
    174     if packet_length > 0:
    175         print("\tif(!DATA_POINTER_CHECK(%d))" % packet_length);
    176         print("\t{");
    177         print("\t\tcrError(\"crUnpack%s: parameters out of range\");" % func_name);
    178         print("\t\treturn;");
    179         print("\t}");
     175    if ("get" in apiutil.Properties(func_name)):
     176        print("\tCHECK_BUFFER_SIZE_STATIC(pState, %s);" % getWritebackPointerOffset(return_type, params));
     177    elif packet_length != 0:
     178        print("\tCHECK_BUFFER_SIZE_STATIC(pState, %s);" % packet_length);
    180179
    181180    vector_func = apiutil.VectorFunction(func_name)
    … …  
    185184        MakeNormalCall( return_type, func_name, params )
    186185    if packet_length == 0:
    187         print("\tINCR_DATA_PTR_NO_ARGS( );")
    188     else:
    189         print("\tINCR_DATA_PTR(%d);" % packet_length)
     186        print("\tINCR_DATA_PTR_NO_ARGS(pState);")
     187    else:
     188        print("\tINCR_DATA_PTR(pState, %d);" % packet_length)
    190189    print("}\n")
    191190
    … …  
    195194#
    196195print("""
    197 typedef struct __dispatchNode {
    198     const unsigned char *unpackData;
    199     struct __dispatchNode *next;
    200 } DispatchNode;
    201 
    202 static DispatchNode *unpackStack = NULL;
    203 
    204 static SPUDispatchTable *cr_lastDispatch = NULL;
    205 
    206 void crUnpackPush(void)
    207 {
    208     DispatchNode *node = (DispatchNode*)crAlloc( sizeof( *node ) );
    209     node->next = unpackStack;
    210     unpackStack = node;
    211     node->unpackData = cr_unpackData;
    212 }
    213 
    214 void crUnpackPop(void)
    215 {
    216     DispatchNode *node = unpackStack;
    217 
    218     if (!node)
    219     {
    220         crError( "crUnpackPop called with an empty stack!" );
    221     }
    222     unpackStack = node->next;
    223     cr_unpackData = node->unpackData;
    224     crFree( node );
    225 }
    226 
    227196CR_UNPACK_BUFFER_TYPE crUnpackGetBufferType(const void *opcodes, unsigned int num_opcodes)
    228197{
    … …  
    249218}
    250219
    251 void crUnpack( const void *data, const void *data_end, const void *opcodes,
    252         unsigned int num_opcodes, SPUDispatchTable *table )
     220void crUnpack(PCrUnpackerState pState)
    253221{
    254222    unsigned int i;
    255     const unsigned char *unpack_opcodes;
    256     if (table != cr_lastDispatch)
    257     {
    258         crSPUCopyDispatchTable( &cr_unpackDispatch, table );
    259         cr_lastDispatch = table;
    260     }
    261 
    262     unpack_opcodes = (const unsigned char *)opcodes;
    263     cr_unpackData = (const unsigned char *)data;
    264     cr_unpackDataEnd = (const unsigned char *)data_end;
    265223
    266224#if defined(CR_UNPACK_DEBUG_OPCODES) || defined(CR_UNPACK_DEBUG_LAST_OPCODES)
    267     crDebug("crUnpack: %d opcodes", num_opcodes);
    268 #endif
    269 
    270     for (i = 0; i < num_opcodes; i++)
     225    crDebug("crUnpack: %d opcodes", pState->cOpcodes);
     226#endif
     227
     228    for (i = 0; i < pState->cOpcodes && RT_SUCCESS(pState->rcUnpack); i++)
    271229    {
    272230   
    273         CRDBGPTR_CHECKZ(writeback_ptr);
    274         CRDBGPTR_CHECKZ(return_ptr);
     231        CRDBGPTR_CHECKZ(pState->pWritebackPtr);
     232        CRDBGPTR_CHECKZ(pState->pReturnPtr);
    275233   
    276         /*crDebug(\"Unpacking opcode \%d\", *unpack_opcodes);*/
     234        /*crDebug(\"Unpacking opcode \%d\", *pState->pbOpcodes);*/
    277235#ifdef CR_UNPACK_DEBUG_PREV_OPCODES
    278         g_VBoxDbgCrPrevOpcode = *unpack_opcodes;
    279 #endif
    280         switch( *unpack_opcodes )
     236        g_VBoxDbgCrPrevOpcode = *pState->pbOpcodes;
     237#endif
     238        switch( *pState->pbOpcodes )
    281239        {""")
    282240
    … …  
    295253                crDebug("Unpack: %s");
    296254#endif """ % apiutil.OpcodeName(func_name))
    297         print('\t\t\t\tcrUnpack%s(); \n\t\t\t\tbreak;' % func_name)
     255        print('\t\t\t\tcrUnpack%s(pState); \n\t\t\t\tbreak;' % func_name)
    298256
    299257print("""       
    300258            case CR_EXTEND_OPCODE:
    301259                #ifdef CR_UNPACK_DEBUG_OPCODES
    302                     crUnpackExtendDbg();
     260                    crUnpackExtendDbg(pState);
    303261                #else
    304262                # ifdef CR_UNPACK_DEBUG_LAST_OPCODES
    305                     if (i==(num_opcodes-1)) crUnpackExtendDbg();
     263                    if (i==(num_opcodes-1)) crUnpackExtendDbg(pState);
    306264                    else
    307265                # endif
    308                     crUnpackExtend();
     266                    crUnpackExtend(pState);
    309267                #endif
    310268                break;
    … …  
    313271            case CR_CMDBLOCKFLUSH_OPCODE:
    314272            case CR_NOP_OPCODE:
    315                 INCR_DATA_PTR_NO_ARGS( );
     273                INCR_DATA_PTR_NO_ARGS(pState);
    316274                break;
    317275            default:
    318                 crError( "Unknown opcode: %d", *unpack_opcodes );
     276                crError( "Unknown opcode: %d", *pState->pbOpcodes );
    319277                break;
    320278        }
    321        
    322         CRDBGPTR_CHECKZ(writeback_ptr);
    323         CRDBGPTR_CHECKZ(return_ptr);
    324        
    325         unpack_opcodes--;
     279
     280        CRDBGPTR_CHECKZ(pState->pWritebackPtr);
     281        CRDBGPTR_CHECKZ(pState->pReturnPtr);
     282        pState->pbOpcodes--;
    326283    }
    327284}""")
    … …  
    336293            return_type = apiutil.ReturnType(func_name)
    337294            params = apiutil.Parameters(func_name)
    338             print('static void crUnpackExtend%s(void)' % func_name)
     295            print('static void crUnpackExtend%s(PCrUnpackerState pState)' % func_name)
    339296            print('{')
    340 
    341             # Verify that the provided buffer length is what we expect.
    342             packet_length = apiutil.PacketLength( params )
    343             if packet_length > 0:
    344                 print("\tif(!DATA_POINTER_CHECK(%d))" % packet_length);
    345                 print("\t{");
    346                 print("\t\tcrError(\"crUnpack%s: parameters out of range\");" % func_name);
    347                 print("\t\treturn;");
    348                 print("\t}");
    349 
     297            if ("get" in apiutil.Properties(func_name)):
     298                print("\tCHECK_BUFFER_SIZE_STATIC(pState, %s);" % (8 + getWritebackPointerOffset(return_type, params)));
     299            else:
     300                print("\tCHECK_BUFFER_SIZE_STATIC(pState, %s);" % (8 + apiutil.PacketLength( params )));
    350301            MakeNormalCall( return_type, func_name, params, 8 )
    351302            print('}\n')
    352303
    353 print('static void crUnpackExtend(void)')
     304print('static void crUnpackExtend(PCrUnpackerState pState)')
    354305print('{')
     306print('\tCHECK_BUFFER_SIZE_STATIC_LAST(pState, 4, GLenum);');
    355307print('\tGLenum extend_opcode = %s;' % ReadData( 4, 'GLenum' ))
    356308print('')
    … …  
    371323        print('\t\tcase %s:' % apiutil.ExtendedOpcodeName( func_name ))
    372324#        print('\t\t\t\tcrDebug("Unpack: %s");' % apiutil.ExtendedOpcodeName( func_name )))
    373         print('\t\t\tcrUnpackExtend%s( );' % func_name)
     325        print('\t\t\tcrUnpackExtend%s(pState);' % func_name)
    374326        print('\t\t\tbreak;')
    375327
    … …  
    378330            break;
    379331    }
    380     INCR_VAR_PTR();
     332    INCR_VAR_PTR(pState);
    381333}""")
    382334
    383 print('static void crUnpackExtendDbg(void)')
     335print('static void crUnpackExtendDbg(PCrUnpackerState pState)')
    384336print('{')
     337print('\tCHECK_BUFFER_SIZE_STATIC_LAST(pState, 4, GLenum);');
    385338print('\tGLenum extend_opcode = %s;' % ReadData( 4, 'GLenum' ))
    386339print('')
    … …  
    402355        if not apiutil.ExtendedOpcodeName(func_name) in nodebug_extopcodes:
    403356            print('\t\t\tcrDebug("Unpack: %s");' % apiutil.ExtendedOpcodeName( func_name ))
    404         print('\t\t\tcrUnpackExtend%s( );' % func_name)
     357        print('\t\t\tcrUnpackExtend%s(pState);' % func_name)
    405358        print('\t\t\tbreak;')
    406359
    … …  
    409362            break;
    410363    }
    411     INCR_VAR_PTR();
     364    INCR_VAR_PTR(pState);
    412365}""")

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_arrays.cpp

    r78189 r78190  
    2020 */
    2121
    22 void crUnpackExtendVertexPointer(void)
    23 {
    24     GLint size = READ_DATA( 8, GLint );
    25     GLenum type = READ_DATA( 12, GLenum );
    26     GLsizei stride = READ_DATA( 16, GLsizei );
    27     GLintptrARB pointer = (GLintptrARB) READ_DATA( 20, GLuint );
    28     cr_unpackDispatch.VertexPointer( size, type, stride, (void *) pointer, false /*fRealPtr*/ );
    29 }
    30 
    31 void crUnpackExtendTexCoordPointer(void)
    32 {
    33     GLint size = READ_DATA( 8, GLint );
    34     GLenum type = READ_DATA( 12, GLenum );
    35     GLsizei stride = READ_DATA( 16, GLsizei );
    36     GLintptrARB pointer = READ_DATA( 20, GLuint );
    37     cr_unpackDispatch.TexCoordPointer( size, type, stride, (void *) pointer, false /*fRealPtr*/ );
    38 }
    39 
    40 void crUnpackExtendNormalPointer(void)
    41 {
    42     GLenum type = READ_DATA( 8, GLenum );
    43     GLsizei stride = READ_DATA( 12, GLsizei );
    44     GLintptrARB pointer = READ_DATA( 16, GLuint );
    45     cr_unpackDispatch.NormalPointer( type, stride, (void *) pointer, false /*fRealPtr*/ );
    46 }
    47 
    48 void crUnpackExtendIndexPointer(void)
    49 {
    50     GLenum type = READ_DATA( 8, GLenum );
    51     GLsizei stride = READ_DATA( 12, GLsizei );
    52     GLintptrARB pointer = READ_DATA( 16, GLuint );
    53     cr_unpackDispatch.IndexPointer( type, stride, (void *) pointer, false /*fRealPtr*/ );
    54 }
    55 
    56 void crUnpackExtendEdgeFlagPointer(void)
    57 {
    58     GLsizei stride = READ_DATA( 8, GLsizei );
    59     GLintptrARB pointer = READ_DATA( 12, GLuint );
    60     cr_unpackDispatch.EdgeFlagPointer( stride, (void *) pointer, false /*fRealPtr*/ );
    61 }
    62 
    63 void crUnpackExtendColorPointer(void)
    64 {
    65     GLint size = READ_DATA( 8, GLint );
    66     GLenum type = READ_DATA( 12, GLenum );
    67     GLsizei stride = READ_DATA( 16, GLsizei );
    68     GLintptrARB pointer = READ_DATA( 20, GLuint );
    69     cr_unpackDispatch.ColorPointer( size, type, stride, (void *) pointer, false /*fRealPtr*/ );
    70 }
    71 
    72 void crUnpackExtendFogCoordPointerEXT(void)
    73 {
    74     GLenum type = READ_DATA( 8, GLenum );
    75     GLsizei stride = READ_DATA( 12, GLsizei );
    76     GLintptrARB pointer = READ_DATA( 16, GLuint );
    77     cr_unpackDispatch.FogCoordPointerEXT( type, stride, (void *) pointer, false /*fRealPtr*/ );
    78 }
    79 
    80 void crUnpackExtendSecondaryColorPointerEXT(void)
    81 {
    82     GLint size = READ_DATA( 8, GLint );
    83     GLenum type = READ_DATA( 12, GLenum );
    84     GLsizei stride = READ_DATA( 16, GLsizei );
    85     GLintptrARB pointer = READ_DATA( 20, GLuint );
    86     cr_unpackDispatch.SecondaryColorPointerEXT( size, type, stride, (void *) pointer, false /*fRealPtr*/ );
    87 }
    88 
    89 void crUnpackExtendVertexAttribPointerARB(void)
    90 {
    91     GLuint index = READ_DATA( 8, GLuint);
    92     GLint size = READ_DATA( 12, GLint );
    93     GLenum type = READ_DATA( 16, GLenum );
    94     GLboolean normalized = READ_DATA( 20, GLboolean );
    95     GLsizei stride = READ_DATA( 24, GLsizei );
    96     GLintptrARB pointer = READ_DATA( 28, GLuint );
    97     cr_unpackDispatch.VertexAttribPointerARB( index, size, type, normalized, stride, (void *) pointer, false /*fRealPtr*/ );
    98 }
    99 
    100 void crUnpackExtendVertexAttribPointerNV(void)
    101 {
    102     GLuint index = READ_DATA( 8, GLuint);
    103     GLint size = READ_DATA( 12, GLint );
    104     GLenum type = READ_DATA( 16, GLenum );
    105     GLsizei stride = READ_DATA( 20, GLsizei );
    106     GLintptrARB pointer = READ_DATA( 24, GLuint );
    107     cr_unpackDispatch.VertexAttribPointerNV( index, size, type, stride, (void *) pointer, false /*fRealPtr*/ );
    108 }
    109 
    110 void crUnpackExtendInterleavedArrays(void)
    111 {
    112     GLenum format = READ_DATA( 8, GLenum );
    113     GLsizei stride = READ_DATA( 12, GLsizei );
    114     GLintptrARB pointer = READ_DATA( 16, GLuint );
    115     cr_unpackDispatch.InterleavedArrays( format, stride, (void *) pointer, false /*fRealPtr*/ );
    116 }
    117 
    118 void crUnpackExtendDrawElements(void)
    119 {
    120     GLenum mode         = READ_DATA( 8, GLenum );
    121     GLsizei count       = READ_DATA( 12, GLsizei );
    122     GLenum type         = READ_DATA( 16, GLenum );
    123     GLintptrARB indices = READ_DATA( 20, GLuint );
     22void crUnpackExtendVertexPointer(PCrUnpackerState pState)
     23{
     24    CHECK_BUFFER_SIZE_STATIC(pState, 20 + sizeof(GLuint) );
     25
     26    GLint size = READ_DATA(pState, 8, GLint );
     27    GLenum type = READ_DATA(pState, 12, GLenum );
     28    GLsizei stride = READ_DATA(pState, 16, GLsizei );
     29    GLintptrARB pointer = (GLintptrARB) READ_DATA(pState, 20, GLuint );
     30    pState->pDispatchTbl->VertexPointer( size, type, stride, (void *) pointer, false /*fRealPtr*/ );
     31}
     32
     33void crUnpackExtendTexCoordPointer(PCrUnpackerState pState)
     34{
     35    CHECK_BUFFER_SIZE_STATIC(pState, 20 + sizeof(GLuint) );
     36
     37    GLint size = READ_DATA(pState, 8, GLint );
     38    GLenum type = READ_DATA(pState, 12, GLenum );
     39    GLsizei stride = READ_DATA(pState, 16, GLsizei );
     40    GLintptrARB pointer = READ_DATA(pState, 20, GLuint );
     41    pState->pDispatchTbl->TexCoordPointer( size, type, stride, (void *) pointer, false /*fRealPtr*/ );
     42}
     43
     44void crUnpackExtendNormalPointer(PCrUnpackerState pState)
     45{
     46    CHECK_BUFFER_SIZE_STATIC(pState, 16 + sizeof(GLuint) );
     47
     48    GLenum type = READ_DATA(pState, 8, GLenum );
     49    GLsizei stride = READ_DATA(pState, 12, GLsizei );
     50    GLintptrARB pointer = READ_DATA(pState, 16, GLuint );
     51    pState->pDispatchTbl->NormalPointer( type, stride, (void *) pointer, false /*fRealPtr*/ );
     52}
     53
     54void crUnpackExtendIndexPointer(PCrUnpackerState pState)
     55{
     56    CHECK_BUFFER_SIZE_STATIC(pState, 16 + sizeof(GLuint) );
     57
     58    GLenum type = READ_DATA(pState, 8, GLenum );
     59    GLsizei stride = READ_DATA(pState, 12, GLsizei );
     60    GLintptrARB pointer = READ_DATA(pState, 16, GLuint );
     61    pState->pDispatchTbl->IndexPointer( type, stride, (void *) pointer, false /*fRealPtr*/ );
     62}
     63
     64void crUnpackExtendEdgeFlagPointer(PCrUnpackerState pState)
     65{
     66    CHECK_BUFFER_SIZE_STATIC(pState, 12 + sizeof(GLuint) );
     67
     68    GLsizei stride = READ_DATA(pState, 8, GLsizei );
     69    GLintptrARB pointer = READ_DATA(pState, 12, GLuint );
     70    pState->pDispatchTbl->EdgeFlagPointer( stride, (void *) pointer, false /*fRealPtr*/ );
     71}
     72
     73void crUnpackExtendColorPointer(PCrUnpackerState pState)
     74{
     75    CHECK_BUFFER_SIZE_STATIC(pState, 20 + sizeof(GLuint) );
     76
     77    GLint size = READ_DATA(pState, 8, GLint );
     78    GLenum type = READ_DATA(pState, 12, GLenum );
     79    GLsizei stride = READ_DATA(pState, 16, GLsizei );
     80    GLintptrARB pointer = READ_DATA(pState, 20, GLuint );
     81    pState->pDispatchTbl->ColorPointer( size, type, stride, (void *) pointer, false /*fRealPtr*/ );
     82}
     83
     84void crUnpackExtendFogCoordPointerEXT(PCrUnpackerState pState)
     85{
     86    CHECK_BUFFER_SIZE_STATIC(pState, 16 + sizeof(GLuint) );
     87
     88    GLenum type = READ_DATA(pState, 8, GLenum );
     89    GLsizei stride = READ_DATA(pState, 12, GLsizei );
     90    GLintptrARB pointer = READ_DATA(pState, 16, GLuint );
     91    pState->pDispatchTbl->FogCoordPointerEXT( type, stride, (void *) pointer, false /*fRealPtr*/ );
     92}
     93
     94void crUnpackExtendSecondaryColorPointerEXT(PCrUnpackerState pState)
     95{
     96    CHECK_BUFFER_SIZE_STATIC(pState, 20 + sizeof(GLuint) );
     97
     98    GLint size = READ_DATA(pState, 8, GLint );
     99    GLenum type = READ_DATA(pState, 12, GLenum );
     100    GLsizei stride = READ_DATA(pState, 16, GLsizei );
     101    GLintptrARB pointer = READ_DATA(pState, 20, GLuint );
     102    pState->pDispatchTbl->SecondaryColorPointerEXT( size, type, stride, (void *) pointer, false /*fRealPtr*/ );
     103}
     104
     105void crUnpackExtendVertexAttribPointerARB(PCrUnpackerState pState)
     106{
     107    CHECK_BUFFER_SIZE_STATIC(pState, 28 + sizeof(GLuint) );
     108
     109    GLuint index = READ_DATA(pState, 8, GLuint);
     110    GLint size = READ_DATA(pState, 12, GLint );
     111    GLenum type = READ_DATA(pState, 16, GLenum );
     112    GLboolean normalized = READ_DATA(pState, 20, GLboolean );
     113    GLsizei stride = READ_DATA(pState, 24, GLsizei );
     114    GLintptrARB pointer = READ_DATA(pState, 28, GLuint );
     115    pState->pDispatchTbl->VertexAttribPointerARB( index, size, type, normalized, stride, (void *) pointer, false /*fRealPtr*/ );
     116}
     117
     118void crUnpackExtendVertexAttribPointerNV(PCrUnpackerState pState)
     119{
     120    CHECK_BUFFER_SIZE_STATIC(pState, 24 + sizeof(GLuint) );
     121
     122    GLuint index = READ_DATA(pState, 8, GLuint);
     123    GLint size = READ_DATA(pState, 12, GLint );
     124    GLenum type = READ_DATA(pState, 16, GLenum );
     125    GLsizei stride = READ_DATA(pState, 20, GLsizei );
     126    GLintptrARB pointer = READ_DATA(pState, 24, GLuint );
     127    pState->pDispatchTbl->VertexAttribPointerNV( index, size, type, stride, (void *) pointer, false /*fRealPtr*/ );
     128}
     129
     130void crUnpackExtendInterleavedArrays(PCrUnpackerState pState)
     131{
     132    CHECK_BUFFER_SIZE_STATIC(pState, 16 + sizeof(GLuint) );
     133
     134    GLenum format = READ_DATA(pState, 8, GLenum );
     135    GLsizei stride = READ_DATA(pState, 12, GLsizei );
     136    GLintptrARB pointer = READ_DATA(pState, 16, GLuint );
     137    pState->pDispatchTbl->InterleavedArrays( format, stride, (void *) pointer, false /*fRealPtr*/ );
     138}
     139
     140void crUnpackExtendDrawElements(PCrUnpackerState pState)
     141{
     142#ifdef CR_ARB_vertex_buffer_object
     143    CHECK_BUFFER_SIZE_STATIC(pState, 28);
     144#else
     145    CHECK_BUFFER_SIZE_STATIC(pState, 24);
     146#endif
     147
     148    GLenum mode         = READ_DATA(pState, 8, GLenum );
     149    GLsizei count       = READ_DATA(pState, 12, GLsizei );
     150    GLenum type         = READ_DATA(pState, 16, GLenum );
     151    GLintptrARB indices = READ_DATA(pState, 20, GLuint );
    124152    void * indexptr;
     153
     154    size_t cbElem = 0;
     155    switch (type)
     156    {
     157        case GL_UNSIGNED_BYTE:
     158            cbElem = sizeof(GLubyte);
     159            break;
     160        case GL_UNSIGNED_SHORT:
     161            cbElem = sizeof(GLubyte);
     162            break;
     163        case GL_UNSIGNED_INT:
     164            cbElem = sizeof(GLubyte);
     165            break;
     166        default:
     167            crError("crUnpackExtendDrawElements: Invalid type (%#x) passed!\n", type);
     168            pState->rcUnpack = VERR_INVALID_PARAMETER;
     169            return;
     170    }
     171
    125172#ifdef CR_ARB_vertex_buffer_object
    126     GLboolean hasidxdata = READ_DATA(24, GLint);
    127     indexptr = hasidxdata ? DATA_POINTER(28, void) : (void*)indices;
     173    GLboolean hasidxdata = READ_DATA(pState, 24, GLint);
     174    indexptr = hasidxdata ? DATA_POINTER(pState, 28, void) : (void*)indices;
     175    if (hasidxdata)
     176        CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_SZ_LAST(pState, indexptr, count, cbElem);
    128177#else
    129     indexptr = DATA_POINTER(24, void);
     178    indexptr = DATA_POINTER(pState, 24, void);
     179    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_SZ_LAST(pState, indexptr, count, cbElem);
    130180#endif
    131     cr_unpackDispatch.DrawElements(mode, count, type, indexptr);
    132 }
    133 
    134 void crUnpackExtendDrawRangeElements(void)
    135 {
    136     GLenum mode         = READ_DATA( 8, GLenum );
    137     GLuint start        = READ_DATA( 12, GLuint );
    138     GLuint end          = READ_DATA( 16, GLuint );
    139     GLsizei count       = READ_DATA( 20, GLsizei );
    140     GLenum type         = READ_DATA( 24, GLenum );
    141     GLintptrARB indices = READ_DATA( 28, GLuint );
     181    pState->pDispatchTbl->DrawElements(mode, count, type, indexptr);
     182}
     183
     184void crUnpackExtendDrawRangeElements(PCrUnpackerState pState)
     185{
     186#ifdef CR_ARB_vertex_buffer_object
     187    CHECK_BUFFER_SIZE_STATIC(pState, 36);
     188#else
     189    CHECK_BUFFER_SIZE_STATIC(pState, 32);
     190#endif
     191
     192    GLenum mode         = READ_DATA(pState, 8, GLenum );
     193    GLuint start        = READ_DATA(pState, 12, GLuint );
     194    GLuint end          = READ_DATA(pState, 16, GLuint );
     195    GLsizei count       = READ_DATA(pState, 20, GLsizei );
     196    GLenum type         = READ_DATA(pState, 24, GLenum );
     197    GLintptrARB indices = READ_DATA(pState, 28, GLuint );
    142198    void * indexptr;
     199
     200    size_t cbElem = 0;
     201    switch (type)
     202    {
     203        case GL_UNSIGNED_BYTE:
     204            cbElem = sizeof(GLubyte);
     205            break;
     206        case GL_UNSIGNED_SHORT:
     207            cbElem = sizeof(GLubyte);
     208            break;
     209        case GL_UNSIGNED_INT:
     210            cbElem = sizeof(GLubyte);
     211            break;
     212        default:
     213            crError("crUnpackExtendDrawElements: Invalid type (%#x) passed!\n", type);
     214            pState->rcUnpack = VERR_INVALID_PARAMETER;
     215            return;
     216    }
    143217#ifdef CR_ARB_vertex_buffer_object
    144     GLboolean hasidxdata = READ_DATA(32, GLint);
    145     indexptr = hasidxdata ? DATA_POINTER(36, void) : (void*)indices;
     218    GLboolean hasidxdata = READ_DATA(pState, 32, GLint);
     219    indexptr = hasidxdata ? DATA_POINTER(pState, 36, void) : (void*)indices;
     220    if (hasidxdata)
     221        CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_SZ_LAST(pState, indexptr, count, cbElem);
    146222#else
    147     indexptr = DATA_POINTER(32, void);
     223    indexptr = DATA_POINTER(pState, 32, void);
     224    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_SZ_LAST(pState, indexptr, count, cbElem);
    148225#endif
    149     cr_unpackDispatch.DrawRangeElements(mode, start, end, count, type, indexptr);
    150 }
    151 
    152 void crUnpackMultiDrawArraysEXT(void)
    153 {
     226
     227    pState->pDispatchTbl->DrawRangeElements(mode, start, end, count, type, indexptr);
     228}
     229
     230void crUnpackMultiDrawArraysEXT(PCrUnpackerState pState)
     231{
     232    RT_NOREF(pState);
    154233    crError( "Can't decode MultiDrawArraysEXT" );
    155234}
    156235
    157 void crUnpackMultiDrawElementsEXT(void)
    158 {
     236void crUnpackMultiDrawElementsEXT(PCrUnpackerState pState)
     237{
     238    RT_NOREF(pState);
    159239    crError( "Can't decode MultiDrawElementsEXT" );
    160240}
    161241
    162 static void crUnpackSetClientPointerByIndex(int index, GLint size,
     242static void crUnpackSetClientPointerByIndex(PCrUnpackerState pState, int index, GLint size,
    163243                                            GLenum type, GLboolean normalized,
    164244                                            GLsizei stride, const GLvoid *pointer, CRClientState *c, int fRealPtr)
    … …  
    171251        {
    172252            case 0:
    173                 cr_unpackDispatch.VertexPointer(size, type, stride, pointer, fRealPtr);
     253                pState->pDispatchTbl->VertexPointer(size, type, stride, pointer, fRealPtr);
    174254                break;
    175255            case 1:
    176                 cr_unpackDispatch.ColorPointer(size, type, stride, pointer, fRealPtr);
     256                pState->pDispatchTbl->ColorPointer(size, type, stride, pointer, fRealPtr);
    177257                break;
    178258            case 2:
    179                 cr_unpackDispatch.FogCoordPointerEXT(type, stride, pointer, fRealPtr);
     259                pState->pDispatchTbl->FogCoordPointerEXT(type, stride, pointer, fRealPtr);
    180260                break;
    181261            case 3:
    182                 cr_unpackDispatch.SecondaryColorPointerEXT(size, type, stride, pointer, fRealPtr);
     262                pState->pDispatchTbl->SecondaryColorPointerEXT(size, type, stride, pointer, fRealPtr);
    183263                break;
    184264            case 4:
    185                 cr_unpackDispatch.EdgeFlagPointer(stride, pointer, fRealPtr);
     265                pState->pDispatchTbl->EdgeFlagPointer(stride, pointer, fRealPtr);
    186266                break;
    187267            case 5:
    188                 cr_unpackDispatch.IndexPointer(type, stride, pointer, fRealPtr);
     268                pState->pDispatchTbl->IndexPointer(type, stride, pointer, fRealPtr);
    189269                break;
    190270            case 6:
    191                 cr_unpackDispatch.NormalPointer(type, stride, pointer, fRealPtr);
     271                pState->pDispatchTbl->NormalPointer(type, stride, pointer, fRealPtr);
    192272                break;
    193273        }
    … …  
    198278        if ((index-7)!=curTexUnit)
    199279        {
    200             cr_unpackDispatch.ClientActiveTextureARB(GL_TEXTURE0_ARB+index-7);
    201         }
    202         cr_unpackDispatch.TexCoordPointer(size, type, stride, pointer, fRealPtr);
     280            pState->pDispatchTbl->ClientActiveTextureARB(GL_TEXTURE0_ARB+index-7);
     281        }
     282        pState->pDispatchTbl->TexCoordPointer(size, type, stride, pointer, fRealPtr);
    203283        if ((index-7)!=curTexUnit)
    204284        {
    205             cr_unpackDispatch.ClientActiveTextureARB(GL_TEXTURE0_ARB+curTexUnit);
     285            pState->pDispatchTbl->ClientActiveTextureARB(GL_TEXTURE0_ARB+curTexUnit);
    206286        }
    207287    }
    208288    else
    209289    {
    210         cr_unpackDispatch.VertexAttribPointerARB(index-7-CR_MAX_TEXTURE_UNITS,
     290        pState->pDispatchTbl->VertexAttribPointerARB(index-7-CR_MAX_TEXTURE_UNITS,
    211291                                                 size, type, normalized, stride, pointer, fRealPtr);
    212292    }
    213293}
    214294
    215 void crUnpackExtendLockArraysEXT(void)
    216 {
    217     GLint first    = READ_DATA(sizeof(int) + 4, GLint);
    218     GLint count    = READ_DATA(sizeof(int) + 8, GLint);
    219     int numenabled = READ_DATA(sizeof(int) + 12, int);
     295void crUnpackExtendLockArraysEXT(PCrUnpackerState pState)
     296{
     297    CHECK_BUFFER_SIZE_STATIC(pState, sizeof(int) + 12 + sizeof(int));
     298
     299    GLint first    = READ_DATA(pState, sizeof(int) + 4, GLint);
     300    GLint count    = READ_DATA(pState, sizeof(int) + 8, GLint);
     301    int numenabled = READ_DATA(pState, sizeof(int) + 12, int);
    220302
    221303    CRContext *g = crStateGetCurrent();
    … …  
    223305    CRClientPointer *cp;
    224306    int i, index, offset;
    225     unsigned char *data;
    226    
     307    uint8_t *data;
     308
    227309    if (first < 0 || count <= 0 || first >= INT32_MAX - count)
    228310    {
    … …  
    243325    for (i = 0; i < numenabled; ++i)
    244326    {
    245         index = READ_DATA(offset, int);
     327        CHECK_BUFFER_SIZE_STATIC_LAST(pState, offset, int);
     328        index = READ_DATA(pState, offset, int);
    246329        offset += sizeof(int);
    247330
    … …  
    258341            }
    259342
    260             data = crAlloc((first + count) * cp->bytesPerIndex);
     343            data = (uint8_t *)crAlloc((first + count) * cp->bytesPerIndex);
    261344
    262345            if (data)
    263346            {
    264                 crMemcpy(data + first * cp->bytesPerIndex, DATA_POINTER(offset, GLvoid), count * cp->bytesPerIndex);
     347                crMemcpy(data + first * cp->bytesPerIndex, DATA_POINTER(pState, offset, GLvoid), count * cp->bytesPerIndex);
    265348                /*crDebug("crUnpackExtendLockArraysEXT: old cp(%i): en/l=%i(%i) p=%p size=%i type=0x%x n=%i str=%i pp=%p pstr=%i",
    266349                        index, cp->enabled, cp->locked, cp->p, cp->size, cp->type, cp->normalized, cp->stride, cp->prevPtr, cp->prevStride);*/
    267                 crUnpackSetClientPointerByIndex(index, cp->size, cp->type, cp->normalized, 0, data, c, 1 /*fRealPtr*/);
     350                crUnpackSetClientPointerByIndex(pState, index, cp->size, cp->type, cp->normalized, 0, data, c, 1);
    268351                /*crDebug("crUnpackExtendLockArraysEXT: new cp(%i): en/l=%i(%i) p=%p size=%i type=0x%x n=%i str=%i pp=%p pstr=%i",
    269352                        index, cp->enabled, cp->locked, cp->p, cp->size, cp->type, cp->normalized, cp->stride, cp->prevPtr, cp->prevStride);*/
    … …  
    284367    }
    285368
    286     cr_unpackDispatch.LockArraysEXT(first, count);
    287 }
    288 
    289 void crUnpackExtendUnlockArraysEXT(void)
     369    pState->pDispatchTbl->LockArraysEXT(first, count);
     370}
     371
     372void crUnpackExtendUnlockArraysEXT(PCrUnpackerState pState)
    290373{
    291374    int i;
    … …  
    296379    /*crDebug("crUnpackExtendUnlockArraysEXT");*/
    297380
    298     cr_unpackDispatch.UnlockArraysEXT();
     381    pState->pDispatchTbl->UnlockArraysEXT();
    299382
    300383    for (i=0; i<CRSTATECLIENT_MAX_VERTEXARRAYS; ++i)
    … …  
    309392            cp->prevPtr = NULL;
    310393            cp->fPrevRealPtr = 0;
    311             crUnpackSetClientPointerByIndex(i, cp->size, cp->type, cp->normalized, cp->prevStride, prevPtr, c, fPrevRealPtr);
     394
     395            crUnpackSetClientPointerByIndex(pState, i, cp->size, cp->type, cp->normalized, cp->prevStride, prevPtr, c, fPrevRealPtr);
    312396            /*crDebug("crUnpackExtendUnlockArraysEXT: new cp(%i): en/l=%i(%i) p=%p size=%i type=0x%x n=%i str=%i pp=%p pstr=%i",
    313397                    i, cp->enabled, cp->locked, cp->p, cp->size, cp->type, cp->normalized, cp->stride, cp->prevPtr, cp->prevStride);*/

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_extend.py

    r78086 r78190  
    1818#define UNPACK_EXTEND_H 1
    1919
     20#include "cr_unpack.h"
     21
    2022#ifdef __cplusplus
    2123extern "C" {
    … …  
    3032for func_name in apiutil.AllSpecials( "unpacker" ):
    3133        if "extpack" in apiutil.ChromiumProps(func_name):
    32                 print('extern void crUnpackExtend%s(void);' % func_name)
     34                print('extern void crUnpackExtend%s(PCrUnpackerState pState);' % func_name)
    3335        else:
    34                 print('extern void crUnpack%s(void);' % func_name)
     36                print('extern void crUnpack%s(PCrUnpackerState pState);' % func_name)
    3537
    3638print("""

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_header.py

    r69390 r78190  
    2222print("""#ifndef CR_UNPACKFUNCTIONS_H
    2323#define CR_UNPACKFUNCTIONS_H
     24
     25#include "cr_unpack.h"
    2426""")
    2527
    2628for func_name in sorted(gl_mapping.keys()):
    2729        ( return_type, arg_names, arg_types ) = gl_mapping[func_name]
    28         print('void crUnpack%s();' %( func_name ))
    29 print('void crUnpackExtend();')
     30        print('void crUnpack%s(PCrUnpackerState pState);' %( func_name ))
     31print('void crUnpackExtend(PCrUnpackerState pState);')
    3032print('\n#endif /* CR_UNPACKFUNCTIONS_H */')

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_misc.cpp

    r78189 r78190  
    77#include "unpacker.h"
    88
    9 void crUnpackExtendChromiumParametervCR( void  )
     9void crUnpackExtendChromiumParametervCR(PCrUnpackerState pState)
    1010{
    11     GLenum target = READ_DATA( 8, GLenum );
    12     GLenum type = READ_DATA( 12, GLenum );
    13     GLsizei count = READ_DATA( 16, GLsizei );
    14     GLvoid *values = DATA_POINTER( 20, GLvoid );
     11    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, GLsizei);
    1512
    16     cr_unpackDispatch.ChromiumParametervCR(target, type, count, values);
     13    GLenum target = READ_DATA(pState, 8, GLenum );
     14    GLenum type = READ_DATA(pState, 12, GLenum );
     15    GLsizei count = READ_DATA(pState, 16, GLsizei );
     16    GLvoid *values = DATA_POINTER(pState, 20, GLvoid );
    1717
     18    size_t cbValue = 0;
     19    switch (type)
     20    {
     21        case GL_BYTE:
     22        case GL_UNSIGNED_BYTE:
     23            cbValue = sizeof(GLbyte);
     24            break;
     25        case GL_SHORT:
     26        case GL_UNSIGNED_SHORT:
     27            cbValue = sizeof(GLshort);
     28            break;
     29        case GL_INT:
     30        case GL_UNSIGNED_INT:
     31            cbValue = sizeof(GLint);
     32            break;
     33        case GL_FLOAT:
     34            cbValue = sizeof(GLfloat);
     35            break;
     36        case GL_DOUBLE:
     37            cbValue = sizeof(GLdouble);
     38            break;
     39        default:
     40            crError("crUnpackExtendChromiumParametervCR: Invalid type (%#x) passed!\n", type);
     41            pState->rcUnpack = VERR_INVALID_PARAMETER;
     42            return;
     43    }
    1844
    19     /*
    20     INCR_VAR_PTR();
    21     */
     45    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_SZ_LAST(pState, values, count, cbValue);
     46    pState->pDispatchTbl->ChromiumParametervCR(target, type, count, values);
    2247}
    2348
    24 void crUnpackExtendDeleteQueriesARB(void)
     49void crUnpackExtendDeleteQueriesARB(PCrUnpackerState pState)
    2550{
    26     GLsizei n = READ_DATA( 8, GLsizei );
    27     const GLuint *ids = DATA_POINTER(12, GLuint);
     51    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 8, GLsizei);
    2852
    29     if (n <= 0 || n >= INT32_MAX / sizeof(GLint) / 4 || !DATA_POINTER_CHECK(12 + n * sizeof(GLuint)))
     53    GLsizei n = READ_DATA(pState, 8, GLsizei );
     54    const GLuint *ids = DATA_POINTER(pState, 12, GLuint);
     55
     56    if (n <= 0 || n >= INT32_MAX / sizeof(GLint) / 4 || !DATA_POINTER_CHECK(pState, 12 + n * sizeof(GLuint)))
    3057    {
    3158        crError("crUnpackExtendDeleteQueriesARB: parameter 'n' is out of range");
    … …  
    3360    }
    3461
    35     cr_unpackDispatch.DeleteQueriesARB(n, ids);
     62
     63    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, ids, n, GLuint);
     64    pState->pDispatchTbl->DeleteQueriesARB(n, ids);
    3665}
    3766
    38 void crUnpackExtendGetPolygonStipple(void)
     67void crUnpackExtendGetPolygonStipple(PCrUnpackerState pState)
    3968{
    40     GLubyte *mask;
     69    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, CRNetworkPointer);
    4170
    42     SET_RETURN_PTR( 8 );
    43     SET_WRITEBACK_PTR( 16 );
    44     mask = DATA_POINTER(8, GLubyte);
     71    SET_RETURN_PTR(pState, 8 );
     72    SET_WRITEBACK_PTR(pState, 16 );
     73    GLubyte *mask = DATA_POINTER(pState, 8, GLubyte);
    4574
    46     cr_unpackDispatch.GetPolygonStipple( mask );
     75    /*
     76     * This method will write to the set writeback buffer and not to the mask argument, the mask argument is only used
     77     * for GL_PIXEL_PACK_BUFFER_ARB contexts where it denotes an offset (GLint) which was already enclosed in the
     78     * buffer verification.
     79     */
     80    pState->pDispatchTbl->GetPolygonStipple( mask );
    4781}
    4882
    49 void crUnpackExtendGetPixelMapfv(void)
     83void crUnpackExtendGetPixelMapfv(PCrUnpackerState pState)
    5084{
    51     GLenum map = READ_DATA( 8, GLenum );
    52     GLfloat *values;
     85    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 20, CRNetworkPointer);
    5386
    54     SET_RETURN_PTR( 12 );
    55     SET_WRITEBACK_PTR( 20 );
    56     values = DATA_POINTER(12, GLfloat);
     87    GLenum map = READ_DATA(pState, 8, GLenum );
    5788
    58     cr_unpackDispatch.GetPixelMapfv( map, values );
     89    SET_RETURN_PTR(pState, 12 );
     90    SET_WRITEBACK_PTR(pState, 20 );
     91    GLfloat *values = DATA_POINTER(pState, 12, GLfloat);
     92
     93    /* see crUnpackExtendGetPolygonStipple() for verification notes. */
     94    pState->pDispatchTbl->GetPixelMapfv( map, values );
    5995}
    6096
    61 void crUnpackExtendGetPixelMapuiv(void)
     97void crUnpackExtendGetPixelMapuiv(PCrUnpackerState pState)
    6298{
    63     GLenum map = READ_DATA( 8, GLenum );
     99    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 20, CRNetworkPointer);
     100
     101    GLenum map = READ_DATA(pState, 8, GLenum );
    64102    GLuint *values;
    65103
    66     SET_RETURN_PTR( 12 );
    67     SET_WRITEBACK_PTR( 20 );
    68     values = DATA_POINTER(12, GLuint);
     104    SET_RETURN_PTR(pState, 12 );
     105    SET_WRITEBACK_PTR(pState, 20 );
     106    values = DATA_POINTER(pState, 12, GLuint);
    69107
    70     cr_unpackDispatch.GetPixelMapuiv( map, values );
     108    /* see crUnpackExtendGetPolygonStipple() for verification notes. */
     109    pState->pDispatchTbl->GetPixelMapuiv( map, values );
    71110}
    72111
    73 void crUnpackExtendGetPixelMapusv(void)
     112void crUnpackExtendGetPixelMapusv(PCrUnpackerState pState)
    74113{
    75     GLenum map = READ_DATA( 8, GLenum );
     114    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 20, CRNetworkPointer);
     115
     116    GLenum map = READ_DATA(pState, 8, GLenum );
    76117    GLushort *values;
    77118
    78     SET_RETURN_PTR( 12 );
    79     SET_WRITEBACK_PTR( 20 );
    80     values = DATA_POINTER(12, GLushort);
     119    SET_RETURN_PTR(pState, 12 );
     120    SET_WRITEBACK_PTR(pState, 20 );
     121    values = DATA_POINTER(pState, 12, GLushort);
    81122
    82     cr_unpackDispatch.GetPixelMapusv( map, values );
     123    /* see crUnpackExtendGetPolygonStipple() for verification notes. */
     124    pState->pDispatchTbl->GetPixelMapusv( map, values );
    83125}
    84126
    85 void crUnpackExtendVBoxTexPresent(void)
     127void crUnpackExtendVBoxTexPresent(PCrUnpackerState pState)
    86128{
    87     GLuint texture = READ_DATA( 8, GLuint );
    88     GLuint cfg = READ_DATA( 12, GLuint );
    89     GLint xPos = READ_DATA( 16, GLint );
    90     GLint yPos = READ_DATA( 20, GLint );
    91     GLint cRects = READ_DATA( 24, GLint );
    92     GLint *pRects = (GLint *)DATA_POINTER( 28, GLvoid );
     129    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 24, GLint);
    93130
    94     if (cRects <= 0 || cRects >= INT32_MAX / sizeof(GLint) / 8 || !DATA_POINTER_CHECK(28 + 4 * cRects * sizeof(GLint)))
     131    GLuint texture = READ_DATA(pState, 8, GLuint );
     132    GLuint cfg = READ_DATA(pState, 12, GLuint );
     133    GLint xPos = READ_DATA(pState, 16, GLint );
     134    GLint yPos = READ_DATA(pState, 20, GLint );
     135    GLint cRects = READ_DATA(pState, 24, GLint );
     136    GLint *pRects = (GLint *)DATA_POINTER(pState, 28, GLvoid );
     137
     138    if (cRects <= 0 || cRects >= INT32_MAX / sizeof(GLint) / 8 || !DATA_POINTER_CHECK(pState, 28 + 4 * cRects * sizeof(GLint)))
    95139    {
    96140        crError("crUnpackExtendVBoxTexPresent: parameter 'cRects' is out of range");
    … …  
    98142    }
    99143
    100     cr_unpackDispatch.VBoxTexPresent( texture, cfg, xPos, yPos, cRects, pRects );
     144    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, pRects, cRects * 4, GLint); /* Each rect as 4 points. */
     145    pState->pDispatchTbl->VBoxTexPresent( texture, cfg, xPos, yPos, cRects, pRects );
    101146}

  • trunk/src/VBox/HostServices/SharedOpenGL/unpacker/unpack_shaders.cpp

    r78189 r78190  
    2323#include "cr_version.h"
    2424
    25 void crUnpackExtendBindAttribLocation(void)
    26 {
    27     GLuint program   = READ_DATA(8, GLuint);
    28     GLuint index     = READ_DATA(12, GLuint);
    29     const char *name = DATA_POINTER(16, const char);
    30 
    31     cr_unpackDispatch.BindAttribLocation(program, index, name);
    32 }
    33 
    34 void crUnpackExtendShaderSource(void)
    35 {
     25void crUnpackExtendBindAttribLocation(PCrUnpackerState pState)
     26{
     27    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 12, GLuint);
     28
     29    GLuint program   = READ_DATA(pState, 8, GLuint);
     30    GLuint index     = READ_DATA(pState, 12, GLuint);
     31    const char *name = DATA_POINTER(pState, 16, const char);
     32
     33    CHECK_STRING_FROM_PTR_UPDATE_NO_SZ(pState, name);
     34    pState->pDispatchTbl->BindAttribLocation(program, index, name);
     35}
     36
     37void crUnpackExtendShaderSource(PCrUnpackerState pState)
     38{
     39    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, GLsizei);
     40
    3641    GLint *length = NULL;
    37     GLuint shader = READ_DATA(8, GLuint);
    38     GLsizei count = READ_DATA(12, GLsizei);
    39     GLint hasNonLocalLen = READ_DATA(16, GLsizei);
    40     GLint *pLocalLength = DATA_POINTER(20, GLint);
     42    GLuint shader = READ_DATA(pState, 8, GLuint);
     43    GLsizei count = READ_DATA(pState, 12, GLsizei);
     44    GLint hasNonLocalLen = READ_DATA(pState, 16, GLsizei);
     45    GLint *pLocalLength = DATA_POINTER(pState, 20, GLint);
    4146    char **ppStrings = NULL;
    4247    GLsizei i, j, jUpTo;
    … …  
    4853        return;
    4954    }
    50 
     55    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, pLocalLength, count, GLint);
     56
     57    /** @todo More verification required here. */
    5158    pos = 20 + count * sizeof(*pLocalLength);
    5259
    53     if (!DATA_POINTER_CHECK(pos))
     60    if (!DATA_POINTER_CHECK(pState, pos))
    5461    {
    5562        crError("crUnpackExtendShaderSource: pos %d is out of range", pos);
    … …  
    5966    if (hasNonLocalLen > 0)
    6067    {
    61         length = DATA_POINTER(pos, GLint);
     68        length = DATA_POINTER(pState, pos, GLint);
    6269        pos += count * sizeof(*length);
    6370    }
    6471
    65     if (!DATA_POINTER_CHECK(pos))
     72    pos_check = pos;
     73
     74    if (!DATA_POINTER_CHECK(pState, pos_check))
    6675    {
    6776        crError("crUnpackExtendShaderSource: pos %d is out of range", pos);
    … …  
    7382    for (i = 0; i < count; ++i)
    7483    {
    75         if (pLocalLength[i] <= 0 || pos_check >= INT32_MAX - pLocalLength[i])
     84        if (pLocalLength[i] <= 0 || pos_check >= INT32_MAX - pLocalLength[i] || !DATA_POINTER_CHECK(pState, pos_check))
    7685        {
    7786            crError("crUnpackExtendShaderSource: pos %d is out of range", pos_check);
    … …  
    8190        pos_check += pLocalLength[i];
    8291
    83         if (!DATA_POINTER_CHECK(pos_check))
     92        if (!DATA_POINTER_CHECK(pState, pos_check))
    8493        {
    8594            crError("crUnpackExtendShaderSource: pos %d is out of range", pos_check);
    … …  
    8897    }
    8998
    90     ppStrings = crAlloc(count * sizeof(char*));
     99    ppStrings = (char **)crAlloc(count * sizeof(char*));
    91100    if (!ppStrings) return;
    92101
    93102    for (i = 0; i < count; ++i)
    94103    {
    95         ppStrings[i] = DATA_POINTER(pos, char);
     104        CHECK_BUFFER_SIZE_STATIC_UPDATE(pState, pos); /** @todo Free ppStrings on error. */
     105        ppStrings[i] = DATA_POINTER(pState, pos, char);
    96106        pos += pLocalLength[i];
    97107        if (!length)
    … …  
    114124    }
    115125
    116 //    cr_unpackDispatch.ShaderSource(shader, count, ppStrings, length ? length : pLocalLength);
    117     cr_unpackDispatch.ShaderSource(shader, 1, (const char**)ppStrings, 0);
     126//    pState->pDispatchTbl->ShaderSource(shader, count, ppStrings, length ? length : pLocalLength);
     127    pState->pDispatchTbl->ShaderSource(shader, 1, (const char**)ppStrings, 0);
    118128
    119129    crFree(ppStrings);
    120130}
    121131
    122 void crUnpackExtendUniform1fv(void)
    123 {
    124     GLint location = READ_DATA(8, GLint);
    125     GLsizei count = READ_DATA(12, GLsizei);
    126     const GLfloat *value = DATA_POINTER(16, const GLfloat);
    127     cr_unpackDispatch.Uniform1fv(location, count, value);
    128 }
    129 
    130 void crUnpackExtendUniform1iv(void)
    131 {
    132     GLint location = READ_DATA(8, GLint);
    133     GLsizei count = READ_DATA(12, GLsizei);
    134     const GLint *value = DATA_POINTER(16, const GLint);
    135     cr_unpackDispatch.Uniform1iv(location, count, value);
    136 }
    137 
    138 void crUnpackExtendUniform2fv(void)
    139 {
    140     GLint location = READ_DATA(8, GLint);
    141     GLsizei count = READ_DATA(12, GLsizei);
    142     const GLfloat *value = DATA_POINTER(16, const GLfloat);
    143     cr_unpackDispatch.Uniform2fv(location, count, value);
    144 }
    145 
    146 void crUnpackExtendUniform2iv(void)
    147 {
    148     GLint location = READ_DATA(8, GLint);
    149     GLsizei count = READ_DATA(12, GLsizei);
    150     const GLint *value = DATA_POINTER(16, const GLint);
    151     cr_unpackDispatch.Uniform2iv(location, count, value);
    152 }
    153 
    154 void crUnpackExtendUniform3fv(void)
    155 {
    156     GLint location = READ_DATA(8, GLint);
    157     GLsizei count = READ_DATA(12, GLsizei);
    158     const GLfloat *value = DATA_POINTER(16, const GLfloat);
    159     cr_unpackDispatch.Uniform3fv(location, count, value);
    160 }
    161 
    162 void crUnpackExtendUniform3iv(void)
    163 {
    164     GLint location = READ_DATA(8, GLint);
    165     GLsizei count = READ_DATA(12, GLsizei);
    166     const GLint *value = DATA_POINTER(16, const GLint);
    167     cr_unpackDispatch.Uniform3iv(location, count, value);
    168 }
    169 
    170 void crUnpackExtendUniform4fv(void)
    171 {
    172     GLint location = READ_DATA(8, GLint);
    173     GLsizei count = READ_DATA(12, GLsizei);
    174     const GLfloat *value = DATA_POINTER(16, const GLfloat);
    175     cr_unpackDispatch.Uniform4fv(location, count, value);
    176 }
    177 
    178 void crUnpackExtendUniform4iv(void)
    179 {
    180     GLint location = READ_DATA(8, GLint);
    181     GLsizei count = READ_DATA(12, GLsizei);
    182     const GLint *value = DATA_POINTER(16, const GLint);
    183     cr_unpackDispatch.Uniform4iv(location, count, value);
    184 }
    185 
    186 void crUnpackExtendUniformMatrix2fv(void)
    187 {
    188     GLint location = READ_DATA(8, GLint);
    189     GLsizei count = READ_DATA(12, GLsizei);
    190     GLboolean transpose = READ_DATA(16, GLboolean);
    191     const GLfloat *value = DATA_POINTER(16+sizeof(GLboolean), const GLfloat);
    192     cr_unpackDispatch.UniformMatrix2fv(location, count, transpose, value);
    193 }
    194 
    195 void crUnpackExtendUniformMatrix3fv(void)
    196 {
    197     GLint location = READ_DATA(8, GLint);
    198     GLsizei count = READ_DATA(12, GLsizei);
    199     GLboolean transpose = READ_DATA(16, GLboolean);
    200     const GLfloat *value = DATA_POINTER(16+sizeof(GLboolean), const GLfloat);
    201     cr_unpackDispatch.UniformMatrix3fv(location, count, transpose, value);
    202 }
    203 
    204 void crUnpackExtendUniformMatrix4fv(void)
    205 {
    206     GLint location = READ_DATA(8, GLint);
    207     GLsizei count = READ_DATA(12, GLsizei);
    208     GLboolean transpose = READ_DATA(16, GLboolean);
    209     const GLfloat *value = DATA_POINTER(16+sizeof(GLboolean), const GLfloat);
    210     cr_unpackDispatch.UniformMatrix4fv(location, count, transpose, value);
    211 }
    212 
    213 void crUnpackExtendUniformMatrix2x3fv(void)
    214 {
    215     GLint location = READ_DATA(8, GLint);
    216     GLsizei count = READ_DATA(12, GLsizei);
    217     GLboolean transpose = READ_DATA(16, GLboolean);
    218     const GLfloat *value = DATA_POINTER(16+sizeof(GLboolean), const GLfloat);
    219     cr_unpackDispatch.UniformMatrix2x3fv(location, count, transpose, value);
    220 }
    221 
    222 void crUnpackExtendUniformMatrix3x2fv(void)
    223 {
    224     GLint location = READ_DATA(8, GLint);
    225     GLsizei count = READ_DATA(12, GLsizei);
    226     GLboolean transpose = READ_DATA(16, GLboolean);
    227     const GLfloat *value = DATA_POINTER(16+sizeof(GLboolean), const GLfloat);
    228     cr_unpackDispatch.UniformMatrix3x2fv(location, count, transpose, value);
    229 }
    230 
    231 void crUnpackExtendUniformMatrix2x4fv(void)
    232 {
    233     GLint location = READ_DATA(8, GLint);
    234     GLsizei count = READ_DATA(12, GLsizei);
    235     GLboolean transpose = READ_DATA(16, GLboolean);
    236     const GLfloat *value = DATA_POINTER(16+sizeof(GLboolean), const GLfloat);
    237     cr_unpackDispatch.UniformMatrix2x4fv(location, count, transpose, value);
    238 }
    239 
    240 void crUnpackExtendUniformMatrix4x2fv(void)
    241 {
    242     GLint location = READ_DATA(8, GLint);
    243     GLsizei count = READ_DATA(12, GLsizei);
    244     GLboolean transpose = READ_DATA(16, GLboolean);
    245     const GLfloat *value = DATA_POINTER(16+sizeof(GLboolean), const GLfloat);
    246     cr_unpackDispatch.UniformMatrix4x2fv(location, count, transpose, value);
    247 }
    248 
    249 void crUnpackExtendUniformMatrix3x4fv(void)
    250 {
    251     GLint location = READ_DATA(8, GLint);
    252     GLsizei count = READ_DATA(12, GLsizei);
    253     GLboolean transpose = READ_DATA(16, GLboolean);
    254     const GLfloat *value = DATA_POINTER(16+sizeof(GLboolean), const GLfloat);
    255     cr_unpackDispatch.UniformMatrix3x4fv(location, count, transpose, value);
    256 }
    257 
    258 void crUnpackExtendUniformMatrix4x3fv(void)
    259 {
    260     GLint location = READ_DATA(8, GLint);
    261     GLsizei count = READ_DATA(12, GLsizei);
    262     GLboolean transpose = READ_DATA(16, GLboolean);
    263     const GLfloat *value = DATA_POINTER(16+sizeof(GLboolean), const GLfloat);
    264     cr_unpackDispatch.UniformMatrix4x3fv(location, count, transpose, value);
    265 }
    266 
    267 void crUnpackExtendDrawBuffers(void)
    268 {
    269     GLsizei n = READ_DATA(8, GLsizei);
    270     const GLenum *bufs = DATA_POINTER(8+sizeof(GLsizei), const GLenum);
    271     cr_unpackDispatch.DrawBuffers(n, bufs);
    272 }
    273 
    274 void crUnpackExtendGetActiveAttrib(void)
    275 {
    276     GLuint program = READ_DATA(8, GLuint);
    277     GLuint index = READ_DATA(12, GLuint);
    278     GLsizei bufSize = READ_DATA(16, GLsizei);
    279     SET_RETURN_PTR(20);
    280     SET_WRITEBACK_PTR(28);
    281     cr_unpackDispatch.GetActiveAttrib(program, index, bufSize, NULL, NULL, NULL, NULL);
    282 }
    283 
    284 void crUnpackExtendGetActiveUniform(void)
    285 {
    286     GLuint program = READ_DATA(8, GLuint);
    287     GLuint index = READ_DATA(12, GLuint);
    288     GLsizei bufSize = READ_DATA(16, GLsizei);
    289     SET_RETURN_PTR(20);
    290     SET_WRITEBACK_PTR(28);
    291     cr_unpackDispatch.GetActiveUniform(program, index, bufSize, NULL, NULL, NULL, NULL);
    292 }
    293 
    294 void crUnpackExtendGetAttachedShaders(void)
    295 {
    296     GLuint program = READ_DATA(8, GLuint);
    297     GLsizei maxCount = READ_DATA(12, GLsizei);
    298     SET_RETURN_PTR(16);
    299     SET_WRITEBACK_PTR(24);
    300     cr_unpackDispatch.GetAttachedShaders(program, maxCount, NULL, NULL);
    301 }
    302 
    303 void crUnpackExtendGetAttachedObjectsARB(void)
    304 {
    305         VBoxGLhandleARB containerObj = READ_DATA(8, VBoxGLhandleARB);
    306         GLsizei maxCount = READ_DATA(12, GLsizei);
    307         SET_RETURN_PTR(16);
    308         SET_WRITEBACK_PTR(24);
    309         cr_unpackDispatch.GetAttachedObjectsARB(containerObj, maxCount, NULL, NULL);
    310 }
    311 
    312 void crUnpackExtendGetInfoLogARB(void)
    313 {
    314         VBoxGLhandleARB obj = READ_DATA(8, VBoxGLhandleARB);
    315         GLsizei maxLength = READ_DATA(12, GLsizei);
    316         SET_RETURN_PTR(16);
    317         SET_WRITEBACK_PTR(24);
    318         cr_unpackDispatch.GetInfoLogARB(obj, maxLength, NULL, NULL);
    319 }
    320 
    321 void crUnpackExtendGetProgramInfoLog(void)
    322 {
    323     GLuint program = READ_DATA(8, GLuint);
    324     GLsizei bufSize = READ_DATA(12, GLsizei);
    325     SET_RETURN_PTR(16);
    326     SET_WRITEBACK_PTR(24);
    327     cr_unpackDispatch.GetProgramInfoLog(program, bufSize, NULL, NULL);
    328 }
    329 
    330 void crUnpackExtendGetShaderInfoLog(void)
    331 {
    332     GLuint shader = READ_DATA(8, GLuint);
    333     GLsizei bufSize = READ_DATA(12, GLsizei);
    334     SET_RETURN_PTR(16);
    335     SET_WRITEBACK_PTR(24);
    336     cr_unpackDispatch.GetShaderInfoLog(shader, bufSize, NULL, NULL);
    337 }
    338 
    339 void crUnpackExtendGetShaderSource(void)
    340 {
    341     GLuint shader = READ_DATA(8, GLuint);
    342     GLsizei bufSize = READ_DATA(12, GLsizei);
    343     SET_RETURN_PTR(16);
    344     SET_WRITEBACK_PTR(24);
    345     cr_unpackDispatch.GetShaderSource(shader, bufSize, NULL, NULL);
    346 }
    347 
    348 void crUnpackExtendGetAttribLocation(void)
    349 {
    350     int packet_length = READ_DATA(0, int);
    351     GLuint program = READ_DATA(8, GLuint);
    352     const char *name = DATA_POINTER(12, const char);
    353 
    354     if (!DATA_POINTER_CHECK(packet_length))
    355     {
    356         crError("crUnpackExtendGetAttribLocation: packet_length is out of range");
     132void crUnpackExtendUniform1fv(PCrUnpackerState pState)
     133{
     134    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 12, GLsizei);
     135
     136    GLint location = READ_DATA(pState, 8, GLint);
     137    GLsizei count = READ_DATA(pState, 12, GLsizei);
     138    const GLfloat *value = DATA_POINTER(pState, 16, const GLfloat);
     139
     140    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count, GLfloat);
     141    pState->pDispatchTbl->Uniform1fv(location, count, value);
     142}
     143
     144void crUnpackExtendUniform1iv(PCrUnpackerState pState)
     145{
     146    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 12, GLsizei);
     147
     148    GLint location = READ_DATA(pState, 8, GLint);
     149    GLsizei count = READ_DATA(pState, 12, GLsizei);
     150    const GLint *value = DATA_POINTER(pState, 16, const GLint);
     151
     152    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count, GLint);
     153    pState->pDispatchTbl->Uniform1iv(location, count, value);
     154}
     155
     156void crUnpackExtendUniform2fv(PCrUnpackerState pState)
     157{
     158    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 12, GLsizei);
     159
     160    GLint location = READ_DATA(pState, 8, GLint);
     161    GLsizei count = READ_DATA(pState, 12, GLsizei);
     162    const GLfloat *value = DATA_POINTER(pState, 16, const GLfloat);
     163
     164    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 2, GLfloat);
     165    pState->pDispatchTbl->Uniform2fv(location, count, value);
     166}
     167
     168void crUnpackExtendUniform2iv(PCrUnpackerState pState)
     169{
     170    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 12, GLsizei);
     171
     172    GLint location = READ_DATA(pState, 8, GLint);
     173    GLsizei count = READ_DATA(pState, 12, GLsizei);
     174    const GLint *value = DATA_POINTER(pState, 16, const GLint);
     175
     176    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 2, GLint);
     177    pState->pDispatchTbl->Uniform2iv(location, count, value);
     178}
     179
     180void crUnpackExtendUniform3fv(PCrUnpackerState pState)
     181{
     182    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 12, GLsizei);
     183
     184    GLint location = READ_DATA(pState, 8, GLint);
     185    GLsizei count = READ_DATA(pState, 12, GLsizei);
     186    const GLfloat *value = DATA_POINTER(pState, 16, const GLfloat);
     187
     188    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 3, GLfloat);
     189    pState->pDispatchTbl->Uniform3fv(location, count, value);
     190}
     191
     192void crUnpackExtendUniform3iv(PCrUnpackerState pState)
     193{
     194    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 12, GLsizei);
     195
     196    GLint location = READ_DATA(pState, 8, GLint);
     197    GLsizei count = READ_DATA(pState, 12, GLsizei);
     198    const GLint *value = DATA_POINTER(pState, 16, const GLint);
     199
     200    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 3, GLint);
     201    pState->pDispatchTbl->Uniform3iv(location, count, value);
     202}
     203
     204void crUnpackExtendUniform4fv(PCrUnpackerState pState)
     205{
     206    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 12, GLsizei);
     207
     208    GLint location = READ_DATA(pState, 8, GLint);
     209    GLsizei count = READ_DATA(pState, 12, GLsizei);
     210    const GLfloat *value = DATA_POINTER(pState, 16, const GLfloat);
     211
     212    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 4, GLfloat);
     213    pState->pDispatchTbl->Uniform4fv(location, count, value);
     214}
     215
     216void crUnpackExtendUniform4iv(PCrUnpackerState pState)
     217{
     218    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 12, GLsizei);
     219
     220    GLint location = READ_DATA(pState, 8, GLint);
     221    GLsizei count = READ_DATA(pState, 12, GLsizei);
     222    const GLint *value = DATA_POINTER(pState, 16, const GLint);
     223
     224    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 4, GLint);
     225    pState->pDispatchTbl->Uniform4iv(location, count, value);
     226}
     227
     228void crUnpackExtendUniformMatrix2fv(PCrUnpackerState pState)
     229{
     230    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, GLboolean);
     231
     232    GLint location = READ_DATA(pState, 8, GLint);
     233    GLsizei count = READ_DATA(pState, 12, GLsizei);
     234    GLboolean transpose = READ_DATA(pState, 16, GLboolean);
     235    const GLfloat *value = DATA_POINTER(pState, 16+sizeof(GLboolean), const GLfloat);
     236
     237    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 2 * 2, GLfloat);
     238    pState->pDispatchTbl->UniformMatrix2fv(location, count, transpose, value);
     239}
     240
     241void crUnpackExtendUniformMatrix3fv(PCrUnpackerState pState)
     242{
     243    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, GLboolean);
     244
     245    GLint location = READ_DATA(pState, 8, GLint);
     246    GLsizei count = READ_DATA(pState, 12, GLsizei);
     247    GLboolean transpose = READ_DATA(pState, 16, GLboolean);
     248    const GLfloat *value = DATA_POINTER(pState, 16+sizeof(GLboolean), const GLfloat);
     249
     250    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 3 * 3, GLfloat);
     251    pState->pDispatchTbl->UniformMatrix3fv(location, count, transpose, value);
     252}
     253
     254void crUnpackExtendUniformMatrix4fv(PCrUnpackerState pState)
     255{
     256    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, GLboolean);
     257
     258    GLint location = READ_DATA(pState, 8, GLint);
     259    GLsizei count = READ_DATA(pState, 12, GLsizei);
     260    GLboolean transpose = READ_DATA(pState, 16, GLboolean);
     261    const GLfloat *value = DATA_POINTER(pState, 16+sizeof(GLboolean), const GLfloat);
     262
     263    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 4 * 4, GLfloat);
     264    pState->pDispatchTbl->UniformMatrix4fv(location, count, transpose, value);
     265}
     266
     267void crUnpackExtendUniformMatrix2x3fv(PCrUnpackerState pState)
     268{
     269    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, GLboolean);
     270
     271    GLint location = READ_DATA(pState, 8, GLint);
     272    GLsizei count = READ_DATA(pState, 12, GLsizei);
     273    GLboolean transpose = READ_DATA(pState, 16, GLboolean);
     274    const GLfloat *value = DATA_POINTER(pState, 16+sizeof(GLboolean), const GLfloat);
     275
     276    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 2 * 3, GLfloat);
     277    pState->pDispatchTbl->UniformMatrix2x3fv(location, count, transpose, value);
     278}
     279
     280void crUnpackExtendUniformMatrix3x2fv(PCrUnpackerState pState)
     281{
     282    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, GLboolean);
     283
     284    GLint location = READ_DATA(pState, 8, GLint);
     285    GLsizei count = READ_DATA(pState, 12, GLsizei);
     286    GLboolean transpose = READ_DATA(pState, 16, GLboolean);
     287    const GLfloat *value = DATA_POINTER(pState, 16+sizeof(GLboolean), const GLfloat);
     288
     289    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 3 * 2, GLfloat);
     290    pState->pDispatchTbl->UniformMatrix3x2fv(location, count, transpose, value);
     291}
     292
     293void crUnpackExtendUniformMatrix2x4fv(PCrUnpackerState pState)
     294{
     295    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, GLboolean);
     296
     297    GLint location = READ_DATA(pState, 8, GLint);
     298    GLsizei count = READ_DATA(pState, 12, GLsizei);
     299    GLboolean transpose = READ_DATA(pState, 16, GLboolean);
     300    const GLfloat *value = DATA_POINTER(pState, 16+sizeof(GLboolean), const GLfloat);
     301
     302    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 2 * 4, GLfloat);
     303    pState->pDispatchTbl->UniformMatrix2x4fv(location, count, transpose, value);
     304}
     305
     306void crUnpackExtendUniformMatrix4x2fv(PCrUnpackerState pState)
     307{
     308    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, GLboolean);
     309
     310    GLint location = READ_DATA(pState, 8, GLint);
     311    GLsizei count = READ_DATA(pState, 12, GLsizei);
     312    GLboolean transpose = READ_DATA(pState, 16, GLboolean);
     313    const GLfloat *value = DATA_POINTER(pState, 16+sizeof(GLboolean), const GLfloat);
     314
     315    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 4 * 2, GLfloat);
     316    pState->pDispatchTbl->UniformMatrix4x2fv(location, count, transpose, value);
     317}
     318
     319void crUnpackExtendUniformMatrix3x4fv(PCrUnpackerState pState)
     320{
     321    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, GLboolean);
     322
     323    GLint location = READ_DATA(pState, 8, GLint);
     324    GLsizei count = READ_DATA(pState, 12, GLsizei);
     325    GLboolean transpose = READ_DATA(pState, 16, GLboolean);
     326    const GLfloat *value = DATA_POINTER(pState, 16+sizeof(GLboolean), const GLfloat);
     327
     328    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 3 * 4, GLfloat);
     329    pState->pDispatchTbl->UniformMatrix3x4fv(location, count, transpose, value);
     330}
     331
     332void crUnpackExtendUniformMatrix4x3fv(PCrUnpackerState pState)
     333{
     334    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 16, GLboolean);
     335
     336    GLint location = READ_DATA(pState, 8, GLint);
     337    GLsizei count = READ_DATA(pState, 12, GLsizei);
     338    GLboolean transpose = READ_DATA(pState, 16, GLboolean);
     339    const GLfloat *value = DATA_POINTER(pState, 16+sizeof(GLboolean), const GLfloat);
     340
     341    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, value, count * 4 * 3, GLfloat);
     342    pState->pDispatchTbl->UniformMatrix4x3fv(location, count, transpose, value);
     343}
     344
     345void crUnpackExtendDrawBuffers(PCrUnpackerState pState)
     346{
     347    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 8, GLsizei);
     348
     349    GLsizei n = READ_DATA(pState, 8, GLsizei);
     350    const GLenum *bufs = DATA_POINTER(pState, 8+sizeof(GLsizei), const GLenum);
     351
     352    CHECK_ARRAY_SIZE_FROM_PTR_UPDATE_LAST(pState, bufs, n, GLenum);
     353    pState->pDispatchTbl->DrawBuffers(n, bufs);
     354}
     355
     356void crUnpackExtendGetActiveAttrib(PCrUnpackerState pState)
     357{
     358    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 28, CRNetworkPointer);
     359
     360    GLuint program = READ_DATA(pState, 8, GLuint);
     361    GLuint index = READ_DATA(pState, 12, GLuint);
     362    GLsizei bufSize = READ_DATA(pState, 16, GLsizei);
     363    SET_RETURN_PTR(pState, 20);
     364    SET_WRITEBACK_PTR(pState, 28);
     365    pState->pDispatchTbl->GetActiveAttrib(program, index, bufSize, NULL, NULL, NULL, NULL);
     366}
     367
     368void crUnpackExtendGetActiveUniform(PCrUnpackerState pState)
     369{
     370    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 28, CRNetworkPointer);
     371
     372    GLuint program = READ_DATA(pState, 8, GLuint);
     373    GLuint index = READ_DATA(pState, 12, GLuint);
     374    GLsizei bufSize = READ_DATA(pState, 16, GLsizei);
     375    SET_RETURN_PTR(pState, 20);
     376    SET_WRITEBACK_PTR(pState, 28);
     377    pState->pDispatchTbl->GetActiveUniform(program, index, bufSize, NULL, NULL, NULL, NULL);
     378}
     379
     380void crUnpackExtendGetAttachedShaders(PCrUnpackerState pState)
     381{
     382    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 24, CRNetworkPointer);
     383
     384    GLuint program = READ_DATA(pState, 8, GLuint);
     385    GLsizei maxCount = READ_DATA(pState, 12, GLsizei);
     386    SET_RETURN_PTR(pState, 16);
     387    SET_WRITEBACK_PTR(pState, 24);
     388    pState->pDispatchTbl->GetAttachedShaders(program, maxCount, NULL, NULL);
     389}
     390
     391void crUnpackExtendGetAttachedObjectsARB(PCrUnpackerState pState)
     392{
     393    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 24, CRNetworkPointer);
     394
     395    VBoxGLhandleARB containerObj = READ_DATA(pState, 8, VBoxGLhandleARB);
     396    GLsizei maxCount = READ_DATA(pState, 12, GLsizei);
     397    SET_RETURN_PTR(pState, 16);
     398    SET_WRITEBACK_PTR(pState, 24);
     399    pState->pDispatchTbl->GetAttachedObjectsARB(containerObj, maxCount, NULL, NULL);
     400}
     401
     402void crUnpackExtendGetInfoLogARB(PCrUnpackerState pState)
     403{
     404    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 24, CRNetworkPointer);
     405
     406    VBoxGLhandleARB obj = READ_DATA(pState, 8, VBoxGLhandleARB);
     407    GLsizei maxLength = READ_DATA(pState, 12, GLsizei);
     408    SET_RETURN_PTR(pState, 16);
     409    SET_WRITEBACK_PTR(pState, 24);
     410    pState->pDispatchTbl->GetInfoLogARB(obj, maxLength, NULL, NULL);
     411}
     412
     413void crUnpackExtendGetProgramInfoLog(PCrUnpackerState pState)
     414{
     415    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 24, CRNetworkPointer);
     416
     417    GLuint program = READ_DATA(pState, 8, GLuint);
     418    GLsizei bufSize = READ_DATA(pState, 12, GLsizei);
     419    SET_RETURN_PTR(pState, 16);
     420    SET_WRITEBACK_PTR(pState, 24);
     421    pState->pDispatchTbl->GetProgramInfoLog(program, bufSize, NULL, NULL);
     422}
     423
     424void crUnpackExtendGetShaderInfoLog(PCrUnpackerState pState)
     425{
     426    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 24, CRNetworkPointer);
     427
     428    GLuint shader = READ_DATA(pState, 8, GLuint);
     429    GLsizei bufSize = READ_DATA(pState, 12, GLsizei);
     430    SET_RETURN_PTR(pState, 16);
     431    SET_WRITEBACK_PTR(pState, 24);
     432    pState->pDispatchTbl->GetShaderInfoLog(shader, bufSize, NULL, NULL);
     433}
     434
     435void crUnpackExtendGetShaderSource(PCrUnpackerState pState)
     436{
     437    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 24, CRNetworkPointer);
     438
     439    GLuint shader = READ_DATA(pState, 8, GLuint);
     440    GLsizei bufSize = READ_DATA(pState, 12, GLsizei);
     441    SET_RETURN_PTR(pState, 16);
     442    SET_WRITEBACK_PTR(pState, 24);
     443    pState->pDispatchTbl->GetShaderSource(shader, bufSize, NULL, NULL);
     444}
     445
     446void crUnpackExtendGetAttribLocation(PCrUnpackerState pState)
     447{
     448    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 8, GLuint);
     449
     450    int packet_length = READ_DATA(pState, 0, int);
     451    GLuint program = READ_DATA(pState, 8, GLuint);
     452    const char *name = DATA_POINTER(pState, 12, const char);
     453
     454    size_t cchStr = CHECK_STRING_FROM_PTR_UPDATE_NO_RETURN(pState, name);
     455    if (RT_UNLIKELY(cchStr == SIZE_MAX || packet_length != cchStr + 2 * sizeof(CRNetworkPointer)))
     456    {
     457        crError("crUnpackExtendGetAttribLocation: packet_length is corrupt");
    357458        return;
    358459    }
    359460
    360     SET_RETURN_PTR(packet_length-16);
    361     SET_WRITEBACK_PTR(packet_length-8);
    362     cr_unpackDispatch.GetAttribLocation(program, name);
    363 }
    364 
    365 void crUnpackExtendGetUniformLocation(void)
    366 {
    367     int packet_length = READ_DATA(0, int);
    368     GLuint program = READ_DATA(8, GLuint);
    369     const char *name = DATA_POINTER(12, const char);
    370 
    371     if (!DATA_POINTER_CHECK(packet_length))
    372     {
    373         crError("crUnpackExtendGetUniformLocation: packet_length is out of range");
     461    CHECK_BUFFER_SIZE_STATIC_UPDATE(pState, packet_length);
     462    SET_RETURN_PTR(pState, packet_length-16);
     463    SET_WRITEBACK_PTR(pState, packet_length-8);
     464    pState->pDispatchTbl->GetAttribLocation(program, name);
     465}
     466
     467void crUnpackExtendGetUniformLocation(PCrUnpackerState pState)
     468{
     469    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 8, GLuint);
     470
     471    int packet_length = READ_DATA(pState, 0, int);
     472    GLuint program = READ_DATA(pState, 8, GLuint);
     473    const char *name = DATA_POINTER(pState, 12, const char);
     474
     475    size_t cchStr = CHECK_STRING_FROM_PTR_UPDATE_NO_RETURN(pState, name);
     476    if (RT_UNLIKELY(cchStr == SIZE_MAX || packet_length != cchStr + 2 * sizeof(CRNetworkPointer)))
     477    {
     478        crError("crUnpackExtendGetUniformLocation: packet_length is corrupt");
    374479        return;
    375480    }
    376481
    377     SET_RETURN_PTR(packet_length-16);
    378     SET_WRITEBACK_PTR(packet_length-8);
    379     cr_unpackDispatch.GetUniformLocation(program, name);
    380 }
    381 
    382 void crUnpackExtendGetUniformsLocations(void)
    383 {
    384         GLuint program = READ_DATA(8, GLuint);
    385         GLsizei maxcbData = READ_DATA(12, GLsizei);
    386         SET_RETURN_PTR(16);
    387         SET_WRITEBACK_PTR(24);
    388         cr_unpackDispatch.GetUniformsLocations(program, maxcbData, NULL, NULL);
    389 }
    390 
    391 void crUnpackExtendGetAttribsLocations(void)
    392 {
    393     GLuint program = READ_DATA(8, GLuint);
    394     GLsizei maxcbData = READ_DATA(12, GLsizei);
    395     SET_RETURN_PTR(16);
    396     SET_WRITEBACK_PTR(24);
    397     cr_unpackDispatch.GetAttribsLocations(program, maxcbData, NULL, NULL);
    398 }
     482    CHECK_BUFFER_SIZE_STATIC_UPDATE(pState, packet_length);
     483    SET_RETURN_PTR(pState, packet_length-16);
     484    SET_WRITEBACK_PTR(pState, packet_length-8);
     485    pState->pDispatchTbl->GetUniformLocation(program, name);
     486}
     487
     488void crUnpackExtendGetUniformsLocations(PCrUnpackerState pState)
     489{
     490    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 24, CRNetworkPointer);
     491
     492    GLuint program = READ_DATA(pState, 8, GLuint);
     493    GLsizei maxcbData = READ_DATA(pState, 12, GLsizei);
     494    SET_RETURN_PTR(pState, 16);
     495    SET_WRITEBACK_PTR(pState, 24);
     496    pState->pDispatchTbl->GetUniformsLocations(program, maxcbData, NULL, NULL);
     497}
     498
     499void crUnpackExtendGetAttribsLocations(PCrUnpackerState pState)
     500{
     501    CHECK_BUFFER_SIZE_STATIC_LAST(pState, 24, CRNetworkPointer);
     502
     503    GLuint program = READ_DATA(pState, 8, GLuint);
     504    GLsizei maxcbData = READ_DATA(pState, 12, GLsizei);
     505    SET_RETURN_PTR(pState, 16);
     506    SET_WRITEBACK_PTR(pState, 24);
     507    pState->pDispatchTbl->GetAttribsLocations(program, maxcbData, NULL, NULL);
     508}
Note: See TracChangeset for help on using the changeset viewer.

© 2025 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette