Merge "oboeservice: headers for service interface"

/*

 * Copyright 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifndef BINDING_AUDIOENDPOINTPARCELABLE_H

#define BINDING_AUDIOENDPOINTPARCELABLE_H

#include <stdint.h>

//#include <sys/mman.h>

#include <binder/Parcel.h>

#include <binder/Parcelable.h>

#include "binding/OboeServiceDefinitions.h"

#include "binding/RingBufferParcelable.h"

using android::status_t;

using android::Parcel;

using android::Parcelable;

namespace oboe {

/**

 * Container for information about the message queues plus

 * general stream information needed by Oboe clients.

 * It contains no addresses, just sizes, offsets and file descriptors for

 * shared memory that can be passed through Binder.

 */

class AudioEndpointParcelable : public Parcelable {

public:

    AudioEndpointParcelable();

    virtual ~AudioEndpointParcelable();

    /**

     * Add the file descriptor to the table.

     * @return index in table or negative error

     */

    int32_t addFileDescriptor(int fd, int32_t sizeInBytes);

    virtual status_t writeToParcel(Parcel* parcel) const override;

    virtual status_t readFromParcel(const Parcel* parcel) override;

    oboe_result_t resolve(EndpointDescriptor *descriptor);

    oboe_result_t validate();

    void dump();

public: // TODO add getters

    // Set capacityInFrames to zero if Queue is unused.

    RingBufferParcelable    mUpMessageQueueParcelable;   // server to client

    RingBufferParcelable    mDownMessageQueueParcelable; // to server

    RingBufferParcelable    mUpDataQueueParcelable;      // eg. record, could share same queue

    RingBufferParcelable    mDownDataQueueParcelable;    // eg. playback

private:

    int32_t                 mNumSharedMemories = 0;

    SharedMemoryParcelable  mSharedMemories[MAX_SHARED_MEMORIES];

};

} /* namespace oboe */

#endif //BINDING_AUDIOENDPOINTPARCELABLE_H

/*

 * Copyright (C) 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifndef BINDING_IOBOEAUDIOSERVICE_H

#define BINDING_IOBOEAUDIOSERVICE_H

#include <stdint.h>

#include <utils/RefBase.h>

#include <binder/TextOutput.h>

#include <binder/IInterface.h>

#include <oboe/OboeAudio.h>

#include "binding/OboeServiceDefinitions.h"

#include "binding/AudioEndpointParcelable.h"

#include "binding/OboeStreamRequest.h"

#include "binding/OboeStreamConfiguration.h"

//using android::status_t;

//using android::IInterface;

//using android::BnInterface;

using oboe::AudioEndpointParcelable;

using oboe::OboeStreamRequest;

using oboe::OboeStreamConfiguration;

namespace android {

// Interface (our AIDL) - Shared by server and client

class IOboeAudioService : public IInterface {

public:

    DECLARE_META_INTERFACE(OboeAudioService);

    virtual oboe_handle_t openStream(OboeStreamRequest &request,

                                     OboeStreamConfiguration &configuration) = 0;

    virtual oboe_result_t closeStream(int32_t streamHandle) = 0;

    /* Get an immutable description of the in-memory queues

    * used to communicate with the underlying HAL or Service.

    */

    virtual oboe_result_t getStreamDescription(oboe_handle_t streamHandle,

                                               AudioEndpointParcelable &parcelable) = 0;

    /**

     * Start the flow of data.

     */

    virtual oboe_result_t startStream(oboe_handle_t streamHandle) = 0;

    /**

     * Stop the flow of data such that start() can resume without loss of data.

     */

    virtual oboe_result_t pauseStream(oboe_handle_t streamHandle) = 0;

    /**

     *  Discard any data held by the underlying HAL or Service.

     */

    virtual oboe_result_t flushStream(oboe_handle_t streamHandle) = 0;

    /**

     * Manage the specified thread as a low latency audio thread.

     */

    virtual oboe_result_t registerAudioThread(oboe_handle_t streamHandle, pid_t clientThreadId,

                                              oboe_nanoseconds_t periodNanoseconds) = 0;

    virtual oboe_result_t unregisterAudioThread(oboe_handle_t streamHandle,

                                                pid_t clientThreadId) = 0;

    /**

     * Poke server instead of running a background thread.

     * Cooperative multi-tasking for early development only.

     * TODO remove tickle() when service has its own thread.

     */

    virtual void tickle() { };

};

class BnOboeAudioService : public BnInterface<IOboeAudioService> {

public:

    virtual status_t onTransact(uint32_t code, const Parcel& data,

                                Parcel* reply, uint32_t flags = 0);

};

} /* namespace android */

#endif //BINDING_IOBOEAUDIOSERVICE_H

