source/src/qt/osd_base.cpp

   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 //#include "emu.h"
  11 #include <string>
  12
  13 #include <QObject>
  14 #include <QWidget>
  15
  16 #include <QMutex>
  17 #include <QSemaphore>
  18 #include <QPainter>
  19 #include <QElapsedTimer>
  20 #include <QQueue>
  21
  22 #include <QDateTime>
  23 #include <QDate>
  24 #include <QTime>
  25 #include <QString>
  26 #include <QObject>
  27 #include <QThread>
  28 #include <QMutex>
  29
  30 #include "simd_types.h"
  31
  32 #include <ctime>
  33 #include <limits>
  34
  35 #include "../config.h"
  36 #include "../fileio.h"
  37 #include "../fifo.h"
  38 #include "qt_input.h"
  39 #include "qt_gldraw.h"
  40 //#include "qt_main.h"
  41 //#include "csp_logger.h"
  42 #include "osd_base.h"
  43
  44 OSD_BASE::OSD_BASE(USING_FLAGS *p, CSP_Logger *logger) : QThread(0)
  45 {
  46         using_flags = p;
  47         vm_mutex = new QMutex(QMutex::Recursive);
  48         locked_vm = false;
  49         screen_mutex = new QMutex(QMutex::Recursive);
  50         device_node_list.clear();
  51         max_vm_nodes = 0;
  52         p_logger = logger;
  53
  54         mapped_screen_pointer = NULL;
  55         mapped_screen_width = 0;
  56         mapped_screen_height = 0;
  57         mapped_screen_status = false;
  58         SupportedFeatures.clear();
  59 }
  60
  61 OSD_BASE::~OSD_BASE()
  62 {
  63         delete vm_mutex;
  64         delete screen_mutex;
  65 }
  66
  67 extern std::string cpp_homedir;
  68 extern std::string my_procname;
  69
  70 EmuThreadClass *OSD_BASE::get_parent_handler()
  71 {
  72         return parent_thread;
  73 }
  74
  75 void OSD_BASE::set_parent_thread(EmuThreadClass *parent)
  76 {
  77         parent_thread = parent;
  78 }
  79
  80 void OSD_BASE::initialize(int rate, int samples)
  81 {
  82 }
  83
  84 void OSD_BASE::release()
  85 {
  86 }
  87
  88 void OSD_BASE::power_off()
  89 {
  90 }
  91
  92 void OSD_BASE::suspend()
  93 {
  94         if(get_use_movie_player()) {
  95                 if(now_movie_play && !now_movie_pause) {
  96                         pause_movie();
  97                         now_movie_pause = false;
  98                 }
  99         }
 100         mute_sound();
 101 }
 102
 103 void OSD_BASE::restore()
 104 {
 105         if(get_use_movie_player()) {
 106                 if(now_movie_play && !now_movie_pause) {
 107                         play_movie();
 108                 }
 109         }
 110 }
 111
 112
 113 void OSD_BASE::debug_log(int level, const char *fmt, ...)
 114 {
 115         char strbuf[4096];
 116         va_list ap;
 117
 118         va_start(ap, fmt);
 119         vsnprintf(strbuf, 4095, fmt, ap);
 120         debug_log(level, 0, strbuf);
 121         va_end(ap);
 122 }
 123
 124 void OSD_BASE::debug_log(int level, int domain_num, const char *fmt, ...)
 125 {
 126         char strbuf[4096];
 127         va_list ap;
 128
 129         va_start(ap, fmt);
 130         vsnprintf(strbuf, 4095, fmt, ap);
 131         debug_log(level, domain_num, strbuf);
 132         va_end(ap);
 133 }
 134
 135 void OSD_BASE::debug_log(int level, int domain_num, char *strbuf)
 136 {
 137 }
 138
 139 _TCHAR *OSD_BASE::get_app_path(void)
 140 {
 141         return app_path;
 142 }
 143
 144 _TCHAR* OSD_BASE::bios_path(const _TCHAR* file_name)
 145 {
 146         static _TCHAR file_path[_MAX_PATH];
 147         snprintf((char *)file_path, _MAX_PATH, "%s%s", app_path, (const char *)file_name);
 148         debug_log(CSP_LOG_INFO, CSP_LOG_TYPE_OSD, "BIOS PATH:%s", file_path);
 149         return file_path;
 150 }
 151
 152 void OSD_BASE::get_host_time(cur_time_t* time)
 153 {
 154         //SYSTEMTIME sTime;
 155         //GetLocalTime(&sTime);
 156         QDateTime nowTime = QDateTime::currentDateTime();
 157         QDate d = nowTime.date();
 158         QTime t = nowTime.time();
 159
 160         time->year = d.year();
 161         time->month = d.month();
 162         time->day = d.day();
 163         time->day_of_week = d.dayOfWeek();
 164         time->hour = t.hour();
 165         time->minute = t.minute();
 166         time->second = t.second();
 167 }
 168
 169 void OSD_BASE::sleep(uint32_t ms)
 170 {
 171         QThread::msleep(ms);
 172 }
 173
 174 void OSD_BASE::create_date_file_name(_TCHAR *name, int length, const _TCHAR *extension)
 175 {
 176         QDateTime nowTime = QDateTime::currentDateTime();
 177         QString tmps = QString::fromUtf8("emu");
 178         tmps = tmps + get_vm_config_name();
 179         tmps = tmps + QString::fromUtf8("_");
 180         tmps = tmps + nowTime.toString(QString::fromUtf8("yyyy-MM-dd_hh-mm-ss.zzz."));
 181         tmps = tmps + QString::fromUtf8((const char *)extension);
 182         snprintf((char *)name, length, "%s", tmps.toLocal8Bit().constData());
 183 }
 184
 185 _TCHAR* OSD_BASE::application_path()
 186 {
 187         return app_path;
 188 }
 189
 190 void OSD_BASE::vm_draw_screen(void)
 191 {
 192
 193 }
 194
 195 double OSD_BASE::vm_frame_rate(void)
 196 {
 197         return 59.94;
 198 }
 199
 200 Sint16* OSD_BASE::create_sound(int *extra_frames)
 201 {
 202         return (Sint16 *)NULL;
 203 }
 204
 205
 206 bool OSD_BASE::get_use_socket(void)
 207 {
 208         return false;
 209 }
 210 bool OSD_BASE::get_support_variable_timing(void)
 211 {
 212         return false;
 213 }
 214
 215 bool OSD_BASE::get_notify_key_down(void)
 216 {
 217         return false;
 218 }
 219
 220 bool OSD_BASE::get_notify_key_down_lr_shift(void)
 221 {
 222         return false;
 223 }
 224
 225 bool OSD_BASE::get_notify_key_down_lr_control(void)
 226 {
 227         return false;
 228 }
 229
 230 bool OSD_BASE::get_notify_key_down_lr_menu(void)
 231 {
 232         return false;
 233 }
 234
 235 bool OSD_BASE::get_use_shift_numpad_key(void)
 236 {
 237         return false;
 238 }
 239
 240 bool OSD_BASE::get_use_auto_key(void)
 241 {
 242         return false;
 243 }
 244
 245 bool OSD_BASE::get_dont_keeep_key_pressed(void)
 246 {
 247         return false;
 248 }
 249
 250 bool OSD_BASE::get_one_board_micro_computer(void)
 251 {
 252         return false;
 253 }
 254
 255 bool OSD_BASE::get_use_screen_rotate(void)
 256 {
 257         return false;
 258 }
 259
 260 bool OSD_BASE::get_use_movie_player(void)
 261 {
 262         return false;
 263 }
 264
 265 bool OSD_BASE::get_use_video_capture(void)
 266 {
 267         return false;
 268 }
 269
 270 void OSD_BASE::vm_key_down(int code, bool flag)
 271 {
 272 }
 273
 274 void OSD_BASE::vm_key_up(int code)
 275 {
 276 }
 277
 278 void OSD_BASE::vm_reset(void)
 279 {
 280
 281 }
 282
 283 int OSD_BASE::get_vm_buttons_code(int num)
 284 {
 285         return 0;
 286 }
 287
 288 void OSD_BASE::update_buttons(bool press_flag, bool release_flag)
 289 {
 290 }
 291
 292 QString OSD_BASE::get_vm_config_name(void)
 293 {
 294         return QString::fromUtf8(" ");
 295 }
 296
 297 int OSD_BASE::get_screen_width(void)
 298 {
 299         return 320;
 300 }
 301
 302 int OSD_BASE::get_screen_height(void)
 303 {
 304         return 200;
 305 }
 306
 307 void OSD_BASE::lock_vm(void)
 308 {
 309         locked_vm = true;
 310 }
 311
 312 void OSD_BASE::unlock_vm(void)
 313 {
 314         locked_vm = false;
 315 }
 316
 317
 318 bool OSD_BASE::is_vm_locked(void)
 319 {
 320         return locked_vm;
 321 }
 322
 323 void OSD_BASE::force_unlock_vm(void)
 324 {
 325 }
 326
 327 void OSD_BASE::set_draw_thread(DrawThreadClass *handler)
 328 {
 329 }
 330
 331 void OSD_BASE::initialize_screen()
 332 {
 333         first_draw_screen = false;
 334         first_invalidate = true;
 335         self_invalidate = false;
 336 }
 337
 338 void OSD_BASE::release_screen()
 339 {
 340 }
 341
 342 int OSD_BASE::get_window_mode_width(int mode)
 343 {
 344         return 640;
 345 }
 346
 347 int OSD_BASE::get_window_mode_height(int mode)
 348 {
 349         return 200;
 350 }
 351
 352 void OSD_BASE::reset_vm_node(void)
 353 {
 354         device_node_list.clear();
 355 //      p_logger->reset();
 356         max_vm_nodes = 0;
 357 }
 358
 359 void OSD_BASE::set_device_name(int id, char *name)
 360 {
 361 }
 362
 363 void OSD_BASE::set_vm_node(int id, const _TCHAR *name)
 364 {
 365         device_node_t sp;
 366         int i;
 367         for(i = 0; i < device_node_list.size(); i++) {
 368                 sp = device_node_list.at(i);
 369                 if(id == sp.id) {
 370                         sp.id = id;
 371                         sp.name = name;
 372                         set_device_name(id, (char *)name);
 373                         device_node_list.replace(i, sp);
 374                         if(id >= max_vm_nodes) max_vm_nodes = id + 1;
 375                         return;
 376                 }
 377         }
 378         // Not Found
 379         sp.id = id;
 380         sp.name = name;
 381         set_device_name(id, (char *)name);
 382         device_node_list.append(sp);
 383         if(id >= max_vm_nodes) max_vm_nodes = id + 1;
 384 }
 385
 386 const _TCHAR *OSD_BASE::get_vm_node_name(int id)
 387 {
 388         int i;
 389         device_node_t sp;
 390         for(i = 0; i < device_node_list.size(); i++) {
 391                 sp = device_node_list.at(i);
 392                 if(id == sp.id) {
 393                         return sp.name;
 394                 }
 395         }
 396         return NULL;
 397 }
 398
 399 int OSD_BASE::get_vm_node_size(void)
 400 {
 401         return max_vm_nodes;
 402 }
 403
 404 void OSD_BASE::add_feature(const _TCHAR *key, double value)
 405 {
 406         QString tmps;
 407         supportedlist_t l;
 408         tmps = QString::fromUtf8(key);
 409         if(!check_feature(key)) {
 410                 l.string = tmps;
 411                 l.v.fvalue = value;
 412                 SupportedFeatures.append(l);
 413         }
 414 }
 415 void OSD_BASE::add_feature(const _TCHAR *key, int64_t value)
 416 {
 417         QString tmps;
 418         supportedlist_t l;
 419         tmps = QString::fromUtf8(key);
 420         if(!check_feature(key)) {
 421                 l.string = tmps;
 422                 l.v.ivalue = value;
 423                 SupportedFeatures.append(l);
 424         }
 425 }
 426
 427 void OSD_BASE::add_feature(const _TCHAR *key, float value)
 428 {
 429         add_feature(key, (double)value);
 430 }
 431
 432 void OSD_BASE::add_feature(const _TCHAR *key, int value)
 433 {
 434         add_feature(key, (int64_t)value);
 435 }
 436
 437 void OSD_BASE::add_feature(const _TCHAR *key, uint32_t value)
 438 {
 439         add_feature(key, (int64_t)(value & 0xffffffff));
 440 }
 441
 442 void OSD_BASE::add_feature(const _TCHAR *key, uint16_t value)
 443 {
 444         add_feature(key, (int64_t)(value & 0xffff));
 445 }
 446
 447 void OSD_BASE::add_feature(const _TCHAR *key, uint8_t value)
 448 {
 449         add_feature(key, (int64_t)(value & 0xff));
 450 }
 451
 452
 453 bool OSD_BASE::check_feature(const _TCHAR *key)
 454 {
 455         QString tmps;
 456         supportedlist_t l;
 457         tmps = QString::fromUtf8(key);
 458         for(int i = 0; i < SupportedFeatures.size(); i++) {
 459                 l = SupportedFeatures.at(i);
 460                 if(l.string == tmps) {
 461                         return true;
 462                 }
 463         }
 464         return false;
 465 }
 466
 467 double OSD_BASE::get_feature_double_value(const _TCHAR *key)
 468 {
 469         QString tmps;
 470         supportedlist_t l;
 471         tmps = QString::fromUtf8(key);
 472         for(int i = 0; i < SupportedFeatures.size(); i++) {
 473                 l = SupportedFeatures.at(i);
 474                 if(l.string == tmps) {
 475                         return l.v.fvalue;
 476                 }
 477         }
 478         return std::numeric_limits<double>::quiet_NaN(); // You don't use (0.0 / 0.0).
 479 }
 480
 481 int64_t OSD_BASE::get_feature_int_value(const _TCHAR *key)
 482 {
 483         QString tmps;
 484         supportedlist_t l;
 485         tmps = QString::fromUtf8(key);
 486         for(int i = 0; i < SupportedFeatures.size(); i++) {
 487                 l = SupportedFeatures.at(i);
 488                 if(l.string == tmps) {
 489                         return l.v.ivalue;
 490                 }
 491         }
 492         return 0;
 493 }
 494
 495 uint32_t OSD_BASE::get_feature_uint32_value(const _TCHAR *key)
 496 {
 497         return (uint32_t)(get_feature_int_value(key) & 0xffffffff);
 498 }
 499
 500 uint16_t OSD_BASE::get_feature_uint16_value(const _TCHAR *key)
 501 {
 502         return (uint16_t)(get_feature_uint32_value(key) & 0xffff);
 503 }
 504
 505 uint8_t OSD_BASE::get_feature_uint8_value(const _TCHAR *key)
 506 {
 507         return (uint8_t)(get_feature_uint32_value(key) & 0xff);
 508 }
 509
 510
 511