1 /****************************************************************************** 2 * 3 * Copyright 2016 The Android Open Source Project 4 * Copyright 2009-2012 Broadcom Corporation 5 * 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at: 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 * 18 ******************************************************************************/ 19 20 #ifndef BTIF_A2DP_SINK_H 21 #define BTIF_A2DP_SINK_H 22 23 #include <bluetooth/log.h> 24 25 #include <cstdint> 26 #include <future> 27 28 #include "audio_a2dp_hw/include/audio_a2dp_hw.h" 29 #include "bta/include/bta_av_api.h" 30 #include "stack/include/bt_hdr.h" 31 #include "types/raw_address.h" 32 33 // 34 // Audio focus state for audio track. 35 // 36 // NOTE: The values must be same as: 37 // - A2dpSinkStreamingStateMachine.STATE_FOCUS_LOST = 0 38 // - A2dpSinkStreamingStateMachine.STATE_FOCUS_GRANTED = 1 39 // 40 typedef enum { 41 BTIF_A2DP_SINK_FOCUS_NOT_GRANTED = 0, 42 BTIF_A2DP_SINK_FOCUS_GRANTED = 1 43 } btif_a2dp_sink_focus_state_t; 44 45 // Initialize the A2DP Sink module. 46 // This function should be called by the BTIF state machine prior to using the 47 // module. 48 bool btif_a2dp_sink_init(void); 49 50 // Startup the A2DP Sink module. 51 // This function should be called by the BTIF state machine after 52 // btif_a2dp_sink_init() to prepare for receiving and processing audio 53 // streaming. 54 bool btif_a2dp_sink_startup(void); 55 56 // Start the A2DP Sink session. 57 // This function should be called by the BTIF state machine after 58 // btif_a2dp_sink_startup() to start the streaming session for |peer_address|. 59 bool btif_a2dp_sink_start_session(const RawAddress& peer_address, 60 std::promise<void> peer_ready_promise); 61 62 // Restart the A2DP Sink session. 63 // This function should be called by the BTIF state machine after 64 // btif_a2dp_sink_startup() to restart the streaming session. 65 // |old_peer_address| is the peer address of the old session. This address 66 // can be empty. 67 // |new_peer_address| is the peer address of the new session. This address 68 // cannot be empty. 69 bool btif_a2dp_sink_restart_session(const RawAddress& old_peer_address, 70 const RawAddress& new_peer_address, 71 std::promise<void> peer_ready_promise); 72 73 // End the A2DP Sink session. 74 // This function should be called by the BTIF state machine to end the 75 // streaming session for |peer_address|. 76 bool btif_a2dp_sink_end_session(const RawAddress& peer_address); 77 78 // Shutdown the A2DP Sink module. 79 // This function should be called by the BTIF state machine before 80 // btif_a2dp_sink_cleanup() to shutdown the processing of the audio streaming. 81 void btif_a2dp_sink_shutdown(void); 82 83 // Cleanup the A2DP Sink module. 84 // This function should be called by the BTIF state machine during graceful 85 // cleanup. 86 void btif_a2dp_sink_cleanup(void); 87 88 // Get the audio sample rate for the A2DP Sink module. 89 tA2DP_SAMPLE_RATE btif_a2dp_sink_get_sample_rate(void); 90 91 // Get the audio channel count for the A2DP Sink module. 92 tA2DP_CHANNEL_COUNT btif_a2dp_sink_get_channel_count(void); 93 94 // Get the audio bits per sample for the A2DP Sink module. 95 tA2DP_BITS_PER_SAMPLE btif_a2dp_sink_get_bits_per_sample(void); 96 97 // Update the decoder for the A2DP Sink module. 98 // |p_codec_info| contains the new codec information. 99 void btif_a2dp_sink_update_decoder(const uint8_t* p_codec_info); 100 101 // Process 'idle' request from the BTIF state machine during initialization. 102 void btif_a2dp_sink_on_idle(void); 103 104 // Process 'stop' request from the BTIF state machine to stop A2DP streaming. 105 // |p_av_suspend| is the data associated with the request - see 106 // |tBTA_AV_SUSPEND|. 107 void btif_a2dp_sink_on_stopped(tBTA_AV_SUSPEND* p_av_suspend); 108 109 // Process 'suspend' request from the BTIF state machine to suspend A2DP 110 // streaming. 111 // |p_av_suspend| is the data associated with the request - see 112 // |tBTA_AV_SUSPEND|. 113 void btif_a2dp_sink_on_suspended(tBTA_AV_SUSPEND* p_av_suspend); 114 115 // Start the decoder for the A2DP Sink module. 116 bool btif_a2dp_sink_on_start(void); 117 118 // Enable/disable discarding of received A2DP frames. 119 // If |enable| is true, the discarding is enabled, otherwise is disabled. 120 void btif_a2dp_sink_set_rx_flush(bool enable); 121 122 // Enqueue a buffer to the A2DP Sink queue. If the queue has reached its 123 // maximum size |MAX_INPUT_A2DP_FRAME_QUEUE_SZ|, the oldest buffer is 124 // removed from the queue. 125 // |p_buf| is the buffer to enqueue. 126 // Returns the number of buffers in the Sink queue after the enqueing. 127 uint8_t btif_a2dp_sink_enqueue_buf(BT_HDR* p_buf); 128 129 // Dump debug-related information for the A2DP Sink module. 130 // |fd| is the file descriptor to use for writing the ASCII formatted 131 // information. 132 void btif_a2dp_sink_debug_dump(int fd); 133 134 // Create a request to set the audio focus state for the audio track. 135 // |state| is the new state value - see |btif_a2dp_sink_focus_state_t| 136 // for valid values. 137 void btif_a2dp_sink_set_focus_state_req(btif_a2dp_sink_focus_state_t state); 138 139 // Set the audio track gain for the audio track. 140 // |gain| is the audio track gain value to use. 141 void btif_a2dp_sink_set_audio_track_gain(float gain); 142 143 // Get audio track handle 144 void * btif_a2dp_sink_get_audio_track(void); 145 146 namespace fmt { 147 template <> 148 struct formatter<btif_a2dp_sink_focus_state_t> 149 : enum_formatter<btif_a2dp_sink_focus_state_t> {}; 150 } // namespace fmt 151 152 #endif /* BTIF_A2DP_SINK_H */ 153