source/src/qt/osd_wrapper.cpp

   1 /*
   2         Skelton for retropc emulator
   3
   4         Author : K.Ohta <whatisthis.sowhat _at_ gmail.com>
   5         Date   : 2015.11.30-
   6
   7         [ VM/OSD Wrapper ]
   8 */
   9
  10 #include <QImage>
  11 #include <QPainter>
  12 #include <QColor>
  13 #include <QPen>
  14 #include <QPoint>
  15 #include <QTextCodec>
  16
  17 #include "osd.h"
  18 #include "../vm/vm.h"
  19 #include "../vm/device.h"
  20
  21 #include "emu.h"
  22
  23 #include "emu_thread.h"
  24 #include "draw_thread.h"
  25 #if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
  26 #include "avio/movie_loader.h"
  27 #endif
  28
  29 #include "qt_gldraw.h"
  30 #include "csp_logger.h"
  31
  32 void OSD::vm_draw_screen(void)
  33 {
  34         vm->draw_screen();
  35 }
  36
  37 double OSD::vm_frame_rate(void)
  38 {
  39 #ifdef SUPPORT_VARIABLE_TIMING
  40         return vm->get_frame_rate();
  41 #else
  42         return FRAMES_PER_SEC;
  43 #endif
  44 }
  45
  46 Sint16* OSD::create_sound(int *extra_frames)
  47 {
  48         return (Sint16 *)vm->create_sound(extra_frames);
  49 }
  50
  51
  52 bool OSD::get_use_socket(void)
  53 {
  54 #ifdef USE_SOCKET
  55         return true;
  56 #else
  57         return false;
  58 #endif
  59 }
  60
  61 bool OSD::get_support_variable_timing(void)
  62 {
  63 #ifdef SUPPORT_VARIABLE_TIMING
  64         return true;
  65 #else
  66         return false;
  67 #endif
  68 }
  69
  70 bool OSD::get_notify_key_down(void)
  71 {
  72 #ifdef NOTIFY_KEY_DOWN
  73         return true;
  74 #else
  75         return false;
  76 #endif
  77 }
  78
  79 bool OSD::get_notify_key_down_lr_shift(void)
  80 {
  81 #ifdef NOTIFY_KEY_DOWN_LR_SHIFT
  82         return true;
  83 #else
  84         return false;
  85 #endif
  86 }
  87
  88 bool OSD::get_notify_key_down_lr_control(void)
  89 {
  90 #ifdef NOTIFY_KEY_DOWN_LR_CONTROL
  91         return true;
  92 #else
  93         return false;
  94 #endif
  95 }
  96
  97 bool OSD::get_notify_key_down_lr_menu(void)
  98 {
  99 #ifdef NOTIFY_KEY_DOWN_LR_MEHU
 100         return true;
 101 #else
 102         return false;
 103 #endif
 104 }
 105
 106 bool OSD::get_use_shift_numpad_key(void)
 107 {
 108 #ifdef USE_SHIFT_NUMPAD_KEY
 109         return true;
 110 #else
 111         return false;
 112 #endif
 113 }
 114
 115 bool OSD::get_use_auto_key(void)
 116 {
 117 #ifdef USE_AUTO_KEY
 118         return true;
 119 #else
 120         return false;
 121 #endif
 122 }
 123
 124 bool OSD::get_dont_keeep_key_pressed(void)
 125 {
 126 #ifdef DONT_KEEEP_KEY_PRESSED
 127         return true;
 128 #else
 129         return false;
 130 #endif
 131 }
 132
 133 bool OSD::get_one_board_micro_computer(void)
 134 {
 135 #ifdef ONE_BOARD_MICRO_COMPUTER
 136         return true;
 137 #else
 138         return false;
 139 #endif
 140 }
 141
 142 bool OSD::get_use_screen_rotate(void)
 143 {
 144 #ifdef USE_SCREEN_ROTATE
 145         return true;
 146 #else
 147         return false;
 148 #endif
 149 }
 150
 151 bool OSD::get_use_movie_player(void)
 152 {
 153 #ifdef USE_MOVIE_PLAYER
 154         return true;
 155 #else
 156         return false;
 157 #endif
 158 }
 159
 160 bool OSD::get_use_video_capture(void)
 161 {
 162 #ifdef USE_VIDEO_CAPTURE
 163         return true;
 164 #else
 165         return false;
 166 #endif
 167 }
 168
 169 void OSD::vm_key_down(int code, bool flag)
 170 {
 171 #ifdef NOTIFY_KEY_DOWN
 172         vm->key_down(code, flag);
 173 #endif
 174 }
 175
 176 void OSD::vm_key_up(int code)
 177 {
 178 #ifdef NOTIFY_KEY_DOWN
 179         vm->key_up(code);
 180 #endif
 181 }
 182
 183 void OSD::vm_reset(void)
 184 {
 185         vm->reset();
 186 }
 187
 188 int OSD::get_vm_buttons_code(int num)
 189 {
 190 #ifdef ONE_BOARD_MICRO_COMPUTER
 191         if(num < 0) return 0;
 192         return vm_buttons[num].code;
 193 #else
 194         return 0;
 195 #endif
 196 }
 197
 198 void OSD::update_buttons(bool press_flag, bool release_flag)
 199 {
 200 #if defined(MAX_BUTTONS)
 201         if(!press_flag && !release_flag) {
 202                 int ii;
 203                 ii = 0;
 204                 for(ii = 0; vm_buttons[ii].code != 0x00; ii++) {
 205                         if((mouse_ptrx >= vm_buttons[ii].x) && (mouse_ptrx < (vm_buttons[ii].x + vm_buttons[ii].width))) {
 206                                 if((mouse_ptry >= vm_buttons[ii].y) && (mouse_ptry < (vm_buttons[ii].y + vm_buttons[ii].height))) {
 207                                         if((key_status[vm_buttons[ii].code] & 0x7f) == 0) this->press_button(ii);
 208                                 }
 209                         }
 210                 }
 211                 if((mouse_ptrx >= vm_buttons[ii].x) && (mouse_ptrx < (vm_buttons[ii].x + vm_buttons[ii].width))) {
 212                         if((mouse_ptry >= vm_buttons[ii].y) && (mouse_ptry < (vm_buttons[ii].y + vm_buttons[ii].height))) {
 213                                 this->press_button(ii);
 214                         }
 215                 }
 216                 mouse_ptrx = mouse_ptry = 0;
 217         }
 218         //return;
 219 #endif
 220 }
 221
 222 QString OSD::get_vm_config_name(void)
 223 {
 224 #if defined(CONFIG_NAME)
 225         return QString::fromUtf8(CONFIG_NAME);
 226 #else
 227         return QString::fromUtf8(" ");
 228 #endif
 229 }
 230
 231 int OSD::get_screen_width(void)
 232 {
 233         return SCREEN_WIDTH;
 234 }
 235
 236 int OSD::get_screen_height(void)
 237 {
 238         return SCREEN_HEIGHT;
 239 }
 240
 241 void OSD::lock_vm(void)
 242 {
 243         locked_vm = true;
 244         if(parent_thread != NULL) {
 245                 if(!parent_thread->now_debugging()) VMSemaphore->acquire(1);
 246         } else {
 247                 VMSemaphore->acquire(1);
 248         }
 249 }
 250
 251 void OSD::unlock_vm(void)
 252 {
 253         if(parent_thread != NULL) {
 254                 if(!parent_thread->now_debugging()) VMSemaphore->release(1);
 255         } else {
 256                 VMSemaphore->release(1);
 257         }
 258         locked_vm = false;
 259 }
 260
 261
 262 bool OSD::is_vm_locked(void)
 263 {
 264         return locked_vm;
 265 }
 266
 267 void OSD::force_unlock_vm(void)
 268 {
 269         if(parent_thread == NULL) {
 270                 while(VMSemaphore->available() < 1) VMSemaphore->release(1);
 271                 locked_vm = false;
 272                 return;
 273         }
 274         if(parent_thread->now_debugging()) {
 275                 locked_vm = false;
 276                 return;
 277         }
 278         while(VMSemaphore->available() < 1) VMSemaphore->release(1);
 279         locked_vm = false;
 280 }
 281
 282 void OSD::set_draw_thread(DrawThreadClass *handler)
 283 {
 284         this->moveToThread(handler);
 285         connect(this, SIGNAL(sig_update_screen(bitmap_t *)), handler, SLOT(do_update_screen(bitmap_t *)));
 286         connect(this, SIGNAL(sig_save_screen(const char *)), glv, SLOT(do_save_frame_screen(const char *)));
 287         connect(this, SIGNAL(sig_resize_vm_screen(QImage *, int, int)), glv, SLOT(do_set_texture_size(QImage *, int, int)));
 288         connect(parent_thread, SIGNAL(sig_debugger_input(QString)), this, SLOT(do_set_input_string(QString)));
 289         connect(parent_thread, SIGNAL(sig_quit_debugger()), this, SLOT(do_close_debugger_thread()));
 290         connect(this, SIGNAL(sig_close_window()), parent_thread, SLOT(doExit()));
 291         connect(this, SIGNAL(sig_console_input_string(QString)), parent_thread, SLOT(do_call_debugger_command(QString)));
 292 }
 293
 294 void OSD::initialize_screen()
 295 {
 296         host_window_width = base_window_width = WINDOW_WIDTH;
 297         host_window_height = base_window_height = WINDOW_HEIGHT;
 298         host_window_mode = true;
 299
 300         vm_screen_width = SCREEN_WIDTH;
 301         vm_screen_height = SCREEN_HEIGHT;
 302         vm_window_width = WINDOW_WIDTH;
 303         vm_window_height = WINDOW_HEIGHT;
 304         vm_window_width_aspect = WINDOW_WIDTH_ASPECT;
 305         vm_window_height_aspect = WINDOW_HEIGHT_ASPECT;
 306
 307         QColor col(0, 0, 0, 255);
 308
 309         vm_screen_buffer.width = SCREEN_WIDTH;
 310         vm_screen_buffer.height = SCREEN_HEIGHT;
 311         vm_screen_buffer.pImage = QImage(SCREEN_WIDTH, SCREEN_HEIGHT, QImage::Format_ARGB32);
 312         vm_screen_buffer.pImage.fill(col);
 313         now_record_video = false;
 314
 315         first_draw_screen = false;
 316         first_invalidate = true;
 317         self_invalidate = false;
 318 }
 319
 320 void OSD::release_screen()
 321 {
 322         stop_record_video();
 323         release_screen_buffer(&vm_screen_buffer);
 324 }
 325
 326 int OSD::get_window_mode_width(int mode)
 327 {
 328         if(get_use_screen_rotate()) {
 329                 if(p_config->rotate_type == 1 || p_config->rotate_type == 3) {
 330                         return (p_config->window_stretch_type == 0 ? vm_window_height : vm_window_height_aspect) * (mode + WINDOW_MODE_BASE);
 331                 }
 332         }
 333         return (p_config->window_stretch_type == 0 ? vm_window_width : vm_window_width_aspect) * (mode + WINDOW_MODE_BASE);
 334 }
 335
 336 int OSD::get_window_mode_height(int mode)
 337 {
 338         if(get_use_screen_rotate()) {
 339                 if(p_config->rotate_type == 1 || p_config->rotate_type == 3) {
 340                         return (p_config->window_stretch_type == 0 ? vm_window_width : vm_window_width_aspect) * (mode + WINDOW_MODE_BASE);
 341                 }
 342         }
 343         return (p_config->window_stretch_type == 0 ? vm_window_height : vm_window_height_aspect) * (mode + WINDOW_MODE_BASE);
 344 }
 345
 346 void OSD::initialize_video()
 347 {
 348         movie_loader = NULL;
 349 #if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
 350         movie_loader = new MOVIE_LOADER(this, &config);
 351         //connect(movie_loader, SIGNAL(sig_send_audio_frame(uint8_t *, long)), this, SLOT(do_run_movie_audio_callback2(uint8_t *, long)));
 352         connect(movie_loader, SIGNAL(sig_movie_end(bool)), this, SLOT(do_video_movie_end(bool)));
 353         connect(this, SIGNAL(sig_movie_play(void)), movie_loader, SLOT(do_play()));
 354         connect(this, SIGNAL(sig_movie_stop(void)), movie_loader, SLOT(do_stop()));
 355         connect(this, SIGNAL(sig_movie_pause(bool)), movie_loader, SLOT(do_pause(bool)));
 356         connect(this, SIGNAL(sig_movie_seek_frame(bool, int)), movie_loader, SLOT(do_seek_frame(bool, int)));
 357         //connect(this, SIGNAL(sig_movie_mute(bool, bool)), movie_loader, SLOT(do_mute(bool, bool)));
 358         connect(movie_loader, SIGNAL(sig_decoding_error(int)), this, SLOT(do_video_decoding_error(int)));
 359 #endif
 360 }
 361
 362 void OSD::release_video()
 363 {
 364 #if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
 365         delete movie_loader;
 366 #endif
 367         movie_loader = NULL;
 368 }
 369
 370
 371 bool OSD::open_movie_file(const _TCHAR* file_path)
 372 {
 373         bool ret = false;
 374         if(file_path == NULL) return ret;
 375 #if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
 376         if(movie_loader != NULL) {
 377                 ret = movie_loader->open(QString::fromUtf8(file_path));
 378         }
 379 #endif
 380         return ret;
 381 }
 382
 383 void OSD::close_movie_file()
 384 {
 385 #if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
 386         if(movie_loader != NULL) {
 387                 movie_loader->close();
 388         }
 389 #endif
 390         now_movie_play = false;
 391         now_movie_pause = false;
 392 }
 393
 394 #include <limits.h>
 395 uint32_t OSD::get_cur_movie_frame()
 396 {
 397         uint64_t pos;
 398 #if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
 399         if(movie_loader != NULL) {
 400                 pos = movie_loader->get_current_frame();
 401                 if(pos > UINT_MAX) {
 402                         return UINT_MAX;
 403                 }
 404                 return (uint32_t)pos;
 405         }
 406 #endif
 407         return 0;
 408 }
 409
 410 void OSD::do_run_movie_audio_callback(uint8_t *data, long len)
 411 {
 412         if(data == NULL) return;
 413 #if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
 414 #if defined(_PX7)
 415         {
 416                 lock_vm();
 417                 this->vm->movie_sound_callback(data, len);
 418                 unlock_vm();
 419         }
 420 #endif
 421 #endif
 422         free(data);
 423 }
 424
 425 void OSD::do_decode_movie(int frames)
 426 {
 427 #if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
 428         movie_loader->do_decode_frames(frames, this->get_vm_window_width(), this->get_vm_window_height());
 429 #endif
 430 }
 431
 432 void OSD::get_video_buffer()
 433 {
 434 #if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
 435         //movie_loader->do_decode_frames(1, this->get_vm_window_width(), this->get_vm_window_height());
 436         movie_loader->get_video_frame();
 437         //printf("**\n");
 438 #endif
 439 }
 440
 441 int OSD::get_movie_sound_rate()
 442 {
 443 #if defined(USE_MOVIE_PLAYER) || defined(USE_VIDEO_CAPTURE)
 444         return movie_loader->get_movie_sound_rate();
 445 #endif
 446 }
 447
 448 void OSD::reset_vm_node()
 449 {
 450         device_node_t sp;
 451         device_node_list.clear();
 452         max_vm_nodes = 0;
 453         for(DEVICE *p = vm->first_device; p != NULL; p = p->next_device) {
 454                 sp.id = p->this_device_id;
 455                 sp.name = p->this_device_name;
 456                 csp_logger->debug_log(CSP_LOG_DEBUG, CSP_LOG_TYPE_GENERAL,  "Device %d :%s", sp.id, sp.name);
 457                 device_node_list.append(sp);
 458                 if(max_vm_nodes <= p->this_device_id) max_vm_nodes = p->this_device_id + 1;
 459         }
 460         for(DEVICE *p = vm->first_device; p != NULL; p = p->next_device) {
 461                 emit sig_update_device_node_name(p->this_device_id, p->this_device_name);
 462         }
 463 }
 464
 465 #if defined(USE_SOCKET)
 466 #include <QHostAddress>
 467 #include "osd_socket.h"
 468 #endif
 469 // Socket
 470 void OSD::initialize_socket()
 471 {
 472         for(int i = 0; i < SOCKET_MAX; i++) {
 473                 tcp_socket[i] = NULL;
 474                 udp_socket[i] = NULL;
 475                 is_tcp[i] = false;
 476                 socket_delay[i] = 0;
 477                 host_mode[i] = false;
 478         }
 479 }
 480
 481 void OSD::release_socket()
 482 {
 483         // release sockets
 484 #ifdef USE_SOCKET
 485         for(int i = 0; i < SOCKET_MAX; i++) {
 486                 if(tcp_socket[i] != NULL) {
 487                         if(tcp_socket[i]->isOpen()) tcp_socket[i]->close();
 488                         delete tcp_socket[i];
 489                         tcp_socket[i] = NULL;
 490                 }
 491                 if(udp_socket[i] != NULL) {
 492                         if(udp_socket[i]->isOpen()) udp_socket[i]->close();
 493                         delete udp_socket[i];
 494                         udp_socket[i] = NULL;
 495                 }
 496         }
 497 #endif
 498 }
 499
 500
 501 void OSD::notify_socket_connected(int ch)
 502 {
 503         do_notify_socket_connected(ch);
 504 }
 505
 506 void OSD::do_notify_socket_connected(int ch)
 507 {
 508 #ifdef USE_SOCKET
 509         vm->notify_socket_connected(ch);
 510 #endif
 511 }
 512
 513
 514 void OSD::notify_socket_disconnected(int ch)
 515 {
 516         do_notify_socket_disconnected(ch);
 517 }
 518
 519
 520 void OSD::do_notify_socket_disconnected(int ch)
 521 {
 522         if(!socket_delay[ch]) {
 523                 socket_delay[ch] = 1;//56;
 524         }
 525 }
 526
 527 // Called per 1 frame.
 528 void OSD::update_socket()
 529 {
 530 #ifdef USE_SOCKET
 531         qint64 bytes;
 532         for(int i = 0; i < SOCKET_MAX; i++) {
 533                 QIODevice *p = NULL;
 534                 if(is_tcp[i]) {
 535                         if(tcp_socket[i] != NULL) {
 536                                 if(tcp_socket[i]->isOpen()) {
 537                                         p = tcp_socket[i];
 538                                 }
 539                         }
 540                 } else {
 541                         if(udp_socket[i] != NULL) {
 542                                 if(udp_socket[i]->isOpen()) {
 543                                         p = udp_socket[i];
 544                                 }
 545                         }
 546                 }
 547                 if(p != NULL) {
 548                         // recv
 549                         bytes = p->bytesAvailable();
 550                         if(bytes > 0) {
 551                                 int size0, size1;
 552                                 uint8_t* buf0 = vm->get_socket_recv_buffer0(i, &size0, &size1);
 553                                 uint8_t* buf1 = vm->get_socket_recv_buffer1(i);
 554                                 qint64 size;
 555
 556                                 if(bytes > (qint64)(size0 + size1)) {
 557                                         bytes = (qint64)(size0 + size1);
 558                                 }
 559                                 QByteArray src = p->read(bytes);
 560
 561                                 size = src.size();
 562                                 uint8_t *pp = (uint8_t *)(src.constData());
 563                                 if(size <= (qint64)size0) {
 564                                         memcpy(buf0, pp, size);
 565                                 } else {
 566                                         memcpy(buf0, pp, size0);
 567                                         memcpy(buf1, pp + size0, (int)size - size0);
 568                                 }
 569                                 vm->inc_socket_recv_buffer_ptr(i, (int)size);
 570                         } else if(socket_delay[i] != 0) {
 571                                 if(--socket_delay[i] == 0) {
 572                                         vm->notify_socket_disconnected(i);
 573                                 }
 574                         }
 575                 }
 576         }
 577 #endif
 578 }
 579
 580 bool OSD::initialize_socket_tcp(int ch)
 581 {
 582 #ifdef USE_SOCKET
 583         if(udp_socket[ch] != NULL) {
 584                 if(udp_socket[ch]->isOpen()) {
 585                         udp_socket[ch]->close();
 586                 }
 587                 delete udp_socket[ch];
 588                 udp_socket[ch] = NULL;
 589         }
 590         if(tcp_socket[ch] != NULL) {
 591                 if(tcp_socket[ch]->isOpen()) tcp_socket[ch]->close();
 592                 delete tcp_socket[ch];
 593         }
 594         is_tcp[ch] = true;
 595         tcp_socket[ch] = new QTcpSocket2(ch);
 596         if(tcp_socket[ch] == NULL) return false;
 597         tcp_socket[ch]->setChannel(ch);
 598         connect(tcp_socket[ch], SIGNAL(connected()), tcp_socket[ch], SLOT(do_connected()));
 599         connect(tcp_socket[ch], SIGNAL(sig_connected(int)), this, SLOT(do_notify_socket_connected(int)));
 600         connect(tcp_socket[ch], SIGNAL(disconnected()), tcp_socket[ch], SLOT(do_disconnected()));
 601         connect(tcp_socket[ch], SIGNAL(sig_disconnected(int)), this, SLOT(do_notify_socket_disconnected(int)));
 602 #endif
 603         return true;
 604 }
 605
 606 bool OSD::initialize_socket_udp(int ch)
 607 {
 608 #ifdef USE_SOCKET
 609         if(tcp_socket[ch] != NULL) {
 610                 if(tcp_socket[ch]->isOpen()) {
 611                         tcp_socket[ch]->close();
 612                 }
 613                 delete tcp_socket[ch];
 614                 tcp_socket[ch] = NULL;
 615         }
 616         if(udp_socket[ch] != NULL) {
 617                 if(udp_socket[ch]->isOpen()) udp_socket[ch]->close();
 618                 delete udp_socket[ch];
 619         }
 620         is_tcp[ch] = false;
 621         udp_socket[ch] = new QUdpSocket2(ch);
 622         if(udp_socket[ch] == NULL) return false;
 623         connect(udp_socket[ch], SIGNAL(connected()), udp_socket[ch], SLOT(do_connected()));
 624         connect(udp_socket[ch], SIGNAL(sig_connected(int)), this, SLOT(do_notify_socket_connected(int)));
 625         connect(udp_socket[ch], SIGNAL(disconnected()), udp_socket[ch], SLOT(do_disconnected()));
 626         connect(udp_socket[ch], SIGNAL(sig_disconnected(int)), this, SLOT(do_notify_socket_disconnected(int)));
 627 #endif
 628         return true;
 629 }
 630
 631 bool OSD::connect_socket(int ch, uint32_t ipaddr, int port)
 632 {
 633 #ifdef USE_SOCKET
 634         QHostAddress addr = QHostAddress((quint32)ipaddr);
 635         if(is_tcp[ch]) {
 636                 if(tcp_socket[ch] != NULL) {
 637                         tcp_socket[ch]->connectToHost(addr, (quint16)port);
 638                 } else {
 639                         return false;
 640                 }
 641         } else {
 642                 if(udp_socket[ch] != NULL) {
 643                         udp_socket[ch]->connectToHost(addr, (quint16)port);
 644                 } else {
 645                         return false;
 646                 }
 647         }
 648         host_mode[ch] = false;
 649 #endif
 650         return true;
 651 }
 652
 653 void OSD::disconnect_socket(int ch)
 654 {
 655 //      soc[ch] = -1;
 656 #ifdef USE_SOCKET
 657         if(host_mode[ch]) {
 658                 if(is_tcp[ch]) {
 659                         if(tcp_socket[ch] != NULL) {
 660                                 if(tcp_socket[ch]->isOpen()) tcp_socket[ch]->close();
 661                         }
 662                 } else {
 663                         if(udp_socket[ch] != NULL) {
 664                                 if(udp_socket[ch]->isOpen()) udp_socket[ch]->close();
 665                         }
 666                 }
 667         } else {
 668                 if(is_tcp[ch]) {
 669                         if(tcp_socket[ch] != NULL) {
 670                                 udp_socket[ch]->disconnectFromHost();
 671                         }
 672                 } else {
 673                         if(udp_socket[ch] != NULL) {
 674                                 udp_socket[ch]->disconnectFromHost();
 675                         }
 676                 }
 677         }
 678         vm->notify_socket_disconnected(ch);
 679 #endif
 680 }
 681
 682 bool OSD::listen_socket(int ch)
 683 {
 684 #ifdef USE_SOCKET
 685         //QHostAddress addr = QHostAddress(QHostAddress::AnyIPv4); // OK?
 686         // This unit is dummy?
 687         //connect(udp_socket[ch], SIGNAL(connected()), udp_socket[ch], SLOT(do_connected()));
 688         //connect(udp_socket[ch], SIGNAL(sig_connected(int)), this, SLOT(do_notify_socket_connected(int)));
 689         //connect(udp_socket[ch], SIGNAL(disconnected()), udp_socket[ch], SLOT(do_disconnected()));
 690         //connect(udp_socket[ch], SIGNAL(sig_disconnected(int)), this, SLOT(do_notify_socket_disconnected(int)));
 691 #endif
 692         return false;
 693 }
 694
 695 void OSD::send_socket_data_tcp(int ch)
 696 {
 697 #ifdef USE_SOCKET
 698         if(is_tcp[ch]) {
 699                 while(1) {
 700                         int size;
 701                         uint8_t *buf = vm->get_socket_send_buffer(ch, &size);
 702                         if(size <= 0) {
 703                                 return;
 704                         }
 705                         qint64 size2 = 0;
 706                         if(tcp_socket[ch] != NULL) {
 707                                 if(tcp_socket[ch]->isWritable()) {
 708                                         size2 = tcp_socket[ch]->write((const char *)buf, (qint64)size);
 709                                         if(size2 < 0) {
 710                                                 disconnect_socket(ch);
 711                                                 notify_socket_disconnected(ch);
 712                                                 return;
 713                                         }
 714                                 }
 715                         } else {
 716                                 return;
 717                         }
 718                         vm->inc_socket_send_buffer_ptr(ch, (int)size2);
 719                 }
 720         }
 721 #endif
 722 }
 723
 724 void OSD::send_socket_data_udp(int ch, uint32_t ipaddr, int port)
 725 {
 726 #ifdef USE_SOCKET
 727         QHostAddress addr = QHostAddress((quint32)ipaddr);
 728         if(!is_tcp[ch]) {
 729                 while(1) {
 730                         int size;
 731                         uint8_t *buf = vm->get_socket_send_buffer(ch, &size);
 732                         if(size <= 0) {
 733                                 return;
 734                         }
 735                         qint64 size2 = 0;
 736
 737                         if(udp_socket[ch] != NULL) {
 738                                 size2 = udp_socket[ch]->writeDatagram((const char *)buf, (qint64)size, addr, (quint16)port);
 739                                 if(size2 < 0) {
 740                                         disconnect_socket(ch);
 741                                         notify_socket_disconnected(ch);
 742                                         return;
 743                                 }
 744                         } else {
 745                                 return;
 746                         }
 747                         vm->inc_socket_send_buffer_ptr(ch, (int)size2);
 748                 }
 749         }
 750 #endif
 751 }
 752
 753 void OSD::send_socket_data(int ch)
 754 {
 755         // This is dummy.
 756 }
 757
 758 void OSD::recv_socket_data(int ch)
 759 {
 760         // This is dummy.
 761 }
 762
 763 int OSD::get_socket(int ch)
 764 {
 765 #ifdef USE_SOCKET
 766         if(is_tcp[ch]) {
 767                 if(tcp_socket[ch] == NULL) return -1;
 768         } else {
 769                 if(udp_socket[ch] == NULL) return -1;
 770         }
 771 #endif
 772         return ch;
 773 }
 774
 775 //
 776 #if defined(USE_SOCKET)
 777 QTcpSocket2::QTcpSocket2(int channel, QObject *parent) : QTcpSocket(parent)
 778 {
 779         ch = channel;
 780 }
 781
 782 QTcpSocket2::~QTcpSocket2()
 783 {
 784 }
 785
 786 void QTcpSocket2::do_connected(void)
 787 {
 788         emit sig_connected(ch);
 789 }
 790
 791 void QTcpSocket2::do_disconnected(void)
 792 {
 793         emit sig_disconnected(ch);
 794 }
 795
 796 void QTcpSocket2::setChannel(int channel)
 797 {
 798         ch = channel;
 799 }
 800
 801 int QTcpSocket2::getChannel(void)
 802 {
 803         return ch;
 804 }
 805
 806 QUdpSocket2::QUdpSocket2(int channel, QObject *parent) : QUdpSocket(parent)
 807 {
 808         ch = channel;
 809 }
 810
 811 QUdpSocket2::~QUdpSocket2()
 812 {
 813 }
 814
 815 void QUdpSocket2::do_connected(void)
 816 {
 817         emit sig_connected(ch);
 818 }
 819
 820 void QUdpSocket2::do_disconnected(void)
 821 {
 822         emit sig_disconnected(ch);
 823 }
 824
 825 void QUdpSocket2::setChannel(int channel)
 826 {
 827         ch = channel;
 828 }
 829
 830 int QUdpSocket2::getChannel(void)
 831 {
 832         return ch;
 833 }
 834 #endif