MetadataRetrieverClient.cpp revision 2a4a7d5af053a17586a262a1267ba993e31790f1 
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 <binder/MemoryDealer.h>
30#include <android_runtime/ActivityManager.h>
31#include <binder/IPCThreadState.h>
32#include <binder/IServiceManager.h>
33#include <media/MediaMetadataRetrieverInterface.h>
34#include <media/MediaPlayerInterface.h>
35#include <media/PVMetadataRetriever.h>
36#include <private/media/VideoFrame.h>
37#include "VorbisMetadataRetriever.h"
38#include "MidiMetadataRetriever.h"
39#include "MetadataRetrieverClient.h"
40#include "StagefrightMetadataRetriever.h"
41
42namespace android {
43
44extern player_type getPlayerType(const char* url);
45extern player_type getPlayerType(int fd, int64_t offset, int64_t length);
46
47MetadataRetrieverClient::MetadataRetrieverClient(pid_t pid)
48{
49    LOGV("MetadataRetrieverClient constructor pid(%d)", pid);
50    mPid = pid;
51    mThumbnailDealer = NULL;
52    mAlbumArtDealer = NULL;
53    mThumbnail = NULL;
54    mAlbumArt = NULL;
55    mRetriever = NULL;
56    mMode = METADATA_MODE_FRAME_CAPTURE_AND_METADATA_RETRIEVAL;
57}
58
59MetadataRetrieverClient::~MetadataRetrieverClient()
60{
61    LOGV("MetadataRetrieverClient destructor");
62    disconnect();
63}
64
65status_t MetadataRetrieverClient::dump(int fd, const Vector<String16>& args) const
66{
67    const size_t SIZE = 256;
68    char buffer[SIZE];
69    String8 result;
70    result.append(" MetadataRetrieverClient\n");
71    snprintf(buffer, 255, "  pid(%d) mode(%d)\n", mPid, mMode);
72    result.append(buffer);
73    write(fd, result.string(), result.size());
74    write(fd, "\n", 1);
75    return NO_ERROR;
76}
77
78void MetadataRetrieverClient::disconnect()
79{
80    LOGV("disconnect from pid %d", mPid);
81    Mutex::Autolock lock(mLock);
82    mRetriever.clear();
83    mThumbnailDealer.clear();
84    mAlbumArtDealer.clear();
85    mThumbnail.clear();
86    mAlbumArt.clear();
87    mMode = METADATA_MODE_FRAME_CAPTURE_AND_METADATA_RETRIEVAL;
88    IPCThreadState::self()->flushCommands();
89}
90
91static sp<MediaMetadataRetrieverBase> createRetriever(player_type playerType)
92{
93    sp<MediaMetadataRetrieverBase> p;
94    switch (playerType) {
95#ifndef NO_OPENCORE
96        case PV_PLAYER:
97            LOGV("create pv metadata retriever");
98            p = new PVMetadataRetriever();
99            break;
100#endif
101        case VORBIS_PLAYER:
102            LOGV("create vorbis metadata retriever");
103            p = new VorbisMetadataRetriever();
104            break;
105        case SONIVOX_PLAYER:
106            LOGV("create midi metadata retriever");
107            p = new MidiMetadataRetriever();
108            break;
109#if BUILD_WITH_FULL_STAGEFRIGHT
110        case STAGEFRIGHT_PLAYER:
111            LOGV("create StagefrightMetadataRetriever");
112            p = new StagefrightMetadataRetriever;
113            break;
114#endif
115        default:
116            // TODO:
117            // support for TEST_PLAYER
118            LOGE("player type %d is not supported",  playerType);
119            break;
120    }
121    if (p == NULL) {
122        LOGE("failed to create a retriever object");
123    }
124    return p;
125}
126
127status_t MetadataRetrieverClient::setDataSource(const char *url)
128{
129    LOGV("setDataSource(%s)", url);
130    Mutex::Autolock lock(mLock);
131    if (url == NULL) {
132        return UNKNOWN_ERROR;
133    }
134    player_type playerType = getPlayerType(url);
135    LOGV("player type = %d", playerType);
136    sp<MediaMetadataRetrieverBase> p = createRetriever(playerType);
137    if (p == NULL) return NO_INIT;
138    status_t ret = p->setMode(mMode);
139    if (ret == NO_ERROR) {
140        ret = p->setDataSource(url);
141    }
142    if (ret == NO_ERROR) mRetriever = p;
143    return ret;
144}
145
146status_t MetadataRetrieverClient::setDataSource(int fd, int64_t offset, int64_t length)
147{
148    LOGV("setDataSource fd=%d, offset=%lld, length=%lld", fd, offset, length);
149    Mutex::Autolock lock(mLock);
150    struct stat sb;
151    int ret = fstat(fd, &sb);
152    if (ret != 0) {
153        LOGE("fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
154        return BAD_VALUE;
155    }
156    LOGV("st_dev  = %llu", sb.st_dev);
157    LOGV("st_mode = %u", sb.st_mode);
158    LOGV("st_uid  = %lu", sb.st_uid);
159    LOGV("st_gid  = %lu", sb.st_gid);
160    LOGV("st_size = %llu", sb.st_size);
161
162    if (offset >= sb.st_size) {
163        LOGE("offset (%lld) bigger than file size (%llu)", offset, sb.st_size);
164        ::close(fd);
165        return BAD_VALUE;
166    }
167    if (offset + length > sb.st_size) {
168        length = sb.st_size - offset;
169        LOGV("calculated length = %lld", length);
170    }
171
172    player_type playerType = getPlayerType(fd, offset, length);
173    LOGV("player type = %d", playerType);
174    sp<MediaMetadataRetrieverBase> p = createRetriever(playerType);
175    if (p == NULL) {
176        ::close(fd);
177        return NO_INIT;
178    }
179    status_t status = p->setMode(mMode);
180    if (status == NO_ERROR) {
181        p->setDataSource(fd, offset, length);
182    }
183    if (status == NO_ERROR) mRetriever = p;
184    ::close(fd);
185    return status;
186}
187
188status_t MetadataRetrieverClient::setMode(int mode)
189{
190    LOGV("setMode");
191    Mutex::Autolock lock(mLock);
192    if (mode < METADATA_MODE_NOOP ||
193        mode > METADATA_MODE_FRAME_CAPTURE_AND_METADATA_RETRIEVAL) {
194        LOGE("invalid mode %d", mode);
195        return BAD_VALUE;
196    }
197    mMode = mode;
198    return NO_ERROR;
199}
200
201status_t MetadataRetrieverClient::getMode(int* mode) const
202{
203    LOGV("getMode");
204    Mutex::Autolock lock(mLock);
205
206    // TODO:
207    // This may not be necessary.
208    // If setDataSource() has not been called, return the cached value
209    // otherwise, return the value retrieved from the retriever
210    if (mRetriever == NULL) {
211        *mode = mMode;
212    } else {
213        mRetriever->getMode(mode);
214    }
215    return NO_ERROR;
216}
217
218sp<IMemory> MetadataRetrieverClient::captureFrame()
219{
220    LOGV("captureFrame");
221    Mutex::Autolock lock(mLock);
222    mThumbnail.clear();
223    mThumbnailDealer.clear();
224    if (mRetriever == NULL) {
225        LOGE("retriever is not initialized");
226        return NULL;
227    }
228    VideoFrame *frame = mRetriever->captureFrame();
229    if (frame == NULL) {
230        LOGE("failed to capture a video frame");
231        return NULL;
232    }
233    size_t size = sizeof(VideoFrame) + frame->mSize;
234    mThumbnailDealer = new MemoryDealer(size);
235    if (mThumbnailDealer == NULL) {
236        LOGE("failed to create MemoryDealer");
237        delete frame;
238        return NULL;
239    }
240    mThumbnail = mThumbnailDealer->allocate(size);
241    if (mThumbnail == NULL) {
242        LOGE("not enough memory for VideoFrame size=%u", size);
243        mThumbnailDealer.clear();
244        delete frame;
245        return NULL;
246    }
247    VideoFrame *frameCopy = static_cast<VideoFrame *>(mThumbnail->pointer());
248    frameCopy->mWidth = frame->mWidth;
249    frameCopy->mHeight = frame->mHeight;
250    frameCopy->mDisplayWidth = frame->mDisplayWidth;
251    frameCopy->mDisplayHeight = frame->mDisplayHeight;
252    frameCopy->mSize = frame->mSize;
253    frameCopy->mData = (uint8_t *)frameCopy + sizeof(VideoFrame);
254    memcpy(frameCopy->mData, frame->mData, frame->mSize);
255    delete frame;  // Fix memory leakage
256    return mThumbnail;
257}
258
259sp<IMemory> MetadataRetrieverClient::extractAlbumArt()
260{
261    LOGV("extractAlbumArt");
262    Mutex::Autolock lock(mLock);
263    mAlbumArt.clear();
264    mAlbumArtDealer.clear();
265    if (mRetriever == NULL) {
266        LOGE("retriever is not initialized");
267        return NULL;
268    }
269    MediaAlbumArt *albumArt = mRetriever->extractAlbumArt();
270    if (albumArt == NULL) {
271        LOGE("failed to extract an album art");
272        return NULL;
273    }
274    size_t size = sizeof(MediaAlbumArt) + albumArt->mSize;
275    mAlbumArtDealer = new MemoryDealer(size);
276    if (mAlbumArtDealer == NULL) {
277        LOGE("failed to create MemoryDealer object");
278        delete albumArt;
279        return NULL;
280    }
281    mAlbumArt = mAlbumArtDealer->allocate(size);
282    if (mAlbumArt == NULL) {
283        LOGE("not enough memory for MediaAlbumArt size=%u", size);
284        mAlbumArtDealer.clear();
285        delete albumArt;
286        return NULL;
287    }
288    MediaAlbumArt *albumArtCopy = static_cast<MediaAlbumArt *>(mAlbumArt->pointer());
289    albumArtCopy->mSize = albumArt->mSize;
290    albumArtCopy->mData = (uint8_t *)albumArtCopy + sizeof(MediaAlbumArt);
291    memcpy(albumArtCopy->mData, albumArt->mData, albumArt->mSize);
292    delete albumArt;  // Fix memory leakage
293    return mAlbumArt;
294}
295
296const char* MetadataRetrieverClient::extractMetadata(int keyCode)
297{
298    LOGV("extractMetadata");
299    Mutex::Autolock lock(mLock);
300    if (mRetriever == NULL) {
301        LOGE("retriever is not initialized");
302        return NULL;
303    }
304    return mRetriever->extractMetadata(keyCode);
305}
306
307}; // namespace android
308