status_t MetadataRetrieverClient::setDataSource(
const sp<IMediaHTTPService> &httpService,
const char *url,
const KeyedVector<String8, String8> *headers)
{
ALOGV("setDataSource(%s)", url);
Mutex::Autolock lock(mLock);
if (url == NULL) {
return UNKNOWN_ERROR;
}
// When asking the MediaPlayerFactory subsystem to choose a media player for
// a given URL, a pointer to an outer IMediaPlayer can be passed to the
// factory system to be taken into consideration along with the URL. In the
// case of choosing an instance of a MediaPlayerBase for a
// MetadataRetrieverClient, there is no outer IMediaPlayer which will
// eventually encapsulate the result of this selection. In this case, just
// pass NULL to getPlayerType to indicate that there is no outer
// IMediaPlayer to consider during selection.
player_type playerType =
MediaPlayerFactory::getPlayerType(NULL /* client */, url);
ALOGV("player type = %d", playerType);
sp<MediaMetadataRetrieverBase> p = createRetriever(playerType);
if (p == NULL) return NO_INIT;
status_t ret = p->setDataSource(httpService, url, headers);
if (ret == NO_ERROR) mRetriever = p;
return ret;
}
status_t MetadataRetrieverClient::setDataSource(
const char *url, const KeyedVector<String8, String8> *headers)
{
ALOGV("setDataSource(%s)", url);
Mutex::Autolock lock(mLock);
if (url == NULL) {
return UNKNOWN_ERROR;
}
MediaPlayerService::mGetPlayerTypeLock.lock();
LOGI("metadata retriever: get player type locked!!\n");
MediaPlayerFactory::IFactory::setPlayerType(STAGEFRIGHT_PLAYER);
player_type playerType = MediaPlayerFactory::getPlayerType(NULL /* client */, url);
MediaPlayerService::mGetPlayerTypeLock.unlock();
LOGI("metadata retriever: get player type unlocked!!\n");
#ifdef CC_SUPPORT_TV_STAGEFRIGHT //Change from java for AOSP
//MTK Begin PIC:Guanghui.Wang
//Already check null point if (headers)
if (headers)
{
ssize_t index2=0;
String8 value;
int ret=0;
mUriHeaders = *headers;
//Retriever-Player
index2 = mUriHeaders.indexOfKey(String8(k_Retriever_PlayerType));
ALOGD("MediaPlayerService::assign-Retriever-Player\n");
if (index2 >= 0) {
value = mUriHeaders.valueAt(index2);
ALOGD("MediaPlayerService::assign-Retriever-Player %s\n",value.string());
if(!strcasecmp(value.string(),"CMPB_PLAYER"))
{
playerType = CMPB_PLAYER; //use cmpb player
}
}
}
LOGI("MetadataRetrieverClient player type = %d", playerType);
//MTK END
#endif
sp<MediaMetadataRetrieverBase> p = createRetriever(playerType);
if (p == NULL) return NO_INIT;
status_t ret = p->setDataSource(url, headers);
if (ret == NO_ERROR) mRetriever = p;
return ret;
}
status_t MetadataRetrieverClient::setDataSource(const char *url)
{
LOGV("setDataSource(%s)", url);
Mutex::Autolock lock(mLock);
if (url == NULL) {
return UNKNOWN_ERROR;
}
player_type playerType = getPlayerType(url);
LOGV("player type = %d", playerType);
sp<MediaMetadataRetrieverBase> p = createRetriever(playerType);
if (p == NULL) return NO_INIT;
status_t ret = p->setDataSource(url);
if (ret == NO_ERROR) mRetriever = p;
return ret;
}
status_t MetadataRetrieverClient::setDataSource(
const sp<IDataSource>& source, const char *mime)
{
ALOGV("setDataSource(IDataSource)");
Mutex::Autolock lock(mLock);
sp<DataSource> dataSource = DataSource::CreateFromIDataSource(source);
player_type playerType =
MediaPlayerFactory::getPlayerType(NULL /* client */, dataSource);
ALOGV("player type = %d", playerType);
sp<MediaMetadataRetrieverBase> p = createRetriever(playerType);
if (p == NULL) return NO_INIT;
status_t ret = p->setDataSource(dataSource, mime);
if (ret == NO_ERROR) mRetriever = p;
return ret;
}
status_t MetadataRetrieverClient::setDataSource(int fd, int64_t offset, int64_t length)
{
ALOGV("setDataSource fd=%d, offset=%lld, length=%lld", fd, offset, length);
Mutex::Autolock lock(mLock);
struct stat sb;
int ret = fstat(fd, &sb);
if (ret != 0) {
ALOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
return BAD_VALUE;
}
ALOGV("st_dev = %llu", sb.st_dev);
ALOGV("st_mode = %u", sb.st_mode);
ALOGV("st_uid = %lu", sb.st_uid);
ALOGV("st_gid = %lu", sb.st_gid);
ALOGV("st_size = %llu", sb.st_size);
if (offset >= sb.st_size) {
ALOGE("offset (%lld) bigger than file size (%llu)", offset, sb.st_size);
::close(fd);
return BAD_VALUE;
}
if (offset + length > sb.st_size) {
length = sb.st_size - offset;
ALOGV("calculated length = %lld", length);
}
MediaPlayerService::mGetPlayerTypeLock.lock();
LOGI("metadata retriever: get player type locked!!\n");
MediaPlayerFactory::IFactory::setPlayerType(STAGEFRIGHT_PLAYER);
player_type playerType = MediaPlayerFactory::getPlayerType(NULL /* client */,
fd,
offset,
length);
LOGI("MetadataRetrieverClient player type = %d", playerType);
MediaPlayerService::mGetPlayerTypeLock.unlock();
LOGI("metadata retriever: get player type unlocked!!\n");
//MTK END
sp<MediaMetadataRetrieverBase> p = createRetriever(playerType);
if (p == NULL) {
::close(fd);
return NO_INIT;
}
status_t status = p->setDataSource(fd, offset, length);
if (status == NO_ERROR) mRetriever = p;
::close(fd);
return status;
}
status_t MetadataRetrieverClient::setDataSource(int fd, int64_t offset, int64_t length)
{
ALOGV("setDataSource fd=%d, offset=%" PRId64 ", length=%" PRId64 "", fd, offset, length);
Mutex::Autolock lock(mLock);
struct stat sb;
int ret = fstat(fd, &sb);
if (ret != 0) {
ALOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
return BAD_VALUE;
}
ALOGV("st_dev = %" PRIu64 "", static_cast<uint64_t>(sb.st_dev));
ALOGV("st_mode = %u", sb.st_mode);
ALOGV("st_uid = %lu", static_cast<unsigned long>(sb.st_uid));
ALOGV("st_gid = %lu", static_cast<unsigned long>(sb.st_gid));
ALOGV("st_size = %" PRIu64 "", sb.st_size);
if (offset >= sb.st_size) {
ALOGE("offset (%" PRId64 ") bigger than file size (%" PRIu64 ")", offset, sb.st_size);
::close(fd);
return BAD_VALUE;
}
if (offset + length > sb.st_size) {
length = sb.st_size - offset;
ALOGV("calculated length = %" PRId64 "", length);
}
player_type playerType =
MediaPlayerFactory::getPlayerType(NULL /* client */,
fd,
offset,
length);
ALOGV("player type = %d", playerType);
sp<MediaMetadataRetrieverBase> p = createRetriever(playerType);
if (p == NULL) {
::close(fd);
return NO_INIT;
}
status_t status = p->setDataSource(fd, offset, length);
if (status == NO_ERROR) mRetriever = p;
::close(fd);
return status;
}
status_t MetadataRetrieverClient::setDataSource(int fd, int64_t offset, int64_t length)
{
LOGV("setDataSource fd=%d, offset=%lld, length=%lld", fd, offset, length);
Mutex::Autolock lock(mLock);
struct stat sb;
int ret = fstat(fd, &sb);
if (ret != 0) {
LOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
return BAD_VALUE;
}
LOGV("st_dev = %llu", sb.st_dev);
LOGV("st_mode = %u", sb.st_mode);
LOGV("st_uid = %lu", sb.st_uid);
LOGV("st_gid = %lu", sb.st_gid);
LOGV("st_size = %llu", sb.st_size);
if (offset >= sb.st_size) {
LOGE("offset (%lld) bigger than file size (%llu)", offset, sb.st_size);
::close(fd);
return BAD_VALUE;
}
if (offset + length > sb.st_size) {
length = sb.st_size - offset;
LOGV("calculated length = %lld", length);
}
player_type playerType = getPlayerType(fd, offset, length);
LOGV("player type = %d", playerType);
sp<MediaMetadataRetrieverBase> p = createRetriever(playerType);
if (p == NULL) {
::close(fd);
return NO_INIT;
}
status_t status = p->setMode(mMode);
if (status == NO_ERROR) {
p->setDataSource(fd, offset, length);
}
if (status == NO_ERROR) mRetriever = p;
::close(fd);
return status;
}
