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