/*

 * Copyright (C) 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifndef BINDING_OBOESERVICEDEFINITIONS_H

#define BINDING_OBOESERVICEDEFINITIONS_H

#include <stdint.h>

#include <utils/RefBase.h>

#include <binder/TextOutput.h>

#include <binder/IInterface.h>

#include <oboe/OboeAudio.h>

using android::NO_ERROR;

using android::IBinder;

namespace oboe {

enum oboe_commands_t {

    OPEN_STREAM = IBinder::FIRST_CALL_TRANSACTION,

    CLOSE_STREAM,

    GET_STREAM_DESCRIPTION,

    START_STREAM,

    PAUSE_STREAM,

    FLUSH_STREAM,

    REGISTER_AUDIO_THREAD,

    UNREGISTER_AUDIO_THREAD,

    TICKLE

};

// TODO Expand this to include all the open parameters.

typedef struct OboeServiceStreamInfo_s {

    int32_t             deviceId;

    int32_t             samplesPerFrame;  // number of channels

    oboe_sample_rate_t  sampleRate;

    oboe_audio_format_t audioFormat;

} OboeServiceStreamInfo;

// This must be a fixed width so it can be in shared memory.

enum RingbufferFlags : uint32_t {

    NONE = 0,

    RATE_ISOCHRONOUS = 0x0001,

    RATE_ASYNCHRONOUS = 0x0002,

    COHERENCY_DMA = 0x0004,

    COHERENCY_ACQUIRE_RELEASE = 0x0008,

    COHERENCY_AUTO = 0x0010,

};

// This is not passed through Binder.

// Client side code will convert Binder data and fill this descriptor.

typedef struct RingBufferDescriptor_s {

    uint8_t* dataAddress;       // offset from read or write block

    int64_t* writeCounterAddress;

    int64_t* readCounterAddress;

    int32_t  bytesPerFrame;     // index is in frames

    int32_t  framesPerBurst;    // for ISOCHRONOUS queues

    int32_t  capacityInFrames;  // zero if unused

    RingbufferFlags flags;

} RingBufferDescriptor;

// This is not passed through Binder.

// Client side code will convert Binder data and fill this descriptor.

typedef struct EndpointDescriptor_s {

    // Set capacityInFrames to zero if Queue is unused.

    RingBufferDescriptor upMessageQueueDescriptor;   // server to client

    RingBufferDescriptor downMessageQueueDescriptor; // client to server

    RingBufferDescriptor upDataQueueDescriptor;      // eg. record

    RingBufferDescriptor downDataQueueDescriptor;    // eg. playback

} EndpointDescriptor;

} // namespace oboe

#endif //BINDING_OBOESERVICEDEFINITIONS_H

/*

 * Copyright 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifndef BINDING_OBOE_STREAM_CONFIGURATION_H

#define BINDING_OBOE_STREAM_CONFIGURATION_H

#include <stdint.h>

#include <binder/Parcel.h>

#include <binder/Parcelable.h>

#include <oboe/OboeDefinitions.h>

using android::status_t;

using android::Parcel;

using android::Parcelable;

namespace oboe {

class OboeStreamConfiguration : public Parcelable {

public:

    OboeStreamConfiguration();

    virtual ~OboeStreamConfiguration();

    oboe_device_id_t getDeviceId() const {

        return mDeviceId;

    }

    void setDeviceId(oboe_device_id_t deviceId) {

        mDeviceId = deviceId;

    }

    oboe_sample_rate_t getSampleRate() const {

        return mSampleRate;

    }

    void setSampleRate(oboe_sample_rate_t sampleRate) {

        mSampleRate = sampleRate;

    }

    int32_t getSamplesPerFrame() const {

        return mSamplesPerFrame;

    }

    void setSamplesPerFrame(int32_t samplesPerFrame) {

        mSamplesPerFrame = samplesPerFrame;

    }

    oboe_audio_format_t getAudioFormat() const {

        return mAudioFormat;

    }

    void setAudioFormat(oboe_audio_format_t audioFormat) {

        mAudioFormat = audioFormat;

    }

    virtual status_t writeToParcel(Parcel* parcel) const override;

    virtual status_t readFromParcel(const Parcel* parcel) override;

    oboe_result_t validate();

    void dump();

protected:

    oboe_device_id_t    mDeviceId        = OBOE_DEVICE_UNSPECIFIED;

    oboe_sample_rate_t  mSampleRate      = OBOE_UNSPECIFIED;

    int32_t             mSamplesPerFrame = OBOE_UNSPECIFIED;

    oboe_audio_format_t mAudioFormat     = OBOE_AUDIO_FORMAT_UNSPECIFIED;

};

} /* namespace oboe */

#endif //BINDING_OBOE_STREAM_CONFIGURATION_H

/*

 * Copyright 2016 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */

#ifndef BINDING_OBOE_STREAM_REQUEST_H

#define BINDING_OBOE_STREAM_REQUEST_H

#include <stdint.h>

#include <binder/Parcel.h>

#include <binder/Parcelable.h>

#include <oboe/OboeDefinitions.h>

#include "binding/OboeStreamConfiguration.h"

using android::status_t;

using android::Parcel;

using android::Parcelable;

namespace oboe {

class OboeStreamRequest : public Parcelable {

public:

    OboeStreamRequest();

    virtual ~OboeStreamRequest();

    uid_t getUserId() const {

        return mUserId;

    }

    void setUserId(uid_t userId) {

        mUserId = userId;

    }

    pid_t getProcessId() const {

        return mProcessId;

    }

    void setProcessId(pid_t processId) {

        mProcessId = processId;

    }

    OboeStreamConfiguration &getConfiguration() {

        return mConfiguration;

    }

    virtual status_t writeToParcel(Parcel* parcel) const override;

    virtual status_t readFromParcel(const Parcel* parcel) override;

    oboe_result_t validate();

    void dump();

protected:

    OboeStreamConfiguration  mConfiguration;

    uid_t    mUserId;

    pid_t    mProcessId;

};

} /* namespace oboe */

#endif //BINDING_OBOE_STREAM_REQUEST_H