drm.cpp File Reference

#include "config.h"
#include "config_unix.h"
#include "config_win32.h"
#include <assert.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
#include <drm_fourcc.h>
#include <memory>
#include <vector>
#include <algorithm>
#include "debug.h"
#include "host.h"
#include "lib_common.h"
#include "pixfmt_conv.h"
#include "utils/color_out.h"
#include "utils/macros.h"
#include "utils/misc.h"
#include "utils/text.h"
#include "utils/string_view_utils.hpp"
#include "video.h"
#include "video_codec.h"
#include "video_display.h"
#include "hwaccel_drm.h"

Include dependency graph for drm.cpp:

Go to the source code of this file.

Classes
struct	drm_display_state
struct	Drm_prime_fb
struct	Drm_state
class	Framebuffer

Macros
#define	MOD_NAME   "[drm] "

Functions
static Framebuffer	create_dumb_fb (int dri, int width, int height, uint32_t pix_fmt)
static void	display_drm_done (void *state)
static bool	display_drm_get_property (void *state, int property, void *val, size_t *len)
static struct video_frame *	display_drm_getf (void *state)
static void *	display_drm_init (struct module *parent, const char *cfg, unsigned int flags)
static void	display_drm_probe (struct device_info **available_cards, int *count, void(**deleter)(void *))
static bool	display_drm_putf (void *state, struct video_frame *f, long long flags)
static bool	display_drm_reconfigure (void *state, struct video_desc desc)
static void	draw_frame (Framebuffer *dst, video_frame *src, bool center=true)
static void	draw_splash (drm_display_state *s)
static Drm_prime_fb	drm_fb_from_frame (drm_display_state *s, frame_uniq frame)
static bool	drm_format_supported (drm_display_state *s, uint32_t fmt)
static bool	get_codecs (drm_display_state *s, void *val, size_t *len)
static const char *	get_connector_status_str (drmModeConnection c)
static std::string	get_connector_str (int type, uint32_t id)
static std::vector< Drm_connector_uniq >	get_connectors (drm_display_state *s)
static int64_t	get_property (int dri, drmModeObjectPropertiesPtr props, std::string_view name)
static Framebuffer	get_splash_fb (drm_display_state *s, int width, int height)
static bool	init_drm_state (drm_display_state *s)
static Fd_uniq	open_dri (drm_display_state *s)
static void	print_connectors (drm_display_state *s)
static void	print_drm_driver_info (drm_display_state *s)
static bool	probe_drm_formats (drm_display_state *s)
static void	recycle_frame (drm_display_state *s, frame_uniq &frame)
static void	recycle_prime_frame (drm_display_state *s, Drm_prime_fb &fb)
	REGISTER_MODULE (drm, &display_drm_info, LIBRARY_CLASS_VIDEO_DISPLAY, VIDEO_DISPLAY_ABI_VERSION)
static bool	set_framebuffer (drm_display_state *s, uint32_t fb_id)
static bool	setup_crtc (drm_display_state *s)
static bool	swap_buffers (drm_display_state *s)

Variables
static const struct video_display_info	display_drm_info

Detailed Description

Author

Martin Piatka piatk.nosp@m.a@ce.nosp@m.snet..nosp@m.cz

Definition in file drm.cpp.

Macro Definition Documentation

MOD_NAME

#define MOD_NAME   "[drm] "

Definition at line 75 of file drm.cpp.

Referenced by create_dumb_fb(), display_drm_done(), display_drm_reconfigure(), draw_splash(), drm_fb_from_frame(), init_drm_state(), open_dri(), print_drm_driver_info(), probe_drm_formats(), set_framebuffer(), and setup_crtc().

Function Documentation

create_dumb_fb()

static Framebuffer create_dumb_fb ( int dri, int width, int height, uint32_t pix_fmt )

static

