MediaPlayerService.cpp revision 8e1b6cce24574b9ecd5b0300155776bd0b4ef756 
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 <dirent.h>
27#include <unistd.h>
28
29#include <string.h>
30
31#include <cutils/atomic.h>
32#include <cutils/properties.h>
33
34#include <utils/misc.h>
35
36#include <android_runtime/ActivityManager.h>
37
38#include <binder/IPCThreadState.h>
39#include <binder/IServiceManager.h>
40#include <binder/MemoryHeapBase.h>
41#include <binder/MemoryBase.h>
42#include <utils/Errors.h>  // for status_t
43#include <utils/String8.h>
44#include <utils/Vector.h>
45#include <cutils/properties.h>
46
47#include <media/MediaPlayerInterface.h>
48#include <media/mediarecorder.h>
49#include <media/MediaMetadataRetrieverInterface.h>
50#include <media/AudioTrack.h>
51
52#include "MediaRecorderClient.h"
53#include "MediaPlayerService.h"
54#include "MetadataRetrieverClient.h"
55
56#include "MidiFile.h"
57#include "VorbisPlayer.h"
58#include <media/PVPlayer.h>
59
60/* desktop Linux needs a little help with gettid() */
61#if defined(HAVE_GETTID) && !defined(HAVE_ANDROID_OS)
62#define __KERNEL__
63# include <linux/unistd.h>
64#ifdef _syscall0
65_syscall0(pid_t,gettid)
66#else
67pid_t gettid() { return syscall(__NR_gettid);}
68#endif
69#undef __KERNEL__
70#endif
71
72namespace {
73using android::status_t;
74using android::OK;
75using android::BAD_VALUE;
76using android::NOT_ENOUGH_DATA;
77using android::Parcel;
78using android::Vector;
79
80// Max number of entries in the filter.
81const int kMaxFilterSize = 64;  // I pulled that out of thin air.
82
83// Keep in sync with ANY in Metadata.java
84const int32_t kAny = 0;
85
86// To order the metadata types in the vector-filter.
87int lessThan(const int32_t *lhs, const int32_t *rhs)
88{
89    return *lhs < *rhs ? 0 : 1;
90}
91
92// Unmarshall a filter from a Parcel.
93// Filter format in a parcel:
94//
95//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
96// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
97// |                       number of entries (n)                   |
98// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
99// |                       metadata type 1                         |
100// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
101// |                       metadata type 2                         |
102// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
103//  ....
104// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
105// |                       metadata type n                         |
106// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
107//
108// @param p Parcel that should start with a filter.
109// @param[out] filter On exit contains the list of metadata type to be
110//                    filtered.
111// @param[out] status On exit contains the status code to be returned.
112// @return true if the parcel starts with a valid filter.
113bool unmarshallFilter(const Parcel& p,
114                      Vector<int32_t> *filter,
115                      status_t *status)
116{
117    int32_t s;
118    if (p.readInt32(&s) != OK)
119    {
120        LOGE("Failed to read filter's length");
121        *status = NOT_ENOUGH_DATA;
122        return false;
123    }
124
125    if( s > kMaxFilterSize || s < 0)
126    {
127        LOGE("Invalid filter len %d", s);
128        *status = BAD_VALUE;
129        return false;
130    }
131
132    size_t size = s;
133
134    filter->clear();
135    filter->setCapacity(size);
136
137    s *= sizeof(int32_t);
138
139    if (p.dataAvail() < static_cast<size_t>(s))
140    {
141        LOGE("Filter too short expected %d but got %d", s, p.dataAvail());
142        *status = NOT_ENOUGH_DATA;
143        return false;
144    }
145
146    const int32_t *data = static_cast<const int32_t*>(p.readInplace(s));
147
148    if (NULL == data )
149    {
150        LOGE("Filter had no data");
151        *status = BAD_VALUE;
152        return false;
153    }
154
155    // TODO: The stl impl of vector would be more efficient here
156    // because it degenerates into a memcpy on pod types. Try to
157    // replace later or use stl::set.
158    for (size_t i = 0; i < size; ++i)
159    {
160        filter->push(*data);
161        ++data;
162    }
163    *status = OK;
164    return true;
165}
166
167bool unmarshallBothFilters(const Parcel& p,
168                           Vector<int32_t> *allow,
169                           Vector<int32_t> *block,
170                           status_t *status)
171{
172    if (!(unmarshallFilter(p, allow, status) && unmarshallFilter(p, block, status)))
173    {
174        return false;
175    }
176    allow->sort(lessThan);
177    block->sort(lessThan);
178    return true;
179}
180
181// @param filter Should be sorted in ascending order.
182// @param val To be searched.
183// @return true if a match was found.
184bool findMetadata(const Vector<int32_t> filter, const int32_t val)
185{
186    // Deal with empty and ANY right away
187    if (filter.isEmpty()) return false;
188    if (filter[0] == kAny) return true;
189
190    ssize_t min = 0;
191    ssize_t max = filter.size() - 1;
192    ssize_t mid;
193    do
194    {
195        mid = (min + max) / 2;
196        if (val > filter[mid])
197        {
198            min = mid + 1;
199        }
200        else
201        {
202            max = mid - 1;
203        }
204        if (filter[mid] == val)
205        {
206            return true;
207        }
208    }
209    while(min <= max);
210    return false;
211}
212
213}  // anonymous namespace
214
215
216namespace android {
217
218// TODO: Temp hack until we can register players
219typedef struct {
220    const char *extension;
221    const player_type playertype;
222} extmap;
223extmap FILE_EXTS [] =  {
224        {".mid", SONIVOX_PLAYER},
225        {".midi", SONIVOX_PLAYER},
226        {".smf", SONIVOX_PLAYER},
227        {".xmf", SONIVOX_PLAYER},
228        {".imy", SONIVOX_PLAYER},
229        {".rtttl", SONIVOX_PLAYER},
230        {".rtx", SONIVOX_PLAYER},
231        {".ota", SONIVOX_PLAYER},
232        {".ogg", VORBIS_PLAYER},
233        {".oga", VORBIS_PLAYER},
234};
235
236// TODO: Find real cause of Audio/Video delay in PV framework and remove this workaround
237/* static */ const uint32_t MediaPlayerService::AudioOutput::kAudioVideoDelayMs = 96;
238/* static */ int MediaPlayerService::AudioOutput::mMinBufferCount = 4;
239/* static */ bool MediaPlayerService::AudioOutput::mIsOnEmulator = false;
240
241void MediaPlayerService::instantiate() {
242    defaultServiceManager()->addService(
243            String16("media.player"), new MediaPlayerService());
244}
245
246MediaPlayerService::MediaPlayerService()
247{
248    LOGV("MediaPlayerService created");
249    mNextConnId = 1;
250}
251
252MediaPlayerService::~MediaPlayerService()
253{
254    LOGV("MediaPlayerService destroyed");
255}
256
257sp<IMediaRecorder> MediaPlayerService::createMediaRecorder(pid_t pid)
258{
259#ifndef NO_OPENCORE
260    sp<MediaRecorderClient> recorder = new MediaRecorderClient(pid);
261#else
262    sp<MediaRecorderClient> recorder = NULL;
263#endif
264    LOGV("Create new media recorder client from pid %d", pid);
265    return recorder;
266}
267
268sp<IMediaMetadataRetriever> MediaPlayerService::createMetadataRetriever(pid_t pid)
269{
270    sp<MetadataRetrieverClient> retriever = new MetadataRetrieverClient(pid);
271    LOGV("Create new media retriever from pid %d", pid);
272    return retriever;
273}
274
275sp<IMediaPlayer> MediaPlayerService::create(pid_t pid, const sp<IMediaPlayerClient>& client, const char* url)
276{
277    int32_t connId = android_atomic_inc(&mNextConnId);
278    sp<Client> c = new Client(this, pid, connId, client);
279    LOGV("Create new client(%d) from pid %d, url=%s, connId=%d", connId, pid, url, connId);
280    if (NO_ERROR != c->setDataSource(url))
281    {
282        c.clear();
283        return c;
284    }
285    wp<Client> w = c;
286    Mutex::Autolock lock(mLock);
287    mClients.add(w);
288    return c;
289}
290
291sp<IMediaPlayer> MediaPlayerService::create(pid_t pid, const sp<IMediaPlayerClient>& client,
292        int fd, int64_t offset, int64_t length)
293{
294    int32_t connId = android_atomic_inc(&mNextConnId);
295    sp<Client> c = new Client(this, pid, connId, client);
296    LOGV("Create new client(%d) from pid %d, fd=%d, offset=%lld, length=%lld",
297            connId, pid, fd, offset, length);
298    if (NO_ERROR != c->setDataSource(fd, offset, length)) {
299        c.clear();
300    } else {
301        wp<Client> w = c;
302        Mutex::Autolock lock(mLock);
303        mClients.add(w);
304    }
305    ::close(fd);
306    return c;
307}
308
309status_t MediaPlayerService::AudioCache::dump(int fd, const Vector<String16>& args) const
310{
311    const size_t SIZE = 256;
312    char buffer[SIZE];
313    String8 result;
314
315    result.append(" AudioCache\n");
316    if (mHeap != 0) {
317        snprintf(buffer, 255, "  heap base(%p), size(%d), flags(%d), device(%s)\n",
318                mHeap->getBase(), mHeap->getSize(), mHeap->getFlags(), mHeap->getDevice());
319        result.append(buffer);
320    }
321    snprintf(buffer, 255, "  msec per frame(%f), channel count(%d), format(%d), frame count(%ld)\n",
322            mMsecsPerFrame, mChannelCount, mFormat, mFrameCount);
323    result.append(buffer);
324    snprintf(buffer, 255, "  sample rate(%d), size(%d), error(%d), command complete(%s)\n",
325            mSampleRate, mSize, mError, mCommandComplete?"true":"false");
326    result.append(buffer);
327    ::write(fd, result.string(), result.size());
328    return NO_ERROR;
329}
330
331status_t MediaPlayerService::AudioOutput::dump(int fd, const Vector<String16>& args) const
332{
333    const size_t SIZE = 256;
334    char buffer[SIZE];
335    String8 result;
336
337    result.append(" AudioOutput\n");
338    snprintf(buffer, 255, "  stream type(%d), left - right volume(%f, %f)\n",
339            mStreamType, mLeftVolume, mRightVolume);
340    result.append(buffer);
341    snprintf(buffer, 255, "  msec per frame(%f), latency (%d)\n",
342            mMsecsPerFrame, mLatency);
343    result.append(buffer);
344    ::write(fd, result.string(), result.size());
345    if (mTrack != 0) {
346        mTrack->dump(fd, args);
347    }
348    return NO_ERROR;
349}
350
351status_t MediaPlayerService::Client::dump(int fd, const Vector<String16>& args) const
352{
353    const size_t SIZE = 256;
354    char buffer[SIZE];
355    String8 result;
356    result.append(" Client\n");
357    snprintf(buffer, 255, "  pid(%d), connId(%d), status(%d), looping(%s)\n",
358            mPid, mConnId, mStatus, mLoop?"true": "false");
359    result.append(buffer);
360    write(fd, result.string(), result.size());
361    if (mAudioOutput != 0) {
362        mAudioOutput->dump(fd, args);
363    }
364    write(fd, "\n", 1);
365    return NO_ERROR;
366}
367
368static int myTid() {
369#ifdef HAVE_GETTID
370    return gettid();
371#else
372    return getpid();
373#endif
374}
375
376#if defined(__arm__)
377extern "C" void get_malloc_leak_info(uint8_t** info, size_t* overallSize,
378        size_t* infoSize, size_t* totalMemory, size_t* backtraceSize);
379extern "C" void free_malloc_leak_info(uint8_t* info);
380
381void memStatus(int fd, const Vector<String16>& args)
382{
383    const size_t SIZE = 256;
384    char buffer[SIZE];
385    String8 result;
386
387    typedef struct {
388        size_t size;
389        size_t dups;
390        intptr_t * backtrace;
391    } AllocEntry;
392
393    uint8_t *info = NULL;
394    size_t overallSize = 0;
395    size_t infoSize = 0;
396    size_t totalMemory = 0;
397    size_t backtraceSize = 0;
398
399    get_malloc_leak_info(&info, &overallSize, &infoSize, &totalMemory, &backtraceSize);
400    if (info) {
401        uint8_t *ptr = info;
402        size_t count = overallSize / infoSize;
403
404        snprintf(buffer, SIZE, " Allocation count %i\n", count);
405        result.append(buffer);
406
407        AllocEntry * entries = new AllocEntry[count];
408
409        for (size_t i = 0; i < count; i++) {
410            // Each entry should be size_t, size_t, intptr_t[backtraceSize]
411            AllocEntry *e = &entries[i];
412
413            e->size = *reinterpret_cast<size_t *>(ptr);
414            ptr += sizeof(size_t);
415
416            e->dups = *reinterpret_cast<size_t *>(ptr);
417            ptr += sizeof(size_t);
418
419            e->backtrace = reinterpret_cast<intptr_t *>(ptr);
420            ptr += sizeof(intptr_t) * backtraceSize;
421        }
422
423        // Now we need to sort the entries.  They come sorted by size but
424        // not by stack trace which causes problems using diff.
425        bool moved;
426        do {
427            moved = false;
428            for (size_t i = 0; i < (count - 1); i++) {
429                AllocEntry *e1 = &entries[i];
430                AllocEntry *e2 = &entries[i+1];
431
432                bool swap = e1->size < e2->size;
433                if (e1->size == e2->size) {
434                    for(size_t j = 0; j < backtraceSize; j++) {
435                        if (e1->backtrace[j] == e2->backtrace[j]) {
436                            continue;
437                        }
438                        swap = e1->backtrace[j] < e2->backtrace[j];
439                        break;
440                    }
441                }
442                if (swap) {
443                    AllocEntry t = entries[i];
444                    entries[i] = entries[i+1];
445                    entries[i+1] = t;
446                    moved = true;
447                }
448            }
449        } while (moved);
450
451        for (size_t i = 0; i < count; i++) {
452            AllocEntry *e = &entries[i];
453
454            snprintf(buffer, SIZE, "size %8i, dup %4i", e->size, e->dups);
455            result.append(buffer);
456            for (size_t ct = 0; (ct < backtraceSize) && e->backtrace[ct]; ct++) {
457                if (ct) {
458                    result.append(", ");
459                }
460                snprintf(buffer, SIZE, "0x%08x", e->backtrace[ct]);
461                result.append(buffer);
462            }
463            result.append("\n");
464        }
465
466        delete[] entries;
467        free_malloc_leak_info(info);
468    }
469
470    write(fd, result.string(), result.size());
471}
472#endif
473
474status_t MediaPlayerService::dump(int fd, const Vector<String16>& args)
475{
476    const size_t SIZE = 256;
477    char buffer[SIZE];
478    String8 result;
479    if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
480        snprintf(buffer, SIZE, "Permission Denial: "
481                "can't dump MediaPlayerService from pid=%d, uid=%d\n",
482                IPCThreadState::self()->getCallingPid(),
483                IPCThreadState::self()->getCallingUid());
484        result.append(buffer);
485    } else {
486        Mutex::Autolock lock(mLock);
487        for (int i = 0, n = mClients.size(); i < n; ++i) {
488            sp<Client> c = mClients[i].promote();
489            if (c != 0) c->dump(fd, args);
490        }
491        result.append(" Files opened and/or mapped:\n");
492        snprintf(buffer, SIZE, "/proc/%d/maps", myTid());
493        FILE *f = fopen(buffer, "r");
494        if (f) {
495            while (!feof(f)) {
496                fgets(buffer, SIZE, f);
497                if (strstr(buffer, " /sdcard/") ||
498                    strstr(buffer, " /system/sounds/") ||
499                    strstr(buffer, " /system/media/")) {
500                    result.append("  ");
501                    result.append(buffer);
502                }
503            }
504            fclose(f);
505        } else {
506            result.append("couldn't open ");
507            result.append(buffer);
508            result.append("\n");
509        }
510
511        snprintf(buffer, SIZE, "/proc/%d/fd", myTid());
512        DIR *d = opendir(buffer);
513        if (d) {
514            struct dirent *ent;
515            while((ent = readdir(d)) != NULL) {
516                if (strcmp(ent->d_name,".") && strcmp(ent->d_name,"..")) {
517                    snprintf(buffer, SIZE, "/proc/%d/fd/%s", myTid(), ent->d_name);
518                    struct stat s;
519                    if (lstat(buffer, &s) == 0) {
520                        if ((s.st_mode & S_IFMT) == S_IFLNK) {
521                            char linkto[256];
522                            int len = readlink(buffer, linkto, sizeof(linkto));
523                            if(len > 0) {
524                                if(len > 255) {
525                                    linkto[252] = '.';
526                                    linkto[253] = '.';
527                                    linkto[254] = '.';
528                                    linkto[255] = 0;
529                                } else {
530                                    linkto[len] = 0;
531                                }
532                                if (strstr(linkto, "/sdcard/") == linkto ||
533                                    strstr(linkto, "/system/sounds/") == linkto ||
534                                    strstr(linkto, "/system/media/") == linkto) {
535                                    result.append("  ");
536                                    result.append(buffer);
537                                    result.append(" -> ");
538                                    result.append(linkto);
539                                    result.append("\n");
540                                }
541                            }
542                        } else {
543                            result.append("  unexpected type for ");
544                            result.append(buffer);
545                            result.append("\n");
546                        }
547                    }
548                }
549            }
550            closedir(d);
551        } else {
552            result.append("couldn't open ");
553            result.append(buffer);
554            result.append("\n");
555        }
556
557#if defined(__arm__)
558        bool dumpMem = false;
559        for (size_t i = 0; i < args.size(); i++) {
560            if (args[i] == String16("-m")) {
561                dumpMem = true;
562            }
563        }
564        if (dumpMem) {
565            memStatus(fd, args);
566        }
567#endif
568    }
569    write(fd, result.string(), result.size());
570    return NO_ERROR;
571}
572
573void MediaPlayerService::removeClient(wp<Client> client)
574{
575    Mutex::Autolock lock(mLock);
576    mClients.remove(client);
577}
578
579MediaPlayerService::Client::Client(const sp<MediaPlayerService>& service, pid_t pid,
580        int32_t connId, const sp<IMediaPlayerClient>& client)
581{
582    LOGV("Client(%d) constructor", connId);
583    mPid = pid;
584    mConnId = connId;
585    mService = service;
586    mClient = client;
587    mLoop = false;
588    mStatus = NO_INIT;
589#if CALLBACK_ANTAGONIZER
590    LOGD("create Antagonizer");
591    mAntagonizer = new Antagonizer(notify, this);
592#endif
593}
594
595MediaPlayerService::Client::~Client()
596{
597    LOGV("Client(%d) destructor pid = %d", mConnId, mPid);
598    mAudioOutput.clear();
599    wp<Client> client(this);
600    disconnect();
601    mService->removeClient(client);
602}
603
604void MediaPlayerService::Client::disconnect()
605{
606    LOGV("disconnect(%d) from pid %d", mConnId, mPid);
607    // grab local reference and clear main reference to prevent future
608    // access to object
609    sp<MediaPlayerBase> p;
610    {
611        Mutex::Autolock l(mLock);
612        p = mPlayer;
613    }
614    mClient.clear();
615    mPlayer.clear();
616
617    // clear the notification to prevent callbacks to dead client
618    // and reset the player. We assume the player will serialize
619    // access to itself if necessary.
620    if (p != 0) {
621        p->setNotifyCallback(0, 0);
622#if CALLBACK_ANTAGONIZER
623        LOGD("kill Antagonizer");
624        mAntagonizer->kill();
625#endif
626        p->reset();
627    }
628
629    IPCThreadState::self()->flushCommands();
630}
631
632static player_type getPlayerType(int fd, int64_t offset, int64_t length)
633{
634    char buf[20];
635    lseek(fd, offset, SEEK_SET);
636    read(fd, buf, sizeof(buf));
637    lseek(fd, offset, SEEK_SET);
638
639    long ident = *((long*)buf);
640
641    // Ogg vorbis?
642    if (ident == 0x5367674f) // 'OggS'
643        return VORBIS_PLAYER;
644
645    // Some kind of MIDI?
646    EAS_DATA_HANDLE easdata;
647    if (EAS_Init(&easdata) == EAS_SUCCESS) {
648        EAS_FILE locator;
649        locator.path = NULL;
650        locator.fd = fd;
651        locator.offset = offset;
652        locator.length = length;
653        EAS_HANDLE  eashandle;
654        if (EAS_OpenFile(easdata, &locator, &eashandle) == EAS_SUCCESS) {
655            EAS_CloseFile(easdata, eashandle);
656            EAS_Shutdown(easdata);
657            return SONIVOX_PLAYER;
658        }
659        EAS_Shutdown(easdata);
660    }
661
662    // Fall through to PV
663    return PV_PLAYER;
664}
665
666static player_type getPlayerType(const char* url)
667{
668
669    // use MidiFile for MIDI extensions
670    int lenURL = strlen(url);
671    for (int i = 0; i < NELEM(FILE_EXTS); ++i) {
672        int len = strlen(FILE_EXTS[i].extension);
673        int start = lenURL - len;
674        if (start > 0) {
675            if (!strncmp(url + start, FILE_EXTS[i].extension, len)) {
676                return FILE_EXTS[i].playertype;
677            }
678        }
679    }
680
681    // Fall through to PV
682    return PV_PLAYER;
683}
684
685static sp<MediaPlayerBase> createPlayer(player_type playerType, void* cookie,
686        notify_callback_f notifyFunc)
687{
688    sp<MediaPlayerBase> p;
689    switch (playerType) {
690#ifndef NO_OPENCORE
691        case PV_PLAYER:
692            LOGV(" create PVPlayer");
693            p = new PVPlayer();
694            break;
695#endif
696        case SONIVOX_PLAYER:
697            LOGV(" create MidiFile");
698            p = new MidiFile();
699            break;
700        case VORBIS_PLAYER:
701            LOGV(" create VorbisPlayer");
702            p = new VorbisPlayer();
703            break;
704    }
705    if (p != NULL) {
706        if (p->initCheck() == NO_ERROR) {
707            p->setNotifyCallback(cookie, notifyFunc);
708        } else {
709            p.clear();
710        }
711    }
712    if (p == NULL) {
713        LOGE("Failed to create player object");
714    }
715    return p;
716}
717
718sp<MediaPlayerBase> MediaPlayerService::Client::createPlayer(player_type playerType)
719{
720    // determine if we have the right player type
721    sp<MediaPlayerBase> p = mPlayer;
722    if ((p != NULL) && (p->playerType() != playerType)) {
723        LOGV("delete player");
724        p.clear();
725    }
726    if (p == NULL) {
727        p = android::createPlayer(playerType, this, notify);
728    }
729    return p;
730}
731
732status_t MediaPlayerService::Client::setDataSource(const char *url)
733{
734    LOGV("setDataSource(%s)", url);
735    if (url == NULL)
736        return UNKNOWN_ERROR;
737
738    if (strncmp(url, "content://", 10) == 0) {
739        // get a filedescriptor for the content Uri and
740        // pass it to the setDataSource(fd) method
741
742        String16 url16(url);
743        int fd = android::openContentProviderFile(url16);
744        if (fd < 0)
745        {
746            LOGE("Couldn't open fd for %s", url);
747            return UNKNOWN_ERROR;
748        }
749        setDataSource(fd, 0, 0x7fffffffffLL); // this sets mStatus
750        close(fd);
751        return mStatus;
752    } else {
753        player_type playerType = getPlayerType(url);
754        LOGV("player type = %d", playerType);
755
756        // create the right type of player
757        sp<MediaPlayerBase> p = createPlayer(playerType);
758        if (p == NULL) return NO_INIT;
759
760        if (!p->hardwareOutput()) {
761            mAudioOutput = new AudioOutput();
762            static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
763        }
764
765        // now set data source
766        LOGV(" setDataSource");
767        mStatus = p->setDataSource(url);
768        if (mStatus == NO_ERROR) mPlayer = p;
769        return mStatus;
770    }
771}
772
773status_t MediaPlayerService::Client::setDataSource(int fd, int64_t offset, int64_t length)
774{
775    LOGV("setDataSource fd=%d, offset=%lld, length=%lld", fd, offset, length);
776    struct stat sb;
777    int ret = fstat(fd, &sb);
778    if (ret != 0) {
779        LOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
780        return UNKNOWN_ERROR;
781    }
782
783    LOGV("st_dev  = %llu", sb.st_dev);
784    LOGV("st_mode = %u", sb.st_mode);
785    LOGV("st_uid  = %lu", sb.st_uid);
786    LOGV("st_gid  = %lu", sb.st_gid);
787    LOGV("st_size = %llu", sb.st_size);
788
789    if (offset >= sb.st_size) {
790        LOGE("offset error");
791        ::close(fd);
792        return UNKNOWN_ERROR;
793    }
794    if (offset + length > sb.st_size) {
795        length = sb.st_size - offset;
796        LOGV("calculated length = %lld", length);
797    }
798
799    player_type playerType = getPlayerType(fd, offset, length);
800    LOGV("player type = %d", playerType);
801
802    // create the right type of player
803    sp<MediaPlayerBase> p = createPlayer(playerType);
804    if (p == NULL) return NO_INIT;
805
806    if (!p->hardwareOutput()) {
807        mAudioOutput = new AudioOutput();
808        static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput);
809    }
810
811    // now set data source
812    mStatus = p->setDataSource(fd, offset, length);
813    if (mStatus == NO_ERROR) mPlayer = p;
814    return mStatus;
815}
816
817status_t MediaPlayerService::Client::setVideoSurface(const sp<ISurface>& surface)
818{
819    LOGV("[%d] setVideoSurface(%p)", mConnId, surface.get());
820    sp<MediaPlayerBase> p = getPlayer();
821    if (p == 0) return UNKNOWN_ERROR;
822    return p->setVideoSurface(surface);
823}
824
825status_t MediaPlayerService::Client::invoke(const Parcel& request,
826                                            Parcel *reply)
827{
828    sp<MediaPlayerBase> p = getPlayer();
829    if (p == NULL) return UNKNOWN_ERROR;
830    return p->invoke(request, reply);
831}
832
833// This call doesn't need to access the native player.
834status_t MediaPlayerService::Client::setMetadataFilter(const Parcel& filter)
835{
836    status_t status;
837    Vector<int32_t> allow, drop;
838
839    if (unmarshallBothFilters(filter, &allow, &drop, &status))
840    {
841        Mutex::Autolock l(mLock);
842
843        mMetadataAllow = allow;
844        mMetadataDrop = drop;
845    }
846    return status;
847}
848
849status_t MediaPlayerService::Client::getMetadata(bool update_only, bool apply_filter, Parcel *metadata)
850{
851    status_t status;
852    metadata->writeInt32(-1);  // Placeholder for the return code
853
854    // FIXME: Implement, query the native player and do the optional filtering, etc...
855    status = OK;
856    return status;
857}
858
859status_t MediaPlayerService::Client::prepareAsync()
860{
861    LOGV("[%d] prepareAsync", mConnId);
862    sp<MediaPlayerBase> p = getPlayer();
863    if (p == 0) return UNKNOWN_ERROR;
864    status_t ret = p->prepareAsync();
865#if CALLBACK_ANTAGONIZER
866    LOGD("start Antagonizer");
867    if (ret == NO_ERROR) mAntagonizer->start();
868#endif
869    return ret;
870}
871
872status_t MediaPlayerService::Client::start()
873{
874    LOGV("[%d] start", mConnId);
875    sp<MediaPlayerBase> p = getPlayer();
876    if (p == 0) return UNKNOWN_ERROR;
877    p->setLooping(mLoop);
878    return p->start();
879}
880
881status_t MediaPlayerService::Client::stop()
882{
883    LOGV("[%d] stop", mConnId);
884    sp<MediaPlayerBase> p = getPlayer();
885    if (p == 0) return UNKNOWN_ERROR;
886    return p->stop();
887}
888
889status_t MediaPlayerService::Client::pause()
890{
891    LOGV("[%d] pause", mConnId);
892    sp<MediaPlayerBase> p = getPlayer();
893    if (p == 0) return UNKNOWN_ERROR;
894    return p->pause();
895}
896
897status_t MediaPlayerService::Client::isPlaying(bool* state)
898{
899    *state = false;
900    sp<MediaPlayerBase> p = getPlayer();
901    if (p == 0) return UNKNOWN_ERROR;
902    *state = p->isPlaying();
903    LOGV("[%d] isPlaying: %d", mConnId, *state);
904    return NO_ERROR;
905}
906
907status_t MediaPlayerService::Client::getCurrentPosition(int *msec)
908{
909    LOGV("getCurrentPosition");
910    sp<MediaPlayerBase> p = getPlayer();
911    if (p == 0) return UNKNOWN_ERROR;
912    status_t ret = p->getCurrentPosition(msec);
913    if (ret == NO_ERROR) {
914        LOGV("[%d] getCurrentPosition = %d", mConnId, *msec);
915    } else {
916        LOGE("getCurrentPosition returned %d", ret);
917    }
918    return ret;
919}
920
921status_t MediaPlayerService::Client::getDuration(int *msec)
922{
923    LOGV("getDuration");
924    sp<MediaPlayerBase> p = getPlayer();
925    if (p == 0) return UNKNOWN_ERROR;
926    status_t ret = p->getDuration(msec);
927    if (ret == NO_ERROR) {
928        LOGV("[%d] getDuration = %d", mConnId, *msec);
929    } else {
930        LOGE("getDuration returned %d", ret);
931    }
932    return ret;
933}
934
935status_t MediaPlayerService::Client::seekTo(int msec)
936{
937    LOGV("[%d] seekTo(%d)", mConnId, msec);
938    sp<MediaPlayerBase> p = getPlayer();
939    if (p == 0) return UNKNOWN_ERROR;
940    return p->seekTo(msec);
941}
942
943status_t MediaPlayerService::Client::reset()
944{
945    LOGV("[%d] reset", mConnId);
946    sp<MediaPlayerBase> p = getPlayer();
947    if (p == 0) return UNKNOWN_ERROR;
948    return p->reset();
949}
950
951status_t MediaPlayerService::Client::setAudioStreamType(int type)
952{
953    LOGV("[%d] setAudioStreamType(%d)", mConnId, type);
954    // TODO: for hardware output, call player instead
955    Mutex::Autolock l(mLock);
956    if (mAudioOutput != 0) mAudioOutput->setAudioStreamType(type);
957    return NO_ERROR;
958}
959
960status_t MediaPlayerService::Client::setLooping(int loop)
961{
962    LOGV("[%d] setLooping(%d)", mConnId, loop);
963    mLoop = loop;
964    sp<MediaPlayerBase> p = getPlayer();
965    if (p != 0) return p->setLooping(loop);
966    return NO_ERROR;
967}
968
969status_t MediaPlayerService::Client::setVolume(float leftVolume, float rightVolume)
970{
971    LOGV("[%d] setVolume(%f, %f)", mConnId, leftVolume, rightVolume);
972    // TODO: for hardware output, call player instead
973    Mutex::Autolock l(mLock);
974    if (mAudioOutput != 0) mAudioOutput->setVolume(leftVolume, rightVolume);
975    return NO_ERROR;
976}
977
978void MediaPlayerService::Client::notify(void* cookie, int msg, int ext1, int ext2)
979{
980    Client* client = static_cast<Client*>(cookie);
981
982    if (MEDIA_INFO == msg &&
983        MEDIA_INFO_METADATA_UPDATE == ext1 &&
984        client->shouldDropMetadata(ext2 /* metadata type */)) {
985        return;
986    }
987    LOGV("[%d] notify (%p, %d, %d, %d)", client->mConnId, cookie, msg, ext1, ext2);
988    client->mClient->notify(msg, ext1, ext2);
989}
990
991bool MediaPlayerService::Client::shouldDropMetadata(int code) const
992{
993    Mutex::Autolock l(mLock);
994
995    if (findMetadata(mMetadataDrop, code))
996    {
997        return true;
998    }
999
1000    if (mMetadataAllow.isEmpty() || findMetadata(mMetadataAllow, code))
1001    {
1002        return false;
1003    }
1004    else
1005    {
1006        return true;
1007    }
1008}
1009
1010#if CALLBACK_ANTAGONIZER
1011const int Antagonizer::interval = 10000; // 10 msecs
1012
1013Antagonizer::Antagonizer(notify_callback_f cb, void* client) :
1014    mExit(false), mActive(false), mClient(client), mCb(cb)
1015{
1016    createThread(callbackThread, this);
1017}
1018
1019void Antagonizer::kill()
1020{
1021    Mutex::Autolock _l(mLock);
1022    mActive = false;
1023    mExit = true;
1024    mCondition.wait(mLock);
1025}
1026
1027int Antagonizer::callbackThread(void* user)
1028{
1029    LOGD("Antagonizer started");
1030    Antagonizer* p = reinterpret_cast<Antagonizer*>(user);
1031    while (!p->mExit) {
1032        if (p->mActive) {
1033            LOGV("send event");
1034            p->mCb(p->mClient, 0, 0, 0);
1035        }
1036        usleep(interval);
1037    }
1038    Mutex::Autolock _l(p->mLock);
1039    p->mCondition.signal();
1040    LOGD("Antagonizer stopped");
1041    return 0;
1042}
1043#endif
1044
1045static size_t kDefaultHeapSize = 1024 * 1024; // 1MB
1046
1047sp<IMemory> MediaPlayerService::decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat)
1048{
1049    LOGV("decode(%s)", url);
1050    sp<MemoryBase> mem;
1051    sp<MediaPlayerBase> player;
1052
1053    // Protect our precious, precious DRMd ringtones by only allowing
1054    // decoding of http, but not filesystem paths or content Uris.
1055    // If the application wants to decode those, it should open a
1056    // filedescriptor for them and use that.
1057    if (url != NULL && strncmp(url, "http://", 7) != 0) {
1058        LOGD("Can't decode %s by path, use filedescriptor instead", url);
1059        return mem;
1060    }
1061
1062    player_type playerType = getPlayerType(url);
1063    LOGV("player type = %d", playerType);
1064
1065    // create the right type of player
1066    sp<AudioCache> cache = new AudioCache(url);
1067    player = android::createPlayer(playerType, cache.get(), cache->notify);
1068    if (player == NULL) goto Exit;
1069    if (player->hardwareOutput()) goto Exit;
1070
1071    static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache);
1072
1073    // set data source
1074    if (player->setDataSource(url) != NO_ERROR) goto Exit;
1075
1076    LOGV("prepare");
1077    player->prepareAsync();
1078
1079    LOGV("wait for prepare");
1080    if (cache->wait() != NO_ERROR) goto Exit;
1081
1082    LOGV("start");
1083    player->start();
1084
1085    LOGV("wait for playback complete");
1086    if (cache->wait() != NO_ERROR) goto Exit;
1087
1088    mem = new MemoryBase(cache->getHeap(), 0, cache->size());
1089    *pSampleRate = cache->sampleRate();
1090    *pNumChannels = cache->channelCount();
1091    *pFormat = cache->format();
1092    LOGV("return memory @ %p, sampleRate=%u, channelCount = %d, format = %d", mem->pointer(), *pSampleRate, *pNumChannels, *pFormat);
1093
1094Exit:
1095    if (player != 0) player->reset();
1096    return mem;
1097}
1098
1099sp<IMemory> MediaPlayerService::decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat)
1100{
1101    LOGV("decode(%d, %lld, %lld)", fd, offset, length);
1102    sp<MemoryBase> mem;
1103    sp<MediaPlayerBase> player;
1104
1105    player_type playerType = getPlayerType(fd, offset, length);
1106    LOGV("player type = %d", playerType);
1107
1108    // create the right type of player
1109    sp<AudioCache> cache = new AudioCache("decode_fd");
1110    player = android::createPlayer(playerType, cache.get(), cache->notify);
1111    if (player == NULL) goto Exit;
1112    if (player->hardwareOutput()) goto Exit;
1113
1114    static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache);
1115
1116    // set data source
1117    if (player->setDataSource(fd, offset, length) != NO_ERROR) goto Exit;
1118
1119    LOGV("prepare");
1120    player->prepareAsync();
1121
1122    LOGV("wait for prepare");
1123    if (cache->wait() != NO_ERROR) goto Exit;
1124
1125    LOGV("start");
1126    player->start();
1127
1128    LOGV("wait for playback complete");
1129    if (cache->wait() != NO_ERROR) goto Exit;
1130
1131    mem = new MemoryBase(cache->getHeap(), 0, cache->size());
1132    *pSampleRate = cache->sampleRate();
1133    *pNumChannels = cache->channelCount();
1134    *pFormat = cache->format();
1135    LOGV("return memory @ %p, sampleRate=%u, channelCount = %d, format = %d", mem->pointer(), *pSampleRate, *pNumChannels, *pFormat);
1136
1137Exit:
1138    if (player != 0) player->reset();
1139    ::close(fd);
1140    return mem;
1141}
1142
1143#undef LOG_TAG
1144#define LOG_TAG "AudioSink"
1145MediaPlayerService::AudioOutput::AudioOutput()
1146{
1147    mTrack = 0;
1148    mStreamType = AudioSystem::MUSIC;
1149    mLeftVolume = 1.0;
1150    mRightVolume = 1.0;
1151    mLatency = 0;
1152    mMsecsPerFrame = 0;
1153    setMinBufferCount();
1154}
1155
1156MediaPlayerService::AudioOutput::~AudioOutput()
1157{
1158    close();
1159}
1160
1161void MediaPlayerService::AudioOutput::setMinBufferCount()
1162{
1163    char value[PROPERTY_VALUE_MAX];
1164    if (property_get("ro.kernel.qemu", value, 0)) {
1165        mIsOnEmulator = true;
1166        mMinBufferCount = 12;  // to prevent systematic buffer underrun for emulator
1167    }
1168}
1169
1170bool MediaPlayerService::AudioOutput::isOnEmulator()
1171{
1172    setMinBufferCount();
1173    return mIsOnEmulator;
1174}
1175
1176int MediaPlayerService::AudioOutput::getMinBufferCount()
1177{
1178    setMinBufferCount();
1179    return mMinBufferCount;
1180}
1181
1182ssize_t MediaPlayerService::AudioOutput::bufferSize() const
1183{
1184    if (mTrack == 0) return NO_INIT;
1185    return mTrack->frameCount() * frameSize();
1186}
1187
1188ssize_t MediaPlayerService::AudioOutput::frameCount() const
1189{
1190    if (mTrack == 0) return NO_INIT;
1191    return mTrack->frameCount();
1192}
1193
1194ssize_t MediaPlayerService::AudioOutput::channelCount() const
1195{
1196    if (mTrack == 0) return NO_INIT;
1197    return mTrack->channelCount();
1198}
1199
1200ssize_t MediaPlayerService::AudioOutput::frameSize() const
1201{
1202    if (mTrack == 0) return NO_INIT;
1203    return mTrack->frameSize();
1204}
1205
1206uint32_t MediaPlayerService::AudioOutput::latency () const
1207{
1208    return mLatency;
1209}
1210
1211float MediaPlayerService::AudioOutput::msecsPerFrame() const
1212{
1213    return mMsecsPerFrame;
1214}
1215
1216status_t MediaPlayerService::AudioOutput::open(uint32_t sampleRate, int channelCount, int format, int bufferCount)
1217{
1218    // Check argument "bufferCount" against the mininum buffer count
1219    if (bufferCount < mMinBufferCount) {
1220        LOGD("bufferCount (%d) is too small and increased to %d", bufferCount, mMinBufferCount);
1221        bufferCount = mMinBufferCount;
1222
1223    }
1224    LOGV("open(%u, %d, %d, %d)", sampleRate, channelCount, format, bufferCount);
1225    if (mTrack) close();
1226    int afSampleRate;
1227    int afFrameCount;
1228    int frameCount;
1229
1230    if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) != NO_ERROR) {
1231        return NO_INIT;
1232    }
1233    if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) != NO_ERROR) {
1234        return NO_INIT;
1235    }
1236
1237    frameCount = (sampleRate*afFrameCount*bufferCount)/afSampleRate;
1238    AudioTrack *t = new AudioTrack(mStreamType, sampleRate, format, channelCount, frameCount);
1239    if ((t == 0) || (t->initCheck() != NO_ERROR)) {
1240        LOGE("Unable to create audio track");
1241        delete t;
1242        return NO_INIT;
1243    }
1244
1245    LOGV("setVolume");
1246    t->setVolume(mLeftVolume, mRightVolume);
1247    mMsecsPerFrame = 1.e3 / (float) sampleRate;
1248    mLatency = t->latency() + kAudioVideoDelayMs;
1249    mTrack = t;
1250    return NO_ERROR;
1251}
1252
1253void MediaPlayerService::AudioOutput::start()
1254{
1255    LOGV("start");
1256    if (mTrack) {
1257        mTrack->setVolume(mLeftVolume, mRightVolume);
1258        mTrack->start();
1259    }
1260}
1261
1262ssize_t MediaPlayerService::AudioOutput::write(const void* buffer, size_t size)
1263{
1264    //LOGV("write(%p, %u)", buffer, size);
1265    if (mTrack) return mTrack->write(buffer, size);
1266    return NO_INIT;
1267}
1268
1269void MediaPlayerService::AudioOutput::stop()
1270{
1271    LOGV("stop");
1272    if (mTrack) mTrack->stop();
1273}
1274
1275void MediaPlayerService::AudioOutput::flush()
1276{
1277    LOGV("flush");
1278    if (mTrack) mTrack->flush();
1279}
1280
1281void MediaPlayerService::AudioOutput::pause()
1282{
1283    LOGV("pause");
1284    if (mTrack) mTrack->pause();
1285}
1286
1287void MediaPlayerService::AudioOutput::close()
1288{
1289    LOGV("close");
1290    delete mTrack;
1291    mTrack = 0;
1292}
1293
1294void MediaPlayerService::AudioOutput::setVolume(float left, float right)
1295{
1296    LOGV("setVolume(%f, %f)", left, right);
1297    mLeftVolume = left;
1298    mRightVolume = right;
1299    if (mTrack) {
1300        mTrack->setVolume(left, right);
1301    }
1302}
1303
1304#undef LOG_TAG
1305#define LOG_TAG "AudioCache"
1306MediaPlayerService::AudioCache::AudioCache(const char* name) :
1307    mChannelCount(0), mFrameCount(1024), mSampleRate(0), mSize(0),
1308    mError(NO_ERROR), mCommandComplete(false)
1309{
1310    // create ashmem heap
1311    mHeap = new MemoryHeapBase(kDefaultHeapSize, 0, name);
1312}
1313
1314uint32_t MediaPlayerService::AudioCache::latency () const
1315{
1316    return 0;
1317}
1318
1319float MediaPlayerService::AudioCache::msecsPerFrame() const
1320{
1321    return mMsecsPerFrame;
1322}
1323
1324status_t MediaPlayerService::AudioCache::open(uint32_t sampleRate, int channelCount, int format, int bufferCount)
1325{
1326    LOGV("open(%u, %d, %d, %d)", sampleRate, channelCount, format, bufferCount);
1327    if (mHeap->getHeapID() < 0) return NO_INIT;
1328    mSampleRate = sampleRate;
1329    mChannelCount = (uint16_t)channelCount;
1330    mFormat = (uint16_t)format;
1331    mMsecsPerFrame = 1.e3 / (float) sampleRate;
1332    return NO_ERROR;
1333}
1334
1335ssize_t MediaPlayerService::AudioCache::write(const void* buffer, size_t size)
1336{
1337    LOGV("write(%p, %u)", buffer, size);
1338    if ((buffer == 0) || (size == 0)) return size;
1339
1340    uint8_t* p = static_cast<uint8_t*>(mHeap->getBase());
1341    if (p == NULL) return NO_INIT;
1342    p += mSize;
1343    LOGV("memcpy(%p, %p, %u)", p, buffer, size);
1344    if (mSize + size > mHeap->getSize()) {
1345        LOGE("Heap size overflow! req size: %d, max size: %d", (mSize + size), mHeap->getSize());
1346        size = mHeap->getSize() - mSize;
1347    }
1348    memcpy(p, buffer, size);
1349    mSize += size;
1350    return size;
1351}
1352
1353// call with lock held
1354status_t MediaPlayerService::AudioCache::wait()
1355{
1356    Mutex::Autolock lock(mLock);
1357    if (!mCommandComplete) {
1358        mSignal.wait(mLock);
1359    }
1360    mCommandComplete = false;
1361
1362    if (mError == NO_ERROR) {
1363        LOGV("wait - success");
1364    } else {
1365        LOGV("wait - error");
1366    }
1367    return mError;
1368}
1369
1370void MediaPlayerService::AudioCache::notify(void* cookie, int msg, int ext1, int ext2)
1371{
1372    LOGV("notify(%p, %d, %d, %d)", cookie, msg, ext1, ext2);
1373    AudioCache* p = static_cast<AudioCache*>(cookie);
1374
1375    // ignore buffering messages
1376    if (msg == MEDIA_BUFFERING_UPDATE) return;
1377
1378    // set error condition
1379    if (msg == MEDIA_ERROR) {
1380        LOGE("Error %d, %d occurred", ext1, ext2);
1381        p->mError = ext1;
1382    }
1383
1384    // wake up thread
1385    LOGV("wakeup thread");
1386    p->mCommandComplete = true;
1387    p->mSignal.signal();
1388}
1389
1390}; // namespace android
1391