Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

am fed9888e: Merge "Remove outdated tests for custom decoder." into lmp-mr1-dev

Browse Source 
* commit 'fed9888e60f0c7c9eecffbeee22ea058aedbc692':
  Remove outdated tests for custom decoder.
This commit is contained in:
Leon Scroggins III
2014-10-22 22:13:38 +00:00
committed by Android Git Automerger
parent 9088e45b45 fed9888e60
commit 694fd58dd9
6 changed files with 0 additions and 498 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
media/tests/omxjpegdecoder/Android.mk
View File

@@ -1,45 +0,0 @@
# Copyright (C) 2009 The Android Open Source Project
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
LOCAL_PATH:= $(call my-dir)
include $(CLEAR_VARS)
LOCAL_SRC_FILES := \
omx_jpeg_decoder.cpp \
jpeg_decoder_bench.cpp \
StreamSource.cpp
LOCAL_SHARED_LIBRARIES := \
libcutils \
libskia \
libstagefright \
libstagefright_foundation \
libbinder \
libutils \
liblog \
libjpeg
LOCAL_C_INCLUDES := \
$(TOP)/external/jpeg \
$(TOP)/frameworks/base/media/libstagefright \
$(TOP)/frameworks/base/include/ \
$(TOP)/frameworks/base/ \
$(TOP)/frameworks/native/include/media/openmax
LOCAL_MODULE := jpeg_bench
LOCAL_MODULE_TAGS := optional
include $(BUILD_EXECUTABLE)

53
media/tests/omxjpegdecoder/StreamSource.cpp
View File

@@ -1,53 +0,0 @@
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#include <media/stagefright/foundation/ADebug.h>
#include "StreamSource.h"
namespace android {
StreamSource::StreamSource(SkStream *stream)
: mStream(stream) {
CHECK(stream != NULL);
mSize = stream->getLength();
}
StreamSource::~StreamSource() {
delete mStream;
mStream = NULL;
}
status_t StreamSource::initCheck() const {
return mStream != NULL ? OK : NO_INIT;
}
ssize_t StreamSource::readAt(off64_t offset, void *data, size_t size) {
Mutex::Autolock autoLock(mLock);
mStream->rewind();
mStream->skip(offset);
ssize_t result = mStream->read(data, size);
return result;
}
status_t StreamSource::getSize(off64_t *size) {
*size = mSize;
return OK;
}
} // namespace android

52
media/tests/omxjpegdecoder/StreamSource.h
View File

@@ -1,52 +0,0 @@
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef STREAM_SOURCE_H_
#define STREAM_SOURCE_H_
#include <stdio.h>
#include <SkStream.h>
#include <media/stagefright/DataSource.h>
#include <media/stagefright/MediaErrors.h>
#include <utils/threads.h>
namespace android {
class StreamSource : public DataSource {
public:
// Pass the ownership of SkStream to StreamSource.
StreamSource(SkStream *SkStream);
virtual status_t initCheck() const;
virtual ssize_t readAt(off64_t offset, void *data, size_t size);
virtual status_t getSize(off64_t *size);
protected:
virtual ~StreamSource();
private:
SkStream *mStream;
size_t mSize;
Mutex mLock;
StreamSource(const StreamSource &);
StreamSource &operator=(const StreamSource &);
};
} // namespace android
#endif // STREAM_SOURCE_H_

114
media/tests/omxjpegdecoder/jpeg_decoder_bench.cpp
View File