Definition at line 703 of file drm.cpp.

                                                                                   {
        Framebuffer buf;
 
        //TODO: Currently pix_fmt is assumed to be single plane and 32 bpp
 
        int res = 0;
 
        {
                Fb_handle handle;
                drm_mode_create_dumb create_info = {};
                create_info.width = width;
                create_info.height = height;
                create_info.bpp = 32;
                res = drmIoctl(dri, DRM_IOCTL_MODE_CREATE_DUMB, &create_info);
                if(res != 0){
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to create a dumb framebuffer (%d)\n", res);
                        return {};
                }
                handle.handle = create_info.handle;
                buf.width = width;
                buf.height = height;
                buf.pitch = create_info.pitch;
                buf.size = create_info.size;
                handle.dri_fd = dri;
                buf.handle = Fb_handle_uniq(handle);
        }
        
        {
                uint32_t handles[] = {buf.handle.get().handle, 0, 0, 0};
                uint32_t pitches[] = {buf.pitch, 0, 0, 0};
                uint32_t offsets[] = {0, 0, 0, 0};
                Fb_id fb_id;
                res = drmModeAddFB2(dri, width, height,
                                pix_fmt, handles, pitches, offsets, &fb_id.id, 0);
 
                if(res != 0){
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to add framebuffer (%d)\n", res);
                        return {};
                }
 
                fb_id.dri_fd = dri;
                buf.id = Fb_id_uniq(fb_id);
        }
 
        log_msg(LOG_LEVEL_INFO, MOD_NAME "Created dumb buffer: pitch %u, handle: %u\n", buf.pitch, buf.handle.get().handle);
 
 
        struct drm_mode_map_dumb map_info = {};
        map_info.handle = buf.handle.get().handle;
 
        res = drmIoctl(dri, DRM_IOCTL_MODE_MAP_DUMB, &map_info);
        if(res != 0){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to get map info (%d)\n", res);
                return {};
        }
 
        buf.map = MemoryMapping::create(0, buf.size, PROT_READ | PROT_WRITE, MAP_SHARED, dri, map_info.offset);
        if(!buf.map.valid()){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to map buffer\n");
                return {};
        }
 
        return buf;
}

References Framebuffer::handle, Framebuffer::height, Framebuffer::id, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, log_msg(), Framebuffer::map, MOD_NAME, Framebuffer::pitch, Framebuffer::size, and Framebuffer::width.

Referenced by display_drm_reconfigure(), and get_splash_fb().

Here is the call graph for this function:

display_drm_done()

static void display_drm_done ( void * state )

static

Definition at line 905 of file drm.cpp.

{
        auto s = std::unique_ptr<drm_display_state>(static_cast<drm_display_state *>(state));
 
        int res = 0;
        res = drmModeSetCrtc(s->drm.dri_fd.get(), s->drm.crtc->crtc_id, s->drm.crtc->buffer_id,
                       s->drm.crtc->x , s->drm.crtc->y, &s->drm.connector->connector_id, 1, &s->drm.crtc->mode);
        if(res < 0){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to restore original crtc (%d)\n", res);
        }
}

References LOG_LEVEL_ERROR, log_msg(), MOD_NAME, and state.

Here is the call graph for this function:

display_drm_get_property()

static bool display_drm_get_property ( void * state, int property, void * val, size_t * len )

static

Definition at line 1037 of file drm.cpp.

{
        auto s = static_cast<drm_display_state *>(state);
 
        int rgb_shift[] = {0, 8, 16};
        if(!drm_format_supported(s, DRM_FORMAT_XBGR8888)){
                std::swap(rgb_shift[0], rgb_shift[2]);
        }
 
        switch (property) {
                case DISPLAY_PROPERTY_CODECS:
                        return get_codecs(s, val, len);
                case DISPLAY_PROPERTY_RGB_SHIFT:
                        if(sizeof(rgb_shift) > *len) {
                                return false;
                        }
                        memcpy(val, rgb_shift, sizeof(rgb_shift));
                        *len = sizeof(rgb_shift);
                        break;
                default:
                        return false;
        }
        return true;
}

References DISPLAY_PROPERTY_CODECS, DISPLAY_PROPERTY_RGB_SHIFT, drm_format_supported(), get_codecs(), len, property, state, and val.

Here is the call graph for this function:

display_drm_getf()

static struct video_frame * display_drm_getf ( void * state )

static

Definition at line 917 of file drm.cpp.

{
        auto s = static_cast<drm_display_state *>(state);
 
        while(!s->free_frames.empty()){
                auto frame = std::move(s->free_frames.back());
                s->free_frames.pop_back();
 
                if(video_desc_eq(video_desc_from_frame(frame.get()), s->desc)){
                        return frame.release();
                }
        }
 
        return vf_alloc_desc_data(s->desc);
}

References frame, state, vf_alloc_desc_data(), video_desc_eq(), and video_desc_from_frame().

Here is the call graph for this function:

display_drm_init()

static void * display_drm_init ( struct module * parent, const char * cfg, unsigned int flags )

static

Definition at line 842 of file drm.cpp.

