Renaming SurfaceEncoder to SurfaceMediaSource

Related to bug id: 4529323

Change-Id: Id820d45a536bd2c65e0a59def564eb5b3ea4a71c

4 files changed, 76 insertions, 78 deletions

diff --git a/media/libstagefright/Android.mk b/media/libstagefright/Android.mk
index 67c0ea4..3a3c082 100644
--- a/media/libstagefright/Android.mk
+++ b/media/libstagefright/Android.mk
@@ -42,7 +42,7 @@ LOCAL_SRC_FILES:=                         \
         SampleTable.cpp                   \
         StagefrightMediaScanner.cpp       \
         StagefrightMetadataRetriever.cpp  \
-        SurfaceEncoder.cpp                \
+        SurfaceMediaSource.cpp            \
         ThrottledSource.cpp               \
         TimeSource.cpp                    \
         TimedEventQueue.cpp               \
diff --git a/media/libstagefright/SurfaceEncoder.cpp b/media/libstagefright/SurfaceMediaSource.cpp
index e4c1938..db208dd 100644
--- a/media/libstagefright/SurfaceEncoder.cpp
+++ b/media/libstagefright/SurfaceMediaSource.cpp
@@ -15,9 +15,9 @@
  */
 
 // #define LOG_NDEBUG 0
-#define LOG_TAG "SurfaceEncoder"
+#define LOG_TAG "SurfaceMediaSource"
 
-#include <media/stagefright/SurfaceEncoder.h>
+#include <media/stagefright/SurfaceMediaSource.h>
 #include <ui/GraphicBuffer.h>
 #include <media/stagefright/MetaData.h>
 #include <media/stagefright/MediaDefs.h>