@@ -1,114 +0,0 @@
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "OmxJpegDecoder"
#include <sys/time.h>
#include <utils/Log.h>
#include <binder/ProcessState.h>
#include "SkBitmap.h"
#include "SkImageDecoder.h"
#include "SkStream.h"
#include "omx_jpeg_decoder.h"
class SkJPEGImageDecoder : public SkImageDecoder {
public:
virtual Format getFormat() const {
return kJPEG_Format;
}
protected:
virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode);
};
int nullObjectReturn(const char msg[]) {
if (msg) {
SkDebugf("--- %s\n", msg);
}
return -1;
}
static int64_t getNowUs() {
struct timeval tv;
gettimeofday(&tv, NULL);
return tv.tv_usec + (int64_t) tv.tv_sec * 1000000;
}
int testDecodeBounds(SkImageDecoder* decoder, SkStream* stream,
SkBitmap* bitmap) {
int64_t startTime = getNowUs();
SkColorType prefColorType = kN32_SkColorType;
SkImageDecoder::Mode decodeMode = SkImageDecoder::kDecodeBounds_Mode;
// Decode the input stream and then use the bitmap.
if (!decoder->decode(stream, bitmap, prefColorType, decodeMode)) {
return nullObjectReturn("decoder->decode returned false");
} else {
int64_t delay = getNowUs() - startTime;
printf("WidthxHeight: %dx%d\n", bitmap->width(), bitmap->height());
printf("Decoding Time in BoundsMode %.1f msec.\n", delay / 1000.0f);
return 0;
}
}
int testDecodePixels(SkImageDecoder* decoder, SkStream* stream,
SkBitmap* bitmap) {
int64_t startTime = getNowUs();
SkColorType prefColorType = kN32_SkColorType;
SkImageDecoder::Mode decodeMode = SkImageDecoder::kDecodePixels_Mode;
// Decode the input stream and then use the bitmap.
if (!decoder->decode(stream, bitmap, prefColorType, decodeMode)) {
return nullObjectReturn("decoder->decode returned false");
} else {
int64_t delay = getNowUs() - startTime;
printf("Decoding Time in PixelsMode %.1f msec.\n", delay / 1000.0f);
const char* filename = "/sdcard/omxJpegDecodedBitmap.rgba";
return storeBitmapToFile(bitmap, filename);
}
}
int testDecoder(SkImageDecoder* decoder, char* filename) {
// test DecodeMode == Pixels
SkStream* stream = new SkFILEStream(filename);
SkBitmap* bitmap = new SkBitmap;
testDecodePixels(decoder, stream, bitmap);
delete bitmap;
// test DecodeMode == Bounds
stream = new SkFILEStream(filename);
bitmap = new SkBitmap;
testDecodeBounds(decoder, stream, bitmap);
delete bitmap;
delete decoder;
return 0;
}
int main(int argc, char** argv) {
android::ProcessState::self()->startThreadPool();
printf("Decoding jpeg with libjpeg...\n");
SkJPEGImageDecoder* libjpeg = new SkJPEGImageDecoder;
testDecoder(libjpeg, argv[1]);
printf("\nDecoding jpeg with OMX...\n");
OmxJpegImageDecoder* omx = new OmxJpegImageDecoder;
testDecoder(omx, argv[1]);
return 0;
}

177
media/tests/omxjpegdecoder/omx_jpeg_decoder.cpp
View File

