oboeservice: headers for service interface (828bea5f) · Commits · e / os / android_frameworks_av

media/liboboe/src/binding/AudioEndpointParcelable.h

0 → 100644

+76 −0

Original line number	Diff line number	Diff line
		/*
		* 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

media/liboboe/src/binding/IOboeAudioService.h

0 → 100644

+101 −0

Original line number	Diff line number	Diff line
		/*
		* 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

media/liboboe/src/binding/OboeServiceDefinitions.h

0 → 100644

+86 −0

Original line number	Diff line number	Diff line
		/*
		* 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

media/liboboe/src/binding/OboeStreamConfiguration.h

0 → 100644

+86 −0

Original line number	Diff line number	Diff line
		/*
		* 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

media/liboboe/src/binding/OboeStreamRequest.h

0 → 100644

+75 −0

Original line number	Diff line number	Diff line
		/*
		* 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