MediaPlayerService.cpp revision cb0b755efc2cd24703f400729994900bf2117f66 
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
1046    {
1047        Mutex::Autolock l(client->mLock);
1048        if (msg == MEDIA_PLAYBACK_COMPLETE && client->mNextClient != NULL) {
1049            if (client->mAudioOutput != NULL)
1050                client->mAudioOutput->switchToNextOutput();
1051            client->mNextClient->start();
1052            client->mNextClient->mClient->notify(MEDIA_INFO, MEDIA_INFO_STARTED_AS_NEXT, 0, obj);
1053        }
1054    }
1055
1056    if (MEDIA_INFO == msg &&
1057        MEDIA_INFO_METADATA_UPDATE == ext1) {
1058        const media::Metadata::Type metadata_type = ext2;
1059
1060        if(client->shouldDropMetadata(metadata_type)) {
1061            return;
1062        }
1063
1064        // Update the list of metadata that have changed. getMetadata
1065        // also access mMetadataUpdated and clears it.
1066        client->addNewMetadataUpdate(metadata_type);
1067    }
1068    ALOGV("[%d] notify (%p, %d, %d, %d)", client->mConnId, cookie, msg, ext1, ext2);
1069    client->mClient->notify(msg, ext1, ext2, obj);
1070}
1071
1072
1073bool MediaPlayerService::Client::shouldDropMetadata(media::Metadata::Type code) const
1074{
1075    Mutex::Autolock lock(mLock);
1076
1077    if (findMetadata(mMetadataDrop, code)) {
1078        return true;
1079    }
1080
1081    if (mMetadataAllow.isEmpty() || findMetadata(mMetadataAllow, code)) {
1082        return false;
1083    } else {
1084        return true;
1085    }
1086}
1087
1088
1089void MediaPlayerService::Client::addNewMetadataUpdate(media::Metadata::Type metadata_type) {
1090    Mutex::Autolock lock(mLock);
1091    if (mMetadataUpdated.indexOf(metadata_type) < 0) {
1092        mMetadataUpdated.add(metadata_type);
1093    }
1094}
1095
1096#if CALLBACK_ANTAGONIZER
1097const int Antagonizer::interval = 10000; // 10 msecs
1098
1099Antagonizer::Antagonizer(notify_callback_f cb, void* client) :
1100    mExit(false), mActive(false), mClient(client), mCb(cb)
1101{
1102    createThread(callbackThread, this);
1103}
1104
1105void Antagonizer::kill()
1106{
1107    Mutex::Autolock _l(mLock);
1108    mActive = false;
1109    mExit = true;
1110    mCondition.wait(mLock);
1111}
1112
1113int Antagonizer::callbackThread(void* user)
1114{
1115    ALOGD("Antagonizer started");
1116    Antagonizer* p = reinterpret_cast<Antagonizer*>(user);
1117    while (!p->mExit) {
1118        if (p->mActive) {
1119            ALOGV("send event");
1120            p->mCb(p->mClient, 0, 0, 0);
1121        }
1122        usleep(interval);
1123    }
1124    Mutex::Autolock _l(p->mLock);
1125    p->mCondition.signal();
1126    ALOGD("Antagonizer stopped");
1127    return 0;
1128}
1129#endif
1130
1131static size_t kDefaultHeapSize = 1024 * 1024; // 1MB
1132
1133sp<IMemory> MediaPlayerService::decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, audio_format_t* pFormat)
1134{
1135    ALOGV("decode(%s)", url);
1136    sp<MemoryBase> mem;
1137    sp<MediaPlayerBase> player;
1138
1139    // Protect our precious, precious DRMd ringtones by only allowing
1140    // decoding of http, but not filesystem paths or content Uris.
1141    // If the application wants to decode those, it should open a
1142    // filedescriptor for them and use that.
1143    if (url != NULL && strncmp(url, "http://", 7) != 0) {
1144        ALOGD("Can't decode %s by path, use filedescriptor instead", url);
1145        return mem;
1146    }
1147
1148    player_type playerType =
1149        MediaPlayerFactory::getPlayerType(NULL /* client */, url);
1150    ALOGV("player type = %d", playerType);
1151
1152    // create the right type of player
1153    sp<AudioCache> cache = new AudioCache(url);
1154    player = MediaPlayerFactory::createPlayer(playerType, cache.get(), cache->notify);
1155    if (player == NULL) goto Exit;
1156    if (player->hardwareOutput()) goto Exit;
1157
1158    static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache);
1159
1160    // set data source
1161    if (player->setDataSource(url) != NO_ERROR) goto Exit;
1162
1163    ALOGV("prepare");
1164    player->prepareAsync();
1165
1166    ALOGV("wait for prepare");
1167    if (cache->wait() != NO_ERROR) goto Exit;
1168
1169    ALOGV("start");
1170    player->start();
1171
1172    ALOGV("wait for playback complete");
1173    cache->wait();
1174    // in case of error, return what was successfully decoded.
1175    if (cache->size() == 0) {
1176        goto Exit;
1177    }
1178
1179    mem = new MemoryBase(cache->getHeap(), 0, cache->size());
1180    *pSampleRate = cache->sampleRate();
1181    *pNumChannels = cache->channelCount();
1182    *pFormat = cache->format();
1183    ALOGV("return memory @ %p, sampleRate=%u, channelCount = %d, format = %d", mem->pointer(), *pSampleRate, *pNumChannels, *pFormat);
1184
1185Exit:
1186    if (player != 0) player->reset();
1187    return mem;
1188}
1189
1190sp<IMemory> MediaPlayerService::decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, audio_format_t* pFormat)
1191{
1192    ALOGV("decode(%d, %lld, %lld)", fd, offset, length);
1193    sp<MemoryBase> mem;
1194    sp<MediaPlayerBase> player;
1195
1196    player_type playerType = MediaPlayerFactory::getPlayerType(NULL /* client */,
1197                                                               fd,
1198                                                               offset,
1199                                                               length);
1200    ALOGV("player type = %d", playerType);
1201
1202    // create the right type of player
1203    sp<AudioCache> cache = new AudioCache("decode_fd");
1204    player = MediaPlayerFactory::createPlayer(playerType, cache.get(), cache->notify);
1205    if (player == NULL) goto Exit;
1206    if (player->hardwareOutput()) goto Exit;
1207
1208    static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache);
1209
1210    // set data source
1211    if (player->setDataSource(fd, offset, length) != NO_ERROR) goto Exit;
1212
1213    ALOGV("prepare");
1214    player->prepareAsync();
1215
1216    ALOGV("wait for prepare");
1217    if (cache->wait() != NO_ERROR) goto Exit;
1218
1219    ALOGV("start");
1220    player->start();
1221
1222    ALOGV("wait for playback complete");
1223    cache->wait();
1224    // in case of error, return what was successfully decoded.
1225    if (cache->size() == 0) {
1226        goto Exit;
1227    }
1228
1229    mem = new MemoryBase(cache->getHeap(), 0, cache->size());
1230    *pSampleRate = cache->sampleRate();
1231    *pNumChannels = cache->channelCount();
1232    *pFormat = cache->format();
1233    ALOGV("return memory @ %p, sampleRate=%u, channelCount = %d, format = %d", mem->pointer(), *pSampleRate, *pNumChannels, *pFormat);
1234
1235Exit:
1236    if (player != 0) player->reset();
1237    ::close(fd);
1238    return mem;
1239}
1240
1241
1242#undef LOG_TAG
1243#define LOG_TAG "AudioSink"
1244MediaPlayerService::AudioOutput::AudioOutput(int sessionId)
1245    : mCallback(NULL),
1246      mCallbackCookie(NULL),
1247      mCallbackData(NULL),
1248      mBytesWritten(0),
1249      mSessionId(sessionId),
1250      mFlags(AUDIO_OUTPUT_FLAG_NONE) {
1251    ALOGV("AudioOutput(%d)", sessionId);
1252    mTrack = 0;
1253    mRecycledTrack = 0;
1254    mStreamType = AUDIO_STREAM_MUSIC;
1255    mLeftVolume = 1.0;
1256    mRightVolume = 1.0;
1257    mPlaybackRatePermille = 1000;
1258    mSampleRateHz = 0;
1259    mMsecsPerFrame = 0;
1260    mAuxEffectId = 0;
1261    mSendLevel = 0.0;
1262    setMinBufferCount();
1263}
1264
1265MediaPlayerService::AudioOutput::~AudioOutput()
1266{
1267    close();
1268    delete mRecycledTrack;
1269    delete mCallbackData;
1270}
1271
1272void MediaPlayerService::AudioOutput::setMinBufferCount()
1273{
1274    char value[PROPERTY_VALUE_MAX];
1275    if (property_get("ro.kernel.qemu", value, 0)) {
1276        mIsOnEmulator = true;
1277        mMinBufferCount = 12;  // to prevent systematic buffer underrun for emulator
1278    }
1279}
1280
1281bool MediaPlayerService::AudioOutput::isOnEmulator()
1282{
1283    setMinBufferCount();
1284    return mIsOnEmulator;
1285}
1286
1287int MediaPlayerService::AudioOutput::getMinBufferCount()
1288{
1289    setMinBufferCount();
1290    return mMinBufferCount;
1291}
1292
1293ssize_t MediaPlayerService::AudioOutput::bufferSize() const
1294{
1295    if (mTrack == 0) return NO_INIT;
1296    return mTrack->frameCount() * frameSize();
1297}
1298
1299ssize_t MediaPlayerService::AudioOutput::frameCount() const
1300{
1301    if (mTrack == 0) return NO_INIT;
1302    return mTrack->frameCount();
1303}
1304
1305ssize_t MediaPlayerService::AudioOutput::channelCount() const
1306{
1307    if (mTrack == 0) return NO_INIT;
1308    return mTrack->channelCount();
1309}
1310
1311ssize_t MediaPlayerService::AudioOutput::frameSize() const
1312{
1313    if (mTrack == 0) return NO_INIT;
1314    return mTrack->frameSize();
1315}
1316
1317uint32_t MediaPlayerService::AudioOutput::latency () const
1318{
1319    if (mTrack == 0) return 0;
1320    return mTrack->latency();
1321}
1322
1323float MediaPlayerService::AudioOutput::msecsPerFrame() const
1324{
1325    return mMsecsPerFrame;
1326}
1327
1328status_t MediaPlayerService::AudioOutput::getPosition(uint32_t *position) const
1329{
1330    if (mTrack == 0) return NO_INIT;
1331    return mTrack->getPosition(position);
1332}
1333
1334status_t MediaPlayerService::AudioOutput::getFramesWritten(uint32_t *frameswritten) const
1335{
1336    if (mTrack == 0) return NO_INIT;
1337    *frameswritten = mBytesWritten / frameSize();
1338    return OK;
1339}
1340
1341status_t MediaPlayerService::AudioOutput::open(
1342        uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
1343        audio_format_t format, int bufferCount,
1344        AudioCallback cb, void *cookie,
1345        audio_output_flags_t flags)
1346{
1347    mCallback = cb;
1348    mCallbackCookie = cookie;
1349
1350    // Check argument "bufferCount" against the mininum buffer count
1351    if (bufferCount < mMinBufferCount) {
1352        ALOGD("bufferCount (%d) is too small and increased to %d", bufferCount, mMinBufferCount);
1353        bufferCount = mMinBufferCount;
1354
1355    }
1356    ALOGV("open(%u, %d, 0x%x, %d, %d, %d)", sampleRate, channelCount, channelMask,
1357            format, bufferCount, mSessionId);
1358    int afSampleRate;
1359    int afFrameCount;
1360    uint32_t frameCount;
1361
1362    if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) != NO_ERROR) {
1363        return NO_INIT;
1364    }
1365    if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) != NO_ERROR) {
1366        return NO_INIT;
1367    }
1368
1369    frameCount = (sampleRate*afFrameCount*bufferCount)/afSampleRate;
1370
1371    if (channelMask == CHANNEL_MASK_USE_CHANNEL_ORDER) {
1372        channelMask = audio_channel_out_mask_from_count(channelCount);
1373        if (0 == channelMask) {
1374            ALOGE("open() error, can\'t derive mask for %d audio channels", channelCount);
1375            return NO_INIT;
1376        }
1377    }
1378
1379    AudioTrack *t;
1380    CallbackData *newcbd = NULL;
1381    if (mCallback != NULL) {
1382        newcbd = new CallbackData(this);
1383        t = new AudioTrack(
1384                mStreamType,
1385                sampleRate,
1386                format,
1387                channelMask,
1388                frameCount,
1389                flags,
1390                CallbackWrapper,
1391                newcbd,
1392                0,  // notification frames
1393                mSessionId);
1394    } else {
1395        t = new AudioTrack(
1396                mStreamType,
1397                sampleRate,
1398                format,
1399                channelMask,
1400                frameCount,
1401                flags,
1402                NULL,
1403                NULL,
1404                0,
1405                mSessionId);
1406    }
1407
1408    if ((t == 0) || (t->initCheck() != NO_ERROR)) {
1409        ALOGE("Unable to create audio track");
1410        delete t;
1411        delete newcbd;
1412        return NO_INIT;
1413    }
1414
1415
1416    if (mRecycledTrack) {
1417        // check if the existing track can be reused as-is, or if a new track needs to be created.
1418
1419        bool reuse = true;
1420        if ((mCallbackData == NULL && mCallback != NULL) ||
1421                (mCallbackData != NULL && mCallback == NULL)) {
1422            // recycled track uses callbacks but the caller wants to use writes, or vice versa
1423            ALOGV("can't chain callback and write");
1424            reuse = false;
1425        } else if ((mRecycledTrack->getSampleRate() != sampleRate) ||
1426                (mRecycledTrack->channelCount() != channelCount) ||
1427                (mRecycledTrack->frameCount() != t->frameCount())) {
1428            ALOGV("samplerate, channelcount or framecount differ: %d/%d Hz, %d/%d ch, %d/%d frames",
1429                  mRecycledTrack->getSampleRate(), sampleRate,
1430                  mRecycledTrack->channelCount(), channelCount,
1431                  mRecycledTrack->frameCount(), t->frameCount());
1432            reuse = false;
1433        } else if (flags != mFlags) {
1434            ALOGV("output flags differ %08x/%08x", flags, mFlags);
1435            reuse = false;
1436        }
1437        if (reuse) {
1438            ALOGV("chaining to next output");
1439            close();
1440            mTrack = mRecycledTrack;
1441            mRecycledTrack = NULL;
1442            if (mCallbackData != NULL) {
1443                mCallbackData->setOutput(this);
1444            }
1445            delete t;
1446            delete newcbd;
1447            return OK;
1448        }
1449
1450        // if we're not going to reuse the track, unblock and flush it
1451        if (mCallbackData != NULL) {
1452            mCallbackData->setOutput(NULL);
1453            mCallbackData->endTrackSwitch();
1454        }
1455        mRecycledTrack->flush();
1456        delete mRecycledTrack;
1457        mRecycledTrack = NULL;
1458        delete mCallbackData;
1459        mCallbackData = NULL;
1460        close();
1461    }
1462
1463    mCallbackData = newcbd;
1464    ALOGV("setVolume");
1465    t->setVolume(mLeftVolume, mRightVolume);
1466
1467    mSampleRateHz = sampleRate;
1468    mFlags = flags;
1469    mMsecsPerFrame = mPlaybackRatePermille / (float) sampleRate;
1470    uint32_t pos;
1471    if (t->getPosition(&pos) == OK) {
1472        mBytesWritten = uint64_t(pos) * t->frameSize();
1473    }
1474    mTrack = t;
1475
1476    status_t res = t->setSampleRate(mPlaybackRatePermille * mSampleRateHz / 1000);
1477    if (res != NO_ERROR) {
1478        return res;
1479    }
1480    t->setAuxEffectSendLevel(mSendLevel);
1481    return t->attachAuxEffect(mAuxEffectId);;
1482}
1483
1484void MediaPlayerService::AudioOutput::start()
1485{
1486    ALOGV("start");
1487    if (mCallbackData != NULL) {
1488        mCallbackData->endTrackSwitch();
1489    }
1490    if (mTrack) {
1491        mTrack->setVolume(mLeftVolume, mRightVolume);
1492        mTrack->setAuxEffectSendLevel(mSendLevel);
1493        mTrack->start();
1494    }
1495}
1496
1497void MediaPlayerService::AudioOutput::setNextOutput(const sp<AudioOutput>& nextOutput) {
1498    mNextOutput = nextOutput;
1499}
1500
1501
1502void MediaPlayerService::AudioOutput::switchToNextOutput() {
1503    ALOGV("switchToNextOutput");
1504    if (mNextOutput != NULL) {
1505        if (mCallbackData != NULL) {
1506            mCallbackData->beginTrackSwitch();
1507        }
1508        delete mNextOutput->mCallbackData;
1509        mNextOutput->mCallbackData = mCallbackData;
1510        mCallbackData = NULL;
1511        mNextOutput->mRecycledTrack = mTrack;
1512        mTrack = NULL;
1513        mNextOutput->mSampleRateHz = mSampleRateHz;
1514        mNextOutput->mMsecsPerFrame = mMsecsPerFrame;
1515        mNextOutput->mBytesWritten = mBytesWritten;
1516        mNextOutput->mFlags = mFlags;
1517    }
1518}
1519
1520ssize_t MediaPlayerService::AudioOutput::write(const void* buffer, size_t size)
1521{
1522    LOG_FATAL_IF(mCallback != NULL, "Don't call write if supplying a callback.");
1523
1524    //ALOGV("write(%p, %u)", buffer, size);
1525    if (mTrack) {
1526        ssize_t ret = mTrack->write(buffer, size);
1527        mBytesWritten += ret;
1528        return ret;
1529    }
1530    return NO_INIT;
1531}
1532
1533void MediaPlayerService::AudioOutput::stop()
1534{
1535    ALOGV("stop");
1536    if (mTrack) mTrack->stop();
1537}
1538
1539void MediaPlayerService::AudioOutput::flush()
1540{
1541    ALOGV("flush");
1542    if (mTrack) mTrack->flush();
1543}
1544
1545void MediaPlayerService::AudioOutput::pause()
1546{
1547    ALOGV("pause");
1548    if (mTrack) mTrack->pause();
1549}
1550
1551void MediaPlayerService::AudioOutput::close()
1552{
1553    ALOGV("close");
1554    delete mTrack;
1555    mTrack = 0;
1556}
1557
1558void MediaPlayerService::AudioOutput::setVolume(float left, float right)
1559{
1560    ALOGV("setVolume(%f, %f)", left, right);
1561    mLeftVolume = left;
1562    mRightVolume = right;
1563    if (mTrack) {
1564        mTrack->setVolume(left, right);
1565    }
1566}
1567
1568status_t MediaPlayerService::AudioOutput::setPlaybackRatePermille(int32_t ratePermille)
1569{
1570    ALOGV("setPlaybackRatePermille(%d)", ratePermille);
1571    status_t res = NO_ERROR;
1572    if (mTrack) {
1573        res = mTrack->setSampleRate(ratePermille * mSampleRateHz / 1000);
1574    } else {
1575        res = NO_INIT;
1576    }
1577    mPlaybackRatePermille = ratePermille;
1578    if (mSampleRateHz != 0) {
1579        mMsecsPerFrame = mPlaybackRatePermille / (float) mSampleRateHz;
1580    }
1581    return res;
1582}
1583
1584status_t MediaPlayerService::AudioOutput::setAuxEffectSendLevel(float level)
1585{
1586    ALOGV("setAuxEffectSendLevel(%f)", level);
1587    mSendLevel = level;
1588    if (mTrack) {
1589        return mTrack->setAuxEffectSendLevel(level);
1590    }
1591    return NO_ERROR;
1592}
1593
1594status_t MediaPlayerService::AudioOutput::attachAuxEffect(int effectId)
1595{
1596    ALOGV("attachAuxEffect(%d)", effectId);
1597    mAuxEffectId = effectId;
1598    if (mTrack) {
1599        return mTrack->attachAuxEffect(effectId);
1600    }
1601    return NO_ERROR;
1602}
1603
1604// static
1605void MediaPlayerService::AudioOutput::CallbackWrapper(
1606        int event, void *cookie, void *info) {
1607    //ALOGV("callbackwrapper");
1608    if (event != AudioTrack::EVENT_MORE_DATA) {
1609        return;
1610    }
1611
1612    CallbackData *data = (CallbackData*)cookie;
1613    data->lock();
1614    AudioOutput *me = data->getOutput();
1615    AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info;
1616    if (me == NULL) {
1617        // no output set, likely because the track was scheduled to be reused
1618        // by another player, but the format turned out to be incompatible.
1619        data->unlock();
1620        buffer->size = 0;
1621        return;
1622    }
1623
1624    size_t actualSize = (*me->mCallback)(
1625            me, buffer->raw, buffer->size, me->mCallbackCookie);
1626
1627    if (actualSize == 0 && buffer->size > 0 && me->mNextOutput == NULL) {
1628        // We've reached EOS but the audio track is not stopped yet,
1629        // keep playing silence.
1630
1631        memset(buffer->raw, 0, buffer->size);
1632        actualSize = buffer->size;
1633    }
1634
1635    buffer->size = actualSize;
1636    data->unlock();
1637}
1638
1639int MediaPlayerService::AudioOutput::getSessionId() const
1640{
1641    return mSessionId;
1642}
1643
1644#undef LOG_TAG
1645#define LOG_TAG "AudioCache"
1646MediaPlayerService::AudioCache::AudioCache(const char* name) :
1647    mChannelCount(0), mFrameCount(1024), mSampleRate(0), mSize(0),
1648    mError(NO_ERROR), mCommandComplete(false)
1649{
1650    // create ashmem heap
1651    mHeap = new MemoryHeapBase(kDefaultHeapSize, 0, name);
1652}
1653
1654uint32_t MediaPlayerService::AudioCache::latency () const
1655{
1656    return 0;
1657}
1658
1659float MediaPlayerService::AudioCache::msecsPerFrame() const
1660{
1661    return mMsecsPerFrame;
1662}
1663
1664status_t MediaPlayerService::AudioCache::getPosition(uint32_t *position) const
1665{
1666    if (position == 0) return BAD_VALUE;
1667    *position = mSize;
1668    return NO_ERROR;
1669}
1670
1671status_t MediaPlayerService::AudioCache::getFramesWritten(uint32_t *written) const
1672{
1673    if (written == 0) return BAD_VALUE;
1674    *written = mSize;
1675    return NO_ERROR;
1676}
1677
1678////////////////////////////////////////////////////////////////////////////////
1679
1680struct CallbackThread : public Thread {
1681    CallbackThread(const wp<MediaPlayerBase::AudioSink> &sink,
1682                   MediaPlayerBase::AudioSink::AudioCallback cb,
1683                   void *cookie);
1684
1685protected:
1686    virtual ~CallbackThread();
1687
1688    virtual bool threadLoop();
1689
1690private:
1691    wp<MediaPlayerBase::AudioSink> mSink;
1692    MediaPlayerBase::AudioSink::AudioCallback mCallback;
1693    void *mCookie;
1694    void *mBuffer;
1695    size_t mBufferSize;
1696
1697    CallbackThread(const CallbackThread &);
1698    CallbackThread &operator=(const CallbackThread &);
1699};
1700
1701CallbackThread::CallbackThread(
1702        const wp<MediaPlayerBase::AudioSink> &sink,
1703        MediaPlayerBase::AudioSink::AudioCallback cb,
1704        void *cookie)
1705    : mSink(sink),
1706      mCallback(cb),
1707      mCookie(cookie),
1708      mBuffer(NULL),
1709      mBufferSize(0) {
1710}
1711
1712CallbackThread::~CallbackThread() {
1713    if (mBuffer) {
1714        free(mBuffer);
1715        mBuffer = NULL;
1716    }
1717}
1718
1719bool CallbackThread::threadLoop() {
1720    sp<MediaPlayerBase::AudioSink> sink = mSink.promote();
1721    if (sink == NULL) {
1722        return false;
1723    }
1724
1725    if (mBuffer == NULL) {
1726        mBufferSize = sink->bufferSize();
1727        mBuffer = malloc(mBufferSize);
1728    }
1729
1730    size_t actualSize =
1731        (*mCallback)(sink.get(), mBuffer, mBufferSize, mCookie);
1732
1733    if (actualSize > 0) {
1734        sink->write(mBuffer, actualSize);
1735    }
1736
1737    return true;
1738}
1739
1740////////////////////////////////////////////////////////////////////////////////
1741
1742status_t MediaPlayerService::AudioCache::open(
1743        uint32_t sampleRate, int channelCount, audio_channel_mask_t channelMask,
1744        audio_format_t format, int bufferCount,
1745        AudioCallback cb, void *cookie, audio_output_flags_t flags)
1746{
1747    ALOGV("open(%u, %d, 0x%x, %d, %d)", sampleRate, channelCount, channelMask, format, bufferCount);
1748    if (mHeap->getHeapID() < 0) {
1749        return NO_INIT;
1750    }
1751
1752    mSampleRate = sampleRate;
1753    mChannelCount = (uint16_t)channelCount;
1754    mFormat = format;
1755    mMsecsPerFrame = 1.e3 / (float) sampleRate;
1756
1757    if (cb != NULL) {
1758        mCallbackThread = new CallbackThread(this, cb, cookie);
1759    }
1760    return NO_ERROR;
1761}
1762
1763void MediaPlayerService::AudioCache::start() {
1764    if (mCallbackThread != NULL) {
1765        mCallbackThread->run("AudioCache callback");
1766    }
1767}
1768
1769void MediaPlayerService::AudioCache::stop() {
1770    if (mCallbackThread != NULL) {
1771        mCallbackThread->requestExitAndWait();
1772    }
1773}
1774
1775ssize_t MediaPlayerService::AudioCache::write(const void* buffer, size_t size)
1776{
1777    ALOGV("write(%p, %u)", buffer, size);
1778    if ((buffer == 0) || (size == 0)) return size;
1779
1780    uint8_t* p = static_cast<uint8_t*>(mHeap->getBase());
1781    if (p == NULL) return NO_INIT;
1782    p += mSize;
1783    ALOGV("memcpy(%p, %p, %u)", p, buffer, size);
1784    if (mSize + size > mHeap->getSize()) {
1785        ALOGE("Heap size overflow! req size: %d, max size: %d", (mSize + size), mHeap->getSize());
1786        size = mHeap->getSize() - mSize;
1787    }
1788    memcpy(p, buffer, size);
1789    mSize += size;
1790    return size;
1791}
1792
1793// call with lock held
1794status_t MediaPlayerService::AudioCache::wait()
1795{
1796    Mutex::Autolock lock(mLock);
1797    while (!mCommandComplete) {
1798        mSignal.wait(mLock);
1799    }
1800    mCommandComplete = false;
1801
1802    if (mError == NO_ERROR) {
1803        ALOGV("wait - success");
1804    } else {
1805        ALOGV("wait - error");
1806    }
1807    return mError;
1808}
1809
1810void MediaPlayerService::AudioCache::notify(
1811        void* cookie, int msg, int ext1, int ext2, const Parcel *obj)
1812{
1813    ALOGV("notify(%p, %d, %d, %d)", cookie, msg, ext1, ext2);
1814    AudioCache* p = static_cast<AudioCache*>(cookie);
1815
1816    // ignore buffering messages
1817    switch (msg)
1818    {
1819    case MEDIA_ERROR:
1820        ALOGE("Error %d, %d occurred", ext1, ext2);
1821        p->mError = ext1;
1822        break;
1823    case MEDIA_PREPARED:
1824        ALOGV("prepared");
1825        break;
1826    case MEDIA_PLAYBACK_COMPLETE:
1827        ALOGV("playback complete");
1828        break;
1829    default:
1830        ALOGV("ignored");
1831        return;
1832    }
1833
1834    // wake up thread
1835    Mutex::Autolock lock(p->mLock);
1836    p->mCommandComplete = true;
1837    p->mSignal.signal();
1838}
1839
1840int MediaPlayerService::AudioCache::getSessionId() const
1841{
1842    return 0;
1843}
1844
1845void MediaPlayerService::addBatteryData(uint32_t params)
1846{
1847    Mutex::Autolock lock(mLock);
1848
1849    int32_t time = systemTime() / 1000000L;
1850
1851    // change audio output devices. This notification comes from AudioFlinger
1852    if ((params & kBatteryDataSpeakerOn)
1853            || (params & kBatteryDataOtherAudioDeviceOn)) {
1854
1855        int deviceOn[NUM_AUDIO_DEVICES];
1856        for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1857            deviceOn[i] = 0;
1858        }
1859
1860        if ((params & kBatteryDataSpeakerOn)
1861                && (params & kBatteryDataOtherAudioDeviceOn)) {
1862            deviceOn[SPEAKER_AND_OTHER] = 1;
1863        } else if (params & kBatteryDataSpeakerOn) {
1864            deviceOn[SPEAKER] = 1;
1865        } else {
1866            deviceOn[OTHER_AUDIO_DEVICE] = 1;
1867        }
1868
1869        for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1870            if (mBatteryAudio.deviceOn[i] != deviceOn[i]){
1871
1872                if (mBatteryAudio.refCount > 0) { // if playing audio
1873                    if (!deviceOn[i]) {
1874                        mBatteryAudio.lastTime[i] += time;
1875                        mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
1876                        mBatteryAudio.lastTime[i] = 0;
1877                    } else {
1878                        mBatteryAudio.lastTime[i] = 0 - time;
1879                    }
1880                }
1881
1882                mBatteryAudio.deviceOn[i] = deviceOn[i];
1883            }
1884        }
1885        return;
1886    }
1887
1888    // an sudio stream is started
1889    if (params & kBatteryDataAudioFlingerStart) {
1890        // record the start time only if currently no other audio
1891        // is being played
1892        if (mBatteryAudio.refCount == 0) {
1893            for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1894                if (mBatteryAudio.deviceOn[i]) {
1895                    mBatteryAudio.lastTime[i] -= time;
1896                }
1897            }
1898        }
1899
1900        mBatteryAudio.refCount ++;
1901        return;
1902
1903    } else if (params & kBatteryDataAudioFlingerStop) {
1904        if (mBatteryAudio.refCount <= 0) {
1905            ALOGW("Battery track warning: refCount is <= 0");
1906            return;
1907        }
1908
1909        // record the stop time only if currently this is the only
1910        // audio being played
1911        if (mBatteryAudio.refCount == 1) {
1912            for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1913                if (mBatteryAudio.deviceOn[i]) {
1914                    mBatteryAudio.lastTime[i] += time;
1915                    mBatteryAudio.totalTime[i] += mBatteryAudio.lastTime[i];
1916                    mBatteryAudio.lastTime[i] = 0;
1917                }
1918            }
1919        }
1920
1921        mBatteryAudio.refCount --;
1922        return;
1923    }
1924
1925    int uid = IPCThreadState::self()->getCallingUid();
1926    if (uid == AID_MEDIA) {
1927        return;
1928    }
1929    int index = mBatteryData.indexOfKey(uid);
1930
1931    if (index < 0) { // create a new entry for this UID
1932        BatteryUsageInfo info;
1933        info.audioTotalTime = 0;
1934        info.videoTotalTime = 0;
1935        info.audioLastTime = 0;
1936        info.videoLastTime = 0;
1937        info.refCount = 0;
1938
1939        if (mBatteryData.add(uid, info) == NO_MEMORY) {
1940            ALOGE("Battery track error: no memory for new app");
1941            return;
1942        }
1943    }
1944
1945    BatteryUsageInfo &info = mBatteryData.editValueFor(uid);
1946
1947    if (params & kBatteryDataCodecStarted) {
1948        if (params & kBatteryDataTrackAudio) {
1949            info.audioLastTime -= time;
1950            info.refCount ++;
1951        }
1952        if (params & kBatteryDataTrackVideo) {
1953            info.videoLastTime -= time;
1954            info.refCount ++;
1955        }
1956    } else {
1957        if (info.refCount == 0) {
1958            ALOGW("Battery track warning: refCount is already 0");
1959            return;
1960        } else if (info.refCount < 0) {
1961            ALOGE("Battery track error: refCount < 0");
1962            mBatteryData.removeItem(uid);
1963            return;
1964        }
1965
1966        if (params & kBatteryDataTrackAudio) {
1967            info.audioLastTime += time;
1968            info.refCount --;
1969        }
1970        if (params & kBatteryDataTrackVideo) {
1971            info.videoLastTime += time;
1972            info.refCount --;
1973        }
1974
1975        // no stream is being played by this UID
1976        if (info.refCount == 0) {
1977            info.audioTotalTime += info.audioLastTime;
1978            info.audioLastTime = 0;
1979            info.videoTotalTime += info.videoLastTime;
1980            info.videoLastTime = 0;
1981        }
1982    }
1983}
1984
1985status_t MediaPlayerService::pullBatteryData(Parcel* reply) {
1986    Mutex::Autolock lock(mLock);
1987
1988    // audio output devices usage
1989    int32_t time = systemTime() / 1000000L; //in ms
1990    int32_t totalTime;
1991
1992    for (int i = 0; i < NUM_AUDIO_DEVICES; i++) {
1993        totalTime = mBatteryAudio.totalTime[i];
1994
1995        if (mBatteryAudio.deviceOn[i]
1996            && (mBatteryAudio.lastTime[i] != 0)) {
1997                int32_t tmpTime = mBatteryAudio.lastTime[i] + time;
1998                totalTime += tmpTime;
1999        }
2000
2001        reply->writeInt32(totalTime);
2002        // reset the total time
2003        mBatteryAudio.totalTime[i] = 0;
2004   }
2005
2006    // codec usage
2007    BatteryUsageInfo info;
2008    int size = mBatteryData.size();
2009
2010    reply->writeInt32(size);
2011    int i = 0;
2012
2013    while (i < size) {
2014        info = mBatteryData.valueAt(i);
2015
2016        reply->writeInt32(mBatteryData.keyAt(i)); //UID
2017        reply->writeInt32(info.audioTotalTime);
2018        reply->writeInt32(info.videoTotalTime);
2019
2020        info.audioTotalTime = 0;
2021        info.videoTotalTime = 0;
2022
2023        // remove the UID entry where no stream is being played
2024        if (info.refCount <= 0) {
2025            mBatteryData.removeItemsAt(i);
2026            size --;
2027            i --;
2028        }
2029        i++;
2030    }
2031    return NO_ERROR;
2032}
2033} // namespace android
2034