Changeset 873

Show
Ignore:
Timestamp:
01/21/08 14:01:52 (16 years ago)
Author:
jwoithe
Message:

MOTU: Reinstate MIDI stream processing code removed during API cleanup.
MOTU: Implement silent audio packets in MOTU transmit stream processor.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/src/libstreaming/motu/MotuReceiveStreamProcessor.cpp

    r864 r873  
    219219            break; 
    220220        case Port::E_Midi: 
    221 //             if(decodeMotuMidiEventsToPort(static_cast<MotuMidiPort *>(*it), (quadlet_t *)data, offset, nevents)) { 
    222 //                 debugWarning("Could not decode packet midi data to port %s",(*it)->getName().c_str()); 
    223 //                 no_problem=false; 
    224 //             } 
     221             if(decodeMotuMidiEventsToPort(static_cast<MotuMidiPort *>(*it), (quadlet_t *)data, offset, nevents)) { 
     222                 debugWarning("Could not decode packet midi data to port %s",(*it)->getName().c_str()); 
     223                 no_problem=false; 
     224             } 
    225225            break; 
    226226 
     
    302302} 
    303303 
     304int 
     305MotuReceiveStreamProcessor::decodeMotuMidiEventsToPort( 
     306                      MotuMidiPort *p, quadlet_t *data, 
     307                      unsigned int offset, unsigned int nevents) 
     308{ 
     309    quadlet_t sample; 
     310    unsigned int j = 0; 
     311    unsigned char *src = NULL; 
     312 
     313    quadlet_t *buffer = (quadlet_t *)(p->getBufferAddress()); 
     314    assert(nevents + offset <= p->getBufferSize()); 
     315    buffer += offset; 
     316 
     317    // Zero the buffer 
     318    memset(buffer, 0, nevents*sizeof(*buffer)); 
     319 
     320    // Get MIDI bytes if present in any frames within the packet.  MOTU MIDI 
     321    // data is sent using a 3-byte sequence starting at the port's position.  
     322    // It's thought that there can never be MIDI data in more than one frame 
     323    // in a given packet, but for completeness we'll check all frames 
     324    // anyway. 
     325    src = (unsigned char *)data + p->getPosition(); 
     326    while (j < nevents) { 
     327        if (*src==0x01 && *(src+1)==0x00) { 
     328            sample = *(src+2); 
     329            *buffer = sample; 
     330        } 
     331        buffer++; 
     332        j++; 
     333        src += m_event_size; 
     334    } 
     335 
     336    return 0;     
     337} 
     338 
    304339} // end of namespace Streaming 
  • trunk/libffado/src/libstreaming/motu/MotuReceiveStreamProcessor.h

    r864 r873  
    3838 
    3939class MotuAudioPort; 
     40class MotuMidiPort; 
    4041/*! 
    4142 * \brief The Base Class for a MOTU receive stream processor 
     
    8384 
    8485    int decodeMotuEventsToPort(MotuAudioPort *, quadlet_t *data, unsigned int offset, unsigned int nevents); 
     86    int decodeMotuMidiEventsToPort(MotuMidiPort *, quadlet_t *data, unsigned int offset, unsigned int nevents); 
    8587 
    8688    /* 
  • trunk/libffado/src/libstreaming/motu/MotuTransmitStreamProcessor.cpp

    r864 r873  
    303303        // Set up each frames's SPH. 
    304304        for (int i=0; i < n_events; i++, quadlet += dbs) { 
    305 //FIXME: not sure which is best for the MOTU 
     305//FIXME: not sure which is best for the MOTU.  Should be consistent with generateSilentPacketData(). 
    306306//            int64_t ts_frame = addTicks(ts, (unsigned int)(i * ticks_per_frame)); 
    307307            int64_t ts_frame = addTicks(m_last_timestamp, (unsigned int)(i * ticks_per_frame)); 
     
    352352                cycle, m_last_timestamp, ( unsigned int ) TICKS_TO_CYCLES ( m_last_timestamp ) ); 
    353353 
    354     // Do housekeeping expected for all packets sent to the MOTU, even 
    355     // for packets containing no audio data. 
    356     *sy = 0x00; 
    357     *tag = 1;      // All MOTU packets have a CIP-like header 
    358     *length = 8; 
    359  
    360     m_tx_dbc += fillNoDataPacketHeader ( (quadlet_t *)data, length ); 
    361     return eCRV_Packet; 
     354    // A "silent" packet is identical to a regular data packet except 
     355    // all audio data is set to zero.  Therefore we can just use 
     356    // generatePacketHeader() to do the work here. 
     357    return generatePacketHeader(data, length, tag, sy, cycle, dropped, max_length); 
    362358} 
    363359 
     
    368364    int cycle, unsigned int dropped, unsigned int max_length ) 
    369365{ 
    370     return eCRV_OK; // no need to do anything 
     366    // Simply set all audio data to zero since that's what's meant by 
     367    // a "silent" packet.  Note that m_event_size is in bytes for MOTU. 
     368 
     369    quadlet_t *quadlet = (quadlet_t *)data; 
     370    quadlet += 2; // skip the header 
     371    // Size of a single data frame in quadlets 
     372    unsigned dbs = m_event_size / 4; 
     373 
     374    // The number of events per packet expected by the MOTU is solely 
     375    // dependent on the current sample rate.  An 'event' is one sample from 
     376    // all channels plus possibly other midi and control data. 
     377    signed n_events = getNominalFramesPerPacket(); 
     378 
     379    memset(quadlet, 0, n_events*m_event_size); 
     380    float ticks_per_frame = m_Parent.getDeviceManager().getStreamProcessorManager().getSyncSource().getActualRate(); 
     381 
     382    // Set up each frames's SPH. 
     383    for (int i=0; i < n_events; i++, quadlet += dbs) { 
     384//FIXME: not sure which is best for the MOTU.  Should be consistent with generatePacketData(). 
     385//        int64_t ts_frame = addTicks(ts, (unsigned int)(i * ticks_per_frame)); 
     386        int64_t ts_frame = addTicks(m_last_timestamp, (unsigned int)(i * ticks_per_frame)); 
     387        *quadlet = htonl(fullTicksToSph(ts_frame)); 
     388    } 
     389 
     390    return eCRV_OK; 
    371391} 
    372392 
     
    450470            break; 
    451471        case Port::E_Midi: 
    452 //             if (encodePortToMotuMidiEvents(static_cast<MotuMidiPort *>(*it), (quadlet_t *)data, offset, nevents)) { 
    453 //                 debugWarning("Could not encode port %s to Midi events",(*it)->getName().c_str()); 
    454 //                 no_problem=false; 
    455 //             } 
     472             if (encodePortToMotuMidiEvents(static_cast<MotuMidiPort *>(*it), (quadlet_t *)data, offset, nevents)) { 
     473                 debugWarning("Could not encode port %s to Midi events",(*it)->getName().c_str()); 
     474                 no_problem=false; 
     475             } 
    456476            break; 
    457477        default: // ignore 
     
    482502            break; 
    483503        case Port::E_Midi: 
    484 //             if (encodeSilencePortToMotuMidiEvents(static_cast<MotuMidiPort *>(*it), (quadlet_t *)data, offset, nevents)) { 
    485 //                 debugWarning("Could not encode port %s to Midi events",(*it)->getName().c_str()); 
    486 //                 no_problem = false; 
    487 //             } 
     504            if (encodeSilencePortToMotuMidiEvents(static_cast<MotuMidiPort *>(*it), (quadlet_t *)data, offset, nevents)) { 
     505                debugWarning("Could not encode port %s to Midi events",(*it)->getName().c_str()); 
     506                no_problem = false; 
     507            } 
    488508            break; 
    489509        default: // ignore 
     
    588608} 
    589609 
     610int MotuTransmitStreamProcessor::encodePortToMotuMidiEvents( 
     611                       MotuMidiPort *p, quadlet_t *data, 
     612                       unsigned int offset, unsigned int nevents) { 
     613 
     614    unsigned int j; 
     615    quadlet_t *src = (quadlet_t *)p->getBufferAddress(); 
     616    src += offset; 
     617 
     618    unsigned char *target = (unsigned char *)data + p->getPosition(); 
     619 
     620    // Send a MIDI byte if there is one to send.  MOTU MIDI data is sent using 
     621    // a 3-byte sequence within a frame starting at the port's position.  For 
     622    // now we assume that a zero within the port's buffer means there is no 
     623    // MIDI data for the corresponding frame, but this may need refining. 
     624 
     625    for (j=0; j<nevents; j++, src++, target+=m_event_size) { 
     626        if (*src != 0) { 
     627            *(target) = 0x01; 
     628            *(target+1) = 0x00; 
     629            *(target+2) = (*src & 0xff); 
     630        } else 
     631          memset(target, 0, 3); 
     632    } 
     633 
     634    return 0; 
     635} 
     636 
     637int MotuTransmitStreamProcessor::encodeSilencePortToMotuMidiEvents( 
     638                       MotuMidiPort *p, quadlet_t *data, 
     639                       unsigned int offset, unsigned int nevents) { 
     640 
     641    unsigned int j; 
     642    unsigned char *target = (unsigned char *)data + p->getPosition(); 
     643 
     644    // For now, a "silent" MIDI event contains nothing but zeroes.  This 
     645    // may have to change if we find this isn't for some reason appropriate. 
     646    for (j=0; j<nevents; j++, target+=m_event_size) { 
     647       memset(target, 0, 3); 
     648    } 
     649 
     650    return 0; 
     651} 
     652 
    590653} // end of namespace Streaming 
  • trunk/libffado/src/libstreaming/motu/MotuTransmitStreamProcessor.h

    r864 r873  
    3939class Port; 
    4040class MotuAudioPort; 
    41  
     41class MotuMidiPort; 
    4242/*! 
    4343\brief The Base Class for an MOTU transmit stream processor 
     
    105105                                unsigned int offset, unsigned int nevents); 
    106106 
     107    int encodePortToMotuMidiEvents( 
     108                       MotuMidiPort *p, quadlet_t *data, 
     109                       unsigned int offset, unsigned int nevents); 
     110    int encodeSilencePortToMotuMidiEvents( 
     111                       MotuMidiPort *p, quadlet_t *data, 
     112                       unsigned int offset, unsigned int nevents); 
     113 
    107114    /* 
    108115     * An iso packet mostly consists of multiple events.  m_event_size