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