RDK Documentation (Open Sourced RDK Components)
musicIdTestApp.cpp
1 /*
2  * If not stated otherwise in this file or this component's Licenses.txt file the
3  * following copyright and licenses apply:
4  *
5  * Copyright 2016 RDK Management
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18 */
19 #include <iostream>
20 #include "audiocapturemgr_iarm.h"
21 #include "libIBus.h"
22 #include <fstream>
23 #include <string.h>
24 #include "safec_lib.h"
25 
26 using namespace audiocapturemgr;
27 static const char * instance_name = NULL;
28 void print_menu(void)
29 {
30  std::cout<<"\n--- audio capture test application menu ---\n";
31  std::cout<<"1. open music-id session\n";
32  std::cout<<"2. print session details\n";
33  std::cout<<"3. get default props\n";
34  std::cout<<"4. set audio props\n";
35  std::cout<<"5. get output props\n";
36  std::cout<<"6. start\n";
37  std::cout<<"7. stop\n";
38  std::cout<<"8. close music session.\n";
39  std::cout<<"9. set output props.\n";
40  std::cout<<"10. get audio props.\n";
41  std::cout<<"11. get precaptured sample.\n";
42  std::cout<<"12. get post-captured sample.\n";
43  std::cout<<"13. quit.\n";
44 }
45 
46 static bool verify_result(IARM_Result_t ret, iarmbus_acm_arg_t &param)
47 {
48  if(IARM_RESULT_SUCCESS != ret)
49  {
50  std::cout<<"Bus call failed.\n";
51  return false;
52  }
53  if(0 != param.result)
54  {
55  std::cout<<"ACM implementation of bus call failed.\n";
56  return false;
57  }
58  return true;
59 }
60 
61 void iarmEventHandler(const char *owner, IARM_EventId_t eventId, void *data, size_t len)
62 {
63  std::cout<<"Received IARM event.\n";
64  iarmbus_notification_payload_t * param = static_cast <iarmbus_notification_payload_t *> (data);
65  std::string filename = param->dataLocator;
66  std::cout<<"Sample "<<filename<<" is ready.\n";
67 }
68 
69 void launcher()
70 {
71  bool keep_running = true;
72  session_id_t session = -1;
73  audio_properties_ifce_t props;
74  std::string socket_path;
75 
76  while(keep_running)
77  {
78  int choice = 0;
79  iarmbus_acm_arg_t param;
80  IARM_Result_t ret;
81 
82  print_menu();
83  std::cout<<"Enter command:\n";
84  if(!(std::cin >> choice))
85  {
86  std::cout<<"Oops!\n";
87  std::cin.clear();
88  std::cin.ignore(10000, '\n');
89  continue;
90  }
91  switch(choice)
92  {
93  case 1:
94  param.details.arg_open.source = 0; //primary
95  param.details.arg_open.output_type = BUFFERED_FILE_OUTPUT;
96  ret = IARM_Bus_Call(IARMBUS_AUDIOCAPTUREMGR_NAME, IARMBUS_AUDIOCAPTUREMGR_OPEN, (void *) &param, sizeof(param));
97  if(!verify_result(ret, param))
98  {
99  break;
100  }
101  session = param.session_id;
102  std::cout<<"Opened new session "<<session<<std::endl;
103  break;
104 
105  case 2:
106  std::cout<<"Session ID is "<<session<<std::endl;
107  break;
108 
109  case 3:
110  param.session_id = session;
111  ret = IARM_Bus_Call(IARMBUS_AUDIOCAPTUREMGR_NAME, IARMBUS_AUDIOCAPTUREMGR_GET_DEFAULT_AUDIO_PROPS, (void *) &param, sizeof(param));
112  if(!verify_result(ret, param))
113  {
114  break;
115  }
116  INFO("Format: 0x%x, delay comp: %dms, fifo size: %d, threshold: %d\n",
117  param.details.arg_audio_properties.format,
118  param.details.arg_audio_properties.delay_compensation_ms,
119  param.details.arg_audio_properties.fifo_size,
120  param.details.arg_audio_properties.threshold);
121  props = param.details.arg_audio_properties;
122  break;
123 
124  case 10:
125  param.session_id = session;
126  ret = IARM_Bus_Call(IARMBUS_AUDIOCAPTUREMGR_NAME, IARMBUS_AUDIOCAPTUREMGR_GET_AUDIO_PROPS, (void *) &param, sizeof(param));
127  if(!verify_result(ret, param))
128  {
129  break;
130  }
131  INFO("Format: 0x%x, delay comp: %dms, fifo size: %d, threshold: %d\n",
132  param.details.arg_audio_properties.format,
133  param.details.arg_audio_properties.delay_compensation_ms,
134  param.details.arg_audio_properties.fifo_size,
135  param.details.arg_audio_properties.threshold);
136  props = param.details.arg_audio_properties;
137  break;
138 
139  case 4:
140  param.session_id = session;
141  param.details.arg_audio_properties = props;
142  param.details.arg_audio_properties.delay_compensation_ms = 190;
143  ret = IARM_Bus_Call(IARMBUS_AUDIOCAPTUREMGR_NAME, IARMBUS_AUDIOCAPTUREMGR_SET_AUDIO_PROPERTIES, (void *) &param, sizeof(param));
144  if(!verify_result(ret, param))
145  {
146  break;
147  }
148  break;
149 
150  case 5:
151  param.session_id = session;
152  ret = IARM_Bus_Call(IARMBUS_AUDIOCAPTUREMGR_NAME, IARMBUS_AUDIOCAPTUREMGR_GET_OUTPUT_PROPS, (void *) &param, sizeof(param));
153  if(!verify_result(ret, param))
154  {
155  break;
156  }
157  std::cout<<"Max supported duration is "<<param.details.arg_output_props.output.max_buffer_duration<<std::endl;
158  break;
159 
160  case 6:
161  param.session_id = session;
162  ret = IARM_Bus_Call(IARMBUS_AUDIOCAPTUREMGR_NAME, IARMBUS_AUDIOCAPTUREMGR_START, (void *) &param, sizeof(param));
163  if(!verify_result(ret, param))
164  {
165  break;
166  }
167  std::cout<<"Start procedure complete.\n";
168  break;
169 
170  case 7:
171  param.session_id = session;
172  ret = IARM_Bus_Call(IARMBUS_AUDIOCAPTUREMGR_NAME, IARMBUS_AUDIOCAPTUREMGR_STOP, (void *) &param, sizeof(param));
173  if(!verify_result(ret, param))
174  {
175  break;
176  }
177  std::cout<<"Stop procedure complete.\n";
178  break;
179 
180  case 8:
181  param.session_id = session;
182  ret = IARM_Bus_Call(IARMBUS_AUDIOCAPTUREMGR_NAME, IARMBUS_AUDIOCAPTUREMGR_CLOSE, (void *) &param, sizeof(param));
183  if(!verify_result(ret, param))
184  {
185  break;
186  }
187  std::cout<<"Close procedure complete.\n";
188  break;
189 
190  case 9:
191  param.session_id = session;
192  param.details.arg_output_props.output.buffer_duration = 10;
193  ret = IARM_Bus_Call(IARMBUS_AUDIOCAPTUREMGR_NAME, IARMBUS_AUDIOCAPTUREMGR_SET_OUTPUT_PROPERTIES, (void *) &param, sizeof(param));
194  if(!verify_result(ret, param))
195  {
196  break;
197  }
198  break;
199 
200  case 11:
201  param.session_id = session;
202  param.details.arg_sample_request.duration = 5; //irrelevant.
203  param.details.arg_sample_request.is_precapture = true;
204  ret = IARM_Bus_Call(IARMBUS_AUDIOCAPTUREMGR_NAME, IARMBUS_AUDIOCAPTUREMGR_REQUEST_SAMPLE, (void *) &param, sizeof(param));
205  if(!verify_result(ret, param))
206  {
207  break;
208  }
209  std::cout<<"Requested precaptured sample.\n";
210  break;
211 
212  case 12:
213  param.session_id = session;
214  param.details.arg_sample_request.duration = 10;
215  param.details.arg_sample_request.is_precapture = false;
216  ret = IARM_Bus_Call(IARMBUS_AUDIOCAPTUREMGR_NAME, IARMBUS_AUDIOCAPTUREMGR_REQUEST_SAMPLE, (void *) &param, sizeof(param));
217  if(!verify_result(ret, param))
218  {
219  break;
220  }
221  std::cout<<"Requested post-captured sample.\n";
222  break;
223 
224  case 13:
225  std::cout<<"Exiting.\n";
226  keep_running = false;
227  break;
228 
229  default:
230  std::cout<<"Unknown input!\n";
231  }
232  }
233 }
234 
235 
236 #define ACM_TESTAPP_NAME_PRFIX "acm_testapp_"
237 int main(int argc, char *argv[])
238 {
239  if(2 > argc)
240  {
241  std::cout<<"Each exec session needs a name. Invoke it as $<exec name> <session-name>"<<std::endl;
242  std::cout<<"For instance, $acm_ipout_testapp alpha\n";
243  return -1;
244  }
245  errno_t rc = -1;
246  instance_name = argv[1];
247  char bus_registration_name[100];
248  rc = sprintf_s(bus_registration_name, sizeof(bus_registration_name), "%s%s", ACM_TESTAPP_NAME_PRFIX, argv[1]);
249  if( rc < EOK )
250  {
251  ERR_CHK(rc);
252  return -1;
253  }
254 
255  if(0 != IARM_Bus_Init(bus_registration_name))
256  {
257  std::cout<<"Unable to init IARMBus. Try another session name.\n";
258  return -1;
259  }
260  if(0 != IARM_Bus_Connect())
261  {
262  std::cout<<"Unable to connect to IARBus\n";
263  return -1;
264  }
265 
266  IARM_Bus_RegisterEventHandler(IARMBUS_AUDIOCAPTUREMGR_NAME, DATA_CAPTURE_IARM_EVENT_AUDIO_CLIP_READY, iarmEventHandler);
267 
268  launcher();
269 
270  IARM_Bus_RemoveEventHandler(IARMBUS_AUDIOCAPTUREMGR_NAME, DATA_CAPTURE_IARM_EVENT_AUDIO_CLIP_READY, iarmEventHandler);
271  IARM_Bus_Disconnect();
272  IARM_Bus_Term();
273  return 0;
274 }
IARM_Bus_Term
IARM_Result_t IARM_Bus_Term(void)
This API is used to terminate the IARM-Bus library.
IARM_Bus_Call
IARM_Result_t IARM_Bus_Call(const char *ownerName, const char *methodName, void *arg, size_t argLen)
This API is used to Invoke RPC method by its application name and method name.
Definition: iarm_bus.c:57
IARM_Bus_RegisterEventHandler
IARM_Result_t IARM_Bus_RegisterEventHandler(const char *ownerName, IARM_EventId_t eventId, IARM_EventHandler_t handler)
This API register to listen to event and provide the callback function for event notification....
Definition: iarmMgrMocks.cpp:43
IARM_Bus_RemoveEventHandler
IARM_Result_t IARM_Bus_RemoveEventHandler(const char *ownerName, IARM_EventId_t eventId, IARM_EventHandler_t handler)
Remove specific handler registered for the given event.
Definition: iarmMgrMocks.cpp:50
IARM_Bus_Disconnect
IARM_Result_t IARM_Bus_Disconnect(void)
This API disconnect Application from IARM Bus so the application will not receive any IARM event or R...
libIBus.h
RDK IARM-Bus API Declarations.
iarmbus_notification_payload_t
Definition: audiocapturemgr_iarm.h:130
audio_properties_ifce_t
Definition: audiocapturemgr_iarm.h:113
IARM_Bus_Connect
IARM_Result_t IARM_Bus_Connect(void)
This API is used to connect application to the IARM bus daemon. After connected, the application can ...
Definition: iarmMgrMocks.cpp:33
iarmbus_acm_arg_t
Definition: audiocapturemgr_iarm.h:152
print_menu
void print_menu()
This API prints the LED use-cases.
Definition: ledmgrmain.cpp:383
IARM_Bus_Init
IARM_Result_t IARM_Bus_Init(const char *name)
This API is used to initialize the IARM-Bus library.
Definition: iarmMgrMocks.cpp:38