MediaPlayerService.cpp revision 0d255b2d9061ba31f13ada3fc0f7e51916407176 
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 <android_runtime/ActivityManager.h>
38
39#include <binder/IPCThreadState.h>
40#include <binder/IServiceManager.h>
41#include <binder/MemoryHeapBase.h>
42#include <binder/MemoryBase.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#include <cutils/properties.h>
48
49#include <media/MediaPlayerInterface.h>
50#include <media/mediarecorder.h>
51#include <media/MediaMetadataRetrieverInterface.h>
52#include <media/Metadata.h>
53#include <media/AudioTrack.h>
54#include <media/MemoryLeakTrackUtil.h>
55
56#include <system/audio.h>
57
58#include <private/android_filesystem_config.h>
59
60#include "MediaRecorderClient.h"
61#include "MediaPlayerService.h"
62#include "MetadataRetrieverClient.h"
63
64#include "MidiFile.h"
65#include "TestPlayerStub.h"
66#include "StagefrightPlayer.h"
67#include "nuplayer/NuPlayerDriver.h"
68
69#include <OMX.h>
70
71/* desktop Linux needs a little help with gettid() */
72#if defined(HAVE_GETTID) && !defined(HAVE_ANDROID_OS)
73#define __KERNEL__
74# include <linux/unistd.h>
75#ifdef _syscall0
76_syscall0(pid_t,gettid)
77#else
78pid_t gettid() { return syscall(__NR_gettid);}
79#endif
80#undef __KERNEL__
81#endif
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        LOGE("Failed to read filter's length");
126        *status = NOT_ENOUGH_DATA;
127        return false;
128    }
129
130    if( val > kMaxFilterSize || val < 0)
131    {
132        LOGE("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        LOGE("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        LOGE("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
191// TODO: Temp hack until we can register players
192typedef struct {
193    const char *extension;
194    const player_type playertype;
195} extmap;
196extmap FILE_EXTS [] =  {
197        {".mid", SONIVOX_PLAYER},
198        {".midi", SONIVOX_PLAYER},
199        {".smf", SONIVOX_PLAYER},
200        {".xmf", SONIVOX_PLAYER},
201        {".imy", SONIVOX_PLAYER},
202        {".rtttl", SONIVOX_PLAYER},
203        {".rtx", SONIVOX_PLAYER},
204        {".ota", SONIVOX_PLAYER},
205};
206
207// TODO: Find real cause of Audio/Video delay in PV framework and remove this workaround
208/* static */ int MediaPlayerService::AudioOutput::mMinBufferCount = 4;
209/* static */ bool MediaPlayerService::AudioOutput::mIsOnEmulator = false;
210
211void MediaPlayerService::instantiate() {
212    defaultServiceManager()->addService(
213            String16("media.player"), new MediaPlayerService());
214}
215
216MediaPlayerService::MediaPlayerService()
217{
218    LOGV("MediaPlayerService created");
219    mNextConnId = 1;
220
221    mBatteryAudio.refCount = 0;
222    for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
223        mBatteryAudio.deviceOn[i] = 0;
224        mBatteryAudio.lastTime[i] = 0;
225        mBatteryAudio.totalTime[i] = 0;
226    }
227    // speaker is on by default
228    mBatteryAudio.deviceOn[SPEAKER] = 1;
229}
230
231MediaPlayerService::~MediaPlayerService()
232{
233    LOGV("MediaPlayerService destroyed");
234}
235
236sp<IMediaRecorder> MediaPlayerService::createMediaRecorder(pid_t pid)
237{
238    sp<MediaRecorderClient> recorder = new MediaRecorderClient(this, pid);
239    wp<MediaRecorderClient> w = recorder;
240    Mutex::Autolock lock(mLock);
241    mMediaRecorderClients.add(w);
242    LOGV("Create new media recorder client from pid %d", pid);
243    return recorder;
244}
245
246void MediaPlayerService::removeMediaRecorderClient(wp<MediaRecorderClient> client)
247{
248    Mutex::Autolock lock(mLock);
249    mMediaRecorderClients.remove(client);
250    LOGV("Delete media recorder client");
251}
252
253sp<IMediaMetadataRetriever> MediaPlayerService::createMetadataRetriever(pid_t pid)
254{
255    sp<MetadataRetrieverClient> retriever = new MetadataRetrieverClient(pid);
256    LOGV("Create new media retriever from pid %d", pid);
257    return retriever;
258}
259
260sp<IMediaPlayer> MediaPlayerService::create(
261        pid_t pid, const sp<IMediaPlayerClient>& client, const char* url,
262        const KeyedVector<String8, String8> *headers, int audioSessionId)
263{
264    int32_t connId = android_atomic_inc(&mNextConnId);
265    sp<Client> c = new Client(this, pid, connId, client, audioSessionId);
266    LOGV("Create new client(%d) from pid %d, url=%s, connId=%d, audioSessionId=%d",
267            connId, pid, url, connId, audioSessionId);
268    if (NO_ERROR != c->setDataSource(url, headers))
269    {
270        c.clear();
271        return c;
272    }
273    wp<Client> w = c;
274    Mutex::Autolock lock(mLock);
275    mClients.add(w);
276    return c;
277}
278
279sp<IMediaPlayer> MediaPlayerService::create(pid_t pid, const sp<IMediaPlayerClient>& client,
280        int fd, int64_t offset, int64_t length, int audioSessionId)
281{
282    int32_t connId = android_atomic_inc(&mNextConnId);
283    sp<Client> c = new Client(this, pid, connId, client, audioSessionId);
284    LOGV("Create new client(%d) from pid %d, fd=%d, offset=%lld, length=%lld, audioSessionId=%d",
285            connId, pid, fd, offset, length, audioSessionId);
286    if (NO_ERROR != c->setDataSource(fd, offset, length)) {
287        c.clear();
288    } else {
289        wp<Client> w = c;
290        Mutex::Autolock lock(mLock);
291        mClients.add(w);
292    }
293    ::close(fd);
294    return c;
295}
296
297sp<IMediaPlayer> MediaPlayerService::create(
298        pid_t pid, const sp<IMediaPlayerClient> &client,
299        const sp<IStreamSource> &source, int audioSessionId) {
300    int32_t connId = android_atomic_inc(&mNextConnId);
301    sp<Client> c = new Client(this, pid, connId, client, audioSessionId);
302
303    LOGV("Create new client(%d) from pid %d, audioSessionId=%d",
304         connId, pid, audioSessionId);
305
306    if (OK != c->setDataSource(source)) {
307        c.clear();
308    } else {
309        wp<Client> w = c;
310        Mutex::Autolock lock(mLock);
311        mClients.add(w);
312    }
313
314    return c;
315}
316
317sp<IOMX> MediaPlayerService::getOMX() {
318    Mutex::Autolock autoLock(mLock);
319
320    if (mOMX.get() == NULL) {
321        mOMX = new OMX;
322    }
323
324    return mOMX;
325}
326
327status_t MediaPlayerService::AudioCache::dump(int fd, const Vector<String16>& args) const
328{
329    const size_t SIZE = 256;
330    char buffer[SIZE];
331    String8 result;
332
333    result.append(" AudioCache\n");
334    if (mHeap != 0) {
335        snprintf(buffer, 255, "  heap base(%p), size(%d), flags(%d), device(%s)\n",
336                mHeap->getBase(), mHeap->getSize(), mHeap->getFlags(), mHeap->getDevice());
337        result.append(buffer);
338    }
339    snprintf(buffer, 255, "  msec per frame(%f), channel count(%d), format(%d), frame count(%ld)\n",
340            mMsecsPerFrame, mChannelCount, mFormat, mFrameCount);
341    result.append(buffer);
342    snprintf(buffer, 255, "  sample rate(%d), size(%d), error(%d), command complete(%s)\n",
343            mSampleRate, mSize, mError, mCommandComplete?"true":"false");
344    result.append(buffer);
345    ::write(fd, result.string(), result.size());
346    return NO_ERROR;
347}
348
349status_t MediaPlayerService::AudioOutput::dump(int fd, const Vector<String16>& args) const
350{
351    const size_t SIZE = 256;
352    char buffer[SIZE];
353    String8 result;
354
355    result.append(" AudioOutput\n");
356    snprintf(buffer, 255, "  stream type(%d), left - right volume(%f, %f)\n",
357            mStreamType, mLeftVolume, mRightVolume);
358    result.append(buffer);
359    snprintf(buffer, 255, "  msec per frame(%f), latency (%d)\n",
360            mMsecsPerFrame, mLatency);
361    result.append(buffer);
362    snprintf(buffer, 255, "  aux effect id(%d), send level (%f)\n",
363            mAuxEffectId, mSendLevel);
364    result.append(buffer);
365
366    ::write(fd, result.string(), result.size());
367    if (mTrack != 0) {
368        mTrack->dump(fd, args);
369    }
370    return NO_ERROR;
371}
372
373status_t MediaPlayerService::Client::dump(int fd, const Vector<String16>& args) const
374{
375    const size_t SIZE = 256;
376    char buffer[SIZE];
377    String8 result;
378    result.append(" Client\n");
379    snprintf(buffer, 255, "  pid(%d), connId(%d), status(%d), looping(%s)\n",
380            mPid, mConnId, mStatus, mLoop?"true": "false");
381    result.append(buffer);
382    write(fd, result.string(), result.size());
383    if (mAudioOutput != 0) {
384        mAudioOutput->dump(fd, args);
385    }
386    write(fd, "\n", 1);
387    return NO_ERROR;
388}
389
390static int myTid() {
391#ifdef HAVE_GETTID
392    return gettid();
393#else
394    return getpid();
395#endif
396}
397
398status_t MediaPlayerService::dump(int fd, const Vector<String16>& args)
399{
400    const size_t SIZE = 256;
401    char buffer[SIZE];
402    String8 result;
403    if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
404        snprintf(buffer, SIZE, "Permission Denial: "
405                "can't dump MediaPlayerService from pid=%d, uid=%d\n",
406                IPCThreadState::self()->getCallingPid(),
407                IPCThreadState::self()->getCallingUid());
408        result.append(buffer);
409    } else {
410        Mutex::Autolock lock(mLock);
411        for (int i = 0, n = mClients.size(); i < n; ++i) {
412            sp<Client> c = mClients[i].promote();
413            if (c != 0) c->dump(fd, args);
414        }
415        if (mMediaRecorderClients.size() == 0) {
416                result.append(" No media recorder client\n\n");
417        } else {
418            for (int i = 0, n = mMediaRecorderClients.size(); i < n; ++i) {
419                sp<MediaRecorderClient> c = mMediaRecorderClients[i].promote();
420                snprintf(buffer, 255, " MediaRecorderClient pid(%d)\n", c->mPid);
421                result.append(buffer);
422                write(fd, result.string(), result.size());
423                result = "\n";
424                c->dump(fd, args);
425            }
426        }
427
428        result.append(" Files opened and/or mapped:\n");
429        snprintf(buffer, SIZE, "/proc/%d/maps", myTid());
430        FILE *f = fopen(buffer, "r");
431        if (f) {
432            while (!feof(f)) {
433                fgets(buffer, SIZE, f);
434                if (strstr(buffer, " /mnt/sdcard/") ||
435                    strstr(buffer, " /system/sounds/") ||
436                    strstr(buffer, " /data/") ||
437                    strstr(buffer, " /system/media/")) {
438                    result.append("  ");
439                    result.append(buffer);
440                }
441            }
442            fclose(f);
443        } else {
444            result.append("couldn't open ");
445            result.append(buffer);
446            result.append("\n");
447        }
448
449        snprintf(buffer, SIZE, "/proc/%d/fd", myTid());
450        DIR *d = opendir(buffer);
451        if (d) {
452            struct dirent *ent;
453            while((ent = readdir(d)) != NULL) {
454                if (strcmp(ent->d_name,".") && strcmp(ent->d_name,"..")) {
455                    snprintf(buffer, SIZE, "/proc/%d/fd/%s", myTid(), ent->d_name);
456                    struct stat s;
457                    if (lstat(buffer, &s) == 0) {
458                        if ((s.st_mode & S_IFMT) == S_IFLNK) {
459                            char linkto[256];
460                            int len = readlink(buffer, linkto, sizeof(linkto));
461                            if(len > 0) {
462                                if(len > 255) {
463                                    linkto[252] = '.';
464                                    linkto[253] = '.';
465                                    linkto[254] = '.';
466                                    linkto[255] = 0;
467                                } else {
468                                    linkto[len] = 0;
469                                }
470                                if (strstr(linkto, "/mnt/sdcard/") == linkto ||
471                                    strstr(linkto, "/system/sounds/") == linkto ||
472                                    strstr(linkto, "/data/") == linkto ||
473                                    strstr(linkto, "/system/media/") == linkto) {
474                                    result.append("  ");
475                                    result.append(buffer);
476                                    result.append(" -> ");
477                                    result.append(linkto);
478                                    result.append("\n");
479                                }
480                            }
481                        } else {
482                            result.append("  unexpected type for ");
483                            result.append(buffer);
484                            result.append("\n");
485                        }
486                    }
487                }
488            }
489            closedir(d);
490        } else {
491            result.append("couldn't open ");
492            result.append(buffer);
493            result.append("\n");
494        }
495
496        bool dumpMem = false;
497        for (size_t i = 0; i < args.size(); i++) {
498            if (args[i] == String16("-m")) {
499                dumpMem = true;
500            }
501        }
502        if (dumpMem) {
503            dumpMemoryAddresses(fd);
504        }
505    }
506    write(fd, result.string(), result.size());
507    return NO_ERROR;
508}
509
510void MediaPlayerService::removeClient(wp<Client> client)
511{
512    Mutex::Autolock lock(mLock);
513    mClients.remove(client);
514}
515
516MediaPlayerService::Client::Client(const sp<MediaPlayerService>& service, pid_t pid,
517        int32_t connId, const sp<IMediaPlayerClient>& client, int audioSessionId)
518{
519    LOGV("Client(%d) constructor", connId);
520    mPid = pid;
521    mConnId = connId;
522    mService = service;
523    mClient = client;
524    mLoop = false;
525    mStatus = NO_INIT;
526    mAudioSessionId = audioSessionId;
527
528#if CALLBACK_ANTAGONIZER
529    LOGD("create Antagonizer");
530    mAntagonizer = new Antagonizer(notify, this);
531#endif
532}
533
534MediaPlayerService::Client::~Client()
535{
536    LOGV("Client(%d) destructor pid = %d", mConnId, mPid);
537    mAudioOutput.clear();
538    wp<Client> client(this);
539    disconnect();
540    mService->removeClient(client);
541}
542
543void MediaPlayerService::Client::disconnect()
544{
545    LOGV("disconnect(%d) from pid %d", mConnId, mPid);
546    // grab local reference and clear main reference to prevent future
547    // access to object
548    sp<MediaPlayerBase> p;
549    {
550        Mutex::Autolock l(mLock);
551        p = mPlayer;
552    }
553    mClient.clear();
554
555    mPlayer.clear();
556
557    // clear the notification to prevent callbacks to dead client
558    // and reset the player. We assume the player will serialize
559    // access to itself if necessary.
560    if (p != 0) {
561        p->setNotifyCallback(0, 0);
562#if CALLBACK_ANTAGONIZER
563        LOGD("kill Antagonizer");
564        mAntagonizer->kill();
565#endif
566        p->reset();
567    }
568
569    IPCThreadState::self()->flushCommands();
570}
571
572static player_type getDefaultPlayerType() {
573    return STAGEFRIGHT_PLAYER;
574}
575
576player_type getPlayerType(int fd, int64_t offset, int64_t length)
577{
578    char buf[20];
579    lseek(fd, offset, SEEK_SET);
580    read(fd, buf, sizeof(buf));
581    lseek(fd, offset, SEEK_SET);
582
583    long ident = *((long*)buf);
584
585    // Ogg vorbis?
586    if (ident == 0x5367674f) // 'OggS'
587        return STAGEFRIGHT_PLAYER;
588
589    // Some kind of MIDI?
590    EAS_DATA_HANDLE easdata;
591    if (EAS_Init(&easdata) == EAS_SUCCESS) {
592        EAS_FILE locator;
593        locator.path = NULL;
594        locator.fd = fd;
595        locator.offset = offset;
596        locator.length = length;
597        EAS_HANDLE  eashandle;
598        if (EAS_OpenFile(easdata, &locator, &eashandle) == EAS_SUCCESS) {
599            EAS_CloseFile(easdata, eashandle);
600            EAS_Shutdown(easdata);
601            return SONIVOX_PLAYER;
602        }
603        EAS_Shutdown(easdata);
604    }
605
606    return getDefaultPlayerType();
607}
608
609player_type getPlayerType(const char* url)
610{
611    if (TestPlayerStub::canBeUsed(url)) {
612        return TEST_PLAYER;
613    }
614
615    if (!strncasecmp("http://", url, 7)
616            || !strncasecmp("https://", url, 8)) {
617        size_t len = strlen(url);
618        if (len >= 5 && !strcasecmp(".m3u8", &url[len - 5])) {
619            return NU_PLAYER;
620        }
621
622        if (strstr(url,"m3u8")) {
623            return NU_PLAYER;
624        }
625    }
626
627    // use MidiFile for MIDI extensions
628    int lenURL = strlen(url);
629    for (int i = 0; i < NELEM(FILE_EXTS); ++i) {
630        int len = strlen(FILE_EXTS[i].extension);
631        int start = lenURL - len;
632        if (start > 0) {
633            if (!strncasecmp(url + start, FILE_EXTS[i].extension, len)) {
634                return FILE_EXTS[i].playertype;
635            }
636        }
637    }
638
639    return getDefaultPlayerType();
640}
641
642static sp<MediaPlayerBase> createPlayer(player_type playerType, void* cookie,
643        notify_callback_f notifyFunc)
644{
645    sp<MediaPlayerBase> p;
646    switch (playerType) {
647        case SONIVOX_PLAYER:
648            LOGV(" create MidiFile");
649            p = new MidiFile();
650            break;
651        case STAGEFRIGHT_PLAYER:
652            LOGV(" create StagefrightPlayer");
653            p = new StagefrightPlayer;
654            break;
655        case NU_PLAYER:
656            LOGV(" create NuPlayer");
657            p = new NuPlayerDriver;
658            break;
659        case TEST_PLAYER:
660            LOGV("Create Test Player stub");
661            p = new TestPlayerStub();
662            break;
663        default:
664            LOGE("Unknown player type: %d", playerType);
665            return NULL;
666    }
667    if (p != NULL) {
668        if (p->initCheck() == NO_ERROR) {
669            p->setNotifyCallback(cookie, notifyFunc);
670        } else {
671            p.clear();
672        }
673    }
674    if (p == NULL) {
675        LOGE("Failed to create player object");
676    }
677    return p;
678}
679
680sp<MediaPlayerBase> MediaPlayerService::Client::createPlayer(player_type playerType)
681{
682    // determine if we have the right player type
683    sp<MediaPlayerBase> p = mPlayer;
684    if ((p != NULL) && (p->playerType() != playerType)) {
685        LOGV("delete player");
686        p.clear();
687    }
688    if (p == NULL) {
689        p = android::createPlayer(playerType, this, notify);
690    }
691    return p;
692}
693
694status_t MediaPlayerService::Client::setDataSource(
695        const char *url, const KeyedVector<String8, String8> *headers)
696{
697    LOGV("setDataSource(%s)", url);
698    if (url == NULL)
699        return UNKNOWN_ERROR;
700
701    if (strncmp(url, "content://", 10) == 0) {
702        // get a filedescriptor for the content Uri and
703        // pass it to the setDataSource(fd) method
704
705        String16 url16(url);
706        int fd = android::openContentProviderFile(url16);
707        if (fd < 0)
708        {
709            LOGE("Couldn't open fd for %s", url);
710            return UNKNOWN_ERROR;
711        }
712        setDataSource(fd, 0, 0x7fffffffffLL); // this sets mStatus
713        close(fd);
714        return mStatus;
715    } else {
716        player_type playerType = getPlayerType(url);
717        LOGV("player type = %d", playerType);
718
719        // create the right type of player
720        sp<MediaPlayerBase> p = createPlayer(playerType);
721        if (p == NULL) return NO_INIT;
722
723        if (!p->hardwareOutput()) {
724            mAudioOutput = new AudioOutput(mAudioSessionId);
725            static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
726        }
727
728        // now set data source
729        LOGV(" setDataSource");
730        mStatus = p->setDataSource(url, headers);
731        if (mStatus == NO_ERROR) {
732            mPlayer = p;
733        } else {
734            LOGE("  error: %d", mStatus);
735        }
736        return mStatus;
737    }
738}
739
740status_t MediaPlayerService::Client::setDataSource(int fd, int64_t offset, int64_t length)
741{
742    LOGV("setDataSource fd=%d, offset=%lld, length=%lld", fd, offset, length);
743    struct stat sb;
744    int ret = fstat(fd, &sb);
745    if (ret != 0) {
746        LOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
747        return UNKNOWN_ERROR;
748    }
749
750    LOGV("st_dev  = %llu", sb.st_dev);
751    LOGV("st_mode = %u", sb.st_mode);
752    LOGV("st_uid  = %lu", sb.st_uid);
753    LOGV("st_gid  = %lu", sb.st_gid);
754    LOGV("st_size = %llu", sb.st_size);
755
756    if (offset >= sb.st_size) {
757        LOGE("offset error");
758        ::close(fd);
759        return UNKNOWN_ERROR;
760    }
761    if (offset + length > sb.st_size) {
762        length = sb.st_size - offset;
763        LOGV("calculated length = %lld", length);
764    }
765
766    player_type playerType = getPlayerType(fd, offset, length);
767    LOGV("player type = %d", playerType);
768
769    // create the right type of player
770    sp<MediaPlayerBase> p = createPlayer(playerType);
771    if (p == NULL) return NO_INIT;
772
773    if (!p->hardwareOutput()) {
774        mAudioOutput = new AudioOutput(mAudioSessionId);
775        static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
776    }
777
778    // now set data source
779    mStatus = p->setDataSource(fd, offset, length);
780    if (mStatus == NO_ERROR) mPlayer = p;
781    return mStatus;
782}
783
784status_t MediaPlayerService::Client::setDataSource(
785        const sp<IStreamSource> &source) {
786    // create the right type of player
787    sp<MediaPlayerBase> p = createPlayer(NU_PLAYER);
788
789    if (p == NULL) {
790        return NO_INIT;
791    }
792
793    if (!p->hardwareOutput()) {
794        mAudioOutput = new AudioOutput(mAudioSessionId);
795        static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
796    }
797
798    // now set data source
799    mStatus = p->setDataSource(source);
800
801    if (mStatus == OK) {
802        mPlayer = p;
803    }
804
805    return mStatus;
806}
807
808status_t MediaPlayerService::Client::setVideoSurface(const sp<Surface>& surface)
809{
810    LOGV("[%d] setVideoSurface(%p)", mConnId, surface.get());
811    sp<MediaPlayerBase> p = getPlayer();
812    if (p == 0) return UNKNOWN_ERROR;
813    return p->setVideoSurface(surface);
814}
815
816status_t MediaPlayerService::Client::setVideoSurfaceTexture(
817        const sp<ISurfaceTexture>& surfaceTexture)
818{
819    LOGV("[%d] setVideoSurfaceTexture(%p)", mConnId, surfaceTexture.get());
820    sp<MediaPlayerBase> p = getPlayer();
821    if (p == 0) return UNKNOWN_ERROR;
822    return p->setVideoSurfaceTexture(surfaceTexture);
823}
824
825status_t MediaPlayerService::Client::invoke(const Parcel& request,
826                                            Parcel *reply)
827{
828    sp<MediaPlayerBase> p = getPlayer();
829    if (p == NULL) return UNKNOWN_ERROR;
830    return p->invoke(request, reply);
831}
832
833// This call doesn't need to access the native player.
834status_t MediaPlayerService::Client::setMetadataFilter(const Parcel& filter)
835{
836    status_t status;
837    media::Metadata::Filter allow, drop;
838
839    if (unmarshallFilter(filter, &allow, &status) &&
840        unmarshallFilter(filter, &drop, &status)) {
841        Mutex::Autolock lock(mLock);
842
843        mMetadataAllow = allow;
844        mMetadataDrop = drop;
845    }
846    return status;
847}
848
849status_t MediaPlayerService::Client::getMetadata(
850        bool update_only, bool apply_filter, Parcel *reply)
851{
852    sp<MediaPlayerBase> player = getPlayer();
853    if (player == 0) return UNKNOWN_ERROR;
854
855    status_t status;
856    // Placeholder for the return code, updated by the caller.
857    reply->writeInt32(-1);
858
859    media::Metadata::Filter ids;
860
861    // We don't block notifications while we fetch the data. We clear
862    // mMetadataUpdated first so we don't lose notifications happening
863    // during the rest of this call.
864    {
865        Mutex::Autolock lock(mLock);
866        if (update_only) {
867            ids = mMetadataUpdated;
868        }
869        mMetadataUpdated.clear();
870    }
871
872    media::Metadata metadata(reply);
873
874    metadata.appendHeader();
875    status = player->getMetadata(ids, reply);
876
877    if (status != OK) {
878        metadata.resetParcel();
879        LOGE("getMetadata failed %d", status);
880        return status;
881    }
882
883    // FIXME: Implement filtering on the result. Not critical since
884    // filtering takes place on the update notifications already. This
885    // would be when all the metadata are fetch and a filter is set.
886
887    // Everything is fine, update the metadata length.
888    metadata.updateLength();
889    return OK;
890}
891
892status_t MediaPlayerService::Client::prepareAsync()
893{
894    LOGV("[%d] prepareAsync", mConnId);
895    sp<MediaPlayerBase> p = getPlayer();
896    if (p == 0) return UNKNOWN_ERROR;
897    status_t ret = p->prepareAsync();
898#if CALLBACK_ANTAGONIZER
899    LOGD("start Antagonizer");
900    if (ret == NO_ERROR) mAntagonizer->start();
901#endif
902    return ret;
903}
904
905status_t MediaPlayerService::Client::start()
906{
907    LOGV("[%d] start", mConnId);
908    sp<MediaPlayerBase> p = getPlayer();
909    if (p == 0) return UNKNOWN_ERROR;
910    p->setLooping(mLoop);
911    return p->start();
912}
913
914status_t MediaPlayerService::Client::stop()
915{
916    LOGV("[%d] stop", mConnId);
917    sp<MediaPlayerBase> p = getPlayer();
918    if (p == 0) return UNKNOWN_ERROR;
919    return p->stop();
920}
921
922status_t MediaPlayerService::Client::pause()
923{
924    LOGV("[%d] pause", mConnId);
925    sp<MediaPlayerBase> p = getPlayer();
926    if (p == 0) return UNKNOWN_ERROR;
927    return p->pause();
928}
929
930status_t MediaPlayerService::Client::isPlaying(bool* state)
931{
932    *state = false;
933    sp<MediaPlayerBase> p = getPlayer();
934    if (p == 0) return UNKNOWN_ERROR;
935    *state = p->isPlaying();
936    LOGV("[%d] isPlaying: %d", mConnId, *state);
937    return NO_ERROR;
938}
939
940status_t MediaPlayerService::Client::getCurrentPosition(int *msec)
941{
942    LOGV("getCurrentPosition");
943    sp<MediaPlayerBase> p = getPlayer();
944    if (p == 0) return UNKNOWN_ERROR;
945    status_t ret = p->getCurrentPosition(msec);
946    if (ret == NO_ERROR) {
947        LOGV("[%d] getCurrentPosition = %d", mConnId, *msec);
948    } else {
949        LOGE("getCurrentPosition returned %d", ret);
950    }
951    return ret;
952}
953
954status_t MediaPlayerService::Client::getDuration(int *msec)
955{
956    LOGV("getDuration");
957    sp<MediaPlayerBase> p = getPlayer();
958    if (p == 0) return UNKNOWN_ERROR;
959    status_t ret = p->getDuration(msec);
960    if (ret == NO_ERROR) {
961        LOGV("[%d] getDuration = %d", mConnId, *msec);
962    } else {
963        LOGE("getDuration returned %d", ret);
964    }
965    return ret;
966}
967
968status_t MediaPlayerService::Client::seekTo(int msec)
969{
970    LOGV("[%d] seekTo(%d)", mConnId, msec);
971    sp<MediaPlayerBase> p = getPlayer();
972    if (p == 0) return UNKNOWN_ERROR;
973    return p->seekTo(msec);
974}
975
976status_t MediaPlayerService::Client::reset()
977{
978    LOGV("[%d] reset", mConnId);
979    sp<MediaPlayerBase> p = getPlayer();
980    if (p == 0) return UNKNOWN_ERROR;
981    return p->reset();
982}
983
984status_t MediaPlayerService::Client::setAudioStreamType(int type)
985{
986    LOGV("[%d] setAudioStreamType(%d)", mConnId, type);
987    // TODO: for hardware output, call player instead
988    Mutex::Autolock l(mLock);
989    if (mAudioOutput != 0) mAudioOutput->setAudioStreamType(type);
990    return NO_ERROR;
991}
992
993status_t MediaPlayerService::Client::setLooping(int loop)
994{
995    LOGV("[%d] setLooping(%d)", mConnId, loop);
996    mLoop = loop;
997    sp<MediaPlayerBase> p = getPlayer();
998    if (p != 0) return p->setLooping(loop);
999    return NO_ERROR;
1000}
1001
1002status_t MediaPlayerService::Client::setVolume(float leftVolume, float rightVolume)
1003{
1004    LOGV("[%d] setVolume(%f, %f)", mConnId, leftVolume, rightVolume);
1005    // TODO: for hardware output, call player instead
1006    Mutex::Autolock l(mLock);
1007    if (mAudioOutput != 0) mAudioOutput->setVolume(leftVolume, rightVolume);
1008    return NO_ERROR;
1009}
1010
1011status_t MediaPlayerService::Client::setAuxEffectSendLevel(float level)
1012{
1013    LOGV("[%d] setAuxEffectSendLevel(%f)", mConnId, level);
1014    Mutex::Autolock l(mLock);
1015    if (mAudioOutput != 0) return mAudioOutput->setAuxEffectSendLevel(level);
1016    return NO_ERROR;
1017}
1018
1019status_t MediaPlayerService::Client::attachAuxEffect(int effectId)
1020{
1021    LOGV("[%d] attachAuxEffect(%d)", mConnId, effectId);
1022    Mutex::Autolock l(mLock);
1023    if (mAudioOutput != 0) return mAudioOutput->attachAuxEffect(effectId);
1024    return NO_ERROR;
1025}
1026
1027status_t MediaPlayerService::Client::setParameter(int key, const Parcel &request) {
1028    LOGV("[%d] setParameter(%d)", mConnId, key);
1029    sp<MediaPlayerBase> p = getPlayer();
1030    if (p == 0) return UNKNOWN_ERROR;
1031    return p->setParameter(key, request);
1032}
1033
1034status_t MediaPlayerService::Client::getParameter(int key, Parcel *reply) {
1035    LOGV("[%d] getParameter(%d)", mConnId, key);
1036    sp<MediaPlayerBase> p = getPlayer();
1037    if (p == 0) return UNKNOWN_ERROR;
1038    return p->getParameter(key, reply);
1039}
1040
1041void MediaPlayerService::Client::notify(
1042        void* cookie, int msg, int ext1, int ext2, const Parcel *obj)
1043{
1044    Client* client = static_cast<Client*>(cookie);
1045
1046    if (MEDIA_INFO == msg &&
1047        MEDIA_INFO_METADATA_UPDATE == ext1) {
1048        const media::Metadata::Type metadata_type = ext2;
1049
1050        if(client->shouldDropMetadata(metadata_type)) {
1051            return;
1052        }
1053
1054        // Update the list of metadata that have changed. getMetadata
1055        // also access mMetadataUpdated and clears it.
1056        client->addNewMetadataUpdate(metadata_type);
1057    }
1058    LOGV("[%d] notify (%p, %d, %d, %d)", client->mConnId, cookie, msg, ext1, ext2);
1059    client->mClient->notify(msg, ext1, ext2, obj);
1060}
1061
1062
1063bool MediaPlayerService::Client::shouldDropMetadata(media::Metadata::Type code) const
1064{
1065    Mutex::Autolock lock(mLock);
1066
1067    if (findMetadata(mMetadataDrop, code)) {
1068        return true;
1069    }
1070
1071    if (mMetadataAllow.isEmpty() || findMetadata(mMetadataAllow, code)) {
1072        return false;
1073    } else {
1074        return true;
1075    }
1076}
1077
1078
1079void MediaPlayerService::Client::addNewMetadataUpdate(media::Metadata::Type metadata_type) {
1080    Mutex::Autolock lock(mLock);
1081    if (mMetadataUpdated.indexOf(metadata_type) < 0) {
1082        mMetadataUpdated.add(metadata_type);
1083    }
1084}
1085
1086#if CALLBACK_ANTAGONIZER
1087const int Antagonizer::interval = 10000; // 10 msecs
1088
1089Antagonizer::Antagonizer(notify_callback_f cb, void* client) :
1090    mExit(false), mActive(false), mClient(client), mCb(cb)
1091{
1092    createThread(callbackThread, this);
1093}
1094
1095void Antagonizer::kill()
1096{
1097    Mutex::Autolock _l(mLock);
1098    mActive = false;
1099    mExit = true;
1100    mCondition.wait(mLock);
1101}
1102
1103int Antagonizer::callbackThread(void* user)
1104{
1105    LOGD("Antagonizer started");
1106    Antagonizer* p = reinterpret_cast<Antagonizer*>(user);
1107    while (!p->mExit) {
1108        if (p->mActive) {
1109            LOGV("send event");
1110            p->mCb(p->mClient, 0, 0, 0);
1111        }
1112        usleep(interval);
1113    }
1114    Mutex::Autolock _l(p->mLock);
1115    p->mCondition.signal();
1116    LOGD("Antagonizer stopped");
1117    return 0;
1118}
1119#endif
1120
1121static size_t kDefaultHeapSize = 1024 * 1024; // 1MB
1122
1123sp<IMemory> MediaPlayerService::decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat)
1124{
1125    LOGV("decode(%s)", url);
1126    sp<MemoryBase> mem;
1127    sp<MediaPlayerBase> player;
1128
1129    // Protect our precious, precious DRMd ringtones by only allowing
1130    // decoding of http, but not filesystem paths or content Uris.
1131    // If the application wants to decode those, it should open a
1132    // filedescriptor for them and use that.
1133    if (url != NULL && strncmp(url, "http://", 7) != 0) {
1134        LOGD("Can't decode %s by path, use filedescriptor instead", url);
1135        return mem;
1136    }
1137
1138    player_type playerType = getPlayerType(url);
1139    LOGV("player type = %d", playerType);
1140
1141    // create the right type of player
1142    sp<AudioCache> cache = new AudioCache(url);
1143    player = android::createPlayer(playerType, cache.get(), cache->notify);
1144    if (player == NULL) goto Exit;
1145    if (player->hardwareOutput()) goto Exit;
1146
1147    static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache);
1148
1149    // set data source
1150    if (player->setDataSource(url) != NO_ERROR) goto Exit;
1151
1152    LOGV("prepare");
1153    player->prepareAsync();
1154
1155    LOGV("wait for prepare");
1156    if (cache->wait() != NO_ERROR) goto Exit;
1157
1158    LOGV("start");
1159    player->start();
1160
1161    LOGV("wait for playback complete");
1162    if (cache->wait() != NO_ERROR) goto Exit;
1163
1164    mem = new MemoryBase(cache->getHeap(), 0, cache->size());
1165    *pSampleRate = cache->sampleRate();
1166    *pNumChannels = cache->channelCount();
1167    *pFormat = (int)cache->format();
1168    LOGV("return memory @ %p, sampleRate=%u, channelCount = %d, format = %d", mem->pointer(), *pSampleRate, *pNumChannels, *pFormat);
1169
1170Exit:
1171    if (player != 0) player->reset();
1172    return mem;
1173}
1174
1175sp<IMemory> MediaPlayerService::decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat)
1176{
1177    LOGV("decode(%d, %lld, %lld)", fd, offset, length);
1178    sp<MemoryBase> mem;
1179    sp<MediaPlayerBase> player;
1180
1181    player_type playerType = getPlayerType(fd, offset, length);
1182    LOGV("player type = %d", playerType);
1183
1184    // create the right type of player
1185    sp<AudioCache> cache = new AudioCache("decode_fd");
1186    player = android::createPlayer(playerType, cache.get(), cache->notify);
1187    if (player == NULL) goto Exit;
1188    if (player->hardwareOutput()) goto Exit;
1189
1190    static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache);
1191
1192    // set data source
1193    if (player->setDataSource(fd, offset, length) != NO_ERROR) goto Exit;
1194
1195    LOGV("prepare");
1196    player->prepareAsync();
1197
1198    LOGV("wait for prepare");
1199    if (cache->wait() != NO_ERROR) goto Exit;
1200
1201    LOGV("start");
1202    player->start();
1203
1204    LOGV("wait for playback complete");
1205    if (cache->wait() != NO_ERROR) goto Exit;
1206
1207    mem = new MemoryBase(cache->getHeap(), 0, cache->size());
1208    *pSampleRate = cache->sampleRate();
1209    *pNumChannels = cache->channelCount();
1210    *pFormat = cache->format();
1211    LOGV("return memory @ %p, sampleRate=%u, channelCount = %d, format = %d", mem->pointer(), *pSampleRate, *pNumChannels, *pFormat);
1212
1213Exit:
1214    if (player != 0) player->reset();
1215    ::close(fd);
1216    return mem;
1217}
1218
1219
1220#undef LOG_TAG
1221#define LOG_TAG "AudioSink"
1222MediaPlayerService::AudioOutput::AudioOutput(int sessionId)
1223    : mCallback(NULL),
1224      mCallbackCookie(NULL),
1225      mSessionId(sessionId) {
1226    LOGV("AudioOutput(%d)", sessionId);
1227    mTrack = 0;
1228    mStreamType = AUDIO_STREAM_MUSIC;
1229    mLeftVolume = 1.0;
1230    mRightVolume = 1.0;
1231    mLatency = 0;
1232    mMsecsPerFrame = 0;
1233    mAuxEffectId = 0;
1234    mSendLevel = 0.0;
1235    setMinBufferCount();
1236}
1237
1238MediaPlayerService::AudioOutput::~AudioOutput()
1239{
1240    close();
1241}
1242
1243void MediaPlayerService::AudioOutput::setMinBufferCount()
1244{
1245    char value[PROPERTY_VALUE_MAX];
1246    if (property_get("ro.kernel.qemu", value, 0)) {
1247        mIsOnEmulator = true;
1248        mMinBufferCount = 12;  // to prevent systematic buffer underrun for emulator
1249    }
1250}
1251
1252bool MediaPlayerService::AudioOutput::isOnEmulator()
1253{
1254    setMinBufferCount();
1255    return mIsOnEmulator;
1256}
1257
1258int MediaPlayerService::AudioOutput::getMinBufferCount()
1259{
1260    setMinBufferCount();
1261    return mMinBufferCount;
1262}
1263
1264ssize_t MediaPlayerService::AudioOutput::bufferSize() const
1265{
1266    if (mTrack == 0) return NO_INIT;
1267    return mTrack->frameCount() * frameSize();
1268}
1269
1270ssize_t MediaPlayerService::AudioOutput::frameCount() const
1271{
1272    if (mTrack == 0) return NO_INIT;
1273    return mTrack->frameCount();
1274}
1275
1276ssize_t MediaPlayerService::AudioOutput::channelCount() const
1277{
1278    if (mTrack == 0) return NO_INIT;
1279    return mTrack->channelCount();
1280}
1281
1282ssize_t MediaPlayerService::AudioOutput::frameSize() const
1283{
1284    if (mTrack == 0) return NO_INIT;
1285    return mTrack->frameSize();
1286}
1287
1288uint32_t MediaPlayerService::AudioOutput::latency () const
1289{
1290    return mLatency;
1291}
1292
1293float MediaPlayerService::AudioOutput::msecsPerFrame() const
1294{
1295    return mMsecsPerFrame;
1296}
1297
1298status_t MediaPlayerService::AudioOutput::getPosition(uint32_t *position)
1299{
1300    if (mTrack == 0) return NO_INIT;
1301    return mTrack->getPosition(position);
1302}
1303
1304status_t MediaPlayerService::AudioOutput::open(
1305        uint32_t sampleRate, int channelCount, int format, int bufferCount,
1306        AudioCallback cb, void *cookie)
1307{
1308    mCallback = cb;
1309    mCallbackCookie = cookie;
1310
1311    // Check argument "bufferCount" against the mininum buffer count
1312    if (bufferCount < mMinBufferCount) {
1313        LOGD("bufferCount (%d) is too small and increased to %d", bufferCount, mMinBufferCount);
1314        bufferCount = mMinBufferCount;
1315
1316    }
1317    LOGV("open(%u, %d, %d, %d, %d)", sampleRate, channelCount, format, bufferCount,mSessionId);
1318    if (mTrack) close();
1319    int afSampleRate;
1320    int afFrameCount;
1321    int frameCount;
1322
1323    if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) != NO_ERROR) {
1324        return NO_INIT;
1325    }
1326    if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) != NO_ERROR) {
1327        return NO_INIT;
1328    }
1329
1330    frameCount = (sampleRate*afFrameCount*bufferCount)/afSampleRate;
1331
1332    AudioTrack *t;
1333    if (mCallback != NULL) {
1334        t = new AudioTrack(
1335                mStreamType,
1336                sampleRate,
1337                format,
1338                (channelCount == 2) ? AUDIO_CHANNEL_OUT_STEREO : AUDIO_CHANNEL_OUT_MONO,
1339                frameCount,
1340                0 /* flags */,
1341                CallbackWrapper,
1342                this,
1343                0,
1344                mSessionId);
1345    } else {
1346        t = new AudioTrack(
1347                mStreamType,
1348                sampleRate,
1349                format,
1350                (channelCount == 2) ? AUDIO_CHANNEL_OUT_STEREO : AUDIO_CHANNEL_OUT_MONO,
1351                frameCount,
1352                0,
1353                NULL,
1354                NULL,
1355                0,
1356                mSessionId);
1357    }
1358
1359    if ((t == 0) || (t->initCheck() != NO_ERROR)) {
1360        LOGE("Unable to create audio track");
1361        delete t;
1362        return NO_INIT;
1363    }
1364
1365    LOGV("setVolume");
1366    t->setVolume(mLeftVolume, mRightVolume);
1367
1368    mMsecsPerFrame = 1.e3 / (float) sampleRate;
1369    mLatency = t->latency();
1370    mTrack = t;
1371
1372    t->setAuxEffectSendLevel(mSendLevel);
1373    return t->attachAuxEffect(mAuxEffectId);;
1374}
1375
1376void MediaPlayerService::AudioOutput::start()
1377{
1378    LOGV("start");
1379    if (mTrack) {
1380        mTrack->setVolume(mLeftVolume, mRightVolume);
1381        mTrack->setAuxEffectSendLevel(mSendLevel);
1382        mTrack->start();
1383    }
1384}
1385
1386
1387
1388ssize_t MediaPlayerService::AudioOutput::write(const void* buffer, size_t size)
1389{
1390    LOG_FATAL_IF(mCallback != NULL, "Don't call write if supplying a callback.");
1391
1392    //LOGV("write(%p, %u)", buffer, size);
1393    if (mTrack) {
1394        ssize_t ret = mTrack->write(buffer, size);
1395        return ret;
1396    }
1397    return NO_INIT;
1398}
1399
1400void MediaPlayerService::AudioOutput::stop()
1401{
1402    LOGV("stop");
1403    if (mTrack) mTrack->stop();
1404}
1405
1406void MediaPlayerService::AudioOutput::flush()
1407{
1408    LOGV("flush");
1409    if (mTrack) mTrack->flush();
1410}
1411
1412void MediaPlayerService::AudioOutput::pause()
1413{
1414    LOGV("pause");
1415    if (mTrack) mTrack->pause();
1416}
1417
1418void MediaPlayerService::AudioOutput::close()
1419{
1420    LOGV("close");
1421    delete mTrack;
1422    mTrack = 0;
1423}
1424
1425void MediaPlayerService::AudioOutput::setVolume(float left, float right)
1426{
1427    LOGV("setVolume(%f, %f)", left, right);
1428    mLeftVolume = left;
1429    mRightVolume = right;
1430    if (mTrack) {
1431        mTrack->setVolume(left, right);
1432    }
1433}
1434
1435status_t MediaPlayerService::AudioOutput::setAuxEffectSendLevel(float level)
1436{
1437    LOGV("setAuxEffectSendLevel(%f)", level);
1438    mSendLevel = level;
1439    if (mTrack) {
1440        return mTrack->setAuxEffectSendLevel(level);
1441    }
1442    return NO_ERROR;
1443}
1444
1445status_t MediaPlayerService::AudioOutput::attachAuxEffect(int effectId)
1446{
1447    LOGV("attachAuxEffect(%d)", effectId);
1448    mAuxEffectId = effectId;
1449    if (mTrack) {
1450        return mTrack->attachAuxEffect(effectId);
1451    }
1452    return NO_ERROR;
1453}
1454
1455// static
1456void MediaPlayerService::AudioOutput::CallbackWrapper(
1457        int event, void *cookie, void *info) {
1458    //LOGV("callbackwrapper");
1459    if (event != AudioTrack::EVENT_MORE_DATA) {
1460        return;
1461    }
1462
1463    AudioOutput *me = (AudioOutput *)cookie;
1464    AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
1465
1466    size_t actualSize = (*me->mCallback)(
1467            me, buffer->raw, buffer->size, me->mCallbackCookie);
1468
1469    if (actualSize == 0 && buffer->size > 0) {
1470        // We've reached EOS but the audio track is not stopped yet,
1471        // keep playing silence.
1472
1473        memset(buffer->raw, 0, buffer->size);
1474        actualSize = buffer->size;
1475    }
1476
1477    buffer->size = actualSize;
1478}
1479
1480int MediaPlayerService::AudioOutput::getSessionId()
1481{
1482    return mSessionId;
1483}
1484
1485#undef LOG_TAG
1486#define LOG_TAG "AudioCache"
1487MediaPlayerService::AudioCache::AudioCache(const char* name) :
1488    mChannelCount(0), mFrameCount(1024), mSampleRate(0), mSize(0),
1489    mError(NO_ERROR), mCommandComplete(false)
1490{
1491    // create ashmem heap
1492    mHeap = new MemoryHeapBase(kDefaultHeapSize, 0, name);
1493}
1494
1495uint32_t MediaPlayerService::AudioCache::latency () const
1496{
1497    return 0;
1498}
1499
1500float MediaPlayerService::AudioCache::msecsPerFrame() const
1501{
1502    return mMsecsPerFrame;
1503}
1504
1505status_t MediaPlayerService::AudioCache::getPosition(uint32_t *position)
1506{
1507    if (position == 0) return BAD_VALUE;
1508    *position = mSize;
1509    return NO_ERROR;
1510}
1511
1512////////////////////////////////////////////////////////////////////////////////
1513
1514struct CallbackThread : public Thread {
1515    CallbackThread(const wp<MediaPlayerBase::AudioSink> &sink,
1516                   MediaPlayerBase::AudioSink::AudioCallback cb,
1517                   void *cookie);
1518
1519protected:
1520    virtual ~CallbackThread();
1521
1522    virtual bool threadLoop();
1523
1524private:
1525    wp<MediaPlayerBase::AudioSink> mSink;
1526    MediaPlayerBase::AudioSink::AudioCallback mCallback;
1527    void *mCookie;
1528    void *mBuffer;
1529    size_t mBufferSize;
1530
1531    CallbackThread(const CallbackThread &);
1532    CallbackThread &operator=(const CallbackThread &);
1533};
1534
1535CallbackThread::CallbackThread(
1536        const wp<MediaPlayerBase::AudioSink> &sink,
1537        MediaPlayerBase::AudioSink::AudioCallback cb,
1538        void *cookie)
1539    : mSink(sink),
1540      mCallback(cb),
1541      mCookie(cookie),
1542      mBuffer(NULL),
1543      mBufferSize(0) {
1544}
1545
1546CallbackThread::~CallbackThread() {
1547    if (mBuffer) {
1548        free(mBuffer);
1549        mBuffer = NULL;
1550    }
1551}
1552
1553bool CallbackThread::threadLoop() {
1554    sp<MediaPlayerBase::AudioSink> sink = mSink.promote();
1555    if (sink == NULL) {
1556        return false;
1557    }
1558
1559    if (mBuffer == NULL) {
1560        mBufferSize = sink->bufferSize();
1561        mBuffer = malloc(mBufferSize);
1562    }
1563
1564    size_t actualSize =
1565        (*mCallback)(sink.get(), mBuffer, mBufferSize, mCookie);
1566
1567    if (actualSize > 0) {
1568        sink->write(mBuffer, actualSize);
1569    }
1570
1571    return true;
1572}
1573
1574////////////////////////////////////////////////////////////////////////////////
1575
1576status_t MediaPlayerService::AudioCache::open(
1577        uint32_t sampleRate, int channelCount, int format, int bufferCount,
1578        AudioCallback cb, void *cookie)
1579{
1580    LOGV("open(%u, %d, %d, %d)", sampleRate, channelCount, format, bufferCount);
1581    if (mHeap->getHeapID() < 0) {
1582        return NO_INIT;
1583    }
1584
1585    mSampleRate = sampleRate;
1586    mChannelCount = (uint16_t)channelCount;
1587    mFormat = (uint16_t)format;
1588    mMsecsPerFrame = 1.e3 / (float) sampleRate;
1589
1590    if (cb != NULL) {
1591        mCallbackThread = new CallbackThread(this, cb, cookie);
1592    }
1593    return NO_ERROR;
1594}
1595
1596void MediaPlayerService::AudioCache::start() {
1597    if (mCallbackThread != NULL) {
1598        mCallbackThread->run("AudioCache callback");
1599    }
1600}
1601
1602void MediaPlayerService::AudioCache::stop() {
1603    if (mCallbackThread != NULL) {
1604        mCallbackThread->requestExitAndWait();
1605    }
1606}
1607
1608ssize_t MediaPlayerService::AudioCache::write(const void* buffer, size_t size)
1609{
1610    LOGV("write(%p, %u)", buffer, size);
1611    if ((buffer == 0) || (size == 0)) return size;
1612
1613    uint8_t* p = static_cast<uint8_t*>(mHeap->getBase());
1614    if (p == NULL) return NO_INIT;
1615    p += mSize;
1616    LOGV("memcpy(%p, %p, %u)", p, buffer, size);
1617    if (mSize + size > mHeap->getSize()) {
1618        LOGE("Heap size overflow! req size: %d, max size: %d", (mSize + size), mHeap->getSize());
1619        size = mHeap->getSize() - mSize;
1620    }
1621    memcpy(p, buffer, size);
1622    mSize += size;
1623    return size;
1624}
1625
1626// call with lock held
1627status_t MediaPlayerService::AudioCache::wait()
1628{
1629    Mutex::Autolock lock(mLock);
1630    while (!mCommandComplete) {
1631        mSignal.wait(mLock);
1632    }
1633    mCommandComplete = false;
1634
1635    if (mError == NO_ERROR) {
1636        LOGV("wait - success");
1637    } else {
1638        LOGV("wait - error");
1639    }
1640    return mError;
1641}
1642
1643void MediaPlayerService::AudioCache::notify(
1644        void* cookie, int msg, int ext1, int ext2, const Parcel *obj)
1645{
1646    LOGV("notify(%p, %d, %d, %d)", cookie, msg, ext1, ext2);
1647    AudioCache* p = static_cast<AudioCache*>(cookie);
1648
1649    // ignore buffering messages
1650    switch (msg)
1651    {
1652    case MEDIA_ERROR:
1653        LOGE("Error %d, %d occurred", ext1, ext2);
1654        p->mError = ext1;
1655        break;
1656    case MEDIA_PREPARED:
1657        LOGV("prepared");
1658        break;
1659    case MEDIA_PLAYBACK_COMPLETE:
1660        LOGV("playback complete");
1661        break;
1662    default:
1663        LOGV("ignored");
1664        return;
1665    }
1666
1667    // wake up thread
1668    Mutex::Autolock lock(p->mLock);
1669    p->mCommandComplete = true;
1670    p->mSignal.signal();
1671}
1672
1673int MediaPlayerService::AudioCache::getSessionId()
1674{
1675    return 0;
1676}
1677
1678void MediaPlayerService::addBatteryData(uint32_t params)
1679{
1680    Mutex::Autolock lock(mLock);
1681
1682    int32_t time = systemTime() / 1000000L;
1683
1684    // change audio output devices. This notification comes from AudioFlinger
1685    if ((params & kBatteryDataSpeakerOn)
1686            || (params & kBatteryDataOtherAudioDeviceOn)) {
1687
1688        int deviceOn[NUM_AUDIO_DEVICES];
1689        for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1690            deviceOn[i] = 0;
1691        }
1692
1693        if ((params & kBatteryDataSpeakerOn)
1694                && (params & kBatteryDataOtherAudioDeviceOn)) {
1695            deviceOn[SPEAKER_AND_OTHER] = 1;
1696        } else if (params & kBatteryDataSpeakerOn) {
1697            deviceOn[SPEAKER] = 1;
1698        } else {
1699            deviceOn[OTHER_AUDIO_DEVICE] = 1;
1700        }
1701
1702        for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1703            if (mBatteryAudio.deviceOn[i] != deviceOn[i]){
1704
1705                if (mBatteryAudio.refCount > 0) { // if playing audio
1706                    if (!deviceOn[i]) {
1707                        mBatteryAudio.lastTime[i] += time;
1708                        mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
1709                        mBatteryAudio.lastTime[i] = 0;
1710                    } else {
1711                        mBatteryAudio.lastTime[i] = 0 - time;
1712                    }
1713                }
1714
1715                mBatteryAudio.deviceOn[i] = deviceOn[i];
1716            }
1717        }
1718        return;
1719    }
1720
1721    // an sudio stream is started
1722    if (params & kBatteryDataAudioFlingerStart) {
1723        // record the start time only if currently no other audio
1724        // is being played
1725        if (mBatteryAudio.refCount == 0) {
1726            for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1727                if (mBatteryAudio.deviceOn[i]) {
1728                    mBatteryAudio.lastTime[i] -= time;
1729                }
1730            }
1731        }
1732
1733        mBatteryAudio.refCount ++;
1734        return;
1735
1736    } else if (params & kBatteryDataAudioFlingerStop) {
1737        if (mBatteryAudio.refCount <= 0) {
1738            LOGW("Battery track warning: refCount is <= 0");
1739            return;
1740        }
1741
1742        // record the stop time only if currently this is the only
1743        // audio being played
1744        if (mBatteryAudio.refCount == 1) {
1745            for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1746                if (mBatteryAudio.deviceOn[i]) {
1747                    mBatteryAudio.lastTime[i] += time;
1748                    mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
1749                    mBatteryAudio.lastTime[i] = 0;
1750                }
1751            }
1752        }
1753
1754        mBatteryAudio.refCount --;
1755        return;
1756    }
1757
1758    int uid = IPCThreadState::self()->getCallingUid();
1759    if (uid == AID_MEDIA) {
1760        return;
1761    }
1762    int index = mBatteryData.indexOfKey(uid);
1763
1764    if (index < 0) { // create a new entry for this UID
1765        BatteryUsageInfo info;
1766        info.audioTotalTime = 0;
1767        info.videoTotalTime = 0;
1768        info.audioLastTime = 0;
1769        info.videoLastTime = 0;
1770        info.refCount = 0;
1771
1772        if (mBatteryData.add(uid, info) == NO_MEMORY) {
1773            LOGE("Battery track error: no memory for new app");
1774            return;
1775        }
1776    }
1777
1778    BatteryUsageInfo &info = mBatteryData.editValueFor(uid);
1779
1780    if (params & kBatteryDataCodecStarted) {
1781        if (params & kBatteryDataTrackAudio) {
1782            info.audioLastTime -= time;
1783            info.refCount ++;
1784        }
1785        if (params & kBatteryDataTrackVideo) {
1786            info.videoLastTime -= time;
1787            info.refCount ++;
1788        }
1789    } else {
1790        if (info.refCount == 0) {
1791            LOGW("Battery track warning: refCount is already 0");
1792            return;
1793        } else if (info.refCount < 0) {
1794            LOGE("Battery track error: refCount < 0");
1795            mBatteryData.removeItem(uid);
1796            return;
1797        }
1798
1799        if (params & kBatteryDataTrackAudio) {
1800            info.audioLastTime += time;
1801            info.refCount --;
1802        }
1803        if (params & kBatteryDataTrackVideo) {
1804            info.videoLastTime += time;
1805            info.refCount --;
1806        }
1807
1808        // no stream is being played by this UID
1809        if (info.refCount == 0) {
1810            info.audioTotalTime += info.audioLastTime;
1811            info.audioLastTime = 0;
1812            info.videoTotalTime += info.videoLastTime;
1813            info.videoLastTime = 0;
1814        }
1815    }
1816}
1817
1818status_t MediaPlayerService::pullBatteryData(Parcel* reply) {
1819    Mutex::Autolock lock(mLock);
1820
1821    // audio output devices usage
1822    int32_t time = systemTime() / 1000000L; //in ms
1823    int32_t totalTime;
1824
1825    for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1826        totalTime = mBatteryAudio.totalTime[i];
1827
1828        if (mBatteryAudio.deviceOn[i]
1829            && (mBatteryAudio.lastTime[i] != 0)) {
1830                int32_t tmpTime = mBatteryAudio.lastTime[i] + time;
1831                totalTime += tmpTime;
1832        }
1833
1834        reply->writeInt32(totalTime);
1835        // reset the total time
1836        mBatteryAudio.totalTime[i] = 0;
1837   }
1838
1839    // codec usage
1840    BatteryUsageInfo info;
1841    int size = mBatteryData.size();
1842
1843    reply->writeInt32(size);
1844    int i = 0;
1845
1846    while (i < size) {
1847        info = mBatteryData.valueAt(i);
1848
1849        reply->writeInt32(mBatteryData.keyAt(i)); //UID
1850        reply->writeInt32(info.audioTotalTime);
1851        reply->writeInt32(info.videoTotalTime);
1852
1853        info.audioTotalTime = 0;
1854        info.videoTotalTime = 0;
1855
1856        // remove the UID entry where no stream is being played
1857        if (info.refCount <= 0) {
1858            mBatteryData.removeItemsAt(i);
1859            size --;
1860            i --;
1861        }
1862        i++;
1863    }
1864    return NO_ERROR;
1865}
1866} // namespace android
1867