Merge "Added VideoSourceDownSampler"

/*

 * Copyright (C) 2010 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.

 */

// VideoSourceDownSampler implements the MediaSource interface,

// downsampling frames provided from a real video source.

#ifndef VIDEO_SOURCE_DOWN_SAMPLER_H_

#define VIDEO_SOURCE_DOWN_SAMPLER_H_

#include <media/stagefright/MediaSource.h>

#include <utils/RefBase.h>

namespace android {

class IMemory;

class MediaBuffer;

class MetaData;

class VideoSourceDownSampler : public MediaSource {

public:

    virtual ~VideoSourceDownSampler();

    // Constructor:

    // videoSource: The real video source which provides the original frames.

    // width, height: The desired width, height. These should be less than or equal

    // to those of the real video source. We then downsample the original frames to

    // this size.

    VideoSourceDownSampler(const sp<MediaSource> &videoSource,

        int32_t width, int32_t height);

    // MediaSource interface

    virtual status_t start(MetaData *params = NULL);

    virtual status_t stop();

    virtual sp<MetaData> getFormat();

    virtual status_t read(

            MediaBuffer **buffer, const ReadOptions *options = NULL);

    virtual status_t pause();

private:

    // Reference to the real video source.

    sp<MediaSource> mRealVideoSource;

    // Size of frames to be provided by this source.

    int32_t mWidth;

    int32_t mHeight;

    // Size of frames provided by the real source.

    int32_t mRealSourceWidth;

    int32_t mRealSourceHeight;

    // Down sampling paramters.

    int32_t mDownSampleOffsetX;

    int32_t mDownSampleOffsetY;

    int32_t mDownSampleSkipX;

    int32_t mDownSampleSkipY;

    // True if we need to crop the still video image to get the video frame.

    bool mNeedDownSampling;

    // Meta data. This is a copy of the real source except for the width and

    // height parameters.

    sp<MetaData> mMeta;

    // Computes the offset, skip parameters for downsampling the original frame

    // to the desired size.

    void computeDownSamplingParameters();

    // Downsamples the frame in sourceBuffer to size (mWidth x mHeight). A new

    // buffer is created which stores the downsampled image.

    void downSampleYUVImage(const MediaBuffer &sourceBuffer, MediaBuffer **buffer) const;

    // Disallow these.

    VideoSourceDownSampler(const VideoSourceDownSampler &);

    VideoSourceDownSampler &operator=(const VideoSourceDownSampler &);

};

}  // namespace android

#endif  // VIDEO_SOURCE_DOWN_SAMPLER_H_

        AwesomePlayer.cpp                 \

        CameraSource.cpp                  \

        CameraSourceTimeLapse.cpp         \

        VideoSourceDownSampler.cpp        \

        DataSource.cpp                    \

        ESDS.cpp                          \

        FileSource.cpp                    \

/*

 * Copyright (C) 2010 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_NDEBUG 0

#define LOG_TAG "VideoSourceDownSampler"

#include <media/stagefright/VideoSourceDownSampler.h>

#include <media/stagefright/MediaBuffer.h>

#include <media/stagefright/MediaDebug.h>

#include <media/stagefright/MetaData.h>

#include <media/stagefright/YUVImage.h>

#include <media/stagefright/YUVCanvas.h>

#include "OMX_Video.h"

namespace android {

VideoSourceDownSampler::VideoSourceDownSampler(const sp<MediaSource> &videoSource,

        int32_t width, int32_t height) {

    LOGV("Construct VideoSourceDownSampler");

    CHECK(width > 0);

    CHECK(height > 0);

    mRealVideoSource = videoSource;

    mWidth = width;

    mHeight = height;

    mMeta = new MetaData(*(mRealVideoSource->getFormat()));

    CHECK(mMeta->findInt32(kKeyWidth, &mRealSourceWidth));

    CHECK(mMeta->findInt32(kKeyHeight, &mRealSourceHeight));

    if ((mWidth != mRealSourceWidth) || (mHeight != mRealSourceHeight)) {

        // Change meta data for width and height.

        CHECK(mWidth <= mRealSourceWidth);

        CHECK(mHeight <= mRealSourceHeight);

        mNeedDownSampling = true;

        computeDownSamplingParameters();

        mMeta->setInt32(kKeyWidth, mWidth);

        mMeta->setInt32(kKeyHeight, mHeight);

    } else {

        mNeedDownSampling = false;

    }

}

VideoSourceDownSampler::~VideoSourceDownSampler() {

}

void VideoSourceDownSampler::computeDownSamplingParameters() {

    mDownSampleSkipX = mRealSourceWidth / mWidth;

    mDownSampleSkipY = mRealSourceHeight / mHeight;

    mDownSampleOffsetX = mRealSourceWidth - mDownSampleSkipX * mWidth;

    mDownSampleOffsetY = mRealSourceHeight - mDownSampleSkipY * mHeight;

}

void VideoSourceDownSampler::downSampleYUVImage(

        const MediaBuffer &sourceBuffer, MediaBuffer **buffer) const {

    // find the YUV format

    int32_t srcFormat;

    CHECK(mMeta->findInt32(kKeyColorFormat, &srcFormat));

    YUVImage::YUVFormat yuvFormat;

    if (srcFormat == OMX_COLOR_FormatYUV420SemiPlanar) {

        yuvFormat = YUVImage::YUV420SemiPlanar;

    } else if (srcFormat == OMX_COLOR_FormatYUV420Planar) {

        yuvFormat = YUVImage::YUV420Planar;

    }

    // allocate mediaBuffer for down sampled image and setup a canvas.

    *buffer = new MediaBuffer(YUVImage::bufferSize(yuvFormat, mWidth, mHeight));

    YUVImage yuvDownSampledImage(yuvFormat,

            mWidth, mHeight,

            (uint8_t *)(*buffer)->data());

    YUVCanvas yuvCanvasDownSample(yuvDownSampledImage);

    YUVImage yuvImageSource(yuvFormat,

            mRealSourceWidth, mRealSourceHeight,

            (uint8_t *)sourceBuffer.data());

    yuvCanvasDownSample.downsample(mDownSampleOffsetX, mDownSampleOffsetY,

            mDownSampleSkipX, mDownSampleSkipY,

            yuvImageSource);

}

status_t VideoSourceDownSampler::start(MetaData *params) {

    LOGV("start");

    return mRealVideoSource->start();

}

status_t VideoSourceDownSampler::stop() {

    LOGV("stop");

    return mRealVideoSource->stop();

}

sp<MetaData> VideoSourceDownSampler::getFormat() {

    LOGV("getFormat");

    return mMeta;

}

status_t VideoSourceDownSampler::read(

        MediaBuffer **buffer, const ReadOptions *options) {

    LOGV("read");

    MediaBuffer *realBuffer;

    status_t err = mRealVideoSource->read(&realBuffer, options);

    if (mNeedDownSampling) {

        downSampleYUVImage(*realBuffer, buffer);

        int64_t frameTime;

        realBuffer->meta_data()->findInt64(kKeyTime, &frameTime);

        (*buffer)->meta_data()->setInt64(kKeyTime, frameTime);

        // We just want this buffer to be deleted when the encoder releases it.

        // So don't add a reference to it and set the observer to NULL.

        (*buffer)->setObserver(NULL);

        // The original buffer is no longer required. Release it.

        realBuffer->release();

    } else {

        *buffer = realBuffer;

    }

    return err;

}

status_t VideoSourceDownSampler::pause() {

    LOGV("pause");

    return mRealVideoSource->pause();

}

}  // namespace android