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> // for property_get 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/SystemClock.h> 45 #include <utils/Vector.h> 46 #include <cutils/properties.h> 47 48 #include <media/MediaPlayerInterface.h> 49 #include <media/mediarecorder.h> 50 #include <media/MediaMetadataRetrieverInterface.h> 51 #include <media/Metadata.h> 52 #include <media/AudioTrack.h> 53 54 #include "MediaRecorderClient.h" 55 #include "MediaPlayerService.h" 56 #include "MetadataRetrieverClient.h" 57 58 #include "MidiFile.h" 59 #include "VorbisPlayer.h" 60 #include <media/PVPlayer.h> 61 #include "TestPlayerStub.h" 62 #include "StagefrightPlayer.h" 63 64 #include <OMX.h> 65 66 /* desktop Linux needs a little help with gettid() */ 67 #if defined(HAVE_GETTID) && !defined(HAVE_ANDROID_OS) 68 #define __KERNEL__ 69 # include <linux/unistd.h> 70 #ifdef _syscall0 71 _syscall0(pid_t,gettid) 72 #else 73 pid_t gettid() { return syscall(__NR_gettid);} 74 #endif 75 #undef __KERNEL__ 76 #endif 77 78 namespace { 79 using android::media::Metadata; 80 using android::status_t; 81 using android::OK; 82 using android::BAD_VALUE; 83 using android::NOT_ENOUGH_DATA; 84 using android::Parcel; 85 86 // Max number of entries in the filter. 87 const int kMaxFilterSize = 64; // I pulled that out of thin air. 88 89 // FIXME: Move all the metadata related function in the Metadata.cpp 90 91 92 // Unmarshall a filter from a Parcel. 93 // Filter format in a parcel: 94 // 95 // 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 96 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 97 // | number of entries (n) | 98 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 99 // | metadata type 1 | 100 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 101 // | metadata type 2 | 102 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 103 // .... 104 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 105 // | metadata type n | 106 // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+ 107 // 108 // @param p Parcel that should start with a filter. 109 // @param[out] filter On exit contains the list of metadata type to be 110 // filtered. 111 // @param[out] status On exit contains the status code to be returned. 112 // @return true if the parcel starts with a valid filter. 113 bool unmarshallFilter(const Parcel& p, 114 Metadata::Filter *filter, 115 status_t *status) 116 { 117 int32_t val; 118 if (p.readInt32(&val) != OK) 119 { 120 LOGE("Failed to read filter's length"); 121 *status = NOT_ENOUGH_DATA; 122 return false; 123 } 124 125 if( val > kMaxFilterSize || val < 0) 126 { 127 LOGE("Invalid filter len %d", val); 128 *status = BAD_VALUE; 129 return false; 130 } 131 132 const size_t num = val; 133 134 filter->clear(); 135 filter->setCapacity(num); 136 137 size_t size = num * sizeof(Metadata::Type); 138 139 140 if (p.dataAvail() < size) 141 { 142 LOGE("Filter too short expected %d but got %d", size, p.dataAvail()); 143 *status = NOT_ENOUGH_DATA; 144 return false; 145 } 146 147 const Metadata::Type *data = 148 static_cast<const Metadata::Type*>(p.readInplace(size)); 149 150 if (NULL == data) 151 { 152 LOGE("Filter had no data"); 153 *status = BAD_VALUE; 154 return false; 155 } 156 157 // TODO: The stl impl of vector would be more efficient here 158 // because it degenerates into a memcpy on pod types. Try to 159 // replace later or use stl::set. 160 for (size_t i = 0; i < num; ++i) 161 { 162 filter->add(*data); 163 ++data; 164 } 165 *status = OK; 166 return true; 167 } 168 169 // @param filter Of metadata type. 170 // @param val To be searched. 171 // @return true if a match was found. 172 bool findMetadata(const Metadata::Filter& filter, const int32_t val) 173 { 174 // Deal with empty and ANY right away 175 if (filter.isEmpty()) return false; 176 if (filter[0] == Metadata::kAny) return true; 177 178 return filter.indexOf(val) >= 0; 179 } 180 181 } // anonymous namespace 182 183 184 namespace android { 185 186 // TODO: Temp hack until we can register players 187 typedef struct { 188 const char *extension; 189 const player_type playertype; 190 } extmap; 191 extmap FILE_EXTS [] = { 192 {".mid", SONIVOX_PLAYER}, 193 {".midi", SONIVOX_PLAYER}, 194 {".smf", SONIVOX_PLAYER}, 195 {".xmf", SONIVOX_PLAYER}, 196 {".imy", SONIVOX_PLAYER}, 197 {".rtttl", SONIVOX_PLAYER}, 198 {".rtx", SONIVOX_PLAYER}, 199 {".ota", SONIVOX_PLAYER}, 200 {".ogg", VORBIS_PLAYER}, 201 {".oga", VORBIS_PLAYER}, 202 #ifndef NO_OPENCORE 203 {".wma", PV_PLAYER}, 204 {".wmv", PV_PLAYER}, 205 {".asf", PV_PLAYER}, 206 #endif 207 }; 208 209 // TODO: Find real cause of Audio/Video delay in PV framework and remove this workaround 210 /* static */ int MediaPlayerService::AudioOutput::mMinBufferCount = 4; 211 /* static */ bool MediaPlayerService::AudioOutput::mIsOnEmulator = false; 212 213 void MediaPlayerService::instantiate() { 214 defaultServiceManager()->addService( 215 String16("media.player"), new MediaPlayerService()); 216 } 217 218 MediaPlayerService::MediaPlayerService() 219 { 220 LOGV("MediaPlayerService created"); 221 mNextConnId = 1; 222 } 223 224 MediaPlayerService::~MediaPlayerService() 225 { 226 LOGV("MediaPlayerService destroyed"); 227 } 228 229 sp<IMediaRecorder> MediaPlayerService::createMediaRecorder(pid_t pid) 230 { 231 #ifndef NO_OPENCORE 232 sp<MediaRecorderClient> recorder = new MediaRecorderClient(this, pid); 233 wp<MediaRecorderClient> w = recorder; 234 Mutex::Autolock lock(mLock); 235 mMediaRecorderClients.add(w); 236 #else 237 sp<MediaRecorderClient> recorder = NULL; 238 #endif 239 LOGV("Create new media recorder client from pid %d", pid); 240 return recorder; 241 } 242 243 void MediaPlayerService::removeMediaRecorderClient(wp<MediaRecorderClient> client) 244 { 245 Mutex::Autolock lock(mLock); 246 mMediaRecorderClients.remove(client); 247 LOGV("Delete media recorder client"); 248 } 249 250 sp<IMediaMetadataRetriever> MediaPlayerService::createMetadataRetriever(pid_t pid) 251 { 252 sp<MetadataRetrieverClient> retriever = new MetadataRetrieverClient(pid); 253 LOGV("Create new media retriever from pid %d", pid); 254 return retriever; 255 } 256 257 sp<IMediaPlayer> MediaPlayerService::create( 258 pid_t pid, const sp<IMediaPlayerClient>& client, const char* url, 259 const KeyedVector<String8, String8> *headers) 260 { 261 int32_t connId = android_atomic_inc(&mNextConnId); 262 sp<Client> c = new Client(this, pid, connId, client); 263 LOGV("Create new client(%d) from pid %d, url=%s, connId=%d", connId, pid, url, connId); 264 if (NO_ERROR != c->setDataSource(url, headers)) 265 { 266 c.clear(); 267 return c; 268 } 269 wp<Client> w = c; 270 Mutex::Autolock lock(mLock); 271 mClients.add(w); 272 return c; 273 } 274 275 sp<IMediaPlayer> MediaPlayerService::create(pid_t pid, const sp<IMediaPlayerClient>& client, 276 int fd, int64_t offset, int64_t length) 277 { 278 int32_t connId = android_atomic_inc(&mNextConnId); 279 sp<Client> c = new Client(this, pid, connId, client); 280 LOGV("Create new client(%d) from pid %d, fd=%d, offset=%lld, length=%lld", 281 connId, pid, fd, offset, length); 282 if (NO_ERROR != c->setDataSource(fd, offset, length)) { 283 c.clear(); 284 } else { 285 wp<Client> w = c; 286 Mutex::Autolock lock(mLock); 287 mClients.add(w); 288 } 289 ::close(fd); 290 return c; 291 } 292 293 sp<IOMX> MediaPlayerService::getOMX() { 294 Mutex::Autolock autoLock(mLock); 295 296 if (mOMX.get() == NULL) { 297 mOMX = new OMX; 298 } 299 300 return mOMX; 301 } 302 303 status_t MediaPlayerService::AudioCache::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(" AudioCache\n"); 310 if (mHeap != 0) { 311 snprintf(buffer, 255, " heap base(%p), size(%d), flags(%d), device(%s)\n", 312 mHeap->getBase(), mHeap->getSize(), mHeap->getFlags(), mHeap->getDevice()); 313 result.append(buffer); 314 } 315 snprintf(buffer, 255, " msec per frame(%f), channel count(%d), format(%d), frame count(%ld)\n", 316 mMsecsPerFrame, mChannelCount, mFormat, mFrameCount); 317 result.append(buffer); 318 snprintf(buffer, 255, " sample rate(%d), size(%d), error(%d), command complete(%s)\n", 319 mSampleRate, mSize, mError, mCommandComplete?"true":"false"); 320 result.append(buffer); 321 ::write(fd, result.string(), result.size()); 322 return NO_ERROR; 323 } 324 325 status_t MediaPlayerService::AudioOutput::dump(int fd, const Vector<String16>& args) const 326 { 327 const size_t SIZE = 256; 328 char buffer[SIZE]; 329 String8 result; 330 331 result.append(" AudioOutput\n"); 332 snprintf(buffer, 255, " stream type(%d), left - right volume(%f, %f)\n", 333 mStreamType, mLeftVolume, mRightVolume); 334 result.append(buffer); 335 snprintf(buffer, 255, " msec per frame(%f), latency (%d)\n", 336 mMsecsPerFrame, mLatency); 337 result.append(buffer); 338 ::write(fd, result.string(), result.size()); 339 if (mTrack != 0) { 340 mTrack->dump(fd, args); 341 } 342 return NO_ERROR; 343 } 344 345 status_t MediaPlayerService::Client::dump(int fd, const Vector<String16>& args) const 346 { 347 const size_t SIZE = 256; 348 char buffer[SIZE]; 349 String8 result; 350 result.append(" Client\n"); 351 snprintf(buffer, 255, " pid(%d), connId(%d), status(%d), looping(%s)\n", 352 mPid, mConnId, mStatus, mLoop?"true": "false"); 353 result.append(buffer); 354 write(fd, result.string(), result.size()); 355 if (mAudioOutput != 0) { 356 mAudioOutput->dump(fd, args); 357 } 358 write(fd, "\n", 1); 359 return NO_ERROR; 360 } 361 362 static int myTid() { 363 #ifdef HAVE_GETTID 364 return gettid(); 365 #else 366 return getpid(); 367 #endif 368 } 369 370 #if defined(__arm__) 371 extern "C" void get_malloc_leak_info(uint8_t** info, size_t* overallSize, 372 size_t* infoSize, size_t* totalMemory, size_t* backtraceSize); 373 extern "C" void free_malloc_leak_info(uint8_t* info); 374 375 // Use the String-class below instead of String8 to allocate all memory 376 // beforehand and not reenter the heap while we are examining it... 377 struct MyString8 { 378 static const size_t MAX_SIZE = 256 * 1024; 379 380 MyString8() 381 : mPtr((char *)malloc(MAX_SIZE)) { 382 *mPtr = '\0'; 383 } 384 385 ~MyString8() { 386 free(mPtr); 387 } 388 389 void append(const char *s) { 390 strcat(mPtr, s); 391 } 392 393 const char *string() const { 394 return mPtr; 395 } 396 397 size_t size() const { 398 return strlen(mPtr); 399 } 400 401 private: 402 char *mPtr; 403 404 MyString8(const MyString8 &); 405 MyString8 &operator=(const MyString8 &); 406 }; 407 408 void memStatus(int fd, const Vector<String16>& args) 409 { 410 const size_t SIZE = 256; 411 char buffer[SIZE]; 412 MyString8 result; 413 414 typedef struct { 415 size_t size; 416 size_t dups; 417 intptr_t * backtrace; 418 } AllocEntry; 419 420 uint8_t *info = NULL; 421 size_t overallSize = 0; 422 size_t infoSize = 0; 423 size_t totalMemory = 0; 424 size_t backtraceSize = 0; 425 426 get_malloc_leak_info(&info, &overallSize, &infoSize, &totalMemory, &backtraceSize); 427 if (info) { 428 uint8_t *ptr = info; 429 size_t count = overallSize / infoSize; 430 431 snprintf(buffer, SIZE, " Allocation count %i\n", count); 432 result.append(buffer); 433 snprintf(buffer, SIZE, " Total memory %i\n", totalMemory); 434 result.append(buffer); 435 436 AllocEntry * entries = new AllocEntry[count]; 437 438 for (size_t i = 0; i < count; i++) { 439 // Each entry should be size_t, size_t, intptr_t[backtraceSize] 440 AllocEntry *e = &entries[i]; 441 442 e->size = *reinterpret_cast<size_t *>(ptr); 443 ptr += sizeof(size_t); 444 445 e->dups = *reinterpret_cast<size_t *>(ptr); 446 ptr += sizeof(size_t); 447 448 e->backtrace = reinterpret_cast<intptr_t *>(ptr); 449 ptr += sizeof(intptr_t) * backtraceSize; 450 } 451 452 // Now we need to sort the entries. They come sorted by size but 453 // not by stack trace which causes problems using diff. 454 bool moved; 455 do { 456 moved = false; 457 for (size_t i = 0; i < (count - 1); i++) { 458 AllocEntry *e1 = &entries[i]; 459 AllocEntry *e2 = &entries[i+1]; 460 461 bool swap = e1->size < e2->size; 462 if (e1->size == e2->size) { 463 for(size_t j = 0; j < backtraceSize; j++) { 464 if (e1->backtrace[j] == e2->backtrace[j]) { 465 continue; 466 } 467 swap = e1->backtrace[j] < e2->backtrace[j]; 468 break; 469 } 470 } 471 if (swap) { 472 AllocEntry t = entries[i]; 473 entries[i] = entries[i+1]; 474 entries[i+1] = t; 475 moved = true; 476 } 477 } 478 } while (moved); 479 480 for (size_t i = 0; i < count; i++) { 481 AllocEntry *e = &entries[i]; 482 483 snprintf(buffer, SIZE, "size %8i, dup %4i, ", e->size, e->dups); 484 result.append(buffer); 485 for (size_t ct = 0; (ct < backtraceSize) && e->backtrace[ct]; ct++) { 486 if (ct) { 487 result.append(", "); 488 } 489 snprintf(buffer, SIZE, "0x%08x", e->backtrace[ct]); 490 result.append(buffer); 491 } 492 result.append("\n"); 493 } 494 495 delete[] entries; 496 free_malloc_leak_info(info); 497 } 498 499 write(fd, result.string(), result.size()); 500 } 501 #endif 502 503 status_t MediaPlayerService::dump(int fd, const Vector<String16>& args) 504 { 505 const size_t SIZE = 256; 506 char buffer[SIZE]; 507 String8 result; 508 if (checkCallingPermission(String16("android.permission.DUMP")) == false) { 509 snprintf(buffer, SIZE, "Permission Denial: " 510 "can't dump MediaPlayerService from pid=%d, uid=%d\n", 511 IPCThreadState::self()->getCallingPid(), 512 IPCThreadState::self()->getCallingUid()); 513 result.append(buffer); 514 } else { 515 Mutex::Autolock lock(mLock); 516 for (int i = 0, n = mClients.size(); i < n; ++i) { 517 sp<Client> c = mClients[i].promote(); 518 if (c != 0) c->dump(fd, args); 519 } 520 for (int i = 0, n = mMediaRecorderClients.size(); i < n; ++i) { 521 result.append(" MediaRecorderClient\n"); 522 sp<MediaRecorderClient> c = mMediaRecorderClients[i].promote(); 523 snprintf(buffer, 255, " pid(%d)\n\n", c->mPid); 524 result.append(buffer); 525 } 526 527 result.append(" Files opened and/or mapped:\n"); 528 snprintf(buffer, SIZE, "/proc/%d/maps", myTid()); 529 FILE *f = fopen(buffer, "r"); 530 if (f) { 531 while (!feof(f)) { 532 fgets(buffer, SIZE, f); 533 if (strstr(buffer, " /sdcard/") || 534 strstr(buffer, " /system/sounds/") || 535 strstr(buffer, " /system/media/")) { 536 result.append(" "); 537 result.append(buffer); 538 } 539 } 540 fclose(f); 541 } else { 542 result.append("couldn't open "); 543 result.append(buffer); 544 result.append("\n"); 545 } 546 547 snprintf(buffer, SIZE, "/proc/%d/fd", myTid()); 548 DIR *d = opendir(buffer); 549 if (d) { 550 struct dirent *ent; 551 while((ent = readdir(d)) != NULL) { 552 if (strcmp(ent->d_name,".") && strcmp(ent->d_name,"..")) { 553 snprintf(buffer, SIZE, "/proc/%d/fd/%s", myTid(), ent->d_name); 554 struct stat s; 555 if (lstat(buffer, &s) == 0) { 556 if ((s.st_mode & S_IFMT) == S_IFLNK) { 557 char linkto[256]; 558 int len = readlink(buffer, linkto, sizeof(linkto)); 559 if(len > 0) { 560 if(len > 255) { 561 linkto[252] = '.'; 562 linkto[253] = '.'; 563 linkto[254] = '.'; 564 linkto[255] = 0; 565 } else { 566 linkto[len] = 0; 567 } 568 if (strstr(linkto, "/sdcard/") == linkto || 569 strstr(linkto, "/system/sounds/") == linkto || 570 strstr(linkto, "/system/media/") == linkto) { 571 result.append(" "); 572 result.append(buffer); 573 result.append(" -> "); 574 result.append(linkto); 575 result.append("\n"); 576 } 577 } 578 } else { 579 result.append(" unexpected type for "); 580 result.append(buffer); 581 result.append("\n"); 582 } 583 } 584 } 585 } 586 closedir(d); 587 } else { 588 result.append("couldn't open "); 589 result.append(buffer); 590 result.append("\n"); 591 } 592 593 #if defined(__arm__) 594 bool dumpMem = false; 595 for (size_t i = 0; i < args.size(); i++) { 596 if (args[i] == String16("-m")) { 597 dumpMem = true; 598 } 599 } 600 if (dumpMem) { 601 memStatus(fd, args); 602 } 603 #endif 604 } 605 write(fd, result.string(), result.size()); 606 return NO_ERROR; 607 } 608 609 void MediaPlayerService::removeClient(wp<Client> client) 610 { 611 Mutex::Autolock lock(mLock); 612 mClients.remove(client); 613 } 614 615 MediaPlayerService::Client::Client(const sp<MediaPlayerService>& service, pid_t pid, 616 int32_t connId, const sp<IMediaPlayerClient>& client) 617 { 618 LOGV("Client(%d) constructor", connId); 619 mPid = pid; 620 mConnId = connId; 621 mService = service; 622 mClient = client; 623 mLoop = false; 624 mStatus = NO_INIT; 625 #if CALLBACK_ANTAGONIZER 626 LOGD("create Antagonizer"); 627 mAntagonizer = new Antagonizer(notify, this); 628 #endif 629 } 630 631 MediaPlayerService::Client::~Client() 632 { 633 LOGV("Client(%d) destructor pid = %d", mConnId, mPid); 634 mAudioOutput.clear(); 635 wp<Client> client(this); 636 disconnect(); 637 mService->removeClient(client); 638 } 639 640 void MediaPlayerService::Client::disconnect() 641 { 642 LOGV("disconnect(%d) from pid %d", mConnId, mPid); 643 // grab local reference and clear main reference to prevent future 644 // access to object 645 sp<MediaPlayerBase> p; 646 { 647 Mutex::Autolock l(mLock); 648 p = mPlayer; 649 } 650 mClient.clear(); 651 652 mPlayer.clear(); 653 654 // clear the notification to prevent callbacks to dead client 655 // and reset the player. We assume the player will serialize 656 // access to itself if necessary. 657 if (p != 0) { 658 p->setNotifyCallback(0, 0); 659 #if CALLBACK_ANTAGONIZER 660 LOGD("kill Antagonizer"); 661 mAntagonizer->kill(); 662 #endif 663 p->reset(); 664 } 665 666 IPCThreadState::self()->flushCommands(); 667 } 668 669 static player_type getDefaultPlayerType() { 670 #if BUILD_WITH_FULL_STAGEFRIGHT 671 char value[PROPERTY_VALUE_MAX]; 672 if (property_get("media.stagefright.enable-player", value, NULL) 673 && (!strcmp(value, "1") || !strcasecmp(value, "true"))) { 674 return STAGEFRIGHT_PLAYER; 675 } 676 #endif 677 678 return PV_PLAYER; 679 } 680 681 // By default we use the VORBIS_PLAYER for vorbis playback (duh!), 682 // but if the magic property is set we will use our new experimental 683 // stagefright code instead. 684 static player_type OverrideStagefrightForVorbis(player_type player) { 685 if (player != VORBIS_PLAYER) { 686 return player; 687 } 688 689 #if BUILD_WITH_FULL_STAGEFRIGHT 690 char value[PROPERTY_VALUE_MAX]; 691 if (property_get("media.stagefright.enable-vorbis", value, NULL) 692 && (!strcmp(value, "1") || !strcmp(value, "true"))) { 693 return STAGEFRIGHT_PLAYER; 694 } 695 #endif 696 697 return VORBIS_PLAYER; 698 } 699 700 701 player_type getPlayerType(int fd, int64_t offset, int64_t length) 702 { 703 char buf[20]; 704 lseek(fd, offset, SEEK_SET); 705 read(fd, buf, sizeof(buf)); 706 lseek(fd, offset, SEEK_SET); 707 708 long ident = *((long*)buf); 709 710 // Ogg vorbis? 711 if (ident == 0x5367674f) // 'OggS' 712 return OverrideStagefrightForVorbis(VORBIS_PLAYER); 713 714 #ifndef NO_OPENCORE 715 if (ident == 0x75b22630) { 716 // The magic number for .asf files, i.e. wmv and wma content. 717 // These are not currently supported through stagefright. 718 return PV_PLAYER; 719 } 720 #endif 721 722 // Some kind of MIDI? 723 EAS_DATA_HANDLE easdata; 724 if (EAS_Init(&easdata) == EAS_SUCCESS) { 725 EAS_FILE locator; 726 locator.path = NULL; 727 locator.fd = fd; 728 locator.offset = offset; 729 locator.length = length; 730 EAS_HANDLE eashandle; 731 if (EAS_OpenFile(easdata, &locator, &eashandle) == EAS_SUCCESS) { 732 EAS_CloseFile(easdata, eashandle); 733 EAS_Shutdown(easdata); 734 return SONIVOX_PLAYER; 735 } 736 EAS_Shutdown(easdata); 737 } 738 739 return getDefaultPlayerType(); 740 } 741 742 player_type getPlayerType(const char* url) 743 { 744 if (TestPlayerStub::canBeUsed(url)) { 745 return TEST_PLAYER; 746 } 747 748 bool useStagefrightForHTTP = false; 749 char value[PROPERTY_VALUE_MAX]; 750 if (property_get("media.stagefright.enable-http", value, NULL) 751 && (!strcmp(value, "1") || !strcasecmp(value, "true"))) { 752 useStagefrightForHTTP = true; 753 } 754 755 // use MidiFile for MIDI extensions 756 int lenURL = strlen(url); 757 for (int i = 0; i < NELEM(FILE_EXTS); ++i) { 758 int len = strlen(FILE_EXTS[i].extension); 759 int start = lenURL - len; 760 if (start > 0) { 761 if (!strncmp(url + start, FILE_EXTS[i].extension, len)) { 762 if (FILE_EXTS[i].playertype == VORBIS_PLAYER 763 && !strncasecmp(url, "http://", 7) 764 && useStagefrightForHTTP) { 765 return STAGEFRIGHT_PLAYER; 766 } 767 return OverrideStagefrightForVorbis(FILE_EXTS[i].playertype); 768 } 769 } 770 } 771 772 if (!strncasecmp(url, "http://", 7)) { 773 if (!useStagefrightForHTTP) { 774 return PV_PLAYER; 775 } 776 } 777 778 // Use PV_PLAYER for rtsp for now 779 if (!strncasecmp(url, "rtsp://", 7)) { 780 return PV_PLAYER; 781 } 782 783 return getDefaultPlayerType(); 784 } 785 786 static sp<MediaPlayerBase> createPlayer(player_type playerType, void* cookie, 787 notify_callback_f notifyFunc) 788 { 789 sp<MediaPlayerBase> p; 790 switch (playerType) { 791 #ifndef NO_OPENCORE 792 case PV_PLAYER: 793 LOGV(" create PVPlayer"); 794 p = new PVPlayer(); 795 break; 796 #endif 797 case SONIVOX_PLAYER: 798 LOGV(" create MidiFile"); 799 p = new MidiFile(); 800 break; 801 case VORBIS_PLAYER: 802 LOGV(" create VorbisPlayer"); 803 p = new VorbisPlayer(); 804 break; 805 #if BUILD_WITH_FULL_STAGEFRIGHT 806 case STAGEFRIGHT_PLAYER: 807 LOGV(" create StagefrightPlayer"); 808 p = new StagefrightPlayer; 809 break; 810 #endif 811 case TEST_PLAYER: 812 LOGV("Create Test Player stub"); 813 p = new TestPlayerStub(); 814 break; 815 } 816 if (p != NULL) { 817 if (p->initCheck() == NO_ERROR) { 818 p->setNotifyCallback(cookie, notifyFunc); 819 } else { 820 p.clear(); 821 } 822 } 823 if (p == NULL) { 824 LOGE("Failed to create player object"); 825 } 826 return p; 827 } 828 829 sp<MediaPlayerBase> MediaPlayerService::Client::createPlayer(player_type playerType) 830 { 831 // determine if we have the right player type 832 sp<MediaPlayerBase> p = mPlayer; 833 if ((p != NULL) && (p->playerType() != playerType)) { 834 LOGV("delete player"); 835 p.clear(); 836 } 837 if (p == NULL) { 838 p = android::createPlayer(playerType, this, notify); 839 } 840 return p; 841 } 842 843 status_t MediaPlayerService::Client::setDataSource( 844 const char *url, const KeyedVector<String8, String8> *headers) 845 { 846 LOGV("setDataSource(%s)", url); 847 if (url == NULL) 848 return UNKNOWN_ERROR; 849 850 if (strncmp(url, "content://", 10) == 0) { 851 // get a filedescriptor for the content Uri and 852 // pass it to the setDataSource(fd) method 853 854 String16 url16(url); 855 int fd = android::openContentProviderFile(url16); 856 if (fd < 0) 857 { 858 LOGE("Couldn't open fd for %s", url); 859 return UNKNOWN_ERROR; 860 } 861 setDataSource(fd, 0, 0x7fffffffffLL); // this sets mStatus 862 close(fd); 863 return mStatus; 864 } else { 865 player_type playerType = getPlayerType(url); 866 LOGV("player type = %d", playerType); 867 868 // create the right type of player 869 sp<MediaPlayerBase> p = createPlayer(playerType); 870 if (p == NULL) return NO_INIT; 871 872 if (!p->hardwareOutput()) { 873 mAudioOutput = new AudioOutput(); 874 static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput); 875 } 876 877 // now set data source 878 LOGV(" setDataSource"); 879 mStatus = p->setDataSource(url, headers); 880 if (mStatus == NO_ERROR) { 881 mPlayer = p; 882 } else { 883 LOGE(" error: %d", mStatus); 884 } 885 return mStatus; 886 } 887 } 888 889 status_t MediaPlayerService::Client::setDataSource(int fd, int64_t offset, int64_t length) 890 { 891 LOGV("setDataSource fd=%d, offset=%lld, length=%lld", fd, offset, length); 892 struct stat sb; 893 int ret = fstat(fd, &sb); 894 if (ret != 0) { 895 LOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno)); 896 return UNKNOWN_ERROR; 897 } 898 899 LOGV("st_dev = %llu", sb.st_dev); 900 LOGV("st_mode = %u", sb.st_mode); 901 LOGV("st_uid = %lu", sb.st_uid); 902 LOGV("st_gid = %lu", sb.st_gid); 903 LOGV("st_size = %llu", sb.st_size); 904 905 if (offset >= sb.st_size) { 906 LOGE("offset error"); 907 ::close(fd); 908 return UNKNOWN_ERROR; 909 } 910 if (offset + length > sb.st_size) { 911 length = sb.st_size - offset; 912 LOGV("calculated length = %lld", length); 913 } 914 915 player_type playerType = getPlayerType(fd, offset, length); 916 LOGV("player type = %d", playerType); 917 918 // create the right type of player 919 sp<MediaPlayerBase> p = createPlayer(playerType); 920 if (p == NULL) return NO_INIT; 921 922 if (!p->hardwareOutput()) { 923 mAudioOutput = new AudioOutput(); 924 static_cast<MediaPlayerInterface*>(p.get())->setAudioSink(mAudioOutput); 925 } 926 927 // now set data source 928 mStatus = p->setDataSource(fd, offset, length); 929 if (mStatus == NO_ERROR) mPlayer = p; 930 return mStatus; 931 } 932 933 status_t MediaPlayerService::Client::setVideoSurface(const sp<ISurface>& surface) 934 { 935 LOGV("[%d] setVideoSurface(%p)", mConnId, surface.get()); 936 sp<MediaPlayerBase> p = getPlayer(); 937 if (p == 0) return UNKNOWN_ERROR; 938 return p->setVideoSurface(surface); 939 } 940 941 status_t MediaPlayerService::Client::invoke(const Parcel& request, 942 Parcel *reply) 943 { 944 sp<MediaPlayerBase> p = getPlayer(); 945 if (p == NULL) return UNKNOWN_ERROR; 946 return p->invoke(request, reply); 947 } 948 949 // This call doesn't need to access the native player. 950 status_t MediaPlayerService::Client::setMetadataFilter(const Parcel& filter) 951 { 952 status_t status; 953 media::Metadata::Filter allow, drop; 954 955 if (unmarshallFilter(filter, &allow, &status) && 956 unmarshallFilter(filter, &drop, &status)) { 957 Mutex::Autolock lock(mLock); 958 959 mMetadataAllow = allow; 960 mMetadataDrop = drop; 961 } 962 return status; 963 } 964 965 status_t MediaPlayerService::Client::getMetadata( 966 bool update_only, bool apply_filter, Parcel *reply) 967 { 968 sp<MediaPlayerBase> player = getPlayer(); 969 if (player == 0) return UNKNOWN_ERROR; 970 971 status_t status; 972 // Placeholder for the return code, updated by the caller. 973 reply->writeInt32(-1); 974 975 media::Metadata::Filter ids; 976 977 // We don't block notifications while we fetch the data. We clear 978 // mMetadataUpdated first so we don't lose notifications happening 979 // during the rest of this call. 980 { 981 Mutex::Autolock lock(mLock); 982 if (update_only) { 983 ids = mMetadataUpdated; 984 } 985 mMetadataUpdated.clear(); 986 } 987 988 media::Metadata metadata(reply); 989 990 metadata.appendHeader(); 991 status = player->getMetadata(ids, reply); 992 993 if (status != OK) { 994 metadata.resetParcel(); 995 LOGE("getMetadata failed %d", status); 996 return status; 997 } 998 999 // FIXME: Implement filtering on the result. Not critical since 1000 // filtering takes place on the update notifications already. This 1001 // would be when all the metadata are fetch and a filter is set. 1002 1003 // Everything is fine, update the metadata length. 1004 metadata.updateLength(); 1005 return OK; 1006 } 1007 1008 status_t MediaPlayerService::Client::suspend() { 1009 sp<MediaPlayerBase> p = getPlayer(); 1010 if (p == 0) return UNKNOWN_ERROR; 1011 1012 return p->suspend(); 1013 } 1014 1015 status_t MediaPlayerService::Client::resume() { 1016 sp<MediaPlayerBase> p = getPlayer(); 1017 if (p == 0) return UNKNOWN_ERROR; 1018 1019 return p->resume(); 1020 } 1021 1022 status_t MediaPlayerService::Client::prepareAsync() 1023 { 1024 LOGV("[%d] prepareAsync", mConnId); 1025 sp<MediaPlayerBase> p = getPlayer(); 1026 if (p == 0) return UNKNOWN_ERROR; 1027 status_t ret = p->prepareAsync(); 1028 #if CALLBACK_ANTAGONIZER 1029 LOGD("start Antagonizer"); 1030 if (ret == NO_ERROR) mAntagonizer->start(); 1031 #endif 1032 return ret; 1033 } 1034 1035 status_t MediaPlayerService::Client::start() 1036 { 1037 LOGV("[%d] start", mConnId); 1038 sp<MediaPlayerBase> p = getPlayer(); 1039 if (p == 0) return UNKNOWN_ERROR; 1040 p->setLooping(mLoop); 1041 return p->start(); 1042 } 1043 1044 status_t MediaPlayerService::Client::stop() 1045 { 1046 LOGV("[%d] stop", mConnId); 1047 sp<MediaPlayerBase> p = getPlayer(); 1048 if (p == 0) return UNKNOWN_ERROR; 1049 return p->stop(); 1050 } 1051 1052 status_t MediaPlayerService::Client::pause() 1053 { 1054 LOGV("[%d] pause", mConnId); 1055 sp<MediaPlayerBase> p = getPlayer(); 1056 if (p == 0) return UNKNOWN_ERROR; 1057 return p->pause(); 1058 } 1059 1060 status_t MediaPlayerService::Client::isPlaying(bool* state) 1061 { 1062 *state = false; 1063 sp<MediaPlayerBase> p = getPlayer(); 1064 if (p == 0) return UNKNOWN_ERROR; 1065 *state = p->isPlaying(); 1066 LOGV("[%d] isPlaying: %d", mConnId, *state); 1067 return NO_ERROR; 1068 } 1069 1070 status_t MediaPlayerService::Client::getCurrentPosition(int *msec) 1071 { 1072 LOGV("getCurrentPosition"); 1073 sp<MediaPlayerBase> p = getPlayer(); 1074 if (p == 0) return UNKNOWN_ERROR; 1075 status_t ret = p->getCurrentPosition(msec); 1076 if (ret == NO_ERROR) { 1077 LOGV("[%d] getCurrentPosition = %d", mConnId, *msec); 1078 } else { 1079 LOGE("getCurrentPosition returned %d", ret); 1080 } 1081 return ret; 1082 } 1083 1084 status_t MediaPlayerService::Client::getDuration(int *msec) 1085 { 1086 LOGV("getDuration"); 1087 sp<MediaPlayerBase> p = getPlayer(); 1088 if (p == 0) return UNKNOWN_ERROR; 1089 status_t ret = p->getDuration(msec); 1090 if (ret == NO_ERROR) { 1091 LOGV("[%d] getDuration = %d", mConnId, *msec); 1092 } else { 1093 LOGE("getDuration returned %d", ret); 1094 } 1095 return ret; 1096 } 1097 1098 status_t MediaPlayerService::Client::seekTo(int msec) 1099 { 1100 LOGV("[%d] seekTo(%d)", mConnId, msec); 1101 sp<MediaPlayerBase> p = getPlayer(); 1102 if (p == 0) return UNKNOWN_ERROR; 1103 return p->seekTo(msec); 1104 } 1105 1106 status_t MediaPlayerService::Client::reset() 1107 { 1108 LOGV("[%d] reset", mConnId); 1109 sp<MediaPlayerBase> p = getPlayer(); 1110 if (p == 0) return UNKNOWN_ERROR; 1111 return p->reset(); 1112 } 1113 1114 status_t MediaPlayerService::Client::setAudioStreamType(int type) 1115 { 1116 LOGV("[%d] setAudioStreamType(%d)", mConnId, type); 1117 // TODO: for hardware output, call player instead 1118 Mutex::Autolock l(mLock); 1119 if (mAudioOutput != 0) mAudioOutput->setAudioStreamType(type); 1120 return NO_ERROR; 1121 } 1122 1123 status_t MediaPlayerService::Client::setLooping(int loop) 1124 { 1125 LOGV("[%d] setLooping(%d)", mConnId, loop); 1126 mLoop = loop; 1127 sp<MediaPlayerBase> p = getPlayer(); 1128 if (p != 0) return p->setLooping(loop); 1129 return NO_ERROR; 1130 } 1131 1132 status_t MediaPlayerService::Client::setVolume(float leftVolume, float rightVolume) 1133 { 1134 LOGV("[%d] setVolume(%f, %f)", mConnId, leftVolume, rightVolume); 1135 // TODO: for hardware output, call player instead 1136 Mutex::Autolock l(mLock); 1137 if (mAudioOutput != 0) mAudioOutput->setVolume(leftVolume, rightVolume); 1138 return NO_ERROR; 1139 } 1140 1141 1142 void MediaPlayerService::Client::notify(void* cookie, int msg, int ext1, int ext2) 1143 { 1144 Client* client = static_cast<Client*>(cookie); 1145 1146 if (MEDIA_INFO == msg && 1147 MEDIA_INFO_METADATA_UPDATE == ext1) { 1148 const media::Metadata::Type metadata_type = ext2; 1149 1150 if(client->shouldDropMetadata(metadata_type)) { 1151 return; 1152 } 1153 1154 // Update the list of metadata that have changed. getMetadata 1155 // also access mMetadataUpdated and clears it. 1156 client->addNewMetadataUpdate(metadata_type); 1157 } 1158 LOGV("[%d] notify (%p, %d, %d, %d)", client->mConnId, cookie, msg, ext1, ext2); 1159 client->mClient->notify(msg, ext1, ext2); 1160 } 1161 1162 1163 bool MediaPlayerService::Client::shouldDropMetadata(media::Metadata::Type code) const 1164 { 1165 Mutex::Autolock lock(mLock); 1166 1167 if (findMetadata(mMetadataDrop, code)) { 1168 return true; 1169 } 1170 1171 if (mMetadataAllow.isEmpty() || findMetadata(mMetadataAllow, code)) { 1172 return false; 1173 } else { 1174 return true; 1175 } 1176 } 1177 1178 1179 void MediaPlayerService::Client::addNewMetadataUpdate(media::Metadata::Type metadata_type) { 1180 Mutex::Autolock lock(mLock); 1181 if (mMetadataUpdated.indexOf(metadata_type) < 0) { 1182 mMetadataUpdated.add(metadata_type); 1183 } 1184 } 1185 1186 #if CALLBACK_ANTAGONIZER 1187 const int Antagonizer::interval = 10000; // 10 msecs 1188 1189 Antagonizer::Antagonizer(notify_callback_f cb, void* client) : 1190 mExit(false), mActive(false), mClient(client), mCb(cb) 1191 { 1192 createThread(callbackThread, this); 1193 } 1194 1195 void Antagonizer::kill() 1196 { 1197 Mutex::Autolock _l(mLock); 1198 mActive = false; 1199 mExit = true; 1200 mCondition.wait(mLock); 1201 } 1202 1203 int Antagonizer::callbackThread(void* user) 1204 { 1205 LOGD("Antagonizer started"); 1206 Antagonizer* p = reinterpret_cast<Antagonizer*>(user); 1207 while (!p->mExit) { 1208 if (p->mActive) { 1209 LOGV("send event"); 1210 p->mCb(p->mClient, 0, 0, 0); 1211 } 1212 usleep(interval); 1213 } 1214 Mutex::Autolock _l(p->mLock); 1215 p->mCondition.signal(); 1216 LOGD("Antagonizer stopped"); 1217 return 0; 1218 } 1219 #endif 1220 1221 static size_t kDefaultHeapSize = 1024 * 1024; // 1MB 1222 1223 sp<IMemory> MediaPlayerService::decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) 1224 { 1225 LOGV("decode(%s)", url); 1226 sp<MemoryBase> mem; 1227 sp<MediaPlayerBase> player; 1228 1229 // Protect our precious, precious DRMd ringtones by only allowing 1230 // decoding of http, but not filesystem paths or content Uris. 1231 // If the application wants to decode those, it should open a 1232 // filedescriptor for them and use that. 1233 if (url != NULL && strncmp(url, "http://", 7) != 0) { 1234 LOGD("Can't decode %s by path, use filedescriptor instead", url); 1235 return mem; 1236 } 1237 1238 player_type playerType = getPlayerType(url); 1239 LOGV("player type = %d", playerType); 1240 1241 // create the right type of player 1242 sp<AudioCache> cache = new AudioCache(url); 1243 player = android::createPlayer(playerType, cache.get(), cache->notify); 1244 if (player == NULL) goto Exit; 1245 if (player->hardwareOutput()) goto Exit; 1246 1247 static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache); 1248 1249 // set data source 1250 if (player->setDataSource(url) != NO_ERROR) goto Exit; 1251 1252 LOGV("prepare"); 1253 player->prepareAsync(); 1254 1255 LOGV("wait for prepare"); 1256 if (cache->wait() != NO_ERROR) goto Exit; 1257 1258 LOGV("start"); 1259 player->start(); 1260 1261 LOGV("wait for playback complete"); 1262 if (cache->wait() != NO_ERROR) goto Exit; 1263 1264 mem = new MemoryBase(cache->getHeap(), 0, cache->size()); 1265 *pSampleRate = cache->sampleRate(); 1266 *pNumChannels = cache->channelCount(); 1267 *pFormat = cache->format(); 1268 LOGV("return memory @ %p, sampleRate=%u, channelCount = %d, format = %d", mem->pointer(), *pSampleRate, *pNumChannels, *pFormat); 1269 1270 Exit: 1271 if (player != 0) player->reset(); 1272 return mem; 1273 } 1274 1275 sp<IMemory> MediaPlayerService::decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) 1276 { 1277 LOGV("decode(%d, %lld, %lld)", fd, offset, length); 1278 sp<MemoryBase> mem; 1279 sp<MediaPlayerBase> player; 1280 1281 player_type playerType = getPlayerType(fd, offset, length); 1282 LOGV("player type = %d", playerType); 1283 1284 // create the right type of player 1285 sp<AudioCache> cache = new AudioCache("decode_fd"); 1286 player = android::createPlayer(playerType, cache.get(), cache->notify); 1287 if (player == NULL) goto Exit; 1288 if (player->hardwareOutput()) goto Exit; 1289 1290 static_cast<MediaPlayerInterface*>(player.get())->setAudioSink(cache); 1291 1292 // set data source 1293 if (player->setDataSource(fd, offset, length) != NO_ERROR) goto Exit; 1294 1295 LOGV("prepare"); 1296 player->prepareAsync(); 1297 1298 LOGV("wait for prepare"); 1299 if (cache->wait() != NO_ERROR) goto Exit; 1300 1301 LOGV("start"); 1302 player->start(); 1303 1304 LOGV("wait for playback complete"); 1305 if (cache->wait() != NO_ERROR) goto Exit; 1306 1307 mem = new MemoryBase(cache->getHeap(), 0, cache->size()); 1308 *pSampleRate = cache->sampleRate(); 1309 *pNumChannels = cache->channelCount(); 1310 *pFormat = cache->format(); 1311 LOGV("return memory @ %p, sampleRate=%u, channelCount = %d, format = %d", mem->pointer(), *pSampleRate, *pNumChannels, *pFormat); 1312 1313 Exit: 1314 if (player != 0) player->reset(); 1315 ::close(fd); 1316 return mem; 1317 } 1318 1319 /* 1320 * Avert your eyes, ugly hack ahead. 1321 * The following is to support music visualizations. 1322 */ 1323 1324 static const int NUMVIZBUF = 32; 1325 static const int VIZBUFFRAMES = 1024; 1326 static const int BUFTIMEMSEC = NUMVIZBUF * VIZBUFFRAMES * 1000 / 44100; 1327 static const int TOTALBUFTIMEMSEC = NUMVIZBUF * BUFTIMEMSEC; 1328 1329 static bool gotMem = false; 1330 static sp<MemoryHeapBase> heap; 1331 static sp<MemoryBase> mem[NUMVIZBUF]; 1332 static uint64_t endTime; 1333 static uint64_t lastReadTime; 1334 static uint64_t lastWriteTime; 1335 static int writeIdx = 0; 1336 1337 static void allocVizBufs() { 1338 if (!gotMem) { 1339 heap = new MemoryHeapBase(NUMVIZBUF * VIZBUFFRAMES * 2, 0, "snooper"); 1340 for (int i=0;i<NUMVIZBUF;i++) { 1341 mem[i] = new MemoryBase(heap, VIZBUFFRAMES * 2 * i, VIZBUFFRAMES * 2); 1342 } 1343 endTime = 0; 1344 gotMem = true; 1345 } 1346 } 1347 1348 1349 /* 1350 * Get a buffer of audio data that is about to be played. 1351 * We don't synchronize this because in practice the writer 1352 * is ahead of the reader, and even if we did happen to catch 1353 * a buffer while it's being written, it's just a visualization, 1354 * so no harm done. 1355 */ 1356 static sp<MemoryBase> getVizBuffer() { 1357 1358 allocVizBufs(); 1359 1360 lastReadTime = uptimeMillis(); 1361 1362 // if there is no recent buffer (yet), just return empty handed 1363 if (lastWriteTime + TOTALBUFTIMEMSEC < lastReadTime) { 1364 //LOGI("@@@@ no audio data to look at yet: %d + %d < %d", (int)lastWriteTime, TOTALBUFTIMEMSEC, (int)lastReadTime); 1365 return NULL; 1366 } 1367 1368 int timedelta = endTime - lastReadTime; 1369 if (timedelta < 0) timedelta = 0; 1370 int framedelta = timedelta * 44100 / 1000; 1371 int headIdx = (writeIdx - framedelta) / VIZBUFFRAMES - 1; 1372 while (headIdx < 0) { 1373 headIdx += NUMVIZBUF; 1374 } 1375 return mem[headIdx]; 1376 } 1377 1378 // Append the data to the vizualization buffer 1379 static void makeVizBuffers(const char *data, int len, uint64_t time) { 1380 1381 allocVizBufs(); 1382 1383 uint64_t startTime = time; 1384 const int frameSize = 4; // 16 bit stereo sample is 4 bytes 1385 int offset = writeIdx; 1386 int maxoff = heap->getSize() / 2; // in shorts 1387 short *base = (short*)heap->getBase(); 1388 short *src = (short*)data; 1389 while (len > 0) { 1390 1391 // Degrade quality by mixing to mono and clearing the lowest 3 bits. 1392 // This should still be good enough for a visualization 1393 base[offset++] = ((int(src[0]) + int(src[1])) >> 1) & ~0x7; 1394 src += 2; 1395 len -= frameSize; 1396 if (offset >= maxoff) { 1397 offset = 0; 1398 } 1399 } 1400 writeIdx = offset; 1401 endTime = time + (len / frameSize) / 44; 1402 //LOGI("@@@ stored buffers from %d to %d", uint32_t(startTime), uint32_t(time)); 1403 } 1404 1405 sp<IMemory> MediaPlayerService::snoop() 1406 { 1407 sp<MemoryBase> mem = getVizBuffer(); 1408 return mem; 1409 } 1410 1411 1412 #undef LOG_TAG 1413 #define LOG_TAG "AudioSink" 1414 MediaPlayerService::AudioOutput::AudioOutput() 1415 : mCallback(NULL), 1416 mCallbackCookie(NULL) { 1417 mTrack = 0; 1418 mStreamType = AudioSystem::MUSIC; 1419 mLeftVolume = 1.0; 1420 mRightVolume = 1.0; 1421 mLatency = 0; 1422 mMsecsPerFrame = 0; 1423 mNumFramesWritten = 0; 1424 setMinBufferCount(); 1425 } 1426 1427 MediaPlayerService::AudioOutput::~AudioOutput() 1428 { 1429 close(); 1430 } 1431 1432 void MediaPlayerService::AudioOutput::setMinBufferCount() 1433 { 1434 char value[PROPERTY_VALUE_MAX]; 1435 if (property_get("ro.kernel.qemu", value, 0)) { 1436 mIsOnEmulator = true; 1437 mMinBufferCount = 12; // to prevent systematic buffer underrun for emulator 1438 } 1439 } 1440 1441 bool MediaPlayerService::AudioOutput::isOnEmulator() 1442 { 1443 setMinBufferCount(); 1444 return mIsOnEmulator; 1445 } 1446 1447 int MediaPlayerService::AudioOutput::getMinBufferCount() 1448 { 1449 setMinBufferCount(); 1450 return mMinBufferCount; 1451 } 1452 1453 ssize_t MediaPlayerService::AudioOutput::bufferSize() const 1454 { 1455 if (mTrack == 0) return NO_INIT; 1456 return mTrack->frameCount() * frameSize(); 1457 } 1458 1459 ssize_t MediaPlayerService::AudioOutput::frameCount() const 1460 { 1461 if (mTrack == 0) return NO_INIT; 1462 return mTrack->frameCount(); 1463 } 1464 1465 ssize_t MediaPlayerService::AudioOutput::channelCount() const 1466 { 1467 if (mTrack == 0) return NO_INIT; 1468 return mTrack->channelCount(); 1469 } 1470 1471 ssize_t MediaPlayerService::AudioOutput::frameSize() const 1472 { 1473 if (mTrack == 0) return NO_INIT; 1474 return mTrack->frameSize(); 1475 } 1476 1477 uint32_t MediaPlayerService::AudioOutput::latency () const 1478 { 1479 return mLatency; 1480 } 1481 1482 float MediaPlayerService::AudioOutput::msecsPerFrame() const 1483 { 1484 return mMsecsPerFrame; 1485 } 1486 1487 status_t MediaPlayerService::AudioOutput::getPosition(uint32_t *position) 1488 { 1489 if (mTrack == 0) return NO_INIT; 1490 return mTrack->getPosition(position); 1491 } 1492 1493 status_t MediaPlayerService::AudioOutput::open( 1494 uint32_t sampleRate, int channelCount, int format, int bufferCount, 1495 AudioCallback cb, void *cookie) 1496 { 1497 mCallback = cb; 1498 mCallbackCookie = cookie; 1499 1500 // Check argument "bufferCount" against the mininum buffer count 1501 if (bufferCount < mMinBufferCount) { 1502 LOGD("bufferCount (%d) is too small and increased to %d", bufferCount, mMinBufferCount); 1503 bufferCount = mMinBufferCount; 1504 1505 } 1506 LOGV("open(%u, %d, %d, %d)", sampleRate, channelCount, format, bufferCount); 1507 if (mTrack) close(); 1508 int afSampleRate; 1509 int afFrameCount; 1510 int frameCount; 1511 1512 if (AudioSystem::getOutputFrameCount(&afFrameCount, mStreamType) != NO_ERROR) { 1513 return NO_INIT; 1514 } 1515 if (AudioSystem::getOutputSamplingRate(&afSampleRate, mStreamType) != NO_ERROR) { 1516 return NO_INIT; 1517 } 1518 1519 frameCount = (sampleRate*afFrameCount*bufferCount)/afSampleRate; 1520 1521 AudioTrack *t; 1522 if (mCallback != NULL) { 1523 t = new AudioTrack( 1524 mStreamType, 1525 sampleRate, 1526 format, 1527 (channelCount == 2) ? AudioSystem::CHANNEL_OUT_STEREO : AudioSystem::CHANNEL_OUT_MONO, 1528 frameCount, 1529 0 /* flags */, 1530 CallbackWrapper, 1531 this); 1532 } else { 1533 t = new AudioTrack( 1534 mStreamType, 1535 sampleRate, 1536 format, 1537 (channelCount == 2) ? AudioSystem::CHANNEL_OUT_STEREO : AudioSystem::CHANNEL_OUT_MONO, 1538 frameCount); 1539 } 1540 1541 if ((t == 0) || (t->initCheck() != NO_ERROR)) { 1542 LOGE("Unable to create audio track"); 1543 delete t; 1544 return NO_INIT; 1545 } 1546 1547 LOGV("setVolume"); 1548 t->setVolume(mLeftVolume, mRightVolume); 1549 mMsecsPerFrame = 1.e3 / (float) sampleRate; 1550 mLatency = t->latency(); 1551 mTrack = t; 1552 return NO_ERROR; 1553 } 1554 1555 void MediaPlayerService::AudioOutput::start() 1556 { 1557 LOGV("start"); 1558 if (mTrack) { 1559 mTrack->setVolume(mLeftVolume, mRightVolume); 1560 mTrack->start(); 1561 mTrack->getPosition(&mNumFramesWritten); 1562 } 1563 } 1564 1565 void MediaPlayerService::AudioOutput::snoopWrite(const void* buffer, size_t size) { 1566 // Only make visualization buffers if anyone recently requested visualization data 1567 uint64_t now = uptimeMillis(); 1568 if (lastReadTime + TOTALBUFTIMEMSEC >= now) { 1569 // Based on the current play counter, the number of frames written and 1570 // the current real time we can calculate the approximate real start 1571 // time of the buffer we're about to write. 1572 uint32_t pos; 1573 mTrack->getPosition(&pos); 1574 1575 // we're writing ahead by this many frames: 1576 int ahead = mNumFramesWritten - pos; 1577 //LOGI("@@@ written: %d, playpos: %d, latency: %d", mNumFramesWritten, pos, mTrack->latency()); 1578 // which is this many milliseconds, assuming 44100 Hz: 1579 ahead /= 44; 1580 1581 makeVizBuffers((const char*)buffer, size, now + ahead + mTrack->latency()); 1582 lastWriteTime = now; 1583 } 1584 } 1585 1586 1587 ssize_t MediaPlayerService::AudioOutput::write(const void* buffer, size_t size) 1588 { 1589 LOG_FATAL_IF(mCallback != NULL, "Don't call write if supplying a callback."); 1590 1591 //LOGV("write(%p, %u)", buffer, size); 1592 if (mTrack) { 1593 snoopWrite(buffer, size); 1594 ssize_t ret = mTrack->write(buffer, size); 1595 mNumFramesWritten += ret / 4; // assume 16 bit stereo 1596 return ret; 1597 } 1598 return NO_INIT; 1599 } 1600 1601 void MediaPlayerService::AudioOutput::stop() 1602 { 1603 LOGV("stop"); 1604 if (mTrack) mTrack->stop(); 1605 lastWriteTime = 0; 1606 } 1607 1608 void MediaPlayerService::AudioOutput::flush() 1609 { 1610 LOGV("flush"); 1611 if (mTrack) mTrack->flush(); 1612 } 1613 1614 void MediaPlayerService::AudioOutput::pause() 1615 { 1616 LOGV("pause"); 1617 if (mTrack) mTrack->pause(); 1618 lastWriteTime = 0; 1619 } 1620 1621 void MediaPlayerService::AudioOutput::close() 1622 { 1623 LOGV("close"); 1624 delete mTrack; 1625 mTrack = 0; 1626 } 1627 1628 void MediaPlayerService::AudioOutput::setVolume(float left, float right) 1629 { 1630 LOGV("setVolume(%f, %f)", left, right); 1631 mLeftVolume = left; 1632 mRightVolume = right; 1633 if (mTrack) { 1634 mTrack->setVolume(left, right); 1635 } 1636 } 1637 1638 // static 1639 void MediaPlayerService::AudioOutput::CallbackWrapper( 1640 int event, void *cookie, void *info) { 1641 //LOGV("callbackwrapper"); 1642 if (event != AudioTrack::EVENT_MORE_DATA) { 1643 return; 1644 } 1645 1646 AudioOutput *me = (AudioOutput *)cookie; 1647 AudioTrack::Buffer *buffer = (AudioTrack::Buffer *)info; 1648 1649 size_t actualSize = (*me->mCallback)( 1650 me, buffer->raw, buffer->size, me->mCallbackCookie); 1651 1652 buffer->size = actualSize; 1653 1654 if (actualSize > 0) { 1655 me->snoopWrite(buffer->raw, actualSize); 1656 } 1657 } 1658 1659 #undef LOG_TAG 1660 #define LOG_TAG "AudioCache" 1661 MediaPlayerService::AudioCache::AudioCache(const char* name) : 1662 mChannelCount(0), mFrameCount(1024), mSampleRate(0), mSize(0), 1663 mError(NO_ERROR), mCommandComplete(false) 1664 { 1665 // create ashmem heap 1666 mHeap = new MemoryHeapBase(kDefaultHeapSize, 0, name); 1667 } 1668 1669 uint32_t MediaPlayerService::AudioCache::latency () const 1670 { 1671 return 0; 1672 } 1673 1674 float MediaPlayerService::AudioCache::msecsPerFrame() const 1675 { 1676 return mMsecsPerFrame; 1677 } 1678 1679 status_t MediaPlayerService::AudioCache::getPosition(uint32_t *position) 1680 { 1681 if (position == 0) return BAD_VALUE; 1682 *position = mSize; 1683 return NO_ERROR; 1684 } 1685 1686 //////////////////////////////////////////////////////////////////////////////// 1687 1688 struct CallbackThread : public Thread { 1689 CallbackThread(const wp<MediaPlayerBase::AudioSink> &sink, 1690 MediaPlayerBase::AudioSink::AudioCallback cb, 1691 void *cookie); 1692 1693 protected: 1694 virtual ~CallbackThread(); 1695 1696 virtual bool threadLoop(); 1697 1698 private: 1699 wp<MediaPlayerBase::AudioSink> mSink; 1700 MediaPlayerBase::AudioSink::AudioCallback mCallback; 1701 void *mCookie; 1702 void *mBuffer; 1703 size_t mBufferSize; 1704 1705 CallbackThread(const CallbackThread &); 1706 CallbackThread &operator=(const CallbackThread &); 1707 }; 1708 1709 CallbackThread::CallbackThread( 1710 const wp<MediaPlayerBase::AudioSink> &sink, 1711 MediaPlayerBase::AudioSink::AudioCallback cb, 1712 void *cookie) 1713 : mSink(sink), 1714 mCallback(cb), 1715 mCookie(cookie), 1716 mBuffer(NULL), 1717 mBufferSize(0) { 1718 } 1719 1720 CallbackThread::~CallbackThread() { 1721 if (mBuffer) { 1722 free(mBuffer); 1723 mBuffer = NULL; 1724 } 1725 } 1726 1727 bool CallbackThread::threadLoop() { 1728 sp<MediaPlayerBase::AudioSink> sink = mSink.promote(); 1729 if (sink == NULL) { 1730 return false; 1731 } 1732 1733 if (mBuffer == NULL) { 1734 mBufferSize = sink->bufferSize(); 1735 mBuffer = malloc(mBufferSize); 1736 } 1737 1738 size_t actualSize = 1739 (*mCallback)(sink.get(), mBuffer, mBufferSize, mCookie); 1740 1741 if (actualSize > 0) { 1742 sink->write(mBuffer, actualSize); 1743 } 1744 1745 return true; 1746 } 1747 1748 //////////////////////////////////////////////////////////////////////////////// 1749 1750 status_t MediaPlayerService::AudioCache::open( 1751 uint32_t sampleRate, int channelCount, int format, int bufferCount, 1752 AudioCallback cb, void *cookie) 1753 { 1754 LOGV("open(%u, %d, %d, %d)", sampleRate, channelCount, format, bufferCount); 1755 if (mHeap->getHeapID() < 0) { 1756 return NO_INIT; 1757 } 1758 1759 mSampleRate = sampleRate; 1760 mChannelCount = (uint16_t)channelCount; 1761 mFormat = (uint16_t)format; 1762 mMsecsPerFrame = 1.e3 / (float) sampleRate; 1763 1764 if (cb != NULL) { 1765 mCallbackThread = new CallbackThread(this, cb, cookie); 1766 } 1767 return NO_ERROR; 1768 } 1769 1770 void MediaPlayerService::AudioCache::start() { 1771 if (mCallbackThread != NULL) { 1772 mCallbackThread->run("AudioCache callback"); 1773 } 1774 } 1775 1776 void MediaPlayerService::AudioCache::stop() { 1777 if (mCallbackThread != NULL) { 1778 mCallbackThread->requestExitAndWait(); 1779 } 1780 } 1781 1782 ssize_t MediaPlayerService::AudioCache::write(const void* buffer, size_t size) 1783 { 1784 LOGV("write(%p, %u)", buffer, size); 1785 if ((buffer == 0) || (size == 0)) return size; 1786 1787 uint8_t* p = static_cast<uint8_t*>(mHeap->getBase()); 1788 if (p == NULL) return NO_INIT; 1789 p += mSize; 1790 LOGV("memcpy(%p, %p, %u)", p, buffer, size); 1791 if (mSize + size > mHeap->getSize()) { 1792 LOGE("Heap size overflow! req size: %d, max size: %d", (mSize + size), mHeap->getSize()); 1793 size = mHeap->getSize() - mSize; 1794 } 1795 memcpy(p, buffer, size); 1796 mSize += size; 1797 return size; 1798 } 1799 1800 // call with lock held 1801 status_t MediaPlayerService::AudioCache::wait() 1802 { 1803 Mutex::Autolock lock(mLock); 1804 while (!mCommandComplete) { 1805 mSignal.wait(mLock); 1806 } 1807 mCommandComplete = false; 1808 1809 if (mError == NO_ERROR) { 1810 LOGV("wait - success"); 1811 } else { 1812 LOGV("wait - error"); 1813 } 1814 return mError; 1815 } 1816 1817 void MediaPlayerService::AudioCache::notify(void* cookie, int msg, int ext1, int ext2) 1818 { 1819 LOGV("notify(%p, %d, %d, %d)", cookie, msg, ext1, ext2); 1820 AudioCache* p = static_cast<AudioCache*>(cookie); 1821 1822 // ignore buffering messages 1823 switch (msg) 1824 { 1825 case MEDIA_ERROR: 1826 LOGE("Error %d, %d occurred", ext1, ext2); 1827 p->mError = ext1; 1828 break; 1829 case MEDIA_PREPARED: 1830 LOGV("prepared"); 1831 break; 1832 case MEDIA_PLAYBACK_COMPLETE: 1833 LOGV("playback complete"); 1834 break; 1835 default: 1836 LOGV("ignored"); 1837 return; 1838 } 1839 1840 // wake up thread 1841 Mutex::Autolock lock(p->mLock); 1842 p->mCommandComplete = true; 1843 p->mSignal.signal(); 1844 } 1845 1846 } // namespace android 1847