path: root/src/wld/intel/intel.c

/* 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 "wld/drm-private.h"
#include "wld/drm.h"
#include "batch.h"
#include "blt.h"
#include "wld/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 ? 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);
}