gugelfrei
/
android_frameworks_av
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

API changes in MicrophoneDirection

Browse Source 
Bug: 128523813
Test: Build, Testbed app

Change-Id: I7b5ee8ba4eec1090866d8aef891a98d50cd09cc5
gugelfrei
Paul McLean 5 years ago
parent 60c73a445b
commit 1234008771
24 changed files with 104 additions and 97 deletions
Show Stats Download Patch File Download Diff File

12
media/libaudioclient/AudioRecord.cpp
Unescape View File

@ -410,8 +410,8 @@ status_t AudioRecord::start(AudioSystem::sync_event_t event, audio_session_t tri
}
// Call these directly because we are already holding the lock.
mAudioRecord->setMicrophoneDirection(mSelectedMicDirection);
mAudioRecord->setMicrophoneFieldDimension(mSelectedMicFieldDimension);
mAudioRecord->setPreferredMicrophoneDirection(mSelectedMicDirection);
mAudioRecord->setPreferredMicrophoneFieldDimension(mSelectedMicFieldDimension);
if (status != NO_ERROR) {
mActive = false;
@ -1381,7 +1381,7 @@ status_t AudioRecord::getActiveMicrophones(std::vector<media::MicrophoneInfo>* a
return mAudioRecord->getActiveMicrophones(activeMicrophones).transactionError();
}
status_t AudioRecord::setMicrophoneDirection(audio_microphone_direction_t direction)
status_t AudioRecord::setPreferredMicrophoneDirection(audio_microphone_direction_t direction)
{
AutoMutex lock(mLock);
if (mSelectedMicDirection == direction) {
@ -1394,11 +1394,11 @@ status_t AudioRecord::setMicrophoneDirection(audio_microphone_direction_t direct
// the internal AudioRecord hasn't be created yet, so just stash the attribute.
return OK;
} else {
return mAudioRecord->setMicrophoneDirection(direction).transactionError();
return mAudioRecord->setPreferredMicrophoneDirection(direction).transactionError();
}
}
status_t AudioRecord::setMicrophoneFieldDimension(float zoom) {
status_t AudioRecord::setPreferredMicrophoneFieldDimension(float zoom) {
AutoMutex lock(mLock);
if (mSelectedMicFieldDimension == zoom) {
// NOP
@ -1410,7 +1410,7 @@ status_t AudioRecord::setMicrophoneFieldDimension(float zoom) {
// the internal AudioRecord hasn't be created yet, so just stash the attribute.
return OK;
} else {
return mAudioRecord->setMicrophoneFieldDimension(zoom).transactionError();
return mAudioRecord->setPreferredMicrophoneFieldDimension(zoom).transactionError();
}
}

4
media/libaudioclient/aidl/android/media/IAudioRecord.aidl
Unescape View File

@ -39,9 +39,9 @@ interface IAudioRecord {
/* Set the microphone direction (for processing).
*/
void setMicrophoneDirection(int /*audio_microphone_direction_t*/ direction);
void setPreferredMicrophoneDirection(int /*audio_microphone_direction_t*/ direction);
/* Set the microphone zoom (for processing).
*/
void setMicrophoneFieldDimension(float zoom);
void setPreferredMicrophoneFieldDimension(float zoom);
}

4
media/libaudioclient/include/media/AudioRecord.h
Unescape View File

@ -542,11 +542,11 @@ public:
/* Set the Microphone direction (for processing purposes).
*/
status_t setMicrophoneDirection(audio_microphone_direction_t direction);
status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
/* Set the Microphone zoom factor (for processing purposes).
*/
status_t setMicrophoneFieldDimension(float zoom);
status_t setPreferredMicrophoneFieldDimension(float zoom);
/* Get the unique port ID assigned to this AudioRecord instance by audio policy manager.
* The ID is unique across all audioserver clients and can change during the life cycle

15
media/libaudiohal/impl/StreamHalHidl.cpp
Unescape View File

@ -855,25 +855,26 @@ status_t StreamInHalHidl::updateSinkMetadata(const
#endif
#if MAJOR_VERSION < 5
status_t StreamInHalHidl::setMicrophoneDirection(audio_microphone_direction_t direction __unused) {
status_t StreamInHalHidl::setPreferredMicrophoneDirection(
audio_microphone_direction_t direction __unused) {
if (mStream == 0) return NO_INIT;
return INVALID_OPERATION;
}
status_t StreamInHalHidl::setMicrophoneFieldDimension(float zoom __unused) {
status_t StreamInHalHidl::setPreferredMicrophoneFieldDimension(float zoom __unused) {
if (mStream == 0) return NO_INIT;
return INVALID_OPERATION;
}
#else
status_t StreamInHalHidl::setMicrophoneDirection(audio_microphone_direction_t direction) {
status_t StreamInHalHidl::setPreferredMicrophoneDirection(audio_microphone_direction_t direction) {
if (!mStream) return NO_INIT;
return processReturn("setMicrophoneDirection",
mStream->setMicrophoneDirection(static_cast<MicrophoneDirection>(direction)));
return processReturn("setPreferredMicrophoneDirection",
mStream->setMicrophoneDirection(static_cast<MicrophoneDirection>(direction)));
}
status_t StreamInHalHidl::setMicrophoneFieldDimension(float zoom) {
status_t StreamInHalHidl::setPreferredMicrophoneFieldDimension(float zoom) {
if (!mStream) return NO_INIT;
return processReturn("setMicrophoneFieldDimension",
return processReturn("setPreferredMicrophoneFieldDimension",
mStream->setMicrophoneFieldDimension(zoom));
}
#endif

5
media/libaudiohal/impl/StreamHalHidl.h
Unescape View File

@ -221,10 +221,11 @@ class StreamInHalHidl : public StreamInHalInterface, public StreamHalHidl {
virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfo> *microphones);
// Set microphone direction (for processing)
virtual status_t setMicrophoneDirection(audio_microphone_direction_t direction) override;
virtual status_t setPreferredMicrophoneDirection(
audio_microphone_direction_t direction) override;
// Set microphone zoom (for processing)
virtual status_t setMicrophoneFieldDimension(float zoom) override;
virtual status_t setPreferredMicrophoneFieldDimension(float zoom) override;
// Called when the metadata of the stream's sink has been changed.
status_t updateSinkMetadata(const SinkMetadata& sinkMetadata) override;

11
media/libaudiohal/impl/StreamHalLocal.cpp
Unescape View File

@ -369,20 +369,21 @@ status_t StreamInHalLocal::getActiveMicrophones(std::vector<media::MicrophoneInf
#endif
#if MAJOR_VERSION < 5
status_t StreamInHalLocal::setMicrophoneDirection(audio_microphone_direction_t direction __unused) {
status_t StreamInHalLocal::setPreferredMicrophoneDirection(
audio_microphone_direction_t direction __unused) {
return INVALID_OPERATION;
}
status_t StreamInHalLocal::setMicrophoneFieldDimension(float zoom __unused) {
status_t StreamInHalLocal::setPreferredMicrophoneFieldDimension(float zoom __unused) {
return INVALID_OPERATION;
}
#else
status_t StreamInHalLocal::setMicrophoneDirection(audio_microphone_direction_t direction) {
status_t StreamInHalLocal::setPreferredMicrophoneDirection(audio_microphone_direction_t direction) {
if (mStream->set_microphone_direction == NULL) return INVALID_OPERATION;
return mStream->set_microphone_direction(mStream, direction);
}
status_t StreamInHalLocal::setMicrophoneFieldDimension(float zoom) {
status_t StreamInHalLocal::setPreferredMicrophoneFieldDimension(float zoom) {
if (mStream->set_microphone_field_dimension == NULL) return INVALID_OPERATION;
return mStream->set_microphone_field_dimension(mStream, zoom);
@ -391,3 +392,5 @@ status_t StreamInHalLocal::setMicrophoneFieldDimension(float zoom) {
} // namespace CPP_VERSION
} // namespace android

4
media/libaudiohal/impl/StreamHalLocal.h
Unescape View File

@ -205,10 +205,10 @@ class StreamInHalLocal : public StreamInHalInterface, public StreamHalLocal {
virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfo> *microphones);
// Sets microphone direction (for processing)
virtual status_t setMicrophoneDirection(audio_microphone_direction_t direction);
virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
// Sets microphone zoom (for processing)
virtual status_t setMicrophoneFieldDimension(float zoom);
virtual status_t setPreferredMicrophoneFieldDimension(float zoom);
// Called when the metadata of the stream's sink has been changed.
status_t updateSinkMetadata(const SinkMetadata& sinkMetadata) override;

4
media/libaudiohal/include/media/audiohal/StreamHalInterface.h
Unescape View File

@ -180,10 +180,10 @@ class StreamInHalInterface : public virtual StreamHalInterface {
virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfo> *microphones) = 0;
// Set direction for capture processing
virtual status_t setMicrophoneDirection(audio_microphone_direction_t) = 0;
virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t) = 0;
// Set zoom factor for capture stream
virtual status_t setMicrophoneFieldDimension(float zoom) = 0;
virtual status_t setPreferredMicrophoneFieldDimension(float zoom) = 0;
struct SinkMetadata {
std::vector<record_track_metadata_t> tracks;

28
media/libmedia/IMediaRecorder.cpp
Unescape View File

@ -66,8 +66,8 @@ enum {
ENABLE_AUDIO_DEVICE_CALLBACK,
GET_ACTIVE_MICROPHONES,
GET_PORT_ID,
SET_MICROPHONE_DIRECTION,
SET_MICROPHONE_FIELD_DIMENSION
SET_PREFERRED_MICROPHONE_DIRECTION,
SET_PREFERRED_MICROPHONE_FIELD_DIMENSION
};
class BpMediaRecorder: public BpInterface<IMediaRecorder>
@ -409,21 +409,21 @@ public:
return status;
}
status_t setMicrophoneDirection(audio_microphone_direction_t direction) {
ALOGV("setMicrophoneDirection(%d)", direction);
status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction) {
ALOGV("setPreferredMicrophoneDirection(%d)", direction);
Parcel data, reply;
data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
data.writeInt32(direction);
status_t status = remote()->transact(SET_MICROPHONE_DIRECTION, data, &reply);
status_t status = remote()->transact(SET_PREFERRED_MICROPHONE_DIRECTION, data, &reply);
return status == NO_ERROR ? (status_t)reply.readInt32() : status;
}
status_t setMicrophoneFieldDimension(float zoom) {
ALOGV("setMicrophoneFieldDimension(%f)", zoom);
status_t setPreferredMicrophoneFieldDimension(float zoom) {
ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
Parcel data, reply;
data.writeInterfaceToken(IMediaRecorder::getInterfaceDescriptor());
data.writeFloat(zoom);
status_t status = remote()->transact(SET_MICROPHONE_FIELD_DIMENSION, data, &reply);
status_t status = remote()->transact(SET_PREFERRED_MICROPHONE_FIELD_DIMENSION, data, &reply);
return status == NO_ERROR ? (status_t)reply.readInt32() : status;
}
@ -709,20 +709,20 @@ status_t BnMediaRecorder::onTransact(
}
return NO_ERROR;
}
case SET_MICROPHONE_DIRECTION: {
ALOGV("SET_MICROPHONE_DIRECTION");
case SET_PREFERRED_MICROPHONE_DIRECTION: {
ALOGV("SET_PREFERRED_MICROPHONE_DIRECTION");
CHECK_INTERFACE(IMediaRecorder, data, reply);
int direction = data.readInt32();
status_t status =
setMicrophoneDirection(static_cast<audio_microphone_direction_t>(direction));
status_t status = setPreferredMicrophoneDirection(
static_cast<audio_microphone_direction_t>(direction));
reply->writeInt32(status);
return NO_ERROR;
}
case SET_MICROPHONE_FIELD_DIMENSION: {
case SET_PREFERRED_MICROPHONE_FIELD_DIMENSION: {
ALOGV("SET_MICROPHONE_FIELD_DIMENSION");
CHECK_INTERFACE(IMediaRecorder, data, reply);
float zoom = data.readFloat();
status_t status = setMicrophoneFieldDimension(zoom);
status_t status = setPreferredMicrophoneFieldDimension(zoom);
reply->writeInt32(status);
return NO_ERROR;
}

4
media/libmedia/include/media/IMediaRecorder.h
Unescape View File

@ -73,8 +73,8 @@ public:
virtual status_t enableAudioDeviceCallback(bool enabled) = 0;
virtual status_t getActiveMicrophones(
std::vector<media::MicrophoneInfo>* activeMicrophones) = 0;
virtual status_t setMicrophoneDirection(audio_microphone_direction_t direction) = 0;
virtual status_t setMicrophoneFieldDimension(float zoom) = 0;
virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction) = 0;
virtual status_t setPreferredMicrophoneFieldDimension(float zoom) = 0;
virtual status_t getPortId(audio_port_handle_t *portId) = 0;
};

4
media/libmedia/include/media/MediaRecorderBase.h
Unescape View File

@ -72,8 +72,8 @@ struct MediaRecorderBase {
virtual status_t enableAudioDeviceCallback(bool enabled) = 0;
virtual status_t getActiveMicrophones(
std::vector<media::MicrophoneInfo>* activeMicrophones) = 0;
virtual status_t setMicrophoneDirection(audio_microphone_direction_t direction) = 0;
virtual status_t setMicrophoneFieldDimension(float zoom) = 0;
virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction) = 0;
virtual status_t setPreferredMicrophoneFieldDimension(float zoom) = 0;
virtual status_t getPortId(audio_port_handle_t *portId) const = 0;

4
media/libmedia/include/media/mediarecorder.h
Unescape View File

@ -264,8 +264,8 @@ public:
status_t getRoutedDeviceId(audio_port_handle_t *deviceId);
status_t enableAudioDeviceCallback(bool enabled);
status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
status_t setMicrophoneDirection(audio_microphone_direction_t direction);
status_t setMicrophoneFieldDimension(float zoom);
status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
status_t setPreferredMicrophoneFieldDimension(float zoom);
status_t getPortId(audio_port_handle_t *portId) const;

12
media/libmedia/mediarecorder.cpp
Unescape View File

@ -842,14 +842,14 @@ status_t MediaRecorder::getActiveMicrophones(std::vector<media::MicrophoneInfo>*
return mMediaRecorder->getActiveMicrophones(activeMicrophones);
}
status_t MediaRecorder::setMicrophoneDirection(audio_microphone_direction_t direction) {
ALOGV("setMicrophoneDirection(%d)", direction);
return mMediaRecorder->setMicrophoneDirection(direction);
status_t MediaRecorder::setPreferredMicrophoneDirection(audio_microphone_direction_t direction) {
ALOGV("setPreferredMicrophoneDirection(%d)", direction);
return mMediaRecorder->setPreferredMicrophoneDirection(direction);
}
status_t MediaRecorder::setMicrophoneFieldDimension(float zoom) {
ALOGV("setMicrophoneFieldDimension(%f)", zoom);
return mMediaRecorder->setMicrophoneFieldDimension(zoom);
status_t MediaRecorder::setPreferredMicrophoneFieldDimension(float zoom) {
ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
return mMediaRecorder->setPreferredMicrophoneFieldDimension(zoom);
}
status_t MediaRecorder::getPortId(audio_port_handle_t *portId) const

13
media/libmediaplayerservice/MediaRecorderClient.cpp
Unescape View File

@ -538,18 +538,19 @@ status_t MediaRecorderClient::getActiveMicrophones(
return NO_INIT;
}
status_t MediaRecorderClient::setMicrophoneDirection(audio_microphone_direction_t direction) {
ALOGV("setMicrophoneDirection(%d)", direction);
status_t MediaRecorderClient::setPreferredMicrophoneDirection(
audio_microphone_direction_t direction) {
ALOGV("setPreferredMicrophoneDirection(%d)", direction);
if (mRecorder != NULL) {
return mRecorder->setMicrophoneDirection(direction);
return mRecorder->setPreferredMicrophoneDirection(direction);
}
return NO_INIT;
}
status_t MediaRecorderClient::setMicrophoneFieldDimension(float zoom) {
ALOGV("setMicrophoneFieldDimension(%f)", zoom);
status_t MediaRecorderClient::setPreferredMicrophoneFieldDimension(float zoom) {
ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
if (mRecorder != NULL) {
return mRecorder->setMicrophoneFieldDimension(zoom);
return mRecorder->setPreferredMicrophoneFieldDimension(zoom);
}
return NO_INIT;
}

4
media/libmediaplayerservice/MediaRecorderClient.h
Unescape View File

@ -109,8 +109,8 @@ public:
virtual status_t enableAudioDeviceCallback(bool enabled);
virtual status_t getActiveMicrophones(
std::vector<media::MicrophoneInfo>* activeMicrophones);
virtual status_t setMicrophoneDirection(audio_microphone_direction_t direction);
virtual status_t setMicrophoneFieldDimension(float zoom);
virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
virtual status_t setPreferredMicrophoneFieldDimension(float zoom);
status_t getPortId(audio_port_handle_t *portId) override;
private:

12
media/libmediaplayerservice/StagefrightRecorder.cpp
Unescape View File

@ -2274,20 +2274,20 @@ status_t StagefrightRecorder::getActiveMicrophones(
return NO_INIT;
}
status_t StagefrightRecorder::setMicrophoneDirection(audio_microphone_direction_t direction) {
ALOGV("setMicrophoneDirection(%d)", direction);
status_t StagefrightRecorder::setPreferredMicrophoneDirection(audio_microphone_direction_t direction) {
ALOGV("setPreferredMicrophoneDirection(%d)", direction);
mSelectedMicDirection = direction;
if (mAudioSourceNode != 0) {
return mAudioSourceNode->setMicrophoneDirection(direction);
return mAudioSourceNode->setPreferredMicrophoneDirection(direction);
}
return NO_INIT;
}
status_t StagefrightRecorder::setMicrophoneFieldDimension(float zoom) {
ALOGV("setMicrophoneFieldDimension(%f)", zoom);
status_t StagefrightRecorder::setPreferredMicrophoneFieldDimension(float zoom) {
ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
mSelectedMicFieldDimension = zoom;
if (mAudioSourceNode != 0) {
return mAudioSourceNode->setMicrophoneFieldDimension(zoom);
return mAudioSourceNode->setPreferredMicrophoneFieldDimension(zoom);
}
return NO_INIT;
}

4
media/libmediaplayerservice/StagefrightRecorder.h
Unescape View File

@ -77,8 +77,8 @@ struct StagefrightRecorder : public MediaRecorderBase {
virtual void setAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback>& callback);
virtual status_t enableAudioDeviceCallback(bool enabled);
virtual status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
virtual status_t setMicrophoneDirection(audio_microphone_direction_t direction);
virtual status_t setMicrophoneFieldDimension(float zoom);
virtual status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
virtual status_t setPreferredMicrophoneFieldDimension(float zoom);
status_t getPortId(audio_port_handle_t *portId) const override;
private:

12
media/libstagefright/AudioSource.cpp
Unescape View File

@ -510,18 +510,18 @@ status_t AudioSource::getActiveMicrophones(
return NO_INIT;
}
status_t AudioSource::setMicrophoneDirection(audio_microphone_direction_t direction) {
ALOGV("setMicrophoneDirection(%d)", direction);
status_t AudioSource::setPreferredMicrophoneDirection(audio_microphone_direction_t direction) {
ALOGV("setPreferredMicrophoneDirection(%d)", direction);
if (mRecord != 0) {
return mRecord->setMicrophoneDirection(direction);
return mRecord->setPreferredMicrophoneDirection(direction);
}
return NO_INIT;
}
status_t AudioSource::setMicrophoneFieldDimension(float zoom) {
ALOGV("setMicrophoneFieldDimension(%f)", zoom);
status_t AudioSource::setPreferredMicrophoneFieldDimension(float zoom) {
ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
if (mRecord != 0) {
return mRecord->setMicrophoneFieldDimension(zoom);
return mRecord->setPreferredMicrophoneFieldDimension(zoom);
}
return NO_INIT;
}

4
media/libstagefright/include/media/stagefright/AudioSource.h
Unescape View File

@ -70,8 +70,8 @@ struct AudioSource : public MediaSource, public MediaBufferObserver {
status_t removeAudioDeviceCallback(const sp<AudioSystem::AudioDeviceCallback>& callback);
status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
status_t setMicrophoneDirection(audio_microphone_direction_t direction);
status_t setMicrophoneFieldDimension(float zoom);
status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
status_t setPreferredMicrophoneFieldDimension(float zoom);
status_t getPortId(audio_port_handle_t *portId) const;

4
services/audioflinger/AudioFlinger.h
Unescape View File

@ -615,9 +615,9 @@ using effect_buffer_t = int16_t;
virtual binder::Status stop();
virtual binder::Status getActiveMicrophones(
std::vector<media::MicrophoneInfo>* activeMicrophones);
virtual binder::Status setMicrophoneDirection(
virtual binder::Status setPreferredMicrophoneDirection(
int /*audio_microphone_direction_t*/ direction);
virtual binder::Status setMicrophoneFieldDimension(float zoom);
virtual binder::Status setPreferredMicrophoneFieldDimension(float zoom);
private:
const sp<RecordThread::RecordTrack> mRecordTrack;

4
services/audioflinger/RecordTracks.h
Unescape View File

@ -71,8 +71,8 @@ public:
status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
status_t setMicrophoneDirection(audio_microphone_direction_t direction);
status_t setMicrophoneFieldDimension(float zoom);
status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
status_t setPreferredMicrophoneFieldDimension(float zoom);
static bool checkServerLatencySupported(
audio_format_t format, audio_input_flags_t flags) {

13
services/audioflinger/Threads.cpp
Unescape View File

@ -7718,18 +7718,19 @@ status_t AudioFlinger::RecordThread::getActiveMicrophones(
return status;
}
status_t AudioFlinger::RecordThread::setMicrophoneDirection(audio_microphone_direction_t direction)
status_t AudioFlinger::RecordThread::setPreferredMicrophoneDirection(
audio_microphone_direction_t direction)
{
ALOGV("setMicrophoneDirection(%d)", direction);
ALOGV("setPreferredMicrophoneDirection(%d)", direction);
AutoMutex _l(mLock);
return mInput->stream->setMicrophoneDirection(direction);
return mInput->stream->setPreferredMicrophoneDirection(direction);
}
status_t AudioFlinger::RecordThread::setMicrophoneFieldDimension(float zoom)
status_t AudioFlinger::RecordThread::setPreferredMicrophoneFieldDimension(float zoom)
{
ALOGV("setMicrophoneFieldDimension(%f)", zoom);
ALOGV("setPreferredMicrophoneFieldDimension(%f)", zoom);
AutoMutex _l(mLock);
return mInput->stream->setMicrophoneFieldDimension(zoom);
return mInput->stream->setPreferredMicrophoneFieldDimension(zoom);
}
void AudioFlinger::RecordThread::updateMetadata_l()

4
services/audioflinger/Threads.h
Unescape View File

@ -1607,8 +1607,8 @@ public:
status_t getActiveMicrophones(std::vector<media::MicrophoneInfo>* activeMicrophones);
status_t setMicrophoneDirection(audio_microphone_direction_t direction);
status_t setMicrophoneFieldDimension(float zoom);
status_t setPreferredMicrophoneDirection(audio_microphone_direction_t direction);
status_t setPreferredMicrophoneFieldDimension(float zoom);
void updateMetadata_l() override;

16
services/audioflinger/Tracks.cpp
Unescape View File

@ -1838,16 +1838,16 @@ binder::Status AudioFlinger::RecordHandle::getActiveMicrophones(
mRecordTrack->getActiveMicrophones(activeMicrophones));
}
binder::Status AudioFlinger::RecordHandle::setMicrophoneDirection(
binder::Status AudioFlinger::RecordHandle::setPreferredMicrophoneDirection(
int /*audio_microphone_direction_t*/ direction) {
ALOGV("%s()", __func__);
return binder::Status::fromStatusT(mRecordTrack->setMicrophoneDirection(
return binder::Status::fromStatusT(mRecordTrack->setPreferredMicrophoneDirection(
static_cast<audio_microphone_direction_t>(direction)));
}
binder::Status AudioFlinger::RecordHandle::setMicrophoneFieldDimension(float zoom) {
binder::Status AudioFlinger::RecordHandle::setPreferredMicrophoneFieldDimension(float zoom) {
ALOGV("%s()", __func__);
return binder::Status::fromStatusT(mRecordTrack->setMicrophoneFieldDimension(zoom));
return binder::Status::fromStatusT(mRecordTrack->setPreferredMicrophoneFieldDimension(zoom));
}
// ----------------------------------------------------------------------------
@ -2144,22 +2144,22 @@ status_t AudioFlinger::RecordThread::RecordTrack::getActiveMicrophones(
}
}
status_t AudioFlinger::RecordThread::RecordTrack::setMicrophoneDirection(
status_t AudioFlinger::RecordThread::RecordTrack::setPreferredMicrophoneDirection(
audio_microphone_direction_t direction) {
sp<ThreadBase> thread = mThread.promote();
if (thread != 0) {
RecordThread *recordThread = (RecordThread *)thread.get();
return recordThread->setMicrophoneDirection(direction);
return recordThread->setPreferredMicrophoneDirection(direction);
} else {
return BAD_VALUE;
}
}
status_t AudioFlinger::RecordThread::RecordTrack::setMicrophoneFieldDimension(float zoom) {
status_t AudioFlinger::RecordThread::RecordTrack::setPreferredMicrophoneFieldDimension(float zoom) {
sp<ThreadBase> thread = mThread.promote();
if (thread != 0) {
RecordThread *recordThread = (RecordThread *)thread.get();
return recordThread->setMicrophoneFieldDimension(zoom);
return recordThread->setPreferredMicrophoneFieldDimension(zoom);
} else {
return BAD_VALUE;
}

Write Preview
Loading…
Cancel
Save