{
        UNUSED(parent), UNUSED(flags);
 
        auto s = std::make_unique<drm_display_state>();
 
        if(cfg)
                s->cfg = cfg;
 
        bool help_requested = false;
        std::string_view sv_cfg(s->cfg);
        while(!sv_cfg.empty()){
                auto token = tokenize(sv_cfg, ':');
                auto key = tokenize(token, '=');
                auto val = tokenize(token, '=');
 
                if(key == "help"){
                        help_requested = true;
                } else if(key == "dev"){
                        s->device_path = val;
                } else if(key == "connector"){
                        s->req_connector = val;
                } else if(key == "mode"){
                        auto res = tokenize(val, '@');
                        auto rate = tokenize(val, '@');
 
                        auto width = tokenize(res, 'x');
                        auto height = tokenize(res, 'x');
 
                        parse_num(width, s->req_width);
                        parse_num(height, s->req_height);
                        parse_num(rate, s->req_rate);
                }
        }
 
        if(!init_drm_state(s.get())){
                return nullptr;
        }
 
        if(help_requested){
                color_printf("\n");
                color_printf("DRM display\n");
                color_printf(TBOLD(TRED("\t-t drm"))"[:dev=<path>][:connector=<c>][:mode=<w>x<h>[@<rate>]]\n");
                color_printf("where:\n");
                color_printf(TBOLD("\tpath") "        - Path to the DRI device. If not specified /dev/video[0..32] are tried.\n");
                color_printf(TBOLD("\tconnector") "   - The physical connector the display device is plugged into.\n");
                color_printf(TBOLD("\tmode") "        - Video mode to use. If not specified, the preferred mode is used. \n");
                color_printf("\n");
                print_connectors(s.get());
                return INIT_NOERR;
        }
 
        if(!setup_crtc(s.get())){
                return nullptr;
        }
 
        s->splashscreen = get_splash_fb(s.get(), s->drm.mode_info->hdisplay, s->drm.mode_info->vdisplay);
 
        draw_splash(s.get());
 
        return s.release();
}

References color_printf(), draw_splash(), flags, get_splash_fb(), init_drm_state(), INIT_NOERR, key, parent, parse_num(), print_connectors(), setup_crtc(), TBOLD, tokenize(), TRED, UNUSED, and val.

Here is the call graph for this function:

display_drm_probe()

static void display_drm_probe ( struct device_info ** available_cards, int * count, void(** deleter )(void *) )

static

Definition at line 1119 of file drm.cpp.

                                                                                                          {
        UNUSED(deleter);
        *available_cards = NULL;
        *count = 0;
}

References count, deleter, and UNUSED.

display_drm_putf()

static bool display_drm_putf ( void * state, struct video_frame * f, long long flags )

static

Definition at line 981 of file drm.cpp.

{
        frame_uniq frame(f);
 
        if (!frame) {
                return true;
        }
 
        auto s = static_cast<drm_display_state *>(state);
 
        if(flags == PUTF_DISCARD){
                recycle_frame(s, frame);
                return true;
        }
 
        if(frame->color_spec == DRM_PRIME){
                Drm_prime_fb fb = drm_fb_from_frame(s, std::move(frame));
                if(!set_framebuffer(s, fb.id.get().id)){
                        return false;
                }
 
                recycle_prime_frame(s, s->drm_prime_fb);
                s->drm_prime_fb = std::move(fb);
                return true;
        }
 
        draw_frame(&s->back_buffer, frame.get());
        recycle_frame(s, frame);
        swap_buffers(s);
 
        return true;
}

References video_frame::color_spec, draw_frame(), drm_fb_from_frame(), DRM_PRIME, flags, frame, Drm_prime_fb::id, PUTF_DISCARD, recycle_frame(), recycle_prime_frame(), set_framebuffer(), state, and swap_buffers().

Here is the call graph for this function:

display_drm_reconfigure()

static bool display_drm_reconfigure ( void * state, struct video_desc desc )

static

Definition at line 1062 of file drm.cpp.

{
        auto s = static_cast<drm_display_state *>(state);
 
        s->desc = desc;
 
        s->frame.reset(vf_alloc_desc_data(desc));
 
        uint32_t pix_fmt;
 
        switch(desc.color_spec){
        case RGBA:
                pix_fmt = drm_format_supported(s, DRM_FORMAT_XBGR8888) ? DRM_FORMAT_XBGR8888 : DRM_FORMAT_XRGB8888;
                break;
        case UYVY:
                pix_fmt = DRM_FORMAT_UYVY;
                break;
        case DRM_PRIME:
                /* We don't create dumb buffers in this case, we import framebuffers from video frames instead
                 */
                pix_fmt = 0; //UNUSED
                if(!s->drm.mode_info || s->drm.mode_info->hdisplay > desc.width || s->drm.mode_info->vdisplay > desc.height){
                        log_msg(LOG_LEVEL_WARNING, MOD_NAME "Video mode resolution must be less or equal to DRM_PRIME frames. Trying to find a suitable mode...\n");
                        s->drm.mode_info = nullptr;
                        for(int i = 0; i < s->drm.connector->count_modes; i++){
                                auto mode = &s->drm.connector->modes[i];
 
                                if(mode->hdisplay > desc.width)
                                        continue;
 
                                if(mode->vdisplay > desc.height)
                                        continue;
 
                                s->drm.mode_info = mode;
                                break;
                        }
                        if(!s->drm.mode_info){
                                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to find suitable mode\n");
                                return false;
                        }
                }
                return true;
        default:
                return false;
        }
 
        if(desc.width > s->drm.mode_info->hdisplay || desc.height > s->drm.mode_info->vdisplay){
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Video resolution is larger than framebuffer. Only part of video frames will be visible\n");
        }
 
        s->front_buffer = create_dumb_fb(s->drm.dri_fd.get(), s->drm.mode_info->hdisplay, s->drm.mode_info->vdisplay, pix_fmt);
        s->back_buffer = create_dumb_fb(s->drm.dri_fd.get(), s->drm.mode_info->hdisplay, s->drm.mode_info->vdisplay, pix_fmt);
 
 
        return true;
}

