blob: 34df384b006f6d4c33e3b02f9b71882938fa3edf [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>
Dongwon Kangd91dc5a2017-10-10 00:07:09 -070058#include <media/stagefright/InterfaceUtils.h>
Lajos Molnar1381d4b2014-08-07 15:18:35 -070059#include <media/stagefright/MediaCodecList.h>
Eric Laurent9cb839a2011-09-27 09:48:56 -070060#include <media/stagefright/MediaErrors.h>
Marco Nelissen83b0fd92015-09-16 13:48:07 -070061#include <media/stagefright/Utils.h>
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +010062#include <media/stagefright/foundation/ADebug.h>
Marco Nelissenf09611f2015-02-13 14:12:42 -080063#include <media/stagefright/foundation/ALooperRoster.h>
Chong Zhang181fd9b2017-02-16 15:53:03 -080064#include <media/stagefright/SurfaceUtils.h>
Ruben Brunk99e69712015-05-26 17:25:07 -070065#include <mediautils/BatteryNotifier.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080066
Andy Hung53541292016-04-13 16:48:51 -070067#include <memunreachable/memunreachable.h>
Dima Zavin64760242011-05-11 14:15:23 -070068#include <system/audio.h>
Dima Zavinfce7a472011-04-19 22:30:36 -070069
Gloria Wang7cf180c2011-02-19 18:37:57 -080070#include <private/android_filesystem_config.h>
71
James Dong559bf282012-03-28 10:29:14 -070072#include "ActivityManager.h"
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080073#include "MediaRecorderClient.h"
74#include "MediaPlayerService.h"
75#include "MetadataRetrieverClient.h"
John Grossman44a7e422012-06-21 17:29:24 -070076#include "MediaPlayerFactory.h"
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080077
Nicolas Catania14d27472009-07-13 14:37:49 -070078#include "TestPlayerStub.h"
Andreas Huberf9334412010-12-15 15:17:42 -080079#include "nuplayer/NuPlayerDriver.h"
Andreas Huber20111aa2009-07-14 16:56:47 -070080
Andreas Huberb7319a72013-05-29 14:20:52 -070081#include "HTTPBase.h"
Andreas Hubered3e3e02012-03-26 11:13:27 -070082
Wei Jia502c2f42017-07-13 17:47:56 -070083static const int kDumpLockRetries = 50;
84static const int kDumpLockSleepUs = 20000;
85
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -070086namespace {
nikoa64c8c72009-07-20 15:07:26 -070087using android::media::Metadata;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -070088using android::status_t;
89using android::OK;
90using android::BAD_VALUE;
91using android::NOT_ENOUGH_DATA;
92using android::Parcel;
Ivan Lozano8cf3a072017-08-09 09:01:33 -070093using android::media::VolumeShaper;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -070094
95// Max number of entries in the filter.
96const int kMaxFilterSize = 64; // I pulled that out of thin air.
97
Andy Hungff874dc2016-04-11 16:49:09 -070098const float kMaxRequiredSpeed = 8.0f; // for PCM tracks allow up to 8x speedup.
99
nikoa64c8c72009-07-20 15:07:26 -0700100// FIXME: Move all the metadata related function in the Metadata.cpp
nikod608a812009-07-16 16:39:53 -0700101
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700102
103// Unmarshall a filter from a Parcel.
104// Filter format in a parcel:
105//
106// 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
107// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
108// | number of entries (n) |
109// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
110// | metadata type 1 |
111// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
112// | metadata type 2 |
113// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
114// ....
115// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
116// | metadata type n |
117// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
118//
119// @param p Parcel that should start with a filter.
120// @param[out] filter On exit contains the list of metadata type to be
121// filtered.
122// @param[out] status On exit contains the status code to be returned.
123// @return true if the parcel starts with a valid filter.
124bool unmarshallFilter(const Parcel& p,
nikoa64c8c72009-07-20 15:07:26 -0700125 Metadata::Filter *filter,
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700126 status_t *status)
127{
Nicolas Catania48290382009-07-10 13:53:06 -0700128 int32_t val;
129 if (p.readInt32(&val) != OK)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700130 {
Steve Block29357bc2012-01-06 19:20:56 +0000131 ALOGE("Failed to read filter's length");
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700132 *status = NOT_ENOUGH_DATA;
133 return false;
134 }
135
Nicolas Catania48290382009-07-10 13:53:06 -0700136 if( val > kMaxFilterSize || val < 0)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700137 {
Steve Block29357bc2012-01-06 19:20:56 +0000138 ALOGE("Invalid filter len %d", val);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700139 *status = BAD_VALUE;
140 return false;
141 }
142
Nicolas Catania48290382009-07-10 13:53:06 -0700143 const size_t num = val;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700144
145 filter->clear();
Nicolas Catania48290382009-07-10 13:53:06 -0700146 filter->setCapacity(num);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700147
nikoa64c8c72009-07-20 15:07:26 -0700148 size_t size = num * sizeof(Metadata::Type);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700149
Nicolas Catania48290382009-07-10 13:53:06 -0700150
151 if (p.dataAvail() < size)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700152 {
Andy Hung833b4752016-04-04 17:15:48 -0700153 ALOGE("Filter too short expected %zu but got %zu", size, p.dataAvail());
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700154 *status = NOT_ENOUGH_DATA;
155 return false;
156 }
157
nikoa64c8c72009-07-20 15:07:26 -0700158 const Metadata::Type *data =
159 static_cast<const Metadata::Type*>(p.readInplace(size));
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700160
Nicolas Catania48290382009-07-10 13:53:06 -0700161 if (NULL == data)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700162 {
Steve Block29357bc2012-01-06 19:20:56 +0000163 ALOGE("Filter had no data");
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700164 *status = BAD_VALUE;
165 return false;
166 }
167
168 // TODO: The stl impl of vector would be more efficient here
169 // because it degenerates into a memcpy on pod types. Try to
170 // replace later or use stl::set.
Nicolas Catania48290382009-07-10 13:53:06 -0700171 for (size_t i = 0; i < num; ++i)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700172 {
Nicolas Catania48290382009-07-10 13:53:06 -0700173 filter->add(*data);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700174 ++data;
175 }
176 *status = OK;
177 return true;
178}
179
Nicolas Catania48290382009-07-10 13:53:06 -0700180// @param filter Of metadata type.
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700181// @param val To be searched.
182// @return true if a match was found.
nikoa64c8c72009-07-20 15:07:26 -0700183bool findMetadata(const Metadata::Filter& filter, const int32_t val)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700184{
185 // Deal with empty and ANY right away
186 if (filter.isEmpty()) return false;
nikoa64c8c72009-07-20 15:07:26 -0700187 if (filter[0] == Metadata::kAny) return true;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700188
Nicolas Catania48290382009-07-10 13:53:06 -0700189 return filter.indexOf(val) >= 0;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700190}
191
192} // anonymous namespace
193
194
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700195namespace {
196using android::Parcel;
197using android::String16;
198
199// marshalling tag indicating flattened utf16 tags
200// keep in sync with frameworks/base/media/java/android/media/AudioAttributes.java
201const int32_t kAudioAttributesMarshallTagFlattenTags = 1;
202
203// Audio attributes format in a parcel:
204//
205// 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
206// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
207// | usage |
208// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
209// | content_type |
210// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Hyejin Kim4f418f92014-09-05 15:50:03 +0900211// | source |
212// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700213// | flags |
214// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
215// | kAudioAttributesMarshallTagFlattenTags | // ignore tags if not found
216// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
217// | flattened tags in UTF16 |
218// | ... |
219// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
220//
221// @param p Parcel that contains audio attributes.
222// @param[out] attributes On exit points to an initialized audio_attributes_t structure
223// @param[out] status On exit contains the status code to be returned.
224void unmarshallAudioAttributes(const Parcel& parcel, audio_attributes_t *attributes)
225{
226 attributes->usage = (audio_usage_t) parcel.readInt32();
227 attributes->content_type = (audio_content_type_t) parcel.readInt32();
Hyejin Kim4f418f92014-09-05 15:50:03 +0900228 attributes->source = (audio_source_t) parcel.readInt32();
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700229 attributes->flags = (audio_flags_mask_t) parcel.readInt32();
230 const bool hasFlattenedTag = (parcel.readInt32() == kAudioAttributesMarshallTagFlattenTags);
231 if (hasFlattenedTag) {
232 // the tags are UTF16, convert to UTF8
233 String16 tags = parcel.readString16();
234 ssize_t realTagSize = utf16_to_utf8_length(tags.string(), tags.size());
235 if (realTagSize <= 0) {
236 strcpy(attributes->tags, "");
237 } else {
238 // copy the flattened string into the attributes as the destination for the conversion:
239 // copying array size -1, array for tags was calloc'd, no need to NULL-terminate it
240 size_t tagSize = realTagSize > AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1 ?
241 AUDIO_ATTRIBUTES_TAGS_MAX_SIZE - 1 : realTagSize;
Sergio Giro1d3f4272016-06-28 18:24:52 +0100242 utf16_to_utf8(tags.string(), tagSize, attributes->tags,
243 sizeof(attributes->tags) / sizeof(attributes->tags[0]));
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700244 }
245 } else {
246 ALOGE("unmarshallAudioAttributes() received unflattened tags, ignoring tag values");
247 strcpy(attributes->tags, "");
248 }
249}
250} // anonymous namespace
251
252
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800253namespace android {
254
Marco Nelissenf09611f2015-02-13 14:12:42 -0800255extern ALooperRoster gLooperRoster;
256
257
Dave Burked681bbb2011-08-30 14:39:17 +0100258static bool checkPermission(const char* permissionString) {
Dave Burked681bbb2011-08-30 14:39:17 +0100259 if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
260 bool ok = checkCallingPermission(String16(permissionString));
Steve Block29357bc2012-01-06 19:20:56 +0000261 if (!ok) ALOGE("Request requires %s", permissionString);
Dave Burked681bbb2011-08-30 14:39:17 +0100262 return ok;
263}
264
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800265// 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 -0800266/* static */ int MediaPlayerService::AudioOutput::mMinBufferCount = 4;
267/* static */ bool MediaPlayerService::AudioOutput::mIsOnEmulator = false;
268
269void MediaPlayerService::instantiate() {
270 defaultServiceManager()->addService(
271 String16("media.player"), new MediaPlayerService());
272}
273
274MediaPlayerService::MediaPlayerService()
275{
Steve Block3856b092011-10-20 11:56:00 +0100276 ALOGV("MediaPlayerService created");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800277 mNextConnId = 1;
Gloria Wang9ee159b2011-02-24 14:51:45 -0800278
John Grossman44a7e422012-06-21 17:29:24 -0700279 MediaPlayerFactory::registerBuiltinFactories();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800280}
281
282MediaPlayerService::~MediaPlayerService()
283{
Steve Block3856b092011-10-20 11:56:00 +0100284 ALOGV("MediaPlayerService destroyed");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800285}
286
Svet Ganovbe71aa22015-04-28 12:06:02 -0700287sp<IMediaRecorder> MediaPlayerService::createMediaRecorder(const String16 &opPackageName)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800288{
Glenn Kastenf37971f2012-02-03 11:06:53 -0800289 pid_t pid = IPCThreadState::self()->getCallingPid();
Svet Ganovbe71aa22015-04-28 12:06:02 -0700290 sp<MediaRecorderClient> recorder = new MediaRecorderClient(this, pid, opPackageName);
Gloria Wangdac6a312009-10-29 15:46:37 -0700291 wp<MediaRecorderClient> w = recorder;
292 Mutex::Autolock lock(mLock);
293 mMediaRecorderClients.add(w);
Steve Block3856b092011-10-20 11:56:00 +0100294 ALOGV("Create new media recorder client from pid %d", pid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800295 return recorder;
296}
297
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700298void MediaPlayerService::removeMediaRecorderClient(const wp<MediaRecorderClient>& client)
Gloria Wangdac6a312009-10-29 15:46:37 -0700299{
300 Mutex::Autolock lock(mLock);
301 mMediaRecorderClients.remove(client);
Steve Block3856b092011-10-20 11:56:00 +0100302 ALOGV("Delete media recorder client");
Gloria Wangdac6a312009-10-29 15:46:37 -0700303}
304
Glenn Kastenf37971f2012-02-03 11:06:53 -0800305sp<IMediaMetadataRetriever> MediaPlayerService::createMetadataRetriever()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800306{
Glenn Kastenf37971f2012-02-03 11:06:53 -0800307 pid_t pid = IPCThreadState::self()->getCallingPid();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800308 sp<MetadataRetrieverClient> retriever = new MetadataRetrieverClient(pid);
Steve Block3856b092011-10-20 11:56:00 +0100309 ALOGV("Create new media retriever from pid %d", pid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800310 return retriever;
311}
312
Glenn Kastenf37971f2012-02-03 11:06:53 -0800313sp<IMediaPlayer> MediaPlayerService::create(const sp<IMediaPlayerClient>& client,
Glenn Kastend848eb42016-03-08 13:42:11 -0800314 audio_session_t audioSessionId)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800315{
Glenn Kastenf37971f2012-02-03 11:06:53 -0800316 pid_t pid = IPCThreadState::self()->getCallingPid();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800317 int32_t connId = android_atomic_inc(&mNextConnId);
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700318
319 sp<Client> c = new Client(
320 this, pid, connId, client, audioSessionId,
321 IPCThreadState::self()->getCallingUid());
322
Steve Block3856b092011-10-20 11:56:00 +0100323 ALOGV("Create new client(%d) from pid %d, uid %d, ", connId, pid,
Dave Burked681bbb2011-08-30 14:39:17 +0100324 IPCThreadState::self()->getCallingUid());
325
326 wp<Client> w = c;
327 {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800328 Mutex::Autolock lock(mLock);
329 mClients.add(w);
330 }
Andreas Hubere2b10282010-11-23 11:41:34 -0800331 return c;
332}
333
Lajos Molnar1381d4b2014-08-07 15:18:35 -0700334sp<IMediaCodecList> MediaPlayerService::getCodecList() const {
335 return MediaCodecList::getLocalInstance();
336}
337
Jeff Brown2013a542012-09-04 21:38:42 -0700338sp<IRemoteDisplay> MediaPlayerService::listenForRemoteDisplay(
Chong Zhangd0a98fa2017-09-14 17:43:10 -0700339 const String16 &/*opPackageName*/,
340 const sp<IRemoteDisplayClient>& /*client*/,
341 const String8& /*iface*/) {
342 ALOGE("listenForRemoteDisplay is no longer supported!");
Jeff Brownaba33d52012-09-07 17:38:58 -0700343
Chong Zhangd0a98fa2017-09-14 17:43:10 -0700344 return NULL;
Jeff Brown2013a542012-09-04 21:38:42 -0700345}
346
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800347status_t MediaPlayerService::AudioOutput::dump(int fd, const Vector<String16>& args) const
348{
349 const size_t SIZE = 256;
350 char buffer[SIZE];
351 String8 result;
352
353 result.append(" AudioOutput\n");
354 snprintf(buffer, 255, " stream type(%d), left - right volume(%f, %f)\n",
355 mStreamType, mLeftVolume, mRightVolume);
356 result.append(buffer);
357 snprintf(buffer, 255, " msec per frame(%f), latency (%d)\n",
Eric Laurentdb354e52012-03-05 17:27:11 -0800358 mMsecsPerFrame, (mTrack != 0) ? mTrack->latency() : -1);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800359 result.append(buffer);
Eric Laurent2beeb502010-07-16 07:43:46 -0700360 snprintf(buffer, 255, " aux effect id(%d), send level (%f)\n",
361 mAuxEffectId, mSendLevel);
362 result.append(buffer);
363
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800364 ::write(fd, result.string(), result.size());
365 if (mTrack != 0) {
366 mTrack->dump(fd, args);
367 }
368 return NO_ERROR;
369}
370
Lajos Molnar6d339f12015-04-17 16:15:53 -0700371status_t MediaPlayerService::Client::dump(int fd, const Vector<String16>& args)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800372{
373 const size_t SIZE = 256;
374 char buffer[SIZE];
375 String8 result;
376 result.append(" Client\n");
377 snprintf(buffer, 255, " pid(%d), connId(%d), status(%d), looping(%s)\n",
378 mPid, mConnId, mStatus, mLoop?"true": "false");
379 result.append(buffer);
Wei Jia502c2f42017-07-13 17:47:56 -0700380
381 sp<MediaPlayerBase> p;
382 sp<AudioOutput> audioOutput;
383 bool locked = false;
384 for (int i = 0; i < kDumpLockRetries; ++i) {
385 if (mLock.tryLock() == NO_ERROR) {
386 locked = true;
387 break;
388 }
389 usleep(kDumpLockSleepUs);
Andreas Hubera0b1d4b2011-06-07 15:52:25 -0700390 }
Wei Jia502c2f42017-07-13 17:47:56 -0700391
392 if (locked) {
393 p = mPlayer;
394 audioOutput = mAudioOutput;
395 mLock.unlock();
396 } else {
397 result.append(" lock is taken, no dump from player and audio output\n");
398 }
399 write(fd, result.string(), result.size());
400
401 if (p != NULL) {
402 p->dump(fd, args);
403 }
404 if (audioOutput != 0) {
405 audioOutput->dump(fd, args);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800406 }
407 write(fd, "\n", 1);
408 return NO_ERROR;
409}
410
Marco Nelissenf09611f2015-02-13 14:12:42 -0800411/**
412 * The only arguments this understands right now are -c, -von and -voff,
413 * which are parsed by ALooperRoster::dump()
414 */
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800415status_t MediaPlayerService::dump(int fd, const Vector<String16>& args)
416{
417 const size_t SIZE = 256;
418 char buffer[SIZE];
419 String8 result;
Ravi Kumar Alamanda330c8e32014-12-22 10:05:29 +0530420 SortedVector< sp<Client> > clients; //to serialise the mutex unlock & client destruction.
421 SortedVector< sp<MediaRecorderClient> > mediaRecorderClients;
422
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800423 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
424 snprintf(buffer, SIZE, "Permission Denial: "
425 "can't dump MediaPlayerService from pid=%d, uid=%d\n",
426 IPCThreadState::self()->getCallingPid(),
427 IPCThreadState::self()->getCallingUid());
428 result.append(buffer);
429 } else {
430 Mutex::Autolock lock(mLock);
431 for (int i = 0, n = mClients.size(); i < n; ++i) {
432 sp<Client> c = mClients[i].promote();
433 if (c != 0) c->dump(fd, args);
Ravi Kumar Alamanda330c8e32014-12-22 10:05:29 +0530434 clients.add(c);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800435 }
James Dongb9141222010-07-08 11:16:11 -0700436 if (mMediaRecorderClients.size() == 0) {
437 result.append(" No media recorder client\n\n");
438 } else {
439 for (int i = 0, n = mMediaRecorderClients.size(); i < n; ++i) {
440 sp<MediaRecorderClient> c = mMediaRecorderClients[i].promote();
James Donge579e282011-10-18 22:29:20 -0700441 if (c != 0) {
442 snprintf(buffer, 255, " MediaRecorderClient pid(%d)\n", c->mPid);
443 result.append(buffer);
444 write(fd, result.string(), result.size());
445 result = "\n";
446 c->dump(fd, args);
Ravi Kumar Alamanda330c8e32014-12-22 10:05:29 +0530447 mediaRecorderClients.add(c);
James Donge579e282011-10-18 22:29:20 -0700448 }
James Dongb9141222010-07-08 11:16:11 -0700449 }
Gloria Wangdac6a312009-10-29 15:46:37 -0700450 }
451
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800452 result.append(" Files opened and/or mapped:\n");
Marco Nelissenf09611f2015-02-13 14:12:42 -0800453 snprintf(buffer, SIZE, "/proc/%d/maps", getpid());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800454 FILE *f = fopen(buffer, "r");
455 if (f) {
456 while (!feof(f)) {
457 fgets(buffer, SIZE, f);
Marco Nelissen73ac1ee2012-05-07 15:36:32 -0700458 if (strstr(buffer, " /storage/") ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800459 strstr(buffer, " /system/sounds/") ||
Dave Sparks02fa8342010-09-27 16:55:18 -0700460 strstr(buffer, " /data/") ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800461 strstr(buffer, " /system/media/")) {
462 result.append(" ");
463 result.append(buffer);
464 }
465 }
466 fclose(f);
467 } else {
468 result.append("couldn't open ");
469 result.append(buffer);
470 result.append("\n");
471 }
472
Marco Nelissenf09611f2015-02-13 14:12:42 -0800473 snprintf(buffer, SIZE, "/proc/%d/fd", getpid());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800474 DIR *d = opendir(buffer);
475 if (d) {
476 struct dirent *ent;
477 while((ent = readdir(d)) != NULL) {
478 if (strcmp(ent->d_name,".") && strcmp(ent->d_name,"..")) {
Marco Nelissenf09611f2015-02-13 14:12:42 -0800479 snprintf(buffer, SIZE, "/proc/%d/fd/%s", getpid(), ent->d_name);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800480 struct stat s;
481 if (lstat(buffer, &s) == 0) {
482 if ((s.st_mode & S_IFMT) == S_IFLNK) {
483 char linkto[256];
484 int len = readlink(buffer, linkto, sizeof(linkto));
485 if(len > 0) {
486 if(len > 255) {
487 linkto[252] = '.';
488 linkto[253] = '.';
489 linkto[254] = '.';
490 linkto[255] = 0;
491 } else {
492 linkto[len] = 0;
493 }
Marco Nelissen73ac1ee2012-05-07 15:36:32 -0700494 if (strstr(linkto, "/storage/") == linkto ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800495 strstr(linkto, "/system/sounds/") == linkto ||
Dave Sparks02fa8342010-09-27 16:55:18 -0700496 strstr(linkto, "/data/") == linkto ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800497 strstr(linkto, "/system/media/") == linkto) {
498 result.append(" ");
499 result.append(buffer);
500 result.append(" -> ");
501 result.append(linkto);
502 result.append("\n");
503 }
504 }
505 } else {
506 result.append(" unexpected type for ");
507 result.append(buffer);
508 result.append("\n");
509 }
510 }
511 }
512 }
513 closedir(d);
514 } else {
515 result.append("couldn't open ");
516 result.append(buffer);
517 result.append("\n");
518 }
519
Marco Nelissenf09611f2015-02-13 14:12:42 -0800520 gLooperRoster.dump(fd, args);
521
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800522 bool dumpMem = false;
Andy Hung53541292016-04-13 16:48:51 -0700523 bool unreachableMemory = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800524 for (size_t i = 0; i < args.size(); i++) {
525 if (args[i] == String16("-m")) {
526 dumpMem = true;
Andy Hung53541292016-04-13 16:48:51 -0700527 } else if (args[i] == String16("--unreachable")) {
528 unreachableMemory = true;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800529 }
530 }
531 if (dumpMem) {
Andy Hung07b745e2016-05-23 16:21:07 -0700532 result.append("\nDumping memory:\n");
533 std::string s = dumpMemoryAddresses(100 /* limit */);
534 result.append(s.c_str(), s.size());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800535 }
Andy Hung53541292016-04-13 16:48:51 -0700536 if (unreachableMemory) {
537 result.append("\nDumping unreachable memory:\n");
538 // TODO - should limit be an argument parameter?
539 std::string s = GetUnreachableMemoryString(true /* contents */, 10000 /* limit */);
540 result.append(s.c_str(), s.size());
541 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800542 }
543 write(fd, result.string(), result.size());
544 return NO_ERROR;
545}
546
Chih-Hung Hsieh36d0ca12016-08-09 14:31:32 -0700547void MediaPlayerService::removeClient(const wp<Client>& client)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800548{
549 Mutex::Autolock lock(mLock);
550 mClients.remove(client);
551}
552
Robert Shihee0a0e32016-08-16 16:50:54 -0700553bool MediaPlayerService::hasClient(wp<Client> client)
554{
555 Mutex::Autolock lock(mLock);
556 return mClients.indexOf(client) != NAME_NOT_FOUND;
557}
558
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700559MediaPlayerService::Client::Client(
560 const sp<MediaPlayerService>& service, pid_t pid,
561 int32_t connId, const sp<IMediaPlayerClient>& client,
Glenn Kastend848eb42016-03-08 13:42:11 -0800562 audio_session_t audioSessionId, uid_t uid)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800563{
Steve Block3856b092011-10-20 11:56:00 +0100564 ALOGV("Client(%d) constructor", connId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800565 mPid = pid;
566 mConnId = connId;
567 mService = service;
568 mClient = client;
569 mLoop = false;
570 mStatus = NO_INIT;
Eric Laurenta514bdb2010-06-21 09:27:30 -0700571 mAudioSessionId = audioSessionId;
Andy Hung1afd0982016-11-08 16:13:44 -0800572 mUid = uid;
John Grossmanc795b642012-02-22 15:38:35 -0800573 mRetransmitEndpointValid = false;
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700574 mAudioAttributes = NULL;
Eric Laurenta514bdb2010-06-21 09:27:30 -0700575
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800576#if CALLBACK_ANTAGONIZER
Steve Blockb8a80522011-12-20 16:23:08 +0000577 ALOGD("create Antagonizer");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800578 mAntagonizer = new Antagonizer(notify, this);
579#endif
580}
581
582MediaPlayerService::Client::~Client()
583{
Steve Block3856b092011-10-20 11:56:00 +0100584 ALOGV("Client(%d) destructor pid = %d", mConnId, mPid);
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700585 mAudioOutput.clear();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800586 wp<Client> client(this);
587 disconnect();
588 mService->removeClient(client);
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -0700589 if (mAudioAttributes != NULL) {
590 free(mAudioAttributes);
591 }
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700592 clearDeathNotifiers_l();
jiabin156c6872017-10-06 09:47:15 -0700593 mAudioDeviceUpdatedListener.clear();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800594}
595
596void MediaPlayerService::Client::disconnect()
597{
Steve Block3856b092011-10-20 11:56:00 +0100598 ALOGV("disconnect(%d) from pid %d", mConnId, mPid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800599 // grab local reference and clear main reference to prevent future
600 // access to object
601 sp<MediaPlayerBase> p;
602 {
603 Mutex::Autolock l(mLock);
604 p = mPlayer;
beanzdcfefde2012-11-05 09:51:43 +0800605 mClient.clear();
Wei Jia502c2f42017-07-13 17:47:56 -0700606 mPlayer.clear();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800607 }
Andreas Huber20111aa2009-07-14 16:56:47 -0700608
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800609 // clear the notification to prevent callbacks to dead client
610 // and reset the player. We assume the player will serialize
611 // access to itself if necessary.
612 if (p != 0) {
613 p->setNotifyCallback(0, 0);
614#if CALLBACK_ANTAGONIZER
Steve Blockb8a80522011-12-20 16:23:08 +0000615 ALOGD("kill Antagonizer");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800616 mAntagonizer->kill();
617#endif
618 p->reset();
619 }
620
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700621 {
622 Mutex::Autolock l(mLock);
623 disconnectNativeWindow_l();
624 }
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700625
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800626 IPCThreadState::self()->flushCommands();
627}
628
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800629sp<MediaPlayerBase> MediaPlayerService::Client::createPlayer(player_type playerType)
630{
631 // determine if we have the right player type
Wei Jia502c2f42017-07-13 17:47:56 -0700632 sp<MediaPlayerBase> p = getPlayer();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800633 if ((p != NULL) && (p->playerType() != playerType)) {
Steve Block3856b092011-10-20 11:56:00 +0100634 ALOGV("delete player");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800635 p.clear();
636 }
637 if (p == NULL) {
Ronghua Wu68845c12015-07-21 09:50:48 -0700638 p = MediaPlayerFactory::createPlayer(playerType, this, notify, mPid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800639 }
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700640
Jason Simmonsdb29e522011-08-12 13:46:55 -0700641 if (p != NULL) {
Andy Hung1afd0982016-11-08 16:13:44 -0800642 p->setUID(mUid);
Jason Simmonsdb29e522011-08-12 13:46:55 -0700643 }
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700644
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800645 return p;
646}
647
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700648MediaPlayerService::Client::ServiceDeathNotifier::ServiceDeathNotifier(
649 const sp<IBinder>& service,
650 const sp<MediaPlayerBase>& listener,
651 int which) {
652 mService = service;
Pawin Vongmasa9c47c972017-02-08 04:09:38 -0800653 mOmx = nullptr;
654 mListener = listener;
655 mWhich = which;
656}
657
658MediaPlayerService::Client::ServiceDeathNotifier::ServiceDeathNotifier(
659 const sp<IOmx>& omx,
660 const sp<MediaPlayerBase>& listener,
661 int which) {
662 mService = nullptr;
663 mOmx = omx;
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700664 mListener = listener;
665 mWhich = which;
666}
667
668MediaPlayerService::Client::ServiceDeathNotifier::~ServiceDeathNotifier() {
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700669}
670
671void MediaPlayerService::Client::ServiceDeathNotifier::binderDied(const wp<IBinder>& /*who*/) {
672 sp<MediaPlayerBase> listener = mListener.promote();
673 if (listener != NULL) {
674 listener->sendEvent(MEDIA_ERROR, MEDIA_ERROR_SERVER_DIED, mWhich);
675 } else {
676 ALOGW("listener for process %d death is gone", mWhich);
677 }
678}
679
Pawin Vongmasa9c47c972017-02-08 04:09:38 -0800680void MediaPlayerService::Client::ServiceDeathNotifier::serviceDied(
681 uint64_t /* cookie */,
682 const wp<::android::hidl::base::V1_0::IBase>& /* who */) {
683 sp<MediaPlayerBase> listener = mListener.promote();
684 if (listener != NULL) {
685 listener->sendEvent(MEDIA_ERROR, MEDIA_ERROR_SERVER_DIED, mWhich);
686 } else {
687 ALOGW("listener for process %d death is gone", mWhich);
688 }
689}
690
691void MediaPlayerService::Client::ServiceDeathNotifier::unlinkToDeath() {
692 if (mService != nullptr) {
693 mService->unlinkToDeath(this);
694 mService = nullptr;
695 } else if (mOmx != nullptr) {
696 mOmx->unlinkToDeath(this);
697 mOmx = nullptr;
698 }
699}
700
jiabin156c6872017-10-06 09:47:15 -0700701void MediaPlayerService::Client::AudioDeviceUpdatedNotifier::onAudioDeviceUpdate(
702 audio_io_handle_t audioIo,
703 audio_port_handle_t deviceId) {
704 sp<MediaPlayerBase> listener = mListener.promote();
705 if (listener != NULL) {
706 listener->sendEvent(MEDIA_AUDIO_ROUTING_CHANGED, audioIo, deviceId);
707 } else {
708 ALOGW("listener for process %d death is gone", MEDIA_AUDIO_ROUTING_CHANGED);
709 }
710}
711
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700712void MediaPlayerService::Client::clearDeathNotifiers_l() {
Pawin Vongmasa9c47c972017-02-08 04:09:38 -0800713 if (mExtractorDeathListener != nullptr) {
714 mExtractorDeathListener->unlinkToDeath();
715 mExtractorDeathListener = nullptr;
716 }
717 if (mCodecDeathListener != nullptr) {
718 mCodecDeathListener->unlinkToDeath();
719 mCodecDeathListener = nullptr;
720 }
721}
722
John Grossmanc795b642012-02-22 15:38:35 -0800723sp<MediaPlayerBase> MediaPlayerService::Client::setDataSource_pre(
724 player_type playerType)
725{
726 ALOGV("player type = %d", playerType);
727
728 // create the right type of player
729 sp<MediaPlayerBase> p = createPlayer(playerType);
730 if (p == NULL) {
731 return p;
732 }
733
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700734 sp<IServiceManager> sm = defaultServiceManager();
735 sp<IBinder> binder = sm->getService(String16("media.extractor"));
Marco Nelissen1b5a7ee2016-09-30 13:54:30 -0700736 if (binder == NULL) {
737 ALOGE("extractor service not available");
738 return NULL;
739 }
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700740 sp<ServiceDeathNotifier> extractorDeathListener =
741 new ServiceDeathNotifier(binder, p, MEDIAEXTRACTOR_PROCESS_DEATH);
742 binder->linkToDeath(extractorDeathListener);
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700743
Pawin Vongmasa620e4662017-10-27 00:12:47 -0700744 sp<IOmx> omx = IOmx::getService();
745 if (omx == nullptr) {
746 ALOGE("IOmx service is not available");
747 return NULL;
Marco Nelissen1b5a7ee2016-09-30 13:54:30 -0700748 }
Pawin Vongmasa620e4662017-10-27 00:12:47 -0700749 sp<ServiceDeathNotifier> codecDeathListener =
750 new ServiceDeathNotifier(omx, p, MEDIACODEC_PROCESS_DEATH);
751 omx->linkToDeath(codecDeathListener, 0);
Marco Nelissen6dc3a3e2016-04-29 15:42:06 -0700752
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700753 Mutex::Autolock lock(mLock);
754
755 clearDeathNotifiers_l();
756 mExtractorDeathListener = extractorDeathListener;
757 mCodecDeathListener = codecDeathListener;
jiabin156c6872017-10-06 09:47:15 -0700758 mAudioDeviceUpdatedListener = new AudioDeviceUpdatedNotifier(p);
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700759
John Grossmanc795b642012-02-22 15:38:35 -0800760 if (!p->hardwareOutput()) {
Marco Nelissend457c972014-02-11 08:47:07 -0800761 mAudioOutput = new AudioOutput(mAudioSessionId, IPCThreadState::self()->getCallingUid(),
jiabin156c6872017-10-06 09:47:15 -0700762 mPid, mAudioAttributes, mAudioDeviceUpdatedListener);
John Grossmanc795b642012-02-22 15:38:35 -0800763 static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
764 }
765
766 return p;
767}
768
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700769status_t MediaPlayerService::Client::setDataSource_post(
John Grossmanc795b642012-02-22 15:38:35 -0800770 const sp<MediaPlayerBase>& p,
771 status_t status)
772{
773 ALOGV(" setDataSource");
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700774 if (status != OK) {
775 ALOGE(" error: %d", status);
776 return status;
John Grossmanc795b642012-02-22 15:38:35 -0800777 }
778
779 // Set the re-transmission endpoint if one was chosen.
780 if (mRetransmitEndpointValid) {
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700781 status = p->setRetransmitEndpoint(&mRetransmitEndpoint);
782 if (status != NO_ERROR) {
783 ALOGE("setRetransmitEndpoint error: %d", status);
John Grossmanc795b642012-02-22 15:38:35 -0800784 }
785 }
786
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700787 if (status == OK) {
788 Mutex::Autolock lock(mLock);
John Grossmanc795b642012-02-22 15:38:35 -0800789 mPlayer = p;
790 }
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700791 return status;
John Grossmanc795b642012-02-22 15:38:35 -0800792}
793
Andreas Huber2db84552010-01-28 11:19:57 -0800794status_t MediaPlayerService::Client::setDataSource(
Andreas Huber1b86fe02014-01-29 11:13:26 -0800795 const sp<IMediaHTTPService> &httpService,
796 const char *url,
797 const KeyedVector<String8, String8> *headers)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800798{
Steve Block3856b092011-10-20 11:56:00 +0100799 ALOGV("setDataSource(%s)", url);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800800 if (url == NULL)
801 return UNKNOWN_ERROR;
802
Dave Burked681bbb2011-08-30 14:39:17 +0100803 if ((strncmp(url, "http://", 7) == 0) ||
804 (strncmp(url, "https://", 8) == 0) ||
805 (strncmp(url, "rtsp://", 7) == 0)) {
806 if (!checkPermission("android.permission.INTERNET")) {
807 return PERMISSION_DENIED;
808 }
809 }
810
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800811 if (strncmp(url, "content://", 10) == 0) {
812 // get a filedescriptor for the content Uri and
813 // pass it to the setDataSource(fd) method
814
815 String16 url16(url);
816 int fd = android::openContentProviderFile(url16);
817 if (fd < 0)
818 {
Steve Block29357bc2012-01-06 19:20:56 +0000819 ALOGE("Couldn't open fd for %s", url);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800820 return UNKNOWN_ERROR;
821 }
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700822 status_t status = setDataSource(fd, 0, 0x7fffffffffLL); // this sets mStatus
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800823 close(fd);
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700824 return mStatus = status;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800825 } else {
John Grossman44a7e422012-06-21 17:29:24 -0700826 player_type playerType = MediaPlayerFactory::getPlayerType(this, url);
John Grossmanc795b642012-02-22 15:38:35 -0800827 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
828 if (p == NULL) {
829 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800830 }
831
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700832 return mStatus =
833 setDataSource_post(
834 p, p->setDataSource(httpService, url, headers));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800835 }
836}
837
838status_t MediaPlayerService::Client::setDataSource(int fd, int64_t offset, int64_t length)
839{
Marco Nelissen83b0fd92015-09-16 13:48:07 -0700840 ALOGV("setDataSource fd=%d (%s), offset=%lld, length=%lld",
841 fd, nameForFd(fd).c_str(), (long long) offset, (long long) length);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800842 struct stat sb;
843 int ret = fstat(fd, &sb);
844 if (ret != 0) {
Steve Block29357bc2012-01-06 19:20:56 +0000845 ALOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800846 return UNKNOWN_ERROR;
847 }
848
Andy Hung833b4752016-04-04 17:15:48 -0700849 ALOGV("st_dev = %llu", static_cast<unsigned long long>(sb.st_dev));
Steve Block3856b092011-10-20 11:56:00 +0100850 ALOGV("st_mode = %u", sb.st_mode);
Mark Salyzyn77342f72014-06-18 16:31:32 -0700851 ALOGV("st_uid = %lu", static_cast<unsigned long>(sb.st_uid));
852 ALOGV("st_gid = %lu", static_cast<unsigned long>(sb.st_gid));
Andy Hung833b4752016-04-04 17:15:48 -0700853 ALOGV("st_size = %llu", static_cast<unsigned long long>(sb.st_size));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800854
855 if (offset >= sb.st_size) {
Steve Block29357bc2012-01-06 19:20:56 +0000856 ALOGE("offset error");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800857 return UNKNOWN_ERROR;
858 }
859 if (offset + length > sb.st_size) {
860 length = sb.st_size - offset;
Andy Hung833b4752016-04-04 17:15:48 -0700861 ALOGV("calculated length = %lld", (long long)length);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800862 }
863
John Grossman44a7e422012-06-21 17:29:24 -0700864 player_type playerType = MediaPlayerFactory::getPlayerType(this,
865 fd,
866 offset,
867 length);
John Grossmanc795b642012-02-22 15:38:35 -0800868 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
869 if (p == NULL) {
870 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800871 }
872
873 // now set data source
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700874 return mStatus = setDataSource_post(p, p->setDataSource(fd, offset, length));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800875}
876
Andreas Hubere2b10282010-11-23 11:41:34 -0800877status_t MediaPlayerService::Client::setDataSource(
878 const sp<IStreamSource> &source) {
879 // create the right type of player
John Grossman44a7e422012-06-21 17:29:24 -0700880 player_type playerType = MediaPlayerFactory::getPlayerType(this, source);
John Grossmanc795b642012-02-22 15:38:35 -0800881 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
Andreas Hubere2b10282010-11-23 11:41:34 -0800882 if (p == NULL) {
883 return NO_INIT;
884 }
885
Andreas Hubere2b10282010-11-23 11:41:34 -0800886 // now set data source
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700887 return mStatus = setDataSource_post(p, p->setDataSource(source));
Andreas Hubere2b10282010-11-23 11:41:34 -0800888}
889
Chris Watkins99f31602015-03-20 13:06:33 -0700890status_t MediaPlayerService::Client::setDataSource(
891 const sp<IDataSource> &source) {
Dongwon Kangd91dc5a2017-10-10 00:07:09 -0700892 sp<DataSource> dataSource = CreateDataSourceFromIDataSource(source);
Chris Watkins99f31602015-03-20 13:06:33 -0700893 player_type playerType = MediaPlayerFactory::getPlayerType(this, dataSource);
894 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
895 if (p == NULL) {
896 return NO_INIT;
897 }
898 // now set data source
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700899 return mStatus = setDataSource_post(p, p->setDataSource(dataSource));
Chris Watkins99f31602015-03-20 13:06:33 -0700900}
901
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700902void MediaPlayerService::Client::disconnectNativeWindow_l() {
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700903 if (mConnectedWindow != NULL) {
Chong Zhang181fd9b2017-02-16 15:53:03 -0800904 status_t err = nativeWindowDisconnect(
905 mConnectedWindow.get(), "disconnectNativeWindow");
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700906
907 if (err != OK) {
Chong Zhang181fd9b2017-02-16 15:53:03 -0800908 ALOGW("nativeWindowDisconnect returned an error: %s (%d)",
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700909 strerror(-err), err);
910 }
911 }
912 mConnectedWindow.clear();
913}
914
Glenn Kasten11731182011-02-08 17:26:17 -0800915status_t MediaPlayerService::Client::setVideoSurfaceTexture(
Andy McFadden484566c2012-12-18 09:46:54 -0800916 const sp<IGraphicBufferProducer>& bufferProducer)
Glenn Kasten11731182011-02-08 17:26:17 -0800917{
Andy McFadden484566c2012-12-18 09:46:54 -0800918 ALOGV("[%d] setVideoSurfaceTexture(%p)", mConnId, bufferProducer.get());
Glenn Kasten11731182011-02-08 17:26:17 -0800919 sp<MediaPlayerBase> p = getPlayer();
920 if (p == 0) return UNKNOWN_ERROR;
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700921
Marco Nelissenf8880202014-11-14 07:58:25 -0800922 sp<IBinder> binder(IInterface::asBinder(bufferProducer));
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700923 if (mConnectedWindowBinder == binder) {
924 return OK;
925 }
926
927 sp<ANativeWindow> anw;
Andy McFadden484566c2012-12-18 09:46:54 -0800928 if (bufferProducer != NULL) {
Marco Nelissenee08f7e2013-09-16 13:30:01 -0700929 anw = new Surface(bufferProducer, true /* controlledByApp */);
Chong Zhang181fd9b2017-02-16 15:53:03 -0800930 status_t err = nativeWindowConnect(anw.get(), "setVideoSurfaceTexture");
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700931
932 if (err != OK) {
Steve Block29357bc2012-01-06 19:20:56 +0000933 ALOGE("setVideoSurfaceTexture failed: %d", err);
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700934 // Note that we must do the reset before disconnecting from the ANW.
935 // Otherwise queue/dequeue calls could be made on the disconnected
936 // ANW, which may result in errors.
937 reset();
938
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700939 Mutex::Autolock lock(mLock);
940 disconnectNativeWindow_l();
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700941
942 return err;
943 }
944 }
945
Andy McFadden484566c2012-12-18 09:46:54 -0800946 // Note that we must set the player's new GraphicBufferProducer before
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700947 // disconnecting the old one. Otherwise queue/dequeue calls could be made
948 // on the disconnected ANW, which may result in errors.
Andy McFadden484566c2012-12-18 09:46:54 -0800949 status_t err = p->setVideoSurfaceTexture(bufferProducer);
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700950
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700951 mLock.lock();
952 disconnectNativeWindow_l();
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700953
954 if (err == OK) {
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700955 mConnectedWindow = anw;
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700956 mConnectedWindowBinder = binder;
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700957 mLock.unlock();
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700958 } else {
Pawin Vongmasaf9c81462017-09-28 05:31:11 -0700959 mLock.unlock();
960 status_t err = nativeWindowDisconnect(
961 anw.get(), "disconnectNativeWindow");
962
963 if (err != OK) {
964 ALOGW("nativeWindowDisconnect returned an error: %s (%d)",
965 strerror(-err), err);
966 }
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700967 }
968
969 return err;
Glenn Kasten11731182011-02-08 17:26:17 -0800970}
971
Nicolas Catania1d187f12009-05-12 23:25:55 -0700972status_t MediaPlayerService::Client::invoke(const Parcel& request,
973 Parcel *reply)
974{
975 sp<MediaPlayerBase> p = getPlayer();
976 if (p == NULL) return UNKNOWN_ERROR;
977 return p->invoke(request, reply);
978}
979
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700980// This call doesn't need to access the native player.
981status_t MediaPlayerService::Client::setMetadataFilter(const Parcel& filter)
982{
983 status_t status;
nikoa64c8c72009-07-20 15:07:26 -0700984 media::Metadata::Filter allow, drop;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700985
Nicolas Catania48290382009-07-10 13:53:06 -0700986 if (unmarshallFilter(filter, &allow, &status) &&
987 unmarshallFilter(filter, &drop, &status)) {
988 Mutex::Autolock lock(mLock);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700989
990 mMetadataAllow = allow;
991 mMetadataDrop = drop;
992 }
993 return status;
994}
995
Nicolas Catania48290382009-07-10 13:53:06 -0700996status_t MediaPlayerService::Client::getMetadata(
Mark Salyzyn77342f72014-06-18 16:31:32 -0700997 bool update_only, bool /*apply_filter*/, Parcel *reply)
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -0700998{
nikoa64c8c72009-07-20 15:07:26 -0700999 sp<MediaPlayerBase> player = getPlayer();
1000 if (player == 0) return UNKNOWN_ERROR;
Nicolas Catania48290382009-07-10 13:53:06 -07001001
nikod608a812009-07-16 16:39:53 -07001002 status_t status;
1003 // Placeholder for the return code, updated by the caller.
1004 reply->writeInt32(-1);
1005
nikoa64c8c72009-07-20 15:07:26 -07001006 media::Metadata::Filter ids;
Nicolas Catania48290382009-07-10 13:53:06 -07001007
1008 // We don't block notifications while we fetch the data. We clear
1009 // mMetadataUpdated first so we don't lose notifications happening
1010 // during the rest of this call.
1011 {
1012 Mutex::Autolock lock(mLock);
1013 if (update_only) {
nikod608a812009-07-16 16:39:53 -07001014 ids = mMetadataUpdated;
Nicolas Catania48290382009-07-10 13:53:06 -07001015 }
1016 mMetadataUpdated.clear();
1017 }
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -07001018
nikoa64c8c72009-07-20 15:07:26 -07001019 media::Metadata metadata(reply);
Nicolas Catania48290382009-07-10 13:53:06 -07001020
nikoa64c8c72009-07-20 15:07:26 -07001021 metadata.appendHeader();
1022 status = player->getMetadata(ids, reply);
nikod608a812009-07-16 16:39:53 -07001023
1024 if (status != OK) {
nikoa64c8c72009-07-20 15:07:26 -07001025 metadata.resetParcel();
Steve Block29357bc2012-01-06 19:20:56 +00001026 ALOGE("getMetadata failed %d", status);
nikod608a812009-07-16 16:39:53 -07001027 return status;
1028 }
1029
1030 // FIXME: Implement filtering on the result. Not critical since
1031 // filtering takes place on the update notifications already. This
1032 // would be when all the metadata are fetch and a filter is set.
1033
nikod608a812009-07-16 16:39:53 -07001034 // Everything is fine, update the metadata length.
nikoa64c8c72009-07-20 15:07:26 -07001035 metadata.updateLength();
nikod608a812009-07-16 16:39:53 -07001036 return OK;
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -07001037}
1038
Wei Jiad399e7e2016-10-26 15:49:11 -07001039status_t MediaPlayerService::Client::setBufferingSettings(
1040 const BufferingSettings& buffering)
1041{
Wei Jiadc6f3402017-01-09 15:04:18 -08001042 ALOGV("[%d] setBufferingSettings{%s}",
1043 mConnId, buffering.toString().string());
Wei Jiad399e7e2016-10-26 15:49:11 -07001044 sp<MediaPlayerBase> p = getPlayer();
1045 if (p == 0) return UNKNOWN_ERROR;
1046 return p->setBufferingSettings(buffering);
1047}
1048
1049status_t MediaPlayerService::Client::getDefaultBufferingSettings(
1050 BufferingSettings* buffering /* nonnull */)
1051{
1052 sp<MediaPlayerBase> p = getPlayer();
1053 // TODO: create mPlayer on demand.
1054 if (p == 0) return UNKNOWN_ERROR;
1055 status_t ret = p->getDefaultBufferingSettings(buffering);
1056 if (ret == NO_ERROR) {
Wei Jiadc6f3402017-01-09 15:04:18 -08001057 ALOGV("[%d] getDefaultBufferingSettings{%s}",
1058 mConnId, buffering->toString().string());
Wei Jiad399e7e2016-10-26 15:49:11 -07001059 } else {
1060 ALOGV("[%d] getDefaultBufferingSettings returned %d", mConnId, ret);
1061 }
1062 return ret;
1063}
1064
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001065status_t MediaPlayerService::Client::prepareAsync()
1066{
Steve Block3856b092011-10-20 11:56:00 +01001067 ALOGV("[%d] prepareAsync", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001068 sp<MediaPlayerBase> p = getPlayer();
1069 if (p == 0) return UNKNOWN_ERROR;
1070 status_t ret = p->prepareAsync();
1071#if CALLBACK_ANTAGONIZER
Steve Blockb8a80522011-12-20 16:23:08 +00001072 ALOGD("start Antagonizer");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001073 if (ret == NO_ERROR) mAntagonizer->start();
1074#endif
1075 return ret;
1076}
1077
1078status_t MediaPlayerService::Client::start()
1079{
Steve Block3856b092011-10-20 11:56:00 +01001080 ALOGV("[%d] start", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001081 sp<MediaPlayerBase> p = getPlayer();
1082 if (p == 0) return UNKNOWN_ERROR;
1083 p->setLooping(mLoop);
1084 return p->start();
1085}
1086
1087status_t MediaPlayerService::Client::stop()
1088{
Steve Block3856b092011-10-20 11:56:00 +01001089 ALOGV("[%d] stop", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001090 sp<MediaPlayerBase> p = getPlayer();
1091 if (p == 0) return UNKNOWN_ERROR;
1092 return p->stop();
1093}
1094
1095status_t MediaPlayerService::Client::pause()
1096{
Steve Block3856b092011-10-20 11:56:00 +01001097 ALOGV("[%d] pause", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001098 sp<MediaPlayerBase> p = getPlayer();
1099 if (p == 0) return UNKNOWN_ERROR;
1100 return p->pause();
1101}
1102
1103status_t MediaPlayerService::Client::isPlaying(bool* state)
1104{
1105 *state = false;
1106 sp<MediaPlayerBase> p = getPlayer();
1107 if (p == 0) return UNKNOWN_ERROR;
1108 *state = p->isPlaying();
Steve Block3856b092011-10-20 11:56:00 +01001109 ALOGV("[%d] isPlaying: %d", mConnId, *state);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001110 return NO_ERROR;
1111}
1112
Lajos Molnar3a474aa2015-04-24 17:10:07 -07001113status_t MediaPlayerService::Client::setPlaybackSettings(const AudioPlaybackRate& rate)
Wei Jia98160162015-02-04 17:01:11 -08001114{
Lajos Molnar3a474aa2015-04-24 17:10:07 -07001115 ALOGV("[%d] setPlaybackSettings(%f, %f, %d, %d)",
1116 mConnId, rate.mSpeed, rate.mPitch, rate.mFallbackMode, rate.mStretchMode);
Wei Jia98160162015-02-04 17:01:11 -08001117 sp<MediaPlayerBase> p = getPlayer();
1118 if (p == 0) return UNKNOWN_ERROR;
Lajos Molnar3a474aa2015-04-24 17:10:07 -07001119 return p->setPlaybackSettings(rate);
1120}
1121
1122status_t MediaPlayerService::Client::getPlaybackSettings(AudioPlaybackRate* rate /* nonnull */)
1123{
1124 sp<MediaPlayerBase> p = getPlayer();
1125 if (p == 0) return UNKNOWN_ERROR;
1126 status_t ret = p->getPlaybackSettings(rate);
1127 if (ret == NO_ERROR) {
1128 ALOGV("[%d] getPlaybackSettings(%f, %f, %d, %d)",
1129 mConnId, rate->mSpeed, rate->mPitch, rate->mFallbackMode, rate->mStretchMode);
1130 } else {
1131 ALOGV("[%d] getPlaybackSettings returned %d", mConnId, ret);
1132 }
1133 return ret;
1134}
1135
1136status_t MediaPlayerService::Client::setSyncSettings(
1137 const AVSyncSettings& sync, float videoFpsHint)
1138{
1139 ALOGV("[%d] setSyncSettings(%u, %u, %f, %f)",
1140 mConnId, sync.mSource, sync.mAudioAdjustMode, sync.mTolerance, videoFpsHint);
1141 sp<MediaPlayerBase> p = getPlayer();
1142 if (p == 0) return UNKNOWN_ERROR;
1143 return p->setSyncSettings(sync, videoFpsHint);
1144}
1145
1146status_t MediaPlayerService::Client::getSyncSettings(
1147 AVSyncSettings* sync /* nonnull */, float* videoFps /* nonnull */)
1148{
1149 sp<MediaPlayerBase> p = getPlayer();
1150 if (p == 0) return UNKNOWN_ERROR;
1151 status_t ret = p->getSyncSettings(sync, videoFps);
1152 if (ret == NO_ERROR) {
1153 ALOGV("[%d] getSyncSettings(%u, %u, %f, %f)",
1154 mConnId, sync->mSource, sync->mAudioAdjustMode, sync->mTolerance, *videoFps);
1155 } else {
1156 ALOGV("[%d] getSyncSettings returned %d", mConnId, ret);
1157 }
1158 return ret;
Wei Jia98160162015-02-04 17:01:11 -08001159}
1160
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001161status_t MediaPlayerService::Client::getCurrentPosition(int *msec)
1162{
Steve Block3856b092011-10-20 11:56:00 +01001163 ALOGV("getCurrentPosition");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001164 sp<MediaPlayerBase> p = getPlayer();
1165 if (p == 0) return UNKNOWN_ERROR;
1166 status_t ret = p->getCurrentPosition(msec);
1167 if (ret == NO_ERROR) {
Steve Block3856b092011-10-20 11:56:00 +01001168 ALOGV("[%d] getCurrentPosition = %d", mConnId, *msec);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001169 } else {
Steve Block29357bc2012-01-06 19:20:56 +00001170 ALOGE("getCurrentPosition returned %d", ret);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001171 }
1172 return ret;
1173}
1174
1175status_t MediaPlayerService::Client::getDuration(int *msec)
1176{
Steve Block3856b092011-10-20 11:56:00 +01001177 ALOGV("getDuration");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001178 sp<MediaPlayerBase> p = getPlayer();
1179 if (p == 0) return UNKNOWN_ERROR;
1180 status_t ret = p->getDuration(msec);
1181 if (ret == NO_ERROR) {
Steve Block3856b092011-10-20 11:56:00 +01001182 ALOGV("[%d] getDuration = %d", mConnId, *msec);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001183 } else {
Steve Block29357bc2012-01-06 19:20:56 +00001184 ALOGE("getDuration returned %d", ret);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001185 }
1186 return ret;
1187}
1188
Marco Nelissen6b74d672012-02-28 16:07:44 -08001189status_t MediaPlayerService::Client::setNextPlayer(const sp<IMediaPlayer>& player) {
1190 ALOGV("setNextPlayer");
1191 Mutex::Autolock l(mLock);
1192 sp<Client> c = static_cast<Client*>(player.get());
Wei Jia28284122016-08-30 13:49:06 -07001193 if (c != NULL && !mService->hasClient(c)) {
Robert Shihee0a0e32016-08-16 16:50:54 -07001194 return BAD_VALUE;
1195 }
1196
Marco Nelissen6b74d672012-02-28 16:07:44 -08001197 mNextClient = c;
John Grossman5f7e55e2012-08-24 14:47:25 -07001198
1199 if (c != NULL) {
1200 if (mAudioOutput != NULL) {
1201 mAudioOutput->setNextOutput(c->mAudioOutput);
1202 } else if ((mPlayer != NULL) && !mPlayer->hardwareOutput()) {
1203 ALOGE("no current audio output");
1204 }
1205
1206 if ((mPlayer != NULL) && (mNextClient->getPlayer() != NULL)) {
1207 mPlayer->setNextPlayer(mNextClient->getPlayer());
1208 }
Marco Nelissen6b74d672012-02-28 16:07:44 -08001209 }
John Grossman5f7e55e2012-08-24 14:47:25 -07001210
Marco Nelissen6b74d672012-02-28 16:07:44 -08001211 return OK;
1212}
1213
Andy Hung9fc8b5c2017-01-24 13:36:48 -08001214VolumeShaper::Status MediaPlayerService::Client::applyVolumeShaper(
1215 const sp<VolumeShaper::Configuration>& configuration,
1216 const sp<VolumeShaper::Operation>& operation) {
1217 // for hardware output, call player instead
1218 ALOGV("Client::applyVolumeShaper(%p)", this);
1219 sp<MediaPlayerBase> p = getPlayer();
1220 {
1221 Mutex::Autolock l(mLock);
1222 if (p != 0 && p->hardwareOutput()) {
1223 // TODO: investigate internal implementation
1224 return VolumeShaper::Status(INVALID_OPERATION);
1225 }
1226 if (mAudioOutput.get() != nullptr) {
1227 return mAudioOutput->applyVolumeShaper(configuration, operation);
1228 }
1229 }
1230 return VolumeShaper::Status(INVALID_OPERATION);
1231}
1232
1233sp<VolumeShaper::State> MediaPlayerService::Client::getVolumeShaperState(int id) {
1234 // for hardware output, call player instead
1235 ALOGV("Client::getVolumeShaperState(%p)", this);
1236 sp<MediaPlayerBase> p = getPlayer();
1237 {
1238 Mutex::Autolock l(mLock);
1239 if (p != 0 && p->hardwareOutput()) {
1240 // TODO: investigate internal implementation.
1241 return nullptr;
1242 }
1243 if (mAudioOutput.get() != nullptr) {
1244 return mAudioOutput->getVolumeShaperState(id);
1245 }
1246 }
1247 return nullptr;
1248}
1249
Wei Jiac5de0912016-11-18 10:22:14 -08001250status_t MediaPlayerService::Client::seekTo(int msec, MediaPlayerSeekMode mode)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001251{
Wei Jiac5de0912016-11-18 10:22:14 -08001252 ALOGV("[%d] seekTo(%d, %d)", mConnId, msec, mode);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001253 sp<MediaPlayerBase> p = getPlayer();
1254 if (p == 0) return UNKNOWN_ERROR;
Wei Jiac5de0912016-11-18 10:22:14 -08001255 return p->seekTo(msec, mode);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001256}
1257
1258status_t MediaPlayerService::Client::reset()
1259{
Steve Block3856b092011-10-20 11:56:00 +01001260 ALOGV("[%d] reset", mConnId);
John Grossmanc795b642012-02-22 15:38:35 -08001261 mRetransmitEndpointValid = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001262 sp<MediaPlayerBase> p = getPlayer();
1263 if (p == 0) return UNKNOWN_ERROR;
1264 return p->reset();
1265}
1266
Wei Jia52c28512017-09-13 18:17:51 -07001267status_t MediaPlayerService::Client::notifyAt(int64_t mediaTimeUs)
1268{
1269 ALOGV("[%d] notifyAt(%lld)", mConnId, (long long)mediaTimeUs);
1270 sp<MediaPlayerBase> p = getPlayer();
1271 if (p == 0) return UNKNOWN_ERROR;
1272 return p->notifyAt(mediaTimeUs);
1273}
1274
Glenn Kastenfff6d712012-01-12 16:38:12 -08001275status_t MediaPlayerService::Client::setAudioStreamType(audio_stream_type_t type)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001276{
Steve Block3856b092011-10-20 11:56:00 +01001277 ALOGV("[%d] setAudioStreamType(%d)", mConnId, type);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001278 // TODO: for hardware output, call player instead
1279 Mutex::Autolock l(mLock);
1280 if (mAudioOutput != 0) mAudioOutput->setAudioStreamType(type);
1281 return NO_ERROR;
1282}
1283
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001284status_t MediaPlayerService::Client::setAudioAttributes_l(const Parcel &parcel)
1285{
1286 if (mAudioAttributes != NULL) { free(mAudioAttributes); }
1287 mAudioAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t));
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001288 if (mAudioAttributes == NULL) {
1289 return NO_MEMORY;
1290 }
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001291 unmarshallAudioAttributes(parcel, mAudioAttributes);
1292
1293 ALOGV("setAudioAttributes_l() usage=%d content=%d flags=0x%x tags=%s",
1294 mAudioAttributes->usage, mAudioAttributes->content_type, mAudioAttributes->flags,
1295 mAudioAttributes->tags);
1296
1297 if (mAudioOutput != 0) {
1298 mAudioOutput->setAudioAttributes(mAudioAttributes);
1299 }
1300 return NO_ERROR;
1301}
1302
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001303status_t MediaPlayerService::Client::setLooping(int loop)
1304{
Steve Block3856b092011-10-20 11:56:00 +01001305 ALOGV("[%d] setLooping(%d)", mConnId, loop);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001306 mLoop = loop;
1307 sp<MediaPlayerBase> p = getPlayer();
1308 if (p != 0) return p->setLooping(loop);
1309 return NO_ERROR;
1310}
1311
1312status_t MediaPlayerService::Client::setVolume(float leftVolume, float rightVolume)
1313{
Steve Block3856b092011-10-20 11:56:00 +01001314 ALOGV("[%d] setVolume(%f, %f)", mConnId, leftVolume, rightVolume);
John Grossman761defc2012-02-09 15:09:05 -08001315
1316 // for hardware output, call player instead
1317 sp<MediaPlayerBase> p = getPlayer();
1318 {
1319 Mutex::Autolock l(mLock);
1320 if (p != 0 && p->hardwareOutput()) {
1321 MediaPlayerHWInterface* hwp =
1322 reinterpret_cast<MediaPlayerHWInterface*>(p.get());
1323 return hwp->setVolume(leftVolume, rightVolume);
1324 } else {
1325 if (mAudioOutput != 0) mAudioOutput->setVolume(leftVolume, rightVolume);
1326 return NO_ERROR;
1327 }
1328 }
1329
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001330 return NO_ERROR;
1331}
1332
Eric Laurent2beeb502010-07-16 07:43:46 -07001333status_t MediaPlayerService::Client::setAuxEffectSendLevel(float level)
1334{
Steve Block3856b092011-10-20 11:56:00 +01001335 ALOGV("[%d] setAuxEffectSendLevel(%f)", mConnId, level);
Eric Laurent2beeb502010-07-16 07:43:46 -07001336 Mutex::Autolock l(mLock);
1337 if (mAudioOutput != 0) return mAudioOutput->setAuxEffectSendLevel(level);
1338 return NO_ERROR;
1339}
1340
1341status_t MediaPlayerService::Client::attachAuxEffect(int effectId)
1342{
Steve Block3856b092011-10-20 11:56:00 +01001343 ALOGV("[%d] attachAuxEffect(%d)", mConnId, effectId);
Eric Laurent2beeb502010-07-16 07:43:46 -07001344 Mutex::Autolock l(mLock);
1345 if (mAudioOutput != 0) return mAudioOutput->attachAuxEffect(effectId);
1346 return NO_ERROR;
1347}
Nicolas Catania48290382009-07-10 13:53:06 -07001348
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001349status_t MediaPlayerService::Client::setParameter(int key, const Parcel &request) {
Steve Block3856b092011-10-20 11:56:00 +01001350 ALOGV("[%d] setParameter(%d)", mConnId, key);
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001351 switch (key) {
1352 case KEY_PARAMETER_AUDIO_ATTRIBUTES:
1353 {
1354 Mutex::Autolock l(mLock);
1355 return setAudioAttributes_l(request);
1356 }
1357 default:
1358 sp<MediaPlayerBase> p = getPlayer();
1359 if (p == 0) { return UNKNOWN_ERROR; }
1360 return p->setParameter(key, request);
1361 }
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001362}
1363
1364status_t MediaPlayerService::Client::getParameter(int key, Parcel *reply) {
Steve Block3856b092011-10-20 11:56:00 +01001365 ALOGV("[%d] getParameter(%d)", mConnId, key);
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001366 sp<MediaPlayerBase> p = getPlayer();
1367 if (p == 0) return UNKNOWN_ERROR;
1368 return p->getParameter(key, reply);
1369}
1370
John Grossmanc795b642012-02-22 15:38:35 -08001371status_t MediaPlayerService::Client::setRetransmitEndpoint(
1372 const struct sockaddr_in* endpoint) {
1373
1374 if (NULL != endpoint) {
1375 uint32_t a = ntohl(endpoint->sin_addr.s_addr);
1376 uint16_t p = ntohs(endpoint->sin_port);
1377 ALOGV("[%d] setRetransmitEndpoint(%u.%u.%u.%u:%hu)", mConnId,
1378 (a >> 24), (a >> 16) & 0xFF, (a >> 8) & 0xFF, (a & 0xFF), p);
1379 } else {
1380 ALOGV("[%d] setRetransmitEndpoint = <none>", mConnId);
1381 }
1382
1383 sp<MediaPlayerBase> p = getPlayer();
1384
1385 // Right now, the only valid time to set a retransmit endpoint is before
1386 // player selection has been made (since the presence or absence of a
1387 // retransmit endpoint is going to determine which player is selected during
1388 // setDataSource).
1389 if (p != 0) return INVALID_OPERATION;
1390
1391 if (NULL != endpoint) {
Pawin Vongmasaf9c81462017-09-28 05:31:11 -07001392 Mutex::Autolock lock(mLock);
John Grossmanc795b642012-02-22 15:38:35 -08001393 mRetransmitEndpoint = *endpoint;
1394 mRetransmitEndpointValid = true;
1395 } else {
Pawin Vongmasaf9c81462017-09-28 05:31:11 -07001396 Mutex::Autolock lock(mLock);
John Grossmanc795b642012-02-22 15:38:35 -08001397 mRetransmitEndpointValid = false;
1398 }
1399
1400 return NO_ERROR;
1401}
1402
John Grossman44a7e422012-06-21 17:29:24 -07001403status_t MediaPlayerService::Client::getRetransmitEndpoint(
1404 struct sockaddr_in* endpoint)
1405{
1406 if (NULL == endpoint)
1407 return BAD_VALUE;
1408
1409 sp<MediaPlayerBase> p = getPlayer();
1410
1411 if (p != NULL)
1412 return p->getRetransmitEndpoint(endpoint);
1413
Pawin Vongmasaf9c81462017-09-28 05:31:11 -07001414 Mutex::Autolock lock(mLock);
John Grossman44a7e422012-06-21 17:29:24 -07001415 if (!mRetransmitEndpointValid)
1416 return NO_INIT;
1417
1418 *endpoint = mRetransmitEndpoint;
1419
1420 return NO_ERROR;
1421}
1422
Gloria Wangb483c472011-04-11 17:23:27 -07001423void MediaPlayerService::Client::notify(
1424 void* cookie, int msg, int ext1, int ext2, const Parcel *obj)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001425{
1426 Client* client = static_cast<Client*>(cookie);
James Dongb8a98252012-08-26 16:13:03 -07001427 if (client == NULL) {
1428 return;
1429 }
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001430
James Dongb8a98252012-08-26 16:13:03 -07001431 sp<IMediaPlayerClient> c;
Haynes Mathew George6cb33752015-06-22 14:16:42 -07001432 sp<Client> nextClient;
1433 status_t errStartNext = NO_ERROR;
Marco Nelissen6b74d672012-02-28 16:07:44 -08001434 {
1435 Mutex::Autolock l(client->mLock);
James Dongb8a98252012-08-26 16:13:03 -07001436 c = client->mClient;
Marco Nelissen6b74d672012-02-28 16:07:44 -08001437 if (msg == MEDIA_PLAYBACK_COMPLETE && client->mNextClient != NULL) {
Haynes Mathew George6cb33752015-06-22 14:16:42 -07001438 nextClient = client->mNextClient;
1439
John Grossmancb0b7552012-08-23 17:47:31 -07001440 if (client->mAudioOutput != NULL)
1441 client->mAudioOutput->switchToNextOutput();
Haynes Mathew George6cb33752015-06-22 14:16:42 -07001442
1443 errStartNext = nextClient->start();
1444 }
1445 }
1446
1447 if (nextClient != NULL) {
1448 sp<IMediaPlayerClient> nc;
1449 {
1450 Mutex::Autolock l(nextClient->mLock);
1451 nc = nextClient->mClient;
1452 }
1453 if (nc != NULL) {
1454 if (errStartNext == NO_ERROR) {
1455 nc->notify(MEDIA_INFO, MEDIA_INFO_STARTED_AS_NEXT, 0, obj);
1456 } else {
1457 nc->notify(MEDIA_ERROR, MEDIA_ERROR_UNKNOWN , 0, obj);
1458 ALOGE("gapless:start playback for next track failed, err(%d)", errStartNext);
Wei Jia2afac0c2016-01-07 12:13:07 -08001459 }
Marco Nelissen6b74d672012-02-28 16:07:44 -08001460 }
1461 }
1462
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001463 if (MEDIA_INFO == msg &&
Nicolas Catania48290382009-07-10 13:53:06 -07001464 MEDIA_INFO_METADATA_UPDATE == ext1) {
nikoa64c8c72009-07-20 15:07:26 -07001465 const media::Metadata::Type metadata_type = ext2;
Nicolas Catania48290382009-07-10 13:53:06 -07001466
1467 if(client->shouldDropMetadata(metadata_type)) {
1468 return;
1469 }
1470
1471 // Update the list of metadata that have changed. getMetadata
1472 // also access mMetadataUpdated and clears it.
1473 client->addNewMetadataUpdate(metadata_type);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001474 }
James Dongb8a98252012-08-26 16:13:03 -07001475
1476 if (c != NULL) {
1477 ALOGV("[%d] notify (%p, %d, %d, %d)", client->mConnId, cookie, msg, ext1, ext2);
1478 c->notify(msg, ext1, ext2, obj);
1479 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001480}
1481
Nicolas Catania48290382009-07-10 13:53:06 -07001482
nikoa64c8c72009-07-20 15:07:26 -07001483bool MediaPlayerService::Client::shouldDropMetadata(media::Metadata::Type code) const
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001484{
Nicolas Catania48290382009-07-10 13:53:06 -07001485 Mutex::Autolock lock(mLock);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001486
Nicolas Catania48290382009-07-10 13:53:06 -07001487 if (findMetadata(mMetadataDrop, code)) {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001488 return true;
1489 }
1490
Nicolas Catania48290382009-07-10 13:53:06 -07001491 if (mMetadataAllow.isEmpty() || findMetadata(mMetadataAllow, code)) {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001492 return false;
Nicolas Catania48290382009-07-10 13:53:06 -07001493 } else {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001494 return true;
1495 }
1496}
1497
Nicolas Catania48290382009-07-10 13:53:06 -07001498
nikoa64c8c72009-07-20 15:07:26 -07001499void MediaPlayerService::Client::addNewMetadataUpdate(media::Metadata::Type metadata_type) {
Nicolas Catania48290382009-07-10 13:53:06 -07001500 Mutex::Autolock lock(mLock);
1501 if (mMetadataUpdated.indexOf(metadata_type) < 0) {
1502 mMetadataUpdated.add(metadata_type);
1503 }
1504}
1505
Hassan Shojaniacefac142017-02-06 21:02:02 -08001506// Modular DRM
1507status_t MediaPlayerService::Client::prepareDrm(const uint8_t uuid[16],
1508 const Vector<uint8_t>& drmSessionId)
1509{
1510 ALOGV("[%d] prepareDrm", mConnId);
1511 sp<MediaPlayerBase> p = getPlayer();
1512 if (p == 0) return UNKNOWN_ERROR;
1513
1514 status_t ret = p->prepareDrm(uuid, drmSessionId);
1515 ALOGV("prepareDrm ret: %d", ret);
1516
1517 return ret;
1518}
1519
1520status_t MediaPlayerService::Client::releaseDrm()
1521{
1522 ALOGV("[%d] releaseDrm", mConnId);
1523 sp<MediaPlayerBase> p = getPlayer();
1524 if (p == 0) return UNKNOWN_ERROR;
1525
1526 status_t ret = p->releaseDrm();
1527 ALOGV("releaseDrm ret: %d", ret);
1528
1529 return ret;
1530}
1531
jiabin156c6872017-10-06 09:47:15 -07001532status_t MediaPlayerService::Client::setOutputDevice(audio_port_handle_t deviceId)
1533{
1534 ALOGV("[%d] setOutputDevice", mConnId);
1535 {
1536 Mutex::Autolock l(mLock);
1537 if (mAudioOutput.get() != nullptr) {
1538 return mAudioOutput->setOutputDevice(deviceId);
1539 }
1540 }
1541 return NO_INIT;
1542}
1543
1544status_t MediaPlayerService::Client::getRoutedDeviceId(audio_port_handle_t* deviceId)
1545{
1546 ALOGV("[%d] getRoutedDeviceId", mConnId);
1547 {
1548 Mutex::Autolock l(mLock);
1549 if (mAudioOutput.get() != nullptr) {
1550 return mAudioOutput->getRoutedDeviceId(deviceId);
1551 }
1552 }
1553 return NO_INIT;
1554}
1555
1556status_t MediaPlayerService::Client::enableAudioDeviceCallback(bool enabled)
1557{
1558 ALOGV("[%d] enableAudioDeviceCallback, %d", mConnId, enabled);
1559 {
1560 Mutex::Autolock l(mLock);
1561 if (mAudioOutput.get() != nullptr) {
1562 return mAudioOutput->enableAudioDeviceCallback(enabled);
1563 }
1564 }
1565 return NO_INIT;
1566}
1567
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001568#if CALLBACK_ANTAGONIZER
1569const int Antagonizer::interval = 10000; // 10 msecs
1570
1571Antagonizer::Antagonizer(notify_callback_f cb, void* client) :
1572 mExit(false), mActive(false), mClient(client), mCb(cb)
1573{
1574 createThread(callbackThread, this);
1575}
1576
1577void Antagonizer::kill()
1578{
1579 Mutex::Autolock _l(mLock);
1580 mActive = false;
1581 mExit = true;
1582 mCondition.wait(mLock);
1583}
1584
1585int Antagonizer::callbackThread(void* user)
1586{
Steve Blockb8a80522011-12-20 16:23:08 +00001587 ALOGD("Antagonizer started");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001588 Antagonizer* p = reinterpret_cast<Antagonizer*>(user);
1589 while (!p->mExit) {
1590 if (p->mActive) {
Steve Block3856b092011-10-20 11:56:00 +01001591 ALOGV("send event");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001592 p->mCb(p->mClient, 0, 0, 0);
1593 }
1594 usleep(interval);
1595 }
1596 Mutex::Autolock _l(p->mLock);
1597 p->mCondition.signal();
Steve Blockb8a80522011-12-20 16:23:08 +00001598 ALOGD("Antagonizer stopped");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001599 return 0;
1600}
1601#endif
1602
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001603#undef LOG_TAG
1604#define LOG_TAG "AudioSink"
Andy Hung1afd0982016-11-08 16:13:44 -08001605MediaPlayerService::AudioOutput::AudioOutput(audio_session_t sessionId, uid_t uid, int pid,
jiabin156c6872017-10-06 09:47:15 -07001606 const audio_attributes_t* attr, const sp<AudioSystem::AudioDeviceCallback>& deviceCallback)
Andreas Huber20111aa2009-07-14 16:56:47 -07001607 : mCallback(NULL),
Eric Laurenta514bdb2010-06-21 09:27:30 -07001608 mCallbackCookie(NULL),
Marco Nelissen6b74d672012-02-28 16:07:44 -08001609 mCallbackData(NULL),
Andy Hungd1c74342015-07-07 16:54:23 -07001610 mStreamType(AUDIO_STREAM_MUSIC),
Andy Hungd1c74342015-07-07 16:54:23 -07001611 mLeftVolume(1.0),
1612 mRightVolume(1.0),
1613 mPlaybackRate(AUDIO_PLAYBACK_RATE_DEFAULT),
1614 mSampleRateHz(0),
1615 mMsecsPerFrame(0),
1616 mFrameSize(0),
Eric Laurent1948eb32012-04-13 16:50:19 -07001617 mSessionId(sessionId),
Marco Nelissen462fd2f2013-01-14 14:12:05 -08001618 mUid(uid),
Marco Nelissend457c972014-02-11 08:47:07 -08001619 mPid(pid),
Andy Hungd1c74342015-07-07 16:54:23 -07001620 mSendLevel(0.0),
1621 mAuxEffectId(0),
Andy Hung4ef88d72017-02-21 19:47:53 -08001622 mFlags(AUDIO_OUTPUT_FLAG_NONE),
jiabin156c6872017-10-06 09:47:15 -07001623 mVolumeHandler(new media::VolumeHandler()),
1624 mSelectedDeviceId(AUDIO_PORT_HANDLE_NONE),
1625 mDeviceCallbackEnabled(false),
1626 mDeviceCallback(deviceCallback)
Andy Hungd1c74342015-07-07 16:54:23 -07001627{
Steve Block3856b092011-10-20 11:56:00 +01001628 ALOGV("AudioOutput(%d)", sessionId);
Eric Laurent43562692015-07-15 16:49:07 -07001629 if (attr != NULL) {
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001630 mAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t));
1631 if (mAttributes != NULL) {
1632 memcpy(mAttributes, attr, sizeof(audio_attributes_t));
1633 mStreamType = audio_attributes_to_stream_type(attr);
1634 }
1635 } else {
1636 mAttributes = NULL;
Eric Laurent43562692015-07-15 16:49:07 -07001637 }
1638
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001639 setMinBufferCount();
1640}
1641
1642MediaPlayerService::AudioOutput::~AudioOutput()
1643{
1644 close();
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001645 free(mAttributes);
Marco Nelissen6b74d672012-02-28 16:07:44 -08001646 delete mCallbackData;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001647}
1648
Andy Hungd1c74342015-07-07 16:54:23 -07001649//static
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001650void MediaPlayerService::AudioOutput::setMinBufferCount()
1651{
1652 char value[PROPERTY_VALUE_MAX];
1653 if (property_get("ro.kernel.qemu", value, 0)) {
1654 mIsOnEmulator = true;
1655 mMinBufferCount = 12; // to prevent systematic buffer underrun for emulator
1656 }
1657}
1658
Andy Hungd1c74342015-07-07 16:54:23 -07001659// static
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001660bool MediaPlayerService::AudioOutput::isOnEmulator()
1661{
Andy Hungd1c74342015-07-07 16:54:23 -07001662 setMinBufferCount(); // benign race wrt other threads
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001663 return mIsOnEmulator;
1664}
1665
Andy Hungd1c74342015-07-07 16:54:23 -07001666// static
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001667int MediaPlayerService::AudioOutput::getMinBufferCount()
1668{
Andy Hungd1c74342015-07-07 16:54:23 -07001669 setMinBufferCount(); // benign race wrt other threads
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001670 return mMinBufferCount;
1671}
1672
1673ssize_t MediaPlayerService::AudioOutput::bufferSize() const
1674{
Andy Hungd1c74342015-07-07 16:54:23 -07001675 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001676 if (mTrack == 0) return NO_INIT;
Andy Hungd1c74342015-07-07 16:54:23 -07001677 return mTrack->frameCount() * mFrameSize;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001678}
1679
1680ssize_t MediaPlayerService::AudioOutput::frameCount() const
1681{
Andy Hungd1c74342015-07-07 16:54:23 -07001682 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001683 if (mTrack == 0) return NO_INIT;
1684 return mTrack->frameCount();
1685}
1686
1687ssize_t MediaPlayerService::AudioOutput::channelCount() const
1688{
Andy Hungd1c74342015-07-07 16:54:23 -07001689 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001690 if (mTrack == 0) return NO_INIT;
1691 return mTrack->channelCount();
1692}
1693
1694ssize_t MediaPlayerService::AudioOutput::frameSize() const
1695{
Andy Hungd1c74342015-07-07 16:54:23 -07001696 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001697 if (mTrack == 0) return NO_INIT;
Andy Hungd1c74342015-07-07 16:54:23 -07001698 return mFrameSize;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001699}
1700
1701uint32_t MediaPlayerService::AudioOutput::latency () const
1702{
Andy Hungd1c74342015-07-07 16:54:23 -07001703 Mutex::Autolock lock(mLock);
Eric Laurentdb354e52012-03-05 17:27:11 -08001704 if (mTrack == 0) return 0;
1705 return mTrack->latency();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001706}
1707
1708float MediaPlayerService::AudioOutput::msecsPerFrame() const
1709{
Andy Hungd1c74342015-07-07 16:54:23 -07001710 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001711 return mMsecsPerFrame;
1712}
1713
Marco Nelissen4110c102012-03-29 09:31:28 -07001714status_t MediaPlayerService::AudioOutput::getPosition(uint32_t *position) const
Eric Laurent342e9cf2010-01-19 17:37:09 -08001715{
Andy Hungd1c74342015-07-07 16:54:23 -07001716 Mutex::Autolock lock(mLock);
Eric Laurent342e9cf2010-01-19 17:37:09 -08001717 if (mTrack == 0) return NO_INIT;
1718 return mTrack->getPosition(position);
1719}
1720
Lajos Molnar06ad1522014-08-28 07:27:44 -07001721status_t MediaPlayerService::AudioOutput::getTimestamp(AudioTimestamp &ts) const
1722{
Andy Hungd1c74342015-07-07 16:54:23 -07001723 Mutex::Autolock lock(mLock);
Lajos Molnar06ad1522014-08-28 07:27:44 -07001724 if (mTrack == 0) return NO_INIT;
1725 return mTrack->getTimestamp(ts);
1726}
1727
Wei Jiac4ac8172015-10-21 10:35:48 -07001728// TODO: Remove unnecessary calls to getPlayedOutDurationUs()
1729// as it acquires locks and may query the audio driver.
1730//
1731// Some calls could conceivably retrieve extrapolated data instead of
1732// accessing getTimestamp() or getPosition() every time a data buffer with
1733// a media time is received.
1734//
1735// Calculate duration of played samples if played at normal rate (i.e., 1.0).
1736int64_t MediaPlayerService::AudioOutput::getPlayedOutDurationUs(int64_t nowUs) const
1737{
1738 Mutex::Autolock lock(mLock);
1739 if (mTrack == 0 || mSampleRateHz == 0) {
Wei Jia213f4902015-10-22 08:55:25 -07001740 return 0;
Wei Jiac4ac8172015-10-21 10:35:48 -07001741 }
1742
1743 uint32_t numFramesPlayed;
Andy Hung5d313802016-10-10 15:09:39 -07001744 int64_t numFramesPlayedAtUs;
Wei Jiac4ac8172015-10-21 10:35:48 -07001745 AudioTimestamp ts;
Wei Jiac4ac8172015-10-21 10:35:48 -07001746
1747 status_t res = mTrack->getTimestamp(ts);
1748 if (res == OK) { // case 1: mixing audio tracks and offloaded tracks.
1749 numFramesPlayed = ts.mPosition;
Andy Hung5d313802016-10-10 15:09:39 -07001750 numFramesPlayedAtUs = ts.mTime.tv_sec * 1000000LL + ts.mTime.tv_nsec / 1000;
1751 //ALOGD("getTimestamp: OK %d %lld", numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001752 } else if (res == WOULD_BLOCK) { // case 2: transitory state on start of a new track
1753 numFramesPlayed = 0;
Andy Hung5d313802016-10-10 15:09:39 -07001754 numFramesPlayedAtUs = nowUs;
Wei Jiac4ac8172015-10-21 10:35:48 -07001755 //ALOGD("getTimestamp: WOULD_BLOCK %d %lld",
Andy Hung5d313802016-10-10 15:09:39 -07001756 // numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001757 } else { // case 3: transitory at new track or audio fast tracks.
1758 res = mTrack->getPosition(&numFramesPlayed);
1759 CHECK_EQ(res, (status_t)OK);
Andy Hung5d313802016-10-10 15:09:39 -07001760 numFramesPlayedAtUs = nowUs;
1761 numFramesPlayedAtUs += 1000LL * mTrack->latency() / 2; /* XXX */
1762 //ALOGD("getPosition: %u %lld", numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001763 }
1764
1765 // CHECK_EQ(numFramesPlayed & (1 << 31), 0); // can't be negative until 12.4 hrs, test
1766 // TODO: remove the (int32_t) casting below as it may overflow at 12.4 hours.
1767 int64_t durationUs = (int64_t)((int32_t)numFramesPlayed * 1000000LL / mSampleRateHz)
Andy Hung5d313802016-10-10 15:09:39 -07001768 + nowUs - numFramesPlayedAtUs;
Wei Jiac4ac8172015-10-21 10:35:48 -07001769 if (durationUs < 0) {
1770 // Occurs when numFramesPlayed position is very small and the following:
1771 // (1) In case 1, the time nowUs is computed before getTimestamp() is called and
Andy Hung5d313802016-10-10 15:09:39 -07001772 // numFramesPlayedAtUs is greater than nowUs by time more than numFramesPlayed.
Wei Jiac4ac8172015-10-21 10:35:48 -07001773 // (2) In case 3, using getPosition and adding mAudioSink->latency() to
Andy Hung5d313802016-10-10 15:09:39 -07001774 // numFramesPlayedAtUs, by a time amount greater than numFramesPlayed.
Wei Jiac4ac8172015-10-21 10:35:48 -07001775 //
1776 // Both of these are transitory conditions.
1777 ALOGV("getPlayedOutDurationUs: negative duration %lld set to zero", (long long)durationUs);
1778 durationUs = 0;
1779 }
1780 ALOGV("getPlayedOutDurationUs(%lld) nowUs(%lld) frames(%u) framesAt(%lld)",
Andy Hung5d313802016-10-10 15:09:39 -07001781 (long long)durationUs, (long long)nowUs,
1782 numFramesPlayed, (long long)numFramesPlayedAtUs);
Wei Jiac4ac8172015-10-21 10:35:48 -07001783 return durationUs;
1784}
1785
Marco Nelissen4110c102012-03-29 09:31:28 -07001786status_t MediaPlayerService::AudioOutput::getFramesWritten(uint32_t *frameswritten) const
1787{
Andy Hungd1c74342015-07-07 16:54:23 -07001788 Mutex::Autolock lock(mLock);
Marco Nelissen4110c102012-03-29 09:31:28 -07001789 if (mTrack == 0) return NO_INIT;
Andy Hung2f6e73d2016-04-08 12:12:58 -07001790 ExtendedTimestamp ets;
1791 status_t status = mTrack->getTimestamp(&ets);
1792 if (status == OK || status == WOULD_BLOCK) {
1793 *frameswritten = (uint32_t)ets.mPosition[ExtendedTimestamp::LOCATION_CLIENT];
1794 }
1795 return status;
Marco Nelissen4110c102012-03-29 09:31:28 -07001796}
1797
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001798status_t MediaPlayerService::AudioOutput::setParameters(const String8& keyValuePairs)
1799{
Andy Hungd1c74342015-07-07 16:54:23 -07001800 Mutex::Autolock lock(mLock);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001801 if (mTrack == 0) return NO_INIT;
1802 return mTrack->setParameters(keyValuePairs);
1803}
1804
1805String8 MediaPlayerService::AudioOutput::getParameters(const String8& keys)
1806{
Andy Hungd1c74342015-07-07 16:54:23 -07001807 Mutex::Autolock lock(mLock);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001808 if (mTrack == 0) return String8::empty();
1809 return mTrack->getParameters(keys);
1810}
1811
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001812void MediaPlayerService::AudioOutput::setAudioAttributes(const audio_attributes_t * attributes) {
Andy Hungd1c74342015-07-07 16:54:23 -07001813 Mutex::Autolock lock(mLock);
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001814 if (attributes == NULL) {
1815 free(mAttributes);
1816 mAttributes = NULL;
1817 } else {
1818 if (mAttributes == NULL) {
1819 mAttributes = (audio_attributes_t *) calloc(1, sizeof(audio_attributes_t));
1820 }
1821 memcpy(mAttributes, attributes, sizeof(audio_attributes_t));
Eric Laurent43562692015-07-15 16:49:07 -07001822 mStreamType = audio_attributes_to_stream_type(attributes);
1823 }
1824}
1825
1826void MediaPlayerService::AudioOutput::setAudioStreamType(audio_stream_type_t streamType)
1827{
Jean-Michel Trivi2650e962015-07-22 18:14:02 -07001828 Mutex::Autolock lock(mLock);
Eric Laurent43562692015-07-15 16:49:07 -07001829 // do not allow direct stream type modification if attributes have been set
1830 if (mAttributes == NULL) {
1831 mStreamType = streamType;
1832 }
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07001833}
1834
Andy Hungd1c74342015-07-07 16:54:23 -07001835void MediaPlayerService::AudioOutput::deleteRecycledTrack_l()
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001836{
Andy Hungd1c74342015-07-07 16:54:23 -07001837 ALOGV("deleteRecycledTrack_l");
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001838 if (mRecycledTrack != 0) {
1839
1840 if (mCallbackData != NULL) {
1841 mCallbackData->setOutput(NULL);
1842 mCallbackData->endTrackSwitch();
1843 }
1844
1845 if ((mRecycledTrack->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) {
Andy Hunge13f8a62016-03-30 14:20:42 -07001846 int32_t msec = 0;
1847 if (!mRecycledTrack->stopped()) { // check if active
1848 (void)mRecycledTrack->pendingDuration(&msec);
1849 }
1850 mRecycledTrack->stop(); // ensure full data drain
1851 ALOGD("deleting recycled track, waiting for data drain (%d msec)", msec);
1852 if (msec > 0) {
1853 static const int32_t WAIT_LIMIT_MS = 3000;
1854 if (msec > WAIT_LIMIT_MS) {
1855 msec = WAIT_LIMIT_MS;
1856 }
1857 usleep(msec * 1000LL);
1858 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001859 }
1860 // An offloaded track isn't flushed because the STREAM_END is reported
1861 // slightly prematurely to allow time for the gapless track switch
1862 // but this means that if we decide not to recycle the track there
1863 // could be a small amount of residual data still playing. We leave
1864 // AudioFlinger to drain the track.
1865
1866 mRecycledTrack.clear();
Andy Hungd1c74342015-07-07 16:54:23 -07001867 close_l();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001868 delete mCallbackData;
1869 mCallbackData = NULL;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001870 }
1871}
1872
Andy Hungd1c74342015-07-07 16:54:23 -07001873void MediaPlayerService::AudioOutput::close_l()
1874{
1875 mTrack.clear();
1876}
1877
Andreas Huber20111aa2009-07-14 16:56:47 -07001878status_t MediaPlayerService::AudioOutput::open(
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001879 uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
1880 audio_format_t format, int bufferCount,
Eric Laurent1948eb32012-04-13 16:50:19 -07001881 AudioCallback cb, void *cookie,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00001882 audio_output_flags_t flags,
Ronghua Wufaeb0f22015-05-21 12:20:21 -07001883 const audio_offload_info_t *offloadInfo,
Andy Hung179652e2015-05-31 22:49:46 -07001884 bool doNotReconnect,
1885 uint32_t suggestedFrameCount)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001886{
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001887 ALOGV("open(%u, %d, 0x%x, 0x%x, %d, %d 0x%x)", sampleRate, channelCount, channelMask,
1888 format, bufferCount, mSessionId, flags);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001889
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001890 // offloading is only supported in callback mode for now.
1891 // offloadInfo must be present if offload flag is set
1892 if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) &&
1893 ((cb == NULL) || (offloadInfo == NULL))) {
1894 return BAD_VALUE;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001895 }
1896
Andy Hung179652e2015-05-31 22:49:46 -07001897 // compute frame count for the AudioTrack internal buffer
1898 size_t frameCount;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001899 if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
1900 frameCount = 0; // AudioTrack will get frame count from AudioFlinger
1901 } else {
Andy Hung179652e2015-05-31 22:49:46 -07001902 // try to estimate the buffer processing fetch size from AudioFlinger.
1903 // framesPerBuffer is approximate and generally correct, except when it's not :-).
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001904 uint32_t afSampleRate;
1905 size_t afFrameCount;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001906 if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) != NO_ERROR) {
1907 return NO_INIT;
1908 }
1909 if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) != NO_ERROR) {
1910 return NO_INIT;
1911 }
Andy Hung179652e2015-05-31 22:49:46 -07001912 const size_t framesPerBuffer =
1913 (unsigned long long)sampleRate * afFrameCount / afSampleRate;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001914
Andy Hung179652e2015-05-31 22:49:46 -07001915 if (bufferCount == 0) {
1916 // use suggestedFrameCount
1917 bufferCount = (suggestedFrameCount + framesPerBuffer - 1) / framesPerBuffer;
1918 }
1919 // Check argument bufferCount against the mininum buffer count
1920 if (bufferCount != 0 && bufferCount < mMinBufferCount) {
1921 ALOGV("bufferCount (%d) increased to %d", bufferCount, mMinBufferCount);
1922 bufferCount = mMinBufferCount;
1923 }
1924 // if frameCount is 0, then AudioTrack will get frame count from AudioFlinger
1925 // which will be the minimum size permitted.
1926 frameCount = bufferCount * framesPerBuffer;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001927 }
Andreas Huber20111aa2009-07-14 16:56:47 -07001928
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001929 if (channelMask == CHANNEL_MASK_USE_CHANNEL_ORDER) {
Glenn Kastenab334fd2012-03-14 12:56:06 -07001930 channelMask = audio_channel_out_mask_from_count(channelCount);
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001931 if (0 == channelMask) {
1932 ALOGE("open() error, can\'t derive mask for %d audio channels", channelCount);
1933 return NO_INIT;
1934 }
1935 }
Eric Laurent1948eb32012-04-13 16:50:19 -07001936
Andy Hungd1c74342015-07-07 16:54:23 -07001937 Mutex::Autolock lock(mLock);
Andy Hung179652e2015-05-31 22:49:46 -07001938 mCallback = cb;
1939 mCallbackCookie = cookie;
1940
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001941 // Check whether we can recycle the track
1942 bool reuse = false;
1943 bool bothOffloaded = false;
Marco Nelissen67295b52012-06-11 14:52:53 -07001944
Glenn Kasten2799d742013-05-30 14:33:29 -07001945 if (mRecycledTrack != 0) {
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001946 // check whether we are switching between two offloaded tracks
1947 bothOffloaded = (flags & mRecycledTrack->getFlags()
1948 & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0;
Marco Nelissen67295b52012-06-11 14:52:53 -07001949
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001950 // check if the existing track can be reused as-is, or if a new track needs to be created.
1951 reuse = true;
1952
Marco Nelissen67295b52012-06-11 14:52:53 -07001953 if ((mCallbackData == NULL && mCallback != NULL) ||
1954 (mCallbackData != NULL && mCallback == NULL)) {
1955 // recycled track uses callbacks but the caller wants to use writes, or vice versa
1956 ALOGV("can't chain callback and write");
1957 reuse = false;
1958 } else if ((mRecycledTrack->getSampleRate() != sampleRate) ||
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001959 (mRecycledTrack->channelCount() != (uint32_t)channelCount) ) {
1960 ALOGV("samplerate, channelcount differ: %u/%u Hz, %u/%d ch",
Marco Nelissen67295b52012-06-11 14:52:53 -07001961 mRecycledTrack->getSampleRate(), sampleRate,
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001962 mRecycledTrack->channelCount(), channelCount);
Marco Nelissen67295b52012-06-11 14:52:53 -07001963 reuse = false;
1964 } else if (flags != mFlags) {
1965 ALOGV("output flags differ %08x/%08x", flags, mFlags);
1966 reuse = false;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001967 } else if (mRecycledTrack->format() != format) {
1968 reuse = false;
Marco Nelissen67295b52012-06-11 14:52:53 -07001969 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001970 } else {
1971 ALOGV("no track available to recycle");
1972 }
1973
1974 ALOGV_IF(bothOffloaded, "both tracks offloaded");
1975
1976 // If we can't recycle and both tracks are offloaded
1977 // we must close the previous output before opening a new one
1978 if (bothOffloaded && !reuse) {
1979 ALOGV("both offloaded and not recycling");
Andy Hungd1c74342015-07-07 16:54:23 -07001980 deleteRecycledTrack_l();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001981 }
1982
1983 sp<AudioTrack> t;
1984 CallbackData *newcbd = NULL;
1985
1986 // We don't attempt to create a new track if we are recycling an
1987 // offloaded track. But, if we are recycling a non-offloaded or we
1988 // are switching where one is offloaded and one isn't then we create
1989 // the new track in advance so that we can read additional stream info
1990
1991 if (!(reuse && bothOffloaded)) {
1992 ALOGV("creating new AudioTrack");
1993
1994 if (mCallback != NULL) {
1995 newcbd = new CallbackData(this);
1996 t = new AudioTrack(
1997 mStreamType,
1998 sampleRate,
1999 format,
2000 channelMask,
2001 frameCount,
2002 flags,
2003 CallbackWrapper,
2004 newcbd,
2005 0, // notification frames
2006 mSessionId,
2007 AudioTrack::TRANSFER_CALLBACK,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08002008 offloadInfo,
Marco Nelissend457c972014-02-11 08:47:07 -08002009 mUid,
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07002010 mPid,
Ronghua Wufaeb0f22015-05-21 12:20:21 -07002011 mAttributes,
jiabin156c6872017-10-06 09:47:15 -07002012 doNotReconnect,
2013 1.0f, // default value for maxRequiredSpeed
2014 mSelectedDeviceId);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002015 } else {
Andy Hungff874dc2016-04-11 16:49:09 -07002016 // TODO: Due to buffer memory concerns, we use a max target playback speed
2017 // based on mPlaybackRate at the time of open (instead of kMaxRequiredSpeed),
2018 // also clamping the target speed to 1.0 <= targetSpeed <= kMaxRequiredSpeed.
2019 const float targetSpeed =
2020 std::min(std::max(mPlaybackRate.mSpeed, 1.0f), kMaxRequiredSpeed);
2021 ALOGW_IF(targetSpeed != mPlaybackRate.mSpeed,
2022 "track target speed:%f clamped from playback speed:%f",
2023 targetSpeed, mPlaybackRate.mSpeed);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002024 t = new AudioTrack(
2025 mStreamType,
2026 sampleRate,
2027 format,
2028 channelMask,
2029 frameCount,
2030 flags,
Marco Nelissen462fd2f2013-01-14 14:12:05 -08002031 NULL, // callback
2032 NULL, // user data
2033 0, // notification frames
2034 mSessionId,
2035 AudioTrack::TRANSFER_DEFAULT,
2036 NULL, // offload info
Marco Nelissend457c972014-02-11 08:47:07 -08002037 mUid,
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07002038 mPid,
Ronghua Wufaeb0f22015-05-21 12:20:21 -07002039 mAttributes,
Andy Hungff874dc2016-04-11 16:49:09 -07002040 doNotReconnect,
jiabin156c6872017-10-06 09:47:15 -07002041 targetSpeed,
2042 mSelectedDeviceId);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002043 }
2044
2045 if ((t == 0) || (t->initCheck() != NO_ERROR)) {
2046 ALOGE("Unable to create audio track");
2047 delete newcbd;
Glenn Kasten3e98ecd2015-05-18 13:13:24 -07002048 // t goes out of scope, so reference count drops to zero
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002049 return NO_INIT;
Jean-Michel Trivid9d7fa02014-06-24 08:01:46 -07002050 } else {
2051 // successful AudioTrack initialization implies a legacy stream type was generated
2052 // from the audio attributes
2053 mStreamType = t->streamType();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002054 }
2055 }
2056
2057 if (reuse) {
2058 CHECK(mRecycledTrack != NULL);
2059
2060 if (!bothOffloaded) {
2061 if (mRecycledTrack->frameCount() != t->frameCount()) {
Andy Hung833b4752016-04-04 17:15:48 -07002062 ALOGV("framecount differs: %zu/%zu frames",
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002063 mRecycledTrack->frameCount(), t->frameCount());
2064 reuse = false;
2065 }
2066 }
2067
Marco Nelissen67295b52012-06-11 14:52:53 -07002068 if (reuse) {
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002069 ALOGV("chaining to next output and recycling track");
Andy Hungd1c74342015-07-07 16:54:23 -07002070 close_l();
Marco Nelissen67295b52012-06-11 14:52:53 -07002071 mTrack = mRecycledTrack;
Glenn Kasten2799d742013-05-30 14:33:29 -07002072 mRecycledTrack.clear();
Marco Nelissen67295b52012-06-11 14:52:53 -07002073 if (mCallbackData != NULL) {
2074 mCallbackData->setOutput(this);
2075 }
Marco Nelissen67295b52012-06-11 14:52:53 -07002076 delete newcbd;
Wei Jiae0bbac92016-07-18 16:04:53 -07002077 return updateTrack();
Marco Nelissen67295b52012-06-11 14:52:53 -07002078 }
Marco Nelissen67295b52012-06-11 14:52:53 -07002079 }
2080
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002081 // we're not going to reuse the track, unblock and flush it
2082 // this was done earlier if both tracks are offloaded
2083 if (!bothOffloaded) {
Andy Hungd1c74342015-07-07 16:54:23 -07002084 deleteRecycledTrack_l();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002085 }
2086
2087 CHECK((t != NULL) && ((mCallback == NULL) || (newcbd != NULL)));
2088
Marco Nelissen67295b52012-06-11 14:52:53 -07002089 mCallbackData = newcbd;
Steve Block3856b092011-10-20 11:56:00 +01002090 ALOGV("setVolume");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002091 t->setVolume(mLeftVolume, mRightVolume);
Eric Laurent2beeb502010-07-16 07:43:46 -07002092
Andy Hung39399b62017-04-21 15:07:45 -07002093 // Restore VolumeShapers for the MediaPlayer in case the track was recreated
2094 // due to an output sink error (e.g. offload to non-offload switch).
2095 mVolumeHandler->forall([&t](const VolumeShaper &shaper) -> VolumeShaper::Status {
2096 sp<VolumeShaper::Operation> operationToEnd =
2097 new VolumeShaper::Operation(shaper.mOperation);
2098 // TODO: Ideally we would restore to the exact xOffset position
2099 // as returned by getVolumeShaperState(), but we don't have that
2100 // information when restoring at the client unless we periodically poll
2101 // the server or create shared memory state.
2102 //
2103 // For now, we simply advance to the end of the VolumeShaper effect
2104 // if it has been started.
2105 if (shaper.isStarted()) {
Andy Hungf3702642017-05-05 17:33:32 -07002106 operationToEnd->setNormalizedTime(1.f);
Andy Hung39399b62017-04-21 15:07:45 -07002107 }
2108 return t->applyVolumeShaper(shaper.mConfiguration, operationToEnd);
Andy Hung4ef88d72017-02-21 19:47:53 -08002109 });
Andy Hung4ef88d72017-02-21 19:47:53 -08002110
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002111 mSampleRateHz = sampleRate;
Preetam Singh Ranawat2e17eef2015-08-12 12:11:46 -07002112 mFlags = flags;
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002113 mMsecsPerFrame = 1E3f / (mPlaybackRate.mSpeed * sampleRate);
Andy Hungd1c74342015-07-07 16:54:23 -07002114 mFrameSize = t->frameSize();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002115 mTrack = t;
Eric Laurent2beeb502010-07-16 07:43:46 -07002116
Wei Jiae0bbac92016-07-18 16:04:53 -07002117 return updateTrack();
2118}
2119
2120status_t MediaPlayerService::AudioOutput::updateTrack() {
2121 if (mTrack == NULL) {
2122 return NO_ERROR;
2123 }
2124
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002125 status_t res = NO_ERROR;
Wei Jia0162d002015-06-09 11:59:33 -07002126 // Note some output devices may give us a direct track even though we don't specify it.
2127 // Example: Line application b/17459982.
Wei Jiae0bbac92016-07-18 16:04:53 -07002128 if ((mTrack->getFlags()
2129 & (AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD | AUDIO_OUTPUT_FLAG_DIRECT)) == 0) {
2130 res = mTrack->setPlaybackRate(mPlaybackRate);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002131 if (res == NO_ERROR) {
Wei Jiae0bbac92016-07-18 16:04:53 -07002132 mTrack->setAuxEffectSendLevel(mSendLevel);
2133 res = mTrack->attachAuxEffect(mAuxEffectId);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002134 }
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002135 }
jiabin156c6872017-10-06 09:47:15 -07002136 mTrack->setOutputDevice(mSelectedDeviceId);
2137 if (mDeviceCallbackEnabled) {
2138 mTrack->addAudioDeviceCallback(mDeviceCallback.promote());
2139 }
Wei Jiae0bbac92016-07-18 16:04:53 -07002140 ALOGV("updateTrack() DONE status %d", res);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002141 return res;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002142}
2143
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002144status_t MediaPlayerService::AudioOutput::start()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002145{
Steve Block3856b092011-10-20 11:56:00 +01002146 ALOGV("start");
Andy Hungd1c74342015-07-07 16:54:23 -07002147 Mutex::Autolock lock(mLock);
Marco Nelissen6b74d672012-02-28 16:07:44 -08002148 if (mCallbackData != NULL) {
2149 mCallbackData->endTrackSwitch();
2150 }
Glenn Kasten2799d742013-05-30 14:33:29 -07002151 if (mTrack != 0) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002152 mTrack->setVolume(mLeftVolume, mRightVolume);
Eric Laurent2beeb502010-07-16 07:43:46 -07002153 mTrack->setAuxEffectSendLevel(mSendLevel);
Andy Hung39399b62017-04-21 15:07:45 -07002154 status_t status = mTrack->start();
2155 if (status == NO_ERROR) {
2156 mVolumeHandler->setStarted();
2157 }
2158 return status;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002159 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002160 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002161}
2162
Marco Nelissen6b74d672012-02-28 16:07:44 -08002163void MediaPlayerService::AudioOutput::setNextOutput(const sp<AudioOutput>& nextOutput) {
Andy Hungd1c74342015-07-07 16:54:23 -07002164 Mutex::Autolock lock(mLock);
Marco Nelissen6b74d672012-02-28 16:07:44 -08002165 mNextOutput = nextOutput;
2166}
Marco Nelissen7ee8ac92010-01-12 09:23:54 -08002167
Marco Nelissen6b74d672012-02-28 16:07:44 -08002168void MediaPlayerService::AudioOutput::switchToNextOutput() {
2169 ALOGV("switchToNextOutput");
Andy Hungd1c74342015-07-07 16:54:23 -07002170
2171 // Try to acquire the callback lock before moving track (without incurring deadlock).
2172 const unsigned kMaxSwitchTries = 100;
2173 Mutex::Autolock lock(mLock);
2174 for (unsigned tries = 0;;) {
2175 if (mTrack == 0) {
2176 return;
Marco Nelissen6b74d672012-02-28 16:07:44 -08002177 }
Andy Hungd1c74342015-07-07 16:54:23 -07002178 if (mNextOutput != NULL && mNextOutput != this) {
2179 if (mCallbackData != NULL) {
2180 // two alternative approaches
2181#if 1
2182 CallbackData *callbackData = mCallbackData;
2183 mLock.unlock();
2184 // proper acquisition sequence
2185 callbackData->lock();
2186 mLock.lock();
2187 // Caution: it is unlikely that someone deleted our callback or changed our target
2188 if (callbackData != mCallbackData || mNextOutput == NULL || mNextOutput == this) {
2189 // fatal if we are starved out.
2190 LOG_ALWAYS_FATAL_IF(++tries > kMaxSwitchTries,
2191 "switchToNextOutput() cannot obtain correct lock sequence");
2192 callbackData->unlock();
2193 continue;
2194 }
2195 callbackData->mSwitching = true; // begin track switch
Wei Jiaadee56a2016-08-05 15:40:34 -07002196 callbackData->setOutput(NULL);
Andy Hungd1c74342015-07-07 16:54:23 -07002197#else
2198 // tryBeginTrackSwitch() returns false if the callback has the lock.
2199 if (!mCallbackData->tryBeginTrackSwitch()) {
2200 // fatal if we are starved out.
2201 LOG_ALWAYS_FATAL_IF(++tries > kMaxSwitchTries,
2202 "switchToNextOutput() cannot obtain callback lock");
2203 mLock.unlock();
2204 usleep(5 * 1000 /* usec */); // allow callback to use AudioOutput
2205 mLock.lock();
2206 continue;
2207 }
2208#endif
2209 }
2210
2211 Mutex::Autolock nextLock(mNextOutput->mLock);
2212
2213 // If the next output track is not NULL, then it has been
2214 // opened already for playback.
2215 // This is possible even without the next player being started,
2216 // for example, the next player could be prepared and seeked.
2217 //
2218 // Presuming it isn't advisable to force the track over.
2219 if (mNextOutput->mTrack == NULL) {
2220 ALOGD("Recycling track for gapless playback");
2221 delete mNextOutput->mCallbackData;
2222 mNextOutput->mCallbackData = mCallbackData;
2223 mNextOutput->mRecycledTrack = mTrack;
2224 mNextOutput->mSampleRateHz = mSampleRateHz;
2225 mNextOutput->mMsecsPerFrame = mMsecsPerFrame;
Andy Hungd1c74342015-07-07 16:54:23 -07002226 mNextOutput->mFlags = mFlags;
2227 mNextOutput->mFrameSize = mFrameSize;
2228 close_l();
2229 mCallbackData = NULL; // destruction handled by mNextOutput
2230 } else {
2231 ALOGW("Ignoring gapless playback because next player has already started");
2232 // remove track in case resource needed for future players.
2233 if (mCallbackData != NULL) {
2234 mCallbackData->endTrackSwitch(); // release lock for callbacks before close.
2235 }
2236 close_l();
2237 }
2238 }
2239 break;
Marco Nelissen6b74d672012-02-28 16:07:44 -08002240 }
2241}
2242
Wei Jia7d3f4df2015-03-03 15:28:00 -08002243ssize_t MediaPlayerService::AudioOutput::write(const void* buffer, size_t size, bool blocking)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002244{
Andy Hungd1c74342015-07-07 16:54:23 -07002245 Mutex::Autolock lock(mLock);
Glenn Kastenadad3d72014-02-21 14:51:43 -08002246 LOG_ALWAYS_FATAL_IF(mCallback != NULL, "Don't call write if supplying a callback.");
Andreas Huber20111aa2009-07-14 16:56:47 -07002247
Steve Block3856b092011-10-20 11:56:00 +01002248 //ALOGV("write(%p, %u)", buffer, size);
Glenn Kasten2799d742013-05-30 14:33:29 -07002249 if (mTrack != 0) {
Andy Hung2f6e73d2016-04-08 12:12:58 -07002250 return mTrack->write(buffer, size, blocking);
Marco Nelissen10dbb8e2009-09-20 10:42:13 -07002251 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002252 return NO_INIT;
2253}
2254
2255void MediaPlayerService::AudioOutput::stop()
2256{
Steve Block3856b092011-10-20 11:56:00 +01002257 ALOGV("stop");
Andy Hungd1c74342015-07-07 16:54:23 -07002258 Mutex::Autolock lock(mLock);
Glenn Kasten2799d742013-05-30 14:33:29 -07002259 if (mTrack != 0) mTrack->stop();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002260}
2261
2262void MediaPlayerService::AudioOutput::flush()
2263{
Steve Block3856b092011-10-20 11:56:00 +01002264 ALOGV("flush");
Andy Hungd1c74342015-07-07 16:54:23 -07002265 Mutex::Autolock lock(mLock);
Glenn Kasten2799d742013-05-30 14:33:29 -07002266 if (mTrack != 0) mTrack->flush();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002267}
2268
2269void MediaPlayerService::AudioOutput::pause()
2270{
Steve Block3856b092011-10-20 11:56:00 +01002271 ALOGV("pause");
Andy Hungd1c74342015-07-07 16:54:23 -07002272 Mutex::Autolock lock(mLock);
Glenn Kasten2799d742013-05-30 14:33:29 -07002273 if (mTrack != 0) mTrack->pause();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002274}
2275
2276void MediaPlayerService::AudioOutput::close()
2277{
Steve Block3856b092011-10-20 11:56:00 +01002278 ALOGV("close");
Erik Wolsheimer7845a1f2015-10-30 12:07:52 -07002279 sp<AudioTrack> track;
2280 {
2281 Mutex::Autolock lock(mLock);
2282 track = mTrack;
2283 close_l(); // clears mTrack
2284 }
2285 // destruction of the track occurs outside of mutex.
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002286}
2287
2288void MediaPlayerService::AudioOutput::setVolume(float left, float right)
2289{
Steve Block3856b092011-10-20 11:56:00 +01002290 ALOGV("setVolume(%f, %f)", left, right);
Andy Hungd1c74342015-07-07 16:54:23 -07002291 Mutex::Autolock lock(mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002292 mLeftVolume = left;
2293 mRightVolume = right;
Glenn Kasten2799d742013-05-30 14:33:29 -07002294 if (mTrack != 0) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002295 mTrack->setVolume(left, right);
2296 }
2297}
2298
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002299status_t MediaPlayerService::AudioOutput::setPlaybackRate(const AudioPlaybackRate &rate)
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002300{
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002301 ALOGV("setPlaybackRate(%f %f %d %d)",
2302 rate.mSpeed, rate.mPitch, rate.mFallbackMode, rate.mStretchMode);
Andy Hungd1c74342015-07-07 16:54:23 -07002303 Mutex::Autolock lock(mLock);
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002304 if (mTrack == 0) {
2305 // remember rate so that we can set it when the track is opened
2306 mPlaybackRate = rate;
2307 return OK;
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002308 }
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002309 status_t res = mTrack->setPlaybackRate(rate);
2310 if (res != NO_ERROR) {
2311 return res;
2312 }
2313 // rate.mSpeed is always greater than 0 if setPlaybackRate succeeded
2314 CHECK_GT(rate.mSpeed, 0.f);
2315 mPlaybackRate = rate;
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002316 if (mSampleRateHz != 0) {
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002317 mMsecsPerFrame = 1E3f / (rate.mSpeed * mSampleRateHz);
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08002318 }
2319 return res;
2320}
2321
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002322status_t MediaPlayerService::AudioOutput::getPlaybackRate(AudioPlaybackRate *rate)
2323{
2324 ALOGV("setPlaybackRate");
Andy Hungd1c74342015-07-07 16:54:23 -07002325 Mutex::Autolock lock(mLock);
Lajos Molnar3a474aa2015-04-24 17:10:07 -07002326 if (mTrack == 0) {
2327 return NO_INIT;
2328 }
2329 *rate = mTrack->getPlaybackRate();
2330 return NO_ERROR;
2331}
2332
Eric Laurent2beeb502010-07-16 07:43:46 -07002333status_t MediaPlayerService::AudioOutput::setAuxEffectSendLevel(float level)
2334{
Steve Block3856b092011-10-20 11:56:00 +01002335 ALOGV("setAuxEffectSendLevel(%f)", level);
Andy Hungd1c74342015-07-07 16:54:23 -07002336 Mutex::Autolock lock(mLock);
Eric Laurent2beeb502010-07-16 07:43:46 -07002337 mSendLevel = level;
Glenn Kasten2799d742013-05-30 14:33:29 -07002338 if (mTrack != 0) {
Eric Laurent2beeb502010-07-16 07:43:46 -07002339 return mTrack->setAuxEffectSendLevel(level);
2340 }
2341 return NO_ERROR;
2342}
2343
2344status_t MediaPlayerService::AudioOutput::attachAuxEffect(int effectId)
2345{
Steve Block3856b092011-10-20 11:56:00 +01002346 ALOGV("attachAuxEffect(%d)", effectId);
Andy Hungd1c74342015-07-07 16:54:23 -07002347 Mutex::Autolock lock(mLock);
Eric Laurent2beeb502010-07-16 07:43:46 -07002348 mAuxEffectId = effectId;
Glenn Kasten2799d742013-05-30 14:33:29 -07002349 if (mTrack != 0) {
Eric Laurent2beeb502010-07-16 07:43:46 -07002350 return mTrack->attachAuxEffect(effectId);
2351 }
2352 return NO_ERROR;
2353}
2354
jiabin156c6872017-10-06 09:47:15 -07002355status_t MediaPlayerService::AudioOutput::setOutputDevice(audio_port_handle_t deviceId)
2356{
2357 ALOGV("setOutputDevice(%d)", deviceId);
2358 Mutex::Autolock lock(mLock);
2359 mSelectedDeviceId = deviceId;
2360 if (mTrack != 0) {
2361 return mTrack->setOutputDevice(deviceId);
2362 }
2363 return NO_ERROR;
2364}
2365
2366status_t MediaPlayerService::AudioOutput::getRoutedDeviceId(audio_port_handle_t* deviceId)
2367{
2368 ALOGV("getRoutedDeviceId");
2369 Mutex::Autolock lock(mLock);
2370 if (mTrack != 0) {
2371 *deviceId = mTrack->getRoutedDeviceId();
2372 return NO_ERROR;
2373 }
2374 return NO_INIT;
2375}
2376
2377status_t MediaPlayerService::AudioOutput::enableAudioDeviceCallback(bool enabled)
2378{
2379 ALOGV("enableAudioDeviceCallback, %d", enabled);
2380 Mutex::Autolock lock(mLock);
2381 mDeviceCallbackEnabled = enabled;
2382 if (mTrack != 0) {
2383 status_t status;
2384 if (enabled) {
2385 status = mTrack->addAudioDeviceCallback(mDeviceCallback.promote());
2386 } else {
2387 status = mTrack->removeAudioDeviceCallback(mDeviceCallback.promote());
2388 }
2389 return status;
2390 }
2391 return NO_ERROR;
2392}
2393
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002394VolumeShaper::Status MediaPlayerService::AudioOutput::applyVolumeShaper(
2395 const sp<VolumeShaper::Configuration>& configuration,
2396 const sp<VolumeShaper::Operation>& operation)
2397{
2398 Mutex::Autolock lock(mLock);
2399 ALOGV("AudioOutput::applyVolumeShaper");
Andy Hung4ef88d72017-02-21 19:47:53 -08002400
Andy Hung4ef88d72017-02-21 19:47:53 -08002401 mVolumeHandler->setIdIfNecessary(configuration);
Andy Hung39399b62017-04-21 15:07:45 -07002402
2403 VolumeShaper::Status status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002404 if (mTrack != 0) {
Andy Hung39399b62017-04-21 15:07:45 -07002405 status = mTrack->applyVolumeShaper(configuration, operation);
2406 if (status >= 0) {
2407 (void)mVolumeHandler->applyVolumeShaper(configuration, operation);
Andy Hungf3702642017-05-05 17:33:32 -07002408 if (mTrack->isPlaying()) { // match local AudioTrack to properly restore.
2409 mVolumeHandler->setStarted();
2410 }
Andy Hung39399b62017-04-21 15:07:45 -07002411 }
Andy Hung4ef88d72017-02-21 19:47:53 -08002412 } else {
Andy Hungc01eddb2017-07-21 16:42:41 -07002413 // VolumeShapers are not affected when a track moves between players for
2414 // gapless playback (setNextMediaPlayer).
2415 // We forward VolumeShaper operations that do not change configuration
2416 // to the new player so that unducking may occur as expected.
2417 // Unducking is an idempotent operation, same if applied back-to-back.
2418 if (configuration->getType() == VolumeShaper::Configuration::TYPE_ID
2419 && mNextOutput != nullptr) {
2420 ALOGV("applyVolumeShaper: Attempting to forward missed operation: %s %s",
2421 configuration->toString().c_str(), operation->toString().c_str());
2422 Mutex::Autolock nextLock(mNextOutput->mLock);
2423
2424 // recycled track should be forwarded from this AudioSink by switchToNextOutput
2425 sp<AudioTrack> track = mNextOutput->mRecycledTrack;
2426 if (track != nullptr) {
2427 ALOGD("Forward VolumeShaper operation to recycled track %p", track.get());
2428 (void)track->applyVolumeShaper(configuration, operation);
2429 } else {
2430 // There is a small chance that the unduck occurs after the next
2431 // player has already started, but before it is registered to receive
2432 // the unduck command.
2433 track = mNextOutput->mTrack;
2434 if (track != nullptr) {
2435 ALOGD("Forward VolumeShaper operation to track %p", track.get());
2436 (void)track->applyVolumeShaper(configuration, operation);
2437 }
2438 }
2439 }
Andy Hung39399b62017-04-21 15:07:45 -07002440 status = mVolumeHandler->applyVolumeShaper(configuration, operation);
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002441 }
Andy Hung39399b62017-04-21 15:07:45 -07002442 return status;
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002443}
2444
2445sp<VolumeShaper::State> MediaPlayerService::AudioOutput::getVolumeShaperState(int id)
2446{
2447 Mutex::Autolock lock(mLock);
2448 if (mTrack != 0) {
2449 return mTrack->getVolumeShaperState(id);
Andy Hung4ef88d72017-02-21 19:47:53 -08002450 } else {
2451 return mVolumeHandler->getVolumeShaperState(id);
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002452 }
Andy Hung9fc8b5c2017-01-24 13:36:48 -08002453}
2454
Andreas Huber20111aa2009-07-14 16:56:47 -07002455// static
2456void MediaPlayerService::AudioOutput::CallbackWrapper(
Glenn Kastend217a8c2011-06-01 15:20:35 -07002457 int event, void *cookie, void *info) {
Steve Block3856b092011-10-20 11:56:00 +01002458 //ALOGV("callbackwrapper");
Marco Nelissen6b74d672012-02-28 16:07:44 -08002459 CallbackData *data = (CallbackData*)cookie;
Andy Hungd1c74342015-07-07 16:54:23 -07002460 // lock to ensure we aren't caught in the middle of a track switch.
Marco Nelissen6b74d672012-02-28 16:07:44 -08002461 data->lock();
2462 AudioOutput *me = data->getOutput();
Andreas Huber20111aa2009-07-14 16:56:47 -07002463 AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
Marco Nelissen6b74d672012-02-28 16:07:44 -08002464 if (me == NULL) {
2465 // no output set, likely because the track was scheduled to be reused
2466 // by another player, but the format turned out to be incompatible.
2467 data->unlock();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002468 if (buffer != NULL) {
2469 buffer->size = 0;
2470 }
Marco Nelissen6b74d672012-02-28 16:07:44 -08002471 return;
2472 }
Andreas Huber20111aa2009-07-14 16:56:47 -07002473
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002474 switch(event) {
2475 case AudioTrack::EVENT_MORE_DATA: {
2476 size_t actualSize = (*me->mCallback)(
2477 me, buffer->raw, buffer->size, me->mCallbackCookie,
2478 CB_EVENT_FILL_BUFFER);
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002479
Andy Hung719b46b2015-05-31 22:18:25 -07002480 // Log when no data is returned from the callback.
2481 // (1) We may have no data (especially with network streaming sources).
2482 // (2) We may have reached the EOS and the audio track is not stopped yet.
2483 // Note that AwesomePlayer/AudioPlayer will only return zero size when it reaches the EOS.
2484 // NuPlayerRenderer will return zero when it doesn't have data (it doesn't block to fill).
2485 //
2486 // This is a benign busy-wait, with the next data request generated 10 ms or more later;
2487 // nevertheless for power reasons, we don't want to see too many of these.
Andreas Huber2e8ffaf2010-02-18 16:45:13 -08002488
Andy Hung719b46b2015-05-31 22:18:25 -07002489 ALOGV_IF(actualSize == 0 && buffer->size > 0, "callbackwrapper: empty buffer returned");
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002490
2491 buffer->size = actualSize;
2492 } break;
2493
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002494 case AudioTrack::EVENT_STREAM_END:
Andy Hung719b46b2015-05-31 22:18:25 -07002495 // currently only occurs for offloaded callbacks
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002496 ALOGV("callbackwrapper: deliver EVENT_STREAM_END");
2497 (*me->mCallback)(me, NULL /* buffer */, 0 /* size */,
2498 me->mCallbackCookie, CB_EVENT_STREAM_END);
2499 break;
2500
2501 case AudioTrack::EVENT_NEW_IAUDIOTRACK :
2502 ALOGV("callbackwrapper: deliver EVENT_TEAR_DOWN");
2503 (*me->mCallback)(me, NULL /* buffer */, 0 /* size */,
2504 me->mCallbackCookie, CB_EVENT_TEAR_DOWN);
2505 break;
2506
Glenn Kasten421743b2015-06-01 08:18:08 -07002507 case AudioTrack::EVENT_UNDERRUN:
Andy Hung719b46b2015-05-31 22:18:25 -07002508 // This occurs when there is no data available, typically
Glenn Kasten421743b2015-06-01 08:18:08 -07002509 // when there is a failure to supply data to the AudioTrack. It can also
2510 // occur in non-offloaded mode when the audio device comes out of standby.
2511 //
Andy Hung719b46b2015-05-31 22:18:25 -07002512 // If an AudioTrack underruns it outputs silence. Since this happens suddenly
2513 // it may sound like an audible pop or glitch.
2514 //
2515 // The underrun event is sent once per track underrun; the condition is reset
2516 // when more data is sent to the AudioTrack.
Eric Laurente93cc032016-05-05 10:15:10 -07002517 ALOGD("callbackwrapper: EVENT_UNDERRUN (discarded)");
Glenn Kasten421743b2015-06-01 08:18:08 -07002518 break;
2519
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01002520 default:
2521 ALOGE("received unknown event type: %d inside CallbackWrapper !", event);
Andreas Huber51c1e0e2011-04-04 11:43:40 -07002522 }
2523
Marco Nelissen6b74d672012-02-28 16:07:44 -08002524 data->unlock();
Andreas Huber20111aa2009-07-14 16:56:47 -07002525}
2526
Glenn Kastend848eb42016-03-08 13:42:11 -08002527audio_session_t MediaPlayerService::AudioOutput::getSessionId() const
Eric Laurent8c563ed2010-10-07 18:23:03 -07002528{
Andy Hungd1c74342015-07-07 16:54:23 -07002529 Mutex::Autolock lock(mLock);
Eric Laurent8c563ed2010-10-07 18:23:03 -07002530 return mSessionId;
2531}
2532
Eric Laurent6f59db12013-07-26 17:16:50 -07002533uint32_t MediaPlayerService::AudioOutput::getSampleRate() const
2534{
Andy Hungd1c74342015-07-07 16:54:23 -07002535 Mutex::Autolock lock(mLock);
Eric Laurent6f59db12013-07-26 17:16:50 -07002536 if (mTrack == 0) return 0;
2537 return mTrack->getSampleRate();
2538}
2539
Andy Hungf2c87b32016-04-07 19:49:29 -07002540int64_t MediaPlayerService::AudioOutput::getBufferDurationInUs() const
2541{
2542 Mutex::Autolock lock(mLock);
2543 if (mTrack == 0) {
2544 return 0;
2545 }
2546 int64_t duration;
2547 if (mTrack->getBufferDurationInUs(&duration) != OK) {
2548 return 0;
2549 }
2550 return duration;
2551}
2552
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002553////////////////////////////////////////////////////////////////////////////////
2554
2555struct CallbackThread : public Thread {
2556 CallbackThread(const wp<MediaPlayerBase::AudioSink> &sink,
2557 MediaPlayerBase::AudioSink::AudioCallback cb,
2558 void *cookie);
2559
2560protected:
2561 virtual ~CallbackThread();
2562
2563 virtual bool threadLoop();
2564
2565private:
2566 wp<MediaPlayerBase::AudioSink> mSink;
2567 MediaPlayerBase::AudioSink::AudioCallback mCallback;
2568 void *mCookie;
2569 void *mBuffer;
2570 size_t mBufferSize;
2571
2572 CallbackThread(const CallbackThread &);
2573 CallbackThread &operator=(const CallbackThread &);
2574};
2575
2576CallbackThread::CallbackThread(
2577 const wp<MediaPlayerBase::AudioSink> &sink,
2578 MediaPlayerBase::AudioSink::AudioCallback cb,
2579 void *cookie)
2580 : mSink(sink),
2581 mCallback(cb),
2582 mCookie(cookie),
2583 mBuffer(NULL),
2584 mBufferSize(0) {
2585}
2586
2587CallbackThread::~CallbackThread() {
2588 if (mBuffer) {
2589 free(mBuffer);
2590 mBuffer = NULL;
2591 }
2592}
2593
2594bool CallbackThread::threadLoop() {
2595 sp<MediaPlayerBase::AudioSink> sink = mSink.promote();
2596 if (sink == NULL) {
2597 return false;
2598 }
2599
2600 if (mBuffer == NULL) {
2601 mBufferSize = sink->bufferSize();
2602 mBuffer = malloc(mBufferSize);
2603 }
2604
2605 size_t actualSize =
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00002606 (*mCallback)(sink.get(), mBuffer, mBufferSize, mCookie,
2607 MediaPlayerBase::AudioSink::CB_EVENT_FILL_BUFFER);
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002608
2609 if (actualSize > 0) {
2610 sink->write(mBuffer, actualSize);
Andy Hunga31335a2014-08-20 17:37:59 -07002611 // Could return false on sink->write() error or short count.
2612 // Not necessarily appropriate but would work for AudioCache behavior.
Andreas Huber7d5b8a72010-02-09 16:59:18 -08002613 }
2614
2615 return true;
2616}
2617
2618////////////////////////////////////////////////////////////////////////////////
2619
Chong Zhange5b9b692017-05-11 11:44:56 -07002620void MediaPlayerService::addBatteryData(uint32_t params) {
2621 mBatteryTracker.addBatteryData(params);
2622}
2623
2624status_t MediaPlayerService::pullBatteryData(Parcel* reply) {
2625 return mBatteryTracker.pullBatteryData(reply);
2626}
2627
2628MediaPlayerService::BatteryTracker::BatteryTracker() {
2629 mBatteryAudio.refCount = 0;
2630 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2631 mBatteryAudio.deviceOn[i] = 0;
2632 mBatteryAudio.lastTime[i] = 0;
2633 mBatteryAudio.totalTime[i] = 0;
2634 }
2635 // speaker is on by default
2636 mBatteryAudio.deviceOn[SPEAKER] = 1;
2637
2638 // reset battery stats
2639 // if the mediaserver has crashed, battery stats could be left
2640 // in bad state, reset the state upon service start.
2641 BatteryNotifier::getInstance().noteResetVideo();
2642}
2643
2644void MediaPlayerService::BatteryTracker::addBatteryData(uint32_t params)
Gloria Wang7cf180c2011-02-19 18:37:57 -08002645{
2646 Mutex::Autolock lock(mLock);
Gloria Wang9ee159b2011-02-24 14:51:45 -08002647
2648 int32_t time = systemTime() / 1000000L;
2649
2650 // change audio output devices. This notification comes from AudioFlinger
2651 if ((params & kBatteryDataSpeakerOn)
2652 || (params & kBatteryDataOtherAudioDeviceOn)) {
2653
2654 int deviceOn[NUM_AUDIO_DEVICES];
2655 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2656 deviceOn[i] = 0;
2657 }
2658
2659 if ((params & kBatteryDataSpeakerOn)
2660 && (params & kBatteryDataOtherAudioDeviceOn)) {
2661 deviceOn[SPEAKER_AND_OTHER] = 1;
2662 } else if (params & kBatteryDataSpeakerOn) {
2663 deviceOn[SPEAKER] = 1;
2664 } else {
2665 deviceOn[OTHER_AUDIO_DEVICE] = 1;
2666 }
2667
2668 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2669 if (mBatteryAudio.deviceOn[i] != deviceOn[i]){
2670
2671 if (mBatteryAudio.refCount > 0) { // if playing audio
2672 if (!deviceOn[i]) {
2673 mBatteryAudio.lastTime[i] += time;
2674 mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
2675 mBatteryAudio.lastTime[i] = 0;
2676 } else {
2677 mBatteryAudio.lastTime[i] = 0 - time;
2678 }
2679 }
2680
2681 mBatteryAudio.deviceOn[i] = deviceOn[i];
2682 }
2683 }
2684 return;
2685 }
2686
Marco Nelissenb7848f12014-12-04 08:57:56 -08002687 // an audio stream is started
Gloria Wang9ee159b2011-02-24 14:51:45 -08002688 if (params & kBatteryDataAudioFlingerStart) {
2689 // record the start time only if currently no other audio
2690 // is being played
2691 if (mBatteryAudio.refCount == 0) {
2692 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2693 if (mBatteryAudio.deviceOn[i]) {
2694 mBatteryAudio.lastTime[i] -= time;
2695 }
2696 }
2697 }
2698
2699 mBatteryAudio.refCount ++;
2700 return;
2701
2702 } else if (params & kBatteryDataAudioFlingerStop) {
2703 if (mBatteryAudio.refCount <= 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002704 ALOGW("Battery track warning: refCount is <= 0");
Gloria Wang9ee159b2011-02-24 14:51:45 -08002705 return;
2706 }
2707
2708 // record the stop time only if currently this is the only
2709 // audio being played
2710 if (mBatteryAudio.refCount == 1) {
2711 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2712 if (mBatteryAudio.deviceOn[i]) {
2713 mBatteryAudio.lastTime[i] += time;
2714 mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
2715 mBatteryAudio.lastTime[i] = 0;
2716 }
2717 }
2718 }
2719
2720 mBatteryAudio.refCount --;
2721 return;
2722 }
2723
Andy Hung1afd0982016-11-08 16:13:44 -08002724 uid_t uid = IPCThreadState::self()->getCallingUid();
Gloria Wang7cf180c2011-02-19 18:37:57 -08002725 if (uid == AID_MEDIA) {
2726 return;
2727 }
2728 int index = mBatteryData.indexOfKey(uid);
Gloria Wang7cf180c2011-02-19 18:37:57 -08002729
2730 if (index < 0) { // create a new entry for this UID
2731 BatteryUsageInfo info;
2732 info.audioTotalTime = 0;
2733 info.videoTotalTime = 0;
2734 info.audioLastTime = 0;
2735 info.videoLastTime = 0;
2736 info.refCount = 0;
2737
Gloria Wang9ee159b2011-02-24 14:51:45 -08002738 if (mBatteryData.add(uid, info) == NO_MEMORY) {
Steve Block29357bc2012-01-06 19:20:56 +00002739 ALOGE("Battery track error: no memory for new app");
Gloria Wang9ee159b2011-02-24 14:51:45 -08002740 return;
2741 }
Gloria Wang7cf180c2011-02-19 18:37:57 -08002742 }
2743
2744 BatteryUsageInfo &info = mBatteryData.editValueFor(uid);
2745
2746 if (params & kBatteryDataCodecStarted) {
2747 if (params & kBatteryDataTrackAudio) {
2748 info.audioLastTime -= time;
2749 info.refCount ++;
2750 }
2751 if (params & kBatteryDataTrackVideo) {
2752 info.videoLastTime -= time;
2753 info.refCount ++;
2754 }
2755 } else {
2756 if (info.refCount == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002757 ALOGW("Battery track warning: refCount is already 0");
Gloria Wang7cf180c2011-02-19 18:37:57 -08002758 return;
2759 } else if (info.refCount < 0) {
Steve Block29357bc2012-01-06 19:20:56 +00002760 ALOGE("Battery track error: refCount < 0");
Gloria Wang7cf180c2011-02-19 18:37:57 -08002761 mBatteryData.removeItem(uid);
2762 return;
2763 }
2764
2765 if (params & kBatteryDataTrackAudio) {
2766 info.audioLastTime += time;
2767 info.refCount --;
2768 }
2769 if (params & kBatteryDataTrackVideo) {
2770 info.videoLastTime += time;
2771 info.refCount --;
2772 }
2773
2774 // no stream is being played by this UID
2775 if (info.refCount == 0) {
2776 info.audioTotalTime += info.audioLastTime;
2777 info.audioLastTime = 0;
2778 info.videoTotalTime += info.videoLastTime;
2779 info.videoLastTime = 0;
2780 }
2781 }
2782}
2783
Chong Zhange5b9b692017-05-11 11:44:56 -07002784status_t MediaPlayerService::BatteryTracker::pullBatteryData(Parcel* reply) {
Gloria Wang7cf180c2011-02-19 18:37:57 -08002785 Mutex::Autolock lock(mLock);
Gloria Wang9ee159b2011-02-24 14:51:45 -08002786
2787 // audio output devices usage
2788 int32_t time = systemTime() / 1000000L; //in ms
2789 int32_t totalTime;
2790
2791 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2792 totalTime = mBatteryAudio.totalTime[i];
2793
2794 if (mBatteryAudio.deviceOn[i]
2795 && (mBatteryAudio.lastTime[i] != 0)) {
2796 int32_t tmpTime = mBatteryAudio.lastTime[i] + time;
2797 totalTime += tmpTime;
2798 }
2799
2800 reply->writeInt32(totalTime);
2801 // reset the total time
2802 mBatteryAudio.totalTime[i] = 0;
2803 }
2804
2805 // codec usage
Gloria Wang7cf180c2011-02-19 18:37:57 -08002806 BatteryUsageInfo info;
2807 int size = mBatteryData.size();
2808
2809 reply->writeInt32(size);
2810 int i = 0;
2811
2812 while (i < size) {
2813 info = mBatteryData.valueAt(i);
2814
2815 reply->writeInt32(mBatteryData.keyAt(i)); //UID
2816 reply->writeInt32(info.audioTotalTime);
2817 reply->writeInt32(info.videoTotalTime);
2818
2819 info.audioTotalTime = 0;
2820 info.videoTotalTime = 0;
2821
2822 // remove the UID entry where no stream is being played
2823 if (info.refCount <= 0) {
2824 mBatteryData.removeItemsAt(i);
2825 size --;
2826 i --;
2827 }
2828 i++;
2829 }
2830 return NO_ERROR;
2831}
nikoa64c8c72009-07-20 15:07:26 -07002832} // namespace android