blob: a963424fd4b53a600c0ed3620ad01304707a6b34 [file] [log] [blame]
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001/*
2**
3** Copyright 2008, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9** http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18// Proxy for media player implementations
19
20//#define LOG_NDEBUG 0
21#define LOG_TAG "MediaPlayerService"
22#include <utils/Log.h>
23
24#include <sys/types.h>
25#include <sys/stat.h>
Gloria Wang7cf180c2011-02-19 18:37:57 -080026#include <sys/time.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080027#include <dirent.h>
28#include <unistd.h>
29
30#include <string.h>
Mathias Agopian6f74b0c2009-06-03 17:32:49 -070031
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080032#include <cutils/atomic.h>
Nicolas Catania14d27472009-07-13 14:37:49 -070033#include <cutils/properties.h> // for property_get
Mathias Agopian6f74b0c2009-06-03 17:32:49 -070034
35#include <utils/misc.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080036
Mathias Agopian75624082009-05-19 19:08:10 -070037#include <binder/IPCThreadState.h>
38#include <binder/IServiceManager.h>
39#include <binder/MemoryHeapBase.h>
40#include <binder/MemoryBase.h>
Mathias Agopianb1e7cd12013-02-14 17:11:27 -080041#include <gui/Surface.h>
Nicolas Catania1d187f12009-05-12 23:25:55 -070042#include <utils/Errors.h> // for status_t
43#include <utils/String8.h>
Marco Nelissen10dbb8e2009-09-20 10:42:13 -070044#include <utils/SystemClock.h>
Lajos Molnar06ad1522014-08-28 07:27:44 -070045#include <utils/Timers.h>
Nicolas Catania1d187f12009-05-12 23:25:55 -070046#include <utils/Vector.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080047
Eric Laurent43562692015-07-15 16:49:07 -070048#include <media/AudioPolicyHelper.h>
Andreas Huber1b86fe02014-01-29 11:13:26 -080049#include <media/IMediaHTTPService.h>
Jeff Brown2013a542012-09-04 21:38:42 -070050#include <media/IRemoteDisplay.h>
51#include <media/IRemoteDisplayClient.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080052#include <media/MediaPlayerInterface.h>
53#include <media/mediarecorder.h>
54#include <media/MediaMetadataRetrieverInterface.h>
nikoa64c8c72009-07-20 15:07:26 -070055#include <media/Metadata.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080056#include <media/AudioTrack.h>
James Dong8635b7b2011-03-14 17:01:38 -070057#include <media/MemoryLeakTrackUtil.h>
Lajos Molnar1381d4b2014-08-07 15:18:35 -070058#include <media/stagefright/MediaCodecList.h>
Eric Laurent9cb839a2011-09-27 09:48:56 -070059#include <media/stagefright/MediaErrors.h>
Marco Nelissen83b0fd92015-09-16 13:48:07 -070060#include <media/stagefright/Utils.h>
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +010061#include <media/stagefright/foundation/ADebug.h>
Marco Nelissenf09611f2015-02-13 14:12:42 -080062#include <media/stagefright/foundation/ALooperRoster.h>
Chong Zhang181fd9b2017-02-16 15:53:03 -080063#include <media/stagefright/SurfaceUtils.h>
Ruben Brunk99e69712015-05-26 17:25:07 -070064#include <mediautils/BatteryNotifier.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080065
Andy Hung53541292016-04-13 16:48:51 -070066#include <memunreachable/memunreachable.h>
Dima Zavin64760242011-05-11 14:15:23 -070067#include <system/audio.h>
Dima Zavinfce7a472011-04-19 22:30:36 -070068
Gloria Wang7cf180c2011-02-19 18:37:57 -080069#include <private/android_filesystem_config.h>
70
James Dong559bf282012-03-28 10:29:14 -070071#include "ActivityManager.h"
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080072#include "MediaRecorderClient.h"
73#include "MediaPlayerService.h"
74#include "MetadataRetrieverClient.h"
John Grossman44a7e422012-06-21 17:29:24 -070075#include "MediaPlayerFactory.h"
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080076
Nicolas Catania14d27472009-07-13 14:37:49 -070077#include "TestPlayerStub.h"
Andreas Huberf9334412010-12-15 15:17:42 -080078#include "nuplayer/NuPlayerDriver.h"
Andreas Huber20111aa2009-07-14 16:56:47 -070079
Andreas Huber20111aa2009-07-14 16:56:47 -070080#include <OMX.h>
Nicolas Catania14d27472009-07-13 14:37:49 -070081
Andreas Huber59451f82012-09-18 10:36:32 -070082#include "HDCP.h"
Andreas Huberb7319a72013-05-29 14:20:52 -070083#include "HTTPBase.h"
Andreas Huber35213f12012-08-29 11:41:50 -070084#include "RemoteDisplay.h"
Andreas Hubered3e3e02012-03-26 11:13:27 -070085
Wei Jia502c2f42017-07-13 17:47:56 -070086static const int kDumpLockRetries = 50;
87static const int kDumpLockSleepUs = 20000;
88
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -070089namespace {
nikoa64c8c72009-07-20 15:07:26 -070090using android::media::Metadata;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -070091using android::status_t;
92using android::OK;
93using android::BAD_VALUE;
94using android::NOT_ENOUGH_DATA;
95using android::Parcel;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -070096
97// Max number of entries in the filter.
98const int kMaxFilterSize = 64; // I pulled that out of thin air.
99
Andy Hungff874dc2016-04-11 16:49:09 -0700100const float kMaxRequiredSpeed = 8.0f; // for PCM tracks allow up to 8x speedup.
101
nikoa64c8c72009-07-20 15:07:26 -0700102// FIXME: Move all the metadata related function in the Metadata.cpp
nikod608a812009-07-16 16:39:53 -0700103
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700104
105// Unmarshall a filter from a Parcel.
106// Filter format in a parcel:
107//
108// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
109// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
110// | number of entries (n) |
111// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
112// | metadata type 1 |
113// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
114// | metadata type 2 |
115// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
116// ....
117// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
118// | metadata type n |
119// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
120//
121// @param p Parcel that should start with a filter.
122// @param[out] filter On exit contains the list of metadata type to be
123// filtered.
124// @param[out] status On exit contains the status code to be returned.
125// @return true if the parcel starts with a valid filter.
126bool unmarshallFilter(const Parcel& p,
nikoa64c8c72009-07-20 15:07:26 -0700127 Metadata::Filter *filter,
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700128 status_t *status)
129{
Nicolas Catania48290382009-07-10 13:53:06 -0700130 int32_t val;
131 if (p.readInt32(&val) != OK)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700132 {
Steve Block29357bc2012-01-06 19:20:56 +0000133 ALOGE("Failed to read filter's length");
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700134 *status = NOT_ENOUGH_DATA;
135 return false;
136 }
137
Nicolas Catania48290382009-07-10 13:53:06 -0700138 if( val > kMaxFilterSize || val < 0)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700139 {
Steve Block29357bc2012-01-06 19:20:56 +0000140 ALOGE("Invalid filter len %d", val);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700141 *status = BAD_VALUE;
142 return false;
143 }
144
Nicolas Catania48290382009-07-10 13:53:06 -0700145 const size_t num = val;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700146
147 filter->clear();
Nicolas Catania48290382009-07-10 13:53:06 -0700148 filter->setCapacity(num);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700149
nikoa64c8c72009-07-20 15:07:26 -0700150 size_t size = num * sizeof(Metadata::Type);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700151
Nicolas Catania48290382009-07-10 13:53:06 -0700152
153 if (p.dataAvail() < size)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700154 {
Andy Hung833b4752016-04-04 17:15:48 -0700155 ALOGE("Filter too short expected %zu but got %zu", size, p.dataAvail());
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700156 *status = NOT_ENOUGH_DATA;
157 return false;
158 }
159
nikoa64c8c72009-07-20 15:07:26 -0700160 const Metadata::Type *data =
161 static_cast<const Metadata::Type*>(p.readInplace(size));
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700162
Nicolas Catania48290382009-07-10 13:53:06 -0700163 if (NULL == data)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700164 {
Steve Block29357bc2012-01-06 19:20:56 +0000165 ALOGE("Filter had no data");
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700166 *status = BAD_VALUE;
167 return false;
168 }
169
170 // TODO: The stl impl of vector would be more efficient here
171 // because it degenerates into a memcpy on pod types. Try to
172 // replace later or use stl::set.
Nicolas Catania48290382009-07-10 13:53:06 -0700173 for (size_t i = 0; i < num; ++i)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700174 {
Nicolas Catania48290382009-07-10 13:53:06 -0700175 filter->add(*data);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700176 ++data;
177 }
178 *status = OK;
179 return true;
180}
181
Nicolas Catania48290382009-07-10 13:53:06 -0700182// @param filter Of metadata type.
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700183// @param val To be searched.
184// @return true if a match was found.
nikoa64c8c72009-07-20 15:07:26 -0700185bool findMetadata(const Metadata::Filter& filter, const int32_t val)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700186{
187 // Deal with empty and ANY right away
188 if (filter.isEmpty()) return false;
nikoa64c8c72009-07-20 15:07:26 -0700189 if (filter[0] == Metadata::kAny) return true;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700190
Nicolas Catania48290382009-07-10 13:53:06 -0700191 return filter.indexOf(val) >= 0;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700192}
193
194} // anonymous namespace
195
196
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700197namespace {
198using android::Parcel;
199using android::String16;
200
201// marshalling tag indicating flattened utf16 tags
202// keep in sync with frameworks/base/media/java/android/media/AudioAttributes.java
203const int32_t kAudioAttributesMarshallTagFlattenTags = 1;
204
205// Audio attributes format in a parcel:
206//
207// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
208// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
209// | usage |
210// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
211// | content_type |
212// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Hyejin Kim4f418f92014-09-05 15:50:03 +0900213// | source |
214// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700215// | flags |
216// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
217// | kAudioAttributesMarshallTagFlattenTags | // ignore tags if not found
218// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
219// | flattened tags in UTF16 |
220// | ... |
221// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
222//
223// @param p Parcel that contains audio attributes.
224// @param[out] attributes On exit points to an initialized audio_attributes_t structure
225// @param[out] status On exit contains the status code to be returned.
226void unmarshallAudioAttributes(const Parcel& parcel, audio_attributes_t *attributes)
227{
228 attributes->usage = (audio_usage_t) parcel.readInt32();
229 attributes->content_type = (audio_content_type_t) parcel.readInt32();
Hyejin Kim4f418f92014-09-05 15:50:03 +0900230 attributes->source = (audio_source_t) parcel.readInt32();
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700231 attributes->flags = (audio_flags_mask_t) parcel.readInt32();
232 const bool hasFlattenedTag = (parcel.readInt32() == kAudioAttributesMarshallTagFlattenTags);
233 if (hasFlattenedTag) {
234 // the tags are UTF16, convert to UTF8
235 String16 tags = parcel.readString16();
236 ssize_t realTagSize = utf16_to_utf8_length(tags.string(), tags.size());
237 if (realTagSize <= 0) {
238 strcpy(attributes->tags, "");
239 } else {
240 // copy the flattened string into the attributes as the destination for the conversion:
241 // copying array size -1, array for tags was calloc'd, no need to NULL-terminate it
242 size_t tagSize = realTagSize > AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1 ?
243 AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1 : realTagSize;
Sergio Giro1d3f4272016-06-28 18:24:52 +0100244 utf16_to_utf8(tags.string(), tagSize, attributes->tags,
245 sizeof(attributes->tags) / sizeof(attributes->tags[0]));
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700246 }
247 } else {
248 ALOGE("unmarshallAudioAttributes() received unflattened tags, ignoring tag values");
249 strcpy(attributes->tags, "");
250 }
251}
252} // anonymous namespace
253
254
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800255namespace android {
256
Marco Nelissenf09611f2015-02-13 14:12:42 -0800257extern ALooperRoster gLooperRoster;
258
259
Dave Burked681bbb2011-08-30 14:39:17 +0100260static bool checkPermission(const char* permissionString) {
Dave Burked681bbb2011-08-30 14:39:17 +0100261 if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
262 bool ok = checkCallingPermission(String16(permissionString));
Steve Block29357bc2012-01-06 19:20:56 +0000263 if (!ok) ALOGE("Request requires %s", permissionString);
Dave Burked681bbb2011-08-30 14:39:17 +0100264 return ok;
265}
266
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800267// TODO: Find real cause of Audio/Video delay in PV framework and remove this workaround
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800268/* static */ int MediaPlayerService::AudioOutput::mMinBufferCount = 4;
269/* static */ bool MediaPlayerService::AudioOutput::mIsOnEmulator = false;
270
271void MediaPlayerService::instantiate() {
272 defaultServiceManager()->addService(
273 String16("media.player"), new MediaPlayerService());
274}
275
276MediaPlayerService::MediaPlayerService()
277{
Steve Block3856b092011-10-20 11:56:00 +0100278 ALOGV("MediaPlayerService created");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800279 mNextConnId = 1;
Gloria Wang9ee159b2011-02-24 14:51:45 -0800280
John Grossman44a7e422012-06-21 17:29:24 -0700281 MediaPlayerFactory::registerBuiltinFactories();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800282}
283
284MediaPlayerService::~MediaPlayerService()
285{
Steve Block3856b092011-10-20 11:56:00 +0100286 ALOGV("MediaPlayerService destroyed");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800287}
288
Svet Ganovbe71aa22015-04-28 12:06:02 -0700289sp<IMediaRecorder> MediaPlayerService::createMediaRecorder(const String16 &opPackageName)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800290{
Glenn Kastenf37971f2012-02-03 11:06:53 -0800291 pid_t pid = IPCThreadState::self()->getCallingPid();
Svet Ganovbe71aa22015-04-28 12:06:02 -0700292 sp<MediaRecorderClient> recorder = new MediaRecorderClient(this, pid, opPackageName);
Gloria Wangdac6a312009-10-29 15:46:37 -0700293 wp<MediaRecorderClient> w = recorder;
294 Mutex::Autolock lock(mLock);
295 mMediaRecorderClients.add(w);
Steve Block3856b092011-10-20 11:56:00 +0100296 ALOGV("Create new media recorder client from pid %d", pid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800297 return recorder;
298}
299
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700300void MediaPlayerService::removeMediaRecorderClient(const wp<MediaRecorderClient>& client)
Gloria Wangdac6a312009-10-29 15:46:37 -0700301{
302 Mutex::Autolock lock(mLock);
303 mMediaRecorderClients.remove(client);
Steve Block3856b092011-10-20 11:56:00 +0100304 ALOGV("Delete media recorder client");
Gloria Wangdac6a312009-10-29 15:46:37 -0700305}
306
Glenn Kastenf37971f2012-02-03 11:06:53 -0800307sp<IMediaMetadataRetriever> MediaPlayerService::createMetadataRetriever()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800308{
Glenn Kastenf37971f2012-02-03 11:06:53 -0800309 pid_t pid = IPCThreadState::self()->getCallingPid();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800310 sp<MetadataRetrieverClient> retriever = new MetadataRetrieverClient(pid);
Steve Block3856b092011-10-20 11:56:00 +0100311 ALOGV("Create new media retriever from pid %d", pid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800312 return retriever;
313}
314
Glenn Kastenf37971f2012-02-03 11:06:53 -0800315sp<IMediaPlayer> MediaPlayerService::create(const sp<IMediaPlayerClient>& client,
Glenn Kastend848eb42016-03-08 13:42:11 -0800316 audio_session_t audioSessionId)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800317{
Glenn Kastenf37971f2012-02-03 11:06:53 -0800318 pid_t pid = IPCThreadState::self()->getCallingPid();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800319 int32_t connId = android_atomic_inc(&mNextConnId);
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700320
321 sp<Client> c = new Client(
322 this, pid, connId, client, audioSessionId,
323 IPCThreadState::self()->getCallingUid());
324
Steve Block3856b092011-10-20 11:56:00 +0100325 ALOGV("Create new client(%d) from pid %d, uid %d, ", connId, pid,
Dave Burked681bbb2011-08-30 14:39:17 +0100326 IPCThreadState::self()->getCallingUid());
327
328 wp<Client> w = c;
329 {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800330 Mutex::Autolock lock(mLock);
331 mClients.add(w);
332 }
Andreas Hubere2b10282010-11-23 11:41:34 -0800333 return c;
334}
335
Lajos Molnar1381d4b2014-08-07 15:18:35 -0700336sp<IMediaCodecList> MediaPlayerService::getCodecList() const {
337 return MediaCodecList::getLocalInstance();
338}
339
Marco Nelissen260e56c2016-01-28 21:41:25 +0000340sp<IOMX> MediaPlayerService::getOMX() {
Marco Nelissen1900e772016-02-02 16:12:16 -0800341 ALOGI("MediaPlayerService::getOMX");
Marco Nelissen260e56c2016-01-28 21:41:25 +0000342 Mutex::Autolock autoLock(mLock);
343
344 if (mOMX.get() == NULL) {
345 mOMX = new OMX;
346 }
347
348 return mOMX;
349}
350
Andreas Huber279dcd82013-01-30 10:41:25 -0800351sp<IHDCP> MediaPlayerService::makeHDCP(bool createEncryptionModule) {
352 return new HDCP(createEncryptionModule);
Andreas Huber59451f82012-09-18 10:36:32 -0700353}
354
Jeff Brown2013a542012-09-04 21:38:42 -0700355sp<IRemoteDisplay> MediaPlayerService::listenForRemoteDisplay(
Svet Ganovbe71aa22015-04-28 12:06:02 -0700356 const String16 &opPackageName,
Jeff Brown2013a542012-09-04 21:38:42 -0700357 const sp<IRemoteDisplayClient>& client, const String8& iface) {
Jeff Brownaba33d52012-09-07 17:38:58 -0700358 if (!checkPermission("android.permission.CONTROL_WIFI_DISPLAY")) {
359 return NULL;
360 }
361
Svet Ganovbe71aa22015-04-28 12:06:02 -0700362 return new RemoteDisplay(opPackageName, client, iface.string());
Jeff Brown2013a542012-09-04 21:38:42 -0700363}
364
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800365status_t MediaPlayerService::AudioOutput::dump(int fd, const Vector<String16>& args) const
366{
367 const size_t SIZE = 256;
368 char buffer[SIZE];
369 String8 result;
370
371 result.append(" AudioOutput\n");
372 snprintf(buffer, 255, " stream type(%d), left - right volume(%f, %f)\n",
373 mStreamType, mLeftVolume, mRightVolume);
374 result.append(buffer);
375 snprintf(buffer, 255, " msec per frame(%f), latency (%d)\n",
Eric Laurentdb354e52012-03-05 17:27:11 -0800376 mMsecsPerFrame, (mTrack != 0) ? mTrack->latency() : -1);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800377 result.append(buffer);
Eric Laurent2beeb502010-07-16 07:43:46 -0700378 snprintf(buffer, 255, " aux effect id(%d), send level (%f)\n",
379 mAuxEffectId, mSendLevel);
380 result.append(buffer);
381
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800382 ::write(fd, result.string(), result.size());
383 if (mTrack != 0) {
384 mTrack->dump(fd, args);
385 }
386 return NO_ERROR;
387}
388
Lajos Molnar6d339f12015-04-17 16:15:53 -0700389status_t MediaPlayerService::Client::dump(int fd, const Vector<String16>& args)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800390{
391 const size_t SIZE = 256;
392 char buffer[SIZE];
393 String8 result;
394 result.append(" Client\n");
395 snprintf(buffer, 255, " pid(%d), connId(%d), status(%d), looping(%s)\n",
396 mPid, mConnId, mStatus, mLoop?"true": "false");
397 result.append(buffer);
Wei Jia502c2f42017-07-13 17:47:56 -0700398
399 sp<MediaPlayerBase> p;
400 sp<AudioOutput> audioOutput;
401 bool locked = false;
402 for (int i = 0; i < kDumpLockRetries; ++i) {
403 if (mLock.tryLock() == NO_ERROR) {
404 locked = true;
405 break;
406 }
407 usleep(kDumpLockSleepUs);
Andreas Hubera0b1d4b2011-06-07 15:52:25 -0700408 }
Wei Jia502c2f42017-07-13 17:47:56 -0700409
410 if (locked) {
411 p = mPlayer;
412 audioOutput = mAudioOutput;
413 mLock.unlock();
414 } else {
415 result.append(" lock is taken, no dump from player and audio output\n");
416 }
417 write(fd, result.string(), result.size());
418
419 if (p != NULL) {
420 p->dump(fd, args);
421 }
422 if (audioOutput != 0) {
423 audioOutput->dump(fd, args);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800424 }
425 write(fd, "\n", 1);
426 return NO_ERROR;
427}
428
Marco Nelissenf09611f2015-02-13 14:12:42 -0800429/**
430 * The only arguments this understands right now are -c, -von and -voff,
431 * which are parsed by ALooperRoster::dump()
432 */
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800433status_t MediaPlayerService::dump(int fd, const Vector<String16>& args)
434{
435 const size_t SIZE = 256;
436 char buffer[SIZE];
437 String8 result;
Ravi Kumar Alamanda330c8e32014-12-22 10:05:29 +0530438 SortedVector< sp<Client> > clients; //to serialise the mutex unlock & client destruction.
439 SortedVector< sp<MediaRecorderClient> > mediaRecorderClients;
440
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800441 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
442 snprintf(buffer, SIZE, "Permission Denial: "
443 "can't dump MediaPlayerService from pid=%d, uid=%d\n",
444 IPCThreadState::self()->getCallingPid(),
445 IPCThreadState::self()->getCallingUid());
446 result.append(buffer);
447 } else {
448 Mutex::Autolock lock(mLock);
449 for (int i = 0, n = mClients.size(); i < n; ++i) {
450 sp<Client> c = mClients[i].promote();
451 if (c != 0) c->dump(fd, args);
Ravi Kumar Alamanda330c8e32014-12-22 10:05:29 +0530452 clients.add(c);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800453 }
James Dongb9141222010-07-08 11:16:11 -0700454 if (mMediaRecorderClients.size() == 0) {
455 result.append(" No media recorder client\n\n");
456 } else {
457 for (int i = 0, n = mMediaRecorderClients.size(); i < n; ++i) {
458 sp<MediaRecorderClient> c = mMediaRecorderClients[i].promote();
James Donge579e282011-10-18 22:29:20 -0700459 if (c != 0) {
460 snprintf(buffer, 255, " MediaRecorderClient pid(%d)\n", c->mPid);
461 result.append(buffer);
462 write(fd, result.string(), result.size());
463 result = "\n";
464 c->dump(fd, args);
Ravi Kumar Alamanda330c8e32014-12-22 10:05:29 +0530465 mediaRecorderClients.add(c);
James Donge579e282011-10-18 22:29:20 -0700466 }
James Dongb9141222010-07-08 11:16:11 -0700467 }
Gloria Wangdac6a312009-10-29 15:46:37 -0700468 }
469
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800470 result.append(" Files opened and/or mapped:\n");
Marco Nelissenf09611f2015-02-13 14:12:42 -0800471 snprintf(buffer, SIZE, "/proc/%d/maps", getpid());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800472 FILE *f = fopen(buffer, "r");
473 if (f) {
474 while (!feof(f)) {
475 fgets(buffer, SIZE, f);
Marco Nelissen73ac1ee2012-05-07 15:36:32 -0700476 if (strstr(buffer, " /storage/") ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800477 strstr(buffer, " /system/sounds/") ||
Dave Sparks02fa8342010-09-27 16:55:18 -0700478 strstr(buffer, " /data/") ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800479 strstr(buffer, " /system/media/")) {
480 result.append(" ");
481 result.append(buffer);
482 }
483 }
484 fclose(f);
485 } else {
486 result.append("couldn't open ");
487 result.append(buffer);
488 result.append("\n");
489 }
490
Marco Nelissenf09611f2015-02-13 14:12:42 -0800491 snprintf(buffer, SIZE, "/proc/%d/fd", getpid());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800492 DIR *d = opendir(buffer);
493 if (d) {
494 struct dirent *ent;
495 while((ent = readdir(d)) != NULL) {
496 if (strcmp(ent->d_name,".") && strcmp(ent->d_name,"..")) {
Marco Nelissenf09611f2015-02-13 14:12:42 -0800497 snprintf(buffer, SIZE, "/proc/%d/fd/%s", getpid(), ent->d_name);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800498 struct stat s;
499 if (lstat(buffer, &s) == 0) {
500 if ((s.st_mode & S_IFMT) == S_IFLNK) {
501 char linkto[256];
502 int len = readlink(buffer, linkto, sizeof(linkto));
503 if(len > 0) {
504 if(len > 255) {
505 linkto[252] = '.';
506 linkto[253] = '.';
507 linkto[254] = '.';
508 linkto[255] = 0;
509 } else {
510 linkto[len] = 0;
511 }
Marco Nelissen73ac1ee2012-05-07 15:36:32 -0700512 if (strstr(linkto, "/storage/") == linkto ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800513 strstr(linkto, "/system/sounds/") == linkto ||
Dave Sparks02fa8342010-09-27 16:55:18 -0700514 strstr(linkto, "/data/") == linkto ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800515 strstr(linkto, "/system/media/") == linkto) {
516 result.append(" ");
517 result.append(buffer);
518 result.append(" -> ");
519 result.append(linkto);
520 result.append("\n");
521 }
522 }
523 } else {
524 result.append(" unexpected type for ");
525 result.append(buffer);
526 result.append("\n");
527 }
528 }
529 }
530 }
531 closedir(d);
532 } else {
533 result.append("couldn't open ");
534 result.append(buffer);
535 result.append("\n");
536 }
537
Marco Nelissenf09611f2015-02-13 14:12:42 -0800538 gLooperRoster.dump(fd, args);
539
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800540 bool dumpMem = false;
Andy Hung53541292016-04-13 16:48:51 -0700541 bool unreachableMemory = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800542 for (size_t i = 0; i < args.size(); i++) {
543 if (args[i] == String16("-m")) {
544 dumpMem = true;
Andy Hung53541292016-04-13 16:48:51 -0700545 } else if (args[i] == String16("--unreachable")) {
546 unreachableMemory = true;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800547 }
548 }
549 if (dumpMem) {
Andy Hung07b745e2016-05-23 16:21:07 -0700550 result.append("\nDumping memory:\n");
551 std::string s = dumpMemoryAddresses(100 /* limit */);
552 result.append(s.c_str(), s.size());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800553 }
Andy Hung53541292016-04-13 16:48:51 -0700554 if (unreachableMemory) {
555 result.append("\nDumping unreachable memory:\n");
556 // TODO - should limit be an argument parameter?
557 std::string s = GetUnreachableMemoryString(true /* contents */, 10000 /* limit */);
558 result.append(s.c_str(), s.size());
559 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800560 }
561 write(fd, result.string(), result.size());
562 return NO_ERROR;
563}
564
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700565void MediaPlayerService::removeClient(const wp<Client>& client)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800566{
567 Mutex::Autolock lock(mLock);
568 mClients.remove(client);
569}
570
Robert Shihee0a0e32016-08-16 16:50:54 -0700571bool MediaPlayerService::hasClient(wp<Client> client)
572{
573 Mutex::Autolock lock(mLock);
574 return mClients.indexOf(client) != NAME_NOT_FOUND;
575}
576
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700577MediaPlayerService::Client::Client(
578 const sp<MediaPlayerService>& service, pid_t pid,
579 int32_t connId, const sp<IMediaPlayerClient>& client,
Glenn Kastend848eb42016-03-08 13:42:11 -0800580 audio_session_t audioSessionId, uid_t uid)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800581{
Steve Block3856b092011-10-20 11:56:00 +0100582 ALOGV("Client(%d) constructor", connId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800583 mPid = pid;
584 mConnId = connId;
585 mService = service;
586 mClient = client;
587 mLoop = false;
588 mStatus = NO_INIT;
Eric Laurenta514bdb2010-06-21 09:27:30 -0700589 mAudioSessionId = audioSessionId;
Andy Hung1afd0982016-11-08 16:13:44 -0800590 mUid = uid;
John Grossmanc795b642012-02-22 15:38:35 -0800591 mRetransmitEndpointValid = false;
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700592 mAudioAttributes = NULL;
Eric Laurenta514bdb2010-06-21 09:27:30 -0700593
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800594#if CALLBACK_ANTAGONIZER
Steve Blockb8a80522011-12-20 16:23:08 +0000595 ALOGD("create Antagonizer");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800596 mAntagonizer = new Antagonizer(notify, this);
597#endif
598}
599
600MediaPlayerService::Client::~Client()
601{
Steve Block3856b092011-10-20 11:56:00 +0100602 ALOGV("Client(%d) destructor pid = %d", mConnId, mPid);
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700603 mAudioOutput.clear();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800604 wp<Client> client(this);
605 disconnect();
606 mService->removeClient(client);
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700607 if (mAudioAttributes != NULL) {
608 free(mAudioAttributes);
609 }
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700610 clearDeathNotifiers_l();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800611}
612
613void MediaPlayerService::Client::disconnect()
614{
Steve Block3856b092011-10-20 11:56:00 +0100615 ALOGV("disconnect(%d) from pid %d", mConnId, mPid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800616 // grab local reference and clear main reference to prevent future
617 // access to object
618 sp<MediaPlayerBase> p;
619 {
620 Mutex::Autolock l(mLock);
621 p = mPlayer;
beanzdcfefde2012-11-05 09:51:43 +0800622 mClient.clear();
Wei Jia502c2f42017-07-13 17:47:56 -0700623 mPlayer.clear();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800624 }
Andreas Huber20111aa2009-07-14 16:56:47 -0700625
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800626 // clear the notification to prevent callbacks to dead client
627 // and reset the player. We assume the player will serialize
628 // access to itself if necessary.
629 if (p != 0) {
630 p->setNotifyCallback(0, 0);
631#if CALLBACK_ANTAGONIZER
Steve Blockb8a80522011-12-20 16:23:08 +0000632 ALOGD("kill Antagonizer");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800633 mAntagonizer->kill();
634#endif
635 p->reset();
636 }
637
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700638 {
639 Mutex::Autolock l(mLock);
640 disconnectNativeWindow_l();
641 }
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700642
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800643 IPCThreadState::self()->flushCommands();
644}
645
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800646sp<MediaPlayerBase> MediaPlayerService::Client::createPlayer(player_type playerType)
647{
648 // determine if we have the right player type
Wei Jia502c2f42017-07-13 17:47:56 -0700649 sp<MediaPlayerBase> p = getPlayer();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800650 if ((p != NULL) && (p->playerType() != playerType)) {
Steve Block3856b092011-10-20 11:56:00 +0100651 ALOGV("delete player");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800652 p.clear();
653 }
654 if (p == NULL) {
Ronghua Wu68845c12015-07-21 09:50:48 -0700655 p = MediaPlayerFactory::createPlayer(playerType, this, notify, mPid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800656 }
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700657
Jason Simmonsdb29e522011-08-12 13:46:55 -0700658 if (p != NULL) {
Andy Hung1afd0982016-11-08 16:13:44 -0800659 p->setUID(mUid);
Jason Simmonsdb29e522011-08-12 13:46:55 -0700660 }
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700661
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800662 return p;
663}
664
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700665MediaPlayerService::Client::ServiceDeathNotifier::ServiceDeathNotifier(
666 const sp<IBinder>& service,
667 const sp<MediaPlayerBase>& listener,
668 int which) {
669 mService = service;
Pawin Vongmasa9c47c972017-02-08 04:09:38 -0800670 mOmx = nullptr;
671 mListener = listener;
672 mWhich = which;
673}
674
675MediaPlayerService::Client::ServiceDeathNotifier::ServiceDeathNotifier(
676 const sp<IOmx>& omx,
677 const sp<MediaPlayerBase>& listener,
678 int which) {
679 mService = nullptr;
680 mOmx = omx;
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700681 mListener = listener;
682 mWhich = which;
683}
684
685MediaPlayerService::Client::ServiceDeathNotifier::~ServiceDeathNotifier() {
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700686}
687
688void MediaPlayerService::Client::ServiceDeathNotifier::binderDied(const wp<IBinder>& /*who*/) {
689 sp<MediaPlayerBase> listener = mListener.promote();
690 if (listener != NULL) {
691 listener->sendEvent(MEDIA_ERROR, MEDIA_ERROR_SERVER_DIED, mWhich);
692 } else {
693 ALOGW("listener for process %d death is gone", mWhich);
694 }
695}
696
Pawin Vongmasa9c47c972017-02-08 04:09:38 -0800697void MediaPlayerService::Client::ServiceDeathNotifier::serviceDied(
698 uint64_t /* cookie */,
699 const wp<::android::hidl::base::V1_0::IBase>& /* who */) {
700 sp<MediaPlayerBase> listener = mListener.promote();
701 if (listener != NULL) {
702 listener->sendEvent(MEDIA_ERROR, MEDIA_ERROR_SERVER_DIED, mWhich);
703 } else {
704 ALOGW("listener for process %d death is gone", mWhich);
705 }
706}
707
708void MediaPlayerService::Client::ServiceDeathNotifier::unlinkToDeath() {
709 if (mService != nullptr) {
710 mService->unlinkToDeath(this);
711 mService = nullptr;
712 } else if (mOmx != nullptr) {
713 mOmx->unlinkToDeath(this);
714 mOmx = nullptr;
715 }
716}
717
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700718void MediaPlayerService::Client::clearDeathNotifiers_l() {
Pawin Vongmasa9c47c972017-02-08 04:09:38 -0800719 if (mExtractorDeathListener != nullptr) {
720 mExtractorDeathListener->unlinkToDeath();
721 mExtractorDeathListener = nullptr;
722 }
723 if (mCodecDeathListener != nullptr) {
724 mCodecDeathListener->unlinkToDeath();
725 mCodecDeathListener = nullptr;
726 }
727}
728
John Grossmanc795b642012-02-22 15:38:35 -0800729sp<MediaPlayerBase> MediaPlayerService::Client::setDataSource_pre(
730 player_type playerType)
731{
732 ALOGV("player type = %d", playerType);
733
734 // create the right type of player
735 sp<MediaPlayerBase> p = createPlayer(playerType);
736 if (p == NULL) {
737 return p;
738 }
739
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700740 sp<IServiceManager> sm = defaultServiceManager();
741 sp<IBinder> binder = sm->getService(String16("media.extractor"));
Marco Nelissen1b5a7ee2016-09-30 13:54:30 -0700742 if (binder == NULL) {
743 ALOGE("extractor service not available");
744 return NULL;
745 }
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700746 sp<ServiceDeathNotifier> extractorDeathListener =
747 new ServiceDeathNotifier(binder, p, MEDIAEXTRACTOR_PROCESS_DEATH);
748 binder->linkToDeath(extractorDeathListener);
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700749
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700750 sp<ServiceDeathNotifier> codecDeathListener;
Pawin Vongmasad4e9ca42017-03-29 17:24:56 -0700751 if (property_get_bool("persist.media.treble_omx", true)) {
Pawin Vongmasa9c47c972017-02-08 04:09:38 -0800752 // Treble IOmx
753 sp<IOmx> omx = IOmx::getService();
754 if (omx == nullptr) {
755 ALOGE("Treble IOmx not available");
756 return NULL;
757 }
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700758 codecDeathListener = new ServiceDeathNotifier(omx, p, MEDIACODEC_PROCESS_DEATH);
759 omx->linkToDeath(codecDeathListener, 0);
Pawin Vongmasa9c47c972017-02-08 04:09:38 -0800760 } else {
761 // Legacy IOMX
762 binder = sm->getService(String16("media.codec"));
763 if (binder == NULL) {
764 ALOGE("codec service not available");
765 return NULL;
766 }
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700767 codecDeathListener = new ServiceDeathNotifier(binder, p, MEDIACODEC_PROCESS_DEATH);
768 binder->linkToDeath(codecDeathListener);
Marco Nelissen1b5a7ee2016-09-30 13:54:30 -0700769 }
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700770
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700771 Mutex::Autolock lock(mLock);
772
773 clearDeathNotifiers_l();
774 mExtractorDeathListener = extractorDeathListener;
775 mCodecDeathListener = codecDeathListener;
776
John Grossmanc795b642012-02-22 15:38:35 -0800777 if (!p->hardwareOutput()) {
Marco Nelissend457c972014-02-11 08:47:07 -0800778 mAudioOutput = new AudioOutput(mAudioSessionId, IPCThreadState::self()->getCallingUid(),
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700779 mPid, mAudioAttributes);
John Grossmanc795b642012-02-22 15:38:35 -0800780 static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
781 }
782
783 return p;
784}
785
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700786status_t MediaPlayerService::Client::setDataSource_post(
John Grossmanc795b642012-02-22 15:38:35 -0800787 const sp<MediaPlayerBase>& p,
788 status_t status)
789{
790 ALOGV(" setDataSource");
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700791 if (status != OK) {
792 ALOGE(" error: %d", status);
793 return status;
John Grossmanc795b642012-02-22 15:38:35 -0800794 }
795
796 // Set the re-transmission endpoint if one was chosen.
797 if (mRetransmitEndpointValid) {
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700798 status = p->setRetransmitEndpoint(&mRetransmitEndpoint);
799 if (status != NO_ERROR) {
800 ALOGE("setRetransmitEndpoint error: %d", status);
John Grossmanc795b642012-02-22 15:38:35 -0800801 }
802 }
803
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700804 if (status == OK) {
805 Mutex::Autolock lock(mLock);
John Grossmanc795b642012-02-22 15:38:35 -0800806 mPlayer = p;
807 }
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700808 return status;
John Grossmanc795b642012-02-22 15:38:35 -0800809}
810
Andreas Huber2db84552010-01-28 11:19:57 -0800811status_t MediaPlayerService::Client::setDataSource(
Andreas Huber1b86fe02014-01-29 11:13:26 -0800812 const sp<IMediaHTTPService> &httpService,
813 const char *url,
814 const KeyedVector<String8, String8> *headers)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800815{
Steve Block3856b092011-10-20 11:56:00 +0100816 ALOGV("setDataSource(%s)", url);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800817 if (url == NULL)
818 return UNKNOWN_ERROR;
819
Dave Burked681bbb2011-08-30 14:39:17 +0100820 if ((strncmp(url, "http://", 7) == 0) ||
821 (strncmp(url, "https://", 8) == 0) ||
822 (strncmp(url, "rtsp://", 7) == 0)) {
823 if (!checkPermission("android.permission.INTERNET")) {
824 return PERMISSION_DENIED;
825 }
826 }
827
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800828 if (strncmp(url, "content://", 10) == 0) {
829 // get a filedescriptor for the content Uri and
830 // pass it to the setDataSource(fd) method
831
832 String16 url16(url);
833 int fd = android::openContentProviderFile(url16);
834 if (fd < 0)
835 {
Steve Block29357bc2012-01-06 19:20:56 +0000836 ALOGE("Couldn't open fd for %s", url);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800837 return UNKNOWN_ERROR;
838 }
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700839 status_t status = setDataSource(fd, 0, 0x7fffffffffLL); // this sets mStatus
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800840 close(fd);
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700841 return mStatus = status;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800842 } else {
John Grossman44a7e422012-06-21 17:29:24 -0700843 player_type playerType = MediaPlayerFactory::getPlayerType(this, url);
John Grossmanc795b642012-02-22 15:38:35 -0800844 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
845 if (p == NULL) {
846 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800847 }
848
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700849 return mStatus =
850 setDataSource_post(
851 p, p->setDataSource(httpService, url, headers));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800852 }
853}
854
855status_t MediaPlayerService::Client::setDataSource(int fd, int64_t offset, int64_t length)
856{
Marco Nelissen83b0fd92015-09-16 13:48:07 -0700857 ALOGV("setDataSource fd=%d (%s), offset=%lld, length=%lld",
858 fd, nameForFd(fd).c_str(), (long long) offset, (long long) length);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800859 struct stat sb;
860 int ret = fstat(fd, &sb);
861 if (ret != 0) {
Steve Block29357bc2012-01-06 19:20:56 +0000862 ALOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800863 return UNKNOWN_ERROR;
864 }
865
Andy Hung833b4752016-04-04 17:15:48 -0700866 ALOGV("st_dev = %llu", static_cast<unsigned long long>(sb.st_dev));
Steve Block3856b092011-10-20 11:56:00 +0100867 ALOGV("st_mode = %u", sb.st_mode);
Mark Salyzyn77342f72014-06-18 16:31:32 -0700868 ALOGV("st_uid = %lu", static_cast<unsigned long>(sb.st_uid));
869 ALOGV("st_gid = %lu", static_cast<unsigned long>(sb.st_gid));
Andy Hung833b4752016-04-04 17:15:48 -0700870 ALOGV("st_size = %llu", static_cast<unsigned long long>(sb.st_size));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800871
872 if (offset >= sb.st_size) {
Steve Block29357bc2012-01-06 19:20:56 +0000873 ALOGE("offset error");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800874 return UNKNOWN_ERROR;
875 }
876 if (offset + length > sb.st_size) {
877 length = sb.st_size - offset;
Andy Hung833b4752016-04-04 17:15:48 -0700878 ALOGV("calculated length = %lld", (long long)length);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800879 }
880
John Grossman44a7e422012-06-21 17:29:24 -0700881 player_type playerType = MediaPlayerFactory::getPlayerType(this,
882 fd,
883 offset,
884 length);
John Grossmanc795b642012-02-22 15:38:35 -0800885 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
886 if (p == NULL) {
887 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800888 }
889
890 // now set data source
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700891 return mStatus = setDataSource_post(p, p->setDataSource(fd, offset, length));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800892}
893
Andreas Hubere2b10282010-11-23 11:41:34 -0800894status_t MediaPlayerService::Client::setDataSource(
895 const sp<IStreamSource> &source) {
896 // create the right type of player
John Grossman44a7e422012-06-21 17:29:24 -0700897 player_type playerType = MediaPlayerFactory::getPlayerType(this, source);
John Grossmanc795b642012-02-22 15:38:35 -0800898 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
Andreas Hubere2b10282010-11-23 11:41:34 -0800899 if (p == NULL) {
900 return NO_INIT;
901 }
902
Andreas Hubere2b10282010-11-23 11:41:34 -0800903 // now set data source
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700904 return mStatus = setDataSource_post(p, p->setDataSource(source));
Andreas Hubere2b10282010-11-23 11:41:34 -0800905}
906
Chris Watkins99f31602015-03-20 13:06:33 -0700907status_t MediaPlayerService::Client::setDataSource(
908 const sp<IDataSource> &source) {
909 sp<DataSource> dataSource = DataSource::CreateFromIDataSource(source);
910 player_type playerType = MediaPlayerFactory::getPlayerType(this, dataSource);
911 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
912 if (p == NULL) {
913 return NO_INIT;
914 }
915 // now set data source
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700916 return mStatus = setDataSource_post(p, p->setDataSource(dataSource));
Chris Watkins99f31602015-03-20 13:06:33 -0700917}
918
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700919void MediaPlayerService::Client::disconnectNativeWindow_l() {
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700920 if (mConnectedWindow != NULL) {
Chong Zhang181fd9b2017-02-16 15:53:03 -0800921 status_t err = nativeWindowDisconnect(
922 mConnectedWindow.get(), "disconnectNativeWindow");
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700923
924 if (err != OK) {
Chong Zhang181fd9b2017-02-16 15:53:03 -0800925 ALOGW("nativeWindowDisconnect returned an error: %s (%d)",
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700926 strerror(-err), err);
927 }
928 }
929 mConnectedWindow.clear();
930}
931
Glenn Kasten11731182011-02-08 17:26:17 -0800932status_t MediaPlayerService::Client::setVideoSurfaceTexture(
Andy McFadden484566c2012-12-18 09:46:54 -0800933 const sp<IGraphicBufferProducer>& bufferProducer)
Glenn Kasten11731182011-02-08 17:26:17 -0800934{
Andy McFadden484566c2012-12-18 09:46:54 -0800935 ALOGV("[%d] setVideoSurfaceTexture(%p)", mConnId, bufferProducer.get());
Glenn Kasten11731182011-02-08 17:26:17 -0800936 sp<MediaPlayerBase> p = getPlayer();
937 if (p == 0) return UNKNOWN_ERROR;
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700938
Marco Nelissenf8880202014-11-14 07:58:25 -0800939 sp<IBinder> binder(IInterface::asBinder(bufferProducer));
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700940 if (mConnectedWindowBinder == binder) {
941 return OK;
942 }
943
944 sp<ANativeWindow> anw;
Andy McFadden484566c2012-12-18 09:46:54 -0800945 if (bufferProducer != NULL) {
Marco Nelissenee08f7e2013-09-16 13:30:01 -0700946 anw = new Surface(bufferProducer, true /* controlledByApp */);
Chong Zhang181fd9b2017-02-16 15:53:03 -0800947 status_t err = nativeWindowConnect(anw.get(), "setVideoSurfaceTexture");
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700948
949 if (err != OK) {
Steve Block29357bc2012-01-06 19:20:56 +0000950 ALOGE("setVideoSurfaceTexture failed: %d", err);
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700951 // Note that we must do the reset before disconnecting from the ANW.
952 // Otherwise queue/dequeue calls could be made on the disconnected
953 // ANW, which may result in errors.
954 reset();
955
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700956 Mutex::Autolock lock(mLock);
957 disconnectNativeWindow_l();
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700958
959 return err;
960 }
961 }
962
Andy McFadden484566c2012-12-18 09:46:54 -0800963 // Note that we must set the player's new GraphicBufferProducer before
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700964 // disconnecting the old one. Otherwise queue/dequeue calls could be made
965 // on the disconnected ANW, which may result in errors.
Andy McFadden484566c2012-12-18 09:46:54 -0800966 status_t err = p->setVideoSurfaceTexture(bufferProducer);
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700967
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700968 mLock.lock();
969 disconnectNativeWindow_l();
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700970
971 if (err == OK) {
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700972 mConnectedWindow = anw;
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700973 mConnectedWindowBinder = binder;
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700974 mLock.unlock();
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700975 } else {
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700976 mLock.unlock();
977 status_t err = nativeWindowDisconnect(
978 anw.get(), "disconnectNativeWindow");
979
980 if (err != OK) {
981 ALOGW("nativeWindowDisconnect returned an error: %s (%d)",
982 strerror(-err), err);
983 }
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700984 }
985
986 return err;
Glenn Kasten11731182011-02-08 17:26:17 -0800987}
988
Nicolas Catania1d187f12009-05-12 23:25:55 -0700989status_t MediaPlayerService::Client::invoke(const Parcel& request,
990 Parcel *reply)
991{
992 sp<MediaPlayerBase> p = getPlayer();
993 if (p == NULL) return UNKNOWN_ERROR;
994 return p->invoke(request, reply);
995}
996
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700997// This call doesn't need to access the native player.
998status_t MediaPlayerService::Client::setMetadataFilter(const Parcel& filter)
999{
1000 status_t status;
nikoa64c8c72009-07-20 15:07:26 -07001001 media::Metadata::Filter allow, drop;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001002
Nicolas Catania48290382009-07-10 13:53:06 -07001003 if (unmarshallFilter(filter, &allow, &status) &&
1004 unmarshallFilter(filter, &drop, &status)) {
1005 Mutex::Autolock lock(mLock);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001006
1007 mMetadataAllow = allow;
1008 mMetadataDrop = drop;
1009 }
1010 return status;
1011}
1012
Nicolas Catania48290382009-07-10 13:53:06 -07001013status_t MediaPlayerService::Client::getMetadata(
Mark Salyzyn77342f72014-06-18 16:31:32 -07001014 bool update_only, bool /*apply_filter*/, Parcel *reply)
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -07001015{
nikoa64c8c72009-07-20 15:07:26 -07001016 sp<MediaPlayerBase> player = getPlayer();
1017 if (player == 0) return UNKNOWN_ERROR;
Nicolas Catania48290382009-07-10 13:53:06 -07001018
nikod608a812009-07-16 16:39:53 -07001019 status_t status;
1020 // Placeholder for the return code, updated by the caller.
1021 reply->writeInt32(-1);
1022
nikoa64c8c72009-07-20 15:07:26 -07001023 media::Metadata::Filter ids;
Nicolas Catania48290382009-07-10 13:53:06 -07001024
1025 // We don't block notifications while we fetch the data. We clear
1026 // mMetadataUpdated first so we don't lose notifications happening
1027 // during the rest of this call.
1028 {
1029 Mutex::Autolock lock(mLock);
1030 if (update_only) {
nikod608a812009-07-16 16:39:53 -07001031 ids = mMetadataUpdated;
Nicolas Catania48290382009-07-10 13:53:06 -07001032 }
1033 mMetadataUpdated.clear();
1034 }
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -07001035
nikoa64c8c72009-07-20 15:07:26 -07001036 media::Metadata metadata(reply);
Nicolas Catania48290382009-07-10 13:53:06 -07001037
nikoa64c8c72009-07-20 15:07:26 -07001038 metadata.appendHeader();
1039 status = player->getMetadata(ids, reply);
nikod608a812009-07-16 16:39:53 -07001040
1041 if (status != OK) {
nikoa64c8c72009-07-20 15:07:26 -07001042 metadata.resetParcel();
Steve Block29357bc2012-01-06 19:20:56 +00001043 ALOGE("getMetadata failed %d", status);
nikod608a812009-07-16 16:39:53 -07001044 return status;
1045 }
1046
1047 // FIXME: Implement filtering on the result. Not critical since
1048 // filtering takes place on the update notifications already. This
1049 // would be when all the metadata are fetch and a filter is set.
1050
nikod608a812009-07-16 16:39:53 -07001051 // Everything is fine, update the metadata length.
nikoa64c8c72009-07-20 15:07:26 -07001052 metadata.updateLength();
nikod608a812009-07-16 16:39:53 -07001053 return OK;
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -07001054}
1055
Wei Jiad399e7e2016-10-26 15:49:11 -07001056status_t MediaPlayerService::Client::setBufferingSettings(
1057 const BufferingSettings& buffering)
1058{
Wei Jiadc6f3402017-01-09 15:04:18 -08001059 ALOGV("[%d] setBufferingSettings{%s}",
1060 mConnId, buffering.toString().string());
Wei Jiad399e7e2016-10-26 15:49:11 -07001061 sp<MediaPlayerBase> p = getPlayer();
1062 if (p == 0) return UNKNOWN_ERROR;
1063 return p->setBufferingSettings(buffering);
1064}
1065
1066status_t MediaPlayerService::Client::getDefaultBufferingSettings(
1067 BufferingSettings* buffering /* nonnull */)
1068{
1069 sp<MediaPlayerBase> p = getPlayer();
1070 // TODO: create mPlayer on demand.
1071 if (p == 0) return UNKNOWN_ERROR;
1072 status_t ret = p->getDefaultBufferingSettings(buffering);
1073 if (ret == NO_ERROR) {
Wei Jiadc6f3402017-01-09 15:04:18 -08001074 ALOGV("[%d] getDefaultBufferingSettings{%s}",
1075 mConnId, buffering->toString().string());
Wei Jiad399e7e2016-10-26 15:49:11 -07001076 } else {
1077 ALOGV("[%d] getDefaultBufferingSettings returned %d", mConnId, ret);
1078 }
1079 return ret;
1080}
1081
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001082status_t MediaPlayerService::Client::prepareAsync()
1083{
Steve Block3856b092011-10-20 11:56:00 +01001084 ALOGV("[%d] prepareAsync", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001085 sp<MediaPlayerBase> p = getPlayer();
1086 if (p == 0) return UNKNOWN_ERROR;
1087 status_t ret = p->prepareAsync();
1088#if CALLBACK_ANTAGONIZER
Steve Blockb8a80522011-12-20 16:23:08 +00001089 ALOGD("start Antagonizer");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001090 if (ret == NO_ERROR) mAntagonizer->start();
1091#endif
1092 return ret;
1093}
1094
1095status_t MediaPlayerService::Client::start()
1096{
Steve Block3856b092011-10-20 11:56:00 +01001097 ALOGV("[%d] start", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001098 sp<MediaPlayerBase> p = getPlayer();
1099 if (p == 0) return UNKNOWN_ERROR;
1100 p->setLooping(mLoop);
1101 return p->start();
1102}
1103
1104status_t MediaPlayerService::Client::stop()
1105{
Steve Block3856b092011-10-20 11:56:00 +01001106 ALOGV("[%d] stop", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001107 sp<MediaPlayerBase> p = getPlayer();
1108 if (p == 0) return UNKNOWN_ERROR;
1109 return p->stop();
1110}
1111
1112status_t MediaPlayerService::Client::pause()
1113{
Steve Block3856b092011-10-20 11:56:00 +01001114 ALOGV("[%d] pause", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001115 sp<MediaPlayerBase> p = getPlayer();
1116 if (p == 0) return UNKNOWN_ERROR;
1117 return p->pause();
1118}
1119
1120status_t MediaPlayerService::Client::isPlaying(bool* state)
1121{
1122 *state = false;
1123 sp<MediaPlayerBase> p = getPlayer();
1124 if (p == 0) return UNKNOWN_ERROR;
1125 *state = p->isPlaying();
Steve Block3856b092011-10-20 11:56:00 +01001126 ALOGV("[%d] isPlaying: %d", mConnId, *state);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001127 return NO_ERROR;
1128}
1129
Lajos Molnar3a474aa2015-04-24 17:10:07 -07001130status_t MediaPlayerService::Client::setPlaybackSettings(const AudioPlaybackRate& rate)
Wei Jia98160162015-02-04 17:01:11 -08001131{
Lajos Molnar3a474aa2015-04-24 17:10:07 -07001132 ALOGV("[%d] setPlaybackSettings(%f, %f, %d, %d)",
1133 mConnId, rate.mSpeed, rate.mPitch, rate.mFallbackMode, rate.mStretchMode);
Wei Jia98160162015-02-04 17:01:11 -08001134 sp<MediaPlayerBase> p = getPlayer();
1135 if (p == 0) return UNKNOWN_ERROR;
Lajos Molnar3a474aa2015-04-24 17:10:07 -07001136 return p->setPlaybackSettings(rate);
1137}
1138
1139status_t MediaPlayerService::Client::getPlaybackSettings(AudioPlaybackRate* rate /* nonnull */)
1140{
1141 sp<MediaPlayerBase> p = getPlayer();
1142 if (p == 0) return UNKNOWN_ERROR;
1143 status_t ret = p->getPlaybackSettings(rate);
1144 if (ret == NO_ERROR) {
1145 ALOGV("[%d] getPlaybackSettings(%f, %f, %d, %d)",
1146 mConnId, rate->mSpeed, rate->mPitch, rate->mFallbackMode, rate->mStretchMode);
1147 } else {
1148 ALOGV("[%d] getPlaybackSettings returned %d", mConnId, ret);
1149 }
1150 return ret;
1151}
1152
1153status_t MediaPlayerService::Client::setSyncSettings(
1154 const AVSyncSettings& sync, float videoFpsHint)
1155{
1156 ALOGV("[%d] setSyncSettings(%u, %u, %f, %f)",
1157 mConnId, sync.mSource, sync.mAudioAdjustMode, sync.mTolerance, videoFpsHint);
1158 sp<MediaPlayerBase> p = getPlayer();
1159 if (p == 0) return UNKNOWN_ERROR;
1160 return p->setSyncSettings(sync, videoFpsHint);
1161}
1162
1163status_t MediaPlayerService::Client::getSyncSettings(
1164 AVSyncSettings* sync /* nonnull */, float* videoFps /* nonnull */)
1165{
1166 sp<MediaPlayerBase> p = getPlayer();
1167 if (p == 0) return UNKNOWN_ERROR;
1168 status_t ret = p->getSyncSettings(sync, videoFps);
1169 if (ret == NO_ERROR) {
1170 ALOGV("[%d] getSyncSettings(%u, %u, %f, %f)",
1171 mConnId, sync->mSource, sync->mAudioAdjustMode, sync->mTolerance, *videoFps);
1172 } else {
1173 ALOGV("[%d] getSyncSettings returned %d", mConnId, ret);
1174 }
1175 return ret;
Wei Jia98160162015-02-04 17:01:11 -08001176}
1177
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001178status_t MediaPlayerService::Client::getCurrentPosition(int *msec)
1179{
Steve Block3856b092011-10-20 11:56:00 +01001180 ALOGV("getCurrentPosition");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001181 sp<MediaPlayerBase> p = getPlayer();
1182 if (p == 0) return UNKNOWN_ERROR;
1183 status_t ret = p->getCurrentPosition(msec);
1184 if (ret == NO_ERROR) {
Steve Block3856b092011-10-20 11:56:00 +01001185 ALOGV("[%d] getCurrentPosition = %d", mConnId, *msec);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001186 } else {
Steve Block29357bc2012-01-06 19:20:56 +00001187 ALOGE("getCurrentPosition returned %d", ret);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001188 }
1189 return ret;
1190}
1191
1192status_t MediaPlayerService::Client::getDuration(int *msec)
1193{
Steve Block3856b092011-10-20 11:56:00 +01001194 ALOGV("getDuration");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001195 sp<MediaPlayerBase> p = getPlayer();
1196 if (p == 0) return UNKNOWN_ERROR;
1197 status_t ret = p->getDuration(msec);
1198 if (ret == NO_ERROR) {
Steve Block3856b092011-10-20 11:56:00 +01001199 ALOGV("[%d] getDuration = %d", mConnId, *msec);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001200 } else {
Steve Block29357bc2012-01-06 19:20:56 +00001201 ALOGE("getDuration returned %d", ret);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001202 }
1203 return ret;
1204}
1205
Marco Nelissen6b74d672012-02-28 16:07:44 -08001206status_t MediaPlayerService::Client::setNextPlayer(const sp<IMediaPlayer>& player) {
1207 ALOGV("setNextPlayer");
1208 Mutex::Autolock l(mLock);
1209 sp<Client> c = static_cast<Client*>(player.get());
Wei Jia28284122016-08-30 13:49:06 -07001210 if (c != NULL && !mService->hasClient(c)) {
Robert Shihee0a0e32016-08-16 16:50:54 -07001211 return BAD_VALUE;
1212 }
1213
Marco Nelissen6b74d672012-02-28 16:07:44 -08001214 mNextClient = c;
John Grossman5f7e55e2012-08-24 14:47:25 -07001215
1216 if (c != NULL) {
1217 if (mAudioOutput != NULL) {
1218 mAudioOutput->setNextOutput(c->mAudioOutput);
1219 } else if ((mPlayer != NULL) && !mPlayer->hardwareOutput()) {
1220 ALOGE("no current audio output");
1221 }
1222
1223 if ((mPlayer != NULL) && (mNextClient->getPlayer() != NULL)) {
1224 mPlayer->setNextPlayer(mNextClient->getPlayer());
1225 }
Marco Nelissen6b74d672012-02-28 16:07:44 -08001226 }
John Grossman5f7e55e2012-08-24 14:47:25 -07001227
Marco Nelissen6b74d672012-02-28 16:07:44 -08001228 return OK;
1229}
1230
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001231VolumeShaper::Status MediaPlayerService::Client::applyVolumeShaper(
1232 const sp<VolumeShaper::Configuration>& configuration,
1233 const sp<VolumeShaper::Operation>& operation) {
1234 // for hardware output, call player instead
1235 ALOGV("Client::applyVolumeShaper(%p)", this);
1236 sp<MediaPlayerBase> p = getPlayer();
1237 {
1238 Mutex::Autolock l(mLock);
1239 if (p != 0 && p->hardwareOutput()) {
1240 // TODO: investigate internal implementation
1241 return VolumeShaper::Status(INVALID_OPERATION);
1242 }
1243 if (mAudioOutput.get() != nullptr) {
1244 return mAudioOutput->applyVolumeShaper(configuration, operation);
1245 }
1246 }
1247 return VolumeShaper::Status(INVALID_OPERATION);
1248}
1249
1250sp<VolumeShaper::State> MediaPlayerService::Client::getVolumeShaperState(int id) {
1251 // for hardware output, call player instead
1252 ALOGV("Client::getVolumeShaperState(%p)", this);
1253 sp<MediaPlayerBase> p = getPlayer();
1254 {
1255 Mutex::Autolock l(mLock);
1256 if (p != 0 && p->hardwareOutput()) {
1257 // TODO: investigate internal implementation.
1258 return nullptr;
1259 }
1260 if (mAudioOutput.get() != nullptr) {
1261 return mAudioOutput->getVolumeShaperState(id);
1262 }
1263 }
1264 return nullptr;
1265}
1266
Wei Jiac5de0912016-11-18 10:22:14 -08001267status_t MediaPlayerService::Client::seekTo(int msec, MediaPlayerSeekMode mode)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001268{
Wei Jiac5de0912016-11-18 10:22:14 -08001269 ALOGV("[%d] seekTo(%d, %d)", mConnId, msec, mode);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001270 sp<MediaPlayerBase> p = getPlayer();
1271 if (p == 0) return UNKNOWN_ERROR;
Wei Jiac5de0912016-11-18 10:22:14 -08001272 return p->seekTo(msec, mode);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001273}
1274
1275status_t MediaPlayerService::Client::reset()
1276{
Steve Block3856b092011-10-20 11:56:00 +01001277 ALOGV("[%d] reset", mConnId);
John Grossmanc795b642012-02-22 15:38:35 -08001278 mRetransmitEndpointValid = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001279 sp<MediaPlayerBase> p = getPlayer();
1280 if (p == 0) return UNKNOWN_ERROR;
1281 return p->reset();
1282}
1283
Glenn Kastenfff6d712012-01-12 16:38:12 -08001284status_t MediaPlayerService::Client::setAudioStreamType(audio_stream_type_t type)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001285{
Steve Block3856b092011-10-20 11:56:00 +01001286 ALOGV("[%d] setAudioStreamType(%d)", mConnId, type);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001287 // TODO: for hardware output, call player instead
1288 Mutex::Autolock l(mLock);
1289 if (mAudioOutput != 0) mAudioOutput->setAudioStreamType(type);
1290 return NO_ERROR;
1291}
1292
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001293status_t MediaPlayerService::Client::setAudioAttributes_l(const Parcel &parcel)
1294{
1295 if (mAudioAttributes != NULL) { free(mAudioAttributes); }
1296 mAudioAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t));
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001297 if (mAudioAttributes == NULL) {
1298 return NO_MEMORY;
1299 }
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001300 unmarshallAudioAttributes(parcel, mAudioAttributes);
1301
1302 ALOGV("setAudioAttributes_l() usage=%d content=%d flags=0x%x tags=%s",
1303 mAudioAttributes->usage, mAudioAttributes->content_type, mAudioAttributes->flags,
1304 mAudioAttributes->tags);
1305
1306 if (mAudioOutput != 0) {
1307 mAudioOutput->setAudioAttributes(mAudioAttributes);
1308 }
1309 return NO_ERROR;
1310}
1311
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001312status_t MediaPlayerService::Client::setLooping(int loop)
1313{
Steve Block3856b092011-10-20 11:56:00 +01001314 ALOGV("[%d] setLooping(%d)", mConnId, loop);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001315 mLoop = loop;
1316 sp<MediaPlayerBase> p = getPlayer();
1317 if (p != 0) return p->setLooping(loop);
1318 return NO_ERROR;
1319}
1320
1321status_t MediaPlayerService::Client::setVolume(float leftVolume, float rightVolume)
1322{
Steve Block3856b092011-10-20 11:56:00 +01001323 ALOGV("[%d] setVolume(%f, %f)", mConnId, leftVolume, rightVolume);
John Grossman761defc2012-02-09 15:09:05 -08001324
1325 // for hardware output, call player instead
1326 sp<MediaPlayerBase> p = getPlayer();
1327 {
1328 Mutex::Autolock l(mLock);
1329 if (p != 0 && p->hardwareOutput()) {
1330 MediaPlayerHWInterface* hwp =
1331 reinterpret_cast<MediaPlayerHWInterface*>(p.get());
1332 return hwp->setVolume(leftVolume, rightVolume);
1333 } else {
1334 if (mAudioOutput != 0) mAudioOutput->setVolume(leftVolume, rightVolume);
1335 return NO_ERROR;
1336 }
1337 }
1338
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001339 return NO_ERROR;
1340}
1341
Eric Laurent2beeb502010-07-16 07:43:46 -07001342status_t MediaPlayerService::Client::setAuxEffectSendLevel(float level)
1343{
Steve Block3856b092011-10-20 11:56:00 +01001344 ALOGV("[%d] setAuxEffectSendLevel(%f)", mConnId, level);
Eric Laurent2beeb502010-07-16 07:43:46 -07001345 Mutex::Autolock l(mLock);
1346 if (mAudioOutput != 0) return mAudioOutput->setAuxEffectSendLevel(level);
1347 return NO_ERROR;
1348}
1349
1350status_t MediaPlayerService::Client::attachAuxEffect(int effectId)
1351{
Steve Block3856b092011-10-20 11:56:00 +01001352 ALOGV("[%d] attachAuxEffect(%d)", mConnId, effectId);
Eric Laurent2beeb502010-07-16 07:43:46 -07001353 Mutex::Autolock l(mLock);
1354 if (mAudioOutput != 0) return mAudioOutput->attachAuxEffect(effectId);
1355 return NO_ERROR;
1356}
Nicolas Catania48290382009-07-10 13:53:06 -07001357
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001358status_t MediaPlayerService::Client::setParameter(int key, const Parcel &request) {
Steve Block3856b092011-10-20 11:56:00 +01001359 ALOGV("[%d] setParameter(%d)", mConnId, key);
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001360 switch (key) {
1361 case KEY_PARAMETER_AUDIO_ATTRIBUTES:
1362 {
1363 Mutex::Autolock l(mLock);
1364 return setAudioAttributes_l(request);
1365 }
1366 default:
1367 sp<MediaPlayerBase> p = getPlayer();
1368 if (p == 0) { return UNKNOWN_ERROR; }
1369 return p->setParameter(key, request);
1370 }
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001371}
1372
1373status_t MediaPlayerService::Client::getParameter(int key, Parcel *reply) {
Steve Block3856b092011-10-20 11:56:00 +01001374 ALOGV("[%d] getParameter(%d)", mConnId, key);
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001375 sp<MediaPlayerBase> p = getPlayer();
1376 if (p == 0) return UNKNOWN_ERROR;
1377 return p->getParameter(key, reply);
1378}
1379
John Grossmanc795b642012-02-22 15:38:35 -08001380status_t MediaPlayerService::Client::setRetransmitEndpoint(
1381 const struct sockaddr_in* endpoint) {
1382
1383 if (NULL != endpoint) {
1384 uint32_t a = ntohl(endpoint->sin_addr.s_addr);
1385 uint16_t p = ntohs(endpoint->sin_port);
1386 ALOGV("[%d] setRetransmitEndpoint(%u.%u.%u.%u:%hu)", mConnId,
1387 (a >> 24), (a >> 16) & 0xFF, (a >> 8) & 0xFF, (a & 0xFF), p);
1388 } else {
1389 ALOGV("[%d] setRetransmitEndpoint = <none>", mConnId);
1390 }
1391
1392 sp<MediaPlayerBase> p = getPlayer();
1393
1394 // Right now, the only valid time to set a retransmit endpoint is before
1395 // player selection has been made (since the presence or absence of a
1396 // retransmit endpoint is going to determine which player is selected during
1397 // setDataSource).
1398 if (p != 0) return INVALID_OPERATION;
1399
1400 if (NULL != endpoint) {
Pawin Vongmasaf9c81462017-09-28 05:31:11 -07001401 Mutex::Autolock lock(mLock);
John Grossmanc795b642012-02-22 15:38:35 -08001402 mRetransmitEndpoint = *endpoint;
1403 mRetransmitEndpointValid = true;
1404 } else {
Pawin Vongmasaf9c81462017-09-28 05:31:11 -07001405 Mutex::Autolock lock(mLock);
John Grossmanc795b642012-02-22 15:38:35 -08001406 mRetransmitEndpointValid = false;
1407 }
1408
1409 return NO_ERROR;
1410}
1411
John Grossman44a7e422012-06-21 17:29:24 -07001412status_t MediaPlayerService::Client::getRetransmitEndpoint(
1413 struct sockaddr_in* endpoint)
1414{
1415 if (NULL == endpoint)
1416 return BAD_VALUE;
1417
1418 sp<MediaPlayerBase> p = getPlayer();
1419
1420 if (p != NULL)
1421 return p->getRetransmitEndpoint(endpoint);
1422
Pawin Vongmasaf9c81462017-09-28 05:31:11 -07001423 Mutex::Autolock lock(mLock);
John Grossman44a7e422012-06-21 17:29:24 -07001424 if (!mRetransmitEndpointValid)
1425 return NO_INIT;
1426
1427 *endpoint = mRetransmitEndpoint;
1428
1429 return NO_ERROR;
1430}
1431
Gloria Wangb483c472011-04-11 17:23:27 -07001432void MediaPlayerService::Client::notify(
Pawin Vongmasa028cf092017-12-12 01:56:40 -08001433 const wp<IMediaPlayer> &listener, int msg, int ext1, int ext2, const Parcel *obj)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001434{
Pawin Vongmasa028cf092017-12-12 01:56:40 -08001435 sp<IMediaPlayer> spListener = listener.promote();
1436 if (spListener == NULL) {
James Dongb8a98252012-08-26 16:13:03 -07001437 return;
1438 }
Pawin Vongmasa028cf092017-12-12 01:56:40 -08001439 Client* client = static_cast<Client*>(spListener.get());
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001440
James Dongb8a98252012-08-26 16:13:03 -07001441 sp<IMediaPlayerClient> c;
Haynes Mathew George6cb33752015-06-22 14:16:42 -07001442 sp<Client> nextClient;
1443 status_t errStartNext = NO_ERROR;
Marco Nelissen6b74d672012-02-28 16:07:44 -08001444 {
1445 Mutex::Autolock l(client->mLock);
James Dongb8a98252012-08-26 16:13:03 -07001446 c = client->mClient;
Marco Nelissen6b74d672012-02-28 16:07:44 -08001447 if (msg == MEDIA_PLAYBACK_COMPLETE && client->mNextClient != NULL) {
Haynes Mathew George6cb33752015-06-22 14:16:42 -07001448 nextClient = client->mNextClient;
1449
John Grossmancb0b7552012-08-23 17:47:31 -07001450 if (client->mAudioOutput != NULL)
1451 client->mAudioOutput->switchToNextOutput();
Haynes Mathew George6cb33752015-06-22 14:16:42 -07001452
1453 errStartNext = nextClient->start();
1454 }
1455 }
1456
1457 if (nextClient != NULL) {
1458 sp<IMediaPlayerClient> nc;
1459 {
1460 Mutex::Autolock l(nextClient->mLock);
1461 nc = nextClient->mClient;
1462 }
1463 if (nc != NULL) {
1464 if (errStartNext == NO_ERROR) {
1465 nc->notify(MEDIA_INFO, MEDIA_INFO_STARTED_AS_NEXT, 0, obj);
1466 } else {
1467 nc->notify(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN , 0, obj);
1468 ALOGE("gapless:start playback for next track failed, err(%d)", errStartNext);
Wei Jia2afac0c2016-01-07 12:13:07 -08001469 }
Marco Nelissen6b74d672012-02-28 16:07:44 -08001470 }
1471 }
1472
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001473 if (MEDIA_INFO == msg &&
Nicolas Catania48290382009-07-10 13:53:06 -07001474 MEDIA_INFO_METADATA_UPDATE == ext1) {
nikoa64c8c72009-07-20 15:07:26 -07001475 const media::Metadata::Type metadata_type = ext2;
Nicolas Catania48290382009-07-10 13:53:06 -07001476
1477 if(client->shouldDropMetadata(metadata_type)) {
1478 return;
1479 }
1480
1481 // Update the list of metadata that have changed. getMetadata
1482 // also access mMetadataUpdated and clears it.
1483 client->addNewMetadataUpdate(metadata_type);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001484 }
James Dongb8a98252012-08-26 16:13:03 -07001485
1486 if (c != NULL) {
Pawin Vongmasa028cf092017-12-12 01:56:40 -08001487 ALOGV("[%d] notify (%p, %d, %d, %d)", client->mConnId, spListener.get(), msg, ext1, ext2);
James Dongb8a98252012-08-26 16:13:03 -07001488 c->notify(msg, ext1, ext2, obj);
1489 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001490}
1491
Nicolas Catania48290382009-07-10 13:53:06 -07001492
nikoa64c8c72009-07-20 15:07:26 -07001493bool MediaPlayerService::Client::shouldDropMetadata(media::Metadata::Type code) const
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001494{
Nicolas Catania48290382009-07-10 13:53:06 -07001495 Mutex::Autolock lock(mLock);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001496
Nicolas Catania48290382009-07-10 13:53:06 -07001497 if (findMetadata(mMetadataDrop, code)) {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001498 return true;
1499 }
1500
Nicolas Catania48290382009-07-10 13:53:06 -07001501 if (mMetadataAllow.isEmpty() || findMetadata(mMetadataAllow, code)) {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001502 return false;
Nicolas Catania48290382009-07-10 13:53:06 -07001503 } else {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001504 return true;
1505 }
1506}
1507
Nicolas Catania48290382009-07-10 13:53:06 -07001508
nikoa64c8c72009-07-20 15:07:26 -07001509void MediaPlayerService::Client::addNewMetadataUpdate(media::Metadata::Type metadata_type) {
Nicolas Catania48290382009-07-10 13:53:06 -07001510 Mutex::Autolock lock(mLock);
1511 if (mMetadataUpdated.indexOf(metadata_type) < 0) {
1512 mMetadataUpdated.add(metadata_type);
1513 }
1514}
1515
Hassan Shojaniacefac142017-02-06 21:02:02 -08001516// Modular DRM
1517status_t MediaPlayerService::Client::prepareDrm(const uint8_t uuid[16],
1518 const Vector<uint8_t>& drmSessionId)
1519{
1520 ALOGV("[%d] prepareDrm", mConnId);
1521 sp<MediaPlayerBase> p = getPlayer();
1522 if (p == 0) return UNKNOWN_ERROR;
1523
1524 status_t ret = p->prepareDrm(uuid, drmSessionId);
1525 ALOGV("prepareDrm ret: %d", ret);
1526
1527 return ret;
1528}
1529
1530status_t MediaPlayerService::Client::releaseDrm()
1531{
1532 ALOGV("[%d] releaseDrm", mConnId);
1533 sp<MediaPlayerBase> p = getPlayer();
1534 if (p == 0) return UNKNOWN_ERROR;
1535
1536 status_t ret = p->releaseDrm();
1537 ALOGV("releaseDrm ret: %d", ret);
1538
1539 return ret;
1540}
1541
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001542#if CALLBACK_ANTAGONIZER
1543const int Antagonizer::interval = 10000; // 10 msecs
1544
Pawin Vongmasa028cf092017-12-12 01:56:40 -08001545Antagonizer::Antagonizer(notify_callback_f cb, const wp<IMediaPlayer> &client) :
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001546 mExit(false), mActive(false), mClient(client), mCb(cb)
1547{
1548 createThread(callbackThread, this);
1549}
1550
1551void Antagonizer::kill()
1552{
1553 Mutex::Autolock _l(mLock);
1554 mActive = false;
1555 mExit = true;
1556 mCondition.wait(mLock);
1557}
1558
1559int Antagonizer::callbackThread(void* user)
1560{
Steve Blockb8a80522011-12-20 16:23:08 +00001561 ALOGD("Antagonizer started");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001562 Antagonizer* p = reinterpret_cast<Antagonizer*>(user);
1563 while (!p->mExit) {
1564 if (p->mActive) {
Steve Block3856b092011-10-20 11:56:00 +01001565 ALOGV("send event");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001566 p->mCb(p->mClient, 0, 0, 0);
1567 }
1568 usleep(interval);
1569 }
1570 Mutex::Autolock _l(p->mLock);
1571 p->mCondition.signal();
Steve Blockb8a80522011-12-20 16:23:08 +00001572 ALOGD("Antagonizer stopped");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001573 return 0;
1574}
1575#endif
1576
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001577#undef LOG_TAG
1578#define LOG_TAG "AudioSink"
Andy Hung1afd0982016-11-08 16:13:44 -08001579MediaPlayerService::AudioOutput::AudioOutput(audio_session_t sessionId, uid_t uid, int pid,
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001580 const audio_attributes_t* attr)
Andreas Huber20111aa2009-07-14 16:56:47 -07001581 : mCallback(NULL),
Eric Laurenta514bdb2010-06-21 09:27:30 -07001582 mCallbackCookie(NULL),
Marco Nelissen6b74d672012-02-28 16:07:44 -08001583 mCallbackData(NULL),
Andy Hungd1c74342015-07-07 16:54:23 -07001584 mStreamType(AUDIO_STREAM_MUSIC),
Andy Hungd1c74342015-07-07 16:54:23 -07001585 mLeftVolume(1.0),
1586 mRightVolume(1.0),
1587 mPlaybackRate(AUDIO_PLAYBACK_RATE_DEFAULT),
1588 mSampleRateHz(0),
1589 mMsecsPerFrame(0),
1590 mFrameSize(0),
Eric Laurent1948eb32012-04-13 16:50:19 -07001591 mSessionId(sessionId),
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001592 mUid(uid),
Marco Nelissend457c972014-02-11 08:47:07 -08001593 mPid(pid),
Andy Hungd1c74342015-07-07 16:54:23 -07001594 mSendLevel(0.0),
1595 mAuxEffectId(0),
Andy Hung4ef88d72017-02-21 19:47:53 -08001596 mFlags(AUDIO_OUTPUT_FLAG_NONE),
1597 mVolumeHandler(new VolumeHandler())
Andy Hungd1c74342015-07-07 16:54:23 -07001598{
Steve Block3856b092011-10-20 11:56:00 +01001599 ALOGV("AudioOutput(%d)", sessionId);
Eric Laurent43562692015-07-15 16:49:07 -07001600 if (attr != NULL) {
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001601 mAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t));
1602 if (mAttributes != NULL) {
1603 memcpy(mAttributes, attr, sizeof(audio_attributes_t));
1604 mStreamType = audio_attributes_to_stream_type(attr);
1605 }
1606 } else {
1607 mAttributes = NULL;
Eric Laurent43562692015-07-15 16:49:07 -07001608 }
1609
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001610 setMinBufferCount();
1611}
1612
1613MediaPlayerService::AudioOutput::~AudioOutput()
1614{
1615 close();
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001616 free(mAttributes);
Marco Nelissen6b74d672012-02-28 16:07:44 -08001617 delete mCallbackData;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001618}
1619
Andy Hungd1c74342015-07-07 16:54:23 -07001620//static
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001621void MediaPlayerService::AudioOutput::setMinBufferCount()
1622{
1623 char value[PROPERTY_VALUE_MAX];
1624 if (property_get("ro.kernel.qemu", value, 0)) {
1625 mIsOnEmulator = true;
1626 mMinBufferCount = 12; // to prevent systematic buffer underrun for emulator
1627 }
1628}
1629
Andy Hungd1c74342015-07-07 16:54:23 -07001630// static
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001631bool MediaPlayerService::AudioOutput::isOnEmulator()
1632{
Andy Hungd1c74342015-07-07 16:54:23 -07001633 setMinBufferCount(); // benign race wrt other threads
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001634 return mIsOnEmulator;
1635}
1636
Andy Hungd1c74342015-07-07 16:54:23 -07001637// static
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001638int MediaPlayerService::AudioOutput::getMinBufferCount()
1639{
Andy Hungd1c74342015-07-07 16:54:23 -07001640 setMinBufferCount(); // benign race wrt other threads
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001641 return mMinBufferCount;
1642}
1643
1644ssize_t MediaPlayerService::AudioOutput::bufferSize() const
1645{
Andy Hungd1c74342015-07-07 16:54:23 -07001646 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001647 if (mTrack == 0) return NO_INIT;
Andy Hungd1c74342015-07-07 16:54:23 -07001648 return mTrack->frameCount() * mFrameSize;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001649}
1650
1651ssize_t MediaPlayerService::AudioOutput::frameCount() const
1652{
Andy Hungd1c74342015-07-07 16:54:23 -07001653 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001654 if (mTrack == 0) return NO_INIT;
1655 return mTrack->frameCount();
1656}
1657
1658ssize_t MediaPlayerService::AudioOutput::channelCount() const
1659{
Andy Hungd1c74342015-07-07 16:54:23 -07001660 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001661 if (mTrack == 0) return NO_INIT;
1662 return mTrack->channelCount();
1663}
1664
1665ssize_t MediaPlayerService::AudioOutput::frameSize() const
1666{
Andy Hungd1c74342015-07-07 16:54:23 -07001667 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001668 if (mTrack == 0) return NO_INIT;
Andy Hungd1c74342015-07-07 16:54:23 -07001669 return mFrameSize;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001670}
1671
1672uint32_t MediaPlayerService::AudioOutput::latency () const
1673{
Andy Hungd1c74342015-07-07 16:54:23 -07001674 Mutex::Autolock lock(mLock);
Eric Laurentdb354e52012-03-05 17:27:11 -08001675 if (mTrack == 0) return 0;
1676 return mTrack->latency();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001677}
1678
1679float MediaPlayerService::AudioOutput::msecsPerFrame() const
1680{
Andy Hungd1c74342015-07-07 16:54:23 -07001681 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001682 return mMsecsPerFrame;
1683}
1684
Marco Nelissen4110c102012-03-29 09:31:28 -07001685status_t MediaPlayerService::AudioOutput::getPosition(uint32_t *position) const
Eric Laurent342e9cf2010-01-19 17:37:09 -08001686{
Andy Hungd1c74342015-07-07 16:54:23 -07001687 Mutex::Autolock lock(mLock);
Eric Laurent342e9cf2010-01-19 17:37:09 -08001688 if (mTrack == 0) return NO_INIT;
1689 return mTrack->getPosition(position);
1690}
1691
Lajos Molnar06ad1522014-08-28 07:27:44 -07001692status_t MediaPlayerService::AudioOutput::getTimestamp(AudioTimestamp &ts) const
1693{
Andy Hungd1c74342015-07-07 16:54:23 -07001694 Mutex::Autolock lock(mLock);
Lajos Molnar06ad1522014-08-28 07:27:44 -07001695 if (mTrack == 0) return NO_INIT;
1696 return mTrack->getTimestamp(ts);
1697}
1698
Wei Jiac4ac8172015-10-21 10:35:48 -07001699// TODO: Remove unnecessary calls to getPlayedOutDurationUs()
1700// as it acquires locks and may query the audio driver.
1701//
1702// Some calls could conceivably retrieve extrapolated data instead of
1703// accessing getTimestamp() or getPosition() every time a data buffer with
1704// a media time is received.
1705//
1706// Calculate duration of played samples if played at normal rate (i.e., 1.0).
1707int64_t MediaPlayerService::AudioOutput::getPlayedOutDurationUs(int64_t nowUs) const
1708{
1709 Mutex::Autolock lock(mLock);
1710 if (mTrack == 0 || mSampleRateHz == 0) {
Wei Jia213f4902015-10-22 08:55:25 -07001711 return 0;
Wei Jiac4ac8172015-10-21 10:35:48 -07001712 }
1713
1714 uint32_t numFramesPlayed;
Andy Hung5d313802016-10-10 15:09:39 -07001715 int64_t numFramesPlayedAtUs;
Wei Jiac4ac8172015-10-21 10:35:48 -07001716 AudioTimestamp ts;
Wei Jiac4ac8172015-10-21 10:35:48 -07001717
1718 status_t res = mTrack->getTimestamp(ts);
1719 if (res == OK) { // case 1: mixing audio tracks and offloaded tracks.
1720 numFramesPlayed = ts.mPosition;
Andy Hung5d313802016-10-10 15:09:39 -07001721 numFramesPlayedAtUs = ts.mTime.tv_sec * 1000000LL + ts.mTime.tv_nsec / 1000;
1722 //ALOGD("getTimestamp: OK %d %lld", numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001723 } else if (res == WOULD_BLOCK) { // case 2: transitory state on start of a new track
1724 numFramesPlayed = 0;
Andy Hung5d313802016-10-10 15:09:39 -07001725 numFramesPlayedAtUs = nowUs;
Wei Jiac4ac8172015-10-21 10:35:48 -07001726 //ALOGD("getTimestamp: WOULD_BLOCK %d %lld",
Andy Hung5d313802016-10-10 15:09:39 -07001727 // numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001728 } else { // case 3: transitory at new track or audio fast tracks.
1729 res = mTrack->getPosition(&numFramesPlayed);
1730 CHECK_EQ(res, (status_t)OK);
Andy Hung5d313802016-10-10 15:09:39 -07001731 numFramesPlayedAtUs = nowUs;
1732 numFramesPlayedAtUs += 1000LL * mTrack->latency() / 2; /* XXX */
1733 //ALOGD("getPosition: %u %lld", numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001734 }
1735
1736 // CHECK_EQ(numFramesPlayed & (1 << 31), 0); // can't be negative until 12.4 hrs, test
1737 // TODO: remove the (int32_t) casting below as it may overflow at 12.4 hours.
1738 int64_t durationUs = (int64_t)((int32_t)numFramesPlayed * 1000000LL / mSampleRateHz)
Andy Hung5d313802016-10-10 15:09:39 -07001739 + nowUs - numFramesPlayedAtUs;
Wei Jiac4ac8172015-10-21 10:35:48 -07001740 if (durationUs < 0) {
1741 // Occurs when numFramesPlayed position is very small and the following:
1742 // (1) In case 1, the time nowUs is computed before getTimestamp() is called and
Andy Hung5d313802016-10-10 15:09:39 -07001743 // numFramesPlayedAtUs is greater than nowUs by time more than numFramesPlayed.
Wei Jiac4ac8172015-10-21 10:35:48 -07001744 // (2) In case 3, using getPosition and adding mAudioSink->latency() to
Andy Hung5d313802016-10-10 15:09:39 -07001745 // numFramesPlayedAtUs, by a time amount greater than numFramesPlayed.
Wei Jiac4ac8172015-10-21 10:35:48 -07001746 //
1747 // Both of these are transitory conditions.
1748 ALOGV("getPlayedOutDurationUs: negative duration %lld set to zero", (long long)durationUs);
1749 durationUs = 0;
1750 }
1751 ALOGV("getPlayedOutDurationUs(%lld) nowUs(%lld) frames(%u) framesAt(%lld)",
Andy Hung5d313802016-10-10 15:09:39 -07001752 (long long)durationUs, (long long)nowUs,
1753 numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001754 return durationUs;
1755}
1756
Marco Nelissen4110c102012-03-29 09:31:28 -07001757status_t MediaPlayerService::AudioOutput::getFramesWritten(uint32_t *frameswritten) const
1758{
Andy Hungd1c74342015-07-07 16:54:23 -07001759 Mutex::Autolock lock(mLock);
Marco Nelissen4110c102012-03-29 09:31:28 -07001760 if (mTrack == 0) return NO_INIT;
Andy Hung2f6e73d2016-04-08 12:12:58 -07001761 ExtendedTimestamp ets;
1762 status_t status = mTrack->getTimestamp(&ets);
1763 if (status == OK || status == WOULD_BLOCK) {
1764 *frameswritten = (uint32_t)ets.mPosition[ExtendedTimestamp::LOCATION_CLIENT];
1765 }
1766 return status;
Marco Nelissen4110c102012-03-29 09:31:28 -07001767}
1768
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001769status_t MediaPlayerService::AudioOutput::setParameters(const String8& keyValuePairs)
1770{
Andy Hungd1c74342015-07-07 16:54:23 -07001771 Mutex::Autolock lock(mLock);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001772 if (mTrack == 0) return NO_INIT;
1773 return mTrack->setParameters(keyValuePairs);
1774}
1775
1776String8 MediaPlayerService::AudioOutput::getParameters(const String8& keys)
1777{
Andy Hungd1c74342015-07-07 16:54:23 -07001778 Mutex::Autolock lock(mLock);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001779 if (mTrack == 0) return String8::empty();
1780 return mTrack->getParameters(keys);
1781}
1782
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001783void MediaPlayerService::AudioOutput::setAudioAttributes(const audio_attributes_t * attributes) {
Andy Hungd1c74342015-07-07 16:54:23 -07001784 Mutex::Autolock lock(mLock);
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001785 if (attributes == NULL) {
1786 free(mAttributes);
1787 mAttributes = NULL;
1788 } else {
1789 if (mAttributes == NULL) {
1790 mAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t));
1791 }
1792 memcpy(mAttributes, attributes, sizeof(audio_attributes_t));
Eric Laurent43562692015-07-15 16:49:07 -07001793 mStreamType = audio_attributes_to_stream_type(attributes);
1794 }
1795}
1796
1797void MediaPlayerService::AudioOutput::setAudioStreamType(audio_stream_type_t streamType)
1798{
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001799 Mutex::Autolock lock(mLock);
Eric Laurent43562692015-07-15 16:49:07 -07001800 // do not allow direct stream type modification if attributes have been set
1801 if (mAttributes == NULL) {
1802 mStreamType = streamType;
1803 }
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001804}
1805
Andy Hungd1c74342015-07-07 16:54:23 -07001806void MediaPlayerService::AudioOutput::deleteRecycledTrack_l()
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001807{
Andy Hungd1c74342015-07-07 16:54:23 -07001808 ALOGV("deleteRecycledTrack_l");
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001809 if (mRecycledTrack != 0) {
1810
1811 if (mCallbackData != NULL) {
1812 mCallbackData->setOutput(NULL);
1813 mCallbackData->endTrackSwitch();
1814 }
1815
1816 if ((mRecycledTrack->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) {
Andy Hunge13f8a62016-03-30 14:20:42 -07001817 int32_t msec = 0;
1818 if (!mRecycledTrack->stopped()) { // check if active
1819 (void)mRecycledTrack->pendingDuration(&msec);
1820 }
1821 mRecycledTrack->stop(); // ensure full data drain
1822 ALOGD("deleting recycled track, waiting for data drain (%d msec)", msec);
1823 if (msec > 0) {
1824 static const int32_t WAIT_LIMIT_MS = 3000;
1825 if (msec > WAIT_LIMIT_MS) {
1826 msec = WAIT_LIMIT_MS;
1827 }
1828 usleep(msec * 1000LL);
1829 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001830 }
1831 // An offloaded track isn't flushed because the STREAM_END is reported
1832 // slightly prematurely to allow time for the gapless track switch
1833 // but this means that if we decide not to recycle the track there
1834 // could be a small amount of residual data still playing. We leave
1835 // AudioFlinger to drain the track.
1836
1837 mRecycledTrack.clear();
Andy Hungd1c74342015-07-07 16:54:23 -07001838 close_l();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001839 delete mCallbackData;
1840 mCallbackData = NULL;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001841 }
1842}
1843
Andy Hungd1c74342015-07-07 16:54:23 -07001844void MediaPlayerService::AudioOutput::close_l()
1845{
1846 mTrack.clear();
1847}
1848
Andreas Huber20111aa2009-07-14 16:56:47 -07001849status_t MediaPlayerService::AudioOutput::open(
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001850 uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
1851 audio_format_t format, int bufferCount,
Eric Laurent1948eb32012-04-13 16:50:19 -07001852 AudioCallback cb, void *cookie,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00001853 audio_output_flags_t flags,
Ronghua Wufaeb0f22015-05-21 12:20:21 -07001854 const audio_offload_info_t *offloadInfo,
Andy Hung179652e2015-05-31 22:49:46 -07001855 bool doNotReconnect,
1856 uint32_t suggestedFrameCount)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001857{
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001858 ALOGV("open(%u, %d, 0x%x, 0x%x, %d, %d 0x%x)", sampleRate, channelCount, channelMask,
1859 format, bufferCount, mSessionId, flags);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001860
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001861 // offloading is only supported in callback mode for now.
1862 // offloadInfo must be present if offload flag is set
1863 if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) &&
1864 ((cb == NULL) || (offloadInfo == NULL))) {
1865 return BAD_VALUE;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001866 }
1867
Andy Hung179652e2015-05-31 22:49:46 -07001868 // compute frame count for the AudioTrack internal buffer
1869 size_t frameCount;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001870 if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
1871 frameCount = 0; // AudioTrack will get frame count from AudioFlinger
1872 } else {
Andy Hung179652e2015-05-31 22:49:46 -07001873 // try to estimate the buffer processing fetch size from AudioFlinger.
1874 // framesPerBuffer is approximate and generally correct, except when it's not :-).
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001875 uint32_t afSampleRate;
1876 size_t afFrameCount;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001877 if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) != NO_ERROR) {
1878 return NO_INIT;
1879 }
1880 if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) != NO_ERROR) {
1881 return NO_INIT;
1882 }
Andy Hung179652e2015-05-31 22:49:46 -07001883 const size_t framesPerBuffer =
1884 (unsigned long long)sampleRate * afFrameCount / afSampleRate;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001885
Andy Hung179652e2015-05-31 22:49:46 -07001886 if (bufferCount == 0) {
1887 // use suggestedFrameCount
1888 bufferCount = (suggestedFrameCount + framesPerBuffer - 1) / framesPerBuffer;
1889 }
1890 // Check argument bufferCount against the mininum buffer count
1891 if (bufferCount != 0 && bufferCount < mMinBufferCount) {
1892 ALOGV("bufferCount (%d) increased to %d", bufferCount, mMinBufferCount);
1893 bufferCount = mMinBufferCount;
1894 }
1895 // if frameCount is 0, then AudioTrack will get frame count from AudioFlinger
1896 // which will be the minimum size permitted.
1897 frameCount = bufferCount * framesPerBuffer;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001898 }
Andreas Huber20111aa2009-07-14 16:56:47 -07001899
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001900 if (channelMask == CHANNEL_MASK_USE_CHANNEL_ORDER) {
Glenn Kastenab334fd2012-03-14 12:56:06 -07001901 channelMask = audio_channel_out_mask_from_count(channelCount);
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001902 if (0 == channelMask) {
1903 ALOGE("open() error, can\'t derive mask for %d audio channels", channelCount);
1904 return NO_INIT;
1905 }
1906 }
Eric Laurent1948eb32012-04-13 16:50:19 -07001907
Andy Hungd1c74342015-07-07 16:54:23 -07001908 Mutex::Autolock lock(mLock);
Andy Hung179652e2015-05-31 22:49:46 -07001909 mCallback = cb;
1910 mCallbackCookie = cookie;
1911
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001912 // Check whether we can recycle the track
1913 bool reuse = false;
1914 bool bothOffloaded = false;
Marco Nelissen67295b52012-06-11 14:52:53 -07001915
Glenn Kasten2799d742013-05-30 14:33:29 -07001916 if (mRecycledTrack != 0) {
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001917 // check whether we are switching between two offloaded tracks
1918 bothOffloaded = (flags & mRecycledTrack->getFlags()
1919 & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0;
Marco Nelissen67295b52012-06-11 14:52:53 -07001920
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001921 // check if the existing track can be reused as-is, or if a new track needs to be created.
1922 reuse = true;
1923
Marco Nelissen67295b52012-06-11 14:52:53 -07001924 if ((mCallbackData == NULL && mCallback != NULL) ||
1925 (mCallbackData != NULL && mCallback == NULL)) {
1926 // recycled track uses callbacks but the caller wants to use writes, or vice versa
1927 ALOGV("can't chain callback and write");
1928 reuse = false;
1929 } else if ((mRecycledTrack->getSampleRate() != sampleRate) ||
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001930 (mRecycledTrack->channelCount() != (uint32_t)channelCount) ) {
1931 ALOGV("samplerate, channelcount differ: %u/%u Hz, %u/%d ch",
Marco Nelissen67295b52012-06-11 14:52:53 -07001932 mRecycledTrack->getSampleRate(), sampleRate,
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001933 mRecycledTrack->channelCount(), channelCount);
Marco Nelissen67295b52012-06-11 14:52:53 -07001934 reuse = false;
1935 } else if (flags != mFlags) {
1936 ALOGV("output flags differ %08x/%08x", flags, mFlags);
1937 reuse = false;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001938 } else if (mRecycledTrack->format() != format) {
1939 reuse = false;
Marco Nelissen67295b52012-06-11 14:52:53 -07001940 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001941 } else {
1942 ALOGV("no track available to recycle");
1943 }
1944
1945 ALOGV_IF(bothOffloaded, "both tracks offloaded");
1946
1947 // If we can't recycle and both tracks are offloaded
1948 // we must close the previous output before opening a new one
1949 if (bothOffloaded && !reuse) {
1950 ALOGV("both offloaded and not recycling");
Andy Hungd1c74342015-07-07 16:54:23 -07001951 deleteRecycledTrack_l();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001952 }
1953
1954 sp<AudioTrack> t;
1955 CallbackData *newcbd = NULL;
1956
1957 // We don't attempt to create a new track if we are recycling an
1958 // offloaded track. But, if we are recycling a non-offloaded or we
1959 // are switching where one is offloaded and one isn't then we create
1960 // the new track in advance so that we can read additional stream info
1961
1962 if (!(reuse && bothOffloaded)) {
1963 ALOGV("creating new AudioTrack");
1964
1965 if (mCallback != NULL) {
1966 newcbd = new CallbackData(this);
1967 t = new AudioTrack(
1968 mStreamType,
1969 sampleRate,
1970 format,
1971 channelMask,
1972 frameCount,
1973 flags,
1974 CallbackWrapper,
1975 newcbd,
1976 0, // notification frames
1977 mSessionId,
1978 AudioTrack::TRANSFER_CALLBACK,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001979 offloadInfo,
Marco Nelissend457c972014-02-11 08:47:07 -08001980 mUid,
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001981 mPid,
Ronghua Wufaeb0f22015-05-21 12:20:21 -07001982 mAttributes,
1983 doNotReconnect);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001984 } else {
Andy Hungff874dc2016-04-11 16:49:09 -07001985 // TODO: Due to buffer memory concerns, we use a max target playback speed
1986 // based on mPlaybackRate at the time of open (instead of kMaxRequiredSpeed),
1987 // also clamping the target speed to 1.0 <= targetSpeed <= kMaxRequiredSpeed.
1988 const float targetSpeed =
1989 std::min(std::max(mPlaybackRate.mSpeed, 1.0f), kMaxRequiredSpeed);
1990 ALOGW_IF(targetSpeed != mPlaybackRate.mSpeed,
1991 "track target speed:%f clamped from playback speed:%f",
1992 targetSpeed, mPlaybackRate.mSpeed);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001993 t = new AudioTrack(
1994 mStreamType,
1995 sampleRate,
1996 format,
1997 channelMask,
1998 frameCount,
1999 flags,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08002000 NULL, // callback
2001 NULL, // user data
2002 0, // notification frames
2003 mSessionId,
2004 AudioTrack::TRANSFER_DEFAULT,
2005 NULL, // offload info
Marco Nelissend457c972014-02-11 08:47:07 -08002006 mUid,
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07002007 mPid,
Ronghua Wufaeb0f22015-05-21 12:20:21 -07002008 mAttributes,
Andy Hungff874dc2016-04-11 16:49:09 -07002009 doNotReconnect,
2010 targetSpeed);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002011 }
2012
2013 if ((t == 0) || (t->initCheck() != NO_ERROR)) {
2014 ALOGE("Unable to create audio track");
2015 delete newcbd;
Glenn Kasten3e98ecd2015-05-18 13:13:24 -07002016 // t goes out of scope, so reference count drops to zero
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002017 return NO_INIT;
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07002018 } else {
2019 // successful AudioTrack initialization implies a legacy stream type was generated
2020 // from the audio attributes
2021 mStreamType = t->streamType();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002022 }
2023 }
2024
2025 if (reuse) {
2026 CHECK(mRecycledTrack != NULL);
2027
2028 if (!bothOffloaded) {
2029 if (mRecycledTrack->frameCount() != t->frameCount()) {
Andy Hung833b4752016-04-04 17:15:48 -07002030 ALOGV("framecount differs: %zu/%zu frames",
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002031 mRecycledTrack->frameCount(), t->frameCount());
2032 reuse = false;
2033 }
2034 }
2035
Marco Nelissen67295b52012-06-11 14:52:53 -07002036 if (reuse) {
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002037 ALOGV("chaining to next output and recycling track");
Andy Hungd1c74342015-07-07 16:54:23 -07002038 close_l();
Marco Nelissen67295b52012-06-11 14:52:53 -07002039 mTrack = mRecycledTrack;
Glenn Kasten2799d742013-05-30 14:33:29 -07002040 mRecycledTrack.clear();
Marco Nelissen67295b52012-06-11 14:52:53 -07002041 if (mCallbackData != NULL) {
2042 mCallbackData->setOutput(this);
2043 }
Marco Nelissen67295b52012-06-11 14:52:53 -07002044 delete newcbd;
Wei Jiae0bbac92016-07-18 16:04:53 -07002045 return updateTrack();
Marco Nelissen67295b52012-06-11 14:52:53 -07002046 }
Marco Nelissen67295b52012-06-11 14:52:53 -07002047 }
2048
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002049 // we're not going to reuse the track, unblock and flush it
2050 // this was done earlier if both tracks are offloaded
2051 if (!bothOffloaded) {
Andy Hungd1c74342015-07-07 16:54:23 -07002052 deleteRecycledTrack_l();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002053 }
2054
2055 CHECK((t != NULL) && ((mCallback == NULL) || (newcbd != NULL)));
2056
Marco Nelissen67295b52012-06-11 14:52:53 -07002057 mCallbackData = newcbd;
Steve Block3856b092011-10-20 11:56:00 +01002058 ALOGV("setVolume");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002059 t->setVolume(mLeftVolume, mRightVolume);
Eric Laurent2beeb502010-07-16 07:43:46 -07002060
Andy Hung39399b62017-04-21 15:07:45 -07002061 // Restore VolumeShapers for the MediaPlayer in case the track was recreated
2062 // due to an output sink error (e.g. offload to non-offload switch).
2063 mVolumeHandler->forall([&t](const VolumeShaper &shaper) -> VolumeShaper::Status {
2064 sp<VolumeShaper::Operation> operationToEnd =
2065 new VolumeShaper::Operation(shaper.mOperation);
2066 // TODO: Ideally we would restore to the exact xOffset position
2067 // as returned by getVolumeShaperState(), but we don't have that
2068 // information when restoring at the client unless we periodically poll
2069 // the server or create shared memory state.
2070 //
2071 // For now, we simply advance to the end of the VolumeShaper effect
2072 // if it has been started.
2073 if (shaper.isStarted()) {
Andy Hungf3702642017-05-05 17:33:32 -07002074 operationToEnd->setNormalizedTime(1.f);
Andy Hung39399b62017-04-21 15:07:45 -07002075 }
2076 return t->applyVolumeShaper(shaper.mConfiguration, operationToEnd);
Andy Hung4ef88d72017-02-21 19:47:53 -08002077 });
Andy Hung4ef88d72017-02-21 19:47:53 -08002078
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002079 mSampleRateHz = sampleRate;
Preetam Singh Ranawat2e17eef2015-08-12 12:11:46 -07002080 mFlags = flags;
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002081 mMsecsPerFrame = 1E3f / (mPlaybackRate.mSpeed * sampleRate);
Andy Hungd1c74342015-07-07 16:54:23 -07002082 mFrameSize = t->frameSize();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002083 mTrack = t;
Eric Laurent2beeb502010-07-16 07:43:46 -07002084
Wei Jiae0bbac92016-07-18 16:04:53 -07002085 return updateTrack();
2086}
2087
2088status_t MediaPlayerService::AudioOutput::updateTrack() {
2089 if (mTrack == NULL) {
2090 return NO_ERROR;
2091 }
2092
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002093 status_t res = NO_ERROR;
Wei Jia0162d002015-06-09 11:59:33 -07002094 // Note some output devices may give us a direct track even though we don't specify it.
2095 // Example: Line application b/17459982.
Wei Jiae0bbac92016-07-18 16:04:53 -07002096 if ((mTrack->getFlags()
2097 & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD | AUDIO_OUTPUT_FLAG_DIRECT)) == 0) {
2098 res = mTrack->setPlaybackRate(mPlaybackRate);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002099 if (res == NO_ERROR) {
Wei Jiae0bbac92016-07-18 16:04:53 -07002100 mTrack->setAuxEffectSendLevel(mSendLevel);
2101 res = mTrack->attachAuxEffect(mAuxEffectId);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002102 }
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002103 }
Wei Jiae0bbac92016-07-18 16:04:53 -07002104 ALOGV("updateTrack() DONE status %d", res);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002105 return res;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002106}
2107
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002108status_t MediaPlayerService::AudioOutput::start()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002109{
Steve Block3856b092011-10-20 11:56:00 +01002110 ALOGV("start");
Andy Hungd1c74342015-07-07 16:54:23 -07002111 Mutex::Autolock lock(mLock);
Marco Nelissen6b74d672012-02-28 16:07:44 -08002112 if (mCallbackData != NULL) {
2113 mCallbackData->endTrackSwitch();
2114 }
Glenn Kasten2799d742013-05-30 14:33:29 -07002115 if (mTrack != 0) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002116 mTrack->setVolume(mLeftVolume, mRightVolume);
Eric Laurent2beeb502010-07-16 07:43:46 -07002117 mTrack->setAuxEffectSendLevel(mSendLevel);
Andy Hung39399b62017-04-21 15:07:45 -07002118 status_t status = mTrack->start();
2119 if (status == NO_ERROR) {
2120 mVolumeHandler->setStarted();
2121 }
2122 return status;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002123 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002124 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002125}
2126
Marco Nelissen6b74d672012-02-28 16:07:44 -08002127void MediaPlayerService::AudioOutput::setNextOutput(const sp<AudioOutput>& nextOutput) {
Andy Hungd1c74342015-07-07 16:54:23 -07002128 Mutex::Autolock lock(mLock);
Marco Nelissen6b74d672012-02-28 16:07:44 -08002129 mNextOutput = nextOutput;
2130}
Marco Nelissen7ee8ac92010-01-12 09:23:54 -08002131
Marco Nelissen6b74d672012-02-28 16:07:44 -08002132void MediaPlayerService::AudioOutput::switchToNextOutput() {
2133 ALOGV("switchToNextOutput");
Andy Hungd1c74342015-07-07 16:54:23 -07002134
2135 // Try to acquire the callback lock before moving track (without incurring deadlock).
2136 const unsigned kMaxSwitchTries = 100;
2137 Mutex::Autolock lock(mLock);
2138 for (unsigned tries = 0;;) {
2139 if (mTrack == 0) {
2140 return;
Marco Nelissen6b74d672012-02-28 16:07:44 -08002141 }
Andy Hungd1c74342015-07-07 16:54:23 -07002142 if (mNextOutput != NULL && mNextOutput != this) {
2143 if (mCallbackData != NULL) {
2144 // two alternative approaches
2145#if 1
2146 CallbackData *callbackData = mCallbackData;
2147 mLock.unlock();
2148 // proper acquisition sequence
2149 callbackData->lock();
2150 mLock.lock();
2151 // Caution: it is unlikely that someone deleted our callback or changed our target
2152 if (callbackData != mCallbackData || mNextOutput == NULL || mNextOutput == this) {
2153 // fatal if we are starved out.
2154 LOG_ALWAYS_FATAL_IF(++tries > kMaxSwitchTries,
2155 "switchToNextOutput() cannot obtain correct lock sequence");
2156 callbackData->unlock();
2157 continue;
2158 }
2159 callbackData->mSwitching = true; // begin track switch
Wei Jiaadee56a2016-08-05 15:40:34 -07002160 callbackData->setOutput(NULL);
Andy Hungd1c74342015-07-07 16:54:23 -07002161#else
2162 // tryBeginTrackSwitch() returns false if the callback has the lock.
2163 if (!mCallbackData->tryBeginTrackSwitch()) {
2164 // fatal if we are starved out.
2165 LOG_ALWAYS_FATAL_IF(++tries > kMaxSwitchTries,
2166 "switchToNextOutput() cannot obtain callback lock");
2167 mLock.unlock();
2168 usleep(5 * 1000 /* usec */); // allow callback to use AudioOutput
2169 mLock.lock();
2170 continue;
2171 }
2172#endif
2173 }
2174
2175 Mutex::Autolock nextLock(mNextOutput->mLock);
2176
2177 // If the next output track is not NULL, then it has been
2178 // opened already for playback.
2179 // This is possible even without the next player being started,
2180 // for example, the next player could be prepared and seeked.
2181 //
2182 // Presuming it isn't advisable to force the track over.
2183 if (mNextOutput->mTrack == NULL) {
2184 ALOGD("Recycling track for gapless playback");
2185 delete mNextOutput->mCallbackData;
2186 mNextOutput->mCallbackData = mCallbackData;
2187 mNextOutput->mRecycledTrack = mTrack;
2188 mNextOutput->mSampleRateHz = mSampleRateHz;
2189 mNextOutput->mMsecsPerFrame = mMsecsPerFrame;
Andy Hungd1c74342015-07-07 16:54:23 -07002190 mNextOutput->mFlags = mFlags;
2191 mNextOutput->mFrameSize = mFrameSize;
2192 close_l();
2193 mCallbackData = NULL; // destruction handled by mNextOutput
2194 } else {
2195 ALOGW("Ignoring gapless playback because next player has already started");
2196 // remove track in case resource needed for future players.
2197 if (mCallbackData != NULL) {
2198 mCallbackData->endTrackSwitch(); // release lock for callbacks before close.
2199 }
2200 close_l();
2201 }
2202 }
2203 break;
Marco Nelissen6b74d672012-02-28 16:07:44 -08002204 }
2205}
2206
Wei Jia7d3f4df2015-03-03 15:28:00 -08002207ssize_t MediaPlayerService::AudioOutput::write(const void* buffer, size_t size, bool blocking)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002208{
Andy Hungd1c74342015-07-07 16:54:23 -07002209 Mutex::Autolock lock(mLock);
Glenn Kastenadad3d72014-02-21 14:51:43 -08002210 LOG_ALWAYS_FATAL_IF(mCallback != NULL, "Don't call write if supplying a callback.");
Andreas Huber20111aa2009-07-14 16:56:47 -07002211
Steve Block3856b092011-10-20 11:56:00 +01002212 //ALOGV("write(%p, %u)", buffer, size);
Glenn Kasten2799d742013-05-30 14:33:29 -07002213 if (mTrack != 0) {
Andy Hung2f6e73d2016-04-08 12:12:58 -07002214 return mTrack->write(buffer, size, blocking);
Marco Nelissen10dbb8e2009-09-20 10:42:13 -07002215 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002216 return NO_INIT;
2217}
2218
2219void MediaPlayerService::AudioOutput::stop()
2220{
Steve Block3856b092011-10-20 11:56:00 +01002221 ALOGV("stop");
Andy Hungd1c74342015-07-07 16:54:23 -07002222 Mutex::Autolock lock(mLock);
Glenn Kasten2799d742013-05-30 14:33:29 -07002223 if (mTrack != 0) mTrack->stop();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002224}
2225
2226void MediaPlayerService::AudioOutput::flush()
2227{
Steve Block3856b092011-10-20 11:56:00 +01002228 ALOGV("flush");
Andy Hungd1c74342015-07-07 16:54:23 -07002229 Mutex::Autolock lock(mLock);
Glenn Kasten2799d742013-05-30 14:33:29 -07002230 if (mTrack != 0) mTrack->flush();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002231}
2232
2233void MediaPlayerService::AudioOutput::pause()
2234{
Steve Block3856b092011-10-20 11:56:00 +01002235 ALOGV("pause");
Andy Hungd1c74342015-07-07 16:54:23 -07002236 Mutex::Autolock lock(mLock);
Glenn Kasten2799d742013-05-30 14:33:29 -07002237 if (mTrack != 0) mTrack->pause();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002238}
2239
2240void MediaPlayerService::AudioOutput::close()
2241{
Steve Block3856b092011-10-20 11:56:00 +01002242 ALOGV("close");
Erik Wolsheimer7845a1f2015-10-30 12:07:52 -07002243 sp<AudioTrack> track;
2244 {
2245 Mutex::Autolock lock(mLock);
2246 track = mTrack;
2247 close_l(); // clears mTrack
2248 }
2249 // destruction of the track occurs outside of mutex.
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002250}
2251
2252void MediaPlayerService::AudioOutput::setVolume(float left, float right)
2253{
Steve Block3856b092011-10-20 11:56:00 +01002254 ALOGV("setVolume(%f, %f)", left, right);
Andy Hungd1c74342015-07-07 16:54:23 -07002255 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002256 mLeftVolume = left;
2257 mRightVolume = right;
Glenn Kasten2799d742013-05-30 14:33:29 -07002258 if (mTrack != 0) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002259 mTrack->setVolume(left, right);
2260 }
2261}
2262
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002263status_t MediaPlayerService::AudioOutput::setPlaybackRate(const AudioPlaybackRate &rate)
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002264{
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002265 ALOGV("setPlaybackRate(%f %f %d %d)",
2266 rate.mSpeed, rate.mPitch, rate.mFallbackMode, rate.mStretchMode);
Andy Hungd1c74342015-07-07 16:54:23 -07002267 Mutex::Autolock lock(mLock);
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002268 if (mTrack == 0) {
2269 // remember rate so that we can set it when the track is opened
2270 mPlaybackRate = rate;
2271 return OK;
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002272 }
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002273 status_t res = mTrack->setPlaybackRate(rate);
2274 if (res != NO_ERROR) {
2275 return res;
2276 }
2277 // rate.mSpeed is always greater than 0 if setPlaybackRate succeeded
2278 CHECK_GT(rate.mSpeed, 0.f);
2279 mPlaybackRate = rate;
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002280 if (mSampleRateHz != 0) {
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002281 mMsecsPerFrame = 1E3f / (rate.mSpeed * mSampleRateHz);
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002282 }
2283 return res;
2284}
2285
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002286status_t MediaPlayerService::AudioOutput::getPlaybackRate(AudioPlaybackRate *rate)
2287{
2288 ALOGV("setPlaybackRate");
Andy Hungd1c74342015-07-07 16:54:23 -07002289 Mutex::Autolock lock(mLock);
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002290 if (mTrack == 0) {
2291 return NO_INIT;
2292 }
2293 *rate = mTrack->getPlaybackRate();
2294 return NO_ERROR;
2295}
2296
Eric Laurent2beeb502010-07-16 07:43:46 -07002297status_t MediaPlayerService::AudioOutput::setAuxEffectSendLevel(float level)
2298{
Steve Block3856b092011-10-20 11:56:00 +01002299 ALOGV("setAuxEffectSendLevel(%f)", level);
Andy Hungd1c74342015-07-07 16:54:23 -07002300 Mutex::Autolock lock(mLock);
Eric Laurent2beeb502010-07-16 07:43:46 -07002301 mSendLevel = level;
Glenn Kasten2799d742013-05-30 14:33:29 -07002302 if (mTrack != 0) {
Eric Laurent2beeb502010-07-16 07:43:46 -07002303 return mTrack->setAuxEffectSendLevel(level);
2304 }
2305 return NO_ERROR;
2306}
2307
2308status_t MediaPlayerService::AudioOutput::attachAuxEffect(int effectId)
2309{
Steve Block3856b092011-10-20 11:56:00 +01002310 ALOGV("attachAuxEffect(%d)", effectId);
Andy Hungd1c74342015-07-07 16:54:23 -07002311 Mutex::Autolock lock(mLock);
Eric Laurent2beeb502010-07-16 07:43:46 -07002312 mAuxEffectId = effectId;
Glenn Kasten2799d742013-05-30 14:33:29 -07002313 if (mTrack != 0) {
Eric Laurent2beeb502010-07-16 07:43:46 -07002314 return mTrack->attachAuxEffect(effectId);
2315 }
2316 return NO_ERROR;
2317}
2318
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002319VolumeShaper::Status MediaPlayerService::AudioOutput::applyVolumeShaper(
2320 const sp<VolumeShaper::Configuration>& configuration,
2321 const sp<VolumeShaper::Operation>& operation)
2322{
2323 Mutex::Autolock lock(mLock);
2324 ALOGV("AudioOutput::applyVolumeShaper");
Andy Hung4ef88d72017-02-21 19:47:53 -08002325
Andy Hung4ef88d72017-02-21 19:47:53 -08002326 mVolumeHandler->setIdIfNecessary(configuration);
Andy Hung39399b62017-04-21 15:07:45 -07002327
2328 VolumeShaper::Status status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002329 if (mTrack != 0) {
Andy Hung39399b62017-04-21 15:07:45 -07002330 status = mTrack->applyVolumeShaper(configuration, operation);
2331 if (status >= 0) {
2332 (void)mVolumeHandler->applyVolumeShaper(configuration, operation);
Andy Hungf3702642017-05-05 17:33:32 -07002333 if (mTrack->isPlaying()) { // match local AudioTrack to properly restore.
2334 mVolumeHandler->setStarted();
2335 }
Andy Hung39399b62017-04-21 15:07:45 -07002336 }
Andy Hung4ef88d72017-02-21 19:47:53 -08002337 } else {
Andy Hung39399b62017-04-21 15:07:45 -07002338 status = mVolumeHandler->applyVolumeShaper(configuration, operation);
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002339 }
Andy Hung39399b62017-04-21 15:07:45 -07002340 return status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002341}
2342
2343sp<VolumeShaper::State> MediaPlayerService::AudioOutput::getVolumeShaperState(int id)
2344{
2345 Mutex::Autolock lock(mLock);
2346 if (mTrack != 0) {
2347 return mTrack->getVolumeShaperState(id);
Andy Hung4ef88d72017-02-21 19:47:53 -08002348 } else {
2349 return mVolumeHandler->getVolumeShaperState(id);
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002350 }
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002351}
2352
Andreas Huber20111aa2009-07-14 16:56:47 -07002353// static
2354void MediaPlayerService::AudioOutput::CallbackWrapper(
Glenn Kastend217a8c2011-06-01 15:20:35 -07002355 int event, void *cookie, void *info) {
Steve Block3856b092011-10-20 11:56:00 +01002356 //ALOGV("callbackwrapper");
Marco Nelissen6b74d672012-02-28 16:07:44 -08002357 CallbackData *data = (CallbackData*)cookie;
Andy Hungd1c74342015-07-07 16:54:23 -07002358 // lock to ensure we aren't caught in the middle of a track switch.
Marco Nelissen6b74d672012-02-28 16:07:44 -08002359 data->lock();
2360 AudioOutput *me = data->getOutput();
Andreas Huber20111aa2009-07-14 16:56:47 -07002361 AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
Marco Nelissen6b74d672012-02-28 16:07:44 -08002362 if (me == NULL) {
2363 // no output set, likely because the track was scheduled to be reused
2364 // by another player, but the format turned out to be incompatible.
2365 data->unlock();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002366 if (buffer != NULL) {
2367 buffer->size = 0;
2368 }
Marco Nelissen6b74d672012-02-28 16:07:44 -08002369 return;
2370 }
Andreas Huber20111aa2009-07-14 16:56:47 -07002371
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002372 switch(event) {
2373 case AudioTrack::EVENT_MORE_DATA: {
2374 size_t actualSize = (*me->mCallback)(
2375 me, buffer->raw, buffer->size, me->mCallbackCookie,
2376 CB_EVENT_FILL_BUFFER);
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002377
Andy Hung719b46b2015-05-31 22:18:25 -07002378 // Log when no data is returned from the callback.
2379 // (1) We may have no data (especially with network streaming sources).
2380 // (2) We may have reached the EOS and the audio track is not stopped yet.
2381 // Note that AwesomePlayer/AudioPlayer will only return zero size when it reaches the EOS.
2382 // NuPlayerRenderer will return zero when it doesn't have data (it doesn't block to fill).
2383 //
2384 // This is a benign busy-wait, with the next data request generated 10 ms or more later;
2385 // nevertheless for power reasons, we don't want to see too many of these.
Andreas Huber2e8ffaf2010-02-18 16:45:13 -08002386
Andy Hung719b46b2015-05-31 22:18:25 -07002387 ALOGV_IF(actualSize == 0 && buffer->size > 0, "callbackwrapper: empty buffer returned");
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002388
2389 buffer->size = actualSize;
2390 } break;
2391
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002392 case AudioTrack::EVENT_STREAM_END:
Andy Hung719b46b2015-05-31 22:18:25 -07002393 // currently only occurs for offloaded callbacks
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002394 ALOGV("callbackwrapper: deliver EVENT_STREAM_END");
2395 (*me->mCallback)(me, NULL /* buffer */, 0 /* size */,
2396 me->mCallbackCookie, CB_EVENT_STREAM_END);
2397 break;
2398
2399 case AudioTrack::EVENT_NEW_IAUDIOTRACK :
2400 ALOGV("callbackwrapper: deliver EVENT_TEAR_DOWN");
2401 (*me->mCallback)(me, NULL /* buffer */, 0 /* size */,
2402 me->mCallbackCookie, CB_EVENT_TEAR_DOWN);
2403 break;
2404
Glenn Kasten421743b2015-06-01 08:18:08 -07002405 case AudioTrack::EVENT_UNDERRUN:
Andy Hung719b46b2015-05-31 22:18:25 -07002406 // This occurs when there is no data available, typically
Glenn Kasten421743b2015-06-01 08:18:08 -07002407 // when there is a failure to supply data to the AudioTrack. It can also
2408 // occur in non-offloaded mode when the audio device comes out of standby.
2409 //
Andy Hung719b46b2015-05-31 22:18:25 -07002410 // If an AudioTrack underruns it outputs silence. Since this happens suddenly
2411 // it may sound like an audible pop or glitch.
2412 //
2413 // The underrun event is sent once per track underrun; the condition is reset
2414 // when more data is sent to the AudioTrack.
Eric Laurente93cc032016-05-05 10:15:10 -07002415 ALOGD("callbackwrapper: EVENT_UNDERRUN (discarded)");
Glenn Kasten421743b2015-06-01 08:18:08 -07002416 break;
2417
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002418 default:
2419 ALOGE("received unknown event type: %d inside CallbackWrapper !", event);
Andreas Huber51c1e0e2011-04-04 11:43:40 -07002420 }
2421
Marco Nelissen6b74d672012-02-28 16:07:44 -08002422 data->unlock();
Andreas Huber20111aa2009-07-14 16:56:47 -07002423}
2424
Glenn Kastend848eb42016-03-08 13:42:11 -08002425audio_session_t MediaPlayerService::AudioOutput::getSessionId() const
Eric Laurent8c563ed2010-10-07 18:23:03 -07002426{
Andy Hungd1c74342015-07-07 16:54:23 -07002427 Mutex::Autolock lock(mLock);
Eric Laurent8c563ed2010-10-07 18:23:03 -07002428 return mSessionId;
2429}
2430
Eric Laurent6f59db12013-07-26 17:16:50 -07002431uint32_t MediaPlayerService::AudioOutput::getSampleRate() const
2432{
Andy Hungd1c74342015-07-07 16:54:23 -07002433 Mutex::Autolock lock(mLock);
Eric Laurent6f59db12013-07-26 17:16:50 -07002434 if (mTrack == 0) return 0;
2435 return mTrack->getSampleRate();
2436}
2437
Andy Hungf2c87b32016-04-07 19:49:29 -07002438int64_t MediaPlayerService::AudioOutput::getBufferDurationInUs() const
2439{
2440 Mutex::Autolock lock(mLock);
2441 if (mTrack == 0) {
2442 return 0;
2443 }
2444 int64_t duration;
2445 if (mTrack->getBufferDurationInUs(&duration) != OK) {
2446 return 0;
2447 }
2448 return duration;
2449}
2450
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002451////////////////////////////////////////////////////////////////////////////////
2452
2453struct CallbackThread : public Thread {
2454 CallbackThread(const wp<MediaPlayerBase::AudioSink> &sink,
2455 MediaPlayerBase::AudioSink::AudioCallback cb,
2456 void *cookie);
2457
2458protected:
2459 virtual ~CallbackThread();
2460
2461 virtual bool threadLoop();
2462
2463private:
2464 wp<MediaPlayerBase::AudioSink> mSink;
2465 MediaPlayerBase::AudioSink::AudioCallback mCallback;
2466 void *mCookie;
2467 void *mBuffer;
2468 size_t mBufferSize;
2469
2470 CallbackThread(const CallbackThread &);
2471 CallbackThread &operator=(const CallbackThread &);
2472};
2473
2474CallbackThread::CallbackThread(
2475 const wp<MediaPlayerBase::AudioSink> &sink,
2476 MediaPlayerBase::AudioSink::AudioCallback cb,
2477 void *cookie)
2478 : mSink(sink),
2479 mCallback(cb),
2480 mCookie(cookie),
2481 mBuffer(NULL),
2482 mBufferSize(0) {
2483}
2484
2485CallbackThread::~CallbackThread() {
2486 if (mBuffer) {
2487 free(mBuffer);
2488 mBuffer = NULL;
2489 }
2490}
2491
2492bool CallbackThread::threadLoop() {
2493 sp<MediaPlayerBase::AudioSink> sink = mSink.promote();
2494 if (sink == NULL) {
2495 return false;
2496 }
2497
2498 if (mBuffer == NULL) {
2499 mBufferSize = sink->bufferSize();
2500 mBuffer = malloc(mBufferSize);
2501 }
2502
2503 size_t actualSize =
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002504 (*mCallback)(sink.get(), mBuffer, mBufferSize, mCookie,
2505 MediaPlayerBase::AudioSink::CB_EVENT_FILL_BUFFER);
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002506
2507 if (actualSize > 0) {
2508 sink->write(mBuffer, actualSize);
Andy Hunga31335a2014-08-20 17:37:59 -07002509 // Could return false on sink->write() error or short count.
2510 // Not necessarily appropriate but would work for AudioCache behavior.
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002511 }
2512
2513 return true;
2514}
2515
2516////////////////////////////////////////////////////////////////////////////////
2517
Chong Zhange5b9b692017-05-11 11:44:56 -07002518void MediaPlayerService::addBatteryData(uint32_t params) {
2519 mBatteryTracker.addBatteryData(params);
2520}
2521
2522status_t MediaPlayerService::pullBatteryData(Parcel* reply) {
2523 return mBatteryTracker.pullBatteryData(reply);
2524}
2525
2526MediaPlayerService::BatteryTracker::BatteryTracker() {
2527 mBatteryAudio.refCount = 0;
2528 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2529 mBatteryAudio.deviceOn[i] = 0;
2530 mBatteryAudio.lastTime[i] = 0;
2531 mBatteryAudio.totalTime[i] = 0;
2532 }
2533 // speaker is on by default
2534 mBatteryAudio.deviceOn[SPEAKER] = 1;
2535
2536 // reset battery stats
2537 // if the mediaserver has crashed, battery stats could be left
2538 // in bad state, reset the state upon service start.
2539 BatteryNotifier::getInstance().noteResetVideo();
2540}
2541
2542void MediaPlayerService::BatteryTracker::addBatteryData(uint32_t params)
Gloria Wang7cf180c2011-02-19 18:37:57 -08002543{
2544 Mutex::Autolock lock(mLock);
Gloria Wang9ee159b2011-02-24 14:51:45 -08002545
2546 int32_t time = systemTime() / 1000000L;
2547
2548 // change audio output devices. This notification comes from AudioFlinger
2549 if ((params & kBatteryDataSpeakerOn)
2550 || (params & kBatteryDataOtherAudioDeviceOn)) {
2551
2552 int deviceOn[NUM_AUDIO_DEVICES];
2553 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2554 deviceOn[i] = 0;
2555 }
2556
2557 if ((params & kBatteryDataSpeakerOn)
2558 && (params & kBatteryDataOtherAudioDeviceOn)) {
2559 deviceOn[SPEAKER_AND_OTHER] = 1;
2560 } else if (params & kBatteryDataSpeakerOn) {
2561 deviceOn[SPEAKER] = 1;
2562 } else {
2563 deviceOn[OTHER_AUDIO_DEVICE] = 1;
2564 }
2565
2566 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2567 if (mBatteryAudio.deviceOn[i] != deviceOn[i]){
2568
2569 if (mBatteryAudio.refCount > 0) { // if playing audio
2570 if (!deviceOn[i]) {
2571 mBatteryAudio.lastTime[i] += time;
2572 mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
2573 mBatteryAudio.lastTime[i] = 0;
2574 } else {
2575 mBatteryAudio.lastTime[i] = 0 - time;
2576 }
2577 }
2578
2579 mBatteryAudio.deviceOn[i] = deviceOn[i];
2580 }
2581 }
2582 return;
2583 }
2584
Marco Nelissenb7848f12014-12-04 08:57:56 -08002585 // an audio stream is started
Gloria Wang9ee159b2011-02-24 14:51:45 -08002586 if (params & kBatteryDataAudioFlingerStart) {
2587 // record the start time only if currently no other audio
2588 // is being played
2589 if (mBatteryAudio.refCount == 0) {
2590 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2591 if (mBatteryAudio.deviceOn[i]) {
2592 mBatteryAudio.lastTime[i] -= time;
2593 }
2594 }
2595 }
2596
2597 mBatteryAudio.refCount ++;
2598 return;
2599
2600 } else if (params & kBatteryDataAudioFlingerStop) {
2601 if (mBatteryAudio.refCount <= 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002602 ALOGW("Battery track warning: refCount is <= 0");
Gloria Wang9ee159b2011-02-24 14:51:45 -08002603 return;
2604 }
2605
2606 // record the stop time only if currently this is the only
2607 // audio being played
2608 if (mBatteryAudio.refCount == 1) {
2609 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2610 if (mBatteryAudio.deviceOn[i]) {
2611 mBatteryAudio.lastTime[i] += time;
2612 mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
2613 mBatteryAudio.lastTime[i] = 0;
2614 }
2615 }
2616 }
2617
2618 mBatteryAudio.refCount --;
2619 return;
2620 }
2621
Andy Hung1afd0982016-11-08 16:13:44 -08002622 uid_t uid = IPCThreadState::self()->getCallingUid();
Gloria Wang7cf180c2011-02-19 18:37:57 -08002623 if (uid == AID_MEDIA) {
2624 return;
2625 }
2626 int index = mBatteryData.indexOfKey(uid);
Gloria Wang7cf180c2011-02-19 18:37:57 -08002627
2628 if (index < 0) { // create a new entry for this UID
2629 BatteryUsageInfo info;
2630 info.audioTotalTime = 0;
2631 info.videoTotalTime = 0;
2632 info.audioLastTime = 0;
2633 info.videoLastTime = 0;
2634 info.refCount = 0;
2635
Gloria Wang9ee159b2011-02-24 14:51:45 -08002636 if (mBatteryData.add(uid, info) == NO_MEMORY) {
Steve Block29357bc2012-01-06 19:20:56 +00002637 ALOGE("Battery track error: no memory for new app");
Gloria Wang9ee159b2011-02-24 14:51:45 -08002638 return;
2639 }
Gloria Wang7cf180c2011-02-19 18:37:57 -08002640 }
2641
2642 BatteryUsageInfo &info = mBatteryData.editValueFor(uid);
2643
2644 if (params & kBatteryDataCodecStarted) {
2645 if (params & kBatteryDataTrackAudio) {
2646 info.audioLastTime -= time;
2647 info.refCount ++;
2648 }
2649 if (params & kBatteryDataTrackVideo) {
2650 info.videoLastTime -= time;
2651 info.refCount ++;
2652 }
2653 } else {
2654 if (info.refCount == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002655 ALOGW("Battery track warning: refCount is already 0");
Gloria Wang7cf180c2011-02-19 18:37:57 -08002656 return;
2657 } else if (info.refCount < 0) {
Steve Block29357bc2012-01-06 19:20:56 +00002658 ALOGE("Battery track error: refCount < 0");
Gloria Wang7cf180c2011-02-19 18:37:57 -08002659 mBatteryData.removeItem(uid);
2660 return;
2661 }
2662
2663 if (params & kBatteryDataTrackAudio) {
2664 info.audioLastTime += time;
2665 info.refCount --;
2666 }
2667 if (params & kBatteryDataTrackVideo) {
2668 info.videoLastTime += time;
2669 info.refCount --;
2670 }
2671
2672 // no stream is being played by this UID
2673 if (info.refCount == 0) {
2674 info.audioTotalTime += info.audioLastTime;
2675 info.audioLastTime = 0;
2676 info.videoTotalTime += info.videoLastTime;
2677 info.videoLastTime = 0;
2678 }
2679 }
2680}
2681
Chong Zhange5b9b692017-05-11 11:44:56 -07002682status_t MediaPlayerService::BatteryTracker::pullBatteryData(Parcel* reply) {
Gloria Wang7cf180c2011-02-19 18:37:57 -08002683 Mutex::Autolock lock(mLock);
Gloria Wang9ee159b2011-02-24 14:51:45 -08002684
2685 // audio output devices usage
2686 int32_t time = systemTime() / 1000000L; //in ms
2687 int32_t totalTime;
2688
2689 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2690 totalTime = mBatteryAudio.totalTime[i];
2691
2692 if (mBatteryAudio.deviceOn[i]
2693 && (mBatteryAudio.lastTime[i] != 0)) {
2694 int32_t tmpTime = mBatteryAudio.lastTime[i] + time;
2695 totalTime += tmpTime;
2696 }
2697
2698 reply->writeInt32(totalTime);
2699 // reset the total time
2700 mBatteryAudio.totalTime[i] = 0;
2701 }
2702
2703 // codec usage
Gloria Wang7cf180c2011-02-19 18:37:57 -08002704 BatteryUsageInfo info;
2705 int size = mBatteryData.size();
2706
2707 reply->writeInt32(size);
2708 int i = 0;
2709
2710 while (i < size) {
2711 info = mBatteryData.valueAt(i);
2712
2713 reply->writeInt32(mBatteryData.keyAt(i)); //UID
2714 reply->writeInt32(info.audioTotalTime);
2715 reply->writeInt32(info.videoTotalTime);
2716
2717 info.audioTotalTime = 0;
2718 info.videoTotalTime = 0;
2719
2720 // remove the UID entry where no stream is being played
2721 if (info.refCount <= 0) {
2722 mBatteryData.removeItemsAt(i);
2723 size --;
2724 i --;
2725 }
2726 i++;
2727 }
2728 return NO_ERROR;
2729}
nikoa64c8c72009-07-20 15:07:26 -07002730} // namespace android