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