1 /*
2 * Copyright 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "a2dp_aac_encoder"
18
19 #include "a2dp_aac_encoder.h"
20
21 #include <inttypes.h>
22 #include <stdio.h>
23 #include <string.h>
24
25 #include <aacenc_lib.h>
26 #include <base/logging.h>
27
28 #include "a2dp_aac.h"
29 #include "bt_common.h"
30 #include "common/time_util.h"
31 #include "osi/include/log.h"
32 #include "osi/include/osi.h"
33
34 //
35 // Encoder for AAC Source Codec
36 //
37
38 // A2DP AAC encoder interval in milliseconds
39 #define A2DP_AAC_ENCODER_INTERVAL_MS 20
40
41 // offset
42 #if (BTA_AV_CO_CP_SCMS_T == TRUE)
43 #define A2DP_AAC_OFFSET (AVDT_MEDIA_OFFSET + 1)
44 #else
45 #define A2DP_AAC_OFFSET AVDT_MEDIA_OFFSET
46 #endif
47
48 typedef struct {
49 uint32_t sample_rate;
50 uint8_t channel_mode;
51 uint8_t bits_per_sample;
52 uint32_t frame_length; // Samples per channel in a frame
53 uint8_t input_channels_n; // Number of channels
54 int max_encoded_buffer_bytes; // Max encoded bytes per frame
55 } tA2DP_AAC_ENCODER_PARAMS;
56
57 typedef struct {
58 float counter;
59 uint32_t bytes_per_tick; /* pcm bytes read each media task tick */
60 uint64_t last_frame_us;
61 } tA2DP_AAC_FEEDING_STATE;
62
63 typedef struct {
64 uint64_t session_start_us;
65
66 size_t media_read_total_expected_packets;
67 size_t media_read_total_expected_reads_count;
68 size_t media_read_total_expected_read_bytes;
69
70 size_t media_read_total_dropped_packets;
71 size_t media_read_total_actual_reads_count;
72 size_t media_read_total_actual_read_bytes;
73 } a2dp_aac_encoder_stats_t;
74
75 typedef struct {
76 a2dp_source_read_callback_t read_callback;
77 a2dp_source_enqueue_callback_t enqueue_callback;
78 uint16_t TxAaMtuSize;
79
80 bool use_SCMS_T;
81 bool is_peer_edr; // True if the peer device supports EDR
82 bool peer_supports_3mbps; // True if the peer device supports 3Mbps EDR
83 uint16_t peer_mtu; // MTU of the A2DP peer
84 uint32_t timestamp; // Timestamp for the A2DP frames
85
86 HANDLE_AACENCODER aac_handle;
87 bool has_aac_handle; // True if aac_handle is valid
88
89 tA2DP_FEEDING_PARAMS feeding_params;
90 tA2DP_AAC_ENCODER_PARAMS aac_encoder_params;
91 tA2DP_AAC_FEEDING_STATE aac_feeding_state;
92
93 a2dp_aac_encoder_stats_t stats;
94 } tA2DP_AAC_ENCODER_CB;
95
96 static uint32_t a2dp_aac_encoder_interval_ms = A2DP_AAC_ENCODER_INTERVAL_MS;
97
98 static tA2DP_AAC_ENCODER_CB a2dp_aac_encoder_cb;
99
100 static void a2dp_aac_encoder_update(uint16_t peer_mtu,
101 A2dpCodecConfig* a2dp_codec_config,
102 bool* p_restart_input,
103 bool* p_restart_output,
104 bool* p_config_updated);
105 static void a2dp_aac_get_num_frame_iteration(uint8_t* num_of_iterations,
106 uint8_t* num_of_frames,
107 uint64_t timestamp_us);
108 static void a2dp_aac_encode_frames(uint8_t nb_frame);
109 static bool a2dp_aac_read_feeding(uint8_t* read_buffer, uint32_t* bytes_read);
110
A2DP_LoadEncoderAac(void)111 bool A2DP_LoadEncoderAac(void) {
112 // Nothing to do - the library is statically linked
113 return true;
114 }
115
A2DP_UnloadEncoderAac(void)116 void A2DP_UnloadEncoderAac(void) {
117 // Nothing to do - the library is statically linked
118 if (a2dp_aac_encoder_cb.has_aac_handle)
119 aacEncClose(&a2dp_aac_encoder_cb.aac_handle);
120 memset(&a2dp_aac_encoder_cb, 0, sizeof(a2dp_aac_encoder_cb));
121 }
122
a2dp_aac_encoder_init(const tA2DP_ENCODER_INIT_PEER_PARAMS * p_peer_params,A2dpCodecConfig * a2dp_codec_config,a2dp_source_read_callback_t read_callback,a2dp_source_enqueue_callback_t enqueue_callback)123 void a2dp_aac_encoder_init(const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params,
124 A2dpCodecConfig* a2dp_codec_config,
125 a2dp_source_read_callback_t read_callback,
126 a2dp_source_enqueue_callback_t enqueue_callback) {
127 if (a2dp_aac_encoder_cb.has_aac_handle)
128 aacEncClose(&a2dp_aac_encoder_cb.aac_handle);
129 memset(&a2dp_aac_encoder_cb, 0, sizeof(a2dp_aac_encoder_cb));
130
131 a2dp_aac_encoder_cb.stats.session_start_us =
132 bluetooth::common::time_get_os_boottime_us();
133
134 a2dp_aac_encoder_cb.read_callback = read_callback;
135 a2dp_aac_encoder_cb.enqueue_callback = enqueue_callback;
136 a2dp_aac_encoder_cb.is_peer_edr = p_peer_params->is_peer_edr;
137 a2dp_aac_encoder_cb.peer_supports_3mbps = p_peer_params->peer_supports_3mbps;
138 a2dp_aac_encoder_cb.peer_mtu = p_peer_params->peer_mtu;
139 a2dp_aac_encoder_cb.timestamp = 0;
140
141 a2dp_aac_encoder_cb.use_SCMS_T = false; // TODO: should be a parameter
142 #if (BTA_AV_CO_CP_SCMS_T == TRUE)
143 a2dp_aac_encoder_cb.use_SCMS_T = true;
144 #endif
145
146 // NOTE: Ignore the restart_input / restart_output flags - this initization
147 // happens when the connection is (re)started.
148 bool restart_input = false;
149 bool restart_output = false;
150 bool config_updated = false;
151 a2dp_aac_encoder_update(a2dp_aac_encoder_cb.peer_mtu, a2dp_codec_config,
152 &restart_input, &restart_output, &config_updated);
153 }
154
updateEncoderUserConfig(const tA2DP_ENCODER_INIT_PEER_PARAMS * p_peer_params,bool * p_restart_input,bool * p_restart_output,bool * p_config_updated)155 bool A2dpCodecConfigAacSource::updateEncoderUserConfig(
156 const tA2DP_ENCODER_INIT_PEER_PARAMS* p_peer_params, bool* p_restart_input,
157 bool* p_restart_output, bool* p_config_updated) {
158 a2dp_aac_encoder_cb.is_peer_edr = p_peer_params->is_peer_edr;
159 a2dp_aac_encoder_cb.peer_supports_3mbps = p_peer_params->peer_supports_3mbps;
160 a2dp_aac_encoder_cb.peer_mtu = p_peer_params->peer_mtu;
161 a2dp_aac_encoder_cb.timestamp = 0;
162
163 if (a2dp_aac_encoder_cb.peer_mtu == 0) {
164 LOG_ERROR(
165 "%s: Cannot update the codec encoder for %s: "
166 "invalid peer MTU",
167 __func__, name().c_str());
168 return false;
169 }
170
171 a2dp_aac_encoder_update(a2dp_aac_encoder_cb.peer_mtu, this, p_restart_input,
172 p_restart_output, p_config_updated);
173 return true;
174 }
175
176 // Update the A2DP AAC encoder.
177 // |peer_mtu| is the peer MTU.
178 // |a2dp_codec_config| is the A2DP codec to use for the update.
a2dp_aac_encoder_update(uint16_t peer_mtu,A2dpCodecConfig * a2dp_codec_config,bool * p_restart_input,bool * p_restart_output,bool * p_config_updated)179 static void a2dp_aac_encoder_update(uint16_t peer_mtu,
180 A2dpCodecConfig* a2dp_codec_config,
181 bool* p_restart_input,
182 bool* p_restart_output,
183 bool* p_config_updated) {
184 tA2DP_AAC_ENCODER_PARAMS* p_encoder_params =
185 &a2dp_aac_encoder_cb.aac_encoder_params;
186 uint8_t codec_info[AVDT_CODEC_SIZE];
187 AACENC_ERROR aac_error;
188 int aac_param_value, aac_sampling_freq, aac_peak_bit_rate;
189
190 *p_restart_input = false;
191 *p_restart_output = false;
192 *p_config_updated = false;
193
194 if (!a2dp_aac_encoder_cb.has_aac_handle) {
195 AACENC_ERROR aac_error = aacEncOpen(&a2dp_aac_encoder_cb.aac_handle, 0,
196 2 /* max 2 channels: stereo */);
197 if (aac_error != AACENC_OK) {
198 LOG_ERROR("%s: Cannot open AAC encoder handle: AAC error 0x%x", __func__,
199 aac_error);
200 return; // TODO: Return an error?
201 }
202 a2dp_aac_encoder_cb.has_aac_handle = true;
203 }
204
205 if (!a2dp_codec_config->copyOutOtaCodecConfig(codec_info)) {
206 LOG_ERROR(
207 "%s: Cannot update the codec encoder for %s: "
208 "invalid codec config",
209 __func__, a2dp_codec_config->name().c_str());
210 return;
211 }
212 const uint8_t* p_codec_info = codec_info;
213
214 // The feeding parameters
215 tA2DP_FEEDING_PARAMS* p_feeding_params = &a2dp_aac_encoder_cb.feeding_params;
216 p_feeding_params->sample_rate = A2DP_GetTrackSampleRateAac(p_codec_info);
217 p_feeding_params->bits_per_sample =
218 a2dp_codec_config->getAudioBitsPerSample();
219 p_feeding_params->channel_count = A2DP_GetTrackChannelCountAac(p_codec_info);
220 LOG_INFO("%s: sample_rate=%u bits_per_sample=%u channel_count=%u", __func__,
221 p_feeding_params->sample_rate, p_feeding_params->bits_per_sample,
222 p_feeding_params->channel_count);
223
224 // The codec parameters
225 p_encoder_params->sample_rate =
226 a2dp_aac_encoder_cb.feeding_params.sample_rate;
227 p_encoder_params->channel_mode = A2DP_GetChannelModeCodeAac(p_codec_info);
228
229 LOG_VERBOSE("%s: original AVDTP MTU size: %d", __func__,
230 a2dp_aac_encoder_cb.TxAaMtuSize);
231 if (a2dp_aac_encoder_cb.is_peer_edr &&
232 !a2dp_aac_encoder_cb.peer_supports_3mbps) {
233 // This condition would be satisfied only if the remote device is
234 // EDR and supports only 2 Mbps, but the effective AVDTP MTU size
235 // exceeds the 2DH5 packet size.
236 LOG_VERBOSE("%s: The remote device is EDR but does not support 3 Mbps",
237 __func__);
238 if (peer_mtu > MAX_2MBPS_AVDTP_MTU) {
239 LOG_WARN("%s: Restricting AVDTP MTU size from %d to %d", __func__,
240 peer_mtu, MAX_2MBPS_AVDTP_MTU);
241 peer_mtu = MAX_2MBPS_AVDTP_MTU;
242 }
243 }
244 uint16_t mtu_size = BT_DEFAULT_BUFFER_SIZE - A2DP_AAC_OFFSET - sizeof(BT_HDR);
245 if (mtu_size < peer_mtu) {
246 a2dp_aac_encoder_cb.TxAaMtuSize = mtu_size;
247 } else {
248 a2dp_aac_encoder_cb.TxAaMtuSize = peer_mtu;
249 }
250
251 LOG_INFO("%s: MTU=%d, peer_mtu=%d", __func__, a2dp_aac_encoder_cb.TxAaMtuSize,
252 peer_mtu);
253 LOG_INFO("%s: sample_rate: %d channel_mode: %d ", __func__,
254 p_encoder_params->sample_rate, p_encoder_params->channel_mode);
255
256 // Set the encoder's parameters: Audio Object Type - MANDATORY
257 // A2DP_AAC_OBJECT_TYPE_MPEG2_LC -> AOT_AAC_LC
258 // A2DP_AAC_OBJECT_TYPE_MPEG4_LC -> AOT_AAC_LC
259 // A2DP_AAC_OBJECT_TYPE_MPEG4_LTP -> AOT_AAC_LTP
260 // A2DP_AAC_OBJECT_TYPE_MPEG4_SCALABLE -> AOT_AAC_SCAL
261 aac_param_value = AOT_AAC_LC;
262 int object_type = A2DP_GetObjectTypeCodeAac(p_codec_info);
263 switch (object_type) {
264 case A2DP_AAC_OBJECT_TYPE_MPEG2_LC:
265 aac_param_value = AOT_AAC_LC;
266 break;
267 case A2DP_AAC_OBJECT_TYPE_MPEG4_LC:
268 aac_param_value = AOT_AAC_LC;
269 break;
270 case A2DP_AAC_OBJECT_TYPE_MPEG4_LTP:
271 aac_param_value = AOT_AAC_LTP;
272 break;
273 case A2DP_AAC_OBJECT_TYPE_MPEG4_SCALABLE:
274 aac_param_value = AOT_AAC_SCAL;
275 break;
276 default:
277 LOG_ERROR(
278 "%s: Cannot set AAC parameter AACENC_AOT: "
279 "invalid object type %d",
280 __func__, object_type);
281 return; // TODO: Return an error?
282 }
283 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle, AACENC_AOT,
284 aac_param_value);
285 if (aac_error != AACENC_OK) {
286 LOG_ERROR(
287 "%s: Cannot set AAC parameter AACENC_AOT to %d: "
288 "AAC error 0x%x",
289 __func__, aac_param_value, aac_error);
290 return; // TODO: Return an error?
291 }
292
293 // Set the encoder's parameters: audioMuxVersion
294 aac_param_value = 2; // audioMuxVersion = "2"
295 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle,
296 AACENC_AUDIOMUXVER, aac_param_value);
297 if (aac_error != AACENC_OK) {
298 LOG_ERROR(
299 "%s: Cannot set AAC parameter AACENC_AUDIOMUXVER to %d: "
300 "AAC error 0x%x",
301 __func__, aac_param_value, aac_error);
302 return; // TODO: Return an error?
303 }
304
305 // Set the encoder's parameters: Signaling mode of the extension AOT
306 aac_param_value = 1; // Signaling mode of the extension AOT = 1
307 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle,
308 AACENC_SIGNALING_MODE, aac_param_value);
309 if (aac_error != AACENC_OK) {
310 LOG_ERROR(
311 "%s: Cannot set AAC parameter AACENC_SIGNALING_MODE to %d: "
312 "AAC error 0x%x",
313 __func__, aac_param_value, aac_error);
314 return; // TODO: Return an error?
315 }
316
317 // Set the encoder's parameters: Sample Rate - MANDATORY
318 aac_param_value = A2DP_GetTrackSampleRateAac(p_codec_info);
319 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle,
320 AACENC_SAMPLERATE, aac_param_value);
321 if (aac_error != AACENC_OK) {
322 LOG_ERROR(
323 "%s: Cannot set AAC parameter AACENC_SAMPLERATE to %d: "
324 "AAC error 0x%x",
325 __func__, aac_param_value, aac_error);
326 return; // TODO: Return an error?
327 }
328 aac_sampling_freq = aac_param_value; // Save for extra usage below
329
330 // Set the encoder's parameters: Bit Rate - MANDATORY
331 aac_param_value = A2DP_GetBitRateAac(p_codec_info);
332 // Calculate the bit rate from MTU and sampling frequency
333 aac_peak_bit_rate =
334 A2DP_ComputeMaxBitRateAac(p_codec_info, a2dp_aac_encoder_cb.TxAaMtuSize);
335 aac_param_value = std::min(aac_param_value, aac_peak_bit_rate);
336 LOG_INFO("%s: MTU = %d Sampling Frequency = %d Bit Rate = %d", __func__,
337 a2dp_aac_encoder_cb.TxAaMtuSize, aac_sampling_freq, aac_param_value);
338 if (aac_param_value == -1) {
339 LOG_ERROR(
340 "%s: Cannot set AAC parameter AACENC_BITRATE: "
341 "invalid codec bit rate",
342 __func__);
343 return; // TODO: Return an error?
344 }
345 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle,
346 AACENC_BITRATE, aac_param_value);
347 if (aac_error != AACENC_OK) {
348 LOG_ERROR(
349 "%s: Cannot set AAC parameter AACENC_BITRATE to %d: "
350 "AAC error 0x%x",
351 __func__, aac_param_value, aac_error);
352 return; // TODO: Return an error?
353 }
354
355 // Set the encoder's parameters: PEAK Bit Rate
356 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle,
357 AACENC_PEAK_BITRATE, aac_peak_bit_rate);
358 if (aac_error != AACENC_OK) {
359 LOG_ERROR(
360 "%s: Cannot set AAC parameter AACENC_PEAK_BITRATE to %d: "
361 "AAC error 0x%x",
362 __func__, aac_peak_bit_rate, aac_error);
363 return; // TODO: Return an error?
364 }
365
366 // Set the encoder's parameters: Channel Mode - MANDATORY
367 if (A2DP_GetTrackChannelCountAac(p_codec_info) == 1) {
368 aac_param_value = MODE_1; // Mono
369 } else {
370 aac_param_value = MODE_2; // Stereo
371 }
372 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle,
373 AACENC_CHANNELMODE, aac_param_value);
374 if (aac_error != AACENC_OK) {
375 LOG_ERROR(
376 "%s: Cannot set AAC parameter AACENC_CHANNELMODE to %d: "
377 "AAC error 0x%x",
378 __func__, aac_param_value, aac_error);
379 return; // TODO: Return an error?
380 }
381
382 // Set the encoder's parameters: Transport Type
383 aac_param_value = TT_MP4_LATM_MCP1; // muxConfigPresent = 1
384 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle,
385 AACENC_TRANSMUX, aac_param_value);
386 if (aac_error != AACENC_OK) {
387 LOG_ERROR(
388 "%s: Cannot set AAC parameter AACENC_TRANSMUX to %d: "
389 "AAC error 0x%x",
390 __func__, aac_param_value, aac_error);
391 return; // TODO: Return an error?
392 }
393
394 // Set the encoder's parameters: Header Period
395 aac_param_value = 1;
396 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle,
397 AACENC_HEADER_PERIOD, aac_param_value);
398 if (aac_error != AACENC_OK) {
399 LOG_ERROR(
400 "%s: Cannot set AAC parameter AACENC_HEADER_PERIOD to %d: "
401 "AAC error 0x%x",
402 __func__, aac_param_value, aac_error);
403 return; // TODO: Return an error?
404 }
405
406 // Set the encoder's parameters: Variable Bit Rate Support
407 aac_param_value = A2DP_GetVariableBitRateSupportAac(p_codec_info);
408 if (aac_param_value == -1) {
409 LOG_ERROR(
410 "%s: Cannot set AAC parameter AACENC_BITRATEMODE: "
411 "invalid codec bit rate mode",
412 __func__);
413 return; // TODO: Return an error?
414 } else if (aac_param_value == A2DP_AAC_VARIABLE_BIT_RATE_ENABLED) {
415 // VBR has 5 modes defined in external/aac/libAACenc/src/aacenc.h
416 // A2DP_AAC_VARIABLE_BIT_RATE_DISABLED is equal to AACENC_BR_MODE_CBR
417 auto bitrate_mode = a2dp_codec_config->getCodecConfig().codec_specific_1;
418 switch (static_cast<AacEncoderBitrateMode>(bitrate_mode)) {
419 case AacEncoderBitrateMode::AACENC_BR_MODE_VBR_1:
420 [[fallthrough]];
421 case AacEncoderBitrateMode::AACENC_BR_MODE_VBR_2:
422 [[fallthrough]];
423 case AacEncoderBitrateMode::AACENC_BR_MODE_VBR_3:
424 [[fallthrough]];
425 case AacEncoderBitrateMode::AACENC_BR_MODE_VBR_4:
426 [[fallthrough]];
427 case AacEncoderBitrateMode::AACENC_BR_MODE_VBR_5:
428 break;
429 default:
430 bitrate_mode =
431 static_cast<int64_t>(AacEncoderBitrateMode::AACENC_BR_MODE_VBR_5);
432 }
433 aac_param_value =
434 static_cast<uint8_t>(bitrate_mode) & ~A2DP_AAC_VARIABLE_BIT_RATE_MASK;
435 }
436 LOG_INFO("%s: AACENC_BITRATEMODE: %d", __func__, aac_param_value);
437 aac_error = aacEncoder_SetParam(a2dp_aac_encoder_cb.aac_handle,
438 AACENC_BITRATEMODE, aac_param_value);
439 if (aac_error != AACENC_OK) {
440 LOG_ERROR(
441 "%s: Cannot set AAC parameter AACENC_BITRATEMODE to %d: "
442 "AAC error 0x%x",
443 __func__, aac_param_value, aac_error);
444 return; // TODO: Return an error?
445 }
446
447 // Mark the end of setting the encoder's parameters
448 aac_error =
449 aacEncEncode(a2dp_aac_encoder_cb.aac_handle, NULL, NULL, NULL, NULL);
450 if (aac_error != AACENC_OK) {
451 LOG_ERROR("%s: Cannot complete setting the AAC parameters: AAC error 0x%x",
452 __func__, aac_error);
453 return; // TODO: Return an error?
454 }
455
456 // Retrieve the encoder info so we can save the frame length
457 AACENC_InfoStruct aac_info;
458 aac_error = aacEncInfo(a2dp_aac_encoder_cb.aac_handle, &aac_info);
459 if (aac_error != AACENC_OK) {
460 LOG_ERROR("%s: Cannot retrieve the AAC encoder info: AAC error 0x%x",
461 __func__, aac_error);
462 return; // TODO: Return an error?
463 }
464 p_encoder_params->frame_length = aac_info.frameLength;
465 p_encoder_params->input_channels_n = aac_info.inputChannels;
466 p_encoder_params->max_encoded_buffer_bytes = aac_info.maxOutBufBytes;
467 LOG_INFO(
468 "%s: AAC frame_length = %u input_channels_n = %u "
469 "max_encoded_buffer_bytes = %d",
470 __func__, p_encoder_params->frame_length,
471 p_encoder_params->input_channels_n,
472 p_encoder_params->max_encoded_buffer_bytes);
473
474 // After encoder params ready, reset the feeding state and its interval.
475 a2dp_aac_feeding_reset();
476 }
477
a2dp_aac_encoder_cleanup(void)478 void a2dp_aac_encoder_cleanup(void) {
479 if (a2dp_aac_encoder_cb.has_aac_handle)
480 aacEncClose(&a2dp_aac_encoder_cb.aac_handle);
481 memset(&a2dp_aac_encoder_cb, 0, sizeof(a2dp_aac_encoder_cb));
482 }
483
a2dp_aac_feeding_reset(void)484 void a2dp_aac_feeding_reset(void) {
485 auto frame_length = a2dp_aac_encoder_cb.aac_encoder_params.frame_length;
486 auto sample_rate = a2dp_aac_encoder_cb.feeding_params.sample_rate;
487 if (frame_length == 0 || sample_rate == 0) {
488 LOG_WARN("%s: AAC encoder is not configured", __func__);
489 a2dp_aac_encoder_interval_ms = A2DP_AAC_ENCODER_INTERVAL_MS;
490 } else {
491 // PCM data size per AAC frame (bits)
492 // = aac_encoder_params.frame_length * feeding_params.bits_per_sample
493 // * feeding_params.channel_count
494 // = feeding_params.sample_rate * feeding_params.bits_per_sample
495 // * feeding_params.channel_count * (T_interval_ms / 1000);
496 // Here we use the nearest integer not greater than the value.
497 a2dp_aac_encoder_interval_ms = frame_length * 1000 / sample_rate;
498 if (a2dp_aac_encoder_interval_ms < A2DP_AAC_ENCODER_INTERVAL_MS)
499 a2dp_aac_encoder_interval_ms = A2DP_AAC_ENCODER_INTERVAL_MS;
500 }
501
502 /* By default, just clear the entire state */
503 memset(&a2dp_aac_encoder_cb.aac_feeding_state, 0,
504 sizeof(a2dp_aac_encoder_cb.aac_feeding_state));
505
506 a2dp_aac_encoder_cb.aac_feeding_state.bytes_per_tick =
507 (a2dp_aac_encoder_cb.feeding_params.sample_rate *
508 a2dp_aac_encoder_cb.feeding_params.bits_per_sample / 8 *
509 a2dp_aac_encoder_cb.feeding_params.channel_count *
510 a2dp_aac_encoder_interval_ms) /
511 1000;
512
513 LOG_INFO("%s: PCM bytes %u per tick %u ms", __func__,
514 a2dp_aac_encoder_cb.aac_feeding_state.bytes_per_tick,
515 a2dp_aac_encoder_interval_ms);
516 }
517
a2dp_aac_feeding_flush(void)518 void a2dp_aac_feeding_flush(void) {
519 a2dp_aac_encoder_cb.aac_feeding_state.counter = 0.0f;
520 }
521
a2dp_aac_get_encoder_interval_ms(void)522 uint64_t a2dp_aac_get_encoder_interval_ms(void) {
523 return a2dp_aac_encoder_interval_ms;
524 }
525
a2dp_aac_send_frames(uint64_t timestamp_us)526 void a2dp_aac_send_frames(uint64_t timestamp_us) {
527 uint8_t nb_frame = 0;
528 uint8_t nb_iterations = 0;
529
530 a2dp_aac_get_num_frame_iteration(&nb_iterations, &nb_frame, timestamp_us);
531 LOG_VERBOSE("%s: Sending %d frames per iteration, %d iterations", __func__,
532 nb_frame, nb_iterations);
533 if (nb_frame == 0) return;
534
535 for (uint8_t counter = 0; counter < nb_iterations; counter++) {
536 // Transcode frame and enqueue
537 a2dp_aac_encode_frames(nb_frame);
538 }
539 }
540
541 // Obtains the number of frames to send and number of iterations
542 // to be used. |num_of_iterations| and |num_of_frames| parameters
543 // are used as output param for returning the respective values.
a2dp_aac_get_num_frame_iteration(uint8_t * num_of_iterations,uint8_t * num_of_frames,uint64_t timestamp_us)544 static void a2dp_aac_get_num_frame_iteration(uint8_t* num_of_iterations,
545 uint8_t* num_of_frames,
546 uint64_t timestamp_us) {
547 uint32_t result = 0;
548 uint8_t nof = 0;
549 uint8_t noi = 1;
550
551 uint32_t pcm_bytes_per_frame =
552 a2dp_aac_encoder_cb.aac_encoder_params.frame_length *
553 a2dp_aac_encoder_cb.feeding_params.channel_count *
554 a2dp_aac_encoder_cb.feeding_params.bits_per_sample / 8;
555 LOG_VERBOSE("%s: pcm_bytes_per_frame %u", __func__, pcm_bytes_per_frame);
556
557 uint32_t us_this_tick = a2dp_aac_encoder_interval_ms * 1000;
558 uint64_t now_us = timestamp_us;
559 if (a2dp_aac_encoder_cb.aac_feeding_state.last_frame_us != 0)
560 us_this_tick =
561 (now_us - a2dp_aac_encoder_cb.aac_feeding_state.last_frame_us);
562 a2dp_aac_encoder_cb.aac_feeding_state.last_frame_us = now_us;
563
564 a2dp_aac_encoder_cb.aac_feeding_state.counter +=
565 (float)a2dp_aac_encoder_cb.aac_feeding_state.bytes_per_tick *
566 us_this_tick / (a2dp_aac_encoder_interval_ms * 1000);
567
568 result = a2dp_aac_encoder_cb.aac_feeding_state.counter / pcm_bytes_per_frame;
569 a2dp_aac_encoder_cb.aac_feeding_state.counter -= result * pcm_bytes_per_frame;
570 nof = result;
571
572 LOG_VERBOSE("%s: effective num of frames %u, iterations %u", __func__, nof,
573 noi);
574
575 *num_of_frames = nof;
576 *num_of_iterations = noi;
577 }
578
a2dp_aac_encode_frames(uint8_t nb_frame)579 static void a2dp_aac_encode_frames(uint8_t nb_frame) {
580 tA2DP_AAC_ENCODER_PARAMS* p_encoder_params =
581 &a2dp_aac_encoder_cb.aac_encoder_params;
582 tA2DP_FEEDING_PARAMS* p_feeding_params = &a2dp_aac_encoder_cb.feeding_params;
583 uint8_t remain_nb_frame = nb_frame;
584 uint8_t read_buffer[BT_DEFAULT_BUFFER_SIZE];
585 int pcm_bytes_per_frame = p_encoder_params->frame_length *
586 p_feeding_params->channel_count *
587 p_feeding_params->bits_per_sample / 8;
588 CHECK(pcm_bytes_per_frame <= static_cast<int>(sizeof(read_buffer)));
589
590 // Setup the input buffer
591 AACENC_BufDesc in_buf_desc;
592 void* in_buf_vector[1] = {nullptr};
593 int in_buf_identifiers[1] = {IN_AUDIO_DATA};
594 int in_buf_sizes[1] = {pcm_bytes_per_frame};
595 int in_buf_element_sizes[1] = {p_feeding_params->bits_per_sample / 8};
596 in_buf_desc.numBufs = 1;
597 in_buf_desc.bufs = in_buf_vector;
598 in_buf_desc.bufferIdentifiers = in_buf_identifiers;
599 in_buf_desc.bufSizes = in_buf_sizes;
600 in_buf_desc.bufElSizes = in_buf_element_sizes;
601
602 // Setup the output buffer (partially)
603 AACENC_BufDesc out_buf_desc;
604 void* out_buf_vector[1] = {nullptr};
605 int out_buf_identifiers[1] = {OUT_BITSTREAM_DATA};
606 int out_buf_sizes[1] = {p_encoder_params->max_encoded_buffer_bytes};
607 // NOTE: out_buf_element_sizes below is probably unused by the encoder
608 int out_buf_element_sizes[1] = {p_feeding_params->bits_per_sample / 8};
609 out_buf_desc.numBufs = 1;
610 out_buf_desc.bufs = out_buf_vector;
611 out_buf_desc.bufferIdentifiers = out_buf_identifiers;
612 out_buf_desc.bufSizes = out_buf_sizes;
613 out_buf_desc.bufElSizes = out_buf_element_sizes;
614 CHECK(p_encoder_params->max_encoded_buffer_bytes <=
615 static_cast<int>(BT_DEFAULT_BUFFER_SIZE - sizeof(BT_HDR)));
616
617 AACENC_InArgs aac_in_args;
618 aac_in_args.numInSamples =
619 p_encoder_params->frame_length * p_feeding_params->channel_count;
620 aac_in_args.numAncBytes = 0;
621
622 AACENC_OutArgs aac_out_args = {
623 .numOutBytes = 0, .numInSamples = 0, .numAncBytes = 0};
624
625 uint32_t count;
626 uint32_t total_bytes_read = 0;
627 int written = 0;
628
629 while (nb_frame) {
630 BT_HDR* p_buf = (BT_HDR*)osi_malloc(BT_DEFAULT_BUFFER_SIZE);
631 p_buf->offset = A2DP_AAC_OFFSET;
632 p_buf->len = 0;
633 p_buf->layer_specific = 0;
634 a2dp_aac_encoder_cb.stats.media_read_total_expected_packets++;
635
636 count = 0;
637 do {
638 //
639 // Read the PCM data and encode it
640 //
641 uint32_t bytes_read = 0;
642 if (a2dp_aac_read_feeding(read_buffer, &bytes_read)) {
643 uint8_t* packet = (uint8_t*)(p_buf + 1) + p_buf->offset + p_buf->len;
644 if (!a2dp_aac_encoder_cb.has_aac_handle) {
645 LOG_ERROR("%s: invalid AAC handle", __func__);
646 a2dp_aac_encoder_cb.stats.media_read_total_dropped_packets++;
647 osi_free(p_buf);
648 return;
649 }
650 in_buf_vector[0] = read_buffer;
651 out_buf_vector[0] = packet + count;
652 AACENC_ERROR aac_error =
653 aacEncEncode(a2dp_aac_encoder_cb.aac_handle, &in_buf_desc,
654 &out_buf_desc, &aac_in_args, &aac_out_args);
655 if (aac_error != AACENC_OK) {
656 LOG_ERROR("%s: AAC encoding error: 0x%x", __func__, aac_error);
657 a2dp_aac_encoder_cb.stats.media_read_total_dropped_packets++;
658 osi_free(p_buf);
659 return;
660 }
661 written = aac_out_args.numOutBytes;
662 count += written;
663 p_buf->len += written;
664 nb_frame--;
665 p_buf->layer_specific++; // added a frame to the buffer
666 } else {
667 LOG_WARN("%s: underflow %d", __func__, nb_frame);
668 a2dp_aac_encoder_cb.aac_feeding_state.counter +=
669 nb_frame * p_encoder_params->frame_length *
670 p_feeding_params->channel_count *
671 p_feeding_params->bits_per_sample / 8;
672
673 // no more pcm to read
674 nb_frame = 0;
675 }
676 total_bytes_read += bytes_read;
677 } while ((written == 0) && nb_frame);
678
679 // NOTE: We don't check whether the packet will fit in the MTU,
680 // because AAC doesn't give us control over the encoded frame size.
681 // If the packet is larger than the MTU, it will be fragmented before
682 // transmission.
683 if (p_buf->len) {
684 /*
685 * Timestamp of the media packet header represent the TS of the
686 * first frame, i.e the timestamp before including this frame.
687 */
688 *((uint32_t*)(p_buf + 1)) = a2dp_aac_encoder_cb.timestamp;
689
690 a2dp_aac_encoder_cb.timestamp +=
691 p_buf->layer_specific * p_encoder_params->frame_length;
692
693 uint8_t done_nb_frame = remain_nb_frame - nb_frame;
694 remain_nb_frame = nb_frame;
695 if (!a2dp_aac_encoder_cb.enqueue_callback(p_buf, done_nb_frame,
696 total_bytes_read))
697 return;
698 } else {
699 a2dp_aac_encoder_cb.stats.media_read_total_dropped_packets++;
700 osi_free(p_buf);
701 }
702 }
703 }
704
a2dp_aac_read_feeding(uint8_t * read_buffer,uint32_t * bytes_read)705 static bool a2dp_aac_read_feeding(uint8_t* read_buffer, uint32_t* bytes_read) {
706 uint32_t read_size = a2dp_aac_encoder_cb.aac_encoder_params.frame_length *
707 a2dp_aac_encoder_cb.feeding_params.channel_count *
708 a2dp_aac_encoder_cb.feeding_params.bits_per_sample / 8;
709
710 a2dp_aac_encoder_cb.stats.media_read_total_expected_reads_count++;
711 a2dp_aac_encoder_cb.stats.media_read_total_expected_read_bytes += read_size;
712
713 /* Read Data from UIPC channel */
714 uint32_t nb_byte_read =
715 a2dp_aac_encoder_cb.read_callback(read_buffer, read_size);
716 a2dp_aac_encoder_cb.stats.media_read_total_actual_read_bytes += nb_byte_read;
717 *bytes_read = nb_byte_read;
718
719 if (nb_byte_read < read_size) {
720 if (nb_byte_read == 0) return false;
721
722 /* Fill the unfilled part of the read buffer with silence (0) */
723 memset(((uint8_t*)read_buffer) + nb_byte_read, 0, read_size - nb_byte_read);
724 nb_byte_read = read_size;
725 }
726 a2dp_aac_encoder_cb.stats.media_read_total_actual_reads_count++;
727
728 return true;
729 }
730
encoderIntervalMs() const731 uint64_t A2dpCodecConfigAacSource::encoderIntervalMs() const {
732 return a2dp_aac_get_encoder_interval_ms();
733 }
734
getEffectiveMtu() const735 int A2dpCodecConfigAacSource::getEffectiveMtu() const {
736 return a2dp_aac_encoder_cb.TxAaMtuSize;
737 }
738
debug_codec_dump(int fd)739 void A2dpCodecConfigAacSource::debug_codec_dump(int fd) {
740 a2dp_aac_encoder_stats_t* stats = &a2dp_aac_encoder_cb.stats;
741
742 A2dpCodecConfig::debug_codec_dump(fd);
743
744 auto codec_specific_1 = getCodecConfig().codec_specific_1;
745 dprintf(
746 fd,
747 " AAC bitrate mode : %s "
748 "(0x%" PRIx64 ")\n",
749 ((codec_specific_1 & ~A2DP_AAC_VARIABLE_BIT_RATE_MASK) == 0 ? "Constant"
750 : "Variable"),
751 codec_specific_1);
752 dprintf(fd,
753 " Packet counts (expected/dropped) : %zu / "
754 "%zu\n",
755 stats->media_read_total_expected_packets,
756 stats->media_read_total_dropped_packets);
757
758 dprintf(fd,
759 " PCM read counts (expected/actual) : %zu / "
760 "%zu\n",
761 stats->media_read_total_expected_reads_count,
762 stats->media_read_total_actual_reads_count);
763
764 dprintf(fd,
765 " PCM read bytes (expected/actual) : %zu / "
766 "%zu\n",
767 stats->media_read_total_expected_read_bytes,
768 stats->media_read_total_actual_read_bytes);
769 }
770