Winmme driver working again.

git-svn-id: http://subversion.jackaudio.org/jack/jack2/trunk/jackmp@4260 0c269be4-1314-0410-8aa9-9f06e86f4224

common/shm.h

@@ -14,7 +14,7 @@ extern "C"
 {
 #endif
 
-#define MAX_SERVERS 64			/* maximum concurrent servers */
+#define MAX_SERVERS 8			/* maximum concurrent servers */
 #define MAX_SHM_ID 256			/* generally about 16 per server */
 #define JACK_SERVER_NAME_SIZE 256	/* maximum length of server name */
 #define JACK_SHM_MAGIC 0x4a41434b	/* shm magic number: "JACK" */

windows/winmme/JackWinMMEDriver.cpp

@@ -212,7 +212,6 @@ JackWinMMEDriver::Open(bool capturing, bool playing, int in_channels,
 int
 JackWinMMEDriver::Read()
 {
-
     jack_nframes_t buffer_size = fEngineControl->fBufferSize;
     for (int i = 0; i < fCaptureChannels; i++) {
         input_ports[i]->ProcessJack(GetInputBuffer(i), buffer_size);
@@ -221,16 +220,14 @@ JackWinMMEDriver::Read()
     return 0;
 }
 
-
 int
 JackWinMMEDriver::Write()
 {
-    /*
     jack_nframes_t buffer_size = fEngineControl->fBufferSize;
     for (int i = 0; i < fPlaybackChannels; i++) {
         output_ports[i]->ProcessJack(GetOutputBuffer(i), buffer_size);
     }
-    */
+
     return 0;
 }
 

windows/winmme/JackWinMMEInputPort.cpp

@@ -50,9 +50,9 @@ JackWinMMEInputPort::JackWinMMEInputPort(const char *alias_name,
                                          size_t max_bytes, size_t max_messages)
 {
     thread_queue = new JackMidiAsyncQueue(max_bytes, max_messages);
-    std::auto_ptr<JackMidiAsyncQueue> thread_queue_ptr(thread_queue);
+    //std::auto_ptr<JackMidiAsyncQueue> thread_queue_ptr(thread_queue);
     write_queue = new JackMidiBufferWriteQueue();
-    std::auto_ptr<JackMidiBufferWriteQueue> write_queue_ptr(write_queue);
+    //std::auto_ptr<JackMidiBufferWriteQueue> write_queue_ptr(write_queue);
     sysex_buffer = new jack_midi_data_t[max_bytes];
     char error_message[MAXERRORLENGTH];
     MMRESULT result = midiInOpen(&handle, index, (DWORD)HandleMidiInputEvent,
@@ -95,8 +95,8 @@ JackWinMMEInputPort::JackWinMMEInputPort(const char *alias_name,
     snprintf(name, sizeof(name) - 1, "%s:capture_%d", client_name, index + 1);
     jack_event = 0;
     started = false;
-    write_queue_ptr.release();
-    thread_queue_ptr.release();
+    //write_queue_ptr.release();
+    //thread_queue_ptr.release();
     return;
 
  unprepare_header:
@@ -164,14 +164,14 @@ JackWinMMEInputPort::ProcessJack(JackMidiBuffer *port_buffer,
     if (! jack_event) {
         jack_event = thread_queue->DequeueEvent();
     }
-    for (; jack_event; jack_event = thread_queue->DequeueEvent()) {
+    for (; jack_event; jack_event = thread_queue->DequeueEvent()) {
         switch (write_queue->EnqueueEvent(jack_event)) {
         case JackMidiWriteQueue::BUFFER_TOO_SMALL:
             jack_error("JackWinMMEMidiInputPort::Process - The buffer write "
                        "queue couldn't enqueue a %d-byte event. Dropping "
                        "event.", jack_event->size);
             // Fallthrough on purpose
-        case JackMidiWriteQueue::OK:
+        case JackMidiWriteQueue::OK:
             continue;
         }
         break;
@@ -182,7 +182,8 @@ void
 JackWinMMEInputPort::ProcessWinMME(UINT message, DWORD param1, DWORD param2)
 {
     set_threaded_log_function();
-    jack_nframes_t current_frame = GetCurrentFrame();
+    jack_nframes_t current_frame = GetCurrentFrame();
+
     switch (message) {
     case MIM_CLOSE:
         jack_info("JackWinMMEInputPort::ProcessWinMME - MIDI device closed.");
@@ -195,13 +196,14 @@ JackWinMMEInputPort::ProcessWinMME(UINT message, DWORD param1, DWORD param2)
     case MIM_DATA:
         jack_midi_data_t message_buffer[3];
         jack_midi_data_t status = param1 & 0xff;
-        int length = GetMessageLength(status);
+        int length = GetMessageLength(status);
+
         switch (length) {
         case 3:
-            message_buffer[2] = param1 & 0xff0000;
+             message_buffer[2] = (param1 >> 16)  & 0xff;
             // Fallthrough on purpose.
         case 2:
-            message_buffer[1] = param1 & 0xff00;
+            message_buffer[1] = (param1 >> 8) & 0xff;
             // Fallthrough on purpose.
         case 1:
             message_buffer[0] = status;
@@ -216,7 +218,7 @@ JackWinMMEInputPort::ProcessWinMME(UINT message, DWORD param1, DWORD param2)
                        "input driver sent an MIM_DATA message with an invalid "
                        "status byte.");
             return;
-        }
+        }
         EnqueueMessage(current_frame, (size_t) length, message_buffer);
         break;
     case MIM_LONGDATA:

windows/winmme/JackWinMMEOutputPort.cpp

@@ -49,11 +49,11 @@ JackWinMMEOutputPort::JackWinMMEOutputPort(const char *alias_name,
                                            size_t max_messages)
 {
     read_queue = new JackMidiBufferReadQueue();
-    std::auto_ptr<JackMidiBufferReadQueue> read_queue_ptr(read_queue);
+    //std::auto_ptr<JackMidiBufferReadQueue> read_queue_ptr(read_queue);
     thread_queue = new JackMidiAsyncQueue(max_bytes, max_messages);
-    std::auto_ptr<JackMidiAsyncQueue> thread_queue_ptr(thread_queue);
+    //std::auto_ptr<JackMidiAsyncQueue> thread_queue_ptr(thread_queue);
     thread = new JackThread(this);
-    std::auto_ptr<JackThread> thread_ptr(thread);
+    //std::auto_ptr<JackThread> thread_ptr(thread);
     char error_message[MAXERRORLENGTH];
     MMRESULT result = midiOutOpen(&handle, index, (DWORD)HandleMessageEvent,
                                   (DWORD)this, CALLBACK_FUNCTION);
@@ -84,8 +84,8 @@ JackWinMMEOutputPort::JackWinMMEOutputPort(const char *alias_name,
     snprintf(alias, sizeof(alias) - 1, "%s:%s:out%d", alias_name, name_tmp,
              index + 1);
     snprintf(name, sizeof(name) - 1, "%s:playback_%d", client_name, index + 1);
-    thread_ptr.release();
-    thread_queue_ptr.release();
+    //thread_ptr.release();
+    //thread_queue_ptr.release();
     return;
 
  destroy_thread_queue_semaphore:
@@ -129,15 +129,12 @@ bool
 JackWinMMEOutputPort::Execute()
 {
     for (;;) {
-        jack_log("JackWinMMEOutputPort::Execute TOTO");
-        JackSleep(100000);
-
-        if (! Wait(thread_queue_semaphore)) {
+         if (! Wait(thread_queue_semaphore)) {
             jack_log("JackWinMMEOutputPort::Execute BREAK");
 
             break;
-        }
-        /*
+        }
+
         jack_midi_event_t *event = thread_queue->DequeueEvent();
         if (! event) {
             break;
@@ -217,7 +214,7 @@ JackWinMMEOutputPort::Execute()
                          "midiOutUnprepareHeader", result);
             break;
         }
-        */
+
     }
  stop_execution:
     return false;
@@ -262,10 +259,12 @@ JackWinMMEOutputPort::Init()
 void
 JackWinMMEOutputPort::ProcessJack(JackMidiBuffer *port_buffer,
                                   jack_nframes_t frames)
-{
-    read_queue->ResetMidiBuffer(port_buffer);
+{
+    read_queue->ResetMidiBuffer(port_buffer);
+
     for (jack_midi_event_t *event = read_queue->DequeueEvent(); event;
-         event = read_queue->DequeueEvent()) {
+        event = read_queue->DequeueEvent()) {
+
         switch (thread_queue->EnqueueEvent(event, frames)) {
         case JackMidiWriteQueue::BUFFER_FULL:
             jack_error("JackWinMMEOutputPort::ProcessJack - The thread queue "
@@ -339,8 +338,6 @@ JackWinMMEOutputPort::Stop()
 bool
 JackWinMMEOutputPort::Wait(HANDLE semaphore)
 {
-    jack_log("JackWinMMEOutputPort::Wait %d", semaphore);
-
     DWORD result = WaitForSingleObject(semaphore, INFINITE);
     switch (result) {
     case WAIT_FAILED: