diff options
Diffstat (limited to 'src/wld/intel.c')
-rw-r--r-- | src/wld/intel.c | 390 |
1 files changed, 390 insertions, 0 deletions
diff --git a/src/wld/intel.c b/src/wld/intel.c new file mode 100644 index 0000000..cdbb240 --- /dev/null +++ b/src/wld/intel.c @@ -0,0 +1,390 @@ +/* wld: intel.c + * + * Copyright (c) 2013, 2014 Michael Forney + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#include "drm-private.h" +#include "drm.h" +#include "intel/batch.h" +#include "intel/blt.h" +#include "wld-private.h" + +#include <unistd.h> +#include <intel_bufmgr.h> +#include <i915_drm.h> + +struct intel_context +{ + struct wld_context base; + drm_intel_bufmgr * bufmgr; +}; + +struct intel_renderer +{ + struct wld_renderer base; + struct intel_batch batch; + struct intel_buffer * target; +}; + +struct intel_buffer +{ + struct buffer base; + struct wld_exporter exporter; + drm_intel_bo * bo; +}; + +#include "interface/context.h" +#include "interface/renderer.h" +#include "interface/buffer.h" +#define DRM_DRIVER_NAME intel +#include "interface/drm.h" +IMPL(intel_context, wld_context) +IMPL(intel_renderer, wld_renderer) +IMPL(intel_buffer, wld_buffer) + +/**** DRM driver ****/ +bool driver_device_supported(uint32_t vendor_id, uint32_t device_id) +{ + return vendor_id == 0x8086; +} + +struct wld_context * driver_create_context(int drm_fd) +{ + struct intel_context * context; + + context = malloc(sizeof *context); + + if (!context) + goto error0; + + context_initialize(&context->base, &wld_context_impl); + context->bufmgr = drm_intel_bufmgr_gem_init(drm_fd, INTEL_BATCH_SIZE); + + if (!context->bufmgr) + goto error1; + + return &context->base; + + error1: + free(context); + error0: + return NULL; +} + +/**** Context ****/ +struct wld_renderer * context_create_renderer(struct wld_context * base) +{ + struct intel_context * context = intel_context(base); + struct intel_renderer * renderer; + + if (!(renderer = malloc(sizeof *renderer))) + goto error0; + + if (!(intel_batch_initialize(&renderer->batch, context->bufmgr))) + goto error1; + + renderer_initialize(&renderer->base, &wld_renderer_impl); + + return &renderer->base; + + error1: + free(renderer); + error0: + return NULL; +} + +static bool export(struct wld_exporter * exporter, struct wld_buffer * base, + uint32_t type, union wld_object * object) +{ + struct intel_buffer * buffer = intel_buffer(base); + + switch (type) + { + case WLD_DRM_OBJECT_HANDLE: + object->u32 = buffer->bo->handle; + return true; + case WLD_DRM_OBJECT_PRIME_FD: + if (drm_intel_bo_gem_export_to_prime(buffer->bo, &object->i) != 0) + return false; + return true; + default: + return false; + } +} + +static struct buffer * new_buffer(uint32_t width, uint32_t height, + uint32_t format, uint32_t pitch, + drm_intel_bo * bo) +{ + struct intel_buffer * buffer; + + if (!(buffer = malloc(sizeof *buffer))) + return NULL; + + buffer_initialize(&buffer->base, &wld_buffer_impl, + width, height, format, pitch); + buffer->bo = bo; + buffer->exporter.export = &export; + wld_buffer_add_exporter(&buffer->base.base, &buffer->exporter); + + return &buffer->base; +} + +struct buffer * context_create_buffer(struct wld_context * base, + uint32_t width, uint32_t height, + uint32_t format, uint32_t flags) +{ + struct intel_context * context = intel_context(base); + struct buffer * buffer; + drm_intel_bo * bo; + uint32_t tiling_mode = width >= 128 && !(flags & WLD_FLAG_CURSOR) ? I915_TILING_X : I915_TILING_NONE; + unsigned long pitch; + + bo = drm_intel_bo_alloc_tiled(context->bufmgr, "buffer", width, height, 4, + &tiling_mode, &pitch, 0); + + if (!bo) + goto error0; + + if (!(buffer = new_buffer(width, height, format, pitch, bo))) + goto error1; + + return buffer; + + error1: + drm_intel_bo_unreference(bo); + error0: + return NULL; +} + +struct buffer * context_import_buffer(struct wld_context * base, + uint32_t type, union wld_object object, + uint32_t width, uint32_t height, + uint32_t format, uint32_t pitch) +{ + struct intel_context * context = intel_context(base); + struct buffer * buffer; + drm_intel_bo * bo; + + switch (type) + { + case WLD_DRM_OBJECT_PRIME_FD: + { + uint32_t size = width * height * format_bytes_per_pixel(format); + bo = drm_intel_bo_gem_create_from_prime(context->bufmgr, + object.i, size); + break; + } + default: bo = NULL; + }; + + if (!bo) + goto error0; + + if (!(buffer = new_buffer(width, height, format, pitch, bo))) + goto error1; + + return buffer; + + error1: + drm_intel_bo_unreference(bo); + error0: + return NULL; +} + +void context_destroy(struct wld_context * base) +{ + struct intel_context * context = intel_context(base); + + drm_intel_bufmgr_destroy(context->bufmgr); + free(context); +} + +/**** Renderer ****/ +uint32_t renderer_capabilities(struct wld_renderer * renderer, + struct buffer * buffer) +{ + if (buffer->base.impl == &wld_buffer_impl) + return WLD_CAPABILITY_READ | WLD_CAPABILITY_WRITE; + + return 0; +} + +bool renderer_set_target(struct wld_renderer * base, struct buffer * buffer) +{ + struct intel_renderer * renderer = intel_renderer(base); + + if (buffer && buffer->base.impl != &wld_buffer_impl) + return false; + + renderer->target = buffer ? intel_buffer(&buffer->base) : NULL; + + return true; +} + +void renderer_fill_rectangle(struct wld_renderer * base, uint32_t color, + int32_t x, int32_t y, + uint32_t width, uint32_t height) +{ + struct intel_renderer * renderer = intel_renderer(base); + struct intel_buffer * dst = renderer->target; + + xy_color_blt(&renderer->batch, dst->bo, dst->base.base.pitch, + x, y, x + width, y + height, color); +} + +void renderer_copy_rectangle(struct wld_renderer * base, + struct buffer * buffer_base, + int32_t dst_x, int32_t dst_y, + int32_t src_x, int32_t src_y, + uint32_t width, uint32_t height) +{ + struct intel_renderer * renderer = intel_renderer(base); + + if (buffer_base->base.impl != &wld_buffer_impl) + return; + + struct intel_buffer * src = intel_buffer(&buffer_base->base), + * dst = renderer->target; + + xy_src_copy_blt(&renderer->batch, + src->bo, src->base.base.pitch, src_x, src_y, + dst->bo, dst->base.base.pitch, dst_x, dst_y, width, height); +} + +void renderer_draw_text(struct wld_renderer * base, + struct font * font, uint32_t color, + int32_t x, int32_t y, const char * text, + uint32_t length, struct wld_extents * extents) +{ + struct intel_renderer * renderer = intel_renderer(base); + struct intel_buffer * dst = renderer->target; + int ret; + struct glyph * glyph; + uint32_t row; + FT_UInt glyph_index; + uint32_t c; + uint8_t immediate[512]; + uint8_t * byte; + int32_t origin_x = x; + + xy_setup_blt(&renderer->batch, true, BLT_RASTER_OPERATION_SRC, + 0, color, dst->bo, dst->base.base.pitch); + + if (length == -1) + length = strlen(text); + + while ((ret = FcUtf8ToUcs4((FcChar8 *) text, &c, length)) > 0 && c != '\0') + { + text += ret; + length -= ret; + glyph_index = FT_Get_Char_Index(font->face, c); + + if (!font_ensure_glyph(font, glyph_index)) + continue; + + glyph = font->glyphs[glyph_index]; + + if (glyph->bitmap.width == 0 || glyph->bitmap.rows == 0) + goto advance; + + byte = immediate; + + /* XY_TEXT_IMMEDIATE requires a pitch with no extra bytes */ + for (row = 0; row < glyph->bitmap.rows; ++row) + { + memcpy(byte, glyph->bitmap.buffer + (row * glyph->bitmap.pitch), + (glyph->bitmap.width + 7) / 8); + byte += (glyph->bitmap.width + 7) / 8; + } + + retry: + ret = xy_text_immediate_blt(&renderer->batch, dst->bo, + origin_x + glyph->x, y + glyph->y, + origin_x + glyph->x + glyph->bitmap.width, + y + glyph->y + glyph->bitmap.rows, + (byte - immediate + 3) / 4, + (uint32_t *) immediate); + + if (ret == INTEL_BATCH_NO_SPACE) + { + intel_batch_flush(&renderer->batch); + xy_setup_blt(&renderer->batch, true, BLT_RASTER_OPERATION_SRC, + 0, color, dst->bo, dst->base.base.pitch); + goto retry; + } + + advance: + origin_x += glyph->advance; + } + + if (extents) + extents->advance = origin_x - x; +} + +void renderer_flush(struct wld_renderer * base) +{ + struct intel_renderer * renderer = intel_renderer(base); + + intel_batch_flush(&renderer->batch); +} + +void renderer_destroy(struct wld_renderer * base) +{ + struct intel_renderer * renderer = intel_renderer(base); + + intel_batch_finalize(&renderer->batch); + free(renderer); +} + +/**** Buffer ****/ +bool buffer_map(struct buffer * base) +{ + struct intel_buffer * buffer = intel_buffer(&base->base); + + if (drm_intel_gem_bo_map_gtt(buffer->bo) != 0) + return false; + + buffer->base.base.map = buffer->bo->virtual; + + return true; +} + +bool buffer_unmap(struct buffer * base) +{ + struct intel_buffer * buffer = intel_buffer(&base->base); + + if (drm_intel_gem_bo_unmap_gtt(buffer->bo) != 0) + return false; + + buffer->base.base.map = NULL; + + return true; +} + +void buffer_destroy(struct buffer * base) +{ + struct intel_buffer * buffer = intel_buffer(&base->base); + + drm_intel_bo_unreference(buffer->bo); + free(buffer); +} + |