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