Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit a75fdf5f authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "aaudio: cleanup logs and comments"

parents 1052fb1d fbf031e8

media/libaaudio/src/binding/AAudioBinderClient.cpp

+4 −4
Original line number Diff line number Diff line
@@ -15,7 +15,7 @@ 
 */





#define LOG_TAG "AAudio"

#define LOG_TAG "AAudioBinderClient"

//#define LOG_NDEBUG 0

#include <utils/Log.h>
@@ -61,11 +61,11 @@ AAudioBinderClient::AAudioBinderClient() 
        , Singleton<AAudioBinderClient>() {

    gKeepBinderClient = this; // so this singleton won't get deleted

    mAAudioClient = new AAudioClient(this);

    ALOGV("AAudioBinderClient() this = %p, created mAAudioClient = %p", this, mAAudioClient.get());

    ALOGV("%s - this = %p, created mAAudioClient = %p", __func__, this, mAAudioClient.get());

}



AAudioBinderClient::~AAudioBinderClient() {

    ALOGV("AAudioBinderClient()::~AAudioBinderClient() destroying %p", this);

    ALOGV("%s - destroying %p", __func__, this);

    Mutex::Autolock _l(mServiceLock);

    if (mAAudioService != 0) {

        IInterface::asBinder(mAAudioService)->unlinkToDeath(mAAudioClient);
@@ -137,7 +137,7 @@ aaudio_handle_t AAudioBinderClient::openStream(const AAudioStreamRequest &reques 
        stream = service->openStream(request, configurationOutput);



        if (stream == AAUDIO_ERROR_NO_SERVICE) {

            ALOGE("AAudioBinderClient::openStream lost connection to AAudioService.");

            ALOGE("openStream lost connection to AAudioService.");

            dropAAudioService(); // force a reconnect

        } else {

            break;

media/libaaudio/src/binding/AAudioStreamRequest.cpp

+7 −7
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ 
 * limitations under the License.

 */



#define LOG_TAG "AAudio"

#define LOG_TAG "AAudioStreamRequest"

//#define LOG_NDEBUG 0

#include <utils/Log.h>
@@ -58,7 +58,7 @@ status_t AAudioStreamRequest::writeToParcel(Parcel* parcel) const { 
    return NO_ERROR;



error:

    ALOGE("AAudioStreamRequest.writeToParcel(): write failed = %d", status);

    ALOGE("writeToParcel(): write failed = %d", status);

    return status;

}
@@ -80,7 +80,7 @@ status_t AAudioStreamRequest::readFromParcel(const Parcel* parcel) { 
    return NO_ERROR;



error:

    ALOGE("AAudioStreamRequest.readFromParcel(): read failed = %d", status);

    ALOGE("readFromParcel(): read failed = %d", status);

    return status;

}
@@ -89,9 +89,9 @@ aaudio_result_t AAudioStreamRequest::validate() const { 
}



void AAudioStreamRequest::dump() const {

    ALOGD("AAudioStreamRequest mUserId    = %d", mUserId);

    ALOGD("AAudioStreamRequest mProcessId = %d", mProcessId);

    ALOGD("AAudioStreamRequest mSharingModeMatchRequired = %d", mSharingModeMatchRequired);

    ALOGD("AAudioStreamRequest mInService = %d", mInService);

    ALOGD("mUserId    = %d", mUserId);

    ALOGD("mProcessId = %d", mProcessId);

    ALOGD("mSharingModeMatchRequired = %d", mSharingModeMatchRequired);

    ALOGD("mInService = %d", mInService);

    mConfiguration.dump();

}

media/libaaudio/src/binding/AudioEndpointParcelable.cpp

+14 −14
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ 
 * limitations under the License.

 */



#define LOG_TAG "AAudio"

#define LOG_TAG "AudioEndpointParcelable"

//#define LOG_NDEBUG 0

#include <utils/Log.h>
@@ -112,49 +112,49 @@ aaudio_result_t AudioEndpointParcelable::close() { 
aaudio_result_t AudioEndpointParcelable::validate() {

    aaudio_result_t result;

    if (mNumSharedMemories < 0 || mNumSharedMemories >= MAX_SHARED_MEMORIES) {

        ALOGE("AudioEndpointParcelable invalid mNumSharedMemories = %d", mNumSharedMemories);

        ALOGE("invalid mNumSharedMemories = %d", mNumSharedMemories);

        return AAUDIO_ERROR_INTERNAL;

    }

    for (int i = 0; i < mNumSharedMemories; i++) {

        result = mSharedMemories[i].validate();

        if (result != AAUDIO_OK) {

            ALOGE("AudioEndpointParcelable invalid mSharedMemories[%d] = %d", i, result);

            ALOGE("invalid mSharedMemories[%d] = %d", i, result);

            return result;

        }

    }

    if ((result = mUpMessageQueueParcelable.validate()) != AAUDIO_OK) {

        ALOGE("AudioEndpointParcelable invalid mUpMessageQueueParcelable = %d", result);

        ALOGE("invalid mUpMessageQueueParcelable = %d", result);

        return result;

    }

    if ((result = mDownMessageQueueParcelable.validate()) != AAUDIO_OK) {

        ALOGE("AudioEndpointParcelable invalid mDownMessageQueueParcelable = %d", result);

        ALOGE("invalid mDownMessageQueueParcelable = %d", result);

        return result;

    }

    if ((result = mUpDataQueueParcelable.validate()) != AAUDIO_OK) {

        ALOGE("AudioEndpointParcelable invalid mUpDataQueueParcelable = %d", result);

        ALOGE("invalid mUpDataQueueParcelable = %d", result);

        return result;

    }

    if ((result = mDownDataQueueParcelable.validate()) != AAUDIO_OK) {

        ALOGE("AudioEndpointParcelable invalid mDownDataQueueParcelable = %d", result);

        ALOGE("invalid mDownDataQueueParcelable = %d", result);

        return result;

    }

    return AAUDIO_OK;

}



void AudioEndpointParcelable::dump() {

    ALOGD("AudioEndpointParcelable ======================================= BEGIN");

    ALOGD("AudioEndpointParcelable mNumSharedMemories = %d", mNumSharedMemories);

    ALOGD("======================================= BEGIN");

    ALOGD("mNumSharedMemories = %d", mNumSharedMemories);

    for (int i = 0; i < mNumSharedMemories; i++) {

        mSharedMemories[i].dump();

    }

    ALOGD("AudioEndpointParcelable mUpMessageQueueParcelable =========");

    ALOGD("mUpMessageQueueParcelable =========");

    mUpMessageQueueParcelable.dump();

    ALOGD("AudioEndpointParcelable mDownMessageQueueParcelable =======");

    ALOGD("mDownMessageQueueParcelable =======");

    mDownMessageQueueParcelable.dump();

    ALOGD("AudioEndpointParcelable mUpDataQueueParcelable ============");

    ALOGD("mUpDataQueueParcelable ============");

    mUpDataQueueParcelable.dump();

    ALOGD("AudioEndpointParcelable mDownDataQueueParcelable ==========");

    ALOGD("mDownDataQueueParcelable ==========");

    mDownDataQueueParcelable.dump();

    ALOGD("AudioEndpointParcelable ======================================= END");

    ALOGD("======================================= END");

}

media/libaaudio/src/binding/RingBufferParcelable.cpp

+13 −13
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ 
 * limitations under the License.

 */



#define LOG_TAG "AAudio"

#define LOG_TAG "RingBufferParcelable"

//#define LOG_NDEBUG 0

#include <utils/Log.h>
@@ -97,7 +97,7 @@ status_t RingBufferParcelable::writeToParcel(Parcel* parcel) const { 
    }

    return NO_ERROR;

error:

    ALOGE("RingBufferParcelable::writeToParcel() error = %d", status);

    ALOGE("writeToParcel() error = %d", status);

    return status;

}
@@ -120,7 +120,7 @@ status_t RingBufferParcelable::readFromParcel(const Parcel* parcel) { 
    }

    return NO_ERROR;

error:

    ALOGE("RingBufferParcelable::readFromParcel() error = %d", status);

    ALOGE("readFromParcel() error = %d", status);

    return status;

}
@@ -154,27 +154,27 @@ aaudio_result_t RingBufferParcelable::resolve(SharedMemoryParcelable *memoryParc 
aaudio_result_t RingBufferParcelable::validate() {

    aaudio_result_t result;

    if (mCapacityInFrames < 0 || mCapacityInFrames >= 32 * 1024) {

        ALOGE("RingBufferParcelable invalid mCapacityInFrames = %d", mCapacityInFrames);

        ALOGE("invalid mCapacityInFrames = %d", mCapacityInFrames);

        return AAUDIO_ERROR_INTERNAL;

    }

    if (mBytesPerFrame < 0 || mBytesPerFrame >= 256) {

        ALOGE("RingBufferParcelable invalid mBytesPerFrame = %d", mBytesPerFrame);

        ALOGE("invalid mBytesPerFrame = %d", mBytesPerFrame);

        return AAUDIO_ERROR_INTERNAL;

    }

    if (mFramesPerBurst < 0 || mFramesPerBurst >= 16 * 1024) {

        ALOGE("RingBufferParcelable invalid mFramesPerBurst = %d", mFramesPerBurst);

        ALOGE("invalid mFramesPerBurst = %d", mFramesPerBurst);

        return AAUDIO_ERROR_INTERNAL;

    }

    if ((result = mReadCounterParcelable.validate()) != AAUDIO_OK) {

        ALOGE("RingBufferParcelable invalid mReadCounterParcelable = %d", result);

        ALOGE("invalid mReadCounterParcelable = %d", result);

        return result;

    }

    if ((result = mWriteCounterParcelable.validate()) != AAUDIO_OK) {

        ALOGE("RingBufferParcelable invalid mWriteCounterParcelable = %d", result);

        ALOGE("invalid mWriteCounterParcelable = %d", result);

        return result;

    }

    if ((result = mDataParcelable.validate()) != AAUDIO_OK) {

        ALOGE("RingBufferParcelable invalid mDataParcelable = %d", result);

        ALOGE("invalid mDataParcelable = %d", result);

        return result;

    }

    return AAUDIO_OK;
@@ -182,11 +182,11 @@ aaudio_result_t RingBufferParcelable::validate() { 




void RingBufferParcelable::dump() {

    ALOGD("RingBufferParcelable mCapacityInFrames = %d ---------", mCapacityInFrames);

    ALOGD("mCapacityInFrames = %d ---------", mCapacityInFrames);

    if (mCapacityInFrames > 0) {

        ALOGD("RingBufferParcelable mBytesPerFrame = %d", mBytesPerFrame);

        ALOGD("RingBufferParcelable mFramesPerBurst = %d", mFramesPerBurst);

        ALOGD("RingBufferParcelable mFlags = %u", mFlags);

        ALOGD("mBytesPerFrame = %d", mBytesPerFrame);

        ALOGD("mFramesPerBurst = %d", mFramesPerBurst);

        ALOGD("mFlags = %u", mFlags);

        mReadCounterParcelable.dump();

        mWriteCounterParcelable.dump();

        mDataParcelable.dump();

media/libaaudio/src/binding/SharedMemoryParcelable.cpp

+15 −19
Original line number Diff line number Diff line
@@ -14,7 +14,7 @@ 
 * limitations under the License.

 */



#define LOG_TAG "AAudio"

#define LOG_TAG "SharedMemoryParcelable"

//#define LOG_NDEBUG 0

#include <utils/Log.h>
@@ -43,8 +43,7 @@ SharedMemoryParcelable::~SharedMemoryParcelable() {}; 


void SharedMemoryParcelable::setup(const unique_fd& fd, int32_t sizeInBytes) {

    mFd.reset(dup(fd.get())); // store a duplicate fd

    ALOGV("SharedMemoryParcelable::setup(%d -> %d, %d) this = %p\n",

          fd.get(), mFd.get(), sizeInBytes, this);

    ALOGV("setup(%d -> %d, %d) this = %p\n", fd.get(), mFd.get(), sizeInBytes, this);

    mSizeInBytes = sizeInBytes;

}
@@ -52,7 +51,7 @@ status_t SharedMemoryParcelable::writeToParcel(Parcel* parcel) const { 
    status_t status = parcel->writeInt32(mSizeInBytes);

    if (status != NO_ERROR) return status;

    if (mSizeInBytes > 0) {

        ALOGV("SharedMemoryParcelable::writeToParcel() mFd = %d, this = %p\n", mFd.get(), this);

        ALOGV("writeToParcel() mFd = %d, this = %p\n", mFd.get(), this);

        status = parcel->writeUniqueFileDescriptor(mFd);

        ALOGE_IF(status != NO_ERROR, "SharedMemoryParcelable writeDupFileDescriptor failed : %d",

                 status);
@@ -70,8 +69,7 @@ status_t SharedMemoryParcelable::readFromParcel(const Parcel* parcel) { 
        unique_fd mmapFd;

        status = parcel->readUniqueFileDescriptor(&mmapFd);

        if (status != NO_ERROR) {

            ALOGE("SharedMemoryParcelable::readFromParcel() readUniqueFileDescriptor() failed : %d",

                  status);

            ALOGE("readFromParcel() readUniqueFileDescriptor() failed : %d", status);

        } else {

            // Resolve the memory now while we still have the FD from the Parcel.

            // Closing the FD will not affect the shared memory once mmap() has been called.
@@ -85,7 +83,7 @@ aaudio_result_t SharedMemoryParcelable::close() { 
    if (mResolvedAddress != MMAP_UNRESOLVED_ADDRESS) {

        int err = munmap(mResolvedAddress, mSizeInBytes);

        if (err < 0) {

            ALOGE("SharedMemoryParcelable::close() munmap() failed %d", err);

            ALOGE("close() munmap() failed %d", err);

            return AAudioConvert_androidToAAudioResult(err);

        }

        mResolvedAddress = MMAP_UNRESOLVED_ADDRESS;
@@ -97,8 +95,7 @@ aaudio_result_t SharedMemoryParcelable::resolveSharedMemory(const unique_fd& fd) 
    mResolvedAddress = (uint8_t *) mmap(0, mSizeInBytes, PROT_READ | PROT_WRITE,

                                        MAP_SHARED, fd.get(), 0);

    if (mResolvedAddress == MMAP_UNRESOLVED_ADDRESS) {

        ALOGE("SharedMemoryParcelable mmap() failed for fd = %d, errno = %s",

              fd.get(), strerror(errno));

        ALOGE("mmap() failed for fd = %d, errno = %s", fd.get(), strerror(errno));

        return AAUDIO_ERROR_INTERNAL;

    }

    return AAUDIO_OK;
@@ -107,10 +104,10 @@ aaudio_result_t SharedMemoryParcelable::resolveSharedMemory(const unique_fd& fd) 
aaudio_result_t SharedMemoryParcelable::resolve(int32_t offsetInBytes, int32_t sizeInBytes,

                                              void **regionAddressPtr) {

    if (offsetInBytes < 0) {

        ALOGE("SharedMemoryParcelable illegal offsetInBytes = %d", offsetInBytes);

        ALOGE("illegal offsetInBytes = %d", offsetInBytes);

        return AAUDIO_ERROR_OUT_OF_RANGE;

    } else if ((offsetInBytes + sizeInBytes) > mSizeInBytes) {

        ALOGE("SharedMemoryParcelable out of range, offsetInBytes = %d, "

        ALOGE("out of range, offsetInBytes = %d, "

                      "sizeInBytes = %d, mSizeInBytes = %d",

              offsetInBytes, sizeInBytes, mSizeInBytes);

        return AAUDIO_ERROR_OUT_OF_RANGE;
@@ -122,16 +119,15 @@ aaudio_result_t SharedMemoryParcelable::resolve(int32_t offsetInBytes, int32_t s 
        if (mFd.get() != -1) {

            result = resolveSharedMemory(mFd);

        } else {

            ALOGE("SharedMemoryParcelable has no file descriptor for shared memory.");

            ALOGE("has no file descriptor for shared memory.");

            result = AAUDIO_ERROR_INTERNAL;

        }

    }



    if (result == AAUDIO_OK && mResolvedAddress != MMAP_UNRESOLVED_ADDRESS) {

        *regionAddressPtr = mResolvedAddress + offsetInBytes;

        ALOGV("SharedMemoryParcelable mResolvedAddress = %p", mResolvedAddress);

        ALOGV("SharedMemoryParcelable offset by %d, *regionAddressPtr = %p",

              offsetInBytes, *regionAddressPtr);

        ALOGV("mResolvedAddress = %p", mResolvedAddress);

        ALOGV("offset by %d, *regionAddressPtr = %p", offsetInBytes, *regionAddressPtr);

    }

    return result;

}
@@ -142,14 +138,14 @@ int32_t SharedMemoryParcelable::getSizeInBytes() { 


aaudio_result_t SharedMemoryParcelable::validate() {

    if (mSizeInBytes < 0 || mSizeInBytes >= MAX_MMAP_SIZE_BYTES) {

        ALOGE("SharedMemoryParcelable invalid mSizeInBytes = %d", mSizeInBytes);

        ALOGE("invalid mSizeInBytes = %d", mSizeInBytes);

        return AAUDIO_ERROR_OUT_OF_RANGE;

    }

    return AAUDIO_OK;

}



void SharedMemoryParcelable::dump() {

    ALOGD("SharedMemoryParcelable mFd = %d", mFd.get());

    ALOGD("SharedMemoryParcelable mSizeInBytes = %d", mSizeInBytes);

    ALOGD("SharedMemoryParcelable mResolvedAddress = %p", mResolvedAddress);

    ALOGD("mFd = %d", mFd.get());

    ALOGD("mSizeInBytes = %d", mSizeInBytes);

    ALOGD("mResolvedAddress = %p", mResolvedAddress);

}