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