References video_desc::color_spec, create_dumb_fb(), desc, drm_display_state::desc, drm_format_supported(), DRM_PRIME, video_desc::height, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, mode, RGBA, state, UYVY, vf_alloc_desc_data(), and video_desc::width.

Here is the call graph for this function:

draw_frame()

static void draw_frame ( Framebuffer * dst, video_frame * src, bool center = true )

static

Definition at line 788 of file drm.cpp.

                                                                              {
        auto dst_p = static_cast<char *>(dst->map.get());
        auto src_p = static_cast<char *>(src->tiles[0].data);
 
        auto src_w = src->tiles[0].width;
        auto src_h = src->tiles[0].height;
 
        unsigned x = 0;
        unsigned y = 0;
 
        if(center){
                if(src_w < dst->width)
                        x = (dst->width - src_w) / 2;
                if(src_h < dst->height)
                        y = (dst->height - src_h) / 2;
        }
 
        int width = std::min(src_w, dst->width - x);
        int height = std::min(src_h, dst->height - y);
 
        auto src_pitch = vc_get_linesize(src_w, src->color_spec);
        auto linesize = vc_get_size(width, src->color_spec);
 
        dst_p += dst->pitch * y;
        dst_p += vc_get_size(x, src->color_spec);
 
        for(int y = 0; y < height; y++){
                memcpy(dst_p, src_p, linesize);
                dst_p += dst->pitch;
                src_p += src_pitch;
        }
}

References video_frame::color_spec, tile::data, Framebuffer::height, tile::height, Framebuffer::map, Framebuffer::pitch, video_frame::tiles, vc_get_linesize(), vc_get_size(), Framebuffer::width, and tile::width.

Referenced by display_drm_putf(), and get_splash_fb().

Here is the call graph for this function:

draw_splash()

static void draw_splash ( drm_display_state * s )

static

Definition at line 779 of file drm.cpp.

                                             {
        int res = 0;
        res = drmModeSetCrtc(s->drm.dri_fd.get(), s->drm.crtc->crtc_id,
                        s->splashscreen.id.get().id, 0, 0, &s->drm.connector->connector_id, 1, s->drm.mode_info);
        if(res < 0){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to set crtc (%d)\n", res);
        }
}

References Drm_state::connector, Drm_state::crtc, Drm_state::dri_fd, drm_display_state::drm, Framebuffer::id, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, Drm_state::mode_info, and drm_display_state::splashscreen.

Referenced by display_drm_init().

Here is the call graph for this function:

drm_fb_from_frame()

static Drm_prime_fb drm_fb_from_frame ( drm_display_state * s, frame_uniq frame )

static

Definition at line 938 of file drm.cpp.

                                                                             {
        assert(frame->color_spec == DRM_PRIME);
 
        Drm_prime_fb fb;
        fb.frame = std::move(frame);
        auto drm_frame = (drm_prime_frame *) fb.frame->tiles[0].data;
 
        for(int i = 0; i < drm_frame->fd_count; i++){
                fb.gem_objects[i] = s->drm.gem_manager->get_handle(drm_frame->dmabuf_fds[i]);
        }
 
        uint32_t handles[4] = {};
        for(int i = 0; i < drm_frame->planes; i++){
                handles[i] = fb.gem_objects[drm_frame->fd_indices[i]].get();
        }
 
        int res = 0;
        Fb_id fb_id;
        res = drmModeAddFB2WithModifiers(s->drm.dri_fd.get(), fb.frame->tiles[0].width, fb.frame->tiles[0].height, drm_frame->drm_format,
                        handles, drm_frame->pitches, drm_frame->offsets, drm_frame->modifiers, &fb_id.id, DRM_MODE_FB_MODIFIERS);
        if(res != 0){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to add FB\n");
        }
        fb_id.dri_fd = s->drm.dri_fd.get();
        fb.id = Fb_id_uniq(fb_id);
 
        return fb;
}

References video_frame::color_spec, Drm_state::dri_fd, drm_display_state::drm, DRM_PRIME, Drm_prime_fb::frame, frame, Drm_state::gem_manager, Drm_prime_fb::gem_objects, Drm_prime_fb::id, LOG_LEVEL_ERROR, log_msg(), and MOD_NAME.

