| /* |
| * Copyright (C) 2014 - 2017 Sony Corporation |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "ldacBT_abr.h" |
| |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #define LDAC_ABR_OBSERVING_TIME_MS 500 /* [ms] the time length for storing Tx Queue Depth */ |
| #define LDAC_ABR_PENALTY_MAX 4 |
| |
| /* Number of observing count to judge whether EQMID may be increase. |
| * Those count can convert in time by following formula: |
| * Time [ms] = (Count - abrQualityModeID) * LDAC_ABR_OBSERVING_TIME_MS |
| * where abrQualityModeID is the value which converted EQMID by aEqmidToAbrQualityModeID[]. |
| * Therefore, using the default value of 12, the observation time in each abrQualityModeID is |
| * as follows: |
| * ---------------------------------------------------- |
| * | abrQualityModeID | 0 | 1 | 2 | 3 | 4 | |
| * | observation time [s] | 6 | 5 | 4 | 3 | 2 | |
| * ---------------------------------------------------- |
| */ |
| #define LDAC_ABR_OBSERVING_COUNT_TO_JUDGE_INC_QUALITY 12 |
| #define LDAC_ABR_OBSERVING_COUNT_FOR_INIT 6 /* = 3sec. keep same EQMID in first 3sec */ |
| /* Default value for thresholds */ |
| #define LDAC_ABR_THRESHOLD_CRITICAL_DEFAULT 6 |
| #define LDAC_ABR_THRESHOLD_DANGEROUSTREND_DEFAULT 4 |
| #define LDAC_ABR_THRESHOLD_SAFETY_FOR_HQSQ_DEFAULT 2 |
| /* Number of steady state count to judge */ |
| #define LDAC_ABR_NUM_STEADY_STATE_TO_JUDGE_STEADY 3 |
| /* Number of steady state count to reset for LDACBT_EQMID_HQ */ |
| #define LDAC_ABR_NUM_STEADY_STATE_TO_RESET_PENALTY_FOR_HQ 60 |
| |
| |
| typedef struct _tx_queue_param |
| { |
| unsigned char *pHist; |
| unsigned int szHist; |
| int sum; |
| unsigned int cnt; |
| unsigned int idx; |
| } TxQ_INFO; |
| |
| typedef struct _ldacbt_abr_param |
| { |
| TxQ_INFO TxQD_Info; |
| int cntToIncQuality; |
| int nSteadyState; |
| int nPenalty; |
| int abrQualityModeIdSteady; |
| unsigned int numToEvaluate; |
| /* thresholds */ |
| unsigned int thCritical; |
| unsigned int thDangerousTrend; |
| unsigned int thSafety4HQSQ; |
| } LDAC_ABR_PARAMS; |
| |
| #define clear_data(ptr, n) memset(ptr, 0, n) |
| |
| #ifdef LOCAL_DEBUG |
| #include <android/log.h> |
| #define ABRDBG(fmt, ... ) \ |
| __android_log_print( ANDROID_LOG_INFO, "******** LDAC ABR ********",\ |
| "%s@%s:%d::"fmt, __func__, __FILE__, __LINE__, ## __VA_ARGS__ ) |
| #else |
| #define ABRDBG(fmt, ...) |
| #endif /* LOCAL_DEBUG */ |
| |
| /* A table for converting EQMID to abrQualityModeID which is sorted in descending order by bit rate. |
| * The relationship between EQMID, bit rate and abrQualityModeID when the sampling frequency is |
| * 96 kHz is as follows: |
| * ---------------------------------------------------- |
| * | EQMID | 0 | 1 | 2 | 3 | 4 | |
| * | bit rate [kbps] | 990 | 660 | 330 | 492 | 396 | |
| * | abrQualityModeID | 0 | 1 | 4 | 2 | 3 | |
| * ---------------------------------------------------- |
| */ |
| static const int aEqmidToAbrQualityModeID[]={ 0, 1, 4, 2, 3}; |
| static const int sizeOfEqmidToBitrateSortedIdTable = (int)(sizeof(aEqmidToAbrQualityModeID) |
| / sizeof(aEqmidToAbrQualityModeID[0])); |
| |
| /* Get LDAC ABR handle */ |
| HANDLE_LDAC_ABR ldac_ABR_get_handle(void) |
| { |
| HANDLE_LDAC_ABR hLdacAbr; |
| ABRDBG( "" ); |
| if ((hLdacAbr = (HANDLE_LDAC_ABR)malloc(sizeof(LDAC_ABR_PARAMS))) == NULL) { |
| ABRDBG( "[ERR] Failed to allocate memory for handle." ); |
| return NULL; |
| } |
| hLdacAbr->TxQD_Info.pHist = NULL; |
| return hLdacAbr; |
| } |
| |
| /* Free LDAC ABR handle */ |
| void ldac_ABR_free_handle(HANDLE_LDAC_ABR hLdacAbr) |
| { |
| ABRDBG( "" ); |
| if (hLdacAbr != NULL) { |
| if (hLdacAbr->TxQD_Info.pHist) { |
| free(hLdacAbr->TxQD_Info.pHist); |
| } |
| free(hLdacAbr); |
| } |
| } |
| |
| /* Initialize LDAC ABR */ |
| int ldac_ABR_Init( HANDLE_LDAC_ABR hLdacAbr, unsigned int interval_ms ) |
| { |
| ABRDBG( "hLdacAbr:0x%x, interval_ms:%u", (unsigned int)hLdacAbr, interval_ms ); |
| if (hLdacAbr == NULL) return -1; |
| if (interval_ms == 0) return -1; |
| if (interval_ms > LDAC_ABR_OBSERVING_TIME_MS) return -1; |
| |
| hLdacAbr->numToEvaluate = LDAC_ABR_OBSERVING_TIME_MS / interval_ms; |
| hLdacAbr->TxQD_Info.sum = 0; |
| hLdacAbr->TxQD_Info.cnt = 0; |
| hLdacAbr->TxQD_Info.idx = 0; |
| hLdacAbr->TxQD_Info.szHist = hLdacAbr->numToEvaluate + 1; |
| if (hLdacAbr->TxQD_Info.pHist) free(hLdacAbr->TxQD_Info.pHist); |
| if ((hLdacAbr->TxQD_Info.pHist = |
| (unsigned char*)malloc(hLdacAbr->TxQD_Info.szHist * sizeof(unsigned char))) == NULL){ |
| return -1; |
| } |
| clear_data(hLdacAbr->TxQD_Info.pHist, hLdacAbr->TxQD_Info.szHist * sizeof(unsigned char)); |
| |
| hLdacAbr->nSteadyState = 0; |
| hLdacAbr->nPenalty = 1; |
| hLdacAbr->abrQualityModeIdSteady = aEqmidToAbrQualityModeID[LDACBT_EQMID_HQ]; |
| hLdacAbr->cntToIncQuality = LDAC_ABR_OBSERVING_COUNT_FOR_INIT; |
| /* thresholds */ |
| hLdacAbr->thCritical = LDAC_ABR_THRESHOLD_CRITICAL_DEFAULT; |
| hLdacAbr->thDangerousTrend = LDAC_ABR_THRESHOLD_DANGEROUSTREND_DEFAULT; |
| hLdacAbr->thSafety4HQSQ = LDAC_ABR_THRESHOLD_SAFETY_FOR_HQSQ_DEFAULT; |
| |
| return 0; |
| } |
| |
| /* Setup thresholds for LDAC ABR */ |
| int ldac_ABR_set_thresholds( HANDLE_LDAC_ABR hLdacAbr, unsigned int thCritical, |
| unsigned int thDangerousTrend, unsigned int thSafety4HQSQ ) |
| { |
| ABRDBG( "thCritical=%u, thDangerousTrend=%u, thSafety4HQSQ=%u", |
| thCritical, thDangerousTrend, thSafety4HQSQ); |
| if (hLdacAbr == NULL) return -1; |
| if (thCritical < thDangerousTrend) return -1; |
| if (thDangerousTrend < thSafety4HQSQ) return -1; |
| hLdacAbr->thCritical = thCritical; |
| hLdacAbr->thDangerousTrend = thDangerousTrend; |
| hLdacAbr->thSafety4HQSQ = thSafety4HQSQ; |
| return 0; |
| } |
| |
| /* LDAC ABR main process */ |
| int ldac_ABR_Proc( HANDLE_LDAC_BT hLDAC, HANDLE_LDAC_ABR hLdacAbr, |
| unsigned int TxQueueDepth, unsigned int flagEnable) |
| { |
| int nStepsToChangeEQMID, abrQualityModeID, eqmid, i; |
| unsigned int TxQD_curr, TxQD_prev; |
| #ifdef LOCAL_DEBUG |
| int qd, TxQ; // for debug |
| #endif |
| |
| if (hLDAC == NULL) return -1; |
| if (hLdacAbr == NULL) return -1; |
| |
| eqmid = ldacBT_get_eqmid(hLDAC); |
| abrQualityModeID = -1; |
| if ((LDACBT_EQMID_HQ <= eqmid) && (eqmid < sizeOfEqmidToBitrateSortedIdTable)) { |
| abrQualityModeID = aEqmidToAbrQualityModeID[eqmid]; |
| } |
| #ifdef LOCAL_DEBUG |
| ABRDBG( "[LDAC ABR] - abrQualityModeID : %d -- eqmid : %d -- TxQue : %d --------------", |
| abrQualityModeID, eqmid, TxQueueDepth); |
| #endif |
| /* check for the situation when unsupported eqmid was return from ldacBT_get_eqmid(). */ |
| if (abrQualityModeID < 0) return eqmid; /* return current eqmid. */ |
| |
| /* update */ |
| TxQD_curr = TxQueueDepth; |
| if ((i = hLdacAbr->TxQD_Info.idx - 1) < 0 ) i = hLdacAbr->TxQD_Info.szHist - 1; |
| TxQD_prev = hLdacAbr->TxQD_Info.pHist[i]; |
| |
| hLdacAbr->TxQD_Info.sum -= hLdacAbr->TxQD_Info.pHist[hLdacAbr->TxQD_Info.idx]; |
| hLdacAbr->TxQD_Info.pHist[hLdacAbr->TxQD_Info.idx] = (unsigned char)TxQD_curr; |
| if (++hLdacAbr->TxQD_Info.idx >= hLdacAbr->TxQD_Info.szHist) hLdacAbr->TxQD_Info.idx = 0; |
| |
| hLdacAbr->TxQD_Info.sum += TxQD_curr; |
| ++hLdacAbr->TxQD_Info.cnt; |
| |
| #ifdef LOCAL_DEBUG |
| qd = (abrQualityModeID * 100000000); |
| qd += (hLdacAbr->nPenalty * 1000000); |
| qd += (hLdacAbr->cntToIncQuality *1000); |
| qd += (hLdacAbr->nSteadyState); |
| TxQ = TxQD_prev * 100 + TxQD_curr; |
| #endif |
| |
| /* judge */ |
| nStepsToChangeEQMID = 0; |
| if (TxQD_curr >= hLdacAbr->thCritical) { |
| /* for Critical situation */ |
| ABRDBG("Critical: %d, %d", TxQ, qd); |
| nStepsToChangeEQMID = -1; |
| if ((eqmid == LDACBT_EQMID_HQ) || (eqmid == LDACBT_EQMID_SQ)) { |
| nStepsToChangeEQMID = -2; |
| } |
| } |
| else if ((TxQD_curr > hLdacAbr->thDangerousTrend) && (TxQD_curr > TxQD_prev)) { |
| ABRDBG("Dangerous: %d, %d", TxQ, qd); |
| nStepsToChangeEQMID = -1; |
| } |
| else if ((TxQD_curr > hLdacAbr->thSafety4HQSQ) && |
| ((eqmid == LDACBT_EQMID_HQ) || (eqmid == LDACBT_EQMID_SQ))) { |
| ABRDBG("Safety4HQSQ: %d, %d", TxQ, qd); |
| nStepsToChangeEQMID = -1; |
| } |
| else if (hLdacAbr->TxQD_Info.cnt >= hLdacAbr->numToEvaluate) { |
| int ave10; |
| hLdacAbr->TxQD_Info.cnt = hLdacAbr->numToEvaluate; |
| /* eanble average process */ |
| ave10 = (hLdacAbr->TxQD_Info.sum * 10) / hLdacAbr->TxQD_Info.cnt; |
| |
| if (ave10 > 15) { /* if average of TxQue_Count in 0.5[s] was larger than 1.5 */ |
| ABRDBG("ave: %d, %d, %d", TxQ, qd, ave10); |
| nStepsToChangeEQMID = -1; |
| } |
| else { |
| ++hLdacAbr->nSteadyState; |
| #ifdef LOCAL_DEBUG |
| qd = (abrQualityModeID * 100000000); |
| qd += (hLdacAbr->nPenalty * 1000000); |
| qd += (hLdacAbr->cntToIncQuality *1000); |
| qd += (hLdacAbr->nSteadyState); |
| #endif |
| |
| if (hLdacAbr->TxQD_Info.sum == 0) { |
| if (--hLdacAbr->cntToIncQuality <= 0) { |
| ABRDBG("inc1: %d, %d, %d", TxQ, qd, ave10); |
| nStepsToChangeEQMID = 1; |
| } |
| else { |
| ABRDBG("reset: %d, %d, %d", TxQ, qd, ave10); |
| hLdacAbr->TxQD_Info.cnt = 0; // reset the number of sample for average proc. |
| } |
| } |
| else { |
| ABRDBG( "reset cntToIncQuality, %d,%d, %d", TxQ,qd, ave10); |
| hLdacAbr->cntToIncQuality = LDAC_ABR_OBSERVING_COUNT_TO_JUDGE_INC_QUALITY |
| - 2 * abrQualityModeID; |
| if (abrQualityModeID >= hLdacAbr->abrQualityModeIdSteady) { |
| hLdacAbr->cntToIncQuality *= hLdacAbr->nPenalty; |
| } |
| } |
| } |
| } |
| #ifdef LOCAL_DEBUG |
| else { |
| ABRDBG("Nothing %d, hLdacAbr->TxQD_Info.cnt %u", TxQ, hLdacAbr->TxQD_Info.cnt); |
| } |
| #endif |
| if (flagEnable) { |
| if (nStepsToChangeEQMID) { |
| int abrQualityModeIDNew; |
| if (nStepsToChangeEQMID < 0) { |
| for (i = 0; i > nStepsToChangeEQMID; --i) { |
| if (ldacBT_alter_eqmid_priority(hLDAC, LDACBT_EQMID_INC_CONNECTION)) { |
| #ifdef LOCAL_DEBUG |
| int err; |
| err = ldacBT_get_error_code(hLDAC); |
| ABRDBG("Info@%d : %d ,%d, %d", __LINE__, |
| LDACBT_API_ERR(err), LDACBT_HANDLE_ERR(err), LDACBT_BLOCK_ERR(err)); |
| #endif |
| break;// EQMID was already the ID of the highest connectivity. |
| } |
| } |
| |
| eqmid = ldacBT_get_eqmid(hLDAC); |
| abrQualityModeIDNew = abrQualityModeID; |
| if (eqmid >= 0) { |
| if (eqmid < sizeOfEqmidToBitrateSortedIdTable) { |
| abrQualityModeIDNew = aEqmidToAbrQualityModeID[eqmid]; |
| } |
| } |
| |
| if (hLdacAbr->nSteadyState < LDAC_ABR_NUM_STEADY_STATE_TO_JUDGE_STEADY) { |
| hLdacAbr->abrQualityModeIdSteady = abrQualityModeIDNew - 1; |
| if (hLdacAbr->abrQualityModeIdSteady < 0) hLdacAbr->abrQualityModeIdSteady = 0; |
| hLdacAbr->nPenalty *= 2; |
| if(hLdacAbr->nPenalty > LDAC_ABR_PENALTY_MAX) { |
| hLdacAbr->nPenalty = LDAC_ABR_PENALTY_MAX; // MAX PENALTY |
| } |
| } |
| } |
| else { |
| if (ldacBT_alter_eqmid_priority( hLDAC, LDACBT_EQMID_INC_QUALITY )) { |
| #ifdef LOCAL_DEBUG |
| int err; |
| err = ldacBT_get_error_code(hLDAC); |
| ABRDBG("Info@%d : %d ,%d, %d", __LINE__, |
| LDACBT_API_ERR(err), LDACBT_HANDLE_ERR(err), LDACBT_BLOCK_ERR(err)); |
| #endif |
| ;// EQMID was already the ID of the highest sound quality. |
| } |
| eqmid = ldacBT_get_eqmid(hLDAC); |
| abrQualityModeIDNew = abrQualityModeID; |
| if (eqmid >= 0) { |
| if (eqmid < sizeOfEqmidToBitrateSortedIdTable) { |
| abrQualityModeIDNew = aEqmidToAbrQualityModeID[eqmid]; |
| } |
| } |
| if (abrQualityModeIDNew < hLdacAbr->abrQualityModeIdSteady) { |
| hLdacAbr->nPenalty = 1; |
| } |
| if (abrQualityModeIDNew == aEqmidToAbrQualityModeID[0]) { /* for HQ */ |
| if (hLdacAbr->nSteadyState > LDAC_ABR_NUM_STEADY_STATE_TO_RESET_PENALTY_FOR_HQ) { |
| hLdacAbr->nPenalty = 1; |
| } |
| } |
| } |
| |
| hLdacAbr->nSteadyState = 0; |
| // reset the number of sample for average proc. |
| hLdacAbr->TxQD_Info.cnt = 0; |
| hLdacAbr->cntToIncQuality = LDAC_ABR_OBSERVING_COUNT_TO_JUDGE_INC_QUALITY |
| - 2 * abrQualityModeIDNew; |
| if (hLdacAbr->cntToIncQuality <= 0) { |
| // set minimum value. e1 f == 0.5[s] |
| hLdacAbr->cntToIncQuality = 1; |
| } |
| hLdacAbr->cntToIncQuality *= hLdacAbr->nPenalty; |
| ABRDBG("EQMID NOW %d", eqmid); |
| } |
| } |
| #ifdef LOCAL_DEBUG |
| else if (TxQueueDepth) { |
| ABRDBG("flagEnable false: %d ,%d", TxQ, qd); |
| } |
| #endif |
| |
| return eqmid; |
| } |
