MetadataRetrieverClient.cpp revision 0e8928bf4f2b01b783f6da97d15e8f1abb0fd7d7 
1/*
2**
3** Copyright (C) 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//#define LOG_NDEBUG 0
19#define LOG_TAG "MetadataRetrieverClient"
20#include <utils/Log.h>
21
22#include <sys/types.h>
23#include <sys/stat.h>
24#include <dirent.h>
25#include <unistd.h>
26
27#include <string.h>
28#include <cutils/atomic.h>
29#include <cutils/properties.h>
30#include <binder/MemoryBase.h>
31#include <binder/MemoryHeapBase.h>
32#include <binder/IPCThreadState.h>
33#include <binder/IServiceManager.h>
34#include <media/IMediaHTTPService.h>
35#include <media/MediaMetadataRetrieverInterface.h>
36#include <media/MediaPlayerInterface.h>
37#include <private/media/VideoFrame.h>
38#include "MetadataRetrieverClient.h"
39#include "StagefrightMetadataRetriever.h"
40#include "MediaPlayerFactory.h"
41
42namespace android {
43
44MetadataRetrieverClient::MetadataRetrieverClient(pid_t pid)
45{
46    ALOGV("MetadataRetrieverClient constructor pid(%d)", pid);
47    mPid = pid;
48    mThumbnail = NULL;
49    mAlbumArt = NULL;
50    mRetriever = NULL;
51}
52
53MetadataRetrieverClient::~MetadataRetrieverClient()
54{
55    ALOGV("MetadataRetrieverClient destructor");
56    disconnect();
57}
58
59status_t MetadataRetrieverClient::dump(int fd, const Vector<String16>& /*args*/) const
60{
61    const size_t SIZE = 256;
62    char buffer[SIZE];
63    String8 result;
64    result.append(" MetadataRetrieverClient\n");
65    snprintf(buffer, 255, "  pid(%d)\n", mPid);
66    result.append(buffer);
67    write(fd, result.string(), result.size());
68    write(fd, "\n", 1);
69    return NO_ERROR;
70}
71
72void MetadataRetrieverClient::disconnect()
73{
74    ALOGV("disconnect from pid %d", mPid);
75    Mutex::Autolock lock(mLock);
76    mRetriever.clear();
77    mThumbnail.clear();
78    mAlbumArt.clear();
79    IPCThreadState::self()->flushCommands();
80}
81
82static sp<MediaMetadataRetrieverBase> createRetriever(player_type playerType)
83{
84    sp<MediaMetadataRetrieverBase> p;
85    switch (playerType) {
86        case STAGEFRIGHT_PLAYER:
87        case NU_PLAYER:
88        {
89            p = new StagefrightMetadataRetriever;
90            break;
91        }
92        default:
93            // TODO:
94            // support for TEST_PLAYER
95            ALOGE("player type %d is not supported",  playerType);
96            break;
97    }
98    if (p == NULL) {
99        ALOGE("failed to create a retriever object");
100    }
101    return p;
102}
103
104status_t MetadataRetrieverClient::setDataSource(
105        const sp<IMediaHTTPService> &httpService,
106        const char *url,
107        const KeyedVector<String8, String8> *headers)
108{
109    ALOGV("setDataSource(%s)", url);
110    Mutex::Autolock lock(mLock);
111    if (url == NULL) {
112        return UNKNOWN_ERROR;
113    }
114
115    // When asking the MediaPlayerFactory subsystem to choose a media player for
116    // a given URL, a pointer to an outer IMediaPlayer can be passed to the
117    // factory system to be taken into consideration along with the URL.  In the
118    // case of choosing an instance of a MediaPlayerBase for a
119    // MetadataRetrieverClient, there is no outer IMediaPlayer which will
120    // eventually encapsulate the result of this selection.  In this case, just
121    // pass NULL to getPlayerType to indicate that there is no outer
122    // IMediaPlayer to consider during selection.
123    player_type playerType =
124        MediaPlayerFactory::getPlayerType(NULL /* client */, url);
125    ALOGV("player type = %d", playerType);
126    sp<MediaMetadataRetrieverBase> p = createRetriever(playerType);
127    if (p == NULL) return NO_INIT;
128    status_t ret = p->setDataSource(httpService, url, headers);
129    if (ret == NO_ERROR) mRetriever = p;
130    return ret;
131}
132
133status_t MetadataRetrieverClient::setDataSource(int fd, int64_t offset, int64_t length)
134{
135    ALOGV("setDataSource fd=%d, offset=%lld, length=%lld", fd, offset, length);
136    Mutex::Autolock lock(mLock);
137    struct stat sb;
138    int ret = fstat(fd, &sb);
139    if (ret != 0) {
140        ALOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
141        return BAD_VALUE;
142    }
143    ALOGV("st_dev  = %llu", sb.st_dev);
144    ALOGV("st_mode = %u", sb.st_mode);
145    ALOGV("st_uid  = %lu", static_cast<unsigned long>(sb.st_uid));
146    ALOGV("st_gid  = %lu", static_cast<unsigned long>(sb.st_gid));
147    ALOGV("st_size = %llu", sb.st_size);
148
149    if (offset >= sb.st_size) {
150        ALOGE("offset (%lld) bigger than file size (%llu)", offset, sb.st_size);
151        ::close(fd);
152        return BAD_VALUE;
153    }
154    if (offset + length > sb.st_size) {
155        length = sb.st_size - offset;
156        ALOGV("calculated length = %lld", length);
157    }
158
159    player_type playerType =
160        MediaPlayerFactory::getPlayerType(NULL /* client */,
161                                          fd,
162                                          offset,
163                                          length);
164    ALOGV("player type = %d", playerType);
165    sp<MediaMetadataRetrieverBase> p = createRetriever(playerType);
166    if (p == NULL) {
167        ::close(fd);
168        return NO_INIT;
169    }
170    status_t status = p->setDataSource(fd, offset, length);
171    if (status == NO_ERROR) mRetriever = p;
172    ::close(fd);
173    return status;
174}
175
176sp<IMemory> MetadataRetrieverClient::getFrameAtTime(int64_t timeUs, int option)
177{
178    ALOGV("getFrameAtTime: time(%lld us) option(%d)", timeUs, option);
179    Mutex::Autolock lock(mLock);
180    mThumbnail.clear();
181    if (mRetriever == NULL) {
182        ALOGE("retriever is not initialized");
183        return NULL;
184    }
185    VideoFrame *frame = mRetriever->getFrameAtTime(timeUs, option);
186    if (frame == NULL) {
187        ALOGE("failed to capture a video frame");
188        return NULL;
189    }
190    size_t size = sizeof(VideoFrame) + frame->mSize;
191    sp<MemoryHeapBase> heap = new MemoryHeapBase(size, 0, "MetadataRetrieverClient");
192    if (heap == NULL) {
193        ALOGE("failed to create MemoryDealer");
194        delete frame;
195        return NULL;
196    }
197    mThumbnail = new MemoryBase(heap, 0, size);
198    if (mThumbnail == NULL) {
199        ALOGE("not enough memory for VideoFrame size=%u", size);
200        delete frame;
201        return NULL;
202    }
203    VideoFrame *frameCopy = static_cast<VideoFrame *>(mThumbnail->pointer());
204    frameCopy->mWidth = frame->mWidth;
205    frameCopy->mHeight = frame->mHeight;
206    frameCopy->mDisplayWidth = frame->mDisplayWidth;
207    frameCopy->mDisplayHeight = frame->mDisplayHeight;
208    frameCopy->mSize = frame->mSize;
209    frameCopy->mRotationAngle = frame->mRotationAngle;
210    ALOGV("rotation: %d", frameCopy->mRotationAngle);
211    frameCopy->mData = (uint8_t *)frameCopy + sizeof(VideoFrame);
212    memcpy(frameCopy->mData, frame->mData, frame->mSize);
213    delete frame;  // Fix memory leakage
214    return mThumbnail;
215}
216
217sp<IMemory> MetadataRetrieverClient::extractAlbumArt()
218{
219    ALOGV("extractAlbumArt");
220    Mutex::Autolock lock(mLock);
221    mAlbumArt.clear();
222    if (mRetriever == NULL) {
223        ALOGE("retriever is not initialized");
224        return NULL;
225    }
226    MediaAlbumArt *albumArt = mRetriever->extractAlbumArt();
227    if (albumArt == NULL) {
228        ALOGE("failed to extract an album art");
229        return NULL;
230    }
231    size_t size = sizeof(MediaAlbumArt) + albumArt->size();
232    sp<MemoryHeapBase> heap = new MemoryHeapBase(size, 0, "MetadataRetrieverClient");
233    if (heap == NULL) {
234        ALOGE("failed to create MemoryDealer object");
235        delete albumArt;
236        return NULL;
237    }
238    mAlbumArt = new MemoryBase(heap, 0, size);
239    if (mAlbumArt == NULL) {
240        ALOGE("not enough memory for MediaAlbumArt size=%u", size);
241        delete albumArt;
242        return NULL;
243    }
244    MediaAlbumArt::init((MediaAlbumArt *) mAlbumArt->pointer(),
245                        albumArt->size(), albumArt->data());
246    delete albumArt;  // We've taken our copy.
247    return mAlbumArt;
248}
249
250const char* MetadataRetrieverClient::extractMetadata(int keyCode)
251{
252    ALOGV("extractMetadata");
253    Mutex::Autolock lock(mLock);
254    if (mRetriever == NULL) {
255        ALOGE("retriever is not initialized");
256        return NULL;
257    }
258    return mRetriever->extractMetadata(keyCode);
259}
260
261}; // namespace android
262