@@ -34,7 +34,7 @@
 
 namespace android {
 
-SurfaceEncoder::SurfaceEncoder(uint32_t bufW, uint32_t bufH) :
+SurfaceMediaSource::SurfaceMediaSource(uint32_t bufW, uint32_t bufH) :
     mDefaultWidth(bufW),
     mDefaultHeight(bufH),
     mPixelFormat(0),
@@ -46,26 +46,26 @@ SurfaceEncoder::SurfaceEncoder(uint32_t bufW, uint32_t bufH) :
     mSynchronousMode(true),
     mConnectedApi(NO_CONNECTED_API),
     mFrameRate(30),
-    mStarted(false)   {
-    LOGV("SurfaceEncoder::SurfaceEncoder");
+    mStarted(false)     {
+    LOGV("SurfaceMediaSource::SurfaceMediaSource");
     sp<ISurfaceComposer> composer(ComposerService::getComposerService());
     mGraphicBufferAlloc = composer->createGraphicBufferAlloc();
 }
 
-SurfaceEncoder::~SurfaceEncoder() {
-    LOGV("SurfaceEncoder::~SurfaceEncoder");
+SurfaceMediaSource::~SurfaceMediaSource() {
+    LOGV("SurfaceMediaSource::~SurfaceMediaSource");
     if (mStarted) {
         stop();
     }
     freeAllBuffers();
 }
 
-size_t SurfaceEncoder::getQueuedCount() const {
+size_t SurfaceMediaSource::getQueuedCount() const {
     Mutex::Autolock lock(mMutex);
     return mQueue.size();
 }
 
-status_t SurfaceEncoder::setBufferCountServerLocked(int bufferCount) {
+status_t SurfaceMediaSource::setBufferCountServerLocked(int bufferCount) {
     if (bufferCount > NUM_BUFFER_SLOTS)
         return BAD_VALUE;
 
@@ -100,13 +100,13 @@ status_t SurfaceEncoder::setBufferCountServerLocked(int bufferCount) {
 }
 
 // Called from the consumer side
-status_t SurfaceEncoder::setBufferCountServer(int bufferCount) {
+status_t SurfaceMediaSource::setBufferCountServer(int bufferCount) {
     Mutex::Autolock lock(mMutex);
     return setBufferCountServerLocked(bufferCount);
 }
 
-status_t SurfaceEncoder::setBufferCount(int bufferCount) {
-    LOGV("SurfaceEncoder::setBufferCount");
+status_t SurfaceMediaSource::setBufferCount(int bufferCount) {
+    LOGV("SurfaceMediaSource::setBufferCount");
     if (bufferCount > NUM_BUFFER_SLOTS) {
         LOGE("setBufferCount: bufferCount is larger than the number of buffer slots");
         return BAD_VALUE;
@@ -147,8 +147,8 @@ status_t SurfaceEncoder::setBufferCount(int bufferCount) {
     return OK;
 }
 
-sp<GraphicBuffer> SurfaceEncoder::requestBuffer(int buf) {
-    LOGV("SurfaceEncoder::requestBuffer");
+sp<GraphicBuffer> SurfaceMediaSource::requestBuffer(int buf) {
+    LOGV("SurfaceMediaSource::requestBuffer");
     Mutex::Autolock lock(mMutex);
     if (buf < 0 || mBufferCount <= buf) {
         LOGE("requestBuffer: slot index out of range [0, %d]: %d",
@@ -159,7 +159,7 @@ sp<GraphicBuffer> SurfaceEncoder::requestBuffer(int buf) {
     return mSlots[buf].mGraphicBuffer;
 }
 
-status_t SurfaceEncoder::dequeueBuffer(int *outBuf, uint32_t w, uint32_t h,
+status_t SurfaceMediaSource::dequeueBuffer(int *outBuf, uint32_t w, uint32_t h,
                                             uint32_t format, uint32_t usage) {
     LOGV("dequeueBuffer");
 
@@ -347,7 +347,7 @@ status_t SurfaceEncoder::dequeueBuffer(int *outBuf, uint32_t w, uint32_t h,
     return returnFlags;
 }
 
-status_t SurfaceEncoder::setSynchronousMode(bool enabled) {
+status_t SurfaceMediaSource::setSynchronousMode(bool enabled) {
     Mutex::Autolock lock(mMutex);
 
     status_t err = OK;
@@ -369,8 +369,8 @@ status_t SurfaceEncoder::setSynchronousMode(bool enabled) {
     return err;
 }
 
-status_t SurfaceEncoder::connect(int api) {
-    LOGV("SurfaceEncoder::connect");
+status_t SurfaceMediaSource::connect(int api) {
+    LOGV("SurfaceMediaSource::connect");
     Mutex::Autolock lock(mMutex);
     int err = NO_ERROR;
     switch (api) {
@@ -391,8 +391,8 @@ status_t SurfaceEncoder::connect(int api) {
     return err;
 }
 
-status_t SurfaceEncoder::disconnect(int api) {
-    LOGV("SurfaceEncoder::disconnect");
+status_t SurfaceMediaSource::disconnect(int api) {
+    LOGV("SurfaceMediaSource::disconnect");
     Mutex::Autolock lock(mMutex);
     int err = NO_ERROR;
     switch (api) {
@@ -413,7 +413,7 @@ status_t SurfaceEncoder::disconnect(int api) {
     return err;
 }
 
-status_t SurfaceEncoder::queueBuffer(int buf, int64_t timestamp,
+status_t SurfaceMediaSource::queueBuffer(int buf, int64_t timestamp,
         uint32_t* outWidth, uint32_t* outHeight, uint32_t* outTransform) {
     LOGV("queueBuffer");
 
@@ -475,13 +475,13 @@ status_t SurfaceEncoder::queueBuffer(int buf, int64_t timestamp,
 // The buffer is NOT made available for dequeueing immediately. We need to
 // wait to hear from StageFrightRecorder to set the buffer FREE
 // Make sure this is called when the mutex is locked
-status_t SurfaceEncoder::onFrameReceivedLocked() {
+status_t SurfaceMediaSource::onFrameReceivedLocked() {
     LOGV("On Frame Received");
     // Signal the encoder that a new frame has arrived
     mFrameAvailableCondition.signal();
 
     // call back the listener
-    // TODO: The listener may not be needed in SurfaceEncoder at all.
+    // TODO: The listener may not be needed in SurfaceMediaSource at all.
     // This can be made a SurfaceTexture specific thing
     sp<FrameAvailableListener> listener;
     if (mSynchronousMode || mQueue.empty()) {
@@ -495,8 +495,8 @@ status_t SurfaceEncoder::onFrameReceivedLocked() {
 }
 
 
-void SurfaceEncoder::cancelBuffer(int buf) {
-    LOGV("SurfaceEncoder::cancelBuffer");
+void SurfaceMediaSource::cancelBuffer(int buf) {
+    LOGV("SurfaceMediaSource::cancelBuffer");
     Mutex::Autolock lock(mMutex);
     if (buf < 0 || buf >= mBufferCount) {
         LOGE("cancelBuffer: slot index out of range [0, %d]: %d",
@@ -511,27 +511,27 @@ void SurfaceEncoder::cancelBuffer(int buf) {
     mDequeueCondition.signal();
 }
 
-nsecs_t SurfaceEncoder::getTimestamp() {
-    LOGV("SurfaceEncoder::getTimestamp");
+nsecs_t SurfaceMediaSource::getTimestamp() {
+    LOGV("SurfaceMediaSource::getTimestamp");
     Mutex::Autolock lock(mMutex);
     return mCurrentTimestamp;
 }
 
 
-void SurfaceEncoder::setFrameAvailableListener(
+void SurfaceMediaSource::setFrameAvailableListener(
         const sp<FrameAvailableListener>& listener) {
-    LOGV("SurfaceEncoder::setFrameAvailableListener");
+    LOGV("SurfaceMediaSource::setFrameAvailableListener");
     Mutex::Autolock lock(mMutex);
     mFrameAvailableListener = listener;
 }
 
-sp<IBinder> SurfaceEncoder::getAllocator() {
+sp<IBinder> SurfaceMediaSource::getAllocator() {
     LOGV("getAllocator");
     return mGraphicBufferAlloc->asBinder();
 }
 
 
-void SurfaceEncoder::freeAllBuffers() {
+void SurfaceMediaSource::freeAllBuffers() {
     LOGV("freeAllBuffers");
     for (int i = 0; i < NUM_BUFFER_SLOTS; i++) {
         mSlots[i].mGraphicBuffer = 0;
@@ -539,12 +539,12 @@ void SurfaceEncoder::freeAllBuffers() {
     }
 }
 
-sp<GraphicBuffer> SurfaceEncoder::getCurrentBuffer() const {
+sp<GraphicBuffer> SurfaceMediaSource::getCurrentBuffer() const {
     Mutex::Autolock lock(mMutex);
     return mCurrentBuf;
 }
 
-int SurfaceEncoder::query(int what, int* outValue)
+int SurfaceMediaSource::query(int what, int* outValue)
 {
     LOGV("query");
     Mutex::Autolock lock(mMutex);
@@ -574,13 +574,13 @@ int SurfaceEncoder::query(int what, int* outValue)
     return NO_ERROR;
 }
 
-void SurfaceEncoder::dump(String8& result) const
+void SurfaceMediaSource::dump(String8& result) const
 {
     char buffer[1024];
     dump(result, "", buffer, 1024);
 }
 
-void SurfaceEncoder::dump(String8& result, const char* prefix,
+void SurfaceMediaSource::dump(String8& result, const char* prefix,
         char* buffer, size_t SIZE) const
 {
     Mutex::Autolock _l(mMutex);
@@ -625,18 +625,18 @@ void SurfaceEncoder::dump(String8& result, const char* prefix,
     }
 }
 
-void SurfaceEncoder::setFrameRate(uint32_t fps)
+void SurfaceMediaSource::setFrameRate(uint32_t fps)
 {
     Mutex::Autolock lock(mMutex);
     mFrameRate = fps;
 }
 
-uint32_t SurfaceEncoder::getFrameRate( ) const {
+uint32_t SurfaceMediaSource::getFrameRate( ) const {
     Mutex::Autolock lock(mMutex);
     return mFrameRate;
 }
 
-status_t SurfaceEncoder::start(MetaData *params)
+status_t SurfaceMediaSource::start(MetaData *params)
 {
     LOGV("start");
     Mutex::Autolock lock(mMutex);
@@ -646,7 +646,7 @@ status_t SurfaceEncoder::start(MetaData *params)
 }
 
 
-status_t SurfaceEncoder::stop()
+status_t SurfaceMediaSource::stop()
 {
     LOGV("Stop");
 
@@ -658,7 +658,7 @@ status_t SurfaceEncoder::stop()
     return OK;
 }
 
-sp<MetaData> SurfaceEncoder::getFormat()
+sp<MetaData> SurfaceMediaSource::getFormat()
 {
     LOGV("getFormat");
     Mutex::Autolock autoLock(mMutex);
@@ -678,7 +678,7 @@ sp<MetaData> SurfaceEncoder::getFormat()
     return meta;
 }
 
-status_t SurfaceEncoder::read( MediaBuffer **buffer,
+status_t SurfaceMediaSource::read( MediaBuffer **buffer,
                                 const ReadOptions *options)
 {
     LOGV("Read. Size of queued buffer: %d", mQueue.size());
@@ -716,7 +716,7 @@ status_t SurfaceEncoder::read( MediaBuffer **buffer,
     return OK;
 }
 
-void SurfaceEncoder::signalBufferReturned(MediaBuffer *buffer) {
+void SurfaceMediaSource::signalBufferReturned(MediaBuffer *buffer) {
     LOGV("signalBufferReturned");
 
     bool foundBuffer = false;
diff --git a/media/libstagefright/tests/Android.mk b/media/libstagefright/tests/Android.mk
index 89d80a9..3ea8f39 100644
--- a/media/libstagefright/tests/Android.mk
+++ b/media/libstagefright/tests/Android.mk
@@ -4,12 +4,12 @@ include $(CLEAR_VARS)
 
 ifneq ($(TARGET_SIMULATOR),true)
 
-LOCAL_MODULE := SurfaceEncoder_test
+LOCAL_MODULE := SurfaceMediaSource_test
 
 LOCAL_MODULE_TAGS := tests
 
 LOCAL_SRC_FILES := \
-    SurfaceEncoder_test.cpp \
+    SurfaceMediaSource_test.cpp \
 	DummyRecorder.cpp \
 
 LOCAL_SHARED_LIBRARIES := \
diff --git a/media/libstagefright/tests/SurfaceEncoder_test.cpp b/media/libstagefright/tests/SurfaceMediaSource_test.cpp
index 65ce7cc..ce10812 100644
--- a/media/libstagefright/tests/SurfaceEncoder_test.cpp
+++ b/media/libstagefright/tests/SurfaceMediaSource_test.cpp
@@ -14,14 +14,14 @@
  * limitations under the License.
  */
 
-#define LOG_TAG "SurfaceEncoder_test"
+#define LOG_TAG "SurfaceMediaSource_test"
 // #define LOG_NDEBUG 0
 
 #include <gtest/gtest.h>
 #include <utils/String8.h>
 #include <utils/Errors.h>
 
-#include <media/stagefright/SurfaceEncoder.h>
+#include <media/stagefright/SurfaceMediaSource.h>
 
 #include <gui/SurfaceTextureClient.h>
 #include <ui/GraphicBuffer.h>
@@ -45,10 +45,10 @@
 namespace android {
 
 
-class SurfaceEncoderTest : public ::testing::Test {
+class SurfaceMediaSourceTest : public ::testing::Test {
 public:
 
-    SurfaceEncoderTest( ): mYuvTexWidth(64), mYuvTexHeight(66) { }
+    SurfaceMediaSourceTest( ): mYuvTexWidth(64), mYuvTexHeight(66) { }
     sp<MPEG4Writer>  setUpWriter(OMXClient &client );
     void oneBufferPass(int width, int height );
     static void fillYV12Buffer(uint8_t* buf, int w, int h, int stride) ;
@@ -57,16 +57,16 @@ public:
 protected:
 
     virtual void SetUp() {
-        mSE = new SurfaceEncoder(mYuvTexWidth, mYuvTexHeight);
-        mSE->setSynchronousMode(true);
-        mSTC = new SurfaceTextureClient(mSE);
+        mSMS = new SurfaceMediaSource(mYuvTexWidth, mYuvTexHeight);
+        mSMS->setSynchronousMode(true);
+        mSTC = new SurfaceTextureClient(mSMS);
         mANW = mSTC;
 
     }
 
 
     virtual void TearDown() {
-        mSE.clear();
+        mSMS.clear();
         mSTC.clear();
         mANW.clear();
     }
@@ -74,13 +74,13 @@ protected:
     const int mYuvTexWidth;//  = 64;
     const int mYuvTexHeight;// = 66;
 
-    sp<SurfaceEncoder> mSE;
+    sp<SurfaceMediaSource> mSMS;
     sp<SurfaceTextureClient> mSTC;
     sp<ANativeWindow> mANW;
 
 };
 
-void SurfaceEncoderTest::oneBufferPass(int width, int height ) {
+void SurfaceMediaSourceTest::oneBufferPass(int width, int height ) {
     LOGV("One Buffer Pass");
     ANativeWindowBuffer* anb;
     ASSERT_EQ(NO_ERROR, mANW->dequeueBuffer(mANW.get(), &anb));
@@ -92,13 +92,13 @@ void SurfaceEncoderTest::oneBufferPass(int width, int height ) {
     // Fill the buffer with the a checkerboard pattern
     uint8_t* img = NULL;
     buf->lock(GRALLOC_USAGE_SW_WRITE_OFTEN, (void**)(&img));
-    SurfaceEncoderTest::fillYV12Buffer(img, width, height, buf->getStride());
+    SurfaceMediaSourceTest::fillYV12Buffer(img, width, height, buf->getStride());
     buf->unlock();
 
     ASSERT_EQ(NO_ERROR, mANW->queueBuffer(mANW.get(), buf->getNativeBuffer()));
 }
 
-sp<MPEG4Writer> SurfaceEncoderTest::setUpWriter(OMXClient &client ) {
+sp<MPEG4Writer> SurfaceMediaSourceTest::setUpWriter(OMXClient &client ) {
     // Writing to a file
     const char *fileName = "/sdcard/outputSurfEnc.mp4";
     sp<MetaData> enc_meta = new MetaData;
@@ -107,7 +107,7 @@ sp<MPEG4Writer> SurfaceEncoderTest::setUpWriter(OMXClient &client ) {
 
     enc_meta->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_MPEG4);
 
-    sp<MetaData> meta = mSE->getFormat();
+    sp<MetaData> meta = mSMS->getFormat();
 
     int32_t width, height, stride, sliceHeight, colorFormat;
     CHECK(meta->findInt32(kKeyWidth, &width));
@@ -129,7 +129,7 @@ sp<MPEG4Writer> SurfaceEncoderTest::setUpWriter(OMXClient &client ) {
 
     sp<MediaSource> encoder =
         OMXCodec::Create(
-                client.interface(), enc_meta, true /* createEncoder */, mSE);
+                client.interface(), enc_meta, true /* createEncoder */, mSMS);
 
     sp<MPEG4Writer> writer = new MPEG4Writer(fileName);
     writer->addSource(encoder);
@@ -138,7 +138,7 @@ sp<MPEG4Writer> SurfaceEncoderTest::setUpWriter(OMXClient &client ) {
 }
 
 // Fill a YV12 buffer with a multi-colored checkerboard pattern
-void SurfaceEncoderTest::fillYV12Buffer(uint8_t* buf, int w, int h, int stride) {
+void SurfaceMediaSourceTest::fillYV12Buffer(uint8_t* buf, int w, int h, int stride) {
     const int blockWidth = w > 16 ? w / 16 : 1;
     const int blockHeight = h > 16 ? h / 16 : 1;
     const int yuvTexOffsetY = 0;
@@ -168,7 +168,7 @@ void SurfaceEncoderTest::fillYV12Buffer(uint8_t* buf, int w, int h, int stride)
 }
 
 // Fill a YV12 buffer with red outside a given rectangle and green inside it.
-void SurfaceEncoderTest::fillYV12BufferRect(uint8_t* buf, int w,
+void SurfaceMediaSourceTest::fillYV12BufferRect(uint8_t* buf, int w,
                   int h, int stride, const android_native_rect_t& rect) {
     const int yuvTexOffsetY = 0;
     int yuvTexStrideY = stride;
@@ -190,7 +190,7 @@ void SurfaceEncoderTest::fillYV12BufferRect(uint8_t* buf, int w,
             }
         }
     }
-}  ///////// End of class SurfaceEncoderTest
+}  ///////// End of class SurfaceMediaSourceTest
 
 ///////////////////////////////////////////////////////////////////
 // Class to imitate the recording     /////////////////////////////
@@ -219,8 +219,8 @@ struct SimpleDummyRecorder {
 
 ///////////////////////////////////////////////////////////////////
 //           TESTS
-// Just pass one buffer from the native_window to the SurfaceEncoder
-TEST_F(SurfaceEncoderTest, EncodingFromCpuFilledYV12BufferNpotOneBufferPass) {
+// Just pass one buffer from the native_window to the SurfaceMediaSource
+TEST_F(SurfaceMediaSourceTest, EncodingFromCpuFilledYV12BufferNpotOneBufferPass) {
     LOGV("Testing OneBufferPass ******************************");
 
     ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
@@ -233,7 +233,7 @@ TEST_F(SurfaceEncoderTest, EncodingFromCpuFilledYV12BufferNpotOneBufferPass) {
 }
 
 // Pass the buffer with the wrong height and weight and should not be accepted
-TEST_F(SurfaceEncoderTest, EncodingFromCpuFilledYV12BufferNpotWrongSizeBufferPass) {
+TEST_F(SurfaceMediaSourceTest, EncodingFromCpuFilledYV12BufferNpotWrongSizeBufferPass) {
     LOGV("Testing Wrong size BufferPass ******************************");
 
     // setting the client side buffer size different than the server size
@@ -250,16 +250,15 @@ TEST_F(SurfaceEncoderTest, EncodingFromCpuFilledYV12BufferNpotWrongSizeBufferPas
 }
 
 
-// pass multiple buffers from the native_window the SurfaceEncoder
+// pass multiple buffers from the native_window the SurfaceMediaSource
 // A dummy writer is used to simulate actual MPEG4Writer
-TEST_F(SurfaceEncoderTest,  EncodingFromCpuFilledYV12BufferNpotMultiBufferPass) {
+TEST_F(SurfaceMediaSourceTest,  EncodingFromCpuFilledYV12BufferNpotMultiBufferPass) {
     LOGV("Testing MultiBufferPass, Dummy Recorder *********************");
     ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
             0, 0, HAL_PIXEL_FORMAT_YV12));
     ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
             GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
-
-    SimpleDummyRecorder writer(mSE);
+    SimpleDummyRecorder writer(mSMS);
     writer.start();
 
     int32_t nFramesCount = 0;
@@ -273,20 +272,19 @@ TEST_F(SurfaceEncoderTest,  EncodingFromCpuFilledYV12BufferNpotMultiBufferPass)
     writer.stop();
 }
 
-// Delayed pass of multiple buffers from the native_window the SurfaceEncoder
+// Delayed pass of multiple buffers from the native_window the SurfaceMediaSource
 // A dummy writer is used to simulate actual MPEG4Writer
-TEST_F(SurfaceEncoderTest,  EncodingFromCpuFilledYV12BufferNpotMultiBufferPassLag) {
+TEST_F(SurfaceMediaSourceTest,  EncodingFromCpuFilledYV12BufferNpotMultiBufferPassLag) {
     LOGV("Testing MultiBufferPass, Dummy Recorder Lagging **************");
     ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
             0, 0, HAL_PIXEL_FORMAT_YV12));
     ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
             GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
-
-    SimpleDummyRecorder writer(mSE);
+    SimpleDummyRecorder writer(mSMS);
     writer.start();
 
     int32_t nFramesCount = 1;
-    const int FRAMES_LAG = mSE->getBufferCount() - 1;
+    const int FRAMES_LAG = mSMS->getBufferCount() - 1;
     while (nFramesCount <= 300) {
         oneBufferPass(mYuvTexWidth, mYuvTexHeight);
         // Forcing the writer to lag behind a few frames
@@ -298,16 +296,16 @@ TEST_F(SurfaceEncoderTest,  EncodingFromCpuFilledYV12BufferNpotMultiBufferPassLa
     writer.stop();
 }
 
-// pass multiple buffers from the native_window the SurfaceEncoder
+// pass multiple buffers from the native_window the SurfaceMediaSource
 // A dummy writer (MULTITHREADED) is used to simulate actual MPEG4Writer
-TEST_F(SurfaceEncoderTest, EncodingFromCpuFilledYV12BufferNpotMultiBufferPassThreaded) {
+TEST_F(SurfaceMediaSourceTest, EncodingFromCpuFilledYV12BufferNpotMultiBufferPassThreaded) {
     LOGV("Testing MultiBufferPass, Dummy Recorder Multi-Threaded **********");
     ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
             0, 0, HAL_PIXEL_FORMAT_YV12));
     ASSERT_EQ(NO_ERROR, native_window_set_usage(mANW.get(),
             GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN));
 
-    DummyRecorder writer(mSE);
+    DummyRecorder writer(mSMS);
     writer.start();
 
     int32_t nFramesCount = 0;
@@ -321,7 +319,7 @@ TEST_F(SurfaceEncoderTest, EncodingFromCpuFilledYV12BufferNpotMultiBufferPassThr
 
 // Test to examine the actual encoding. Temporarily disabled till the
 // colorformat and encoding from GRAlloc data is resolved
-TEST_F(SurfaceEncoderTest, DISABLED_EncodingFromCpuFilledYV12BufferNpotWrite) {
+TEST_F(SurfaceMediaSourceTest, DISABLED_EncodingFromCpuFilledYV12BufferNpotWrite) {
     LOGV("Testing the whole pipeline with actual Recorder");
     ASSERT_EQ(NO_ERROR, native_window_set_buffers_geometry(mANW.get(),
             0, 0, HAL_PIXEL_FORMAT_YV12)); // OMX_COLOR_FormatYUV420Planar)); // ));