Referenced by display_drm_putf().

Here is the call graph for this function:

drm_format_supported()

static bool drm_format_supported ( drm_display_state * s, uint32_t fmt )

static

Definition at line 821 of file drm.cpp.

                                                                    {
        return s->drm.supported_drm_formats.find(fmt) != s->drm.supported_drm_formats.end();
}

References drm_display_state::drm, fmt, and Drm_state::supported_drm_formats.

Referenced by display_drm_get_property(), display_drm_reconfigure(), and get_splash_fb().

get_codecs()

static bool get_codecs ( drm_display_state * s, void * val, size_t * len )

static

Definition at line 1014 of file drm.cpp.

                                                                    {
        std::vector<codec_t> out;
 
        if(s->drm.prime_support)
                out.push_back(DRM_PRIME);
 
        if(s->drm.supported_drm_formats.find(DRM_FORMAT_UYVY) != s->drm.supported_drm_formats.end())
                out.push_back(UYVY);
 
        out.push_back(RGBA);
 
        size_t length = sizeof(codec_t) * out.size();
 
        if(*len < length) {
                return false;
        }
        *len = length;
        memcpy(val, out.data(), *len);
 
        return true;
 
}

References drm_display_state::drm, DRM_PRIME, len, Drm_state::prime_support, RGBA, Drm_state::supported_drm_formats, UYVY, and val.

Referenced by display_drm_get_property().

get_connector_status_str()

static const char * get_connector_status_str ( drmModeConnection c )

static

Definition at line 563 of file drm.cpp.

                                                                {
        switch(c){
        case DRM_MODE_CONNECTED:
                return " (Connected)";
        case DRM_MODE_DISCONNECTED:
                return " (Not connected)";
        case DRM_MODE_UNKNOWNCONNECTION:
        default:
                return "";
        }
}

Referenced by print_connectors().

get_connector_str()

static std::string get_connector_str ( int type, uint32_t id )

static

Definition at line 375 of file drm.cpp.

                                                         {
        std::string res;
        switch(type){
        case DRM_MODE_CONNECTOR_VGA: res = "VGA"; break;
        case DRM_MODE_CONNECTOR_HDMIA: res = "HDMI-A"; break;
        case DRM_MODE_CONNECTOR_HDMIB: res = "HDMI-B"; break;
        case DRM_MODE_CONNECTOR_DisplayPort: res = "DP"; break;
        case DRM_MODE_CONNECTOR_eDP: res = "eDP"; break;
        case DRM_MODE_CONNECTOR_DVII: res = "DVI-I"; break;
        case DRM_MODE_CONNECTOR_DVID: res = "DVI-D"; break;
        case DRM_MODE_CONNECTOR_DVIA: res = "DVI-A"; break;
#ifdef DRM_MODE_CONNECTOR_USB
        case DRM_MODE_CONNECTOR_USB: res = "USB"; break;
#endif
        default:
                res = std::to_string(type);
        }
 
        res += "-";
        res += std::to_string(id);
 
        return res;
}

References type.

Referenced by print_connectors(), and setup_crtc().

get_connectors()

static std::vector< Drm_connector_uniq > get_connectors ( drm_display_state * s )

static

Definition at line 514 of file drm.cpp.

                                                                         {
        std::vector<Drm_connector_uniq> res;
 
        for(int i = 0; i < s->drm.res->count_connectors; i++){
                Drm_connector_uniq conn(drmModeGetConnector(s->drm.dri_fd.get(), s->drm.res->connectors[i]));
                if(!conn)
                        continue;
 
                res.push_back(std::move(conn));
        }
 
        return res;
}

References Drm_state::dri_fd, drm_display_state::drm, and Drm_state::res.

Referenced by print_connectors(), and setup_crtc().

get_property()

static int64_t get_property ( int dri, drmModeObjectPropertiesPtr props, std::string_view name )

static

Definition at line 465 of file drm.cpp.

                                                                                           {
        for(unsigned i = 0; i < props->count_props; i++){
                Drm_property_uniq prop(drmModeGetProperty(dri, props->props[i]));
                if(!prop)
                        continue;
 
                if(prop->name == name)
                        return props->prop_values[i];
        }
        return -1;
}

References name.

Referenced by probe_drm_formats(), and sdi_register_display_callbacks().

get_splash_fb()

static Framebuffer get_splash_fb ( drm_display_state * s, int width, int height )

static

Definition at line 825 of file drm.cpp.

                                                                             {
        frame_uniq splash_frame(get_splashscreen());
 
        uint32_t pix_fmt;
        if(drm_format_supported(s, DRM_FORMAT_XBGR8888)){
                pix_fmt = DRM_FORMAT_XBGR8888;
        } else {
                //XRGB_8888 should be always present
                //red and blue will be swapped, but for splash it doesn't matter much
                pix_fmt = DRM_FORMAT_XRGB8888;
        }
        auto fb = create_dumb_fb(s->drm.dri_fd.get(), width, height, pix_fmt);
        draw_frame(&fb, splash_frame.get(), true);
 
        return fb;
}

