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