blob: 9553458c595a2cd1b8b8496bad999accd50dc302 [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>
Nicolas Catania1d187f12009-05-12 23:25:55 -070045#include <utils/Vector.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080046
Jeff Brown2013a542012-09-04 21:38:42 -070047#include <media/IRemoteDisplay.h>
48#include <media/IRemoteDisplayClient.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080049#include <media/MediaPlayerInterface.h>
50#include <media/mediarecorder.h>
51#include <media/MediaMetadataRetrieverInterface.h>
nikoa64c8c72009-07-20 15:07:26 -070052#include <media/Metadata.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080053#include <media/AudioTrack.h>
James Dong8635b7b2011-03-14 17:01:38 -070054#include <media/MemoryLeakTrackUtil.h>
Eric Laurent9cb839a2011-09-27 09:48:56 -070055#include <media/stagefright/MediaErrors.h>
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +010056#include <media/stagefright/AudioPlayer.h>
57#include <media/stagefright/foundation/ADebug.h>
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080058
Dima Zavin64760242011-05-11 14:15:23 -070059#include <system/audio.h>
Dima Zavinfce7a472011-04-19 22:30:36 -070060
Gloria Wang7cf180c2011-02-19 18:37:57 -080061#include <private/android_filesystem_config.h>
62
James Dong559bf282012-03-28 10:29:14 -070063#include "ActivityManager.h"
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080064#include "MediaRecorderClient.h"
65#include "MediaPlayerService.h"
66#include "MetadataRetrieverClient.h"
John Grossman44a7e422012-06-21 17:29:24 -070067#include "MediaPlayerFactory.h"
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -080068
69#include "MidiFile.h"
Nicolas Catania14d27472009-07-13 14:37:49 -070070#include "TestPlayerStub.h"
Andreas Huber20111aa2009-07-14 16:56:47 -070071#include "StagefrightPlayer.h"
Andreas Huberf9334412010-12-15 15:17:42 -080072#include "nuplayer/NuPlayerDriver.h"
Andreas Huber20111aa2009-07-14 16:56:47 -070073
Andreas Huber20111aa2009-07-14 16:56:47 -070074#include <OMX.h>
Nicolas Catania14d27472009-07-13 14:37:49 -070075
Andreas Hubered3e3e02012-03-26 11:13:27 -070076#include "Crypto.h"
Jeff Tinkercc82dc62013-02-08 10:18:35 -080077#include "Drm.h"
Andreas Huber59451f82012-09-18 10:36:32 -070078#include "HDCP.h"
Andreas Huberb7319a72013-05-29 14:20:52 -070079#include "HTTPBase.h"
Andreas Huber35213f12012-08-29 11:41:50 -070080#include "RemoteDisplay.h"
Andreas Hubered3e3e02012-03-26 11:13:27 -070081
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -070082namespace {
nikoa64c8c72009-07-20 15:07:26 -070083using android::media::Metadata;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -070084using android::status_t;
85using android::OK;
86using android::BAD_VALUE;
87using android::NOT_ENOUGH_DATA;
88using android::Parcel;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -070089
90// Max number of entries in the filter.
91const int kMaxFilterSize = 64; // I pulled that out of thin air.
92
nikoa64c8c72009-07-20 15:07:26 -070093// FIXME: Move all the metadata related function in the Metadata.cpp
nikod608a812009-07-16 16:39:53 -070094
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -070095
96// Unmarshall a filter from a Parcel.
97// Filter format in a parcel:
98//
99// 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
100// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
101// | number of entries (n) |
102// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
103// | metadata type 1 |
104// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
105// | metadata type 2 |
106// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
107// ....
108// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
109// | metadata type n |
110// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
111//
112// @param p Parcel that should start with a filter.
113// @param[out] filter On exit contains the list of metadata type to be
114// filtered.
115// @param[out] status On exit contains the status code to be returned.
116// @return true if the parcel starts with a valid filter.
117bool unmarshallFilter(const Parcel& p,
nikoa64c8c72009-07-20 15:07:26 -0700118 Metadata::Filter *filter,
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700119 status_t *status)
120{
Nicolas Catania48290382009-07-10 13:53:06 -0700121 int32_t val;
122 if (p.readInt32(&val) != OK)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700123 {
Steve Block29357bc2012-01-06 19:20:56 +0000124 ALOGE("Failed to read filter's length");
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700125 *status = NOT_ENOUGH_DATA;
126 return false;
127 }
128
Nicolas Catania48290382009-07-10 13:53:06 -0700129 if( val > kMaxFilterSize || val < 0)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700130 {
Steve Block29357bc2012-01-06 19:20:56 +0000131 ALOGE("Invalid filter len %d", val);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700132 *status = BAD_VALUE;
133 return false;
134 }
135
Nicolas Catania48290382009-07-10 13:53:06 -0700136 const size_t num = val;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700137
138 filter->clear();
Nicolas Catania48290382009-07-10 13:53:06 -0700139 filter->setCapacity(num);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700140
nikoa64c8c72009-07-20 15:07:26 -0700141 size_t size = num * sizeof(Metadata::Type);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700142
Nicolas Catania48290382009-07-10 13:53:06 -0700143
144 if (p.dataAvail() < size)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700145 {
Steve Block29357bc2012-01-06 19:20:56 +0000146 ALOGE("Filter too short expected %d but got %d", size, p.dataAvail());
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700147 *status = NOT_ENOUGH_DATA;
148 return false;
149 }
150
nikoa64c8c72009-07-20 15:07:26 -0700151 const Metadata::Type *data =
152 static_cast<const Metadata::Type*>(p.readInplace(size));
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700153
Nicolas Catania48290382009-07-10 13:53:06 -0700154 if (NULL == data)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700155 {
Steve Block29357bc2012-01-06 19:20:56 +0000156 ALOGE("Filter had no data");
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700157 *status = BAD_VALUE;
158 return false;
159 }
160
161 // TODO: The stl impl of vector would be more efficient here
162 // because it degenerates into a memcpy on pod types. Try to
163 // replace later or use stl::set.
Nicolas Catania48290382009-07-10 13:53:06 -0700164 for (size_t i = 0; i < num; ++i)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700165 {
Nicolas Catania48290382009-07-10 13:53:06 -0700166 filter->add(*data);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700167 ++data;
168 }
169 *status = OK;
170 return true;
171}
172
Nicolas Catania48290382009-07-10 13:53:06 -0700173// @param filter Of metadata type.
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700174// @param val To be searched.
175// @return true if a match was found.
nikoa64c8c72009-07-20 15:07:26 -0700176bool findMetadata(const Metadata::Filter& filter, const int32_t val)
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700177{
178 // Deal with empty and ANY right away
179 if (filter.isEmpty()) return false;
nikoa64c8c72009-07-20 15:07:26 -0700180 if (filter[0] == Metadata::kAny) return true;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700181
Nicolas Catania48290382009-07-10 13:53:06 -0700182 return filter.indexOf(val) >= 0;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700183}
184
185} // anonymous namespace
186
187
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800188namespace android {
189
Dave Burked681bbb2011-08-30 14:39:17 +0100190static bool checkPermission(const char* permissionString) {
191#ifndef HAVE_ANDROID_OS
192 return true;
193#endif
194 if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
195 bool ok = checkCallingPermission(String16(permissionString));
Steve Block29357bc2012-01-06 19:20:56 +0000196 if (!ok) ALOGE("Request requires %s", permissionString);
Dave Burked681bbb2011-08-30 14:39:17 +0100197 return ok;
198}
199
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800200// 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 -0800201/* static */ int MediaPlayerService::AudioOutput::mMinBufferCount = 4;
202/* static */ bool MediaPlayerService::AudioOutput::mIsOnEmulator = false;
203
204void MediaPlayerService::instantiate() {
205 defaultServiceManager()->addService(
206 String16("media.player"), new MediaPlayerService());
207}
208
209MediaPlayerService::MediaPlayerService()
210{
Steve Block3856b092011-10-20 11:56:00 +0100211 ALOGV("MediaPlayerService created");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800212 mNextConnId = 1;
Gloria Wang9ee159b2011-02-24 14:51:45 -0800213
214 mBatteryAudio.refCount = 0;
215 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
216 mBatteryAudio.deviceOn[i] = 0;
217 mBatteryAudio.lastTime[i] = 0;
218 mBatteryAudio.totalTime[i] = 0;
219 }
220 // speaker is on by default
221 mBatteryAudio.deviceOn[SPEAKER] = 1;
John Grossman44a7e422012-06-21 17:29:24 -0700222
223 MediaPlayerFactory::registerBuiltinFactories();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800224}
225
226MediaPlayerService::~MediaPlayerService()
227{
Steve Block3856b092011-10-20 11:56:00 +0100228 ALOGV("MediaPlayerService destroyed");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800229}
230
Glenn Kastenf37971f2012-02-03 11:06:53 -0800231sp<IMediaRecorder> MediaPlayerService::createMediaRecorder()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800232{
Glenn Kastenf37971f2012-02-03 11:06:53 -0800233 pid_t pid = IPCThreadState::self()->getCallingPid();
Gloria Wangdac6a312009-10-29 15:46:37 -0700234 sp<MediaRecorderClient> recorder = new MediaRecorderClient(this, pid);
235 wp<MediaRecorderClient> w = recorder;
236 Mutex::Autolock lock(mLock);
237 mMediaRecorderClients.add(w);
Steve Block3856b092011-10-20 11:56:00 +0100238 ALOGV("Create new media recorder client from pid %d", pid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800239 return recorder;
240}
241
Gloria Wangdac6a312009-10-29 15:46:37 -0700242void MediaPlayerService::removeMediaRecorderClient(wp<MediaRecorderClient> client)
243{
244 Mutex::Autolock lock(mLock);
245 mMediaRecorderClients.remove(client);
Steve Block3856b092011-10-20 11:56:00 +0100246 ALOGV("Delete media recorder client");
Gloria Wangdac6a312009-10-29 15:46:37 -0700247}
248
Glenn Kastenf37971f2012-02-03 11:06:53 -0800249sp<IMediaMetadataRetriever> MediaPlayerService::createMetadataRetriever()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800250{
Glenn Kastenf37971f2012-02-03 11:06:53 -0800251 pid_t pid = IPCThreadState::self()->getCallingPid();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800252 sp<MetadataRetrieverClient> retriever = new MetadataRetrieverClient(pid);
Steve Block3856b092011-10-20 11:56:00 +0100253 ALOGV("Create new media retriever from pid %d", pid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800254 return retriever;
255}
256
Glenn Kastenf37971f2012-02-03 11:06:53 -0800257sp<IMediaPlayer> MediaPlayerService::create(const sp<IMediaPlayerClient>& client,
Dave Burked681bbb2011-08-30 14:39:17 +0100258 int audioSessionId)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800259{
Glenn Kastenf37971f2012-02-03 11:06:53 -0800260 pid_t pid = IPCThreadState::self()->getCallingPid();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800261 int32_t connId = android_atomic_inc(&mNextConnId);
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700262
263 sp<Client> c = new Client(
264 this, pid, connId, client, audioSessionId,
265 IPCThreadState::self()->getCallingUid());
266
Steve Block3856b092011-10-20 11:56:00 +0100267 ALOGV("Create new client(%d) from pid %d, uid %d, ", connId, pid,
Dave Burked681bbb2011-08-30 14:39:17 +0100268 IPCThreadState::self()->getCallingUid());
269
270 wp<Client> w = c;
271 {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800272 Mutex::Autolock lock(mLock);
273 mClients.add(w);
274 }
Andreas Hubere2b10282010-11-23 11:41:34 -0800275 return c;
276}
277
Andreas Huber318ad9c2009-10-15 13:46:54 -0700278sp<IOMX> MediaPlayerService::getOMX() {
279 Mutex::Autolock autoLock(mLock);
280
281 if (mOMX.get() == NULL) {
282 mOMX = new OMX;
283 }
284
285 return mOMX;
Andreas Huber20111aa2009-07-14 16:56:47 -0700286}
287
Andreas Hubered3e3e02012-03-26 11:13:27 -0700288sp<ICrypto> MediaPlayerService::makeCrypto() {
Andreas Huber1bd139a2012-04-03 14:19:20 -0700289 return new Crypto;
Andreas Hubered3e3e02012-03-26 11:13:27 -0700290}
291
Jeff Tinkercc82dc62013-02-08 10:18:35 -0800292sp<IDrm> MediaPlayerService::makeDrm() {
293 return new Drm;
294}
295
Andreas Huber279dcd82013-01-30 10:41:25 -0800296sp<IHDCP> MediaPlayerService::makeHDCP(bool createEncryptionModule) {
297 return new HDCP(createEncryptionModule);
Andreas Huber59451f82012-09-18 10:36:32 -0700298}
299
Jeff Brown2013a542012-09-04 21:38:42 -0700300sp<IRemoteDisplay> MediaPlayerService::listenForRemoteDisplay(
301 const sp<IRemoteDisplayClient>& client, const String8& iface) {
Jeff Brownaba33d52012-09-07 17:38:58 -0700302 if (!checkPermission("android.permission.CONTROL_WIFI_DISPLAY")) {
303 return NULL;
304 }
305
Jeff Brownced24b32012-09-05 17:48:03 -0700306 return new RemoteDisplay(client, iface.string());
Jeff Brown2013a542012-09-04 21:38:42 -0700307}
308
Andreas Huberb7319a72013-05-29 14:20:52 -0700309status_t MediaPlayerService::updateProxyConfig(
310 const char *host, int32_t port, const char *exclusionList) {
311 return HTTPBase::UpdateProxyConfig(host, port, exclusionList);
312}
313
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800314status_t MediaPlayerService::AudioCache::dump(int fd, const Vector<String16>& args) const
315{
316 const size_t SIZE = 256;
317 char buffer[SIZE];
318 String8 result;
319
320 result.append(" AudioCache\n");
321 if (mHeap != 0) {
Eric Laurent3d00aa62013-09-24 09:53:27 -0700322 snprintf(buffer, 255, " heap base(%p), size(%d), flags(%d)\n",
323 mHeap->getBase(), mHeap->getSize(), mHeap->getFlags());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800324 result.append(buffer);
325 }
Scott Fan7d409692013-04-28 10:13:54 +0800326 snprintf(buffer, 255, " msec per frame(%f), channel count(%d), format(%d), frame count(%zd)\n",
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800327 mMsecsPerFrame, mChannelCount, mFormat, mFrameCount);
328 result.append(buffer);
329 snprintf(buffer, 255, " sample rate(%d), size(%d), error(%d), command complete(%s)\n",
330 mSampleRate, mSize, mError, mCommandComplete?"true":"false");
331 result.append(buffer);
332 ::write(fd, result.string(), result.size());
333 return NO_ERROR;
334}
335
336status_t MediaPlayerService::AudioOutput::dump(int fd, const Vector<String16>& args) const
337{
338 const size_t SIZE = 256;
339 char buffer[SIZE];
340 String8 result;
341
342 result.append(" AudioOutput\n");
343 snprintf(buffer, 255, " stream type(%d), left - right volume(%f, %f)\n",
344 mStreamType, mLeftVolume, mRightVolume);
345 result.append(buffer);
346 snprintf(buffer, 255, " msec per frame(%f), latency (%d)\n",
Eric Laurentdb354e52012-03-05 17:27:11 -0800347 mMsecsPerFrame, (mTrack != 0) ? mTrack->latency() : -1);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800348 result.append(buffer);
Eric Laurent2beeb502010-07-16 07:43:46 -0700349 snprintf(buffer, 255, " aux effect id(%d), send level (%f)\n",
350 mAuxEffectId, mSendLevel);
351 result.append(buffer);
352
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800353 ::write(fd, result.string(), result.size());
354 if (mTrack != 0) {
355 mTrack->dump(fd, args);
356 }
357 return NO_ERROR;
358}
359
360status_t MediaPlayerService::Client::dump(int fd, const Vector<String16>& args) const
361{
362 const size_t SIZE = 256;
363 char buffer[SIZE];
364 String8 result;
365 result.append(" Client\n");
366 snprintf(buffer, 255, " pid(%d), connId(%d), status(%d), looping(%s)\n",
367 mPid, mConnId, mStatus, mLoop?"true": "false");
368 result.append(buffer);
369 write(fd, result.string(), result.size());
Andreas Hubera0b1d4b2011-06-07 15:52:25 -0700370 if (mPlayer != NULL) {
371 mPlayer->dump(fd, args);
372 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800373 if (mAudioOutput != 0) {
374 mAudioOutput->dump(fd, args);
375 }
376 write(fd, "\n", 1);
377 return NO_ERROR;
378}
379
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800380status_t MediaPlayerService::dump(int fd, const Vector<String16>& args)
381{
382 const size_t SIZE = 256;
383 char buffer[SIZE];
384 String8 result;
385 if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
386 snprintf(buffer, SIZE, "Permission Denial: "
387 "can't dump MediaPlayerService from pid=%d, uid=%d\n",
388 IPCThreadState::self()->getCallingPid(),
389 IPCThreadState::self()->getCallingUid());
390 result.append(buffer);
391 } else {
392 Mutex::Autolock lock(mLock);
393 for (int i = 0, n = mClients.size(); i < n; ++i) {
394 sp<Client> c = mClients[i].promote();
395 if (c != 0) c->dump(fd, args);
396 }
James Dongb9141222010-07-08 11:16:11 -0700397 if (mMediaRecorderClients.size() == 0) {
398 result.append(" No media recorder client\n\n");
399 } else {
400 for (int i = 0, n = mMediaRecorderClients.size(); i < n; ++i) {
401 sp<MediaRecorderClient> c = mMediaRecorderClients[i].promote();
James Donge579e282011-10-18 22:29:20 -0700402 if (c != 0) {
403 snprintf(buffer, 255, " MediaRecorderClient pid(%d)\n", c->mPid);
404 result.append(buffer);
405 write(fd, result.string(), result.size());
406 result = "\n";
407 c->dump(fd, args);
408 }
James Dongb9141222010-07-08 11:16:11 -0700409 }
Gloria Wangdac6a312009-10-29 15:46:37 -0700410 }
411
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800412 result.append(" Files opened and/or mapped:\n");
Glenn Kasten0512ab52011-05-04 17:58:57 -0700413 snprintf(buffer, SIZE, "/proc/%d/maps", gettid());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800414 FILE *f = fopen(buffer, "r");
415 if (f) {
416 while (!feof(f)) {
417 fgets(buffer, SIZE, f);
Marco Nelissen73ac1ee2012-05-07 15:36:32 -0700418 if (strstr(buffer, " /storage/") ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800419 strstr(buffer, " /system/sounds/") ||
Dave Sparks02fa8342010-09-27 16:55:18 -0700420 strstr(buffer, " /data/") ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800421 strstr(buffer, " /system/media/")) {
422 result.append(" ");
423 result.append(buffer);
424 }
425 }
426 fclose(f);
427 } else {
428 result.append("couldn't open ");
429 result.append(buffer);
430 result.append("\n");
431 }
432
Glenn Kasten0512ab52011-05-04 17:58:57 -0700433 snprintf(buffer, SIZE, "/proc/%d/fd", gettid());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800434 DIR *d = opendir(buffer);
435 if (d) {
436 struct dirent *ent;
437 while((ent = readdir(d)) != NULL) {
438 if (strcmp(ent->d_name,".") && strcmp(ent->d_name,"..")) {
Glenn Kasten0512ab52011-05-04 17:58:57 -0700439 snprintf(buffer, SIZE, "/proc/%d/fd/%s", gettid(), ent->d_name);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800440 struct stat s;
441 if (lstat(buffer, &s) == 0) {
442 if ((s.st_mode & S_IFMT) == S_IFLNK) {
443 char linkto[256];
444 int len = readlink(buffer, linkto, sizeof(linkto));
445 if(len > 0) {
446 if(len > 255) {
447 linkto[252] = '.';
448 linkto[253] = '.';
449 linkto[254] = '.';
450 linkto[255] = 0;
451 } else {
452 linkto[len] = 0;
453 }
Marco Nelissen73ac1ee2012-05-07 15:36:32 -0700454 if (strstr(linkto, "/storage/") == linkto ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800455 strstr(linkto, "/system/sounds/") == linkto ||
Dave Sparks02fa8342010-09-27 16:55:18 -0700456 strstr(linkto, "/data/") == linkto ||
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800457 strstr(linkto, "/system/media/") == linkto) {
458 result.append(" ");
459 result.append(buffer);
460 result.append(" -> ");
461 result.append(linkto);
462 result.append("\n");
463 }
464 }
465 } else {
466 result.append(" unexpected type for ");
467 result.append(buffer);
468 result.append("\n");
469 }
470 }
471 }
472 }
473 closedir(d);
474 } else {
475 result.append("couldn't open ");
476 result.append(buffer);
477 result.append("\n");
478 }
479
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800480 bool dumpMem = false;
481 for (size_t i = 0; i < args.size(); i++) {
482 if (args[i] == String16("-m")) {
483 dumpMem = true;
484 }
485 }
486 if (dumpMem) {
James Dong8635b7b2011-03-14 17:01:38 -0700487 dumpMemoryAddresses(fd);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800488 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800489 }
490 write(fd, result.string(), result.size());
491 return NO_ERROR;
492}
493
494void MediaPlayerService::removeClient(wp<Client> client)
495{
496 Mutex::Autolock lock(mLock);
497 mClients.remove(client);
498}
499
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700500MediaPlayerService::Client::Client(
501 const sp<MediaPlayerService>& service, pid_t pid,
502 int32_t connId, const sp<IMediaPlayerClient>& client,
503 int audioSessionId, uid_t uid)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800504{
Steve Block3856b092011-10-20 11:56:00 +0100505 ALOGV("Client(%d) constructor", connId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800506 mPid = pid;
507 mConnId = connId;
508 mService = service;
509 mClient = client;
510 mLoop = false;
511 mStatus = NO_INIT;
Eric Laurenta514bdb2010-06-21 09:27:30 -0700512 mAudioSessionId = audioSessionId;
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700513 mUID = uid;
John Grossmanc795b642012-02-22 15:38:35 -0800514 mRetransmitEndpointValid = false;
Eric Laurenta514bdb2010-06-21 09:27:30 -0700515
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800516#if CALLBACK_ANTAGONIZER
Steve Blockb8a80522011-12-20 16:23:08 +0000517 ALOGD("create Antagonizer");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800518 mAntagonizer = new Antagonizer(notify, this);
519#endif
520}
521
522MediaPlayerService::Client::~Client()
523{
Steve Block3856b092011-10-20 11:56:00 +0100524 ALOGV("Client(%d) destructor pid = %d", mConnId, mPid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800525 mAudioOutput.clear();
526 wp<Client> client(this);
527 disconnect();
528 mService->removeClient(client);
529}
530
531void MediaPlayerService::Client::disconnect()
532{
Steve Block3856b092011-10-20 11:56:00 +0100533 ALOGV("disconnect(%d) from pid %d", mConnId, mPid);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800534 // grab local reference and clear main reference to prevent future
535 // access to object
536 sp<MediaPlayerBase> p;
537 {
538 Mutex::Autolock l(mLock);
539 p = mPlayer;
beanzdcfefde2012-11-05 09:51:43 +0800540 mClient.clear();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800541 }
Andreas Huber20111aa2009-07-14 16:56:47 -0700542
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800543 mPlayer.clear();
544
545 // clear the notification to prevent callbacks to dead client
546 // and reset the player. We assume the player will serialize
547 // access to itself if necessary.
548 if (p != 0) {
549 p->setNotifyCallback(0, 0);
550#if CALLBACK_ANTAGONIZER
Steve Blockb8a80522011-12-20 16:23:08 +0000551 ALOGD("kill Antagonizer");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800552 mAntagonizer->kill();
553#endif
554 p->reset();
555 }
556
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700557 disconnectNativeWindow();
558
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800559 IPCThreadState::self()->flushCommands();
560}
561
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800562sp<MediaPlayerBase> MediaPlayerService::Client::createPlayer(player_type playerType)
563{
564 // determine if we have the right player type
565 sp<MediaPlayerBase> p = mPlayer;
566 if ((p != NULL) && (p->playerType() != playerType)) {
Steve Block3856b092011-10-20 11:56:00 +0100567 ALOGV("delete player");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800568 p.clear();
569 }
570 if (p == NULL) {
John Grossman44a7e422012-06-21 17:29:24 -0700571 p = MediaPlayerFactory::createPlayer(playerType, this, notify);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800572 }
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700573
Jason Simmonsdb29e522011-08-12 13:46:55 -0700574 if (p != NULL) {
575 p->setUID(mUID);
576 }
Andreas Huber9b80c2b2011-06-30 15:47:02 -0700577
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800578 return p;
579}
580
John Grossmanc795b642012-02-22 15:38:35 -0800581sp<MediaPlayerBase> MediaPlayerService::Client::setDataSource_pre(
582 player_type playerType)
583{
584 ALOGV("player type = %d", playerType);
585
586 // create the right type of player
587 sp<MediaPlayerBase> p = createPlayer(playerType);
588 if (p == NULL) {
589 return p;
590 }
591
592 if (!p->hardwareOutput()) {
593 mAudioOutput = new AudioOutput(mAudioSessionId);
594 static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
595 }
596
597 return p;
598}
599
600void MediaPlayerService::Client::setDataSource_post(
601 const sp<MediaPlayerBase>& p,
602 status_t status)
603{
604 ALOGV(" setDataSource");
605 mStatus = status;
606 if (mStatus != OK) {
607 ALOGE(" error: %d", mStatus);
608 return;
609 }
610
611 // Set the re-transmission endpoint if one was chosen.
612 if (mRetransmitEndpointValid) {
613 mStatus = p->setRetransmitEndpoint(&mRetransmitEndpoint);
614 if (mStatus != NO_ERROR) {
615 ALOGE("setRetransmitEndpoint error: %d", mStatus);
616 }
617 }
618
619 if (mStatus == OK) {
620 mPlayer = p;
621 }
622}
623
Andreas Huber2db84552010-01-28 11:19:57 -0800624status_t MediaPlayerService::Client::setDataSource(
625 const char *url, const KeyedVector<String8, String8> *headers)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800626{
Steve Block3856b092011-10-20 11:56:00 +0100627 ALOGV("setDataSource(%s)", url);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800628 if (url == NULL)
629 return UNKNOWN_ERROR;
630
Dave Burked681bbb2011-08-30 14:39:17 +0100631 if ((strncmp(url, "http://", 7) == 0) ||
632 (strncmp(url, "https://", 8) == 0) ||
633 (strncmp(url, "rtsp://", 7) == 0)) {
634 if (!checkPermission("android.permission.INTERNET")) {
635 return PERMISSION_DENIED;
636 }
637 }
638
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800639 if (strncmp(url, "content://", 10) == 0) {
640 // get a filedescriptor for the content Uri and
641 // pass it to the setDataSource(fd) method
642
643 String16 url16(url);
644 int fd = android::openContentProviderFile(url16);
645 if (fd < 0)
646 {
Steve Block29357bc2012-01-06 19:20:56 +0000647 ALOGE("Couldn't open fd for %s", url);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800648 return UNKNOWN_ERROR;
649 }
650 setDataSource(fd, 0, 0x7fffffffffLL); // this sets mStatus
651 close(fd);
652 return mStatus;
653 } else {
John Grossman44a7e422012-06-21 17:29:24 -0700654 player_type playerType = MediaPlayerFactory::getPlayerType(this, url);
John Grossmanc795b642012-02-22 15:38:35 -0800655 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
656 if (p == NULL) {
657 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800658 }
659
John Grossmanc795b642012-02-22 15:38:35 -0800660 setDataSource_post(p, p->setDataSource(url, headers));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800661 return mStatus;
662 }
663}
664
665status_t MediaPlayerService::Client::setDataSource(int fd, int64_t offset, int64_t length)
666{
Steve Block3856b092011-10-20 11:56:00 +0100667 ALOGV("setDataSource fd=%d, offset=%lld, length=%lld", fd, offset, length);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800668 struct stat sb;
669 int ret = fstat(fd, &sb);
670 if (ret != 0) {
Steve Block29357bc2012-01-06 19:20:56 +0000671 ALOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800672 return UNKNOWN_ERROR;
673 }
674
Steve Block3856b092011-10-20 11:56:00 +0100675 ALOGV("st_dev = %llu", sb.st_dev);
676 ALOGV("st_mode = %u", sb.st_mode);
677 ALOGV("st_uid = %lu", sb.st_uid);
678 ALOGV("st_gid = %lu", sb.st_gid);
679 ALOGV("st_size = %llu", sb.st_size);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800680
681 if (offset >= sb.st_size) {
Steve Block29357bc2012-01-06 19:20:56 +0000682 ALOGE("offset error");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800683 ::close(fd);
684 return UNKNOWN_ERROR;
685 }
686 if (offset + length > sb.st_size) {
687 length = sb.st_size - offset;
Steve Block3856b092011-10-20 11:56:00 +0100688 ALOGV("calculated length = %lld", length);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800689 }
690
John Grossman44a7e422012-06-21 17:29:24 -0700691 player_type playerType = MediaPlayerFactory::getPlayerType(this,
692 fd,
693 offset,
694 length);
John Grossmanc795b642012-02-22 15:38:35 -0800695 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
696 if (p == NULL) {
697 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800698 }
699
700 // now set data source
John Grossmanc795b642012-02-22 15:38:35 -0800701 setDataSource_post(p, p->setDataSource(fd, offset, length));
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800702 return mStatus;
703}
704
Andreas Hubere2b10282010-11-23 11:41:34 -0800705status_t MediaPlayerService::Client::setDataSource(
706 const sp<IStreamSource> &source) {
707 // create the right type of player
John Grossman44a7e422012-06-21 17:29:24 -0700708 player_type playerType = MediaPlayerFactory::getPlayerType(this, source);
John Grossmanc795b642012-02-22 15:38:35 -0800709 sp<MediaPlayerBase> p = setDataSource_pre(playerType);
Andreas Hubere2b10282010-11-23 11:41:34 -0800710 if (p == NULL) {
711 return NO_INIT;
712 }
713
Andreas Hubere2b10282010-11-23 11:41:34 -0800714 // now set data source
John Grossmanc795b642012-02-22 15:38:35 -0800715 setDataSource_post(p, p->setDataSource(source));
Andreas Hubere2b10282010-11-23 11:41:34 -0800716 return mStatus;
717}
718
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700719void MediaPlayerService::Client::disconnectNativeWindow() {
720 if (mConnectedWindow != NULL) {
721 status_t err = native_window_api_disconnect(mConnectedWindow.get(),
722 NATIVE_WINDOW_API_MEDIA);
723
724 if (err != OK) {
Steve Block5ff1dd52012-01-05 23:22:43 +0000725 ALOGW("native_window_api_disconnect returned an error: %s (%d)",
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700726 strerror(-err), err);
727 }
728 }
729 mConnectedWindow.clear();
730}
731
Glenn Kasten11731182011-02-08 17:26:17 -0800732status_t MediaPlayerService::Client::setVideoSurfaceTexture(
Andy McFadden484566c2012-12-18 09:46:54 -0800733 const sp<IGraphicBufferProducer>& bufferProducer)
Glenn Kasten11731182011-02-08 17:26:17 -0800734{
Andy McFadden484566c2012-12-18 09:46:54 -0800735 ALOGV("[%d] setVideoSurfaceTexture(%p)", mConnId, bufferProducer.get());
Glenn Kasten11731182011-02-08 17:26:17 -0800736 sp<MediaPlayerBase> p = getPlayer();
737 if (p == 0) return UNKNOWN_ERROR;
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700738
Andy McFadden484566c2012-12-18 09:46:54 -0800739 sp<IBinder> binder(bufferProducer == NULL ? NULL :
740 bufferProducer->asBinder());
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700741 if (mConnectedWindowBinder == binder) {
742 return OK;
743 }
744
745 sp<ANativeWindow> anw;
Andy McFadden484566c2012-12-18 09:46:54 -0800746 if (bufferProducer != NULL) {
Marco Nelissenee08f7e2013-09-16 13:30:01 -0700747 anw = new Surface(bufferProducer, true /* controlledByApp */);
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700748 status_t err = native_window_api_connect(anw.get(),
749 NATIVE_WINDOW_API_MEDIA);
750
751 if (err != OK) {
Steve Block29357bc2012-01-06 19:20:56 +0000752 ALOGE("setVideoSurfaceTexture failed: %d", err);
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700753 // Note that we must do the reset before disconnecting from the ANW.
754 // Otherwise queue/dequeue calls could be made on the disconnected
755 // ANW, which may result in errors.
756 reset();
757
758 disconnectNativeWindow();
759
760 return err;
761 }
762 }
763
Andy McFadden484566c2012-12-18 09:46:54 -0800764 // Note that we must set the player's new GraphicBufferProducer before
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700765 // disconnecting the old one. Otherwise queue/dequeue calls could be made
766 // on the disconnected ANW, which may result in errors.
Andy McFadden484566c2012-12-18 09:46:54 -0800767 status_t err = p->setVideoSurfaceTexture(bufferProducer);
Jamie Gennis7dae00b2011-10-26 18:36:31 -0700768
769 disconnectNativeWindow();
770
771 mConnectedWindow = anw;
772
773 if (err == OK) {
774 mConnectedWindowBinder = binder;
775 } else {
776 disconnectNativeWindow();
777 }
778
779 return err;
Glenn Kasten11731182011-02-08 17:26:17 -0800780}
781
Nicolas Catania1d187f12009-05-12 23:25:55 -0700782status_t MediaPlayerService::Client::invoke(const Parcel& request,
783 Parcel *reply)
784{
785 sp<MediaPlayerBase> p = getPlayer();
786 if (p == NULL) return UNKNOWN_ERROR;
787 return p->invoke(request, reply);
788}
789
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700790// This call doesn't need to access the native player.
791status_t MediaPlayerService::Client::setMetadataFilter(const Parcel& filter)
792{
793 status_t status;
nikoa64c8c72009-07-20 15:07:26 -0700794 media::Metadata::Filter allow, drop;
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700795
Nicolas Catania48290382009-07-10 13:53:06 -0700796 if (unmarshallFilter(filter, &allow, &status) &&
797 unmarshallFilter(filter, &drop, &status)) {
798 Mutex::Autolock lock(mLock);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -0700799
800 mMetadataAllow = allow;
801 mMetadataDrop = drop;
802 }
803 return status;
804}
805
Nicolas Catania48290382009-07-10 13:53:06 -0700806status_t MediaPlayerService::Client::getMetadata(
807 bool update_only, bool apply_filter, Parcel *reply)
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -0700808{
nikoa64c8c72009-07-20 15:07:26 -0700809 sp<MediaPlayerBase> player = getPlayer();
810 if (player == 0) return UNKNOWN_ERROR;
Nicolas Catania48290382009-07-10 13:53:06 -0700811
nikod608a812009-07-16 16:39:53 -0700812 status_t status;
813 // Placeholder for the return code, updated by the caller.
814 reply->writeInt32(-1);
815
nikoa64c8c72009-07-20 15:07:26 -0700816 media::Metadata::Filter ids;
Nicolas Catania48290382009-07-10 13:53:06 -0700817
818 // We don't block notifications while we fetch the data. We clear
819 // mMetadataUpdated first so we don't lose notifications happening
820 // during the rest of this call.
821 {
822 Mutex::Autolock lock(mLock);
823 if (update_only) {
nikod608a812009-07-16 16:39:53 -0700824 ids = mMetadataUpdated;
Nicolas Catania48290382009-07-10 13:53:06 -0700825 }
826 mMetadataUpdated.clear();
827 }
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -0700828
nikoa64c8c72009-07-20 15:07:26 -0700829 media::Metadata metadata(reply);
Nicolas Catania48290382009-07-10 13:53:06 -0700830
nikoa64c8c72009-07-20 15:07:26 -0700831 metadata.appendHeader();
832 status = player->getMetadata(ids, reply);
nikod608a812009-07-16 16:39:53 -0700833
834 if (status != OK) {
nikoa64c8c72009-07-20 15:07:26 -0700835 metadata.resetParcel();
Steve Block29357bc2012-01-06 19:20:56 +0000836 ALOGE("getMetadata failed %d", status);
nikod608a812009-07-16 16:39:53 -0700837 return status;
838 }
839
840 // FIXME: Implement filtering on the result. Not critical since
841 // filtering takes place on the update notifications already. This
842 // would be when all the metadata are fetch and a filter is set.
843
nikod608a812009-07-16 16:39:53 -0700844 // Everything is fine, update the metadata length.
nikoa64c8c72009-07-20 15:07:26 -0700845 metadata.updateLength();
nikod608a812009-07-16 16:39:53 -0700846 return OK;
Nicolas Catania8e1b6cc2009-07-09 09:21:33 -0700847}
848
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800849status_t MediaPlayerService::Client::prepareAsync()
850{
Steve Block3856b092011-10-20 11:56:00 +0100851 ALOGV("[%d] prepareAsync", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800852 sp<MediaPlayerBase> p = getPlayer();
853 if (p == 0) return UNKNOWN_ERROR;
854 status_t ret = p->prepareAsync();
855#if CALLBACK_ANTAGONIZER
Steve Blockb8a80522011-12-20 16:23:08 +0000856 ALOGD("start Antagonizer");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800857 if (ret == NO_ERROR) mAntagonizer->start();
858#endif
859 return ret;
860}
861
862status_t MediaPlayerService::Client::start()
863{
Steve Block3856b092011-10-20 11:56:00 +0100864 ALOGV("[%d] start", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800865 sp<MediaPlayerBase> p = getPlayer();
866 if (p == 0) return UNKNOWN_ERROR;
867 p->setLooping(mLoop);
868 return p->start();
869}
870
871status_t MediaPlayerService::Client::stop()
872{
Steve Block3856b092011-10-20 11:56:00 +0100873 ALOGV("[%d] stop", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800874 sp<MediaPlayerBase> p = getPlayer();
875 if (p == 0) return UNKNOWN_ERROR;
876 return p->stop();
877}
878
879status_t MediaPlayerService::Client::pause()
880{
Steve Block3856b092011-10-20 11:56:00 +0100881 ALOGV("[%d] pause", mConnId);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800882 sp<MediaPlayerBase> p = getPlayer();
883 if (p == 0) return UNKNOWN_ERROR;
884 return p->pause();
885}
886
887status_t MediaPlayerService::Client::isPlaying(bool* state)
888{
889 *state = false;
890 sp<MediaPlayerBase> p = getPlayer();
891 if (p == 0) return UNKNOWN_ERROR;
892 *state = p->isPlaying();
Steve Block3856b092011-10-20 11:56:00 +0100893 ALOGV("[%d] isPlaying: %d", mConnId, *state);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800894 return NO_ERROR;
895}
896
897status_t MediaPlayerService::Client::getCurrentPosition(int *msec)
898{
Steve Block3856b092011-10-20 11:56:00 +0100899 ALOGV("getCurrentPosition");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800900 sp<MediaPlayerBase> p = getPlayer();
901 if (p == 0) return UNKNOWN_ERROR;
902 status_t ret = p->getCurrentPosition(msec);
903 if (ret == NO_ERROR) {
Steve Block3856b092011-10-20 11:56:00 +0100904 ALOGV("[%d] getCurrentPosition = %d", mConnId, *msec);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800905 } else {
Steve Block29357bc2012-01-06 19:20:56 +0000906 ALOGE("getCurrentPosition returned %d", ret);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800907 }
908 return ret;
909}
910
911status_t MediaPlayerService::Client::getDuration(int *msec)
912{
Steve Block3856b092011-10-20 11:56:00 +0100913 ALOGV("getDuration");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800914 sp<MediaPlayerBase> p = getPlayer();
915 if (p == 0) return UNKNOWN_ERROR;
916 status_t ret = p->getDuration(msec);
917 if (ret == NO_ERROR) {
Steve Block3856b092011-10-20 11:56:00 +0100918 ALOGV("[%d] getDuration = %d", mConnId, *msec);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800919 } else {
Steve Block29357bc2012-01-06 19:20:56 +0000920 ALOGE("getDuration returned %d", ret);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800921 }
922 return ret;
923}
924
Marco Nelissen6b74d672012-02-28 16:07:44 -0800925status_t MediaPlayerService::Client::setNextPlayer(const sp<IMediaPlayer>& player) {
926 ALOGV("setNextPlayer");
927 Mutex::Autolock l(mLock);
928 sp<Client> c = static_cast<Client*>(player.get());
929 mNextClient = c;
John Grossman5f7e55e2012-08-24 14:47:25 -0700930
931 if (c != NULL) {
932 if (mAudioOutput != NULL) {
933 mAudioOutput->setNextOutput(c->mAudioOutput);
934 } else if ((mPlayer != NULL) && !mPlayer->hardwareOutput()) {
935 ALOGE("no current audio output");
936 }
937
938 if ((mPlayer != NULL) && (mNextClient->getPlayer() != NULL)) {
939 mPlayer->setNextPlayer(mNextClient->getPlayer());
940 }
Marco Nelissen6b74d672012-02-28 16:07:44 -0800941 }
John Grossman5f7e55e2012-08-24 14:47:25 -0700942
Marco Nelissen6b74d672012-02-28 16:07:44 -0800943 return OK;
944}
945
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800946status_t MediaPlayerService::Client::seekTo(int msec)
947{
Steve Block3856b092011-10-20 11:56:00 +0100948 ALOGV("[%d] seekTo(%d)", mConnId, msec);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800949 sp<MediaPlayerBase> p = getPlayer();
950 if (p == 0) return UNKNOWN_ERROR;
951 return p->seekTo(msec);
952}
953
954status_t MediaPlayerService::Client::reset()
955{
Steve Block3856b092011-10-20 11:56:00 +0100956 ALOGV("[%d] reset", mConnId);
John Grossmanc795b642012-02-22 15:38:35 -0800957 mRetransmitEndpointValid = false;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800958 sp<MediaPlayerBase> p = getPlayer();
959 if (p == 0) return UNKNOWN_ERROR;
960 return p->reset();
961}
962
Glenn Kastenfff6d712012-01-12 16:38:12 -0800963status_t MediaPlayerService::Client::setAudioStreamType(audio_stream_type_t type)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800964{
Steve Block3856b092011-10-20 11:56:00 +0100965 ALOGV("[%d] setAudioStreamType(%d)", mConnId, type);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800966 // TODO: for hardware output, call player instead
967 Mutex::Autolock l(mLock);
968 if (mAudioOutput != 0) mAudioOutput->setAudioStreamType(type);
969 return NO_ERROR;
970}
971
972status_t MediaPlayerService::Client::setLooping(int loop)
973{
Steve Block3856b092011-10-20 11:56:00 +0100974 ALOGV("[%d] setLooping(%d)", mConnId, loop);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800975 mLoop = loop;
976 sp<MediaPlayerBase> p = getPlayer();
977 if (p != 0) return p->setLooping(loop);
978 return NO_ERROR;
979}
980
981status_t MediaPlayerService::Client::setVolume(float leftVolume, float rightVolume)
982{
Steve Block3856b092011-10-20 11:56:00 +0100983 ALOGV("[%d] setVolume(%f, %f)", mConnId, leftVolume, rightVolume);
John Grossman761defc2012-02-09 15:09:05 -0800984
985 // for hardware output, call player instead
986 sp<MediaPlayerBase> p = getPlayer();
987 {
988 Mutex::Autolock l(mLock);
989 if (p != 0 && p->hardwareOutput()) {
990 MediaPlayerHWInterface* hwp =
991 reinterpret_cast<MediaPlayerHWInterface*>(p.get());
992 return hwp->setVolume(leftVolume, rightVolume);
993 } else {
994 if (mAudioOutput != 0) mAudioOutput->setVolume(leftVolume, rightVolume);
995 return NO_ERROR;
996 }
997 }
998
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -0800999 return NO_ERROR;
1000}
1001
Eric Laurent2beeb502010-07-16 07:43:46 -07001002status_t MediaPlayerService::Client::setAuxEffectSendLevel(float level)
1003{
Steve Block3856b092011-10-20 11:56:00 +01001004 ALOGV("[%d] setAuxEffectSendLevel(%f)", mConnId, level);
Eric Laurent2beeb502010-07-16 07:43:46 -07001005 Mutex::Autolock l(mLock);
1006 if (mAudioOutput != 0) return mAudioOutput->setAuxEffectSendLevel(level);
1007 return NO_ERROR;
1008}
1009
1010status_t MediaPlayerService::Client::attachAuxEffect(int effectId)
1011{
Steve Block3856b092011-10-20 11:56:00 +01001012 ALOGV("[%d] attachAuxEffect(%d)", mConnId, effectId);
Eric Laurent2beeb502010-07-16 07:43:46 -07001013 Mutex::Autolock l(mLock);
1014 if (mAudioOutput != 0) return mAudioOutput->attachAuxEffect(effectId);
1015 return NO_ERROR;
1016}
Nicolas Catania48290382009-07-10 13:53:06 -07001017
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001018status_t MediaPlayerService::Client::setParameter(int key, const Parcel &request) {
Steve Block3856b092011-10-20 11:56:00 +01001019 ALOGV("[%d] setParameter(%d)", mConnId, key);
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001020 sp<MediaPlayerBase> p = getPlayer();
1021 if (p == 0) return UNKNOWN_ERROR;
1022 return p->setParameter(key, request);
1023}
1024
1025status_t MediaPlayerService::Client::getParameter(int key, Parcel *reply) {
Steve Block3856b092011-10-20 11:56:00 +01001026 ALOGV("[%d] getParameter(%d)", mConnId, key);
Gloria Wang4f9e47f2011-04-25 17:28:22 -07001027 sp<MediaPlayerBase> p = getPlayer();
1028 if (p == 0) return UNKNOWN_ERROR;
1029 return p->getParameter(key, reply);
1030}
1031
John Grossmanc795b642012-02-22 15:38:35 -08001032status_t MediaPlayerService::Client::setRetransmitEndpoint(
1033 const struct sockaddr_in* endpoint) {
1034
1035 if (NULL != endpoint) {
1036 uint32_t a = ntohl(endpoint->sin_addr.s_addr);
1037 uint16_t p = ntohs(endpoint->sin_port);
1038 ALOGV("[%d] setRetransmitEndpoint(%u.%u.%u.%u:%hu)", mConnId,
1039 (a >> 24), (a >> 16) & 0xFF, (a >> 8) & 0xFF, (a & 0xFF), p);
1040 } else {
1041 ALOGV("[%d] setRetransmitEndpoint = <none>", mConnId);
1042 }
1043
1044 sp<MediaPlayerBase> p = getPlayer();
1045
1046 // Right now, the only valid time to set a retransmit endpoint is before
1047 // player selection has been made (since the presence or absence of a
1048 // retransmit endpoint is going to determine which player is selected during
1049 // setDataSource).
1050 if (p != 0) return INVALID_OPERATION;
1051
1052 if (NULL != endpoint) {
1053 mRetransmitEndpoint = *endpoint;
1054 mRetransmitEndpointValid = true;
1055 } else {
1056 mRetransmitEndpointValid = false;
1057 }
1058
1059 return NO_ERROR;
1060}
1061
John Grossman44a7e422012-06-21 17:29:24 -07001062status_t MediaPlayerService::Client::getRetransmitEndpoint(
1063 struct sockaddr_in* endpoint)
1064{
1065 if (NULL == endpoint)
1066 return BAD_VALUE;
1067
1068 sp<MediaPlayerBase> p = getPlayer();
1069
1070 if (p != NULL)
1071 return p->getRetransmitEndpoint(endpoint);
1072
1073 if (!mRetransmitEndpointValid)
1074 return NO_INIT;
1075
1076 *endpoint = mRetransmitEndpoint;
1077
1078 return NO_ERROR;
1079}
1080
Gloria Wangb483c472011-04-11 17:23:27 -07001081void MediaPlayerService::Client::notify(
1082 void* cookie, int msg, int ext1, int ext2, const Parcel *obj)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001083{
1084 Client* client = static_cast<Client*>(cookie);
James Dongb8a98252012-08-26 16:13:03 -07001085 if (client == NULL) {
1086 return;
1087 }
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001088
James Dongb8a98252012-08-26 16:13:03 -07001089 sp<IMediaPlayerClient> c;
Marco Nelissen6b74d672012-02-28 16:07:44 -08001090 {
1091 Mutex::Autolock l(client->mLock);
James Dongb8a98252012-08-26 16:13:03 -07001092 c = client->mClient;
Marco Nelissen6b74d672012-02-28 16:07:44 -08001093 if (msg == MEDIA_PLAYBACK_COMPLETE && client->mNextClient != NULL) {
John Grossmancb0b7552012-08-23 17:47:31 -07001094 if (client->mAudioOutput != NULL)
1095 client->mAudioOutput->switchToNextOutput();
Marco Nelissen6b74d672012-02-28 16:07:44 -08001096 client->mNextClient->start();
1097 client->mNextClient->mClient->notify(MEDIA_INFO, MEDIA_INFO_STARTED_AS_NEXT, 0, obj);
1098 }
1099 }
1100
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001101 if (MEDIA_INFO == msg &&
Nicolas Catania48290382009-07-10 13:53:06 -07001102 MEDIA_INFO_METADATA_UPDATE == ext1) {
nikoa64c8c72009-07-20 15:07:26 -07001103 const media::Metadata::Type metadata_type = ext2;
Nicolas Catania48290382009-07-10 13:53:06 -07001104
1105 if(client->shouldDropMetadata(metadata_type)) {
1106 return;
1107 }
1108
1109 // Update the list of metadata that have changed. getMetadata
1110 // also access mMetadataUpdated and clears it.
1111 client->addNewMetadataUpdate(metadata_type);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001112 }
James Dongb8a98252012-08-26 16:13:03 -07001113
1114 if (c != NULL) {
1115 ALOGV("[%d] notify (%p, %d, %d, %d)", client->mConnId, cookie, msg, ext1, ext2);
1116 c->notify(msg, ext1, ext2, obj);
1117 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001118}
1119
Nicolas Catania48290382009-07-10 13:53:06 -07001120
nikoa64c8c72009-07-20 15:07:26 -07001121bool MediaPlayerService::Client::shouldDropMetadata(media::Metadata::Type code) const
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001122{
Nicolas Catania48290382009-07-10 13:53:06 -07001123 Mutex::Autolock lock(mLock);
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001124
Nicolas Catania48290382009-07-10 13:53:06 -07001125 if (findMetadata(mMetadataDrop, code)) {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001126 return true;
1127 }
1128
Nicolas Catania48290382009-07-10 13:53:06 -07001129 if (mMetadataAllow.isEmpty() || findMetadata(mMetadataAllow, code)) {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001130 return false;
Nicolas Catania48290382009-07-10 13:53:06 -07001131 } else {
Nicolas Cataniaa7e0e8b2009-07-08 08:57:42 -07001132 return true;
1133 }
1134}
1135
Nicolas Catania48290382009-07-10 13:53:06 -07001136
nikoa64c8c72009-07-20 15:07:26 -07001137void MediaPlayerService::Client::addNewMetadataUpdate(media::Metadata::Type metadata_type) {
Nicolas Catania48290382009-07-10 13:53:06 -07001138 Mutex::Autolock lock(mLock);
1139 if (mMetadataUpdated.indexOf(metadata_type) < 0) {
1140 mMetadataUpdated.add(metadata_type);
1141 }
1142}
1143
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001144#if CALLBACK_ANTAGONIZER
1145const int Antagonizer::interval = 10000; // 10 msecs
1146
1147Antagonizer::Antagonizer(notify_callback_f cb, void* client) :
1148 mExit(false), mActive(false), mClient(client), mCb(cb)
1149{
1150 createThread(callbackThread, this);
1151}
1152
1153void Antagonizer::kill()
1154{
1155 Mutex::Autolock _l(mLock);
1156 mActive = false;
1157 mExit = true;
1158 mCondition.wait(mLock);
1159}
1160
1161int Antagonizer::callbackThread(void* user)
1162{
Steve Blockb8a80522011-12-20 16:23:08 +00001163 ALOGD("Antagonizer started");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001164 Antagonizer* p = reinterpret_cast<Antagonizer*>(user);
1165 while (!p->mExit) {
1166 if (p->mActive) {
Steve Block3856b092011-10-20 11:56:00 +01001167 ALOGV("send event");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001168 p->mCb(p->mClient, 0, 0, 0);
1169 }
1170 usleep(interval);
1171 }
1172 Mutex::Autolock _l(p->mLock);
1173 p->mCondition.signal();
Steve Blockb8a80522011-12-20 16:23:08 +00001174 ALOGD("Antagonizer stopped");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001175 return 0;
1176}
1177#endif
1178
Eric Laurent3d00aa62013-09-24 09:53:27 -07001179status_t MediaPlayerService::decode(const char* url, uint32_t *pSampleRate, int* pNumChannels,
1180 audio_format_t* pFormat,
1181 const sp<IMemoryHeap>& heap, size_t *pSize)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001182{
Steve Block3856b092011-10-20 11:56:00 +01001183 ALOGV("decode(%s)", url);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001184 sp<MediaPlayerBase> player;
Eric Laurent3d00aa62013-09-24 09:53:27 -07001185 status_t status = BAD_VALUE;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001186
1187 // Protect our precious, precious DRMd ringtones by only allowing
1188 // decoding of http, but not filesystem paths or content Uris.
1189 // If the application wants to decode those, it should open a
1190 // filedescriptor for them and use that.
1191 if (url != NULL && strncmp(url, "http://", 7) != 0) {
Steve Blockb8a80522011-12-20 16:23:08 +00001192 ALOGD("Can't decode %s by path, use filedescriptor instead", url);
Eric Laurent3d00aa62013-09-24 09:53:27 -07001193 return BAD_VALUE;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001194 }
1195
John Grossman44a7e422012-06-21 17:29:24 -07001196 player_type playerType =
1197 MediaPlayerFactory::getPlayerType(NULL /* client */, url);
Steve Block3856b092011-10-20 11:56:00 +01001198 ALOGV("player type = %d", playerType);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001199
1200 // create the right type of player
Eric Laurent3d00aa62013-09-24 09:53:27 -07001201 sp<AudioCache> cache = new AudioCache(heap);
John Grossman44a7e422012-06-21 17:29:24 -07001202 player = MediaPlayerFactory::createPlayer(playerType, cache.get(), cache->notify);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001203 if (player == NULL) goto Exit;
1204 if (player->hardwareOutput()) goto Exit;
1205
1206 static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache);
1207
1208 // set data source
1209 if (player->setDataSource(url) != NO_ERROR) goto Exit;
1210
Steve Block3856b092011-10-20 11:56:00 +01001211 ALOGV("prepare");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001212 player->prepareAsync();
1213
Steve Block3856b092011-10-20 11:56:00 +01001214 ALOGV("wait for prepare");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001215 if (cache->wait() != NO_ERROR) goto Exit;
1216
Steve Block3856b092011-10-20 11:56:00 +01001217 ALOGV("start");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001218 player->start();
1219
Steve Block3856b092011-10-20 11:56:00 +01001220 ALOGV("wait for playback complete");
Eric Laurent9cb839a2011-09-27 09:48:56 -07001221 cache->wait();
1222 // in case of error, return what was successfully decoded.
1223 if (cache->size() == 0) {
1224 goto Exit;
1225 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001226
Eric Laurent3d00aa62013-09-24 09:53:27 -07001227 *pSize = cache->size();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001228 *pSampleRate = cache->sampleRate();
1229 *pNumChannels = cache->channelCount();
Glenn Kastene1c39622012-01-04 09:36:37 -08001230 *pFormat = cache->format();
Eric Laurent3d00aa62013-09-24 09:53:27 -07001231 ALOGV("return size %d sampleRate=%u, channelCount = %d, format = %d",
1232 *pSize, *pSampleRate, *pNumChannels, *pFormat);
1233 status = NO_ERROR;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001234
1235Exit:
1236 if (player != 0) player->reset();
Eric Laurent3d00aa62013-09-24 09:53:27 -07001237 return status;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001238}
1239
Eric Laurent3d00aa62013-09-24 09:53:27 -07001240status_t MediaPlayerService::decode(int fd, int64_t offset, int64_t length,
1241 uint32_t *pSampleRate, int* pNumChannels,
1242 audio_format_t* pFormat,
1243 const sp<IMemoryHeap>& heap, size_t *pSize)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001244{
Steve Block3856b092011-10-20 11:56:00 +01001245 ALOGV("decode(%d, %lld, %lld)", fd, offset, length);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001246 sp<MediaPlayerBase> player;
Eric Laurent3d00aa62013-09-24 09:53:27 -07001247 status_t status = BAD_VALUE;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001248
John Grossman44a7e422012-06-21 17:29:24 -07001249 player_type playerType = MediaPlayerFactory::getPlayerType(NULL /* client */,
1250 fd,
1251 offset,
1252 length);
Steve Block3856b092011-10-20 11:56:00 +01001253 ALOGV("player type = %d", playerType);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001254
1255 // create the right type of player
Eric Laurent3d00aa62013-09-24 09:53:27 -07001256 sp<AudioCache> cache = new AudioCache(heap);
John Grossman44a7e422012-06-21 17:29:24 -07001257 player = MediaPlayerFactory::createPlayer(playerType, cache.get(), cache->notify);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001258 if (player == NULL) goto Exit;
1259 if (player->hardwareOutput()) goto Exit;
1260
1261 static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache);
1262
1263 // set data source
1264 if (player->setDataSource(fd, offset, length) != NO_ERROR) goto Exit;
1265
Steve Block3856b092011-10-20 11:56:00 +01001266 ALOGV("prepare");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001267 player->prepareAsync();
1268
Steve Block3856b092011-10-20 11:56:00 +01001269 ALOGV("wait for prepare");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001270 if (cache->wait() != NO_ERROR) goto Exit;
1271
Steve Block3856b092011-10-20 11:56:00 +01001272 ALOGV("start");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001273 player->start();
1274
Steve Block3856b092011-10-20 11:56:00 +01001275 ALOGV("wait for playback complete");
Eric Laurent9cb839a2011-09-27 09:48:56 -07001276 cache->wait();
1277 // in case of error, return what was successfully decoded.
1278 if (cache->size() == 0) {
1279 goto Exit;
1280 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001281
Eric Laurent3d00aa62013-09-24 09:53:27 -07001282 *pSize = cache->size();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001283 *pSampleRate = cache->sampleRate();
1284 *pNumChannels = cache->channelCount();
1285 *pFormat = cache->format();
Eric Laurent3d00aa62013-09-24 09:53:27 -07001286 ALOGV("return size %d, sampleRate=%u, channelCount = %d, format = %d",
1287 *pSize, *pSampleRate, *pNumChannels, *pFormat);
1288 status = NO_ERROR;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001289
1290Exit:
1291 if (player != 0) player->reset();
1292 ::close(fd);
Eric Laurent3d00aa62013-09-24 09:53:27 -07001293 return status;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001294}
1295
Marco Nelissen10dbb8e2009-09-20 10:42:13 -07001296
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001297#undef LOG_TAG
1298#define LOG_TAG "AudioSink"
Eric Laurenta514bdb2010-06-21 09:27:30 -07001299MediaPlayerService::AudioOutput::AudioOutput(int sessionId)
Andreas Huber20111aa2009-07-14 16:56:47 -07001300 : mCallback(NULL),
Eric Laurenta514bdb2010-06-21 09:27:30 -07001301 mCallbackCookie(NULL),
Marco Nelissen6b74d672012-02-28 16:07:44 -08001302 mCallbackData(NULL),
Marco Nelissen4110c102012-03-29 09:31:28 -07001303 mBytesWritten(0),
Eric Laurent1948eb32012-04-13 16:50:19 -07001304 mSessionId(sessionId),
1305 mFlags(AUDIO_OUTPUT_FLAG_NONE) {
Steve Block3856b092011-10-20 11:56:00 +01001306 ALOGV("AudioOutput(%d)", sessionId);
Dima Zavinfce7a472011-04-19 22:30:36 -07001307 mStreamType = AUDIO_STREAM_MUSIC;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001308 mLeftVolume = 1.0;
1309 mRightVolume = 1.0;
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08001310 mPlaybackRatePermille = 1000;
1311 mSampleRateHz = 0;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001312 mMsecsPerFrame = 0;
Eric Laurent2beeb502010-07-16 07:43:46 -07001313 mAuxEffectId = 0;
1314 mSendLevel = 0.0;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001315 setMinBufferCount();
1316}
1317
1318MediaPlayerService::AudioOutput::~AudioOutput()
1319{
1320 close();
Marco Nelissen6b74d672012-02-28 16:07:44 -08001321 delete mCallbackData;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001322}
1323
1324void MediaPlayerService::AudioOutput::setMinBufferCount()
1325{
1326 char value[PROPERTY_VALUE_MAX];
1327 if (property_get("ro.kernel.qemu", value, 0)) {
1328 mIsOnEmulator = true;
1329 mMinBufferCount = 12; // to prevent systematic buffer underrun for emulator
1330 }
1331}
1332
1333bool MediaPlayerService::AudioOutput::isOnEmulator()
1334{
1335 setMinBufferCount();
1336 return mIsOnEmulator;
1337}
1338
1339int MediaPlayerService::AudioOutput::getMinBufferCount()
1340{
1341 setMinBufferCount();
1342 return mMinBufferCount;
1343}
1344
1345ssize_t MediaPlayerService::AudioOutput::bufferSize() const
1346{
1347 if (mTrack == 0) return NO_INIT;
1348 return mTrack->frameCount() * frameSize();
1349}
1350
1351ssize_t MediaPlayerService::AudioOutput::frameCount() const
1352{
1353 if (mTrack == 0) return NO_INIT;
1354 return mTrack->frameCount();
1355}
1356
1357ssize_t MediaPlayerService::AudioOutput::channelCount() const
1358{
1359 if (mTrack == 0) return NO_INIT;
1360 return mTrack->channelCount();
1361}
1362
1363ssize_t MediaPlayerService::AudioOutput::frameSize() const
1364{
1365 if (mTrack == 0) return NO_INIT;
1366 return mTrack->frameSize();
1367}
1368
1369uint32_t MediaPlayerService::AudioOutput::latency () const
1370{
Eric Laurentdb354e52012-03-05 17:27:11 -08001371 if (mTrack == 0) return 0;
1372 return mTrack->latency();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001373}
1374
1375float MediaPlayerService::AudioOutput::msecsPerFrame() const
1376{
1377 return mMsecsPerFrame;
1378}
1379
Marco Nelissen4110c102012-03-29 09:31:28 -07001380status_t MediaPlayerService::AudioOutput::getPosition(uint32_t *position) const
Eric Laurent342e9cf2010-01-19 17:37:09 -08001381{
1382 if (mTrack == 0) return NO_INIT;
1383 return mTrack->getPosition(position);
1384}
1385
Marco Nelissen4110c102012-03-29 09:31:28 -07001386status_t MediaPlayerService::AudioOutput::getFramesWritten(uint32_t *frameswritten) const
1387{
1388 if (mTrack == 0) return NO_INIT;
1389 *frameswritten = mBytesWritten / frameSize();
1390 return OK;
1391}
1392
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001393status_t MediaPlayerService::AudioOutput::setParameters(const String8& keyValuePairs)
1394{
1395 if (mTrack == 0) return NO_INIT;
1396 return mTrack->setParameters(keyValuePairs);
1397}
1398
1399String8 MediaPlayerService::AudioOutput::getParameters(const String8& keys)
1400{
1401 if (mTrack == 0) return String8::empty();
1402 return mTrack->getParameters(keys);
1403}
1404
1405void MediaPlayerService::AudioOutput::deleteRecycledTrack()
1406{
1407 ALOGV("deleteRecycledTrack");
1408
1409 if (mRecycledTrack != 0) {
1410
1411 if (mCallbackData != NULL) {
1412 mCallbackData->setOutput(NULL);
1413 mCallbackData->endTrackSwitch();
1414 }
1415
1416 if ((mRecycledTrack->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) {
1417 mRecycledTrack->flush();
1418 }
1419 // An offloaded track isn't flushed because the STREAM_END is reported
1420 // slightly prematurely to allow time for the gapless track switch
1421 // but this means that if we decide not to recycle the track there
1422 // could be a small amount of residual data still playing. We leave
1423 // AudioFlinger to drain the track.
1424
1425 mRecycledTrack.clear();
1426 delete mCallbackData;
1427 mCallbackData = NULL;
1428 close();
1429 }
1430}
1431
Andreas Huber20111aa2009-07-14 16:56:47 -07001432status_t MediaPlayerService::AudioOutput::open(
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001433 uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
1434 audio_format_t format, int bufferCount,
Eric Laurent1948eb32012-04-13 16:50:19 -07001435 AudioCallback cb, void *cookie,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00001436 audio_output_flags_t flags,
1437 const audio_offload_info_t *offloadInfo)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001438{
Andreas Huber20111aa2009-07-14 16:56:47 -07001439 mCallback = cb;
1440 mCallbackCookie = cookie;
1441
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001442 // Check argument "bufferCount" against the mininum buffer count
1443 if (bufferCount < mMinBufferCount) {
Steve Blockb8a80522011-12-20 16:23:08 +00001444 ALOGD("bufferCount (%d) is too small and increased to %d", bufferCount, mMinBufferCount);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001445 bufferCount = mMinBufferCount;
1446
1447 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001448 ALOGV("open(%u, %d, 0x%x, 0x%x, %d, %d 0x%x)", sampleRate, channelCount, channelMask,
1449 format, bufferCount, mSessionId, flags);
Glenn Kasten1127d652012-11-14 08:44:39 -08001450 uint32_t afSampleRate;
Glenn Kasten7da35f22012-11-14 12:54:39 -08001451 size_t afFrameCount;
Eric Laurent1948eb32012-04-13 16:50:19 -07001452 uint32_t frameCount;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001453
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001454 // offloading is only supported in callback mode for now.
1455 // offloadInfo must be present if offload flag is set
1456 if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) &&
1457 ((cb == NULL) || (offloadInfo == NULL))) {
1458 return BAD_VALUE;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001459 }
1460
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001461 if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
1462 frameCount = 0; // AudioTrack will get frame count from AudioFlinger
1463 } else {
1464 uint32_t afSampleRate;
1465 size_t afFrameCount;
1466
1467 if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) != NO_ERROR) {
1468 return NO_INIT;
1469 }
1470 if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) != NO_ERROR) {
1471 return NO_INIT;
1472 }
1473
1474 frameCount = (sampleRate*afFrameCount*bufferCount)/afSampleRate;
1475 }
Andreas Huber20111aa2009-07-14 16:56:47 -07001476
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001477 if (channelMask == CHANNEL_MASK_USE_CHANNEL_ORDER) {
Glenn Kastenab334fd2012-03-14 12:56:06 -07001478 channelMask = audio_channel_out_mask_from_count(channelCount);
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001479 if (0 == channelMask) {
1480 ALOGE("open() error, can\'t derive mask for %d audio channels", channelCount);
1481 return NO_INIT;
1482 }
1483 }
Eric Laurent1948eb32012-04-13 16:50:19 -07001484
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001485 // Check whether we can recycle the track
1486 bool reuse = false;
1487 bool bothOffloaded = false;
Marco Nelissen67295b52012-06-11 14:52:53 -07001488
Glenn Kasten2799d742013-05-30 14:33:29 -07001489 if (mRecycledTrack != 0) {
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001490 // check whether we are switching between two offloaded tracks
1491 bothOffloaded = (flags & mRecycledTrack->getFlags()
1492 & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0;
Marco Nelissen67295b52012-06-11 14:52:53 -07001493
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001494 // check if the existing track can be reused as-is, or if a new track needs to be created.
1495 reuse = true;
1496
Marco Nelissen67295b52012-06-11 14:52:53 -07001497 if ((mCallbackData == NULL && mCallback != NULL) ||
1498 (mCallbackData != NULL && mCallback == NULL)) {
1499 // recycled track uses callbacks but the caller wants to use writes, or vice versa
1500 ALOGV("can't chain callback and write");
1501 reuse = false;
1502 } else if ((mRecycledTrack->getSampleRate() != sampleRate) ||
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001503 (mRecycledTrack->channelCount() != (uint32_t)channelCount) ) {
1504 ALOGV("samplerate, channelcount differ: %u/%u Hz, %u/%d ch",
Marco Nelissen67295b52012-06-11 14:52:53 -07001505 mRecycledTrack->getSampleRate(), sampleRate,
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001506 mRecycledTrack->channelCount(), channelCount);
Marco Nelissen67295b52012-06-11 14:52:53 -07001507 reuse = false;
1508 } else if (flags != mFlags) {
1509 ALOGV("output flags differ %08x/%08x", flags, mFlags);
1510 reuse = false;
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001511 } else if (mRecycledTrack->format() != format) {
1512 reuse = false;
Marco Nelissen67295b52012-06-11 14:52:53 -07001513 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001514 } else {
1515 ALOGV("no track available to recycle");
1516 }
1517
1518 ALOGV_IF(bothOffloaded, "both tracks offloaded");
1519
1520 // If we can't recycle and both tracks are offloaded
1521 // we must close the previous output before opening a new one
1522 if (bothOffloaded && !reuse) {
1523 ALOGV("both offloaded and not recycling");
1524 deleteRecycledTrack();
1525 }
1526
1527 sp<AudioTrack> t;
1528 CallbackData *newcbd = NULL;
1529
1530 // We don't attempt to create a new track if we are recycling an
1531 // offloaded track. But, if we are recycling a non-offloaded or we
1532 // are switching where one is offloaded and one isn't then we create
1533 // the new track in advance so that we can read additional stream info
1534
1535 if (!(reuse && bothOffloaded)) {
1536 ALOGV("creating new AudioTrack");
1537
1538 if (mCallback != NULL) {
1539 newcbd = new CallbackData(this);
1540 t = new AudioTrack(
1541 mStreamType,
1542 sampleRate,
1543 format,
1544 channelMask,
1545 frameCount,
1546 flags,
1547 CallbackWrapper,
1548 newcbd,
1549 0, // notification frames
1550 mSessionId,
1551 AudioTrack::TRANSFER_CALLBACK,
1552 offloadInfo);
1553 } else {
1554 t = new AudioTrack(
1555 mStreamType,
1556 sampleRate,
1557 format,
1558 channelMask,
1559 frameCount,
1560 flags,
1561 NULL,
1562 NULL,
1563 0,
1564 mSessionId);
1565 }
1566
1567 if ((t == 0) || (t->initCheck() != NO_ERROR)) {
1568 ALOGE("Unable to create audio track");
1569 delete newcbd;
1570 return NO_INIT;
1571 }
1572 }
1573
1574 if (reuse) {
1575 CHECK(mRecycledTrack != NULL);
1576
1577 if (!bothOffloaded) {
1578 if (mRecycledTrack->frameCount() != t->frameCount()) {
1579 ALOGV("framecount differs: %u/%u frames",
1580 mRecycledTrack->frameCount(), t->frameCount());
1581 reuse = false;
1582 }
1583 }
1584
Marco Nelissen67295b52012-06-11 14:52:53 -07001585 if (reuse) {
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001586 ALOGV("chaining to next output and recycling track");
Marco Nelissen67295b52012-06-11 14:52:53 -07001587 close();
1588 mTrack = mRecycledTrack;
Glenn Kasten2799d742013-05-30 14:33:29 -07001589 mRecycledTrack.clear();
Marco Nelissen67295b52012-06-11 14:52:53 -07001590 if (mCallbackData != NULL) {
1591 mCallbackData->setOutput(this);
1592 }
Marco Nelissen67295b52012-06-11 14:52:53 -07001593 delete newcbd;
1594 return OK;
1595 }
Marco Nelissen67295b52012-06-11 14:52:53 -07001596 }
1597
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001598 // we're not going to reuse the track, unblock and flush it
1599 // this was done earlier if both tracks are offloaded
1600 if (!bothOffloaded) {
1601 deleteRecycledTrack();
1602 }
1603
1604 CHECK((t != NULL) && ((mCallback == NULL) || (newcbd != NULL)));
1605
Marco Nelissen67295b52012-06-11 14:52:53 -07001606 mCallbackData = newcbd;
Steve Block3856b092011-10-20 11:56:00 +01001607 ALOGV("setVolume");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001608 t->setVolume(mLeftVolume, mRightVolume);
Eric Laurent2beeb502010-07-16 07:43:46 -07001609
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08001610 mSampleRateHz = sampleRate;
Eric Laurent1948eb32012-04-13 16:50:19 -07001611 mFlags = flags;
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08001612 mMsecsPerFrame = mPlaybackRatePermille / (float) sampleRate;
Marco Nelissen99448602012-04-02 12:16:49 -07001613 uint32_t pos;
1614 if (t->getPosition(&pos) == OK) {
1615 mBytesWritten = uint64_t(pos) * t->frameSize();
1616 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001617 mTrack = t;
Eric Laurent2beeb502010-07-16 07:43:46 -07001618
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001619 status_t res = NO_ERROR;
1620 if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) {
1621 res = t->setSampleRate(mPlaybackRatePermille * mSampleRateHz / 1000);
1622 if (res == NO_ERROR) {
1623 t->setAuxEffectSendLevel(mSendLevel);
1624 res = t->attachAuxEffect(mAuxEffectId);
1625 }
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08001626 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001627 ALOGV("open() DONE status %d", res);
1628 return res;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001629}
1630
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001631status_t MediaPlayerService::AudioOutput::start()
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001632{
Steve Block3856b092011-10-20 11:56:00 +01001633 ALOGV("start");
Marco Nelissen6b74d672012-02-28 16:07:44 -08001634 if (mCallbackData != NULL) {
1635 mCallbackData->endTrackSwitch();
1636 }
Glenn Kasten2799d742013-05-30 14:33:29 -07001637 if (mTrack != 0) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001638 mTrack->setVolume(mLeftVolume, mRightVolume);
Eric Laurent2beeb502010-07-16 07:43:46 -07001639 mTrack->setAuxEffectSendLevel(mSendLevel);
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001640 return mTrack->start();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001641 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001642 return NO_INIT;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001643}
1644
Marco Nelissen6b74d672012-02-28 16:07:44 -08001645void MediaPlayerService::AudioOutput::setNextOutput(const sp<AudioOutput>& nextOutput) {
1646 mNextOutput = nextOutput;
1647}
Marco Nelissen7ee8ac92010-01-12 09:23:54 -08001648
1649
Marco Nelissen6b74d672012-02-28 16:07:44 -08001650void MediaPlayerService::AudioOutput::switchToNextOutput() {
1651 ALOGV("switchToNextOutput");
1652 if (mNextOutput != NULL) {
1653 if (mCallbackData != NULL) {
1654 mCallbackData->beginTrackSwitch();
1655 }
1656 delete mNextOutput->mCallbackData;
1657 mNextOutput->mCallbackData = mCallbackData;
1658 mCallbackData = NULL;
1659 mNextOutput->mRecycledTrack = mTrack;
Glenn Kasten2799d742013-05-30 14:33:29 -07001660 mTrack.clear();
Marco Nelissen6b74d672012-02-28 16:07:44 -08001661 mNextOutput->mSampleRateHz = mSampleRateHz;
1662 mNextOutput->mMsecsPerFrame = mMsecsPerFrame;
Marco Nelissen4110c102012-03-29 09:31:28 -07001663 mNextOutput->mBytesWritten = mBytesWritten;
Marco Nelissend791e092012-06-11 17:00:59 -07001664 mNextOutput->mFlags = mFlags;
Marco Nelissen6b74d672012-02-28 16:07:44 -08001665 }
1666}
1667
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001668ssize_t MediaPlayerService::AudioOutput::write(const void* buffer, size_t size)
1669{
Andreas Huber20111aa2009-07-14 16:56:47 -07001670 LOG_FATAL_IF(mCallback != NULL, "Don't call write if supplying a callback.");
1671
Steve Block3856b092011-10-20 11:56:00 +01001672 //ALOGV("write(%p, %u)", buffer, size);
Glenn Kasten2799d742013-05-30 14:33:29 -07001673 if (mTrack != 0) {
Marco Nelissen10dbb8e2009-09-20 10:42:13 -07001674 ssize_t ret = mTrack->write(buffer, size);
Marco Nelissen4110c102012-03-29 09:31:28 -07001675 mBytesWritten += ret;
Marco Nelissen10dbb8e2009-09-20 10:42:13 -07001676 return ret;
1677 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001678 return NO_INIT;
1679}
1680
1681void MediaPlayerService::AudioOutput::stop()
1682{
Steve Block3856b092011-10-20 11:56:00 +01001683 ALOGV("stop");
Glenn Kasten2799d742013-05-30 14:33:29 -07001684 if (mTrack != 0) mTrack->stop();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001685}
1686
1687void MediaPlayerService::AudioOutput::flush()
1688{
Steve Block3856b092011-10-20 11:56:00 +01001689 ALOGV("flush");
Glenn Kasten2799d742013-05-30 14:33:29 -07001690 if (mTrack != 0) mTrack->flush();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001691}
1692
1693void MediaPlayerService::AudioOutput::pause()
1694{
Steve Block3856b092011-10-20 11:56:00 +01001695 ALOGV("pause");
Glenn Kasten2799d742013-05-30 14:33:29 -07001696 if (mTrack != 0) mTrack->pause();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001697}
1698
1699void MediaPlayerService::AudioOutput::close()
1700{
Steve Block3856b092011-10-20 11:56:00 +01001701 ALOGV("close");
Glenn Kasten2799d742013-05-30 14:33:29 -07001702 mTrack.clear();
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001703}
1704
1705void MediaPlayerService::AudioOutput::setVolume(float left, float right)
1706{
Steve Block3856b092011-10-20 11:56:00 +01001707 ALOGV("setVolume(%f, %f)", left, right);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001708 mLeftVolume = left;
1709 mRightVolume = right;
Glenn Kasten2799d742013-05-30 14:33:29 -07001710 if (mTrack != 0) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001711 mTrack->setVolume(left, right);
1712 }
1713}
1714
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08001715status_t MediaPlayerService::AudioOutput::setPlaybackRatePermille(int32_t ratePermille)
1716{
1717 ALOGV("setPlaybackRatePermille(%d)", ratePermille);
1718 status_t res = NO_ERROR;
Glenn Kasten2799d742013-05-30 14:33:29 -07001719 if (mTrack != 0) {
Jean-Michel Trivi7a8b0ed2012-02-02 09:06:31 -08001720 res = mTrack->setSampleRate(ratePermille * mSampleRateHz / 1000);
1721 } else {
1722 res = NO_INIT;
1723 }
1724 mPlaybackRatePermille = ratePermille;
1725 if (mSampleRateHz != 0) {
1726 mMsecsPerFrame = mPlaybackRatePermille / (float) mSampleRateHz;
1727 }
1728 return res;
1729}
1730
Eric Laurent2beeb502010-07-16 07:43:46 -07001731status_t MediaPlayerService::AudioOutput::setAuxEffectSendLevel(float level)
1732{
Steve Block3856b092011-10-20 11:56:00 +01001733 ALOGV("setAuxEffectSendLevel(%f)", level);
Eric Laurent2beeb502010-07-16 07:43:46 -07001734 mSendLevel = level;
Glenn Kasten2799d742013-05-30 14:33:29 -07001735 if (mTrack != 0) {
Eric Laurent2beeb502010-07-16 07:43:46 -07001736 return mTrack->setAuxEffectSendLevel(level);
1737 }
1738 return NO_ERROR;
1739}
1740
1741status_t MediaPlayerService::AudioOutput::attachAuxEffect(int effectId)
1742{
Steve Block3856b092011-10-20 11:56:00 +01001743 ALOGV("attachAuxEffect(%d)", effectId);
Eric Laurent2beeb502010-07-16 07:43:46 -07001744 mAuxEffectId = effectId;
Glenn Kasten2799d742013-05-30 14:33:29 -07001745 if (mTrack != 0) {
Eric Laurent2beeb502010-07-16 07:43:46 -07001746 return mTrack->attachAuxEffect(effectId);
1747 }
1748 return NO_ERROR;
1749}
1750
Andreas Huber20111aa2009-07-14 16:56:47 -07001751// static
1752void MediaPlayerService::AudioOutput::CallbackWrapper(
Glenn Kastend217a8c2011-06-01 15:20:35 -07001753 int event, void *cookie, void *info) {
Steve Block3856b092011-10-20 11:56:00 +01001754 //ALOGV("callbackwrapper");
Marco Nelissen6b74d672012-02-28 16:07:44 -08001755 CallbackData *data = (CallbackData*)cookie;
1756 data->lock();
1757 AudioOutput *me = data->getOutput();
Andreas Huber20111aa2009-07-14 16:56:47 -07001758 AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
Marco Nelissen6b74d672012-02-28 16:07:44 -08001759 if (me == NULL) {
1760 // no output set, likely because the track was scheduled to be reused
1761 // by another player, but the format turned out to be incompatible.
1762 data->unlock();
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001763 if (buffer != NULL) {
1764 buffer->size = 0;
1765 }
Marco Nelissen6b74d672012-02-28 16:07:44 -08001766 return;
1767 }
Andreas Huber20111aa2009-07-14 16:56:47 -07001768
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001769 switch(event) {
1770 case AudioTrack::EVENT_MORE_DATA: {
1771 size_t actualSize = (*me->mCallback)(
1772 me, buffer->raw, buffer->size, me->mCallbackCookie,
1773 CB_EVENT_FILL_BUFFER);
Andreas Huber7d5b8a72010-02-09 16:59:18 -08001774
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001775 if (actualSize == 0 && buffer->size > 0 && me->mNextOutput == NULL) {
1776 // We've reached EOS but the audio track is not stopped yet,
1777 // keep playing silence.
Andreas Huber2e8ffaf2010-02-18 16:45:13 -08001778
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001779 memset(buffer->raw, 0, buffer->size);
1780 actualSize = buffer->size;
1781 }
1782
1783 buffer->size = actualSize;
1784 } break;
1785
1786
1787 case AudioTrack::EVENT_STREAM_END:
1788 ALOGV("callbackwrapper: deliver EVENT_STREAM_END");
1789 (*me->mCallback)(me, NULL /* buffer */, 0 /* size */,
1790 me->mCallbackCookie, CB_EVENT_STREAM_END);
1791 break;
1792
1793 case AudioTrack::EVENT_NEW_IAUDIOTRACK :
1794 ALOGV("callbackwrapper: deliver EVENT_TEAR_DOWN");
1795 (*me->mCallback)(me, NULL /* buffer */, 0 /* size */,
1796 me->mCallbackCookie, CB_EVENT_TEAR_DOWN);
1797 break;
1798
1799 default:
1800 ALOGE("received unknown event type: %d inside CallbackWrapper !", event);
Andreas Huber51c1e0e2011-04-04 11:43:40 -07001801 }
1802
Marco Nelissen6b74d672012-02-28 16:07:44 -08001803 data->unlock();
Andreas Huber20111aa2009-07-14 16:56:47 -07001804}
1805
Marco Nelissen4110c102012-03-29 09:31:28 -07001806int MediaPlayerService::AudioOutput::getSessionId() const
Eric Laurent8c563ed2010-10-07 18:23:03 -07001807{
1808 return mSessionId;
1809}
1810
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001811#undef LOG_TAG
1812#define LOG_TAG "AudioCache"
Eric Laurent3d00aa62013-09-24 09:53:27 -07001813MediaPlayerService::AudioCache::AudioCache(const sp<IMemoryHeap>& heap) :
1814 mHeap(heap), mChannelCount(0), mFrameCount(1024), mSampleRate(0), mSize(0),
1815 mError(NO_ERROR), mCommandComplete(false)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001816{
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001817}
1818
1819uint32_t MediaPlayerService::AudioCache::latency () const
1820{
1821 return 0;
1822}
1823
1824float MediaPlayerService::AudioCache::msecsPerFrame() const
1825{
1826 return mMsecsPerFrame;
1827}
1828
Marco Nelissen4110c102012-03-29 09:31:28 -07001829status_t MediaPlayerService::AudioCache::getPosition(uint32_t *position) const
Eric Laurent342e9cf2010-01-19 17:37:09 -08001830{
1831 if (position == 0) return BAD_VALUE;
1832 *position = mSize;
1833 return NO_ERROR;
1834}
1835
Marco Nelissen4110c102012-03-29 09:31:28 -07001836status_t MediaPlayerService::AudioCache::getFramesWritten(uint32_t *written) const
1837{
1838 if (written == 0) return BAD_VALUE;
1839 *written = mSize;
1840 return NO_ERROR;
1841}
1842
Andreas Huber7d5b8a72010-02-09 16:59:18 -08001843////////////////////////////////////////////////////////////////////////////////
1844
1845struct CallbackThread : public Thread {
1846 CallbackThread(const wp<MediaPlayerBase::AudioSink> &sink,
1847 MediaPlayerBase::AudioSink::AudioCallback cb,
1848 void *cookie);
1849
1850protected:
1851 virtual ~CallbackThread();
1852
1853 virtual bool threadLoop();
1854
1855private:
1856 wp<MediaPlayerBase::AudioSink> mSink;
1857 MediaPlayerBase::AudioSink::AudioCallback mCallback;
1858 void *mCookie;
1859 void *mBuffer;
1860 size_t mBufferSize;
1861
1862 CallbackThread(const CallbackThread &);
1863 CallbackThread &operator=(const CallbackThread &);
1864};
1865
1866CallbackThread::CallbackThread(
1867 const wp<MediaPlayerBase::AudioSink> &sink,
1868 MediaPlayerBase::AudioSink::AudioCallback cb,
1869 void *cookie)
1870 : mSink(sink),
1871 mCallback(cb),
1872 mCookie(cookie),
1873 mBuffer(NULL),
1874 mBufferSize(0) {
1875}
1876
1877CallbackThread::~CallbackThread() {
1878 if (mBuffer) {
1879 free(mBuffer);
1880 mBuffer = NULL;
1881 }
1882}
1883
1884bool CallbackThread::threadLoop() {
1885 sp<MediaPlayerBase::AudioSink> sink = mSink.promote();
1886 if (sink == NULL) {
1887 return false;
1888 }
1889
1890 if (mBuffer == NULL) {
1891 mBufferSize = sink->bufferSize();
1892 mBuffer = malloc(mBufferSize);
1893 }
1894
1895 size_t actualSize =
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00001896 (*mCallback)(sink.get(), mBuffer, mBufferSize, mCookie,
1897 MediaPlayerBase::AudioSink::CB_EVENT_FILL_BUFFER);
Andreas Huber7d5b8a72010-02-09 16:59:18 -08001898
1899 if (actualSize > 0) {
1900 sink->write(mBuffer, actualSize);
1901 }
1902
1903 return true;
1904}
1905
1906////////////////////////////////////////////////////////////////////////////////
1907
Andreas Huber20111aa2009-07-14 16:56:47 -07001908status_t MediaPlayerService::AudioCache::open(
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001909 uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
1910 audio_format_t format, int bufferCount,
Richard Fitzgeraldad3af332013-03-25 16:54:37 +00001911 AudioCallback cb, void *cookie, audio_output_flags_t flags,
1912 const audio_offload_info_t *offloadInfo)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001913{
Jean-Michel Trivi786618f2012-03-02 14:54:07 -08001914 ALOGV("open(%u, %d, 0x%x, %d, %d)", sampleRate, channelCount, channelMask, format, bufferCount);
Dave Sparks8eb80112009-12-09 20:20:26 -08001915 if (mHeap->getHeapID() < 0) {
1916 return NO_INIT;
1917 }
Andreas Huber20111aa2009-07-14 16:56:47 -07001918
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001919 mSampleRate = sampleRate;
1920 mChannelCount = (uint16_t)channelCount;
Glenn Kastene1c39622012-01-04 09:36:37 -08001921 mFormat = format;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001922 mMsecsPerFrame = 1.e3 / (float) sampleRate;
Andreas Huber7d5b8a72010-02-09 16:59:18 -08001923
1924 if (cb != NULL) {
1925 mCallbackThread = new CallbackThread(this, cb, cookie);
1926 }
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001927 return NO_ERROR;
1928}
1929
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001930status_t MediaPlayerService::AudioCache::start() {
Andreas Huber7d5b8a72010-02-09 16:59:18 -08001931 if (mCallbackThread != NULL) {
1932 mCallbackThread->run("AudioCache callback");
1933 }
Richard Fitzgeraldd89532e2013-05-14 13:18:21 +01001934 return NO_ERROR;
Andreas Huber7d5b8a72010-02-09 16:59:18 -08001935}
1936
1937void MediaPlayerService::AudioCache::stop() {
1938 if (mCallbackThread != NULL) {
1939 mCallbackThread->requestExitAndWait();
1940 }
1941}
1942
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001943ssize_t MediaPlayerService::AudioCache::write(const void* buffer, size_t size)
1944{
Steve Block3856b092011-10-20 11:56:00 +01001945 ALOGV("write(%p, %u)", buffer, size);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001946 if ((buffer == 0) || (size == 0)) return size;
1947
1948 uint8_t* p = static_cast<uint8_t*>(mHeap->getBase());
1949 if (p == NULL) return NO_INIT;
1950 p += mSize;
Steve Block3856b092011-10-20 11:56:00 +01001951 ALOGV("memcpy(%p, %p, %u)", p, buffer, size);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001952 if (mSize + size > mHeap->getSize()) {
Steve Block29357bc2012-01-06 19:20:56 +00001953 ALOGE("Heap size overflow! req size: %d, max size: %d", (mSize + size), mHeap->getSize());
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001954 size = mHeap->getSize() - mSize;
1955 }
1956 memcpy(p, buffer, size);
1957 mSize += size;
1958 return size;
1959}
1960
1961// call with lock held
1962status_t MediaPlayerService::AudioCache::wait()
1963{
1964 Mutex::Autolock lock(mLock);
Dave Sparks4bbc0ba2010-03-01 19:29:58 -08001965 while (!mCommandComplete) {
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001966 mSignal.wait(mLock);
1967 }
1968 mCommandComplete = false;
1969
1970 if (mError == NO_ERROR) {
Steve Block3856b092011-10-20 11:56:00 +01001971 ALOGV("wait - success");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001972 } else {
Steve Block3856b092011-10-20 11:56:00 +01001973 ALOGV("wait - error");
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001974 }
1975 return mError;
1976}
1977
Gloria Wangb483c472011-04-11 17:23:27 -07001978void MediaPlayerService::AudioCache::notify(
1979 void* cookie, int msg, int ext1, int ext2, const Parcel *obj)
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001980{
Steve Block3856b092011-10-20 11:56:00 +01001981 ALOGV("notify(%p, %d, %d, %d)", cookie, msg, ext1, ext2);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001982 AudioCache* p = static_cast<AudioCache*>(cookie);
1983
1984 // ignore buffering messages
Dave Sparks8eb80112009-12-09 20:20:26 -08001985 switch (msg)
1986 {
1987 case MEDIA_ERROR:
Steve Block29357bc2012-01-06 19:20:56 +00001988 ALOGE("Error %d, %d occurred", ext1, ext2);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08001989 p->mError = ext1;
Dave Sparks8eb80112009-12-09 20:20:26 -08001990 break;
1991 case MEDIA_PREPARED:
Steve Block3856b092011-10-20 11:56:00 +01001992 ALOGV("prepared");
Dave Sparks8eb80112009-12-09 20:20:26 -08001993 break;
1994 case MEDIA_PLAYBACK_COMPLETE:
Steve Block3856b092011-10-20 11:56:00 +01001995 ALOGV("playback complete");
Dave Sparks8eb80112009-12-09 20:20:26 -08001996 break;
1997 default:
Steve Block3856b092011-10-20 11:56:00 +01001998 ALOGV("ignored");
Dave Sparks8eb80112009-12-09 20:20:26 -08001999 return;
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002000 }
2001
2002 // wake up thread
Dave Sparksfe4c6f02010-03-02 12:56:37 -08002003 Mutex::Autolock lock(p->mLock);
The Android Open Source Project89fa4ad2009-03-03 19:31:44 -08002004 p->mCommandComplete = true;
2005 p->mSignal.signal();
2006}
2007
Marco Nelissen4110c102012-03-29 09:31:28 -07002008int MediaPlayerService::AudioCache::getSessionId() const
Eric Laurent8c563ed2010-10-07 18:23:03 -07002009{
2010 return 0;
2011}
2012
Gloria Wang7cf180c2011-02-19 18:37:57 -08002013void MediaPlayerService::addBatteryData(uint32_t params)
2014{
2015 Mutex::Autolock lock(mLock);
Gloria Wang9ee159b2011-02-24 14:51:45 -08002016
2017 int32_t time = systemTime() / 1000000L;
2018
2019 // change audio output devices. This notification comes from AudioFlinger
2020 if ((params & kBatteryDataSpeakerOn)
2021 || (params & kBatteryDataOtherAudioDeviceOn)) {
2022
2023 int deviceOn[NUM_AUDIO_DEVICES];
2024 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2025 deviceOn[i] = 0;
2026 }
2027
2028 if ((params & kBatteryDataSpeakerOn)
2029 && (params & kBatteryDataOtherAudioDeviceOn)) {
2030 deviceOn[SPEAKER_AND_OTHER] = 1;
2031 } else if (params & kBatteryDataSpeakerOn) {
2032 deviceOn[SPEAKER] = 1;
2033 } else {
2034 deviceOn[OTHER_AUDIO_DEVICE] = 1;
2035 }
2036
2037 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2038 if (mBatteryAudio.deviceOn[i] != deviceOn[i]){
2039
2040 if (mBatteryAudio.refCount > 0) { // if playing audio
2041 if (!deviceOn[i]) {
2042 mBatteryAudio.lastTime[i] += time;
2043 mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
2044 mBatteryAudio.lastTime[i] = 0;
2045 } else {
2046 mBatteryAudio.lastTime[i] = 0 - time;
2047 }
2048 }
2049
2050 mBatteryAudio.deviceOn[i] = deviceOn[i];
2051 }
2052 }
2053 return;
2054 }
2055
2056 // an sudio stream is started
2057 if (params & kBatteryDataAudioFlingerStart) {
2058 // record the start time only if currently no other audio
2059 // is being played
2060 if (mBatteryAudio.refCount == 0) {
2061 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2062 if (mBatteryAudio.deviceOn[i]) {
2063 mBatteryAudio.lastTime[i] -= time;
2064 }
2065 }
2066 }
2067
2068 mBatteryAudio.refCount ++;
2069 return;
2070
2071 } else if (params & kBatteryDataAudioFlingerStop) {
2072 if (mBatteryAudio.refCount <= 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002073 ALOGW("Battery track warning: refCount is <= 0");
Gloria Wang9ee159b2011-02-24 14:51:45 -08002074 return;
2075 }
2076
2077 // record the stop time only if currently this is the only
2078 // audio being played
2079 if (mBatteryAudio.refCount == 1) {
2080 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2081 if (mBatteryAudio.deviceOn[i]) {
2082 mBatteryAudio.lastTime[i] += time;
2083 mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
2084 mBatteryAudio.lastTime[i] = 0;
2085 }
2086 }
2087 }
2088
2089 mBatteryAudio.refCount --;
2090 return;
2091 }
2092
Gloria Wang7cf180c2011-02-19 18:37:57 -08002093 int uid = IPCThreadState::self()->getCallingUid();
2094 if (uid == AID_MEDIA) {
2095 return;
2096 }
2097 int index = mBatteryData.indexOfKey(uid);
Gloria Wang7cf180c2011-02-19 18:37:57 -08002098
2099 if (index < 0) { // create a new entry for this UID
2100 BatteryUsageInfo info;
2101 info.audioTotalTime = 0;
2102 info.videoTotalTime = 0;
2103 info.audioLastTime = 0;
2104 info.videoLastTime = 0;
2105 info.refCount = 0;
2106
Gloria Wang9ee159b2011-02-24 14:51:45 -08002107 if (mBatteryData.add(uid, info) == NO_MEMORY) {
Steve Block29357bc2012-01-06 19:20:56 +00002108 ALOGE("Battery track error: no memory for new app");
Gloria Wang9ee159b2011-02-24 14:51:45 -08002109 return;
2110 }
Gloria Wang7cf180c2011-02-19 18:37:57 -08002111 }
2112
2113 BatteryUsageInfo &info = mBatteryData.editValueFor(uid);
2114
2115 if (params & kBatteryDataCodecStarted) {
2116 if (params & kBatteryDataTrackAudio) {
2117 info.audioLastTime -= time;
2118 info.refCount ++;
2119 }
2120 if (params & kBatteryDataTrackVideo) {
2121 info.videoLastTime -= time;
2122 info.refCount ++;
2123 }
2124 } else {
2125 if (info.refCount == 0) {
Steve Block5ff1dd52012-01-05 23:22:43 +00002126 ALOGW("Battery track warning: refCount is already 0");
Gloria Wang7cf180c2011-02-19 18:37:57 -08002127 return;
2128 } else if (info.refCount < 0) {
Steve Block29357bc2012-01-06 19:20:56 +00002129 ALOGE("Battery track error: refCount < 0");
Gloria Wang7cf180c2011-02-19 18:37:57 -08002130 mBatteryData.removeItem(uid);
2131 return;
2132 }
2133
2134 if (params & kBatteryDataTrackAudio) {
2135 info.audioLastTime += time;
2136 info.refCount --;
2137 }
2138 if (params & kBatteryDataTrackVideo) {
2139 info.videoLastTime += time;
2140 info.refCount --;
2141 }
2142
2143 // no stream is being played by this UID
2144 if (info.refCount == 0) {
2145 info.audioTotalTime += info.audioLastTime;
2146 info.audioLastTime = 0;
2147 info.videoTotalTime += info.videoLastTime;
2148 info.videoLastTime = 0;
2149 }
2150 }
2151}
2152
2153status_t MediaPlayerService::pullBatteryData(Parcel* reply) {
2154 Mutex::Autolock lock(mLock);
Gloria Wang9ee159b2011-02-24 14:51:45 -08002155
2156 // audio output devices usage
2157 int32_t time = systemTime() / 1000000L; //in ms
2158 int32_t totalTime;
2159
2160 for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2161 totalTime = mBatteryAudio.totalTime[i];
2162
2163 if (mBatteryAudio.deviceOn[i]
2164 && (mBatteryAudio.lastTime[i] != 0)) {
2165 int32_t tmpTime = mBatteryAudio.lastTime[i] + time;
2166 totalTime += tmpTime;
2167 }
2168
2169 reply->writeInt32(totalTime);
2170 // reset the total time
2171 mBatteryAudio.totalTime[i] = 0;
2172 }
2173
2174 // codec usage
Gloria Wang7cf180c2011-02-19 18:37:57 -08002175 BatteryUsageInfo info;
2176 int size = mBatteryData.size();
2177
2178 reply->writeInt32(size);
2179 int i = 0;
2180
2181 while (i < size) {
2182 info = mBatteryData.valueAt(i);
2183
2184 reply->writeInt32(mBatteryData.keyAt(i)); //UID
2185 reply->writeInt32(info.audioTotalTime);
2186 reply->writeInt32(info.videoTotalTime);
2187
2188 info.audioTotalTime = 0;
2189 info.videoTotalTime = 0;
2190
2191 // remove the UID entry where no stream is being played
2192 if (info.refCount <= 0) {
2193 mBatteryData.removeItemsAt(i);
2194 size --;
2195 i --;
2196 }
2197 i++;
2198 }
2199 return NO_ERROR;
2200}
nikoa64c8c72009-07-20 15:07:26 -07002201} // namespace android