root/trunk/libffado/tests/streaming/teststreaming3.c

Revision 742, 7.8 kB (checked in by ppalmers, 13 years ago)

- Remove some obsolete support files and dirs

- Clean up the license statements in the source files. Everything is

GPL version 3 now.

- Add license and copyright notices to scons scripts

- Clean up some other text files

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