blob: 77f0cab58a9ef48b4590c3f1326dffb1ad65caec [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);
Wei Jia502c2f42017-07-13 17:47:56 -0700603 {
604 Mutex::Autolock l(mLock);
605 mAudioOutput.clear();
606 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800607 wp<Client> client(this);
608 disconnect();
609 mService->removeClient(client);
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700610 if (mAudioAttributes != NULL) {
611 free(mAudioAttributes);
612 }
Pawin Vongmasa9c47c972017-02-08 04:09:38 -0800613 clearDeathNotifiers();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800614}
615
616void MediaPlayerService::Client::disconnect()
617{
Steve Block3856b092011-10-20 11:56:00 +0100618 ALOGV("disconnect(%d) from pid %d", mConnId, mPid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800619 // grab local reference and clear main reference to prevent future
620 // access to object
621 sp<MediaPlayerBase> p;
622 {
623 Mutex::Autolock l(mLock);
624 p = mPlayer;
beanzdcfefde2012-11-05 09:51:43 +0800625 mClient.clear();
Wei Jia502c2f42017-07-13 17:47:56 -0700626 mPlayer.clear();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800627 }
Andreas Huber20111aa2009-07-14 16:56:47 -0700628
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800629 // clear the notification to prevent callbacks to dead client
630 // and reset the player. We assume the player will serialize
631 // access to itself if necessary.
632 if (p != 0) {
633 p->setNotifyCallback(0, 0);
634#if CALLBACK_ANTAGONIZER
Steve Blockb8a80522011-12-20 16:23:08 +0000635 ALOGD("kill Antagonizer");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800636 mAntagonizer->kill();
637#endif
638 p->reset();
639 }
640
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700641 disconnectNativeWindow();
642
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
718void MediaPlayerService::Client::clearDeathNotifiers() {
719 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);
Pawin Vongmasa9c47c972017-02-08 04:09:38 -0800733 clearDeathNotifiers();
John Grossmanc795b642012-02-22 15:38:35 -0800734
735 // create the right type of player
736 sp<MediaPlayerBase> p = createPlayer(playerType);
737 if (p == NULL) {
738 return p;
739 }
740
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700741 sp<IServiceManager> sm = defaultServiceManager();
742 sp<IBinder> binder = sm->getService(String16("media.extractor"));
Marco Nelissen1b5a7ee2016-09-30 13:54:30 -0700743 if (binder == NULL) {
744 ALOGE("extractor service not available");
745 return NULL;
746 }
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700747 mExtractorDeathListener = new ServiceDeathNotifier(binder, p, MEDIAEXTRACTOR_PROCESS_DEATH);
748 binder->linkToDeath(mExtractorDeathListener);
749
Pawin Vongmasad4e9ca42017-03-29 17:24:56 -0700750 if (property_get_bool("persist.media.treble_omx", true)) {
Pawin Vongmasa9c47c972017-02-08 04:09:38 -0800751 // Treble IOmx
752 sp<IOmx> omx = IOmx::getService();
753 if (omx == nullptr) {
754 ALOGE("Treble IOmx not available");
755 return NULL;
756 }
757 mCodecDeathListener = new ServiceDeathNotifier(omx, p, MEDIACODEC_PROCESS_DEATH);
758 omx->linkToDeath(mCodecDeathListener, 0);
759 } else {
760 // Legacy IOMX
761 binder = sm->getService(String16("media.codec"));
762 if (binder == NULL) {
763 ALOGE("codec service not available");
764 return NULL;
765 }
766 mCodecDeathListener = new ServiceDeathNotifier(binder, p, MEDIACODEC_PROCESS_DEATH);
767 binder->linkToDeath(mCodecDeathListener);
Marco Nelissen1b5a7ee2016-09-30 13:54:30 -0700768 }
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700769
John Grossmanc795b642012-02-22 15:38:35 -0800770 if (!p->hardwareOutput()) {
Jean-Michel Trivi2650e962015-07-22 18:14:02 -0700771 Mutex::Autolock l(mLock);
Marco Nelissend457c972014-02-11 08:47:07 -0800772 mAudioOutput = new AudioOutput(mAudioSessionId, IPCThreadState::self()->getCallingUid(),
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700773 mPid, mAudioAttributes);
John Grossmanc795b642012-02-22 15:38:35 -0800774 static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
775 }
776
777 return p;
778}
779
780void MediaPlayerService::Client::setDataSource_post(
781 const sp<MediaPlayerBase>& p,
782 status_t status)
783{
784 ALOGV(" setDataSource");
785 mStatus = status;
786 if (mStatus != OK) {
787 ALOGE(" error: %d", mStatus);
788 return;
789 }
790
791 // Set the re-transmission endpoint if one was chosen.
792 if (mRetransmitEndpointValid) {
793 mStatus = p->setRetransmitEndpoint(&mRetransmitEndpoint);
794 if (mStatus != NO_ERROR) {
795 ALOGE("setRetransmitEndpoint error: %d", mStatus);
796 }
797 }
798
799 if (mStatus == OK) {
Wei Jia502c2f42017-07-13 17:47:56 -0700800 Mutex::Autolock l(mLock);
John Grossmanc795b642012-02-22 15:38:35 -0800801 mPlayer = p;
802 }
803}
804
Andreas Huber2db84552010-01-28 11:19:57 -0800805status_t MediaPlayerService::Client::setDataSource(
Andreas Huber1b86fe02014-01-29 11:13:26 -0800806 const sp<IMediaHTTPService> &httpService,
807 const char *url,
808 const KeyedVector<String8, String8> *headers)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800809{
Steve Block3856b092011-10-20 11:56:00 +0100810 ALOGV("setDataSource(%s)", url);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800811 if (url == NULL)
812 return UNKNOWN_ERROR;
813
Dave Burked681bbb2011-08-30 14:39:17 +0100814 if ((strncmp(url, "http://", 7) == 0) ||
815 (strncmp(url, "https://", 8) == 0) ||
816 (strncmp(url, "rtsp://", 7) == 0)) {
817 if (!checkPermission("android.permission.INTERNET")) {
818 return PERMISSION_DENIED;
819 }
820 }
821
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800822 if (strncmp(url, "content://", 10) == 0) {
823 // get a filedescriptor for the content Uri and
824 // pass it to the setDataSource(fd) method
825
826 String16 url16(url);
827 int fd = android::openContentProviderFile(url16);
828 if (fd < 0)
829 {
Steve Block29357bc2012-01-06 19:20:56 +0000830 ALOGE("Couldn't open fd for %s", url);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800831 return UNKNOWN_ERROR;
832 }
833 setDataSource(fd, 0, 0x7fffffffffLL); // this sets mStatus
834 close(fd);
835 return mStatus;
836 } else {
John Grossman44a7e422012-06-21 17:29:24 -0700837 player_type playerType = MediaPlayerFactory::getPlayerType(this, url);
John Grossmanc795b642012-02-22 15:38:35 -0800838 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
839 if (p == NULL) {
840 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800841 }
842
Andreas Huber1b86fe02014-01-29 11:13:26 -0800843 setDataSource_post(p, p->setDataSource(httpService, url, headers));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800844 return mStatus;
845 }
846}
847
848status_t MediaPlayerService::Client::setDataSource(int fd, int64_t offset, int64_t length)
849{
Marco Nelissen83b0fd92015-09-16 13:48:07 -0700850 ALOGV("setDataSource fd=%d (%s), offset=%lld, length=%lld",
851 fd, nameForFd(fd).c_str(), (long long) offset, (long long) length);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800852 struct stat sb;
853 int ret = fstat(fd, &sb);
854 if (ret != 0) {
Steve Block29357bc2012-01-06 19:20:56 +0000855 ALOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800856 return UNKNOWN_ERROR;
857 }
858
Andy Hung833b4752016-04-04 17:15:48 -0700859 ALOGV("st_dev = %llu", static_cast<unsigned long long>(sb.st_dev));
Steve Block3856b092011-10-20 11:56:00 +0100860 ALOGV("st_mode = %u", sb.st_mode);
Mark Salyzyn77342f72014-06-18 16:31:32 -0700861 ALOGV("st_uid = %lu", static_cast<unsigned long>(sb.st_uid));
862 ALOGV("st_gid = %lu", static_cast<unsigned long>(sb.st_gid));
Andy Hung833b4752016-04-04 17:15:48 -0700863 ALOGV("st_size = %llu", static_cast<unsigned long long>(sb.st_size));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800864
865 if (offset >= sb.st_size) {
Steve Block29357bc2012-01-06 19:20:56 +0000866 ALOGE("offset error");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800867 return UNKNOWN_ERROR;
868 }
869 if (offset + length > sb.st_size) {
870 length = sb.st_size - offset;
Andy Hung833b4752016-04-04 17:15:48 -0700871 ALOGV("calculated length = %lld", (long long)length);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800872 }
873
John Grossman44a7e422012-06-21 17:29:24 -0700874 player_type playerType = MediaPlayerFactory::getPlayerType(this,
875 fd,
876 offset,
877 length);
John Grossmanc795b642012-02-22 15:38:35 -0800878 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
879 if (p == NULL) {
880 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800881 }
882
883 // now set data source
John Grossmanc795b642012-02-22 15:38:35 -0800884 setDataSource_post(p, p->setDataSource(fd, offset, length));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800885 return mStatus;
886}
887
Andreas Hubere2b10282010-11-23 11:41:34 -0800888status_t MediaPlayerService::Client::setDataSource(
889 const sp<IStreamSource> &source) {
890 // create the right type of player
John Grossman44a7e422012-06-21 17:29:24 -0700891 player_type playerType = MediaPlayerFactory::getPlayerType(this, source);
John Grossmanc795b642012-02-22 15:38:35 -0800892 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
Andreas Hubere2b10282010-11-23 11:41:34 -0800893 if (p == NULL) {
894 return NO_INIT;
895 }
896
Andreas Hubere2b10282010-11-23 11:41:34 -0800897 // now set data source
John Grossmanc795b642012-02-22 15:38:35 -0800898 setDataSource_post(p, p->setDataSource(source));
Andreas Hubere2b10282010-11-23 11:41:34 -0800899 return mStatus;
900}
901
Chris Watkins99f31602015-03-20 13:06:33 -0700902status_t MediaPlayerService::Client::setDataSource(
903 const sp<IDataSource> &source) {
904 sp<DataSource> dataSource = DataSource::CreateFromIDataSource(source);
905 player_type playerType = MediaPlayerFactory::getPlayerType(this, dataSource);
906 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
907 if (p == NULL) {
908 return NO_INIT;
909 }
910 // now set data source
911 setDataSource_post(p, p->setDataSource(dataSource));
912 return mStatus;
913}
914
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700915void MediaPlayerService::Client::disconnectNativeWindow() {
916 if (mConnectedWindow != NULL) {
Chong Zhang181fd9b2017-02-16 15:53:03 -0800917 status_t err = nativeWindowDisconnect(
918 mConnectedWindow.get(), "disconnectNativeWindow");
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700919
920 if (err != OK) {
Chong Zhang181fd9b2017-02-16 15:53:03 -0800921 ALOGW("nativeWindowDisconnect returned an error: %s (%d)",
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700922 strerror(-err), err);
923 }
924 }
925 mConnectedWindow.clear();
926}
927
Glenn Kasten11731182011-02-08 17:26:17 -0800928status_t MediaPlayerService::Client::setVideoSurfaceTexture(
Andy McFadden484566c2012-12-18 09:46:54 -0800929 const sp<IGraphicBufferProducer>& bufferProducer)
Glenn Kasten11731182011-02-08 17:26:17 -0800930{
Andy McFadden484566c2012-12-18 09:46:54 -0800931 ALOGV("[%d] setVideoSurfaceTexture(%p)", mConnId, bufferProducer.get());
Glenn Kasten11731182011-02-08 17:26:17 -0800932 sp<MediaPlayerBase> p = getPlayer();
933 if (p == 0) return UNKNOWN_ERROR;
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700934
Marco Nelissenf8880202014-11-14 07:58:25 -0800935 sp<IBinder> binder(IInterface::asBinder(bufferProducer));
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700936 if (mConnectedWindowBinder == binder) {
937 return OK;
938 }
939
940 sp<ANativeWindow> anw;
Andy McFadden484566c2012-12-18 09:46:54 -0800941 if (bufferProducer != NULL) {
Marco Nelissenee08f7e2013-09-16 13:30:01 -0700942 anw = new Surface(bufferProducer, true /* controlledByApp */);
Chong Zhang181fd9b2017-02-16 15:53:03 -0800943 status_t err = nativeWindowConnect(anw.get(), "setVideoSurfaceTexture");
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700944
945 if (err != OK) {
Steve Block29357bc2012-01-06 19:20:56 +0000946 ALOGE("setVideoSurfaceTexture failed: %d", err);
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700947 // Note that we must do the reset before disconnecting from the ANW.
948 // Otherwise queue/dequeue calls could be made on the disconnected
949 // ANW, which may result in errors.
950 reset();
951
952 disconnectNativeWindow();
953
954 return err;
955 }
956 }
957
Andy McFadden484566c2012-12-18 09:46:54 -0800958 // Note that we must set the player's new GraphicBufferProducer before
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700959 // disconnecting the old one. Otherwise queue/dequeue calls could be made
960 // on the disconnected ANW, which may result in errors.
Andy McFadden484566c2012-12-18 09:46:54 -0800961 status_t err = p->setVideoSurfaceTexture(bufferProducer);
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700962
963 disconnectNativeWindow();
964
965 mConnectedWindow = anw;
966
967 if (err == OK) {
968 mConnectedWindowBinder = binder;
969 } else {
970 disconnectNativeWindow();
971 }
972
973 return err;
Glenn Kasten11731182011-02-08 17:26:17 -0800974}
975
Nicolas Catania1d187f12009-05-12 23:25:55 -0700976status_t MediaPlayerService::Client::invoke(const Parcel& request,
977 Parcel *reply)
978{
979 sp<MediaPlayerBase> p = getPlayer();
980 if (p == NULL) return UNKNOWN_ERROR;
981 return p->invoke(request, reply);
982}
983
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700984// This call doesn't need to access the native player.
985status_t MediaPlayerService::Client::setMetadataFilter(const Parcel& filter)
986{
987 status_t status;
nikoa64c8c72009-07-20 15:07:26 -0700988 media::Metadata::Filter allow, drop;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700989
Nicolas Catania48290382009-07-10 13:53:06 -0700990 if (unmarshallFilter(filter, &allow, &status) &&
991 unmarshallFilter(filter, &drop, &status)) {
992 Mutex::Autolock lock(mLock);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700993
994 mMetadataAllow = allow;
995 mMetadataDrop = drop;
996 }
997 return status;
998}
999
Nicolas Catania48290382009-07-10 13:53:06 -07001000status_t MediaPlayerService::Client::getMetadata(
Mark Salyzyn77342f72014-06-18 16:31:32 -07001001 bool update_only, bool /*apply_filter*/, Parcel *reply)
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -07001002{
nikoa64c8c72009-07-20 15:07:26 -07001003 sp<MediaPlayerBase> player = getPlayer();
1004 if (player == 0) return UNKNOWN_ERROR;
Nicolas Catania48290382009-07-10 13:53:06 -07001005
nikod608a812009-07-16 16:39:53 -07001006 status_t status;
1007 // Placeholder for the return code, updated by the caller.
1008 reply->writeInt32(-1);
1009
nikoa64c8c72009-07-20 15:07:26 -07001010 media::Metadata::Filter ids;
Nicolas Catania48290382009-07-10 13:53:06 -07001011
1012 // We don't block notifications while we fetch the data. We clear
1013 // mMetadataUpdated first so we don't lose notifications happening
1014 // during the rest of this call.
1015 {
1016 Mutex::Autolock lock(mLock);
1017 if (update_only) {
nikod608a812009-07-16 16:39:53 -07001018 ids = mMetadataUpdated;
Nicolas Catania48290382009-07-10 13:53:06 -07001019 }
1020 mMetadataUpdated.clear();
1021 }
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -07001022
nikoa64c8c72009-07-20 15:07:26 -07001023 media::Metadata metadata(reply);
Nicolas Catania48290382009-07-10 13:53:06 -07001024
nikoa64c8c72009-07-20 15:07:26 -07001025 metadata.appendHeader();
1026 status = player->getMetadata(ids, reply);
nikod608a812009-07-16 16:39:53 -07001027
1028 if (status != OK) {
nikoa64c8c72009-07-20 15:07:26 -07001029 metadata.resetParcel();
Steve Block29357bc2012-01-06 19:20:56 +00001030 ALOGE("getMetadata failed %d", status);
nikod608a812009-07-16 16:39:53 -07001031 return status;
1032 }
1033
1034 // FIXME: Implement filtering on the result. Not critical since
1035 // filtering takes place on the update notifications already. This
1036 // would be when all the metadata are fetch and a filter is set.
1037
nikod608a812009-07-16 16:39:53 -07001038 // Everything is fine, update the metadata length.
nikoa64c8c72009-07-20 15:07:26 -07001039 metadata.updateLength();
nikod608a812009-07-16 16:39:53 -07001040 return OK;
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -07001041}
1042
Wei Jiad399e7e2016-10-26 15:49:11 -07001043status_t MediaPlayerService::Client::setBufferingSettings(
1044 const BufferingSettings& buffering)
1045{
Wei Jiadc6f3402017-01-09 15:04:18 -08001046 ALOGV("[%d] setBufferingSettings{%s}",
1047 mConnId, buffering.toString().string());
Wei Jiad399e7e2016-10-26 15:49:11 -07001048 sp<MediaPlayerBase> p = getPlayer();
1049 if (p == 0) return UNKNOWN_ERROR;
1050 return p->setBufferingSettings(buffering);
1051}
1052
1053status_t MediaPlayerService::Client::getDefaultBufferingSettings(
1054 BufferingSettings* buffering /* nonnull */)
1055{
1056 sp<MediaPlayerBase> p = getPlayer();
1057 // TODO: create mPlayer on demand.
1058 if (p == 0) return UNKNOWN_ERROR;
1059 status_t ret = p->getDefaultBufferingSettings(buffering);
1060 if (ret == NO_ERROR) {
Wei Jiadc6f3402017-01-09 15:04:18 -08001061 ALOGV("[%d] getDefaultBufferingSettings{%s}",
1062 mConnId, buffering->toString().string());
Wei Jiad399e7e2016-10-26 15:49:11 -07001063 } else {
1064 ALOGV("[%d] getDefaultBufferingSettings returned %d", mConnId, ret);
1065 }
1066 return ret;
1067}
1068
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001069status_t MediaPlayerService::Client::prepareAsync()
1070{
Steve Block3856b092011-10-20 11:56:00 +01001071 ALOGV("[%d] prepareAsync", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001072 sp<MediaPlayerBase> p = getPlayer();
1073 if (p == 0) return UNKNOWN_ERROR;
1074 status_t ret = p->prepareAsync();
1075#if CALLBACK_ANTAGONIZER
Steve Blockb8a80522011-12-20 16:23:08 +00001076 ALOGD("start Antagonizer");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001077 if (ret == NO_ERROR) mAntagonizer->start();
1078#endif
1079 return ret;
1080}
1081
1082status_t MediaPlayerService::Client::start()
1083{
Steve Block3856b092011-10-20 11:56:00 +01001084 ALOGV("[%d] start", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001085 sp<MediaPlayerBase> p = getPlayer();
1086 if (p == 0) return UNKNOWN_ERROR;
1087 p->setLooping(mLoop);
1088 return p->start();
1089}
1090
1091status_t MediaPlayerService::Client::stop()
1092{
Steve Block3856b092011-10-20 11:56:00 +01001093 ALOGV("[%d] stop", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001094 sp<MediaPlayerBase> p = getPlayer();
1095 if (p == 0) return UNKNOWN_ERROR;
1096 return p->stop();
1097}
1098
1099status_t MediaPlayerService::Client::pause()
1100{
Steve Block3856b092011-10-20 11:56:00 +01001101 ALOGV("[%d] pause", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001102 sp<MediaPlayerBase> p = getPlayer();
1103 if (p == 0) return UNKNOWN_ERROR;
1104 return p->pause();
1105}
1106
1107status_t MediaPlayerService::Client::isPlaying(bool* state)
1108{
1109 *state = false;
1110 sp<MediaPlayerBase> p = getPlayer();
1111 if (p == 0) return UNKNOWN_ERROR;
1112 *state = p->isPlaying();
Steve Block3856b092011-10-20 11:56:00 +01001113 ALOGV("[%d] isPlaying: %d", mConnId, *state);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001114 return NO_ERROR;
1115}
1116
Lajos Molnar3a474aa2015-04-24 17:10:07 -07001117status_t MediaPlayerService::Client::setPlaybackSettings(const AudioPlaybackRate& rate)
Wei Jia98160162015-02-04 17:01:11 -08001118{
Lajos Molnar3a474aa2015-04-24 17:10:07 -07001119 ALOGV("[%d] setPlaybackSettings(%f, %f, %d, %d)",
1120 mConnId, rate.mSpeed, rate.mPitch, rate.mFallbackMode, rate.mStretchMode);
Wei Jia98160162015-02-04 17:01:11 -08001121 sp<MediaPlayerBase> p = getPlayer();
1122 if (p == 0) return UNKNOWN_ERROR;
Lajos Molnar3a474aa2015-04-24 17:10:07 -07001123 return p->setPlaybackSettings(rate);
1124}
1125
1126status_t MediaPlayerService::Client::getPlaybackSettings(AudioPlaybackRate* rate /* nonnull */)
1127{
1128 sp<MediaPlayerBase> p = getPlayer();
1129 if (p == 0) return UNKNOWN_ERROR;
1130 status_t ret = p->getPlaybackSettings(rate);
1131 if (ret == NO_ERROR) {
1132 ALOGV("[%d] getPlaybackSettings(%f, %f, %d, %d)",
1133 mConnId, rate->mSpeed, rate->mPitch, rate->mFallbackMode, rate->mStretchMode);
1134 } else {
1135 ALOGV("[%d] getPlaybackSettings returned %d", mConnId, ret);
1136 }
1137 return ret;
1138}
1139
1140status_t MediaPlayerService::Client::setSyncSettings(
1141 const AVSyncSettings& sync, float videoFpsHint)
1142{
1143 ALOGV("[%d] setSyncSettings(%u, %u, %f, %f)",
1144 mConnId, sync.mSource, sync.mAudioAdjustMode, sync.mTolerance, videoFpsHint);
1145 sp<MediaPlayerBase> p = getPlayer();
1146 if (p == 0) return UNKNOWN_ERROR;
1147 return p->setSyncSettings(sync, videoFpsHint);
1148}
1149
1150status_t MediaPlayerService::Client::getSyncSettings(
1151 AVSyncSettings* sync /* nonnull */, float* videoFps /* nonnull */)
1152{
1153 sp<MediaPlayerBase> p = getPlayer();
1154 if (p == 0) return UNKNOWN_ERROR;
1155 status_t ret = p->getSyncSettings(sync, videoFps);
1156 if (ret == NO_ERROR) {
1157 ALOGV("[%d] getSyncSettings(%u, %u, %f, %f)",
1158 mConnId, sync->mSource, sync->mAudioAdjustMode, sync->mTolerance, *videoFps);
1159 } else {
1160 ALOGV("[%d] getSyncSettings returned %d", mConnId, ret);
1161 }
1162 return ret;
Wei Jia98160162015-02-04 17:01:11 -08001163}
1164
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001165status_t MediaPlayerService::Client::getCurrentPosition(int *msec)
1166{
Steve Block3856b092011-10-20 11:56:00 +01001167 ALOGV("getCurrentPosition");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001168 sp<MediaPlayerBase> p = getPlayer();
1169 if (p == 0) return UNKNOWN_ERROR;
1170 status_t ret = p->getCurrentPosition(msec);
1171 if (ret == NO_ERROR) {
Steve Block3856b092011-10-20 11:56:00 +01001172 ALOGV("[%d] getCurrentPosition = %d", mConnId, *msec);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001173 } else {
Steve Block29357bc2012-01-06 19:20:56 +00001174 ALOGE("getCurrentPosition returned %d", ret);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001175 }
1176 return ret;
1177}
1178
1179status_t MediaPlayerService::Client::getDuration(int *msec)
1180{
Steve Block3856b092011-10-20 11:56:00 +01001181 ALOGV("getDuration");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001182 sp<MediaPlayerBase> p = getPlayer();
1183 if (p == 0) return UNKNOWN_ERROR;
1184 status_t ret = p->getDuration(msec);
1185 if (ret == NO_ERROR) {
Steve Block3856b092011-10-20 11:56:00 +01001186 ALOGV("[%d] getDuration = %d", mConnId, *msec);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001187 } else {
Steve Block29357bc2012-01-06 19:20:56 +00001188 ALOGE("getDuration returned %d", ret);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001189 }
1190 return ret;
1191}
1192
Marco Nelissen6b74d672012-02-28 16:07:44 -08001193status_t MediaPlayerService::Client::setNextPlayer(const sp<IMediaPlayer>& player) {
1194 ALOGV("setNextPlayer");
1195 Mutex::Autolock l(mLock);
1196 sp<Client> c = static_cast<Client*>(player.get());
Wei Jia28284122016-08-30 13:49:06 -07001197 if (c != NULL && !mService->hasClient(c)) {
Robert Shihee0a0e32016-08-16 16:50:54 -07001198 return BAD_VALUE;
1199 }
1200
Marco Nelissen6b74d672012-02-28 16:07:44 -08001201 mNextClient = c;
John Grossman5f7e55e2012-08-24 14:47:25 -07001202
1203 if (c != NULL) {
1204 if (mAudioOutput != NULL) {
1205 mAudioOutput->setNextOutput(c->mAudioOutput);
1206 } else if ((mPlayer != NULL) && !mPlayer->hardwareOutput()) {
1207 ALOGE("no current audio output");
1208 }
1209
1210 if ((mPlayer != NULL) && (mNextClient->getPlayer() != NULL)) {
1211 mPlayer->setNextPlayer(mNextClient->getPlayer());
1212 }
Marco Nelissen6b74d672012-02-28 16:07:44 -08001213 }
John Grossman5f7e55e2012-08-24 14:47:25 -07001214
Marco Nelissen6b74d672012-02-28 16:07:44 -08001215 return OK;
1216}
1217
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001218VolumeShaper::Status MediaPlayerService::Client::applyVolumeShaper(
1219 const sp<VolumeShaper::Configuration>& configuration,
1220 const sp<VolumeShaper::Operation>& operation) {
1221 // for hardware output, call player instead
1222 ALOGV("Client::applyVolumeShaper(%p)", this);
1223 sp<MediaPlayerBase> p = getPlayer();
1224 {
1225 Mutex::Autolock l(mLock);
1226 if (p != 0 && p->hardwareOutput()) {
1227 // TODO: investigate internal implementation
1228 return VolumeShaper::Status(INVALID_OPERATION);
1229 }
1230 if (mAudioOutput.get() != nullptr) {
1231 return mAudioOutput->applyVolumeShaper(configuration, operation);
1232 }
1233 }
1234 return VolumeShaper::Status(INVALID_OPERATION);
1235}
1236
1237sp<VolumeShaper::State> MediaPlayerService::Client::getVolumeShaperState(int id) {
1238 // for hardware output, call player instead
1239 ALOGV("Client::getVolumeShaperState(%p)", this);
1240 sp<MediaPlayerBase> p = getPlayer();
1241 {
1242 Mutex::Autolock l(mLock);
1243 if (p != 0 && p->hardwareOutput()) {
1244 // TODO: investigate internal implementation.
1245 return nullptr;
1246 }
1247 if (mAudioOutput.get() != nullptr) {
1248 return mAudioOutput->getVolumeShaperState(id);
1249 }
1250 }
1251 return nullptr;
1252}
1253
Wei Jiac5de0912016-11-18 10:22:14 -08001254status_t MediaPlayerService::Client::seekTo(int msec, MediaPlayerSeekMode mode)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001255{
Wei Jiac5de0912016-11-18 10:22:14 -08001256 ALOGV("[%d] seekTo(%d, %d)", mConnId, msec, mode);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001257 sp<MediaPlayerBase> p = getPlayer();
1258 if (p == 0) return UNKNOWN_ERROR;
Wei Jiac5de0912016-11-18 10:22:14 -08001259 return p->seekTo(msec, mode);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001260}
1261
1262status_t MediaPlayerService::Client::reset()
1263{
Steve Block3856b092011-10-20 11:56:00 +01001264 ALOGV("[%d] reset", mConnId);
John Grossmanc795b642012-02-22 15:38:35 -08001265 mRetransmitEndpointValid = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001266 sp<MediaPlayerBase> p = getPlayer();
1267 if (p == 0) return UNKNOWN_ERROR;
1268 return p->reset();
1269}
1270
Glenn Kastenfff6d712012-01-12 16:38:12 -08001271status_t MediaPlayerService::Client::setAudioStreamType(audio_stream_type_t type)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001272{
Steve Block3856b092011-10-20 11:56:00 +01001273 ALOGV("[%d] setAudioStreamType(%d)", mConnId, type);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001274 // TODO: for hardware output, call player instead
1275 Mutex::Autolock l(mLock);
1276 if (mAudioOutput != 0) mAudioOutput->setAudioStreamType(type);
1277 return NO_ERROR;
1278}
1279
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001280status_t MediaPlayerService::Client::setAudioAttributes_l(const Parcel &parcel)
1281{
1282 if (mAudioAttributes != NULL) { free(mAudioAttributes); }
1283 mAudioAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t));
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001284 if (mAudioAttributes == NULL) {
1285 return NO_MEMORY;
1286 }
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001287 unmarshallAudioAttributes(parcel, mAudioAttributes);
1288
1289 ALOGV("setAudioAttributes_l() usage=%d content=%d flags=0x%x tags=%s",
1290 mAudioAttributes->usage, mAudioAttributes->content_type, mAudioAttributes->flags,
1291 mAudioAttributes->tags);
1292
1293 if (mAudioOutput != 0) {
1294 mAudioOutput->setAudioAttributes(mAudioAttributes);
1295 }
1296 return NO_ERROR;
1297}
1298
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001299status_t MediaPlayerService::Client::setLooping(int loop)
1300{
Steve Block3856b092011-10-20 11:56:00 +01001301 ALOGV("[%d] setLooping(%d)", mConnId, loop);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001302 mLoop = loop;
1303 sp<MediaPlayerBase> p = getPlayer();
1304 if (p != 0) return p->setLooping(loop);
1305 return NO_ERROR;
1306}
1307
1308status_t MediaPlayerService::Client::setVolume(float leftVolume, float rightVolume)
1309{
Steve Block3856b092011-10-20 11:56:00 +01001310 ALOGV("[%d] setVolume(%f, %f)", mConnId, leftVolume, rightVolume);
John Grossman761defc2012-02-09 15:09:05 -08001311
1312 // for hardware output, call player instead
1313 sp<MediaPlayerBase> p = getPlayer();
1314 {
1315 Mutex::Autolock l(mLock);
1316 if (p != 0 && p->hardwareOutput()) {
1317 MediaPlayerHWInterface* hwp =
1318 reinterpret_cast<MediaPlayerHWInterface*>(p.get());
1319 return hwp->setVolume(leftVolume, rightVolume);
1320 } else {
1321 if (mAudioOutput != 0) mAudioOutput->setVolume(leftVolume, rightVolume);
1322 return NO_ERROR;
1323 }
1324 }
1325
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001326 return NO_ERROR;
1327}
1328
Eric Laurent2beeb502010-07-16 07:43:46 -07001329status_t MediaPlayerService::Client::setAuxEffectSendLevel(float level)
1330{
Steve Block3856b092011-10-20 11:56:00 +01001331 ALOGV("[%d] setAuxEffectSendLevel(%f)", mConnId, level);
Eric Laurent2beeb502010-07-16 07:43:46 -07001332 Mutex::Autolock l(mLock);
1333 if (mAudioOutput != 0) return mAudioOutput->setAuxEffectSendLevel(level);
1334 return NO_ERROR;
1335}
1336
1337status_t MediaPlayerService::Client::attachAuxEffect(int effectId)
1338{
Steve Block3856b092011-10-20 11:56:00 +01001339 ALOGV("[%d] attachAuxEffect(%d)", mConnId, effectId);
Eric Laurent2beeb502010-07-16 07:43:46 -07001340 Mutex::Autolock l(mLock);
1341 if (mAudioOutput != 0) return mAudioOutput->attachAuxEffect(effectId);
1342 return NO_ERROR;
1343}
Nicolas Catania48290382009-07-10 13:53:06 -07001344
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001345status_t MediaPlayerService::Client::setParameter(int key, const Parcel &request) {
Steve Block3856b092011-10-20 11:56:00 +01001346 ALOGV("[%d] setParameter(%d)", mConnId, key);
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001347 switch (key) {
1348 case KEY_PARAMETER_AUDIO_ATTRIBUTES:
1349 {
1350 Mutex::Autolock l(mLock);
1351 return setAudioAttributes_l(request);
1352 }
1353 default:
1354 sp<MediaPlayerBase> p = getPlayer();
1355 if (p == 0) { return UNKNOWN_ERROR; }
1356 return p->setParameter(key, request);
1357 }
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001358}
1359
1360status_t MediaPlayerService::Client::getParameter(int key, Parcel *reply) {
Steve Block3856b092011-10-20 11:56:00 +01001361 ALOGV("[%d] getParameter(%d)", mConnId, key);
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001362 sp<MediaPlayerBase> p = getPlayer();
1363 if (p == 0) return UNKNOWN_ERROR;
1364 return p->getParameter(key, reply);
1365}
1366
John Grossmanc795b642012-02-22 15:38:35 -08001367status_t MediaPlayerService::Client::setRetransmitEndpoint(
1368 const struct sockaddr_in* endpoint) {
1369
1370 if (NULL != endpoint) {
1371 uint32_t a = ntohl(endpoint->sin_addr.s_addr);
1372 uint16_t p = ntohs(endpoint->sin_port);
1373 ALOGV("[%d] setRetransmitEndpoint(%u.%u.%u.%u:%hu)", mConnId,
1374 (a >> 24), (a >> 16) & 0xFF, (a >> 8) & 0xFF, (a & 0xFF), p);
1375 } else {
1376 ALOGV("[%d] setRetransmitEndpoint = <none>", mConnId);
1377 }
1378
1379 sp<MediaPlayerBase> p = getPlayer();
1380
1381 // Right now, the only valid time to set a retransmit endpoint is before
1382 // player selection has been made (since the presence or absence of a
1383 // retransmit endpoint is going to determine which player is selected during
1384 // setDataSource).
1385 if (p != 0) return INVALID_OPERATION;
1386
1387 if (NULL != endpoint) {
1388 mRetransmitEndpoint = *endpoint;
1389 mRetransmitEndpointValid = true;
1390 } else {
1391 mRetransmitEndpointValid = false;
1392 }
1393
1394 return NO_ERROR;
1395}
1396
John Grossman44a7e422012-06-21 17:29:24 -07001397status_t MediaPlayerService::Client::getRetransmitEndpoint(
1398 struct sockaddr_in* endpoint)
1399{
1400 if (NULL == endpoint)
1401 return BAD_VALUE;
1402
1403 sp<MediaPlayerBase> p = getPlayer();
1404
1405 if (p != NULL)
1406 return p->getRetransmitEndpoint(endpoint);
1407
1408 if (!mRetransmitEndpointValid)
1409 return NO_INIT;
1410
1411 *endpoint = mRetransmitEndpoint;
1412
1413 return NO_ERROR;
1414}
1415
Gloria Wangb483c472011-04-11 17:23:27 -07001416void MediaPlayerService::Client::notify(
1417 void* cookie, int msg, int ext1, int ext2, const Parcel *obj)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001418{
1419 Client* client = static_cast<Client*>(cookie);
James Dongb8a98252012-08-26 16:13:03 -07001420 if (client == NULL) {
1421 return;
1422 }
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001423
James Dongb8a98252012-08-26 16:13:03 -07001424 sp<IMediaPlayerClient> c;
Haynes Mathew George6cb33752015-06-22 14:16:42 -07001425 sp<Client> nextClient;
1426 status_t errStartNext = NO_ERROR;
Marco Nelissen6b74d672012-02-28 16:07:44 -08001427 {
1428 Mutex::Autolock l(client->mLock);
James Dongb8a98252012-08-26 16:13:03 -07001429 c = client->mClient;
Marco Nelissen6b74d672012-02-28 16:07:44 -08001430 if (msg == MEDIA_PLAYBACK_COMPLETE && client->mNextClient != NULL) {
Haynes Mathew George6cb33752015-06-22 14:16:42 -07001431 nextClient = client->mNextClient;
1432
John Grossmancb0b7552012-08-23 17:47:31 -07001433 if (client->mAudioOutput != NULL)
1434 client->mAudioOutput->switchToNextOutput();
Haynes Mathew George6cb33752015-06-22 14:16:42 -07001435
1436 errStartNext = nextClient->start();
1437 }
1438 }
1439
1440 if (nextClient != NULL) {
1441 sp<IMediaPlayerClient> nc;
1442 {
1443 Mutex::Autolock l(nextClient->mLock);
1444 nc = nextClient->mClient;
1445 }
1446 if (nc != NULL) {
1447 if (errStartNext == NO_ERROR) {
1448 nc->notify(MEDIA_INFO, MEDIA_INFO_STARTED_AS_NEXT, 0, obj);
1449 } else {
1450 nc->notify(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN , 0, obj);
1451 ALOGE("gapless:start playback for next track failed, err(%d)", errStartNext);
Wei Jia2afac0c2016-01-07 12:13:07 -08001452 }
Marco Nelissen6b74d672012-02-28 16:07:44 -08001453 }
1454 }
1455
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001456 if (MEDIA_INFO == msg &&
Nicolas Catania48290382009-07-10 13:53:06 -07001457 MEDIA_INFO_METADATA_UPDATE == ext1) {
nikoa64c8c72009-07-20 15:07:26 -07001458 const media::Metadata::Type metadata_type = ext2;
Nicolas Catania48290382009-07-10 13:53:06 -07001459
1460 if(client->shouldDropMetadata(metadata_type)) {
1461 return;
1462 }
1463
1464 // Update the list of metadata that have changed. getMetadata
1465 // also access mMetadataUpdated and clears it.
1466 client->addNewMetadataUpdate(metadata_type);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001467 }
James Dongb8a98252012-08-26 16:13:03 -07001468
1469 if (c != NULL) {
1470 ALOGV("[%d] notify (%p, %d, %d, %d)", client->mConnId, cookie, msg, ext1, ext2);
1471 c->notify(msg, ext1, ext2, obj);
1472 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001473}
1474
Nicolas Catania48290382009-07-10 13:53:06 -07001475
nikoa64c8c72009-07-20 15:07:26 -07001476bool MediaPlayerService::Client::shouldDropMetadata(media::Metadata::Type code) const
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001477{
Nicolas Catania48290382009-07-10 13:53:06 -07001478 Mutex::Autolock lock(mLock);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001479
Nicolas Catania48290382009-07-10 13:53:06 -07001480 if (findMetadata(mMetadataDrop, code)) {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001481 return true;
1482 }
1483
Nicolas Catania48290382009-07-10 13:53:06 -07001484 if (mMetadataAllow.isEmpty() || findMetadata(mMetadataAllow, code)) {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001485 return false;
Nicolas Catania48290382009-07-10 13:53:06 -07001486 } else {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001487 return true;
1488 }
1489}
1490
Nicolas Catania48290382009-07-10 13:53:06 -07001491
nikoa64c8c72009-07-20 15:07:26 -07001492void MediaPlayerService::Client::addNewMetadataUpdate(media::Metadata::Type metadata_type) {
Nicolas Catania48290382009-07-10 13:53:06 -07001493 Mutex::Autolock lock(mLock);
1494 if (mMetadataUpdated.indexOf(metadata_type) < 0) {
1495 mMetadataUpdated.add(metadata_type);
1496 }
1497}
1498
Hassan Shojaniacefac142017-02-06 21:02:02 -08001499// Modular DRM
1500status_t MediaPlayerService::Client::prepareDrm(const uint8_t uuid[16],
1501 const Vector<uint8_t>& drmSessionId)
1502{
1503 ALOGV("[%d] prepareDrm", mConnId);
1504 sp<MediaPlayerBase> p = getPlayer();
1505 if (p == 0) return UNKNOWN_ERROR;
1506
1507 status_t ret = p->prepareDrm(uuid, drmSessionId);
1508 ALOGV("prepareDrm ret: %d", ret);
1509
1510 return ret;
1511}
1512
1513status_t MediaPlayerService::Client::releaseDrm()
1514{
1515 ALOGV("[%d] releaseDrm", mConnId);
1516 sp<MediaPlayerBase> p = getPlayer();
1517 if (p == 0) return UNKNOWN_ERROR;
1518
1519 status_t ret = p->releaseDrm();
1520 ALOGV("releaseDrm ret: %d", ret);
1521
1522 return ret;
1523}
1524
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001525#if CALLBACK_ANTAGONIZER
1526const int Antagonizer::interval = 10000; // 10 msecs
1527
1528Antagonizer::Antagonizer(notify_callback_f cb, void* client) :
1529 mExit(false), mActive(false), mClient(client), mCb(cb)
1530{
1531 createThread(callbackThread, this);
1532}
1533
1534void Antagonizer::kill()
1535{
1536 Mutex::Autolock _l(mLock);
1537 mActive = false;
1538 mExit = true;
1539 mCondition.wait(mLock);
1540}
1541
1542int Antagonizer::callbackThread(void* user)
1543{
Steve Blockb8a80522011-12-20 16:23:08 +00001544 ALOGD("Antagonizer started");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001545 Antagonizer* p = reinterpret_cast<Antagonizer*>(user);
1546 while (!p->mExit) {
1547 if (p->mActive) {
Steve Block3856b092011-10-20 11:56:00 +01001548 ALOGV("send event");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001549 p->mCb(p->mClient, 0, 0, 0);
1550 }
1551 usleep(interval);
1552 }
1553 Mutex::Autolock _l(p->mLock);
1554 p->mCondition.signal();
Steve Blockb8a80522011-12-20 16:23:08 +00001555 ALOGD("Antagonizer stopped");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001556 return 0;
1557}
1558#endif
1559
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001560#undef LOG_TAG
1561#define LOG_TAG "AudioSink"
Andy Hung1afd0982016-11-08 16:13:44 -08001562MediaPlayerService::AudioOutput::AudioOutput(audio_session_t sessionId, uid_t uid, int pid,
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001563 const audio_attributes_t* attr)
Andreas Huber20111aa2009-07-14 16:56:47 -07001564 : mCallback(NULL),
Eric Laurenta514bdb2010-06-21 09:27:30 -07001565 mCallbackCookie(NULL),
Marco Nelissen6b74d672012-02-28 16:07:44 -08001566 mCallbackData(NULL),
Andy Hungd1c74342015-07-07 16:54:23 -07001567 mStreamType(AUDIO_STREAM_MUSIC),
Andy Hungd1c74342015-07-07 16:54:23 -07001568 mLeftVolume(1.0),
1569 mRightVolume(1.0),
1570 mPlaybackRate(AUDIO_PLAYBACK_RATE_DEFAULT),
1571 mSampleRateHz(0),
1572 mMsecsPerFrame(0),
1573 mFrameSize(0),
Eric Laurent1948eb32012-04-13 16:50:19 -07001574 mSessionId(sessionId),
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001575 mUid(uid),
Marco Nelissend457c972014-02-11 08:47:07 -08001576 mPid(pid),
Andy Hungd1c74342015-07-07 16:54:23 -07001577 mSendLevel(0.0),
1578 mAuxEffectId(0),
Andy Hung4ef88d72017-02-21 19:47:53 -08001579 mFlags(AUDIO_OUTPUT_FLAG_NONE),
1580 mVolumeHandler(new VolumeHandler())
Andy Hungd1c74342015-07-07 16:54:23 -07001581{
Steve Block3856b092011-10-20 11:56:00 +01001582 ALOGV("AudioOutput(%d)", sessionId);
Eric Laurent43562692015-07-15 16:49:07 -07001583 if (attr != NULL) {
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001584 mAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t));
1585 if (mAttributes != NULL) {
1586 memcpy(mAttributes, attr, sizeof(audio_attributes_t));
1587 mStreamType = audio_attributes_to_stream_type(attr);
1588 }
1589 } else {
1590 mAttributes = NULL;
Eric Laurent43562692015-07-15 16:49:07 -07001591 }
1592
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001593 setMinBufferCount();
1594}
1595
1596MediaPlayerService::AudioOutput::~AudioOutput()
1597{
1598 close();
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001599 free(mAttributes);
Marco Nelissen6b74d672012-02-28 16:07:44 -08001600 delete mCallbackData;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001601}
1602
Andy Hungd1c74342015-07-07 16:54:23 -07001603//static
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001604void MediaPlayerService::AudioOutput::setMinBufferCount()
1605{
1606 char value[PROPERTY_VALUE_MAX];
1607 if (property_get("ro.kernel.qemu", value, 0)) {
1608 mIsOnEmulator = true;
1609 mMinBufferCount = 12; // to prevent systematic buffer underrun for emulator
1610 }
1611}
1612
Andy Hungd1c74342015-07-07 16:54:23 -07001613// static
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001614bool MediaPlayerService::AudioOutput::isOnEmulator()
1615{
Andy Hungd1c74342015-07-07 16:54:23 -07001616 setMinBufferCount(); // benign race wrt other threads
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001617 return mIsOnEmulator;
1618}
1619
Andy Hungd1c74342015-07-07 16:54:23 -07001620// static
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001621int MediaPlayerService::AudioOutput::getMinBufferCount()
1622{
Andy Hungd1c74342015-07-07 16:54:23 -07001623 setMinBufferCount(); // benign race wrt other threads
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001624 return mMinBufferCount;
1625}
1626
1627ssize_t MediaPlayerService::AudioOutput::bufferSize() const
1628{
Andy Hungd1c74342015-07-07 16:54:23 -07001629 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001630 if (mTrack == 0) return NO_INIT;
Andy Hungd1c74342015-07-07 16:54:23 -07001631 return mTrack->frameCount() * mFrameSize;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001632}
1633
1634ssize_t MediaPlayerService::AudioOutput::frameCount() const
1635{
Andy Hungd1c74342015-07-07 16:54:23 -07001636 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001637 if (mTrack == 0) return NO_INIT;
1638 return mTrack->frameCount();
1639}
1640
1641ssize_t MediaPlayerService::AudioOutput::channelCount() const
1642{
Andy Hungd1c74342015-07-07 16:54:23 -07001643 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001644 if (mTrack == 0) return NO_INIT;
1645 return mTrack->channelCount();
1646}
1647
1648ssize_t MediaPlayerService::AudioOutput::frameSize() const
1649{
Andy Hungd1c74342015-07-07 16:54:23 -07001650 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001651 if (mTrack == 0) return NO_INIT;
Andy Hungd1c74342015-07-07 16:54:23 -07001652 return mFrameSize;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001653}
1654
1655uint32_t MediaPlayerService::AudioOutput::latency () const
1656{
Andy Hungd1c74342015-07-07 16:54:23 -07001657 Mutex::Autolock lock(mLock);
Eric Laurentdb354e52012-03-05 17:27:11 -08001658 if (mTrack == 0) return 0;
1659 return mTrack->latency();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001660}
1661
1662float MediaPlayerService::AudioOutput::msecsPerFrame() const
1663{
Andy Hungd1c74342015-07-07 16:54:23 -07001664 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001665 return mMsecsPerFrame;
1666}
1667
Marco Nelissen4110c102012-03-29 09:31:28 -07001668status_t MediaPlayerService::AudioOutput::getPosition(uint32_t *position) const
Eric Laurent342e9cf2010-01-19 17:37:09 -08001669{
Andy Hungd1c74342015-07-07 16:54:23 -07001670 Mutex::Autolock lock(mLock);
Eric Laurent342e9cf2010-01-19 17:37:09 -08001671 if (mTrack == 0) return NO_INIT;
1672 return mTrack->getPosition(position);
1673}
1674
Lajos Molnar06ad1522014-08-28 07:27:44 -07001675status_t MediaPlayerService::AudioOutput::getTimestamp(AudioTimestamp &ts) const
1676{
Andy Hungd1c74342015-07-07 16:54:23 -07001677 Mutex::Autolock lock(mLock);
Lajos Molnar06ad1522014-08-28 07:27:44 -07001678 if (mTrack == 0) return NO_INIT;
1679 return mTrack->getTimestamp(ts);
1680}
1681
Wei Jiac4ac8172015-10-21 10:35:48 -07001682// TODO: Remove unnecessary calls to getPlayedOutDurationUs()
1683// as it acquires locks and may query the audio driver.
1684//
1685// Some calls could conceivably retrieve extrapolated data instead of
1686// accessing getTimestamp() or getPosition() every time a data buffer with
1687// a media time is received.
1688//
1689// Calculate duration of played samples if played at normal rate (i.e., 1.0).
1690int64_t MediaPlayerService::AudioOutput::getPlayedOutDurationUs(int64_t nowUs) const
1691{
1692 Mutex::Autolock lock(mLock);
1693 if (mTrack == 0 || mSampleRateHz == 0) {
Wei Jia213f4902015-10-22 08:55:25 -07001694 return 0;
Wei Jiac4ac8172015-10-21 10:35:48 -07001695 }
1696
1697 uint32_t numFramesPlayed;
Andy Hung5d313802016-10-10 15:09:39 -07001698 int64_t numFramesPlayedAtUs;
Wei Jiac4ac8172015-10-21 10:35:48 -07001699 AudioTimestamp ts;
Wei Jiac4ac8172015-10-21 10:35:48 -07001700
1701 status_t res = mTrack->getTimestamp(ts);
1702 if (res == OK) { // case 1: mixing audio tracks and offloaded tracks.
1703 numFramesPlayed = ts.mPosition;
Andy Hung5d313802016-10-10 15:09:39 -07001704 numFramesPlayedAtUs = ts.mTime.tv_sec * 1000000LL + ts.mTime.tv_nsec / 1000;
1705 //ALOGD("getTimestamp: OK %d %lld", numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001706 } else if (res == WOULD_BLOCK) { // case 2: transitory state on start of a new track
1707 numFramesPlayed = 0;
Andy Hung5d313802016-10-10 15:09:39 -07001708 numFramesPlayedAtUs = nowUs;
Wei Jiac4ac8172015-10-21 10:35:48 -07001709 //ALOGD("getTimestamp: WOULD_BLOCK %d %lld",
Andy Hung5d313802016-10-10 15:09:39 -07001710 // numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001711 } else { // case 3: transitory at new track or audio fast tracks.
1712 res = mTrack->getPosition(&numFramesPlayed);
1713 CHECK_EQ(res, (status_t)OK);
Andy Hung5d313802016-10-10 15:09:39 -07001714 numFramesPlayedAtUs = nowUs;
1715 numFramesPlayedAtUs += 1000LL * mTrack->latency() / 2; /* XXX */
1716 //ALOGD("getPosition: %u %lld", numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001717 }
1718
1719 // CHECK_EQ(numFramesPlayed & (1 << 31), 0); // can't be negative until 12.4 hrs, test
1720 // TODO: remove the (int32_t) casting below as it may overflow at 12.4 hours.
1721 int64_t durationUs = (int64_t)((int32_t)numFramesPlayed * 1000000LL / mSampleRateHz)
Andy Hung5d313802016-10-10 15:09:39 -07001722 + nowUs - numFramesPlayedAtUs;
Wei Jiac4ac8172015-10-21 10:35:48 -07001723 if (durationUs < 0) {
1724 // Occurs when numFramesPlayed position is very small and the following:
1725 // (1) In case 1, the time nowUs is computed before getTimestamp() is called and
Andy Hung5d313802016-10-10 15:09:39 -07001726 // numFramesPlayedAtUs is greater than nowUs by time more than numFramesPlayed.
Wei Jiac4ac8172015-10-21 10:35:48 -07001727 // (2) In case 3, using getPosition and adding mAudioSink->latency() to
Andy Hung5d313802016-10-10 15:09:39 -07001728 // numFramesPlayedAtUs, by a time amount greater than numFramesPlayed.
Wei Jiac4ac8172015-10-21 10:35:48 -07001729 //
1730 // Both of these are transitory conditions.
1731 ALOGV("getPlayedOutDurationUs: negative duration %lld set to zero", (long long)durationUs);
1732 durationUs = 0;
1733 }
1734 ALOGV("getPlayedOutDurationUs(%lld) nowUs(%lld) frames(%u) framesAt(%lld)",
Andy Hung5d313802016-10-10 15:09:39 -07001735 (long long)durationUs, (long long)nowUs,
1736 numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001737 return durationUs;
1738}
1739
Marco Nelissen4110c102012-03-29 09:31:28 -07001740status_t MediaPlayerService::AudioOutput::getFramesWritten(uint32_t *frameswritten) const
1741{
Andy Hungd1c74342015-07-07 16:54:23 -07001742 Mutex::Autolock lock(mLock);
Marco Nelissen4110c102012-03-29 09:31:28 -07001743 if (mTrack == 0) return NO_INIT;
Andy Hung2f6e73d2016-04-08 12:12:58 -07001744 ExtendedTimestamp ets;
1745 status_t status = mTrack->getTimestamp(&ets);
1746 if (status == OK || status == WOULD_BLOCK) {
1747 *frameswritten = (uint32_t)ets.mPosition[ExtendedTimestamp::LOCATION_CLIENT];
1748 }
1749 return status;
Marco Nelissen4110c102012-03-29 09:31:28 -07001750}
1751
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001752status_t MediaPlayerService::AudioOutput::setParameters(const String8& keyValuePairs)
1753{
Andy Hungd1c74342015-07-07 16:54:23 -07001754 Mutex::Autolock lock(mLock);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001755 if (mTrack == 0) return NO_INIT;
1756 return mTrack->setParameters(keyValuePairs);
1757}
1758
1759String8 MediaPlayerService::AudioOutput::getParameters(const String8& keys)
1760{
Andy Hungd1c74342015-07-07 16:54:23 -07001761 Mutex::Autolock lock(mLock);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001762 if (mTrack == 0) return String8::empty();
1763 return mTrack->getParameters(keys);
1764}
1765
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001766void MediaPlayerService::AudioOutput::setAudioAttributes(const audio_attributes_t * attributes) {
Andy Hungd1c74342015-07-07 16:54:23 -07001767 Mutex::Autolock lock(mLock);
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001768 if (attributes == NULL) {
1769 free(mAttributes);
1770 mAttributes = NULL;
1771 } else {
1772 if (mAttributes == NULL) {
1773 mAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t));
1774 }
1775 memcpy(mAttributes, attributes, sizeof(audio_attributes_t));
Eric Laurent43562692015-07-15 16:49:07 -07001776 mStreamType = audio_attributes_to_stream_type(attributes);
1777 }
1778}
1779
1780void MediaPlayerService::AudioOutput::setAudioStreamType(audio_stream_type_t streamType)
1781{
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001782 Mutex::Autolock lock(mLock);
Eric Laurent43562692015-07-15 16:49:07 -07001783 // do not allow direct stream type modification if attributes have been set
1784 if (mAttributes == NULL) {
1785 mStreamType = streamType;
1786 }
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001787}
1788
Andy Hungd1c74342015-07-07 16:54:23 -07001789void MediaPlayerService::AudioOutput::deleteRecycledTrack_l()
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001790{
Andy Hungd1c74342015-07-07 16:54:23 -07001791 ALOGV("deleteRecycledTrack_l");
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001792 if (mRecycledTrack != 0) {
1793
1794 if (mCallbackData != NULL) {
1795 mCallbackData->setOutput(NULL);
1796 mCallbackData->endTrackSwitch();
1797 }
1798
1799 if ((mRecycledTrack->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) {
Andy Hunge13f8a62016-03-30 14:20:42 -07001800 int32_t msec = 0;
1801 if (!mRecycledTrack->stopped()) { // check if active
1802 (void)mRecycledTrack->pendingDuration(&msec);
1803 }
1804 mRecycledTrack->stop(); // ensure full data drain
1805 ALOGD("deleting recycled track, waiting for data drain (%d msec)", msec);
1806 if (msec > 0) {
1807 static const int32_t WAIT_LIMIT_MS = 3000;
1808 if (msec > WAIT_LIMIT_MS) {
1809 msec = WAIT_LIMIT_MS;
1810 }
1811 usleep(msec * 1000LL);
1812 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001813 }
1814 // An offloaded track isn't flushed because the STREAM_END is reported
1815 // slightly prematurely to allow time for the gapless track switch
1816 // but this means that if we decide not to recycle the track there
1817 // could be a small amount of residual data still playing. We leave
1818 // AudioFlinger to drain the track.
1819
1820 mRecycledTrack.clear();
Andy Hungd1c74342015-07-07 16:54:23 -07001821 close_l();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001822 delete mCallbackData;
1823 mCallbackData = NULL;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001824 }
1825}
1826
Andy Hungd1c74342015-07-07 16:54:23 -07001827void MediaPlayerService::AudioOutput::close_l()
1828{
1829 mTrack.clear();
1830}
1831
Andreas Huber20111aa2009-07-14 16:56:47 -07001832status_t MediaPlayerService::AudioOutput::open(
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001833 uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
1834 audio_format_t format, int bufferCount,
Eric Laurent1948eb32012-04-13 16:50:19 -07001835 AudioCallback cb, void *cookie,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00001836 audio_output_flags_t flags,
Ronghua Wufaeb0f22015-05-21 12:20:21 -07001837 const audio_offload_info_t *offloadInfo,
Andy Hung179652e2015-05-31 22:49:46 -07001838 bool doNotReconnect,
1839 uint32_t suggestedFrameCount)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001840{
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001841 ALOGV("open(%u, %d, 0x%x, 0x%x, %d, %d 0x%x)", sampleRate, channelCount, channelMask,
1842 format, bufferCount, mSessionId, flags);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001843
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001844 // offloading is only supported in callback mode for now.
1845 // offloadInfo must be present if offload flag is set
1846 if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) &&
1847 ((cb == NULL) || (offloadInfo == NULL))) {
1848 return BAD_VALUE;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001849 }
1850
Andy Hung179652e2015-05-31 22:49:46 -07001851 // compute frame count for the AudioTrack internal buffer
1852 size_t frameCount;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001853 if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
1854 frameCount = 0; // AudioTrack will get frame count from AudioFlinger
1855 } else {
Andy Hung179652e2015-05-31 22:49:46 -07001856 // try to estimate the buffer processing fetch size from AudioFlinger.
1857 // framesPerBuffer is approximate and generally correct, except when it's not :-).
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001858 uint32_t afSampleRate;
1859 size_t afFrameCount;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001860 if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) != NO_ERROR) {
1861 return NO_INIT;
1862 }
1863 if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) != NO_ERROR) {
1864 return NO_INIT;
1865 }
Andy Hung179652e2015-05-31 22:49:46 -07001866 const size_t framesPerBuffer =
1867 (unsigned long long)sampleRate * afFrameCount / afSampleRate;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001868
Andy Hung179652e2015-05-31 22:49:46 -07001869 if (bufferCount == 0) {
1870 // use suggestedFrameCount
1871 bufferCount = (suggestedFrameCount + framesPerBuffer - 1) / framesPerBuffer;
1872 }
1873 // Check argument bufferCount against the mininum buffer count
1874 if (bufferCount != 0 && bufferCount < mMinBufferCount) {
1875 ALOGV("bufferCount (%d) increased to %d", bufferCount, mMinBufferCount);
1876 bufferCount = mMinBufferCount;
1877 }
1878 // if frameCount is 0, then AudioTrack will get frame count from AudioFlinger
1879 // which will be the minimum size permitted.
1880 frameCount = bufferCount * framesPerBuffer;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001881 }
Andreas Huber20111aa2009-07-14 16:56:47 -07001882
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001883 if (channelMask == CHANNEL_MASK_USE_CHANNEL_ORDER) {
Glenn Kastenab334fd2012-03-14 12:56:06 -07001884 channelMask = audio_channel_out_mask_from_count(channelCount);
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001885 if (0 == channelMask) {
1886 ALOGE("open() error, can\'t derive mask for %d audio channels", channelCount);
1887 return NO_INIT;
1888 }
1889 }
Eric Laurent1948eb32012-04-13 16:50:19 -07001890
Andy Hungd1c74342015-07-07 16:54:23 -07001891 Mutex::Autolock lock(mLock);
Andy Hung179652e2015-05-31 22:49:46 -07001892 mCallback = cb;
1893 mCallbackCookie = cookie;
1894
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001895 // Check whether we can recycle the track
1896 bool reuse = false;
1897 bool bothOffloaded = false;
Marco Nelissen67295b52012-06-11 14:52:53 -07001898
Glenn Kasten2799d742013-05-30 14:33:29 -07001899 if (mRecycledTrack != 0) {
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001900 // check whether we are switching between two offloaded tracks
1901 bothOffloaded = (flags & mRecycledTrack->getFlags()
1902 & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0;
Marco Nelissen67295b52012-06-11 14:52:53 -07001903
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001904 // check if the existing track can be reused as-is, or if a new track needs to be created.
1905 reuse = true;
1906
Marco Nelissen67295b52012-06-11 14:52:53 -07001907 if ((mCallbackData == NULL && mCallback != NULL) ||
1908 (mCallbackData != NULL && mCallback == NULL)) {
1909 // recycled track uses callbacks but the caller wants to use writes, or vice versa
1910 ALOGV("can't chain callback and write");
1911 reuse = false;
1912 } else if ((mRecycledTrack->getSampleRate() != sampleRate) ||
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001913 (mRecycledTrack->channelCount() != (uint32_t)channelCount) ) {
1914 ALOGV("samplerate, channelcount differ: %u/%u Hz, %u/%d ch",
Marco Nelissen67295b52012-06-11 14:52:53 -07001915 mRecycledTrack->getSampleRate(), sampleRate,
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001916 mRecycledTrack->channelCount(), channelCount);
Marco Nelissen67295b52012-06-11 14:52:53 -07001917 reuse = false;
1918 } else if (flags != mFlags) {
1919 ALOGV("output flags differ %08x/%08x", flags, mFlags);
1920 reuse = false;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001921 } else if (mRecycledTrack->format() != format) {
1922 reuse = false;
Marco Nelissen67295b52012-06-11 14:52:53 -07001923 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001924 } else {
1925 ALOGV("no track available to recycle");
1926 }
1927
1928 ALOGV_IF(bothOffloaded, "both tracks offloaded");
1929
1930 // If we can't recycle and both tracks are offloaded
1931 // we must close the previous output before opening a new one
1932 if (bothOffloaded && !reuse) {
1933 ALOGV("both offloaded and not recycling");
Andy Hungd1c74342015-07-07 16:54:23 -07001934 deleteRecycledTrack_l();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001935 }
1936
1937 sp<AudioTrack> t;
1938 CallbackData *newcbd = NULL;
1939
1940 // We don't attempt to create a new track if we are recycling an
1941 // offloaded track. But, if we are recycling a non-offloaded or we
1942 // are switching where one is offloaded and one isn't then we create
1943 // the new track in advance so that we can read additional stream info
1944
1945 if (!(reuse && bothOffloaded)) {
1946 ALOGV("creating new AudioTrack");
1947
1948 if (mCallback != NULL) {
1949 newcbd = new CallbackData(this);
1950 t = new AudioTrack(
1951 mStreamType,
1952 sampleRate,
1953 format,
1954 channelMask,
1955 frameCount,
1956 flags,
1957 CallbackWrapper,
1958 newcbd,
1959 0, // notification frames
1960 mSessionId,
1961 AudioTrack::TRANSFER_CALLBACK,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001962 offloadInfo,
Marco Nelissend457c972014-02-11 08:47:07 -08001963 mUid,
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001964 mPid,
Ronghua Wufaeb0f22015-05-21 12:20:21 -07001965 mAttributes,
1966 doNotReconnect);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001967 } else {
Andy Hungff874dc2016-04-11 16:49:09 -07001968 // TODO: Due to buffer memory concerns, we use a max target playback speed
1969 // based on mPlaybackRate at the time of open (instead of kMaxRequiredSpeed),
1970 // also clamping the target speed to 1.0 <= targetSpeed <= kMaxRequiredSpeed.
1971 const float targetSpeed =
1972 std::min(std::max(mPlaybackRate.mSpeed, 1.0f), kMaxRequiredSpeed);
1973 ALOGW_IF(targetSpeed != mPlaybackRate.mSpeed,
1974 "track target speed:%f clamped from playback speed:%f",
1975 targetSpeed, mPlaybackRate.mSpeed);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001976 t = new AudioTrack(
1977 mStreamType,
1978 sampleRate,
1979 format,
1980 channelMask,
1981 frameCount,
1982 flags,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001983 NULL, // callback
1984 NULL, // user data
1985 0, // notification frames
1986 mSessionId,
1987 AudioTrack::TRANSFER_DEFAULT,
1988 NULL, // offload info
Marco Nelissend457c972014-02-11 08:47:07 -08001989 mUid,
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001990 mPid,
Ronghua Wufaeb0f22015-05-21 12:20:21 -07001991 mAttributes,
Andy Hungff874dc2016-04-11 16:49:09 -07001992 doNotReconnect,
1993 targetSpeed);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001994 }
1995
1996 if ((t == 0) || (t->initCheck() != NO_ERROR)) {
1997 ALOGE("Unable to create audio track");
1998 delete newcbd;
Glenn Kasten3e98ecd2015-05-18 13:13:24 -07001999 // t goes out of scope, so reference count drops to zero
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002000 return NO_INIT;
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07002001 } else {
2002 // successful AudioTrack initialization implies a legacy stream type was generated
2003 // from the audio attributes
2004 mStreamType = t->streamType();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002005 }
2006 }
2007
2008 if (reuse) {
2009 CHECK(mRecycledTrack != NULL);
2010
2011 if (!bothOffloaded) {
2012 if (mRecycledTrack->frameCount() != t->frameCount()) {
Andy Hung833b4752016-04-04 17:15:48 -07002013 ALOGV("framecount differs: %zu/%zu frames",
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002014 mRecycledTrack->frameCount(), t->frameCount());
2015 reuse = false;
2016 }
2017 }
2018
Marco Nelissen67295b52012-06-11 14:52:53 -07002019 if (reuse) {
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002020 ALOGV("chaining to next output and recycling track");
Andy Hungd1c74342015-07-07 16:54:23 -07002021 close_l();
Marco Nelissen67295b52012-06-11 14:52:53 -07002022 mTrack = mRecycledTrack;
Glenn Kasten2799d742013-05-30 14:33:29 -07002023 mRecycledTrack.clear();
Marco Nelissen67295b52012-06-11 14:52:53 -07002024 if (mCallbackData != NULL) {
2025 mCallbackData->setOutput(this);
2026 }
Marco Nelissen67295b52012-06-11 14:52:53 -07002027 delete newcbd;
Wei Jiae0bbac92016-07-18 16:04:53 -07002028 return updateTrack();
Marco Nelissen67295b52012-06-11 14:52:53 -07002029 }
Marco Nelissen67295b52012-06-11 14:52:53 -07002030 }
2031
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002032 // we're not going to reuse the track, unblock and flush it
2033 // this was done earlier if both tracks are offloaded
2034 if (!bothOffloaded) {
Andy Hungd1c74342015-07-07 16:54:23 -07002035 deleteRecycledTrack_l();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002036 }
2037
2038 CHECK((t != NULL) && ((mCallback == NULL) || (newcbd != NULL)));
2039
Marco Nelissen67295b52012-06-11 14:52:53 -07002040 mCallbackData = newcbd;
Steve Block3856b092011-10-20 11:56:00 +01002041 ALOGV("setVolume");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002042 t->setVolume(mLeftVolume, mRightVolume);
Eric Laurent2beeb502010-07-16 07:43:46 -07002043
Andy Hung39399b62017-04-21 15:07:45 -07002044 // Restore VolumeShapers for the MediaPlayer in case the track was recreated
2045 // due to an output sink error (e.g. offload to non-offload switch).
2046 mVolumeHandler->forall([&t](const VolumeShaper &shaper) -> VolumeShaper::Status {
2047 sp<VolumeShaper::Operation> operationToEnd =
2048 new VolumeShaper::Operation(shaper.mOperation);
2049 // TODO: Ideally we would restore to the exact xOffset position
2050 // as returned by getVolumeShaperState(), but we don't have that
2051 // information when restoring at the client unless we periodically poll
2052 // the server or create shared memory state.
2053 //
2054 // For now, we simply advance to the end of the VolumeShaper effect
2055 // if it has been started.
2056 if (shaper.isStarted()) {
Andy Hungf3702642017-05-05 17:33:32 -07002057 operationToEnd->setNormalizedTime(1.f);
Andy Hung39399b62017-04-21 15:07:45 -07002058 }
2059 return t->applyVolumeShaper(shaper.mConfiguration, operationToEnd);
Andy Hung4ef88d72017-02-21 19:47:53 -08002060 });
Andy Hung4ef88d72017-02-21 19:47:53 -08002061
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002062 mSampleRateHz = sampleRate;
Preetam Singh Ranawat2e17eef2015-08-12 12:11:46 -07002063 mFlags = flags;
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002064 mMsecsPerFrame = 1E3f / (mPlaybackRate.mSpeed * sampleRate);
Andy Hungd1c74342015-07-07 16:54:23 -07002065 mFrameSize = t->frameSize();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002066 mTrack = t;
Eric Laurent2beeb502010-07-16 07:43:46 -07002067
Wei Jiae0bbac92016-07-18 16:04:53 -07002068 return updateTrack();
2069}
2070
2071status_t MediaPlayerService::AudioOutput::updateTrack() {
2072 if (mTrack == NULL) {
2073 return NO_ERROR;
2074 }
2075
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002076 status_t res = NO_ERROR;
Wei Jia0162d002015-06-09 11:59:33 -07002077 // Note some output devices may give us a direct track even though we don't specify it.
2078 // Example: Line application b/17459982.
Wei Jiae0bbac92016-07-18 16:04:53 -07002079 if ((mTrack->getFlags()
2080 & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD | AUDIO_OUTPUT_FLAG_DIRECT)) == 0) {
2081 res = mTrack->setPlaybackRate(mPlaybackRate);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002082 if (res == NO_ERROR) {
Wei Jiae0bbac92016-07-18 16:04:53 -07002083 mTrack->setAuxEffectSendLevel(mSendLevel);
2084 res = mTrack->attachAuxEffect(mAuxEffectId);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002085 }
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002086 }
Wei Jiae0bbac92016-07-18 16:04:53 -07002087 ALOGV("updateTrack() DONE status %d", res);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002088 return res;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002089}
2090
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002091status_t MediaPlayerService::AudioOutput::start()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002092{
Steve Block3856b092011-10-20 11:56:00 +01002093 ALOGV("start");
Andy Hungd1c74342015-07-07 16:54:23 -07002094 Mutex::Autolock lock(mLock);
Marco Nelissen6b74d672012-02-28 16:07:44 -08002095 if (mCallbackData != NULL) {
2096 mCallbackData->endTrackSwitch();
2097 }
Glenn Kasten2799d742013-05-30 14:33:29 -07002098 if (mTrack != 0) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002099 mTrack->setVolume(mLeftVolume, mRightVolume);
Eric Laurent2beeb502010-07-16 07:43:46 -07002100 mTrack->setAuxEffectSendLevel(mSendLevel);
Andy Hung39399b62017-04-21 15:07:45 -07002101 status_t status = mTrack->start();
2102 if (status == NO_ERROR) {
2103 mVolumeHandler->setStarted();
2104 }
2105 return status;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002106 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002107 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002108}
2109
Marco Nelissen6b74d672012-02-28 16:07:44 -08002110void MediaPlayerService::AudioOutput::setNextOutput(const sp<AudioOutput>& nextOutput) {
Andy Hungd1c74342015-07-07 16:54:23 -07002111 Mutex::Autolock lock(mLock);
Marco Nelissen6b74d672012-02-28 16:07:44 -08002112 mNextOutput = nextOutput;
2113}
Marco Nelissen7ee8ac92010-01-12 09:23:54 -08002114
Marco Nelissen6b74d672012-02-28 16:07:44 -08002115void MediaPlayerService::AudioOutput::switchToNextOutput() {
2116 ALOGV("switchToNextOutput");
Andy Hungd1c74342015-07-07 16:54:23 -07002117
2118 // Try to acquire the callback lock before moving track (without incurring deadlock).
2119 const unsigned kMaxSwitchTries = 100;
2120 Mutex::Autolock lock(mLock);
2121 for (unsigned tries = 0;;) {
2122 if (mTrack == 0) {
2123 return;
Marco Nelissen6b74d672012-02-28 16:07:44 -08002124 }
Andy Hungd1c74342015-07-07 16:54:23 -07002125 if (mNextOutput != NULL && mNextOutput != this) {
2126 if (mCallbackData != NULL) {
2127 // two alternative approaches
2128#if 1
2129 CallbackData *callbackData = mCallbackData;
2130 mLock.unlock();
2131 // proper acquisition sequence
2132 callbackData->lock();
2133 mLock.lock();
2134 // Caution: it is unlikely that someone deleted our callback or changed our target
2135 if (callbackData != mCallbackData || mNextOutput == NULL || mNextOutput == this) {
2136 // fatal if we are starved out.
2137 LOG_ALWAYS_FATAL_IF(++tries > kMaxSwitchTries,
2138 "switchToNextOutput() cannot obtain correct lock sequence");
2139 callbackData->unlock();
2140 continue;
2141 }
2142 callbackData->mSwitching = true; // begin track switch
Wei Jiaadee56a2016-08-05 15:40:34 -07002143 callbackData->setOutput(NULL);
Andy Hungd1c74342015-07-07 16:54:23 -07002144#else
2145 // tryBeginTrackSwitch() returns false if the callback has the lock.
2146 if (!mCallbackData->tryBeginTrackSwitch()) {
2147 // fatal if we are starved out.
2148 LOG_ALWAYS_FATAL_IF(++tries > kMaxSwitchTries,
2149 "switchToNextOutput() cannot obtain callback lock");
2150 mLock.unlock();
2151 usleep(5 * 1000 /* usec */); // allow callback to use AudioOutput
2152 mLock.lock();
2153 continue;
2154 }
2155#endif
2156 }
2157
2158 Mutex::Autolock nextLock(mNextOutput->mLock);
2159
2160 // If the next output track is not NULL, then it has been
2161 // opened already for playback.
2162 // This is possible even without the next player being started,
2163 // for example, the next player could be prepared and seeked.
2164 //
2165 // Presuming it isn't advisable to force the track over.
2166 if (mNextOutput->mTrack == NULL) {
2167 ALOGD("Recycling track for gapless playback");
2168 delete mNextOutput->mCallbackData;
2169 mNextOutput->mCallbackData = mCallbackData;
2170 mNextOutput->mRecycledTrack = mTrack;
2171 mNextOutput->mSampleRateHz = mSampleRateHz;
2172 mNextOutput->mMsecsPerFrame = mMsecsPerFrame;
Andy Hungd1c74342015-07-07 16:54:23 -07002173 mNextOutput->mFlags = mFlags;
2174 mNextOutput->mFrameSize = mFrameSize;
2175 close_l();
2176 mCallbackData = NULL; // destruction handled by mNextOutput
2177 } else {
2178 ALOGW("Ignoring gapless playback because next player has already started");
2179 // remove track in case resource needed for future players.
2180 if (mCallbackData != NULL) {
2181 mCallbackData->endTrackSwitch(); // release lock for callbacks before close.
2182 }
2183 close_l();
2184 }
2185 }
2186 break;
Marco Nelissen6b74d672012-02-28 16:07:44 -08002187 }
2188}
2189
Wei Jia7d3f4df2015-03-03 15:28:00 -08002190ssize_t MediaPlayerService::AudioOutput::write(const void* buffer, size_t size, bool blocking)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002191{
Andy Hungd1c74342015-07-07 16:54:23 -07002192 Mutex::Autolock lock(mLock);
Glenn Kastenadad3d72014-02-21 14:51:43 -08002193 LOG_ALWAYS_FATAL_IF(mCallback != NULL, "Don't call write if supplying a callback.");
Andreas Huber20111aa2009-07-14 16:56:47 -07002194
Steve Block3856b092011-10-20 11:56:00 +01002195 //ALOGV("write(%p, %u)", buffer, size);
Glenn Kasten2799d742013-05-30 14:33:29 -07002196 if (mTrack != 0) {
Andy Hung2f6e73d2016-04-08 12:12:58 -07002197 return mTrack->write(buffer, size, blocking);
Marco Nelissen10dbb8e2009-09-20 10:42:13 -07002198 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002199 return NO_INIT;
2200}
2201
2202void MediaPlayerService::AudioOutput::stop()
2203{
Steve Block3856b092011-10-20 11:56:00 +01002204 ALOGV("stop");
Andy Hungd1c74342015-07-07 16:54:23 -07002205 Mutex::Autolock lock(mLock);
Glenn Kasten2799d742013-05-30 14:33:29 -07002206 if (mTrack != 0) mTrack->stop();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002207}
2208
2209void MediaPlayerService::AudioOutput::flush()
2210{
Steve Block3856b092011-10-20 11:56:00 +01002211 ALOGV("flush");
Andy Hungd1c74342015-07-07 16:54:23 -07002212 Mutex::Autolock lock(mLock);
Glenn Kasten2799d742013-05-30 14:33:29 -07002213 if (mTrack != 0) mTrack->flush();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002214}
2215
2216void MediaPlayerService::AudioOutput::pause()
2217{
Steve Block3856b092011-10-20 11:56:00 +01002218 ALOGV("pause");
Andy Hungd1c74342015-07-07 16:54:23 -07002219 Mutex::Autolock lock(mLock);
Glenn Kasten2799d742013-05-30 14:33:29 -07002220 if (mTrack != 0) mTrack->pause();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002221}
2222
2223void MediaPlayerService::AudioOutput::close()
2224{
Steve Block3856b092011-10-20 11:56:00 +01002225 ALOGV("close");
Erik Wolsheimer7845a1f2015-10-30 12:07:52 -07002226 sp<AudioTrack> track;
2227 {
2228 Mutex::Autolock lock(mLock);
2229 track = mTrack;
2230 close_l(); // clears mTrack
2231 }
2232 // destruction of the track occurs outside of mutex.
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002233}
2234
2235void MediaPlayerService::AudioOutput::setVolume(float left, float right)
2236{
Steve Block3856b092011-10-20 11:56:00 +01002237 ALOGV("setVolume(%f, %f)", left, right);
Andy Hungd1c74342015-07-07 16:54:23 -07002238 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002239 mLeftVolume = left;
2240 mRightVolume = right;
Glenn Kasten2799d742013-05-30 14:33:29 -07002241 if (mTrack != 0) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002242 mTrack->setVolume(left, right);
2243 }
2244}
2245
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002246status_t MediaPlayerService::AudioOutput::setPlaybackRate(const AudioPlaybackRate &rate)
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002247{
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002248 ALOGV("setPlaybackRate(%f %f %d %d)",
2249 rate.mSpeed, rate.mPitch, rate.mFallbackMode, rate.mStretchMode);
Andy Hungd1c74342015-07-07 16:54:23 -07002250 Mutex::Autolock lock(mLock);
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002251 if (mTrack == 0) {
2252 // remember rate so that we can set it when the track is opened
2253 mPlaybackRate = rate;
2254 return OK;
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002255 }
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002256 status_t res = mTrack->setPlaybackRate(rate);
2257 if (res != NO_ERROR) {
2258 return res;
2259 }
2260 // rate.mSpeed is always greater than 0 if setPlaybackRate succeeded
2261 CHECK_GT(rate.mSpeed, 0.f);
2262 mPlaybackRate = rate;
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002263 if (mSampleRateHz != 0) {
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002264 mMsecsPerFrame = 1E3f / (rate.mSpeed * mSampleRateHz);
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002265 }
2266 return res;
2267}
2268
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002269status_t MediaPlayerService::AudioOutput::getPlaybackRate(AudioPlaybackRate *rate)
2270{
2271 ALOGV("setPlaybackRate");
Andy Hungd1c74342015-07-07 16:54:23 -07002272 Mutex::Autolock lock(mLock);
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002273 if (mTrack == 0) {
2274 return NO_INIT;
2275 }
2276 *rate = mTrack->getPlaybackRate();
2277 return NO_ERROR;
2278}
2279
Eric Laurent2beeb502010-07-16 07:43:46 -07002280status_t MediaPlayerService::AudioOutput::setAuxEffectSendLevel(float level)
2281{
Steve Block3856b092011-10-20 11:56:00 +01002282 ALOGV("setAuxEffectSendLevel(%f)", level);
Andy Hungd1c74342015-07-07 16:54:23 -07002283 Mutex::Autolock lock(mLock);
Eric Laurent2beeb502010-07-16 07:43:46 -07002284 mSendLevel = level;
Glenn Kasten2799d742013-05-30 14:33:29 -07002285 if (mTrack != 0) {
Eric Laurent2beeb502010-07-16 07:43:46 -07002286 return mTrack->setAuxEffectSendLevel(level);
2287 }
2288 return NO_ERROR;
2289}
2290
2291status_t MediaPlayerService::AudioOutput::attachAuxEffect(int effectId)
2292{
Steve Block3856b092011-10-20 11:56:00 +01002293 ALOGV("attachAuxEffect(%d)", effectId);
Andy Hungd1c74342015-07-07 16:54:23 -07002294 Mutex::Autolock lock(mLock);
Eric Laurent2beeb502010-07-16 07:43:46 -07002295 mAuxEffectId = effectId;
Glenn Kasten2799d742013-05-30 14:33:29 -07002296 if (mTrack != 0) {
Eric Laurent2beeb502010-07-16 07:43:46 -07002297 return mTrack->attachAuxEffect(effectId);
2298 }
2299 return NO_ERROR;
2300}
2301
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002302VolumeShaper::Status MediaPlayerService::AudioOutput::applyVolumeShaper(
2303 const sp<VolumeShaper::Configuration>& configuration,
2304 const sp<VolumeShaper::Operation>& operation)
2305{
2306 Mutex::Autolock lock(mLock);
2307 ALOGV("AudioOutput::applyVolumeShaper");
Andy Hung4ef88d72017-02-21 19:47:53 -08002308
Andy Hung4ef88d72017-02-21 19:47:53 -08002309 mVolumeHandler->setIdIfNecessary(configuration);
Andy Hung39399b62017-04-21 15:07:45 -07002310
2311 VolumeShaper::Status status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002312 if (mTrack != 0) {
Andy Hung39399b62017-04-21 15:07:45 -07002313 status = mTrack->applyVolumeShaper(configuration, operation);
2314 if (status >= 0) {
2315 (void)mVolumeHandler->applyVolumeShaper(configuration, operation);
Andy Hungf3702642017-05-05 17:33:32 -07002316 if (mTrack->isPlaying()) { // match local AudioTrack to properly restore.
2317 mVolumeHandler->setStarted();
2318 }
Andy Hung39399b62017-04-21 15:07:45 -07002319 }
Andy Hung4ef88d72017-02-21 19:47:53 -08002320 } else {
Andy Hung39399b62017-04-21 15:07:45 -07002321 status = mVolumeHandler->applyVolumeShaper(configuration, operation);
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002322 }
Andy Hung39399b62017-04-21 15:07:45 -07002323 return status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002324}
2325
2326sp<VolumeShaper::State> MediaPlayerService::AudioOutput::getVolumeShaperState(int id)
2327{
2328 Mutex::Autolock lock(mLock);
2329 if (mTrack != 0) {
2330 return mTrack->getVolumeShaperState(id);
Andy Hung4ef88d72017-02-21 19:47:53 -08002331 } else {
2332 return mVolumeHandler->getVolumeShaperState(id);
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002333 }
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002334}
2335
Andreas Huber20111aa2009-07-14 16:56:47 -07002336// static
2337void MediaPlayerService::AudioOutput::CallbackWrapper(
Glenn Kastend217a8c2011-06-01 15:20:35 -07002338 int event, void *cookie, void *info) {
Steve Block3856b092011-10-20 11:56:00 +01002339 //ALOGV("callbackwrapper");
Marco Nelissen6b74d672012-02-28 16:07:44 -08002340 CallbackData *data = (CallbackData*)cookie;
Andy Hungd1c74342015-07-07 16:54:23 -07002341 // lock to ensure we aren't caught in the middle of a track switch.
Marco Nelissen6b74d672012-02-28 16:07:44 -08002342 data->lock();
2343 AudioOutput *me = data->getOutput();
Andreas Huber20111aa2009-07-14 16:56:47 -07002344 AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
Marco Nelissen6b74d672012-02-28 16:07:44 -08002345 if (me == NULL) {
2346 // no output set, likely because the track was scheduled to be reused
2347 // by another player, but the format turned out to be incompatible.
2348 data->unlock();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002349 if (buffer != NULL) {
2350 buffer->size = 0;
2351 }
Marco Nelissen6b74d672012-02-28 16:07:44 -08002352 return;
2353 }
Andreas Huber20111aa2009-07-14 16:56:47 -07002354
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002355 switch(event) {
2356 case AudioTrack::EVENT_MORE_DATA: {
2357 size_t actualSize = (*me->mCallback)(
2358 me, buffer->raw, buffer->size, me->mCallbackCookie,
2359 CB_EVENT_FILL_BUFFER);
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002360
Andy Hung719b46b2015-05-31 22:18:25 -07002361 // Log when no data is returned from the callback.
2362 // (1) We may have no data (especially with network streaming sources).
2363 // (2) We may have reached the EOS and the audio track is not stopped yet.
2364 // Note that AwesomePlayer/AudioPlayer will only return zero size when it reaches the EOS.
2365 // NuPlayerRenderer will return zero when it doesn't have data (it doesn't block to fill).
2366 //
2367 // This is a benign busy-wait, with the next data request generated 10 ms or more later;
2368 // nevertheless for power reasons, we don't want to see too many of these.
Andreas Huber2e8ffaf2010-02-18 16:45:13 -08002369
Andy Hung719b46b2015-05-31 22:18:25 -07002370 ALOGV_IF(actualSize == 0 && buffer->size > 0, "callbackwrapper: empty buffer returned");
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002371
2372 buffer->size = actualSize;
2373 } break;
2374
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002375 case AudioTrack::EVENT_STREAM_END:
Andy Hung719b46b2015-05-31 22:18:25 -07002376 // currently only occurs for offloaded callbacks
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002377 ALOGV("callbackwrapper: deliver EVENT_STREAM_END");
2378 (*me->mCallback)(me, NULL /* buffer */, 0 /* size */,
2379 me->mCallbackCookie, CB_EVENT_STREAM_END);
2380 break;
2381
2382 case AudioTrack::EVENT_NEW_IAUDIOTRACK :
2383 ALOGV("callbackwrapper: deliver EVENT_TEAR_DOWN");
2384 (*me->mCallback)(me, NULL /* buffer */, 0 /* size */,
2385 me->mCallbackCookie, CB_EVENT_TEAR_DOWN);
2386 break;
2387
Glenn Kasten421743b2015-06-01 08:18:08 -07002388 case AudioTrack::EVENT_UNDERRUN:
Andy Hung719b46b2015-05-31 22:18:25 -07002389 // This occurs when there is no data available, typically
Glenn Kasten421743b2015-06-01 08:18:08 -07002390 // when there is a failure to supply data to the AudioTrack. It can also
2391 // occur in non-offloaded mode when the audio device comes out of standby.
2392 //
Andy Hung719b46b2015-05-31 22:18:25 -07002393 // If an AudioTrack underruns it outputs silence. Since this happens suddenly
2394 // it may sound like an audible pop or glitch.
2395 //
2396 // The underrun event is sent once per track underrun; the condition is reset
2397 // when more data is sent to the AudioTrack.
Eric Laurente93cc032016-05-05 10:15:10 -07002398 ALOGD("callbackwrapper: EVENT_UNDERRUN (discarded)");
Glenn Kasten421743b2015-06-01 08:18:08 -07002399 break;
2400
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002401 default:
2402 ALOGE("received unknown event type: %d inside CallbackWrapper !", event);
Andreas Huber51c1e0e2011-04-04 11:43:40 -07002403 }
2404
Marco Nelissen6b74d672012-02-28 16:07:44 -08002405 data->unlock();
Andreas Huber20111aa2009-07-14 16:56:47 -07002406}
2407
Glenn Kastend848eb42016-03-08 13:42:11 -08002408audio_session_t MediaPlayerService::AudioOutput::getSessionId() const
Eric Laurent8c563ed2010-10-07 18:23:03 -07002409{
Andy Hungd1c74342015-07-07 16:54:23 -07002410 Mutex::Autolock lock(mLock);
Eric Laurent8c563ed2010-10-07 18:23:03 -07002411 return mSessionId;
2412}
2413
Eric Laurent6f59db12013-07-26 17:16:50 -07002414uint32_t MediaPlayerService::AudioOutput::getSampleRate() const
2415{
Andy Hungd1c74342015-07-07 16:54:23 -07002416 Mutex::Autolock lock(mLock);
Eric Laurent6f59db12013-07-26 17:16:50 -07002417 if (mTrack == 0) return 0;
2418 return mTrack->getSampleRate();
2419}
2420
Andy Hungf2c87b32016-04-07 19:49:29 -07002421int64_t MediaPlayerService::AudioOutput::getBufferDurationInUs() const
2422{
2423 Mutex::Autolock lock(mLock);
2424 if (mTrack == 0) {
2425 return 0;
2426 }
2427 int64_t duration;
2428 if (mTrack->getBufferDurationInUs(&duration) != OK) {
2429 return 0;
2430 }
2431 return duration;
2432}
2433
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002434////////////////////////////////////////////////////////////////////////////////
2435
2436struct CallbackThread : public Thread {
2437 CallbackThread(const wp<MediaPlayerBase::AudioSink> &sink,
2438 MediaPlayerBase::AudioSink::AudioCallback cb,
2439 void *cookie);
2440
2441protected:
2442 virtual ~CallbackThread();
2443
2444 virtual bool threadLoop();
2445
2446private:
2447 wp<MediaPlayerBase::AudioSink> mSink;
2448 MediaPlayerBase::AudioSink::AudioCallback mCallback;
2449 void *mCookie;
2450 void *mBuffer;
2451 size_t mBufferSize;
2452
2453 CallbackThread(const CallbackThread &);
2454 CallbackThread &operator=(const CallbackThread &);
2455};
2456
2457CallbackThread::CallbackThread(
2458 const wp<MediaPlayerBase::AudioSink> &sink,
2459 MediaPlayerBase::AudioSink::AudioCallback cb,
2460 void *cookie)
2461 : mSink(sink),
2462 mCallback(cb),
2463 mCookie(cookie),
2464 mBuffer(NULL),
2465 mBufferSize(0) {
2466}
2467
2468CallbackThread::~CallbackThread() {
2469 if (mBuffer) {
2470 free(mBuffer);
2471 mBuffer = NULL;
2472 }
2473}
2474
2475bool CallbackThread::threadLoop() {
2476 sp<MediaPlayerBase::AudioSink> sink = mSink.promote();
2477 if (sink == NULL) {
2478 return false;
2479 }
2480
2481 if (mBuffer == NULL) {
2482 mBufferSize = sink->bufferSize();
2483 mBuffer = malloc(mBufferSize);
2484 }
2485
2486 size_t actualSize =
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002487 (*mCallback)(sink.get(), mBuffer, mBufferSize, mCookie,
2488 MediaPlayerBase::AudioSink::CB_EVENT_FILL_BUFFER);
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002489
2490 if (actualSize > 0) {
2491 sink->write(mBuffer, actualSize);
Andy Hunga31335a2014-08-20 17:37:59 -07002492 // Could return false on sink->write() error or short count.
2493 // Not necessarily appropriate but would work for AudioCache behavior.
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002494 }
2495
2496 return true;
2497}
2498
2499////////////////////////////////////////////////////////////////////////////////
2500
Chong Zhange5b9b692017-05-11 11:44:56 -07002501void MediaPlayerService::addBatteryData(uint32_t params) {
2502 mBatteryTracker.addBatteryData(params);
2503}
2504
2505status_t MediaPlayerService::pullBatteryData(Parcel* reply) {
2506 return mBatteryTracker.pullBatteryData(reply);
2507}
2508
2509MediaPlayerService::BatteryTracker::BatteryTracker() {
2510 mBatteryAudio.refCount = 0;
2511 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2512 mBatteryAudio.deviceOn[i] = 0;
2513 mBatteryAudio.lastTime[i] = 0;
2514 mBatteryAudio.totalTime[i] = 0;
2515 }
2516 // speaker is on by default
2517 mBatteryAudio.deviceOn[SPEAKER] = 1;
2518
2519 // reset battery stats
2520 // if the mediaserver has crashed, battery stats could be left
2521 // in bad state, reset the state upon service start.
2522 BatteryNotifier::getInstance().noteResetVideo();
2523}
2524
2525void MediaPlayerService::BatteryTracker::addBatteryData(uint32_t params)
Gloria Wang7cf180c2011-02-19 18:37:57 -08002526{
2527 Mutex::Autolock lock(mLock);
Gloria Wang9ee159b2011-02-24 14:51:45 -08002528
2529 int32_t time = systemTime() / 1000000L;
2530
2531 // change audio output devices. This notification comes from AudioFlinger
2532 if ((params & kBatteryDataSpeakerOn)
2533 || (params & kBatteryDataOtherAudioDeviceOn)) {
2534
2535 int deviceOn[NUM_AUDIO_DEVICES];
2536 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2537 deviceOn[i] = 0;
2538 }
2539
2540 if ((params & kBatteryDataSpeakerOn)
2541 && (params & kBatteryDataOtherAudioDeviceOn)) {
2542 deviceOn[SPEAKER_AND_OTHER] = 1;
2543 } else if (params & kBatteryDataSpeakerOn) {
2544 deviceOn[SPEAKER] = 1;
2545 } else {
2546 deviceOn[OTHER_AUDIO_DEVICE] = 1;
2547 }
2548
2549 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2550 if (mBatteryAudio.deviceOn[i] != deviceOn[i]){
2551
2552 if (mBatteryAudio.refCount > 0) { // if playing audio
2553 if (!deviceOn[i]) {
2554 mBatteryAudio.lastTime[i] += time;
2555 mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
2556 mBatteryAudio.lastTime[i] = 0;
2557 } else {
2558 mBatteryAudio.lastTime[i] = 0 - time;
2559 }
2560 }
2561
2562 mBatteryAudio.deviceOn[i] = deviceOn[i];
2563 }
2564 }
2565 return;
2566 }
2567
Marco Nelissenb7848f12014-12-04 08:57:56 -08002568 // an audio stream is started
Gloria Wang9ee159b2011-02-24 14:51:45 -08002569 if (params & kBatteryDataAudioFlingerStart) {
2570 // record the start time only if currently no other audio
2571 // is being played
2572 if (mBatteryAudio.refCount == 0) {
2573 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2574 if (mBatteryAudio.deviceOn[i]) {
2575 mBatteryAudio.lastTime[i] -= time;
2576 }
2577 }
2578 }
2579
2580 mBatteryAudio.refCount ++;
2581 return;
2582
2583 } else if (params & kBatteryDataAudioFlingerStop) {
2584 if (mBatteryAudio.refCount <= 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002585 ALOGW("Battery track warning: refCount is <= 0");
Gloria Wang9ee159b2011-02-24 14:51:45 -08002586 return;
2587 }
2588
2589 // record the stop time only if currently this is the only
2590 // audio being played
2591 if (mBatteryAudio.refCount == 1) {
2592 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2593 if (mBatteryAudio.deviceOn[i]) {
2594 mBatteryAudio.lastTime[i] += time;
2595 mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
2596 mBatteryAudio.lastTime[i] = 0;
2597 }
2598 }
2599 }
2600
2601 mBatteryAudio.refCount --;
2602 return;
2603 }
2604
Andy Hung1afd0982016-11-08 16:13:44 -08002605 uid_t uid = IPCThreadState::self()->getCallingUid();
Gloria Wang7cf180c2011-02-19 18:37:57 -08002606 if (uid == AID_MEDIA) {
2607 return;
2608 }
2609 int index = mBatteryData.indexOfKey(uid);
Gloria Wang7cf180c2011-02-19 18:37:57 -08002610
2611 if (index < 0) { // create a new entry for this UID
2612 BatteryUsageInfo info;
2613 info.audioTotalTime = 0;
2614 info.videoTotalTime = 0;
2615 info.audioLastTime = 0;
2616 info.videoLastTime = 0;
2617 info.refCount = 0;
2618
Gloria Wang9ee159b2011-02-24 14:51:45 -08002619 if (mBatteryData.add(uid, info) == NO_MEMORY) {
Steve Block29357bc2012-01-06 19:20:56 +00002620 ALOGE("Battery track error: no memory for new app");
Gloria Wang9ee159b2011-02-24 14:51:45 -08002621 return;
2622 }
Gloria Wang7cf180c2011-02-19 18:37:57 -08002623 }
2624
2625 BatteryUsageInfo &info = mBatteryData.editValueFor(uid);
2626
2627 if (params & kBatteryDataCodecStarted) {
2628 if (params & kBatteryDataTrackAudio) {
2629 info.audioLastTime -= time;
2630 info.refCount ++;
2631 }
2632 if (params & kBatteryDataTrackVideo) {
2633 info.videoLastTime -= time;
2634 info.refCount ++;
2635 }
2636 } else {
2637 if (info.refCount == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002638 ALOGW("Battery track warning: refCount is already 0");
Gloria Wang7cf180c2011-02-19 18:37:57 -08002639 return;
2640 } else if (info.refCount < 0) {
Steve Block29357bc2012-01-06 19:20:56 +00002641 ALOGE("Battery track error: refCount < 0");
Gloria Wang7cf180c2011-02-19 18:37:57 -08002642 mBatteryData.removeItem(uid);
2643 return;
2644 }
2645
2646 if (params & kBatteryDataTrackAudio) {
2647 info.audioLastTime += time;
2648 info.refCount --;
2649 }
2650 if (params & kBatteryDataTrackVideo) {
2651 info.videoLastTime += time;
2652 info.refCount --;
2653 }
2654
2655 // no stream is being played by this UID
2656 if (info.refCount == 0) {
2657 info.audioTotalTime += info.audioLastTime;
2658 info.audioLastTime = 0;
2659 info.videoTotalTime += info.videoLastTime;
2660 info.videoLastTime = 0;
2661 }
2662 }
2663}
2664
Chong Zhange5b9b692017-05-11 11:44:56 -07002665status_t MediaPlayerService::BatteryTracker::pullBatteryData(Parcel* reply) {
Gloria Wang7cf180c2011-02-19 18:37:57 -08002666 Mutex::Autolock lock(mLock);
Gloria Wang9ee159b2011-02-24 14:51:45 -08002667
2668 // audio output devices usage
2669 int32_t time = systemTime() / 1000000L; //in ms
2670 int32_t totalTime;
2671
2672 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2673 totalTime = mBatteryAudio.totalTime[i];
2674
2675 if (mBatteryAudio.deviceOn[i]
2676 && (mBatteryAudio.lastTime[i] != 0)) {
2677 int32_t tmpTime = mBatteryAudio.lastTime[i] + time;
2678 totalTime += tmpTime;
2679 }
2680
2681 reply->writeInt32(totalTime);
2682 // reset the total time
2683 mBatteryAudio.totalTime[i] = 0;
2684 }
2685
2686 // codec usage
Gloria Wang7cf180c2011-02-19 18:37:57 -08002687 BatteryUsageInfo info;
2688 int size = mBatteryData.size();
2689
2690 reply->writeInt32(size);
2691 int i = 0;
2692
2693 while (i < size) {
2694 info = mBatteryData.valueAt(i);
2695
2696 reply->writeInt32(mBatteryData.keyAt(i)); //UID
2697 reply->writeInt32(info.audioTotalTime);
2698 reply->writeInt32(info.videoTotalTime);
2699
2700 info.audioTotalTime = 0;
2701 info.videoTotalTime = 0;
2702
2703 // remove the UID entry where no stream is being played
2704 if (info.refCount <= 0) {
2705 mBatteryData.removeItemsAt(i);
2706 size --;
2707 i --;
2708 }
2709 i++;
2710 }
2711 return NO_ERROR;
2712}
nikoa64c8c72009-07-20 15:07:26 -07002713} // namespace android