intel: Use specified alignment for writes into the upload buffer

[mesa.git] / src / mesa / drivers / dri / i965 / brw_draw_upload.c

diff --git a/src/mesa/drivers/dri/i965/brw_draw_upload.c b/src/mesa/drivers/dri/i965/brw_draw_upload.c
index 62e43e83bb8ac8567c7e6bd45b34a3aae0924d92..d4841226bfa3ef3aad4ae86ae8177bc5b1f3a9d1 100644 (file)
--- a/src/mesa/drivers/dri/i965/brw_draw_upload.c
+++ b/src/mesa/drivers/dri/i965/brw_draw_upload.c
@@ -249,11 +249,11 @@ copy_array_to_vbo_array( struct brw_context *brw,
 
    buffer->stride = dst_stride;
    if (dst_stride == element->glarray->StrideB) {
-      intel_upload_data(&brw->intel, element->glarray->Ptr, size,
+      intel_upload_data(&brw->intel, element->glarray->Ptr, size, dst_stride,
                        &buffer->bo, &buffer->offset);
    } else {
       const unsigned char *src = element->glarray->Ptr;
-      char *dst = intel_upload_map(&brw->intel, size);
+      char *dst = intel_upload_map(&brw->intel, size, dst_stride);
       int i;
 
       for (i = 0; i < element->count; i++) {
@@ -261,7 +261,7 @@ copy_array_to_vbo_array( struct brw_context *brw,
         src += element->glarray->StrideB;
         dst += dst_stride;
       }
-      intel_upload_unmap(&brw->intel, dst, size,
+      intel_upload_unmap(&brw->intel, dst, size, dst_stride,
                         &buffer->bo, &buffer->offset);
    }
 }
@@ -314,24 +314,24 @@ static void brw_prepare_vertices(struct brw_context *brw)
 
    for (i = j = 0; i < brw->vb.nr_enabled; i++) {
       struct brw_vertex_element *input = brw->vb.enabled[i];
-      int type_size = get_size(input->glarray->Type);
+      const struct gl_client_array *glarray = input->glarray;
+      int type_size = get_size(glarray->Type);
 
-      input->element_size = type_size * input->glarray->Size;
+      input->element_size = type_size * glarray->Size;
 
-      if (_mesa_is_bufferobj(input->glarray->BufferObj)) {
+      if (_mesa_is_bufferobj(glarray->BufferObj)) {
         struct intel_buffer_object *intel_buffer =
-           intel_buffer_object(input->glarray->BufferObj);
+           intel_buffer_object(glarray->BufferObj);
         int k;
 
         for (k = 0; k < i; k++) {
-           struct brw_vertex_element *other = brw->vb.enabled[k];
-           if (input->glarray->BufferObj == other->glarray->BufferObj &&
-               input->glarray->StrideB == other->glarray->StrideB &&
-               (uintptr_t)(input->glarray->Ptr - other->glarray->Ptr) <
-               input->glarray->StrideB)
+           const struct gl_client_array *other = brw->vb.enabled[k]->glarray;
+           if (glarray->BufferObj == other->BufferObj &&
+               glarray->StrideB == other->StrideB &&
+               (uintptr_t)(glarray->Ptr - other->Ptr) < glarray->StrideB)
            {
-              input->buffer = other->buffer;
-              input->offset = input->glarray->Ptr - other->glarray->Ptr;
+              input->buffer = brw->vb.enabled[k]->buffer;
+              input->offset = glarray->Ptr - other->Ptr;
               break;
            }
         }
@@ -341,13 +341,13 @@ static void brw_prepare_vertices(struct brw_context *brw)
            buffer->bo = intel_bufferobj_source(intel, intel_buffer,
                                                &buffer->offset);
            drm_intel_bo_reference(buffer->bo);
-           buffer->offset += (uintptr_t)input->glarray->Ptr;
-           buffer->stride = input->glarray->StrideB;
+           buffer->offset += (uintptr_t)glarray->Ptr;
+           buffer->stride = glarray->StrideB;
 
            input->buffer = j++;
            input->offset = 0;
         }
-        input->count = input->glarray->_MaxElement;
+        input->count = glarray->_MaxElement;
 
         /* This is a common place to reach if the user mistakenly supplies
          * a pointer in place of a VBO offset.  If we just let it go through,
@@ -363,7 +363,7 @@ static void brw_prepare_vertices(struct brw_context *brw)
          */
         assert(input->offset < brw->vb.buffers[input->buffer].bo->size);
       } else {
-        input->count = input->glarray->StrideB ? max_index + 1 : 1;
+        input->count = glarray->StrideB ? max_index + 1 : 1;
 
         /* Queue the buffer object up to be uploaded in the next pass,
          * when we've decided if we're doing interleaved or not.
@@ -371,17 +371,16 @@ static void brw_prepare_vertices(struct brw_context *brw)
         if (nr_uploads == 0) {
            /* Position array not properly enabled:
             */
-           if (input->attrib == VERT_ATTRIB_POS &&
-               input->glarray->StrideB == 0) {
+           if (input->attrib == VERT_ATTRIB_POS && glarray->StrideB == 0) {
                intel->Fallback = GL_TRUE; /* boolean, not bitfield */
                return;
             }
 
-           interleaved = input->glarray->StrideB;
-           ptr = input->glarray->Ptr;
+           interleaved = glarray->StrideB;
+           ptr = glarray->Ptr;
         }
-        else if (interleaved != input->glarray->StrideB ||
-                 (uintptr_t)(input->glarray->Ptr - ptr) > interleaved)
+        else if (interleaved != glarray->StrideB ||
+                 (uintptr_t)(glarray->Ptr - ptr) > interleaved)
         {
            interleaved = 0;
         }
@@ -422,7 +421,7 @@ static void brw_prepare_vertices(struct brw_context *brw)
         int count = upload[0]->count, offset;
         char *map;
 
-        map = intel_upload_map(&brw->intel, total_size * count);
+        map = intel_upload_map(&brw->intel, total_size * count, total_size);
         for (i = offset = 0; i < nr_uploads; i++) {
            const unsigned char *src = upload[i]->glarray->Ptr;
            int size = upload[i]->element_size;
@@ -441,7 +440,7 @@ static void brw_prepare_vertices(struct brw_context *brw)
 
            offset += size;
         }
-        intel_upload_unmap(&brw->intel, map, total_size * count,
+        intel_upload_unmap(&brw->intel, map, total_size * count, total_size,
                            &buffer->bo, &buffer->offset);
         buffer->stride = offset;
         j++;
@@ -609,7 +608,8 @@ static void brw_prepare_indices(struct brw_context *brw)
 
       /* Get new bufferobj, offset:
        */
-      intel_upload_data(&brw->intel, index_buffer->ptr, ib_size, &bo, &offset);
+      intel_upload_data(&brw->intel, index_buffer->ptr, ib_size, ib_type_size,
+                       &bo, &offset);
       brw->ib.start_vertex_offset = offset / ib_type_size;
       offset = 0;
    } else {
@@ -625,7 +625,8 @@ static void brw_prepare_indices(struct brw_context *brw)
                                                 bufferobj);
            map += offset;
 
-          intel_upload_data(&brw->intel, map, ib_size, &bo, &offset);
+          intel_upload_data(&brw->intel, map, ib_size, ib_type_size,
+                            &bo, &offset);
           brw->ib.start_vertex_offset = offset / ib_type_size;
           offset = 0;