Changeset 480

Show
Ignore:
Timestamp:
06/11/07 17:53:30 (14 years ago)
Author:
jwoithe
Message:

Make teststreaming2 work again (needed for MOTU debugging).
Fix a typo in StreamProcessorManager? which assigned the value of snoopMode to m_is_slave.
Debugging of MOTU driver.

Files:

Legend:

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

    r445 r480  
    151151            m_is_disabled=false; 
    152152 
    153             debugOutput(DEBUG_LEVEL_VERBOSE,"Enabling StreamProcessor %p at %u\n", this, cycle); 
     153            debugOutput(DEBUG_LEVEL_VERBOSE,"Enabling Tx StreamProcessor %p at %u\n", this, cycle); 
    154154 
    155155            // initialize the buffer head & tail 
     
    961961        if (cycle == m_cycle_to_enable_at) { 
    962962            m_is_disabled=false; 
    963             debugOutput(DEBUG_LEVEL_VERBOSE,"Enabling StreamProcessor %p at %d\n", 
     963            debugOutput(DEBUG_LEVEL_VERBOSE,"Enabling Rx StreamProcessor %p at %d\n", 
    964964                this, cycle); 
    965965 
  • trunk/libffado/src/libstreaming/StreamProcessorManager.cpp

    r445 r480  
    197197 
    198198    m_is_slave=false; 
    199     if(!getOption("snoopMode", m_is_slave)) { 
    200         debugWarning("Could not retrieve slaveMode parameter, defauling to false\n"); 
     199    if(!getOption("slaveMode", m_is_slave)) { 
     200        debugWarning("Could not retrieve slaveMode parameter, defaulting to false\n"); 
    201201    } 
    202202 
  • trunk/libffado/src/motu/motu_avdevice.cpp

    r479 r480  
    7777    // Free ieee1394 bus resources if they have been allocated 
    7878    if (m_p1394Service != NULL) { 
    79         if (m_iso_recv_channel>=0 && m_p1394Service->freeIsoChannel(m_iso_recv_channel)) { 
     79        if (m_iso_recv_channel>=0 && !m_p1394Service->freeIsoChannel(m_iso_recv_channel)) { 
    8080            debugOutput(DEBUG_LEVEL_VERBOSE, "Could not free recv iso channel %d\n", m_iso_recv_channel); 
    8181        } 
    82         if (m_iso_send_channel>=0 && m_p1394Service->freeIsoChannel(m_iso_send_channel)) { 
     82        if (m_iso_send_channel>=0 && !m_p1394Service->freeIsoChannel(m_iso_send_channel)) { 
    8383            debugOutput(DEBUG_LEVEL_VERBOSE, "Could not free send iso channel %d\n", m_iso_send_channel); 
    8484        } 
  • trunk/libffado/tests/streaming/teststreaming2.c

    r445 r480  
    3838#include <signal.h> 
    3939 
    40 #include "libfreebob/freebob_streaming.h" 
     40#include "libffado/ffado.h" 
    4141 
    4242#include "debugtools.h" 
     
    5858        int retval=0; 
    5959        int i=0; 
     60        int start_flag=0; 
    6061 
    6162        int nb_periods=0; 
    6263 
    63         freebob_sample_t **audiobuffer; 
    64         freebob_sample_t *nullbuffer; 
     64        ffado_sample_t **audiobuffer; 
     65        ffado_sample_t *nullbuffer; 
    6566         
    6667        run=1; 
    6768 
    68         printf("Freebob streaming test application (2)\n"); 
     69        printf("Ffado streaming test application (2)\n"); 
    6970 
    7071        signal (SIGINT, sighandler); 
    7172        signal (SIGPIPE, sighandler); 
    7273 
    73         freebob_device_info_t device_info; 
    74  
    75         freebob_options_t dev_options; 
     74        ffado_device_info_t device_info; 
     75 
     76        ffado_options_t dev_options; 
    7677 
    7778        dev_options.sample_rate=44100; 
     
    8687        dev_options.packetizer_priority=60; 
    8788 
    88         freebob_device_t *dev=freebob_streaming_init(&device_info, dev_options); 
     89        ffado_device_t *dev=ffado_streaming_init(&device_info, dev_options); 
    8990        if (!dev) { 
    90                 fprintf(stderr,"Could not init Freebob Streaming layer\n"); 
     91                fprintf(stderr,"Could not init Ffado Streaming layer\n"); 
    9192                exit(-1); 
    9293        } 
    9394 
    94         nb_in_channels=freebob_streaming_get_nb_capture_streams(dev); 
    95         nb_out_channels=freebob_streaming_get_nb_playback_streams(dev); 
     95        nb_in_channels=ffado_streaming_get_nb_capture_streams(dev); 
     96        nb_out_channels=ffado_streaming_get_nb_playback_streams(dev); 
    9697 
    9798        /* allocate intermediate buffers */ 
    98         audiobuffer=calloc(nb_in_channels,sizeof(freebob_sample_t *)); 
    99         for (i=0;i<nb_in_channels;i++) { 
    100                 audiobuffer[i]=calloc(PERIOD_SIZE+1,sizeof(freebob_sample_t)); 
    101                          
    102                 switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    103                         case freebob_stream_type_audio: 
     99        audiobuffer=calloc(nb_in_channels,sizeof(ffado_sample_t *)); 
     100        for (i=0;i<nb_in_channels;i++) { 
     101                audiobuffer[i]=calloc(PERIOD_SIZE+1,sizeof(ffado_sample_t)); 
     102                         
     103                switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     104                        case ffado_stream_type_audio: 
    104105                                /* assign the audiobuffer to the stream */ 
    105                                 freebob_streaming_set_capture_stream_buffer(dev, i, (char *)(audiobuffer[i])); 
    106                                 freebob_streaming_set_capture_buffer_type(dev, i, freebob_buffer_type_int24); 
     106                                ffado_streaming_set_capture_stream_buffer(dev, i, (char *)(audiobuffer[i])); 
     107                                ffado_streaming_set_capture_buffer_type(dev, i, ffado_buffer_type_int24); 
    107108                                break; 
    108109                                // this is done with read/write routines because the nb of bytes can differ. 
    109                         case freebob_stream_type_midi: 
     110                        case ffado_stream_type_midi: 
    110111                        default: 
    111112                                break; 
     
    113114        } 
    114115         
    115         nullbuffer=calloc(PERIOD_SIZE+1,sizeof(freebob_sample_t)); 
     116        nullbuffer=calloc(PERIOD_SIZE+1,sizeof(ffado_sample_t)); 
    116117 
    117118#if 1 
    118119        for (i=0;i<nb_out_channels;i++) { 
    119                 switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    120                         case freebob_stream_type_audio: 
     120                switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     121                        case ffado_stream_type_audio: 
    121122                                if (i<nb_in_channels) { 
    122123                                        /* assign the audiobuffer to the stream */ 
    123                                         freebob_streaming_set_playback_stream_buffer(dev, i, (char *)audiobuffer[i]); 
     124                                        ffado_streaming_set_playback_stream_buffer(dev, i, (char *)audiobuffer[i]); 
    124125                                } else { 
    125                                         freebob_streaming_set_playback_stream_buffer(dev, i, (char *)nullbuffer); 
     126                                        ffado_streaming_set_playback_stream_buffer(dev, i, (char *)nullbuffer); 
    126127                                } 
    127                                 freebob_streaming_set_playback_buffer_type(dev, i, freebob_buffer_type_int24); 
     128                                ffado_streaming_set_playback_buffer_type(dev, i, ffado_buffer_type_int24); 
    128129                                break; 
    129130                                // this is done with read/write routines because the nb of bytes can differ. 
    130                         case freebob_stream_type_midi: 
     131                        case ffado_stream_type_midi: 
    131132                        default: 
    132133                                break; 
     
    145146                fid_out[i]=fopen(name,"w"); 
    146147 
    147                 freebob_streaming_get_playback_stream_name(dev,i,name,sizeof(name)); 
     148                ffado_streaming_get_playback_stream_name(dev,i,name,sizeof(name)); 
    148149                fprintf(fid_out[i],"Channel name: %s\n",name); 
    149                 switch (freebob_streaming_get_playback_stream_type(dev,i)) { 
    150                 case freebob_stream_type_audio: 
     150                switch (ffado_streaming_get_playback_stream_type(dev,i)) { 
     151                case ffado_stream_type_audio: 
    151152                        fprintf(fid_out[i],"Channel type: audio\n"); 
    152153                        break; 
    153                 case freebob_stream_type_midi: 
     154                case ffado_stream_type_midi: 
    154155                        fprintf(fid_out[i],"Channel type: midi\n"); 
    155156                        break; 
    156                 case freebob_stream_type_unknown: 
     157                case ffado_stream_type_unknown: 
    157158                        fprintf(fid_out[i],"Channel type: unknown\n"); 
    158159                        break; 
    159160                default: 
    160                 case freebob_stream_type_invalid: 
     161                case ffado_stream_type_invalid: 
    161162                        fprintf(fid_out[i],"Channel type: invalid\n"); 
    162163                        break; 
     
    168169                fid_in[i]=fopen(name,"w"); 
    169170 
    170                 freebob_streaming_get_capture_stream_name(dev,i,name,sizeof(name)); 
     171                ffado_streaming_get_capture_stream_name(dev,i,name,sizeof(name)); 
    171172                fprintf(fid_in[i], "Channel name: %s\n",name); 
    172                 switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    173                 case freebob_stream_type_audio: 
     173                switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     174                case ffado_stream_type_audio: 
    174175                        fprintf(fid_in[i], "Channel type: audio\n"); 
    175176                        break; 
    176                 case freebob_stream_type_midi: 
     177                case ffado_stream_type_midi: 
    177178                        fprintf(fid_in[i], "Channel type: midi\n"); 
    178179                        break; 
    179                 case freebob_stream_type_unknown: 
     180                case ffado_stream_type_unknown: 
    180181                        fprintf(fid_in[i],"Channel type: unknown\n"); 
    181182                        break; 
    182183                default: 
    183                 case freebob_stream_type_invalid: 
     184                case ffado_stream_type_invalid: 
    184185                        fprintf(fid_in[i],"Channel type: invalid\n"); 
    185186                        break; 
     
    190191 
    191192        // prepare and start the streaming layer 
    192         freebob_streaming_prepare(dev); 
    193         freebob_streaming_start(dev); 
     193        ffado_streaming_prepare(dev); 
     194        start_flag = ffado_streaming_start(dev); 
    194195 
    195196        fprintf(stderr,"Entering receive loop (%d,%d)\n",nb_in_channels,nb_out_channels); 
    196         while(run) { 
    197                 retval = freebob_streaming_wait(dev); 
     197        while(run && start_flag==0) { 
     198                retval = ffado_streaming_wait(dev); 
    198199                if (retval < 0) { 
    199200                        fprintf(stderr,"Xrun\n"); 
    200                         freebob_streaming_reset(dev); 
     201                        ffado_streaming_reset(dev); 
    201202                        continue; 
    202203                } 
    203204                 
    204205                for (i=0;i<nb_in_channels;i++) { 
    205                         memset(audiobuffer[i],0xCC,(PERIOD_SIZE+1)*sizeof(freebob_sample_t)); 
    206                 } 
    207  
    208 //              freebob_streaming_transfer_buffers(dev); 
    209                 freebob_streaming_transfer_capture_buffers(dev); 
    210                 freebob_streaming_transfer_playback_buffers(dev); 
     206                        memset(audiobuffer[i],0xCC,(PERIOD_SIZE+1)*sizeof(ffado_sample_t)); 
     207                } 
     208 
     209//              ffado_streaming_transfer_buffers(dev); 
     210                ffado_streaming_transfer_capture_buffers(dev); 
     211                ffado_streaming_transfer_playback_buffers(dev); 
    211212                 
    212213                nb_periods++; 
     
    219220                         
    220221                         
    221                         switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    222                         case freebob_stream_type_audio: 
     222                        switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     223                        case ffado_stream_type_audio: 
    223224                                // no need to get the buffers manually, we have set the API internal buffers to the audiobuffer[i]'s 
    224 //                              //samplesread=freebob_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE); 
     225//                              //samplesread=ffado_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE); 
    225226                                samplesread=PERIOD_SIZE; 
    226227                                break; 
    227                         case freebob_stream_type_midi: 
    228                                 samplesread=freebob_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE); 
     228                        case ffado_stream_type_midi: 
     229                                samplesread=ffado_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE); 
    229230                                break; 
    230231                        default: 
     
    233234         
    234235//                      fprintf(fid_in[i], "---- Period read  (%d samples) ----\n",samplesread); 
    235 //                      hexDumpToFile(fid_in[i],(unsigned char*)audiobuffer[i],samplesread*sizeof(freebob_sample_t)+1); 
     236//                      hexDumpToFile(fid_in[i],(unsigned char*)audiobuffer[i],samplesread*sizeof(ffado_sample_t)+1); 
    236237// FIXME: Dump analog1 as raw data to a separate binary file for testing 
    237238//if (i==2) { 
    238 //  fwrite(audiobuffer[i],sizeof(freebob_sample_t),samplesread,of); 
     239//  fwrite(audiobuffer[i],sizeof(ffado_sample_t),samplesread,of); 
    239240//} 
    240241                } 
    241242 
    242243                for(i=0;i<nb_out_channels;i++) { 
    243                         freebob_sample_t *buff; 
     244                        ffado_sample_t *buff; 
    244245                        if (i<nb_in_channels) { 
    245246                                buff=audiobuffer[i]; 
     
    248249                        } 
    249250                         
    250                         switch (freebob_streaming_get_playback_stream_type(dev,i)) { 
    251                         case freebob_stream_type_audio: 
    252 //// Calling freebob_streaming_write() causes problems since the buffer is external here. 
     251                        switch (ffado_streaming_get_playback_stream_type(dev,i)) { 
     252                        case ffado_stream_type_audio: 
     253//// Calling ffado_streaming_write() causes problems since the buffer is external here. 
    253254//// Just mirror the read case since it seems to work. 
    254 ////                            sampleswritten=freebob_streaming_write(dev, i, buff, PERIOD_SIZE); 
     255////                            sampleswritten=ffado_streaming_write(dev, i, buff, PERIOD_SIZE); 
    255256                                sampleswritten=PERIOD_SIZE; 
    256257                                break; 
    257                         case freebob_stream_type_midi: 
    258                                 sampleswritten=freebob_streaming_write(dev, i, buff, PERIOD_SIZE); 
     258                        case ffado_stream_type_midi: 
     259                                sampleswritten=ffado_streaming_write(dev, i, buff, PERIOD_SIZE); 
    259260                                break; 
    260261                        default: 
     
    262263                        } 
    263264//                      fprintf(fid_out[i], "---- Period write (%d samples) ----\n",sampleswritten); 
    264 //                      hexDumpToFile(fid_out[i],(unsigned char*)buff,sampleswritten*sizeof(freebob_sample_t)); 
     265//                      hexDumpToFile(fid_out[i],(unsigned char*)buff,sampleswritten*sizeof(ffado_sample_t)); 
    265266                } 
    266267 
     
    271272        fprintf(stderr,"Exiting receive loop\n"); 
    272273         
    273         freebob_streaming_stop(dev); 
    274  
    275         freebob_streaming_finish(dev); 
     274        ffado_streaming_stop(dev); 
     275 
     276        ffado_streaming_finish(dev); 
    276277fclose(of); 
    277278