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