Changeset 3934

Show
Ignore:
Timestamp:
03/02/10 12:27:58 (5 months ago)
Author:
sletz
Message:

Cleanup, limit size for sync packet.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • jack2/branches/libjacknet/common/JackNetInterface.cpp

    r3932 r3934  
    2626 
    2727#define PACKET_AVAILABLE_SIZE (fParams.fMtu - sizeof(packet_header_t)) 
     28#define HEADER_SIZE (sizeof(packet_header_t)) 
    2829 
    2930/*   
     
    310311 
    311312        //audio netbuffer length 
    312         fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize(); 
    313         fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize(); 
     313        fAudioTxLen = HEADER_SIZE + fNetAudioCaptureBuffer->GetSize(); 
     314        fAudioRxLen = HEADER_SIZE + fNetAudioPlaybackBuffer->GetSize(); 
    314315    } 
    315316 
     
    341342    { 
    342343        int rx_bytes; 
    343         if ( ( ( rx_bytes = fSocket.Recv ( fRxBuffer, size, flags ) ) == SOCKET_ERROR ) && fRunning ) 
    344        
     344         
     345        if ((( rx_bytes = fSocket.Recv(fRxBuffer, size, flags)) == SOCKET_ERROR) && fRunning)
    345346            net_error_t error = fSocket.GetError(); 
    346347            //no data isn't really a network error, so just return 0 avalaible read bytes 
    347             if ( error == NET_NO_DATA ) 
     348            if (error == NET_NO_DATA) { 
    348349                return 0; 
    349             else if ( error == NET_CONN_ERROR ) 
    350             { 
     350            } else if (error == NET_CONN_ERROR) { 
    351351                //fatal connection issue, exit 
    352                 jack_error ( "'%s' : %s, exiting.", fParams.fName, StrError ( NET_ERROR_CODE ) ); 
     352                jack_error ( "'%s' : %s, exiting.", fParams.fName, StrError(NET_ERROR_CODE)); 
    353353                //ask to the manager to properly remove the master 
    354354                Exit(); 
     
    356356                // UGLY temporary way to be sure the thread does not call code possibly causing a deadlock in JackEngine. 
    357357                ThreadExit(); 
    358             } 
    359             else 
    360                 jack_error ( "Error in master receive : %s", StrError ( NET_ERROR_CODE ) ); 
     358            } else { 
     359                jack_error ( "Error in master receive : %s", StrError(NET_ERROR_CODE)); 
     360            } 
    361361        } 
    362362         
     
    372372        PacketHeaderHToN(header, header); 
    373373         
    374         if ( ( ( tx_bytes = fSocket.Send ( fTxBuffer, size, flags ) ) == SOCKET_ERROR ) && fRunning ) 
    375         { 
     374        if (((tx_bytes = fSocket.Send(fTxBuffer, size, flags)) == SOCKET_ERROR) && fRunning) { 
    376375            net_error_t error = fSocket.GetError(); 
    377             if ( error == NET_CONN_ERROR ) 
    378             { 
     376            if (error == NET_CONN_ERROR) { 
    379377                //fatal connection issue, exit 
    380                 jack_error ( "'%s' : %s, exiting.", fParams.fName, StrError ( NET_ERROR_CODE ) ); 
     378                jack_error ("'%s' : %s, exiting.", fParams.fName, StrError (NET_ERROR_CODE)); 
    381379                Exit(); 
    382380                 
    383381                // UGLY temporary way to be sure the thread does not call code possibly causing a deadlock in JackEngine. 
    384382                ThreadExit(); 
    385             } 
    386             else 
    387                 jack_error ( "Error in master send : %s", StrError ( NET_ERROR_CODE ) ); 
     383            } else { 
     384                jack_error("Error in master send : %s", StrError(NET_ERROR_CODE)); 
     385            } 
    388386        } 
    389387        return tx_bytes; 
     
    405403        fTxHeader.fDataType = 's'; 
    406404        fTxHeader.fIsLastPckt = ( fParams.fSendMidiChannels == 0 && fParams.fSendAudioChannels == 0) ?  1 : 0; 
    407         fTxHeader.fPacketSize = fParams.fMtu
    408         memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) ); 
    409         return Send ( fTxHeader.fPacketSize, 0 ); 
     405        fTxHeader.fPacketSize = HEADER_SIZE
     406        memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE); 
     407        return Send(fTxHeader.fPacketSize, 0); 
    410408    } 
    411409 
     
    423421            { 
    424422                fTxHeader.fSubCycle = subproc; 
    425                 fTxHeader.fIsLastPckt = ( ( subproc == ( fTxHeader.fNMidiPckt - 1 ) ) && (fParams.fSendAudioChannels == 0)) ? 1 : 0; 
    426                 fTxHeader.fPacketSize = sizeof ( packet_header_t ) + fNetMidiCaptureBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize ); 
    427                 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) ); 
    428                 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR
     423                fTxHeader.fIsLastPckt = (( subproc == (fTxHeader.fNMidiPckt - 1)) && (fParams.fSendAudioChannels == 0)) ? 1 : 0; 
     424                fTxHeader.fPacketSize = HEADER_SIZE + fNetMidiCaptureBuffer->RenderToNetwork(subproc, fTxHeader.fMidiDataSize); 
     425                memcpy ( fTxBuffer, &fTxHeader, HEADER_SIZE); 
     426                if (Send (fTxHeader.fPacketSize, 0) == SOCKET_ERROR
    429427                    return SOCKET_ERROR; 
    430428            } 
     
    437435            fTxHeader.fMidiDataSize = 0; 
    438436            fTxHeader.fNMidiPckt = 0; 
    439             for ( subproc = 0; subproc < fNSubProcess; subproc++
     437            for (subproc = 0; subproc < fNSubProcess; subproc++
    440438            { 
    441439                fTxHeader.fSubCycle = subproc; 
    442                 fTxHeader.fIsLastPckt = ( subproc == ( fNSubProcess - 1 ) ) ? 1 : 0; 
     440                fTxHeader.fIsLastPckt = (subproc == (fNSubProcess - 1)) ? 1 : 0; 
    443441                fTxHeader.fPacketSize = fAudioTxLen; 
    444                 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) ); 
    445                 fNetAudioCaptureBuffer->RenderFromJackPorts ( subproc ); 
    446                 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR
     442                memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE); 
     443                fNetAudioCaptureBuffer->RenderFromJackPorts(subproc); 
     444                if (Send(fTxHeader.fPacketSize, 0) == SOCKET_ERROR
    447445                    return SOCKET_ERROR; 
    448446            } 
     
    455453    { 
    456454        packet_header_t* rx_head = reinterpret_cast<packet_header_t*> ( fRxBuffer ); 
    457         int rx_bytes = Recv ( fParams.fMtu, MSG_PEEK ); 
     455        int rx_bytes = Recv(HEADER_SIZE, MSG_PEEK); 
    458456         
    459457        if ( ( rx_bytes == 0 ) || ( rx_bytes == SOCKET_ERROR ) ) 
     
    486484                //  - if the network is too fast, just wait the next cycle, the benefit here is the master's cycle is shorter 
    487485                //  - indeed, data is supposed to be on the network rx buffer, so we don't have to wait for it 
    488                 if (fCycleOffset < 1) { 
     486                if (fCycleOffset < CYCLE_OFFSET_NORMAL) { 
    489487                    return 0; 
    490488                } else { 
     
    492490                } 
    493491                     
    494                 if (fCycleOffset != 1)  { 
     492                if (fCycleOffset > CYCLE_OFFSET_NORMAL)  { 
    495493                    jack_info("'%s' can't run in normal network mode, data received too late (%d cycle(s) offset)", fParams.fName, fCycleOffset); 
    496494                } 
     
    504502                rx_bytes = Recv ( rx_head->fPacketSize, 0 ); 
    505503                 
    506                 if (fCycleOffset != 0) { 
     504                if (fCycleOffset > CYCLE_OFFSET_FAST) { 
    507505                    jack_info("'%s' can't run in fast network mode, data received too late (%d cycle(s) offset)", fParams.fName, fCycleOffset); 
    508506                } 
     
    527525        { 
    528526            //how much data is queued on the rx buffer ? 
    529             rx_bytes = Recv ( fParams.fMtu, MSG_PEEK ); 
     527            rx_bytes = Recv(HEADER_SIZE, MSG_PEEK); 
    530528               
    531529            if ( rx_bytes == SOCKET_ERROR ) 
     
    547545                        fRxHeader.fCycle = rx_head->fCycle; 
    548546                        fRxHeader.fIsLastPckt = rx_head->fIsLastPckt; 
    549                         fNetMidiPlaybackBuffer->RenderFromNetwork ( rx_head->fSubCycle, rx_bytes - sizeof ( packet_header_t ) ); 
     547                        fNetMidiPlaybackBuffer->RenderFromNetwork(rx_head->fSubCycle, rx_bytes - HEADER_SIZE); 
    550548                        if ( ++recvd_midi_pckt == rx_head->fNMidiPckt ) 
    551549                            fNetMidiPlaybackBuffer->RenderToJackPorts(); 
     
    733731            memset(&net_params, 0, sizeof ( session_params_t )); 
    734732            rx_bytes = fSocket.CatchHost ( &net_params, sizeof ( session_params_t ), 0 ); 
    735              
    736             SessionParamsDisplay(&net_params); 
    737             jack_error ( "rx_bytes %d %d", rx_bytes, errno ); 
    738              
    739              
    740733            SessionParamsNToH(&net_params, &host_params); 
    741734            if ( ( rx_bytes == SOCKET_ERROR ) && ( fSocket.GetError() != NET_NO_DATA ) ) 
     
    744737                return NET_RECV_ERROR; 
    745738            } 
    746             for (int i = 0; i < 7; i++) { 
    747                 jack_info ( " fPacketType %d", host_params.fPacketType[i]); 
    748             } 
    749             jack_info ( " received... host_params param %s %s %d %d",  net_params.fPacketType, fParams.fPacketType, net_params.fPacketID, GetPacketType ( &host_params )); 
    750          
    751             SessionParamsDisplay(&host_params); 
    752739        } 
    753740        while ( strcmp ( host_params.fPacketType, fParams.fPacketType )  && ( GetPacketType ( &host_params ) != SLAVE_SETUP ) ); 
    754  
    755         jack_info ( "SLAVE_SETUP received..." ); 
    756          
     741    
    757742        //everything is OK, copy parameters 
     743        SessionParamsDisplay(&host_params); 
    758744        fParams = host_params; 
    759745 
     
    811797 
    812798        //audio netbuffer length 
    813         fAudioTxLen = sizeof ( packet_header_t ) + fNetAudioPlaybackBuffer->GetSize(); 
    814         fAudioRxLen = sizeof ( packet_header_t ) + fNetAudioCaptureBuffer->GetSize(); 
     799        fAudioTxLen = HEADER_SIZE + fNetAudioPlaybackBuffer->GetSize(); 
     800        fAudioRxLen = HEADER_SIZE + fNetAudioCaptureBuffer->GetSize(); 
    815801    } 
    816802 
     
    868854        do 
    869855        { 
    870             rx_bytes = Recv ( fParams.fMtu, 0 ); 
     856            rx_bytes = Recv(HEADER_SIZE, 0); 
    871857            //connection issue, send will detect it, so don't skip the cycle (return 0) 
    872858            if ( rx_bytes == SOCKET_ERROR ) 
     
    890876        while ( !fRxHeader.fIsLastPckt ) 
    891877        { 
    892             rx_bytes = Recv ( fParams.fMtu, MSG_PEEK ); 
     878            rx_bytes = Recv(HEADER_SIZE, MSG_PEEK); 
    893879            //error here, problem with recv, just skip the cycle (return -1) 
    894880 
     
    903889                        fRxHeader.fCycle = rx_head->fCycle; 
    904890                        fRxHeader.fIsLastPckt = rx_head->fIsLastPckt; 
    905                         fNetMidiCaptureBuffer->RenderFromNetwork ( rx_head->fSubCycle, rx_bytes - sizeof ( packet_header_t ) ); 
     891                        fNetMidiCaptureBuffer->RenderFromNetwork(rx_head->fSubCycle, rx_bytes - HEADER_SIZE); 
    906892                        // Last midi packet is received, so finish rendering... 
    907893                        if ( ++recvd_midi_pckt == rx_head->fNMidiPckt ) 
     
    939925    { 
    940926        //tx header 
    941         if ( fParams.fSlaveSyncMode ) 
     927        if ( fParams.fSlaveSyncMode ) { 
    942928            fTxHeader.fCycle = fRxHeader.fCycle; 
    943         else 
     929        } else { 
    944930            fTxHeader.fCycle++; 
     931        } 
    945932        fTxHeader.fSubCycle = 0; 
    946933        fTxHeader.fDataType = 's'; 
    947934        fTxHeader.fIsLastPckt = ( fParams.fReturnMidiChannels == 0 && fParams.fReturnAudioChannels == 0) ?  1 : 0; 
    948         fTxHeader.fPacketSize = fParams.fMtu; 
    949         memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) ); 
    950         return Send ( fTxHeader.fPacketSize, 0 ); 
     935        fTxHeader.fPacketSize = HEADER_SIZE; 
     936         
     937        memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE); 
     938        return Send (fTxHeader.fPacketSize, 0); 
    951939    } 
    952940 
     
    964952            { 
    965953                fTxHeader.fSubCycle = subproc; 
    966                 fTxHeader.fIsLastPckt = ( ( subproc == ( fTxHeader.fNMidiPckt - 1 ) ) && !fParams.fReturnAudioChannels ) ? 1 : 0; 
    967                 fTxHeader.fPacketSize = sizeof ( packet_header_t ) + fNetMidiPlaybackBuffer->RenderToNetwork ( subproc, fTxHeader.fMidiDataSize ); 
    968                 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) ); 
    969                 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR
     954                fTxHeader.fIsLastPckt = ((subproc == (fTxHeader.fNMidiPckt - 1)) && !fParams.fReturnAudioChannels) ? 1 : 0; 
     955                fTxHeader.fPacketSize = HEADER_SIZE+ fNetMidiPlaybackBuffer->RenderToNetwork(subproc, fTxHeader.fMidiDataSize); 
     956                memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE); 
     957                if (Send(fTxHeader.fPacketSize, 0) == SOCKET_ERROR
    970958                    return SOCKET_ERROR; 
    971959            } 
     
    981969            { 
    982970                fTxHeader.fSubCycle = subproc; 
    983                 fTxHeader.fIsLastPckt = ( subproc == ( fNSubProcess - 1 ) ) ? 1 : 0; 
     971                fTxHeader.fIsLastPckt = (subproc == (fNSubProcess - 1)) ? 1 : 0; 
    984972                fTxHeader.fPacketSize = fAudioTxLen; 
    985                 memcpy ( fTxBuffer, &fTxHeader, sizeof ( packet_header_t ) ); 
    986                 fNetAudioPlaybackBuffer->RenderFromJackPorts ( subproc ); 
    987                 if ( Send ( fTxHeader.fPacketSize, 0 ) == SOCKET_ERROR
     973                memcpy(fTxBuffer, &fTxHeader, HEADER_SIZE); 
     974                fNetAudioPlaybackBuffer->RenderFromJackPorts (subproc); 
     975                if (Send(fTxHeader.fPacketSize, 0) == SOCKET_ERROR
    988976                    return SOCKET_ERROR; 
    989977            } 
  • jack2/branches/libjacknet/common/JackNetInterface.h

    r3932 r3934  
    213213#define SLAVE_INIT_TIMEOUT 2000000      // in usec 
    214214 
    215 #define CYCLE_OFFSET_SLOW 2 
     215#define CYCLE_OFFSET_FAST   0 
     216#define CYCLE_OFFSET_NORMAL 1 
     217#define CYCLE_OFFSET_SLOW   3 
    216218#define MAX_LATENCY CYCLE_OFFSET_SLOW * 4 
    217219 
  • jack2/branches/libjacknet/macosx/iphone/main_slave.mm

    r3932 r3934  
    6363    jack_master_t result; 
    6464 
    65     if ((net = jack_net_slave_open("169.254.136.64", DEFAULT_PORT, "iPhone", &request, &result))  == 0) { 
     65    //if ((net = jack_net_slave_open("169.254.121.189", DEFAULT_PORT, "iPhone", &request, &result))  == 0) { 
     66    if ((net = jack_net_slave_open(DEFAULT_MULTICAST_IP, DEFAULT_PORT, "iPhone", &request, &result))  == 0) { 
    6667        return -1; 
    6768    } 
     69     
    6870     
    6971    if ((adapter = jack_create_adapter(NUM_INPUT,