am b3d2a85b: am 694fd58d: am fed9888e: Merge "Remove outdated tests for custom...

# 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)

/*

 * 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

/*

 * 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_

/*

 * 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;

}

/*

 * 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));

}