References create_dumb_fb(), draw_frame(), Drm_state::dri_fd, drm_display_state::drm, drm_format_supported(), and get_splashscreen().

Referenced by display_drm_init().

Here is the call graph for this function:

init_drm_state()

static bool init_drm_state ( drm_display_state * s )

static

Definition at line 528 of file drm.cpp.

                                                {
        s->drm.dri_fd = open_dri(s);
 
        int dri = s->drm.dri_fd.get();
        if(dri < 0){
                return false;
        }
 
        print_drm_driver_info(s);
 
        int res = 0;
        res = drmSetClientCap(dri, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1);
        if(res != 0){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to set universal planes capab\n");
                return false;
        }
 
        s->drm.gem_manager = std::make_unique<Gem_handle_manager>(dri);
 
        s->drm.res.reset(drmModeGetResources(dri));
        if(!s->drm.res){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to get DRI resources: %s\n", strerror(errno));
                return false;
        }
 
        uint64_t prime_support = false;
        res = drmGetCap(dri, DRM_CAP_PRIME, &prime_support);
        if(res < 0 || !prime_support){
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "DRM device does not support PRIME buffers\n");
        }
        s->drm.prime_support = prime_support;
 
        return true;
}

References Drm_state::dri_fd, drm_display_state::drm, Drm_state::gem_manager, LOG_LEVEL_ERROR, LOG_LEVEL_WARNING, log_msg(), MOD_NAME, open_dri(), Drm_state::prime_support, print_drm_driver_info(), and Drm_state::res.

Referenced by display_drm_init().

Here is the call graph for this function:

open_dri()

static Fd_uniq open_dri ( drm_display_state * s )

static

Definition at line 415 of file drm.cpp.

                                             {
 
        auto do_open = [](const char *path) -> Fd_uniq {
                int fd = open(path, O_RDWR);
                if(fd < 0){
                        if(errno != ENOENT)
                                log_msg(LOG_LEVEL_INFO, MOD_NAME "Failed to open %s (%s)\n", path, strerror(errno));
 
                        return {};
                }
                Fd_uniq ret(fd);
 
                Drm_res_uniq resources(drmModeGetResources(fd));
                if(!resources){
                        log_msg(LOG_LEVEL_INFO, MOD_NAME "Failed to get resources on %s (%s)\n", path, strerror(errno));
                        return {};
                }
 
                uint64_t dumb_support = false;
                int res = 0;
                res = drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &dumb_support);
                if(res < 0 || !dumb_support){
                        log_msg(LOG_LEVEL_WARNING, MOD_NAME "%s does not support dumb buffers\n", path);
                        return {};
                }
 
                log_msg(LOG_LEVEL_INFO, MOD_NAME "Opened %s DRI device\n", path);
                return ret;
        };
 
        if(!s->device_path.empty()){
                auto ret = do_open(s->device_path.c_str());
                if(!ret)
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to open specified device (%s)\n", s->device_path.c_str());
 
                return ret;
        }
 
        char buf[256] = {};
        const int max_index = 32;
        for(int i = 0; i < max_index; i++){
                snprintf(buf, sizeof(buf), DRM_DEV_NAME, DRM_DIR_NAME, i);
                auto ret = do_open(buf);
                if(ret)
                        return ret;
        }
        log_msg(LOG_LEVEL_ERROR, MOD_NAME "No suitable DRI device found\n");
        return {};
}

References drm_display_state::device_path, LOG_LEVEL_ERROR, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, log_msg(), and MOD_NAME.

Referenced by init_drm_state().

Here is the call graph for this function:

print_connectors()

static void print_connectors ( drm_display_state * s )

static

Definition at line 575 of file drm.cpp.

                                                  {
        color_printf("Connectors:\n");
 
        auto connectors = get_connectors(s);
        for(auto& connector : connectors){
                color_printf("\t%s%s:\n", get_connector_str(connector->connector_type, connector->connector_type_id).c_str(),
                                get_connector_status_str(connector->connection));
 
                for(int i = 0; i < connector->count_modes; i++){
                        auto mode_info = &connector->modes[i];
                        color_printf("\t\t%dx%d@%d (%s)%s\n", mode_info->hdisplay, mode_info->vdisplay, mode_info->vrefresh, mode_info->name,
                                        mode_info->type & DRM_MODE_TYPE_PREFERRED ? " preferred" : "");
                }
        }
}

References color_printf(), get_connector_status_str(), get_connector_str(), and get_connectors().

Referenced by display_drm_init().

Here is the call graph for this function:

print_drm_driver_info()

