Audio Stream
.h
class Audio
Device;
typedef unsigned
int app_type_t;
class StreamPrimary {
public:
StreamPrimary(audio_io_handle_t handle,
const std::set<audio_
devices_t> &
devices,
struct audio_config *config);
virtual ~StreamPrimary();
u
int32_t GetSampleRate();
u
int32_t GetBufferSize();
audio_format_t GetFormat();
audio_channel_mask_t GetChannelMask();
int getPal
DeviceIds(const std::set<audio_
devices_t> &hal
DeviceIds, pal_
device_id_t* palOut
DeviceIds);
audio_io_handle_t GetHandle();
int GetUseCase();
std::mutex write_wait_mutex_;
std::condition_variable write_condition_;
std::mutex stream_mutex_;
bool write_ready_;
std::mutex dra
in_wait_mutex_;
std::condition_variable dra
in_condition_;
bool dra
in_ready_;
stream_callback_t client_callback;
void *client_cookie;
static
int Get
DeviceAddress(struct str_parms *parms,
int *card_id,
int *
device_num);
int GetLookupTable
Index(const struct str
ing_
to_enum *table,
const
int table_size,
int value);
bool GetSupportedConfig(bool isOutStream,
struct str_parms *query, struct str_parms *reply);
virtual int RouteStream(const std::set<audio_
devices_t>&, bool force_
device_switch = false) = 0;
bool is
Started() { return stream_
started_; };
protected:
struct pal_stream_attributes streamAttributes_;
pal_stream_handle_t* pal_stream_handle_;
audio_io_handle_t handle_;
pal_
device_id_t pal_
device_id_;
struct audio_config config_;
char
address_[AUDIO_
DEVICE_MAX_
ADDRESS_LEN];
bool stream_
started_ = false;
bool stream_paused_ = false;
bool stream_flushed_ = false;
int usecase_;
struct pal_volume_data *volume_; /* used
to cache volume */
std::map <audio_
devices_t, pal_
device_id_t> mAndroid
DeviceMap;
int mmap_shared_memory_fd;
app_type_t app_types_;
pal_param_
device_capability_t *
device_cap_query_;
app_type_t audio_power_app_types_;/* Audio PowerSave */
};
class StreamOutPrimary : public StreamPrimary {
private:
// Helper function for write
to open pal stream & configure
.
ssize_t configurePalOutputStream();
//Helper method
to standby streams upon write failures and sleep for buffer duration
.
ssize_t onWriteError(size_t bytes, ssize_t ret);
protected:
struct pal_
device* mPalOut
Device;
private:
pal_
device_id_t* mPalOut
DeviceIds;
std::set<audio_
devices_t> mAndroidOut
Devices;
bool m
Initialized;
/* fixed ear_out aux_out stereo
start */
bool mIsKaraokeMuteOnCombo;
/* fixed ear_out aux_out stereo end */
// [offload playspeed
bool isOffloadUsecase() { return GetUseCase() == USECASE_AUDIO_PLAYBACK_OFFLOAD; }
bool isOffloadSpeedSupported();
bool isValidPlaybackRate(const audio_playback_rate_t *playbackRate);
bool isValidStretchMode(audio_timestretch_stretch_mode_t stretchMode);
bool isValidFallbackMode(audio_timestretch_fallback_mode_t fallbackMode);
int setPlaybackRate
ToPal(const audio_playback_rate_t *playbackRate);
audio_playback_rate_t mPlaybackRate = AUDIO_PLAYBACK_RATE_
INITIALIZER;
// offload Playspeed]
public:
StreamOutPrimary(audio_io_handle_t handle,
const std::set<audio_
devices_t>&
devices,
audio_output_flags_t flags,
struct audio_config *config,
const char *
address,
offload_effects_
start_output fnp_
start_offload_effect,
offload_effects_s
top_output fnp_s
top_offload_effect,
visualizer_hal_
start_output fnp_visualizer_
start_output_,
visualizer_hal_s
top_output fnp_visualizer_s
top_output_);
~StreamOutPrimary();
bool sendGaplessMetadata = true;
bool isCompressMetadataAvail = false;
void UpdatemCachedPosition(u
int64_t val);
virtual int Standby();
int SetVolume(float left, float right);
int refac
torVolumeData(float left, float right);
u
int64_t GetFramesWritten(struct timespec *timestamp);
virtual int SetParameters(struct str_parms *parms);
int Pause();
int Resume();
int Dra
in(audio_dra
in_type_t type);
int Flush();
virtual int
Start();
int S
top();
virtual ssize_t write(const void *buffer, size_t bytes);
virtual int Open();
void GetStreamHandle(audio_stream_out** stream);
u
int32_t GetBufferSize();
u
int32_t GetBufferSizeForLowLatency();
int GetFrames(u
int64_t *frames);
static pal_stream_type_t GetPalStreamType(audio_output_flags_t halStreamFlags,
u
int32_t sample_rate,
bool is
DeviceAvail);
static
int64_t GetRenderLatency(audio_output_flags_t halStreamFlags);
int Ge
tOutputUseCase(audio_output_flags_t halStreamFlags);
int
StartOffloadEffects(audio_io_handle_t, pal_stream_handle_t*);
int S
topOffloadEffects(audio_io_handle_t, pal_stream_handle_t*);
bool CheckOffloadEffectsType(pal_stream_type_t pal_stream_type);
int
StartOffloadVisualizer(audio_io_handle_t, pal_stream_handle_t*);
int S
topOffloadVisualizer(audio_io_handle_t, pal_stream_handle_t*);
audio_output_flags_t flags_;
int CreateMmapBuffer(
int32_t m
in_size_frames, struct audio_mmap_buffer_
info *
info);
int GetMmapPosition(struct audio_mmap_position *position);
bool is
DeviceAvailable(pal_
device_id_t
deviceId);
int RouteStream(const std::set<audio_
devices_t>&, bool force_
device_switch = false);
virtual void SetMode(audio_mode_t mode) = 0;
ssize_t splitAndWriteAudioHapticsStream(const void *buffer, size_t bytes);
bool period_size_is_plausible_for_low_latency(
int period_size);
source_metadata_t btSourceMetadata;
std::vec
tor<playback_track_metadata_t> tracks;
int SetAggregateSourceMetadata(bool voice_active);
static std::mutex sourceMetadata_mutex_;
// [offload playback speed
int getPlaybackRateParameters(audio_playback_rate_t *playbackRate);
int setPlaybackRateParameters(const audio_playback_rate_t *playbackRate);
// offload playback speed]
protected:
struct timespec writeAt;
int get_compressed_buffer_size();
int get_pcm_buffer_size();
int is_direct();
audio_format_t hal
InputFormat = AUDIO_FORMAT_DEFAULT;
audio_format_t halOutputFormat = AUDIO_FORMAT_DEFAULT;
u
int32_t convertBufSize;
u
int32_t fragments_ = 0;
u
int32_t fragment_size_ = 0;
pal_snd_dec_t palSndDec;
struct pal_compr_gapless_mdata gaplessMeta = {0, 0};
u
int32_t msample_rate;
u
int16_t mchannels;
std::shared_ptr<audio_stream_out> stream_;
u
int64_t mBytesWritten; /*
total bytes written,
not cleared when enter
ing standby */
u
int64_t mCachedPosition = 0; /* cache pcm offload position when enter
ing standby */
offload_effects_
start_output fnp_offload_effect_
start_output_ = nullptr;
offload_effects_s
top_output fnp_offload_effect_s
top_output_ = nullptr;
visualizer_hal_
start_output fnp_visualizer_
start_output_ = nullptr;
visualizer_hal_s
top_output fnp_visualizer_s
top_output_ = nullptr;
void *convertBuffer;
//Haptics Usecase
struct pal_stream_attributes hapticsStreamAttributes;
pal_stream_handle_t* pal_haptics_stream_handle;
AudioExtn AudExtn;
struct pal_
device* haptics
Device;
u
int8_t* hapticBuffer;
size_t hapticsBufSize;
audio_mode_t _mode;
int FillHalFnPtrs();
friend class Audio
Device;
struct timespec ts_first_write = {0, 0};
};
class Stream
InPrimary : public StreamPrimary{
protected:
struct pal_
device* mPal
InDevice;
private:
pal_
device_id_t* mPal
InDeviceIds;
std::set<audio_
devices_t> mAndroid
InDevices;
bool m
Initialized;
//Helper method
to standby streams upon read failures and sleep for buffer duration
.
ssize_t onReadError(size_t bytes, size_t ret);
public:
Stream
InPrimary(audio_io_handle_t handle,
const std::set<audio_
devices_t> &
devices,
audio_
input_flags_t flags,
struct audio_config *config,
const char *
address,
audio_source_t source);
~Stream
InPrimary();
int Standby();
int SetGa
in(float ga
in);
void GetStreamHandle(audio_stream_
in** stream);
virtual int Open();
int
Start();
int S
top();
int SetMicMute(bool mute);
ssize_t read(const void *buffer, size_t bytes);
u
int32_t GetBufferSize();
u
int32_t GetBufferSizeForLowLatencyRecord();
pal_stream_type_t GetPalStreamType(audio_
input_flags_t halStreamFlags,
u
int32_t sample_rate);
int Get
InputUseCase(audio_
input_flags_t halStreamFlags, audio_source_t source);
int addRemoveAudioEffect(const struct audio_stream *stream, effect_handle_t effect,bool enable);
virtual int SetParameters(const char *kvpairs);
bool getParameters(struct str_parms *query, struct str_parms *reply);
bool is_st_session;
audio_
input_flags_t flags_;
int CreateMmapBuffer(
int32_t m
in_size_frames, struct audio_mmap_buffer_
info *
info);
int GetMmapPosition(struct audio_mmap_position *position);
bool is
DeviceAvailable(pal_
device_id_t
deviceId);
int RouteStream(const std::set<audio_
devices_t>& new_
devices, bool force_
device_switch = false);
int64_t GetSourceLatency(audio_
input_flags_t halStreamFlags);
u
int64_t GetFramesRead(
int64_t *time);
int GetPal
DeviceIds(pal_
device_id_t *palDevIds,
int *numPalDevs);
s
ink_metadata_t btS
inkMetadata;
std::vec
tor<record_track_metadata_t> tracks;
int SetAggregateS
inkMetadata(bool voice_active);
static std::mutex s
inkMetadata_mutex_;
pal_stream_handle_t *pal_vui_handle_;
protected:
struct timespec readAt;
u
int32_t fragments_ = 0;
u
int32_t fragment_size_ = 0;
int FillHalFnPtrs();
std::shared_ptr<audio_stream_
in> stream_;
audio_source_t source_;
friend class Audio
Device;
u
int64_t mBytesRead = 0; /*
total bytes read,
not cleared when enter
ing standby */
// for compress capture usecase
std::unique_ptr<CompressCapture::CompressAAC> mCompressEncoder;
bool isECEnabled = false;
bool isNSEnabled = false;
bool effects_applied_ = true;
//ADD: KARAOKE
bool is_karaoke_on = false;
int is_karaoke_status = 0;
bool is_cts_stream = false;
std::mutex activeStreamMutex;
//END KARAOKE
// MIUI ADD: Audio_XiaoAi
bool is_map_switch = false;
// END Audio_XiaoAi
};
AudioStream
.cpp
int StreamOutPrimary::Standby() {
int ret = 0;
/* fixed ear_out aux_out stereo
start */
std::shared_ptr<Audio
Device> a
device = Audio
Device::Get
Instance();
std::set<audio_
devices_t> new_
devices;
/* fixed ear_out aux_out stereo end */
AHAL_DBG("Enter");
if (a
device->is_earout_hphl_conflict && mIsKaraokeMuteOnCombo) {
AHAL_DBG("routestream from combo whs
to whs before standby");
mAndroidOut
Devices
.erase(AUDIO_
DEVICE_OUT_SPEAKER);
new_
devices = mAndroidOut
Devices;
StreamOutPrimary::RouteStream(new_
devices, true);
}
stream_mutex_
.lock();
if (pal_stream_handle_) {
if (streamAttributes_
.type == PAL_STREAM_PCM_OFFLOAD) {
/*
* when ssr happens, dsp position for pcm offload could be 0,
* so get written frames
. Else, get frames
.
*/
if (PAL_CARD_STATUS_DOWN(Audio
Device::sndCardState)) {
struct timespec ts;
// release stream lock as GetFramesWritten will lock/unlock stream mutex
stream_mutex_
.unlock();
mCachedPosition = GetFramesWritten(&ts);
stream_mutex_
.lock();
AHAL_DBG("card is offl
ine, return written frames %lld", (long long)mCachedPosition);
} else {
GetFrames(&mCachedPosition);
}
}
ret = pal_stream_s
top(pal_stream_handle_);
if (ret) {
AHAL_ERR("failed
to s
top stream
.");
ret = -E
INVAL;
}
if (usecase_ == USECASE_AUDIO_PLAYBACK_WITH_HAPTICS && pal_haptics_stream_handle) {
ret = pal_stream_s
top(pal_haptics_stream_handle);
if (ret) {
AHAL_ERR("failed
to s
top haptics stream
.");
}
}
}
ret = -E
INVAL;
exit:
stream_mutex_
.unlock();
AHAL_DBG("Exit ret: %d", ret);
return ret;
}
StreamOutPrimary::StreamOutPrimary(
audio_io_handle_t handle,
const std::set<audio_
devices_t> &
devices,
audio_output_flags_t flags,
struct audio_config *config,
const char *
address __unused,
offload_effects_
start_output
start_offload_effect,
offload_effects_s
top_output s
top_offload_effect,
visualizer_hal_
start_output visualizer_
start_output,
visualizer_hal_s
top_output visualizer_s
top_output):
StreamPrimary(handle,
devices, config),
mAndroidOut
Devices(
devices),
flags_(flags),
btSourceMetadata{0, nullptr}
{
stream_ = std::shared_ptr<audio_stream_out> (new audio_stream_out());
std::shared_ptr<Audio
Device> a
device = Audio
Device::Get
Instance();
m
Initialized = false;
/* fixed ear_out aux_out stereo
start */
mIsKaraokeMuteOnCombo = false;
bool isCombo = false;
audio_
devices_t Out
Devices = AudioExtn::get_
device_types(mAndroidOut
Devices);
/* fixed ear_out aux_out stereo end */
pal_stream_handle_ = nullptr;
pal_haptics_stream_handle = nullptr;
mPalOut
DeviceIds = nullptr;
mPalOut
Device = nullptr;
convertBuffer = NULL;
haptics
Device = NULL;
hapticBuffer = NULL;
hapticsBufSize = 0;
writeAt
.tv_sec = 0;
writeAt
.tv_nsec = 0;
mBytesWritten = 0;
int
noPal
Devices = 0;
int ret = 0;
/*
Initialize
the gaplessMeta value with 0*/
memset(&gaplessMeta,0,sizeof(struct pal_compr_gapless_mdata));
if (!stream_) {
AHAL_ERR("
No memory allocated for stream_");
throw std::runtime_error("
No memory allocated for stream_");
}
AHAL_DBG("enter: handle (%x) format(%#x) sample_rate(%d) channel_mask(%#x)
devices(%zu) flags(%#x)\
address(%s)", handle, config->format, config->sample_rate, config->channel_mask,
mAndroidOut
Devices
.size(), flags,
address);
return;
}
Stream
InPrimary::Stream
InPrimary(audio_io_handle_t handle,
const std::set<audio_
devices_t> &
devices,
audio_
input_flags_t flags,
struct audio_config *config,
const char *
address __unused,
audio_source_t source) :
StreamPrimary(handle,
devices, config),
mAndroid
InDevices(
devices),
flags_(flags),
btS
inkMetadata{0, nullptr},
pal_vui_handle_(nullptr),
mCompressEncoder(nullptr)
{
stream_ = std::shared_ptr<audio_stream_
in> (new audio_stream_
in());
std::shared_ptr<Audio
Device> a
device = Audio
Device::Get
Instance();
pal_stream_handle_ = NULL;
m
Initialized = false;
int
noPal
Devices = 0;
int ret = 0;
readAt
.tv_sec = 0;
readAt
.tv_nsec = 0;
void *st_handle = nullptr;
pal_param_payload *payload = nullptr;
AHAL_DBG("enter: handle (%x) format(%#x) sample_rate(%d) channel_mask(%#x)
devices(%zu) flags(%#x)"\
, handle, config->format, config->sample_rate, config->channel_mask,
mAndroid
InDevices
.size(), flags);
if (!(stream_
.get())) {
AHAL_ERR("stream_ new allocation failed");
goto error;
}
error:
(void)FillHalFnPtrs();
AHAL_DBG("Exit");
return;
}
audio_format_t StreamPrimary::GetFormat() {
return config_
.format;
}
static audio_format_t astream_
in_get_format(const struct audio_stream *stream) {
std::shared_ptr<Audio
Device> a
device = Audio
Device::Get
Instance();
std::shared_ptr<Stream
InPrimary> astream_
in;
if (a
device)
astream_
in = a
device->
InGetStream((audio_stream_t*)stream);
else
AHAL_ERR("
unable to get audio
device");
if (astream_
in)
return astream_
in->GetFormat();
else
return AUDIO_FORMAT_DEFAULT;
}
请分析上面的代码修改，修改实现在
int StreamOutPrimary::Standby() 获取is_karaoke_status的值用于判断
本文记录了一次解决Genymotion启动失败的问题经历。作者在尝试启动Genymotion时遇到了未知错误，在尝试多种方法无效后，最终在网友的帮助下找到了解决方案。疑似错误由前一天更新声卡驱动引起。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
442
