RDK Documentation (Open Sourced RDK Components)
btrMgr_audioCap.c
Go to the documentation of this file.
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 /**
20  * @file btrMgr_audioCap.c
21  *
22  * @description This file implements bluetooth manager's Generic Audio Capture interface from external modules
23  *
24  */
25 
26 #ifdef HAVE_CONFIG_H
27 #include <config.h>
28 #endif
29 
30 /* System Headers */
31 #include <stdlib.h>
32 #include <stdbool.h>
33 #include <string.h>
34 
35 #if defined(USE_ACM)
36 #include <unistd.h>
37 #include <fcntl.h>
38 #include <sys/socket.h>
39 #include <sys/un.h>
40 #include <errno.h>
41 #endif
42 
43 /* Ext lib Headers */
44 #include <glib.h>
45 
46 /* Interface lib Headers */
47 #if defined(USE_AC_RMF)
48 #include "rmfAudioCapture.h"
49 #endif
50 
51 #if defined(USE_ACM)
52 #include "libIBus.h"
53 #include "libIARM.h"
54 
55 #include "audiocapturemgr_iarm.h"
56 #endif
57 
58 #include "btrMgr_logger.h"
59 #ifdef RDK_LOGGER_ENABLED
60 int b_rdk_logger_enabled = 0;
61 #endif
62 
63 /* Local Headers */
64 #include "btrMgr_Types.h"
65 #include "btrMgr_mediaTypes.h"
66 #include "btrMgr_audioCap.h"
67 
68 /* Local defines */
69 #if defined(USE_ACM)
70 //TODO: Should match the value in src/rpc/btmgr_iarm_interface.h. Find a better way
71 #define IARM_BUS_BTRMGR_NAME "BTRMgrBus"
72 #endif
73 
74 #if defined(BUILD_SKY)
75 #define TV_CUSTOM_DELAY_COMP 1
76 #endif
77 
78 /* Local types */
79 #if defined(USE_ACM)
80 typedef enum _eBTRMgrACAcmDCOp {
81  eBTRMgrACAcmDCStart,
82  eBTRMgrACAcmDCStop,
83  eBTRMgrACAcmDCResume,
84  eBTRMgrACAcmDCPause,
85  eBTRMgrACAcmDCExit,
86  eBTRMgrACAcmDCUnknown
87 } eBTRMgrACAcmDCOp;
88 #endif
89 
90 typedef struct _stBTRMgrACHdl {
91  stBTRMgrMediaStatus stBtrMgrAcStatus;
92 #if defined(USE_AC_RMF)
93  RMF_AudioCaptureHandle hBTRMgrRmfAcHdl;
94  RMF_AudioCapture_Settings stBtrMgrRmfAcDefSettings;
95  RMF_AudioCapture_Settings stBtrMgrRmfAcCurSettings;
96  RMF_AudioCapture_Status stBtrMgrRmfAcStatus;
97 #endif
98 
99 #if defined(USE_ACM)
100  GThread* pBtrMgrAcmDataCapGThread;
101  GAsyncQueue* pBtrMgrAcmDataCapGAOpQueue;
102  session_id_t hBtrMgrIarmAcmHdl;
103  audio_properties_ifce_t stBtrMgrAcmDefSettings;
104  audio_properties_ifce_t stBtrMgrAcmCurSettings;
105  audio_properties_ifce_t* pstBtrMgrAcmSettings;
106  char pcBtrMgrAcmSockPath[MAX_OUTPUT_PATH_LEN];
107  int i32BtrMgrAcmDCSockFd;
108  int i32BtrMgrAcmExternalIARMMode;
109 #endif
110 
111  tBTRMgrAcType pcBTRMgrAcType;
112 
113  fPtr_BTRMgr_AC_DataReadyCb fpcBBtrMgrAcDataReady;
114  void* vpBtrMgrAcDataReadyUserData;
115 
116  fPtr_BTRMgr_AC_StatusCb fpcBBtrMgrAcStatus;
117  void* vpBtrMgrAcStatusUserData;
118 } stBTRMgrACHdl;
119 
120 
121 /* Static Function Prototypes */
122 
123 /* Local Op Threads */
124 #if defined(USE_ACM)
125 static gpointer btrMgr_AC_acmDataCapture_InTask (gpointer user_data);
126 #endif
127 
128 /* Incoming Callbacks */
129 #if defined(USE_AC_RMF)
130 static rmf_Error btrMgr_AC_rmfBufferReadyCb (void* pContext, void* pInDataBuf, unsigned int inBytesToEncode);
131 static rmf_Error btrMgr_AC_rmfStatusChangeCb (void* pContext);
132 #endif
133 
134 
135 /* Static Function Definition */
136 
137 /* Local Op Threads */
138 #if defined(USE_ACM)
139 static gpointer
140 btrMgr_AC_acmDataCapture_InTask (
141  gpointer user_data
142 ) {
143  stBTRMgrACHdl* pstBtrMgrAcHdl = (stBTRMgrACHdl*)user_data;
144  gint64 li64usTimeout = 0;
145  guint16 lui16msTimeout = 500;
146  eBTRMgrACAcmDCOp leBtrMgrAcmDCPrvOp = eBTRMgrACAcmDCUnknown;
147  eBTRMgrACAcmDCOp leBtrMgrAcmDCCurOp = eBTRMgrACAcmDCUnknown;
148  gpointer lpeBtrMgrAcmDCOp = NULL;
149  void* lpInDataBuf = NULL;
150 
151 
152  if (pstBtrMgrAcHdl == NULL) {
153  BTRMGRLOG_ERROR("Fail - eBTRMgrFailInArg\n");
154  return NULL;
155  }
156 
157  BTRMGRLOG_DEBUG ("Enter\n");
158 
159  do {
160  /* Process incoming events */
161  {
162  li64usTimeout = lui16msTimeout * G_TIME_SPAN_MILLISECOND;
163  if ((lpeBtrMgrAcmDCOp = g_async_queue_timeout_pop(pstBtrMgrAcHdl->pBtrMgrAcmDataCapGAOpQueue, li64usTimeout)) != NULL) {
164  leBtrMgrAcmDCCurOp = *((eBTRMgrACAcmDCOp*)lpeBtrMgrAcmDCOp);
165  g_free(lpeBtrMgrAcmDCOp);
166  BTRMGRLOG_DEBUG ("g_async_queue_timeout_pop %d\n", leBtrMgrAcmDCCurOp);
167  }
168  }
169 
170 
171  /* Set up operation changes */
172  if (leBtrMgrAcmDCPrvOp != leBtrMgrAcmDCCurOp) {
173  leBtrMgrAcmDCPrvOp = leBtrMgrAcmDCCurOp;
174 
175  /* eBTRMgrACAcmDCStart - START */
176  if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCStart) {
177  struct sockaddr_un lstBtrMgrAcmDCSockAddr;
178  int li32BtrMgrAcmDCSockFd = -1;
179  int li32BtrMgrAcmDCSockFlags;
180  int lerrno = 0;
181 
182  lui16msTimeout = 1;
183  BTRMGRLOG_INFO ("eBTRMgrACAcmDCStart\n");
184 
185  if (!strlen(pstBtrMgrAcHdl->pcBtrMgrAcmSockPath)) {
186  BTRMGRLOG_ERROR("eBTRMgrACAcmDCStart - Invalid Socket Path\n");
187  }
188  else {
189  BTRMGRLOG_DEBUG ("pcBtrMgrAcmSockPath = %s\n", pstBtrMgrAcHdl->pcBtrMgrAcmSockPath);
190 
191  lstBtrMgrAcmDCSockAddr.sun_family = AF_UNIX;
192  strncpy(lstBtrMgrAcmDCSockAddr.sun_path, pstBtrMgrAcHdl->pcBtrMgrAcmSockPath,
193  strlen(pstBtrMgrAcHdl->pcBtrMgrAcmSockPath) < (sizeof(lstBtrMgrAcmDCSockAddr.sun_path) - 1) ?
194  strlen(pstBtrMgrAcHdl->pcBtrMgrAcmSockPath) + 1 : sizeof(lstBtrMgrAcmDCSockAddr.sun_path)); //CID:136289 - Buffer size and 23363 - Overrun
195 
196 
197  if ((li32BtrMgrAcmDCSockFd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0)) == -1) {
198  lerrno = errno;
199  BTRMGRLOG_ERROR("eBTRMgrACAcmDCStart - Unable to create socket :FAILURE - %d\n", lerrno);
200  }
201 
202  if ((li32BtrMgrAcmDCSockFd != -1) &&
203  ((li32BtrMgrAcmDCSockFlags = fcntl(li32BtrMgrAcmDCSockFd, F_GETFL, 0)) != -1) &&
204  (fcntl(li32BtrMgrAcmDCSockFd, F_SETFL, li32BtrMgrAcmDCSockFlags | O_NONBLOCK) != -1)) {
205  BTRMGRLOG_DEBUG("eBTRMgrACAcmDCStart - Socket O_NONBLOCK : SUCCESS\n");
206  }
207 
208  if ((li32BtrMgrAcmDCSockFd != -1) &&
209  (connect(li32BtrMgrAcmDCSockFd, (const struct sockaddr*)&lstBtrMgrAcmDCSockAddr, sizeof(lstBtrMgrAcmDCSockAddr)) == -1)) {
210  lerrno = errno;
211  BTRMGRLOG_ERROR("eBTRMgrACAcmDCStart - Unable to connect socket :FAILURE - %d\n", lerrno);
212  if( li32BtrMgrAcmDCSockFd > 0 ) {
213  close(li32BtrMgrAcmDCSockFd);
214  li32BtrMgrAcmDCSockFd = -1;
215  }
216  lerrno = errno;
217  }
218  else {
219  lerrno = errno;
220  if (!(lpInDataBuf = malloc(pstBtrMgrAcHdl->pstBtrMgrAcmSettings->threshold))) {
221  BTRMGRLOG_ERROR("eBTRMgrACAcmDCStart - Unable to alloc\n");
222  break;
223  }
224  }
225  }
226 
227  pstBtrMgrAcHdl->i32BtrMgrAcmDCSockFd = li32BtrMgrAcmDCSockFd;
228  BTRMGRLOG_INFO ("eBTRMgrACAcmDCStart - Read socket : %d - %d\n", pstBtrMgrAcHdl->i32BtrMgrAcmDCSockFd, lerrno);
229  }
230  /* eBTRMgrACAcmDCStop - STOP */
231  else if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCStop) {
232  lui16msTimeout = 50;
233  BTRMGRLOG_INFO ("eBTRMgrACAcmDCStop\n");
234 
235  if (pstBtrMgrAcHdl->i32BtrMgrAcmDCSockFd == -1) {
236  BTRMGRLOG_ERROR("eBTRMgrACAcmDCStop :FAILURE\n");
237  }
238  else {
239  iarmbus_acm_arg_t lstBtrMgrIarmAcmArgs;
240  IARM_Result_t leBtrMgIarmAcmRet = IARM_RESULT_SUCCESS;
241 
242  // Flush the read queue before closing the read socket
243  if (lpInDataBuf) {
244  int li32InDataBufBytesRead = 0;
245  unsigned int lui32EmptyDataIdx = 8; // BTRMGR_MAX_INTERNAL_QUEUE_ELEMENTS
246 
247  do {
248  li32InDataBufBytesRead = (int)read( pstBtrMgrAcHdl->i32BtrMgrAcmDCSockFd,
249  lpInDataBuf,
250  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->threshold);
251  } while ((li32InDataBufBytesRead > 0) && --lui32EmptyDataIdx);
252 
253  free(lpInDataBuf);
254  lpInDataBuf = NULL;
255  }
256 
257  if (pstBtrMgrAcHdl->i32BtrMgrAcmDCSockFd > 0) {
258  close(pstBtrMgrAcHdl->i32BtrMgrAcmDCSockFd); //CID:23436
259  pstBtrMgrAcHdl->i32BtrMgrAcmDCSockFd = -1;
260  }
261 
262  memset(&lstBtrMgrIarmAcmArgs, 0, sizeof(iarmbus_acm_arg_t));
263  lstBtrMgrIarmAcmArgs.session_id = pstBtrMgrAcHdl->hBtrMgrIarmAcmHdl;
264 
265  if ((leBtrMgIarmAcmRet = IARM_Bus_Call (IARMBUS_AUDIOCAPTUREMGR_NAME,
266  IARMBUS_AUDIOCAPTUREMGR_STOP,
267  (void *)&lstBtrMgrIarmAcmArgs,
268  sizeof(lstBtrMgrIarmAcmArgs))) != IARM_RESULT_SUCCESS) {
269  BTRMGRLOG_ERROR("IARMBUS_AUDIOCAPTUREMGR_STOP:Return Status = %d\n", leBtrMgIarmAcmRet);
270  }
271 
272  if (lstBtrMgrIarmAcmArgs.result != 0) {
273  BTRMGRLOG_ERROR("lstBtrMgrIarmAcmArgs:Return Status = %d\n", lstBtrMgrIarmAcmArgs.result);
274  }
275 
276  }
277  }
278  /* eBTRMgrACAcmDCPause - PAUSE */
279  else if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCPause) {
280  lui16msTimeout = 500;
281  BTRMGRLOG_INFO ("eBTRMgrACAcmDCPause\n");
282 
283  }
284  /* eBTRMgrACAcmDCResume - RESUME */
285  else if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCResume) {
286  lui16msTimeout = 1;
287  BTRMGRLOG_INFO ("eBTRMgrACAcmDCResume\n");
288 
289  }
290  /* eBTRMgrACAcmDCExit - EXIT */
291  else if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCExit) {
292  BTRMGRLOG_INFO ("eBTRMgrACAcmDCExit\n");
293  break;
294  }
295  /* eBTRMgrACAcmDCUnknown - UNKNOWN */
296  else if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCUnknown) {
297  g_thread_yield();
298  }
299  }
300 
301 
302  /* Process Operations */
303  {
304  /* eBTRMgrACAcmDCStart - START */
305  if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCStart) {
306  int li32InDataBufBytesRead = 0;
307 
308  if((pstBtrMgrAcHdl->i32BtrMgrAcmDCSockFd >= 0) && (lpInDataBuf)) {
309  li32InDataBufBytesRead = (int)read( pstBtrMgrAcHdl->i32BtrMgrAcmDCSockFd,
310  lpInDataBuf,
311  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->threshold);
312  } //CID:23331 and 23351- Negative returns, 23362 - Forward null
313 
314 
315  if (pstBtrMgrAcHdl->fpcBBtrMgrAcDataReady && (li32InDataBufBytesRead > 0)) {
316  if (pstBtrMgrAcHdl->fpcBBtrMgrAcDataReady(lpInDataBuf,
317  li32InDataBufBytesRead,
318  pstBtrMgrAcHdl->vpBtrMgrAcDataReadyUserData) != eBTRMgrSuccess) {
319  BTRMGRLOG_ERROR("AC Data Ready Callback Failed\n");
320  }
321  }
322  }
323  /* eBTRMgrACAcmDCStop - STOP */
324  else if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCStop) {
325  g_thread_yield();
326  }
327  /* eBTRMgrACAcmDCPause - PAUSE */
328  else if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCPause) {
329  }
330  /* eBTRMgrACAcmDCResume - RESUME */
331  else if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCResume) {
332  }
333  /* eBTRMgrACAcmDCExit - EXIT */
334  else if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCExit) {
335  g_thread_yield();
336  }
337  /* eBTRMgrACAcmDCUnknown - UNKNOWN */
338  else if (leBtrMgrAcmDCCurOp == eBTRMgrACAcmDCUnknown) {
339  g_thread_yield();
340  }
341  }
342 
343  } while(1);
344 
345  if(lpInDataBuf != NULL) {
346  free(lpInDataBuf); //CID:23332 - Resource leak
347  }
348  BTRMGRLOG_DEBUG ("Exit\n");
349 
350  return NULL;
351 }
352 #endif
353 
354 
355 /* Interfaces */
356 eBTRMgrRet
357 BTRMgr_AC_Init (
358  tBTRMgrAcHdl* phBTRMgrAcHdl,
359  tBTRMgrAcType api8BTRMgrAcType
360 ) {
361  eBTRMgrRet leBtrMgrAcRet = eBTRMgrSuccess;
362  stBTRMgrACHdl* pstBtrMgrAcHdl = NULL;
363 
364 #if defined(USE_AC_RMF)
365  rmf_Error leBtrMgrRmfAcRet = RMF_SUCCESS;
366  RMF_AudioCaptureType lrmfAcType;
367 #endif
368 
369 #if defined(USE_ACM)
370  iarmbus_acm_arg_t lstBtrMgrIarmAcmArgs;
371  IARM_Result_t leBtrMgIarmAcmRet = IARM_RESULT_SUCCESS;
372  const char* lpcProcessName = IARM_BUS_BTRMGR_NAME;
373 #endif
374 
375  if ((pstBtrMgrAcHdl = (stBTRMgrACHdl*)g_malloc0 (sizeof(stBTRMgrACHdl))) == NULL) {
376  BTRMGRLOG_ERROR("Unable to allocate memory\n");
377  return eBTRMgrInitFailure;
378  }
379 
380 #if defined(USE_AC_RMF)
381  if ((api8BTRMgrAcType != NULL) &&
382  (!strncmp(api8BTRMgrAcType, BTRMGR_AC_TYPE_AUXILIARY, strlen(BTRMGR_AC_TYPE_AUXILIARY)))) {
383  lrmfAcType = RMF_AC_TYPE_AUXILIARY;
384  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_Open_Type(&pstBtrMgrAcHdl->hBTRMgrRmfAcHdl, lrmfAcType)) != RMF_SUCCESS) {
385  BTRMGRLOG_ERROR("RMF_AudioCapture_Open:Return Status = %d\n", leBtrMgrRmfAcRet);
386  leBtrMgrAcRet = eBTRMgrInitFailure;
387  }
388  }
389 #endif
390 
391 #if defined(USE_ACM)
392  if ((api8BTRMgrAcType == NULL) ||
393  (!strncmp(api8BTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) {
394  memset(pstBtrMgrAcHdl->pcBtrMgrAcmSockPath, '\0', MAX_OUTPUT_PATH_LEN);
395  pstBtrMgrAcHdl->i32BtrMgrAcmDCSockFd = -1;
396 
397  if(!IARM_Bus_IsConnected(lpcProcessName, &pstBtrMgrAcHdl->i32BtrMgrAcmExternalIARMMode)) {
398  BTRMGRLOG_TRACE("Error in IARM_Bus_IsConnected\n");
399  } //CID:101819 - Checked return
400 
401  if (!pstBtrMgrAcHdl->i32BtrMgrAcmExternalIARMMode) {
402  IARM_Bus_Init(lpcProcessName);
403  IARM_Bus_Connect();
404  }
405 
406 
407  pstBtrMgrAcHdl->hBtrMgrIarmAcmHdl = -1;
408  memset(&pstBtrMgrAcHdl->stBtrMgrAcmDefSettings, 0, sizeof(audio_properties_ifce_t));
409  memset(&pstBtrMgrAcHdl->stBtrMgrAcmCurSettings, 0, sizeof(audio_properties_ifce_t));
410 
411 
412  memset(&lstBtrMgrIarmAcmArgs, 0, sizeof(iarmbus_acm_arg_t));
413  lstBtrMgrIarmAcmArgs.details.arg_open.source = 0; //primary
414  lstBtrMgrIarmAcmArgs.details.arg_open.output_type = REALTIME_SOCKET;
415 
416  if ((leBtrMgIarmAcmRet = IARM_Bus_Call (IARMBUS_AUDIOCAPTUREMGR_NAME,
417  IARMBUS_AUDIOCAPTUREMGR_OPEN,
418  (void *)&lstBtrMgrIarmAcmArgs,
419  sizeof(lstBtrMgrIarmAcmArgs))) != IARM_RESULT_SUCCESS) {
420  BTRMGRLOG_ERROR("IARMBUS_AUDIOCAPTUREMGR_OPEN:Return Status = %d\n", leBtrMgIarmAcmRet);
421  leBtrMgrAcRet = eBTRMgrInitFailure;
422  }
423 
424  if ((leBtrMgrAcRet != eBTRMgrSuccess) || (lstBtrMgrIarmAcmArgs.result != 0)) {
425  BTRMGRLOG_ERROR("lstBtrMgrIarmAcmArgs:Return Status = %d\n", lstBtrMgrIarmAcmArgs.result);
426  leBtrMgrAcRet = eBTRMgrInitFailure;
427  }
428  else {
429  pstBtrMgrAcHdl->hBtrMgrIarmAcmHdl = lstBtrMgrIarmAcmArgs.session_id;
430 
431  if (((pstBtrMgrAcHdl->pBtrMgrAcmDataCapGAOpQueue = g_async_queue_new()) == NULL) ||
432  ((pstBtrMgrAcHdl->pBtrMgrAcmDataCapGThread = g_thread_new("btrMgr_AC_acmDataCapture_InTask", btrMgr_AC_acmDataCapture_InTask, pstBtrMgrAcHdl)) == NULL)) {
433  leBtrMgrAcRet = eBTRMgrInitFailure;
434  }
435 
436  BTRMGRLOG_DEBUG ("btrMgr_AC_acmDataCapture_InTask : %p\n", pstBtrMgrAcHdl->pBtrMgrAcmDataCapGThread);
437  }
438  }
439 #elif defined(USE_AC_RMF)
440  else if ((api8BTRMgrAcType == NULL) ||
441  (!strncmp(api8BTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) {
442  lrmfAcType = RMF_AC_TYPE_PRIMARY;
443  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_Open(&pstBtrMgrAcHdl->hBTRMgrRmfAcHdl)) != RMF_SUCCESS) {
444  BTRMGRLOG_ERROR("RMF_AudioCapture_Open:Return Status = %d\n", leBtrMgrRmfAcRet);
445  leBtrMgrAcRet = eBTRMgrInitFailure;
446  }
447  }
448 #endif
449 
450  if (api8BTRMgrAcType)
451  pstBtrMgrAcHdl->pcBTRMgrAcType = g_strndup(api8BTRMgrAcType, 32);
452 
453  if (leBtrMgrAcRet != eBTRMgrSuccess) {
454  BTRMgr_AC_DeInit((tBTRMgrAcHdl)pstBtrMgrAcHdl); //CID:127655 - Use after free
455  return leBtrMgrAcRet;
456  }
457 
458  *phBTRMgrAcHdl = (tBTRMgrAcHdl)pstBtrMgrAcHdl;
459 
460  return leBtrMgrAcRet;
461 }
462 
463 
464 eBTRMgrRet
465 BTRMgr_AC_DeInit (
466  tBTRMgrAcHdl hBTRMgrAcHdl
467 ) {
468  eBTRMgrRet leBtrMgrAcRet = eBTRMgrSuccess;
469  stBTRMgrACHdl* pstBtrMgrAcHdl = (stBTRMgrACHdl*)hBTRMgrAcHdl;
470 
471 #if defined(USE_AC_RMF)
472  rmf_Error leBtrMgrRmfAcRet = RMF_SUCCESS;
473 #endif
474 
475 #if defined(USE_ACM)
476  iarmbus_acm_arg_t lstBtrMgrIarmAcmArgs;
477  IARM_Result_t leBtrMgIarmAcmRet = IARM_RESULT_SUCCESS;
478 #endif
479 
480  if (pstBtrMgrAcHdl == NULL) {
481  return eBTRMgrNotInitialized;
482  }
483 
484 #if defined(USE_AC_RMF)
485  if ((pstBtrMgrAcHdl->pcBTRMgrAcType != NULL) &&
486  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_AUXILIARY, strlen(BTRMGR_AC_TYPE_AUXILIARY))) &&
487  (pstBtrMgrAcHdl->hBTRMgrRmfAcHdl != NULL)) {
488  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_Close(pstBtrMgrAcHdl->hBTRMgrRmfAcHdl)) != RMF_SUCCESS) {
489  BTRMGRLOG_ERROR("Return Status = %d\n", leBtrMgrRmfAcRet);
490  leBtrMgrAcRet = eBTRMgrFailure;
491  }
492 
493  pstBtrMgrAcHdl->hBTRMgrRmfAcHdl = NULL;
494  }
495 #endif
496 
497 #if defined(USE_ACM)
498  if ((pstBtrMgrAcHdl->pcBTRMgrAcType == NULL) ||
499  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) {
500  if (pstBtrMgrAcHdl->pBtrMgrAcmDataCapGThread) {
501  gpointer lpeBtrMgrAcmDCOp = NULL;
502  if ((lpeBtrMgrAcmDCOp = g_malloc0(sizeof(eBTRMgrACAcmDCOp))) != NULL) {
503  *((eBTRMgrACAcmDCOp*)lpeBtrMgrAcmDCOp) = eBTRMgrACAcmDCExit;
504  g_async_queue_push(pstBtrMgrAcHdl->pBtrMgrAcmDataCapGAOpQueue, lpeBtrMgrAcmDCOp);
505  BTRMGRLOG_DEBUG ("g_async_queue_push: eBTRMgrACAcmDCExit\n");
506  }
507  }
508  else {
509  BTRMGRLOG_ERROR("pBtrMgrAcmDataCapGThread: eBTRMgrACAcmDCExit - FAILED\n");
510  leBtrMgrAcRet = eBTRMgrFailure;
511  }
512 
513  if (pstBtrMgrAcHdl->pBtrMgrAcmDataCapGThread) {
514  g_thread_join(pstBtrMgrAcHdl->pBtrMgrAcmDataCapGThread);
515  pstBtrMgrAcHdl->pBtrMgrAcmDataCapGThread = NULL;
516  }
517 
518  if (pstBtrMgrAcHdl->pBtrMgrAcmDataCapGAOpQueue) {
519  g_async_queue_unref(pstBtrMgrAcHdl->pBtrMgrAcmDataCapGAOpQueue);
520  pstBtrMgrAcHdl->pBtrMgrAcmDataCapGAOpQueue = NULL;
521  }
522 
523 
524  memset(&lstBtrMgrIarmAcmArgs, 0, sizeof(iarmbus_acm_arg_t));
525  lstBtrMgrIarmAcmArgs.session_id = pstBtrMgrAcHdl->hBtrMgrIarmAcmHdl;
526 
527  if ((lstBtrMgrIarmAcmArgs.session_id != 0) &&
528  ((leBtrMgIarmAcmRet = IARM_Bus_Call (IARMBUS_AUDIOCAPTUREMGR_NAME,
529  IARMBUS_AUDIOCAPTUREMGR_CLOSE,
530  (void *)&lstBtrMgrIarmAcmArgs,
531  sizeof(lstBtrMgrIarmAcmArgs))) != IARM_RESULT_SUCCESS)) {
532  BTRMGRLOG_ERROR("IARMBUS_AUDIOCAPTUREMGR_CLOSE:Return Status = %d\n", leBtrMgIarmAcmRet);
533  leBtrMgrAcRet = eBTRMgrFailure;
534  }
535 
536  if ((leBtrMgrAcRet != eBTRMgrSuccess) || (lstBtrMgrIarmAcmArgs.result != 0)) {
537  BTRMGRLOG_ERROR("lstBtrMgrIarmAcmArgs:Return Status = %d\n", lstBtrMgrIarmAcmArgs.result);
538  leBtrMgrAcRet = eBTRMgrFailure;
539  }
540 
541  memset(&pstBtrMgrAcHdl->stBtrMgrAcmDefSettings, 0, sizeof(audio_properties_ifce_t));
542  memset(&pstBtrMgrAcHdl->stBtrMgrAcmCurSettings, 0, sizeof(audio_properties_ifce_t));
543  pstBtrMgrAcHdl->hBtrMgrIarmAcmHdl = -1;
544 
545 
546  if (!pstBtrMgrAcHdl->i32BtrMgrAcmExternalIARMMode) {
547  IARM_Bus_Disconnect();
548  IARM_Bus_Term();
549  }
550 
551  pstBtrMgrAcHdl->i32BtrMgrAcmDCSockFd = -1;
552  memset(pstBtrMgrAcHdl->pcBtrMgrAcmSockPath, '\0', MAX_OUTPUT_PATH_LEN);
553  }
554 #elif defined(USE_AC_RMF)
555  else if (((pstBtrMgrAcHdl->pcBTRMgrAcType == NULL) ||
556  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) &&
557  (pstBtrMgrAcHdl->hBTRMgrRmfAcHdl != NULL)) {
558  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_Close(pstBtrMgrAcHdl->hBTRMgrRmfAcHdl)) != RMF_SUCCESS) {
559  BTRMGRLOG_ERROR("Return Status = %d\n", leBtrMgrRmfAcRet);
560  leBtrMgrAcRet = eBTRMgrFailure;
561  }
562 
563  pstBtrMgrAcHdl->hBTRMgrRmfAcHdl = NULL;
564  }
565 #endif
566 
567  if (pstBtrMgrAcHdl->pcBTRMgrAcType) {
568  g_free(pstBtrMgrAcHdl->pcBTRMgrAcType);
569  pstBtrMgrAcHdl->pcBTRMgrAcType = NULL;
570  }
571 
572  g_free((void*)pstBtrMgrAcHdl);
573  pstBtrMgrAcHdl = NULL;
574 
575  return leBtrMgrAcRet;
576 }
577 
578 
579 eBTRMgrRet
580 BTRMgr_AC_GetDefaultSettings (
581  tBTRMgrAcHdl hBTRMgrAcHdl,
582  stBTRMgrOutASettings* apstBtrMgrAcOutASettings
583 ) {
584  eBTRMgrRet leBtrMgrAcRet = eBTRMgrSuccess;
585  stBTRMgrACHdl* pstBtrMgrAcHdl = (stBTRMgrACHdl*)hBTRMgrAcHdl;
586 
587 #if defined(USE_AC_RMF)
588  rmf_Error leBtrMgrRmfAcRet = RMF_SUCCESS;
589 #endif
590 
591 #if defined(USE_ACM)
592  iarmbus_acm_arg_t lstBtrMgrIarmAcmArgs;
593  IARM_Result_t leBtrMgIarmAcmRet = IARM_RESULT_SUCCESS;
594 #endif
595 
596  if (pstBtrMgrAcHdl == NULL) {
597  return eBTRMgrNotInitialized;
598  }
599 
600  if ((apstBtrMgrAcOutASettings == NULL) || (apstBtrMgrAcOutASettings->pstBtrMgrOutCodecInfo == NULL)) {
601  return eBTRMgrFailInArg;
602  }
603 
604 
605 #if defined(USE_AC_RMF)
606  if ((pstBtrMgrAcHdl->pcBTRMgrAcType != NULL) &&
607  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_AUXILIARY, strlen(BTRMGR_AC_TYPE_AUXILIARY)))) {
608  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_GetDefaultSettings(&pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings)) != RMF_SUCCESS) {
609  BTRMGRLOG_ERROR("Return Status = %d\n", leBtrMgrRmfAcRet);
610  leBtrMgrAcRet = eBTRMgrFailure;
611  }
612 
613  BTRMGRLOG_TRACE ("Default CBBufferReady = %p\n", pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings.cbBufferReady);
614  BTRMGRLOG_TRACE ("Default Fifosize = %d\n", (int)pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings.fifoSize);
615  BTRMGRLOG_TRACE ("Default Threshold = %d\n", (int)pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings.threshold);
616 
617  //TODO: Get the format capture format from RMF_AudioCapture Settings
618  apstBtrMgrAcOutASettings->eBtrMgrOutAType = eBTRMgrATypePCM;
619 
620  if (apstBtrMgrAcOutASettings->eBtrMgrOutAType == eBTRMgrATypePCM) {
621  stBTRMgrPCMInfo* pstBtrMgrAcOutPcmInfo = (stBTRMgrPCMInfo*)(apstBtrMgrAcOutASettings->pstBtrMgrOutCodecInfo);
622 
623  switch (pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings.format) {
624  case racFormat_e16BitStereo:
625  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
626  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
627  break;
628  case racFormat_e24BitStereo:
629  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
630  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
631  break;
632  case racFormat_e16BitMonoLeft:
633  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
634  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
635  break;
636  case racFormat_e16BitMonoRight:
637  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
638  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
639  break;
640  case racFormat_e16BitMono:
641  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
642  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
643  break;
644  case racFormat_e24Bit5_1:
645  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
646  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChan5_1;
647  break;
648  case racFormat_eMax:
649  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmtUnknown;
650  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanUnknown;
651  break;
652  default:
653  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
654  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
655  break;
656  }
657 
658  switch (pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings.samplingFreq) {
659  case racFreq_e16000:
660  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq16K;
661  break;
662  case racFreq_e32000:
663  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq32K;
664  break;
665  case racFreq_e44100:
666  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq44_1K;
667  break;
668  case racFreq_e48000:
669  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
670  break;
671  case racFreq_eMax:
672  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreqUnknown;
673  break;
674  default:
675  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
676  break;
677  }
678  }
679  else {
680  leBtrMgrAcRet = eBTRMgrFailure;
681  }
682  }
683 #endif
684 
685 #if defined(USE_ACM)
686  if ((pstBtrMgrAcHdl->pcBTRMgrAcType == NULL) ||
687  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) {
688  memset(&lstBtrMgrIarmAcmArgs, 0, sizeof(iarmbus_acm_arg_t));
689  lstBtrMgrIarmAcmArgs.session_id = pstBtrMgrAcHdl->hBtrMgrIarmAcmHdl;
690 
691  if ((leBtrMgIarmAcmRet = IARM_Bus_Call (IARMBUS_AUDIOCAPTUREMGR_NAME,
692  IARMBUS_AUDIOCAPTUREMGR_GET_DEFAULT_AUDIO_PROPS,
693  (void *)&lstBtrMgrIarmAcmArgs,
694  sizeof(lstBtrMgrIarmAcmArgs))) != IARM_RESULT_SUCCESS) {
695  BTRMGRLOG_ERROR("IARMBUS_AUDIOCAPTUREMGR_GET_DEFAULT_AUDIO_PROPS:Return Status = %d\n", leBtrMgIarmAcmRet);
696  leBtrMgrAcRet = eBTRMgrFailure;
697  }
698 
699  if ((leBtrMgrAcRet != eBTRMgrSuccess) || (lstBtrMgrIarmAcmArgs.result != 0)) {
700  BTRMGRLOG_ERROR("lstBtrMgrIarmAcmArgs:Return Status = %d\n", lstBtrMgrIarmAcmArgs.result);
701  leBtrMgrAcRet = eBTRMgrFailure;
702  }
703 
704 
705  if (leBtrMgrAcRet == eBTRMgrSuccess) {
706  memcpy(&pstBtrMgrAcHdl->stBtrMgrAcmDefSettings, &lstBtrMgrIarmAcmArgs.details.arg_audio_properties, sizeof(audio_properties_ifce_t));
707 
708  BTRMGRLOG_TRACE ("Default Fifosize = %d\n", (int)pstBtrMgrAcHdl->stBtrMgrAcmDefSettings.fifo_size);
709  BTRMGRLOG_TRACE ("Default Threshold= %d\n", (int)pstBtrMgrAcHdl->stBtrMgrAcmDefSettings.threshold);
710  BTRMGRLOG_TRACE ("Default DelayComp= %d\n", pstBtrMgrAcHdl->stBtrMgrAcmDefSettings.delay_compensation_ms);
711 
712  //TODO: Get the format capture format from IARMBUS_AUDIOCAPTUREMGR_NAME
713  apstBtrMgrAcOutASettings->eBtrMgrOutAType = eBTRMgrATypePCM;
714 
715  if (apstBtrMgrAcOutASettings->eBtrMgrOutAType == eBTRMgrATypePCM) {
716  stBTRMgrPCMInfo* pstBtrMgrAcOutPcmInfo = (stBTRMgrPCMInfo*)(apstBtrMgrAcOutASettings->pstBtrMgrOutCodecInfo);
717 
718  switch (pstBtrMgrAcHdl->stBtrMgrAcmDefSettings.format) {
719  case acmFormate16BitStereo:
720  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
721  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
722  break;
723  case acmFormate24BitStereo:
724  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
725  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
726  break;
727  case acmFormate16BitMonoLeft:
728  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
729  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
730  break;
731  case acmFormate16BitMonoRight:
732  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
733  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
734  break;
735  case acmFormate16BitMono:
736  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
737  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
738  break;
739  case acmFormate24Bit5_1:
740  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
741  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChan5_1;
742  break;
743  case acmFormateMax:
744  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmtUnknown;
745  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanUnknown;
746  break;
747  default:
748  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
749  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
750  break;
751  }
752 
753  switch (pstBtrMgrAcHdl->stBtrMgrAcmDefSettings.sampling_frequency) {
754  case acmFreqe16000:
755  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq16K;
756  break;
757  case acmFreqe32000:
758  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq32K;
759  break;
760  case acmFreqe44100:
761  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq44_1K;
762  break;
763  case acmFreqe48000:
764  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
765  break;
766  case acmFreqeMax:
767  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreqUnknown;
768  break;
769  default:
770  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
771  break;
772  }
773  }
774  else {
775  leBtrMgrAcRet = eBTRMgrFailure;
776  }
777  }
778  }
779 #elif defined(USE_AC_RMF)
780  else if ((pstBtrMgrAcHdl->pcBTRMgrAcType == NULL) ||
781  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) {
782  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_GetDefaultSettings(&pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings)) != RMF_SUCCESS) {
783  BTRMGRLOG_ERROR("Return Status = %d\n", leBtrMgrRmfAcRet);
784  leBtrMgrAcRet = eBTRMgrFailure;
785  }
786 
787  BTRMGRLOG_TRACE ("Default CBBufferReady = %p\n", pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings.cbBufferReady);
788  BTRMGRLOG_TRACE ("Default Fifosize = %d\n", pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings.fifoSize);
789  BTRMGRLOG_TRACE ("Default Threshold = %d\n", pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings.threshold);
790 
791  //TODO: Get the format capture format from RMF_AudioCapture Settings
792  apstBtrMgrAcOutASettings->eBtrMgrOutAType = eBTRMgrATypePCM;
793 
794  if (apstBtrMgrAcOutASettings->eBtrMgrOutAType == eBTRMgrATypePCM) {
795  stBTRMgrPCMInfo* pstBtrMgrAcOutPcmInfo = (stBTRMgrPCMInfo*)(apstBtrMgrAcOutASettings->pstBtrMgrOutCodecInfo);
796 
797  switch (pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings.format) {
798  case racFormat_e16BitStereo:
799  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
800  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
801  break;
802  case racFormat_e24BitStereo:
803  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
804  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
805  break;
806  case racFormat_e16BitMonoLeft:
807  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
808  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
809  break;
810  case racFormat_e16BitMonoRight:
811  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
812  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
813  break;
814  case racFormat_e16BitMono:
815  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
816  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
817  break;
818  case racFormat_e24Bit5_1:
819  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
820  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChan5_1;
821  break;
822  case racFormat_eMax:
823  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmtUnknown;
824  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanUnknown;
825  break;
826  default:
827  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
828  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
829  break;
830  }
831 
832  switch (pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings.samplingFreq) {
833  case racFreq_e16000:
834  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq16K;
835  break;
836  case racFreq_e32000:
837  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq32K;
838  break;
839  case racFreq_e44100:
840  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq44_1K;
841  break;
842  case racFreq_e48000:
843  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
844  break;
845  case racFreq_eMax:
846  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreqUnknown;
847  break;
848  default:
849  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
850  break;
851  }
852  }
853  else {
854  leBtrMgrAcRet = eBTRMgrFailure;
855  }
856  }
857 #endif
858 
859  return leBtrMgrAcRet;
860 }
861 
862 eBTRMgrRet
863 BTRMgr_AC_GetCurrentSettings (
864  tBTRMgrAcHdl hBTRMgrAcHdl,
865  stBTRMgrOutASettings* apstBtrMgrAcOutASettings
866 ) {
867  eBTRMgrRet leBtrMgrAcRet = eBTRMgrSuccess;
868  stBTRMgrACHdl* pstBtrMgrAcHdl = (stBTRMgrACHdl*)hBTRMgrAcHdl;
869 
870 #if defined(USE_AC_RMF)
871  rmf_Error leBtrMgrRmfAcRet = RMF_SUCCESS;
872 #endif
873 
874 #if defined(USE_ACM)
875  iarmbus_acm_arg_t lstBtrMgrIarmAcmArgs;
876  IARM_Result_t leBtrMgIarmAcmRet = IARM_RESULT_SUCCESS;
877 #endif
878 
879  if (pstBtrMgrAcHdl == NULL) {
880  return eBTRMgrNotInitialized;
881  }
882 
883  if (apstBtrMgrAcOutASettings == NULL) {
884  return eBTRMgrFailInArg;
885  }
886 
887 #if defined(USE_AC_RMF)
888  if ((pstBtrMgrAcHdl->pcBTRMgrAcType != NULL) &&
889  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_AUXILIARY, strlen(BTRMGR_AC_TYPE_AUXILIARY)))) {
890  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_GetCurrentSettings( pstBtrMgrAcHdl->hBTRMgrRmfAcHdl,
891  &pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings)) != RMF_SUCCESS) {
892  BTRMGRLOG_ERROR("Return Status = %d\n", leBtrMgrRmfAcRet);
893  leBtrMgrAcRet = eBTRMgrFailure;
894  }
895 
896  BTRMGRLOG_DEBUG ("Current CBBufferReady = %p\n", pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.cbBufferReady);
897  BTRMGRLOG_DEBUG ("Current Fifosize = %d\n", (int)pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.fifoSize);
898  BTRMGRLOG_DEBUG ("Current Threshold = %d\n", (int)pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.threshold);
899 
900  //TODO: Get the format capture format from RMF_AudioCapture Settings
901  apstBtrMgrAcOutASettings->eBtrMgrOutAType = eBTRMgrATypePCM;
902 
903  if (apstBtrMgrAcOutASettings->eBtrMgrOutAType == eBTRMgrATypePCM) {
904  stBTRMgrPCMInfo* pstBtrMgrAcOutPcmInfo = (stBTRMgrPCMInfo*)(apstBtrMgrAcOutASettings->pstBtrMgrOutCodecInfo);
905 
906  switch (pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.format) {
907  case racFormat_e16BitStereo:
908  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
909  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
910  break;
911  case racFormat_e24BitStereo:
912  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
913  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
914  break;
915  case racFormat_e16BitMonoLeft:
916  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
917  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
918  break;
919  case racFormat_e16BitMonoRight:
920  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
921  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
922  break;
923  case racFormat_e16BitMono:
924  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
925  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
926  break;
927  case racFormat_e24Bit5_1:
928  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
929  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChan5_1;
930  break;
931  case racFormat_eMax:
932  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmtUnknown;
933  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanUnknown;
934  break;
935  default:
936  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
937  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
938  break;
939  }
940 
941  switch (pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.samplingFreq) {
942  case racFreq_e16000:
943  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq16K;
944  break;
945  case racFreq_e32000:
946  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq32K;
947  break;
948  case racFreq_e44100:
949  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq44_1K;
950  break;
951  case racFreq_e48000:
952  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
953  break;
954  case racFreq_eMax:
955  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreqUnknown;
956  break;
957  default:
958  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
959  break;
960  }
961  }
962  else {
963  leBtrMgrAcRet = eBTRMgrFailure;
964  }
965  }
966 #endif
967 
968 #if defined(USE_ACM)
969  if ((pstBtrMgrAcHdl->pcBTRMgrAcType == NULL) ||
970  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) {
971  memset(&lstBtrMgrIarmAcmArgs, 0, sizeof(iarmbus_acm_arg_t));
972  lstBtrMgrIarmAcmArgs.session_id = pstBtrMgrAcHdl->hBtrMgrIarmAcmHdl;
973 
974  if ((leBtrMgIarmAcmRet = IARM_Bus_Call (IARMBUS_AUDIOCAPTUREMGR_NAME,
975  IARMBUS_AUDIOCAPTUREMGR_GET_AUDIO_PROPS,
976  (void *)&lstBtrMgrIarmAcmArgs,
977  sizeof(lstBtrMgrIarmAcmArgs))) != IARM_RESULT_SUCCESS) {
978  BTRMGRLOG_ERROR("IARMBUS_AUDIOCAPTUREMGR_GET_AUDIO_PROPS:Return Status = %d\n", leBtrMgIarmAcmRet);
979  leBtrMgrAcRet = eBTRMgrFailure;
980  }
981 
982  if ((leBtrMgrAcRet != eBTRMgrSuccess) || (lstBtrMgrIarmAcmArgs.result != 0)) {
983  BTRMGRLOG_ERROR("lstBtrMgrIarmAcmArgs:Return Status = %d\n", lstBtrMgrIarmAcmArgs.result);
984  leBtrMgrAcRet = eBTRMgrFailure;
985  }
986 
987 
988  if (leBtrMgrAcRet == eBTRMgrSuccess) {
989  memcpy(&pstBtrMgrAcHdl->stBtrMgrAcmCurSettings, &lstBtrMgrIarmAcmArgs.details.arg_audio_properties, sizeof(audio_properties_ifce_t));
990 
991  BTRMGRLOG_DEBUG ("Current Fifosize = %d\n", (int)pstBtrMgrAcHdl->stBtrMgrAcmCurSettings.fifo_size);
992  BTRMGRLOG_DEBUG ("Current Threshold= %d\n", (int)pstBtrMgrAcHdl->stBtrMgrAcmCurSettings.threshold);
993  BTRMGRLOG_DEBUG ("Current DelayComp= %d\n", pstBtrMgrAcHdl->stBtrMgrAcmCurSettings.delay_compensation_ms);
994 
995  //TODO: Get the format capture format from IARMBUS_AUDIOCAPTUREMGR_NAME
996  apstBtrMgrAcOutASettings->eBtrMgrOutAType = eBTRMgrATypePCM;
997 
998  if (apstBtrMgrAcOutASettings->eBtrMgrOutAType == eBTRMgrATypePCM) {
999  stBTRMgrPCMInfo* pstBtrMgrAcOutPcmInfo = (stBTRMgrPCMInfo*)(apstBtrMgrAcOutASettings->pstBtrMgrOutCodecInfo);
1000 
1001  switch (pstBtrMgrAcHdl->stBtrMgrAcmCurSettings.format) {
1002  case acmFormate16BitStereo:
1003  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1004  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
1005  break;
1006  case acmFormate24BitStereo:
1007  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
1008  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
1009  break;
1010  case acmFormate16BitMonoLeft:
1011  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1012  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
1013  break;
1014  case acmFormate16BitMonoRight:
1015  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1016  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
1017  break;
1018  case acmFormate16BitMono:
1019  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1020  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
1021  break;
1022  case acmFormate24Bit5_1:
1023  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
1024  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChan5_1;
1025  break;
1026  case acmFormateMax:
1027  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmtUnknown;
1028  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanUnknown;
1029  break;
1030  default:
1031  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1032  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
1033  break;
1034  }
1035 
1036  switch (pstBtrMgrAcHdl->stBtrMgrAcmCurSettings.sampling_frequency) {
1037  case acmFreqe16000:
1038  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq16K;
1039  break;
1040  case acmFreqe32000:
1041  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq32K;
1042  break;
1043  case acmFreqe44100:
1044  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq44_1K;
1045  break;
1046  case acmFreqe48000:
1047  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
1048  break;
1049  case acmFreqeMax:
1050  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreqUnknown;
1051  break;
1052  default:
1053  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
1054  break;
1055  }
1056  }
1057  else {
1058  leBtrMgrAcRet = eBTRMgrFailure;
1059  }
1060  }
1061  }
1062 #elif defined(USE_AC_RMF)
1063  else if ((pstBtrMgrAcHdl->pcBTRMgrAcType == NULL) ||
1064  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) {
1065  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_GetCurrentSettings( pstBtrMgrAcHdl->hBTRMgrRmfAcHdl,
1066  &pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings)) != RMF_SUCCESS) {
1067  BTRMGRLOG_ERROR("Return Status = %d\n", leBtrMgrRmfAcRet);
1068  leBtrMgrAcRet = eBTRMgrFailure;
1069  }
1070 
1071  BTRMGRLOG_DEBUG ("Current CBBufferReady = %p\n", pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.cbBufferReady);
1072  BTRMGRLOG_DEBUG ("Current Fifosize = %d\n", pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.fifoSize);
1073  BTRMGRLOG_DEBUG ("Current Threshold = %d\n", pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.threshold);
1074 
1075  //TODO: Get the format capture format from RMF_AudioCapture Settings
1076  apstBtrMgrAcOutASettings->eBtrMgrOutAType = eBTRMgrATypePCM;
1077 
1078  if (apstBtrMgrAcOutASettings->eBtrMgrOutAType == eBTRMgrATypePCM) {
1079  stBTRMgrPCMInfo* pstBtrMgrAcOutPcmInfo = (stBTRMgrPCMInfo*)(apstBtrMgrAcOutASettings->pstBtrMgrOutCodecInfo);
1080 
1081  switch (pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.format) {
1082  case racFormat_e16BitStereo:
1083  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1084  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
1085  break;
1086  case racFormat_e24BitStereo:
1087  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
1088  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
1089  break;
1090  case racFormat_e16BitMonoLeft:
1091  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1092  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
1093  break;
1094  case racFormat_e16BitMonoRight:
1095  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1096  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
1097  break;
1098  case racFormat_e16BitMono:
1099  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1100  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanMono;
1101  break;
1102  case racFormat_e24Bit5_1:
1103  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt24bit;
1104  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChan5_1;
1105  break;
1106  case racFormat_eMax:
1107  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmtUnknown;
1108  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanUnknown;
1109  break;
1110  default:
1111  pstBtrMgrAcOutPcmInfo->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1112  pstBtrMgrAcOutPcmInfo->eBtrMgrAChan = eBTRMgrAChanStereo;
1113  break;
1114  }
1115 
1116  switch (pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.samplingFreq) {
1117  case racFreq_e16000:
1118  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq16K;
1119  break;
1120  case racFreq_e32000:
1121  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq32K;
1122  break;
1123  case racFreq_e44100:
1124  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq44_1K;
1125  break;
1126  case racFreq_e48000:
1127  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
1128  break;
1129  case racFreq_eMax:
1130  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreqUnknown;
1131  break;
1132  default:
1133  pstBtrMgrAcOutPcmInfo->eBtrMgrSFreq = eBTRMgrSFreq48K;
1134  break;
1135  }
1136  }
1137  else {
1138  leBtrMgrAcRet = eBTRMgrFailure;
1139  }
1140  }
1141 #endif
1142 
1143  return leBtrMgrAcRet;
1144 }
1145 
1146 
1147 eBTRMgrRet
1148 BTRMgr_AC_GetStatus (
1149  tBTRMgrAcHdl hBTRMgrAcHdl,
1150  stBTRMgrMediaStatus* apstBtrMgrAcStatus
1151 ) {
1152  eBTRMgrRet leBtrMgrAcRet = eBTRMgrSuccess;
1153 
1154  return leBtrMgrAcRet;
1155 }
1156 
1157 
1158 eBTRMgrRet
1159 BTRMgr_AC_Start (
1160  tBTRMgrAcHdl hBTRMgrAcHdl,
1161  stBTRMgrOutASettings* apstBtrMgrAcOutASettings,
1162  fPtr_BTRMgr_AC_DataReadyCb afpcBBtrMgrAcDataReady,
1163  fPtr_BTRMgr_AC_StatusCb afpcBBtrMgrAcStatus,
1164  void* apvUserData
1165 ) {
1166  eBTRMgrRet leBtrMgrAcRet = eBTRMgrSuccess;
1167  stBTRMgrACHdl* pstBtrMgrAcHdl = (stBTRMgrACHdl*)hBTRMgrAcHdl;
1168 
1169 #if defined(USE_AC_RMF)
1170  rmf_Error leBtrMgrRmfAcRet = RMF_SUCCESS;
1171  RMF_AudioCapture_Settings* pstBtrMgrRmfAcSettings = NULL;
1172 #endif
1173 
1174 #if defined(USE_ACM)
1175  iarmbus_acm_arg_t lstBtrMgrIarmAcmArgs;
1176  IARM_Result_t leBtrMgIarmAcmRet = IARM_RESULT_SUCCESS;
1177 #endif
1178 
1179  if (pstBtrMgrAcHdl == NULL) {
1180  return eBTRMgrNotInitialized;
1181  }
1182 
1183  if (apstBtrMgrAcOutASettings == NULL) {
1184  return eBTRMgrFailInArg;
1185  }
1186 
1187  pstBtrMgrAcHdl->fpcBBtrMgrAcDataReady = afpcBBtrMgrAcDataReady;
1188  pstBtrMgrAcHdl->vpBtrMgrAcDataReadyUserData = apvUserData;
1189 
1190  pstBtrMgrAcHdl->fpcBBtrMgrAcStatus = afpcBBtrMgrAcStatus;
1191  pstBtrMgrAcHdl->vpBtrMgrAcStatusUserData = apvUserData;
1192 
1193 #if defined(USE_AC_RMF)
1194  if ((pstBtrMgrAcHdl->pcBTRMgrAcType != NULL) &&
1195  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_AUXILIARY, strlen(BTRMGR_AC_TYPE_AUXILIARY)))) {
1196 
1197  if (pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.fifoSize)
1198  pstBtrMgrRmfAcSettings = &pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings;
1199  else
1200  pstBtrMgrRmfAcSettings = &pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings;
1201 
1202 
1203  pstBtrMgrRmfAcSettings->cbBufferReady = btrMgr_AC_rmfBufferReadyCb;
1204  pstBtrMgrRmfAcSettings->cbBufferReadyParm = pstBtrMgrAcHdl;
1205  pstBtrMgrRmfAcSettings->cbStatusChange = btrMgr_AC_rmfStatusChangeCb;
1206  pstBtrMgrRmfAcSettings->cbStatusParm = pstBtrMgrAcHdl;
1207  pstBtrMgrRmfAcSettings->fifoSize = 8 * apstBtrMgrAcOutASettings->i32BtrMgrOutBufMaxSize;
1208  pstBtrMgrRmfAcSettings->threshold = apstBtrMgrAcOutASettings->i32BtrMgrOutBufMaxSize;
1209 
1210  #if defined(TV_CUSTOM_DELAY_COMP)
1211  //TODO: Work on a intelligent way to arrive at this value. This is not good enough
1212  if (pstBtrMgrAcHdl->pstBtrMgrAcmSettings->threshold > 4096) {
1213  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms = 260;
1214  }
1215  else if (pstBtrMgrAcHdl->pstBtrMgrAcmSettings->threshold >= 3584) {
1216  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms = 260;
1217  }
1218  else {
1219  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms = 240;
1220  }
1221 
1222  if ((apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay != 0) && (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay != 0xFFFFu)) {
1223  // There is no ideal BT device capable of rendering instantaneously, as the external device is
1224  // specifying delay, deduct from aggregate values of trials of device which donot specify any delay param
1225  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms -= 100;
1226  // As the external device is specifying delay, add it to total Compensation
1227  // Device delay is in 1/10 of millisecond
1228  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay/10;
1229  // AVDTP 1.3 - 5.5 Delay Reporting
1230  // The delay reporting feature enables synchronization of audio and video playback by
1231  // reporting of SNK delay values caused by buffering, decoding and rendering
1232 
1233  if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay >= 1500) {
1234  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms -= 50;
1235  }
1236  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay >= 1400) {
1237  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms -= 40;
1238  }
1239  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay >= 1200) {
1240  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms -= 20;
1241  }
1242  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay >= 1000) {
1243  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms -= 0;
1244  }
1245  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay >= 800) {
1246  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 20;
1247  }
1248  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay > 600) {
1249  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 30;
1250  }
1251  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay > 400) {
1252  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 40;
1253  }
1254  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay > 200) {
1255  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 60;
1256  }
1257  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay > 100) {
1258  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 80;
1259  }
1260  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay > 50) {
1261  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 100;
1262  }
1263  }
1264  #else
1265  //TODO: Work on a intelligent way to arrive at this value. This is not good enough
1266  if (pstBtrMgrRmfAcSettings->threshold > 4096) {
1267  pstBtrMgrRmfAcSettings->delayCompensation_ms = 400;
1268  }
1269  else if (pstBtrMgrRmfAcSettings->threshold >= 3584) {
1270  pstBtrMgrRmfAcSettings->delayCompensation_ms = 380;
1271  }
1272  else {
1273  pstBtrMgrRmfAcSettings->delayCompensation_ms = 360;
1274  }
1275 
1276  if ((apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay != 0) && (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay != 0xFFFFu)) {
1277  // There is no ideal BT device capable of rendering instantaneously, as the external device is
1278  // specifying delay, deduct from aggregate values of trials of device which donot specify any delay param
1279  pstBtrMgrRmfAcSettings->delayCompensation_ms -= 120;
1280  // As the external device is specifying delay, add it to total Compensation
1281  // Device delay is in 1/10 of millisecond
1282  pstBtrMgrRmfAcSettings->delayCompensation_ms += apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay/10;
1283  // AVDTP 1.3 - 5.5 Delay Reporting
1284  // The delay reporting feature enables synchronization of audio and video playback by
1285  // reporting of SNK delay values caused by buffering, decoding and rendering
1286  }
1287  #endif
1288  //TODO: Bad hack above, need to modify before taking it to stable2
1289 
1290 
1291  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_Start(pstBtrMgrAcHdl->hBTRMgrRmfAcHdl,
1292  pstBtrMgrRmfAcSettings)) != RMF_SUCCESS) {
1293  BTRMGRLOG_ERROR("Return Status = %d\n", leBtrMgrRmfAcRet);
1294  leBtrMgrAcRet = eBTRMgrFailure;
1295  }
1296  }
1297 #endif
1298 
1299 #if defined(USE_ACM)
1300  if ((pstBtrMgrAcHdl->pcBTRMgrAcType == NULL) ||
1301  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) {
1302  memset(&lstBtrMgrIarmAcmArgs, 0, sizeof(iarmbus_acm_arg_t));
1303  lstBtrMgrIarmAcmArgs.session_id = pstBtrMgrAcHdl->hBtrMgrIarmAcmHdl;
1304 
1305 
1306  if ((pstBtrMgrAcHdl->stBtrMgrAcmCurSettings.fifo_size != 0) && (pstBtrMgrAcHdl->stBtrMgrAcmCurSettings.threshold != 0))
1307  pstBtrMgrAcHdl->pstBtrMgrAcmSettings = &pstBtrMgrAcHdl->stBtrMgrAcmCurSettings;
1308  else
1309  pstBtrMgrAcHdl->pstBtrMgrAcmSettings = &pstBtrMgrAcHdl->stBtrMgrAcmDefSettings;
1310 
1311 
1312  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->fifo_size = 8 * apstBtrMgrAcOutASettings->i32BtrMgrOutBufMaxSize;
1313  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->threshold = apstBtrMgrAcOutASettings->i32BtrMgrOutBufMaxSize;
1314 
1315  #if defined(TV_CUSTOM_DELAY_COMP)
1316  //TODO: Work on a intelligent way to arrive at this value. This is not good enough
1317  if (pstBtrMgrAcHdl->pstBtrMgrAcmSettings->threshold > 4096) {
1318  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms = 260;
1319  }
1320  else if (pstBtrMgrAcHdl->pstBtrMgrAcmSettings->threshold >= 3584) {
1321  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms = 260;
1322  }
1323  else {
1324  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms = 240;
1325  }
1326 
1327  if ((apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay != 0) && (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay != 0xFFFFu)) {
1328  // There is no ideal BT device capable of rendering instantaneously, as the external device is
1329  // specifying delay, deduct from aggregate values of trials of device which donot specify any delay param
1330  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms -= 100;
1331  // As the external device is specifying delay, add it to total Compensation
1332  // Device delay is in 1/10 of millisecond
1333  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay/10;
1334  // AVDTP 1.3 - 5.5 Delay Reporting
1335  // The delay reporting feature enables synchronization of audio and video playback by
1336  // reporting of SNK delay values caused by buffering, decoding and rendering
1337 
1338  if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay >= 1500) {
1339  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms -= 50;
1340  }
1341  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay >= 1400) {
1342  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms -= 40;
1343  }
1344  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay >= 1200) {
1345  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms -= 20;
1346  }
1347  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay >= 1000) {
1348  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms -= 0;
1349  }
1350  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay >= 800) {
1351  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 20;
1352  }
1353  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay > 600) {
1354  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 30;
1355  }
1356  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay > 400) {
1357  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 40;
1358  }
1359  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay > 200) {
1360  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 60;
1361  }
1362  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay > 100) {
1363  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 80;
1364  }
1365  else if (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay > 50) {
1366  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += 100;
1367  }
1368  }
1369  #else
1370  //TODO: Work on a intelligent way to arrive at this value. This is not good enough
1371  if (pstBtrMgrAcHdl->pstBtrMgrAcmSettings->threshold > 4096) {
1372  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms = 240;
1373  }
1374  else if (pstBtrMgrAcHdl->pstBtrMgrAcmSettings->threshold >= 3584) {
1375  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms = 220;
1376  }
1377  else {
1378  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms = 200;
1379  }
1380 
1381  if ((apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay != 0) && (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay != 0xFFFFu)) {
1382  // There is no ideal BT device capable of rendering instantaneously, as the external device is
1383  // specifying delay, deduct from aggregate values of trials of device which donot specify any delay param
1384  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms -= 120;
1385  // As the external device is specifying delay, add it to total Compensation
1386  // Device delay is in 1/10 of millisecond
1387  pstBtrMgrAcHdl->pstBtrMgrAcmSettings->delay_compensation_ms += apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay/10;
1388  // AVDTP 1.3 - 5.5 Delay Reporting
1389  // The delay reporting feature enables synchronization of audio and video playback by
1390  // reporting of SNK delay values caused by buffering, decoding and rendering
1391  }
1392  #endif
1393  //TODO: Bad hack above, need to modify before taking it to stable2
1394 
1395  memcpy(&lstBtrMgrIarmAcmArgs.details.arg_audio_properties, pstBtrMgrAcHdl->pstBtrMgrAcmSettings, sizeof(audio_properties_ifce_t));
1396 
1397  if ((leBtrMgIarmAcmRet = IARM_Bus_Call (IARMBUS_AUDIOCAPTUREMGR_NAME,
1398  IARMBUS_AUDIOCAPTUREMGR_SET_AUDIO_PROPERTIES,
1399  (void *)&lstBtrMgrIarmAcmArgs,
1400  sizeof(lstBtrMgrIarmAcmArgs))) != IARM_RESULT_SUCCESS) {
1401  BTRMGRLOG_ERROR("IARMBUS_AUDIOCAPTUREMGR_SET_AUDIO_PROPERTIES:Return Status = %d\n", leBtrMgIarmAcmRet);
1402  leBtrMgrAcRet = eBTRMgrFailure;
1403  }
1404 
1405  if ((leBtrMgrAcRet != eBTRMgrSuccess) || (lstBtrMgrIarmAcmArgs.result != 0)) {
1406  BTRMGRLOG_ERROR("lstBtrMgrIarmAcmArgs:Return Status = %d\n", lstBtrMgrIarmAcmArgs.result);
1407  leBtrMgrAcRet = eBTRMgrFailure;
1408  }
1409 
1410 
1411 
1412  memset(&lstBtrMgrIarmAcmArgs, 0, sizeof(iarmbus_acm_arg_t));
1413  lstBtrMgrIarmAcmArgs.session_id = pstBtrMgrAcHdl->hBtrMgrIarmAcmHdl;
1414 
1415  if ((leBtrMgIarmAcmRet = IARM_Bus_Call (IARMBUS_AUDIOCAPTUREMGR_NAME,
1416  IARMBUS_AUDIOCAPTUREMGR_GET_OUTPUT_PROPS,
1417  (void *)&lstBtrMgrIarmAcmArgs,
1418  sizeof(lstBtrMgrIarmAcmArgs))) != IARM_RESULT_SUCCESS) {
1419  BTRMGRLOG_ERROR("IARMBUS_AUDIOCAPTUREMGR_GET_OUTPUT_PROPS:Return Status = %d\n", leBtrMgIarmAcmRet);
1420  leBtrMgrAcRet = eBTRMgrFailure;
1421  }
1422 
1423  if ((leBtrMgrAcRet != eBTRMgrSuccess) || (lstBtrMgrIarmAcmArgs.result != 0)) {
1424  BTRMGRLOG_ERROR("lstBtrMgrIarmAcmArgs:Return Status = %d\n", lstBtrMgrIarmAcmArgs.result);
1425  leBtrMgrAcRet = eBTRMgrFailure;
1426  }
1427 
1428  strncpy(pstBtrMgrAcHdl->pcBtrMgrAcmSockPath, lstBtrMgrIarmAcmArgs.details.arg_output_props.output.file_path,
1429  strlen(lstBtrMgrIarmAcmArgs.details.arg_output_props.output.file_path) < MAX_OUTPUT_PATH_LEN ?
1430  strlen(lstBtrMgrIarmAcmArgs.details.arg_output_props.output.file_path) : MAX_OUTPUT_PATH_LEN - 1);
1431 
1432  BTRMGRLOG_DEBUG ("IARMBUS_AUDIOCAPTUREMGR_GET_OUTPUT_PROPS : pcBtrMgrAcmSockPath = %s\n", pstBtrMgrAcHdl->pcBtrMgrAcmSockPath);
1433 
1434 
1435  memset(&lstBtrMgrIarmAcmArgs, 0, sizeof(iarmbus_acm_arg_t));
1436  lstBtrMgrIarmAcmArgs.session_id = pstBtrMgrAcHdl->hBtrMgrIarmAcmHdl;
1437 
1438  if ((leBtrMgIarmAcmRet = IARM_Bus_Call (IARMBUS_AUDIOCAPTUREMGR_NAME,
1439  IARMBUS_AUDIOCAPTUREMGR_START,
1440  (void *)&lstBtrMgrIarmAcmArgs,
1441  sizeof(lstBtrMgrIarmAcmArgs))) != IARM_RESULT_SUCCESS) {
1442  BTRMGRLOG_ERROR("IARMBUS_AUDIOCAPTUREMGR_START:Return Status = %d\n", leBtrMgIarmAcmRet);
1443  leBtrMgrAcRet = eBTRMgrFailure;
1444  }
1445 
1446  if ((leBtrMgrAcRet != eBTRMgrSuccess) || (lstBtrMgrIarmAcmArgs.result != 0)) {
1447  BTRMGRLOG_ERROR("lstBtrMgrIarmAcmArgs:Return Status = %d\n", lstBtrMgrIarmAcmArgs.result);
1448  leBtrMgrAcRet = eBTRMgrFailure;
1449  }
1450 
1451 
1452  if (pstBtrMgrAcHdl->pBtrMgrAcmDataCapGThread) {
1453  gpointer lpeBtrMgrAcmDCOp = NULL;
1454  if ((lpeBtrMgrAcmDCOp = g_malloc0(sizeof(eBTRMgrACAcmDCOp))) != NULL) {
1455  *((eBTRMgrACAcmDCOp*)lpeBtrMgrAcmDCOp) = eBTRMgrACAcmDCStart;
1456  g_async_queue_push(pstBtrMgrAcHdl->pBtrMgrAcmDataCapGAOpQueue, lpeBtrMgrAcmDCOp);
1457  BTRMGRLOG_DEBUG ("g_async_queue_push: eBTRMgrACAcmDCStart\n");
1458  }
1459  }
1460  else {
1461  BTRMGRLOG_ERROR("pBtrMgrAcmDataCapGThread: eBTRMgrACAcmDCStart - FAILED\n");
1462  leBtrMgrAcRet = eBTRMgrFailure;
1463  }
1464  }
1465 #elif defined(USE_AC_RMF)
1466  else if ((pstBtrMgrAcHdl->pcBTRMgrAcType == NULL) ||
1467  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) {
1468 
1469  if (pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings.fifoSize)
1470  pstBtrMgrRmfAcSettings = &pstBtrMgrAcHdl->stBtrMgrRmfAcCurSettings;
1471  else
1472  pstBtrMgrRmfAcSettings = &pstBtrMgrAcHdl->stBtrMgrRmfAcDefSettings;
1473 
1474 
1475  pstBtrMgrRmfAcSettings->cbBufferReady = btrMgr_AC_rmfBufferReadyCb;
1476  pstBtrMgrRmfAcSettings->cbBufferReadyParm = pstBtrMgrAcHdl;
1477  pstBtrMgrRmfAcSettings->cbStatusChange = NULL;
1478  pstBtrMgrRmfAcSettings->cbStatusParm = NULL;
1479  pstBtrMgrRmfAcSettings->fifoSize = 8 * apstBtrMgrAcOutASettings->i32BtrMgrOutBufMaxSize;
1480  pstBtrMgrRmfAcSettings->threshold = apstBtrMgrAcOutASettings->i32BtrMgrOutBufMaxSize;
1481 
1482  //TODO: Work on a intelligent way to arrive at this value. This is not good enough
1483  if ((apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay != 0) && (apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay != 0xFFFFu))
1484  pstBtrMgrRmfAcSettings->delayCompensation_ms = apstBtrMgrAcOutASettings->ui32BtrMgrDevDelay;
1485  else if (pstBtrMgrRmfAcSettings->threshold > 4096)
1486  pstBtrMgrRmfAcSettings->delayCompensation_ms = 400;
1487  else
1488  pstBtrMgrRmfAcSettings->delayCompensation_ms = 360;
1489  //TODO: Bad hack above, need to modify before taking it to stable2
1490 
1491  BTRMGRLOG_WARN ("Current Fifosize = %d\n", pstBtrMgrRmfAcSettings->fifoSize);
1492  BTRMGRLOG_WARN ("Current Threshold= %d\n", pstBtrMgrRmfAcSettings->threshold);
1493  BTRMGRLOG_WARN ("Current DelayComp= %d\n", pstBtrMgrRmfAcSettings->delayCompensation_ms);
1494 
1495  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_Start(pstBtrMgrAcHdl->hBTRMgrRmfAcHdl,
1496  pstBtrMgrRmfAcSettings)) != RMF_SUCCESS) {
1497  BTRMGRLOG_ERROR("Return Status = %d\n", leBtrMgrRmfAcRet);
1498  leBtrMgrAcRet = eBTRMgrFailure;
1499  }
1500  }
1501 #endif
1502 
1503  return leBtrMgrAcRet;
1504 }
1505 
1506 
1507 eBTRMgrRet
1508 BTRMgr_AC_Stop (
1509  tBTRMgrAcHdl hBTRMgrAcHdl
1510 ) {
1511  eBTRMgrRet leBtrMgrAcRet = eBTRMgrSuccess;
1512  stBTRMgrACHdl* pstBtrMgrAcHdl = (stBTRMgrACHdl*)hBTRMgrAcHdl;
1513 
1514 #if defined(USE_AC_RMF)
1515  rmf_Error leBtrMgrRmfAcRet = RMF_SUCCESS;
1516 #endif
1517 
1518 
1519  if (pstBtrMgrAcHdl == NULL) {
1520  return eBTRMgrNotInitialized;
1521  }
1522 
1523 #if defined(USE_AC_RMF)
1524  if ((pstBtrMgrAcHdl->pcBTRMgrAcType != NULL) &&
1525  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_AUXILIARY, strlen(BTRMGR_AC_TYPE_AUXILIARY)))) {
1526  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_Stop(pstBtrMgrAcHdl->hBTRMgrRmfAcHdl)) != RMF_SUCCESS) {
1527  BTRMGRLOG_ERROR("Return Status = %d\n", leBtrMgrRmfAcRet);
1528  leBtrMgrAcRet = eBTRMgrFailure;
1529  }
1530  }
1531 #endif
1532 
1533 #if defined(USE_ACM)
1534  if ((pstBtrMgrAcHdl->pcBTRMgrAcType == NULL) ||
1535  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) {
1536 
1537  if (pstBtrMgrAcHdl->pBtrMgrAcmDataCapGThread) {
1538  gpointer lpeBtrMgrAcmDCOp = NULL;
1539  if ((lpeBtrMgrAcmDCOp = g_malloc0(sizeof(eBTRMgrACAcmDCOp))) != NULL) {
1540  *((eBTRMgrACAcmDCOp*)lpeBtrMgrAcmDCOp) = eBTRMgrACAcmDCStop;
1541  g_async_queue_push(pstBtrMgrAcHdl->pBtrMgrAcmDataCapGAOpQueue, lpeBtrMgrAcmDCOp);
1542  BTRMGRLOG_DEBUG ("g_async_queue_push: eBTRMgrACAcmDCStop\n");
1543  }
1544  }
1545  else {
1546  BTRMGRLOG_ERROR("pBtrMgrAcmDataCapGThread: eBTRMgrACAcmDCStop - FAILED\n");
1547  leBtrMgrAcRet = eBTRMgrFailure;
1548  }
1549 
1550  pstBtrMgrAcHdl->fpcBBtrMgrAcDataReady = NULL;
1551  }
1552 #elif defined(USE_AC_RMF)
1553  if ((pstBtrMgrAcHdl->pcBTRMgrAcType == NULL) ||
1554  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_PRIMARY, strlen(BTRMGR_AC_TYPE_PRIMARY)))) {
1555  if ((leBtrMgrRmfAcRet = RMF_AudioCapture_Stop(pstBtrMgrAcHdl->hBTRMgrRmfAcHdl)) != RMF_SUCCESS) {
1556  BTRMGRLOG_ERROR("Return Status = %d\n", leBtrMgrRmfAcRet);
1557  leBtrMgrAcRet = eBTRMgrFailure;
1558  }
1559  }
1560 #endif
1561 
1562  return leBtrMgrAcRet;
1563 }
1564 
1565 
1566 eBTRMgrRet
1567 BTRMgr_AC_Pause (
1568  tBTRMgrAcHdl hBTRMgrAcHdl
1569 ) {
1570  eBTRMgrRet leBtrMgrAcRet = eBTRMgrSuccess;
1571 
1572  return leBtrMgrAcRet;
1573 }
1574 
1575 
1576 eBTRMgrRet
1577 BTRMgr_AC_Resume (
1578  tBTRMgrAcHdl hBTRMgrAcHdl
1579 ) {
1580  eBTRMgrRet leBtrMgrAcRet = eBTRMgrSuccess;
1581 
1582  return leBtrMgrAcRet;
1583 }
1584 
1585 // Outgoing callbacks Registration Interfaces
1586 
1587 
1588 /* Incoming Callbacks */
1589 #if defined(USE_AC_RMF)
1590 static rmf_Error
1591 btrMgr_AC_rmfBufferReadyCb (
1592  void* pContext,
1593  void* pInDataBuf,
1594  unsigned int inBytesToEncode
1595 ) {
1596  stBTRMgrACHdl* pstBtrMgrAcHdl = (stBTRMgrACHdl*)pContext;
1597 
1598  if (pstBtrMgrAcHdl && pstBtrMgrAcHdl->fpcBBtrMgrAcDataReady) {
1599  if (pstBtrMgrAcHdl->fpcBBtrMgrAcDataReady(pInDataBuf, inBytesToEncode, pstBtrMgrAcHdl->vpBtrMgrAcDataReadyUserData) != eBTRMgrSuccess) {
1600  BTRMGRLOG_ERROR("AC Data Ready Callback Failed\n");
1601  }
1602  }
1603 
1604  return RMF_SUCCESS;
1605 }
1606 
1607 
1608 static rmf_Error
1609 btrMgr_AC_rmfStatusChangeCb (
1610  void* pContext
1611 ) {
1612  stBTRMgrACHdl* pstBtrMgrAcHdl = (stBTRMgrACHdl*)pContext;
1613  bool bTriggerStatusChanged = false;
1614 
1615  if (pstBtrMgrAcHdl) {
1616  RMF_AudioCapture_Status lstBtrMgrRmfAcStatus;
1617  RMF_AudioCapture_Status* pstBtrMgrRmfAcStatus = &pstBtrMgrAcHdl->stBtrMgrRmfAcStatus;
1618 
1619  BTRMGRLOG_WARN("Status Changed\n");
1620  memset(&lstBtrMgrRmfAcStatus, 0, sizeof(RMF_AudioCapture_Status));
1621  RMF_AudioCapture_GetStatus(pstBtrMgrAcHdl->hBTRMgrRmfAcHdl, &lstBtrMgrRmfAcStatus);
1622 
1623  if (pstBtrMgrRmfAcStatus->started != lstBtrMgrRmfAcStatus.started) {
1624  BTRMGRLOG_WARN("Status Changed - Started = %d\n", lstBtrMgrRmfAcStatus.started);
1625  pstBtrMgrRmfAcStatus->started = lstBtrMgrRmfAcStatus.started;
1626  bTriggerStatusChanged = true;
1627  }
1628 
1629  if (pstBtrMgrRmfAcStatus->format != lstBtrMgrRmfAcStatus.format) {
1630  BTRMGRLOG_WARN("Status Changed - Format = %d\n", lstBtrMgrRmfAcStatus.format);
1631  pstBtrMgrRmfAcStatus->format = lstBtrMgrRmfAcStatus.format;
1632  bTriggerStatusChanged = true;
1633  }
1634 
1635  if (pstBtrMgrRmfAcStatus->samplingFreq != lstBtrMgrRmfAcStatus.samplingFreq) {
1636  BTRMGRLOG_WARN("Status Changed - Sampling Freq = %d\n", lstBtrMgrRmfAcStatus.samplingFreq);
1637  pstBtrMgrRmfAcStatus->samplingFreq = lstBtrMgrRmfAcStatus.samplingFreq;
1638  bTriggerStatusChanged = true;
1639  }
1640 
1641  if (pstBtrMgrRmfAcStatus->fifoDepth != lstBtrMgrRmfAcStatus.fifoDepth) {
1642  BTRMGRLOG_WARN("Status Changed - Fifo Depth = %d\n", (int)lstBtrMgrRmfAcStatus.fifoDepth);
1643  pstBtrMgrRmfAcStatus->fifoDepth = lstBtrMgrRmfAcStatus.fifoDepth;
1644  bTriggerStatusChanged = true;
1645  }
1646 
1647  if (pstBtrMgrRmfAcStatus->overflows != lstBtrMgrRmfAcStatus.overflows) {
1648  BTRMGRLOG_WARN("Status Changed - Overflow = %d\n", lstBtrMgrRmfAcStatus.overflows);
1649  pstBtrMgrRmfAcStatus->overflows = lstBtrMgrRmfAcStatus.overflows;
1650  bTriggerStatusChanged = true;
1651  }
1652 
1653  if (pstBtrMgrRmfAcStatus->underflows != lstBtrMgrRmfAcStatus.underflows) {
1654  BTRMGRLOG_WARN("Status Changed - Underflow = %d\n", lstBtrMgrRmfAcStatus.underflows);
1655  pstBtrMgrRmfAcStatus->underflows = lstBtrMgrRmfAcStatus.underflows;
1656  bTriggerStatusChanged = true;
1657  }
1658 
1659  if (pstBtrMgrRmfAcStatus->muted != lstBtrMgrRmfAcStatus.muted) {
1660  BTRMGRLOG_WARN("Status Changed - Muted = %d\n", lstBtrMgrRmfAcStatus.muted);
1661  pstBtrMgrRmfAcStatus->muted = lstBtrMgrRmfAcStatus.muted;
1662  bTriggerStatusChanged = true;
1663  }
1664 
1665  if (pstBtrMgrRmfAcStatus->paused != lstBtrMgrRmfAcStatus.paused) {
1666  BTRMGRLOG_WARN("Status Changed - Paused = %d\n", lstBtrMgrRmfAcStatus.paused);
1667  pstBtrMgrRmfAcStatus->paused = lstBtrMgrRmfAcStatus.paused;
1668  bTriggerStatusChanged = true;
1669  }
1670 
1671  if (pstBtrMgrRmfAcStatus->volume != lstBtrMgrRmfAcStatus.volume) {
1672  BTRMGRLOG_WARN("Status Changed - Volume = %f\n", lstBtrMgrRmfAcStatus.volume);
1673  pstBtrMgrRmfAcStatus->volume = lstBtrMgrRmfAcStatus.volume;
1674  bTriggerStatusChanged = true;
1675  }
1676 
1677  if (bTriggerStatusChanged) {
1678  stBTRMgrMediaStatus lstBtrMgrAcMediaStatus;
1679  stBTRMgrMediaStatus* pstBtrMgrAcMediaStatus = &pstBtrMgrAcHdl->stBtrMgrAcStatus;
1680 
1681  if (pstBtrMgrRmfAcStatus->paused) {
1682  pstBtrMgrAcMediaStatus->eBtrMgrState = eBTRMgrStatePaused;
1683 
1684  if ((pstBtrMgrAcHdl->pcBTRMgrAcType != NULL) &&
1685  (!strncmp(pstBtrMgrAcHdl->pcBTRMgrAcType, BTRMGR_AC_TYPE_AUXILIARY, strlen(BTRMGR_AC_TYPE_AUXILIARY)))) {
1686  }
1687  }
1688  else {
1689  pstBtrMgrAcMediaStatus->eBtrMgrState = eBTRMgrStatePlaying;
1690  }
1691 
1692  switch (pstBtrMgrRmfAcStatus->format) {
1693  case racFormat_e16BitStereo:
1694  pstBtrMgrAcMediaStatus->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1695  pstBtrMgrAcMediaStatus->eBtrMgrAChan = eBTRMgrAChanStereo;
1696  break;
1697  case racFormat_e24BitStereo:
1698  pstBtrMgrAcMediaStatus->eBtrMgrSFmt = eBTRMgrSFmt24bit;
1699  pstBtrMgrAcMediaStatus->eBtrMgrAChan = eBTRMgrAChanStereo;
1700  break;
1701  case racFormat_e16BitMonoLeft:
1702  pstBtrMgrAcMediaStatus->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1703  pstBtrMgrAcMediaStatus->eBtrMgrAChan = eBTRMgrAChanMono;
1704  break;
1705  case racFormat_e16BitMonoRight:
1706  pstBtrMgrAcMediaStatus->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1707  pstBtrMgrAcMediaStatus->eBtrMgrAChan = eBTRMgrAChanMono;
1708  break;
1709  case racFormat_e16BitMono:
1710  pstBtrMgrAcMediaStatus->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1711  pstBtrMgrAcMediaStatus->eBtrMgrAChan = eBTRMgrAChanMono;
1712  break;
1713  case racFormat_e24Bit5_1:
1714  pstBtrMgrAcMediaStatus->eBtrMgrSFmt = eBTRMgrSFmt24bit;
1715  pstBtrMgrAcMediaStatus->eBtrMgrAChan = eBTRMgrAChan5_1;
1716  break;
1717  case racFormat_eMax:
1718  pstBtrMgrAcMediaStatus->eBtrMgrSFmt = eBTRMgrSFmtUnknown;
1719  pstBtrMgrAcMediaStatus->eBtrMgrAChan = eBTRMgrAChanUnknown;
1720  break;
1721  default:
1722  pstBtrMgrAcMediaStatus->eBtrMgrSFmt = eBTRMgrSFmt16bit;
1723  pstBtrMgrAcMediaStatus->eBtrMgrAChan = eBTRMgrAChanStereo;
1724  break;
1725  }
1726 
1727  switch (pstBtrMgrRmfAcStatus->samplingFreq) {
1728  case racFreq_e16000:
1729  pstBtrMgrAcMediaStatus->eBtrMgrSFreq = eBTRMgrSFreq16K;
1730  break;
1731  case racFreq_e32000:
1732  pstBtrMgrAcMediaStatus->eBtrMgrSFreq = eBTRMgrSFreq32K;
1733  break;
1734  case racFreq_e44100:
1735  pstBtrMgrAcMediaStatus->eBtrMgrSFreq = eBTRMgrSFreq44_1K;
1736  break;
1737  case racFreq_e48000:
1738  pstBtrMgrAcMediaStatus->eBtrMgrSFreq = eBTRMgrSFreq48K;
1739  break;
1740  case racFreq_eMax:
1741  pstBtrMgrAcMediaStatus->eBtrMgrSFreq = eBTRMgrSFreqUnknown;
1742  break;
1743  default:
1744  pstBtrMgrAcMediaStatus->eBtrMgrSFreq = eBTRMgrSFreq48K;
1745  break;
1746  }
1747 
1748  pstBtrMgrAcMediaStatus->ui32OverFlowCnt = pstBtrMgrRmfAcStatus->overflows;
1749  pstBtrMgrAcMediaStatus->ui32UnderFlowCnt= pstBtrMgrRmfAcStatus->underflows;
1750 
1751  if (!pstBtrMgrRmfAcStatus->muted) {
1752  pstBtrMgrAcMediaStatus->ui8Volume = (unsigned char) (255 * pstBtrMgrRmfAcStatus->volume);
1753  }
1754  else {
1755  pstBtrMgrAcMediaStatus->ui8Volume = 0;
1756  }
1757 
1758  memcpy (&lstBtrMgrAcMediaStatus, pstBtrMgrAcMediaStatus, sizeof(stBTRMgrMediaStatus));
1759 
1760  if (pstBtrMgrAcHdl->fpcBBtrMgrAcStatus) {
1761  if (pstBtrMgrAcHdl->fpcBBtrMgrAcStatus(&lstBtrMgrAcMediaStatus, pstBtrMgrAcHdl->vpBtrMgrAcStatusUserData) != eBTRMgrSuccess) {
1762  BTRMGRLOG_ERROR("AC Status Callback Failed\n");
1763  }
1764  }
1765 
1766  }
1767  }
1768 
1769  return RMF_SUCCESS;
1770 }
1771 #endif
1772 
racFormat_e24Bit5_1
@ racFormat_e24Bit5_1
Definition: rmfAudioCapture.h:75
btrMgr_Types.h
RMF_AudioCapture_Settings
Definition: rmfAudioCapture.h:104
RMF_AudioCapture_Settings::cbStatusParm
void * cbStatusParm
Definition: rmfAudioCapture.h:110
IARM_Bus_Term
IARM_Result_t IARM_Bus_Term(void)
This API is used to terminate the IARM-Bus library.
racFreq_e48000
@ racFreq_e48000
Definition: rmfAudioCapture.h:88
RMF_AudioCapture_Settings::delayCompensation_ms
unsigned int delayCompensation_ms
Definition: rmfAudioCapture.h:120
btrMgr_mediaTypes.h
RMF_AudioCapture_Start
rmf_Error RMF_AudioCapture_Start(RMF_AudioCaptureHandle handle, RMF_AudioCapture_Settings *settings)
This API will start the Audio capture.
Definition: rmfAudioCapture.c:71
_stBTRMgrACHdl
Definition: btrMgr_audioCap.c:90
BTRMgr_AC_DeInit
eBTRMgrRet BTRMgr_AC_DeInit(tBTRMgrAcHdl hBTRMgrAcHdl)
This API deinitializes the bluetooth manager audio capture interface.
Definition: btrMgr_audioCap.c:465
RMF_AudioCapture_Status::fifoDepth
size_t fifoDepth
Definition: rmfAudioCapture.h:128
BTRMgr_AC_Resume
eBTRMgrRet BTRMgr_AC_Resume(tBTRMgrAcHdl hBTRMgrAcHdl)
This API resumes the state of audio capture.
Definition: btrMgr_audioCap.c:1577
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
RMF_AudioCapture_Status::started
int started
Definition: rmfAudioCapture.h:125
RMF_AudioCapture_Settings::threshold
size_t threshold
Definition: rmfAudioCapture.h:114
RMF_AudioCapture_Open
rmf_Error RMF_AudioCapture_Open(RMF_AudioCaptureHandle *handle)
This API creates audio capture session, create all required resources to provide audio capture handle...
Definition: rmfAudioCapture.c:23
racFreq_e32000
@ racFreq_e32000
Definition: rmfAudioCapture.h:86
acmFreqe44100
@ acmFreqe44100
Definition: audiocapturemgr_iarm.h:101
RMF_AudioCapture_Status::muted
int muted
Definition: rmfAudioCapture.h:131
BTRMgr_AC_GetDefaultSettings
eBTRMgrRet BTRMgr_AC_GetDefaultSettings(tBTRMgrAcHdl hBTRMgrAcHdl, stBTRMgrOutASettings *apstBtrMgrAcOutASettings)
This API will fetch default RMF AudioCapture Settings.
Definition: btrMgr_audioCap.c:580
BTRMgr_AC_GetCurrentSettings
eBTRMgrRet BTRMgr_AC_GetCurrentSettings(tBTRMgrAcHdl hBTRMgrAcHdl, stBTRMgrOutASettings *apstBtrMgrAcOutASettings)
This API fetches the current settings to capture data as part of the specific Audio capture context.
Definition: btrMgr_audioCap.c:863
racFormat_e16BitMonoRight
@ racFormat_e16BitMonoRight
Definition: rmfAudioCapture.h:73
_stBTRMgrMediaStatus
Represents the media file status.
Definition: btrMgr_mediaTypes.h:165
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...
IARM_Bus_IsConnected
IARM_Result_t IARM_Bus_IsConnected(const char *memberName, int *isRegistered)
This API is used to check if the current process is registered with IARM.
RMF_AudioCapture_Settings::cbBufferReadyParm
void * cbBufferReadyParm
Definition: rmfAudioCapture.h:106
RMF_AudioCapture_Status::format
racFormat format
Definition: rmfAudioCapture.h:126
racFormat_e24BitStereo
@ racFormat_e24BitStereo
Definition: rmfAudioCapture.h:69
_stBTRMgrOutASettings
Represents the audio output settings.
Definition: btrMgr_mediaTypes.h:153
racFormat_e16BitMono
@ racFormat_e16BitMono
Definition: rmfAudioCapture.h:74
RMF_AudioCapture_Status::paused
int paused
Definition: rmfAudioCapture.h:132
libIBus.h
RDK IARM-Bus API Declarations.
RMF_AudioCapture_Settings::fifoSize
size_t fifoSize
Definition: rmfAudioCapture.h:112
acmFreqe32000
@ acmFreqe32000
Definition: audiocapturemgr_iarm.h:100
RMF_AudioCapture_Stop
rmf_Error RMF_AudioCapture_Stop(RMF_AudioCaptureHandle handle)
This API will stop the audio capture.
Definition: rmfAudioCapture.c:82
RMF_AudioCapture_Settings::cbStatusChange
RMF_AudioCapture_StatusChangeCb cbStatusChange
Definition: rmfAudioCapture.h:108
eBTRMgrRet
enum _eBTRMgrRet eBTRMgrRet
Represents the bluetooth manager return values.
RMF_AudioCapture_Status::underflows
unsigned int underflows
Definition: rmfAudioCapture.h:130
RMF_AudioCapture_GetCurrentSettings
rmf_Error RMF_AudioCapture_GetCurrentSettings(RMF_AudioCaptureHandle handle, RMF_AudioCapture_Settings *settings)
This API will return the audio capture settings which has been successfully set for that context.
Definition: rmfAudioCapture.c:60
acmFreqe16000
@ acmFreqe16000
Definition: audiocapturemgr_iarm.h:98
BTRMgr_AC_Stop
eBTRMgrRet BTRMgr_AC_Stop(tBTRMgrAcHdl hBTRMgrAcHdl)
This function will stop the audio capture.
Definition: btrMgr_audioCap.c:1508
BTRMgr_AC_Pause
eBTRMgrRet BTRMgr_AC_Pause(tBTRMgrAcHdl hBTRMgrAcHdl)
This API pauses the state of audio capture.
Definition: btrMgr_audioCap.c:1567
racFreq_e44100
@ racFreq_e44100
Definition: rmfAudioCapture.h:87
RMF_AudioCapture_Close
rmf_Error RMF_AudioCapture_Close(RMF_AudioCaptureHandle handle)
This API will free all resources associated with this audio capture handle. It will close audio captu...
Definition: rmfAudioCapture.c:91
RMF_AudioCapture_Status::overflows
unsigned int overflows
Definition: rmfAudioCapture.h:129
BTRMgr_AC_GetStatus
eBTRMgrRet BTRMgr_AC_GetStatus(tBTRMgrAcHdl hBTRMgrAcHdl, stBTRMgrMediaStatus *apstBtrMgrAcStatus)
This API fetches the status of the operation.
Definition: btrMgr_audioCap.c:1148
audio_properties_ifce_t
Definition: audiocapturemgr_iarm.h:113
RMF_AudioCapture_GetDefaultSettings
rmf_Error RMF_AudioCapture_GetDefaultSettings(RMF_AudioCapture_Settings *settings)
This API Will return default RMF audio capture settings.
Definition: rmfAudioCapture.c:51
_stBTRMgrPCMInfo
Represents the PCM codec details.
Definition: btrMgr_mediaTypes.h:103
RMF_AudioCapture_Open_Type
rmf_Error RMF_AudioCapture_Open_Type(RMF_AudioCaptureHandle *handle, RMF_AudioCaptureType rmfAcType)
This API creates audio capture session, create all required resources to provide audio capture handle...
Definition: rmfAudioCapture.c:31
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
acmFreqe48000
@ acmFreqe48000
Definition: audiocapturemgr_iarm.h:102
iarmbus_acm_arg_t
Definition: audiocapturemgr_iarm.h:152
BTRMgr_AC_Init
eBTRMgrRet BTRMgr_AC_Init(tBTRMgrAcHdl *phBTRMgrAcHdl, tBTRMgrAcType api8BTRMgrAcType)
This API initializes the bluetooth manager audio capture interface.
Definition: btrMgr_audioCap.c:357
BTRMgr_AC_Start
eBTRMgrRet BTRMgr_AC_Start(tBTRMgrAcHdl hBTRMgrAcHdl, stBTRMgrOutASettings *apstBtrMgrAcOutASettings, fPtr_BTRMgr_AC_DataReadyCb afpcBBtrMgrAcDataReady, fPtr_BTRMgr_AC_StatusCb afpcBBtrMgrAcStatus, void *apvUserData)
This function will start the Audio capture with the default capture settings.
Definition: btrMgr_audioCap.c:1159
RMF_AudioCapture_Settings::cbBufferReady
RMF_AudioCaptureBufferReadyCb cbBufferReady
Definition: rmfAudioCapture.h:105
btrMgr_audioCap.h
racFreq_e16000
@ racFreq_e16000
Definition: rmfAudioCapture.h:83
racFormat_e16BitStereo
@ racFormat_e16BitStereo
Definition: rmfAudioCapture.h:68
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
RMF_AudioCapture_Status
Definition: rmfAudioCapture.h:124
RMF_AudioCapture_GetStatus
rmf_Error RMF_AudioCapture_GetStatus(RMF_AudioCaptureHandle handle, RMF_AudioCapture_Status *status)
This API is used to enquire the current status of Audio Capture associated with the current Audio Cap...
Definition: rmfAudioCapture.c:40
racFormat_e16BitMonoLeft
@ racFormat_e16BitMonoLeft
Definition: rmfAudioCapture.h:72
RMF_AudioCapture_Status::samplingFreq
racFreq samplingFreq
Definition: rmfAudioCapture.h:127
RMF_AudioCapture_Status::volume
float volume
Definition: rmfAudioCapture.h:133