Changeset 514

Show
Ignore:
Timestamp:
08/09/07 16:15:41 (15 years ago)
Author:
jwoithe
Message:

Port remaining streaming tests to ffado and fix minor compilation errors.

Files:

Legend:

Unmodified
Added
Removed
Modified
Copied
Moved
  • trunk/libffado/tests/streaming/testmidistreaming1.c

    r445 r514  
    4545#include <alsa/asoundlib.h> 
    4646 
    47 #include "libfreebob/freebob_streaming.h" 
     47#include "libffado/ffado.h" 
    4848 
    4949#include "debugtools.h" 
     
    6868        snd_midi_event_t *parser; 
    6969        snd_seq_t *seq_handle; 
    70 } freebob_midi_port_t; 
     70} ffado_midi_port_t; 
    7171 
    7272typedef struct { 
    7373        snd_seq_t *seq_handle; 
    7474        int nb_seq_ports; 
    75         freebob_midi_port_t *ports[MAX_MIDI_PORTS]; 
    76 } freebob_midi_ports_t; 
     75        ffado_midi_port_t *ports[MAX_MIDI_PORTS]; 
     76} ffado_midi_ports_t; 
    7777 
    7878int open_seq(snd_seq_t **seq_handle, int in_ports[], int out_ports[], int num_in, int num_out); 
     
    113113} 
    114114 
    115 void decode_midi_byte (freebob_midi_port_t *port, int byte) { 
     115void decode_midi_byte (ffado_midi_port_t *port, int byte) { 
    116116        snd_seq_event_t ev; 
    117117        if ((snd_midi_event_encode_byte(port->parser,byte, &ev)) > 0) { 
     
    127127} 
    128128 
    129 int encode_midi_bytes(freebob_midi_port_t *port, unsigned char *byte_buff, int len) { 
     129int encode_midi_bytes(ffado_midi_port_t *port, unsigned char *byte_buff, int len) { 
    130130        return 0; 
    131131} 
     
    140140        int retval=0; 
    141141        int i=0; 
     142        int start_flag = 0; 
    142143 
    143144        int nb_periods=0; 
    144145 
    145         freebob_sample_t **audiobuffers_in; 
    146         freebob_sample_t **audiobuffers_out; 
    147         freebob_sample_t *nullbuffer; 
     146        ffado_sample_t **audiobuffers_in; 
     147        ffado_sample_t **audiobuffers_out; 
     148        ffado_sample_t *nullbuffer; 
    148149         
    149150        run=1; 
    150151 
    151         printf("Freebob MIDI streaming test application (1)\n"); 
     152        printf("Ffado MIDI streaming test application (1)\n"); 
    152153 
    153154        signal (SIGINT, sighandler); 
    154155        signal (SIGPIPE, sighandler); 
    155156 
    156         freebob_device_info_t device_info; 
    157  
    158         freebob_options_t dev_options; 
     157        ffado_device_info_t device_info; 
     158 
     159        ffado_options_t dev_options; 
    159160 
    160161        dev_options.sample_rate=-1; // -1 = detect from discovery 
     
    169170        dev_options.packetizer_priority=60; 
    170171         
    171         freebob_device_t *dev=freebob_streaming_init(&device_info, dev_options); 
     172        ffado_device_t *dev=ffado_streaming_init(&device_info, dev_options); 
    172173        if (!dev) { 
    173                 fprintf(stderr,"Could not init Freebob Streaming layer\n"); 
     174                fprintf(stderr,"Could not init Ffado Streaming layer\n"); 
    174175                exit(-1); 
    175176        } 
    176177 
    177         nb_in_channels=freebob_streaming_get_nb_capture_streams(dev); 
    178         nb_out_channels=freebob_streaming_get_nb_playback_streams(dev); 
     178        nb_in_channels=ffado_streaming_get_nb_capture_streams(dev); 
     179        nb_out_channels=ffado_streaming_get_nb_playback_streams(dev); 
    179180 
    180181        int midi_in_nbchannels=0; 
     
    182183         
    183184        /* allocate intermediate buffers */ 
    184         audiobuffers_in=calloc(nb_in_channels,sizeof(freebob_sample_t *)); 
    185         audiobuffers_out=calloc(nb_in_channels,sizeof(freebob_sample_t)); 
     185        audiobuffers_in=calloc(nb_in_channels,sizeof(ffado_sample_t *)); 
     186        audiobuffers_out=calloc(nb_in_channels,sizeof(ffado_sample_t)); 
    186187        for (i=0;i<nb_in_channels;i++) { 
    187                 audiobuffers_in[i]=calloc(PERIOD_SIZE+1,sizeof(freebob_sample_t)); 
    188                 audiobuffers_out[i]=calloc(PERIOD_SIZE+1,sizeof(freebob_sample_t)); 
     188                audiobuffers_in[i]=calloc(PERIOD_SIZE+1,sizeof(ffado_sample_t)); 
     189                audiobuffers_out[i]=calloc(PERIOD_SIZE+1,sizeof(ffado_sample_t)); 
    189190                         
    190                 switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    191                         case freebob_stream_type_audio: 
     191                switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     192                        case ffado_stream_type_audio: 
    192193                                /* assign the audiobuffer to the stream */ 
    193                                 freebob_streaming_set_capture_stream_buffer(dev, i, (char *)(audiobuffers_in[i])); 
    194                                 freebob_streaming_set_capture_buffer_type(dev, i, freebob_buffer_type_float); 
     194                                ffado_streaming_set_capture_stream_buffer(dev, i, (char *)(audiobuffers_in[i])); 
     195                                ffado_streaming_set_capture_buffer_type(dev, i, ffado_buffer_type_float); 
    195196                                break; 
    196197                                 
    197198                        // this is done with read/write routines because the nb of bytes can differ. 
    198                         case freebob_stream_type_midi: 
     199                        case ffado_stream_type_midi: 
    199200                                midi_in_nbchannels++; 
    200201                        default: 
     
    203204        } 
    204205         
    205         nullbuffer=calloc(PERIOD_SIZE+1,sizeof(freebob_sample_t)); 
     206        nullbuffer=calloc(PERIOD_SIZE+1,sizeof(ffado_sample_t)); 
    206207         
    207208        for (i=0;i<nb_out_channels;i++) { 
    208                 switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    209                         case freebob_stream_type_audio: 
     209                switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     210                        case ffado_stream_type_audio: 
    210211                                if (i<nb_in_channels) { 
    211212                                        /* assign the audiobuffer to the stream */ 
    212                                         freebob_streaming_set_playback_stream_buffer(dev, i, (char *)(audiobuffers_in[i])); 
    213                                         freebob_streaming_set_playback_buffer_type(dev, i, freebob_buffer_type_float); 
     213                                        ffado_streaming_set_playback_stream_buffer(dev, i, (char *)(audiobuffers_in[i])); 
     214                                        ffado_streaming_set_playback_buffer_type(dev, i, ffado_buffer_type_float); 
    214215                                } else { 
    215                                         freebob_streaming_set_playback_stream_buffer(dev, i, (char *)nullbuffer); 
    216                                         freebob_streaming_set_playback_buffer_type(dev, i, freebob_buffer_type_int24);         
     216                                        ffado_streaming_set_playback_stream_buffer(dev, i, (char *)nullbuffer); 
     217                                        ffado_streaming_set_playback_buffer_type(dev, i, ffado_buffer_type_int24);     
    217218                                } 
    218219                                break; 
    219220                                // this is done with read/write routines because the nb of bytes can differ. 
    220                         case freebob_stream_type_midi: 
     221                        case ffado_stream_type_midi: 
    221222                                midi_out_nbchannels++; 
    222223                        default: 
     
    235236                fid_out[i]=fopen(name,"w"); 
    236237 
    237                 freebob_streaming_get_playback_stream_name(dev,i,name,sizeof(name)); 
     238                ffado_streaming_get_playback_stream_name(dev,i,name,sizeof(name)); 
    238239                fprintf(fid_out[i],"Channel name: %s\n",name); 
    239                 switch (freebob_streaming_get_playback_stream_type(dev,i)) { 
    240                 case freebob_stream_type_audio: 
     240                switch (ffado_streaming_get_playback_stream_type(dev,i)) { 
     241                case ffado_stream_type_audio: 
    241242                        fprintf(fid_out[i],"Channel type: audio\n"); 
    242243                        break; 
    243                 case freebob_stream_type_midi: 
     244                case ffado_stream_type_midi: 
    244245                        fprintf(fid_out[i],"Channel type: midi\n"); 
    245246                        break; 
    246                 case freebob_stream_type_unknown: 
     247                case ffado_stream_type_unknown: 
    247248                        fprintf(fid_out[i],"Channel type: unknown\n"); 
    248249                        break; 
    249250                default: 
    250                 case freebob_stream_type_invalid: 
     251                case ffado_stream_type_invalid: 
    251252                        fprintf(fid_out[i],"Channel type: invalid\n"); 
    252253                        break; 
     
    258259                fid_in[i]=fopen(name,"w"); 
    259260 
    260                 freebob_streaming_get_capture_stream_name(dev,i,name,sizeof(name)); 
    261                 fprintf(fid_in[i], "Channel name: %s\n"); 
    262                 switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    263                 case freebob_stream_type_audio: 
     261                ffado_streaming_get_capture_stream_name(dev,i,name,sizeof(name)); 
     262                fprintf(fid_in[i], "Channel name: %s\n", name); 
     263                switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     264                case ffado_stream_type_audio: 
    264265                        fprintf(fid_in[i], "Channel type: audio\n"); 
    265266                        break; 
    266                 case freebob_stream_type_midi: 
     267                case ffado_stream_type_midi: 
    267268                        fprintf(fid_in[i], "Channel type: midi\n"); 
    268269                        break; 
    269                 case freebob_stream_type_unknown: 
     270                case ffado_stream_type_unknown: 
    270271                        fprintf(fid_in[i],"Channel type: unknown\n"); 
    271272                        break; 
    272273                default: 
    273                 case freebob_stream_type_invalid: 
     274                case ffado_stream_type_invalid: 
    274275                        fprintf(fid_in[i],"Channel type: invalid\n"); 
    275276                        break; 
     
    288289        } 
    289290 
    290         freebob_midi_port_t* midi_out_portmap[nb_out_channels]; 
    291         freebob_midi_port_t* midi_in_portmap[nb_in_channels]; 
     291        ffado_midi_port_t* midi_out_portmap[nb_out_channels]; 
     292        ffado_midi_port_t* midi_in_portmap[nb_in_channels]; 
    292293         
    293294        int cnt=0; 
    294295         
    295296        for (i=0;i<nb_out_channels;i++) { 
    296                 freebob_midi_port_t *midi_out_port; 
    297                 switch (freebob_streaming_get_playback_stream_type(dev,i)) { 
    298                         case freebob_stream_type_audio: 
     297                ffado_midi_port_t *midi_out_port; 
     298                switch (ffado_streaming_get_playback_stream_type(dev,i)) { 
     299                        case ffado_stream_type_audio: 
    299300                                midi_out_portmap[i]=NULL; 
    300301                                break; 
    301                         case freebob_stream_type_midi: 
    302                                 midi_out_port=malloc(sizeof(freebob_midi_port_t)); 
     302                        case ffado_stream_type_midi: 
     303                                midi_out_port=malloc(sizeof(ffado_midi_port_t)); 
    303304                                if(!midi_out_port) { 
    304305                                        fprintf(stderr, "Could not allocate memory for MIDI OUT port %d\n",i); 
     
    314315                                } 
    315316                                break; 
     317                        default: break; 
    316318                } 
    317319        } 
     
    319321        cnt=0; 
    320322        for (i=0;i<nb_in_channels;i++) { 
    321                 freebob_midi_port_t *midi_in_port; 
    322                 switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    323                         case freebob_stream_type_audio: 
     323                ffado_midi_port_t *midi_in_port; 
     324                switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     325                        case ffado_stream_type_audio: 
    324326                                midi_in_portmap[i]=NULL; 
    325327                                break; 
    326                         case freebob_stream_type_midi: 
     328                        case ffado_stream_type_midi: 
    327329                 
    328                                 midi_in_port=malloc(sizeof(freebob_midi_port_t)); 
     330                                midi_in_port=malloc(sizeof(ffado_midi_port_t)); 
    329331                                if(!midi_in_port) { 
    330332                                        fprintf(stderr, "Could not allocate memory for MIDI IN port %d\n",i); 
     
    340342                                        midi_in_portmap[i]=midi_in_port; 
    341343                                } 
    342                         break; 
     344                                break; 
     345                        default: break; 
    343346                } 
    344347        }        
    345348         
    346349        // start the streaming layer 
    347         freebob_streaming_start(dev); 
     350        start_flag = ffado_streaming_start(dev); 
    348351 
    349352        fprintf(stderr,"Entering receive loop (%d,%d)\n",nb_in_channels,nb_out_channels); 
    350         while(run) { 
    351                 retval = freebob_streaming_wait(dev); 
     353        while(run && start_flag==0) { 
     354                retval = ffado_streaming_wait(dev); 
    352355                if (retval < 0) { 
    353356                        fprintf(stderr,"Xrun\n"); 
    354                         freebob_streaming_reset(dev); 
     357                        ffado_streaming_reset(dev); 
    355358                        continue; 
    356359                } 
    357360                 
    358 //              freebob_streaming_transfer_buffers(dev); 
    359                 freebob_streaming_transfer_capture_buffers(dev); 
    360                 freebob_streaming_transfer_playback_buffers(dev); 
     361//              ffado_streaming_transfer_buffers(dev); 
     362                ffado_streaming_transfer_capture_buffers(dev); 
     363                ffado_streaming_transfer_playback_buffers(dev); 
    361364                 
    362365                nb_periods++; 
     
    369372                        int s; 
    370373                         
    371                         switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    372                         case freebob_stream_type_audio: 
     374                        switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     375                        case ffado_stream_type_audio: 
    373376                                // no need to get the buffers manually, we have set the API internal buffers to the audiobuffer[i]'s 
    374 //                              //samplesread=freebob_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE); 
     377//                              //samplesread=ffado_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE); 
    375378                                samplesread=PERIOD_SIZE; 
    376379                                break; 
    377                         case freebob_stream_type_midi: 
    378                                 samplesread=freebob_streaming_read(dev, i, audiobuffers_in[i], PERIOD_SIZE); 
     380                        case ffado_stream_type_midi: 
     381                                samplesread=ffado_streaming_read(dev, i, audiobuffers_in[i], PERIOD_SIZE); 
    379382                                quadlet_t *buff=(quadlet_t *)audiobuffers_in[i]; 
    380383                                for (s=0;s<samplesread;s++) { 
     
    385388                                if(samplesread>0) { 
    386389                                        fprintf(fid_in[i], "---- Period read (%d samples) ----\n",samplesread); 
    387                                         hexDumpToFile(fid_in[i],(unsigned char*)audiobuffers_in[i],samplesread*sizeof(freebob_sample_t)); 
    388                                 } 
    389                                 break; 
     390                                        hexDumpToFile(fid_in[i],(unsigned char*)audiobuffers_in[i],samplesread*sizeof(ffado_sample_t)); 
     391                                } 
     392                                break; 
     393                        default: break; 
    390394                        } 
    391395//                      fprintf(fid_in[i], "---- Period read (%d samples) ----\n",samplesread); 
    392 //                      hexDumpToFile(fid_in[i],(unsigned char*)buff,samplesread*sizeof(freebob_sample_t)); 
     396//                      hexDumpToFile(fid_in[i],(unsigned char*)buff,samplesread*sizeof(ffado_sample_t)); 
    393397         
    394398                } 
    395399 
    396400                for(i=0;i<nb_out_channels;i++) { 
    397                         freebob_sample_t *buff; 
     401                        ffado_sample_t *buff; 
    398402                        int b=0; 
    399403                        unsigned char* byte_buff; 
     
    405409                        } 
    406410                         
    407                         switch (freebob_streaming_get_playback_stream_type(dev,i)) { 
    408                         case freebob_stream_type_audio: 
    409 //                              sampleswritten=freebob_streaming_write(dev, i, buff, PERIOD_SIZE); 
     411                        switch (ffado_streaming_get_playback_stream_type(dev,i)) { 
     412                        case ffado_stream_type_audio: 
     413//                              sampleswritten=ffado_streaming_write(dev, i, buff, PERIOD_SIZE); 
    410414//                              sampleswritten=PERIOD_SIZE; 
    411415                                break; 
    412                         case freebob_stream_type_midi: 
     416                        case ffado_stream_type_midi: 
    413417                                 
    414418                                #define max_midi_bytes_to_write PERIOD_SIZE/8 
     
    418422                                 
    419423                                for(b=0;b<sampleswritten;b++) { 
    420                                         freebob_sample_t tmp_event=*(byte_buff+b); 
    421                                         freebob_streaming_write(dev, i, &tmp_event, 1); 
     424                                        ffado_sample_t tmp_event=*(byte_buff+b); 
     425                                        ffado_streaming_write(dev, i, &tmp_event, 1); 
    422426                                } 
    423427                                 
    424428                                 
    425429                                fprintf(fid_out[i], "---- Period write (%d samples) ----\n",sampleswritten); 
    426                                 hexDumpToFile(fid_out[i],(unsigned char*)buff,sampleswritten*sizeof(freebob_sample_t)); 
    427                                 break; 
     430                                hexDumpToFile(fid_out[i],(unsigned char*)buff,sampleswritten*sizeof(ffado_sample_t)); 
     431                                break; 
     432                        default: break; 
    428433                        } 
    429434                } 
     
    435440        fprintf(stderr,"Exiting receive loop\n"); 
    436441         
    437         freebob_streaming_stop(dev); 
    438  
    439         freebob_streaming_finish(dev); 
     442        ffado_streaming_stop(dev); 
     443 
     444        ffado_streaming_finish(dev); 
    440445 
    441446        for (i=0;i<nb_out_channels;i++) { 
     
    457462        // free the MIDI to seq parsers and port structures 
    458463        for(i=0;i<midi_in_nbchannels;i++) { 
    459                 freebob_midi_port_t *midi_in_port=midi_in_portmap[i]; 
     464                ffado_midi_port_t *midi_in_port=midi_in_portmap[i]; 
    460465                 
    461466                if(midi_in_port) { 
     
    466471        // free the MIDI to seq parsers and port structures 
    467472        for(i=0;i<midi_out_nbchannels;i++) { 
    468                 freebob_midi_port_t *midi_out_port=midi_out_portmap[i]; 
     473                ffado_midi_port_t *midi_out_port=midi_out_portmap[i]; 
    469474 
    470475                if(midi_out_port) { 
  • trunk/libffado/tests/streaming/teststreaming.c

    r445 r514  
    3636#include <signal.h> 
    3737 
    38 #include "libfreebob/freebob_streaming.h" 
     38#include "libffado/ffado.h" 
    3939 
    4040#include "debugtools.h" 
     
    5656        int retval=0; 
    5757        int i=0; 
     58        int start_flag = 0; 
    5859 
    5960        int nb_periods=0; 
    6061 
    61         freebob_sample_t **audiobuffer; 
    62         freebob_sample_t *nullbuffer; 
     62        ffado_sample_t **audiobuffer; 
     63        ffado_sample_t *nullbuffer; 
    6364         
    6465        run=1; 
    6566 
    66         printf("Freebob streaming test application\n"); 
     67        printf("Ffado streaming test application\n"); 
    6768 
    6869        signal (SIGINT, sighandler); 
    6970        signal (SIGPIPE, sighandler); 
    7071 
    71         freebob_device_info_t device_info; 
    72  
    73         freebob_options_t dev_options; 
     72        ffado_device_info_t device_info; 
     73 
     74        ffado_options_t dev_options; 
    7475 
    7576        dev_options.sample_rate=44100; 
     
    8485        dev_options.packetizer_priority=60; 
    8586 
    86         freebob_device_t *dev=freebob_streaming_init(&device_info, dev_options); 
     87        ffado_device_t *dev=ffado_streaming_init(&device_info, dev_options); 
    8788        if (!dev) { 
    88                 fprintf(stderr,"Could not init Freebob Streaming layer\n"); 
     89                fprintf(stderr,"Could not init Ffado Streaming layer\n"); 
    8990                exit(-1); 
    9091        } 
    9192 
    92         nb_in_channels=freebob_streaming_get_nb_capture_streams(dev); 
    93         nb_out_channels=freebob_streaming_get_nb_playback_streams(dev); 
     93        nb_in_channels=ffado_streaming_get_nb_capture_streams(dev); 
     94        nb_out_channels=ffado_streaming_get_nb_playback_streams(dev); 
    9495 
    9596        /* allocate intermediate buffers */ 
    96         audiobuffer=calloc(nb_in_channels,sizeof(freebob_sample_t *)); 
    97         for (i=0;i<nb_in_channels;i++) { 
    98                 audiobuffer[i]=calloc(PERIOD_SIZE+1,sizeof(freebob_sample_t)); 
    99         } 
    100          
    101         nullbuffer=calloc(PERIOD_SIZE+1,sizeof(freebob_sample_t)); 
     97        audiobuffer=calloc(nb_in_channels,sizeof(ffado_sample_t *)); 
     98        for (i=0;i<nb_in_channels;i++) { 
     99                audiobuffer[i]=calloc(PERIOD_SIZE+1,sizeof(ffado_sample_t)); 
     100        } 
     101         
     102        nullbuffer=calloc(PERIOD_SIZE+1,sizeof(ffado_sample_t)); 
    102103         
    103104        /* open the files to write to*/ 
     
    111112                fid_out[i]=fopen(name,"w"); 
    112113 
    113                 freebob_streaming_get_playback_stream_name(dev,i,name,sizeof(name)); 
     114                ffado_streaming_get_playback_stream_name(dev,i,name,sizeof(name)); 
    114115                fprintf(fid_out[i],"Channel name: %s\n",name); 
    115                 switch (freebob_streaming_get_playback_stream_type(dev,i)) { 
    116                 case freebob_stream_type_audio: 
     116                switch (ffado_streaming_get_playback_stream_type(dev,i)) { 
     117                case ffado_stream_type_audio: 
    117118                        fprintf(fid_out[i],"Channel type: audio\n"); 
    118119                        break; 
    119                 case freebob_stream_type_midi: 
     120                case ffado_stream_type_midi: 
    120121                        fprintf(fid_out[i],"Channel type: midi\n"); 
    121122                        break; 
    122                 case freebob_stream_type_unknown: 
     123                case ffado_stream_type_unknown: 
    123124                        fprintf(fid_out[i],"Channel type: unknown\n"); 
    124125                        break; 
    125126                default: 
    126                 case freebob_stream_type_invalid: 
     127                case ffado_stream_type_invalid: 
    127128                        fprintf(fid_out[i],"Channel type: invalid\n"); 
    128129                        break; 
     
    134135                fid_in[i]=fopen(name,"w"); 
    135136 
    136                 freebob_streaming_get_capture_stream_name(dev,i,name,sizeof(name)); 
     137                ffado_streaming_get_capture_stream_name(dev,i,name,sizeof(name)); 
    137138                fprintf(fid_in[i], "Channel name: %s\n",name); 
    138                 switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    139                 case freebob_stream_type_audio: 
     139                switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     140                case ffado_stream_type_audio: 
    140141                        fprintf(fid_in[i], "Channel type: audio\n"); 
    141142                        break; 
    142                 case freebob_stream_type_midi: 
     143                case ffado_stream_type_midi: 
    143144                        fprintf(fid_in[i], "Channel type: midi\n"); 
    144145                        break; 
    145                 case freebob_stream_type_unknown: 
     146                case ffado_stream_type_unknown: 
    146147                        fprintf(fid_in[i],"Channel type: unknown\n"); 
    147148                        break; 
    148149                default: 
    149                 case freebob_stream_type_invalid: 
     150                case ffado_stream_type_invalid: 
    150151                        fprintf(fid_in[i],"Channel type: invalid\n"); 
    151152                        break; 
     
    153154        } 
    154155 
    155         freebob_streaming_prepare(dev); 
    156         freebob_streaming_start(dev); 
     156        ffado_streaming_prepare(dev); 
     157        start_flag = ffado_streaming_start(dev); 
    157158 
    158159        fprintf(stderr,"Entering receive loop (%d,%d)\n",nb_in_channels,nb_out_channels); 
    159         while(run) { 
    160                 retval = freebob_streaming_wait(dev); 
     160        while(run && start_flag==0) { 
     161                retval = ffado_streaming_wait(dev); 
    161162                if (retval < 0) { 
    162163                        fprintf(stderr,"Xrun\n"); 
    163                         freebob_streaming_reset(dev); 
     164                        ffado_streaming_reset(dev); 
    164165                        continue; 
    165166                } 
    166167 
    167 //              freebob_streaming_transfer_buffers(dev); 
    168                 freebob_streaming_transfer_capture_buffers(dev); 
    169                 freebob_streaming_transfer_playback_buffers(dev); 
     168//              ffado_streaming_transfer_buffers(dev); 
     169                ffado_streaming_transfer_capture_buffers(dev); 
     170                ffado_streaming_transfer_playback_buffers(dev); 
    170171                 
    171172                nb_periods++; 
     
    176177 
    177178                for(i=0;i<nb_in_channels;i++) { 
    178                         switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    179                         case freebob_stream_type_audio: 
    180                                 samplesread=freebob_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE); 
    181                                 break; 
    182                         case freebob_stream_type_midi: 
    183                                 samplesread=freebob_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE); 
     179                        switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     180                        case ffado_stream_type_audio: 
     181                                samplesread=ffado_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE); 
     182                                break; 
     183                        case ffado_stream_type_midi: 
     184                                samplesread=ffado_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE); 
    184185                                break; 
    185186                        default: 
     
    187188                        } 
    188189//                      fprintf(fid_in[i], "---- Period read  (%d samples) ----\n",samplesread); 
    189 //                      hexDumpToFile(fid_in[i],(unsigned char*)audiobuffer[i],samplesread*sizeof(freebob_sample_t)); 
     190//                      hexDumpToFile(fid_in[i],(unsigned char*)audiobuffer[i],samplesread*sizeof(ffado_sample_t)); 
    190191                } 
    191192 
    192193                for(i=0;i<nb_out_channels;i++) { 
    193                         freebob_sample_t *buff; 
     194                        ffado_sample_t *buff; 
    194195                        if (i<nb_in_channels) { 
    195196                                buff=audiobuffer[i]; 
     
    198199                        } 
    199200                         
    200                         switch (freebob_streaming_get_playback_stream_type(dev,i)) { 
    201                         case freebob_stream_type_audio: 
    202                                 sampleswritten=freebob_streaming_write(dev, i, buff, PERIOD_SIZE); 
    203                                 break; 
    204                         case freebob_stream_type_midi: 
    205                                 sampleswritten=freebob_streaming_write(dev, i, buff, PERIOD_SIZE); 
     201                        switch (ffado_streaming_get_playback_stream_type(dev,i)) { 
     202                        case ffado_stream_type_audio: 
     203                                sampleswritten=ffado_streaming_write(dev, i, buff, PERIOD_SIZE); 
     204                                break; 
     205                        case ffado_stream_type_midi: 
     206                                sampleswritten=ffado_streaming_write(dev, i, buff, PERIOD_SIZE); 
    206207                                break; 
    207208                        default: 
     
    209210                        } 
    210211//                      fprintf(fid_out[i], "---- Period write (%d samples) ----\n",sampleswritten); 
    211 //                      hexDumpToFile(fid_out[i],(unsigned char*)buff,sampleswritten*sizeof(freebob_sample_t)); 
     212//                      hexDumpToFile(fid_out[i],(unsigned char*)buff,sampleswritten*sizeof(ffado_sample_t)); 
    212213                } 
    213214 
     
    218219        fprintf(stderr,"Exiting receive loop\n"); 
    219220         
    220         freebob_streaming_stop(dev); 
    221  
    222         freebob_streaming_finish(dev); 
     221        ffado_streaming_stop(dev); 
     222 
     223        ffado_streaming_finish(dev); 
    223224 
    224225        for (i=0;i<nb_out_channels;i++) { 
  • trunk/libffado/tests/streaming/teststreaming3.c

    r445 r514  
    3838#include <signal.h> 
    3939 
    40 #include "libfreebob/freebob_streaming.h" 
     40#include "libffado/ffado.h" 
    4141 
    4242#include "debugtools.h" 
     
    5959        int retval=0; 
    6060        int i=0; 
     61        int start_flag = 0; 
    6162 
    6263        int nb_periods=0; 
    6364 
    6465        float **audiobuffers_in; 
    65         freebob_sample_t **audiobuffers_out; 
    66         freebob_sample_t *nullbuffer; 
     66        ffado_sample_t **audiobuffers_out; 
     67        ffado_sample_t *nullbuffer; 
    6768         
    6869        run=1; 
    6970 
    70         printf("Freebob streaming test application (3)\n"); 
     71        printf("Ffado streaming test application (3)\n"); 
    7172 
    7273        signal (SIGINT, sighandler); 
    7374        signal (SIGPIPE, sighandler); 
    7475 
    75         freebob_device_info_t device_info; 
    76  
    77         freebob_options_t dev_options; 
     76        ffado_device_info_t device_info; 
     77 
     78        ffado_options_t dev_options; 
    7879 
    7980        dev_options.sample_rate=44100; 
     
    8889        dev_options.packetizer_priority=70; 
    8990         
    90         freebob_device_t *dev=freebob_streaming_init(&device_info, dev_options); 
     91        ffado_device_t *dev=ffado_streaming_init(&device_info, dev_options); 
    9192        if (!dev) { 
    92                 fprintf(stderr,"Could not init Freebob Streaming layer\n"); 
     93                fprintf(stderr,"Could not init Ffado Streaming layer\n"); 
    9394                exit(-1); 
    9495        } 
    9596 
    96         nb_in_channels=freebob_streaming_get_nb_capture_streams(dev); 
    97         nb_out_channels=freebob_streaming_get_nb_playback_streams(dev); 
     97        nb_in_channels=ffado_streaming_get_nb_capture_streams(dev); 
     98        nb_out_channels=ffado_streaming_get_nb_playback_streams(dev); 
    9899 
    99100        /* allocate intermediate buffers */ 
    100101        audiobuffers_in=calloc(nb_in_channels,sizeof(float *)); 
    101         audiobuffers_out=calloc(nb_in_channels,sizeof(freebob_sample_t)); 
     102        audiobuffers_out=calloc(nb_in_channels,sizeof(ffado_sample_t)); 
    102103        for (i=0;i<nb_in_channels;i++) { 
    103104                audiobuffers_in[i]=calloc(PERIOD_SIZE+1,sizeof(float)); 
    104                 audiobuffers_out[i]=calloc(PERIOD_SIZE+1,sizeof(freebob_sample_t)); 
    105                          
    106                 switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    107                         case freebob_stream_type_audio: 
     105                audiobuffers_out[i]=calloc(PERIOD_SIZE+1,sizeof(ffado_sample_t)); 
     106                         
     107                switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     108                        case ffado_stream_type_audio: 
    108109                                /* assign the audiobuffer to the stream */ 
    109                                 freebob_streaming_set_capture_stream_buffer(dev, i, (char *)(audiobuffers_in[i])); 
    110                                 freebob_streaming_set_capture_buffer_type(dev, i, freebob_buffer_type_float); 
     110                                ffado_streaming_set_capture_stream_buffer(dev, i, (char *)(audiobuffers_in[i])); 
     111                                ffado_streaming_set_capture_buffer_type(dev, i, ffado_buffer_type_float); 
    111112                                break; 
    112113                                // this is done with read/write routines because the nb of bytes can differ. 
    113                         case freebob_stream_type_midi: 
     114                        case ffado_stream_type_midi: 
    114115                        default: 
    115116                                break; 
     
    117118        } 
    118119         
    119         nullbuffer=calloc(PERIOD_SIZE+1,sizeof(freebob_sample_t)); 
     120        nullbuffer=calloc(PERIOD_SIZE+1,sizeof(ffado_sample_t)); 
    120121         
    121122        for (i=0;i<nb_out_channels;i++) { 
    122                 switch (freebob_streaming_get_playback_stream_type(dev,i)) { 
    123                         case freebob_stream_type_audio: 
     123                switch (ffado_streaming_get_playback_stream_type(dev,i)) { 
     124                        case ffado_stream_type_audio: 
    124125                                if (i<nb_in_channels) { 
    125126                                        /* assign the audiobuffer to the stream */ 
    126                                         freebob_streaming_set_playback_stream_buffer(dev, i, (char *)(audiobuffers_in[i])); 
    127                                         freebob_streaming_set_playback_buffer_type(dev, i, freebob_buffer_type_float); 
     127                                        ffado_streaming_set_playback_stream_buffer(dev, i, (char *)(audiobuffers_in[i])); 
     128                                        ffado_streaming_set_playback_buffer_type(dev, i, ffado_buffer_type_float); 
    128129                                } else { 
    129                                         freebob_streaming_set_playback_stream_buffer(dev, i, (char *)nullbuffer); 
    130                                         freebob_streaming_set_playback_buffer_type(dev, i, freebob_buffer_type_int24);         
     130                                        ffado_streaming_set_playback_stream_buffer(dev, i, (char *)nullbuffer); 
     131                                        ffado_streaming_set_playback_buffer_type(dev, i, ffado_buffer_type_int24);     
    131132                                } 
    132133                                break; 
    133134                                // this is done with read/write routines because the nb of bytes can differ. 
    134                         case freebob_stream_type_midi: 
     135                        case ffado_stream_type_midi: 
    135136                        default: 
    136137                                break; 
     
    148149                fid_out[i]=fopen(name,"w"); 
    149150 
    150                 freebob_streaming_get_playback_stream_name(dev,i,name,sizeof(name)); 
     151                ffado_streaming_get_playback_stream_name(dev,i,name,sizeof(name)); 
    151152                fprintf(fid_out[i],"Channel name: %s\n",name); 
    152                 switch (freebob_streaming_get_playback_stream_type(dev,i)) { 
    153                 case freebob_stream_type_audio: 
     153                switch (ffado_streaming_get_playback_stream_type(dev,i)) { 
     154                case ffado_stream_type_audio: 
    154155                        fprintf(fid_out[i],"Channel type: audio\n"); 
    155156                        break; 
    156                 case freebob_stream_type_midi: 
     157                case ffado_stream_type_midi: 
    157158                        fprintf(fid_out[i],"Channel type: midi\n"); 
    158159                        break; 
    159                 case freebob_stream_type_unknown: 
     160                case ffado_stream_type_unknown: 
    160161                        fprintf(fid_out[i],"Channel type: unknown\n"); 
    161162                        break; 
    162163                default: 
    163                 case freebob_stream_type_invalid: 
     164                case ffado_stream_type_invalid: 
    164165                        fprintf(fid_out[i],"Channel type: invalid\n"); 
    165166                        break; 
     
    171172                fid_in[i]=fopen(name,"w"); 
    172173 
    173                 freebob_streaming_get_capture_stream_name(dev,i,name,sizeof(name)); 
    174                 fprintf(fid_in[i], "Channel name: %s\n"); 
    175                 switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    176                 case freebob_stream_type_audio: 
     174                ffado_streaming_get_capture_stream_name(dev,i,name,sizeof(name)); 
     175                fprintf(fid_in[i], "Channel name: %s\n",name); 
     176                switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     177                case ffado_stream_type_audio: 
    177178                        fprintf(fid_in[i], "Channel type: audio\n"); 
    178179                        break; 
    179                 case freebob_stream_type_midi: 
     180                case ffado_stream_type_midi: 
    180181                        fprintf(fid_in[i], "Channel type: midi\n"); 
    181182                        break; 
    182                 case freebob_stream_type_unknown: 
     183                case ffado_stream_type_unknown: 
    183184                        fprintf(fid_in[i],"Channel type: unknown\n"); 
    184185                        break; 
    185186                default: 
    186                 case freebob_stream_type_invalid: 
     187                case ffado_stream_type_invalid: 
    187188                        fprintf(fid_in[i],"Channel type: invalid\n"); 
    188189                        break; 
     
    191192 
    192193        // start the streaming layer 
    193         freebob_streaming_start(dev); 
     194        ffado_streaming_prepare(dev); 
     195        start_flag = ffado_streaming_start(dev); 
    194196 
    195197        fprintf(stderr,"Entering receive loop (%d,%d)\n",nb_in_channels,nb_out_channels); 
    196         while(run) { 
    197                 retval = freebob_streaming_wait(dev); 
     198        while(run && start_flag==0) { 
     199                retval = ffado_streaming_wait(dev); 
    198200                if (retval < 0) { 
    199201                        fprintf(stderr,"Xrun\n"); 
    200                         freebob_streaming_reset(dev); 
     202                        ffado_streaming_reset(dev); 
    201203                        continue; 
    202204                } 
    203205                 
    204 //              freebob_streaming_transfer_buffers(dev); 
    205                 freebob_streaming_transfer_capture_buffers(dev); 
    206                 freebob_streaming_transfer_playback_buffers(dev); 
     206//              ffado_streaming_transfer_buffers(dev); 
     207                ffado_streaming_transfer_capture_buffers(dev); 
     208                ffado_streaming_transfer_playback_buffers(dev); 
    207209                 
    208210                nb_periods++; 
     
    215217                         
    216218                         
    217                         switch (freebob_streaming_get_capture_stream_type(dev,i)) { 
    218                         case freebob_stream_type_audio: 
     219                        switch (ffado_streaming_get_capture_stream_type(dev,i)) { 
     220                        case ffado_stream_type_audio: 
    219221                                // no need to get the buffers manually, we have set the API internal buffers to the audiobuffer[i]'s 
    220222//                              //samplesread=freebob_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE); 
    221223                                samplesread=PERIOD_SIZE; 
    222224                                break; 
    223                         case freebob_stream_type_midi: 
    224                                 samplesread=freebob_streaming_read(dev, i, audiobuffers_out[i], PERIOD_SIZE); 
    225                                 break; 
     225                        case ffado_stream_type_midi: 
     226                                samplesread=ffado_streaming_read(dev, i, audiobuffers_out[i], PERIOD_SIZE); 
     227                                break; 
     228                        default: break; 
    226229                        } 
    227230         
     
    231234 
    232235                for(i=0;i<nb_out_channels;i++) { 
    233                         freebob_sample_t *buff; 
     236                        ffado_sample_t *buff; 
    234237                        int sampleswritten=0; 
    235238                        if (i<nb_in_channels) { 
     
    239242                        } 
    240243                         
    241                         switch (freebob_streaming_get_playback_stream_type(dev,i)) { 
    242                         case freebob_stream_type_audio: 
     244                        switch (ffado_streaming_get_playback_stream_type(dev,i)) { 
     245                        case ffado_stream_type_audio: 
    243246//                              sampleswritten=freebob_streaming_write(dev, i, buff, PERIOD_SIZE); 
    244247                                sampleswritten=PERIOD_SIZE; 
    245248                                break; 
    246                         case freebob_stream_type_midi: 
     249                        case ffado_stream_type_midi: 
    247250//                              sampleswritten=freebob_streaming_write(dev, i, buff, PERIOD_SIZE); 
    248251                                break; 
     252                        default: break; 
    249253                        } 
    250254//                      fprintf(fid_out[i], "---- Period write (%d samples) ----\n",sampleswritten); 
    251 //                      hexDumpToFile(fid_out[i],(unsigned char*)buff,sampleswritten*sizeof(freebob_sample_t)); 
     255//                      hexDumpToFile(fid_out[i],(unsigned char*)buff,sampleswritten*sizeof(ffado_sample_t)); 
    252256                } 
    253257 
     
    258262        fprintf(stderr,"Exiting receive loop\n"); 
    259263         
    260         freebob_streaming_stop(dev); 
    261  
    262         freebob_streaming_finish(dev); 
     264        ffado_streaming_stop(dev); 
     265 
     266        ffado_streaming_finish(dev); 
    263267 
    264268        for (i=0;i<nb_out_channels;i++) {