blob: 8c36f0e5d61194703074daab86211f03cc84c06f [file] [log] [blame]
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001/*
2 * Copyright (C) 2007 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#ifndef ANDROID_MEDIAPLAYERINTERFACE_H
18#define ANDROID_MEDIAPLAYERINTERFACE_H
19
20#ifdef __cplusplus
21
Nicolas Catania14d27472009-07-13 14:37:49 -070022#include <sys/types.h>
Nicolas Catania14d27472009-07-13 14:37:49 -070023#include <utils/Errors.h>
Andreas Huber2db84552010-01-28 11:19:57 -080024#include <utils/KeyedVector.h>
25#include <utils/String8.h>
26#include <utils/RefBase.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080027
28#include <media/mediaplayer.h>
Lajos Molnar3a474aa2015-04-24 17:10:07 -070029#include <media/AudioResamplerPublic.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080030#include <media/AudioSystem.h>
Lajos Molnar06ad1522014-08-28 07:27:44 -070031#include <media/AudioTimestamp.h>
Lajos Molnar3a474aa2015-04-24 17:10:07 -070032#include <media/AVSyncSettings.h>
nikoa64c8c72009-07-20 15:07:26 -070033#include <media/Metadata.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080034
John Grossmanc795b642012-02-22 15:38:35 -080035// Fwd decl to make sure everyone agrees that the scope of struct sockaddr_in is
36// global, and not in android::
37struct sockaddr_in;
38
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080039namespace android {
40
Chris Watkins99f31602015-03-20 13:06:33 -070041class DataSource;
Nicolas Catania1d187f12009-05-12 23:25:55 -070042class Parcel;
Andreas Huber5daeb122010-08-16 08:49:37 -070043class Surface;
Andy McFadden484566c2012-12-18 09:46:54 -080044class IGraphicBufferProducer;
Mathias Agopian3cf61352010-02-09 17:46:37 -080045
nikod608a812009-07-16 16:39:53 -070046template<typename T> class SortedVector;
Nicolas Catania1d187f12009-05-12 23:25:55 -070047
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080048enum player_type {
Andreas Huberf9334412010-12-15 15:17:42 -080049 STAGEFRIGHT_PLAYER = 3,
50 NU_PLAYER = 4,
Nicolas Catania14d27472009-07-13 14:37:49 -070051 // Test players are available only in the 'test' and 'eng' builds.
52 // The shared library with the test player is passed passed as an
53 // argument to the 'test:' url in the setDataSource call.
54 TEST_PLAYER = 5,
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080055};
56
Nicolas Catania1d187f12009-05-12 23:25:55 -070057
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080058#define DEFAULT_AUDIOSINK_BUFFERCOUNT 4
59#define DEFAULT_AUDIOSINK_BUFFERSIZE 1200
60#define DEFAULT_AUDIOSINK_SAMPLERATE 44100
61
Jean-Michel Trivi786618f2012-03-02 14:54:07 -080062// when the channel mask isn't known, use the channel count to derive a mask in AudioSink::open()
63#define CHANNEL_MASK_USE_CHANNEL_ORDER 0
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080064
Eric Laurent1948eb32012-04-13 16:50:19 -070065// duration below which we do not allow deep audio buffering
66#define AUDIO_SINK_MIN_DEEP_BUFFER_DURATION_US 5000000
67
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080068// callback mechanism for passing messages to MediaPlayer object
Gloria Wangb483c472011-04-11 17:23:27 -070069typedef void (*notify_callback_f)(void* cookie,
70 int msg, int ext1, int ext2, const Parcel *obj);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080071
72// abstract base class - use MediaPlayerInterface
73class MediaPlayerBase : public RefBase
74{
75public:
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080076 // AudioSink: abstraction layer for audio output
77 class AudioSink : public RefBase {
78 public:
Richard Fitzgeraldad3af332013-03-25 16:54:37 +000079 enum cb_event_t {
80 CB_EVENT_FILL_BUFFER, // Request to write more data to buffer.
81 CB_EVENT_STREAM_END, // Sent after all the buffers queued in AF and HW are played
82 // back (after stop is called)
83 CB_EVENT_TEAR_DOWN // The AudioTrack was invalidated due to use case change:
84 // Need to re-evaluate offloading options
85 };
86
Andreas Huber7d5b8a72010-02-09 16:59:18 -080087 // Callback returns the number of bytes actually written to the buffer.
88 typedef size_t (*AudioCallback)(
Richard Fitzgeraldad3af332013-03-25 16:54:37 +000089 AudioSink *audioSink, void *buffer, size_t size, void *cookie,
90 cb_event_t event);
Andreas Huber20111aa2009-07-14 16:56:47 -070091
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080092 virtual ~AudioSink() {}
93 virtual bool ready() const = 0; // audio output is open and ready
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080094 virtual ssize_t bufferSize() const = 0;
95 virtual ssize_t frameCount() const = 0;
96 virtual ssize_t channelCount() const = 0;
97 virtual ssize_t frameSize() const = 0;
98 virtual uint32_t latency() const = 0;
99 virtual float msecsPerFrame() const = 0;
Marco Nelissen4110c102012-03-29 09:31:28 -0700100 virtual status_t getPosition(uint32_t *position) const = 0;
Lajos Molnar06ad1522014-08-28 07:27:44 -0700101 virtual status_t getTimestamp(AudioTimestamp &ts) const = 0;
Marco Nelissen4110c102012-03-29 09:31:28 -0700102 virtual status_t getFramesWritten(uint32_t *frameswritten) const = 0;
103 virtual int getSessionId() const = 0;
Eric Laurent22612342013-11-14 17:28:47 -0800104 virtual audio_stream_type_t getAudioStreamType() const = 0;
Eric Laurent6f59db12013-07-26 17:16:50 -0700105 virtual uint32_t getSampleRate() const = 0;
Andreas Huber20111aa2009-07-14 16:56:47 -0700106
107 // If no callback is specified, use the "write" API below to submit
Andreas Huber7d5b8a72010-02-09 16:59:18 -0800108 // audio data.
Andreas Huber20111aa2009-07-14 16:56:47 -0700109 virtual status_t open(
Jean-Michel Trivi786618f2012-03-02 14:54:07 -0800110 uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
Glenn Kastene1c39622012-01-04 09:36:37 -0800111 audio_format_t format=AUDIO_FORMAT_PCM_16_BIT,
Andreas Huber20111aa2009-07-14 16:56:47 -0700112 int bufferCount=DEFAULT_AUDIOSINK_BUFFERCOUNT,
113 AudioCallback cb = NULL,
Eric Laurent1948eb32012-04-13 16:50:19 -0700114 void *cookie = NULL,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +0000115 audio_output_flags_t flags = AUDIO_OUTPUT_FLAG_NONE,
Ronghua Wufaeb0f22015-05-21 12:20:21 -0700116 const audio_offload_info_t *offloadInfo = NULL,
117 bool doNotResuscitate = false) = 0;
Andreas Huber20111aa2009-07-14 16:56:47 -0700118
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +0100119 virtual status_t start() = 0;
Wei Jia7d3f4df2015-03-03 15:28:00 -0800120
121 /* Input parameter |size| is in byte units stored in |buffer|.
122 * Data is copied over and actual number of bytes written (>= 0)
123 * is returned, or no data is copied and a negative status code
124 * is returned (even when |blocking| is true).
125 * When |blocking| is false, AudioSink will immediately return after
126 * part of or full |buffer| is copied over.
127 * When |blocking| is true, AudioSink will wait to copy the entire
128 * buffer, unless an error occurs or the copy operation is
129 * prematurely stopped.
130 */
131 virtual ssize_t write(const void* buffer, size_t size, bool blocking = true) = 0;
132
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800133 virtual void stop() = 0;
134 virtual void flush() = 0;
135 virtual void pause() = 0;
136 virtual void close() = 0;
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -0800137
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700138 virtual status_t setPlaybackRate(const AudioPlaybackRate& rate) = 0;
139 virtual status_t getPlaybackRate(AudioPlaybackRate* rate /* nonnull */) = 0;
Marco Nelissen6b74d672012-02-28 16:07:44 -0800140 virtual bool needsTrailingPadding() { return true; }
Richard Fitzgeraldad3af332013-03-25 16:54:37 +0000141
Lajos Molnaree4e1b12015-04-17 13:46:19 -0700142 virtual status_t setParameters(const String8& /* keyValuePairs */) { return NO_ERROR; }
143 virtual String8 getParameters(const String8& /* keys */) { return String8::empty(); }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800144 };
145
146 MediaPlayerBase() : mCookie(0), mNotify(0) {}
147 virtual ~MediaPlayerBase() {}
148 virtual status_t initCheck() = 0;
149 virtual bool hardwareOutput() = 0;
Andreas Huber2db84552010-01-28 11:19:57 -0800150
Lajos Molnaree4e1b12015-04-17 13:46:19 -0700151 virtual status_t setUID(uid_t /* uid */) {
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700152 return INVALID_OPERATION;
153 }
154
Andreas Huber2db84552010-01-28 11:19:57 -0800155 virtual status_t setDataSource(
Andreas Huber1b86fe02014-01-29 11:13:26 -0800156 const sp<IMediaHTTPService> &httpService,
Andreas Huber2db84552010-01-28 11:19:57 -0800157 const char *url,
158 const KeyedVector<String8, String8> *headers = NULL) = 0;
159
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800160 virtual status_t setDataSource(int fd, int64_t offset, int64_t length) = 0;
Andreas Hubere2b10282010-11-23 11:41:34 -0800161
Lajos Molnaree4e1b12015-04-17 13:46:19 -0700162 virtual status_t setDataSource(const sp<IStreamSource>& /* source */) {
Andreas Hubere2b10282010-11-23 11:41:34 -0800163 return INVALID_OPERATION;
164 }
165
Lajos Molnaree4e1b12015-04-17 13:46:19 -0700166 virtual status_t setDataSource(const sp<DataSource>& /* source */) {
Chris Watkins99f31602015-03-20 13:06:33 -0700167 return INVALID_OPERATION;
168 }
169
Andy McFadden484566c2012-12-18 09:46:54 -0800170 // pass the buffered IGraphicBufferProducer to the media player service
Glenn Kasten11731182011-02-08 17:26:17 -0800171 virtual status_t setVideoSurfaceTexture(
Andy McFadden484566c2012-12-18 09:46:54 -0800172 const sp<IGraphicBufferProducer>& bufferProducer) = 0;
Glenn Kasten11731182011-02-08 17:26:17 -0800173
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800174 virtual status_t prepare() = 0;
175 virtual status_t prepareAsync() = 0;
176 virtual status_t start() = 0;
177 virtual status_t stop() = 0;
178 virtual status_t pause() = 0;
179 virtual bool isPlaying() = 0;
Lajos Molnar3a474aa2015-04-24 17:10:07 -0700180 virtual status_t setPlaybackSettings(const AudioPlaybackRate& rate) {
181 // by default, players only support setting rate to the default
182 if (!isAudioPlaybackRateEqual(rate, AUDIO_PLAYBACK_RATE_DEFAULT)) {
183 return BAD_VALUE;
184 }
185 return OK;
186 }
187 virtual status_t getPlaybackSettings(AudioPlaybackRate* rate /* nonnull */) {
188 *rate = AUDIO_PLAYBACK_RATE_DEFAULT;
189 return OK;
190 }
191 virtual status_t setSyncSettings(const AVSyncSettings& sync, float /* videoFps */) {
192 // By default, players only support setting sync source to default; all other sync
193 // settings are ignored. There is no requirement for getters to return set values.
194 if (sync.mSource != AVSYNC_SOURCE_DEFAULT) {
195 return BAD_VALUE;
196 }
197 return OK;
198 }
199 virtual status_t getSyncSettings(
200 AVSyncSettings* sync /* nonnull */, float* videoFps /* nonnull */) {
201 *sync = AVSyncSettings();
202 *videoFps = -1.f;
203 return OK;
204 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800205 virtual status_t seekTo(int msec) = 0;
206 virtual status_t getCurrentPosition(int *msec) = 0;
207 virtual status_t getDuration(int *msec) = 0;
208 virtual status_t reset() = 0;
209 virtual status_t setLooping(int loop) = 0;
210 virtual player_type playerType() = 0;
Gloria Wang4f9e47f2011-04-25 17:28:22 -0700211 virtual status_t setParameter(int key, const Parcel &request) = 0;
212 virtual status_t getParameter(int key, Parcel *reply) = 0;
Andreas Huber4e92c7e2010-02-12 12:35:58 -0800213
John Grossman5f7e55e2012-08-24 14:47:25 -0700214 // default no-op implementation of optional extensions
Lajos Molnaree4e1b12015-04-17 13:46:19 -0700215 virtual status_t setRetransmitEndpoint(const struct sockaddr_in* /* endpoint */) {
John Grossmanc795b642012-02-22 15:38:35 -0800216 return INVALID_OPERATION;
217 }
Lajos Molnaree4e1b12015-04-17 13:46:19 -0700218 virtual status_t getRetransmitEndpoint(struct sockaddr_in* /* endpoint */) {
John Grossman44a7e422012-06-21 17:29:24 -0700219 return INVALID_OPERATION;
220 }
Lajos Molnaree4e1b12015-04-17 13:46:19 -0700221 virtual status_t setNextPlayer(const sp<MediaPlayerBase>& /* next */) {
John Grossman5f7e55e2012-08-24 14:47:25 -0700222 return OK;
223 }
John Grossmanc795b642012-02-22 15:38:35 -0800224
Nicolas Catania1d187f12009-05-12 23:25:55 -0700225 // Invoke a generic method on the player by using opaque parcels
226 // for the request and reply.
nikod608a812009-07-16 16:39:53 -0700227 //
Nicolas Catania1d187f12009-05-12 23:25:55 -0700228 // @param request Parcel that is positioned at the start of the
229 // data sent by the java layer.
230 // @param[out] reply Parcel to hold the reply data. Cannot be null.
nikod608a812009-07-16 16:39:53 -0700231 // @return OK if the call was successful.
Nicolas Catania1d187f12009-05-12 23:25:55 -0700232 virtual status_t invoke(const Parcel& request, Parcel *reply) = 0;
nikod608a812009-07-16 16:39:53 -0700233
234 // The Client in the MetadataPlayerService calls this method on
235 // the native player to retrieve all or a subset of metadata.
236 //
237 // @param ids SortedList of metadata ID to be fetch. If empty, all
238 // the known metadata should be returned.
239 // @param[inout] records Parcel where the player appends its metadata.
240 // @return OK if the call was successful.
Lajos Molnaree4e1b12015-04-17 13:46:19 -0700241 virtual status_t getMetadata(const media::Metadata::Filter& /* ids */,
242 Parcel* /* records */) {
nikoa64c8c72009-07-20 15:07:26 -0700243 return INVALID_OPERATION;
244 };
nikod608a812009-07-16 16:39:53 -0700245
Andreas Huber01f39422011-01-26 11:19:19 -0800246 void setNotifyCallback(
247 void* cookie, notify_callback_f notifyFunc) {
248 Mutex::Autolock autoLock(mNotifyLock);
249 mCookie = cookie; mNotify = notifyFunc;
250 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800251
Gloria Wangb483c472011-04-11 17:23:27 -0700252 void sendEvent(int msg, int ext1=0, int ext2=0,
253 const Parcel *obj=NULL) {
Chong Zhangdf2592b2014-10-24 18:53:44 -0700254 notify_callback_f notifyCB;
255 void* cookie;
256 {
257 Mutex::Autolock autoLock(mNotifyLock);
258 notifyCB = mNotify;
259 cookie = mCookie;
260 }
261
262 if (notifyCB) notifyCB(cookie, msg, ext1, ext2, obj);
Andreas Huber01f39422011-01-26 11:19:19 -0800263 }
264
Lajos Molnaree4e1b12015-04-17 13:46:19 -0700265 virtual status_t dump(int /* fd */, const Vector<String16>& /* args */) const {
Andreas Hubera0b1d4b2011-06-07 15:52:25 -0700266 return INVALID_OPERATION;
267 }
268
Andreas Huber01f39422011-01-26 11:19:19 -0800269private:
270 friend class MediaPlayerService;
271
272 Mutex mNotifyLock;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800273 void* mCookie;
274 notify_callback_f mNotify;
275};
276
277// Implement this class for media players that use the AudioFlinger software mixer
278class MediaPlayerInterface : public MediaPlayerBase
279{
280public:
281 virtual ~MediaPlayerInterface() { }
282 virtual bool hardwareOutput() { return false; }
283 virtual void setAudioSink(const sp<AudioSink>& audioSink) { mAudioSink = audioSink; }
284protected:
285 sp<AudioSink> mAudioSink;
286};
287
Glenn Kasten11731182011-02-08 17:26:17 -0800288// Implement this class for media players that output audio directly to hardware
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800289class MediaPlayerHWInterface : public MediaPlayerBase
290{
291public:
292 virtual ~MediaPlayerHWInterface() {}
293 virtual bool hardwareOutput() { return true; }
294 virtual status_t setVolume(float leftVolume, float rightVolume) = 0;
Glenn Kastenfff6d712012-01-12 16:38:12 -0800295 virtual status_t setAudioStreamType(audio_stream_type_t streamType) = 0;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800296};
297
298}; // namespace android
299
300#endif // __cplusplus
301
302
303#endif // ANDROID_MEDIAPLAYERINTERFACE_H