source/src/qt/osd_base.h

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : K.Ohta <whatisthis.sowhat _at_ gmail.com>
   5         Date   : 2015.11.30-
   6
   7         [ Qt dependent ]
   8 */
   9
  10 #ifndef _QT_OSD_BASE_H_
  11 #define _QT_OSD_BASE_H_
  12
  13
  14 #include <QList>
  15 #include <QObject>
  16 #include <QThread>
  17 #include <QString>
  18 #include <QStringList>
  19 #include <QImage>
  20
  21 #include <SDL.h>
  22
  23 #include <mutex>
  24 #include <string>
  25 #include <list>
  26 #include <memory>
  27 #include <atomic>
  28
  29 #define SOCKET_MAX 4
  30 #define SOCKET_BUFFER_MAX 0x100000
  31 #include "../config.h"
  32 #include "osd_types.h"
  33 // For UIs
  34 #include "osdcall_types.h"
  35
  36 #define N_MAX_BUTTONS 128
  37
  38 #define WM_RESIZE  (WM_USER + 1)
  39 #define WM_SOCKET0 (WM_USER + 2)
  40 #define WM_SOCKET1 (WM_USER + 3)
  41 #define WM_SOCKET2 (WM_USER + 4)
  42 #define WM_SOCKET3 (WM_USER + 5)
  43
  44 // osd common
  45
  46 #define OSD_CONSOLE_BLUE       1 // text color contains blue
  47 #define OSD_CONSOLE_GREEN      2 // text color contains green
  48 #define OSD_CONSOLE_RED                4 // text color contains red
  49 #define OSD_CONSOLE_INTENSITY  8 // text color is intensified
  50
  51 //#ifdef USE_VIDEO_CAPTURE
  52 #define MAX_CAPTURE_DEVS 8
  53 //#endif
  54
  55 //#include "qt_main.h"
  56
  57 enum {
  58         SAMPLE_TYPE_SINT8 = 0,
  59         SAMPLE_TYPE_UINT8,
  60         SAMPLE_TYPE_SINT16_BE,
  61         SAMPLE_TYPE_SINT16_LE,
  62         SAMPLE_TYPE_UINT16_BE,
  63         SAMPLE_TYPE_UINT16_LE,
  64         SAMPLE_TYPE_SINT32_BE,
  65         SAMPLE_TYPE_SINT32_LE,
  66         SAMPLE_TYPE_UINT32_BE,
  67         SAMPLE_TYPE_UINT32_LE,
  68         SAMPLE_TYPE_FLOAT_BE,
  69         SAMPLE_TYPE_FLOAT_LE,
  70 };
  71
  72 class GLDrawClass;
  73 class EmuThreadClass;
  74 class DrawThreadClass;
  75 class Ui_MainWindow;
  76 class EMU;
  77 class VM_TEMPLATE;
  78 class FIFO;
  79 class FILEIO;
  80 class CSP_KeyTables;
  81 class USING_FLAGS;
  82 class CSP_logger;
  83
  84 class QOpenGLContext;
  85 namespace SOUND_MODULE {
  86         namespace OUTPUT {
  87                 class M_BASE;
  88         }
  89 }
  90
  91 QT_BEGIN_NAMESPACE
  92
  93 #define MAX_SOUND_CAPTURE_DEVICES 8
  94 #define MAX_CAPTURE_SOUNDS 16
  95 typedef struct {
  96         int id;
  97         const _TCHAR *name;
  98 } device_node_t;
  99
 100 typedef struct {
 101         QString string;
 102         union {
 103                 int64_t ivalue;
 104                 uint64_t uvalue;
 105                 double  fvalue;
 106         } v;
 107 } supportedlist_t;
 108
 109
 110 typedef struct {
 111         SDL_AudioFormat format;
 112         int buffer_size;
 113         int readlen;
 114         int writelen;
 115         int readpos;
 116         int writepos;
 117         uint8_t* read_buffer_ptr;
 118 } osd_snddata_capture_t;
 119
 120 typedef struct {
 121         SDL_AudioFormat format;
 122         int sample_rate;
 123         int channels;
 124         int buffer_samples;
 125         int silence;
 126         int size;
 127         SDL_AudioCallback callback;
 128         osd_snddata_capture_t userdata;
 129 } osd_snd_capture_dev_desc_t;
 130
 131 typedef struct {
 132         int physical_dev;
 133         SDL_AudioFormat  read_format;
 134         int read_rate;
 135         int read_channels;
 136         int read_samples;
 137         int read_silence;
 138         int read_size;
 139         SDL_AudioCallback read_callback;
 140         void *read_userdata;
 141         // For output
 142         int sample_type; // ToDo : ENUM
 143         int rate;
 144         int channels;
 145         int samples;
 146         int write_size;
 147         int write_pos;
 148         int read_pos;
 149         int read_data_len;
 150         int read_buffer_len;
 151
 152         uint8_t *read_buffer_ptr;
 153         uint8_t *out_buffer;
 154 } osd_snd_capture_desc_t;
 155
 156
 157
 158 class SOUND_BUFFER_QT;
 159
 160 class DLL_PREFIX OSD_BASE : public  QObject
 161 {
 162         Q_OBJECT
 163 private:
 164         #if 1 /* Note: Below are new sound driver. */
 165         std::shared_ptr<SOUND_MODULE::OUTPUT::M_BASE> m_sound_driver;
 166         #else /* Note */
 167         qint64 sound_us_before_rendered;
 168         qint64 elapsed_us_before_rendered;
 169         SOUND_BUFFER_QT *m_audioOutput;
 170         SOUND_BUFFER_QT *m_audioInput;
 171
 172         QAudioFormat m_audioOutputFormat;
 173         QAudioFormat m_audioInputFormat;
 174
 175         #endif
 176         uint8_t m_sound_period;
 177 protected:
 178         EmuThreadClass          *parent_thread;
 179         sdl_snddata_t           snddata;
 180         std::shared_ptr<USING_FLAGS>                    using_flags;
 181         config_t                        *p_config;
 182         std::shared_ptr<CSP_Logger> p_logger;
 183
 184         QOpenGLContext *glContext;
 185         bool is_glcontext_shared;
 186
 187         QList<supportedlist_t> SupportedFeatures;
 188
 189         bool __USE_AUTO_KEY;
 190
 191         _TCHAR app_path[_MAX_PATH];
 192         QElapsedTimer osd_timer;
 193         bool locked_vm;
 194         // console
 195         virtual void initialize_console();
 196         virtual void release_console();
 197
 198         FILE *hStdIn, *hStdOut;
 199         QString console_cmd_str;
 200
 201         bool use_telnet;
 202         std::atomic<bool> telnet_closed;
 203         std::atomic<int> console_count;
 204         // input
 205         void initialize_input();
 206         void release_input();
 207         void key_down_sub(int code, bool repeat);
 208         void key_up_sub(int code);
 209         CSP_KeyTables *key_table;
 210
 211         bool dinput_key_ok;
 212 //      bool dinput_joy_ok;
 213
 214         uint8_t keycode_conv[256];
 215         uint8_t key_status[256];        // windows key code mapping
 216         uint8_t key_dik_prev[256];
 217         uint8_t key_converted[256];
 218         bool    joy_to_key_status[256];
 219
 220         bool numpad_5_pressed;
 221         bool key_shift_pressed, key_shift_released;
 222
 223
 224         uint32_t modkey_status;
 225         bool lost_focus;
 226         /*
 227          * 0  - 3:
 228          * joystick #1, - #4 (b0 = up, b1 = down, b2 = left, b3 = right, b4- = buttons)
 229          * 4  - 11:
 230          * ANALOG #1 - #4 AXIS LEFT X,Y : VALUE 65536 - 0 (RAW VALUE PLUS 32768)
 231          * 12 - 19:
 232          * ANALOG #1 - #4 AXIS RIGHT X,Y : VALUE = 65536 - 0 (RAW VALUE PLUS 32768)
 233          * 20 - 23:
 234          * ANALOG #1 - #4 DIGITAL DIR (b0 = UP, b1 = DOWN, b2 = LEFT, b3 = RIGHT)
 235          */
 236         uint32_t joy_status[32];
 237
 238         int32_t mouse_status[3];        // x, y, button (b0 = left, b1 = right)
 239         bool mouse_enabled;
 240         double mouse_ptrx;
 241         double mouse_ptry;
 242     int32_t mouse_button;
 243         double mouse_oldx;
 244         double mouse_oldy;
 245         //Qt::CursorShape mouse_shape;
 246
 247         QImage background_image;
 248         QImage button_images[N_MAX_BUTTONS];
 249         QImage rec_image_buffer;
 250
 251         // printer
 252
 253         // screen
 254         void initialize_screen();
 255         void release_screen();
 256
 257         virtual void initialize_screen_buffer(bitmap_t *buffer, int width, int height, int mode);
 258         void release_screen_buffer(bitmap_t *buffer);
 259         void rotate_screen_buffer(bitmap_t *source, bitmap_t *dest);
 260         virtual scrntype_t *get_buffer(bitmap_t *p, int y);
 261
 262         void stretch_screen_buffer(bitmap_t *source, bitmap_t *dest);
 263         virtual int add_video_frames();
 264
 265         bitmap_t vm_screen_buffer;
 266         bitmap_t video_screen_buffer;
 267         bitmap_t* draw_screen_buffer;
 268         int vm_window_width, vm_window_height;
 269         int vm_window_width_aspect, vm_window_height_aspect;
 270
 271         int host_window_width, host_window_height;
 272         bool host_window_mode;
 273         int base_window_width, base_window_height;
 274         int vm_screen_width, vm_screen_height;
 275         int draw_screen_width, draw_screen_height;
 276         int rec_video_nsec, rec_video_fps_nsec;
 277
 278         _TCHAR video_file_name[_MAX_PATH];
 279         int rec_video_fps;
 280
 281         uint64_t dwAVIFileSize;
 282         uint64_t lAVIFrames;
 283
 284         rec_video_thread_param_t rec_video_thread_param;
 285
 286         bool first_draw_screen;
 287         bool first_invalidate;
 288         bool self_invalidate;
 289
 290         // sound
 291 #if defined(USE_SDL2)
 292         SDL_AudioDeviceID audio_dev_id;
 293 #else
 294         int audio_dev_id;
 295 #endif
 296         SDL_AudioSpec snd_spec_req, snd_spec_presented;
 297         void release_sound();
 298 #if 0
 299         static void audio_capture_callback(void *udata, Uint8 *stream, int len);
 300         static void audio_callback(void *udata, Uint8 *stream, int len);
 301         void convert_sound_format(uint8_t* dst1, uint8_t* dst2, int16_t* src1, int16_t* src2, int samples1, int samples2);
 302 #endif
 303         virtual void init_sound_device_list();
 304
 305         int sound_rate, sound_samples;
 306         bool sound_ok, sound_started, now_mute;
 307         bool sound_first_half;
 308         QStringList sound_device_list;
 309
 310         _TCHAR sound_file_name[_MAX_PATH];
 311         FILEIO* rec_sound_fio;
 312         int rec_sound_bytes;
 313         int rec_sound_buffer_ptr;
 314
 315         int sound_buffer_size;
 316         int sound_data_len;
 317         int sound_data_pos;
 318         int sound_write_pos;
 319         bool sound_exit;
 320         bool sound_debug;
 321         bool sound_initialized;
 322         uint8_t *sound_buf_ptr;
 323         Uint8 snd_total_volume;
 324
 325         // sound capture
 326         QStringList sound_capture_device_list;
 327         bool sound_capturing_emu[MAX_CAPTURE_SOUNDS];
 328         osd_snd_capture_desc_t  sound_capture_desc[MAX_CAPTURE_SOUNDS]; // To EMU:: and VM::
 329         bool capturing_sound[MAX_SOUND_CAPTURE_DEVICES];
 330         osd_snd_capture_dev_desc_t  sound_capture_dev_desc[MAX_SOUND_CAPTURE_DEVICES]; // From physical devices
 331         uint8_t sound_capture_buffer[MAX_SOUND_CAPTURE_DEVICES][32768];
 332         // video device
 333         virtual void initialize_video();
 334         virtual void release_video();
 335
 336         bitmap_t dshow_screen_buffer;
 337         int direct_show_width, direct_show_height;
 338         bool direct_show_mute[2];
 339
 340         double movie_frame_rate;
 341         int movie_sound_rate;
 342
 343         void enum_capture_devs();
 344         bool connect_capture_dev(int index, bool pin);
 345         int cur_capture_dev_index;
 346         int num_capture_devs;
 347         _TCHAR capture_dev_name[MAX_CAPTURE_DEVS][256];
 348
 349         _TCHAR prn_file_name[_MAX_PATH];
 350         FILEIO *prn_fio;
 351         int prn_data, prn_wait_frames;
 352         bool prn_strobe;
 353
 354         // socket
 355         virtual void initialize_socket();
 356         virtual void release_socket();
 357
 358         bool is_tcp[SOCKET_MAX];
 359         bool host_mode[SOCKET_MAX];
 360         int socket_delay[SOCKET_MAX];
 361
 362         // MIDI : Will implement
 363         virtual void initialize_midi();
 364         virtual void release_midi();
 365
 366         // wrapper
 367         int max_vm_nodes;
 368         QList<device_node_t> device_node_list;
 369         void vm_draw_screen(void);
 370         Sint16* create_sound(int *extra_frames);
 371
 372         virtual bool get_use_socket(void);
 373         virtual bool get_use_auto_key(void);
 374         virtual bool get_dont_keeep_key_pressed(void);
 375         virtual bool get_one_board_micro_computer(void);
 376         virtual bool get_use_screen_rotate(void);
 377         virtual bool get_use_movie_player(void);
 378         virtual bool get_use_video_capture(void);
 379         void vm_key_down(int code, bool flag);
 380         void vm_key_up(int code);
 381         void vm_reset(void);
 382
 383         virtual int get_screen_width(void);
 384         virtual int get_screen_height(void);
 385         virtual int get_vm_buttons_code(int num);
 386         virtual void update_input_mouse();
 387
 388 public:
 389         OSD_BASE(std::shared_ptr<USING_FLAGS> p, std::shared_ptr<CSP_Logger> logger);
 390         ~OSD_BASE();
 391
 392         // common
 393         VM_TEMPLATE* vm;
 394         //EMU* emu;
 395         class Ui_MainWindow *main_window_handle;
 396
 397         std::recursive_timed_mutex screen_mutex;
 398         std::recursive_timed_mutex vm_mutex;
 399         std::recursive_timed_mutex debug_mutex;
 400         std::recursive_timed_mutex joystick_mutex;
 401         std::recursive_timed_mutex mouse_mutex;
 402         std::recursive_timed_mutex log_mutex;
 403         int host_cpus;
 404         bool now_auto_key;
 405
 406         virtual void initialize(int rate, int samples, int* presented_rate, int* presented_samples);
 407         // sound
 408         virtual void initialize_sound(int rate, int samples, int* presented_rate, int* presented_samples);
 409
 410         virtual void release();
 411
 412         void notify_power_off(); // For USE_NOTIFY_POWER_OFF .
 413
 414         void power_off();
 415         void suspend();
 416         void restore();
 417         _TCHAR* application_path();
 418         _TCHAR* bios_path(const _TCHAR* file_name);
 419         void get_host_time(cur_time_t* time);
 420         void sleep(uint32_t ms);
 421         void create_date_file_name(_TCHAR *name, int length, const _TCHAR *extension);
 422         _TCHAR  *get_app_path(void);
 423         // common console
 424         virtual void open_console(int width, int height, const _TCHAR* title);
 425         virtual void close_console();
 426         virtual unsigned int get_console_code_page();
 427         virtual bool is_console_closed();
 428
 429         void set_console_text_attribute(unsigned short attr);
 430         void write_console(const _TCHAR* buffer, unsigned int length);
 431         int read_console_input(_TCHAR* buffer, int length);
 432         bool is_console_key_pressed(uint32_t ch);
 433         void update_keyname_table(void);
 434         // console / telnet
 435         virtual void open_telnet(const _TCHAR* title);
 436         virtual void close_telnet();
 437         virtual void send_telnet(const char* string);
 438
 439         // common input
 440         void update_input();
 441         void key_down(int code, bool extended, bool repeat);
 442         void key_up(int code, bool extended);
 443         void key_down_native(int code, bool repeat);
 444         void key_up_native(int code);
 445         void key_lost_focus();
 446         void press_button(int num);
 447
 448 # if !defined(Q_OS_WIN) && !defined(Q_OS_CYGWIN)
 449         uint16_t GetAsyncKeyState(uint32_t vk);  // Win32 GetAsyncKeyState() wrappeer.
 450 # endif
 451         void key_modifiers(uint32_t mod);
 452         bool is_mouse_enabled();
 453         //QImage *getPseudoVramClass(void) { return pPseudoVram;}
 454         void set_mouse_pointer(double x, double y);
 455         void set_mouse_button(int button);
 456         void modify_key_buffer(int code, uint8_t val);
 457         uint8_t* get_key_buffer();
 458         uint32_t* get_joy_buffer();
 459         void release_joy_buffer(uint32_t* ptr);
 460         int32_t get_mouse_button();
 461         int32_t* get_mouse_buffer();
 462         void release_mouse_buffer(int32_t* ptr);
 463         // common printer
 464         void reset_printer();
 465         void update_printer();
 466         void printer_out(uint8_t value);
 467         void printer_strobe(bool value);
 468         // printer
 469         void initialize_printer();
 470         void release_printer();
 471         void open_printer_file();
 472         void close_printer_file();
 473
 474         // common screen
 475         int get_window_mode_width(int mode);
 476         int get_window_mode_height(int mode);
 477         double get_window_mode_power(int mode);
 478         void set_host_window_size(int window_width, int window_height, bool window_mode);
 479         void set_vm_screen_size(int width, int height, int width_aspect, int height_aspect, int window_width, int window_height);
 480         void set_vm_screen_lines(int lines); // 20170118
 481         int get_vm_screen_width();
 482         int get_vm_screen_height();
 483
 484         int get_vm_window_width();
 485         int get_vm_window_height();
 486         int get_vm_window_width_aspect();
 487         int get_vm_window_height_aspect();
 488         scrntype_t* get_vm_screen_buffer(int y);
 489         void reset_screen_buffer()
 490         {
 491                 // It's ugly hack for screen.
 492                 emit sig_resize_vm_screen((QImage*)NULL, -1, -1);
 493         }
 494         //int draw_screen();
 495         //int no_draw_screen();
 496         void reload_bitmap();
 497         void capture_screen();
 498         bool start_record_video(int fps);
 499         void stop_record_video();
 500         void restart_record_video();
 501         void add_extra_frames(int extra_frames);
 502         bool now_record_video;
 503         bool screen_skip_line;
 504         // common sound
 505         void update_sound(int* extra_frames);
 506         void mute_sound();
 507         void unmute_sound();
 508         void stop_sound();
 509         void start_record_sound();
 510         void stop_record_sound();
 511         void restart_record_sound();
 512
 513         const _TCHAR *get_vm_device_name();
 514         const _TCHAR *get_sound_device_name(int num);
 515         QStringList  get_sound_device_list()
 516         {
 517                 return sound_device_list;
 518         }
 519
 520         int get_sound_device_num();
 521
 522         bool now_record_sound;
 523         int get_sound_rate();
 524
 525         // To VM:: and EMU::
 526         void *get_capture_sound_buffer(int ch);
 527         bool is_capture_sound_buffer(int ch);
 528         void *open_capture_sound_emu(int ch, int rate, int channels, int sample_type, int samples, int physical_device_num);
 529         void close_capture_sound_emu(int ch);
 530
 531         // From physical device?
 532         bool open_sound_capture_device(int num, int req_rate, int req_channels);
 533         bool close_sound_capture_device(int num, bool force);
 534
 535         // common video device
 536         virtual void get_video_buffer();
 537         void mute_video_dev(bool l, bool r);
 538         virtual bool open_movie_file(const _TCHAR* file_path);
 539         virtual void close_movie_file();
 540         void play_movie();
 541         void stop_movie();
 542         void pause_movie();
 543         double get_movie_frame_rate();
 544         virtual int get_movie_sound_rate();
 545         void set_cur_movie_frame(int frame, bool relative);
 546         uint32_t get_cur_movie_frame();
 547         bool now_movie_play, now_movie_pause;
 548         int get_cur_capture_dev_index();
 549         int get_num_capture_devs();
 550         _TCHAR* get_capture_dev_name(int index);
 551         void open_capture_dev(int index, bool pin);
 552         void close_capture_dev();
 553         void show_capture_dev_filter();
 554         void show_capture_dev_pin();
 555         void show_capture_dev_source();
 556         void set_capture_dev_channel(int ch);
 557
 558         // common printer
 559         void create_bitmap(bitmap_t *bitmap, int width, int height);
 560         void release_bitmap(bitmap_t *bitmap);
 561         void create_font(font_t *font, const _TCHAR *family, int width, int height, int rotate, bool bold, bool italic);
 562         void release_font(font_t *font);
 563         void create_pen(pen_t *pen, int width, uint8_t r, uint8_t g, uint8_t b);
 564         void release_pen(pen_t *pen);
 565
 566         void clear_bitmap(bitmap_t *bitmap, uint8_t r, uint8_t g, uint8_t b);
 567         int get_text_width(bitmap_t *bitmap, font_t *font, const char *text);
 568
 569         void draw_text_to_bitmap(bitmap_t *bitmap, font_t *font, int x, int y, const _TCHAR *text, uint8_t r, uint8_t g, uint8_t b);
 570         void draw_line_to_bitmap(bitmap_t *bitmap, pen_t *pen, int sx, int sy, int ex, int ey);
 571         void draw_rectangle_to_bitmap(bitmap_t *bitmap, int x, int y, int width, int height, uint8_t r, uint8_t g, uint8_t b);
 572         void draw_point_to_bitmap(bitmap_t *bitmap, int x, int y, uint8_t r, uint8_t g, uint8_t b);
 573
 574         void stretch_bitmap(bitmap_t *dest, int dest_x, int dest_y, int dest_width, int dest_height, bitmap_t *source, int source_x, int source_y, int source_width, int source_height);
 575         void write_bitmap_to_file(bitmap_t *bitmap, const _TCHAR *file_path);
 576         double vm_frame_rate(void);
 577
 578         // common socket
 579         virtual SOCKET get_socket(int ch);
 580         virtual void notify_socket_connected(int ch);
 581         virtual void notify_socket_disconnected(int ch);
 582         virtual void update_socket();
 583         virtual bool initialize_socket_tcp(int ch);
 584         virtual bool initialize_socket_udp(int ch);
 585         virtual bool connect_socket(int ch, uint32_t ipaddr, int port);
 586         virtual void disconnect_socket(int ch);
 587         virtual bool listen_socket(int ch);
 588         virtual void send_socket_data_tcp(int ch);
 589         virtual void send_socket_data_udp(int ch, uint32_t ipaddr, int port);
 590         virtual void send_socket_data(int ch);
 591         virtual void recv_socket_data(int ch);
 592
 593         // common MIDI
 594         virtual void __FASTCALL send_to_midi(uint8_t data, int ch, double timestamp_usec);
 595         virtual bool __FASTCALL recv_from_midi(uint8_t* data, int ch, double timestamp_usec);
 596         virtual bool __FASTCALL send_to_midi_timeout(uint8_t data, int ch, uint64_t timeout_ms, double timestamp_usec);
 597         virtual bool __FASTCALL recv_from_midi_timeout(uint8_t* data, int ch, uint64_t timeout_ms, double timestamp_usec);
 598         // Note: Belows maybe make Qt SLOTs.
 599         virtual void __FASTCALL notify_timeout_sending_to_midi(int ch);
 600         virtual void __FASTCALL notify_timeout_receiving_from_midi(int ch);
 601
 602         virtual void reset_to_midi(int ch, double timestamp_usec);
 603         virtual void initialize_midi_device(bool handshake_from_midi, bool handshake_to_midi, int ch);
 604         virtual void __FASTCALL ready_receive_from_midi(int ch, double timestamp_usec);
 605         virtual void __FASTCALL ready_send_to_midi(int ch, double timestamp_usec);
 606
 607         virtual void __FASTCALL request_stop_to_receive_from_midi(int ch, double timestamp_usec);
 608         virtual void __FASTCALL request_stop_to_send_to_midi(int ch, double timestamp_usec);
 609
 610         // win32 dependent
 611         void update_screen();
 612         void set_parent_thread(EmuThreadClass *parent);
 613         EmuThreadClass *get_parent_handler();
 614
 615         _TCHAR *console_input_string(void);
 616         void clear_console_input_string(void);
 617
 618         void lock_vm(void);
 619         void unlock_vm(void);
 620         void force_unlock_vm(void);
 621         bool is_vm_locked(void);
 622         virtual const _TCHAR *get_lib_common_vm_version();
 623         const _TCHAR *get_lib_common_vm_git_version();
 624         const _TCHAR *get_lib_osd_version();
 625
 626         // Wrapper
 627         virtual void set_draw_thread(DrawThreadClass *handler);
 628         virtual QString get_vm_config_name(void);
 629         virtual void reset_vm_node(void);
 630
 631         void set_device_name(int id, char *name);
 632
 633         void set_vm_node(int id, const _TCHAR *name);
 634         const _TCHAR *get_vm_node_name(int id);
 635         int get_vm_node_size(void);
 636
 637         int get_key_name_table_size(void);
 638         uint32_t get_scancode_by_vk(uint32_t vk);
 639         uint32_t get_vk_by_scancode(uint32_t scancode);
 640         const _TCHAR *get_key_name_by_scancode(uint32_t scancode);
 641         const _TCHAR *get_key_name_by_vk(uint32_t vk);
 642
 643         // Get #define S to value.You may use inside of VM/ .
 644         virtual void set_features(void) {}
 645         void add_feature(const _TCHAR *key, double value);
 646         void add_feature(const _TCHAR *key, float value);
 647         void add_feature(const _TCHAR *key, int value = 1);
 648         void add_feature(const _TCHAR *key, int64_t value);
 649         void add_feature(const _TCHAR *key, int16_t value);
 650         void add_feature(const _TCHAR *key, int8_t value);
 651         void add_feature(const _TCHAR *key, uint64_t value);
 652         void add_feature(const _TCHAR *key, uint32_t value);
 653         void add_feature(const _TCHAR *key, uint16_t value);
 654         void add_feature(const _TCHAR *key, uint8_t value);
 655         bool check_feature(const _TCHAR *key);
 656         double get_feature_double_value(const _TCHAR *key);
 657         int get_feature_int_value(const _TCHAR *key);
 658         int64_t get_feature_int64_value(const _TCHAR *key);
 659         int32_t get_feature_int32_value(const _TCHAR *key);
 660         int16_t get_feature_int16_value(const _TCHAR *key);
 661         int8_t get_feature_int8_value(const _TCHAR *key);
 662
 663         uint64_t get_feature_uint64_value(const _TCHAR *key);
 664         uint32_t get_feature_uint32_value(const _TCHAR *key);
 665         uint16_t get_feature_uint16_value(const _TCHAR *key);
 666         uint8_t get_feature_uint8_value(const _TCHAR *key);
 667
 668         void debug_log(int level, const char *fmt, ...);
 669         void debug_log(int level, int domain_num, const char *fmt, ...);
 670         void debug_log(int level, int domain_num, char *strbuf);
 671         virtual double get_vm_current_usec() { return 0.0; }
 672         virtual uint64_t get_vm_current_clock_uint64() { return 0;}
 673
 674         std::shared_ptr<USING_FLAGS> get_config_flags(void) { return using_flags; }
 675         // Special
 676         std::shared_ptr<CSP_Logger> get_logger(void) { return p_logger; }
 677         virtual bool set_glview(GLDrawClass *glv) { /* Dummy */ return false;}
 678         QOpenGLContext *get_gl_context();
 679         virtual GLDrawClass *get_gl_view() { return NULL; }
 680
 681         // common debugger
 682         void start_waiting_in_debugger();
 683         void finish_waiting_in_debugger();
 684         void process_waiting_in_debugger();
 685
 686         // Messaging wrapper from EMU:: to OSD::
 687         void __FASTCALL string_message_from_emu(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t  message_type, _TCHAR* message);
 688         void __FASTCALL int_message_from_emu(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, int64_t data);
 689
 690 public slots:
 691         void enable_mouse();
 692         void disable_mouse();
 693         void toggle_mouse();
 694
 695         void upload_bitmap(QImage *p);
 696         void set_buttons();
 697
 698         int no_draw_screen();
 699
 700         void do_write_inputdata(QString s);
 701         void do_set_input_string(QString s);
 702
 703         void close_debugger_console();
 704         void do_close_debugger_thread();
 705
 706         void do_assign_js_setting(int jsnum, int axis_idx, int assigned_value);
 707         void do_start_record_video();
 708         virtual void do_decode_movie(int frames);
 709         void do_video_movie_end(bool flag);
 710         void do_video_decoding_error(int num);
 711         virtual void do_run_movie_audio_callback(uint8_t *data, long len);
 712         virtual int draw_screen();
 713
 714         void do_draw(bool flag);
 715
 716         void set_dbg_completion_list(std::list<std::string> *p);
 717         void clear_dbg_completion_list(void);
 718         void set_hdd_image_name(int drv, _TCHAR *filename);
 719
 720         void do_set_host_sound_output_device(QString device_name);
 721         void do_update_master_volume(int level);
 722
 723 signals:
 724         int sig_update_screen(void *, bool);
 725         int sig_save_screen(const char *);
 726         int sig_draw_frames(int);
 727         int sig_close_window(void);
 728         int sig_resize_vm_screen(QImage *, int, int);
 729         int sig_resize_vm_lines(int);
 730         int sig_put_string_debugger(QString);
 731         int sig_console_input_string(QString);
 732         int sig_enqueue_video(int, int, int, QImage *);
 733         int sig_enqueue_audio(int16_t *data, int size);
 734         int sig_movie_set_width(int);
 735         int sig_movie_set_height(int);
 736         int sig_debugger_finished();
 737         int sig_req_encueue_video(int, int, int);
 738         int sig_save_as_movie(QString, int, int);
 739         int sig_stop_saving_movie();
 740
 741         int sig_movie_play();
 742         int sig_movie_stop();
 743         int sig_movie_pause(bool);
 744         int sig_movie_seek_frame(bool, int);
 745
 746         int sig_set_sound_device(QString);
 747         int sig_set_sound_volume(double);
 748         int sig_set_sound_volume(int);
 749
 750         int sig_update_sound_output_list();
 751         int sig_clear_sound_output_list();
 752         int sig_append_sound_output_list(QString);
 753
 754         int sig_update_device_node_name(int id, const _TCHAR *name);
 755         int sig_enable_mouse(void);
 756         int sig_disable_mouse(void);
 757         int sig_close_console(void);
 758         int sig_set_attribute_debugger(QString, bool);
 759         int sig_move_mouse_to_center(void);
 760         int sig_clear_dbg_completion_list(void);
 761         int sig_add_dbg_completion_list(_TCHAR *);
 762         int sig_apply_dbg_completion_list(void);
 763
 764         int sig_clear_keyname_table(void);
 765         int sig_add_keyname_table(uint32_t, QString);
 766
 767         int sig_change_virtual_media(int, int, QString);
 768
 769         int sig_notify_power_off(void); // To GUI 20230120 K.O
 770
 771         // To GUI 20230125 K.O
 772         int sig_ui_floppy_insert_history(int, QString, quint64);
 773 };
 774
 775 QT_END_NAMESPACE
 776
 777 #endif