MediaPlayerService.cpp revision 81e68448f3361eaf8618930471fdc3c21bdf5cbc 
1/*
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>
26#include <sys/time.h>
27#include <dirent.h>
28#include <unistd.h>
29
30#include <string.h>
31
32#include <cutils/atomic.h>
33#include <cutils/properties.h> // for property_get
34
35#include <utils/misc.h>
36
37#include <binder/IPCThreadState.h>
38#include <binder/IServiceManager.h>
39#include <binder/MemoryHeapBase.h>
40#include <binder/MemoryBase.h>
41#include <gui/Surface.h>
42#include <utils/Errors.h>  // for status_t
43#include <utils/String8.h>
44#include <utils/SystemClock.h>
45#include <utils/Vector.h>
46
47#include <media/IMediaHTTPService.h>
48#include <media/IRemoteDisplay.h>
49#include <media/IRemoteDisplayClient.h>
50#include <media/MediaPlayerInterface.h>
51#include <media/mediarecorder.h>
52#include <media/MediaMetadataRetrieverInterface.h>
53#include <media/Metadata.h>
54#include <media/AudioTrack.h>
55#include <media/MemoryLeakTrackUtil.h>
56#include <media/stagefright/MediaErrors.h>
57#include <media/stagefright/AudioPlayer.h>
58#include <media/stagefright/foundation/ADebug.h>
59
60#include <system/audio.h>
61
62#include <private/android_filesystem_config.h>
63
64#include "ActivityManager.h"
65#include "MediaRecorderClient.h"
66#include "MediaPlayerService.h"
67#include "MetadataRetrieverClient.h"
68#include "MediaPlayerFactory.h"
69
70#include "MidiFile.h"
71#include "TestPlayerStub.h"
72#include "StagefrightPlayer.h"
73#include "nuplayer/NuPlayerDriver.h"
74
75#include <OMX.h>
76
77#include "Crypto.h"
78#include "Drm.h"
79#include "HDCP.h"
80#include "HTTPBase.h"
81#include "RemoteDisplay.h"
82
83namespace {
84using android::media::Metadata;
85using android::status_t;
86using android::OK;
87using android::BAD_VALUE;
88using android::NOT_ENOUGH_DATA;
89using android::Parcel;
90
91// Max number of entries in the filter.
92const int kMaxFilterSize = 64;  // I pulled that out of thin air.
93
94// FIXME: Move all the metadata related function in the Metadata.cpp
95
96
97// Unmarshall a filter from a Parcel.
98// Filter format in a parcel:
99//
100//  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
101// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
102// |                       number of entries (n)                   |
103// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
104// |                       metadata type 1                         |
105// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
106// |                       metadata type 2                         |
107// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
108//  ....
109// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
110// |                       metadata type n                         |
111// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
112//
113// @param p Parcel that should start with a filter.
114// @param[out] filter On exit contains the list of metadata type to be
115//                    filtered.
116// @param[out] status On exit contains the status code to be returned.
117// @return true if the parcel starts with a valid filter.
118bool unmarshallFilter(const Parcel& p,
119                      Metadata::Filter *filter,
120                      status_t *status)
121{
122    int32_t val;
123    if (p.readInt32(&val) != OK)
124    {
125        ALOGE("Failed to read filter's length");
126        *status = NOT_ENOUGH_DATA;
127        return false;
128    }
129
130    if( val > kMaxFilterSize || val < 0)
131    {
132        ALOGE("Invalid filter len %d", val);
133        *status = BAD_VALUE;
134        return false;
135    }
136
137    const size_t num = val;
138
139    filter->clear();
140    filter->setCapacity(num);
141
142    size_t size = num * sizeof(Metadata::Type);
143
144
145    if (p.dataAvail() < size)
146    {
147        ALOGE("Filter too short expected %d but got %d", size, p.dataAvail());
148        *status = NOT_ENOUGH_DATA;
149        return false;
150    }
151
152    const Metadata::Type *data =
153            static_cast<const Metadata::Type*>(p.readInplace(size));
154
155    if (NULL == data)
156    {
157        ALOGE("Filter had no data");
158        *status = BAD_VALUE;
159        return false;
160    }
161
162    // TODO: The stl impl of vector would be more efficient here
163    // because it degenerates into a memcpy on pod types. Try to
164    // replace later or use stl::set.
165    for (size_t i = 0; i < num; ++i)
166    {
167        filter->add(*data);
168        ++data;
169    }
170    *status = OK;
171    return true;
172}
173
174// @param filter Of metadata type.
175// @param val To be searched.
176// @return true if a match was found.
177bool findMetadata(const Metadata::Filter& filter, const int32_t val)
178{
179    // Deal with empty and ANY right away
180    if (filter.isEmpty()) return false;
181    if (filter[0] == Metadata::kAny) return true;
182
183    return filter.indexOf(val) >= 0;
184}
185
186}  // anonymous namespace
187
188
189namespace android {
190
191static bool checkPermission(const char* permissionString) {
192#ifndef HAVE_ANDROID_OS
193    return true;
194#endif
195    if (getpid() == IPCThreadState::self()->getCallingPid()) return true;
196    bool ok = checkCallingPermission(String16(permissionString));
197    if (!ok) ALOGE("Request requires %s", permissionString);
198    return ok;
199}
200
201// TODO: Find real cause of Audio/Video delay in PV framework and remove this workaround
202/* static */ int MediaPlayerService::AudioOutput::mMinBufferCount = 4;
203/* static */ bool MediaPlayerService::AudioOutput::mIsOnEmulator = false;
204
205void MediaPlayerService::instantiate() {
206    defaultServiceManager()->addService(
207            String16("media.player"), new MediaPlayerService());
208}
209
210MediaPlayerService::MediaPlayerService()
211{
212    ALOGV("MediaPlayerService created");
213    mNextConnId = 1;
214
215    mBatteryAudio.refCount = 0;
216    for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
217        mBatteryAudio.deviceOn[i] = 0;
218        mBatteryAudio.lastTime[i] = 0;
219        mBatteryAudio.totalTime[i] = 0;
220    }
221    // speaker is on by default
222    mBatteryAudio.deviceOn[SPEAKER] = 1;
223
224    MediaPlayerFactory::registerBuiltinFactories();
225}
226
227MediaPlayerService::~MediaPlayerService()
228{
229    ALOGV("MediaPlayerService destroyed");
230}
231
232sp<IMediaRecorder> MediaPlayerService::createMediaRecorder()
233{
234    pid_t pid = IPCThreadState::self()->getCallingPid();
235    sp<MediaRecorderClient> recorder = new MediaRecorderClient(this, pid);
236    wp<MediaRecorderClient> w = recorder;
237    Mutex::Autolock lock(mLock);
238    mMediaRecorderClients.add(w);
239    ALOGV("Create new media recorder client from pid %d", pid);
240    return recorder;
241}
242
243void MediaPlayerService::removeMediaRecorderClient(wp<MediaRecorderClient> client)
244{
245    Mutex::Autolock lock(mLock);
246    mMediaRecorderClients.remove(client);
247    ALOGV("Delete media recorder client");
248}
249
250sp<IMediaMetadataRetriever> MediaPlayerService::createMetadataRetriever()
251{
252    pid_t pid = IPCThreadState::self()->getCallingPid();
253    sp<MetadataRetrieverClient> retriever = new MetadataRetrieverClient(pid);
254    ALOGV("Create new media retriever from pid %d", pid);
255    return retriever;
256}
257
258sp<IMediaPlayer> MediaPlayerService::create(const sp<IMediaPlayerClient>& client,
259        int audioSessionId)
260{
261    pid_t pid = IPCThreadState::self()->getCallingPid();
262    int32_t connId = android_atomic_inc(&mNextConnId);
263
264    sp<Client> c = new Client(
265            this, pid, connId, client, audioSessionId,
266            IPCThreadState::self()->getCallingUid());
267
268    ALOGV("Create new client(%d) from pid %d, uid %d, ", connId, pid,
269         IPCThreadState::self()->getCallingUid());
270
271    wp<Client> w = c;
272    {
273        Mutex::Autolock lock(mLock);
274        mClients.add(w);
275    }
276    return c;
277}
278
279sp<IOMX> MediaPlayerService::getOMX() {
280    Mutex::Autolock autoLock(mLock);
281
282    if (mOMX.get() == NULL) {
283        mOMX = new OMX;
284    }
285
286    return mOMX;
287}
288
289sp<ICrypto> MediaPlayerService::makeCrypto() {
290    return new Crypto;
291}
292
293sp<IDrm> MediaPlayerService::makeDrm() {
294    return new Drm;
295}
296
297sp<IHDCP> MediaPlayerService::makeHDCP(bool createEncryptionModule) {
298    return new HDCP(createEncryptionModule);
299}
300
301sp<IRemoteDisplay> MediaPlayerService::listenForRemoteDisplay(
302        const sp<IRemoteDisplayClient>& client, const String8& iface) {
303    if (!checkPermission("android.permission.CONTROL_WIFI_DISPLAY")) {
304        return NULL;
305    }
306
307    return new RemoteDisplay(client, iface.string());
308}
309
310status_t MediaPlayerService::AudioCache::dump(int fd, const Vector<String16>& args) const
311{
312    const size_t SIZE = 256;
313    char buffer[SIZE];
314    String8 result;
315
316    result.append(" AudioCache\n");
317    if (mHeap != 0) {
318        snprintf(buffer, 255, "  heap base(%p), size(%d), flags(%d)\n",
319                mHeap->getBase(), mHeap->getSize(), mHeap->getFlags());
320        result.append(buffer);
321    }
322    snprintf(buffer, 255, "  msec per frame(%f), channel count(%d), format(%d), frame count(%zd)\n",
323            mMsecsPerFrame, mChannelCount, mFormat, mFrameCount);
324    result.append(buffer);
325    snprintf(buffer, 255, "  sample rate(%d), size(%d), error(%d), command complete(%s)\n",
326            mSampleRate, mSize, mError, mCommandComplete?"true":"false");
327    result.append(buffer);
328    ::write(fd, result.string(), result.size());
329    return NO_ERROR;
330}
331
332status_t MediaPlayerService::AudioOutput::dump(int fd, const Vector<String16>& args) const
333{
334    const size_t SIZE = 256;
335    char buffer[SIZE];
336    String8 result;
337
338    result.append(" AudioOutput\n");
339    snprintf(buffer, 255, "  stream type(%d), left - right volume(%f, %f)\n",
340            mStreamType, mLeftVolume, mRightVolume);
341    result.append(buffer);
342    snprintf(buffer, 255, "  msec per frame(%f), latency (%d)\n",
343            mMsecsPerFrame, (mTrack != 0) ? mTrack->latency() : -1);
344    result.append(buffer);
345    snprintf(buffer, 255, "  aux effect id(%d), send level (%f)\n",
346            mAuxEffectId, mSendLevel);
347    result.append(buffer);
348
349    ::write(fd, result.string(), result.size());
350    if (mTrack != 0) {
351        mTrack->dump(fd, args);
352    }
353    return NO_ERROR;
354}
355
356status_t MediaPlayerService::Client::dump(int fd, const Vector<String16>& args) const
357{
358    const size_t SIZE = 256;
359    char buffer[SIZE];
360    String8 result;
361    result.append(" Client\n");
362    snprintf(buffer, 255, "  pid(%d), connId(%d), status(%d), looping(%s)\n",
363            mPid, mConnId, mStatus, mLoop?"true": "false");
364    result.append(buffer);
365    write(fd, result.string(), result.size());
366    if (mPlayer != NULL) {
367        mPlayer->dump(fd, args);
368    }
369    if (mAudioOutput != 0) {
370        mAudioOutput->dump(fd, args);
371    }
372    write(fd, "\n", 1);
373    return NO_ERROR;
374}
375
376status_t MediaPlayerService::dump(int fd, const Vector<String16>& args)
377{
378    const size_t SIZE = 256;
379    char buffer[SIZE];
380    String8 result;
381    if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
382        snprintf(buffer, SIZE, "Permission Denial: "
383                "can't dump MediaPlayerService from pid=%d, uid=%d\n",
384                IPCThreadState::self()->getCallingPid(),
385                IPCThreadState::self()->getCallingUid());
386        result.append(buffer);
387    } else {
388        Mutex::Autolock lock(mLock);
389        for (int i = 0, n = mClients.size(); i < n; ++i) {
390            sp<Client> c = mClients[i].promote();
391            if (c != 0) c->dump(fd, args);
392        }
393        if (mMediaRecorderClients.size() == 0) {
394                result.append(" No media recorder client\n\n");
395        } else {
396            for (int i = 0, n = mMediaRecorderClients.size(); i < n; ++i) {
397                sp<MediaRecorderClient> c = mMediaRecorderClients[i].promote();
398                if (c != 0) {
399                    snprintf(buffer, 255, " MediaRecorderClient pid(%d)\n", c->mPid);
400                    result.append(buffer);
401                    write(fd, result.string(), result.size());
402                    result = "\n";
403                    c->dump(fd, args);
404                }
405            }
406        }
407
408        result.append(" Files opened and/or mapped:\n");
409        snprintf(buffer, SIZE, "/proc/%d/maps", gettid());
410        FILE *f = fopen(buffer, "r");
411        if (f) {
412            while (!feof(f)) {
413                fgets(buffer, SIZE, f);
414                if (strstr(buffer, " /storage/") ||
415                    strstr(buffer, " /system/sounds/") ||
416                    strstr(buffer, " /data/") ||
417                    strstr(buffer, " /system/media/")) {
418                    result.append("  ");
419                    result.append(buffer);
420                }
421            }
422            fclose(f);
423        } else {
424            result.append("couldn't open ");
425            result.append(buffer);
426            result.append("\n");
427        }
428
429        snprintf(buffer, SIZE, "/proc/%d/fd", gettid());
430        DIR *d = opendir(buffer);
431        if (d) {
432            struct dirent *ent;
433            while((ent = readdir(d)) != NULL) {
434                if (strcmp(ent->d_name,".") && strcmp(ent->d_name,"..")) {
435                    snprintf(buffer, SIZE, "/proc/%d/fd/%s", gettid(), ent->d_name);
436                    struct stat s;
437                    if (lstat(buffer, &s) == 0) {
438                        if ((s.st_mode & S_IFMT) == S_IFLNK) {
439                            char linkto[256];
440                            int len = readlink(buffer, linkto, sizeof(linkto));
441                            if(len > 0) {
442                                if(len > 255) {
443                                    linkto[252] = '.';
444                                    linkto[253] = '.';
445                                    linkto[254] = '.';
446                                    linkto[255] = 0;
447                                } else {
448                                    linkto[len] = 0;
449                                }
450                                if (strstr(linkto, "/storage/") == linkto ||
451                                    strstr(linkto, "/system/sounds/") == linkto ||
452                                    strstr(linkto, "/data/") == linkto ||
453                                    strstr(linkto, "/system/media/") == linkto) {
454                                    result.append("  ");
455                                    result.append(buffer);
456                                    result.append(" -> ");
457                                    result.append(linkto);
458                                    result.append("\n");
459                                }
460                            }
461                        } else {
462                            result.append("  unexpected type for ");
463                            result.append(buffer);
464                            result.append("\n");
465                        }
466                    }
467                }
468            }
469            closedir(d);
470        } else {
471            result.append("couldn't open ");
472            result.append(buffer);
473            result.append("\n");
474        }
475
476        bool dumpMem = false;
477        for (size_t i = 0; i < args.size(); i++) {
478            if (args[i] == String16("-m")) {
479                dumpMem = true;
480            }
481        }
482        if (dumpMem) {
483            dumpMemoryAddresses(fd);
484        }
485    }
486    write(fd, result.string(), result.size());
487    return NO_ERROR;
488}
489
490void MediaPlayerService::removeClient(wp<Client> client)
491{
492    Mutex::Autolock lock(mLock);
493    mClients.remove(client);
494}
495
496MediaPlayerService::Client::Client(
497        const sp<MediaPlayerService>& service, pid_t pid,
498        int32_t connId, const sp<IMediaPlayerClient>& client,
499        int audioSessionId, uid_t uid)
500{
501    ALOGV("Client(%d) constructor", connId);
502    mPid = pid;
503    mConnId = connId;
504    mService = service;
505    mClient = client;
506    mLoop = false;
507    mStatus = NO_INIT;
508    mAudioSessionId = audioSessionId;
509    mUID = uid;
510    mRetransmitEndpointValid = false;
511
512#if CALLBACK_ANTAGONIZER
513    ALOGD("create Antagonizer");
514    mAntagonizer = new Antagonizer(notify, this);
515#endif
516}
517
518MediaPlayerService::Client::~Client()
519{
520    ALOGV("Client(%d) destructor pid = %d", mConnId, mPid);
521    mAudioOutput.clear();
522    wp<Client> client(this);
523    disconnect();
524    mService->removeClient(client);
525}
526
527void MediaPlayerService::Client::disconnect()
528{
529    ALOGV("disconnect(%d) from pid %d", mConnId, mPid);
530    // grab local reference and clear main reference to prevent future
531    // access to object
532    sp<MediaPlayerBase> p;
533    {
534        Mutex::Autolock l(mLock);
535        p = mPlayer;
536        mClient.clear();
537    }
538
539    mPlayer.clear();
540
541    // clear the notification to prevent callbacks to dead client
542    // and reset the player. We assume the player will serialize
543    // access to itself if necessary.
544    if (p != 0) {
545        p->setNotifyCallback(0, 0);
546#if CALLBACK_ANTAGONIZER
547        ALOGD("kill Antagonizer");
548        mAntagonizer->kill();
549#endif
550        p->reset();
551    }
552
553    disconnectNativeWindow();
554
555    IPCThreadState::self()->flushCommands();
556}
557
558sp<MediaPlayerBase> MediaPlayerService::Client::createPlayer(player_type playerType)
559{
560    // determine if we have the right player type
561    sp<MediaPlayerBase> p = mPlayer;
562    if ((p != NULL) && (p->playerType() != playerType)) {
563        ALOGV("delete player");
564        p.clear();
565    }
566    if (p == NULL) {
567        p = MediaPlayerFactory::createPlayer(playerType, this, notify);
568    }
569
570    if (p != NULL) {
571        p->setUID(mUID);
572    }
573
574    return p;
575}
576
577sp<MediaPlayerBase> MediaPlayerService::Client::setDataSource_pre(
578        player_type playerType)
579{
580    ALOGV("player type = %d", playerType);
581
582    // create the right type of player
583    sp<MediaPlayerBase> p = createPlayer(playerType);
584    if (p == NULL) {
585        return p;
586    }
587
588    if (!p->hardwareOutput()) {
589        mAudioOutput = new AudioOutput(mAudioSessionId, IPCThreadState::self()->getCallingUid());
590        static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
591    }
592
593    return p;
594}
595
596void MediaPlayerService::Client::setDataSource_post(
597        const sp<MediaPlayerBase>& p,
598        status_t status)
599{
600    ALOGV(" setDataSource");
601    mStatus = status;
602    if (mStatus != OK) {
603        ALOGE("  error: %d", mStatus);
604        return;
605    }
606
607    // Set the re-transmission endpoint if one was chosen.
608    if (mRetransmitEndpointValid) {
609        mStatus = p->setRetransmitEndpoint(&mRetransmitEndpoint);
610        if (mStatus != NO_ERROR) {
611            ALOGE("setRetransmitEndpoint error: %d", mStatus);
612        }
613    }
614
615    if (mStatus == OK) {
616        mPlayer = p;
617    }
618}
619
620status_t MediaPlayerService::Client::setDataSource(
621        const sp<IMediaHTTPService> &httpService,
622        const char *url,
623        const KeyedVector<String8, String8> *headers)
624{
625    ALOGV("setDataSource(%s)", url);
626    if (url == NULL)
627        return UNKNOWN_ERROR;
628
629    if ((strncmp(url, "http://", 7) == 0) ||
630        (strncmp(url, "https://", 8) == 0) ||
631        (strncmp(url, "rtsp://", 7) == 0)) {
632        if (!checkPermission("android.permission.INTERNET")) {
633            return PERMISSION_DENIED;
634        }
635    }
636
637    if (strncmp(url, "content://", 10) == 0) {
638        // get a filedescriptor for the content Uri and
639        // pass it to the setDataSource(fd) method
640
641        String16 url16(url);
642        int fd = android::openContentProviderFile(url16);
643        if (fd < 0)
644        {
645            ALOGE("Couldn't open fd for %s", url);
646            return UNKNOWN_ERROR;
647        }
648        setDataSource(fd, 0, 0x7fffffffffLL); // this sets mStatus
649        close(fd);
650        return mStatus;
651    } else {
652        player_type playerType = MediaPlayerFactory::getPlayerType(this, url);
653        sp<MediaPlayerBase> p = setDataSource_pre(playerType);
654        if (p == NULL) {
655            return NO_INIT;
656        }
657
658        setDataSource_post(p, p->setDataSource(httpService, url, headers));
659        return mStatus;
660    }
661}
662
663status_t MediaPlayerService::Client::setDataSource(int fd, int64_t offset, int64_t length)
664{
665    ALOGV("setDataSource fd=%d, offset=%lld, length=%lld", fd, offset, length);
666    struct stat sb;
667    int ret = fstat(fd, &sb);
668    if (ret != 0) {
669        ALOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
670        return UNKNOWN_ERROR;
671    }
672
673    ALOGV("st_dev  = %llu", sb.st_dev);
674    ALOGV("st_mode = %u", sb.st_mode);
675    ALOGV("st_uid  = %lu", sb.st_uid);
676    ALOGV("st_gid  = %lu", sb.st_gid);
677    ALOGV("st_size = %llu", sb.st_size);
678
679    if (offset >= sb.st_size) {
680        ALOGE("offset error");
681        ::close(fd);
682        return UNKNOWN_ERROR;
683    }
684    if (offset + length > sb.st_size) {
685        length = sb.st_size - offset;
686        ALOGV("calculated length = %lld", length);
687    }
688
689    player_type playerType = MediaPlayerFactory::getPlayerType(this,
690                                                               fd,
691                                                               offset,
692                                                               length);
693    sp<MediaPlayerBase> p = setDataSource_pre(playerType);
694    if (p == NULL) {
695        return NO_INIT;
696    }
697
698    // now set data source
699    setDataSource_post(p, p->setDataSource(fd, offset, length));
700    return mStatus;
701}
702
703status_t MediaPlayerService::Client::setDataSource(
704        const sp<IStreamSource> &source) {
705    // create the right type of player
706    player_type playerType = MediaPlayerFactory::getPlayerType(this, source);
707    sp<MediaPlayerBase> p = setDataSource_pre(playerType);
708    if (p == NULL) {
709        return NO_INIT;
710    }
711
712    // now set data source
713    setDataSource_post(p, p->setDataSource(source));
714    return mStatus;
715}
716
717void MediaPlayerService::Client::disconnectNativeWindow() {
718    if (mConnectedWindow != NULL) {
719        status_t err = native_window_api_disconnect(mConnectedWindow.get(),
720                NATIVE_WINDOW_API_MEDIA);
721
722        if (err != OK) {
723            ALOGW("native_window_api_disconnect returned an error: %s (%d)",
724                    strerror(-err), err);
725        }
726    }
727    mConnectedWindow.clear();
728}
729
730status_t MediaPlayerService::Client::setVideoSurfaceTexture(
731        const sp<IGraphicBufferProducer>& bufferProducer)
732{
733    ALOGV("[%d] setVideoSurfaceTexture(%p)", mConnId, bufferProducer.get());
734    sp<MediaPlayerBase> p = getPlayer();
735    if (p == 0) return UNKNOWN_ERROR;
736
737    sp<IBinder> binder(bufferProducer == NULL ? NULL :
738            bufferProducer->asBinder());
739    if (mConnectedWindowBinder == binder) {
740        return OK;
741    }
742
743    sp<ANativeWindow> anw;
744    if (bufferProducer != NULL) {
745        anw = new Surface(bufferProducer, true /* controlledByApp */);
746        status_t err = native_window_api_connect(anw.get(),
747                NATIVE_WINDOW_API_MEDIA);
748
749        if (err != OK) {
750            ALOGE("setVideoSurfaceTexture failed: %d", err);
751            // Note that we must do the reset before disconnecting from the ANW.
752            // Otherwise queue/dequeue calls could be made on the disconnected
753            // ANW, which may result in errors.
754            reset();
755
756            disconnectNativeWindow();
757
758            return err;
759        }
760    }
761
762    // Note that we must set the player's new GraphicBufferProducer before
763    // disconnecting the old one.  Otherwise queue/dequeue calls could be made
764    // on the disconnected ANW, which may result in errors.
765    status_t err = p->setVideoSurfaceTexture(bufferProducer);
766
767    disconnectNativeWindow();
768
769    mConnectedWindow = anw;
770
771    if (err == OK) {
772        mConnectedWindowBinder = binder;
773    } else {
774        disconnectNativeWindow();
775    }
776
777    return err;
778}
779
780status_t MediaPlayerService::Client::invoke(const Parcel& request,
781                                            Parcel *reply)
782{
783    sp<MediaPlayerBase> p = getPlayer();
784    if (p == NULL) return UNKNOWN_ERROR;
785    return p->invoke(request, reply);
786}
787
788// This call doesn't need to access the native player.
789status_t MediaPlayerService::Client::setMetadataFilter(const Parcel& filter)
790{
791    status_t status;
792    media::Metadata::Filter allow, drop;
793
794    if (unmarshallFilter(filter, &allow, &status) &&
795        unmarshallFilter(filter, &drop, &status)) {
796        Mutex::Autolock lock(mLock);
797
798        mMetadataAllow = allow;
799        mMetadataDrop = drop;
800    }
801    return status;
802}
803
804status_t MediaPlayerService::Client::getMetadata(
805        bool update_only, bool apply_filter, Parcel *reply)
806{
807    sp<MediaPlayerBase> player = getPlayer();
808    if (player == 0) return UNKNOWN_ERROR;
809
810    status_t status;
811    // Placeholder for the return code, updated by the caller.
812    reply->writeInt32(-1);
813
814    media::Metadata::Filter ids;
815
816    // We don't block notifications while we fetch the data. We clear
817    // mMetadataUpdated first so we don't lose notifications happening
818    // during the rest of this call.
819    {
820        Mutex::Autolock lock(mLock);
821        if (update_only) {
822            ids = mMetadataUpdated;
823        }
824        mMetadataUpdated.clear();
825    }
826
827    media::Metadata metadata(reply);
828
829    metadata.appendHeader();
830    status = player->getMetadata(ids, reply);
831
832    if (status != OK) {
833        metadata.resetParcel();
834        ALOGE("getMetadata failed %d", status);
835        return status;
836    }
837
838    // FIXME: Implement filtering on the result. Not critical since
839    // filtering takes place on the update notifications already. This
840    // would be when all the metadata are fetch and a filter is set.
841
842    // Everything is fine, update the metadata length.
843    metadata.updateLength();
844    return OK;
845}
846
847status_t MediaPlayerService::Client::prepareAsync()
848{
849    ALOGV("[%d] prepareAsync", mConnId);
850    sp<MediaPlayerBase> p = getPlayer();
851    if (p == 0) return UNKNOWN_ERROR;
852    status_t ret = p->prepareAsync();
853#if CALLBACK_ANTAGONIZER
854    ALOGD("start Antagonizer");
855    if (ret == NO_ERROR) mAntagonizer->start();
856#endif
857    return ret;
858}
859
860status_t MediaPlayerService::Client::start()
861{
862    ALOGV("[%d] start", mConnId);
863    sp<MediaPlayerBase> p = getPlayer();
864    if (p == 0) return UNKNOWN_ERROR;
865    p->setLooping(mLoop);
866    return p->start();
867}
868
869status_t MediaPlayerService::Client::stop()
870{
871    ALOGV("[%d] stop", mConnId);
872    sp<MediaPlayerBase> p = getPlayer();
873    if (p == 0) return UNKNOWN_ERROR;
874    return p->stop();
875}
876
877status_t MediaPlayerService::Client::pause()
878{
879    ALOGV("[%d] pause", mConnId);
880    sp<MediaPlayerBase> p = getPlayer();
881    if (p == 0) return UNKNOWN_ERROR;
882    return p->pause();
883}
884
885status_t MediaPlayerService::Client::isPlaying(bool* state)
886{
887    *state = false;
888    sp<MediaPlayerBase> p = getPlayer();
889    if (p == 0) return UNKNOWN_ERROR;
890    *state = p->isPlaying();
891    ALOGV("[%d] isPlaying: %d", mConnId, *state);
892    return NO_ERROR;
893}
894
895status_t MediaPlayerService::Client::getCurrentPosition(int *msec)
896{
897    ALOGV("getCurrentPosition");
898    sp<MediaPlayerBase> p = getPlayer();
899    if (p == 0) return UNKNOWN_ERROR;
900    status_t ret = p->getCurrentPosition(msec);
901    if (ret == NO_ERROR) {
902        ALOGV("[%d] getCurrentPosition = %d", mConnId, *msec);
903    } else {
904        ALOGE("getCurrentPosition returned %d", ret);
905    }
906    return ret;
907}
908
909status_t MediaPlayerService::Client::getDuration(int *msec)
910{
911    ALOGV("getDuration");
912    sp<MediaPlayerBase> p = getPlayer();
913    if (p == 0) return UNKNOWN_ERROR;
914    status_t ret = p->getDuration(msec);
915    if (ret == NO_ERROR) {
916        ALOGV("[%d] getDuration = %d", mConnId, *msec);
917    } else {
918        ALOGE("getDuration returned %d", ret);
919    }
920    return ret;
921}
922
923status_t MediaPlayerService::Client::setNextPlayer(const sp<IMediaPlayer>& player) {
924    ALOGV("setNextPlayer");
925    Mutex::Autolock l(mLock);
926    sp<Client> c = static_cast<Client*>(player.get());
927    mNextClient = c;
928
929    if (c != NULL) {
930        if (mAudioOutput != NULL) {
931            mAudioOutput->setNextOutput(c->mAudioOutput);
932        } else if ((mPlayer != NULL) && !mPlayer->hardwareOutput()) {
933            ALOGE("no current audio output");
934        }
935
936        if ((mPlayer != NULL) && (mNextClient->getPlayer() != NULL)) {
937            mPlayer->setNextPlayer(mNextClient->getPlayer());
938        }
939    }
940
941    return OK;
942}
943
944status_t MediaPlayerService::Client::seekTo(int msec)
945{
946    ALOGV("[%d] seekTo(%d)", mConnId, msec);
947    sp<MediaPlayerBase> p = getPlayer();
948    if (p == 0) return UNKNOWN_ERROR;
949    return p->seekTo(msec);
950}
951
952status_t MediaPlayerService::Client::reset()
953{
954    ALOGV("[%d] reset", mConnId);
955    mRetransmitEndpointValid = false;
956    sp<MediaPlayerBase> p = getPlayer();
957    if (p == 0) return UNKNOWN_ERROR;
958    return p->reset();
959}
960
961status_t MediaPlayerService::Client::setAudioStreamType(audio_stream_type_t type)
962{
963    ALOGV("[%d] setAudioStreamType(%d)", mConnId, type);
964    // TODO: for hardware output, call player instead
965    Mutex::Autolock l(mLock);
966    if (mAudioOutput != 0) mAudioOutput->setAudioStreamType(type);
967    return NO_ERROR;
968}
969
970status_t MediaPlayerService::Client::setLooping(int loop)
971{
972    ALOGV("[%d] setLooping(%d)", mConnId, loop);
973    mLoop = loop;
974    sp<MediaPlayerBase> p = getPlayer();
975    if (p != 0) return p->setLooping(loop);
976    return NO_ERROR;
977}
978
979status_t MediaPlayerService::Client::setVolume(float leftVolume, float rightVolume)
980{
981    ALOGV("[%d] setVolume(%f, %f)", mConnId, leftVolume, rightVolume);
982
983    // for hardware output, call player instead
984    sp<MediaPlayerBase> p = getPlayer();
985    {
986      Mutex::Autolock l(mLock);
987      if (p != 0 && p->hardwareOutput()) {
988          MediaPlayerHWInterface* hwp =
989                  reinterpret_cast<MediaPlayerHWInterface*>(p.get());
990          return hwp->setVolume(leftVolume, rightVolume);
991      } else {
992          if (mAudioOutput != 0) mAudioOutput->setVolume(leftVolume, rightVolume);
993          return NO_ERROR;
994      }
995    }
996
997    return NO_ERROR;
998}
999
1000status_t MediaPlayerService::Client::setAuxEffectSendLevel(float level)
1001{
1002    ALOGV("[%d] setAuxEffectSendLevel(%f)", mConnId, level);
1003    Mutex::Autolock l(mLock);
1004    if (mAudioOutput != 0) return mAudioOutput->setAuxEffectSendLevel(level);
1005    return NO_ERROR;
1006}
1007
1008status_t MediaPlayerService::Client::attachAuxEffect(int effectId)
1009{
1010    ALOGV("[%d] attachAuxEffect(%d)", mConnId, effectId);
1011    Mutex::Autolock l(mLock);
1012    if (mAudioOutput != 0) return mAudioOutput->attachAuxEffect(effectId);
1013    return NO_ERROR;
1014}
1015
1016status_t MediaPlayerService::Client::setParameter(int key, const Parcel &request) {
1017    ALOGV("[%d] setParameter(%d)", mConnId, key);
1018    sp<MediaPlayerBase> p = getPlayer();
1019    if (p == 0) return UNKNOWN_ERROR;
1020    return p->setParameter(key, request);
1021}
1022
1023status_t MediaPlayerService::Client::getParameter(int key, Parcel *reply) {
1024    ALOGV("[%d] getParameter(%d)", mConnId, key);
1025    sp<MediaPlayerBase> p = getPlayer();
1026    if (p == 0) return UNKNOWN_ERROR;
1027    return p->getParameter(key, reply);
1028}
1029
1030status_t MediaPlayerService::Client::setRetransmitEndpoint(
1031        const struct sockaddr_in* endpoint) {
1032
1033    if (NULL != endpoint) {
1034        uint32_t a = ntohl(endpoint->sin_addr.s_addr);
1035        uint16_t p = ntohs(endpoint->sin_port);
1036        ALOGV("[%d] setRetransmitEndpoint(%u.%u.%u.%u:%hu)", mConnId,
1037                (a >> 24), (a >> 16) & 0xFF, (a >> 8) & 0xFF, (a & 0xFF), p);
1038    } else {
1039        ALOGV("[%d] setRetransmitEndpoint = <none>", mConnId);
1040    }
1041
1042    sp<MediaPlayerBase> p = getPlayer();
1043
1044    // Right now, the only valid time to set a retransmit endpoint is before
1045    // player selection has been made (since the presence or absence of a
1046    // retransmit endpoint is going to determine which player is selected during
1047    // setDataSource).
1048    if (p != 0) return INVALID_OPERATION;
1049
1050    if (NULL != endpoint) {
1051        mRetransmitEndpoint = *endpoint;
1052        mRetransmitEndpointValid = true;
1053    } else {
1054        mRetransmitEndpointValid = false;
1055    }
1056
1057    return NO_ERROR;
1058}
1059
1060status_t MediaPlayerService::Client::getRetransmitEndpoint(
1061        struct sockaddr_in* endpoint)
1062{
1063    if (NULL == endpoint)
1064        return BAD_VALUE;
1065
1066    sp<MediaPlayerBase> p = getPlayer();
1067
1068    if (p != NULL)
1069        return p->getRetransmitEndpoint(endpoint);
1070
1071    if (!mRetransmitEndpointValid)
1072        return NO_INIT;
1073
1074    *endpoint = mRetransmitEndpoint;
1075
1076    return NO_ERROR;
1077}
1078
1079void MediaPlayerService::Client::notify(
1080        void* cookie, int msg, int ext1, int ext2, const Parcel *obj)
1081{
1082    Client* client = static_cast<Client*>(cookie);
1083    if (client == NULL) {
1084        return;
1085    }
1086
1087    sp<IMediaPlayerClient> c;
1088    {
1089        Mutex::Autolock l(client->mLock);
1090        c = client->mClient;
1091        if (msg == MEDIA_PLAYBACK_COMPLETE && client->mNextClient != NULL) {
1092            if (client->mAudioOutput != NULL)
1093                client->mAudioOutput->switchToNextOutput();
1094            client->mNextClient->start();
1095            client->mNextClient->mClient->notify(MEDIA_INFO, MEDIA_INFO_STARTED_AS_NEXT, 0, obj);
1096        }
1097    }
1098
1099    if (MEDIA_INFO == msg &&
1100        MEDIA_INFO_METADATA_UPDATE == ext1) {
1101        const media::Metadata::Type metadata_type = ext2;
1102
1103        if(client->shouldDropMetadata(metadata_type)) {
1104            return;
1105        }
1106
1107        // Update the list of metadata that have changed. getMetadata
1108        // also access mMetadataUpdated and clears it.
1109        client->addNewMetadataUpdate(metadata_type);
1110    }
1111
1112    if (c != NULL) {
1113        ALOGV("[%d] notify (%p, %d, %d, %d)", client->mConnId, cookie, msg, ext1, ext2);
1114        c->notify(msg, ext1, ext2, obj);
1115    }
1116}
1117
1118
1119bool MediaPlayerService::Client::shouldDropMetadata(media::Metadata::Type code) const
1120{
1121    Mutex::Autolock lock(mLock);
1122
1123    if (findMetadata(mMetadataDrop, code)) {
1124        return true;
1125    }
1126
1127    if (mMetadataAllow.isEmpty() || findMetadata(mMetadataAllow, code)) {
1128        return false;
1129    } else {
1130        return true;
1131    }
1132}
1133
1134
1135void MediaPlayerService::Client::addNewMetadataUpdate(media::Metadata::Type metadata_type) {
1136    Mutex::Autolock lock(mLock);
1137    if (mMetadataUpdated.indexOf(metadata_type) < 0) {
1138        mMetadataUpdated.add(metadata_type);
1139    }
1140}
1141
1142#if CALLBACK_ANTAGONIZER
1143const int Antagonizer::interval = 10000; // 10 msecs
1144
1145Antagonizer::Antagonizer(notify_callback_f cb, void* client) :
1146    mExit(false), mActive(false), mClient(client), mCb(cb)
1147{
1148    createThread(callbackThread, this);
1149}
1150
1151void Antagonizer::kill()
1152{
1153    Mutex::Autolock _l(mLock);
1154    mActive = false;
1155    mExit = true;
1156    mCondition.wait(mLock);
1157}
1158
1159int Antagonizer::callbackThread(void* user)
1160{
1161    ALOGD("Antagonizer started");
1162    Antagonizer* p = reinterpret_cast<Antagonizer*>(user);
1163    while (!p->mExit) {
1164        if (p->mActive) {
1165            ALOGV("send event");
1166            p->mCb(p->mClient, 0, 0, 0);
1167        }
1168        usleep(interval);
1169    }
1170    Mutex::Autolock _l(p->mLock);
1171    p->mCondition.signal();
1172    ALOGD("Antagonizer stopped");
1173    return 0;
1174}
1175#endif
1176
1177status_t MediaPlayerService::decode(
1178        const sp<IMediaHTTPService> &httpService,
1179        const char* url,
1180        uint32_t *pSampleRate,
1181        int* pNumChannels,
1182        audio_format_t* pFormat,
1183        const sp<IMemoryHeap>& heap,
1184        size_t *pSize)
1185{
1186    ALOGV("decode(%s)", url);
1187    sp<MediaPlayerBase> player;
1188    status_t status = BAD_VALUE;
1189
1190    // Protect our precious, precious DRMd ringtones by only allowing
1191    // decoding of http, but not filesystem paths or content Uris.
1192    // If the application wants to decode those, it should open a
1193    // filedescriptor for them and use that.
1194    if (url != NULL && strncmp(url, "http://", 7) != 0) {
1195        ALOGD("Can't decode %s by path, use filedescriptor instead", url);
1196        return BAD_VALUE;
1197    }
1198
1199    player_type playerType =
1200        MediaPlayerFactory::getPlayerType(NULL /* client */, url);
1201    ALOGV("player type = %d", playerType);
1202
1203    // create the right type of player
1204    sp<AudioCache> cache = new AudioCache(heap);
1205    player = MediaPlayerFactory::createPlayer(playerType, cache.get(), cache->notify);
1206    if (player == NULL) goto Exit;
1207    if (player->hardwareOutput()) goto Exit;
1208
1209    static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache);
1210
1211    // set data source
1212    if (player->setDataSource(httpService, url) != NO_ERROR) goto Exit;
1213
1214    ALOGV("prepare");
1215    player->prepareAsync();
1216
1217    ALOGV("wait for prepare");
1218    if (cache->wait() != NO_ERROR) goto Exit;
1219
1220    ALOGV("start");
1221    player->start();
1222
1223    ALOGV("wait for playback complete");
1224    cache->wait();
1225    // in case of error, return what was successfully decoded.
1226    if (cache->size() == 0) {
1227        goto Exit;
1228    }
1229
1230    *pSize = cache->size();
1231    *pSampleRate = cache->sampleRate();
1232    *pNumChannels = cache->channelCount();
1233    *pFormat = cache->format();
1234    ALOGV("return size %d sampleRate=%u, channelCount = %d, format = %d",
1235          *pSize, *pSampleRate, *pNumChannels, *pFormat);
1236    status = NO_ERROR;
1237
1238Exit:
1239    if (player != 0) player->reset();
1240    return status;
1241}
1242
1243status_t MediaPlayerService::decode(int fd, int64_t offset, int64_t length,
1244                                       uint32_t *pSampleRate, int* pNumChannels,
1245                                       audio_format_t* pFormat,
1246                                       const sp<IMemoryHeap>& heap, size_t *pSize)
1247{
1248    ALOGV("decode(%d, %lld, %lld)", fd, offset, length);
1249    sp<MediaPlayerBase> player;
1250    status_t status = BAD_VALUE;
1251
1252    player_type playerType = MediaPlayerFactory::getPlayerType(NULL /* client */,
1253                                                               fd,
1254                                                               offset,
1255                                                               length);
1256    ALOGV("player type = %d", playerType);
1257
1258    // create the right type of player
1259    sp<AudioCache> cache = new AudioCache(heap);
1260    player = MediaPlayerFactory::createPlayer(playerType, cache.get(), cache->notify);
1261    if (player == NULL) goto Exit;
1262    if (player->hardwareOutput()) goto Exit;
1263
1264    static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache);
1265
1266    // set data source
1267    if (player->setDataSource(fd, offset, length) != NO_ERROR) goto Exit;
1268
1269    ALOGV("prepare");
1270    player->prepareAsync();
1271
1272    ALOGV("wait for prepare");
1273    if (cache->wait() != NO_ERROR) goto Exit;
1274
1275    ALOGV("start");
1276    player->start();
1277
1278    ALOGV("wait for playback complete");
1279    cache->wait();
1280    // in case of error, return what was successfully decoded.
1281    if (cache->size() == 0) {
1282        goto Exit;
1283    }
1284
1285    *pSize = cache->size();
1286    *pSampleRate = cache->sampleRate();
1287    *pNumChannels = cache->channelCount();
1288    *pFormat = cache->format();
1289    ALOGV("return size %d, sampleRate=%u, channelCount = %d, format = %d",
1290          *pSize, *pSampleRate, *pNumChannels, *pFormat);
1291    status = NO_ERROR;
1292
1293Exit:
1294    if (player != 0) player->reset();
1295    ::close(fd);
1296    return status;
1297}
1298
1299
1300#undef LOG_TAG
1301#define LOG_TAG "AudioSink"
1302MediaPlayerService::AudioOutput::AudioOutput(int sessionId, int uid)
1303    : mCallback(NULL),
1304      mCallbackCookie(NULL),
1305      mCallbackData(NULL),
1306      mBytesWritten(0),
1307      mSessionId(sessionId),
1308      mUid(uid),
1309      mFlags(AUDIO_OUTPUT_FLAG_NONE) {
1310    ALOGV("AudioOutput(%d)", sessionId);
1311    mStreamType = AUDIO_STREAM_MUSIC;
1312    mLeftVolume = 1.0;
1313    mRightVolume = 1.0;
1314    mPlaybackRatePermille = 1000;
1315    mSampleRateHz = 0;
1316    mMsecsPerFrame = 0;
1317    mAuxEffectId = 0;
1318    mSendLevel = 0.0;
1319    setMinBufferCount();
1320}
1321
1322MediaPlayerService::AudioOutput::~AudioOutput()
1323{
1324    close();
1325    delete mCallbackData;
1326}
1327
1328void MediaPlayerService::AudioOutput::setMinBufferCount()
1329{
1330    char value[PROPERTY_VALUE_MAX];
1331    if (property_get("ro.kernel.qemu", value, 0)) {
1332        mIsOnEmulator = true;
1333        mMinBufferCount = 12;  // to prevent systematic buffer underrun for emulator
1334    }
1335}
1336
1337bool MediaPlayerService::AudioOutput::isOnEmulator()
1338{
1339    setMinBufferCount();
1340    return mIsOnEmulator;
1341}
1342
1343int MediaPlayerService::AudioOutput::getMinBufferCount()
1344{
1345    setMinBufferCount();
1346    return mMinBufferCount;
1347}
1348
1349ssize_t MediaPlayerService::AudioOutput::bufferSize() const
1350{
1351    if (mTrack == 0) return NO_INIT;
1352    return mTrack->frameCount() * frameSize();
1353}
1354
1355ssize_t MediaPlayerService::AudioOutput::frameCount() const
1356{
1357    if (mTrack == 0) return NO_INIT;
1358    return mTrack->frameCount();
1359}
1360
1361ssize_t MediaPlayerService::AudioOutput::channelCount() const
1362{
1363    if (mTrack == 0) return NO_INIT;
1364    return mTrack->channelCount();
1365}
1366
1367ssize_t MediaPlayerService::AudioOutput::frameSize() const
1368{
1369    if (mTrack == 0) return NO_INIT;
1370    return mTrack->frameSize();
1371}
1372
1373uint32_t MediaPlayerService::AudioOutput::latency () const
1374{
1375    if (mTrack == 0) return 0;
1376    return mTrack->latency();
1377}
1378
1379float MediaPlayerService::AudioOutput::msecsPerFrame() const
1380{
1381    return mMsecsPerFrame;
1382}
1383
1384status_t MediaPlayerService::AudioOutput::getPosition(uint32_t *position) const
1385{
1386    if (mTrack == 0) return NO_INIT;
1387    return mTrack->getPosition(position);
1388}
1389
1390status_t MediaPlayerService::AudioOutput::getFramesWritten(uint32_t *frameswritten) const
1391{
1392    if (mTrack == 0) return NO_INIT;
1393    *frameswritten = mBytesWritten / frameSize();
1394    return OK;
1395}
1396
1397status_t MediaPlayerService::AudioOutput::setParameters(const String8& keyValuePairs)
1398{
1399    if (mTrack == 0) return NO_INIT;
1400    return mTrack->setParameters(keyValuePairs);
1401}
1402
1403String8  MediaPlayerService::AudioOutput::getParameters(const String8& keys)
1404{
1405    if (mTrack == 0) return String8::empty();
1406    return mTrack->getParameters(keys);
1407}
1408
1409void MediaPlayerService::AudioOutput::deleteRecycledTrack()
1410{
1411    ALOGV("deleteRecycledTrack");
1412
1413    if (mRecycledTrack != 0) {
1414
1415        if (mCallbackData != NULL) {
1416            mCallbackData->setOutput(NULL);
1417            mCallbackData->endTrackSwitch();
1418        }
1419
1420        if ((mRecycledTrack->getFlags() & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) {
1421            mRecycledTrack->flush();
1422        }
1423        // An offloaded track isn't flushed because the STREAM_END is reported
1424        // slightly prematurely to allow time for the gapless track switch
1425        // but this means that if we decide not to recycle the track there
1426        // could be a small amount of residual data still playing. We leave
1427        // AudioFlinger to drain the track.
1428
1429        mRecycledTrack.clear();
1430        delete mCallbackData;
1431        mCallbackData = NULL;
1432        close();
1433    }
1434}
1435
1436status_t MediaPlayerService::AudioOutput::open(
1437        uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
1438        audio_format_t format, int bufferCount,
1439        AudioCallback cb, void *cookie,
1440        audio_output_flags_t flags,
1441        const audio_offload_info_t *offloadInfo)
1442{
1443    mCallback = cb;
1444    mCallbackCookie = cookie;
1445
1446    // Check argument "bufferCount" against the mininum buffer count
1447    if (bufferCount < mMinBufferCount) {
1448        ALOGD("bufferCount (%d) is too small and increased to %d", bufferCount, mMinBufferCount);
1449        bufferCount = mMinBufferCount;
1450
1451    }
1452    ALOGV("open(%u, %d, 0x%x, 0x%x, %d, %d 0x%x)", sampleRate, channelCount, channelMask,
1453                format, bufferCount, mSessionId, flags);
1454    uint32_t afSampleRate;
1455    size_t afFrameCount;
1456    uint32_t frameCount;
1457
1458    // offloading is only supported in callback mode for now.
1459    // offloadInfo must be present if offload flag is set
1460    if (((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) &&
1461            ((cb == NULL) || (offloadInfo == NULL))) {
1462        return BAD_VALUE;
1463    }
1464
1465    if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0) {
1466        frameCount = 0; // AudioTrack will get frame count from AudioFlinger
1467    } else {
1468        uint32_t afSampleRate;
1469        size_t afFrameCount;
1470
1471        if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) != NO_ERROR) {
1472            return NO_INIT;
1473        }
1474        if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) != NO_ERROR) {
1475            return NO_INIT;
1476        }
1477
1478        frameCount = (sampleRate*afFrameCount*bufferCount)/afSampleRate;
1479    }
1480
1481    if (channelMask == CHANNEL_MASK_USE_CHANNEL_ORDER) {
1482        channelMask = audio_channel_out_mask_from_count(channelCount);
1483        if (0 == channelMask) {
1484            ALOGE("open() error, can\'t derive mask for %d audio channels", channelCount);
1485            return NO_INIT;
1486        }
1487    }
1488
1489    // Check whether we can recycle the track
1490    bool reuse = false;
1491    bool bothOffloaded = false;
1492
1493    if (mRecycledTrack != 0) {
1494        // check whether we are switching between two offloaded tracks
1495        bothOffloaded = (flags & mRecycledTrack->getFlags()
1496                                & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) != 0;
1497
1498        // check if the existing track can be reused as-is, or if a new track needs to be created.
1499        reuse = true;
1500
1501        if ((mCallbackData == NULL && mCallback != NULL) ||
1502                (mCallbackData != NULL && mCallback == NULL)) {
1503            // recycled track uses callbacks but the caller wants to use writes, or vice versa
1504            ALOGV("can't chain callback and write");
1505            reuse = false;
1506        } else if ((mRecycledTrack->getSampleRate() != sampleRate) ||
1507                (mRecycledTrack->channelCount() != (uint32_t)channelCount) ) {
1508            ALOGV("samplerate, channelcount differ: %u/%u Hz, %u/%d ch",
1509                  mRecycledTrack->getSampleRate(), sampleRate,
1510                  mRecycledTrack->channelCount(), channelCount);
1511            reuse = false;
1512        } else if (flags != mFlags) {
1513            ALOGV("output flags differ %08x/%08x", flags, mFlags);
1514            reuse = false;
1515        } else if (mRecycledTrack->format() != format) {
1516            reuse = false;
1517        }
1518    } else {
1519        ALOGV("no track available to recycle");
1520    }
1521
1522    ALOGV_IF(bothOffloaded, "both tracks offloaded");
1523
1524    // If we can't recycle and both tracks are offloaded
1525    // we must close the previous output before opening a new one
1526    if (bothOffloaded && !reuse) {
1527        ALOGV("both offloaded and not recycling");
1528        deleteRecycledTrack();
1529    }
1530
1531    sp<AudioTrack> t;
1532    CallbackData *newcbd = NULL;
1533
1534    // We don't attempt to create a new track if we are recycling an
1535    // offloaded track. But, if we are recycling a non-offloaded or we
1536    // are switching where one is offloaded and one isn't then we create
1537    // the new track in advance so that we can read additional stream info
1538
1539    if (!(reuse && bothOffloaded)) {
1540        ALOGV("creating new AudioTrack");
1541
1542        if (mCallback != NULL) {
1543            newcbd = new CallbackData(this);
1544            t = new AudioTrack(
1545                    mStreamType,
1546                    sampleRate,
1547                    format,
1548                    channelMask,
1549                    frameCount,
1550                    flags,
1551                    CallbackWrapper,
1552                    newcbd,
1553                    0,  // notification frames
1554                    mSessionId,
1555                    AudioTrack::TRANSFER_CALLBACK,
1556                    offloadInfo,
1557                    mUid);
1558        } else {
1559            t = new AudioTrack(
1560                    mStreamType,
1561                    sampleRate,
1562                    format,
1563                    channelMask,
1564                    frameCount,
1565                    flags,
1566                    NULL, // callback
1567                    NULL, // user data
1568                    0, // notification frames
1569                    mSessionId,
1570                    AudioTrack::TRANSFER_DEFAULT,
1571                    NULL, // offload info
1572                    mUid);
1573        }
1574
1575        if ((t == 0) || (t->initCheck() != NO_ERROR)) {
1576            ALOGE("Unable to create audio track");
1577            delete newcbd;
1578            return NO_INIT;
1579        }
1580    }
1581
1582    if (reuse) {
1583        CHECK(mRecycledTrack != NULL);
1584
1585        if (!bothOffloaded) {
1586            if (mRecycledTrack->frameCount() != t->frameCount()) {
1587                ALOGV("framecount differs: %u/%u frames",
1588                      mRecycledTrack->frameCount(), t->frameCount());
1589                reuse = false;
1590            }
1591        }
1592
1593        if (reuse) {
1594            ALOGV("chaining to next output and recycling track");
1595            close();
1596            mTrack = mRecycledTrack;
1597            mRecycledTrack.clear();
1598            if (mCallbackData != NULL) {
1599                mCallbackData->setOutput(this);
1600            }
1601            delete newcbd;
1602            return OK;
1603        }
1604    }
1605
1606    // we're not going to reuse the track, unblock and flush it
1607    // this was done earlier if both tracks are offloaded
1608    if (!bothOffloaded) {
1609        deleteRecycledTrack();
1610    }
1611
1612    CHECK((t != NULL) && ((mCallback == NULL) || (newcbd != NULL)));
1613
1614    mCallbackData = newcbd;
1615    ALOGV("setVolume");
1616    t->setVolume(mLeftVolume, mRightVolume);
1617
1618    mSampleRateHz = sampleRate;
1619    mFlags = flags;
1620    mMsecsPerFrame = mPlaybackRatePermille / (float) sampleRate;
1621    uint32_t pos;
1622    if (t->getPosition(&pos) == OK) {
1623        mBytesWritten = uint64_t(pos) * t->frameSize();
1624    }
1625    mTrack = t;
1626
1627    status_t res = NO_ERROR;
1628    if ((flags & AUDIO_OUTPUT_FLAG_COMPRESS_OFFLOAD) == 0) {
1629        res = t->setSampleRate(mPlaybackRatePermille * mSampleRateHz / 1000);
1630        if (res == NO_ERROR) {
1631            t->setAuxEffectSendLevel(mSendLevel);
1632            res = t->attachAuxEffect(mAuxEffectId);
1633        }
1634    }
1635    ALOGV("open() DONE status %d", res);
1636    return res;
1637}
1638
1639status_t MediaPlayerService::AudioOutput::start()
1640{
1641    ALOGV("start");
1642    if (mCallbackData != NULL) {
1643        mCallbackData->endTrackSwitch();
1644    }
1645    if (mTrack != 0) {
1646        mTrack->setVolume(mLeftVolume, mRightVolume);
1647        mTrack->setAuxEffectSendLevel(mSendLevel);
1648        return mTrack->start();
1649    }
1650    return NO_INIT;
1651}
1652
1653void MediaPlayerService::AudioOutput::setNextOutput(const sp<AudioOutput>& nextOutput) {
1654    mNextOutput = nextOutput;
1655}
1656
1657
1658void MediaPlayerService::AudioOutput::switchToNextOutput() {
1659    ALOGV("switchToNextOutput");
1660    if (mNextOutput != NULL) {
1661        if (mCallbackData != NULL) {
1662            mCallbackData->beginTrackSwitch();
1663        }
1664        delete mNextOutput->mCallbackData;
1665        mNextOutput->mCallbackData = mCallbackData;
1666        mCallbackData = NULL;
1667        mNextOutput->mRecycledTrack = mTrack;
1668        mTrack.clear();
1669        mNextOutput->mSampleRateHz = mSampleRateHz;
1670        mNextOutput->mMsecsPerFrame = mMsecsPerFrame;
1671        mNextOutput->mBytesWritten = mBytesWritten;
1672        mNextOutput->mFlags = mFlags;
1673    }
1674}
1675
1676ssize_t MediaPlayerService::AudioOutput::write(const void* buffer, size_t size)
1677{
1678    LOG_FATAL_IF(mCallback != NULL, "Don't call write if supplying a callback.");
1679
1680    //ALOGV("write(%p, %u)", buffer, size);
1681    if (mTrack != 0) {
1682        ssize_t ret = mTrack->write(buffer, size);
1683        mBytesWritten += ret;
1684        return ret;
1685    }
1686    return NO_INIT;
1687}
1688
1689void MediaPlayerService::AudioOutput::stop()
1690{
1691    ALOGV("stop");
1692    if (mTrack != 0) mTrack->stop();
1693}
1694
1695void MediaPlayerService::AudioOutput::flush()
1696{
1697    ALOGV("flush");
1698    if (mTrack != 0) mTrack->flush();
1699}
1700
1701void MediaPlayerService::AudioOutput::pause()
1702{
1703    ALOGV("pause");
1704    if (mTrack != 0) mTrack->pause();
1705}
1706
1707void MediaPlayerService::AudioOutput::close()
1708{
1709    ALOGV("close");
1710    mTrack.clear();
1711}
1712
1713void MediaPlayerService::AudioOutput::setVolume(float left, float right)
1714{
1715    ALOGV("setVolume(%f, %f)", left, right);
1716    mLeftVolume = left;
1717    mRightVolume = right;
1718    if (mTrack != 0) {
1719        mTrack->setVolume(left, right);
1720    }
1721}
1722
1723status_t MediaPlayerService::AudioOutput::setPlaybackRatePermille(int32_t ratePermille)
1724{
1725    ALOGV("setPlaybackRatePermille(%d)", ratePermille);
1726    status_t res = NO_ERROR;
1727    if (mTrack != 0) {
1728        res = mTrack->setSampleRate(ratePermille * mSampleRateHz / 1000);
1729    } else {
1730        res = NO_INIT;
1731    }
1732    mPlaybackRatePermille = ratePermille;
1733    if (mSampleRateHz != 0) {
1734        mMsecsPerFrame = mPlaybackRatePermille / (float) mSampleRateHz;
1735    }
1736    return res;
1737}
1738
1739status_t MediaPlayerService::AudioOutput::setAuxEffectSendLevel(float level)
1740{
1741    ALOGV("setAuxEffectSendLevel(%f)", level);
1742    mSendLevel = level;
1743    if (mTrack != 0) {
1744        return mTrack->setAuxEffectSendLevel(level);
1745    }
1746    return NO_ERROR;
1747}
1748
1749status_t MediaPlayerService::AudioOutput::attachAuxEffect(int effectId)
1750{
1751    ALOGV("attachAuxEffect(%d)", effectId);
1752    mAuxEffectId = effectId;
1753    if (mTrack != 0) {
1754        return mTrack->attachAuxEffect(effectId);
1755    }
1756    return NO_ERROR;
1757}
1758
1759// static
1760void MediaPlayerService::AudioOutput::CallbackWrapper(
1761        int event, void *cookie, void *info) {
1762    //ALOGV("callbackwrapper");
1763    CallbackData *data = (CallbackData*)cookie;
1764    data->lock();
1765    AudioOutput *me = data->getOutput();
1766    AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
1767    if (me == NULL) {
1768        // no output set, likely because the track was scheduled to be reused
1769        // by another player, but the format turned out to be incompatible.
1770        data->unlock();
1771        if (buffer != NULL) {
1772            buffer->size = 0;
1773        }
1774        return;
1775    }
1776
1777    switch(event) {
1778    case AudioTrack::EVENT_MORE_DATA: {
1779        size_t actualSize = (*me->mCallback)(
1780                me, buffer->raw, buffer->size, me->mCallbackCookie,
1781                CB_EVENT_FILL_BUFFER);
1782
1783        if (actualSize == 0 && buffer->size > 0 && me->mNextOutput == NULL) {
1784            // We've reached EOS but the audio track is not stopped yet,
1785            // keep playing silence.
1786
1787            memset(buffer->raw, 0, buffer->size);
1788            actualSize = buffer->size;
1789        }
1790
1791        buffer->size = actualSize;
1792        } break;
1793
1794
1795    case AudioTrack::EVENT_STREAM_END:
1796        ALOGV("callbackwrapper: deliver EVENT_STREAM_END");
1797        (*me->mCallback)(me, NULL /* buffer */, 0 /* size */,
1798                me->mCallbackCookie, CB_EVENT_STREAM_END);
1799        break;
1800
1801    case AudioTrack::EVENT_NEW_IAUDIOTRACK :
1802        ALOGV("callbackwrapper: deliver EVENT_TEAR_DOWN");
1803        (*me->mCallback)(me,  NULL /* buffer */, 0 /* size */,
1804                me->mCallbackCookie, CB_EVENT_TEAR_DOWN);
1805        break;
1806
1807    default:
1808        ALOGE("received unknown event type: %d inside CallbackWrapper !", event);
1809    }
1810
1811    data->unlock();
1812}
1813
1814int MediaPlayerService::AudioOutput::getSessionId() const
1815{
1816    return mSessionId;
1817}
1818
1819uint32_t MediaPlayerService::AudioOutput::getSampleRate() const
1820{
1821    if (mTrack == 0) return 0;
1822    return mTrack->getSampleRate();
1823}
1824
1825#undef LOG_TAG
1826#define LOG_TAG "AudioCache"
1827MediaPlayerService::AudioCache::AudioCache(const sp<IMemoryHeap>& heap) :
1828    mHeap(heap), mChannelCount(0), mFrameCount(1024), mSampleRate(0), mSize(0),
1829    mError(NO_ERROR),  mCommandComplete(false)
1830{
1831}
1832
1833uint32_t MediaPlayerService::AudioCache::latency () const
1834{
1835    return 0;
1836}
1837
1838float MediaPlayerService::AudioCache::msecsPerFrame() const
1839{
1840    return mMsecsPerFrame;
1841}
1842
1843status_t MediaPlayerService::AudioCache::getPosition(uint32_t *position) const
1844{
1845    if (position == 0) return BAD_VALUE;
1846    *position = mSize;
1847    return NO_ERROR;
1848}
1849
1850status_t MediaPlayerService::AudioCache::getFramesWritten(uint32_t *written) const
1851{
1852    if (written == 0) return BAD_VALUE;
1853    *written = mSize;
1854    return NO_ERROR;
1855}
1856
1857////////////////////////////////////////////////////////////////////////////////
1858
1859struct CallbackThread : public Thread {
1860    CallbackThread(const wp<MediaPlayerBase::AudioSink> &sink,
1861                   MediaPlayerBase::AudioSink::AudioCallback cb,
1862                   void *cookie);
1863
1864protected:
1865    virtual ~CallbackThread();
1866
1867    virtual bool threadLoop();
1868
1869private:
1870    wp<MediaPlayerBase::AudioSink> mSink;
1871    MediaPlayerBase::AudioSink::AudioCallback mCallback;
1872    void *mCookie;
1873    void *mBuffer;
1874    size_t mBufferSize;
1875
1876    CallbackThread(const CallbackThread &);
1877    CallbackThread &operator=(const CallbackThread &);
1878};
1879
1880CallbackThread::CallbackThread(
1881        const wp<MediaPlayerBase::AudioSink> &sink,
1882        MediaPlayerBase::AudioSink::AudioCallback cb,
1883        void *cookie)
1884    : mSink(sink),
1885      mCallback(cb),
1886      mCookie(cookie),
1887      mBuffer(NULL),
1888      mBufferSize(0) {
1889}
1890
1891CallbackThread::~CallbackThread() {
1892    if (mBuffer) {
1893        free(mBuffer);
1894        mBuffer = NULL;
1895    }
1896}
1897
1898bool CallbackThread::threadLoop() {
1899    sp<MediaPlayerBase::AudioSink> sink = mSink.promote();
1900    if (sink == NULL) {
1901        return false;
1902    }
1903
1904    if (mBuffer == NULL) {
1905        mBufferSize = sink->bufferSize();
1906        mBuffer = malloc(mBufferSize);
1907    }
1908
1909    size_t actualSize =
1910        (*mCallback)(sink.get(), mBuffer, mBufferSize, mCookie,
1911                MediaPlayerBase::AudioSink::CB_EVENT_FILL_BUFFER);
1912
1913    if (actualSize > 0) {
1914        sink->write(mBuffer, actualSize);
1915    }
1916
1917    return true;
1918}
1919
1920////////////////////////////////////////////////////////////////////////////////
1921
1922status_t MediaPlayerService::AudioCache::open(
1923        uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
1924        audio_format_t format, int bufferCount,
1925        AudioCallback cb, void *cookie, audio_output_flags_t flags,
1926        const audio_offload_info_t *offloadInfo)
1927{
1928    ALOGV("open(%u, %d, 0x%x, %d, %d)", sampleRate, channelCount, channelMask, format, bufferCount);
1929    if (mHeap->getHeapID() < 0) {
1930        return NO_INIT;
1931    }
1932
1933    mSampleRate = sampleRate;
1934    mChannelCount = (uint16_t)channelCount;
1935    mFormat = format;
1936    mMsecsPerFrame = 1.e3 / (float) sampleRate;
1937
1938    if (cb != NULL) {
1939        mCallbackThread = new CallbackThread(this, cb, cookie);
1940    }
1941    return NO_ERROR;
1942}
1943
1944status_t MediaPlayerService::AudioCache::start() {
1945    if (mCallbackThread != NULL) {
1946        mCallbackThread->run("AudioCache callback");
1947    }
1948    return NO_ERROR;
1949}
1950
1951void MediaPlayerService::AudioCache::stop() {
1952    if (mCallbackThread != NULL) {
1953        mCallbackThread->requestExitAndWait();
1954    }
1955}
1956
1957ssize_t MediaPlayerService::AudioCache::write(const void* buffer, size_t size)
1958{
1959    ALOGV("write(%p, %u)", buffer, size);
1960    if ((buffer == 0) || (size == 0)) return size;
1961
1962    uint8_t* p = static_cast<uint8_t*>(mHeap->getBase());
1963    if (p == NULL) return NO_INIT;
1964    p += mSize;
1965    ALOGV("memcpy(%p, %p, %u)", p, buffer, size);
1966    if (mSize + size > mHeap->getSize()) {
1967        ALOGE("Heap size overflow! req size: %d, max size: %d", (mSize + size), mHeap->getSize());
1968        size = mHeap->getSize() - mSize;
1969    }
1970    memcpy(p, buffer, size);
1971    mSize += size;
1972    return size;
1973}
1974
1975// call with lock held
1976status_t MediaPlayerService::AudioCache::wait()
1977{
1978    Mutex::Autolock lock(mLock);
1979    while (!mCommandComplete) {
1980        mSignal.wait(mLock);
1981    }
1982    mCommandComplete = false;
1983
1984    if (mError == NO_ERROR) {
1985        ALOGV("wait - success");
1986    } else {
1987        ALOGV("wait - error");
1988    }
1989    return mError;
1990}
1991
1992void MediaPlayerService::AudioCache::notify(
1993        void* cookie, int msg, int ext1, int ext2, const Parcel *obj)
1994{
1995    ALOGV("notify(%p, %d, %d, %d)", cookie, msg, ext1, ext2);
1996    AudioCache* p = static_cast<AudioCache*>(cookie);
1997
1998    // ignore buffering messages
1999    switch (msg)
2000    {
2001    case MEDIA_ERROR:
2002        ALOGE("Error %d, %d occurred", ext1, ext2);
2003        p->mError = ext1;
2004        break;
2005    case MEDIA_PREPARED:
2006        ALOGV("prepared");
2007        break;
2008    case MEDIA_PLAYBACK_COMPLETE:
2009        ALOGV("playback complete");
2010        break;
2011    default:
2012        ALOGV("ignored");
2013        return;
2014    }
2015
2016    // wake up thread
2017    Mutex::Autolock lock(p->mLock);
2018    p->mCommandComplete = true;
2019    p->mSignal.signal();
2020}
2021
2022int MediaPlayerService::AudioCache::getSessionId() const
2023{
2024    return 0;
2025}
2026
2027uint32_t MediaPlayerService::AudioCache::getSampleRate() const
2028{
2029    if (mMsecsPerFrame == 0) {
2030        return 0;
2031    }
2032    return (uint32_t)(1.e3 / mMsecsPerFrame);
2033}
2034
2035void MediaPlayerService::addBatteryData(uint32_t params)
2036{
2037    Mutex::Autolock lock(mLock);
2038
2039    int32_t time = systemTime() / 1000000L;
2040
2041    // change audio output devices. This notification comes from AudioFlinger
2042    if ((params & kBatteryDataSpeakerOn)
2043            || (params & kBatteryDataOtherAudioDeviceOn)) {
2044
2045        int deviceOn[NUM_AUDIO_DEVICES];
2046        for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2047            deviceOn[i] = 0;
2048        }
2049
2050        if ((params & kBatteryDataSpeakerOn)
2051                && (params & kBatteryDataOtherAudioDeviceOn)) {
2052            deviceOn[SPEAKER_AND_OTHER] = 1;
2053        } else if (params & kBatteryDataSpeakerOn) {
2054            deviceOn[SPEAKER] = 1;
2055        } else {
2056            deviceOn[OTHER_AUDIO_DEVICE] = 1;
2057        }
2058
2059        for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2060            if (mBatteryAudio.deviceOn[i] != deviceOn[i]){
2061
2062                if (mBatteryAudio.refCount > 0) { // if playing audio
2063                    if (!deviceOn[i]) {
2064                        mBatteryAudio.lastTime[i] += time;
2065                        mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
2066                        mBatteryAudio.lastTime[i] = 0;
2067                    } else {
2068                        mBatteryAudio.lastTime[i] = 0 - time;
2069                    }
2070                }
2071
2072                mBatteryAudio.deviceOn[i] = deviceOn[i];
2073            }
2074        }
2075        return;
2076    }
2077
2078    // an sudio stream is started
2079    if (params & kBatteryDataAudioFlingerStart) {
2080        // record the start time only if currently no other audio
2081        // is being played
2082        if (mBatteryAudio.refCount == 0) {
2083            for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2084                if (mBatteryAudio.deviceOn[i]) {
2085                    mBatteryAudio.lastTime[i] -= time;
2086                }
2087            }
2088        }
2089
2090        mBatteryAudio.refCount ++;
2091        return;
2092
2093    } else if (params & kBatteryDataAudioFlingerStop) {
2094        if (mBatteryAudio.refCount <= 0) {
2095            ALOGW("Battery track warning: refCount is <= 0");
2096            return;
2097        }
2098
2099        // record the stop time only if currently this is the only
2100        // audio being played
2101        if (mBatteryAudio.refCount == 1) {
2102            for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2103                if (mBatteryAudio.deviceOn[i]) {
2104                    mBatteryAudio.lastTime[i] += time;
2105                    mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
2106                    mBatteryAudio.lastTime[i] = 0;
2107                }
2108            }
2109        }
2110
2111        mBatteryAudio.refCount --;
2112        return;
2113    }
2114
2115    int uid = IPCThreadState::self()->getCallingUid();
2116    if (uid == AID_MEDIA) {
2117        return;
2118    }
2119    int index = mBatteryData.indexOfKey(uid);
2120
2121    if (index < 0) { // create a new entry for this UID
2122        BatteryUsageInfo info;
2123        info.audioTotalTime = 0;
2124        info.videoTotalTime = 0;
2125        info.audioLastTime = 0;
2126        info.videoLastTime = 0;
2127        info.refCount = 0;
2128
2129        if (mBatteryData.add(uid, info) == NO_MEMORY) {
2130            ALOGE("Battery track error: no memory for new app");
2131            return;
2132        }
2133    }
2134
2135    BatteryUsageInfo &info = mBatteryData.editValueFor(uid);
2136
2137    if (params & kBatteryDataCodecStarted) {
2138        if (params & kBatteryDataTrackAudio) {
2139            info.audioLastTime -= time;
2140            info.refCount ++;
2141        }
2142        if (params & kBatteryDataTrackVideo) {
2143            info.videoLastTime -= time;
2144            info.refCount ++;
2145        }
2146    } else {
2147        if (info.refCount == 0) {
2148            ALOGW("Battery track warning: refCount is already 0");
2149            return;
2150        } else if (info.refCount < 0) {
2151            ALOGE("Battery track error: refCount < 0");
2152            mBatteryData.removeItem(uid);
2153            return;
2154        }
2155
2156        if (params & kBatteryDataTrackAudio) {
2157            info.audioLastTime += time;
2158            info.refCount --;
2159        }
2160        if (params & kBatteryDataTrackVideo) {
2161            info.videoLastTime += time;
2162            info.refCount --;
2163        }
2164
2165        // no stream is being played by this UID
2166        if (info.refCount == 0) {
2167            info.audioTotalTime += info.audioLastTime;
2168            info.audioLastTime = 0;
2169            info.videoTotalTime += info.videoLastTime;
2170            info.videoLastTime = 0;
2171        }
2172    }
2173}
2174
2175status_t MediaPlayerService::pullBatteryData(Parcel* reply) {
2176    Mutex::Autolock lock(mLock);
2177
2178    // audio output devices usage
2179    int32_t time = systemTime() / 1000000L; //in ms
2180    int32_t totalTime;
2181
2182    for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
2183        totalTime = mBatteryAudio.totalTime[i];
2184
2185        if (mBatteryAudio.deviceOn[i]
2186            && (mBatteryAudio.lastTime[i] != 0)) {
2187                int32_t tmpTime = mBatteryAudio.lastTime[i] + time;
2188                totalTime += tmpTime;
2189        }
2190
2191        reply->writeInt32(totalTime);
2192        // reset the total time
2193        mBatteryAudio.totalTime[i] = 0;
2194   }
2195
2196    // codec usage
2197    BatteryUsageInfo info;
2198    int size = mBatteryData.size();
2199
2200    reply->writeInt32(size);
2201    int i = 0;
2202
2203    while (i < size) {
2204        info = mBatteryData.valueAt(i);
2205
2206        reply->writeInt32(mBatteryData.keyAt(i)); //UID
2207        reply->writeInt32(info.audioTotalTime);
2208        reply->writeInt32(info.videoTotalTime);
2209
2210        info.audioTotalTime = 0;
2211        info.videoTotalTime = 0;
2212
2213        // remove the UID entry where no stream is being played
2214        if (info.refCount <= 0) {
2215            mBatteryData.removeItemsAt(i);
2216            size --;
2217            i --;
2218        }
2219        i++;
2220    }
2221    return NO_ERROR;
2222}
2223} // namespace android
2224