static void print_drm_driver_info ( drm_display_state * s )

static

Definition at line 399 of file drm.cpp.

                                                       {
        drmVersionPtr version = drmGetVersion(s->drm.dri_fd.get());
        if(!version){
                log_msg(LOG_LEVEL_WARNING, MOD_NAME "Failed to get DRM driver version\n");
                return;
        }
 
        log_msg(LOG_LEVEL_INFO, MOD_NAME "DRM version: %d.%d.%d (%s), Driver: %s\n",
                        version->version_major,
                        version->version_minor,
                        version->version_patchlevel,
                        version->date,
                        version->name);
        drmFreeVersion(version);
}

References Drm_state::dri_fd, drm_display_state::drm, LOG_LEVEL_INFO, LOG_LEVEL_WARNING, log_msg(), and MOD_NAME.

Referenced by init_drm_state().

Here is the call graph for this function:

probe_drm_formats()

static bool probe_drm_formats ( drm_display_state * s )

static

Definition at line 477 of file drm.cpp.

                                                   {
        int dri = s->drm.dri_fd.get();
        Drm_plane_res_uniq plane_res(drmModeGetPlaneResources(dri));
        if(!plane_res){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to get plane resources (%s)\n", strerror(errno));
                return false;
        }
 
        Drm_plane_uniq primary_plane;
        for(unsigned i = 0; i < plane_res->count_planes; i++){
                Drm_plane_uniq plane(drmModeGetPlane(dri, plane_res->planes[i]));
                if(!(plane->possible_crtcs & (1 << s->drm.crtc_index)))
                        continue;
 
                Drm_object_properties_uniq props(drmModeObjectGetProperties(dri, plane_res->planes[i], DRM_MODE_OBJECT_PLANE));
                if(!props){
                        log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to get plane props (%s)\n", strerror(errno));
                        continue;
                }
                if(get_property(dri, props.get(), "type") == DRM_PLANE_TYPE_PRIMARY){
                        primary_plane = std::move(plane);
                        break;
                }
        }
 
        if(!primary_plane){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to find the primary plane\n");
                return false;
        }
 
        for(unsigned i = 0; i < primary_plane->count_formats; i++){
                s->drm.supported_drm_formats.insert(primary_plane->formats[i]);
        }
 
        return true;
}

References Drm_state::crtc_index, Drm_state::dri_fd, drm_display_state::drm, get_property(), LOG_LEVEL_ERROR, log_msg(), MOD_NAME, and Drm_state::supported_drm_formats.

Referenced by setup_crtc().

Here is the call graph for this function:

recycle_frame()

static void recycle_frame ( drm_display_state * s, frame_uniq & frame )

static

Definition at line 967 of file drm.cpp.

                                                                  {
        vf_recycle(frame.get());
        s->free_frames.push_back(std::move(frame));
}

References frame, drm_display_state::free_frames, and vf_recycle().

Referenced by display_drm_putf().

Here is the call graph for this function:

recycle_prime_frame()

static void recycle_prime_frame ( drm_display_state * s, Drm_prime_fb & fb )

static

Definition at line 972 of file drm.cpp.

                                                                       {
        frame_uniq frame = std::move(fb.frame);
        fb = {};
        if(frame){
                vf_recycle(frame.get());
                s->free_frames.push_back(std::move(frame));
        }
}

References Drm_prime_fb::frame, frame, drm_display_state::free_frames, and vf_recycle().

Referenced by display_drm_putf().

Here is the call graph for this function:

REGISTER_MODULE()

REGISTER_MODULE	(	drm	,
		&	display_drm_info,
		LIBRARY_CLASS_VIDEO_DISPLAY	,
		VIDEO_DISPLAY_ABI_VERSION	)

set_framebuffer()

static bool set_framebuffer ( drm_display_state * s, uint32_t fb_id )

static

Definition at line 768 of file drm.cpp.

                                                                 {
        int res = 0;
        res = drmModeSetCrtc(s->drm.dri_fd.get(), s->drm.crtc->crtc_id,
                        fb_id, 0, 0, &s->drm.connector->connector_id, 1, s->drm.mode_info);
        if(res < 0){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to set crtc (%d)\n", res);
                return false;
        }
        return true;
}

References Drm_state::connector, Drm_state::crtc, Drm_state::dri_fd, drm_display_state::drm, LOG_LEVEL_ERROR, log_msg(), MOD_NAME, and Drm_state::mode_info.

Referenced by display_drm_putf(), and swap_buffers().

Here is the call graph for this function:

setup_crtc()

static bool setup_crtc ( drm_display_state * s )

static