@@ -1,177 +0,0 @@
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "OmxJpegDecoder"
#include <sys/time.h>
#include <utils/Log.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <binder/IServiceManager.h>
#include <binder/ProcessState.h>
#include <media/IMediaPlayerService.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/MediaSource.h>
#include <media/stagefright/MetaData.h>
#include <media/stagefright/OMXClient.h>
#include <media/stagefright/OMXCodec.h>
#include <SkImage.h>
#include <SkMallocPixelRef.h>
#include "omx_jpeg_decoder.h"
#include "StreamSource.h"
using namespace android;
static void getJpegOutput(MediaBuffer* buffer, const char* filename) {
int size = buffer->range_length();
int offset = buffer->range_offset();
FILE *pFile = fopen(filename, "w+");
if (pFile == NULL) {
printf("Error: cannot open %s.\n", filename);
} else {
char* data = (char*) buffer->data();
data += offset;
while (size > 0) {
int numChars = fwrite(data, sizeof(char), 1024, pFile);
int numBytes = numChars * sizeof(char);
size -= numBytes;
data += numBytes;
}
fclose(pFile);
}
return;
}
extern int storeBitmapToFile(SkBitmap* bitmap, const char* filename) {
bitmap->lockPixels();
uint8_t* data = (uint8_t *)bitmap->getPixels();
int size = bitmap->getSize();
FILE* fp = fopen(filename, "w+");
if (NULL == fp) {
printf("Cannot open the output file! \n");
return -1;
} else {
while (size > 0) {
int numChars = fwrite(data, sizeof(char), 1024, fp);
int numBytes = numChars * sizeof(char);
size -= numBytes;
data += numBytes;
}
fclose(fp);
}
return 0;
}
static int64_t getNowUs() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (int64_t)tv.tv_usec + tv.tv_sec * 1000000;
}
OmxJpegImageDecoder::OmxJpegImageDecoder() {
status_t err = mClient.connect();
CHECK_EQ(err, (status_t)OK);
}
OmxJpegImageDecoder::~OmxJpegImageDecoder() {
mClient.disconnect();
}
bool OmxJpegImageDecoder::onDecode(SkStream* stream,
SkBitmap* bm, Mode mode) {
sp<MediaSource> source = prepareMediaSource(stream);
sp<MetaData> meta = source->getFormat();
int width;
int height;
meta->findInt32(kKeyWidth, &width);
meta->findInt32(kKeyHeight, &height);
configBitmapSize(
bm, getPrefColorType(k32Bit_SrcDepth, false),
width, height);
// mode == DecodeBounds
if (mode == SkImageDecoder::kDecodeBounds_Mode) {
return true;
}
// mode == DecodePixels
if (!this->allocPixelRef(bm, NULL)) {
ALOGI("Cannot allocPixelRef()!");
return false;
}
sp<MediaSource> decoder = getDecoder(&mClient, source);
return decodeSource(decoder, source, bm);
}
JPEGSource* OmxJpegImageDecoder::prepareMediaSource(SkStream* stream) {
DataSource::RegisterDefaultSniffers();
sp<DataSource> dataSource = new StreamSource(stream);
return new JPEGSource(dataSource);
}
sp<MediaSource> OmxJpegImageDecoder::getDecoder(
OMXClient *client, const sp<MediaSource>& source) {
sp<MetaData> meta = source->getFormat();
sp<MediaSource> decoder = OMXCodec::Create(
client->interface(), meta, false /* createEncoder */, source);
CHECK(decoder != NULL);
return decoder;
}
bool OmxJpegImageDecoder::decodeSource(sp<MediaSource> decoder,
const sp<MediaSource>& source, SkBitmap* bm) {
status_t rt = decoder->start();
if (rt != OK) {
ALOGE("Cannot start OMX Decoder!");
return false;
}
int64_t startTime = getNowUs();
MediaBuffer *buffer;
// decode source
status_t err = decoder->read(&buffer, NULL);
int64_t duration = getNowUs() - startTime;
if (err != OK) {
CHECK(buffer == NULL);
}
printf("Duration in decoder->read(): %.1f (msecs). \n",
duration / 1E3 );
// Copy pixels from buffer to bm.
// May need to check buffer->rawBytes() == bm->rawBytes().
CHECK_EQ(buffer->size(), bm->getSize());
memcpy(bm->getPixels(), buffer->data(), buffer->size());
buffer->release();
decoder->stop();
return true;
}
void OmxJpegImageDecoder::configBitmapSize(SkBitmap* bm, SkColorType pref,
int width, int height) {
// Set the color space to ARGB_8888 for now (ignoring pref)
// because of limitation in hardware support.
bm->setInfo(SkImageInfo::MakeN32(width, height, kOpaque_SkAlphaType));
}

57
media/tests/omxjpegdecoder/omx_jpeg_decoder.h
View File

@@ -1,57 +0,0 @@
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef OMXJPEGIMAGEDECODER
#define OMXJPEGIMAGEDECODER
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <media/stagefright/JPEGSource.h>
#include <media/stagefright/MediaSource.h>
#include <media/stagefright/OMXClient.h>
#include <media/stagefright/OMXCodec.h>
#include <SkImageDecoder.h>
#include <SkStream.h>
using namespace android;
extern int storeBitmapToFile(SkBitmap* bitmap, const char* filename);
class OmxJpegImageDecoder : public SkImageDecoder {
public:
OmxJpegImageDecoder();
~OmxJpegImageDecoder();
virtual Format getFormat() const {
return kJPEG_Format;
}
protected:
virtual bool onDecode(SkStream* stream, SkBitmap* bm, Mode mode);
private:
JPEGSource* prepareMediaSource(SkStream* stream);
sp<MediaSource> getDecoder(OMXClient* client, const sp<MediaSource>& source);
bool decodeSource(sp<MediaSource> decoder, const sp<MediaSource>& source,
SkBitmap* bm);
void configBitmapSize(SkBitmap* bm, SkColorType, int width, int height);
OMXClient mClient;
};
#endif