return err;
}
-static cl_int _cl_map_mem(cl_mem mem, void *ptr, void **mem_ptr, size_t offset, size_t size)
+static cl_int _cl_map_mem(cl_mem mem, void *ptr, void **mem_ptr,
+ size_t offset, size_t size,
+ const size_t *origin, const size_t *region)
{
cl_int slot = -1;
int err = CL_SUCCESS;
mem->mapped_ptr[slot].ptr = *mem_ptr;
mem->mapped_ptr[slot].v_ptr = ptr;
mem->mapped_ptr[slot].size = size;
+ if(origin) {
+ assert(region);
+ mem->mapped_ptr[slot].origin[0] = origin[0];
+ mem->mapped_ptr[slot].origin[1] = origin[1];
+ mem->mapped_ptr[slot].origin[2] = origin[2];
+ mem->mapped_ptr[slot].region[0] = region[0];
+ mem->mapped_ptr[slot].region[1] = region[1];
+ mem->mapped_ptr[slot].region[2] = region[2];
+ }
mem->map_ref++;
error:
if (err != CL_SUCCESS)
goto error;
}
}
- err = _cl_map_mem(buffer, ptr, &mem_ptr, offset, size);
+ err = _cl_map_mem(buffer, ptr, &mem_ptr, offset, size, NULL, NULL);
if (err != CL_SUCCESS)
goto error;
goto error;
}
- if (image_slice_pitch)
- *image_slice_pitch = image->slice_pitch;
- if (image->image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY)
- *image_row_pitch = image->slice_pitch;
- else
- *image_row_pitch = image->row_pitch;
-
if ((map_flags & CL_MAP_READ &&
mem->flags & (CL_MEM_HOST_WRITE_ONLY | CL_MEM_HOST_NO_ACCESS)) ||
(map_flags & (CL_MAP_WRITE | CL_MAP_WRITE_INVALIDATE_REGION) &&
}
size_t offset = image->bpp*origin[0] + image->row_pitch*origin[1] + image->slice_pitch*origin[2];
- size_t size;
- if(region[2] == 1) {
- if(region[1] == 1)
- size = image->bpp * region[0];
- else
- size = image->row_pitch * (region[1] - 1) + (image->bpp * (origin[0] + region[0]));
- } else {
- size = image->slice_pitch * (region[2] - 1);
- size += image->row_pitch * (origin[1] + region[1]);
- size += image->bpp * (origin[0] + region[0]);
- }
TRY(cl_event_check_waitlist, num_events_in_wait_list, event_wait_list, event, mem->ctx);
data->mem_obj = mem;
data->origin[0] = origin[0]; data->origin[1] = origin[1]; data->origin[2] = origin[2];
data->region[0] = region[0]; data->region[1] = region[1]; data->region[2] = region[2];
- data->row_pitch = *image_row_pitch;
- if (image_slice_pitch)
- data->slice_pitch = *image_slice_pitch;
data->ptr = ptr;
data->offset = offset;
data->unsync_map = 1;
goto error;
}
}
- err = _cl_map_mem(mem, ptr, &mem_ptr, offset, size);
+ err = _cl_map_mem(mem, ptr, &mem_ptr, offset, 0, origin, region);
if (err != CL_SUCCESS)
goto error;
+ if(mem->flags & CL_MEM_USE_HOST_PTR) {
+ if (image_slice_pitch)
+ *image_slice_pitch = image->host_slice_pitch;
+ *image_row_pitch = image->host_row_pitch;
+ } else {
+ if (image_slice_pitch)
+ *image_slice_pitch = image->slice_pitch;
+ if (image->image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY)
+ *image_row_pitch = image->slice_pitch;
+ else
+ *image_row_pitch = image->row_pitch;
+ }
+
error:
if (errcode_ret)
*errcode_ret = err;
cl_int err = CL_SUCCESS;
cl_mem mem = data->mem_obj;
void *ptr = NULL;
+ size_t row_pitch = 0;
CHECK_IMAGE(mem, image);
if(data->unsync_map == 1)
goto error;
}
data->ptr = ptr;
+ if (image->image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY)
+ row_pitch = image->slice_pitch;
+ else
+ row_pitch = image->row_pitch;
if(mem->flags & CL_MEM_USE_HOST_PTR) {
assert(mem->host_ptr);
cl_mem_copy_image_region(data->origin, data->region,
mem->host_ptr, image->host_row_pitch, image->host_slice_pitch,
- data->ptr, data->row_pitch, data->slice_pitch, image);
+ data->ptr, row_pitch, image->slice_pitch, image);
}
error:
cl_int cl_enqueue_unmap_mem_object(enqueue_data *data)
{
cl_int err = CL_SUCCESS;
- int i;
+ int i, j;
size_t mapped_size = 0;
+ size_t origin[3], region[3];
void * v_ptr = NULL;
void * mapped_ptr = data->ptr;
cl_mem memobj = data->mem_obj;
+ size_t row_pitch = 0;
assert(memobj->mapped_ptr_sz >= memobj->map_ref);
INVALID_VALUE_IF(!mapped_ptr);
memobj->mapped_ptr[i].ptr = NULL;
mapped_size = memobj->mapped_ptr[i].size;
v_ptr = memobj->mapped_ptr[i].v_ptr;
+ for(j=0; j<3; j++) {
+ region[j] = memobj->mapped_ptr[i].region[j];
+ origin[j] = memobj->mapped_ptr[i].origin[j];
+ memobj->mapped_ptr[i].region[j] = 0;
+ memobj->mapped_ptr[i].origin[j] = 0;
+ }
memobj->mapped_ptr[i].size = 0;
memobj->mapped_ptr[i].v_ptr = NULL;
memobj->map_ref--;
INVALID_VALUE_IF(i == memobj->mapped_ptr_sz);
if (memobj->flags & CL_MEM_USE_HOST_PTR) {
- assert(mapped_ptr >= memobj->host_ptr &&
- mapped_ptr + mapped_size <= memobj->host_ptr + memobj->size);
- /* Sync the data. */
- memcpy(v_ptr, mapped_ptr, mapped_size);
+ if(memobj->type == CL_MEM_BUFFER_TYPE ||
+ memobj->type == CL_MEM_SUBBUFFER_TYPE) {
+ assert(mapped_ptr >= memobj->host_ptr &&
+ mapped_ptr + mapped_size <= memobj->host_ptr + memobj->size);
+ /* Sync the data. */
+ memcpy(v_ptr, mapped_ptr, mapped_size);
+ } else {
+ CHECK_IMAGE(memobj, image);
+ if (image->image_type == CL_MEM_OBJECT_IMAGE1D_ARRAY)
+ row_pitch = image->slice_pitch;
+ else
+ row_pitch = image->row_pitch;
+ cl_mem_copy_image_region(origin, region, v_ptr, row_pitch, image->slice_pitch,
+ memobj->host_ptr, image->host_row_pitch, image->host_slice_pitch,
+ image);
+ }
} else {
assert(v_ptr == mapped_ptr);
}