root/trunk/libffado/tests/test-mixer.cpp

Revision 742, 7.7 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

Line 
1 /*
2  * Copyright (C) 2005-2007 by Daniel Wagner
3  * Copyright (C) 2005-2007 by Pieter Palmers
4  *
5  * This file is part of FFADO
6  * FFADO = Free Firewire (pro-)audio drivers for linux
7  *
8  * FFADO is based upon FreeBoB.
9  *
10  * This program is free software: you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation, either version 3 of the License, or
13  * (at your option) any later version.
14  *
15  * This program is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  * GNU General Public License for more details.
19  *
20  * You should have received a copy of the GNU General Public License
21  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
22  *
23  */
24
25 #include "libavc/avc_function_block.h"
26 #include "libavc/avc_serialize.h"
27 #include "debugmodule/debugmodule.h"
28
29 #include "libieee1394/ieee1394service.h"
30 #include <string.h>
31
32 DECLARE_GLOBAL_DEBUG_MODULE;
33
34 const bool bVerbose = true;
35
36 bool
37 doApp( Ieee1394Service& ieee1394service, int node_id, int fb_id )
38 {
39     FunctionBlockCmd fbCmd( ieee1394service,
40                             FunctionBlockCmd::eFBT_Processing,
41                             fb_id,
42                             FunctionBlockCmd::eCA_Current );
43     fbCmd.setNodeId( node_id );
44     fbCmd.setSubunitId( 0x00 );
45     fbCmd.setCommandType( AVCCommand::eCT_Status );
46     fbCmd.m_pFBProcessing->m_pEnhancedMixer = new FunctionBlockProcessingEnhancedMixer;
47
48     debugOutput(DEBUG_LEVEL_NORMAL, "Requesting mixer programmable state...\n");
49
50     fbCmd.m_pFBProcessing->m_fbInputPlugNumber = 0x00;
51     fbCmd.m_pFBProcessing->m_inputAudioChannelNumber  = 0xff;
52     fbCmd.m_pFBProcessing->m_outputAudioChannelNumber = 0xff;
53     fbCmd.m_pFBProcessing->m_pEnhancedMixer->m_statusSelector
54         = FunctionBlockProcessingEnhancedMixer::eSS_ProgramableState;
55
56     fbCmd.setVerbose( bVerbose );
57     if (bVerbose) {
58         ieee1394service.setVerboseLevel( DEBUG_LEVEL_VERY_VERBOSE );
59     }
60
61     if ( !fbCmd.fire() ) {
62         debugError( "cmd failed\n" );
63     }
64
65     if ( bVerbose ) {
66         CoutSerializer se;
67         fbCmd.serialize( se );
68     }
69    
70     debugOutput(DEBUG_LEVEL_NORMAL, "Requesting mixer level state...\n");
71    
72     fbCmd.m_pFBProcessing->m_fbInputPlugNumber = 0x00;
73     fbCmd.m_pFBProcessing->m_inputAudioChannelNumber  = 0x00;
74     fbCmd.m_pFBProcessing->m_outputAudioChannelNumber = 0x00;
75     fbCmd.m_pFBProcessing->m_pEnhancedMixer->m_statusSelector
76         = FunctionBlockProcessingEnhancedMixer::eSS_Level;
77    
78     if ( !fbCmd.fire() ) {
79         debugError( "cmd failed\n" );
80     }
81
82     if ( bVerbose ) {
83         CoutSerializer se;
84         fbCmd.serialize( se );
85     }
86
87     return true;
88 }
89
90 bool
91 selectorGet( Ieee1394Service& ieee1394service, int node_id, int fb_id )
92 {
93     FunctionBlockCmd fbCmd( ieee1394service,
94                             FunctionBlockCmd::eFBT_Selector,
95                             fb_id,
96                             FunctionBlockCmd::eCA_Current );
97     fbCmd.setNodeId( node_id );
98     fbCmd.setSubunitId( 0x00 );
99     fbCmd.setCommandType( AVCCommand::eCT_Status );
100     fbCmd.m_pFBSelector->m_inputFbPlugNumber=0;
101
102     debugOutput(DEBUG_LEVEL_NORMAL, "Requesting selector state...\n");
103
104     fbCmd.setVerbose( bVerbose );
105     if (bVerbose) {
106         ieee1394service.setVerboseLevel( DEBUG_LEVEL_VERY_VERBOSE );
107     }
108    
109     if ( !fbCmd.fire() ) {
110         debugError( "cmd failed\n" );
111     }
112
113     if ( bVerbose ) {
114         CoutSerializer se;
115         fbCmd.serialize( se );
116     }
117
118     return true;
119 }
120
121 bool
122 selectorSet( Ieee1394Service& ieee1394service, int node_id, int fb_id , int val )
123 {
124     FunctionBlockCmd fbCmd( ieee1394service,
125                             FunctionBlockCmd::eFBT_Selector,
126                             fb_id,
127                             FunctionBlockCmd::eCA_Current );
128     fbCmd.setNodeId( node_id );
129     fbCmd.setSubunitId( 0x00 );
130     fbCmd.setCommandType( AVCCommand::eCT_Control );
131     fbCmd.m_pFBSelector->m_inputFbPlugNumber=val;
132
133     debugOutput(DEBUG_LEVEL_NORMAL, "Setting selector state to %d...\n", val);
134
135     fbCmd.setVerbose( bVerbose );
136     if (bVerbose) {
137         ieee1394service.setVerboseLevel( DEBUG_LEVEL_VERY_VERBOSE );
138     }
139    
140     if ( !fbCmd.fire() ) {
141         debugError( "cmd failed\n" );
142     }
143
144     if ( bVerbose ) {
145         CoutSerializer se;
146         fbCmd.serialize( se );
147     }
148
149     return true;
150 }
151
152 bool
153 volumeGet( Ieee1394Service& ieee1394service, int node_id, int fb_id, int channel )
154 {
155     FunctionBlockCmd fbCmd( ieee1394service,
156                             FunctionBlockCmd::eFBT_Feature,
157                             fb_id,
158                             FunctionBlockCmd::eCA_Current );
159     fbCmd.setNodeId( node_id );
160     fbCmd.setSubunitId( 0x00 );
161     fbCmd.setCommandType( AVCCommand::eCT_Status );
162     fbCmd.m_pFBFeature->m_audioChannelNumber=channel;
163     fbCmd.m_pFBFeature->m_controlSelector=FunctionBlockFeature::eCSE_Feature_Volume;
164     fbCmd.m_pFBFeature->m_pVolume->m_volume=0;
165
166     debugOutput(DEBUG_LEVEL_NORMAL, "Requesting volume feature block state...\n");
167
168     fbCmd.setVerbose( bVerbose );
169     if (bVerbose) {
170         ieee1394service.setVerboseLevel( DEBUG_LEVEL_VERY_VERBOSE );
171     }
172    
173     if ( !fbCmd.fire() ) {
174         debugError( "cmd failed\n" );
175     }
176
177     if ( bVerbose ) {
178         CoutSerializer se;
179         fbCmd.serialize( se );
180     }
181
182     return true;
183 }
184
185 bool
186 volumeSet( Ieee1394Service& ieee1394service, int node_id, int fb_id, int channel, int value )
187 {
188     FunctionBlockCmd fbCmd( ieee1394service,
189                             FunctionBlockCmd::eFBT_Feature,
190                             fb_id,
191                             FunctionBlockCmd::eCA_Current );
192     fbCmd.setNodeId( node_id );
193     fbCmd.setSubunitId( 0x00 );
194     fbCmd.setCommandType( AVCCommand::eCT_Control );
195     fbCmd.m_pFBFeature->m_audioChannelNumber=channel;
196     fbCmd.m_pFBFeature->m_controlSelector=FunctionBlockFeature::eCSE_Feature_Volume;
197     fbCmd.m_pFBFeature->m_pVolume->m_volume=value;
198
199     debugOutput(DEBUG_LEVEL_NORMAL, "Setting volume feature block channel %d state to %d...\n", channel, value);
200
201     fbCmd.setVerbose( bVerbose );
202     if (bVerbose) {
203         ieee1394service.setVerboseLevel( DEBUG_LEVEL_VERY_VERBOSE );
204     }
205    
206     if ( !fbCmd.fire() ) {
207         debugError( "cmd failed\n" );
208     }
209
210     if ( bVerbose ) {
211         CoutSerializer se;
212         fbCmd.serialize( se );
213     }
214
215     return true;
216 }
217
218 ///////////////////////////
219 // main
220 //////////////////////////
221 int
222 main( int argc, char **argv )
223 {
224
225     if (argc < 4) {
226         debugError("usage: PORT NODE_ID CMD FB_ID [VAL1] [VAL2]\n");
227         exit(0);
228     }
229
230     int errno = 0;
231     char* tail;
232     int port = strtol( argv[1], &tail, 0 );
233     int node_id = strtol( argv[2], &tail, 0 );
234     int cmd = strtol( argv[3], &tail, 0 );
235     int fb_id   = strtol( argv[4], &tail, 0 );
236    
237     int value1=-1;
238     int value2=-1;
239    
240     if (argc>=6)
241         value1 = strtol(argv[5], &tail, 0 );
242        
243     if (argc>=7)
244         value2 = strtol(argv[6], &tail, 0 );
245    
246     if (errno) {
247         debugError("argument parsing failed: %s", strerror(errno));
248         return -1;
249     }
250     Ieee1394Service ieee1394service;
251     if ( !ieee1394service.initialize( port ) ) {
252         debugError( "could not set port on ieee1394service\n" );
253         return -1;
254     }
255
256     switch(cmd) {
257     case 0:
258         doApp( ieee1394service, node_id, fb_id );
259         break;
260     case 1:
261         selectorGet( ieee1394service, node_id, fb_id );
262         break;
263     case 2:
264         selectorSet( ieee1394service, node_id, fb_id , value1 );
265         break;
266     case 3:
267         volumeGet( ieee1394service, node_id, fb_id, value1);
268         break;
269     case 4:
270         volumeSet( ieee1394service, node_id, fb_id, value1, value2);
271         break;
272     }
273
274     return 0;
275 }
Note: See TracBrowser for help on using the browser.