1 /*
2 * Copyright (C) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "../include/a2dp_encoder_sbc.h"
17 #include <cmath>
18 #include <cstring>
19 #include <mutex>
20 #include "../../include/a2dp_sbc_param_ctrl.h"
21 #include "log.h"
22 #include "packet.h"
23 #include "securec.h"
24 #include "../../../a2dp_service.h"
25
26 namespace OHOS {
27 namespace bluetooth {
28 const int BIT_SBC_NUMBER_PER_SAMPLE = 8;
29 const int MS_TO_US = 1000;
30 const int NUMBER32 = 32;
31 const int BIT8 = 8;
32 const int SUBBAND8 = 8;
33 const int SUBBAND4 = 4;
34 const int CHANNEL_ONE = 1;
35 const int CHANNEL_TWO = 2;
36 const int PROTECT_ONE = 1;
37 const int PROTECT_TWO = 2;
38 const int PROTECT_THREE = 3;
39 const int BIT_NUMBER5 = 5;
40 const int PCM_REMAIN_BUFFER_SIZE = 1024;
41 const int BIT_POOL_SIXTEEN = 16;
42 const int FRAGMENT_SIZE_TWO = 2;
43 const int FRAGMENT_SIZE_THREE = 3;
44 const int VALUE_TWO = 2;
45
46 sbc::CodecParam g_sbcEncode = {};
47
48
49 std::recursive_mutex g_sbcMutex {};
A2dpSbcEncoder(const A2dpEncoderInitPeerParams * peerParams,A2dpCodecConfig * config)50 A2dpSbcEncoder::A2dpSbcEncoder(
51 const A2dpEncoderInitPeerParams *peerParams, A2dpCodecConfig *config) : A2dpEncoder(config)
52 {
53 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
54 a2dpSbcEncoderCb_.isPeerEdr = peerParams->isPeerEdr;
55 a2dpSbcEncoderCb_.peerSupports3mbps = peerParams->peerSupports3mbps;
56 a2dpSbcEncoderCb_.peerMtu = peerParams->peermtu;
57 a2dpSbcEncoderCb_.timestamp = 0;
58 a2dpSbcEncoderCb_.sendDataSize = 0;
59 codecLib_ = std::make_unique<A2dpSBCDynamicLibCtrl>(true);
60 codecSbcEncoderLib_ = codecLib_->LoadCodecSbcLib();
61 if (codecSbcEncoderLib_ == nullptr) {
62 LOG_ERROR("[SbcDecoder] %{public}s load sbc lib failed\n", __func__);
63 }
64 updateParam();
65 }
66
~A2dpSbcEncoder()67 A2dpSbcEncoder::~A2dpSbcEncoder()
68 {
69 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
70 if (codecSbcEncoderLib_ != nullptr) {
71 codecSbcEncoderLib_->sbcEncoder.destroySbcEncode(sbcEncoder_);
72 codecLib_->UnloadCodecSbcLib(codecSbcEncoderLib_);
73 codecSbcEncoderLib_ = nullptr;
74 }
75 }
76
ResetFeedingState(void)77 void A2dpSbcEncoder::ResetFeedingState(void)
78 {
79 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
80 std::lock_guard<std::recursive_mutex> lock(g_sbcMutex);
81 (void)memset_s(&a2dpSbcEncoderCb_.feedingState, sizeof(A2dpSbcFeedingState), 0, sizeof(A2dpSbcFeedingState));
82 a2dpSbcEncoderCb_.feedingState.bytesPerTick =
83 a2dpSbcEncoderCb_.feedingParams.sampleRate * a2dpSbcEncoderCb_.feedingParams.bitsPerSample /
84 BIT_SBC_NUMBER_PER_SAMPLE * a2dpSbcEncoderCb_.feedingParams.channelCount * A2DP_SBC_ENCODER_INTERVAL_MS /
85 MS_TO_US;
86 LOG_INFO("[SbcEncoder] %{public}s, sampleRate %{public}u, bitsPerSample %{public}u channelCount %{public}u\n",
87 __func__, a2dpSbcEncoderCb_.feedingParams.sampleRate, a2dpSbcEncoderCb_.feedingParams.bitsPerSample,
88 a2dpSbcEncoderCb_.feedingParams.channelCount);
89
90 a2dpSbcEncoderCb_.timestamp = 0;
91 a2dpSbcEncoderCb_.sendDataSize = 0;
92 }
93
GetRenderPosition(uint16_t & sendDataSize,uint32_t & timeStamp)94 void A2dpSbcEncoder::GetRenderPosition(uint16_t &sendDataSize, uint32_t &timeStamp)
95 {
96 std::lock_guard<std::recursive_mutex> lock(g_sbcMutex);
97 sendDataSize = a2dpSbcEncoderCb_.sendDataSize;
98 timeStamp = a2dpSbcEncoderCb_.timestamp;
99 LOG_INFO("[A2dpSbcEncoder] %{public}s sendDataSize = %{public}hu, timeStamp = %{public}u\n",
100 __func__, sendDataSize, timeStamp);
101 }
102
SendFrames(uint64_t timeStampUs)103 void A2dpSbcEncoder::SendFrames(uint64_t timeStampUs)
104 {
105 LOG_INFO("[A2dpSbcEncoder] %{public}s\n", __func__);
106 std::lock_guard<std::recursive_mutex> lock(g_sbcMutex);
107 A2dpSbcEncodeFrames();
108 }
109
A2dpSbcGetSampleRate(const uint8_t * codecInfo)110 uint16_t A2dpSbcEncoder::A2dpSbcGetSampleRate(const uint8_t *codecInfo)
111 {
112 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
113 switch (GetSampleRateSbc(codecInfo)) {
114 case A2DP_SBC_SAMPLE_RATE_16000:
115 return SBC_SAMPLE_RATE_16000;
116 case A2DP_SBC_SAMPLE_RATE_32000:
117 return SBC_SAMPLE_RATE_32000;
118 case A2DP_SBC_SAMPLE_RATE_44100:
119 return SBC_SAMPLE_RATE_44100;
120 case A2DP_SBC_SAMPLE_RATE_48000:
121 return SBC_SAMPLE_RATE_48000;
122 default:
123 LOG_INFO("Use default sampleRate: 48000");
124 return SBC_SAMPLE_RATE_48000;
125 }
126 }
127
A2dpSbcGetBitsPerSample() const128 uint16_t A2dpSbcEncoder::A2dpSbcGetBitsPerSample() const
129 {
130 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
131
132 switch (config_->GetAudioBitsPerSample()) {
133 case A2DP_SAMPLE_BITS_16:
134 return SBC_SAMPLE_BITS_16;
135 case A2DP_SAMPLE_BITS_24:
136 return SBC_SAMPLE_BITS_24;
137 case A2DP_SAMPLE_BITS_32:
138 return SBC_SAMPLE_BITS_32;
139 default:
140 LOG_INFO("Use default bitsPerSample: 16");
141 return SBC_SAMPLE_BITS_16;
142 }
143 }
144
A2dpSbcGetTrackChannelCount(const uint8_t * codecInfo)145 uint8_t A2dpSbcEncoder::A2dpSbcGetTrackChannelCount(const uint8_t *codecInfo)
146 {
147 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
148 switch (GetTrackChannelCountSbc(codecInfo)) {
149 case A2DP_SBC_CHANNEL_MODE_MONO:
150 return SBC_SINGLE_CHANNEL_COUNT;
151 case A2DP_SBC_CHANNEL_MODE_DUAL:
152 case A2DP_SBC_CHANNEL_MODE_STEREO:
153 case A2DP_SBC_CHANNEL_MODE_JOINT_STEREO:
154 return SBC_DOUBLE_CHANNEL_COUNT;
155 default:
156 LOG_INFO("Failed extract a2dpSbcEncoderCb_.feedingParams.channelCount from config");
157 LOG_INFO("Use default ChannelCount: 1");
158 return SBC_SINGLE_CHANNEL_COUNT;
159 }
160 }
161
A2dpSbcGetTrackChannelMode(const uint8_t * codecInfo)162 int16_t A2dpSbcEncoder::A2dpSbcGetTrackChannelMode(const uint8_t *codecInfo)
163 {
164 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
165 switch (GetTrackChannelModeSbc(codecInfo)) {
166 case A2DP_SBC_CHANNEL_MODE_MONO:
167 return SBC_MONO;
168 case A2DP_SBC_CHANNEL_MODE_DUAL:
169 return SBC_DUAL;
170 case A2DP_SBC_CHANNEL_MODE_STEREO:
171 return SBC_STEREO;
172 case A2DP_SBC_CHANNEL_MODE_JOINT_STEREO:
173 return SBC_JOINT_STEREO;
174 default:
175 LOG_INFO("Use default channelMode: JOINT_STEREO");
176 return SBC_JOINT_STEREO;
177 }
178 }
179
A2dpSbcGetNumberOfSubbands(const uint8_t * codecInfo)180 int16_t A2dpSbcEncoder::A2dpSbcGetNumberOfSubbands(const uint8_t *codecInfo)
181 {
182 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
183 switch (GetNumberOfSubbandsSbc(codecInfo)) {
184 case A2DP_SBC_SUBBAND_4:
185 return SBC_SUBBAND_4;
186 case A2DP_SBC_SUBBAND_8:
187 return SBC_SUBBAND_8;
188 default:
189 LOG_INFO("Use default numOfSubBands: 8");
190 return SBC_SUBBAND_8;
191 }
192 }
193
A2dpSbcGetNumberOfBlocks(const uint8_t * codecInfo)194 int16_t A2dpSbcEncoder::A2dpSbcGetNumberOfBlocks(const uint8_t *codecInfo)
195 {
196 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
197 switch (GetNumberOfBlocksSbc(codecInfo)) {
198 case A2DP_SBC_BLOCKS_4:
199 return SBC_BLOCKS_4;
200 case A2DP_SBC_BLOCKS_8:
201 return SBC_BLOCKS_8;
202 case A2DP_SBC_BLOCKS_12:
203 return SBC_BLOCKS_12;
204 case A2DP_SBC_BLOCKS_16:
205 return SBC_BLOCKS_16;
206 default:
207 LOG_INFO("Use default numOfBlocks: 16");
208 return SBC_BLOCKS_16;
209 }
210 }
211
A2dpSbcGetAllocationMethodCode(const uint8_t * codecInfo)212 int16_t A2dpSbcEncoder::A2dpSbcGetAllocationMethodCode(const uint8_t *codecInfo)
213 {
214 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
215 switch (GetAllocationMethodCodeSbc(codecInfo)) {
216 case A2DP_SBC_ALLOC_MODE_S:
217 return SBC_SNR;
218 case A2DP_SBC_ALLOC_MODE_L:
219 return SBC_LOUDNESS;
220 default:
221 LOG_INFO("Use default allocationMethod: LOUDNESS");
222 return SBC_LOUDNESS;
223 }
224 }
225
A2dpSbcUpdateEncodeFeedingParams(const uint8_t * codecInfo)226 void A2dpSbcEncoder::A2dpSbcUpdateEncodeFeedingParams(const uint8_t *codecInfo)
227 {
228 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
229 a2dpSbcEncoderCb_.feedingParams.sampleRate = A2dpSbcGetSampleRate(codecInfo);
230 a2dpSbcEncoderCb_.feedingParams.bitsPerSample = A2dpSbcGetBitsPerSample();
231 a2dpSbcEncoderCb_.feedingParams.channelCount = A2dpSbcGetTrackChannelCount(codecInfo);
232
233 LOG_INFO("[SbcEncoder] %{public}s [sampleRate:%u] [bitsPerSample:%u] [channelMode:%u]",
234 __func__,
235 a2dpSbcEncoderCb_.feedingParams.sampleRate,
236 a2dpSbcEncoderCb_.feedingParams.bitsPerSample,
237 a2dpSbcEncoderCb_.feedingParams.channelCount);
238 }
239
A2dpSbcUpdateEncoderParams(SBCEncoderParams * encParams,const uint8_t * codecInfo) const240 void A2dpSbcEncoder::A2dpSbcUpdateEncoderParams(SBCEncoderParams *encParams, const uint8_t *codecInfo) const
241 {
242 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
243 encParams->channelMode = A2dpSbcGetTrackChannelMode(codecInfo);
244 encParams->subBands = A2dpSbcGetNumberOfSubbands(codecInfo);
245 encParams->numOfBlocks = A2dpSbcGetNumberOfBlocks(codecInfo);
246 encParams->allocationMethod = A2dpSbcGetAllocationMethodCode(codecInfo);
247 encParams->samplingFreq = A2dpSbcGetSampleRate(codecInfo);
248 encParams->channels = A2dpSbcGetTrackChannelCount(codecInfo);
249
250 LOG_INFO("[SbcEncoder] %{public}s [cMode:%u] [sub:%u] [blk:%u] [allc::%u] [freq:%u] [ch:%u]",
251 __func__,
252 encParams->channelMode,
253 encParams->subBands,
254 encParams->numOfBlocks,
255 encParams->allocationMethod,
256 encParams->samplingFreq,
257 encParams->channels);
258 }
259
SetSBCParam()260 void A2dpSbcEncoder::SetSBCParam()
261 {
262 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
263 ConvertFreqParamToSBCParam();
264 ConvertModeParamToSBCParam();
265 ConvertSubbandsParamToSBCParam();
266 ConvertBlockParamToSBCParam();
267 ConvertAllocationParamToSBCParam();
268 ConvertBitpoolParamToSBCParam();
269 g_sbcEncode.endian = sbc::SBC_ENDIANESS_LE;
270 sbcEncoder_ = codecSbcEncoderLib_->sbcEncoder.createSbcEncode();
271 LOG_INFO("[SbcEncoder] %{public}s[freq:%u][mode:%u][sub:%u][block:%u][alc:%u][bitpool:%u]\n",
272 __func__,
273 g_sbcEncode.frequency,
274 g_sbcEncode.channelMode,
275 g_sbcEncode.subbands,
276 g_sbcEncode.blocks,
277 g_sbcEncode.allocation,
278 g_sbcEncode.bitpool);
279 }
280
updateParam(void)281 void A2dpSbcEncoder::updateParam(void)
282 {
283 UpdateEncoderParam();
284 }
285
UpdateEncoderParam(void)286 void A2dpSbcEncoder::UpdateEncoderParam(void)
287 {
288 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
289 SBCEncoderParams *encParams = &a2dpSbcEncoderCb_.sbcEncoderParams;
290 uint16_t samplingFreq = 48000;
291 uint8_t codecInfo[A2DP_CODEC_SIZE];
292 uint8_t *codecConfigInfo = &codecInfo[0];
293 if (!config_->CopyOutOtaCodecConfig(codecConfigInfo)) {
294 LOG_ERROR("Failed to read A2dpCodecConfig!");
295 return;
296 }
297 const uint8_t *codecCfgInfo = codecConfigInfo;
298 int minBitPool = GetMinBitpoolSbc(codecCfgInfo);
299 int maxBitPool = GetMaxBitpoolSbc(codecCfgInfo);
300
301 A2dpSbcUpdateEncodeFeedingParams(codecCfgInfo);
302
303 ResetFeedingState();
304
305 A2dpSbcUpdateEncoderParams(encParams, codecCfgInfo);
306
307 const uint16_t mtu = A2DP_SBC_MAX_PACKET_SIZE - A2DP_SBC_PACKET_HEAD_SIZE - A2DP_SBC_MEDIA_PAYLOAD_HEAD_SIZE;
308 if (mtu < a2dpSbcEncoderCb_.peerMtu) {
309 a2dpSbcEncoderCb_.mtuSize = mtu;
310 } else {
311 a2dpSbcEncoderCb_.mtuSize = a2dpSbcEncoderCb_.peerMtu;
312 }
313
314 samplingFreq = encParams->samplingFreq;
315 encParams->bitRate = A2DP_SBC_DEFAULT_BITRATE;
316
317 if (!a2dpSbcEncoderCb_.isPeerEdr) {
318 encParams->bitRate = A2DP_SBC_NON_EDR_MAX_BITRATE;
319 }
320
321 A2dpSbcCalculateEncBitPool(samplingFreq, minBitPool, maxBitPool);
322 SetSBCParam();
323 UpdateMtuSize();
324 }
325
A2dpSbcReadFeeding(uint32_t * bytesRead)326 bool A2dpSbcEncoder::A2dpSbcReadFeeding(uint32_t *bytesRead)
327 {
328 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
329
330 uint32_t expectedReadPcmData = a2dpSbcEncoderCb_.feedingState.bytesPerTick;
331
332 if (expectedReadPcmData + a2dpSbcEncoderCb_.offsetPCM > FRAME_THREE * A2DP_SBC_MAX_PACKET_SIZE) {
333 LOG_ERROR("[Feeding] buffer no space");
334 return false;
335 }
336 A2dpProfile *profile = GetProfileInstance(A2DP_ROLE_SOURCE);
337 uint32_t actualReadPcmData = profile->GetPcmData(&a2dpSbcEncoderCb_.pcmBuffer[a2dpSbcEncoderCb_.offsetPCM],
338 expectedReadPcmData);
339 LOG_INFO("[ReadA2dpSharedBuffer][expectedReadPcmData:%u][actualReadPcmData:%u]",
340 expectedReadPcmData, actualReadPcmData);
341
342 *bytesRead = actualReadPcmData;
343
344 if (actualReadPcmData) {
345 LOG_INFO("[Feeding][offsetPCM:%u][readBytes:%u]", a2dpSbcEncoderCb_.offsetPCM, actualReadPcmData);
346 return true;
347 } else {
348 LOG_ERROR("[Feeding][read no data][readBytes:%u]", actualReadPcmData);
349 return false;
350 }
351 }
352
ConvertFreqParamToSBCParam(void)353 void A2dpSbcEncoder::ConvertFreqParamToSBCParam(void)
354 {
355 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
356 SBCEncoderParams *encParams = &a2dpSbcEncoderCb_.sbcEncoderParams;
357 switch (encParams->samplingFreq) {
358 case SBC_SAMPLE_RATE_16000:
359 g_sbcEncode.frequency = sbc::SBC_FREQ_16000;
360 break;
361 case SBC_SAMPLE_RATE_32000:
362 g_sbcEncode.frequency = sbc::SBC_FREQ_32000;
363 break;
364 case SBC_SAMPLE_RATE_44100:
365 g_sbcEncode.frequency = sbc::SBC_FREQ_44100;
366 break;
367 case SBC_SAMPLE_RATE_48000:
368 g_sbcEncode.frequency = sbc::SBC_FREQ_48000;
369 break;
370 default:
371 g_sbcEncode.frequency = sbc::SBC_FREQ_44100;
372 break;
373 }
374 }
375
ConvertModeParamToSBCParam(void)376 void A2dpSbcEncoder::ConvertModeParamToSBCParam(void)
377 {
378 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
379 SBCEncoderParams *encParams = &a2dpSbcEncoderCb_.sbcEncoderParams;
380 switch (encParams->channelMode) {
381 case SBC_MONO:
382 g_sbcEncode.channelMode = sbc::SBC_CHANNEL_MODE_MONO;
383 break;
384 case SBC_DUAL:
385 g_sbcEncode.channelMode = sbc::SBC_CHANNEL_MODE_DUAL_CHANNEL;
386 break;
387 case SBC_STEREO:
388 g_sbcEncode.channelMode = sbc::SBC_CHANNEL_MODE_STEREO;
389 break;
390 case SBC_JOINT_STEREO:
391 g_sbcEncode.channelMode = sbc::SBC_CHANNEL_MODE_JOINT_STEREO;
392 break;
393 default:
394 g_sbcEncode.channelMode = sbc::SBC_CHANNEL_MODE_STEREO;
395 break;
396 }
397 }
398
ConvertSubbandsParamToSBCParam(void)399 void A2dpSbcEncoder::ConvertSubbandsParamToSBCParam(void)
400 {
401 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
402 SBCEncoderParams *encParams = &a2dpSbcEncoderCb_.sbcEncoderParams;
403 switch (encParams->subBands) {
404 case SBC_SUBBAND_4:
405 g_sbcEncode.subbands = sbc::SBC_SUBBAND4;
406 break;
407 case SBC_SUBBAND_8:
408 g_sbcEncode.subbands = sbc::SBC_SUBBAND8;
409 break;
410 default:
411 g_sbcEncode.subbands = sbc::SBC_SUBBAND8;
412 break;
413 }
414 }
415
ConvertBlockParamToSBCParam(void)416 void A2dpSbcEncoder::ConvertBlockParamToSBCParam(void)
417 {
418 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
419 SBCEncoderParams *encParams = &a2dpSbcEncoderCb_.sbcEncoderParams;
420 switch (encParams->numOfBlocks) {
421 case SBC_BLOCKS_4:
422 g_sbcEncode.blocks = sbc::SBC_BLOCK4;
423 break;
424 case SBC_BLOCKS_8:
425 g_sbcEncode.blocks = sbc::SBC_BLOCK8;
426 break;
427 case SBC_BLOCKS_12:
428 g_sbcEncode.blocks = sbc::SBC_BLOCK12;
429 break;
430 case SBC_BLOCKS_16:
431 g_sbcEncode.blocks = sbc::SBC_BLOCK16;
432 break;
433 default:
434 g_sbcEncode.blocks = sbc::SBC_BLOCK16;
435 break;
436 }
437 }
438
ConvertAllocationParamToSBCParam(void)439 void A2dpSbcEncoder::ConvertAllocationParamToSBCParam(void)
440 {
441 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
442 SBCEncoderParams *encParams = &a2dpSbcEncoderCb_.sbcEncoderParams;
443 switch (encParams->allocationMethod) {
444 case SBC_LOUDNESS:
445 g_sbcEncode.allocation = sbc::SBC_ALLOCATION_LOUDNESS;
446 break;
447 case SBC_SNR:
448 g_sbcEncode.allocation = sbc::SBC_ALLOCATION_SNR;
449 break;
450 default:
451 g_sbcEncode.allocation = sbc::SBC_ALLOCATION_LOUDNESS;
452 break;
453 }
454 }
455
ConvertBitpoolParamToSBCParam(void)456 void A2dpSbcEncoder::ConvertBitpoolParamToSBCParam(void)
457 {
458 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
459 SBCEncoderParams *encParams = &a2dpSbcEncoderCb_.sbcEncoderParams;
460 g_sbcEncode.bitpool = encParams->bitPool;
461 }
462
CalculateSbcPCMRemain(uint16_t codecSize,uint32_t bytesNum,uint8_t * numOfFrame)463 void A2dpSbcEncoder::CalculateSbcPCMRemain(uint16_t codecSize, uint32_t bytesNum, uint8_t *numOfFrame)
464 {
465 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
466 if (codecSize != 0) {
467 LOG_INFO("[offset:%u][bytes:%u][codecSize:%u]", a2dpSbcEncoderCb_.offsetPCM, bytesNum, codecSize);
468 *numOfFrame = (a2dpSbcEncoderCb_.offsetPCM + bytesNum) / codecSize;
469 a2dpSbcEncoderCb_.offsetPCM = (a2dpSbcEncoderCb_.offsetPCM + bytesNum) % codecSize;
470 uint16_t encodePCMSize = *numOfFrame * codecSize;
471 LOG_INFO("[numOfFrame:%u][offset:%u][bytes:%u]", *numOfFrame, a2dpSbcEncoderCb_.offsetPCM, bytesNum);
472 if (a2dpSbcEncoderCb_.offsetPCM > PCM_REMAIN_BUFFER_SIZE) {
473 a2dpSbcEncoderCb_.offsetPCM = PCM_REMAIN_BUFFER_SIZE;
474 }
475 (void)memcpy_s(a2dpSbcEncoderCb_.pcmRemain, A2DP_SBC_MAX_PACKET_SIZE,
476 &a2dpSbcEncoderCb_.pcmBuffer[encodePCMSize], a2dpSbcEncoderCb_.offsetPCM);
477 }
478 }
479
A2dpSbcEncodeFrames(void)480 void A2dpSbcEncoder::A2dpSbcEncodeFrames(void)
481 {
482 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
483 size_t encoded = 0;
484 SBCEncoderParams *encParams = &a2dpSbcEncoderCb_.sbcEncoderParams;
485 uint16_t blocksXsubbands = encParams->subBands * encParams->numOfBlocks;
486 uint16_t channelMode = (g_sbcEncode.channelMode == sbc::SBC_CHANNEL_MODE_MONO) ? CHANNEL_ONE : CHANNEL_TWO;
487 uint16_t subbands = g_sbcEncode.subbands ? SUBBAND8 : SUBBAND4;
488 const uint16_t blocks = SUBBAND4 + (g_sbcEncode.blocks * SUBBAND4);
489 uint16_t codecSize = subbands * blocks * channelMode * VALUE_TWO;
490 Packet *pkt = PacketMalloc(A2DP_SBC_FRAGMENT_HEADER, 0, 0);
491 uint32_t bytesNum = 0;
492 uint8_t numOfFrame = 0;
493 if (A2dpSbcReadFeeding(&bytesNum)) {
494 CalculateSbcPCMRemain(codecSize, bytesNum, &numOfFrame);
495 uint8_t frameIter = 0;
496 uint16_t pcmOffset = 0;
497 while (numOfFrame) {
498 uint8_t outputBuf[A2DP_SBC_HQ_DUAL_BP_53_FRAME_SIZE] = {};
499 int16_t outputLen = sbcEncoder_->SBCEncode(g_sbcEncode, &a2dpSbcEncoderCb_.pcmBuffer[pcmOffset],
500 blocksXsubbands * channelMode, outputBuf, sizeof(outputBuf), &encoded);
501 LOG_INFO("[SbcEncoder] %{public}s encoded %{public}zu, pcmOffset%{public}u\n",
502 __func__, encoded, pcmOffset);
503 if (outputLen < 0) {
504 LOG_ERROR("err occur.");
505 }
506 pcmOffset += blocksXsubbands * channelMode * CHANNEL_TWO;
507 Buffer *encBuf = BufferMalloc(encoded);
508 if (memcpy_s(BufferPtr(encBuf), encoded, outputBuf, encoded) != EOK) {
509 BufferFree(encBuf);
510 PacketFree(pkt);
511 return;
512 }
513 PacketPayloadAddLast(pkt, encBuf);
514 BufferFree(encBuf);
515 numOfFrame--;
516 frameIter++;
517 }
518 uint16_t encodePacketSize = PacketSize(pkt);
519 (void)memset_s(a2dpSbcEncoderCb_.pcmBuffer, A2DP_SBC_MAX_PACKET_SIZE * FRAME_THREE,
520 0, sizeof(a2dpSbcEncoderCb_.pcmBuffer));
521 if (memcpy_s(a2dpSbcEncoderCb_.pcmBuffer, A2DP_SBC_MAX_PACKET_SIZE * FRAME_THREE,
522 a2dpSbcEncoderCb_.pcmRemain, a2dpSbcEncoderCb_.offsetPCM) != EOK) {
523 PacketFree(pkt);
524 return;
525 }
526 (void)memset_s(a2dpSbcEncoderCb_.pcmRemain, A2DP_SBC_MAX_PACKET_SIZE, 0, sizeof(a2dpSbcEncoderCb_.pcmRemain));
527 if (encodePacketSize > 0) {
528 uint32_t pktTimeStamp = a2dpSbcEncoderCb_.timestamp;
529 a2dpSbcEncoderCb_.timestamp += frameIter * blocksXsubbands;
530 a2dpSbcEncoderCb_.sendDataSize += codecSize * frameIter;
531 EnqueuePacket(pkt, frameIter, encodePacketSize, pktTimeStamp, (uint16_t)encoded); // Enqueue Packet.
532 LOG_INFO("[SbcEncoder] %{public}s timestamp %{public}u, sendDataSize%{public}u\n",
533 __func__, a2dpSbcEncoderCb_.timestamp, a2dpSbcEncoderCb_.sendDataSize);
534 }
535 }
536 PacketFree(pkt);
537 }
538
EnqueuePacket(Packet * pkt,size_t frames,const uint32_t bytes,uint32_t timeStamp,const uint16_t frameSize) const539 void A2dpSbcEncoder::EnqueuePacket(
540 Packet *pkt, size_t frames, const uint32_t bytes, uint32_t timeStamp, const uint16_t frameSize) const
541 {
542 LOG_INFO("[EnqueuePacket][frameSize:%hu][FrameNum:%zu], mtu[%hu], totalSize[%u]",
543 frameSize, frames, a2dpSbcEncoderCb_.mtuSize, PacketSize(pkt));
544 if (PacketSize(pkt) < static_cast<uint32_t>(a2dpSbcEncoderCb_.mtuSize)) {
545 Buffer *header = PacketHead(pkt);
546 uint8_t *p = static_cast<uint8_t*>(BufferPtr(header));
547 *p = frames;
548 A2dpProfile *profile = GetProfileInstance(A2DP_ROLE_SOURCE);
549 profile->EnqueuePacket(pkt, frames, bytes, timeStamp); // Enqueue Packet.
550 } else {
551 EnqueuePacketFragment(pkt, frames, bytes, timeStamp, frameSize);
552 }
553 }
554
EnqueuePacketFragment(Packet * pkt,size_t frames,const uint32_t bytes,uint32_t timeStamp,const uint16_t frameSize) const555 void A2dpSbcEncoder::EnqueuePacketFragment(
556 Packet *pkt, size_t frames, const uint32_t bytes, uint32_t timeStamp, const uint16_t frameSize) const
557 {
558 LOG_INFO("[SbcEncoder] %{public}s\n", __func__);
559 uint8_t count = 1;
560 uint32_t pktLen = 0;
561 uint8_t frameNum = 0;
562 uint8_t sentFrameNum = 0;
563 uint16_t blocksXsubbands
564 = a2dpSbcEncoderCb_.sbcEncoderParams.subBands * a2dpSbcEncoderCb_.sbcEncoderParams.numOfBlocks;
565 bool frameFragmented = false;
566 if ((static_cast<uint16_t>(frames) / FRAGMENT_SIZE_TWO + 1) * frameSize < (a2dpSbcEncoderCb_.mtuSize)) {
567 count = FRAGMENT_SIZE_TWO;
568 pktLen = (frames / count) * frameSize;
569 } else {
570 count = FRAGMENT_SIZE_THREE;
571 pktLen = (frames / count) * frameSize;
572 if (pktLen > static_cast<uint32_t>(a2dpSbcEncoderCb_.mtuSize) ||
573 (frames - frames / count * FRAGMENT_SIZE_TWO) * frameSize >
574 static_cast<uint32_t>(a2dpSbcEncoderCb_.mtuSize)) {
575 frameFragmented = true;
576 LOG_ERROR("mtu size isn't enough.[frameSize:%u] mtu[%u]", pktLen, a2dpSbcEncoderCb_.mtuSize);
577 }
578 }
579 frameNum = frames / count;
580 if (!frameFragmented) {
581 size_t remainFrames = frames;
582 uint16_t offset = 0;
583 do {
584 Packet *mediaPacket = PacketMalloc(A2DP_SBC_FRAGMENT_HEADER, 0, 0);
585 if (count == 1) {
586 frameNum = remainFrames;
587 pktLen = frameNum * frameSize;
588 }
589 count--;
590 LOG_INFO("[EnqueuePacket] [pktLen:%u] [sFrameNum:%u] [remain:%u]", pktLen, frameNum, PacketSize(pkt));
591 Buffer *header = PacketHead(mediaPacket);
592 uint8_t *p = static_cast<uint8_t*>(BufferPtr(header));
593 *p = frameNum;
594 uint8_t bufferFra[1024];
595 size_t encoded = pktLen;
596 PacketPayloadRead(pkt, bufferFra, offset, pktLen);
597 offset += pktLen;
598 Buffer *encBuf = BufferMalloc(encoded);
599 if (memcpy_s(BufferPtr(encBuf), encoded, bufferFra, encoded) != EOK) {
600 LOG_ERROR("[EnqueuePacket] memcpy_s fail");
601 return;
602 }
603 PacketPayloadAddLast(mediaPacket, encBuf);
604 BufferFree(encBuf);
605 remainFrames -= frameNum;
606
607 uint16_t encodePacketSize = PacketSize(mediaPacket);
608 LOG_ERROR("[EnqueuePacket] encodePacketSize is ");
609 A2dpProfile *profile = GetProfileInstance(A2DP_ROLE_SOURCE);
610 profile->EnqueuePacket(mediaPacket, frameNum, encodePacketSize, timeStamp + sentFrameNum * blocksXsubbands);
611 // Enqueue Packet.
612 sentFrameNum += frameNum;
613 PacketFree(mediaPacket);
614 } while (count > 0);
615 }
616 }
617
A2dpSbcCalculateEncBitPool(uint16_t samplingFreq,uint16_t minBitPool,uint16_t maxBitPool)618 void A2dpSbcEncoder::A2dpSbcCalculateEncBitPool(uint16_t samplingFreq, uint16_t minBitPool, uint16_t maxBitPool)
619 {
620 SBCEncoderParams *encParams = &a2dpSbcEncoderCb_.sbcEncoderParams;
621 uint8_t protect = 0;
622 int16_t bitPool = 0;
623 int16_t bitRate = 0;
624 if ((encParams == nullptr) || (samplingFreq == 0) || (encParams->subBands == 0) || (encParams->channels == 0)) {
625 return;
626 }
627 do { // Dynamic bitpool support.
628 if ((encParams->channelMode == SBC_JOINT_STEREO) || (encParams->channelMode == SBC_STEREO)) {
629 bitPool = static_cast<int16_t>((encParams->bitRate * encParams->subBands * MS_TO_US / samplingFreq) -
630 ((NUMBER32 + (SUBBAND4 * encParams->subBands * encParams->channels) +
631 ((encParams->channelMode - CHANNEL_TWO) * encParams->subBands)) /
632 encParams->numOfBlocks));
633 int16_t frameLen =
634 SUBBAND4 + (SUBBAND4 * encParams->subBands * encParams->channels) / BIT8 +
635 (((encParams->channelMode - CHANNEL_TWO) * encParams->subBands) + (encParams->numOfBlocks * bitPool)) /
636 BIT8;
637 bitRate = (BIT8 * frameLen * samplingFreq) / (encParams->subBands * encParams->numOfBlocks * MS_TO_US);
638 if (bitRate > encParams->bitRate) {
639 bitPool--;
640 }
641 encParams->bitPool =
642 (bitPool > (NUMBER32 * encParams->subBands)) ? (NUMBER32 * encParams->subBands) : bitPool;
643 } else { // Mono or Dual Channel.
644 bitPool = static_cast<int16_t>(
645 ((encParams->subBands * encParams->bitRate * MS_TO_US) / (samplingFreq * encParams->channels)) -
646 (((NUMBER32 / encParams->channels) + (SUBBAND4 * encParams->subBands)) / encParams->numOfBlocks));
647 encParams->bitPool = (bitPool > (BIT_POOL_SIXTEEN * encParams->subBands)) ?
648 (BIT_POOL_SIXTEEN * encParams->subBands) : bitPool;
649 }
650 if (bitPool > maxBitPool) {
651 encParams->bitRate -= BIT_NUMBER5;
652 protect |= PROTECT_ONE;
653 } else if (bitPool < minBitPool) {
654 uint16_t preBitRate = encParams->bitRate;
655 encParams->bitRate += BIT_NUMBER5;
656 protect |= PROTECT_TWO;
657 if (encParams->bitRate < preBitRate) {
658 protect |= PROTECT_THREE;
659 }
660 } else {
661 break;
662 }
663 if (protect == PROTECT_THREE) {
664 break;
665 }
666 } while (true);
667 encParams->bitPool = bitPool;
668 }
669
UpdateMtuSize(void)670 void A2dpSbcEncoder::UpdateMtuSize(void)
671 {
672 LOG_INFO("[SBCEncoder] %{public}s", __func__);
673 uint16_t mtu = a2dpSbcEncoderCb_.mtuSize;
674
675 if (a2dpSbcEncoderCb_.isPeerEdr) {
676 if (!a2dpSbcEncoderCb_.peerSupports3mbps) {
677 if (mtu > MAX_2MBPS_SBC_PAYLOAD_MTU) { // MTU is only payload.
678 mtu = MAX_2MBPS_SBC_PAYLOAD_MTU;
679 a2dpSbcEncoderCb_.mtuSize = mtu;
680 }
681 } else { // EDR 3mbps.
682 if (mtu > MAX_3MBPS_SBC_PAYLOAD_MTU) { // MTU is only payload.
683 mtu = MAX_3MBPS_SBC_PAYLOAD_MTU;
684 a2dpSbcEncoderCb_.mtuSize = mtu;
685 }
686 }
687 }
688 LOG_INFO("[SBCEncoder] %{public}s [mtuSize:%u]", __func__, a2dpSbcEncoderCb_.mtuSize);
689 }
690 } // namespace bluetooth
691 } // namespace OHOS