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