i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Rewrote headers.

Browse Source 
+alphabranch


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32747 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Stephan Aßmus
2009-08-27 12:35:43 +00:00
parent 9fe35223cf
commit a69c16fec5
6 changed files with 393 additions and 327 deletions
Download Patch File Download Diff File Expand all files Collapse all files
headers/os/add-ons/graphics/Accelerant.h
+209 -137
View File
@@ -1,128 +1,161 @@
/*
* Copyright 2009, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License.
*/
#ifndef _ACCELERANT_H_ #ifndef _ACCELERANT_H_
#define _ACCELERANT_H_ #define _ACCELERANT_H_
#include <BeBuild.h>
#include <SupportDefs.h>
#include <GraphicsDefs.h> #include <GraphicsDefs.h>
#include <OS.h> #include <OS.h>
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
#endif #endif
#define B_ACCELERANT_ENTRY_POINT "get_accelerant_hook" #define B_ACCELERANT_ENTRY_POINT "get_accelerant_hook"
#define B_ACCELERANT_VERSION 1 #define B_ACCELERANT_VERSION 1
typedef void * (*GetAccelerantHook)(uint32, void *);
void *get_accelerant_hook(uint32 feature, void *data); typedef void* (*GetAccelerantHook)(uint32, void*);
void* get_accelerant_hook(uint32 feature, void* data);
enum { enum {
/* initialization */ /* initialization */
B_INIT_ACCELERANT = 0, /* required */ B_INIT_ACCELERANT = 0, /* required */
B_ACCELERANT_CLONE_INFO_SIZE, /* required */ B_ACCELERANT_CLONE_INFO_SIZE, /* required */
B_GET_ACCELERANT_CLONE_INFO, /* required */ B_GET_ACCELERANT_CLONE_INFO, /* required */
B_CLONE_ACCELERANT, /* required */ B_CLONE_ACCELERANT, /* required */
B_UNINIT_ACCELERANT, /* required */ B_UNINIT_ACCELERANT, /* required */
B_GET_ACCELERANT_DEVICE_INFO, /* required */ B_GET_ACCELERANT_DEVICE_INFO, /* required */
B_ACCELERANT_RETRACE_SEMAPHORE, /* optional */ B_ACCELERANT_RETRACE_SEMAPHORE, /* optional */
/* mode configuration */ /* mode configuration */
B_ACCELERANT_MODE_COUNT = 0x100, /* required */ B_ACCELERANT_MODE_COUNT = 0x100, /* required */
B_GET_MODE_LIST, /* required */ B_GET_MODE_LIST, /* required */
B_PROPOSE_DISPLAY_MODE, /* optional */ B_PROPOSE_DISPLAY_MODE, /* optional */
B_SET_DISPLAY_MODE, /* required */ B_SET_DISPLAY_MODE, /* required */
B_GET_DISPLAY_MODE, /* required */ B_GET_DISPLAY_MODE, /* required */
B_GET_FRAME_BUFFER_CONFIG, /* required */ B_GET_FRAME_BUFFER_CONFIG, /* required */
B_GET_PIXEL_CLOCK_LIMITS, /* required */ B_GET_PIXEL_CLOCK_LIMITS, /* required */
B_GET_TIMING_CONSTRAINTS, /* optional */ B_GET_TIMING_CONSTRAINTS, /* optional */
B_MOVE_DISPLAY, /* optional */ B_MOVE_DISPLAY, /* optional */
B_SET_INDEXED_COLORS, /* required if driver supports 8bit indexed modes */ B_SET_INDEXED_COLORS, /* required if driver supports 8bit */
B_DPMS_CAPABILITIES, /* required if driver supports DPMS */ /* indexed modes */
B_DPMS_MODE, /* required if driver supports DPMS */ B_DPMS_CAPABILITIES, /* required if driver supports DPMS */
B_SET_DPMS_MODE, /* required if driver supports DPMS */ B_DPMS_MODE, /* required if driver supports DPMS */
B_GET_PREFERRED_DISPLAY_MODE, /* optional */ B_SET_DPMS_MODE, /* required if driver supports DPMS */
B_GET_MONITOR_INFO, /* optional */ B_GET_PREFERRED_DISPLAY_MODE, /* optional */
B_GET_EDID_INFO, /* optional */ B_GET_MONITOR_INFO, /* optional */
B_GET_EDID_INFO, /* optional */
/* cursor managment */ /* cursor managment */
B_MOVE_CURSOR = 0x200, /* optional */ B_MOVE_CURSOR = 0x200, /* optional */
B_SET_CURSOR_SHAPE, /* optional */ B_SET_CURSOR_SHAPE, /* optional */
B_SHOW_CURSOR, /* optional */ B_SHOW_CURSOR, /* optional */
/* synchronization */ /* synchronization */
B_ACCELERANT_ENGINE_COUNT = 0x300, /* required */ B_ACCELERANT_ENGINE_COUNT = 0x300, /* required */
B_ACQUIRE_ENGINE, /* required */ B_ACQUIRE_ENGINE, /* required */
B_RELEASE_ENGINE, /* required */ B_RELEASE_ENGINE, /* required */
B_WAIT_ENGINE_IDLE, /* required */ B_WAIT_ENGINE_IDLE, /* required */
B_GET_SYNC_TOKEN, /* required */ B_GET_SYNC_TOKEN, /* required */
B_SYNC_TO_TOKEN, /* required */ B_SYNC_TO_TOKEN, /* required */
/* 2D acceleration */ /* 2D acceleration */
B_SCREEN_TO_SCREEN_BLIT = 0x400, /* optional */ B_SCREEN_TO_SCREEN_BLIT = 0x400, /* optional */
B_FILL_RECTANGLE, /* optional */ B_FILL_RECTANGLE, /* optional */
B_INVERT_RECTANGLE, /* optional */ B_INVERT_RECTANGLE, /* optional */
B_FILL_SPAN, /* optional */ B_FILL_SPAN, /* optional */
B_SCREEN_TO_SCREEN_TRANSPARENT_BLIT, /* optional */ B_SCREEN_TO_SCREEN_TRANSPARENT_BLIT, /* optional */
B_SCREEN_TO_SCREEN_SCALED_FILTERED_BLIT, /* optional. NOTE: source and dest may NOT overlap */ B_SCREEN_TO_SCREEN_SCALED_FILTERED_BLIT, /* optional.
NOTE: source and dest may NOT overlap */
/* 3D acceleration */ /* 3D acceleration */
B_ACCELERANT_PRIVATE_START = (int)0x80000000 B_ACCELERANT_PRIVATE_START = (int)0x80000000
}; };
typedef struct {
uint32 version; /* structure version number */
char name[32]; /* a name the user will recognize the device by */
char chipset[32]; /* the chipset used by the device */
char serial_no[32]; /* serial number for the device */
uint32 memory; /* amount of memory on the device, in bytes */
uint32 dac_speed; /* nominal DAC speed, in MHz */
} accelerant_device_info;
typedef struct { typedef struct {
uint32 pixel_clock; /* kHz */ uint32 version; /* structure version number */
uint16 h_display; /* in pixels (not character clocks) */ char name[32]; /* a name the user will recognize */
/* the device by */
char chipset[32]; /* the chipset used by the device */
char serial_no[32]; /* serial number for the device */
uint32 memory; /* amount of memory on the device, */
/* in bytes */
uint32 dac_speed; /* nominal DAC speed, in MHz */
} accelerant_device_info;
typedef struct {
uint32 pixel_clock; /* kHz */
uint16 h_display; /* in pixels (not character clocks) */
uint16 h_sync_start; uint16 h_sync_start;
uint16 h_sync_end; uint16 h_sync_end;
uint16 h_total; uint16 h_total;
uint16 v_display; /* in lines */ uint16 v_display; /* in lines */
uint16 v_sync_start; uint16 v_sync_start;
uint16 v_sync_end; uint16 v_sync_end;
uint16 v_total; uint16 v_total;
uint32 flags; /* sync polarity, etc. */ uint32 flags; /* sync polarity, etc. */
} display_timing; } display_timing;
typedef struct { typedef struct {
display_timing timing; /* CTRC info */ display_timing timing; /* CTRC info */
uint32 space; /* pixel configuration */ uint32 space; /* pixel configuration */
uint16 virtual_width; /* in pixels */ uint16 virtual_width; /* in pixels */
uint16 virtual_height; /* in lines */ uint16 virtual_height; /* in lines */
uint16 h_display_start; /* first displayed pixel in line */ uint16 h_display_start; /* first displayed pixel in line */
uint16 v_display_start; /* first displayed line */ uint16 v_display_start; /* first displayed line */
uint32 flags; /* mode flags */ uint32 flags; /* mode flags (Some drivers use this */
/* for dual head related options.) */
} display_mode; } display_mode;
typedef struct { typedef struct {
void *frame_buffer; /* pointer to first byte of frame buffer in virtual memory */ void* frame_buffer; /* pointer to first byte of frame */
void *frame_buffer_dma; /* pointer to first byte of frame buffer in physical memory for DMA */ /* buffer in virtual memory */
uint32 bytes_per_row; /* number of bytes in one virtual_width line */
/* not neccesarily the same as virtual_width * byte_per_pixel */ void* frame_buffer_dma; /* pointer to first byte of frame */
/* buffer in physical memory for DMA */
uint32 bytes_per_row; /* number of bytes in one */
/* virtual_width line */
/* not neccesarily the same as */
/* virtual_width * byte_per_pixel */
} frame_buffer_config; } frame_buffer_config;
typedef struct { typedef struct {
uint16 h_res; /* minimum effective change in horizontal pixels, usually 8 */ uint16 h_res; /* minimum effective change in */
uint16 h_sync_min; /* min/max horizontal sync pulse width in pixels, a multiple of h_res */ /* horizontal pixels, usually 8 */
uint16 h_sync_min; /* min/max horizontal sync pulse */
/* width in pixels, a multiple of */
/* h_res */
uint16 h_sync_max; uint16 h_sync_max;
uint16 h_blank_min; /* min/max horizontal blank pulse width in pixels, a multiple of h_res */ uint16 h_blank_min; /* min/max horizontal blank pulse */
/* width in pixels, a multiple of */
/* h_res */
uint16 h_blank_max; uint16 h_blank_max;
uint16 v_res; /* minimum effective change in vertical lines, usually 1 */ uint16 v_res; /* minimum effective change in */
uint16 v_sync_min; /* min/max vertical sync pulse width in lines, a multiple of v_res */ /* vertical lines, usually 1 */
uint16 v_sync_min; /* min/max vertical sync pulse */
/* width in lines, a multiple of */
/* v_res */
uint16 v_sync_max; uint16 v_sync_max;
uint16 v_blank_min; /* min/max vertical blank pulse width in linex, a multiple of v_res */ uint16 v_blank_min; /* min/max vertical blank pulse */
/* width in linex, a multiple of */
/* v_res */
uint16 v_blank_max; uint16 v_blank_max;
} display_timing_constraints; } display_timing_constraints;
// TODO: experimental API
// WARNING: This is experimental new Haiku API
typedef struct { typedef struct {
uint32 version; uint32 version;
char vendor[128]; char vendor[128];
@@ -135,81 +168,107 @@ typedef struct {
} produced; } produced;
float width; float width;
float height; float height;
uint32 min_horizontal_frequency; // in kHz uint32 min_horizontal_frequency; /* in kHz */
uint32 max_horizontal_frequency; uint32 max_horizontal_frequency;
uint32 min_vertical_frequency; // in Hz uint32 min_vertical_frequency; /* in Hz */
uint32 max_vertical_frequency; uint32 max_vertical_frequency;
uint32 max_pixel_clock; // in kHz uint32 max_pixel_clock; /* in kHz */
} monitor_info; } monitor_info;
enum { /* mode flags */
B_SCROLL = 1 << 0, /* mode flags */
B_8_BIT_DAC = 1 << 1, enum {
B_HARDWARE_CURSOR = 1 << 2, B_SCROLL = 1 << 0,
B_PARALLEL_ACCESS = 1 << 3, B_8_BIT_DAC = 1 << 1,
B_DPMS = 1 << 4, B_HARDWARE_CURSOR = 1 << 2,
B_IO_FB_NA = 1 << 5 B_PARALLEL_ACCESS = 1 << 3,
B_DPMS = 1 << 4,
B_IO_FB_NA = 1 << 5
}; };
enum { /* power saver flags */
B_DPMS_ON = 1 << 0, /* power saver flags */
B_DPMS_STAND_BY = 1 << 1, enum {
B_DPMS_SUSPEND = 1 << 2, B_DPMS_ON = 1 << 0,
B_DPMS_OFF = 1 << 3 B_DPMS_STAND_BY = 1 << 1,
B_DPMS_SUSPEND = 1 << 2,
B_DPMS_OFF = 1 << 3
}; };
enum { /* timing flags */
B_BLANK_PEDESTAL = 1 << 27, /* timing flags */
B_TIMING_INTERLACED = 1 << 28, enum {
B_POSITIVE_HSYNC = 1 << 29, B_BLANK_PEDESTAL = 1 << 27,
B_POSITIVE_VSYNC = 1 << 30, B_TIMING_INTERLACED = 1 << 28,
B_SYNC_ON_GREEN = 1 << 31 B_POSITIVE_HSYNC = 1 << 29,
B_POSITIVE_VSYNC = 1 << 30,
B_SYNC_ON_GREEN = 1 << 31
}; };
typedef struct { typedef struct {
uint16 src_left; /* guaranteed constrained to virtual width and height */ uint16 src_left; /* guaranteed constrained to */
/* virtual width and height */
uint16 src_top; uint16 src_top;
uint16 dest_left; uint16 dest_left;
uint16 dest_top; uint16 dest_top;
uint16 width; /* 0 to N, where zero means one pixel, one means two pixels, etc. */ uint16 width; /* 0 to N, where zero means */
uint16 height; /* 0 to M, where zero means one line, one means two lines, etc. */ /* one pixel, one means two pixels, */
/* etc. */
uint16 height; /* 0 to M, where zero means one */
/* line, one means two lines, etc. */
} blit_params; } blit_params;
typedef struct {
uint16 src_left; /* guaranteed constrained to virtual width and height */
uint16 src_top;
uint16 src_width; /* 0 to N, where zero means one pixel, one means two pixels, etc. */
uint16 src_height; /* 0 to M, where zero means one line, one means two lines, etc. */
uint16 dest_left;
uint16 dest_top;
uint16 dest_width; /* 0 to N, where zero means one pixel, one means two pixels, etc. */
uint16 dest_height; /* 0 to M, where zero means one line, one means two lines, etc. */
} scaled_blit_params;
typedef struct { typedef struct {
uint16 left; /* guaranteed constrained to virtual width and height */ uint16 src_left; /* guaranteed constrained to */
/* virtual width and height */
uint16 src_top;
uint16 src_width; /* 0 to N, where zero means one */
/* pixel, one means two pixels, */
/* etc. */
uint16 src_height; /* 0 to M, where zero means one */
/* line, one means two lines, etc. */
uint16 dest_left;
uint16 dest_top;
uint16 dest_width; /* 0 to N, where zero means one */
/* pixel, one means two pixels, etc. */
uint16 dest_height; /* 0 to M, where zero means one */
/* line, one means two lines, etc. */
} scaled_blit_params;
typedef struct {
uint16 left; /* guaranteed constrained to */
/* virtual width and height */
uint16 top; uint16 top;
uint16 right; uint16 right;
uint16 bottom; uint16 bottom;
} fill_rect_params; } fill_rect_params;
typedef struct { typedef struct {
uint32 engine_id; /* 0 == no engine, 1,2,3 etc individual engines */ uint32 engine_id; /* 0 == no engine, 1,2,3 etc */
uint32 capability_mask; /* features this engine supports */ /* individual engines */
void *opaque; /* optional pointer to engine private storage */ uint32 capability_mask; /* features this engine supports */
void* opaque; /* optional pointer to engine */
/* private storage */
} engine_token; } engine_token;
enum { /* engine capabilities */ enum { /* engine capabilities */
B_2D_ACCELERATION = 1 << 0, B_2D_ACCELERATION = 1 << 0,
B_3D_ACCELERATION = 1 << 1 B_3D_ACCELERATION = 1 << 1
}; };
typedef struct { typedef struct {
uint64 counter; /* counts issued primatives */ uint64 counter; /* counts issued primatives */
uint32 engine_id; /* what engine the counter is for */ uint32 engine_id; /* what engine the counter is for */
char opaque[12]; /* 12 bytes of private storage */ char opaque[12]; /* 12 bytes of private storage */
} sync_token; } sync_token;
/* Masks for color info */ /* Masks for color info */
/* B_CMAP8 - 0x000000ff */ /* B_CMAP8 - 0x000000ff */
/* B_RGB15/16 - 0x0000ffff */ /* B_RGB15/16 - 0x0000ffff */
@@ -218,49 +277,62 @@ typedef struct {
typedef status_t (*init_accelerant)(int fd); typedef status_t (*init_accelerant)(int fd);
typedef ssize_t (*accelerant_clone_info_size)(void); typedef ssize_t (*accelerant_clone_info_size)(void);
typedef void (*get_accelerant_clone_info)(void *data); typedef void (*get_accelerant_clone_info)(void* data);
typedef status_t (*clone_accelerant)(void *data); typedef status_t (*clone_accelerant)(void* data);
typedef void (*uninit_accelerant)(void); typedef void (*uninit_accelerant)(void);
typedef status_t (*get_accelerant_device_info)(accelerant_device_info *adi); typedef status_t (*get_accelerant_device_info)(accelerant_device_info* adi);
typedef uint32 (*accelerant_mode_count)(void); typedef uint32 (*accelerant_mode_count)(void);
typedef status_t (*get_mode_list)(display_mode *); typedef status_t (*get_mode_list)(display_mode*);
typedef status_t (*propose_display_mode)(display_mode *target, display_mode *low, display_mode *high); typedef status_t (*propose_display_mode)(display_mode* target,
typedef status_t (*set_display_mode)(display_mode *mode_to_set); display_mode* low, display_mode* high);
typedef status_t (*get_display_mode)(display_mode *current_mode); typedef status_t (*set_display_mode)(display_mode* mode_to_set);
typedef status_t (*get_frame_buffer_config)(frame_buffer_config *a_frame_buffer); typedef status_t (*get_display_mode)(display_mode* current_mode);
typedef status_t (*get_pixel_clock_limits)(display_mode *dm, uint32 *low, uint32 *high); typedef status_t (*get_frame_buffer_config)(frame_buffer_config*
typedef status_t (*move_display_area)(uint16 h_display_start, uint16 v_display_start); a_frame_buffer);
typedef status_t (*get_timing_constraints)(display_timing_constraints *dtc); typedef status_t (*get_pixel_clock_limits)(display_mode* dm, uint32* low,
typedef void (*set_indexed_colors)(uint count, uint8 first, uint8 *color_data, uint32 flags); uint32* high);
typedef status_t (*move_display_area)(uint16 h_display_start,
uint16 v_display_start);
typedef status_t (*get_timing_constraints)(display_timing_constraints* dtc);
typedef void (*set_indexed_colors)(uint count, uint8 first, uint8* color_data,
uint32 flags);
typedef uint32 (*dpms_capabilities)(void); typedef uint32 (*dpms_capabilities)(void);
typedef uint32 (*dpms_mode)(void); typedef uint32 (*dpms_mode)(void);
typedef status_t (*set_dpms_mode)(uint32 dpms_flags); typedef status_t (*set_dpms_mode)(uint32 dpms_flags);
typedef status_t (*get_preferred_display_mode)(display_mode *preferredMode); typedef status_t (*get_preferred_display_mode)(display_mode* preferredMode);
typedef status_t (*get_monitor_info)(monitor_info *info); typedef status_t (*get_monitor_info)(monitor_info* info);
typedef status_t (*get_edid_info)(void *info, uint32 size, uint32 *_version); typedef status_t (*get_edid_info)(void* info, uint32 size, uint32* _version);
typedef sem_id (*accelerant_retrace_semaphore)(void); typedef sem_id (*accelerant_retrace_semaphore)(void);
typedef status_t (*set_cursor_shape)(uint16 width, uint16 height, uint16 hot_x, uint16 hot_y, uint8 *andMask, uint8 *xorMask); typedef status_t (*set_cursor_shape)(uint16 width, uint16 height,
uint16 hot_x, uint16 hot_y, uint8* andMask, uint8* xorMask);
typedef void (*move_cursor)(uint16 x, uint16 y); typedef void (*move_cursor)(uint16 x, uint16 y);
typedef void (*show_cursor)(bool is_visible); typedef void (*show_cursor)(bool is_visible);
typedef uint32 (*accelerant_engine_count)(void); typedef uint32 (*accelerant_engine_count)(void);
typedef status_t (*acquire_engine)(uint32 capabilities, uint32 max_wait, sync_token *st, engine_token **et); typedef status_t (*acquire_engine)(uint32 capabilities, uint32 max_wait,
typedef status_t (*release_engine)(engine_token *et, sync_token *st); sync_token* st, engine_token** et);
typedef status_t (*release_engine)(engine_token* et, sync_token* st);
typedef void (*wait_engine_idle)(void); typedef void (*wait_engine_idle)(void);
typedef status_t (*get_sync_token)(engine_token *et, sync_token *st); typedef status_t (*get_sync_token)(engine_token* et, sync_token* st);
typedef status_t (*sync_to_token)(sync_token *st); typedef status_t (*sync_to_token)(sync_token* st);
typedef void (*screen_to_screen_blit)(engine_token *et, blit_params *list, uint32 count); typedef void (*screen_to_screen_blit)(engine_token* et, blit_params* list,
typedef void (*fill_rectangle)(engine_token *et, uint32 color, fill_rect_params *list, uint32 count); uint32 count);
typedef void (*invert_rectangle)(engine_token *et, fill_rect_params *list, uint32 count); typedef void (*fill_rectangle)(engine_token* et, uint32 color,
typedef void (*screen_to_screen_transparent_blit)(engine_token *et, uint32 transparent_color, blit_params *list, uint32 count); fill_rect_params* list, uint32 count);
typedef void (*screen_to_screen_scaled_filtered_blit)(engine_token *et, scaled_blit_params *list, uint32 count); typedef void (*invert_rectangle)(engine_token* et, fill_rect_params* list,
uint32 count);
typedef void (*screen_to_screen_transparent_blit)(engine_token* et,
uint32 transparent_color, blit_params* list, uint32 count);
typedef void (*screen_to_screen_scaled_filtered_blit)(engine_token* et,
scaled_blit_params* list, uint32 count);
typedef void (*fill_span)(engine_token *et, uint32 color, uint16 *list, uint32 count); typedef void (*fill_span)(engine_token* et, uint32 color, uint16* list,
uint32 count);
/* /*
The uint16 *list points to a list of tripples: The uint16* list points to a list of tripples:
list[N+0] Y co-ordinate of span list[N+0] Y co-ordinate of span
list[N+1] Left x co-ordinate of span list[N+1] Left x co-ordinate of span
list[N+2] Right x co-ordinate of span list[N+2] Right x co-ordinate of span
headers/os/add-ons/graphics/GraphicsCard.h
+74 -93
View File
@@ -1,23 +1,15 @@
/****************************************************************************** /*
/ * Copyright 2009, Haiku, Inc. All rights reserved.
/ File: GraphicsCard.h * Distributed under the terms of the MIT License.
/ */
/ Description: App Server interface for graphics card add-ons.
/
/ Copyright 1993-98, Be Incorporated
/
*******************************************************************************/
#ifndef _GRAPHICS_CARD_H #ifndef _GRAPHICS_CARD_H
#define _GRAPHICS_CARD_H #define _GRAPHICS_CARD_H
#include <BeBuild.h>
#include <GraphicsDefs.h> #include <GraphicsDefs.h>
#include <SupportDefs.h>
/*-------------------------------------------------------------*/
/*----- Command Constants -------------------------------------*/
/* #pragma mark - command constants */
enum { enum {
B_OPEN_GRAPHICS_CARD, B_OPEN_GRAPHICS_CARD,
B_CLOSE_GRAPHICS_CARD, B_CLOSE_GRAPHICS_CARD,
@@ -28,115 +20,115 @@ enum {
B_CONFIG_GRAPHICS_CARD, B_CONFIG_GRAPHICS_CARD,
B_GET_REFRESH_RATES, B_GET_REFRESH_RATES,
B_SET_SCREEN_GAMMA, B_SET_SCREEN_GAMMA,
B_GET_INFO_FOR_CLONE_SIZE, B_GET_INFO_FOR_CLONE_SIZE,
B_GET_INFO_FOR_CLONE, B_GET_INFO_FOR_CLONE,
B_SET_CLONED_GRAPHICS_CARD, B_SET_CLONED_GRAPHICS_CARD,
B_CLOSE_CLONED_GRAPHICS_CARD, B_CLOSE_CLONED_GRAPHICS_CARD,
B_PROPOSE_FRAME_BUFFER, B_PROPOSE_FRAME_BUFFER,
B_SET_FRAME_BUFFER, B_SET_FRAME_BUFFER,
B_SET_DISPLAY_AREA, B_SET_DISPLAY_AREA,
B_MOVE_DISPLAY_AREA} B_MOVE_DISPLAY_AREA
;
/*----- Optional ---------------*/
enum {
B_CRT_CONTROL = 0x0001,
B_GAMMA_CONTROL = 0x0002,
B_FRAME_BUFFER_CONTROL = 0x0004,
B_PARALLEL_BUFFER_ACCESS = 0x0008,
B_LAME_ASS_CARD = 0x0010
}; };
/*-------------------------------------------------------------*/ /* #pragma mark - optional flags */
/*----- Structures --------------------------------------------*/ enum {
B_CRT_CONTROL = 0x0001,
B_GAMMA_CONTROL = 0x0002,
B_FRAME_BUFFER_CONTROL = 0x0004,
B_PARALLEL_BUFFER_ACCESS = 0x0008,
B_LAME_ASS_CARD = 0x0010
};
/* #pragma mark - structures */
typedef struct { typedef struct {
int16 version; int16 version;
int16 id; int16 id;
void *frame_buffer; void* frame_buffer;
char rgba_order[4]; char rgba_order[4];
int16 flags; int16 flags;
int16 bits_per_pixel; int16 bits_per_pixel;
int16 bytes_per_row; int16 bytes_per_row;
int16 width; int16 width;
int16 height; int16 height;
} graphics_card_info; } graphics_card_info;
typedef struct { typedef struct {
int32 index; int32 index;
rgb_color color; rgb_color color;
} indexed_color; } indexed_color;
typedef struct { typedef struct {
uint32 space; uint32 space;
float refresh_rate; float refresh_rate;
uchar h_position; uchar h_position;
uchar v_position; uchar v_position;
uchar h_size; uchar h_size;
uchar v_size; uchar v_size;
} graphics_card_config; } graphics_card_config;
typedef struct { typedef struct {
float min; float min;
float max; float max;
float current; float current;
} refresh_rate_info; } refresh_rate_info;
typedef struct { typedef struct {
void *screen_base; void* screen_base;
void *io_base; void* io_base;
uint32 vendor_id; uint32 vendor_id;
uint32 device_id; uint32 device_id;
uint32 _reserved1_; uint32 _reserved1_;
uint32 _reserved2_; uint32 _reserved2_;
} graphics_card_spec; } graphics_card_spec;
typedef struct { typedef struct {
int16 x1; int16 x1;
int16 y1; int16 y1;
int16 x2; int16 x2;
int16 y2; int16 y2;
rgb_color color; rgb_color color;
} rgb_color_line; } rgb_color_line;
typedef struct { typedef struct {
int16 x1; int16 x1;
int16 y1; int16 y1;
int16 x2; int16 x2;
int16 y2; int16 y2;
uchar color; uchar color;
} indexed_color_line; } indexed_color_line;
typedef struct { typedef struct {
int16 bits_per_pixel; int16 bits_per_pixel;
int16 bytes_per_row; int16 bytes_per_row;
int16 width; int16 width;
int16 height; int16 height;
int16 display_width; int16 display_width;
int16 display_height; int16 display_height;
int16 display_x; int16 display_x;
int16 display_y; int16 display_y;
} frame_buffer_info; } frame_buffer_info;
typedef struct { typedef struct {
uchar red[256]; uchar red[256];
uchar green[256]; uchar green[256];
uchar blue[256]; uchar blue[256];
} screen_gamma; } screen_gamma;
/*-------------------------------------------------------------*/ /* #pragma mark - hook function */
/*----- Hook Function -----------------------------------------*/
typedef void (*graphics_card_hook) (); typedef void (*graphics_card_hook) ();
@@ -147,42 +139,31 @@ typedef void (*graphics_card_hook) ();
extern "C" { extern "C" {
#endif #endif
int32 control_graphics_card(uint32, void*); int32 control_graphics_card(uint32, void*);
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
/*-------------------------------------------------------------*/ /* #pragma mark - debugging functions */
/*----- Debugging Functions ------------------------------------*/
#ifdef __cplusplus #ifdef __cplusplus
extern "C" { extern "C" {
#endif #endif
void dprintf(const char *format, ...); void dprintf(const char *format, ...);
bool set_dprintf_enabled(bool); /* returns old enable flag */ bool set_dprintf_enabled(bool);
/* returns old enable flag */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
/*-------------------------------------------------------------*/ /* #pragma mark - deprecated */
/*----- Obsolete ---------------------------------------------*/
#define B_HOOK_COUNT B_GRAPHICS_HOOK_COUNT #define B_HOOK_COUNT B_GRAPHICS_HOOK_COUNT
/*-------------------------------------------------------------*/
/*-------------------------------------------------------------*/
#endif /* _GRAPHICS_CARD_H */ #endif /* _GRAPHICS_CARD_H */
headers/os/add-ons/input_server/InputServerDevice.h
+1 -1
View File
@@ -1,5 +1,5 @@
/* /*
* Copyright 2008 Haiku, Inc. All rights reserved. * Copyright 2008, Haiku, Inc. All rights reserved.
* Distributed under the terms of the MIT License. * Distributed under the terms of the MIT License.
*/ */
#ifndef _INPUTSERVERDEVICE_H #ifndef _INPUTSERVERDEVICE_H
headers/os/add-ons/input_server/InputServerFilter.h
+20 -24
View File
@@ -1,40 +1,36 @@
/****************************************************************************** /*
/ * Copyright 2009, Haiku, Inc. All rights reserved.
/ File: InputServerFilter.h * Distributed under the terms of the MIT License.
/ */
/ Description: Add-on class for input_server filters.
/
/ Copyright 1998, Be Incorporated, All Rights Reserved.
/
*******************************************************************************/
#ifndef _INPUTSERVERFILTER_H #ifndef _INPUTSERVERFILTER_H
#define _INPUTSERVERFILTER_H #define _INPUTSERVERFILTER_H
#include <BeBuild.h>
#include <MessageFilter.h> #include <MessageFilter.h>
#include <SupportDefs.h>
class BRegion; class BRegion;
class BInputServerFilter { class BInputServerFilter {
public: public:
BInputServerFilter(); BInputServerFilter();
virtual ~BInputServerFilter(); virtual ~BInputServerFilter();
virtual status_t InitCheck(); virtual status_t InitCheck();
virtual filter_result Filter(BMessage *message, BList *outList); virtual filter_result Filter(BMessage* message, BList* _list);
status_t GetScreenRegion(BRegion *region) const; status_t GetScreenRegion(BRegion* region) const;
private: private:
virtual void _ReservedInputServerFilter1(); // FBC Padding
virtual void _ReservedInputServerFilter2(); virtual void _ReservedInputServerFilter1();
virtual void _ReservedInputServerFilter3(); virtual void _ReservedInputServerFilter2();
virtual void _ReservedInputServerFilter4(); virtual void _ReservedInputServerFilter3();
uint32 _reserved[4]; virtual void _ReservedInputServerFilter4();
uint32 _reserved[4];
}; };
#endif // _INPUTSERVERFILTER_H
#endif
headers/os/add-ons/input_server/InputServerMethod.h
+30 -32
View File
@@ -1,19 +1,12 @@
/****************************************************************************** /*
/ * Copyright 2009, Haiku, Inc. All rights reserved.
/ File: InputServerMethod.h * Distributed under the terms of the MIT License.
/ */
/ Description: Add-on class for input_server methods.
/
/ Copyright 1998, Be Incorporated, All Rights Reserved.
/
******************************************************************************/
#ifndef _INPUTSERVERMETHOD_H #ifndef _INPUTSERVERMETHOD_H
#define _INPUTSERVERMETHOD_H #define _INPUTSERVERMETHOD_H
#include <BeBuild.h>
#include <InputServerFilter.h> #include <InputServerFilter.h>
#include <SupportDefs.h>
class _BMethodAddOn_; class _BMethodAddOn_;
@@ -21,32 +14,37 @@ class AddOnManager;
class BMenu; class BMenu;
class InputServer; class InputServer;
class BInputServerMethod : public BInputServerFilter { class BInputServerMethod : public BInputServerFilter {
public: public:
BInputServerMethod(const char *name, BInputServerMethod(const char* name,
const uchar *icon); const uchar* icon);
virtual ~BInputServerMethod(); virtual ~BInputServerMethod();
virtual status_t MethodActivated(bool active); virtual status_t MethodActivated(bool active);
status_t EnqueueMessage(BMessage *message); status_t EnqueueMessage(BMessage* message);
status_t SetName(const char *name); status_t SetName(const char* name);
status_t SetIcon(const uchar *icon); status_t SetIcon(const uchar* icon);
status_t SetMenu(const BMenu *menu, const BMessenger target); status_t SetMenu(const BMenu* menu,
const BMessenger target);
private: private:
_BMethodAddOn_* fOwner; // FBC padding
virtual void _ReservedInputServerMethod1();
friend class AddOnManager; virtual void _ReservedInputServerMethod2();
friend class InputServer; virtual void _ReservedInputServerMethod3();
virtual void _ReservedInputServerMethod4();
virtual void _ReservedInputServerMethod1();
virtual void _ReservedInputServerMethod2(); uint32 _reserved[4];
virtual void _ReservedInputServerMethod3();
virtual void _ReservedInputServerMethod4(); private:
uint32 _reserved[4]; friend class AddOnManager;
friend class InputServer;
private:
_BMethodAddOn_* fOwner;
}; };
#endif // _INPUTSERVERMETHOD_H
#endif
headers/os/kernel/scheduler.h
+59 -40
View File
@@ -1,54 +1,73 @@
/***************************************************************************** /*
* Copyright 2009, Haiku, Inc. All rights reserved.
File: scheduler.h * Distributed under the terms of the MIT License.
*/
Description: Scheduling inquiry functions #ifndef SCHEDULER_H
Copyright 1998-, Be Incorporated, All Rights Reserved.
*****************************************************************************/
#if !defined(SCHEDULER_H)
#define SCHEDULER_H #define SCHEDULER_H
#include <SupportDefs.h>
#include <OS.h> #include <OS.h>
/* To get a good thread priority, call suggest_thread_priority() with the following information: */
/* 'what' is a bit mask describing what you're doing in the thread. */ /*!
/* 'period' is how many times a second your thread needs to run (-1 if you're running continuously.) */ To get a good thread priority, call suggest_thread_priority() with the
/* 'jitter' is an estimate (in us) of how much that period can vary, as long as it stays centered on the average. */ following information:
/* 'length' is how long (in us) you expect to run for each invocation. */ \a what is a bit mask describing what you're doing in the thread.
/* "invocation" means, typically, receiving a message, dispatching it, and then returning to reading a message. */ \a period is how many times a second your thread needs to run
/* MANIPULATION means both filtering and compression/decompression. */ (-1 if you're running continuously.)
/* PLAYBACK and RECORDING means threads feeding/reading ACTUAL HARDWARE ONLY. */ \a jitter is an estimate (in us) of how much that period can vary,
/* 0 means don't care */ as long as it stays centered on the average.
enum be_task_flags { /* bitmasks for "what" */ \a length is how long (in us) you expect to run for each invocation.
B_DEFAULT_MEDIA_PRIORITY = 0, "Invocation" means, typically, receiving a message, dispatching
B_OFFLINE_PROCESSING = 0x1, it, and then returning to reading a message.
B_STATUS_RENDERING = 0x2, /* can also use this for "preview" type things */ MANIPULATION means both filtering and compression/decompression.
B_USER_INPUT_HANDLING = 0x4, PLAYBACK and RECORDING means threads feeding/reading ACTUAL
B_LIVE_VIDEO_MANIPULATION = 0x8, /* non-live processing is OFFLINE_PROCESSING */ HARDWARE ONLY.
B_VIDEO_PLAYBACK = 0x10, /* feeding hardware */ 0 means don't care
B_VIDEO_RECORDING = 0x20, /* grabbing from hardware */ */
B_LIVE_AUDIO_MANIPULATION = 0x40, /* non-live processing is OFFLINE_PROCESSING */
B_AUDIO_PLAYBACK = 0x80, /* feeding hardware */ /* bitmasks for suggest_thread_priority() */
B_AUDIO_RECORDING = 0x100, /* grabbing from hardware */ enum be_task_flags {
B_LIVE_3D_RENDERING = 0x200, /* non-live rendering is OFFLINE_PROCESSING */ B_DEFAULT_MEDIA_PRIORITY = 0x000,
B_NUMBER_CRUNCHING = 0x400, B_OFFLINE_PROCESSING = 0x001,
B_MIDI_PROCESSING = 0x800 B_STATUS_RENDERING = 0x002, /* can also use this for */
/* "preview" type things */
B_USER_INPUT_HANDLING = 0x004,
B_LIVE_VIDEO_MANIPULATION = 0x008, /* non-live processing is */
/* OFFLINE_PROCESSING */
B_VIDEO_PLAYBACK = 0x010, /* feeding hardware */
B_VIDEO_RECORDING = 0x020, /* grabbing from hardware */
B_LIVE_AUDIO_MANIPULATION = 0x040, /* non-live processing is */
/* OFFLINE_PROCESSING */
B_AUDIO_PLAYBACK = 0x080, /* feeding hardware */
B_AUDIO_RECORDING = 0x100, /* grabbing from hardware */
B_LIVE_3D_RENDERING = 0x200, /* non-live rendering is */
/* OFFLINE_PROCESSING */
B_NUMBER_CRUNCHING = 0x400,
B_MIDI_PROCESSING = 0x800
}; };
#if defined(__cplusplus) #if defined(__cplusplus)
extern "C" { extern "C" {
int32 suggest_thread_priority(uint32 task_flags = B_DEFAULT_MEDIA_PRIORITY, int32 suggest_thread_priority(uint32 task_flags = B_DEFAULT_MEDIA_PRIORITY,
int32 period = 0, bigtime_t jitter = 0, bigtime_t length = 0); int32 period = 0, bigtime_t jitter = 0, bigtime_t length = 0);
bigtime_t estimate_max_scheduling_latency(thread_id th = -1); /* default is current thread */
bigtime_t estimate_max_scheduling_latency(thread_id th = -1);
/* default is current thread */
} }
#else #else
int32 suggest_thread_priority(uint32 what, int32 period, bigtime_t jitter, bigtime_t length);
bigtime_t estimate_max_scheduling_latency(thread_id th); /* default is current thread */ int32 suggest_thread_priority(uint32 what, int32 period, bigtime_t jitter,
bigtime_t length);
bigtime_t estimate_max_scheduling_latency(thread_id th);
/* default is current thread */
#endif #endif
#endif /* SCHEDULER_H */ #endif // SCHEDULER_H