root/branches/libfreebob-2.0/tests/streaming/teststreaming2.c

Revision 285, 8.1 kB (checked in by jwoithe, 16 years ago)

Connect ports to the Motu playback stream handlers & make playback work.
Make teststreaming2.c copy input ports to output ports for testing.

  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
Line 
1 /***************************************************************************
2   Copyright (C) 2005 by Pieter Palmers   *
3                                                                        *
4   This program is free software; you can redistribute it and/or modify  *
5   it under the terms of the GNU General Public License as published by  *
6   the Free Software Foundation; either version 2 of the License, or     *
7   (at your option) any later version.                                   *
8                                                                         *
9   This program is distributed in the hope that it will be useful,       *
10   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
12   GNU General Public License for more details.                          *
13                                                                         *
14   You should have received a copy of the GNU General Public License     *
15   along with this program; if not, write to the                         *
16   Free Software Foundation, Inc.,                                       *
17   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
18  ***************************************************************************/
19
20
21 /**
22  * Test application for the direct decode stream API
23  *
24  */
25
26 #ifdef HAVE_CONFIG_H
27 #include <config.h>
28 #endif
29
30 #include <stdio.h>
31 #include <stdlib.h>
32 #include <string.h>
33
34 #include <signal.h>
35
36 #include "libfreebob/freebob_streaming.h"
37
38 #include "debugtools.h"
39
40 int run;
41
42 static void sighandler (int sig)
43 {
44         run = 0;
45 }
46
47 int main(int argc, char *argv[])
48 {
49
50         #define PERIOD_SIZE 1024
51
52         int samplesread=0, sampleswritten=0;
53         int nb_in_channels=0, nb_out_channels=0;
54         int retval=0;
55         int i=0;
56
57         int nb_periods=0;
58
59         freebob_sample_t **audiobuffer;
60         freebob_sample_t *nullbuffer;
61        
62         run=1;
63
64         printf("Freebob streaming test application (2)\n");
65
66         signal (SIGINT, sighandler);
67         signal (SIGPIPE, sighandler);
68
69         freebob_device_info_t device_info;
70
71         freebob_options_t dev_options;
72
73         dev_options.sample_rate=44100;
74         dev_options.period_size=PERIOD_SIZE;
75
76         dev_options.nb_buffers=3;
77
78         dev_options.port=0;
79         dev_options.node_id=-1;
80        
81         dev_options.realtime=0;
82         dev_options.packetizer_priority=60;
83
84         freebob_device_t *dev=freebob_streaming_init(&device_info, dev_options);
85         if (!dev) {
86                 fprintf(stderr,"Could not init Freebob Streaming layer\n");
87                 exit(-1);
88         }
89
90         nb_in_channels=freebob_streaming_get_nb_capture_streams(dev);
91         nb_out_channels=freebob_streaming_get_nb_playback_streams(dev);
92
93         /* allocate intermediate buffers */
94         audiobuffer=calloc(nb_in_channels,sizeof(freebob_sample_t *));
95         for (i=0;i<nb_in_channels;i++) {
96                 audiobuffer[i]=calloc(PERIOD_SIZE+1,sizeof(freebob_sample_t));
97                        
98                 switch (freebob_streaming_get_capture_stream_type(dev,i)) {
99                         case freebob_stream_type_audio:
100                                 /* assign the audiobuffer to the stream */
101                                 freebob_streaming_set_capture_stream_buffer(dev, i, (char *)(audiobuffer[i]));
102                                 freebob_streaming_set_capture_buffer_type(dev, i, freebob_buffer_type_int24);
103                                 break;
104                                 // this is done with read/write routines because the nb of bytes can differ.
105                         case freebob_stream_type_midi:
106                         default:
107                                 break;
108                 }
109         }
110        
111         nullbuffer=calloc(PERIOD_SIZE+1,sizeof(freebob_sample_t));
112
113 #if 1
114         for (i=0;i<nb_out_channels;i++) {
115                 switch (freebob_streaming_get_capture_stream_type(dev,i)) {
116                         case freebob_stream_type_audio:
117                                 if (i<nb_in_channels) {
118                                         /* assign the audiobuffer to the stream */
119                                         freebob_streaming_set_playback_stream_buffer(dev, i, (char *)audiobuffer[i]);
120                                 } else {
121                                         freebob_streaming_set_playback_stream_buffer(dev, i, (char *)nullbuffer);
122                                 }
123                                 freebob_streaming_set_playback_buffer_type(dev, i, freebob_buffer_type_int24);
124                                 break;
125                                 // this is done with read/write routines because the nb of bytes can differ.
126                         case freebob_stream_type_midi:
127                         default:
128                                 break;
129                 }
130         }
131 #endif
132        
133         /* open the files to write to*/
134         FILE* fid_out[nb_out_channels];
135         FILE* fid_in[nb_in_channels];
136         char name[256];
137
138         for (i=0;i<nb_out_channels;i++) {
139                 snprintf(name,sizeof(name),"out_ch_%02d",i);
140
141                 fid_out[i]=fopen(name,"w");
142
143                 freebob_streaming_get_playback_stream_name(dev,i,name,sizeof(name));
144                 fprintf(fid_out[i],"Channel name: %s\n",name);
145                 switch (freebob_streaming_get_playback_stream_type(dev,i)) {
146                 case freebob_stream_type_audio:
147                         fprintf(fid_out[i],"Channel type: audio\n");
148                         break;
149                 case freebob_stream_type_midi:
150                         fprintf(fid_out[i],"Channel type: midi\n");
151                         break;
152                 case freebob_stream_type_unknown:
153                         fprintf(fid_out[i],"Channel type: unknown\n");
154                         break;
155                 default:
156                 case freebob_stream_type_invalid:
157                         fprintf(fid_out[i],"Channel type: invalid\n");
158                         break;
159                 }
160
161         }
162         for (i=0;i<nb_in_channels;i++) {
163                 snprintf(name,sizeof(name),"in_ch_%02d",i);
164                 fid_in[i]=fopen(name,"w");
165
166                 freebob_streaming_get_capture_stream_name(dev,i,name,sizeof(name));
167                 fprintf(fid_in[i], "Channel name: %s\n",name);
168                 switch (freebob_streaming_get_capture_stream_type(dev,i)) {
169                 case freebob_stream_type_audio:
170                         fprintf(fid_in[i], "Channel type: audio\n");
171                         break;
172                 case freebob_stream_type_midi:
173                         fprintf(fid_in[i], "Channel type: midi\n");
174                         break;
175                 case freebob_stream_type_unknown:
176                         fprintf(fid_in[i],"Channel type: unknown\n");
177                         break;
178                 default:
179                 case freebob_stream_type_invalid:
180                         fprintf(fid_in[i],"Channel type: invalid\n");
181                         break;
182                 }
183         }
184
185 FILE *of=fopen("foo.dat","w");
186
187         // prepare and start the streaming layer
188         freebob_streaming_prepare(dev);
189         freebob_streaming_start(dev);
190
191         fprintf(stderr,"Entering receive loop (%d,%d)\n",nb_in_channels,nb_out_channels);
192         while(run) {
193                 retval = freebob_streaming_wait(dev);
194                 if (retval < 0) {
195                         fprintf(stderr,"Xrun\n");
196                         freebob_streaming_reset(dev);
197                         continue;
198                 }
199                
200                 for (i=0;i<nb_in_channels;i++) {
201                         memset(audiobuffer[i],0xCC,(PERIOD_SIZE+1)*sizeof(freebob_sample_t));
202                 }
203
204 //              freebob_streaming_transfer_buffers(dev);
205                 freebob_streaming_transfer_capture_buffers(dev);
206                 freebob_streaming_transfer_playback_buffers(dev);
207                
208                 nb_periods++;
209
210                 if((nb_periods % 32)==0) {
211                         fprintf(stderr,"\r%05d periods",nb_periods);
212                 }
213
214                 for(i=0;i<nb_in_channels;i++) {
215                        
216                        
217                         switch (freebob_streaming_get_capture_stream_type(dev,i)) {
218                         case freebob_stream_type_audio:
219                                 // no need to get the buffers manually, we have set the API internal buffers to the audiobuffer[i]'s
220 //                              //samplesread=freebob_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE);
221                                 samplesread=PERIOD_SIZE;
222                                 break;
223                         case freebob_stream_type_midi:
224                                 samplesread=freebob_streaming_read(dev, i, audiobuffer[i], PERIOD_SIZE);
225                                 break;
226                         default:
227                                 ;
228                         }
229        
230 //                      fprintf(fid_in[i], "---- Period read  (%d samples) ----\n",samplesread);
231 //                      hexDumpToFile(fid_in[i],(unsigned char*)audiobuffer[i],samplesread*sizeof(freebob_sample_t)+1);
232 // FIXME: Dump analog1 as raw data to a separate binary file for testing
233 if (i==2) {
234   fwrite(audiobuffer[i],sizeof(freebob_sample_t),samplesread,of);
235 }
236                 }
237
238                 for(i=0;i<nb_out_channels;i++) {
239                         freebob_sample_t *buff;
240                         if (i<nb_in_channels) {
241                                 buff=audiobuffer[i];
242                         } else {
243                                 buff=nullbuffer;
244                         }
245                        
246                         switch (freebob_streaming_get_playback_stream_type(dev,i)) {
247                         case freebob_stream_type_audio:
248 //// Calling freebob_streaming_write() causes problems since the buffer is external here.
249 //// Just mirror the read case since it seems to work.
250 ////                            sampleswritten=freebob_streaming_write(dev, i, buff, PERIOD_SIZE);
251                                 sampleswritten=PERIOD_SIZE;
252                                 break;
253                         case freebob_stream_type_midi:
254                                 sampleswritten=freebob_streaming_write(dev, i, buff, PERIOD_SIZE);
255                                 break;
256                         default:
257                                 ;
258                         }
259 //                      fprintf(fid_out[i], "---- Period write (%d samples) ----\n",sampleswritten);
260 //                      hexDumpToFile(fid_out[i],(unsigned char*)buff,sampleswritten*sizeof(freebob_sample_t));
261                 }
262
263         }
264
265         fprintf(stderr,"\n");
266
267         fprintf(stderr,"Exiting receive loop\n");
268        
269         freebob_streaming_stop(dev);
270
271         freebob_streaming_finish(dev);
272 fclose(of);
273
274         for (i=0;i<nb_out_channels;i++) {
275                 fclose(fid_out[i]);
276
277         }
278         for (i=0;i<nb_in_channels;i++) {
279                 fclose(fid_in[i]);
280         }
281        
282         for (i=0;i<nb_in_channels;i++) {
283                 free(audiobuffer[i]);
284         }
285         free(nullbuffer);
286         free(audiobuffer);
287
288   return EXIT_SUCCESS;
289 }
Note: See TracBrowser for help on using the browser.