Definition at line 591 of file drm.cpp.

                                            {
        auto connectors = get_connectors(s);
 
        for(auto& connector : connectors){
                if(!s->req_connector.empty()){
                        if(s->req_connector == get_connector_str(connector->connector_type, connector->connector_type_id)){
                                s->drm.connector = std::move(connector);
                                break;
                        } else {
                                continue;
                        }
                }
 
                if(connector->count_modes > 0 && connector->connection == DRM_MODE_CONNECTED){
                        s->drm.connector = std::move(connector);
                        break;
                }
        }
 
        if(!s->drm.connector){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Connector not found\n");
                return false;
        }
 
        bool find_preferred_mode = s->req_width <= 0 && s->req_height <= 0 && s->req_rate <= 0;
        for(int i = 0; i < s->drm.connector->count_modes; i++){
                auto mode = &s->drm.connector->modes[i];
 
                if(s->req_width > 0 && mode->hdisplay != s->req_width)
                        continue;
 
                if(s->req_height > 0 && mode->vdisplay != s->req_height)
                        continue;
 
                if(s->req_rate > 0 && mode->vrefresh != s->req_rate)
                        continue;
 
                if(find_preferred_mode && !(mode->type & DRM_MODE_TYPE_PREFERRED)){
                        continue;
                }
 
                s->drm.mode_info = mode;
                break;
        }
 
        if(!s->drm.mode_info){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Mode not found\n");
                return false;
        }
 
        int dri = s->drm.dri_fd.get();
 
        std::vector<int> encoder_list;
        if(s->drm.connector->encoder_id){
                encoder_list.push_back(s->drm.connector->encoder_id);
        }
        for(int i = 0; i < s->drm.connector->count_encoders; i++){
                encoder_list.push_back(s->drm.connector->encoders[i]);
        }
 
        for(int encoder_id : encoder_list){
                s->drm.encoder.reset(drmModeGetEncoder(dri, encoder_id));
                if(!s->drm.encoder)
                        continue;
 
                std::vector<unsigned> crtc_list;
                if(s->drm.encoder->crtc_id){
                        crtc_list.push_back(s->drm.encoder->crtc_id);
                }
                for(int i = 0; i < s->drm.res->count_crtcs; i++){
                        if((1 << i) & s->drm.encoder->possible_crtcs){
                                crtc_list.push_back(s->drm.res->crtcs[i]);
                        }
                }
 
                for(unsigned crtc_id : crtc_list){
                        s->drm.crtc.reset(drmModeGetCrtc(dri, crtc_id));
                        if(s->drm.crtc){
                                for(int i = 0; i < s->drm.res->count_crtcs; i++){
                                        if(s->drm.res->crtcs[i] == crtc_id){
                                                s->drm.crtc_index = i;
                                                break;
                                        }
                                }
                                break;
                        }
                }
                if(s->drm.crtc)
                        break;
        }
 
 
        if(!s->drm.crtc){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to find encoder crtc pair\n");
                return false;
        }
 
        if(!probe_drm_formats(s)){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Failed to probe DRM supported formats\n");
                return false;
        }
 
        int res = 0;
        res = drmSetMaster(dri);
        if(res != 0){
                log_msg(LOG_LEVEL_ERROR, MOD_NAME "Unable to get DRM master. Is X11 or Wayland running?\n");
                return false;
        }
 
        return true;
}

References Drm_state::connector, Drm_state::crtc, Drm_state::crtc_index, Drm_state::dri_fd, drm_display_state::drm, Drm_state::encoder, get_connector_str(), get_connectors(), LOG_LEVEL_ERROR, log_msg(), MOD_NAME, mode, Drm_state::mode_info, probe_drm_formats(), drm_display_state::req_connector, drm_display_state::req_height, drm_display_state::req_rate, drm_display_state::req_width, and Drm_state::res.

Referenced by display_drm_init().

Here is the call graph for this function:

swap_buffers()

static bool swap_buffers ( drm_display_state * s )

static

Definition at line 933 of file drm.cpp.

                                              {
        std::swap(s->front_buffer, s->back_buffer);
        return set_framebuffer(s, s->front_buffer.id.get().id);
}

References drm_display_state::back_buffer, drm_display_state::front_buffer, Framebuffer::id, and set_framebuffer().

Referenced by display_drm_putf().

Here is the call graph for this function:

Variable Documentation

display_drm_info

const struct video_display_info display_drm_info

static

Initial value:

= {
        display_drm_probe,
        display_drm_init,
        NULL, 
        display_drm_done,
        display_drm_getf,
        display_drm_putf,
        display_drm_reconfigure,
        display_drm_get_property,
        NULL, 
        NULL, 
        MOD_NAME,
}

Definition at line 1125 of file drm.cpp.

                                                          {
        display_drm_probe,
        display_drm_init,
        NULL, // _run
        display_drm_done,
        display_drm_getf,
        display_drm_putf,
        display_drm_reconfigure,
        display_drm_get_property,
        NULL, // _put_audio_frame
        NULL, // _reconfigure_audio
        MOD_NAME,
};